Unità- motore molto potente, progressivo con grande potenziale. Ha molte funzioni già integrate (incluso un motore fisico Nvidia PhysX), che noi utenti non dobbiamo registrare manualmente. :)
In questo breve articolo, vorrei discutere le capacità fisiche del motore. Quindi, iniziamo:

Corpo rigido

Cos'è?

Dietro la funzione Corpo rigido Nascondere il corpo assolutamente rigido ( ATT). Se lo spieghi in modo approssimativo e chiaro, allora ATT in fisica e meccanica, è un corpo rigido ideale che, sotto l'influenza della forza, non può cambiare le sue proprietà, ma può (sotto la sua influenza) muoversi in 3 dimensioni (basso, alto, avanti, ecc., cioè nei nostri assi X-Y-Z ), oltre a ruotare in 3 dimensioni (di nuovo, lungo gli assi X-Y-Z).

A Unità, come in altri motori di gioco (di nuovo, li chiamo più o meno motori di "gioco"), Corpo rigido utilizzato per vari oggetti con cui possiamo interagire spingendo, calciando, ecc. Tali oggetti sotto la nostra influenza continueranno a rotolare, muoversi e scontrarsi con altri oggetti sotto l'influenza della gravità.

Quale applicazione possiamo trovare per questa funzione?

Ad esempio, per creare un'auto, oltre a Corpo rigido abbiamo bisogno Collider a 4 ruote"e e il codice (sceneggiatura), che applica forza alle ruote, a seconda dei tasti premuti.

Funzionalità configurabili

• Messa- Messa del nostro oggetto in chilogrammi. Si raccomanda di non impostare valori di massa 100 volte maggiori o minori delle masse degli altri ATT.
• Lagna- Quanto un corpo è soggetto alla resistenza dell'aria quando si muove sotto l'influenza di forze. Con un valore 0 non c'è resistenza e un valore infinito fermerà istantaneamente il nostro oggetto.
• Trascinamento angolare- Quanto il corpo è soggetto alla resistenza dell'aria quando ruota sotto l'influenza delle forze. Con un valore 0 non c'è resistenza e un valore infinito fermerà istantaneamente la rotazione del nostro oggetto.
• Gravità- Quando acceso, l'oggetto viene influenzato dalla gravità.
• è cinematico- Quando abilitato, l'oggetto non viene influenzato dal motore fisico e può essere modificato solo dalla sua funzione Trasformare. Questo può essere utile per creare piattaforme mobili, ad esempio.
• Interpolare- Si applica solo se i movimenti del tuo ATT ti sembrano strani o goffi, ecc.:
  1. Nessuno: Interpolazione non applicata
  2. interpolare: Rispetto alla trasformazione del frame precedente ( telaio) , il successivo verrà levigato.
  3. estrapolare: La trasformazione del frame corrente viene smussata rispetto alla trasformazione stimata (approssimativa) di quella successiva.
• Blocca rotazione- Disabilita qualsiasi rotazione, sia con script che con collisione. Tuttavia, la rotazione può essere eseguita dalla funzione trasforma.Ruota()
• Rilevamento di collisioni- Utilizzato per impedire agli oggetti in rapido movimento di passare attraverso altri oggetti senza trovarli collisione"ov" (una speciale "griglia" sugli oggetti che si scontrano tra loro e con il giocatore).
  1. discreto: Il valore predefinito per il nostro oggetto per "notare" tutti gli altri oggetti con cui potrebbe entrare in collisione.
  2. Continuo: Uso Collisione discreta con oggetti di collisione dinamici (che hanno ATT), un Collisione continua per statico Mesh Collider"ov (senza ATT). Modalità Dinamica Continua usi Collisione continua per uno specifico ATT. riposo ATT utilizzerà la modalità Discreto. (Ciò influenzerà notevolmente il carico del motore fisico, basta andarsene Discreto, se non ci sono problemi con la collisione di oggetti veloci)
  3. Dinamica continua: Usato per oggetti in modalità continuo o Collisione dinamica continua. Collisione continua sarà utilizzato anche per statico Mesh Collider"ov (senza ATT). Per tutti gli altri viene utilizzata la modalità Discreto. Usato per oggetti in rapido movimento.

Come possiamo utilizzare questa funzione?

Conoscenza di base.

Usare ATT, abbiamo bisogno di un oggetto di gioco già creato ( GameObject), cliccandoci sopra si accede al menù lungo il seguente percorso: Componenti - Fisica - Rigidbody . Tutto, ATT aggiunto! :)
Ora l'oggetto è soggetto alla gravità, puoi applicargli delle forze usando gli script, ma affinché l'oggetto si comporti esattamente come ti serve, dovresti aggiungere Collisore o giunto.

Il codice governa il mondo.

