Egység- nagyon erős, progresszív motor nagy lehetőségekkel. Sok már beépített funkcióval rendelkezik (beleértve a fizikai motort is Nvidia PhysX), amelyet nekünk, felhasználóknak nem kell manuálisan regisztrálnunk. :)
Ebben a rövid cikkben a motor fizikai képességeit szeretném tárgyalni. Tehát kezdjük:

Merev test

Ami?

A funkció mögött Merev test Teljesen merev test elrejtése ( ATT). Ha durván és érthetően elmagyarázod, akkor ATT a fizikában és a mechanikában ideális merev test, amely erő hatására nem tudja megváltoztatni tulajdonságait, de (hatása alatt) 3 dimenzióban mozoghat (le, fel, előre stb., azaz X-Y-Z tengelyeinkben). ), valamint 3 dimenzióban forgatni (ismét az X-Y-Z tengelyek mentén).

NÁL NÉL Egység, mint a többi játékmotorban (ismét durván "játékmotoroknak" hívom őket), Merev test különféle tárgyakhoz használják, amelyekkel kölcsönhatásba léphetünk lökéssel, rúgással stb. A hatásunk alatt lévő ilyen tárgyak a gravitáció hatására továbbra is gurulnak, mozognak és ütköznek más tárgyakkal.

Milyen alkalmazást találhatunk ehhez a funkcióhoz?

Például autó létrehozásához, amellett Merev test szükségünk van 4 Kerékütköző"ésés a kód (forgatókönyv), amely a megnyomott billentyűktől függően erőt fejt ki a kerekekre.

Konfigurálható funkciók

• Tömeg- Tárgyunk tömege kilogrammban. Javasoljuk, hogy ne állítson be más tömegek tömegénél 100-szor nagyobb vagy kisebb tömegértékeket ATT.
• Húzza- Mennyire van kitéve egy test légellenállásnak, amikor az erők hatására mozog. Egy értékkel 0 nincs ellenállás, és egy végtelen érték azonnal leállítja tárgyunkat.
• Szögletes húzás- Mennyire van kitéve a test légellenállásnak, amikor az erők hatására forog. Egy értékkel 0 nincs ellenállás, és egy végtelen érték azonnal leállítja tárgyunk forgását.
• Gravitáció- Bekapcsoláskor a gravitáció hatással lesz a tárgyra.
• Kinematikus- Ha engedélyezve van, az objektumra nem lesz hatással a fizikai motor, és csak a funkciója módosíthatja Átalakítani. Ez hasznos lehet például mozgó platformok létrehozásához.
• Interpolál- Csak akkor érvényes, ha az ATT mozgása furcsának vagy ügyetlennek tűnik számodra stb.:
  1. Egyik sem: Az interpoláció nincs alkalmazva
  2. interpolál:Összehasonlítva az előző képkocka átalakításával ( keret) , a következő simításra kerül.
  3. extrapolálni: Az aktuális keret transzformációja a következő becsült (közelítő) transzformációjához képest simított.
• Freeze Rotation- Letilt minden forgatást, mind a szkriptet, mind az ütközést. A forgatást azonban a funkció végrehajthatja transform.Rotate()
• Ütközésészlelés- Megakadályozza, hogy gyorsan mozgó tárgyak áthaladjanak más tárgyakon anélkül, hogy megtalálnák ütközés"ov" (egy speciális "rács" azokon a tárgyakon, amelyek ütköznek egymással és a játékossal).
  1. diszkrét: Az objektumunk alapértelmezett értéke „észrevesz” minden más objektumot, amellyel ütközhet.
  2. Folyamatos: Használat Diszkrét ütközés dinamikus ütközési objektumokkal (amelyek rendelkeznek ATT), a Folyamatos ütközés statikus számára MeshCollider"ov (anélkül ATT). Mód Folyamatos dinamikus használ Folyamatos ütközés egy konkrét ATT. Pihenés ATT módot fogja használni Diszkrét. (Ez nagymértékben befolyásolja a fizikai motor terhelését, csak hagyja Diszkrét, ha nincs probléma a gyors tárgyak ütközésével)
  3. Folyamatos dinamikus:Üzemmódban lévő objektumokhoz használatos Folyamatos vagy Folyamatos dinamikus ütközés. Folyamatos ütközés statikusra is használják MeshCollider"ov (anélkül ATT). Az összes többi esetében a mód használatos Diszkrét. Gyorsan mozgó tárgyakhoz használják.

Hogyan használhatjuk ezt a funkciót?

Alap tudás.

Használni ATT, szükségünk van egy már létrehozott játékobjektumra ( GameObject), rákattintva a menübe jutunk az alábbi útvonalon: Alkatrészek - Fizika - Merev test . Összes, ATT hozzáadva! :)
Most az objektum a gravitációnak van kitéve, szkriptek segítségével erőt is alkalmazhat rá, de ahhoz, hogy az objektum pontosan úgy viselkedjen, ahogyan szüksége van rá, hozzá kell adnia Ütköző vagy közös.

A kód uralja a világot.

