Programar un joc amb Unity: una guia per a principiants

Programar un joc amb Unity: una guia per a principiants
Aquesta guia està disponible per descarregar-la en format PDF gratuït. Descarregueu aquest fitxer ara . No dubteu a copiar i compartir això amb els vostres amics i familiars.

Una característica sorprenent de l'economia d'Internet és l'augment dels videojocs independents. Una vegada que era el domini exclusiu dels estudis triple A de mil milions de dòlars, s’han desenvolupat diversos conjunts d’eines que aporten recursos moderns per al desenvolupament de jocs a mans de particulars o petites col·leccions ad hoc de programadors i dissenyadors. Anteriorment hem comentat els millors jocs independents, així que assegureu-vos de comprovar-los si hi ha inspiració sobre què es pot aconseguir amb eines com Unity.





Aquests equips de desenvolupament de jocs independents han demostrat una agilitat i una tolerància al risc que, en molts casos, els permet impulsar la innovació del joc més ràpidament que els seus homòlegs amb un gran pressupost. Durant els darrers anys s’han estrenat una sèrie de títols independents d’èxit sorprenent, inclosos Minecraft , Limbo , i Super Meat Boy , i fins i tot si no heu de tenir habilitats per crear jocs com aquest, podeu fer un joc amb Buildbox.





En el panorama del desenvolupament de jocs independents en ràpida evolució, Unitat s'ha convertit en una norma de facto: el seu baix cost, la seva facilitat d'ús i el seu ampli conjunt de funcions el fan ideal per al desenvolupament ràpid de jocs. La unitat és tan flexible que fins i tot es pot aconseguir fes els teus propis controladors de jocs personalitzats amb una mica de bricolatge, saber fer-ho!





Fins i tot grans estudis com CCP (desenvolupadors de Eve Online ) utilitzeu-lo per prototipar ràpidament conceptes de jocs. Unity proporciona un 'motor de jocs en una caixa': un motor de física i representació amb ganxos per a diversos llenguatges de seqüència, adaptable a pràcticament qualsevol gènere de videojocs.

Tot i que Unity proporciona un editor visual per manipular l’entorn del joc, Unity no és una eina de creació de jocs de programació zero. Requereix que programeu per obtenir resultats, però també us proporciona una eina molt més flexible i potent del que podria fer qualsevol programa de 'fabricant de jocs'.



Unity no us farà la feina, però redueix substancialment la barrera d’entrada. Començant completament de zero amb C ++ i OpenGL, poden trigar dies a arribar al punt en què hi hagi alguna cosa que es mostri a la pantalla. Utilitzant Unity, triga uns deu segons. Unity posa els elements bàsics de la creació de jocs en mans de programadors novells d’una manera ràpida i intuïtiva.

Avui us guiaré per tot el que heu de saber per fer un joc a Unity, que es divideix en deu capítols principals:





§1 – Versions de la unitat

§2 – Instal·lar Unity





§3 – Una breu introducció al paradigma orientat a objectes

§4 – Fonaments bàsics de la unitat

§5 – Exemple: elements bàsics d'un joc

§6 – Scripting a Unity

§7 – Exemple: Scripting Pong

§8 – Explorar la documentació / Aprendre més

§9 – Creació del vostre joc / Compilació a una aplicació autònoma

§10-Notes de cloenda

1. Versions d’unitat

Unity presenta dos sabors bàsics: la versió pro i la versió gratuïta. Hi ha un nombre de diferències , però, a grans trets, la versió professional admet una sèrie de millores visuals (com ara ombres suaus en temps real i post-processament) i un gran nombre de funcions relativament menors que són extremadament útils per a jocs més complexos.

Dit això, per a la majoria de jocs relativament simples que vulgueu construir, la versió gratuïta d’Unity és perfectament adequada. A continuació, detallarem les diferències claus més detallades per als interessats.

1.1 Preus

La versió gratuïta d’Unity és, per descomptat, gratuïta. Tot i això, hi ha algunes limitacions: la versió gratuïta d’Unity no es pot llicenciar a cap empresa amb ingressos anuals superiors a $ 100,000 . Tot i que aquestes organitzacions estan fora de l’abast d’aquesta guia, si sospiteu que us podríeu convertir en una organització d’aquest tipus, probablement és recomanable buscar la versió Pro.

La versió Pro d’Unity és $ 75 un mes, o $ 1500 per obtenir una llicència permanent i no té límits en el que podeu fer amb els jocs creats amb ella. També hi ha disponible una prova gratuïta de 30 dies, que farem servir per a aquesta guia, per oferir-vos una visió general completa de les funcions disponibles. També hi ha disponible una llicència d’estudiant d’un any Estudiar per $ 129 .

1.2 Funcions

Hi ha moltes funcions absents a la versió gratuïta d’Unity. Tanmateix, les diferències més importants són les següents: la versió gratuïta d’Unity no disposa d’una sèrie d’opcions de renderització que permetin jocs amb millor aspecte i funcionament més ràpid (suport LOD, post-processament de l’espai de pantalla, ombres avançades, programació en temps real ombres i representació diferida). També li falta la totalitat sistema d'animació mechanim , i algunes eines d’intel·ligència artificial.

