Demo en curso esenthel

[IsGreen]

Este es el enlace de descarga de la demo que estoy realizando con Esenthel (lenguaje de programación C++). demostracion.

Incluye:
-Código de programación.

Recursos del juego.

Todos los tutoriales.cpp de Esenthel en un archivo.html.

Pequeña guía Blender&Mesh editor.



Tareas pendientes de realizar:
-Sonido.

Interfaz o Hud.

Menú.

Crear más tipos de enemigos.

El código ya funciona con los elementos básicos del juego.

Si alguien está interesado en agregar o mejorar código para la demo que lo deje en este mensajes. Saludos.

Información sobre el motor de juego: https://www.foro3d.com/f113/Esenthel...ón-70205.html.

[pigo0019]

Muchas gracias por el código, de inmediato le echaré un vistazo, te dejo un saludo desde México.

[IsGreen]

Saludos.



Este es el código de lo que sería el menú del juego. Primero, deberían ejecutar el tutorial de la SDK situado en advanced\2 - Animation, physics, rendering\rendering\20 - Volumetric clouds, cpp, y generar las texturas y el archivo con la configuración establecida.

/******************************************************************************/.
#include stdafx.h.
/******************************************************************************/.
// global variables.

Mesh meshplane.

Matrix matrixplane.

Char8 *cctext[7]={player,dificulty,start,easy,normal,expert,insert name}.

Flt posiciontexto[6][4]={0.514f,0.357f,0.885f,0.235f, 0.443f,0.058f,0.952f,-0.06f, 0.552f,-0.243f,0.855f,-0.354f, 0.55f,0.357f,0.847f,0.239f, 0.495f,0.056f,0.912f,-0.052f, 0.498f,-0.243f,0.906f,-0.357f}.

Str name.

I8 indicemenu (0), dificulty(0).

Flt incx, incy, incz.
// general functions.

Void actualizarraton(vec2 pos) {.

Switch (indicemenu) {.

Case 0 : {.

Frep(3) if ((pos.x>posiciontexto[i][0])&&(pos.x<posiciontexto[i][2])&&(pos, y<posiciontexto[i][1])&&(pos, y>posiciontexto[i][3])) indicemenu=i+1.

Break.
}.

Case 2 : {.

Frep(3) if ((pos.x>posiciontexto[i+3][0])&&(pos.x<posiciontexto[i+3][2])&&(pos, y<posiciontexto[i+3][1])&&(pos, y>posiciontexto[i+3][3])) dificulty=i.
}.
}.
}.
/******************************************************************************/.

Void initpre ().
{.

App, name (Volumetric clouds).

App, flag=ap_full_togle.

Iopath(./data).

Pakadd(engine, pak).full(true), ambmode (amb_high4), ambpower(0.3), HDR(true), hdrmaxbright(1.5), hdrexposure (0.7).
}.
/******************************************************************************/.

Bol init().
{.

Sky, set().

Sun &sun=suns. New(), // create a new Sun in suns container.

Sun, set(*gfxs(GFX/sky/sun, GFX)), // set image.

Sun, pos=.vec(-20000,-5800,-5000), // set custom position.

Sun, rays, color, set(0.3f,0.2f,0.1f).

Sun, size=0.2f.

Sun, rays, mode=sun_rays_high.

Clouds, Volumetric, set(gfxs(localdata/cloud, GFX),gfxs(localdata/detail, GFX)).

Clouds, Volumetric, load(localdata/volumetric_clouds).

Meshplane, load(localdata/obj/glider/glider, Mesh).

Meshplane, mirrory().

Setrender().

Matrixplane, setscale (1).

Move (vec(-62,76,34)).

Orn, setrotatey(-1.7f).

Scale (40).

Cam, Matrix.move (vec(0,65,0)).

Cam, setangle (Cam, Matrix.pos,1.57f,0.2f,3.1415f), updatevelocities(), set().

Incx=randomf()/10, incy=randomf()/10, incz=randomf()/10.

Return true.
}.
/******************************************************************************/.