Nello script, ora manipoleremo il nostro oggetto usando le funzioni AddForce() e Aggiungi coppia() .
Dato che ci sono Unità applicare JavaScript, i miei esempi saranno con esso, collegamenti ad altri esempi di scripting (a C# o Boh) che troverete di seguito, al paragrafo Ulteriori informazioni su ATT.

» Corpo rigido.AddForce

// Rigidbody.AddForce utilizza 2 tipi di formule, come molte altre funzioni relative ai movimenti nello spazio. // 1 tipo: funzione AddForce (force: Vector3, mode: ForceMode = ForceMode.Force) : void // La forza che spinge l'oggetto verso l'alto, relativa al sistema di coordinate globale. function FixedUpdate () ( rigidbody.AddForce (Vector3.up * 10); ) // Usando Vector3, una funzione Unity incorporata che è sostanzialmente la stessa del sistema di coordinate standard. // 2° tipo: funzione AddForce (x: float, y: float, z: float, modalità: ForceMode = ForceMode.Force) : void // Lo stesso, ma usato qui Sistema X-Y-Z coordinate. funzione FixedUpdate() ( rigidbody.AddForce(0, 10, 0); )

» Corpo rigido.AddTorque

// La funzione ruota l'oggetto attorno all'asse specificato. // 1 tipo: funzione AddTorque (torque: Vector3, mode: ForceMode = ForceMode.Force) : void // Fa girare l'ATT attorno all'asse globale Y. function FixedUpdate () ( rigidbody.AddTorque (Vector3.up * 10); ) // tipo 2: funzione AddTorque (x: float, y: float, z: float, modalità: ForceMode = ForceMode.Force) : void // Fa la stessa cosa, ma di nuovo in un sistema di misura diverso. funzione FixedUpdate() ( rigidbody.AddTorque(0, 10, 0); )

ATT interagisce con gli oggetti.

Per il corretto funzionamento del ns ATT devono essere forniti Collisore"Ami (o collisione"Ami, come preferisci ^.^).
Leggi di più sui collisori di seguito.

Le misure contano!

Osserva le dimensioni del tuo oggetto, perché sono molto più significative anche di massa ATT. Se il tuo oggetto si muove in modo errato, fluttua nell'aria o non entra in collisione, prova a regolarne la grandezza (non ATT, ma l'oggetto stesso). Quando si importa un modello dall'editor 3D, le sue dimensioni vengono conservate, quindi prestare attenzione durante la fase di modellazione e rispettare le dimensioni di tutti i modelli.

Ulteriori informazioni su ATT

Su questo, descrivi ATT o Corpo rigido Probabilmente finirò. Tuttavia, ci sono un paio di consigli, soprattutto per coloro che hanno letto fino a qui :)

1. dimensione del cubo standard Unitàè uguale a 1 metro, quindi, è molto comodo controllare la taglia dei tuoi modelli utilizzandolo. Per creare un cubo, seleziona dal menu GameObject - Crea altro - Cubo
2. Indicatore relativo Messa definisce come due oggetti interagiranno tra loro.
3. Messa non pregiudica la velocità di caduta dall'alto, per questi scopi utilizzare Lagna.
4. Più alti sono i valori Lagna più pesa l'oggetto. i valori standard variano da 0,001(pezzo di metallo solido) a 10(piuma).
5. Se hai bisogno di modificare un oggetto sia con gli script che con la fisica, aggiungilo ATT con parametro cinematico.

Collider

Cos'è?

Nella sezione precedente, abbiamo discusso di come Corpo rigido e menzionato il cosiddetto collisori. Collisore per noi - un oggetto ausiliario sotto forma di griglia di una forma primitiva semplice o, al contrario, una forma complessa, che si trova attorno al nostro modello o parte del modello e interagisce con altri oggetti se sono anche circondati da collisori.
Per spiegare chiaramente agli esperti dell'editor mondiale di *Warcraft 3*, immagina il modello che abbiamo importato, a cui non abbiamo assegnato texture di percorso nell'editor dudad: questo sarà il nostro oggetto; e il ruolo dei collisori qui sarà svolto dai bloccanti del percorso attorno al modello. Naturalmente, questo è un confronto piuttosto approssimativo, perché in Unità sono molto più funzionali. Bene, diamo un'occhiata più da vicino.

Tipi di collisori.

I collider vengono aggiunti tramite il menu Componente - Fisica . Ci sono diversi tipi:

• Collisore di scatole- a forma di cubo.
• Collisore di sfere- a forma di sfera.
• Collisore di capsule- sotto forma di capsula.
• Collisore a maglie- crea automaticamente un collider in base alla forma della griglia dell'oggetto, non può entrare in collisione con altri collider dello stesso tipo. Utilizzato principalmente per oggetti statici, come l'ambiente di una pista.
• Collisore di ruote- usato per le ruote, una cosa molto utile.
• Collider composto- combinazioni di primitivi che insieme agiscono come uno. Per creare un collisore così complesso, è necessario aggiungere oggetti figlio al nostro collisore di base e già associarli tramite primitiva. Così, ad esempio, i semplici collisori per auto sono realizzati in modo molto conveniente.

Funzionalità configurabili

In linea di principio, tutti i collisori sono simili tra loro, vengono utilizzati solo per oggetti di forme diverse, tuttavia hanno diversi parametri diversi.

• Cubo
  • Materiale- Mostra come il collisore interagisce con altri oggetti, mentre assegna un materiale fisico, come metallo, ghiaccio, ecc.
  • è il grilletto- Se il parametro è abilitato, l'oggetto è influenzato dallo script, non dalla fisica.
  • taglia- La dimensione del collisore lungo gli assi X-Y-Z.
  • Centro- La posizione del collisore, relativa alle coordinate locali dell'oggetto.
• Sfera
  • Raggio- Il raggio della sfera, sostituisce il parametro taglia.
  • Il resto dei parametri è invariato.
• Capsula(i parametri sostituiscono la dimensione)
  • Raggio- Lo spessore della capsula.
  • Altezza- L'altezza della parte cilindrica del collisore (senza basi arrotondate).
  • direzione- La direzione del collisore, relativa alle coordinate locali dell'oggetto.