En general, per a projectes complexos a gran escala o projectes on el rendiment gràfic és important, val la pena la versió professional. Faig servir la versió professional, perquè desenvolupo jocs de realitat virtual per a Oculus Rift i el suport de post-processament de l’espai de la pantalla és necessari per interactuar correctament amb els auriculars.

2. Instal·lació d’Unity

Unity és senzill d’instal·lar. Podeu descarregar l'executable des de unity3d.com/get-unity/download .

Un cop descarregat, executeu-lo i seguiu les instruccions de l’instal·lador. Quan finalitzi la instal·lació, apareixerà una finestra titulada 'activa la vostra llicència Unity'. Marqueu la casella 'Activa una prova gratuïta de 30 dies d'Unity Pro' i, a continuació, 'D'acord'.

Enhorabona! Ara teniu una prova de 30 dies d’Unity Pro. Quan caduqui la prova, si no voleu comprar la versió professional, podeu canviar a la versió gratuïta i conservar el contingut existent.

algú em va bloquejar a Facebook com puc veure el seu perfil

3. Una breu introducció al paradigma orientat a objectes

Abans de començar amb Unity, és important que repassem una mica els conceptes bàsics. Unity admet tots dos C # i JavaScript per programació de jocs ; treballarem amb C # per a aquest tutorial.

En primer lloc, si no heu programat mai abans, deixeu de banda aquest tutorial i passeu uns dies treballant a través de Microsoft C # Language Primer fins que us sentiu còmode utilitzant el llenguatge per a tasques senzilles.

Si voleu alguna cosa diferent de C # (però no necessàriament un idioma que pugueu utilitzar a Unity), consulteu la nostra guia dels sis llenguatges de programació més fàcils per a principiants.

Si heu programat anteriorment en un llenguatge imperatiu o orientat a objectes, com ara C o Java, analitzeu la introducció i familiaritzeu-vos amb la diferència de C # d'altres idiomes que heu utilitzat anteriorment. Sigui com sigui, no continueu amb el tutorial fins que no us sentiu còmode resolent problemes senzills amb C # (per exemple, si us demanés que escrivíssiu un programa que imprimeixi els primers cent números primers, hauríeu de poder escriure aquest programa sense consultant Google).

El concepte més important que cal entendre aquí és el paradigma orientat a objectes (abreujat com OBERT ). En els llenguatges orientats a objectes, els programes es divideixen en unitats funcionals anomenades Objectes . Cada objecte té les seves pròpies variables i funcions privades. Es diuen funcions específiques d’objecte mètodes .

La idea aquí és la modularitat: tenint cada objecte aïllat i obligant altres objectes a interactuar amb ell a través dels seus mètodes, podeu reduir el nombre de possibles interaccions involuntàries i, per extensió, errors. També podeu crear objectes que pugueu reutilitzar més tard sense cap modificació. A Unity, crearàs aquests objectes i els adjuntaràs entitats de joc (el comportament del qual governaran).

Els objectes s’instancien des de classes : una classe és només un fitxer que exposa la definició del vostre objecte. Per tant, si voleu un mook objecte que manegi la IA per a un enemic del vostre joc, escrivireu una classe 'Mook' i, a continuació, adjuntareu aquest fitxer a totes les entitats enemigues. Quan executeu el joc, cada enemic estarà equipat amb una còpia de l'objecte 'Mook'.

Adjuntar un script nou a un objecte té el següent aspecte:

Primer, seleccioneu l'objecte i anar al Inspector . Feu clic al botó Afegeix component botó.

Anar a nou guió , introduïu el nom que vulgueu i feu clic a crear i afegir .

Ara teniu un script nou que podeu editar fent-hi doble clic.

Un fitxer de classe té aquest aspecte:

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 */
}
}
}

Desglossem això:

  • Utilitzant UnityEngine: Aquesta línia indica a C # que volem fer servir les biblioteques d’Unity, que ens permeten connectar-nos al motor de jocs d’Unity.
  • Classe pública Mook: MonoBehaviour: Aquesta línia declara la classe i el seu nom - mook .
  • Salut del flotador privat: Això declara una variable de classe privada (que només es pot canviar des de la classe). La variable té un valor en Començar .
  • Inici del buit (): Això declara un mètode anomenat Començar . Start és un mètode especial que només s’executa una vegada, quan el joc s’inicia inicialment.
  • Actualització buida (): L’actualització és un altre mètode especial que s’executa en tots els fotogrames. La majoria de la vostra lògica de joc anirà aquí.
  • // si et trobes amb el jugador a la carretera, mata'l: Aquesta línia és un comentari (qualsevol línia que comenci amb una barra diagonal doble és ignorada per C #). Els comentaris s’utilitzen per recordar-vos què fan determinats fragments de codi. En aquest cas, aquest comentari s’utilitza per defensar un bloc de codi més complicat que realment faci el que el comentari descriu.