Void Shut().
{.
}.
/******************************************************************************/.

Bol main().
{.

If(kb, bp(kb_esc)) if (indicemenu==0) {return false;} else {indicemenu=0, return true;}.

If ((kb, bp(kb_back)) && (indicemenu==1) && (name, length()>0)) {name, removelast(), return true;}.

If((kb, c()) && (indicemenu==1) && (name, length()<15)) {name+=kb, c(), return true;}.

If (ms, b(0)) actualizarraton(ms, pos).
// if (indicemenu==3) run_game.

Clouds, Volumetric, update (vec2(4,4)).

Return true.
}.
/******************************************************************************/.

Void render().
{.

Switch(renderer()).
{.

Case rm_solid:
Matrixplane, move (vec(incx,incy,incz)).

If ((matrixplane, pos.x>-42) || (matrixplane, pos.x<-82)) incx=-incx.

If ((matrixplane, pues, y>96) || (matrixplane, pues, y<56)) incy=-incy.

If ((matrixplane, pues, z>54) || (matrixplane, pues, z<20)) incz=-incz.

Meshplane, draw(matrixplane).

Break.
}.
}.

Void draw().
{.

Renderer(render).

Textds TDS.

Tds, color=grey_dark.

Tds, scale*=2.

Tds, shadow=64.

Switch (indicemenu) {.

Case 0 : {.

Frep(3) d.text(TDS,0.7f,0.3f-i*0.3f, cctext[i]).

Break.
}.

Case 1 : {.text(TDS,0.75f,0.25f, cctext[6]).

Tds, align, set(1,0).

Tds, color=grey_dark2.

Tds, shadow=0.

If ((int)tm, time ()%2==0) d.text(TDS,0.25f,0,s+name+_), else d.text(TDS,0.25f,0,name).

Break.
}.

Case 2 : {.

Frep (3) {.

If (dificulty==i) {TDS, color=grey_dark2;} else {TDS, color=grey;}.text(TDS,0.7f,0.3f-i*0.3f, cctext[i+3]).
}.
}.
}.
//d.text(0,-0.8,s+ms, pos).
}.
/******************************************************************************/.

[IsGreen]

Nuevo código demo en curso. http://www.spedyshare.com/195238708.html.

Añadido terreno creado con el world editor.

Crear y eliminar copias de las estructuras del juego utilizando contenedores de memoria (nodos, memoria dinámica).

Añadida interfaz de juego.

Música y sonido.

Mejorado código, simplificando procesos del juego y reduciendo el número de variables utilizadas.



Para la creación del terreno en un archivo (*.mshg) (Mesh group) donde podemos aplicar varios materiales sobre una malla, primero, creamos el escenario desde el world editor y después ejecutamos la acción construir desde el menú main->build. Si el escenario creado esta formado por varias áreas o superficies durante la construcción del escenario se habrán generado varios archivo (*.mshg). Por esta razón he creado un escenario compuesto por una única superficie o área.

El world editor detecta automáticamente los materiales disponibles para la creación del escenario desde la carpeta mtrl situada en la ruta establecida al iniciar por primera vez el world editor o el Mesh editor, pero también, he tenido que copiar los materiales utilizados en la creación del archivo (*.mshg), en la carpeta del motor de juego data/mtrl y así ser utilizado desde el código del programa.

Partes del código:

// archivos de cabecera.
#include.
// definir nombre de macros.
#define.
// variables globales.
// declaración de estructuras o clases. Tú puedes crear copias durante este proceso (memoria estática).
// crear copias de estructuras/clases (memoria estática) o crear contenedores de memoria (nodos) de estructuras/clases del juego (memoria dinámica).
// funciones generales.
// definición estructuras o clases.
// funciones del motor de juego Esenthel.
// Void initpre () {. }.
// bol init () { desde aquí, realizamos la construcción de las copias de las estructuras/clases de memoria estática}.
// Void Shut {}.
// bol main { aquí, creamos y eliminamos las copias de estructuras/clases que utilizan memoria dinámica (contenedores de memoria) }.
// Void draw() {}