• Collisore a maglie(i parametri sostituiscono la dimensione)
  • maglia- Selezione della mesh desiderata per creare un collisore.
  • Collisioni di sfere lisce - L'abilitazione di questa funzione leviga la superficie del collisore. Va utilizzato su superfici lisce, ad esempio terreni in pendenza senza troppa spigolosità, su cui le sfere dovrebbero rotolare.
  • Convesso- Quando abilitato, consente al nostro collisore di entrare in collisione con altri collisori. Collisore a maglia convessa"è limitato a 255 triangoli.
• Collisore di ruote(i parametri sostituiscono la dimensione)
• Raggio- Raggio della ruota.
• Distanza di sospensione- Distanza massima per aumentare la sospensione delle ruote. La sospensione aumenta sempre lungo l'asse locale Y.
• Molla di sospensione- La sospensione cerca di raggiungere il punto specificato utilizzando varie forze.

1. Spring:// Tenta di raggiungere il punto (posizione) specificato. Maggiore è l'impostazione, più velocemente viene raggiunta.
2. Damper:// Ammorbidisce, rallenta la velocità della sospensione. Più alto è il valore, più lentamente si muove l'ammortizzatore.
3. Posizione target:// Il "percorso" completo che la sospensione può "percorrere". 0 significa un ammortizzatore completamente esteso, e 1 - completamente compresso. Il valore predefinito è 0, che corrisponde a una normale sospensione dell'auto.

• Messa- Massa della ruota.
• Attrito in avanti/laterale - Parametri di attrito per il semplice rotolamento della ruota e per il rotolamento laterale (questo accade in slittamento o derapata).

mi piace +15 - 0

*Unity* è un motore molto potente e progressivo con molto potenziale. Ha molte funzioni integrate (incluso il motore fisico *NvidiaPhysX*) che noi utenti non dobbiamo prescrivere manualmente. :)
In questo breve articolo, vorrei discutere le capacità fisiche del motore. Quindi, iniziamo:

Corpo rigido
=
= Cos'è questo? =
Dietro la funzione *Rigidbody* c'è un Absolutely Rigid Body (*ATT*). Per spiegare in modo approssimativo e chiaro, *ATT* in fisica e meccanica è un corpo rigido ideale che, sotto l'influenza di una forza, non può cambiare le sue proprietà, ma può (sotto la sua influenza) muoversi in 3 dimensioni (basso, alto, avanti, ecc.). ecc., cioè nei nostri assi X-Y-Z), oltre a ruotare in 3 dimensioni (sempre, lungo gli assi X-Y-Z).

In *Unity*, così come in altri motori di gioco (di nuovo, li chiamo più o meno motori di "gioco"), *Rigidbody* è usato per vari oggetti con cui possiamo interagire spingendo, calciando, ecc. Tali oggetti sotto la nostra influenza continueranno a rotolare, muoversi e scontrarsi con altri oggetti sotto l'influenza della gravità.

Quale applicazione possiamo trovare per questa funzione? =
Ad esempio, per creare un'auto, oltre a *Rigidbody* abbiamo bisogno Collider a 4 ruote"a e *codice* (*script*) che applica la forza alle ruote, a seconda dei tasti premuti.

• *Massa* - La massa del nostro oggetto in chilogrammi. Si raccomanda di non impostare valori di massa 100 volte maggiori o minori delle masse di altri *ATT*.
• *Trascinamento* - Quanto il corpo è soggetto alla resistenza dell'aria quando si muove sotto l'influenza di forze. Con un valore di *0* non c'è resistenza e un valore infinito fermerà istantaneamente il nostro oggetto.
• Trascinamento angolare- Quanto il corpo è soggetto alla resistenza dell'aria quando ruota sotto l'influenza delle forze. Con un valore di *0* non c'è resistenza e un valore infinito fermerà istantaneamente la rotazione del nostro oggetto.
• Gravità- Quando acceso, l'oggetto viene influenzato dalla gravità.
• è cinematico- Quando abilitato, l'oggetto non viene influenzato dal motore fisico e può essere modificato solo dalla sua funzione *Trasforma*. Questo può essere utile per creare piattaforme mobili, ad esempio.
• *Interpola* - Si applica solo se i tuoi movimenti ATT ti sembrano strani o goffi, ecc.:

1. Nessuno: Interpolazione non applicata
2. interpolare: Rispetto alla trasformazione del frame precedente (*frame*), il successivo verrà smussato.
3. estrapolare: La trasformazione del frame corrente viene smussata rispetto alla trasformazione stimata (approssimativa) di quella successiva.

• Blocca rotazione- Disabilita qualsiasi rotazione, sia con script che con collisione. Tuttavia, la rotazione può essere eseguita dalla funzione // trasforma.Ruota()
• Rilevamento di collisioni- Utilizzato per impedire agli oggetti in rapido movimento di passare attraverso altri oggetti senza trovarli collisione"ov" (una speciale "griglia" sugli oggetti che si scontrano tra loro e con il giocatore).