Conjuntament amb Començar i Actualització , podeu crear instàncies dels vostres propis mètodes amb gairebé qualsevol nom. Tanmateix, els mètodes que creeu no s'executaran tret que se'ls cridi. Declarem un mètode per a una hipotètica classe anomenada addTwoNumbers que suma dos nombres junts:

public float addTwoNumbers(float a, float b) {
return a+b;
}

Això declara un mètode públic (accessible per a altres objectes) que retorna un float, anomenat addTwoNumbers , que pren dos flotadors com a entrada (anomenat a i b ). A continuació, retorna la suma dels dos valors com a sortida.

Cridar a aquest mètode des de la mateixa classe (per exemple, des de dins Actualització ) té aquest aspecte:

float result = addTwoNumbers(1, 2);

Cridar el mètode des d’una altra classe és similar:

addTwoNumbers instance;
float result = instance.addTwoNumbers(1, 2);

Una vegada més, això només crea una instància de la nostra classe, accedeix al mètode adequat i alimenta els números que volem afegir i després emmagatzema el resultat a resultat . Simple.

Si el vostre script s’adjunta a un objecte que té propietats especials (com un emissor de partícules) al qual no es pot accedir sota el conjunt normal de paràmetres de GameObject, podeu triar-lo com un altre tipus d’entitat de joc mitjançant GetComponent mètode.

La sintaxi per a això té aquest aspecte:

GetComponent().Play();

Si alguna cosa d'això no us és familiar, torneu enrere i consulteu la instrucció C #. Us estalviarà molta frustració a mesura que avancem.

4. Fonaments bàsics de la unitat

En aquesta secció, ens obrirem camí a través de la mecànica bàsica del motor Unity. El flux de treball a Unity és així:

  1. Creeu una entitat per fer un paper al joc (en blanc GameObjects es pot utilitzar per a tasques lògiques abstractes).
  2. Escriviu o trobeu un fitxer de classe i afegiu-lo a l'entitat com a script (mitjançant el fitxer Afegeix component botó al fitxer inspector vista.
  3. Correr > prova > depurar > repetir fins que funcioni i passeu al següent element del joc.

Unity inclou diverses pestanyes bàsiques de visualització que es poden dissenyar de diverses maneres al gust de l'usuari. Els cinc grans són:

  1. Joc: mostra una instància en curs del joc amb la qual podeu interactuar i provar.
  2. Escena: proporciona una versió estàtica i editable del fitxer món del joc .
  3. Inspector: us permet modificar entitats individuals del món del joc seleccionant-les al fitxer editor fitxa.
  4. Projecte: us permet navegar pels fitxers del projecte i arrossegar models, materials i altres recursos al fitxer editor fitxa per situar-los al món del joc.
  5. Jerarquia: aquesta pestanya mostra tots els objectes del món, cosa que us permet trobar objectes distants a l'escena i entitats parent entre si fent clic i arrossegant.

Consulteu el diagrama següent per localitzar totes aquestes coses:

4.1 Entitats d’unitat

4.1.1 Malles

Les malles són el camí Geometria 3D es representa a Unity. Podeu utilitzar la versió integrada d'Unity primitiu objectes (cubs, esferes, cilindres, etc.), o bé importeu els vostres propis models 3D d'un paquet de modelatge com Batedora o bé Maya . Unity admet una gran varietat de formats 3D, inclosos .fbx , i .3ds .

Les eines bàsiques per manipular malles són els botons d’escala, rotació i translació de l’extrem superior esquerre de la interfície. Aquests botons afegeixen icones de control als models de la vista de l'editor, que després es poden utilitzar per manipular-los a l'espai. Per alterar la textura o les propietats físiques d'un objecte, seleccioneu-les i utilitzeu el fitxer inspector vista per analitzar el material i cos rígid elements.

4.1.2 GUI Elements

Els sprites i el text tradicionals de la interfície gràfica d’usuari es poden mostrar mitjançant el fitxer GUI Text i la Textura GUI GameObjects a l'editor. Tanmateix, una manera més robusta i realista de manejar els elements de la IU és utilitzar el fitxer Text en 3D i Quàdruple GameObjects (amb textures transparents i un ombrejat transparent il·luminat) per situar els elements HUD al món del joc com a entitats.

A la jerarquia vista, aquests elements de joc es poden arrossegar a la càmera principal per fer-los nens, assegurant-se que es mouen i giren amb la càmera.

Els elements de la GUI (text i textures) poden ajustar la seva mida i escala mitjançant els camps rellevants de la pestanya Inspector.

4.1.3 Materials

Els materials són combinacions de textures i ombres i es poden arrossegar directament als objectes del joc des de la pestanya del projecte. Unity Pro inclou un gran nombre de shaders i podeu ajustar la textura que s'hi adjunta mitjançant la pestanya Inspector d'un objecte al qual s'apliquen.

Per importar una textura, converteix-la a .jpg , .png , o .bmp i arrossegueu-lo al fitxer actius al directori del projecte Unity (que apareix a Els meus documents per defecte). Al cap d’uns segons, apareixerà una barra de càrrega a l’editor. Quan acabi, podreu trobar la imatge com a textura a sota del fitxer projecte fitxa.