Para crear contenedores de memoria, he utilizado el contenedor de tipo memx.

Características de este tipo de contenedor de memoria (memx):
Ventajas:
Rápido (ligeramente más lento que memb).

Baja fragmentación de memoria.

Rápido acceso a i-th elemento (nodos).

Calculo inmediato del índice de elementos.

La eliminación de cualquier elemento es sencillo.

La eliminación de elementos no cambia la dirección a memoria de otros elementos.

Desventajas:
La inserción manual de elementos antes que otros no está disponible.

Declaración del contenedor de memoria memx:

memx <tipodedato> nombrecontenedor;

Crear nuevo nodo con la función new(). También, añadimos el nombre de la función constructora (en este caso activar ()).

nombrecontenedor. New(), activar(),

Actualizar contenedor y eliminar elemento i-th o nodo si es necesario. Utilizaremos la macro repa (dato) (del inglés repeat all, es decir, repetir todo que genera un bucle que se repite tantas veces como el número de elementos existentes del tipo de dato establecido entre paréntesis) para recorrer todos los nodos y ejecutar la función de actualización (en este caso actualizar()). Añadimos la condición donde si inactivo es verdadero, eliminamos el elemento i-th o nodo en curso.

repa (nombrecontenedor) {.

Nombrecontenedor[i], actualizar().

If (nombrecontenedor[i]. Inactivo) nombrecontenedor, removevalid(i).
}

Dibujamos desde la función render del programa que utiliza los modos de renderizado del motor de juego (rm_solid, rm_light, rm_blend.) mediante la función de dibujo (en este caso dibujar()).

repa (nombrecontenedor) {.

Nombrecontenedor[i].dibujar().
}

También, he añadido algunas líneas de código en la fución Shut del motor de juego para limpiar los contenedores de memoria.

nombrecontenedor, clear(),

No he utilizado funciones virtual en las estructuras del juego porque necesito ejecutar la función actualizar() individualmente para eliminar los nodos en los contenedores de memoria, o algunos elementos del juego son renderizado desde varios modos.

Para calcular el movimiento de los disparos del enemigo, he utilizado:
Vec dir = (vec posición del objetivo - Vec posición inicial) * tm, d() * _velocidad_ / Dist (vec posición del objetivo, Vec posición inicial).

Donde _velocidad_ es el nombre de una macro que representa el valor asignado a la velocidad de movimiento, y Dist es una función del motor de juego que calcula la distancia entre dos puntos. Esta es la mejor fórmula que conozco para calcular el desplazamiento del objeto (disparo del enemigo). Después, aplicaremos el Vector dirá la Matrix del objeto con la función move () (es decir, mover).

matrixdisparoenemigo, move (dir),

La barra de energía del jugador está formada por dos imágenes. Estas imágenes fueron convertidas desde el formato (*.png) al formato.GFX utilizado por el motor de juego mediante la herramienta converter tool, que emplea varios formatos de pixel:
Dxt3: (compressed, 4-bit nonpremultiplied alpha).

Dxt5: (compressed, interpolated nonpremultiplied alpha).

A8r8g8b8: (32 bits per píxel, a: 8, r: 8, g: 8, b: .

X8r8g8b8: (32 bits per píxel, a: x, r: 8, g: 8, b: .

A8: (8 bits per píxel, alpha: .

L8: (8 bits per píxel, luminance:.

A8l8: (16 bits per píxel, a: 8, l:.

Más información: http://msdn.Microsoft.com/en-us/library/bb322854.aspx.

La opción mipmap se encuentra establecida inicialmente en el converter tool (en la pestaña GFX). Durante la conversión en formato.GFX, he desactivado esta opción y he seleccionado el formato de píxel a8r8g8b8 que guarda la imagen junto al canal alpha.

Deberemos arrastrar y soltar el archivo imagen desde el explorados de Windows hasta el converter tool. Entonces podremos renderizar la imagen desde el modo rm_blend. Saludos.