A szkriptben most függvényekkel kezeljük az objektumunkat AddForce()és AddTorque() .
Mióta bent vagyok Egység alkalmaz JavaScript, a példáim hozzá lesznek, linkek más szkriptpéldákhoz (at C# vagy Lehurrogás) lentebb, a bekezdésben találja További információ az ATT-ről.

» Rigidbody.AddForce

// A Rigidbody.AddForce 2 típusú képletet használ, mint sok más, a térben történő mozgásokhoz kapcsolódó függvény. // 1 típus: function AddForce (force: Vector3, mód: ForceMode = ForceMode.Force) : void // Az az erő, amely az objektumot felfelé tolja, a globális koordinátarendszerhez képest. function FixedUpdate () ( rigidbody.AddForce (Vector3.up * 10); ) // Vector3 használatával, egy beépített Unity függvényrel, amely alapvetően megegyezik a szabványos koordinátarendszerrel. // 2. típus: függvény AddForce (x: float, y: float, z: lebegés, mód: ForceMode = ForceMode.Force) : void // Ugyanaz, de itt használjuk X-Y-Z rendszer koordináták. függvény FixedUpdate() ( rigidbody.AddForce(0, 10, 0); )

» Merev test.AddTorque

// A függvény az objektumot az adott tengely körül forgatja. // 1 típus: function AddTorque (nyomaték: Vector3, mód: ForceMode = ForceMode.Force) : void // Az ATT-t a globális Y tengely körül forgatja. function FixedUpdate () ( rigidbody.AddTorque (Vector3.up * 10); ) // 2. típus: függvény AddTorque (x: float, y: float, z: float, mode: ForceMode = ForceMode.Force) : void // Ugyanazt csinálja, de megint más mérési rendszerben. függvény FixedUpdate() ( rigidbody.AddTorque(0, 10, 0); )

Az ATT kölcsönhatásba lép az objektumokkal.

A mi megfelelő működésünk érdekében ATT el kell látni őket Ütköző"ami (vagy ütközés"ami, ahogy tetszik ^.^).
Az ütköztetőkről lentebb olvashat bővebben.

A méret számít!

Figyelje meg tárgya méreteit, mert ezek sokkal jelentősebbek a páros tömegűek ATT. Ha az objektum helytelenül mozog, lebeg a levegőben vagy nem ütközik, próbálja meg módosítani a nagyságát (nem ATT, hanem maga a tárgy). Amikor egy modellt importál a 3D szerkesztőből, a méretei megmaradnak, ezért legyen óvatos a modellezési szakaszban, és tartsa tiszteletben az összes modell méreteit.

További információ az ATT-ről

Ezt írja le ATT vagy Merev test Valószínűleg befejezem. Azért van egy-két tipp, főleg azoknak, akik idáig olvastak :)

1. szabványos kockaméret Egység egyenlő 1 méter, ezért nagyon kényelmes ellenőrizni a modellek méretét ezzel. Kocka létrehozásához válassza ki a menüből GameObject – Más létrehozása – Kocka
2. Relatív mutató Tömeg meghatározza, hogy két objektum hogyan fog kölcsönhatásba lépni egymással.
3. Tömeg nem befolyásolja a magasból való esés sebességét, erre a célra használja Húzza.
4. Minél magasabbak az értékek Húzza minél többet nyom a tárgy. standard értékek változnak 0,001-től(tömör fémdarab) 10-re(madártoll).
5. Ha szkriptekkel és fizikával is módosítania kell egy objektumot, adja hozzá ATT paraméterrel Kinematikai.

Ütközők

Ami?

Az előző részben megbeszéltük, hogyan Merev testés megemlítette az ún ütközők. Ütköző számunkra - egy segédobjektum egy egyszerű primitív vagy éppen ellenkezőleg, összetett alakú rács formájában, amely a modellünk vagy a modell egy része körül helyezkedik el, és kölcsönhatásba lép más objektumokkal, ha azokat ütköztetők is körülveszik.
Hogy érthetően elmagyarázzuk a *Warcraft 3* világszerkesztő szakértőinek, képzeljük el az általunk importált modellt, amelyhez nem rendeltünk elérési út textúrákat a dudad szerkesztőben – ez lesz a mi célunk; és az ütközők szerepét itt a modell körüli út blokkolói fogják betölteni. Természetesen ez egy elég durva összehasonlítás, mert in Egység sokkal funkcionálisabbak. Nos, nézzük meg közelebbről.

Ütközők típusai.

Ütközők hozzáadása a menün keresztül történik Alkatrész - Fizika . Több típusa van:

• Box Collider- kocka formájában.
• Gömbütköztető- gömb formájában.
• Kapszulaütköztető- kapszula formájában.
• Mesh Collider- automatikusan létrehoz egy ütközőt a tárgyrács alakjának megfelelően, nem ütközhet más, azonos típusú ütközővel. Főleg statikus tárgyakhoz, például versenypálya környezetéhez használják.
• Kerékütköztető- kerekekhez használt, nagyon hasznos dolog.
• Compound Collider- primitívek kombinációi, amelyek együtt egyként működnek. Egy ilyen összetett ütköztető létrehozásához hozzá kell adnia gyermekobjektumokat az alapütköztetőnkhoz, és már primitíven kell hozzájuk kötni. Így például az autók egyszerű ütköztetői nagyon kényelmesen készülnek.

Konfigurálható funkciók

Elvileg minden ütköztető hasonló egymáshoz, csak különböző formájú tárgyakhoz használják, azonban több különböző paraméterrel rendelkeznek.

• Kocka
  • anyag- Megmutatja, hogy az ütköző hogyan lép kölcsönhatásba más tárgyakkal, miközben hozzárendel egy fizikai anyagot, például fémet, jeget stb.
  • A Trigger- Ha a paraméter engedélyezve van, akkor az objektumot a szkript érinti, nem a fizika.
  • méret- Az ütköző mérete az X-Y-Z tengelyek mentén.
  • Központ- Az ütköző helyzete az objektum helyi koordinátáihoz képest.
• Szféra
  • Sugár- A gömb sugara helyettesíti a paramétert méret.
  • A többi paraméter változatlan.
• Kapszula(a paraméterek a méretet helyettesítik)
  • Sugár- A kapszula vastagsága.
  • Magasság- Az ütköző hengeres részének magassága (lekerekített talpak nélkül).
  • irány- Az ütköző iránya az objektum helyi koordinátáihoz viszonyítva.