4.1.5 Llums

Les llums ho són GameObjects que projecten resplendor al món. Si no hi ha llums a la vostra escena, tots els polígons es dibuixen al mateix nivell de brillantor, donant al món un aspecte planer i rentat.

Els llums es poden col·locar, girar i tenir diverses característiques internes que podeu personalitzar. El intensitat el control lliscant controla la brillantor de la llum i la abast controla la rapidesa amb què s’esvaeix.

Les directrius del vista d'escena us mostrarà el màxim abast de la il·luminació. Juga amb les dues configuracions per aconseguir l’efecte desitjat. També podeu ajustar el color de la llum, el patró ( galeta que es mostra a la superfície on s’assenyala la llum i quin tipus de flamarada apareix a la pantalla quan es mira directament la llum. La galeta es pot utilitzar per falsificar patrons de llum més realistes, crear ombres falses dramàtiques i simular projectors.

Els tres tipus principals de llum són taca , punt , i direccional .

Llums de punt tenen una ubicació a l’espai 3D i projecten la llum només en una direcció en un con d’angle variable. Són bons per a llanternes, reflectors i, en general, us ofereixen un control més precís de la il·luminació. Els focus poden projectar ombres.

Llums puntuals teniu una ubicació a l’espai 3D i projecteu la llum de manera uniforme en totes les direccions. Els llums puntuals no projecten ombres.

Llums direccionals , finalment, s'utilitzen per simular la llum solar: projecten la llum en una direcció com des de infinitament llunyana. Les llums direccionals afecten tots els objectes de l’escena i poden produir ombres.

4.1.6 Sistemes de partícules

A Sistema de partícules és un GameObject que genera i controla centenars o milers de partícules simultàniament. Les partícules són objectes 2D petits i optimitzats que es mostren en espai 3D. Els sistemes de partícules utilitzen una representació i una física simplificades, però poden mostrar milers d’entitats en temps real sense tartamudejar, cosa que els fa ideals per a fum, foc, pluja, espurnes, efectes màgics i molt més.

Hi ha molts paràmetres que podeu modificar per aconseguir aquests efectes i podeu accedir-hi generant un sistema de partícules a la editor de components > seleccionant el sistema de partícules > obrint la pestanya inspector . Podeu canviar la mida, la velocitat, la direcció, la rotació, el color i la textura de cada partícula i configurar la majoria d’aquests paràmetres perquè també canviïn amb el pas del temps.

Sota la col·lisió atribut, si l'activeu i configureu l'espai de simulació a món obtindreu partícules que xoquen amb objectes del món, que es poden utilitzar per a efectes de partícules realistes, com ara pluja, aigua en moviment i espurnes.

5. Exemple: elements bàsics d’un joc

Per a aquest tutorial, farem un joc senzill de pong - alguna cosa que ja hem tractat diverses vegades en bricolatge:

  • Arduino Classic Pong
  • Arduino OLED Pong

En aquesta secció, analitzarem els elements bàsics: el tutorial de script vindrà més tard.

En primer lloc, desglossem el joc de Pong en els seus components bàsics. En primer lloc, necessitem dues pales i una pilota. La pilota vola fora de pantalla, així que voldrem un mecanisme per restablir-la. També volem que el text mostri la puntuació actual i, per mostrar-vos tots els elements bàsics d’Unity, voldríem un efecte de partícula de fantasia quan toqueu la pilota. Haureu d’il·luminar dramàticament tot el joc.

Això es divideix en un objecte de pilota (una esfera), a reproductor , dos accessoris de pàdel amb emissors de partícules adjunt, a Entitat de text en 3D , i a llum de punt . Per a aquest tutorial, farem servir el material físic per defecte rebot , amb combinar de rebot ajustat a multiplicar . A continuació, es mostra l’aspecte de la configuració en deu captures de pantalla:

En primer lloc, creeu un fitxer cub prop per al pàdel.

Escaleu-lo adequadament, duplicar-lo , i posar un esfera entre les pales per a la pilota.

A continuació, creeu un fitxer Objecte 3DText i escala i posició correctament, canviant el fitxer mida de la font atribut per obtenir una imatge menys pixelada.

A continuació, creeu-ne dos sistemes de partícules , trieu les característiques que vulgueu i enganxeu-les a les pales.

A continuació, voldreu posiciona i gira la càmera de manera que emmarqui l’escena correctament. Mentre es selecciona la càmera, podeu veure una petita previsualització de la vista de la càmera a la cantonada inferior dreta.

Abans d’acabar, hem de crear dos cubs addicionals per ser para-xocs, per evitar que la pilota reboti fora de la zona de joc. Podem fer-los invisibles desmarcant el fitxer renderitzador de malla al pestanya inspector .

Si premeu el joc, ara podreu veure els elements bàsics del nostre joc. Encara no faran res, però hi arribarem.

Ara que tenim aquesta configuració, parlarem del que implica la creació de scripts d’aquests elements per crear un joc.

6. Scripting a Unity