1. discreto: Il valore predefinito per il nostro oggetto per "notare" tutti gli altri oggetti con cui potrebbe entrare in collisione.
2. Continuo: Uso Collisione discreta con oggetti di collisione dinamici (che hanno *ATT*), e Collisione continua per statico Mesh Collider"s (senza * ATT *). Modalità Dinamica Continua usi Collisione continua per uno specifico *ATT*. Il resto *ATT* utilizzerà la modalità _Discreta_. (Ciò influenzerà notevolmente il carico del motore fisico, basta lasciare _Discreto_ se non ci sono problemi con la collisione di oggetti veloci)
3. Dinamica continua: Utilizzato per oggetti in modalità _Continua_ o Collisione dinamica continua. Collisione continua sarà utilizzato anche per statico Mesh Collider"s (senza * ATT *). Per tutti gli altri, viene utilizzata la modalità _Discreta_. Utilizzata per oggetti in rapido movimento.

Come possiamo utilizzare questa funzione? =
= Conoscenza di base.
Per utilizzare *ATT*, abbiamo bisogno di un oggetto di gioco già creato (*GameObject*), cliccando su di esso andiamo al menu lungo il seguente percorso: Componenti - Fisica - Rigidbody . Questo è tutto, *ATT* ha aggiunto! :)
Ora l'oggetto è soggetto alla gravità, puoi applicargli forze usando gli script, ma affinché l'oggetto si comporti esattamente come ti serve, dovresti aggiungere *Collider* o *Joint*.

Il codice governa il mondo.
Nello script, ora manipoleremo il nostro oggetto usando le funzioni AddForce() e Aggiungi coppia() .
Poiché uso *JavaScript* in *Unity*, i miei esempi saranno con esso, collegamenti ad altri esempi di scripting (su C# o *Boo*) che troverai di seguito, al paragrafo Ulteriori informazioni su ATT.

Rigidbody.AddForce

// Rigidbody.AddForce utilizza 2 tipi di formule, come molte altre funzioni relative ai movimenti nello spazio. // 1 tipo: funzione AddForce (force: Vector3, mode: ForceMode = ForceMode.Force) : void // La forza che spinge l'oggetto verso l'alto, relativa al sistema di coordinate globale. function FixedUpdate () ( rigidbody.AddForce (Vector3.up * 10); ) // Usando Vector3, una funzione Unity incorporata che è sostanzialmente la stessa del sistema di coordinate standard. // 2° tipo: function AddForce (x: float, y: float, z: float, mode: ForceMode = ForceMode.Force) : void // Stessa cosa, ma usa il sistema di coordinate X-Y-Z. funzione FixedUpdate() ( rigidbody.AddForce(0, 10, 0); )

Rigidbody.AddTorque

// La funzione ruota l'oggetto attorno all'asse specificato. // 1 tipo: funzione AddTorque (torque: Vector3, mode: ForceMode = ForceMode.Force) : void // Fa girare l'ATT attorno all'asse globale Y. function FixedUpdate () ( rigidbody.AddTorque (Vector3.up * 10); ) // tipo 2: funzione AddTorque (x: float, y: float, z: float, modalità: ForceMode = ForceMode.Force) : void // Fa la stessa cosa, ma di nuovo in un sistema di misura diverso. funzione FixedUpdate() ( rigidbody.AddTorque(0, 10, 0); )

ATT interagisce con gli oggetti.
Per il corretto funzionamento dei nostri *ATT* devono essere forniti Collisore"Ami (o collisione"Ami, come preferisci ^.^).
Leggi di più sui collisori di seguito.

Le misure contano!
Osserva le dimensioni del tuo oggetto, perché sono molto più significative anche delle masse *ATT*. Se il tuo oggetto si muove in modo errato, fluttua nell'aria o non entra in collisione, prova a regolare la sua magnitudine (non *ATT*, ma l'oggetto stesso). Quando si importa un modello dall'editor 3D, le sue dimensioni vengono conservate, quindi prestare attenzione durante la fase di modellazione e rispettare le dimensioni di tutti i modelli.

Ulteriori informazioni su ATT =
Su questo, descrivendo *ATT* o *Rigidbody*, io, forse, finirò. Tuttavia, ci sono un paio di consigli, soprattutto per coloro che hanno letto fino a qui :)

1. La dimensione standard del cubo in *Unity* è 1 metro, quindi, è molto comodo controllare la taglia dei tuoi modelli utilizzandolo. Per creare un cubo, seleziona dal menu GameObject - Crea altro - Cubo
2. L'esponente relativo *Mass* determina come due oggetti interagiranno tra loro.
3. *Massa* non influisce sulla velocità di caduta dall'alto, usa *Trascina* per questo scopo.
4. Più alti sono i valori *Trascina*, più pesa l'articolo. i valori standard variano da 0,001(pezzo di metallo solido) a 10(piuma).
5. Se hai bisogno di cambiare un oggetto sia usando gli script che usando la fisica, aggiungi *ATT* ad esso con il parametro *Kinematic*.

È possibile visualizzare esempi di script dell'impatto delle forze esterne su un oggetto con la funzione *ATT* ai seguenti collegamenti:
*Aggiungi forza*
*Aggiungi coppia*

Per modificare l'esempio di script, fare clic sul testo con il nome del linguaggio di programmazione!

Collider
=
= Cos'è questo? =
Nella sezione precedente, abbiamo visto come funziona *Rigidbody* e abbiamo menzionato i cosiddetti *collider*. * Collider * per noi è un oggetto ausiliario sotto forma di griglia di una semplice primitiva o, al contrario, di una forma complessa, che si trova attorno al nostro modello o parte del modello e interagisce con altri oggetti se sono anch'essi circondati da collider .
Per spiegare chiaramente agli esperti dell'editor mondiale di *Warcraft 3*, immagina il modello che abbiamo importato, a cui non abbiamo assegnato texture di percorso nell'editor dudad: questo sarà il nostro oggetto; e il ruolo dei collisori qui sarà svolto dai bloccanti del percorso attorno al modello. Naturalmente, questo è un confronto piuttosto approssimativo, perché in *Unity* sono molto più funzionali. Bene, diamo un'occhiata più da vicino.

Tipi di collisori. =
I collider vengono aggiunti tramite il menu Componente - Fisica . Ci sono diversi tipi:

• Collisore di scatole- a forma di cubo.
• Collisore di sfere- a forma di sfera.
• Collisore di capsule- sotto forma di capsula.
• Collisore a maglie- crea automaticamente un collider in base alla forma della griglia dell'oggetto, non può entrare in collisione con altri collider dello stesso tipo. Utilizzato principalmente per oggetti statici, come l'ambiente di una pista.
• Collisore di ruote- usato per le ruote, una cosa molto utile.
• Collider composto- combinazioni di primitivi che insieme agiscono come uno. Per creare un collisore così complesso, è necessario aggiungere oggetti figlio al nostro collisore di base e già associarli tramite primitiva. Così, ad esempio, i semplici collisori per auto sono realizzati in modo molto conveniente.

Specifiche personalizzate =
In linea di principio, tutti i collisori sono simili tra loro, vengono utilizzati solo per oggetti di forme diverse, tuttavia hanno diversi parametri diversi.

• *Cubo*

* *Materiale* - Mostra come il collisore interagisce con altri oggetti, mentre assegna un materiale fisico, come metallo, ghiaccio, ecc.
* è il grilletto- Se il parametro è abilitato, l'oggetto è influenzato dallo script, non dalla fisica.
* *Size* - La dimensione del collisore lungo gli assi X-Y-Z.
* *Centro* - La posizione del collisore, relativa alle coordinate locali dell'oggetto.

• *Sfera*

* *Radius* - Il raggio della sfera, sostituisce il parametro *Size*.
* Altri parametri invariati.

• *Capsula* (i parametri sostituiscono la dimensione)

* *Raggio* - Spessore capsula.
* *Altezza* - L'altezza della parte cilindrica del collisore (senza basi arrotondate).
* *Direzione* - La direzione del collisore, relativa alle coordinate locali dell'oggetto.

• Collisore a maglie(i parametri sostituiscono la dimensione)

* *Mesh* - Seleziona la mesh desiderata per creare il collisore.
* Collisioni di sfere lisce - L'abilitazione di questa funzione leviga la superficie del collisore. Va utilizzato su superfici lisce, ad esempio terreni in pendenza senza troppa spigolosità, su cui le sfere dovrebbero rotolare.
* *Convesso* - Se abilitato, consente al nostro collisore di entrare in collisione con altri collisori. Collisore a maglia convessa"è limitato a 255 triangoli.

• Collisore di ruote(i parametri sostituiscono la dimensione)

* *Raggio* - Raggio della ruota.
* Distanza di sospensione- Distanza massima per aumentare la sospensione delle ruote. La sospensione aumenta sempre lungo l'asse locale *Y*.
* Molla di sospensione- La sospensione cerca di raggiungere il punto specificato utilizzando varie forze.

1. Primavera: tenta di raggiungere il punto (posizione) specificato. Maggiore è l'impostazione, più velocemente viene raggiunta.
2. Ammortizzatore: Ammorbidisce, rallenta la velocità della sospensione. Più alto è il valore, più lentamente si muove l'ammortizzatore.
3. Posizione target: il "percorso" totale che la sospensione può "percorrere". *0* significa completamente esteso e *1* completamente compresso. Il valore predefinito è 0, che corrisponde a una normale sospensione dell'auto.

* *Massa* - Massa della ruota.
* Attrito in avanti/laterale - Parametri di attrito per il semplice rotolamento della ruota e per il rotolamento laterale (questo accade in slittamento o derapata).

Visto: 734

Il mio strano percorso creativo mi ha portato nello sviluppo del gioco. Grazie a un eccellente programma per studenti di un'azienda informatica, il cui nome è composto da una minuscola lettera greca, collaborando con la nostra università, siamo riusciti a mettere insieme un team, dare vita alla documentazione e impostare lo sviluppo di giochi Agile sotto la supervisione di un'alta classe Ingegnere QA (ciao Anna!)

Senza pensarci troppo, Unity è stato scelto come motore. Questo è un motore meraviglioso, su cui puoi davvero fare molto rapidamente e facilmente brutta partita che, nella loro mente sana, nessuno giocherà mai. Creare bel gioco, devi ancora spalare la documentazione, approfondire alcune funzionalità e acquisire esperienza di sviluppo.

Il nostro gioco ha utilizzato il motore fisico in un modo inaspettato, il che ha causato molti problemi di prestazioni sulle piattaforme mobili. Questo articolo, usando l'esempio del nostro gioco, descrive la mia lotta con il motore fisico e tutte le caratteristiche del suo lavoro che sono state notate sulla strada per una versione beta praticabile.

Il gioco