• Mesh Collider(a paraméterek a méretet helyettesítik)
  • háló- A kívánt háló kiválasztása ütköző létrehozásához.
  • Sima gömb ütközések - Ennek a funkciónak az engedélyezése simítja az ütköző felületét. Sima felületeken kell használni, például lejtős terepen, túlságosan szögletesség nélkül, amelyen a gömböknek gördülniük kell.
  • Konvex- Ha engedélyezve van, lehetővé teszi ütköztetőnk ütközését más ütköztetőkkel. Konvex hálóütköztető"re korlátozódik 255 háromszög.
• Kerékütköztető(a paraméterek a méretet helyettesítik)
• Sugár- Keréksugár.
• Felfüggesztési távolság- Maximális távolság a kerékfelfüggesztés növeléséhez. A felfüggesztés mindig a helyi tengely mentén növekszik Y.
• felfüggesztő rugó- A felfüggesztés különböző erők segítségével próbálja elérni a megadott pontot.

1. Spring:// Megkísérli elérni a megadott pontot (pozíciót). Minél magasabb a beállítás, annál gyorsabban érhető el.
2. Damper:// Lágyítja, lassítja a felfüggesztés sebességét. Minél magasabb az érték, annál lassabban mozog a csappantyú.
3. Target Position:// A teljes „út”, amelyet a felfüggesztés „utazni tud”. 0 teljesen kinyújtott lengéscsillapítót jelent, és 1 - teljesen összenyomva. Az alapértelmezett érték 0, ami egy normál autófelfüggesztésnek felel meg.

• Tömeg- A kerék tömege.
• Előre/oldalsó súrlódás - Súrlódási paraméterek a kerék egyszerű gördüléséhez és oldalirányú gördüléshez (ez megcsúszásnál vagy sodródásnál történik).

szeretem +15 - 0

A *Unity* egy nagyon erős, progresszív motor, rengeteg lehetőséggel. Számos beépített funkcióval rendelkezik (köztük az *NvidiaPhysX* fizikai motor), amelyeket nekünk, felhasználóknak nem kell manuálisan előírnunk. :)
Ebben a rövid cikkben a motor fizikai képességeit szeretném tárgyalni. Tehát kezdjük:

Merev test
=
= Mi ez? =
A *Rigidbody* funkció mögött egy Absolutely Rigid Body (*ATT*) található. Hogy durván és érthetően elmagyarázzuk, az *ATT* a fizikában és a mechanikában egy ideális merev test, amely erő hatására nem tudja megváltoztatni tulajdonságait, de (hatása alatt) 3 dimenzióban mozoghat (le, fel, előre, stb.) stb., azaz az X-Y-Z tengelyeinkben), valamint 3 dimenzióban forgatni (ismét az X-Y-Z tengelyek mentén).

A *Unity*-ben és más játékmotorokban is (ezeket ismét "játékmotoroknak" hívom durván) a *Rigidbody*-t különféle tárgyakra használják, amelyekkel kölcsönhatásba léphetünk lökéssel, rúgással stb. A hatásunk alatt lévő ilyen tárgyak a gravitáció hatására továbbra is gurulnak, mozognak és ütköznek más tárgyakkal.

Milyen alkalmazást találhatunk ehhez a funkcióhoz? =
Például egy autó létrehozásához a *Rigidbody* mellett szükségünk van 4 Kerékütköző"a és *kód* (*script*), amely erőt fejt ki a kerekekre, a lenyomott billentyűktől függően.

• *Mass* - Tárgyunk tömege kilogrammban. Javasoljuk, hogy ne állítson be más *ATT* tömegénél 100-szor nagyobb vagy kisebb tömegértékeket.
• *Húzás* – Mennyire van kitéve a test légellenállásnak, amikor az erők hatására mozog. A *0* értéknél nincs ellenállás, és egy végtelen érték azonnal leállítja az objektumunkat.
• Szögletes húzás- Mennyire van kitéve a test légellenállásnak, amikor az erők hatására forog. A *0* értéknél nincs ellenállás, és egy végtelen érték azonnal leállítja az objektum forgását.
• Gravitáció- Bekapcsoláskor a gravitáció hatással lesz a tárgyra.
• Kinematikus- Ha engedélyezve van, az objektumra nem lesz hatással a fizikai motor, és csak a *Transform* funkciója módosíthatja. Ez hasznos lehet például mozgó platformok létrehozásához.
• *Interpoláció* – Csak akkor érvényes, ha az ATT mozgása furcsának vagy ügyetlennek tűnik számodra stb.:

1. Egyik sem: Az interpoláció nincs alkalmazva
2. interpolál: Az előző képkocka (*frame*) átalakításához képest a következő simításra kerül.
3. extrapolálni: Az aktuális keret transzformációja a következő becsült (közelítő) transzformációjához képest simított.

• Freeze Rotation- Letilt minden forgatást, mind a szkriptet, mind az ütközést. A forgatás azonban végrehajtható a // funkcióval transform.Rotate()
• Ütközésészlelés- Megakadályozza, hogy gyorsan mozgó tárgyak áthaladjanak más tárgyakon anélkül, hogy megtalálnák ütközés"ov" (egy speciális "rács" azokon a tárgyakon, amelyek ütköznek egymással és a játékossal).

1. diszkrét: Az objektumunk alapértelmezett értéke „észrevesz” minden más objektumot, amellyel ütközhet.
2. Folyamatos: Használat Diszkrét ütközés dinamikus ütközési objektumokkal (amelyeknek *ATT* van), és Folyamatos ütközés statikus számára MeshCollider"s (* ATT * nélkül). Mód Folyamatos dinamikus használ Folyamatos ütközés egy adott *ATT* számára. A többi *ATT* a _Diszkrét_ módot fogja használni. (Ez nagyban befolyásolja a fizikai motor terhelését, csak hagyja a _Diszkrét_ beállítást, ha nincs probléma a gyors objektumok ütközésével)
3. Folyamatos dinamikus: _Folyamatos_ módban lévő objektumokhoz ill Folyamatos dinamikus ütközés. Folyamatos ütközés statikusra is használják MeshCollider"s (* ATT * nélkül). Az összes többi esetében a _Diszkrét_ módot használják. Gyorsan mozgó objektumok esetén használatos.

Hogyan használhatjuk ezt a funkciót? =
= Alapismeretek.
Az *ATT* használatához szükségünk van egy már elkészített játékobjektumra (*GameObject*), erre kattintva a menübe jutunk a következő útvonalon: Alkatrészek - Fizika - Merev test . Ennyi – tette hozzá *ATT*! :)
Most az objektum a gravitációnak van kitéve, szkriptek segítségével erőket is kifejthet rá, de ahhoz, hogy az objektum pontosan úgy viselkedjen, ahogyan szüksége van rá, hozzá kell adnia a *Collider* vagy a *Joint* elemet.

A kód uralja a világot.
A szkriptben most függvényekkel kezeljük az objektumunkat AddForce()és AddTorque() .
Mivel a *JavaScriptet* használom a *Unity*-ban, a példáim hozzá fognak tartozni, hivatkozások más szkriptpéldákra (on C# vagy *Boo*) lentebb, a bekezdésben található További információ az ATT-ről.

Merev test.AddForce

// A Rigidbody.AddForce 2 típusú képletet használ, mint sok más, a térben történő mozgásokhoz kapcsolódó függvény. // 1 típus: function AddForce (force: Vector3, mód: ForceMode = ForceMode.Force) : void // Az az erő, amely az objektumot felfelé tolja, a globális koordinátarendszerhez képest. function FixedUpdate () ( rigidbody.AddForce (Vector3.up * 10); ) // Vector3 használatával, egy beépített Unity függvényrel, amely alapvetően megegyezik a szabványos koordinátarendszerrel. // 2. típus: függvény AddForce (x: float, y: float, z: lebegés, mód: ForceMode = ForceMode.Force) : void // Ugyanaz, de az X-Y-Z koordinátarendszert használja. függvény FixedUpdate() ( rigidbody.AddForce(0, 10, 0); )

Merev test.AddTorque

// A függvény az objektumot az adott tengely körül forgatja. // 1 típus: function AddTorque (nyomaték: Vector3, mód: ForceMode = ForceMode.Force) : void // Az ATT-t a globális Y tengely körül forgatja. function FixedUpdate () ( rigidbody.AddTorque (Vector3.up * 10); ) // 2. típus: függvény AddTorque (x: float, y: float, z: float, mode: ForceMode = ForceMode.Force) : void // Ugyanazt csinálja, de megint más mérési rendszerben. függvény FixedUpdate() ( rigidbody.AddTorque(0, 10, 0); )

Az ATT kölcsönhatásba lép az objektumokkal.
Az * ATT * helyes működéséhez ezeket el kell látni Ütköző"ami (vagy ütközés"ami, ahogy tetszik ^.^).
Az ütköztetőkről lentebb olvashat bővebben.

A méret számít!
Figyelje meg az objektum méreteit, mert azok sokkal jelentősebbek, mint akár az *ATT* tömegek. Ha az objektum helytelenül mozog, lebeg a levegőben vagy nem ütközik, próbálja meg beállítani a nagyságát (nem *ATT*, hanem maga az objektum). Amikor egy modellt importál a 3D szerkesztőből, a méretei megmaradnak, ezért legyen óvatos a modellezési szakaszban, és tartsa tiszteletben az összes modell méreteit.

További információ az ATT-ről =
Ezzel, az *ATT* vagy a *merev test* leírásával, talán befejezem. Azért van egy-két tipp, főleg azoknak, akik idáig olvastak :)

1. A *Unity* szabványos kockamérete a következő 1 méter, ezért nagyon kényelmes ellenőrizni a modellek méretét ezzel. Kocka létrehozásához válassza ki a menüből GameObject – Más létrehozása – Kocka
2. A *Mass* relatív kitevő határozza meg, hogy két objektum hogyan fog kölcsönhatásba lépni egymással.
3. A *Tömeg* nem befolyásolja a magasból való esés sebességét, erre a célra használja a *Drag*-ot.
4. Minél magasabb a *Drag* érték, annál nagyobb az elem súlya. standard értékek változnak 0,001-től(tömör fémdarab) 10-re(madártoll).
5. Ha egy objektumot szkriptek és fizika használatával is meg kell változtatnia, adja hozzá az *ATT*-ot a *Kinematic* paraméterrel.

A következő hivatkozásokon megtekintheti a külső erők objektumra gyakorolt ​​hatásának parancsfájljait az *ATT* függvény segítségével:
*Erő hozzáadása*
*AddTorque*

A szkriptpélda megváltoztatásához kattintson a programozási nyelv nevét tartalmazó szövegre!

Ütközők
=
= Mi ez? =
Az előző részben megvizsgáltuk a *Rigidbody* működését, és megemlítettük az úgynevezett *ütközőket*. * Az ütköztető * számunkra egy segédobjektum egy egyszerű primitív vagy fordítva, összetett alakú rács formájában, amely a modellünk vagy a modell egy része körül helyezkedik el, és kölcsönhatásba lép más objektumokkal, ha azokat is ütköztetők veszik körül. .
Hogy érthetően elmagyarázzuk a *Warcraft 3* világszerkesztő szakértőinek, képzeljük el az általunk importált modellt, amelyhez nem rendeltünk elérési út textúrákat a dudad szerkesztőben – ez lesz a mi célunk; és az ütközők szerepét itt a modell körüli út blokkolói fogják betölteni. Természetesen ez elég durva összehasonlítás, mert a *Unity*-ban sokkal funkcionálisabbak. Nos, nézzük meg közelebbről.

