Share
Sei curioso di sviluppare il gioco in 3D? Ora è il momento di imparare! Questa serie di tutorial in cinque parti mostrerà come creare un gioco semplice con ShiVa3D Suite, un motore di gioco 3D multipiattaforma e uno strumento di authoring. Questa è la quarta puntata della serie, in cui completerai la programmazione del modello AI per il gioco e imparerai come creare test unitari per verificare il tuo lavoro.
Nella parte 3, abbiamo imparato come modificare la scena della nostra applicazione. Abbiamo anche iniziato a inserire il codice per gli AIModels del gioco e abbiamo completato la codifica per DuckAI. Nella parte 4, termineremo la codifica per i rimanenti AIModels, EggAI e MainAI, ed eseguiremo test unitari animando il gioco. Eseguiremo quindi il gioco dall'Editor ShiVa per l'importazione nello Strumento di authoring di Shiva. Infine, discuteremo due diverse opzioni di authoring nello Shiva Authoring Tool: uno per generare un eseguibile Android e un altro per generare un progetto Eclipse.
Nell'Editor AIModel, seleziona la scheda EggAI. (Se non vedi la scheda EggAI, porta l'Editor AIModel e l'Explorer Dati affiancati, quindi vai a Data Explorer -> Risorse -> AIModels e fai doppio clic su EggAI. Dovresti visualizzare EggAI in una scheda in AIModel Editor.)
Aggiungi due variabili a EggAI:
Aggiungi i gestori su Init e onEnterFrame come fatto in precedenza. Inoltre, aggiungi un gestore personalizzato selezionando Aggiungi gestore -> Personalizzato come mostrato di seguito.
Assegna un nome al gestore personalizzato "onCaptureInput". Nota: è importante non digitare "on" perché viene aggiunto dalla finestra di dialogo come mostrato di seguito.
Dovresti vedere quanto segue.
Ora porta l'editor di AIModel e l'editor degli script fianco a fianco, come abbiamo fatto prima. Su Editor AIModel, seleziona la scheda EggAI. Facendo doppio clic su onInit, onEnterFrame e onCaptureInput uno per uno, inserire il codice corrispondente in Script Editor e sostituirli con il seguente. In ogni caso, non dimenticare di salvare gli script nello Script Editor tramite Control + S.
Per onInit:
function EggAI.onInit () -------------------------------------------- ------------------------------------ object.setTranslation (this.getObject (), 0, 3, 0, object.kGlobalSpace) -------------------------------------------- ------------------------------------ fine --------------------------------------------------------------------------------
Per onEnterFrame:
function EggAI.onEnterFrame () -------------------------------------------- ------------------------------------ local lObject = this.getObject () local x, y, z = object.getRotation (lObject, object.kLocalSpace) object.setRotation (lObject, x + 1, y, z, object.kLocalSpace) local xp, yp, zp = object.getTranslation (this.getObject (), object.kGlobalSpace) if (ZP < -5) then this.isBack (false ) elseif(zp > 5) then this.isBack (true) end if (this.isBack ()) then object.setTranslation (this.getObject (), 0, 3, zp-0.005-math.abs (this.jump ()), object. kGlobalSpace) else object.setTranslation (this.getObject (), 0, 3, zp + 0.005 + math.abs (this.jump ()), object.kGlobalSpace) termina this.jump (0) ------- -------------------------------------------------- ----------------------- fine --------------------------------------------------------------------------------
Per onCaptureInput:
funzione EggAI.onCaptureInput (d) ------------------------------------------- ------------------------------------- if (d == 1) then this.jump (0.1 ) this.isBack (false) elseif (d == - 1) then this.jump (-0.1) this.isBack (true) end -------------------- -------------------------------------------------- ---------- fine --------------------------------------------------------------------------------
Abbiamo finito con le variabili e il codice per EggAI.
Ora lavoreremo su MainAI. Questo è l'ultimo pezzo di codice prima di compilare tutto ed eseguire un test locale. Nella scheda MainAI dell'Eimodel Editor, aggiungi le tre variabili mostrate di seguito.
Facendo clic su Aggiungi funzione, aggiungere tre funzioni: displayRestart, requestRestart e reset.
Infine, aggiungi quattro gestori: onInit, onTouchSequenceBegin, onTouchSequenceChange e onTouchSequenceEnd. Si noti che per aggiungere gli ultimi tre gestori, è necessario selezionare Aggiungi gestore -> Gestore utenti.
Per ognuna delle funzioni e dei gestori sopra riportati, sostituire il codice con quanto segue nello Script Editor. Non dimenticare di salvare usando Control + S.
Per displayRestart:
function MainAI.displayRestart () -------------------------------------------- ------------------------------------ lUser locale = application.getCurrentUser () local lComp = hud.newComponent (lUser, hud.kComponentTypeLabel) if (lComp ~ = nil) quindi hud.setComponentPosition (lComp, 50, 50) hud.setComponentSize (lComp, 100, 10) hud.setComponentBackgroundColor (lComp, 0, 0, 0, 0) hud .setComponentBorderColor (lComp, 0, 0, 0, 0) hud.setComponentVisible (lComp, true) hud.setComponentZOrder (lComp, 255) hud.setLabelText (lComp, "Riavvio del gioco") hud.setDefaultFont (lUser, "DefaultFont") hud.setLabelTextHeight (lComp, 100) hud.setLabelTextAlignment (lComp, hud.kAlignCenter, hud.kAlignCenter) end --------------------------- -------------------------------------------------- --- fine --------------------------------------------------------------------------------
Per requestRestart:
function MainAI.requestRestart () -------------------------------------------- ------------------------------------ application.restart () --------- -------------------------------------------------- --------------------- fine --------------------------------------------------------------------------------
Per ripristinare:
function MainAI.reset () -------------------------------------------- ------------------------------------ this.prevTouchCount (0) this.prevY0 (0) - -------------------------------------------------- ---------------------------- fine --------------------------------------------------------------------------------
Per onInit:
Accentsconagua
function MainAI.onInit () -------------------------------------------- ------------------------------------ application.setCurrentUserScene ("MyScene") application.setOption (applicazione. kOptionViewportRotation, 3) local lCamera = application.getCurrentUserActiveCamera () object.setTranslation (lCamera, 6, 7, 5, object.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 () ----------------- -------------------------------------------------- ------------- fine -------------------------------------------------------------------------------- Per onTouchSequenceBegin:
function MainAI.onTouchSequenceBegin () -------------------------------------------- ------------------------------------ this.reset () --------- -------------------------------------------------- --------------------- fine --------------------------------------------------------------------------------
Per onTouchSequenceChange:
funzione MainAI.onTouchSequenceChange (nTaps0, nX0, nY0, nTaps1, nX1, nY1, nTaps2, nX2, nY2, nTaps3, nX3, nT3, nTaps4, nX4, nY4) --------------- -------------------------------------------------- --------------- local touchCount = 0 if (nTaps0> 0) quindi touchCount = 1 end if (nTaps1> 0) quindi touchCount = 2 end if (nTaps2> 0) quindi touchCount = 3 end if (nTaps3> 0) quindi touchCount = 4 end if (nTaps4> 0) quindi touchCount = 5 end if (touchCount == this.prevTouchCount ()) then if (touchCount == 1) then if (nY0> this. prevY0 ()) then 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) then this.displayRestart () this.postEvent (1, "requestRestart") end end end - memorizza le variabili di questo evento per il prossimo evento this.prevTouchCount (touchCount) this.prevY0 (nY0) ------- -------------------------------------------------- ----------------------- fine --------------------------------------------------------------------------------
Per onTouchSequenceEnd:
function MainAI.onTouchSequenceEnd () -------------------------------------------- ------------------------------------ this.reset () --------- -------------------------------------------------- --------------------- fine --------------------------------------------------------------------------------
Ora, premi F7 per compilare tutto. Dovresti vedere 0 errori e 0 avvisi.
Ora proviamo il gioco. Nel menu della barra in alto, seleziona Animazione. Quindi, seleziona Visualizza -> Dimensioni -> Android -> 480x800 come mostrato di seguito.
Quindi, selezionare Visualizza -> Modalità visualizzazione -> Runtime.
Premi F9 per iniziare l'animazione. Il gioco inizia a giocare come segue.
Nota che non puoi muovere l'uovo a questo punto, perché il movimento dell'uovo è controllato tramite eventi touch screen. Pertanto, il test effettivo di spostamento dell'uovo può essere eseguito solo dopo averlo installato su un dispositivo Android. Durante l'animazione nell'Editor di ShiVa, l'anatra e l'uovo si muoveranno liberamente senza alcun input. Durante la libertà di movimento, possono scontrarsi tra loro ogni tanto. Quando ciò accade, l'anatra cambierà la sua direzione di rotazione sull'asse globale. Noterai inoltre che dopo ogni collisione verrà aperto un browser per visualizzare l'URL http://www.stonetrip.com. Ciò è dovuto alla seguente riga nella funzione DuckAI.onSensorCollisionBegin:
... system.openURL ("http://www.stonetrip.com", "") Lo scopo di questa linea è di far vibrare il dispositivo quando si verifica una collisione. Modificheremo il codice Java in Eclipse per sovrascrivere il system.openURL () gestore di eventi per far vibrare il dispositivo invece di aprire un browser. Per ora, puoi impedire a ShiVa Editor di aprire automaticamente un browser durante l'animazione. A tale scopo, commentare la riga di codice in DuckAI.onSensorCollisionBegin come di seguito e quindi ricompilare prima di avviare l'animazione.
... --system.openURL ("http://www.stonetrip.com", "") Tuttavia, non dimenticare di rimuovere il doppio trattino (-) e ricompilare tutto prima di esportare il gioco.
Avendo finito di sviluppare il nostro gioco, ora lo esporteremo per essere utilizzato dallo strumento di authoring ShiVa.
In Esplora dati, evidenzia la cartella Giochi e seleziona Anatra. Dal menu di scelta rapida, seleziona Esporta gioco come mostrato di seguito.
Seleziona una cartella locale, ad es. D: \ temp. Seleziona anche il pacchetto di runtime per Android. Fai clic su Esporta. (Vedi sotto.)
Apparirà una finestra di dialogo come mostrato di seguito.
Attendere fino al completamento dell'esportazione e premere OK per chiudere la finestra di dialogo. Vedi sotto:
Ora dovresti vedere un file chiamato Duck.stk nella cartella locale che hai selezionato per esportare il gioco.
In questa sezione, discuteremo lo strumento di authoring di Shiva. Come accennato in precedenza, lo scopo principale dello strumento di authoring ShiVa è convertire un gioco, creato tramite l'Editor ShiVa, in un'applicazione che può essere distribuita in un particolare dispositivo. Di seguito, descriveremo i passaggi per convertire il gioco in un'applicazione Android.
Poiché Shiva Authoring Tool può essere utilizzato per installare il gioco sul dispositivo Android, è necessario preparare il dispositivo per l'installazione. Innanzitutto, nelle impostazioni dell'applicazione, seleziona Origini sconosciute come mostrato di seguito.
Quindi, nelle Opzioni di sviluppo del tuo dispositivo controlla il debug USB come mostrato di seguito.
Inoltre, assicurarsi che il dispositivo sia collegato alla macchina di sviluppo tramite un cavo USB. Notare che quando si connette un particolare dispositivo Android al computer di sviluppo per la prima volta, Windows installerà il driver di periferica appropriato nel computer. Potrebbe essere necessario puntare l'Installazione guidata hardware nel percorso della cartella di installazione di Android SDK per la procedura guidata per trovare un driver adatto.
Come abbiamo discusso in precedenza nel tutorial, i due tipi di authoring disponibili nello Shiva Authoring Tool sono Project e APK Package. Authoring for Project genera un progetto Eclipse per personalizzare ulteriormente l'applicazione di gioco in Eclipse. L'authoring per APK Package genera un file APK Android per l'installazione diretta dell'applicazione di gioco nel dispositivo. Dal momento che vogliamo personalizzare il gioco per far vibrare il dispositivo quando si verifica una collisione, prima esamineremo il processo di authoring per il progetto.
Nelle istruzioni seguenti, si presume che Duck.stk sia installato in D: \ tmp. Se lo hai archiviato in un'altra posizione, modifica le istruzioni di conseguenza.
In preparazione per questa sezione, estrai app_icon.png e app_splash.png dall'archivio di download che accompagna questo tutorial e salvali in una cartella locale, ad es. D: \ tmp. Il file app_splash.png verrà visualizzato come pagina iniziale nel dispositivo per il gioco all'avvio. App_icon.png verrà visualizzato nella schermata principale del dispositivo Android come mostrato di seguito.
Apri lo strumento di creazione di Shiva. Seleziona Android sulla barra di navigazione a sinistra. Fai clic sull'immagine della freccia sotto "O iniziare subito ..." come mostrato di seguito.
Al punto 1, seleziona Duck.stk, app_icon.png e app_splash.png dalle cartelle locali del tuo computer come mostrato di seguito. Qui, si noti che il separatore della cartella è barra (/), non backslash (\). Premere Avanti.
Nel passaggio 2, in Tipo di autore, selezionare Progetto. Per il tipo di identificatore del pacchetto in un nome, ad esempio com.shiva3d.demo. Questo nome corrisponde al nome del pacchetto Java. Accetta i valori predefiniti per versione e codice versione (vedi sotto). Fai clic su Passaggio 3: Build.
Al passaggio 3, selezionare Tipo di costruzione: Sviluppo e lasciare deselezionate tutte le caselle di controllo come mostrato di seguito.
Inoltre, effettuare le seguenti selezioni:
Quelli sono mostrati sotto.
Nota che il nostro obiettivo principale in questo tutorial è Android 3.2, per il quale è stata testata l'applicazione.
Fai clic su Build. Questo porterà la visualizzazione della console. Se tutto procede correttamente, vedrai un messaggio che dice "Build finished successfully!", Come mostrato di seguito. Inoltre, nella cartella di output (D: \ temp) dovresti vedere Duck_Android.zip.
Qui, esamineremo il processo di authoring utilizzato per creare un file APK (che è un'applicazione Android) che può essere installato direttamente in un dispositivo. Come opzione, puoi installare il gioco sul tuo dispositivo come parte della build. Per fare ciò, è necessario aver completato i passaggi sopra descritti in "Preparare il dispositivo Android per l'installazione".
Nota che se stai creando un pacchetto APK, la personalizzazione del codice in Eclipse non sarà possibile. Di conseguenza, la funzione di vibrazione non sarà disponibile (cioè, quando l'anatra e l'uovo si scontrano, il dispositivo non vibrerà). Per questo motivo, è necessario modificare DuckAI.onSensorCollisionBegin e commentare o rimuovere la riga seguente:
system.openURL ("http://www.stonetrip.com", "") Quindi compilare ed esportare Duck.stk come facevamo prima.
Ora, fai apparire lo strumento di authoring di Shiva e segui gli stessi passaggi di cui sopra con le seguenti eccezioni.
Al passaggio 2, seleziona il tipo di authoring come Pacchetto APK anziché come Sviluppo:
Al punto 3, controlla Installa sul dispositivo connesso (vedi sotto)
Una volta completati i passi di costruzione, nella cartella di output dovresti vedere Duck-debug.apk. Inoltre, il gioco deve essere stato installato sul tuo dispositivo. (Si noti che se non si desidera installare l'applicazione nel dispositivo come parte della build, non selezionare Installa sul dispositivo connesso.È possibile installare Duck-debug.apk nel dispositivo un'altra volta utilizzando lo strumento ADB nell'SDK di Android .)
Nella parte 4, abbiamo terminato la codifica per l'EggAI e il MainAI e abbiamo eseguito test delle unità animando il gioco. Abbiamo quindi esportato il gioco dall'editor ShiVa per l'importazione nello strumento di creazione di Shiva. Infine, abbiamo discusso di due diverse opzioni di authoring nello Shiva Authoring Tool, una per la generazione di un eseguibile Android e un'altra per la generazione di un progetto Eclipse. Nella parte 5, inizieremo imparando come personalizzare il gioco in Eclipse. Ciò includerà l'impostazione del progetto Eclipse, le modifiche al codice, la costruzione del codice Java e le librerie native. A quel punto avremo completato il tutorial in termini di sviluppo e implementazione. Nel resto della parte 5 esamineremo il codice e discuteremo come trasferire il gioco su dispositivi iOS.
