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 tercera entrega de la serie, en la que aprenderá cómo editar las escenas de un juego y comenzar a codificar los modelos AI..
En la parte 2, comenzamos describiendo cómo desarrollar el juego utilizando ShiVa Editor. Presentamos los módulos del Editor ShiVa utilizados en el desarrollo de la aplicación tutorial y hablamos sobre los archivos de modelos de Collada que representan a los personajes principales de la aplicación. Luego discutimos algunos pasos iniciales necesarios para crear la aplicación, como crear el juego y la escena e importar los modelos de Collada. En la parte 3, mostraremos cómo editar la escena de nuestra aplicación. También comenzaremos a ingresar el código para los AIModels del juego. En particular, introduciremos el código para el DuckAI..
Ahora vamos a establecer varias propiedades de la escena..
Suponemos que el archivo de imagen marble.jpg se ha copiado en la carpeta llamada D: \ temp \ skybox. En su entorno, si copia el archivo en otra ubicación, asegúrese de cambiar las instrucciones a continuación como corresponde..
En el DataExplorer, vaya a Importar -> Textura. En el cuadro de diálogo, seleccione el archivo como se muestra a continuación y haga clic en Importar.
Ahora, en la carpeta Texturas del DataExplorer, debería ver una textura llamada mármol.
Vamos a editar varios atributos de la escena usando el editor de ambiente. Muestre el Editor de ambiente y el Explorador de datos de lado a lado y haga doble clic en MyScene en la carpeta Escenas. En este punto, es posible que se le solicite que guarde la escena, como se muestra a continuación. Haga clic en Sí y cierre el diálogo..
Ahora, el Editor de ambientes y el Explorador de datos deberían verse juntos de la siguiente manera.
En la sección Iluminación, ajuste el color del tragaluz para obtener un tono amarillo descolorido como se muestra a continuación.
Para cada uno de los elementos de la caja del cielo en la sección Cielo, seleccione la canica.
Lleve el Editor de juegos y el Explorador de datos de lado a lado. Seleccione Duck -> Juegos en Data Explorer y haga doble clic en Duck. Esto abrirá el juego en el Editor del juego. Seleccione Recursos -> Fuentes en el Explorador de datos. En el Editor de juegos, presiona la pestaña Recursos. Arrastre y suelte la fuente predeterminada desde el Explorador de datos en la pestaña Recursos (ver más abajo).
Ahora añadiremos una etiqueta al huevo. (Un objeto se puede buscar y ubicar en un juego mediante programación en función de su etiqueta). Traiga el Explorador de escenas y el Explorador de datos lado a lado. En Data Explorer, seleccione Duck -> Scenes -> MyScene y haga doble clic. En este punto, es posible que se le solicite que guarde MyScene de la siguiente manera. Haga clic en Sí y cierre el diálogo..
En el Explorador de escenas, resalte la esfera y, en el menú contextual, seleccione la etiqueta Editar selección. En el cuadro de diálogo, escriba 'huevo' para la etiqueta. Esos pasos se muestran en las dos imágenes consecutivas a continuación.
Ahora crearemos los AIModels y el código asociado para nuestro juego. Recuerde de la discusión anterior que los AIModels representan el comportamiento de los objetos en un juego. El pato y el huevo tendrán cada uno sus propios AIModels, DuckAI y EggAI respectivamente. Además, el juego en sí tendrá su propio AIModel, llamado MainAI. MainAI será responsable de inicializar la cámara y la escena, así como de procesar y enviar los eventos de los usuarios..
Primero revisemos algunos de los conceptos relacionados con AIModels, tomando información prestada de la documentación de ayuda de ShiVa Editor..
Comencemos ahora a definir los AIModels en nuestro juego. Muestre el Explorador de escenas y el Explorador de datos uno al lado del otro y haga doble clic en MyScene en el Explorador de datos en la carpeta Escenas. (Si se le solicita, guarde MyScene y cierre el cuadro de diálogo). En el Explorador de escenas, seleccione la pestaña Objetos y seleccione la tecla de pato, luego haga clic con el botón derecho en Controladores -> AI -> Crear AI. Esto se muestra a continuación.
Nombre la IA como DuckAI en el diálogo como se muestra a continuación y presione OK.
De manera similar, en la pestaña Objetos del Explorador de escenas, seleccione la esfera, luego haga clic con el botón derecho en el menú Controladores -> AI -> Crear AI. Nombre la AI como EggAI en el diálogo y haga clic en Aceptar.
En el Explorador de datos, seleccione Crear -> Recurso -> AIModel (ver más abajo). Nómbrelo MainAI.
En Data Explorer, ahora debería ver tres AIModels en la carpeta Recursos -> AIModels: DuckAI, EggAI, MainAI. Abra el Editor de juegos y el Explorador de datos de lado a lado. En Game Editor, selecciona la pestaña Principal. Desde Recursos -> carpeta AIModels, arrastre y suelte MainAI en el área de texto de User MainAI en Game Editor (ver más abajo).
Ahora, abra el Editor AIModel y el Explorador de datos lado a lado. Haga doble clic en DuckAI, EggAI y MainAI. Debería ver una pestaña separada para cada uno de los AIModels en AIModel Editor como se muestra a continuación.
En la pestaña DuckAI, haga clic en Agregar variable y agregue una variable de tipo booleano. Nombre es Positivo, siendo verdadero el valor inicial (que se muestra a continuación). Haga clic en Aceptar para cerrar el cuadro de diálogo..
De manera similar, agregue una variable llamada 'puntuación' donde el tipo sea 'número' y el valor inicial sea 0. Incluso si lo escribe como 0, la variable se inicializará como un flotador, es decir, 0,000.
Aún en la pestaña DuckAI, haga clic en Agregar controlador -> onEnterFrame, como se muestra a continuación.
Del mismo modo, haga clic en Agregar controlador -> onInit. Finalmente, haga clic en Agregar controlador -> Controlador de objetos -> onSensorCollisionBegin (ver más abajo).
Ahora, la pestaña DuckAI se verá como la siguiente.
Trae el Editor AIModel y el Editor de secuencias de comandos de lado a lado. En la pestaña DuckAI del Editor de AIModel, haga doble clic enInit (). Un código de esqueleto para esto se abrirá en el Editor de secuencias de comandos como se muestra a continuación.
Copie y pegue lo siguiente en el editor de secuencias de comandos, reemplazando completamente el código existente (en una sección posterior se dará una revisión del código). En el Editor de secuencias de comandos, haga clic en Control + S para guardar la secuencia de comandos..
Accentsconagua
función DuckAI.onInit () -------------------------------------------- ------------------------------------ object.setTranslation (this.getObject (), 2, 3, 2, object.kGlobalSpace) local lUser = application.getCurrentUser () local lComp = hud.newComponent (lUser, hud.kComponentTypeLabel, "HUD.disp") if (lComp ~ = nil) entonces hud.setComponentPosition (lComp, 75, 7 ) hud.setComponentSize (lComp, 30, 10) hud.setComponentBackgroundColor (lComp, 0, 0, 0, 0) hud.setComponentBorderColor (lComp, 0, 0, 0, 0) hud.setComponentVisible (lComp, true) hud.setComponentComponentZOrder (lComp, 255) hud.setLabelText (lComp, string.format ("Score:% 2i", this.score ())) hud.setDefaultFont (lUser, "DefaultFont") hud.setLabelTextHeight (lComp, 100) hud.setLabelTextAlignment (lComp, hud.kAlignCenter, hud.kAlignCenter) end -------------------------------------- ------------------------------------------ final -------------------------------------------------------------------------------- De manera similar, reemplace el código de onEnterFrame de la siguiente manera.
función DuckAI.onEnterFrame () -------------------------------------------- ------------------------------------ local lObject = this.getObject () if (this.isPositive ( )) luego object.rotateAroundTo (lObject, 0,0,0,0,0.75,0, object.kGlobalSpace, 0.5) else object.rotateAroundTo (lObject, 0,0,0,0, -0.75,0, object.kGlobalSpace , 0.5) final local x, y, z = object.getRotation (lObject, object.kLocalSpace) object.setRotation (lObject, x + 0.3, y + 0.5, z + 1, object.kLocalSpace) ------- -------------------------------------------------- ----------------------- final --------------------------------------------------------------------------------
Luego, reemplace el código de onSensorCollisionBegin con lo siguiente:
función DuckAI.onSensorCollisionBegin (nSensorID, hTargetObject, nTargetSensorID) --------------------------------------- ----------------------------------------- this.score (this.score () +1) local lComp = hud.getComponent (application.getCurrentUser (), "HUD.disp") if (lComp) luego hud.setLabelText (lComp, string.format ("Score:% 2i", this.score ()) ) finaliza if (this.isPositive ()) y luego this.isPositive (false); de lo contrario this.isPositive (true) end system.openURL ("http://www.stonetrip.com", "") ------ -------------------------------------------------- ------------------------ final -------------------------------------------------------------------------------- Ahora hemos terminado con las variables y el código para DuckAI.
En la parte 3, mostramos cómo editar la escena de nuestra aplicación. También comenzamos a ingresar el código para los AIModels del juego. Hasta el momento, hemos completado el código para el DuckAI. En la parte 4, terminaremos de codificar 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 de creación diferentes en la Herramienta de creación de Shiva, una para generar un ejecutable de Android y otra para generar un proyecto de Eclipse.