Ütközők típusai. =
Ütközők hozzáadása a menün keresztül történik Alkatrész - Fizika . Több típusa van:

• Box Collider- kocka formájában.
• Gömbütköztető- gömb formájában.
• Kapszulaütköztető- kapszula formájában.
• Mesh Collider- automatikusan létrehoz egy ütközőt a tárgyrács alakjának megfelelően, nem ütközhet más, azonos típusú ütközővel. Főleg statikus tárgyakhoz, például versenypálya környezetéhez használják.
• Kerékütköztető- kerekekhez használt, nagyon hasznos dolog.
• Compound Collider- primitívek kombinációi, amelyek együtt egyként működnek. Egy ilyen összetett ütköztető létrehozásához hozzá kell adnia gyermekobjektumokat az alapütköztetőnkhoz, és már primitíven kell hozzájuk kötni. Így például az autók egyszerű ütköztetői nagyon kényelmesen készülnek.

Egyedi specifikációk =
Elvileg minden ütköztető hasonló egymáshoz, csak különböző formájú tárgyakhoz használják, azonban több különböző paraméterrel rendelkeznek.

• *Kocka*

* *Anyag* – Megmutatja, hogy az ütköző hogyan lép kölcsönhatásba más tárgyakkal, miközben hozzárendel egy fizikai anyagot, például fémet, jeget stb.
* A Trigger- Ha a paraméter engedélyezve van, akkor az objektumot a szkript érinti, nem a fizika.
* *Méret* – Az ütköző mérete az X-Y-Z tengelyek mentén.
* *Közép* - Az ütköző helyzete az objektum helyi koordinátáihoz képest.

• *Szféra*

* *Radius* – A gömb sugara, a *Size* paraméter helyére.
* Egyéb paraméterek változatlanok.

• *Kapszula* (a paraméterek a méretet helyettesítik)

* *Radius* - Kapszula vastagsága.
* *Magasság* – Az ütköző hengeres részének magassága (lekerekített talpak nélkül).
* *Irány* – Az ütköző iránya az objektum helyi koordinátáihoz viszonyítva.

• Mesh Collider(a paraméterek a méretet helyettesítik)

* *Mesh* - Válassza ki a kívánt hálót az ütköző létrehozásához.
* Sima gömb ütközések - Ennek a funkciónak az engedélyezése simítja az ütköző felületét. Sima felületeken kell használni, például lejtős terepen, túlságosan szögletesség nélkül, amelyen a gömböknek gördülniük kell.
* *Konvex* - Ha engedélyezve van, lehetővé teszi ütköztetőnk ütközését más ütköztetőkkel. Konvex hálóütköztető"re korlátozódik 255 háromszög.

• Kerékütköztető(a paraméterek a méretet helyettesítik)

* *Radius* – Keréksugár.
* Felfüggesztési távolság- Maximális távolság a kerékfelfüggesztés növeléséhez. A felfüggesztés mindig a helyi *Y* tengely mentén növekszik.
* felfüggesztő rugó- A felfüggesztés különböző erők segítségével próbálja elérni a megadott pontot.

1. Rugó: Megkísérli elérni a megadott pontot (pozíciót). Minél magasabb a beállítás, annál gyorsabban érhető el.
2. Lengéscsillapító: Lágyítja, lassítja a felfüggesztés sebességét. Minél magasabb az érték, annál lassabban mozog a csappantyú.
3. Célpozíció: Az a teljes „út”, amelyet a felfüggesztés „megtehet”. A *0* azt jelenti, hogy teljesen ki van húzva, az *1* pedig teljesen tömörített. Az alapértelmezett érték 0, ami egy normál autófelfüggesztésnek felel meg.

* *Tömeg* – A kerék tömege.
* Előre/oldalsó súrlódás - Súrlódási paraméterek a kerék egyszerű gördüléséhez és oldalirányú gördüléshez (ez megcsúszásnál vagy sodródásnál történik).

Megtekintve: 734

Furcsa kreatív utam a játékfejlesztésbe vitt. Egy informatikai cég, melynek neve egy kis görög betűből áll, kiváló hallgatói programjának köszönhetően az egyetemünkkel együttműködve sikerült csapatot összeállítani, dokumentációt megszületni és agilis játékfejlesztést beindítani egy nívós szakember felügyelete mellett. minőségbiztosítási mérnök (szia Anna!)

Sok gondolkodás nélkül a Unity-t választották motornak. Ez egy csodálatos motor, amelyen nagyon gyorsan és egyszerűen készíthetsz nagyon rossz játék amit ép eszükkel soha senki nem fog játszani. Készíteni jó játék, még lapátolnia kell a dokumentációt, bele kell mélyednie néhány funkcióba, és fejlesztési tapasztalatot kell szereznie.

A játékunk nem várt módon használta a fizikai motort, ami sok teljesítményproblémát okozott mobil platformokon. Ez a cikk a játékunk példáján leírja a fizikai motorral való küzdelmemet és annak munkájának minden olyan jellemzőjét, amelyre az életképes béta verzió felé vezető úton figyeltek fel.

A játék

Néhány szó az elkészítés módjáról.
Blenderrel és néhány python szkripttel készült. A forgatás idején a képernyő sarkában 16 négyzet volt, amelyek színe 32 bit lebegőpontos számot kódolt - a telefon adott időpontban történő forgását. R, G - adat, B - paritás. 0 - 0, 255 - 1. A számítógépen felvett videót ffmpeg segítségével kockákra osztottuk, minden render képkockához dekódolt szöget rendeltünk. Ez a formátum lehetővé tette bármilyen tömörítés túlélését a forgatási folyamat során, és leküzdötte azt a tényt, hogy minden program kissé eltérő elképzelésekkel rendelkezik az idő múlásával kapcsolatban. A valóságban a játék ugyanúgy működik, mint a renderen.

A gép egy végtelen és kiszámíthatatlan barlangon repül át, amelyben bónuszok, mindenféle érmék és ellenségek vannak, amelyeket irányító rakétákkal lőhet ki. A falnak ütközött - azonnal elveszett.
A játék jellegzetessége, hogy a szint a horizonthoz van szögezve, a benne lévő vezérlés pedig giroszkópos, ráadásul abszolút. Döntse meg a telefont 45 fokkal - a gép 45 fokos szögben repült. Holt hurkot kell készítenie - meg kell csavarnia a tablettát. Nincs érzékenység, csak hardcore.
Kiemeljünk két fő és nyilvánvaló problémát a fejlesztő számára:

1. probléma: Végtelen

A Unity normál 32 bites lebegésként tárolja és dolgozza fel az objektumkoordinátákat, valahol akár 6 tizedesjegy pontossággal. A probléma az, hogy végtelen játékunk van, és ha elég sokáig repülünk, mindenféle őrült bug kezdődik, egészen a falakon keresztüli teleportálásig. Számos megközelítés létezik a probléma megoldására:

Figyelmen kívül hagyva. A Minecraftban például a kerekítési hibák a spawning által csak érdekesebbé tették a játékot.

Teleportálás (0;0;0)-ra, ha a repülőgép túl messze van az origótól.

Referenciapont változása. Nem a sík mozog, hanem a körülötte lévő szint.

Esetünkben az egyetlen elfogadható lehetőség a harmadik, amely megvalósult. A megvalósításról - egy kicsit később.
Az első – figyelmen kívül hagyása – abszolút elfogadhatatlan. Egy olyan robot létrehozása, amely örökké játszhatja a játékunkat, érdekes (és meglehetősen egyszerű) feladat, amelyet valaki meg fog oldani. A hétköznapi koreai játékosokat pedig nem szabad alábecsülni - a repülőgép gyors, a szint kiszámíthatatlanul generálódik. És ha repül és repül, mielőtt áthaladna a falakon, akkor a sokkal pontosabb lövés nyilvánvalóan 5 perc repülés után meghibásodik.
A második - a játékos és az egész világ teleportálása - térdre kényszeríti a mobileszközöket, bizonyos esetekben körülbelül fél másodpercre. Ez nagyon észrevehető, és ezért - elfogadhatatlan. De ez egy teljesen elfogadható lehetőség az egyszerű végtelen PC-játékokhoz.

2. probléma: Szintgenerálás

Számos alapvető megközelítés létezik a végtelen futók felépítésére:

Véletlenszerűen illeszkedő kész szintszegmensek használata. Ez történik például a Subway Surfersben. Könnyen kivitelezhető, de a játékos gyorsan megszokja, és tudja, mire kell készülnie, ami unalmas.

A szint csak egy egyenes vonal, amelyen az akadályok véletlenszerűen helyezkednek el. Így történik ez a Joypack Joyride-ban és a Temple Run-ban. Esetünkben ez nagyban korlátozná a manőverek számát.

Minden véletlenszerűen generálódik. A játékos számára a legnehezebb, kiszámíthatatlan és legérdekesebb lehetőség.

Természetesen a legnehezebb megoldást választottuk. Középpontjában egy nagyon összetett állapotgép áll, amely véletlenszerű átmeneteket hajt végre rajtuk. De jelen cikk keretein belül nem a mechanizmus az érdekes, hanem a szint generálásának folyamata és annak szervezése, a választott kiindulópont figyelembevételével.

Szintstruktúra

Egy barlangban repülünk, van padlója és mennyezete - pár háztömb, elemi épületegységek. A blokkokat szegmensekké egyesítik, amelyek zökkenőmentesen kapcsolódnak egymáshoz. A szegmensek összességében a repülőgép körül forognak, és annak sebességvektora mentén mozognak, a repülés illúzióját keltve. Ha egy szegmens elhagyja a kamera látóterét, a generátor utasításai szerint megtisztítja a blokkoktól, a szint utolsó szegmenséhez rögzíti és új blokkokkal tölti fel. Az ilyen szegmensek összessége a szint.
A tapasztalt Unity fejlesztők jogosan összerándulhattak, miután felbecsülték a munka mennyiségét és az összes lehetséges buktatót. De szavakkal minden egyszerű, de nem volt fejlesztési tapasztalatom ...

A fizika alaptörvényei egységben

Egy hónapnyi fejlesztés, kísérletezés és dokumentáció olvasása alatt a fizika három alapvető törvényét azonosítottam a Unityben. Megsérthetők, de a megsértés ára a termelékenység. A motor semmilyen módon nem fog figyelmeztetni a hibára, profilozó nélkül pedig lehet, hogy soha nem tud róluk. Ezen törvények be nem tartása lelassíthatja a játékot tízben egyszer. Ha jól értem, bármilyen törvény megsértése azt eredményezi, hogy a fizikai motor hibásnak jelöli meg a sértő ütközőt, és újra létrehozza az objektumon, majd a fizika újraszámítása következik:

1. Az ütközők nem mozoghatnak, foroghatnak, nem kapcsolhatnak be/ki, és nem változtathatják meg a méretüket.

Miután hozzáadott egy ütközőt egy objektumhoz, felejtse el az arra vagy a benne lévő objektumokra gyakorolt ​​​​hatásokat. A közönséges ütköztető egy kizárólag statikus tárgy. Egy fa például egy ütközővel lehet. Ha a fa rádőlhet a játékosra - a fa a teljesítménnyel együtt fog esni. Ha ez a fa egy varázslatos tápanyagfelhőből nő ki, amelynek nincs ütköztetője, de mozogni tud, akkor ez teljesítménycsökkenéssel jár.

2. Ha a tárgy mozog vagy forog - szilárd testnek kell lennie, azaz. merevtest komponenssel rendelkeznek.

A dokumentációban le van írva róla, igen. Amit nem szükséges átgondoltan olvasni a játék készítéséhez, mert a Unity nagyon egyszerű és intuitív.
A merev test megváltoztatja a fizikai motor és az objektum viszonyát. Külső erők kezdenek hatni rá, lehet lineáris és szögsebessége, és ami a legfontosabb, egy merev test tud mozogni és forogni egy fizikai motor segítségével anélkül, hogy a fizika teljes újraszámítását okozná.
Kétféle szilárd anyag létezik - hagyományos és kinematikus. A közönséges testek kölcsönhatásba lépnek egymással és a közönséges ütköztetőkkel – egyik test nem tud áthaladni a másikon. A kinematikai testek egyszerűsített szimulációs szabályokat követnek – semmilyen külső erő nem hat rájuk, beleértve a gravitációt sem. Bármit szabadon átélhetnek.
Ha nem kár tárgyakat a fizikai motor irányítása alá adni - használjon közönséges merev testeket. Például, ha gyönyörűen kell köveket legurítani egy szikláról. Ha szkriptjei vagy animátorai közvetlenül vezérlik az objektumot, használjon kinematikus testeket, így nem kell folyamatosan foglalkoznia a motorral és a véletlenszerű objektumok ütközésével. Például, ha van egy animált karaktere vagy egy irányított rakétája, amely valamivel érintkezve felrobban.

3. Ha az objektum merev test, akkor a merevtest módszerekkel kell mozognia és forognia.

Felejtsd el, hogy közvetlenül "egy objektumon hívd meg a Transformot, miután egy ütközőt hozzáadtál hozzá. Mostantól fogva a Transform az ellenséged és a teljesítménygyilkos. Mielőtt beírnád a transform.position = ... vagy a transform.eulerAngles = ... parancsot, mondd ki ezt a mondatot: „Most már teljesen világosan értem, mit csinálok, meg vagyok elégedve a fékekkel, amiket ez a vonal fog okozni.” Ne feledkezzünk meg a hierarchikus összefüggésekről: ha hirtelen elmozdítunk egy merev testeket tartalmazó tárgyat, a fizika újraszámításra kerül.

A merev testszabályozásnak három szintje van:

- A legmagasabb és ezért természetes szint az erők által van. Ezek az AddForce és az AddTorque metódusok. A fizikai motor figyelembe veszi a test tömegét, és helyesen számítja ki a kapott sebességet. A testek minden kölcsönhatása ezen a szinten megy végbe.
- Átlagos szint - sebességváltás. Ezek a sebesség és a szögsebesség tulajdonságai. Ezek alapján kiszámítják azokat az erőket, amelyek a testekre kölcsönhatásuk során hatnak, és nyilvánvalóan a következő pillanatban elfoglalt helyzetüket. Ha egy merev testnek nagyon alacsony a sebessége, akkor az erőforrások megtakarítása érdekében "elalszik".
- A legalacsonyabb szint - közvetlenül az objektum koordinátái és a térben való tájolása. Ezek a MovePosition és MoveRotation metódusok. A fizikai számítás következő iterációjánál (ez azért fontos, mert minden következő metódushívás egy kereten belül felváltja az előző hívását) új pozícióba teleportálják az objektumot, ami után az ugyanúgy él, mint korábban. A mi játékunkban ezt a szintet használjuk, és csak azt, mert teljes irányítást biztosít az objektum felett.

Mi marad hátra? Kapcsolja be/ki az objektumot, és nagyítson. Nem tudom, van-e mód egy objektum átméretezésére anélkül, hogy a motort összezavarná. Teljesen lehetséges, hogy nem. Az objektum kikapcsolása fájdalommentes, bekapcsolása pedig... igen, a fizika újraszámítását okozza a bekapcsolt objektum közelében. Ezért próbáljon meg ne tartalmazzon túl sok objektumot egyszerre, húzza ki időben ezt a folyamatot, hogy a felhasználó ne vegye észre.

Van egy törvény, ami nem befolyásolja a teljesítményt, de befolyásolja a teljesítményt: a merev test nem lehet egy merev test része. A szülőobjektum dominál, így a gyermek vagy mozdulatlanul fog állni a szülőhöz képest, vagy kiszámíthatatlanul és helytelenül viselkedik.

Érdemes megemlíteni a Unity egy másik, nem fizikai jellemzőjét is: az objektumok dinamikus létrehozása és törlése Példányosítási/Megsemmisítési metódusokkal ÖRÜLTSÉGESEN lassú. Félek elképzelni is, mi zajlik a motorháztető alatt az objektum létrehozása közben. Ha valamit dinamikusan kell létrehoznia és törölnie - használja a gyárakat, és töltse fel őket a szükséges objektumokkal a játék betöltése során. Utolsó megoldásként a példányosítást kell hívni - ha a gyárban hirtelen kifogynak a szabad objektumok, és örökre felejtsd el a Destroyt - mindent, ami létrejött, újra fel kell használni.

Jogszabályok alkalmazása a gyakorlatban

(ez a rész tartalmazza a játék és annak jellemzői létrehozásának gondolatmenetét)

A szintnek nyilvánvalóan forognia és mozognia kell.
Könnyítsük meg életünket örökre azzal, hogy a szint - a repülőgép - forgástengelyét a koordináták origójába helyezzük. Most kiszámolhatjuk egy pont távolságát a pont koordinátavektorának hosszának kiszámításával. Apróság, de szép.
Az objektumok kooperatív mozgása könnyen megvalósítható a Unity objektumhierarchiáján keresztül, mivel a gyerekek a szülő részei. Például a leírt szintstruktúra logikailag a következőképpen valósul meg:
- Forgástengely
-- Szint
- - - 1. szegmens
- - - - 1. blokk (ütköző)
- - - - ...
----N. blokk
- - - 2. szegmens...
- - - 3. szegmens...
- - - 4. szegmens...
(A szintobjektum nélkül is megteheti)

A tengelyen lévő script adatokat kap a giroszkóptól, és beállítja a megfelelő szöget... És azonnal sok szabályt sért, mert a forgás a hierarchián keresztül átkerül az ütközőkhöz, amitől a fizikai motor megőrül. A tengelyt merev testté kell tenni, és a megfelelő módszerrel el kell forgatni. De mi a helyzet a nívós mozgással? Nyilvánvalóan a forgástengely és a szintobjektum nem fog elmozdulni, minden szakaszt külön-külön kell mozgatni, különben a végtelenség problémájával állunk szemben. Ez azt jelenti, hogy a szegmenseknek merev testeknek kell lenniük. De már van egy merev testünk magasabban a hierarchiában, és egy merev test nem lehet egy merev test része. A logikus és elegáns hierarchia nem illik, mindent kézzel kell elvégezni - mind a forgatást, mind a fordítást, anélkül, hogy tárgyat használna a forgástengelyhez. Készülj fel erre, ha egyedi játékfunkciókkal rendelkezel.

Ha mindenképpen közvetlenül kell mozgatnia a szegmenseket, akkor el kell forgatnia őket. A fő nehézséget az jelenti, hogy a Unity fizikai motorban nincs „forgatj egy objektumot tetszőleges pont körül” módszer (a Transformnak megvan, de ne essünk kísértésbe). Csak "forog a központja körül". Ez logikus, mert egy tetszőleges tengely körüli forgatás egyszerre forgás és mozgás is, és ez két különböző művelet. De lehet utánozni. Először a szegmenst a saját tengelye körül forgatjuk, majd a „saját tengely” koordinátáit forgatjuk a repülőgép körül. Tekintettel arra, hogy a gép az origónál van, még az iskolai geometriára sem kell emlékezni és a Wikipédiára menni, a Unityben már minden megvan. Elegendő a forgásszöget kvaternióvá alakítani és megszorozni a pont koordinátáival. Erről egyébként pont a cikk írásakor tudtam meg, előtte forgatási mátrixot használtam.

Vannak ellenségeink, akik belenyomják a gépet a falba, abban a reményben, hogy megölnek. Van egy pajzs, ami eltaszítja a repülőt a falaktól, segíti a túlélést. Ezt triviálisan valósítják meg - van egy eltolási vektor, amelyet minden egyes szegmens koordinátáihoz minden képkockában hozzáadnak, és utána visszaállítják. Bárki, aki meg akarja rúgni a repülőgépet, egy speciális módszerrel elhagyhatja a rúgás vektorát, amely hozzáadódik ehhez az elmozdulási vektorhoz.

Végül a szegmens, minden képkocka valós koordinátáit a szint mozgásvezérlő központja számítja ki, valahogy így:
Vector3 pozíció = segment.CachedRigidbody.position; Vector3 deltaPos = Time.deltaTime * Vector3.left * settings.Speed; segment.truePosition = Quaternion.Euler(0, 0, deltaAngle) * (pozíció + deltaPos + mozgáseltolás);
A regeneráció során a szegmensek pontos rögzítéséhez szükséges összes számítás és mankó után a segment.truePosition elküldésre kerül a szegmens merev testének MovePosition metódusába.

következtetéseket

Milyen gyorsan működik mindez? A régi zászlóshajókon - Nexus 5 és LG G2 - a játék 60 FPS-sel repül, alig észrevehető csökkenéssel, amikor új ütköztetőket kapcsolnak be a szegmensgenerálás során (ez elkerülhetetlen, és semmiképpen sem kerülhető el), és kiszorítja a férgeket a gépből. földet (halmozhatsz valami poklot, hogy megkerüld, de most a harmadik törvény szándékos megsértése történt). A 40 stabil FPS minden olyan giroszkópos eszközt kiad, amivel találkoztunk. Minden törvény ismerete és figyelembevétele nélkül a teljesítmény finoman szólva is nem volt kielégítő, a telefonok pedig túlmelegedtek. Olyannyira, hogy arra gondoltam, írok egy saját, egyszerű speciális motort a 2D fizikához. Szerencsére a Unity fizika elég rugalmasnak bizonyult ahhoz, hogy minden probléma megkerülhető és létrehozható legyen egyedi játék, elég volt pár hét kísérletezés.

Most, ismerve a Unity fizikai motor összes fő buktatóját, gyorsan klónozhatja játékunkat, tönkretéve három szegény diák álmait, életét és az emberiségbe vetett hitét. Remélem, ez a cikk sok időt takarít meg a jövőben, és segít megtalálni a produktív fizika törvényeinek nem túl nyilvánvaló megsértését projektjei során.

Olvassa el a dokumentációt és kísérletezzen, még akkor is, ha egyszerű és intuitív eszközöket használ.