Programming Isang Laro Sa Pagkakaisa: Gabay ng Isang Baguhan

Ang gabay na ito ay magagamit upang i-download bilang isang libreng PDF. I-download ang file na ito ngayon . Huwag mag-atubiling kopyahin at ibahagi ito sa iyong mga kaibigan at pamilya.

Ang isang nakakagulat na tampok ng ekonomiya sa internet ay ang pagtaas ng mga indie videogame. Sa sandaling ang eksklusibong domain ng libong-tao, multi-milyong dolyar na triple-A studio, isang bilang ng mga toolet ang binuo na nagdadala ng mga modernong mapagkukunan sa pag-unlad ng laro sa mga kamay ng mga indibidwal o maliit, ad-hoc na koleksyon ng mga programmer at taga-disenyo. Tinalakay na namin dati ang pinakamahusay na mga laro sa indie, kaya tiyaking suriin mo ang mga iyon para sa ilang inspirasyon kung ano ang maaaring makamit sa mga tool tulad ng Unity.

Ang mga koponan sa pag-unlad na laro ng indie ay nagpakita ng isang liksi at pagpaparaya sa peligro na, sa maraming mga kaso, pinapayagan silang itulak ang pagbabago ng gameplay nang mas mabilis kaysa sa kanilang malaking mga katapat sa badyet. Ang isang bilang ng mga nakakagulat na matagumpay na pamagat ng indie ay nag-premiere sa mga nagdaang taon, kasama ang Minecraft , Limbo , at Super Meat Boy , at kahit na hindi mo kailangang kasanayan upang makagawa ng mga larong ito, maaari kang gumawa ng isang laro gamit ang Buildbox.

Sa mabilis na umuusbong na tanawin ng pag-unlad ng laro ng indie, Pagkakaisa ay lumitaw bilang isang bagay ng isang pamantayang de-facto: ang mababang gastos, kadalian sa paggamit, at malawak na tampok na tampok na ginagawang perpekto para sa mabilis na pag-unlad ng laro. Ang pagkakaisa ay napaka-kakayahang umangkop, na maaari mo kahit na gumawa ng iyong sariling pasadyang mga Controller ng laro na may kaunting DIY alam kung paano!

Kahit na ang malalaking studio tulad ng CCP (Developers ng Eve Online ) gamitin ito para sa mabilis na pag-prototyp na mga konsepto ng laro. Nagbibigay ang Unity ng isang 'game engine sa isang kahon' - isang physics at rendering engine na may mga kawit para sa maraming mga wika sa pag-script, na nababagay sa halos anumang uri ng videogame.

Habang ang Unity ay nagbibigay ng isang visual editor para sa pagmamanipula ng kapaligiran sa laro, ang Unity ay hindi isang tool na tagalikha ng laro na 'zero programming'. Kinakailangan ka nitong mag-program upang makabuo ng mga resulta, ngunit nagbibigay din sa iyo ng isang mas nababaluktot at makapangyarihang tool kaysa sa anumang programang 'game maker' na posibleng magawa.

Hindi gagawin ng pagkakaisa ang trabaho para sa iyo, ngunit binabaan nito ang hadlang sa pagpasok nang malaki. Simula nang ganap mula sa simula gamit ang C ++ at OpenGL, maaari itong tumagal ng ilang araw upang maabot ang puntong talagang mayroong isang nai-render na onscreen. Gamit ang Unity, tatagal ng halos sampung segundo. Inilalagay ng pagkakaisa ang mga pangunahing elemento ng paglikha ng laro sa mga kamay ng mga programmer ng baguhan sa isang mabilis, madaling maunawaan na paraan.

Ngayon ay gagabayan kita sa lahat ng kailangan mong malaman upang makagawa ng isang laro sa Unity, na pinaghiwalay sa sampung pangunahing mga kabanata:

§1 – Mga Bersyon ng Pagkakaisa

§2 – Pag-install ng Unity

§3 – Isang Maikling Panimula sa Paradigm na Nakatuon sa Bagay

§4 – Mga Pangunahing Kaalaman sa Unity

§5 – Halimbawa: Pangunahing Mga Sangkap ng isang Laro

§6 – Scripting in Unity

§7 – Halimbawa: Scripting Pong

§8 – Pagtuklas sa Dokumentasyon / Pag-aaral Nang Higit Pa

§9 – Pagbuo ng Iyong Laro / Pagsasama sa isang Mag-iisang Application

§10-Mga Tala sa Pagsara

1. Mga Bersyon ng Pagkakaisa

Ang pagkakaisa ay nagmumula sa dalawang pangunahing lasa: ang pro bersyon at ang libreng bersyon. Mayroong a bilang ng mga pagkakaiba , ngunit, sa malawak na pagsasalita, sinusuportahan ng pro bersyon ang isang bilang ng mga pagpapahusay sa visual (tulad ng real-time na mga soft shadow at post-processing), at isang malaking bilang ng mga medyo menor de edad na tampok na lubos na nakakatulong para sa mas kumplikadong mga laro.

Sinabi na, para sa karamihan sa mga simpleng laro na maaaring gusto mong buuin, ang libreng bersyon ng Unity ay perpektong sapat. Masisira namin ang mga pangunahing pagkakaiba sa ibaba nang mas detalyado para sa mga interesado.

1.1 Pagpepresyo

Ang libreng bersyon ng Unity ay, syempre, libre. Gayunpaman, mayroong ilang mga limitasyon: ang libreng bersyon ng Unity ay hindi maaaring lisensyado sa anumang kumpanya na may taunang kita na higit sa $ 100,000 . Habang ang mga nasabing samahan ay nasa labas ng saklaw ng gabay na ito, kung pinaghihinalaan mo na maaari kang maging isang samahan, marahil ay matalino na mag-spring para sa Pro bersyon.

Ang Pro bersyon ng Unity ay $ 75 isang buwan, o $ 1500 para sa isang permanenteng lisensya, at walang mga limitasyon sa kung ano ang maaari mong gawin sa mga larong nilikha kasama nito. Mayroon ding magagamit na 30-araw na libreng pagsubok, na gagamitin namin para sa gabay na ito, upang mabigyan ka ng kumpletong isang pangkalahatang ideya ng mga magagamit na tampok hangga't maaari. Ang isang isang taong lisensya ng mag-aaral ay magagamit din sa pamamagitan ng Pag-aaral para sa $ 129 .

1.2 Mga Tampok