Un cop tingueu un script adjunt a un objecte, podeu revisar-lo fent doble clic a la finestra inspector . Això s'obre MonoDevelop , l'entorn de desenvolupament predeterminat per a Unity. En essència, Monodevelop és un editor de text amb funcions específicament optimitzades per a la programació.

Les paraules clau i els comentaris es ressalten a blau i verd i apareixen els valors i les cadenes numèriques a xarxa . Si ho heu fet servir eclipsi o altres IDE, MonoDevelop és molt similar. Tu pots construir els scripts des de l’editor, per comprovar si hi ha errors de sintaxi, com ara:

En general, per aconseguir que l’escriptura interactuï amb Unity, haureu de fer referència als elements que posseeix l’objecte que conté l’escriptura (podeu veure una llista d’aquests elements a la secció inspector quan es selecciona l’objecte corresponent). A continuació, podeu trucar a mètodes o establir variables per a cadascun d’aquests elements per aplicar els canvis que vulgueu.

Si voleu que un script d’un objecte afecti les propietats d’un objecte diferent, podeu crear un buit GameObject variable al vostre script i utilitzeu el fitxer inspector per assignar-lo a un altre objecte de l’escena.

La llista dels elements que pot tenir un objecte és la següent (extreta de la vista de l’inspector d’una de les nostres pales de l’exemple anterior):

  1. Transformar
  2. Cub (filtre de malla)
  3. Box Collider
  4. Representador de malla

Cadascun d'aquests aspectes de l'objecte es pot influir des d'un script. A continuació, veurem exactament com.

6.1 Transformar

Les funcions de transformació d'un GameObject en Unity controlen els paràmetres físics d'aquest objecte: el seu escala , la seva posició , i la seva orientació . Podeu accedir-hi des d'un script com aquest:

transform.position = newPositionVector3;
transform.rotation = newRotationQuaternion;
transform.localScale = newScaleVector3;

En els exemples anteriors, les variables anomenades són dels tipus especificats als noms. Aquí hi ha alguns detalls clau: la posició i l’escala, com era d’esperar, s’emmagatzemen com Vector3s . Podeu accedir al fitxer X , I , i AMB components de cadascun (per exemple, transform.position.y us dóna la distància d’un objecte per sobre del pla zero).

No obstant això, per evitar pany de cardan , les rotacions es gestionen com Quaternions (vectors de quatre components). Com que els quaternions de manipulació manual no són intuïtius, podeu manipular les rotacions mitjançant angles eulerianos mitjançant el Quaternion.Euler mètode així:

transform.rotation = Quaternion.Euler(pitch, yaw, roll);

Si voleu moure objectes sense problemes d'un lloc a un altre, trobareu el fitxer Slerp útil per a quaternions i vector3s. Slerp recull tres arguments: l’estat actual, l’estat final i la velocitat de canvi, i s’interpola sense problemes entre ells a la velocitat donada. La sintaxi té aquest aspecte:

transform.position = Vector3.Slerp(startPositionVector3, newDestinationVector3, 1);

6.2 Representador

Les funcions de renderització a Unity us permeten controlar la manera com es representen a la pantalla les superfícies dels accessoris. Podeu reassignar la textura, canviar el color i canviar l'ombra i la visibilitat de l'objecte. La sintaxi té aquest aspecte:

renderer.enabled = false;
renderer.material.color = new Color(0, 255, 0);
renderer.material.mainTexture = myTexture;
renderer.material.shader = newShader;

La majoria tenen funcions bastant clares. El primer exemple fa invisible l’objecte en qüestió: un truc útil en diverses situacions. El segon exemple assigna un nou Color RGB (és a dir, verd) a l'objecte en qüestió. El tercer assigna la textura difusa principal a una nova variable de textura. L'últim exemple canvia el matís del material de l'objecte a una variable de matís acabada de definir.

6.3 Física

Unity ve amb un motor de física integrat, cosa que tots els jocs de sandbox de física utilitzen. Això us permet assignar les propietats físiques dels objectes i deixar que els detalls de la seva simulació siguin gestionats per a vosaltres. En general, en lloc d’intentar implementar la vostra pròpia física mitjançant un llibre de text i el sistema de transformació, és més senzill i robust utilitzar el motor de física d’Unity en la major mesura possible.

Tots els accessoris de física requereixen col·lisionadors . Tanmateix, la simulació real és gestionada per un cos rígid , que es pot afegir al fitxer inspector vista. Els cossos rígids poden ser cinemàtica o bé no cinemàtic .

Els accessoris físics cinemàtics xoquen amb (i produeixen) accessoris físics no cinemàtics al seu voltant, però no es veuen afectats per la col·lisió. Els objectes cinemàtics estàtics són els proverbials objectes immòbils, i els objectes cinemàtics en moviment són la força imparable proverbial (per recordar-se, quan xoquen, simplement passen entre si).

Més enllà d’això, podeu ajustar l’arrossegament angular de l’objecte (quanta energia es necessita per fer-lo girar), canviar-ne la massa, dictar si està afectat o no per la gravetat i aplicar-hi forces.

Exemples:

rigidbody.angularDrag = 0.1f;
rigidbody.mass = 100;
rigidbody.isKinematic = false;
rigidbody.useGravity = true;
rigidbody.AddForce(transform.forward * 100);

Tot això s’explica per si mateix. L’únic que cal tenir en compte aquí és l’ús de transformar.avançar . Tots Vector3 tenen tres components ( .forward , .up , i .dret ) associada amb ells, a la qual es pot accedir i gira amb ells ( endavant és la direcció de la fletxa blava a l'editor). El transformar.avançar La paraula clau és simplement el vector cap endavant de l'objecte actual amb magnitud 1. Es pot multiplicar per un flotant per crear més força sobre l'objecte. També podeu fer referència transform.up i transformar.dret , i negar-los per obtenir els seus reversos.

6.4 Col·lisió

Sovint, en construir un joc, voldríeu que una col·lisió produeixi algun canvi d’estat al codi, més enllà de la simulació física. Per a això, necessitareu un mètode de detecció de col·lisions .

Hi ha una certa quantitat de treball de preparació necessari per detectar col·lisions a Unity. En primer lloc, almenys un dels objectes de la col·lisió necessita un cos rígid no cinemàtic lligat a ella. Tots dos objectes han de tenir col·lisionadors correctes, configurats com a no activadors. La velocitat total d’ambdós objectes ha de ser prou baixa com per xocar en realitat, en lloc de simplement saltar-se entre si.

Si teniu tot això cuidat, podeu comprovar si hi ha col·lisió col·locant un mètode especial de detecció de col·lisions en un script adjunt a l'objecte amb el qual vulgueu comprovar la col·lisió. El mètode serà així:

void OnCollisionEnter(Collision other) {
//do things here
}

Aquest mètode s'executarà automàticament durant el primer marc que un altre objecte toca amb el vostre objecte. L'entitat de col·lisió altres és una referència a l'objecte al qual heu colpejat. Podeu, per exemple, fer referència a la seva gameobject , cos rígid , i transformar característiques per manipular-lo de diverses maneres. Mentre OnCollisionEnter és probablement la funció més comuna que faràs servir, també pots utilitzar OnCollisionExit i OnCollisionStay (amb sintaxi i ús d'altra banda idèntics), que s'activen durant el primer fotograma que deixeu de xocar amb un objecte i durant cada fotograma que esteu xocant amb un objecte, respectivament.

De vegades, també pot ser útil fer el que es diu emissió de raigs . En el raycasting, una línia infinitament fina (a raig ) es llança pel món des d'algun origen, al llarg d'algun vector i, quan toca alguna cosa, es retorna la posició i altres detalls de la primera col·lisió. El codi per a un raycast té aquest aspecte:

RaycastHit hit;
if (Physics.Raycast(transform.position, -Vector3.up, out hit)) {
float distanceToGround = hit.distance;
}

Això llança un raig des de la posició de l'objecte actual al llarg de -Vector3.up (recte cap avall) i enllaça la variable colpejar al primer objecte amb què xoca. Un cop el raig hagi colpejat alguna cosa, hi podeu accedir hit.distance per determinar quina distància es troba o hit.GameObject per manipular l’objecte que heu colpejat.

Raycasts com aquest es poden utilitzar per als tiradors per determinar a què apunta la pistola, o per seleccionar objectes quan la càmera els mira o per a determinats estils de moviment mecànic.

6.5 Correcció del temps

Un factor important a tenir en compte quan manipuleu objectes d’aquesta manera té a veure framerate . Per més optimització que tingueu, els percentatges de fotogrames sempre variaran i no voleu que la velocitat del joc variï en conseqüència. Si algú més executa el joc en un ordinador més ràpid del que el vau desenvolupar, no voleu que el joc funcioni a doble velocitat.

La manera de corregir-ho és multiplicant els valors que utilitzeu pel temps que va trigar a representar l’últim fotograma. Això es fa utilitzant Time.deltaTime . Això canvia efectivament la velocitat de qualsevol variable a la qual augmenteu cada fotograma canvi per fotograma a canvi per segon , i probablement hauríeu de fer aquest canvi a qualsevol valor que estigueu incrementant o disminuint cada fotograma.

6.6 Fonts d'àudio i oients

Ara que hem analitzat com crear, representar i controlar objectes, parlem de l’altre sentit que poden servir els jocs d’ordinador: és a dir, so . Unity admet dos tipus de sons: 2D i 3D sons. Els sons en 3D varien el volum segons la distància i es distorsionen a mesura que es mouen en relació amb la càmera; Els sons 2D no ho fan.

Els sons 2D són adequats per a les veus en off i la música de fons, i els sons 3D s’apliquen als sons generats per esdeveniments del món. Per canviar si un so és 3D o no, seleccioneu-lo al fitxer projecte visualitzar, canviar a inspector visualitzeu i seleccioneu l'opció adequada al menú desplegable i premeu el botó reimportació botó.

Per reproduir el so realment, haureu d’adjuntar-ne un audiosource a un puntal (puntal del qual voleu que s’origini el so, en el cas d’un so 3D). A continuació, haureu d'obrir el fitxer audioclip i seleccioneu el fitxer de so.

com obtenir Outlook Express a Windows 10

Pots fer servir myAudioSource.Pause () i myAudioSource.Play () per controlar aquests fitxers de so. Podeu ajustar els comportaments de caiguda, el volum i el desplaçament doppler dels sons a sota del fitxer inspector pestanya de la font d’àudio.

6.7 Entrada

Un joc que no té cap aportació de l'usuari no és gaire un joc. Hi ha molts tipus d’entrada que podeu llegir i gairebé tots són accessibles des de Entrada i Clau objectes. A continuació es mostren algunes declaracions d’entrada d’exemple (que tenen un valor avaluat en cada fotograma).

Vector3 mousePos = Input.mousePosition;
bool isLeftClicking = Input.GetMouseButton(0);
bool isPressingSpace = Input.GetKey(KeyCode.Space);

Les funcions d’aquestes línies s’expliquen sobretot per si mateixes. Mitjançant aquests tres tipus de referència d’entrada, podeu reconstruir els esquemes de control de la majoria dels jocs d’ordinador 3D moderns.

6.8 Depurar un script

Suposem que un guió no funciona. Com diu el bon metge, et poden passar problemes i problemes de connexió. Si hi ha errors de sintaxi directes amb el vostre C #, el joc generalment es negarà a executar-se quan feu clic a Play i es proporcionaran alguns missatges d’error força útils si construir els scripts des de l'editor. Mirar abaix:

Aquests errors normalment no són els més difícils de solucionar. El que pot ser més problemàtic són subtils errors semàntics, en els quals heu escrit amb èxit un fitxer ple de C # vàlid, però no un que faci el que pensàveu. Si teniu un d'aquests errors i teniu problemes per rastrejar-lo, hi ha algunes coses que podeu intentar per millorar la situació.

El primer és posar en pausa l'execució del joc i comprovar la consola. Podeu posar en pausa el joc fent clic al botó pausa icona a la part mitjana superior de l'editor i, a continuació, seleccioneu consola des de la part inferior del fitxer finestra menú (o prement Ctrl > Maj > C ). Fins i tot si no hi ha errors, les advertències poden ajudar a donar algunes pistes sobre el que podria anar malament.

Si això no funciona, també podeu intentar fer-vos una idea sobre l'estat del vostre script imprimint l'estat de les variables internes per validar que el programa està fent el que creieu que està fent. Pots fer servir Debug.Log (cadena) per imprimir el contingut d'una cadena a la consola quan l'execució del programa arriba a aquesta línia. En general, si treballeu enrere del que creieu que hauria de passar a través de les coses que haurien de fer-ho, arribareu a un punt en què les impressions de depuració no facin el que espereu que facin. Aquí és on es troba el vostre error.

7. Exemple: Scripting Pong

Per construir Pong, desglossem el joc en els seus elements bàsics: necessitem una pilota que rebotgi entre les pales a una velocitat creixent, necessitem un marcador que sàpiga quan les pilotes han passat les pales i necessitem un mecanisme per reiniciar la pilota quan això passi. Un bon primer pas seria afegir un cos rígid no cinemàtic a la pilota, dos cossos rígids cinemàtics a les paletes, desactivar la gravetat per a tots ells i assignar un material físic adequat dels actius estàndard ( rebot amb combinar de rebot ajustat a multiplicar ).

A continuació, podeu veure el guió de la pilota amb comentaris explicatius. La pilota ha d’aconseguir alguns objectius bàsics: ha de rebotar en un patró complicat, mantenint sempre el moviment en ambdós eixos, i ha d’accelerar a un ritme desafiant però no impossible en la direcció horitzontal.

BallHandler.cs

A continuació, hem d’escriure el nostre pàdel, que podeu veure a continuació. La pala ha de moure amunt i avall en resposta a les tecles (però no fora de certs límits). També ha d’activar el sistema de partícules quan xoca amb alguna cosa.

PaddleHandler.cs

A continuació, necessitem IA enemiga: alguna cosa que faci que la pala de l'enemic pugui rastrejar cap a la pilota a un ritme fix. Per a això, utilitzarem Vector3.Slerp per a la màxima simplicitat. També ens agradaria el mateix comportament de partícules que veiem a la nostra pròpia pala.

EnemyAI.cs

Finalment, necessitem un guió per actualitzar el marcador i restablir la pilota quan surt fora dels límits.

ScoreboardUpdater.cs

Amb aquests scripts adjunts i emplenades les referències, quan executem el nostre joc de Pong, experimentem el joc.

Tu pots descarrega la meva demostració de Pong , si voleu veure tot el que he esbossat en acció. Funciona amb sistemes Windows, Mac i Linux.

8. Explorar la documentació / Aprendre més

Unity és un motor complex amb moltes més funcions de les que es podria incloure en una guia d’aquest estil, i això és abans d’incloure l’àmplia gamma d’extensions Unity (gratuïtes i comercials) disponibles a Internet. Aquesta guia us proporcionarà un fort punt de partida per desenvolupar un joc, però l’autoeducació és una habilitat important per a qualsevol empresa, i doblement aquí.

