Share
¿Tienes curiosidad por el desarrollo de juegos en 3D? ¡Ahora es el momento de aprender! Esta serie de tutoriales de cinco partes demostrará cómo construir un juego simple con ShiVa3D Suite, un motor de juegos 3D multiplataforma y una herramienta de creación. Esta es la cuarta entrega de la serie, donde completarás la programación del Modelo AI para el juego y aprenderás a crear pruebas unitarias para verificar tu trabajo..
En la parte 3, aprendimos cómo editar la escena de nuestra aplicación. También comenzamos a ingresar el código para los AIModels del juego y completamos la codificación para el DuckAI. En la parte 4, terminaremos la codificación de los restantes AIModels, EggAI y MainAI, y realizaremos pruebas de unidad animando el juego. Luego exportaremos el juego desde ShiVa Editor para importarlo a Shiva Authoring Tool. Finalmente, discutiremos dos opciones diferentes de creación en la Herramienta de creación Shiva: una para generar un ejecutable de Android y otra para generar un proyecto de Eclipse.
En el Editor de AIModel, seleccione la pestaña EggAI. (Si no ve la pestaña EggAI, lleve el Editor de AIModel y el Explorador de datos uno al lado del otro. Luego, vaya a Explorador de datos -> Recursos -> AIModels y haga doble clic en EggAI. Esto debería mostrar EggAI en una pestaña en AIModel Editor.)
Agregue dos variables a EggAI:
Agregue los manejadores onInit y onEnterFrame como hicimos anteriormente. Además, agregue un controlador personalizado seleccionando Agregar controlador -> Personalizado como se muestra a continuación.
Nombre el controlador personalizado 'onCaptureInput'. Nota: es importante que no escriba 'on' porque el cuadro de diálogo lo agrega como se muestra a continuación.
Deberías ver lo siguiente.
Ahora trae el Editor AIModel y el Editor de secuencias de comandos, uno al lado del otro, como hicimos antes. En el Editor de AIModel, seleccione la pestaña EggAI. Al hacer doble clic en onInit, onEnterFrame y onCaptureInput uno por uno, traiga el código correspondiente en el Editor de secuencias de comandos y sustitúyalos por los siguientes. En cada caso, no olvide guardar los scripts en el Editor de scripts a través de Control + S.
Para onInit:
función EggAI.onInit () -------------------------------------------- ------------------------------------ object.setTranslation (this.getObject (), 0, 3, 0, object.kGlobalSpace) -------------------------------------------- ------------------------------------ final --------------------------------------------------------------------------------
Para onEnterFrame:
función EggAI.onEnterFrame () -------------------------------------------- ------------------------------------ local lObject = this.getObject () local x, y, z = object.getRotation (lObject, object.kLocalSpace) object.setRotation (lObject, x + 1, y, z, object.kLocalSpace) xp local, yp, zp = object.getTranslation (this.getObject (), object.kGlobalSpace) si (zp < -5) then this.isBack (false ) elseif(zp > 5) entonces this.isBack (true) termina si (this.isBack ()) entonces object.setTranslation (this.getObject (), 0, 3, zp-0.005-math.abs (this.jump ()), objeto. kGlobalSpace) else object.setTranslation (this.getObject (), 0, 3, zp + 0.005 + math.abs (this.jump ()), object.kGlobalSpace) termina this.jump (0) ------- -------------------------------------------------- ----------------------- final --------------------------------------------------------------------------------
Para onCaptureInput:
función EggAI.onCaptureInput (d) ------------------------------------------- ------------------------------------- if (d == 1) entonces this.jump (0.1 ) this.isBack (false) elseif (d == - 1) entonces this.jump (-0.1) this.isBack (true) end -------------------- -------------------------------------------------- ---------- final --------------------------------------------------------------------------------
Hemos terminado con las variables y el código para EggAI..
Ahora, trabajaremos en el MainAI. Este es el último fragmento de código antes de compilar todo y ejecutar una prueba local. En la pestaña MainAI del Editor de AIModel, agregue las tres variables que se muestran a continuación.
Al hacer clic en Agregar función, agregue tres funciones: mostrar reiniciar, solicitar reiniciar y reiniciar.
Finalmente, agregue cuatro manejadores: onInit, onTouchSequenceBegin, onTouchSequenceChange y onTouchSequenceEnd. Tenga en cuenta que para agregar los últimos tres controladores, debe seleccionar Agregar controlador -> Administrador de usuarios.
Para cada una de las funciones y controladores anteriores, reemplace el código con lo siguiente en el Editor de secuencias de comandos. No olvides guardar utilizando Control + S..
Para displayRestart:
función MainAI.displayRestart () -------------------------------------------- ------------------------------------ local lUser = application.getCurrentUser () local lComp = hud.newComponent (lUser, hud.kComponentTypeLabel) if (lComp ~ = nil) entonces hud.setComponentPosition (lComp, 50, 50) hud.setComponentSize (lComp, 100, 10) hud.setComponentBackgroundColor (lComp, 0, 0, 0, 0, 0) hud .setComponentBorderColor (lComp, 0, 0, 0, 0) hud.setComponentVisible (lComp, true) hud.setComponentZOrder (lComp, 255) hud.setLabelText (lComp, "Game Restarting") hud.setDefaultFont (lUser, "DefaultFont") hud.setLabelTextHeight (lComp, 100) hud.setLabelTextAlignment (lComp, hud.kAlignCenter, hud.kAlignCenter) end ----------------------------- -------------------------------------------------- --- final --------------------------------------------------------------------------------
Para requestRestart:
función MainAI.requestRestart () -------------------------------------------- ------------------------------------ application.restart () --------- -------------------------------------------------- --------------------- final --------------------------------------------------------------------------------
Para restablecer:
función MainAI.reset () -------------------------------------------- ------------------------------------ this.prevTouchCount (0) this.prevY0 (0) - -------------------------------------------------- ---------------------------- final --------------------------------------------------------------------------------
Para onInit:
Accentsconagua
función MainAI.onInit () -------------------------------------------- ------------------------------------ application.setCurrentUserScene ("MyScene") application.setOption (application. 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 () ------------------- -------------------------------------------------- ------------- final -------------------------------------------------------------------------------- Para onTouchSequenceBegin:
función MainAI.onTouchSequenceBegin () -------------------------------------------- ------------------------------------ this.reset () --------- -------------------------------------------------- --------------------- final --------------------------------------------------------------------------------
Para onTouchSequenceChange:
función MainAI.onTouchSequenceChange (nTaps0, nX0, nY0, nTaps1, nX1, nY1, nTaps2, nX2, nY2, nTaps3, nX3, nY3, nTaps4, nX4, nY4) --------------- -------------------------------------------------- --------------- local touchCount = 0 si (nTaps0> 0) luego touchCount = 1 fin si (nTaps1> 0) luego touchCount = 2 fin si (nTaps2> 0) luego touchCount = 3 finalice si (nTaps3> 0) y luego toqueCount = 4 finalice si (nTaps4> 0) luego toqueCount = 5 finalice si (touchCount == this.prevTouchCount ()) luego si (touchCount == 1) luego si (nY0> this). prevY0 ()) luego 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) luego this.displayRestart () this.postEvent (1, "requestRestart") end end end end - almacena las variables de este evento para el próximo evento this.prevTouchCount (touchCount) this.prevY0 (nY0) ------- -------------------------------------------------- ----------------------- final --------------------------------------------------------------------------------
Para onTouchSequenceEnd:
función MainAI.onTouchSequenceEnd () -------------------------------------------- ------------------------------------ this.reset () --------- -------------------------------------------------- --------------------- final --------------------------------------------------------------------------------
Ahora, presiona F7 para compilar todo. Debes ver 0 errores y 0 advertencias.
Ahora, vamos a probar el juego. En el menú de la barra superior, seleccione Animación. Luego, seleccione Pantalla -> Tamaño -> Android -> 480x800 como se muestra a continuación.
Luego, seleccione Pantalla -> Modo de vista -> Tiempo de ejecución.
Presiona F9 para comenzar a animar. El juego comienza a jugar de la siguiente manera.
Tenga en cuenta que no puede mover el huevo en este punto, porque el movimiento del huevo se controla a través de los eventos táctiles de la pantalla. Por lo tanto, la prueba real de mover el huevo solo se puede realizar después de instalarlo en un dispositivo Android. Mientras se anima en el Editor de ShiVa, el pato y el huevo se moverán libremente sin ninguna entrada. Durante el movimiento libre, pueden chocar entre sí de vez en cuando. Cuando esto sucede, el pato cambiará su dirección de rotación en el eje global. También notará que después de cada colisión se abrirá un navegador para mostrar la URL http://www.stonetrip.com. Esto se debe a la siguiente línea en la función DuckAI.onSensorCollisionBegin:
... system.openURL ("http://www.stonetrip.com", "") El propósito de esta línea es hacer vibrar el dispositivo cuando ocurre una colisión. Editaremos el código Java en Eclipse para anular el system.openURL () controlador de eventos para vibrar el dispositivo en lugar de abrir un navegador. Por ahora, puedes evitar que ShiVa Editor abra un navegador automáticamente durante la animación. Para ello, comente la línea de código en DuckAI.onSensorCollisionBegin como se muestra a continuación y luego vuelva a compilar antes de comenzar la animación..
… --System.openURL ("http://www.stonetrip.com", "") Sin embargo, no olvides eliminar el doble guión (-) y recompilar todo antes de exportar el juego..
Una vez que hayamos terminado de desarrollar nuestro juego, ahora lo exportaremos para que lo utilice la herramienta de creación de ShiVa..
En el Explorador de datos, resalta la carpeta Juegos y selecciona Duck. En el menú contextual, seleccione Exportar juego como se muestra a continuación..
Seleccione una carpeta local, por ejemplo, D: \ temp. También seleccione el paquete Runtime para Android. Haga clic en Exportar. (Vea abajo.)
Aparecerá un diálogo de progreso como se muestra a continuación.
Espere hasta que finalice la exportación y presione OK para cerrar el cuadro de diálogo. Vea abajo:
Ahora, debería ver un archivo llamado Duck.stk en la carpeta local que seleccionó para exportar el juego.
En esta sección, discutiremos la herramienta de creación de Shiva. Como se mencionó anteriormente, el propósito principal de ShiVa Authoring Tool es convertir un juego, creado a través del Editor ShiVa, en una aplicación que se pueda implementar en un dispositivo en particular. A continuación, describiremos los pasos para convertir el juego en una aplicación de Android..
Como la herramienta de creación de Shiva se puede utilizar para instalar el juego en el dispositivo Android, debe preparar el dispositivo para la instalación. En primer lugar, en la configuración de la aplicación, marque Fuentes desconocidas como se muestra a continuación.
Luego, en las Opciones de desarrollo de su dispositivo, verifique la depuración USB como se muestra a continuación..
Además, asegúrese de que su dispositivo esté conectado a su máquina de desarrollo mediante un cable USB. Tenga en cuenta que cuando conecte un dispositivo Android en particular a su computadora de desarrollo por primera vez, Windows instalará el controlador de dispositivo apropiado en su computadora. Es posible que deba apuntar el Asistente para agregar hardware a la ubicación de la carpeta de instalación del SDK de Android para que el asistente encuentre un controlador adecuado.
Como hemos comentado anteriormente en el tutorial, los dos tipos de creación disponibles en Shiva Authoring Tool son Project y APK Package. La creación de Proyecto genera un proyecto de Eclipse para personalizar aún más la aplicación del juego en Eclipse. La creación del paquete APK genera un archivo APK de Android para instalar directamente la aplicación del juego en el dispositivo. Ya que queremos personalizar el juego para que vibre el dispositivo cuando ocurra una colisión, primero revisaremos el proceso de creación del proyecto..
En las instrucciones a continuación, se supone que Duck.stk está instalado en D: \ tmp. Si lo guardó en otra ubicación, cambie las instrucciones según corresponda..
En preparación para esta sección, extraiga app_icon.png y app_splash.png del archivo de descarga que acompaña a este tutorial y guárdelos en una carpeta local, por ejemplo. D: \ tmp. El archivo app_splash.png se mostrará como la página de inicio en el dispositivo para el juego cuando comience. La app_icon.png se mostrará en la pantalla de inicio del dispositivo Android como se muestra a continuación.
Muestra la herramienta de creación de Shiva. Seleccione Android en la navegación izquierda. Haga clic en la imagen de la flecha debajo de 'O comience ahora ...' como se muestra a continuación.
En el Paso 1, seleccione Duck.stk, app_icon.png y app_splash.png de las carpetas locales de su computadora como se muestra a continuación. Aquí, observe que el separador de carpeta es una barra (/), no una barra invertida (\). Presiona siguiente.
En el Paso 2 en Tipo de autoría, seleccione Proyecto. Para el tipo de identificador de paquete en un nombre, por ejemplo, com.shiva3d.demo. Este nombre corresponde al nombre del paquete de Java. Acepte los valores predeterminados para la versión y el código de la versión (ver más abajo). Haga clic en el paso 3: Construir.
En el Paso 3, seleccione Tipo de compilación: Desarrollo, y deje todas las casillas sin marcar como se muestra a continuación.
Además, haga las siguientes selecciones:
Los que se muestran a continuación.
Tenga en cuenta que nuestro objetivo principal en este tutorial es Android 3.2, para el cual se ha probado la aplicación..
Haga clic en Construir. Esto traerá la vista de la consola. Si todo va bien, verá un mensaje que dice '¡La construcción se completó con éxito!', Como se muestra a continuación. Además, en la carpeta de salida (D: \ temp) debería ver Duck_Android.zip.
Aquí, revisaremos el proceso de creación utilizado para crear un archivo APK (que es una aplicación de Android) que se puede instalar directamente en un dispositivo. Como opción, puedes instalar el juego en tu dispositivo como parte de la compilación. Para hacer esto, debe haber completado los pasos descritos anteriormente en 'Preparar el dispositivo Android para la instalación'.
Tenga en cuenta que si está creando para el paquete APK, la personalización del código en Eclipse no será posible. Como resultado, la función de vibración no estará disponible (es decir, cuando el pato y el huevo colisionen, el dispositivo no vibrará). Por este motivo, necesita editar DuckAI.onSensorCollisionBegin y comentar o eliminar la siguiente línea:
system.openURL ("http://www.stonetrip.com", "") Luego, compile y exporte Duck.stk como hicimos antes.
Ahora, muestre la Herramienta de creación de Shiva y siga los mismos pasos anteriores con las siguientes excepciones.
En el Paso 2, seleccione el tipo de creación como Paquete APK en lugar de como Desarrollo:
En el paso 3, marque Instalar en el dispositivo conectado (ver más abajo)
Cuando se completen los pasos de compilación, en la carpeta de salida debería ver Duck-debug.apk. Además, el juego debe haber sido instalado en tu dispositivo. (Tenga en cuenta que si no desea instalar la aplicación en el dispositivo como parte de la compilación, no marque Instalar en el dispositivo conectado. Puede instalar Duck-debug.apk en su dispositivo otra vez utilizando la herramienta ADB en el SDK de Android .)
En la parte 4, terminamos de codificar el EggAI y el MainAI, y realizamos pruebas de unidad animando el juego. Luego exportamos el juego desde ShiVa Editor para importar a Shiva Authoring Tool. Finalmente, discutimos dos opciones de creación diferentes en Shiva Authoring Tool, una para generar un ejecutable de Android y otra para generar un proyecto de Eclipse. En la parte 5, comenzaremos por aprender cómo personalizar el juego en Eclipse. Esto incluirá la configuración del proyecto Eclipse, los cambios de código, la creación del código Java y las bibliotecas nativas. En ese momento habremos completado el tutorial en términos de desarrollo e implementación. En el resto de la parte 5, revisaremos el código y discutiremos cómo migrar el juego a dispositivos iOS.
