Advertentie
Een verrassend kenmerk van de interneteconomie is de opkomst van indiegames. Ooit het exclusieve domein van duizend man, multi-miljoen dollar triple-A studio's, zijn er een aantal toolsets ontwikkeld breng de middelen voor moderne game-ontwikkeling in handen van individuen of kleine, ad-hoccollecties van programmeurs en ontwerpers. We hebben eerder de beste indiegames 10 Indie-games zo goed dat je vergeet dat ze helemaal indie zijnEr kunnen echter momenten zijn dat je iets anders wilt dan de indie-norm. Een game die indie-waarden volgt, maar toch is gemaakt met de kwaliteit waar eersteklas AAA-games om bekend staan. Titels zoals ... Lees verder , dus zorg ervoor dat je die bekijkt voor wat inspiratie over wat kan worden bereikt met tools zoals Unity.
Deze indie-game-ontwikkelingsteams hebben een behendigheid en risicotolerantie getoond die hen in veel gevallen in staat stelt om gameplay-innovatie sneller te stimuleren dan hun tegenhangers met een groot budget. Een aantal schokkend succesvolle indietitels zijn de afgelopen jaren in première gegaan, waaronder
Minecraft, Limbo, en Super Meat Boy, en zelfs als je niet over de vaardigheden hoeft te beschikken om dit soort games te maken, kan dat maak een spel met Buildbox Hoe maak je een videogame in een week met BuildboxEr is een programma dat de ontwikkeling van games ongelooflijk gemakkelijk maakt, zelfs voor mensen die absoluut geen ervaring hebben met het ontwerpen van videogames. Het heet Buildbox. Dit is waarom je het zou moeten proberen. Lees verder .In het snel evoluerende landschap van de ontwikkeling van indiegames, Eenheid is de facto een standaard geworden: dankzij de lage kosten, het gebruiksgemak en de uitgebreide functieset is het ideaal voor snelle game-ontwikkeling. Eenheid is zo flexibel dat u zelfs kunt maak uw eigen aangepaste gamecontrollers Hoe maak je een aangepaste gamecontroller met Arduino en UnityHeb je ooit je eigen gamecontroller willen ontwerpen? Het is makkelijker dan je denkt! Lees verder met een beetje DIY-knowhow!
Zelfs grote studio's zoals CCP (Developers of Eve Online) gebruik het voor het snel prototypen van spelconcepten. Unity biedt een "game-engine in een doos" - een physics- en rendering-engine met hooks voor verschillende scripttalen, aanpasbaar aan vrijwel elk genre van videogames.
Hoewel Unity een visuele editor biedt voor het manipuleren van de game-omgeving, is Unity geen tool voor het maken van games zonder programmeren. Het vereist dat je programmeert om resultaten te produceren, maar het geeft je ook een veel flexibeler en krachtiger hulpmiddel dan welk 'spelmaker'-programma dan ook.
Eenheid zal het werk niet voor u doen, maar het verlaagt de toegangsdrempel aanzienlijk. Het begint helemaal opnieuw met C ++ en OpenGL, het kan dagen duren om zover te komen dat er daadwerkelijk iets op het scherm wordt weergegeven. Met Unity duurt het ongeveer tien seconden. Unity legt de basiselementen van het maken van games op een snelle, intuïtieve manier in handen van beginnende programmeurs.
Vandaag leid ik je door alles wat je moet weten om een game in Unity te maken, die is onderverdeeld in tien hoofdhoofdstukken:
§1 – Versies van eenheid
§2 - Unity installeren
§3 - Een korte inleiding tot het objectgeoriënteerde paradigma
§4 - Basisprincipes van eenheid
§5 – Voorbeeld: basiselementen van een spel
§6 - Scripting in eenheid
§7 – Voorbeeld: Scripting Pong
§8 – De documentatie verkennen / meer leren
§9 - Je game bouwen / compileren naar een zelfstandige applicatie
§10-afsluitende opmerkingen
1. Versies van Unity
Unity wordt geleverd in twee basissmaken: de pro-versie en de gratis versie. Er zijn een aantal verschillen, maar over het algemeen ondersteunt de pro-versie een aantal visuele verbeteringen (zoals realtime zachte schaduwen en nabewerking) en een groot aantal relatief kleine functies die uiterst nuttig zijn voor complexere spellen.
Dat gezegd hebbende, voor de meeste relatief eenvoudige spellen die je misschien wilt bouwen, is de gratis versie van Unity perfect geschikt. We zullen de belangrijkste verschillen hieronder meer gedetailleerd uitsplitsen voor geïnteresseerden.
1.1 Prijzen
De gratis versie van Unity is natuurlijk gratis. Er zijn echter enkele beperkingen: de gratis versie van Unity kan niet worden gelicentieerd aan een bedrijf met een jaarinkomen van meer dan $100,000. Hoewel dergelijke organisaties buiten het bestek van deze gids vallen, is het waarschijnlijk verstandig om voor de Pro-versie te kiezen als je vermoedt dat je zo'n organisatie zou kunnen worden.
De Pro-versie van Unity is $75 een maand, of $1500 voor een permanente licentie en heeft geen grenzen aan wat u kunt doen met de spellen die ermee zijn gemaakt. Er is ook een gratis proefperiode van 30 dagen beschikbaar, die we voor deze handleiding zullen gebruiken, om u een zo volledig mogelijk overzicht van de beschikbare functies te geven. Een jaarlicentie voor studenten is ook verkrijgbaar via Studica voor $129.
1.2 Functies
Er zijn veel functies die ontbreken in de gratis versie van Unity. De belangrijkste verschillen zijn echter als volgt: de gratis versie van Unity mist een aantal renderingopties die dit mogelijk maken beter uitziende, sneller lopende games (LOD-ondersteuning, nabewerking van schermruimte, geavanceerde shaders, realtime zachte schaduwen en uitgestelde weergave). Het mist ook het volledige mechanim animatiesysteem, en enkele AI-tools.
Over het algemeen is de pro-versie de moeite waard voor complexe, grootschalige projecten of projecten waarbij grafische prestaties belangrijk zijn. Ik gebruik de pro-versie, omdat ik virtual reality-spellen ontwikkel voor de Oculus Rift Oculus Rift ReviewVirtual Reality is niet nieuw, maar het is eindelijk betaalbaar en binnen ons bereik. Na vier jaar en twee ontwikkelingsprototypes is de laatste consumenteneditie van de Oculus Rift gearriveerd. Lees verder , en de nabewerking van de schermruimte is nodig om correct te communiceren met de headset.
2. Unity installeren
Unity is eenvoudig te installeren. U kunt het uitvoerbare bestand downloaden van unit3d.com/get-unity/download.
Na het downloaden voert u het uit en volgt u de installatie-instructies. Wanneer de installatie is voltooid, verschijnt er een venster met de titel ‘Activeer uw Unity-licentie’. Vink het vakje aan ‘Activeer een gratis proefversie van 30 dagen van Unity Pro’ en vervolgens ‘OK’.
Gefeliciteerd! U heeft nu een proefperiode van 30 dagen voor Unity Pro. Als de proefperiode afloopt en u de pro-versie niet wilt kopen, kunt u overschakelen naar de gratis versie en uw bestaande inhoud behouden.
3. Een korte introductie tot het objectgeoriënteerde paradigma
Voordat we aan de slag gaan met Unity, is het belangrijk dat we de basis een beetje doornemen. Unity ondersteunt beide C # en JavaScript voor spelprogrammering 7 Unity Game Development-talen om te leren: wat is het beste?Wil je beginnen met het ontwikkelen van games in Unity? U moet bekend zijn met een van deze Unity-compatibele talen. Lees verder ; we werken met C # voor deze tutorial.
Ten eerste, als je nog nooit eerder hebt geprogrammeerd, leg deze tutorial dan opzij en besteed een paar dagen aan het werken met die van Microsoft C # Language Primer totdat u zich op uw gemak voelt bij het gebruik van de taal voor eenvoudige taken.
Als je iets anders wilt dan C # (maar niet noodzakelijk een taal die je in Unity kunt gebruiken), bekijk dan onze gids voor de zes gemakkelijkste programmeertalen voor beginners 6 eenvoudigste programmeertalen om te leren voor beginnersLeren programmeren gaat net zo goed over het vinden van de juiste taal als over het opbouwproces. Hier zijn de zes gemakkelijkste programmeertalen voor beginners. Lees verder .
Als je eerder hebt geprogrammeerd in een imperatieve of objectgeoriënteerde taal zoals C of Java, blader dan door de primer en maak jezelf vertrouwd met hoe C # verschilt van andere talen die je in het verleden hebt gebruikt. Hoe dan ook, ga niet door met de zelfstudie totdat u zich op uw gemak voelt bij het oplossen van eenvoudige problemen met C # (bijvoorbeeld als ik zou vragen Als u een programma schrijft dat de eerste honderd priemgetallen afdrukt, moet u dat programma zonder overleg kunnen schrijven Google).
Het belangrijkste concept om hier te begrijpen is de objectgeoriënteerd paradigma Waar heeft "objectgeoriënteerde" programmering zijn naam aan ontleend?Object Oriented is niet zomaar een willekeurig modewoord dat je hoort in programmeerkringen. Er zit een reden achter de naam - maar wat? Doe met me mee terwijl ik enkele van de grondbeginselen van programmeerconcepten verken en uitleg ... Lees verder (afgekort als OOP). In objectgeoriënteerde talen zijn programma's onderverdeeld in functionele eenheden genaamd Voorwerpen. Elk object heeft zijn eigen privévariabelen en functies. Objectspecifieke functies worden aangeroepen methoden.
Het idee hier is modulariteit: door elk object geïsoleerd te houden en andere objecten te dwingen om ermee te interageren door middel van zijn methoden kunt u het aantal mogelijke onbedoelde interacties verminderen - en, bij uitbreiding, bugs. U kunt ook objecten maken die u later zonder aanpassingen opnieuw kunt gebruiken. In Unity ga je deze objecten bouwen en eraan vastmaken game-entiteiten (wiens gedrag ze zullen beheersen).
Objecten worden geïnstantieerd klassen: een klasse is slechts een bestand waarin de definitie van uw object wordt uiteengezet. Dus als je een Mook object dat AI verwerkt voor een vijand in je spel, zou je een 'Mook'-klasse schrijven en dat bestand vervolgens aan elke vijandelijke entiteit koppelen. Wanneer je je spel uitvoert, wordt elke vijand uitgerust met een kopie van het 'Mook'-object.
Het koppelen van een nieuw script aan een object ziet er als volgt uit:
Eerste, selecteer het object en ga naar de Inspecteur. Klik op de Component toevoegen knop.
Ga naar nieuw script, voer de gewenste naam in en klik op maken en toevoegen.
Nu heb je een nieuw script dat je kunt bewerken door erop te dubbelklikken!
Een klassenbestand ziet er ongeveer zo uit:
UnityEngine gebruiken; public class Mook: MonoBehaviour {private float health; ongeldig Start () {health = 100; } void Update () {if (health> 0) {/ * Zoek naar speler als je de speler onderweg tegenkomt, dood hem als je wordt neergeschoten, verwijder een willekeurige hoeveelheid gezondheid * /}} }
Laten we dit opsplitsen:
- UnityEngine gebruiken: Deze regel vertelt C # dat we de bibliotheken van Unity willen gebruiken, waarmee we verbinding kunnen maken met de Unity-game-engine.
- Openbare klasse Mook: MonoBehaviour:Deze regel geeft de klasse en de naam aan - Mook.
- Private float-gezondheid: Hiermee wordt een privéklasse-variabele verklaard (die alleen binnen de klasse kan worden gewijzigd). De variabele krijgt een waarde in Begin.
- Ongeldige start (): Dit verklaart een methode genaamd Begin. Start is een speciale methode die maar één keer wordt uitgevoerd, wanneer de game voor het eerst wordt gestart.
- Ongeldige update (): Update is een andere speciale methode die op elk frame wordt uitgevoerd. Het grootste deel van je spellogica komt hier.
- // als je de speler onderweg tegenkomt, dood hem: Deze regel is een opmerking (elke regel die begint met een dubbele schuine streep wordt genegeerd door C #). Opmerkingen worden gebruikt om jezelf eraan te herinneren wat bepaalde stukjes code doen. In dit geval wordt deze opmerking gebruikt om een ingewikkelder codeblok te vervangen dat daadwerkelijk doet wat de opmerking beschrijft.
Samen met Begin en Bijwerkenkunt u uw eigen methoden instantiëren met bijna elke naam. Methoden die u maakt, worden echter niet uitgevoerd tenzij ze worden aangeroepen. Laten we een methode declareren voor een hypothetische klasse met de naam addTwoNumbers dat telt twee getallen bij elkaar op:
public float addTwoNumbers (zweven a, zweven b) {retourneren a + b; }
Dit verklaart een openbare (toegankelijk voor andere objecten) methode die een float retourneert, genaamd addTwoNumbers, waarvoor twee drijvers als invoer nodig zijn (genaamd een en b). Vervolgens wordt de som van de twee waarden als uitvoer geretourneerd.
Deze methode aanroepen vanuit dezelfde klasse (zeg maar van binnenuit) Bijwerken) het lijkt hierop:
zwevend resultaat = addTwoNumbers (1, 2);
De methode aanroepen vanuit een andere klasse is vergelijkbaar:
addTwoNumbers-instantie; float result = instance.addTwoNumbers (1, 2);
Nogmaals, dit creëert gewoon een exemplaar van onze klasse, benadert de juiste methode en voert het de nummers in die we willen toevoegen, en slaat het resultaat vervolgens op in resultaat. Gemakkelijk.
Als uw script is gekoppeld aan een object met speciale eigenschappen (zoals een deeltjesemitter) die niet toegankelijk zijn onder de normale set GameObject-parameters kunt u ervoor kiezen om het te behandelen als een ander soort game-entiteit door te gebruiken de GetComponent methode.
De syntaxis daarvoor ziet er als volgt uit:
GetComponent().Speel();
Als een van deze dingen u niet bekend is, gaat u terug en gaat u door de C # -primer. Het bespaart u veel frustratie terwijl we doorgaan.
4. Unity Basics
In dit gedeelte gaan we ons een weg banen door de basismechanica van de Unity-engine. De workflow in Unity gaat ongeveer als volgt:
- Maak een entiteit om een rol in het spel te vervullen (leeg GameObjects kan worden gebruikt voor abstracte logische taken).
- Schrijf of zoek een klassebestand en voeg het als script toe aan de entiteit (met behulp van de Component toevoegen knop in de inspecteur visie.
- Rennen > test > debuggen > herhaling totdat het werkt en ga verder naar het volgende element van het spel.
Unity wordt geleverd met een aantal basisweergavetabbladen die op verschillende manieren kunnen worden ingedeeld naar de smaak van de gebruiker. De big five zijn:
- Spel: geeft een lopend exemplaar van het spel weer waarmee u kunt communiceren en testen.
- Tafereel: biedt een statische, bewerkbare versie van de spel wereld.
- Inspecteur: kunt u individuele entiteiten in de spelwereld wijzigen door ze te selecteren in de editor tabblad.
- Project: kunt u door de bestanden van het project bladeren en modellen, materialen en andere bronnen naar de editor tabblad om ze in de gamewereld te plaatsen.
- Hiërarchie: dit tabblad toont alle objecten in de wereld, zodat u objecten op afstand in de scène en bovenliggende entiteiten naar elkaar kunt vinden door te klikken en te slepen.
Zie het onderstaande diagram voor de locaties van al deze dingen:
4.1 Eenheidsentiteiten
4.1.1 Meshes
Meshes zijn de weg 3D-geometrie is vertegenwoordigd in Unity. U kunt ofwel de ingebouwde Unity gebruiken primitief objecten (kubussen, bollen, cilinders, enz.), of importeer uw eigen 3D-modellen uit een modelleerpakket zoals Blender Aan de slag met Blender: 7 fantastische tutorials voor nieuwkomers3D-modellering is een uitstekende manier om creativiteit uit te oefenen terwijl u contact houdt met uw technische kant. Hier zijn enkele geweldige gratis tutorials. Lees verder of Maya Maya 2016 leren: waar te beginnenMaya is een tool die wordt gebruikt voor 3D-animatie, maar het heeft een ongelooflijk steile leercurve. Welk goed lesmateriaal is er? Lees verder . Unity ondersteunt verschillende 3D-formaten, waaronder .fbx, en .3ds.
De basisinstrumenten voor het manipuleren van meshes zijn de knoppen voor schalen, roteren en vertalen in de linkerbovenhoek van de interface. Deze knoppen voegen controlepictogrammen toe aan de modellen in de editorweergave, die vervolgens kunnen worden gebruikt om ze in de ruimte te manipuleren. Om de textuur- of fysische eigenschappen van een object te wijzigen, selecteert u ze en gebruikt u de inspecteur bekijken om de materiaal en star lichaam elementen.
4.1.2 GUI-elementen
Traditionele GUI-sprites en tekst kunnen worden weergegeven met de GUI-tekst en de GUI-textuur GameObjects in de editor. Een meer robuuste en realistische manier om met UI-elementen om te gaan, is door de 3D-tekst en Quad GameObjects (met transparante texturen en een onverlichte transparante arcering) om HUD-elementen als entiteiten in de gamewereld te plaatsen.
In de hiërarchie Deze gameplay-elementen kunnen naar de hoofdcamera worden gesleept om ze kinderen te maken, zodat ze met de camera kunnen bewegen en draaien.
Van GUI-elementen (tekst en texturen) kan de grootte en schaal worden aangepast met behulp van de relevante velden op het tabblad Inspector.
4.1.3 Materialen
Materialen zijn combinaties van texturen en shaders Vijf belangrijke PC Gaming-termen uitgelegdAls je een game op een console speelt, worden de technische details voor je afgehandeld. Sommige spelers geven hier de voorkeur aan, maar pc-gamers genieten vaak van de grotere mate van controle die ze hebben over het oog van een game ... Lees verder en kan rechtstreeks vanaf het projecttabblad naar game-objecten worden gesleept. Unity Pro wordt geleverd met een groot aantal shaders en u kunt de textuur die eraan is gekoppeld aanpassen met behulp van het infovenster voor een object waarop ze zijn toegepast.
Om een texture te importeren, zet u deze om in a .jpg, .png, of .bmpen sleep het naar de middelen map onder de Unity-projectmap (die verschijnt in Mijn Documenten standaard). Na een paar seconden verschijnt er een laadbalk in de editor. Als het klaar is, kun je de afbeelding als een textuur onder de vinden project tabblad.
4.1.5 Verlichting
Lichten zijn GameObjects welke uitstraling uitstraalt op de wereld. Als er geen lichten in uw scène zijn, worden alle polygonen op hetzelfde helderheidsniveau getekend, waardoor de wereld een platte, vervaagde look krijgt.
Lichten kunnen worden gepositioneerd, gedraaid en hebben verschillende interne kenmerken die u kunt aanpassen. De intensiteit schuifregelaar regelt de helderheid van het licht en de bereik bepaalt hoe snel het verdwijnt.
De richtlijnen in de scène bekijken tonen u het maximale bereik van de verlichting. Speel met beide instellingen om het gewenste effect te bereiken. Je kunt ook de kleur van het licht, het patroon (koekje wordt weergegeven op het oppervlak waarop het licht is gericht, en wat voor soort overstraling verschijnt op het scherm als u rechtstreeks naar het licht kijkt. De cookie kan worden gebruikt om meer realistische lichtpatronen te vervalsen, dramatische valse schaduwen te creëren en projectoren te simuleren.
De drie belangrijkste soorten licht zijn plek, punt, en directioneel.
Spotlichten hebben een locatie in 3D-ruimte en projecteren licht slechts in één richting in een kegel met variabele hoek. Deze zijn goed voor zaklampen, zoeklichten en geven u over het algemeen een nauwkeurigere regeling van de verlichting. Spotlichten kunnen schaduwen werpen.
Point lichten hebben een locatie in 3D-ruimte en werpen het licht gelijkmatig in alle richtingen. Puntlichten werpen geen schaduwen.
Richtingaanwijzerstenslotte worden ze gebruikt om zonlicht te simuleren: ze projecteren licht in een richting alsof ze van oneindig ver weg zijn. Gericht licht beïnvloedt elk object in de scène en kan schaduwen produceren.
4.1.6 Deeltjesystemen
EEN Deeltjes systeem is een GameObject die honderden of duizenden deeltjes tegelijkertijd genereert en controleert. Deeltjes zijn kleine, geoptimaliseerde 2D-objecten die in de 3D-ruimte worden weergegeven. Deeltjesystemen gebruiken vereenvoudigde weergave en fysica, maar kunnen duizenden entiteiten in realtime weergeven zonder te stotteren, waardoor ze ideaal zijn voor rook, vuur, regen, vonken, magische effecten en meer.
Er zijn veel parameters die u kunt aanpassen om deze effecten te bereiken, en u kunt ze openen door een deeltjessysteem onder de component editor > het selecteren van het deeltjessysteem > het inspecteurstabblad openen. U kunt de grootte, snelheid, richting, rotatie, kleur en textuur van elk deeltje wijzigen en de meeste van die parameters instellen om ook in de loop van de tijd te veranderen.
Onder de botsing attribuut, als u het inschakelt en de simulatieruimte instelt op wereld krijg je deeltjes die in botsing komen met objecten in de wereld, die kunnen worden gebruikt voor een aantal realistische deeltjeseffecten, waaronder regen, bewegend water en vonken.
5. Voorbeeld: basiselementen van een spel
Voor deze tutorial gaan we een eenvoudig spelletje maken Pong - iets dat we al meerdere keren in DIY hebben besproken:
- Arduino Classic Pong Hoe het klassieke pongspel te recreëren met ArduinoPong was de allereerste videogame die de massamarkt bereikte. Voor het eerst in de geschiedenis werd het concept van een "videogame" dankzij de Atari 2600 -... in het ouderlijk huis gebracht. Lees verder
- Arduino OLED Pong Arduino Retro Gaming met een OLED-displayHeb je je ooit afgevraagd hoeveel werk er nodig is om je eigen retrogames te schrijven? Hoe gemakkelijk is Pong om te coderen voor de Arduino? Lees verder
In deze sectie bespreken we de kernelementen - de scripttutorial komt later.
Laten we eerst het spel Pong opsplitsen in de basiscomponenten. Ten eerste hebben we twee peddels en een bal nodig. De bal vliegt buiten het scherm, dus we willen een mechanisme om de bal te resetten. We willen ook dat tekst de huidige score weergeeft en om u alle kernelementen van Unity te laten zien, willen we een fraai deeltjeseffect wanneer u de bal raakt. Het hele spel moet dramatisch verlicht worden.
Dat valt uiteen in een bal object (een bol), een spawner, twee peddelsteunen met deeltjesemitters in bijlage, een 3D-tekst entiteit, en een spot licht. Voor deze tutorial gebruiken we het standaard fysieke materiaal stuiteren, met stuiteren combineren ingesteld op vermenigvuldigen. Zo ziet de opstelling eruit, in tien screenshots:
Maak eerst een kubus prop voor de peddel.
Passend schalen, dupliceer het, en zet een gebied tussen de peddels voor de bal.
Maak vervolgens een 3DText-object en schaal en positie het correct, het veranderen van de lettertypegrootte attribuut om een minder korrelig beeld te krijgen.
Maak er vervolgens twee deeltjes systemen, kies de gewenste kenmerken en bevestig ze aan de peddels.
Vervolgens wil je positie en draai de camera zodat het de scène correct inkadert. Terwijl de camera is geselecteerd, ziet u een klein voorbeeld van het cameraweergave in de rechter benedenhoek.
Voordat we klaar zijn, moeten we twee extra blokjes maken om bumpers te zijn, om te voorkomen dat de bal het speelgebied uit stuitert. We kunnen ze onzichtbaar maken door de optie uit te vinken mesh renderer in de tabblad inspecteur.
Als je op play drukt, kun je nu de basiselementen van ons spel zien. Ze doen nog niets, maar daar komen we wel op terug!
Nu we die opzet hebben, gaan we het hebben over wat er komt kijken bij het scripten van deze elementen om een game te maken.
6. Scripting in eenheid
Zodra u een script aan een object hebt gekoppeld, kunt u het herzien door erop te dubbelklikken in de inspecteur. Dit gaat open MonoDevelop, de standaard ontwikkelomgeving voor Unity. In wezen is Monodevelop een teksteditor met functies die specifiek zijn geoptimaliseerd voor programmeren.
Sleutelwoorden en opmerkingen zijn gemarkeerd in blauw en groen, en numerieke waarden en tekenreeksen verschijnen in rood. Als je hebt gebruikt Verduistering of andere IDE's, MonoDevelop lijkt erg op elkaar. Jij kan bouwen uw scripts vanuit de editor om te controleren op syntaxisfouten, zoals:
Om uw script in interactie te brengen met Unity, moet u over het algemeen verwijzen naar elementen die het object met het script bezit (u kunt een lijst met deze elementen zien onder de inspecteur tabblad wanneer het relevante object is geselecteerd). U kunt vervolgens methoden aanroepen of variabelen instellen voor elk van deze elementen om de gewenste wijzigingen door te voeren.
Als u wilt dat een script op een object de eigenschappen van een ander object beïnvloedt, kunt u een lege maken GameObject variabele in uw script en gebruik de inspecteur om het toe te wijzen aan een ander object in de scène.
Een lijst met de elementen die een object kan hebben, is als volgt (afkomstig uit de inspecteurweergave van een van onze paddles in het bovenstaande voorbeeld):
- Transformeren
- Kubus (meshfilter)
- Box Collider
- Mesh Renderer
Elk van deze aspecten van het object kan vanuit een script worden beïnvloed. Vervolgens bekijken we precies hoe.
6.1 Transformeren
De transformatiefuncties voor een GameObject in Unity besturen de fysieke parameters van dat object: zijn schaal, het is positie, en zijn oriëntatie. Je kunt ze openen vanuit een script als dit:
transform.position = newPositionVector3; transform.rotation = newRotationQuaternion; transform.localScale = newScaleVector3;
In de bovenstaande voorbeelden zijn de benoemde variabelen van het type dat in de namen is gespecificeerd. Hier zijn een paar belangrijke details: positie en schaal worden, zoals je zou verwachten, opgeslagen als Vector3s. U heeft toegang tot de X, Y, en Z componenten van elk (bijvoorbeeld transform.position.y geeft je de afstand van een object boven het nulvlak).
Echter te vermijden cardanische vergrendelingrotaties worden behandeld als Quaternions (vier-componentenvectoren). Omdat quaternions met de hand niet intuïtief zijn, kunt u rotaties manipuleren met behulp van Eulerian-hoeken door de Quaternion. Euler methode zoals:
transform.rotation = Quaternion. Euler (pitch, yaw, roll);
Als u objecten soepel van de ene plaats naar de andere wilt verplaatsen, vindt u de Slerp methode voor quaternions en vector3s nuttig. Slerp neemt drie argumenten aan - de huidige toestand, de eindtoestand en de snelheid van verandering, en interpoleert ze vlot met de gegeven snelheid. De syntaxis ziet er als volgt uit:
transform.position = Vector3.Slerp (startPositionVector3, newDestinationVector3, 1);
6.2 Renderer
Met de rendererfuncties in Unity kunt u bepalen hoe de oppervlakken van rekwisieten op het scherm worden weergegeven. U kunt de textuur opnieuw toewijzen, de kleur wijzigen en de arcering en zichtbaarheid van het object wijzigen. De syntaxis ziet er als volgt uit:
renderer.enabled = false; renderer.material.color = nieuwe kleur (0, 255, 0); renderer.material.mainTexture = myTexture; renderer.material.shader = newShader;
De meeste hiervan hebben vrij duidelijke functies. Het eerste voorbeeld maakt het betreffende object onzichtbaar: een handige truc in een aantal situaties. In het tweede voorbeeld wordt een nieuw toegewezen RGB-kleur (namelijk groen) op het betreffende object. De derde kent de belangrijkste diffuse textuur toe aan een nieuwe textuurvariabele. In het laatste voorbeeld wordt de arcering van het materiaal van het object gewijzigd in een nieuw gedefinieerde arceringsvariabele.
6.3 Fysica
Unity wordt geleverd met een geïntegreerde physics-engine - iets dat fysica sandbox-spellen Smash, Drive & Build: 3 Awesome Physics Sandboxes Simulators Lees verder alle gebruik. Hiermee kunt u de fysieke eigenschappen van objecten toewijzen en de details van hun simulatie voor u laten behandelen. In het algemeen is het, in plaats van te proberen uw eigen fysica te implementeren met behulp van een leerboek en het transformatiesysteem, eenvoudiger en robuuster om de fysica-engine van Unity zo veel mogelijk te gebruiken.
Alle natuurkundige rekwisieten vereisen botsers. De daadwerkelijke simulatie zelf wordt echter afgehandeld door een star lichaam, die kan worden toegevoegd in de inspecteur visie. Rigidbodies kunnen zijn kinematisch of niet-kinematisch.
Kinematische fysica-rekwisieten botsen met (en effect) niet-kinematische fysica-rekwisieten om hen heen, maar worden zelf niet beïnvloed door botsingen. Statische kinematische rekwisieten zijn de spreekwoordelijke onroerende objecten en bewegende kinematische objecten zijn de spreekwoordelijke niet te stoppen kracht (voor de goede orde, als ze botsen, passeren ze ze gewoon allemaal andere).
Daarnaast kunt u de hoekweerstand van het object aanpassen (hoeveel energie er nodig is om het te draaien), de massa veranderen, dicteren of het al dan niet wordt beïnvloed door zwaartekracht en er krachten op uitoefenen.
Voorbeelden:
rigidbody.angularDrag = 0.1f; rigidbody.mass = 100; rigidbody.isKinematic = false; rigidbody.useGravity = waar; star lichaam. AddForce (transform.forward * 100);
Dit spreekt allemaal voor zich. Het enige dat hier moet worden opgemerkt, is het gebruik van transformeren. Vector3's hebben allemaal drie componenten (.vooruit, .up, en .Rechtsaf) geassocieerd met hen, die toegankelijk zijn en met hen roteert (vooruit is de richting van de blauwe pijl in de editor). De transformeren trefwoord is gewoon de voorwaartse vector voor het huidige object met magnitude 1. Het kan worden vermenigvuldigd met een drijver om meer kracht op het object te creëren. U kunt ook verwijzen transformeren en transformeren. goed, en ontken ze om hun tegenslagen te krijgen.
6.4 Botsing
Vaak wil je bij het bouwen van een game dat een botsing resulteert in een bepaalde statusverandering in je code, naast alleen natuurkundige simulatie. Hiervoor heb je een botsingsdetectiemethode.
Er is een bepaalde hoeveelheid voorbereidend werk nodig om botsingen in Unity te detecteren. Ten eerste heeft ten minste één van de objecten in de botsing een nodig niet-kinematisch star lichaam eraan vastgemaakt. Beide objecten moeten de juiste botsingen hebben, ingesteld als niet-triggers. De totale snelheid van beide objecten moet zo laag zijn dat ze daadwerkelijk botsen, in plaats van simpelweg door elkaar heen te springen.
Als alles is geregeld, kunt u controleren op botsingen door een speciale methode voor botsingsdetectie te plaatsen in een script dat is gekoppeld aan het object waarmee u de botsing wilt controleren. De methode ziet er als volgt uit:
void OnCollisionEnter (Collision other) {// doe hier dingen. }
Deze methode wordt automatisch uitgevoerd tijdens het eerste frame dat een ander object uw object raakt. De botsingsentiteit andere is een verwijzing naar het object dat je raakt. U kunt er bijvoorbeeld naar verwijzen gameobject, star lichaam, en transformeren kenmerken om het op verschillende manieren te manipuleren. Terwijl OnCollisionEnter is waarschijnlijk de meest voorkomende functie die u gaat gebruiken, u kunt ook gebruiken OnCollisionExit en OnCollisionStay (met verder identieke syntaxis en gebruik), die worden geactiveerd tijdens het eerste frame dat u stopt met het botsen met een object en tijdens elk frame dat u respectievelijk met een object botst.
Soms kan het ook handig zijn om te doen wat wordt genoemd raycasting. Bij raycasting is een oneindig dunne lijn (a straal) wordt vanuit een bepaalde oorsprong, langs een bepaalde vector door de wereld geworpen, en wanneer het iets raakt, worden de positie en andere details van de eerste botsing geretourneerd. De code voor een raycast ziet er als volgt uit:
RaycastHit hit; if (Fysica. Raycast (transform.position, -Vector3.up, out hit)) {float distanceToGround = hit.distance; }
Dit werpt een straal vanaf de positie van het huidige object langs -Vector3.up (recht naar beneden) en verbindt de variabele raken tegen het eerste object waarmee het in botsing komt. Zodra uw straal iets heeft geraakt, heeft u toegang hit. afstand om te bepalen hoe ver het is, of raken. GameObject om het object dat je raakt te manipuleren.
Raycasts zoals deze kunnen worden gebruikt voor fotografen om te bepalen waar het pistool naar wijst, of om objecten te selecteren wanneer de camera ernaar kijkt, of voor bepaalde bewegingsmechanica.
6.5 Tijdcorrectie
Een belangrijke factor waarmee u rekening moet houden wanneer u objecten op deze manier manipuleert, heeft hiermee te maken frame rate. Hoe zorgvuldig u ook optimaliseert, framerates zullen altijd variëren en u wilt niet dat uw spelsnelheid dienovereenkomstig varieert. Als iemand anders je game op een snellere computer draait dan waarop je hem hebt ontwikkeld, wil je niet dat de game op dubbele snelheid draait.
De manier waarop u dit corrigeert, is door de waarden die u gebruikt te vermenigvuldigen met de tijd die nodig was om het laatste frame weer te geven. Dit wordt gedaan met Time.deltaTime. Dit verandert effectief de snelheid van elke variabele waarvan u elk frame verhoogt verandering per frame naar verandering per seconde, en u moet deze wijziging waarschijnlijk aanbrengen in elke waarde die u elk frame verhoogt of verlaagt.
6.6 Audiobronnen en luisteraars
Nu we hebben besproken hoe objecten kunnen worden gemaakt, weergegeven en beheerd, laten we het hebben over het andere gevoel dat computerspellen kunnen dienen: namelijk geluid. Unity ondersteunt twee soorten geluiden: 2D en 3D geluiden. 3D-geluiden variëren hun volume op basis van afstand en vervormen wanneer ze bewegen ten opzichte van de camera; 2D-geluiden niet.
2D-geluiden zijn geschikt voor voice-overs en achtergrondmuziek, en 3D-geluiden zijn van toepassing op geluiden die worden gegenereerd door gebeurtenissen in de wereld. Om te wijzigen of een geluid al dan niet 3D is, selecteert u het in de project bekijken, overschakelen naar de inspecteur bekijken en selecteer de juiste optie in het vervolgkeuzemenu en druk vervolgens op opnieuw importeren knop.
Om het geluid daadwerkelijk af te spelen, moet je een geluidsbron naar een prop (de prop waarvan je wilt dat het geluid afkomstig is, in het geval van een 3D-geluid). Dan moet je de openen audioclip veld en selecteer uw geluidsbestand.
Je kunt gebruiken myAudioSource. Pauze() en myAudioSource. Speel() om die geluidsbestanden te bedienen. U kunt het afvalsgedrag, het volume en de dopplerverschuiving van de geluiden onder de aanpassen inspecteur tabblad voor de audiobron.
6.7 Invoer
Een game die geen input heeft van de gebruiker is niet echt een game. Er zijn veel verschillende soorten invoer die u kunt inlezen, en bijna allemaal zijn ze toegankelijk via de Invoer en Sleutelcode voorwerpen. Enkele voorbeeldinvoerinstructies (waarvan de waarden elk frame hebben geëvalueerd) staan hieronder.
Vector3 mousePos = Input.mousePosition; bool isLeftClick = Input. GetMouseButton (0); bool isPressingSpace = Input. GetKey (KeyCode. Ruimte);
De functies van deze lijnen spreken meestal voor zich. Met behulp van deze drie soorten invoerreferentie kunt u de besturingsschema's van de meeste moderne 3D-computerspellen reconstrueren.
6.8 Debuggen van een script
Stel dat een script niet werkt. Zoals de goede dokter zegt, kun je bangups en hangups overkomen. Als er regelrechte syntaxisfouten zijn met uw C #, zal de game over het algemeen weigeren te worden uitgevoerd wanneer u op play drukt, en er worden enkele redelijk nuttige foutmeldingen gegeven als u bouwen de scripts vanuit de editor. Zie hieronder:
Deze bugs zijn meestal niet de moeilijkste om op te lossen. Wat nog problematischer kan zijn, zijn subtiele semantische fouten, waarbij u met succes een bestand vol geldige C # hebt geschreven - alleen niet een bestand dat doet wat u dacht dat het zou doen. Als u een van deze fouten heeft en u ondervindt problemen bij het opsporen ervan, zijn er een paar dingen die u kunt proberen om de situatie te verbeteren.
De eerste is om de uitvoering van het spel te pauzeren en de console te controleren. Je kunt het spel pauzeren door op te klikken pauze pictogram in het bovenste middelste gedeelte van de editor en selecteer vervolgens troosten vanaf de onderkant van de venster menu (of door op te drukken Ctrl > Verschuiving > C). Zelfs als er geen fouten zijn, kunnen waarschuwingen toch helpen om wat aanwijzingen te geven over wat er mis zou kunnen gaan.
Als dit niet werkt, kunt u ook proberen een idee te krijgen van de status van uw script door de status van interne variabelen af te drukken om te valideren dat het programma doet wat u denkt dat het doet. Je kunt gebruiken Debuggen. Log (String) om de inhoud van een string naar de console af te drukken wanneer de programma-uitvoering die regel raakt. In het algemeen, als je achteruit werkt van wat je denkt dat er zou moeten gebeuren door de dingen die zouden moeten zijn Als u dit mogelijk maakt, bereikt u uiteindelijk een punt waarop uw foutopsporingsafdrukken niet doen wat u verwacht Doen. Dat is uw fout.
7. Voorbeeld: Scripting Pong
Om Pong te bouwen, laten we het spel opsplitsen in de kernelementen: we hebben een bal nodig die heen en weer schiet tussen de peddels om snelheid, we hebben een scorebord nodig dat weet wanneer de ballen de paddles zijn gepasseerd, en we hebben een mechanisme nodig om de bal opnieuw te starten wanneer dat gebeurt. Een goede eerste stap zou zijn om een niet-kinematisch star lichaam aan de bal toe te voegen, twee kinematisch starre lichamen aan de peddels, schakel de zwaartekracht voor ze allemaal uit en wijs een geschikt fysisch materiaal toe uit de standaardassets (stuiteren met stuiteren combineren ingesteld op vermenigvuldigen).
Hieronder kunt u het script voor de bal bekijken met toelichtende opmerkingen. De bal moet een aantal basisdoelen bereiken: hij moet stuiteren in een gecompliceerd patroon, altijd behoudend beweging op beide assen, en het zou in een horizontaal maar uitdagend maar niet onmogelijk tempo moeten versnellen richting.
BallHandler.cs
Vervolgens moeten we onze peddel een script geven, die u hieronder kunt bekijken. De peddel moet op en neer bewegen als gevolg van toetsaanslagen (maar niet buiten bepaalde grenzen). Het moet ook het deeltjessysteem activeren wanneer het ergens tegenaan botst.
PaddleHandler.cs
Vervolgens hebben we vijandelijke AI nodig: iets dat ervoor zorgt dat de peddel van de vijand met een vaste snelheid naar de bal volgt. Daarvoor gebruiken we Vector3.Slerp voor maximale eenvoud. We willen ook hetzelfde deeltjesgedrag dat we op onze eigen peddel zien.
EnemyAI.cs
Ten slotte hebben we een script nodig om het scorebord bij te werken en de bal opnieuw in te stellen wanneer deze de grenzen verlaat.
ScorebordUpdater.cs
Met die scripts bijgevoegd en de referenties ingevuld, ervaren we gameplay wanneer we ons spel van Pong uitvoeren!
Jij kan download mijn Pong-demo, als je alles wat ik heb geschetst in actie wilt zien. Het werkt op Windows-, Mac- en Linux-systemen.
8. De documentatie verkennen / meer leren
Unity is een complexe engine met veel meer functies dan mogelijk zou zijn in een gids van deze stijl, en dat is voordat u de brede reeks (gratis en commerciële) Unity-extensies die beschikbaar zijn op de internet. Deze gids geeft je een sterke startplaats voor het ontwikkelen van een game, maar zelfstudie is een belangrijke vaardigheid bij elke onderneming, en dubbel hier.
Een cruciale bron hier is de Unity ScriptReference. De ScriptReference is een doorzoekbare database, beschikbaar voor zowel C # als Javascript, die een lijst heeft van elke Unity-opdracht en -functie, met beschrijvingen van hun functies en korte voorbeelden van syntaxis.
Als je problemen hebt met de editor en interface van Unity, of gewoon als video-tutorials als een kwestie van voorkeur, is er een lange lijst van hoge kwaliteit Unity video-tutorials De beste Unity 3D-zelfstudies voor beginnersWil je games ontwikkelen met Unity, maar weet je niet waar je moet beginnen? Probeer vandaag nog een van deze geweldige Unity 3D-tutorials. Lees verder beschikbaar. Uitgebreider (maar minder breed) tekstlessen voor Unity zijn ook verkrijgbaar bij CatLikeCoding.
Als u tot slot vragen heeft die buiten het bereik van documentatie of zelfstudies vallen, kunt u specifieke vragen stellen op antwoorden. Unity3d.com. Onthoud dat antwoorden door vrijwilligers worden gegeven, dus respecteer hun tijd en doorzoek eerst de database om er zeker van te zijn dat uw vraag nog niet is beantwoord.
9. Je game bouwen / compileren naar een zelfstandige applicatie
Als je iets hebt gebouwd waar je trots op bent (of je hebt ons ietwat dodgy Pong-voorbeeld gekloond om te oefenen), is het tijd om verplaats uw spel van de editor en verander het in iets dat u op internet kunt plaatsen en dwing uw vrienden en familie Speel. Om dat te doen, moet je een stand-alone app bouwen. Het goede nieuws is dat dit in Unity heel, heel gemakkelijk is. Er zijn echter een paar mogelijke hikken waar u op moet letten.
Weet om te beginnen dat u alleen een foutloos project kunt bouwen. Zorg er daarom voor dat je de console tijdens het bouwen open hebt staan: er zijn enkele foutvoorwaarden die de game in de editor negeert, maar een poging tot bouwen afbreekt. Dit dumpt alleen foutmeldingen naar de console, zonder zichtbare resultaten op het scherm, wat frustrerend kan zijn als je vergeet te controleren. Zodra u uw game foutloos heeft samengesteld, kunt u selecteren Build-instellingen onder de het dossier menu of druk op Ctrl > Verschuiving
> B. Dit zal een eenvoudig dialoogvenster openen waarmee je je spel voor verschillende platforms kunt bouwen.
Het proces van daaruit spreekt voor zich: selecteer uw opties en druk op bouwen; het spel zal je vragen om een directory om te installeren, en zal zowel de executable als de data directory daar plaatsen. Deze twee bestanden kunnen aan elkaar worden gezipt en gedistribueerd (zorg er wel voor dat u geen kosten in rekening brengt voor een game die is ingebouwd in de Unity-demo, aangezien dit in strijd is met de servicevoorwaarden).
10. Notities sluiten
Zoals bij elke game-ontwikkelingstool, is iteratieve ontwikkeling de sleutel tot succes met Unity. Je moet beheersbare stappen bouwen - wees ambitieus, maar wees ambitieus in kleine stukjes, en regel die brokjes zodat, zelfs als je je ultieme ambitie niet haalt, je op zijn minst eindigt met een coherente Product.
Haal eerst de meest cruciale elementen in huis: heb een idee voor ogen minimaal levensvatbaar product, het eenvoudigste, meest kale ding dat je ooit zou kunnen maken en nog steeds het gevoel hebt dat je iets waardevols hebt bereikt. Ga naar dat minimaal haalbare project voordat je doorgaat naar grotere ambities.
Deze tutorial geeft je een sterke startplaats, maar de beste manier om Unity te leren is door een game te bouwen. Begin met het bouwen van een game, vul hiaten in je kennis op als ze naar boven komen, en de geleidelijke stroom van kennis zal de dingen die je niet verrassend snel weet weg te werken.
Als je dit allemaal hebt gelezen en een beetje overweldigd bent door de codering die vereist is voor Unity, kijk dan hoe je leer game-ontwikkeling met Unity Learn Unity Learn is de gemakkelijkste manier om game-ontwikkeling onder de knie te krijgenWil je beginnen met het ontwikkelen van je eigen games? Unity Learn is de beste en gemakkelijkste manier om te leren en te beheersen wat u moet weten. Lees verder en lees ook onze gids over hoe je videogames kunt maken zonder programmeren Videogames maken zonder programmerenWilt u een videogame maken, maar kunt u niet coderen? Gebruik dan een bouwpakket voor videogames waarmee je games kunt bouwen zonder dat je iets hoeft te coderen! Lees verder .
Unity is een krachtig hulpmiddel en met een beetje verkenning kun je er sneller indrukwekkende projecten mee bouwen dan je zou verwachten. Laat ons weten wat je hebt gebouwd in de onderstaande opmerkingen - we zien het graag!
Andre, een schrijver en journalist gevestigd in het zuidwesten, blijft gegarandeerd functioneel tot 50 graden Celcius en is waterdicht tot een diepte van twaalf voet.