Crónicas D+D Engine: Todo sigue en pie.

Luego de un periodo de oscuridad.

La luz encontró su camino.

Primero: ¿Por qué la ausencia de entradas?, es porque estoy rindiendo un par de finales.
Segundo: ¿El proyecto sigue en pie?: Obviamente que si!

Novedades:

Los objetos que se encargan del sonido están desarrollados a un 50%. En teoria andan bien, pero quiero pulir varios detalles para que quede un poco más que usable.

Por otro ladro el objeto Teclado ha sufrido una evolución. Tiene nuevos atributos y métodos que permiten lectura de string del teclado.
Los nuevos metodos son:

std::string getBufferString(); Devuelve lo leido por el teclado.
void vaciarBufferString(); Limpia lo leido por el teclado.
void activarLecturaString( bool terminarConEnter); Activa la lecutra de string, y ademas se debe especificar si esta lectura termina o no cuando se presiona la tecla enter.
void activarLecturaString( bool terminarConEnter, const char * txtInicial); Esta es similar a la anterior ( de hecho esta llama a la anterior internamente) pero con el agregado que se setea el texto leido en un determinado valor, para permitir escribir desde ahi.
void desactivarLecturaString(); Desactiva el leer string.
bool isActivadaLecturaString();Devuelve si esta activada la funcion de lectura
void dibujarLecturaString(Pantalla * pantalla, int x, int y, Uint32 color); Dibuja lo que esta escribiendo con un cursor incluso. La fuente con que se escribe es la asignada al objeto pantalla, si no se ha asignado ninguna fuente todavía se arroja una excepcion

Por último el objeto pantalla esta sufriendo modificaciones para completar las funcionalidades que debe tener. Además todavía me falta implementar el patrón SINGLETON, para hacer que solo se pueda crear solo uno de estos objetos por programa, como debería ser.

Eso es todo por ahora, los mantendré informados. Apartir de mañana sigo trabajando con más intensidad porque rindo el ultimo final y voy a tener mas tiempo libre.

Una ultima cosa, el release del proyecto será en forma de DLL y el codigo fuente no será revelado (Bueno solo lo compartire en privado con la gente que me lo pida explicitamente o bien que ya me lo haya pedido :p) pero creo será freeware o algo asi (antes tengo que investigar un poco sobre licencias jeje.)

Un saludo.

Crónicas D+D Engine: En la recta final.

Ya falta poco.
No nos pongamos a definir poco ;)

¡Que kilombo! Bueno ahi se ven primitivas, sprites, fuentes subrayadas, y etc......

Bueno como el título dice ya casi estoy en la recta final. ¿Y que hay hecho hasta ahora?:

Mouse. (Nuevo)
Teclado.

Pantalla.

ControlFPS.

ObjetoMovil.

Particula.(Nuevo)
ImagenFuente.
Fondo.
TileSet.
Sprite.

Bueno y que falta:

SistemaDeParticulas. ( Similar al de GM, pero diferente :p )

TileSetScrolled (Realmente no se si sera util asi que dudo todavia si lo implemento o no.)

Sonido.
Reproductor.

Las novedades:
Mouse: bueno pense que iba a ser más complicada de implementar pero resulto asombrosamente mas sencillo de lo que esperaba. Es más no tube que mirar ejemplos, la documentacion de SDL lo tenia todo.
Hay una funcion muy util llamada: Uint8 SDL_GetMouseState(int * x,int * y); la cual en la x e y nos deja la posicion del mouse obviamente y nos devulve un entero de 8 que nos sirve para verificar el estado de los botones.
Es sencillo de usar, he aqui el metodo actualizar del objeto Mouse;

void Mouse::actualizar()
{
SDL_PumpEvents();

Uint8 e;
e = SDL_GetMouseState(&x,&y);

for (int i=1; i<=5; i++) { old[i]=botones[i]; botones[i] = e & SDL_BUTTON(i); } }

Por otro lado esta la Clase Particula (La cual pienso ampliar más) que hereda de ObjetoMovil. Por lo tanto ya esta resuelto todo lo que influye al movimiento de las mismas. Por ahora tiene varios tipos de particulas: LINEA,CUADRADO,CIRCULO,TRIANGULO,LINEA_MOV,TRIANGULO_MOV, SPRITE.

Las que terminan en MOV quiere decir que su forma se ve afectada por el movimiento de la particula.
Tambien tiene tamaño, y se le puede asignar un sprite (aunque todavia esta medio rustico el asunto). Cuenta ademas con un atributo crecimiento que hace crecer o decrecer el tamaño la particula.
Resta agregar y diseñar el comportamiento para modificar el color de la particula (Algo asi como desplazamiento de alpha y mezclas de color), y tambien agregar mas formas MOV, u otro tipo que se me ocurra.