Qualche parola su come è fatto.
Realizzato con Blender e un paio di script Python. Al momento delle riprese, c'erano 16 quadrati nell'angolo dello schermo, il cui colore codificava 32 bit di un numero in virgola mobile: la rotazione del telefono in un dato momento. R, G - dati, B - parità. 0 - 0, 255 - 1. Il video girato sul computer è stato suddiviso in fotogrammi utilizzando ffmpeg, a ciascun fotogramma di rendering è stato assegnato un angolo decodificato. Questo formato ha permesso di sopravvivere a qualsiasi compressione durante il processo di ripresa e ha superato il fatto che tutti i programmi hanno idee leggermente diverse sul passare del tempo. In realtà, il gioco funziona allo stesso modo del rendering.

L'aereo vola attraverso una caverna infinita e imprevedibile, in cui ci sono bonus, tutti i tipi di monete e nemici che puoi sparare con missili a ricerca. Si è schiantato contro il muro - perso immediatamente.
Una caratteristica distintiva del gioco è che il livello è inchiodato all'orizzonte e il controllo al suo interno è giroscopico, per di più assoluto. Inclinare il telefono di 45 gradi: l'aereo ha volato con un angolo di 45 gradi. Devi creare un ciclo morto: devi girare il tablet. Non c'è sensibilità, solo hardcore.
Evidenziamo due problemi principali e ovvi per lo sviluppatore:

Problema 1: Infinito

Unity memorizza ed elabora le coordinate degli oggetti come normali float a 32 bit con una precisione fino a 6 cifre decimali. Il problema è che abbiamo un gioco infinito e se voliamo abbastanza a lungo, inizieranno tutti i tipi di bug folli, fino al teletrasporto attraverso i muri. Esistono diversi approcci per risolvere questo problema:

Ignorando. In Minecraft, ad esempio, gli errori di arrotondamento hanno solo reso il gioco più interessante generando .

Teletrasporto a (0;0;0) quando l'aereo è troppo lontano dall'origine.

Cambio punto di riferimento. Non è l'aereo che si muove, ma il livello che lo circonda.

Nel nostro caso, l'unica opzione accettabile è la terza, che è stata implementata. Informazioni sull'implementazione - un po 'più tardi.
Il primo - ignorare - è assolutamente inaccettabile. Creare un robot che possa giocare il nostro gioco per sempre è un compito interessante (e abbastanza semplice) che qualcuno risolverà. E i normali giocatori coreani non devono essere sottovalutati: l'aereo è veloce, il livello viene generato in modo imprevedibile. E se voli e voli prima di passare attraverso le pareti, le riprese molto più accurate inizieranno ovviamente a presentare problemi dopo 5 minuti di volo.
Il secondo - il teletrasporto del giocatore e del mondo intero - mette in ginocchio i dispositivi mobili, in alcuni casi, per circa mezzo secondo. Questo è molto evidente e quindi - inaccettabile. Ma questa è un'opzione perfettamente accettabile per semplici giochi per PC senza fine.

Problema 2: generazione di livelli

Esistono diversi approcci di base per la creazione di corridori infiniti:

Utilizzando segmenti di livello già pronti che si adattano in modo casuale. Questo viene fatto, ad esempio, in Subway Surfers. È facile da implementare, ma il giocatore si abitua rapidamente e sa cosa prepararsi, il che è noioso.

Il livello è solo una linea retta su cui gli ostacoli sono posizionati casualmente. Ecco come si fa in Joypack Joyride e Temple Run. Nel nostro caso, questo limiterebbe notevolmente il numero di manovre.

Tutto è generato casualmente. L'opzione più difficile, imprevedibile e interessante per il giocatore.

Naturalmente, abbiamo scelto l'opzione più difficile. Al centro c'è una macchina a stati molto complessa che esegue transizioni casuali su di esse. Ma nell'ambito di questo articolo, non è il meccanismo ad essere interessante, ma il processo di generazione del livello e la sua organizzazione, tenendo conto del punto di partenza scelto.

Struttura del livello

Stiamo volando in una grotta, ha un pavimento e un soffitto - un paio di blocchi, unità edilizie elementari. I blocchi sono combinati in segmenti che si uniscono senza soluzione di continuità. I segmenti, nel loro insieme, ruotano attorno all'aereo e si muovono lungo il suo vettore di velocità, creando l'illusione del volo. Se un segmento lascia il campo visivo della telecamera, viene ripulito dai blocchi, agganciato all'ultimo segmento del livello e riempito con nuovi blocchi, secondo le istruzioni del generatore. La totalità di tali segmenti è il livello.
Gli sviluppatori esperti di Unity potrebbero giustamente sussultare, dopo aver stimato la quantità di lavoro e tutte le possibili insidie. Ma a parole, tutto è semplice, ma non avevo esperienza di sviluppo...

Leggi fondamentali della fisica nell'unità

In un mese di sviluppo, sperimentazione e lettura della documentazione, ho identificato tre leggi fondamentali della fisica in Unity. Possono essere violati, ma il prezzo della violazione è la produttività. Il motore non ti avviserà in alcun modo dell'errore e senza un profiler potresti non conoscerli mai. Il mancato rispetto di queste leggi può rallentare il tuo gioco in decine una volta. A quanto ho capito, la violazione di qualsiasi legge porta al fatto che il motore fisico contrassegna il collisore incriminato come errato e lo ricrea sull'oggetto, seguito dal ricalcolo della fisica:

1. I collider non devono muoversi, ruotare, accendersi/spegnersi e cambiare dimensione.

Dopo aver aggiunto un collisore a un oggetto, dimentica qualsiasi impatto su di esso o sugli oggetti che contiene. Un normale collisore è un oggetto esclusivamente statico. Un albero, ad esempio, può essere con un collisore. Se l'albero può cadere sul giocatore, l'albero cadrà insieme alla performance. Se questo albero cresce da una nuvola di nutrienti magica che non ha un collisore, ma può muoversi, questo sarà accompagnato da un calo delle prestazioni.

2. Se l'oggetto si sta muovendo o ruotando, deve essere un corpo solido, ad es. hanno un componente Rigidbody.

A riguardo è scritto nella documentazione, sì. Che non è necessario leggere attentamente per iniziare a realizzare un gioco, perché Unity è molto semplice e intuitivo.
Rigidbody cambia la relazione del motore fisico con l'oggetto. Le forze esterne iniziano ad agire su di esso, può avere velocità lineari e angolari e, soprattutto, un corpo rigido può muoversi e ruotare per mezzo di un motore fisico senza causare un completo ricalcolo della fisica.
Esistono due tipi di solidi: convenzionali e cinematici. I corpi ordinari interagiscono tra loro e con i normali collisori: un corpo non può passare attraverso un altro. I corpi cinematici seguono regole di simulazione semplificate: non sono influenzati da forze esterne, inclusa la gravità. Sono liberi di affrontare qualsiasi cosa.
Se non è un peccato dare oggetti sotto il controllo del motore fisico, usa normali corpi rigidi. Ad esempio, se hai bisogno di far rotolare magnificamente pietre da una scogliera. Se i tuoi script o animatori controllano direttamente l'oggetto, usa i corpi cinematici, in modo da non dover affrontare costantemente il motore e le collisioni casuali degli oggetti. Ad esempio, se hai un personaggio animato o un missile guidato che esplode al contatto con qualcosa.

3. Se l'oggetto è un corpo rigido, deve muoversi e ruotare attraverso i metodi del corpo rigido.

Dimentica di chiamare direttamente Transform "su un oggetto subito dopo aver aggiunto un collisore ad esso. D'ora in poi e per sempre, Transform è il tuo nemico e killer delle prestazioni. Prima di scrivere transform.position = ... o transform.eulerAngles = ..., dì la frase "Ora capisco perfettamente quello che sto facendo, sono soddisfatto dei freni che saranno causati da questa linea". Non dimenticare le relazioni gerarchiche: se muovi improvvisamente un oggetto contenente corpi rigidi, la fisica sarà ricalcolato.

Esistono tre livelli di controllo del corpo rigido:

- Il livello più alto e quindi naturale è attraverso le forze. Questi sono i metodi AddForce e AddTorque. Il motore fisico terrà conto della massa del corpo e calcolerà correttamente la velocità risultante. Tutte le interazioni dei corpi avvengono a questo livello.
- Livello medio - cambio di velocità. Queste sono le proprietà Velocity e angularVelocity. Sulla base di essi vengono calcolate le forze che influiscono sui corpi durante la loro interazione, nonché, ovviamente, le loro posizioni nel momento successivo. Se un corpo rigido ha una velocità molto bassa, "si addormenta" per risparmiare risorse.
- Il livello più basso - direttamente le coordinate dell'oggetto e il suo orientamento nello spazio. Questi sono i metodi MovePosition e MoveRotation. Alla successiva iterazione del calcolo fisico (questo è importante, poiché ogni successiva chiamata al metodo all'interno di un frame sostituisce la chiamata del precedente), teletrasportano l'oggetto in una nuova posizione, dopodiché rivive come prima. Nel nostro gioco, questo livello viene utilizzato, e solo esso, perché fornisce il pieno controllo sull'oggetto.

Cosa resta? Attiva/disattiva l'oggetto e ingrandisci. Non so se esiste un modo per ridimensionare un oggetto senza confondere il motore. È del tutto possibile di no. Lo spegnimento dell'oggetto è indolore e l'accensione... sì, provoca un ricalcolo della fisica in prossimità dell'oggetto acceso. Pertanto, cerca di non includere troppi oggetti contemporaneamente, allunga questo processo nel tempo in modo che l'utente non se ne accorga.

C'è una legge che non influisce sulle prestazioni, ma influisce sulle prestazioni: un corpo rigido non può far parte di un corpo rigido. L'oggetto genitore dominerà, quindi il bambino starà fermo rispetto al genitore o si comporterà in modo imprevedibile e scorretto.

C'è un'altra caratteristica non fisica di Unity che vale la pena menzionare: creare ed eliminare dinamicamente oggetti tramite i metodi Instanzia/Distruggi è DAVVERO lento. Ho paura anche solo di immaginare cosa sta succedendo sotto il cofano durante la creazione dell'oggetto. Se hai bisogno di creare ed eliminare qualcosa in modo dinamico, usa le fabbriche e riempile con gli oggetti necessari durante il caricamento del gioco. Instanziate dovrebbe essere chiamato come ultima risorsa - se la fabbrica esaurisce improvvisamente gli oggetti liberi e dimentica per sempre Destroy - tutto ciò che è stato creato dovrebbe essere riutilizzato.

Applicazione pratica delle leggi

(questa sezione contiene il percorso di ragionamento durante la creazione del gioco e le sue caratteristiche)

Il livello ovviamente deve ruotare e muoversi.
Semplifichiamoci la vita per sempre ponendo l'asse di rotazione del livello - l'aereo - all'origine delle coordinate. Ora possiamo calcolare la distanza da un punto ad esso calcolando la lunghezza del vettore di coordinate del punto. Un po', ma carino.
Il movimento cooperativo degli oggetti è facilmente implementabile attraverso la gerarchia degli oggetti in Unity perché i figli fanno parte del genitore. Ad esempio, la struttura dei livelli descritta è implementata logicamente come segue:
- Asse di rotazione
- - Livello
- - - Segmento 1
- - - - Blocco 1 (Collider)
- - - - ...
- - - - Blocco N
- - - Segmento 2 ...
- - - Segmento 3 ...
- - - Segmento 4 ...
(Puoi anche fare a meno dell'oggetto livello)

Lo script sull'asse riceve i dati dal giroscopio e imposta l'angolo appropriato per esso ... E viola immediatamente molte regole, perché la rotazione verrà trasferita attraverso la gerarchia ai collider, il che farà impazzire il motore fisico. Dovrai rendere l'asse un corpo rigido e ruotarlo attraverso il metodo appropriato. Ma per quanto riguarda il movimento di livello? Ovviamente l'asse di rotazione e l'oggetto di livello non si muoveranno, ogni segmento deve essere spostato singolarmente, altrimenti siamo di fronte al problema dell'infinito. Ciò significa che i segmenti devono essere corpi rigidi. Ma abbiamo già un corpo rigido più in alto nella gerarchia e un corpo rigido non può far parte di un corpo rigido. Una gerarchia logica ed elegante non si adatta, tutto dovrà essere fatto a mano, sia in rotazione che in traslazione, senza utilizzare un oggetto per l'asse di rotazione. Preparati a questo se hai caratteristiche di gioco uniche.

Se dovessi comunque spostare i segmenti direttamente, dovrai ruotarli. La difficoltà principale è che nel motore fisico Unity non esiste il metodo "ruota un oggetto attorno a un punto arbitrario" (Transform ce l'ha, ma non lasciarti tentare). C'è solo "ruota attorno al suo centro". Questo è logico, perché la rotazione attorno a un asse arbitrario è sia rotazione che movimento allo stesso tempo, e queste sono due operazioni diverse. Ma può essere imitato. Innanzitutto, ruotiamo il segmento attorno al proprio asse, quindi ruotiamo le coordinate del "proprio asse" attorno al velivolo. Dato che abbiamo il piano all'origine, non devi nemmeno ricordare la geometria della scuola e andare su Wikipedia, Unity ha già tutto. Basta convertire l'angolo di rotazione in un quaternione e moltiplicarlo per le coordinate del punto. A proposito, l'ho scoperto proprio al momento della stesura dell'articolo, prima che fosse utilizzata una matrice di rotazione.

Abbiamo nemici che spingono l'aereo contro il muro, sperando di uccidere. C'è uno scudo che respinge l'aereo dalle pareti, aiutando a sopravvivere. Questo è implementato banalmente: c'è un vettore di offset, che viene aggiunto alle coordinate di ciascun segmento ogni fotogramma e ripristinato successivamente. Chiunque voglia dare un calcio all'aereo, attraverso un metodo speciale, può lasciare il vettore del suo calcio, che verrà aggiunto a questo vettore di spostamento.

In definitiva, le coordinate reali del segmento, ogni fotogramma, vengono calcolate dal centro di controllo del movimento del livello in questo modo:
Posizione Vector3 = segmento.CachedRigidbody.position; Vector3 deltaPos = Time.deltaTime * Vector3.left * settings.Speed; segment.truePosition = Quaternion.Euler(0, 0, deltaAngle) * (posizione + deltaPos + movementOffset);
Dopo tutti i calcoli e le stampelle necessarie per lavorare con l'aggancio esatto dei segmenti durante la rigenerazione, segment.truePosition viene inviato al metodo MovePosition del corpo rigido del segmento.

conclusioni

Quanto velocemente funziona tutto? Sulle vecchie ammiraglie - Nexus 5 e LG G2 - il gioco vola a 60 FPS, con un drawdown appena percettibile quando vengono attivati ​​nuovi collider durante la generazione del segmento (questo è inevitabile e non può essere evitato in alcun modo) e spingendo i vermi fuori dal terreno (puoi accumulare una specie di inferno, per aggirarlo, ma ora c'è una deliberata violazione della terza legge). 40 FPS stabili emettono qualsiasi dispositivo con un giroscopio in cui ci siamo imbattuti. Senza conoscere e tenere conto di tutte le leggi, le prestazioni sono state, per usare un eufemismo, insoddisfacenti e i telefoni si sono surriscaldati. Tanto che ho pensato di scrivere il mio semplice motore specializzato per la fisica 2D. Fortunatamente, la fisica in Unity si è rivelata sufficientemente flessibile da poter aggirare e creare tutti i problemi gioco unico, sono bastate solo un paio di settimane di esperimenti.

Ora, conoscendo tutte le principali insidie ​​del motore fisico di Unity, puoi clonare rapidamente il nostro gioco, distruggendo i sogni, le vite e la fede di tre poveri studenti dell'umanità. Spero che questo articolo ti farà risparmiare molto tempo in futuro e ti aiuterà a trovare violazioni non del tutto evidenti delle leggi della fisica produttiva nei tuoi progetti.

Leggi la documentazione e sperimenta, anche se utilizzi strumenti semplici e intuitivi.