Share
Curios despre dezvoltarea jocurilor 3D? Acum este momentul să înveți! Această serie de tutori din cinci părți va demonstra cum să construiți un joc simplu cu ShiVa3D Suite, un motor de joc 3D și un instrument de creație. Aceasta este cea de-a patra tranșă a seriei, unde veți finaliza programarea modelului AI pentru joc și veți învăța cum să creați teste unitare pentru a vă verifica munca.
În partea a 3-a, am învățat cum să editați scena aplicației noastre. De asemenea, am început să introducem codul pentru AIModelele jocului și am terminat codificarea pentru DuckAI. În partea a 4-a, vom termina codificarea pentru restul AIModelurilor, EggAI și MainAI și vom efectua testarea unităților prin animarea jocului. Apoi vom exporta jocul din ShiVa Editor pentru a fi importat în Shiva Authoring Tool. În cele din urmă, vom discuta două opțiuni de creație diferite în instrumentul Shiva Authoring Tool: unul pentru generarea unui executabil Android și altul pentru generarea unui proiect Eclipse.
În editorul AIModel, selectați fila EggAI. (Dacă nu vedeți fila EggAI, aduceți Editorul AIModel și Data Explorer alături, apoi mergeți la Data Explorer -> Resurse -> AIModele și faceți dublu-clic pe EggAI.Aceasta ar trebui să afișeze EggAI într-o filă în AIModel Editor.)
Adăugați două variabile la EggAI:
Adăugați handler-ele onInit și onEnterFrame așa cum am făcut-o anterior. De asemenea, adăugați un handler personalizat selectând Add Handler -> Custom, după cum se arată mai jos.
Denumiți manipularea personalizată "onCaptureInput". Notă: este important să nu introduceți "on", deoarece este adăugat prin dialog, după cum se arată mai jos.
Ar trebui să vedeți următoarele.
Acum aduceți editorul AIModel și editorul de scripturi alăturate, așa cum am făcut înainte. În editorul AIModel, selectați fila EggAI. Dând dublu clic pe onInit, onEnterFrame și onCaptureInput unul câte unul, aduceți codul corespunzător în Editorul Script și înlocuiți-le cu următoarele. În fiecare caz, nu uitați să salvați scripturile din Editorul Script prin intermediul Control + S.
Pentru onInit:
funcția EggAI.onInit () -------------------------------------------- ------------------------------------ object.setTranslation (this.getObject (), 0, 3, 0, object.kGlobalSpace) -------------------------------------------- ------------------------------------ Sfârșit --------------------------------------------------------------------------------
Pentru onEnterFrame:
funcția EggAI.onEnterFrame () -------------------------------------------- ------------------------------------ locală lObject = this.getObject () locală x, y, z = object.getRotarea (lObject, object.kLocalSpace) object.setRotation (lObject, x + 1, y, z, object.kLocalSpace) local xp, yp, zp = object.getTranslation (this.getObject (), object.kGlobalSpace) în cazul în care (zp < -5) then this.isBack (false ) elseif(zp > 5), atunci acest.isBack (adevărat) se termină dacă (this.isBack ()), apoi object.setTranslation (this.getObject (), 0, 3, zp-0.005-math.abs (this.jump ()) obiect. kGlobalSpace) altceva object.setTranslation (this.getObject (), 0, 3, zp + 0.005 + math.abs (this.jump ()), object.kGlobalSpace) end this.jump (0) ------- -------------------------------------------------- ----------------------- Sfârșit --------------------------------------------------------------------------------
Pentru onCaptureInput:
funcția EggAI.onCaptureInput (d) ------------------------------------------- ------------------------------------- dacă (d == 1) atunci this.jump (0.1 ) this.isBack (false) elseif (d == - 1) apoi this.jump (-0.1) this.isBack (true) end -------------------- -------------------------------------------------- ---------- Sfârșit --------------------------------------------------------------------------------
Am terminat cu variabilele și codul pentru EggAI.
Acum, vom lucra la MainAI. Aceasta este ultima bucată de cod înainte de a compila totul și de a rula un test local. În fila MainAI a Editorului AIModel, adăugați cele trei variabile prezentate mai jos.
Dacă faceți clic pe Adăugare funcție, adăugați trei funcții: displayRestart, requestRestart și resetare.
În cele din urmă, adăugați patru manageri: onInit, onTouchSequenceBegin, onTouchSequenceChange și onTouchSequenceEnd. Rețineți că pentru a adăuga ultimele trei agende, trebuie să selectați Add Handler -> Handler de utilizator.
Pentru fiecare funcție și gestionare de mai sus, înlocuiți codul cu următoarele în Editorul scriptului. Nu uitați să salvați utilizând Control + S.
Pentru displayRestart:
funcția MainAI.displayRestart () -------------------------------------------- ------------------------------------ local lUser = application.getCurrentUser () local lComp = hud.newComponent (lComp, 0, 0, 0), dacă (lComp ~ = nil) atunci hud.setComponentPosition (lComp, 50, 50) hud.setComponentSize (lComp, 100, 10) hud.setComponentBackgroundColor .setComponentBorderColor (lComp, 0, 0, 0, 0) hud.setComponentVisible (lComp, true) hud.setComponentZOrder (lComp, 255) hud.setLabelText (lComp, "Restartarea jocului") hud.setDefaultFont hud.setLabelTextHeight (lComp, 100) hud.setLabelTextAlignment (lComp, hud.kAlignCenter, hud.kAlignCenter) sfârșitul --------------------------- -------------------------------------------------- --- Sfârșit --------------------------------------------------------------------------------
Pentru cerereRestart:
funcție MainAI.requestRestart () -------------------------------------------- ------------------------------------ application.restart () --------- -------------------------------------------------- --------------------- Sfârșit --------------------------------------------------------------------------------
Pentru resetare:
funcție MainAI.reset () -------------------------------------------- ------------------------------------ this.prevTouchCount (0) this.prevY0 (0) - -------------------------------------------------- ---------------------------- Sfârșit --------------------------------------------------------------------------------
Pentru onInit:
Accentsconagua
funcția MainAI.onInit () -------------------------------------------- ------------------------------------ aplicație.setCurrentUserScene ("MyScene") application.setOption (aplicație. kOptionViewportRotation, 3) local lCamera = application.getCurrentUserActiveCamera () object.setTranslation (lCamera, 6, 7, 5, obiect.kGlobalSpace) object.lookAt (lCamera, 0, 1.9, -1, object.kGlobalSpace, 1) this.egg (scene.getTaggedObject (application.getCurrentUserScene (), "egg")) input.enableMultiTouch (this.getUser (), true) this.reset () ----------------- -------------------------------------------------- ------------- Sfârșit -------------------------------------------------------------------------------- Pentru onTouchSequenceBegin:
funcția MainAI.onTouchSequenceBegin () -------------------------------------------- ------------------------------------ this.reset () --------- -------------------------------------------------- --------------------- Sfârșit --------------------------------------------------------------------------------
Pentru onTouchSequenceChange:
funcție MainAI.onTouchSequenceChange (nTaps0, nX0, nY0, nTaps1, nX1, nY1, nTaps2, nX2, nY2, nTaps3, nX3, nY3, nTaps4, nX4, nY4) --------------- -------------------------------------------------- --------------- local touchCount = 0 dacă (nTaps0> 0), apoi touchCount = 1 capăt dacă (nTaps1> 0), apoi touchCount = 2 end dacă (nTaps2> 0) 3 sfarsit daca (nTaps3> 0) apoi touchCount = 4 sfarsit daca (nTaps4> 0) apoi touchCount = 5 sfarsit daca (touchCount == this.prevTouchCount ()) atunci daca (touchCount ==1) prevY0 ()) apoi local d = -1 object.sendEvent (this.egg (), "EggAI", "onCaptureInput", d) elseif (nY0 < this.prevY0()) then local d = 1 object.sendEvent ( this.egg ( ), "EggAI", "onCaptureInput", d ) end elseif(touchCount == 2) then if(math.abs (nY0 - nY1) > 0.2), apoi this.displayRestart () this.postEvent (1, "requestRestart") end end end - stoca variabilele acestui eveniment pentru următorul eveniment this.prevTouchCount (touchCount) this.prevY0 (nY0) ------- -------------------------------------------------- ----------------------- Sfârșit --------------------------------------------------------------------------------
Pentru onTouchSequenceEnd:
funcția MainAI.onTouchSequenceEnd () -------------------------------------------- ------------------------------------ this.reset () --------- -------------------------------------------------- --------------------- Sfârșit --------------------------------------------------------------------------------
Acum, apăsați F7 pentru a compila totul. Ar trebui să vedeți 0 erori și 0 avertismente.
Acum, să testăm jocul. În meniul barei de sus, selectați Animație. Apoi, selectați Afișaj -> Dimensiune -> Android -> 480x800 după cum se arată mai jos.
Apoi, selectați Display -> View Mode -> Runtime.
Apăsați F9 pentru a începe animarea. Jocul începe să joace după cum urmează.
Rețineți că nu puteți muta oul în acest punct, deoarece mișcarea de ouă este controlată prin intermediul evenimentelor touch touch. Prin urmare, testul efectiv de mutare a oului se poate face numai după instalarea acestuia într-un dispozitiv Android. În timp ce animați în Editorul ShiVa, rața și oul se vor mișca liber fără nici o intrare. În timpul mișcării libere, ei se pot ciocni unul câte unul din când în când. Când se întâmplă acest lucru, rața își va schimba direcția de rotație pe axa globală. De asemenea, veți observa că după fiecare coliziune va fi deschis un browser pentru afișarea adresei http://www.stonetrip.com. Acest lucru se datorează următoarei linii în funcție DuckAI.onSensorCollisionBegin:
... system.openURL ("http://www.stonetrip.com", "") Scopul acestei linii este de a vibra aparatul în momentul unei coliziuni. Vom edita codul Java în Eclipse pentru a suprascrie system.openURL () pentru a vibra dispozitivul în loc să deschidă un browser. Deocamdată, puteți împiedica editorul ShiVa să deschidă automat un browser în timpul animației. În acest scop, comentați linia de cod în DuckAI.onSensorCollisionBegin ca mai jos și apoi recompilați înainte de a începe animația.
... --system.openURL ("http://www.stonetrip.com", "") Cu toate acestea, nu uitați să eliminați linia dublă (-) și să recompilați totul înainte de a exporta jocul.
După ce am finalizat dezvoltarea jocului nostru, acum îl vom exporta pentru a fi utilizat de ShiVa Authoring Tool.
În Data Explorer, evidențiați folderul Jocuri și selectați Duck. Din meniul cu butonul din dreapta, selectați Exportă joc, după cum se arată mai jos.
Selectați un dosar local, de ex. D: \ temp. De asemenea, selectați pachetul Runtime pentru Android. Faceți clic pe Export. (Vezi mai jos.)
Va apărea un dialog de progres, după cum se arată mai jos.
Așteptați până la finalizarea exportului și apăsați OK pentru a închide fereastra de dialog. Vezi mai jos:
Acum, ar trebui să vedeți un fișier numit Duck.stk în directorul local pe care ați ales să îl exportați.
În această secțiune vom discuta instrumentul Shiva Authoring Tool. După cum sa menționat anterior, scopul principal al instrumentului ShiVa Authoring Tool este de a converti un joc, creat prin editorul ShiVa, într-o aplicație care poate fi implementată într-un anumit dispozitiv. Mai jos, vom descrie pașii pentru a transforma jocul într-o aplicație Android.
Deoarece instrumentul Shiva Authoring Tool poate fi folosit pentru a instala jocul în dispozitivul Android, trebuie să pregătiți dispozitivul pentru instalare. Mai întâi, în Setări aplicație, verificați sursele necunoscute, după cum se arată mai jos.
Apoi, în opțiunile de dezvoltare ale dispozitivului, verificați depanarea USB după cum se arată mai jos.
De asemenea, asigurați-vă că dispozitivul dvs. este conectat la dispozitivul de dezvoltare printr-un cablu USB. Rețineți că atunci când conectați pentru prima dată un anumit dispozitiv Android la computerul de dezvoltare, Windows va instala driverul de dispozitiv corespunzător în computer. Este posibil să fie necesar să îndreptați Expertul Adăugare Hardware la locația folderului de instalare SDK pentru Android pentru a găsi un driver potrivit.
Așa cum am discutat mai devreme în tutorial, cele două tipuri de creație disponibile în Shiva Authoring Tool sunt Project and APK Package. Autorizarea proiectului generează un proiect Eclipse pentru a personaliza în continuare aplicația de joc în Eclipse. Autorizarea pachetului APK generează un fișier APK Android pentru instalarea directă a aplicației de joc în dispozitiv. Deoarece vrem să personalizăm jocul să vibreze dispozitivul în momentul unei coliziuni, vom examina mai întâi procesul de creație pentru proiect.
În instrucțiunile de mai jos, se presupune că Duck.stk este instalat în D: \ tmp. Dacă ați stocat-o într-o altă locație, schimbați instrucțiunile corespunzătoare.
În pregătirea pentru această secțiune, extrageți app_icon.png și app_splash.png din arhiva de descărcare care însoțește acest tutorial și salvați-le sub un dosar local, de ex. D: \ tmp. Fișierul app_splash.png va fi afișat ca pagină de start în dispozitiv pentru joc atunci când acesta va porni. Aplicația app_icon.png va fi afișată pe ecranul de pornire al dispozitivului Android, după cum se arată mai jos.
Aduceți Shiva Authoring Tool. Selectați Android din navigația din stânga. Faceți clic pe imaginea cu săgeată din secțiunea "Sau începeți acum ...", după cum se arată mai jos.
În pasul 1, selectați Duck.stk, app_icon.png și app_splash.png din folderele locale ale computerului, după cum se arată mai jos. Aici, observați că separatorul de foldere este slash (/), nu întârziere (\). Apăsați pe Următorul.
În Pasul 2, sub Tip autor, selectați Proiect. Pentru tipul de identificator Bundle într-un nume, de exemplu com.shiva3d.demo. Acest nume corespunde numelui pachetului Java. Acceptați setările implicite pentru versiunea și codul versiunii (vedeți mai jos). Faceți clic pe Pasul 3: Construiți.
La Pasul 3, selectați Tip construire: Dezvoltare și lăsați toate casetele de selectare neconfirmate după cum se arată mai jos.
De asemenea, efectuați următoarele selecții:
Acestea sunt prezentate mai jos.
Rețineți că obiectivul nostru principal în acest tutorial este Android 3.2, pentru care aplicația a fost testată.
Faceți clic pe Construiți. Aceasta va aduce viziunea consolei. Dacă totul merge în mod corespunzător, veți vedea un mesaj care spune "Construit terminat cu succes!", După cum se arată mai jos. De asemenea, în directorul de ieșire (D: \ temp) ar trebui să vedeți Duck_Android.zip.
Aici vom examina procesul de creare folosit pentru a crea un fișier APK (care este o aplicație Android) care poate fi instalat direct într-un dispozitiv. Ca o opțiune, puteți instala jocul în aparat ca parte a construirii. Pentru a face acest lucru, trebuie să fi finalizat pașii descriși mai sus în "Pregătiți dispozitivul Android pentru instalare".
Rețineți că dacă creați pachet APK, personalizarea codului în Eclipse nu va fi posibilă. Ca urmare, caracteristica vibratoare nu va fi disponibilă (adică atunci când rața și oul se ciocnesc, dispozitivul nu va vibra). Din acest motiv, trebuie să editați DuckAI.onSensorCollisionBegin și să comentați sau să eliminați următorul rând:
system.openURL ("http://www.stonetrip.com", "") Apoi, compilați și exportați Duck.stk ca și înainte.
Acum, ridicați Shiva Authoring Tool și parcurgeți aceiași pași ca mai sus, cu următoarele excepții.
În pasul 2, selectați tipul de redactare ca pachet APK și nu ca Dezvoltare:
La Pasul 3, bifați Instalați pe dispozitivul conectat (vedeți mai jos)
Când etapele de construire sunt finalizate, în directorul de ieșire ar trebui să vedeți Duck-debug.apk. De asemenea, jocul trebuie să fi fost instalat pe dispozitiv. (Rețineți că, dacă nu doriți să instalați aplicația în dispozitiv ca parte a construirii, nu verificați Instalați pe dispozitivul conectat.Puteți instala Duck-debug.apk în dispozitivul dvs. altă dată utilizând ADB Tool în Android SDK .)
În partea a 4-a, am terminat codarea pentru EggAI și MainAI și am testat unitatea prin animarea jocului. Apoi am exportat jocul de la Editorul ShiVa pentru importul în Shiva Authoring Tool. În cele din urmă, am discutat două opțiuni diferite de creație în Instrumentul de editare Shiva, unul pentru generarea unui executabil Android și altul pentru generarea unui proiect Eclipse. În partea a 5-a, vom începe prin a învăța cum să personalizăm jocul în Eclipse. Aceasta va include configurarea proiectului Eclipse, modificările de cod, construirea codului Java și bibliotecile native. În acest moment, vom fi finalizat tutorialul în ceea ce privește dezvoltarea și implementarea. În restul părții 5 vom examina codul și vom discuta cum să portăm jocul pe dispozitivele iOS.