Un recurs crucial aquí és el Unity ScriptReference . ScriptReference és una base de dades que es pot cercar, disponible tant per a C # com per a Javascript, que conté una llista de totes les funcions i ordres d’Unity, amb descripcions de les seves funcions i breus exemples de sintaxi.

Si teniu problemes amb l’editor i la interfície d’Unity, o bé com els tutorials de vídeo com a qüestió de preferència, hi ha una llarga llista d’alta qualitat Tutorials de vídeo Unity disponible. Més extens (però menys ampli) tutorials de text per a Unity també estan disponibles a CatLikeCoding.

Finalment, si teniu preguntes fora de l’àmbit de la documentació o tutorials, podeu fer preguntes específiques a answers.Unity3d.com . Recordeu que les respostes les proporcionen els voluntaris, així que respecteu el seu temps i cerqueu primer a la base de dades per assegurar-vos que la vostra pregunta encara no s’hagi respost.

9. Construir el vostre joc / Compilació a una aplicació autònoma

Quan hàgiu creat quelcom que us enorgulleixi (o que hàgiu acabat de clonar el nostre exemple de Pong lleugerament desconcertant per a la pràctica), és el moment de moure el joc de l’editor i convertir-lo en quelcom que pugueu publicar a Internet i forçar-lo els seus amics i familiars a jugar. Per fer-ho, haureu de crear una aplicació independent. La bona notícia és que a Unity, això és molt, molt fàcil. Tanmateix, hi ha alguns possibles entrebancs amb els quals voldreu anar amb compte.

Per començar, sabeu que només podeu crear un projecte sense errors. Amb aquest objectiu, assegureu-vos que teniu la consola oberta mentre es construeix: hi ha algunes condicions d'error que el joc ignorarà a l'editor, però que avortarà tot un intent de construcció. Això només envia els missatges d'error a la consola, sense resultats visibles a la pantalla, cosa que pot resultar frustrant si oblideu comprovar-ho. Un cop tingueu la compilació del joc lliure d'errors, però, podeu seleccionar Configuració de compilació sota la Dossier o premeu Ctrl > Maj

> B . Això mostrarà un diàleg senzill que us permetrà construir el vostre joc per a diverses plataformes.

El procés d’aquí s’explica per si mateix: seleccioneu les opcions i premeu construir ; el joc us demanarà un directori on instal·lar-hi i hi col·locarà tant el directori executable com el de dades. Aquests dos fitxers es poden comprimir i distribuir (només assegureu-vos de no cobrar per un joc integrat a la demostració d'Unity, ja que infringeix les condicions del servei).

10. Notes de cloenda

Com passa amb qualsevol eina de desenvolupament de jocs, la clau de l'èxit amb Unity és el desenvolupament iteratiu. Heu de construir en increments manejables: sigueu ambiciosos, per descomptat, però sigueu ambiciosos en petits trossos i organitzeu-los de manera que, fins i tot si no arribeu a la vostra última ambició, almenys us acabareu amb una coherència producte.

Obtingueu en primer lloc els elements més crucials: tingueu present una idea producte viable mínim , la cosa més senzilla i més òssia que podríeu crear i que encara tingueu la sensació d’haver aconseguit alguna cosa que valgui la pena. Arribeu a aquest projecte mínim viable abans de passar a ambicions més grans.

Aquest tutorial us proporciona un bon punt de partida, però la millor manera d’aprendre Unity és construint un joc. Comenceu a construir un joc, ompliu els buits del vostre coneixement a mesura que apareixen, i el flux gradual de coneixement desgastarà ràpidament les coses que no coneixeu.

Si heu llegit tot això i esteu una mica aclaparat per la codificació necessària amb Unity, assegureu-vos de comprovar com fer-ho aprendre el desenvolupament de jocs amb Unity Learn i també llegiu la nostra guia sobre com fer videojocs sense cap programació.

Unity és una eina poderosa i, amb una mica d’exploració, podeu construir projectes impressionants amb ella més ràpid del que podríeu esperar. Feu-nos saber què heu creat als comentaris següents: ens encantaria veure-ho.

Compartir Compartir Tweet Correu electrònic 3 maneres de comprovar si un correu electrònic és real o fals

Si heu rebut un correu electrònic que sembla una mica dubtós, sempre és millor comprovar-ne l’autenticitat. A continuació, es mostren tres maneres de saber si un correu electrònic és real.

Llegiu a continuació
Temes relacionats
  • Programació
  • Programació
  • Forma llarga
  • Guia de forma llarga
Sobre l'autor Andre Infant(131 articles publicats)

Escriptor i periodista establert al sud-oest, es garanteix que Andre continuarà funcionant fins a 50 graus centígrads i és impermeable fins a una profunditat de dotze peus.

Més d'Andre Infante

Subscriu-te al nostre butlletí

Uniu-vos al nostre butlletí per obtenir consells tècnics, ressenyes, llibres electrònics gratuïts i ofertes exclusives.

Feu clic aquí per subscriure-us