Home-theater-designers
Een verrassend kenmerk van de interneteconomie is de opkomst van indie-videogames. Eens het exclusieve domein van triple-A-studio's met duizenden man en meerdere miljoenen dollars, is een aantal toolsets ontwikkeld die moderne middelen voor game-ontwikkeling in de handen van individuen of kleine, ad-hoccollecties van programmeurs en ontwerpers brengen. We hebben eerder de beste indiegames besproken, dus zorg ervoor dat je die bekijkt voor wat inspiratie over wat je kunt bereiken met tools zoals Unity.
Deze ontwikkelingsteams voor indiegames hebben blijk gegeven van een behendigheid en risicotolerantie, waardoor ze in veel gevallen gameplay-innovatie sneller kunnen stimuleren dan hun tegenhangers met een groot budget. Een aantal schokkend succesvolle indietitels zijn de afgelopen jaren in première gegaan, waaronder: Minecraft , voorgeborchte , en Super vlees jongen , en zelfs als je geen vaardigheden hoeft te hebben om dit soort spellen te maken, kun je een spel maken met Buildbox .
In het snel evoluerende landschap van de ontwikkeling van indiegames, Eenheid is naar voren gekomen als iets van een de-facto standaard: de lage kosten, het gebruiksgemak en de brede functieset maken het ideaal voor snelle game-ontwikkeling. Unity is zo flexibel, dat je zelfs maak je eigen aangepaste gamecontrollers met een beetje doe-het-zelf-kennis!
Zelfs grote studio's zoals CCP (Ontwikkelaars van Eva online ) gebruiken voor het snel prototypen van spelconcepten. Unity biedt een 'game-engine in a box' -- 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 'zero programming'-tool voor het maken van games. Het vereist dat je programmeert om resultaten te produceren, maar het geeft je ook een veel flexibeler en krachtiger hulpmiddel dan welk 'game maker'-programma dan ook zou kunnen.
Unity zal het werk niet voor u doen, maar het verlaagt de toetredingsdrempel aanzienlijk. Helemaal opnieuw beginnen met C++ en OpenGL, kan het dagen duren om op het punt te komen waarop 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 de handen van beginnende programmeurs.
Vandaag zal ik je door alles leiden wat je moet weten om een spel te maken in Unity, dat is onderverdeeld in tien hoofdhoofdstukken:
§3–Een korte inleiding tot het objectgeoriënteerde paradigma
§5–Voorbeeld: basiselementen van een spel
§8–De documentatie verkennen / meer leren
§9–Je game bouwen / compileren naar een zelfstandige applicatie
1. Versies van Unity
Unity is er 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 games.
Dat gezegd hebbende, voor de meeste relatief eenvoudige games die je misschien wilt bouwen, is de gratis versie van Unity perfect geschikt. We zullen de belangrijkste verschillen hieronder in meer detail uitsplitsen voor geïnteresseerden.
1.1 Prijzen
De gratis versie van Unity is natuurlijk gratis. Er zijn echter een paar 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 springen als u vermoedt dat u zo'n organisatie zou kunnen worden.
De Pro-versie van Unity is $ 75 een maand, of $ 1500 voor een permanente licentie, en er zijn geen grenzen aan wat je kunt doen met de games 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 te geven van de beschikbare functies. Een eenjarige studentenlicentie is ook beschikbaar via: Studie voor $ 129 .
1.2 Kenmerken
Er ontbreken veel functies in de gratis versie van Unity. De belangrijkste verschillen zijn echter de volgende: de gratis versie van Unity mist een aantal weergave-opties die zorgen voor mooiere, sneller draaiende games (LOD-ondersteuning, screen-space post-processing, geavanceerde shaders, real-time soft schaduwen en uitgestelde weergave). Het mist ook de volledige mechanisme 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-games ontwikkel voor de Oculus Rift en de ondersteuning voor nabewerking van de schermruimte nodig is om correct te communiceren met de headset.
2. Unity installeren
Unity is eenvoudig te installeren. U kunt het uitvoerbare bestand downloaden van unity3d.com/get-unity/download .
Nadat het is gedownload, voert u het uit en volgt u de instructies van het installatieprogramma. Wanneer de installatie is voltooid, verschijnt een venster met de titel 'activeer uw Unity-licentie'. Vink het vakje aan met 'activeer een gratis proefperiode 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.
wat voor soort schroevendraaier voor ps4
3. Een korte inleiding 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 ; we zullen voor deze zelfstudie met C # werken.
Ten eerste, als je nog nooit eerder hebt geprogrammeerd, leg dan deze tutorial opzij en besteed een paar dagen aan het werken met Microsoft's C # Taalprimer 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 per se een taal die je in Unity kunt gebruiken), bekijk dan onze gids voor de zes gemakkelijkste programmeertalen voor beginners.
Als je eerder hebt geprogrammeerd in een imperatief of objectgeoriënteerde taal zoals C of Java, sla dan de inleiding over en maak jezelf vertrouwd met hoe C# verschilt van andere talen die je in het verleden hebt gebruikt. Hoe dan ook, ga niet verder met de tutorial totdat je je op je gemak voelt bij het oplossen van eenvoudige problemen met C# (als ik je bijvoorbeeld zou vragen een programma te schrijven dat de eerste honderd priemgetallen afdrukt, zou je dat programma moeten kunnen schrijven zonder Google raadplegen).
Het belangrijkste concept om hier te begrijpen is het objectgeoriënteerde paradigma (afgekort als: OPEN ). 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 te isoleren en andere objecten te dwingen ermee te communiceren via zijn methoden, kun je het aantal mogelijke onbedoelde interacties verminderen - en bij uitbreiding bugs. U kunt ook objecten maken die u later zonder wijziging kunt hergebruiken. In Unity bouw je deze objecten en bevestig je ze aan spel entiteiten (wiens gedrag ze zullen regeren).
Objecten worden geïnstantieerd van klassen : een klasse is slechts een bestand dat de definitie van uw object aangeeft. Dus als je een Mook object dat AI voor een vijand in je spel afhandelt, zou je een 'Mook'-klasse schrijven en dat bestand vervolgens aan elke vijandelijke entiteit toevoegen. 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:
Eerst, 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:
using UnityEngine;
public class Mook : MonoBehaviour {
private float health;
void Start () {
health = 100;
}
void Update(){
if (health > 0) {
/* Search for player
if you encounter the player on the road, kill him
if you get shot, remove a random amount of health */
}
}
}Laten we dit opsplitsen:
- UnityEngin gebruiken: Deze regel vertelt C# dat we de bibliotheken van Unity willen gebruiken, waarmee we verbinding kunnen maken met de Unity-game-engine.
- Openbare les Mook : MonoGedrag: Deze regel geeft de klasse en zijn naam aan -- Mook .
- Gezondheid privé vlotter: Dit declareert een private class-variabele (die alleen vanuit de class kan worden gewijzigd). De variabele krijgt een waarde in Begin .
- Ongeldige start(): Dit declareert een methode genaamd Begin . Start is een speciale methode die slechts éé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 zal hier naartoe gaan.
- // als je de speler op de weg tegenkomt, dood hem: Deze regel is een commentaar (elke regel die begint met een dubbele schuine streep wordt genegeerd door C#). Opmerkingen worden gebruikt om uzelf 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 Update , kunt u uw eigen methoden met bijna elke naam instantiëren. Methoden die u maakt, worden echter pas uitgevoerd als ze worden aangeroepen. Laten we een methode declareren voor een hypothetische klasse genaamd addTwoNumbers die twee getallen bij elkaar optelt:
public float addTwoNumbers(float a, float b) {
return a+b;
}Dit declareert een openbare (toegankelijk voor andere objecten) methode die een float retourneert, genaamd addTwoNumbers , waarvoor twee floats als invoer nodig zijn (genaamd tot en B ). Het retourneert vervolgens de som van de twee waarden als uitvoer.
Deze methode aanroepen vanuit dezelfde klasse (bijvoorbeeld van binnenuit) Update ) het lijkt op dit:
float result = addTwoNumbers(1, 2);Het aanroepen van de methode vanuit een andere klasse is vergelijkbaar:
addTwoNumbers instance;
float result = instance.addTwoNumbers(1, 2);Nogmaals, dit maakt gewoon een instantie van onze klasse, geeft toegang tot de juiste methode en geeft deze de nummers die we willen toevoegen, en slaat het resultaat vervolgens op in resultaat . Eenvoudig.
Als je script is gekoppeld aan een object dat speciale eigenschappen heeft (zoals een deeltjeszender) die niet toegankelijk zijn onder de normale set GameObject-parameters, kun je ervoor kiezen om het als een ander soort game-entiteit te behandelen door de GetComponent methode.
De syntaxis daarvoor ziet er als volgt uit:
GetComponent().Play();Als dit je niet bekend is, ga dan terug en doorloop de C#-primer. Het zal u veel frustratie besparen als we verder gaan.
4. Basisprincipes van eenheid
In dit gedeelte gaan we ons een weg banen door de basismechanica van de Unity-engine. De workflow in Unity gaat ongeveer als volgt:
- Creëer een entiteit om een rol in het spel te vervullen (leeg GameObjecten kan worden gebruikt voor abstracte logische taken).
- Schrijf of zoek een klassenbestand en voeg het toe aan de entiteit als een script (met behulp van de Component toevoegen knop in de inspecteur weergave.
- Loop > toets > debuggen > herhalen totdat het werkt en ga verder met het volgende element van het spel.
Unity wordt geleverd met een aantal basisweergavetabbladen die op verschillende manieren naar de smaak van de gebruiker kunnen worden ingedeeld. De grote vijf zijn:
- Spel: geeft een actieve instantie van de game weer waarmee u kunt communiceren en testen.
- Tafereel: biedt een statische, bewerkbare versie van de spel wereld .
- Inspecteur: stelt je in staat om individuele entiteiten in de spelwereld te wijzigen door ze te selecteren in de editor tabblad.
- Project: stelt u in staat door de bestanden van het project te bladeren en modellen, materialen en andere bronnen naar de editor tab 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 mazen
Mesh is de manier 3D-geometrie is vertegenwoordigd in Unity. Je kunt de ingebouwde Unity's gebruiken primitief objecten (kubussen, bollen, cilinders, enz.), of importeer uw eigen 3D-modellen uit een modelleerpakket zoals Blender of Maya . Unity ondersteunt verschillende 3D-formaten, waaronder: .fbx , en .3ds .
De basishulpmiddelen voor het manipuleren van meshes zijn de knoppen voor schalen, roteren en vertalen in de linkerbovenhoek van de interface. Deze knoppen voegen bedieningspictogrammen 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 . te analyseren 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 echter om de 3D-tekst en Vierpersoonskamer GameObjects (met transparante texturen en een onverlichte transparante shader) om HUD-elementen als entiteiten in de gamewereld te plaatsen.
In de hiërarchie bekijken, kunnen deze gameplay-elementen naar de hoofdcamera worden gesleept om ze kinderen te maken, zodat ze met de camera kunnen bewegen en roteren.
GUI-elementen (tekst en texturen) kunnen hun grootte en schaal laten aanpassen met behulp van de relevante velden in het infovenster.
4.1.3 Materialen
Materialen zijn combinaties van texturen en shaders en kunnen rechtstreeks vanaf het projecttabblad naar game-objecten worden gesleept. Unity Pro wordt geleverd met een groot aantal shaders en u kunt de eraan gekoppelde textuur aanpassen met behulp van het infovenster voor een object waarop ze zijn toegepast.
Om een textuur te importeren, converteert u deze naar a .jpg , .png , of .bmp en sleep het naar de middelen map onder de Unity-projectdirectory (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 vinden onder de projecteren tabblad.
4.1.5 Verlichting
Lichten zijn GameObjecten die uitstraling op de wereld projecteren. Als er geen licht in je scène is, worden alle polygonen met hetzelfde helderheidsniveau getekend, waardoor de wereld een vlak, vervaagd uiterlijk krijgt.
Lampen 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 vervaagt.
De richtlijnen in de scèneweergave laat u het maximale bereik van de verlichting zien. Speel met beide instellingen om het gewenste effect te bereiken. U kunt ook de kleur van het licht, het patroon ( koekje weergegeven op het oppervlak waarop het licht is gericht, en wat voor soort overstraling er op het scherm verschijnt als je rechtstreeks in het licht kijkt. De cookie kan worden gebruikt om realistischere lichtpatronen te vervalsen, dramatische valse schaduwen te creëren en projectoren te simuleren.
De drie belangrijkste soorten licht zijn: plek , punt , en directioneel .
Spotlichten een locatie in de 3D-ruimte hebben en licht slechts in één richting projecteren in een kegel met variabele hoek. Deze zijn goed voor zaklampen, zoeklichten en geven u over het algemeen een nauwkeurigere controle over de verlichting. Spotlichten kunnen schaduwen werpen.
Puntverlichting hebben een locatie in de 3D-ruimte en werpen het licht gelijkmatig in alle richtingen. Puntlichten werpen geen schaduwen.
Richtingaanwijzers , ten slotte, worden gebruikt om zonlicht te simuleren: ze projecteren licht in een richting alsof het van oneindig ver weg is. Directionele lichten beïnvloeden elk object in de scène en kunnen schaduwen produceren.
4.1.6 Deeltjessystemen
TOT Deeltjessysteem is een GameObject die honderden of duizenden deeltjes tegelijk genereert en bestuurt. Deeltjes zijn kleine, geoptimaliseerde 2D-objecten die in de 3D-ruimte worden weergegeven. Deeltjessystemen maken gebruik van 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 er toegang toe krijgen door een deeltjessysteem onder de component-editor > het deeltjessysteem selecteren > het tabblad Inspecteur openen . U kunt de grootte, snelheid, richting, rotatie, kleur en textuur van elk deeltje wijzigen en de meeste van die parameters ook instellen om in de loop van de tijd te veranderen.
Onder de botsing attribuut, als u het inschakelt en de simulatieruimte instelt op wereld- je krijgt deeltjes die botsen 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 spel maken van Pong -- iets dat we al vaker in DIY hebben behandeld:
- Arduino Klassieke Pong
- Arduino OLED Pong
In deze sectie gaan we de kernelementen ordenen -- de scripting-tutorial komt later.
Laten we eerst het spel Pong opsplitsen in zijn basiscomponenten. Eerst hebben we twee peddels en een bal nodig. De bal vliegt buiten beeld, dus we willen een mechanisme om hem te resetten. We willen ook dat tekst de huidige score weergeeft, en om je alle kernelementen van Unity te laten zien, willen we een mooi partikeleffect wanneer je de bal raakt. Het hele spel moet dramatisch verlicht zijn.
Dat valt uiteen in een bal object (een bol), a spawner , twee peddelsteunen met deeltjesstralers bijgevoegd, een 3D-tekst entiteit , en een spotlicht . Voor deze tutorial gebruiken we het standaard fysieke materiaal stuiteren , met bounce combineren ingesteld op vermenigvuldigen . Zo ziet de setup eruit, in tien screenshots:
Maak eerst een kubus prop voor de peddel.
Schaal het op de juiste manier, dupliceer het , en zet een gebied tussen de peddels voor de bal.
Maak dan een 3DText-object en schaal en positie het correct, het veranderen van de lettertypegrootte attribuut om een minder gepixelde afbeelding te krijgen.
Maak vervolgens twee deeltjessystemen , kies de gewenste kenmerken en bevestig ze aan de peddels.
Vervolgens wil je positie en draai de camera zodat het de scène correct omlijst. Terwijl de camera is geselecteerd, ziet u een klein voorbeeld van het camerabeeld in de rechterbenedenhoek.
Voordat we klaar zijn, moeten we twee extra kubussen maken als bumpers, om te voorkomen dat de bal uit het spelgebied stuitert. We kunnen ze onzichtbaar maken door het vinkje 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 aan!
Nu we die opstelling hebben, gaan we het hebben over wat er komt kijken bij het scripten van deze elementen om een spel te maken.
6. Scripten in Unity
Als je eenmaal een script aan een object hebt gekoppeld, kun je het herzien door erop te dubbelklikken in de inspecteur . Dit opent MonoDevelop , de standaard ontwikkelomgeving voor Unity. In wezen is Monodevelop een teksteditor met functies die specifiek zijn geoptimaliseerd voor programmeren.
Trefwoorden en opmerkingen zijn gemarkeerd in blauw en groente , en numerieke waarden en tekenreeksen verschijnen in netto- . 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 zo:
Over het algemeen moet u, om uw script met Unity te laten werken, verwijzen naar elementen die het object met het script bezit (u kunt een lijst van 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 GameObject variabele in je script, en gebruik de inspecteur om het toe te wijzen aan een ander object in de scène.
Een lijst van de elementen die een object kan hebben is als volgt (overgenomen uit de inspecteur-weergave van een van onze paddles in het bovenstaande voorbeeld):
- Transformeren
- Kubus (gaasfilter)
- 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 regelen de fysieke parameters van dat object: zijn schaal , zijn positie , en zijn oriëntatie . Je kunt ze openen vanuit een script zoals dit:
transform.position = newPositionVector3;
transform.rotation = newRotationQuaternion;
transform.localScale = newScaleVector3;In de bovenstaande voorbeelden zijn de benoemde variabelen van de typen die in de namen zijn gespecificeerd. Er zijn een paar belangrijke details: positie en schaal worden, zoals je zou verwachten, opgeslagen als Vector3s . U heeft toegang tot de x , EN , en MET componenten van elk (bijvoorbeeld transformeer.positie.y geeft u de afstand van een object boven het nulvlak).
Echter, om te voorkomen dat gimbal slot , worden rotaties behandeld als Quaternions (viercomponentenvectoren). Omdat het manipuleren van quaternionen met de hand niet intuïtief is, kunt u rotaties manipuleren met Euleriaanse hoeken met behulp van de Quaternion.Euler methode als volgt:
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 quaternionen en vector3s nuttig. Slerp gebruikt drie argumenten - de huidige status, de uiteindelijke status en de snelheid van verandering, en interpoleert daar soepel tussen 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 = new Color(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 handig trucje in een aantal situaties. Het tweede voorbeeld wijst een nieuwe . toe RGB-kleur (namelijk groen) aan het object in kwestie. De derde wijst de belangrijkste diffuse textuur toe aan een nieuwe textuurvariabele. Het laatste voorbeeld verandert de arcering van het materiaal van het object in een nieuw gedefinieerde shader-variabele.
6.3 Natuurkunde
Unity wordt geleverd met een geïntegreerde physics-engine - iets dat alle physics-sandbox-games gebruiken. Hiermee kunt u de fysieke eigenschappen van objecten toewijzen en de details van hun simulatie voor u laten regelen. Over het algemeen is het eenvoudiger en robuuster om de physics-engine van Unity zo veel mogelijk te gebruiken, in plaats van te proberen je eigen fysica te implementeren met behulp van een leerboek en het transformatiesysteem.
Alle natuurkundige rekwisieten vereisen: botsers . De eigenlijke simulatie zelf wordt echter afgehandeld door a star lichaam , die kan worden toegevoegd in de inspecteur weergave. Stijve lichamen kunnen zijn: kinematisch of niet-kinematisch .
Kinematische fysica rekwisieten botsen met (en effect) niet-kinematische fysica rekwisieten om hen heen, maar worden niet beïnvloed door botsing zelf. Statische kinematische rekwisieten zijn de spreekwoordelijke onbeweeglijke objecten, en bewegende kinematische objecten zijn de spreekwoordelijke onstuitbare kracht (voor de goede orde, wanneer ze botsen, gaan ze gewoon door elkaar heen).
Verder kun je de hoekweerstand van het object aanpassen (hoeveel energie het kost om het te laten draaien), de massa veranderen, dicteren of het al dan niet wordt beïnvloed door de zwaartekracht en er krachten op uitoefenen.
Voorbeelden:
rigidbody.angularDrag = 0.1f;
rigidbody.mass = 100;
rigidbody.isKinematic = false;
rigidbody.useGravity = true;
rigidbody.AddForce(transform.forward * 100);Deze zijn allemaal vrij vanzelfsprekend. Het enige dat hier opvalt, is het gebruik van transformeren.vooruit . Vector3's hebben allemaal drie componenten ( .naar voren , .omhoog , en .Rechtsaf ) geassocieerd met hen, die kan worden geopend en roteert met hen ( naar voren is de richting van de blauwe pijl in de editor). De transformeren.vooruit trefwoord is gewoon de voorwaartse vector voor het huidige object met magnitude 1. Het kan worden vermenigvuldigd met een float om meer kracht op het object te creëren. U kunt ook verwijzen naar transformeren.up en transformeren.rechts en negeer ze om hun tegenslagen te krijgen.
6.4 Botsing
Bij het bouwen van een game wil je vaak dat een botsing resulteert in een verandering van status 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 niet-kinematisch star lichaam eraan gehecht. Beide objecten moeten de juiste versnellers hebben, ingesteld op niet-triggers. De totale snelheid van beide objecten moet zo laag zijn dat ze daadwerkelijk botsen, in plaats van gewoon door elkaar heen te springen.
Als je dat allemaal hebt geregeld, kun je controleren op botsingen door een speciale methode voor het detecteren van botsingen in een script te plaatsen dat is gekoppeld aan het object waarmee je de botsing wilt controleren. De methode ziet er als volgt uit:
void OnCollisionEnter(Collision other) {
//do things here
}Deze methode wordt automatisch uitgevoerd tijdens het eerste frame dat een ander object uw object raakt. De botsingsentiteit ander is een verwijzing naar het object dat je raakt. U kunt bijvoorbeeld verwijzen naar zijn gameobject , star lichaam , en transformeren kenmerken om het op verschillende manieren te manipuleren. Terwijl OnCollisionEnter is waarschijnlijk de meest voorkomende functie die u zult gebruiken, u kunt ook gebruiken Bij CollisionExit en OnCollisionStay (met verder identieke syntaxis en gebruik), die respectievelijk worden geactiveerd tijdens het eerste frame dat u stopt met botsen met een object en tijdens elk frame dat u met een object botst.
Soms kan het ook handig zijn om te doen wat heet raycasting . Bij raycasting is een oneindig dunne lijn (a straal ) wordt door de wereld geworpen vanaf een bepaalde oorsprong, langs een vector, 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 (Physics.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 koppelt de variabele raken naar het eerste object waarmee het botst. Zodra je straal iets heeft geraakt, heb je toegang tot hit.afstand om te bepalen hoe ver het is, of hit.GameObject om het object dat je raakt te manipuleren.
Raycasts zoals deze kunnen worden gebruikt voor schutters om te bepalen waar het pistool op gericht is, of om objecten te selecteren wanneer de camera ernaar kijkt, of voor bepaalde bewegingsmechanismen.
6.5 Tijdcorrectie
Een belangrijke factor om in gedachten te houden wanneer u objecten op deze manier manipuleert, heeft te maken met: frame rate . Hoe zorgvuldig je ook optimaliseert, framerates zullen altijd variëren en je wilt niet dat je spelsnelheid dienovereenkomstig varieert. Als iemand anders je spel op een snellere computer draait dan waarop je het hebt ontwikkeld, wil je niet dat het spel 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 behulp van Tijd.deltaTijd . Dit verandert effectief de snelheid van elke variabele waarvan u elk frame verhoogt wijzigen per frame tot 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 u objecten kunt maken, weergeven en besturen, gaan we het hebben over het andere gevoel dat computerspellen kunnen dienen: namelijk: geluid . Unity ondersteunt twee soorten geluiden: 2D en 3D klinkt. 3D-geluiden variëren in volume op basis van afstand en vervormen als ze ten opzichte van de camera bewegen; 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 projecteren bekijken, overschakelen naar de inspecteur bekijk en selecteer de juiste optie in het vervolgkeuzemenu en druk vervolgens op de opnieuw importeren knop.
Om het geluid daadwerkelijk af te spelen, moet u een geluidsbron naar een prop (de prop waarvan u wilt dat het geluid afkomstig is, in het geval van een 3D-geluid). Dan moet je de . openen audioclip veld en selecteer uw geluidsbestand.
hoe u kunt controleren hoeveel abonnees u heeft
Je kunt gebruiken mijnAudioSource.Pauze () en mijnAudioSource.Play () om die geluidsbestanden te bedienen. U kunt het fall-off-gedrag, het volume en de dopplerverschuiving van de geluiden aanpassen onder de inspecteur tabblad voor de audiobron.
6.7 Invoer
Een game die geen input van de gebruiker nodig heeft, is niet echt een game. Er zijn veel verschillende soorten invoer die u kunt inlezen, en ze zijn bijna allemaal toegankelijk via de Invoer en Sleutelcode voorwerpen. Hieronder staan enkele voorbeelden van invoerinstructies (met een geëvalueerde waarde voor elk frame).
Vector3 mousePos = Input.mousePosition;
bool isLeftClicking = Input.GetMouseButton(0);
bool isPressingSpace = Input.GetKey(KeyCode.Space);De functies van deze lijnen spreken grotendeels voor zich. Met behulp van deze drie soorten invoerreferentie kunt u de besturingsschema's van de meeste moderne 3D-computerspellen reconstrueren.
6.8 Foutopsporing in een script
Stel dat een script niet werkt. Zoals de goede dokter zegt, kunnen knallen en ophangen je overkomen. Als er regelrechte syntaxisfouten zijn met uw C#, zal de game over het algemeen weigeren te draaien wanneer u op play drukt, en er worden enkele redelijk bruikbare foutmeldingen weergegeven als u bouwen de scripts vanuit de editor. Zie onder:
Deze bugs zijn meestal niet de moeilijkste om op te lossen. Wat problematischer kan zijn, zijn subtiele semantische fouten, waarin u met succes een bestand vol geldig C# hebt geschreven - alleen niet een bestand dat doet wat u dacht dat het zou doen. Als je een van deze fouten hebt en je hebt problemen om deze op te sporen, zijn er een paar dingen die je kunt proberen om de situatie te verbeteren.
De eerste is om de uitvoering van het spel te pauzeren en de console te controleren. U kunt het spel pauzeren door op de te klikken pauze pictogram in het bovenste middelste gedeelte van de editor en selecteer vervolgens troosten vanaf de onderkant van de raam menu (of druk op Ctrl > Verschuiving > C ). Zelfs als er geen fouten zijn, kunnen waarschuwingen toch helpen om aanwijzingen te geven over wat er mis kan 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 Debug.Log (tekenreeks) om de inhoud van een tekenreeks naar de console af te drukken wanneer de uitvoering van het programma die regel raakt. In het algemeen, als je achteruit werkt van wat je denkt dat er zou moeten gebeuren door de dingen die het zouden moeten laten gebeuren, zul je uiteindelijk een punt bereiken waarop je debug-afdrukken niet doen wat je verwacht dat ze doen. Daar zit je fout.
7. Voorbeeld: Scripting Pong
Laten we, om Pong te bouwen, het spel opsplitsen in zijn kernelementen: we hebben een bal nodig die met toenemende snelheid heen en weer tussen de peddels afketst, we hebben een scorebord nodig dat weet wanneer de ballen de peddels zijn gepasseerd, en we hebben een mechanisme nodig om de bal opnieuw starten wanneer dat gebeurt. Een goede eerste stap zou zijn om een niet-kinematisch star lichaam aan de bal toe te voegen, twee kinematische starlichamen aan de peddels, de zwaartekracht voor allemaal uit te schakelen en een geschikt fysiek materiaal toe te wijzen uit de standaardmiddelen ( stuiteren met bounce combineren ingesteld op vermenigvuldigen ).
Hieronder kun je het script voor de bal met toelichting bekijken. De bal moet een aantal basisdoelen bereiken: hij moet stuiteren in een ingewikkeld patroon, altijd in beweging blijven op beide assen, en hij moet versnellen met een uitdagend maar niet onmogelijk tempo in horizontale richting.
Vervolgens moeten we onze paddle scripten, die je hieronder kunt bekijken. De peddel moet op en neer bewegen als reactie op toetsaanslagen (maar niet buiten bepaalde grenzen). Het moet ook het deeltjessysteem activeren wanneer het ergens tegenaan botst.
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.
VijandAI.cs
Ten slotte hebben we een script nodig om het scorebord bij te werken en de bal te resetten wanneer deze buiten de baan gaat.
Met die scripts bijgevoegd en de referenties ingevuld, ervaren we gameplay wanneer we ons spel Pong spelen!
Jij kan download mijn Pong-demo , als je alles wat ik heb geschetst in actie wilt zien. Het draait op Windows-, Mac- en Linux-systemen.
8. De documentatie verkennen / meer leren
Unity is een complexe engine met veel meer functies dan mogelijk zou kunnen worden behandeld in een gids van deze stijl, en dat is voordat u de brede reeks (gratis en commerciële) Unity-extensies die op internet beschikbaar zijn, opneemt. Deze gids geeft je een goed uitgangspunt voor het ontwikkelen van een game, maar zelfstudie is een belangrijke vaardigheid bij elke onderneming, en dat geldt hier dubbel.
Een cruciale hulpbron hier is de Unity ScriptReferentie . De ScriptReference is een doorzoekbare database, beschikbaar voor zowel C# als Javascript, die een lijst heeft van alle Unity-opdrachten en -functies, met beschrijvingen van hun functies en korte voorbeelden van syntaxis.
Als je problemen hebt met de editor en interface van Unity, of gewoon video-tutorials als een kwestie van voorkeur hebt, is er een lange lijst met hoogwaardige Unity-videozelfstudies beschikbaar. Uitgebreider (maar minder breed) teksthandleidingen voor Unity zijn ook verkrijgbaar bij CatLikeCoding.
Tot slot, als u vragen heeft die buiten het bestek van documentatie of tutorials vallen, kunt u specifieke vragen stellen op: antwoorden.Unity3d.com . Onthoud dat de 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 spel bouwen / compileren naar een zelfstandige applicatie
Als je iets hebt gebouwd waar je trots op bent (of als je klaar bent met het klonen van ons ietwat onbetrouwbare Pong-voorbeeld om te oefenen), is het tijd om je game van de editor te verplaatsen en er iets van te maken dat je op internet kunt plaatsen en forceren je vrienden en familie om te spelen. Om dat te doen, moet u een zelfstandige toepassing bouwen. Het goede nieuws is dat dit in Unity heel, heel eenvoudig is. Er zijn echter een paar mogelijke problemen 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 open hebt staan terwijl je aan het bouwen bent: er zijn enkele foutcondities die de game in de editor negeert, maar een poging tot bouwen nog steeds zal afbreken. Dit dumpt alleen foutmeldingen naar de console, zonder zichtbare resultaten op het scherm, wat frustrerend kan zijn als je vergeet te controleren. Als je spel echter foutloos is gecompileerd, kun je kiezen voor Build-instellingen onder de Bestand menu, of druk op Ctrl > Verschuiving
> B . Dit zal een eenvoudig dialoogvenster openen waarmee je je spel voor verschillende platforms kunt bouwen.
Het proces vanaf daar spreekt voor zich: selecteer uw opties en druk op bouwen ; het spel zal je vragen om een map om naar te installeren, en zal zowel het uitvoerbare bestand als de gegevensmap daar plaatsen. Deze twee bestanden kunnen aan elkaar worden gecomprimeerd en gedistribueerd (zorg er wel voor dat u geen geld in rekening brengt voor een game die is gebouwd in de Unity-demo, omdat dit in strijd is met de servicevoorwaarden).
10. Slotopmerkingen
Zoals met elke game-ontwikkelingstool, is de sleutel tot succes met Unity iteratieve ontwikkeling. Je moet in beheersbare stappen bouwen -- wees in ieder geval ambitieus, maar wees ambitieus in kleine brokken, en rangschik die brokken zo dat, zelfs als je je uiteindelijke ambitie niet haalt, je op zijn minst een coherent Product.
Haal de meest cruciale elementen als eerste binnen: heb een idee voor uw minimaal levensvatbaar product , het eenvoudigste, meest kale ding dat je mogelijk kunt maken en toch het gevoel hebt dat je iets bereikt hebt dat de moeite waard is. Ga naar dat minimaal levensvatbare 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 spel, vul gaten in je kennis als ze zich voordoen, en de geleidelijke stroom van kennis zal de dingen die je niet weet verrassend snel weghollen.
Als je dit allemaal hebt gelezen en een beetje overweldigd bent door de codering die vereist is met Unity, kijk dan eens hoe je leer game-ontwikkeling met Unity Learn en lees ook onze gids over het maken van videogames zonder programmeren.
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 reacties hieronder - we zouden het graag zien!
Deel Deel Tweeten E-mail 3 manieren om te controleren of een e-mail echt of nep isAls je een e-mail hebt ontvangen die er een beetje dubieus uitziet, is het altijd het beste om de authenticiteit ervan te controleren. Hier zijn drie manieren om te zien of een e-mail echt is.
Lees volgende Gerelateerde onderwerpen- Programmeren
- Programmeren
- lange vorm
- Longform-gids
Andre, een schrijver en journalist uit het zuidwesten, blijft gegarandeerd functioneel tot 50 graden Celsius en is waterdicht tot een diepte van drie meter.
Meer van André InfanteAbonneer op onze nieuwsbrief
Word lid van onze nieuwsbrief voor technische tips, recensies, gratis e-boeken en exclusieve deals!
Klik hier om je te abonneren