Con respecto a las clases relacionadas al sonido todavia nos las diseñe porque no conozco la forma en que se usan en SDL. Asi que no hay mucho que decir.

Por otro lado la clase SistemaDeParticulas va a ser una clase contenedora que manejara una lista de particulas dinamicas, la cual se va a encargar de eliminar y crear las instancias de Particulas segun algunos metodos.

Eso es todo por ahorªaAaa!

Crónicas D+D Engine: Curiosidades de SDL

Entrada sabor tutifruti.
Pero con pocas ganas de escribir :p

Bueno esta pequeña entrada es para comentar algunas curiosidades de SDL y etc...

Bueno la primera impresion que todos tenemos de SDL es sencilla. ¡Wau! Que linda librería portable.
Ahora bien cuando empezamos a ver en detalle vemos algunas durezas y que si bien es una API bastante completa, le falta un poco más para poder ser usada comodamente. Gracias a muchos desarrolladores disponemos de librerías complementarias para ampliar el poder de SDL (SDL_Image, SDL_tff, SDL_gfx, SDL_Mixer) y es por esto que en mi opinion SDL se gana unos buenos puntos.

Para alguien con experiencias incorporar las librerías extras no son mucho trabajo, no obstante si sos (como yo) principiante en este asunto te va a costar un poco.

Bueno como dije esta entrada iba a tratar de las curiosidades de SDL y algunos extras, asi que a eso voy.

La primera que me encontre, no fue mas que por parte de mi ignorancia. Cuando estaba implementando la clase Teclado, pense que el array de teclas sería de un tamaño de 255, pero al probar los metodos de esta clase me di cuenta que algo andaba mal. En si el array tiene 322 elementos que corresponden a distintas teclas del teclado (Si ya se el teclado solo tiene 101 teclas) pero bueno, esto es así para simplificarnos las cosas.

La segunda que me encontre fue la del formato de color. Podemos encontrarnos con dos formatos: SDL_Color, y usando un Uint32 de esta manera 0x00RRGGBB. Bueno no se porque se termino implementando SDL_Color ya que la notacion de un Uint32 es bastante simple y cómoda. Como condimento extra si incorporamos SDL_gfx encontramos con que este ultimo complemento expresa los Colores asi 0xRRGGBBAA (Esta AA es el Alpha), la cual es muy comoda y mas copleta que las anteriores; no obstante hay incompatibilidad entre ellas.

A quien le interese les regalo una pequeña funcion para descomponer un color de SDL_gfx (es decir en formato 0xRRGGBBAA):

void getComponentesRGBA(Uint32 color, int & r, int & g,int & b, int & a)
{
r = (0xFF000000 & color) / 0x01000000;
g = (0x00FF0000 & color) / 0x00010000;
b = (0x0000FF00 & color) / 0x00000100;
a = (0x000000FF & color);
}

Bueno la función mediante un and con una máscara y una división nos devuelve los componentes del color; esta fue la solución más eficiente que se me ocurio. Capaz que a alguien le sirva tambien :)

Otra curiosidad es que con SDL pelado, podemos dibujar rectangulos rellenos pero no asi bordes de rectangulos.

Bueno como dije son curiosidades nada que ver con errores ni nada de ello. Lluego sigo la lista pero por ahora queria nombrar la optimizacion de algunas cosas en el engine y como muestra de ello de nuevo el "hola mundo".

    #include
    #include "Pantalla.h"
    #include "ControlFPS.h"
    #include "TrueFont.h"
    #include "Teclado.h"

    Pantalla * pantalla;
    Teclado * teclado;
    TrueFont * fuente;
    ControlFPS * timer;

    int main (int argc, char *argv[])
    {
    bool termino=false;
    int xTexto=0;


    /*Se inicializa el subsitema de video y se crea la surface de dibujo, de tamaño 640,480 con
    Bufer y superficie por software, mas un modificador extra para las banderas de inicializar
    SDL_video en este caso nada extra */

    pantalla = new Pantalla(640,480, 0);

    teclado = new Teclado(); /* Se crea el objeto teclado */

    timer = new ControlFPS(); /* Se crea el objeto que se encargara de controlar los FPS*/

    fuente = new TrueFont("fuente.ttf",16); /* Se crea la fuente especificando ruta y tamaño*/

    pantalla->setFuente(fuente); // se asigna la fuente a la maquina de escribir de la pantalla.

    while (!termino) {
    timer->actualizarTimer(); // se toma la medida

    teclado->actualizar(); // se lee el estado de las teclas

    xTexto+=4; // para mover el texto
    if (xTexto>640) {xTexto=0};

    /* si se presiona la tecla escape sale del juego. */
    if (teclado->isTeclaSePresiona[SDL_ESCAPE] ) { termino = true;};

    // limpia la pantalla
    pantalla->limpiar(pantalla->NEGRO);

    // escribe el texto en pantalla
    pantalla->dTexto("¡Hola mundo!",xTexto, 240,pantalla->BLANCO);

    // vuelva el buffer en pantalla
    pantalla->renderizar();

    timer->controlarTiempoMax(30);// hace que el timer haga durar cada
    // step comominimo 30

    }

    };