Maraming mga tampok na wala sa libreng bersyon ng Unity. Gayunpaman, ang pinakamahalagang pagkakaiba ay ang mga sumusunod: ang libreng bersyon ng Unity ay walang isang bilang ng mga pagpipilian sa pag-render na nagbibigay-daan para sa mas mahusay na hitsura, mas mabilis na pagpapatakbo ng mga laro (suporta sa LOD, pag-proseso ng post-space post, advanced shaders, real-time soft mga anino, at ipinagpaliban ang pag-render). Kulang din sa buo sistema ng mekanismo ng mekanismo , at ilang mga tool sa AI.

Sa pangkalahatan, para sa mga kumplikado, malakihang proyekto, o proyekto kung saan mahalaga ang grapikong pagganap, sulit ang pro bersyon. Ginagamit ko ang pro bersyon, dahil bumubuo ako ng mga virtual reality game para sa Oculus Rift, at kinakailangan ang suporta sa post-processing na space-space upang maayos na makipag-ugnay sa headset.

2. Pag-install ng Unity

Ang pagkakaisa ay prangka upang mai-install. Maaari mong i-download ang maipapatupad mula sa pagkakaisa3d.com/get-unity/download .

Kapag na-download na, patakbuhin ito, at pagkatapos ay sundin ang mga tagubilin ng installer. Kapag natapos ang pag-install, lilitaw ang isang window na pinamagatang 'buhayin ang iyong lisensya ng Unity'. Lagyan ng tsek ang kahon na may markang 'buhayin ang isang libreng 30-araw na pagsubok ng Unity Pro' at pagkatapos ay 'OK'.

Binabati kita! Mayroon ka na ngayong 30 araw na pagsubok sa Unity Pro. Kapag nag-expire ang pagsubok, kung hindi mo nais na bilhin ang pro bersyon, maaari kang lumipat sa libreng bersyon at mapanatili ang iyong mayroon nang nilalaman.

kung paano makakuha ng mas maraming google survey

3. Isang Maikling Panimula sa Paradigm na Nakatuon sa Bagay

Bago magsimula sa Unity, mahalagang masuri muna natin ang mga pangunahing kaalaman. Sinusuportahan ng pagkakaisa ang pareho C # at JavaScript para sa programa sa laro ; makikipagtulungan kami sa C # para sa tutorial na ito.

Una, kung hindi mo pa nai-program dati, isantabi ang tutorial na ito at gumastos ng ilang araw na pagtatrabaho sa pamamagitan ng Microsoft C # Pangunahing Wika hanggang sa maging komportable ka sa paggamit ng wika para sa mga simpleng gawain.

Kung nais mo ang isang bagay na medyo kakaiba sa C # (ngunit hindi kinakailangang isang wika na maaari mong gamitin sa Unity), pagkatapos ay tingnan ang aming gabay sa anim na pinakamadaling wika ng pagprograma para sa mga nagsisimula.

Kung na-program mo dati sa isang pautos o pang-object na wika tulad ng C o Java, i-skim ang panimulang aklat at pamilyar sa kung paano naiiba ang C # sa ibang mga wikang ginamit mo sa nakaraan. Alinmang paraan, huwag magpatuloy sa tutorial hanggang sa komportable ka sa paglutas ng mga simpleng problema sa C # (halimbawa, kung hihilingin ko sa iyo na magsulat ng isang programa na naglilimbag ng unang daang punong numero, dapat mong maisulat ang program na iyon nang walang pagkonsulta sa Google).

Ang pinakamahalagang konsepto na dapat maunawaan dito ay ang paradigma na nakatuon sa object (dinaglat bilang BUKSAN ). Sa mga object na nakatuon sa wika, ang mga programa ay nahahati sa mga yunit na ginagamit na tinatawag Mga Bagay . Ang bawat bagay ay may sariling mga pribadong variable at pag-andar. Ang mga pagpapaandar na tumutukoy sa object ay tinatawag paraan .

Ang ideya dito ay modularity: sa pamamagitan ng pagkakaroon ng bawat bagay na nakahiwalay, at pagpuwersa sa iba pang mga bagay na makipag-ugnay dito sa pamamagitan ng mga pamamaraan nito, maaari mong bawasan ang bilang ng mga posibleng hindi sinasadyang pakikipag-ugnay - at, sa pamamagitan ng pagpapalawak, mga bug. Maaari ka ring lumikha ng mga bagay na maaari mong muling magamit sa ibang pagkakataon nang walang pagbabago. Sa Unity, itatayo mo ang mga bagay na ito at ikakabit sa kanila mga entity ng laro (kaninong pamamahala ang pamamahalaan nila).

Ang mga bagay ay itinatag mula sa mga klase : ang isang klase ay isang file lamang na naglalagay ng kahulugan ng iyong object. Kaya, kung nais mo a mook bagay na humahawak sa AI para sa isang kaaway sa iyong laro, magsusulat ka ng isang klase na 'Mook', at pagkatapos ay ilakip ang file na iyon sa bawat nilalang ng kaaway. Kapag pinatakbo mo ang iyong laro, ang bawat kaaway ay bibigyan ng isang kopya ng object na 'Mook'.

Ang paglakip ng isang bagong script sa isang bagay ay ganito ang hitsura:

Una, piliin ang bagay at pumunta sa Inspektor . Mag-click sa Magdagdag ng Component pindutan

Pumunta sa bagong script , ipasok ang gusto mong pangalan, at i-click lumikha at idagdag .

Ngayon mayroon kang isang bagong script na maaari mong i-edit sa pamamagitan ng pag-double click dito!

Ang isang file ng klase ay ganito ang hitsura:

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

Tanggalin natin ito:

Paggamit ng UnityEngine: Sinasabi ng linyang ito ang C # na nais naming gamitin ang mga aklatan ng Unity, na nagpapahintulot sa amin na kumonekta sa engine ng laro ng Unity.
Public class na Mook: MonoBehaviour: Inilahad ng linyang ito ang klase at ang pangalan nito - mook .
Pribadong kalusugan sa float: Ito ay nagdedeklara ng isang variable ng pribadong klase (na mababago lamang mula sa loob ng klase). Ang variable ay binibigyan ng isang halaga sa Magsimula .
Void Start (): Ito ay nagdedeklara ng isang pamamaraan na tinawag Magsimula . Ang pagsisimula ay isang espesyal na pamamaraan na tumatakbo nang isang beses lamang, kapag ang laro ay unang inilulunsad.
Void Update (): Ang pag-update ay isa pang espesyal na pamamaraan, na tumatakbo sa bawat frame. Ang karamihan sa iyong lohika sa laro ay pupunta dito.
// kung makaharap mo ang manlalaro sa daan, patayin mo siya: Ang linyang ito ay isang komento (ang anumang linya na nagsisimula sa isang dobleng slash ay hindi pinansin ng C #). Ginagamit ang mga puna upang ipaalala sa iyong sarili kung ano ang ginagawa ng mga partikular na piraso ng code. Sa kasong ito, ginagamit ang komentong ito upang tumayo para sa isang mas kumplikadong bloke ng code na talagang ginagawa ang inilalarawan ng komento.

