Lo primero es descargase el SDK dónde vienen ejemplos, guidelines y lo que es más importante, el ejecutable Windows del motor
Os propongo la siguiente estructura de carpetas para organizar los datos (recursos) del juego. Esta estructura colgará de una carpeta raíz llamada “data”.
Os propongo la siguiente estructura de carpetas para organizar los datos (recursos) del juego. Esta estructura colgará de una carpeta raíz llamada “data”.
Textures\
Music\
Scripts\
Sounds\
Luego en la raíz del proyecto tendremos los archivos de
arranque que explicaremos más adelante junto el ejecutable Windows:
Main.pi
nlkEngine.exe
Además de estos (durante el desarrollo) tendremos el
“command.ini” que simplemente nos permite establecer unos parámetros de
arranque del ejecutable donde se indica si queremos ejecutar en debug, etc.
<command.ini>
-debug -run main.pi
Esto mismo podemos hacerlo sin el archivo “command.ini”
teniendo un acceso directo o un archivo .BAT (el ejecutable permite argumentos para configurar su inicialización, esta información se puede encontrar en la documentación adjunta al SDK)
nlkEngine -debug -run main.pi
A continuación vamos a detallar lo que ocurre una vez
arrancamos el ejecutable. Tras el arranque, antes de inicializar la pantalla,
audio, etc. Se ejecuta el script “Config.pi”. Este script indica al ejecutable
con que parámetros se quiere configurar todo.
class SERVICE
{
defines:
//
Resolucion del IPAD
RESX = 1024;
RESY = 768;
function Init ()
{
System_SetParam (SP_TITLE, "MyPROJECT");
#if __MACHINE_PC__
System_SetParam (SP_CURSOR, true);
#else
System_SetParam (SP_CURSOR, false);
#endif
System_SetParam
(SP_RESX, RESX);
System_SetParam (SP_RESY, RESY);
System_SetParam (SP_SCREENROT, 1);
// LANDSCAPE
System_SetParam (SP_BPP, 16);
System_SetParam (SP_SND_STEREO,
true);
System_SetParam (SP_SND_BITS, 16);
System_SetParam (SP_SND_FREQ,
44100);
//
NO usamos 3D asi que no consumimos memoria para esto
System_SetParam (SP_POOL_MAX3D, 0);
System_SetParam (SP_POOL_MAX3DALPHA, 0);
// reservamos 256Kb para primitivas de dibujo inicialmente
// reservamos 256Kb para primitivas de dibujo inicialmente
System_SetParam (SP_POOL_MAX2D, 256*1024);
}
}
Con <defines> crea 2 constantes globales (RESX,
RESY) que serán las que usaré durante todo el juego para hacer referencia a la
resolución de la pantalla. Hay que tener en cuenta que el motor trabaja con 2
resoluciones: La virtual y la real (la del dispositivo). La virtual es con la
que trabajamos nosotros a la hora de dibujar, posicionar cosas, etc. La real
será la que tenga la pantalla del dispositivo final. Por ejemplo: Aquí vamos a
configurar que nuestra resolución virtual es 1024x768. Trabajaremos así en todo
momento. Sin embargo, si arrancamos el juego en un IPHONE3 lo que ocurrirá es
que automáticamente todo se redimensionara a la resolución de 480x320. Esta
conversión es transparente para nosotros.
Otras cosas que hacemos en el “config.pi” es habilitar el
cursor si estamos en PC (siempre nos facilita el trabajo ver por donde llevamos
al puntero a la hora de hacer clicks). Indicar que usaremos LANDSCAPE en vez de
PORTRAIT y algunos otros parámetros de audio y video.
Tras el config, el motor se inicializa y arranca el
siguiente script “main.pi”. Realmente es el “main.pi” si no hemos establecido
ningún otro por defecto. Podríamos establecer otro script de arranque usando el
parámetro de exe “-run”.
Bien, ya estamos en el “main.pi”. Este script ha de ser
un Servicio. Los Servicio son una herramienta del motor que permite la
ejecución en hilos y síncrona de procesos.
Cuando arranca un servicio, lo primero es ejecutar su
función INIT. Tras ello, en cada frame, se ejecuta primero el MOVE y luego el
DRAW. En el MOVE actualizamos la lógica y en el DRAW procesamos primitivas de
dibujo. Cuando borramos un servicio, previo a su borrado se ejecuta la función
FINAL. Además de estas funciones también tienen la función START y STOP. Que se
invocan cuando arranca o se detiene un Servicio.
import
package "data/scripts/*.*"
class
Service
{
properties:
function Init ()
{
Render_SetProperty (RP_INRESX,
1024);
Render_SetProperty
(RP_INRESY, 768);
//
Determinamos los paths por defecto para texturas, scripts, musica y fx
System_SetDirectory (DIRECTORY_GAME,
"data/");
System_SetDirectory
(DIRECTORY_TEXTURE, "textures/");
System_SetDirectory
(DIRECTORY_SCRIPT, "scripts/");
System_SetDirectory
(DIRECTORY_MUSIC, "music/");
System_SetDirectory
(DIRECTORY_SOUND, "sound/");
//
Arrancamos el modulo de juego
game
= Service_Run ("game", "game.pi");
}
function Final ()
{
}
function Start ()
{
}
function Stop ()
{
}
function
Move ()
{
}
function
Draw ()
{
}
}
Bueno, pues así comienza la ejecución de cualquier
aplicación o juego en nlkEngine. A partir de aquí ya es cuestión de cómo se
organicen los datos y el código. Todo se puede hacer de muchas formas
distintas. Nosotros vamos a proponer la siguiente estructura de scripts que
ubicaremos en “data/scripts/”.
Game [Service]
Aquí
se centraliza todas las partes de nuestro juego (menu, pantallas, etc.). Será
la columna vertebral del mismo.
Menu
Módulo
que se encargará de gestionar el menú del juego. A partir de aquí, según el
nivel de nuestro menú igual se requieren de submodulos, etc. Según la
profundidad y complejidad del sistema de menú.
HUD
Módulo
encargado de representar el interface del juego mientras se juega.
Stage
Módulo
encargado de gestionar un escenario o pantalla.
Player
Módulo
encargado de controlar al jugador y gestionar sus acciones.
No hay comentarios:
Publicar un comentario