No es la gran cosa pero hace mas transparente el manejo de la escritura de texto.

¡Hasta la proxima!

Crónicas de "D+D Engine": Una muestra Gratis.

Porque lo bueno tambien viene en paquetes pequeños.

Con ganas de presumir lo que llevo hecho XD

Bueno andaba con ganas de mostrar. Lo que tenia hecho:

¡Tan tan! Si... eso es todom bueno para el ojo del aficionado. Que se ve en esta scr_shot ademas de incoherencias:
En primer lugar el logo :) .

En segundo lugar se ve un fondo aplicado con alpha a la mitad con repeticion vertical y horizontal ademas de con hspeed y vspeed (Anque no se note en una screenshot obviamente).

Luego se ve escrito "tecla esta suelta" lo que muestra varias cosas, en primer lugar que tecla esta suelta (jeje) y lo otro es la clase MaquinaDeEscribir y la Clase Teclado funcionando al 100%!

Otra cosa más, casi imperceptible, es un pixel blanco en la esquina superior derecha. Bueno este pequeño pixel queire decir que tuve éxito incorporando (para lo cual soy malisimo) la libreria SDL_gfx! Que conoci gracias por la recomendacion de Adva como siempre.

Bueno eso era lo que queria presumir.... no mentira tambien tengo algo de codigo fuente para presumir :O:

Es un ejemplo de "Hola mundo" animado con D+D Engine:

Codigo:

#include
#include "Pantalla.h"
#include "ControlFPS.h"
#include "TrueFont.h"
#include "MaquinaDeEscribir.h"
#include "Teclado.h"

Pantalla * pantalla;
Teclado * teclado;
TrueFont * fuente;
MaquinaDeEscribir * maquina;
ControlFPS * timer;

int main (int argc, char *argv[])
{
bool termino=false;
int xTexto=0;

/* esto es temporal, pero por ahora funciona asi, este es el color negro y el blanco */
SDL_Color negro, blanco;
negro.r = 0;
negro.g= 0;
negro.b = 0;

blanco.r = 255;
blanco.g= 255;
blanco.b= 255;

/*Se inicializa el subsitema de video y se crea la surface de dibujo, de tamaño 640,480 con
Bufer y superficie por software, mas un modificador extra para las banderas de inicializar
SDL_video en este caso nada extra */

pantalla = new Pantalla(640,480, 0);

teclado = new Teclado(); /* Se crea el objeto teclado */

timer = new ControlFPS(); /* Se crea el objeto que se encargara de controlar los FPS*/

fuente = new TrueFont("fuente.ttf",16); /* Se crea la fuente especificando ruta y tamaño*/

maquina = new MaquinaDeEscribir(); /* Se crea el objeto que se encarga de escribir */
maquina->setFuente(fuente); // se asigna la fuente.

while (!termino) {
timer->actualizarTimer(); // se toma la medida
teclado->actualizar(); // se lee el estado de las teclas

xTexto+=4; // para mover el texto
if (xTexto>640) {xTexto=0};

/* si se presiona la tecla escape sale del juego. */
if (teclado->isTeclaSePresiona[SDL_ESCAPE] ) { termino = true;};

// limpia la pantalla
pantalla->limpiar(negro);

// escribe el texto en pantalla
maquina->escribir("¡Hola mundo!",xTexto, 240, blanco, pantalla);

// vuelva el buffer en pantalla
pantalla->renderizar();

timer->controlarTiempoMax(30);// hace que el timer haga durar cada
// step comominimo 30

}

};

Bueno aunque el codigo no es muy corto, es muy sencillo de leer y en estas lineas esta lo basico para hacer un pequeño juego si la complicamos un poco mas. Por lo que se puede ver se nombra a SDL simplemente para SDL_color, pero planeo cambiar esto en el futuro.
Los mismos objetos se encargan de inciar y de dar de baja los modulos de SDL.

Ahora si eso es todo! Espero que les parezca interesante, comenten y critiquen todo lo que quieran!

Un saludo!