Kasama ni Magsimula at Update , maaari mong patunayan ang iyong sariling mga pamamaraan na may halos anumang pangalan. Gayunpaman, ang mga pamamaraan na iyong nilikha ay hindi tatakbo maliban kung sila ay tinawag. Ideklara natin ang isang pamamaraan para sa isang hipotesis na klase na tinawag magdagdagTwoNumber na nagdaragdag ng dalawang numero nang magkasama:

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

Ito ay nagdedeklara ng isang pampublikong (naa-access sa iba pang mga bagay) na paraan na nagbabalik ng isang float, na tinawag magdagdagTwoNumber , na tumatagal ng dalawang floats bilang input (tinatawag sa at b ). Pagkatapos ay ibabalik nito ang kabuuan ng dalawang halaga bilang output nito.

Ang pagtawag sa pamamaraang ito mula sa loob ng parehong klase (sabihin, mula sa loob Update ) ganito ang hitsura:

float result = addTwoNumbers(1, 2);

Ang pagtawag sa pamamaraan mula sa isa pang klase ay pareho:

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

Muli, lumilikha lamang ito ng isang halimbawa ng aming klase, ina-access ang naaangkop na pamamaraan at pinapakain ito ng mga numero na nais naming idagdag, pagkatapos ay iniimbak ang resulta sa resulta . Simple

Kung ang iyong script ay nakakabit sa isang bagay na may mga espesyal na katangian (tulad ng isang maliit na butil na emitter) na hindi ma-access sa ilalim ng normal na hanay ng mga parameter ng GameObject, maaari mong piliing tratuhin ito bilang isang iba't ibang uri ng entity ng laro sa pamamagitan ng paggamit ng GetComponent pamamaraan

Ganito ang hitsura ng syntax:

GetComponent().Play();

Kung alinman sa mga ito ay hindi pamilyar sa iyo, bumalik at dumaan sa C # primer. Makakatipid ito sa iyo ng maraming pagkabigo sa pagpapatuloy namin.

4. Mga Batayan sa Unity

Sa seksyong ito, gagana kami sa aming pangunahing mekanika ng Unity engine. Ang daloy ng trabaho sa Unity ay tulad nito:

Lumikha ng isang nilalang upang maghatid ng isang papel sa laro (blangko Mga GameObject maaaring magamit para sa mga abstract na lohikal na gawain).
Sumulat o maghanap ng isang file ng klase, at idagdag ito sa nilalang bilang isang script (gamit ang Magdagdag ng Component pindutan sa inspektor tingnan
Takbo > pagsusulit > pag-debug > ulitin hanggang sa gumana ito at magpatuloy sa susunod na elemento ng laro.

Ang pagkakaisa ay may kasamang isang bilang ng mga pangunahing tab na tingnan na maaaring mailatag sa iba't ibang mga paraan ayon sa panlasa ng gumagamit. Ang malaking limang ay:

Laro: nagpapakita ng isang tumatakbo na halimbawa ng laro na maaari mong makipag-ugnay at subukan.
Eksena: ay nagbibigay ng isang static, mae-edit na bersyon ng mundo ng laro .
Inspektor: ay nagbibigay-daan sa iyo upang baguhin ang mga indibidwal na entity sa mundo ng laro sa pamamagitan ng pagpili sa kanila sa editor tab
Proyekto: Pinapayagan kang mag-browse sa mga file ng proyekto at i-drag ang mga modelo, materyales, at iba pang mga mapagkukunan sa editor tab upang ilagay ang mga ito sa mundo ng laro.
Hierarchy: ipinapakita ng tab na ito ang lahat ng mga bagay sa mundo, na nagbibigay-daan sa iyo upang makahanap ng mga malalayong bagay sa eksena, at mga magulang na entity sa isa't isa sa pamamagitan ng pag-click at pag-drag.

Tingnan ang diagram sa ibaba para sa mga lokasyon ng lahat ng mga bagay na ito:

4.1 Mga Unity Entity

4.1.1 Meshes

Meshes ang daan 3D geometry ay kinakatawan sa Unity. Maaari mong gamitin ang built-in na Unity primitive mga bagay (cubes, spheres, silindro, atbp), o i-import ang iyong sariling mga modelo ng 3D mula sa isang pagmomodel na tulad ng Blender o Maya . Sinusuportahan ng Unity ang iba't ibang mga format na 3D, kasama ang .fbx , at .3ds .

Ang pangunahing mga tool para sa pagmamanipula ng meshes ay ang mga pindutan ng pag-scale, pag-ikot, at pagsasalin sa itaas na kaliwang sulok ng interface. Ang mga pindutan na ito ay nagdaragdag ng mga icon ng kontrol sa mga modelo sa view ng editor, na maaaring magamit upang manipulahin ang mga ito sa kalawakan. Upang baguhin ang pagkakayari ng texture o pisika ng isang bagay, piliin ang mga ito at gamitin ang inspektor tingnan upang pag-aralan ang materyal at tigas mga elemento.

4.1.2 Mga Elemento ng GUI

Maaaring ipakita ang tradisyonal na GUI sprite at teksto gamit ang Teksto ng GUI at ang GUI Texture Mga GameObject sa editor. Gayunpaman, isang mas matatag at makatotohanang paraan upang hawakan ang mga elemento ng UI ay ang paggamit ng 3D text at Quad Mga GameObjects (na may mga transparent na pagkakayari at isang walang ilaw na shader) upang ilagay ang mga elemento ng HUD sa mundo ng laro bilang mga nilalang.

Nasa hierarchy tingnan, ang mga elemento ng gameplay na ito ay maaaring ma-drag papunta sa pangunahing camera upang gawin silang mga bata, na tinitiyak na ilipat at paikutin nila gamit ang camera.

Ang mga elemento ng GUI (teksto at mga texture) ay maaaring magkaroon ng laki at sukat na nabago gamit ang mga nauugnay na patlang sa tab na inspektor.

4.1.3 Mga Kagamitan

Ang mga materyales ay mga kumbinasyon ng mga texture at shader, at maaaring mai-drag nang direkta sa mga object ng laro mula sa tab ng proyekto. Ang isang malaking bilang ng mga shader ay may Unity Pro, at maaari mong ayusin ang texture na nakakabit sa kanila gamit ang inspector tab para sa isang bagay na inilapat nila.

Upang mag-import ng isang texture, i-convert ito sa a .jpg , .png , o .bmp , at i-drag ito sa mga assets folder sa ilalim ng direktoryo ng proyekto ng Unity (na lilitaw sa Ang Aking Mga Dokumento bilang default). Pagkatapos ng ilang segundo, lilitaw ang isang loading bar sa editor. Kapag natapos ito, mahahanap mo ang imahe bilang isang texture sa ilalim ng proyekto tab

4.1.5 Mga Ilaw

Ang mga ilaw ay Mga GameObject aling proyekto ang ningning sa buong mundo. Kung walang mga ilaw sa iyong eksena, ang lahat ng mga polygon ay iginuhit sa parehong antas ng ningning, na nagbibigay sa mundo ng isang patag, hugasan na hitsura.

Ang mga ilaw ay maaaring nakaposisyon, paikutin, at magkaroon ng maraming mga panloob na katangian na maaari mong ipasadya. Ang kasidhian kinokontrol ng slider ang ningning ng ilaw, at ang saklaw kinokontrol kung gaano kabilis maglaho.

Ang mga alituntunin sa tanawin ng eksena ipakita sa iyo ang maximum na saklaw ng pag-iilaw. Maglaro kasama ang parehong mga setting upang makamit ang nais na epekto. Maaari mo ring ayusin ang kulay ng ilaw, ang pattern ( cookie ipinakita sa ibabaw ng ilaw ay itinuro, at kung anong uri ng flare ang lilitaw sa onscreen kapag direktang tumitingin sa ilaw. Maaaring gamitin ang cookie upang peke ang mas makatotohanang mga pattern ng ilaw, lumikha ng mga dramatikong maling anino, at gayahin ang mga projector.

Ang tatlong pangunahing uri ng ilaw ay lugar , punto , at direksyon .

Spot lights magkaroon ng isang lokasyon sa 3D space at light ng proyekto lamang sa isang direksyon sa isang kono ng variable anggulo. Mabuti ang mga ito para sa mga flashlight, searchlight, at, sa pangkalahatan, bibigyan ka ng mas tumpak na kontrol sa pag-iilaw. Ang mga ilaw ng spot ay maaaring magpakita ng mga anino.

Mga ilaw ng point magkaroon ng isang lokasyon sa 3D space, at pantay na mag-ilaw sa lahat ng direksyon. Ang mga ilaw na point ay hindi nagpapahiwatig ng mga anino.

Mga ilaw sa direksyon , sa wakas, ay ginagamit upang gayahin ang sikat ng araw: naglalabas sila ng ilaw sa isang direksyon na parang mula sa walang katapusang malayo. Ang mga ilaw na nakadidirekta ay nakakaapekto sa bawat bagay sa eksena, at maaaring makagawa ng mga anino.

4.1.6 Mga Sistemang Particle

SA Sistema ng maliit na butil ay isang GameObject na bumubuo at kumokontrol sa daan-daang o libu-libong mga particle nang sabay-sabay. Ang mga maliit na butil ay maliit, na-optimize na mga bagay na 2D na ipinapakita sa 3D space. Gumagamit ang mga system ng particle ng pinasimple na pag-render at physics, ngunit maaaring ipakita ang libu-libong mga entity sa real time nang hindi nauutal, ginagawang perpekto para sa usok, sunog, ulan, sparks, magic effects, at marami pa.

Mayroong maraming mga parameter na maaari mong i-tweak upang makamit ang mga epektong ito, at maaari mong ma-access ang mga ito sa pamamagitan ng pangingitlog ng isang sistema ng maliit na butil sa ilalim ng editor ng sangkap > pagpili ng system ng maliit na butil > pagbubukas ng tab ng inspektor . Maaari mong baguhin ang laki, bilis, direksyon, pag-ikot, kulay, at pagkakayari ng bawat maliit na butil, at itakda ang karamihan sa mga parameter na iyon upang baguhin din sa paglipas ng panahon.

Sa ilalim ng pagkakabanggaan katangian, kung pinagana mo ito at itakda ang puwang ng simulation sa mundo makakakuha ka ng mga maliit na butil na mababanggaan ng mga bagay sa mundo, na maaaring magamit para sa isang bilang ng mga makatotohanang epekto ng maliit na butil, kabilang ang ulan, paggalaw ng tubig, at mga spark.

5. Halimbawa: Pangunahing Mga Elemento ng isang Laro

Para sa tutorial na ito, gagawa kami ng isang simpleng laro ng Pong - isang bagay na sakop namin ng maraming beses sa DIY dati:

Arduino Classic Pong
Arduino OLED Pong

Sa seksyong ito, susuriin namin ang pag-aayos ng mga pangunahing elemento - ang tutorial sa scripting ay darating mamaya.

Una, paghiwalayin natin ang laro ng Pong sa mga pangunahing sangkap nito. Una, kailangan namin ng dalawang sagwan, at isang bola. Ang bola ay lilipad sa offscreen, kaya gugustuhin namin ang isang mekanismo upang i-reset ito. Gusto rin namin ng teksto na ipakita ang kasalukuyang marka, at, alang-alang sa pagpapakita sa iyo ng lahat ng mga pangunahing elemento ng Unity, gugustuhin namin ang isang magarbong epekto ng maliit na butil kapag na-hit mo ang bola. Ang buong laro ay kailangang malabong naiilawan.

Naghiwalay iyon sa a object ng bola (isang globo), a spawner , dalawang paddle props na may mga emitter ng maliit na butil nakalakip, a Entity ng 3D-text , at a ilaw ng ilaw . Para sa tutorial na ito, gagamitin namin ang default na materyal na pisiko talbog , kasama bounce pagsamahin itakda sa magparami . Narito kung ano ang hitsura ng pag-set up, sa sampung mga screenshot:

Una, lumikha ng a cube prop para sa sagwan.

Sukatin ito nang naaangkop, doblehin ito , at lagyan ng a globo sa pagitan ng mga sagwan para sa bola.

Pagkatapos, lumikha ng a Bagay na 3DText at sukatan at posisyon tama, binabago ang laki ng font katangian upang makakuha ng isang mas kaunting pixelated na imahe.

Susunod, lumikha ng dalawa mga system ng maliit na butil , piliin ang mga katangiang nais mo, at ilakip ang mga ito sa mga sagwan.

Susunod, gugustuhin mo posisyon at paikutin ang camera upang mai-frame nang tama ang eksena. Habang ang camera ay napili, maaari mong makita ang isang maliit na preview ng view ng camera sa ibabang kanang sulok.

Bago namin tapusin, kailangan naming lumikha ng dalawang karagdagang mga cube upang maging mga bumper, upang maiwasan ang bola mula sa pag-bounce sa labas ng lugar ng laro. Maaari nating gawin silang hindi nakikita sa pamamagitan ng pag-uncheck ng tagapagbigay ng mata nasa tab ng inspektor .

Kung na-hit ang play, maaari mo na ngayong makita ang mga pangunahing elemento ng aming laro na inilatag. Wala pa silang gagawin, ngunit makakarating tayo doon!

Ngayon na nakuha namin ang pag-set up na iyon, pag-uusapan natin ang tungkol sa kung ano ang kasangkot sa pag-script ng mga elementong ito upang makagawa ng isang laro.

6. Pag-iskrip sa Pagkakaisa

Kapag mayroon kang isang script na nakakabit sa isang object, maaari mo itong baguhin sa pamamagitan ng pag-double click dito sa inspektor . Bubukas ito MonoDevelop , ang default na kapaligiran sa pag-unlad para sa Unity. Sa kakanyahan, ang Monodevelop ay isang text editor na may mga tampok na partikular na na-optimize patungo sa pag-program.

Ang mga keyword at komento ay nai-highlight sa bughaw at berde , at lumitaw ang mga halagang may bilang at mga string neto . Kung nagamit mo na Eclipse o iba pang mga IDE, ang MonoDevelop ay halos kapareho. Kaya mo magtayo ang iyong mga script mula sa loob ng editor, upang suriin ang mga error sa syntax, tulad nito:

Sa pangkalahatan, upang makaugnayan ang iyong script sa Unity, kakailanganin mong mag-refer ng mga elemento na taglay ng object na hawak ang script (maaari mong makita ang isang listahan ng mga elementong ito sa ilalim ng inspektor tab kapag napili ang nauugnay na bagay). Maaari kang tumawag sa mga pamamaraan o magtakda ng mga variable para sa bawat isa sa mga elementong ito upang maisagawa ang mga pagbabagong nais mo.

Kung nais mo ang isang script sa isang bagay na makakaapekto sa mga pag-aari ng ibang object, maaari kang lumikha ng isang walang laman GameObject variable sa iyong script, at gamitin ang inspektor upang italaga ito sa ibang bagay sa eksena.

Ang isang listahan ng mga elemento na maaaring mayroon ang isang bagay ay ang mga sumusunod (kinuha mula sa pagtingin ng inspektor ng isa sa aming mga sagwan sa nabanggit na halimbawa):

Magbago
Cube (Mesh Filter)
Box Collider
Mesh Renderer

Ang bawat isa sa mga aspetong ito ng bagay ay maaaring maimpluwensyahan mula sa loob ng isang script. Susunod, titingnan natin nang eksakto kung paano.

6.1 Pagbabago

Kinokontrol ng mga pagpapaandar ang pagbabago para sa isang GameObject in Unity ang mga pisikal na parameter ng bagay na iyon: nito sukatan , nito posisyon , at nito oryentasyon . Maaari mong ma-access ang mga ito mula sa loob ng isang script na tulad nito:

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

Sa mga halimbawa sa itaas, ang mga pinangalanang variable ay ng mga uri na tinukoy sa mga pangalan. Mayroong ilang mga pangunahing detalye dito: ang posisyon at sukat ay, tulad ng iyong inaasahan, na nakaimbak bilang Mga Vector3 . Maaari mong ma-access ang X , AT , at MAY mga bahagi ng bawat isa (halimbawa, ibahin ang anyo.posisyon.y nagbibigay sa iyo ng distansya ng isang bagay sa itaas ng zero eroplano).

Gayunpaman, upang maiwasan gimbal lock , ang pag-ikot ay pinangangasiwaan bilang Mga Quaternion (mga vector na may apat na sangkap). Dahil hindi sinasadya ang mga quaternion na nagmamanipula ng kamay, maaari mong manipulahin ang mga pag-ikot gamit ang mga Eulerian na anggulo sa pamamagitan ng paggamit ng Quaternion.Euler paraan tulad nito:

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

Kung nais mong ilipat ang mga bagay nang maayos mula sa isang lugar patungo sa iba pa, mahahanap mo ang Slerp paraan para sa mga quaternion at vector3 na kapaki-pakinabang. Tumatagal ang Slerp ng tatlong mga argumento - ang kasalukuyang estado, ang pangwakas na estado, at ang bilis ng pagbabago, at maayos na nakikipag-interpolate sa pagitan nila sa ibinigay na bilis. Ganito ang hitsura ng syntax:

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

6.2 Nagbibigay

Ang mga pagpapaandar ng renderer sa Unity ay nagbibigay-daan sa iyo upang makontrol ang paraan ng mga ibabaw ng props na nai-render sa-screen. Maaari mong italaga ang pagkakayari, baguhin ang kulay, at baguhin ang shader at kakayahang makita ng bagay. Ganito ang hitsura ng syntax:

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

Karamihan sa mga ito ay may malinaw na pag-andar. Ginagawa ng unang halimbawa ang bagay na pinag-uusapan na hindi nakikita: isang kapaki-pakinabang na trick sa isang bilang ng mga sitwasyon. Ang pangalawang halimbawa ay nagtatalaga ng bago Kulay ng RGB (katulad, berde) sa bagay na pinag-uusapan. Ang pangatlo ay nagtatalaga ng pangunahing nagkakalat na texture sa isang bagong variable ng Texture. Ang huling halimbawa ay binabago ang shader ng materyal ng bagay sa isang bagong tinukoy na variable ng shader.

6.3 Physics

Ang Unity ay may kasamang integrated engine engine - isang bagay na ginagamit ng mga physics sandbox games. Pinapayagan kang magtalaga ng mga pisikal na katangian ng mga bagay at hayaang hawakan ang mga detalye ng kanilang simulation para sa iyo. Sa pangkalahatan, sa halip na subukang ipatupad ang iyong sariling pisika gamit ang isang libro at ang transform system, mas simple at mas matatag na gamitin ang physics engine ng Unity sa pinakamaraming makakaya.

Kailangan ng lahat ng props ng pisika mga nakabangga . Gayunpaman, ang aktwal na simulasi mismo ay pinangangasiwaan ng a tigas , na maaaring idagdag sa inspektor tingnan Ang mga rigidbodies ay maaaring kinematic o hindi mala .

Ang mga propemang physics ng kinematic ay sumalpok sa (at epekto) na mga nonkinematic physics props sa paligid nila, ngunit hindi apektado ng banggaan mismo. Ang mga static na kinematic props ay ang mga salawikain na hindi maikakalipat na mga bagay, at ang mga gumagalaw na kinematic na bagay ay ang hindi maipipigil na puwersa (para sa talaan, kapag sumalpok sila, dumadaan lamang sila sa isa't isa).

Higit pa rito, maaari mong ayusin ang angular drag ng object (kung gaano karaming enerhiya ang kinakailangan upang paikutin ito), baguhin ang masa nito, idikta kung apektado ito ng gravity o hindi, at maglapat ng mga puwersa dito.

Mga halimbawa:

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

Ang lahat ng ito ay medyo nagpapaliwanag sa sarili. Ang tanging bagay na dapat tandaan dito ay ang paggamit ng ibahin ang anyo.pasa . Ang lahat ng Vector3 ay mayroong tatlong sangkap ( .pasauna , .pataas , at . tama ) na nauugnay sa kanila, na maaaring ma-access at paikutin sa kanila ( pasulong ay ang direksyon ng asul na arrow sa editor). Ang ibahin ang anyo.pasa Ang keyword ay ang pasulong na vector para sa kasalukuyang bagay na may lakas na 1. Maaari itong i-multiply ng isang float upang lumikha ng higit na puwersa sa object. Maaari ka ring mag-refer ibahin ang anyo.up at ibahin ang anyo. tama , at tanggihan ang mga ito upang makuha ang kanilang mga kabaligtaran.

6.4 Pagkabangga

Kadalasan, kapag nagtatayo ng isang laro, nais mong ang isang banggaan upang magresulta sa ilang pagbabago-ng-estado sa iyong code, lampas sa simulation lamang ng pisika. Para sa mga ito, kakailanganin mo ng pamamaraan ng pagtuklas ng banggaan .

Mayroong isang tiyak na halaga ng prep work na kinakailangan upang makita ang mga banggaan sa Unity. Una, hindi bababa sa isa sa mga bagay sa banggaan ay nangangailangan ng a di-kinematic rigidbody nakakabit dito. Ang parehong mga bagay ay dapat na may tamang mga collider, itinakda na maging mga hindi nag-trigger. Ang kabuuang bilis ng parehong mga bagay ay dapat na sapat na mababa na talagang sila ay nagsalpukan, sa halip na lumaktaw sa isa't isa.

Kung nakuha mo ang lahat ng inaalagaan, maaari mong suriin ang banggaan sa pamamagitan ng paglalagay ng isang espesyal na pamamaraan ng pagtuklas ng banggaan sa isang script na nakakabit sa bagay na nais mong suriin ang banggaan. Ganito ang magiging hitsura ng pamamaraan:

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

Awtomatikong tatakbo ang pamamaraang ito sa unang frame na hinahawakan ng ibang bagay ang iyong object. Ang entity ng banggaan iba pa ay isang sanggunian sa bagay na na-hit mo. Maaari mong, halimbawa, sanggunian ito gameobject , tigas , at magbago mga katangiang manipulahin ito sa iba`t ibang paraan. Habang OnCollisionEnter marahil ang pinaka-karaniwang pag-andar na iyong gagamitin, maaari mo ring gamitin OnCollisionExit at OnCollisionStay (na may magkaparehong magkatulad na syntax at paggamit), na nagpapagana sa panahon ng unang frame na hihinto ka sa pagkakabangga sa isang bagay at sa bawat frame na nakabangga mo sa isang bagay, ayon sa pagkakabanggit.

Minsan, maaari ding maging kapaki-pakinabang upang gawin ang tinatawag pag-raycasting . Sa pag-raycast, isang walang katapusang manipis na linya (a sinag ) ay itinapon sa buong mundo mula sa ilang pinagmulan, kasama ang ilang vector, at, kapag may pinindot ito, ang posisyon at iba pang mga detalye ng unang banggaan ay naibalik. Ganito ang code para sa isang raycast:

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

Nagpapadala ito ng isang sinag mula sa posisyon ng kasalukuyang bagay na kasama ang -Vector3.up (diretso pababa), at maiugnay ang variable hit sa unang bagay na nabangga nito. Kapag na-hit ng iyong sinag ang isang bagay, maaari mong ma-access hit.distansya upang matukoy kung gaano kalayo ito, o hit.GameObject upang manipulahin ang bagay na iyong na-hit.

Ang mga Raycast na tulad nito ay maaaring magamit para sa mga shooter upang matukoy kung ano ang itinuro ng baril, o upang pumili ng mga bagay kapag tinitingnan sila ng camera, o para sa ilang mga estilo ng mekaniko ng paggalaw.

6.5 Pagwawasto ng Oras

Ang isang mahalagang kadahilanan na dapat tandaan kapag nagmamanipula ka ng mga bagay sa ganitong paraan ay may kinalaman sa frame rate . Hindi mahalaga kung gaano mo maingat na na-optimize, ang mga framerates ay palaging magkakaiba, at hindi mo nais na ang bilis ng iyong laro ay magkakaiba ayon. Kung may ibang nagpapatakbo ng iyong laro sa isang mas mabilis na computer kaysa sa pagbuo mo dito, hindi mo nais na tumakbo ang laro sa dobleng bilis.

Ang paraan mong pagwawasto para dito ay sa pamamagitan ng pagpaparami ng mga halaga na iyong ginagamit sa pamamagitan ng oras na kinakailangan upang maibigay ang huling frame. Ginagawa ito sa pamamagitan ng paggamit Oras.deltaTime . Mabisa nitong binabago ang bilis ng anumang variable na iyong pinapalago ang bawat frame mula sa baguhin ang bawat frame sa baguhin bawat segundo , at marahil ay dapat mong gawin ang pagbabagong ito sa anumang halagang iyong nadaragdagan o binabawasan ang bawat frame.

6.6 Mga Pinagmulan ng Audio at Nakikinig

Ngayon na natakpan namin kung paano lumikha, mag-render, at makontrol ang mga bagay, pag-usapan natin ang iba pang kahulugan na maaaring maghatid ng mga laro sa computer: lalo na, tunog . Sinusuportahan ng Unity ang dalawang uri ng tunog: 2D at 3D tunog Ang mga tunog ng 3D ay nag-iiba-iba ng kanilang dami batay sa distansya, at nagpapangit habang gumagalaw sila kaugnay sa camera; Ang tunog ng 2D ay hindi.

Ang mga tunog ng 2D ay naaangkop para sa mga voice-overs at background music, at nalalapat ang mga tunog na 3D sa mga tunog na nabuo ng mga kaganapan sa mundo. Upang mabago kung ang isang tunog ay 3D o hindi, piliin ito sa proyekto tingnan, lumipat sa inspektor tingnan at piliin ang naaangkop na pagpipilian mula sa dropdown menu, pagkatapos ay pindutin ang muling pag-import pindutan

Upang mai-play ang tunog, kakailanganin mong maglakip ng audiosource sa isang prop (ang prop na nais mong magmula ang tunog, sa kaso ng isang 3D na tunog). Pagkatapos ay kakailanganin mong buksan ang audioclip patlang at piliin ang iyong file ng tunog.

kung paano mabuhay muli ang isang patay na baterya ng laptop

Pwede mong gamitin myAudioSource.Pause () at myAudioSource.Play () upang makontrol ang mga file ng tunog. Maaari mong ayusin ang mga pag-uugali ng falloff, dami, at paglilipat ng doppler ng mga tunog sa ilalim ng inspektor tab para sa audiosource.

6.7 Input

Ang isang laro na hindi kumukuha ng anumang input mula sa gumagamit ay hindi gaanong isang laro. Mayroong maraming iba't ibang mga uri ng input na maaari mong basahin, at halos lahat sa kanila ay maa-access sa pamamagitan ng Input at KeyCode mga bagay Ang ilang mga halimbawang pahayag ng input (na may mga halagang sinusuri ang bawat frame) ay nasa ibaba.

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

Ang mga pagpapaandar ng mga linyang ito ay kadalasang nagpapaliwanag. Gamit ang tatlong uri ng sanggunian sa pag-input, maaari mong buuin muli ang mga control scheme ng karamihan sa mga modernong larong computer sa 3D.

6.8 Pag-debug ng isang Script

Sabihin nating hindi gagana ang isang script. Tulad ng sinabi ng mabuting doktor, ang mga bangup at hangup ay maaaring mangyari sa iyo. Kung mayroong mga tama na error sa syntax sa iyong C #, sa pangkalahatan ay tatanggi na tumakbo ang laro kapag na-hit mo ang pag-play, at ang ilang medyo kapaki-pakinabang na mga mensahe ng error ay ibinigay kung ikaw magtayo ang mga script mula sa loob ng editor. Tingnan sa ibaba:

Ang mga bug na ito ay karaniwang hindi ang pinakamahirap na ayusin. Ano ang maaaring maging mas may problema ay ang banayad na mga error sa semantiko, kung saan matagumpay kang nakasulat ng isang file na puno ng wastong C # - hindi lamang isa ang gumagawa kung ano ang naisip mo. Kung mayroon kang isa sa mga error na ito, at nagkakaproblema ka sa pagsubaybay dito, maraming mga bagay na maaari mong subukang pagbutihin ang sitwasyon.

Ang una ay i-pause ang pagpapatupad ng laro, at suriin ang console. Maaari mong i-pause ang laro sa pamamagitan ng pag-click sa huminto icon sa itaas na gitnang bahagi ng editor, at pagkatapos ay pagpili console mula sa ilalim ng bintana menu (o pagpindot Ctrl > Shift > C ). Kahit na walang mga pagkakamali, makakatulong pa rin ang mga babala upang magbigay ng ilang mga pahiwatig kung ano ang maaaring mali.

Kung hindi ito gumana, maaari mo ring subukang makakuha ng ilang ideya tungkol sa estado ng iyong script sa pamamagitan ng pag-print ng estado ng mga panloob na variable upang mapatunayan na ginagawa ng programa ang sa palagay mo ginagawa. Pwede mong gamitin Debug.Log (String) upang mai-print ang mga nilalaman ng isang string sa console kapag ang pagpapatupad ng programa ay na-hit sa linyang iyon. Sa pangkalahatan, kung nagtatrabaho ka ng paatras mula sa kung ano sa tingin mo ay dapat mangyari sa pamamagitan ng mga bagay na dapat itong gawin, sa paglaon ay maaabot mo ang isang punto kung saan hindi nagawa ng iyong mga pag-print ng debug kung ano ang inaasahan mong gawin nila. Nandyan ang iyong error.

7. Halimbawa: Scripting Pong

Upang maitayo ang Pong, paghiwalayin natin ang laro sa mga pangunahing elemento nito: kailangan natin ng isang bola na pabalik-balik sa pagitan ng mga paddle sa pagtaas ng bilis, kailangan namin ng isang scoreboard na alam kung kailan naipasa ng mga bola ang mga paddle, at kailangan namin ng isang mekanismo para sa pag-restart ng bola kapag nangyari iyon. Ang isang mahusay na unang hakbang ay upang magdagdag ng isang hindi kinematic rigidbody sa bola, dalawang kinematic rigidbodies sa mga paddle, huwag paganahin ang gravity para sa kanilang lahat, at magtalaga ng isang naaangkop na materyal na pisiko mula sa karaniwang mga assets ( talbog kasama si bounce pagsamahin itakda sa magparami ).

Sa ibaba, maaari mong tingnan ang script para sa bola na may mga nagpapaliwanag na puna. Ang bola ay kailangang makamit ang ilang pangunahing mga layunin: dapat itong tumalbog sa isang kumplikadong pattern, palaging pinapanatili ang paggalaw sa parehong mga palakol, at dapat itong mapabilis sa isang mapaghamong ngunit hindi imposibleng tulin sa pahalang na direksyon.

BallHandler.cs

Susunod, kailangan naming i-script ang aming sagwan, na maaari mong tingnan sa ibaba. Ang sagwan ay kailangang ilipat pataas at pababa bilang tugon sa mga pangunahing pagpindot (ngunit hindi sa labas ng ilang mga hangganan). Kailangan din nitong mag-trigger ng system ng maliit na butil kapag sumalpok ito sa isang bagay.

PaddleHandler.cs

Susunod, kailangan namin ng kaaway AI: isang bagay na magiging sanhi ng pagsagwan ng sagwan ng kaaway patungo sa bola sa isang nakapirming rate. Para doon, gagamitin namin ang Vector3.Slerp para sa maximum na pagiging simple. Gusto rin namin ang parehong pag-uugali ng maliit na butil na nakikita namin sa aming sariling sagwan.

KaawayAI.cs

Sa wakas, kailangan namin ng isang script upang mai-update ang scoreboard at i-reset ang bola kapag lumabas ito sa mga hangganan.

ScoreboardUpdater.cs

Sa mga script na nakalakip at napunan ang mga sanggunian, kapag nagpatakbo kami ng aming laro ng Pong, nakakaranas kami ng gameplay!

Kaya mo i-download ang aking Pong demo , kung nais mong makita ang lahat ng aking binalangkas sa pagkilos. Tumatakbo ito sa mga system ng Windows, Mac at Linux.

8. Pagtuklas sa Dokumentasyon / Pag-aaral Nang Higit Pa

Ang Unity ay isang kumplikadong makina na may higit pang mga tampok kaysa sa posible na sakupin sa isang gabay ng istilong ito, at bago mo isama ang malawak na swathe ng (libre at komersyal) Mga extension ng pagkakaisa na magagamit sa internet. Ang gabay na ito ay magbibigay sa iyo ng isang malakas na lugar ng pagsisimula para sa pagbuo ng isang laro, ngunit ang edukasyon sa sarili ay isang mahalagang kasanayan sa anumang pagsisikap, at doble dito.

Isang mahalagang mapagkukunan dito ay ang Unity ScriptReferensi . Ang ScriptReferen ay isang nahahanapang database, magagamit para sa parehong C # at Javascript, na mayroong isang listahan ng bawat utos at tampok ng Unity, na may mga paglalarawan ng kanilang mga pag-andar at maikling halimbawa ng syntax.

Kung nagkakaproblema ka sa editor at interface ng Unity, o tulad ng mga tutorial sa video bilang isang kagustuhan, mayroong isang mahabang listahan ng de-kalidad Mga tutorial sa video ng pagkakaisa magagamit Mas malawak (ngunit hindi gaanong malawak) mga tutorial sa teksto para sa Unity magagamit din mula sa CatLikeCoding.

Panghuli, kung mayroon kang mga katanungan na lampas sa saklaw ng dokumentasyon o mga tutorial, maaari kang magtanong ng mga partikular na katanungan sa mga sagot.Unity3d.com . Tandaan na ang mga sagot ay ibinibigay ng mga boluntaryo, kaya igalang ang kanilang oras at hanapin muna ang database upang matiyak na hindi pa nasasagot ang iyong katanungan.

9. Pagbuo ng Iyong Laro / Pagsasama sa isang Mag-isang Application

Kapag nakabuo ka ng isang bagay na ipinagmamalaki mo (o natapos mo na ang pag-clone ng aming bahagyang nakatalang halimbawa ng Pong para sa pagsasanay), oras na upang ilipat ang iyong laro mula sa editor at gawing isang bagay na maaari mong mai-post sa internet at puwersahin ang iyong mga kaibigan at pamilya upang maglaro. Upang magawa iyon, kakailanganin mong bumuo ng isang nakapag-iisang application. Ang magandang balita ay sa Unity, ito ay napakadali. Gayunpaman, may ilang mga potensyal na hiccough na nais mong mag-ingat.

Para sa mga nagsisimula, alamin na makakagawa ka lamang ng isang proyekto na walang error. Sa layuning iyon, tiyaking mayroon kang bukas na console habang nagtatayo ka: mayroong ilang mga kundisyon ng error na hindi papansinin ng laro sa editor, ngunit tatanggalin pa rin ang isang pagtatangka sa pagbuo. Itinapon lamang nito ang mga mensahe ng error sa console, na walang nakikitang mga resulta sa screen, na maaaring maging nakakabigo kung nakalimutan mong suriin. Kapag nakuha mo na ang iyong laro sa pag-iipon ng walang error, gayunpaman, maaari kang pumili Mga Setting ng Build sa ilalim ng File menu, o pindutin Ctrl > Shift

> B . Dadalhin nito ang isang simpleng diyalogo na magbibigay-daan sa iyo upang mabuo ang iyong laro para sa maraming mga platform.

Ang proseso mula doon ay nagpapaliwanag sa sarili: piliin ang iyong mga pagpipilian, at pindutin magtayo ; ipo-prompt ka ng laro para sa isang direktoryo upang mai-install, at ilalagay ang parehong naisakatuparan at direktoryo ng data doon. Ang dalawang mga file na ito ay maaaring i-zip nang sama-sama at ipamahagi (siguraduhin lamang na hindi ka naniningil para sa isang laro na binuo sa Unity demo, dahil lumalabag ito sa mga tuntunin ng serbisyo).

10. Mga Tala sa Pagsara

Tulad ng anumang tool sa pagbuo ng laro, ang susi sa tagumpay sa Unity ay umuulit na pag-unlad. Kailangan mong bumuo ng mga pinamamahalaang dagdag - maging mapaghangad, sa lahat ng paraan, ngunit maging mapaghangad sa maliliit na mga tipak, at ayusin ang mga chunks na ganoon, kahit na maikli mo ang iyong panghuli na ambisyon, hindi bababa sa makakakuha ka ng isang koherent produkto

Kunin ang pinaka-mahahalagang elemento sa una: magkaroon ng ideya sa iyong minimum na mabubuhay na produkto , ang pinakasimpleng, pinaka-hubad na buto na bagay na maaari mong likhain at pakiramdam mo ay parang nakamit mo ang isang bagay na sulit. Makuha sa pinakamababang mabubuting proyekto bago lumipat sa mas malaking mga ambisyon.

Nagbibigay sa iyo ang tutorial na ito ng isang malakas na lugar ng pagsisimula, ngunit ang pinakamahusay na paraan upang malaman ang Unity ay sa pamamagitan ng pagbuo ng isang laro. Simulang bumuo ng isang laro, punan ang mga puwang sa iyong kaalaman sa paglabas nito, at ang unti-unting pagdaloy ng kaalaman ay makakaalis sa mga bagay na hindi mo alam na nakakagulat na mabilis.

Kung nabasa mo ang lahat ng ito at medyo nalulula ka sa pag-coding na kinakailangan sa Unity, tiyaking suriin mo kung paano alamin ang pagbuo ng laro sa Unity Learn at basahin din ang aming gabay sa kung paano gumawa ng mga video game nang walang anumang programa.

Ang pagkakaisa ay isang malakas na tool, at sa kaunting paggalugad, maaari kang bumuo ng mga kahanga-hangang proyekto kasama nito nang mas mabilis kaysa sa maaari mong asahan. Ipaalam sa amin kung ano ang iyong itinayo sa mga komento sa ibaba - nais naming makita!

Magbahagi Magbahagi Mag-tweet Email 3 Mga Paraan upang Suriin kung Ang isang Email Ay Totoo o Pekeng

Kung nakatanggap ka ng isang email na mukhang medyo nagdududa, palaging pinakamahusay na suriin ang pagiging tunay nito. Narito ang tatlong paraan upang malaman kung ang isang email ay totoo.

Basahin Susunod Mga Kaugnay na Paksa

Programming
Programming
Longform
Patnubay sa Longform

Tungkol sa May-akda Andre Infante(131 Artikulo Nai-publish)

Ang isang manunulat at mamamahayag na nakabase sa Timog-Kanlurang Kanluran, si Andre ay garantisadong mananatiling umaandar hanggang 50 degree Celcius, at hindi tinatablan ng tubig sa lalim na labindalawang talampakan.

Higit pa Mula kay Andre Infante

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe