no te juzgo siento si te he dado esa impresión

ya esta modificado tu nick en el post principal por nanodiLL0. 

Hola a todos

eXeDestr0yer siento mucho no haber puesto el tutorial fue por falta de tiempo por que no tenia enlace, si no que me lo pusiste directamente en el correo

Pero ya he vuelto de las vacaciones y lo he actualizado.

Te has cambiado otra vez el nick??? ya no se que nick ponerte en la lista  

TrashAmbishion me has mandado al correo la solución del reto 5, ya estamos fuera de fecha, pero no pasa nada si me mandas el tutorial lo pongo en el reto.

Flamer en octubre puedes seguir contando conmigo  

Un saludo
Kaltorak.

 

Me alegra mucho saber que les a gustado  

Muchas gracias por el apoyo.

Un saludo
Kaltorak.

Hola a todos

He creado este manual, por petición de Dato000 miembro del grupo de desarrollo de videojuegos al que pertenezco,  en el voy a realizar una versión simple del videojuego Snake(o serpiente), usando C++ y la librería gráfica SDL, veréis que con apenas 280 lineas de código, contando espacios y comentarios se puede hacer el videojuego Snake(o serpiente) y que no es tan difícil como parece.

Espero que este manual le sea de ayuda a la gente que se apunto al reto y no pudo resolverlo, o para todo aquel que alguna vez a querido realizar el videojuego Snake(o serpiente) y no ha sido capaz.

Voy a empezar poniendo el código completo, para después ir explicándolo  linea a linea, doy por sentado que el lector de este manual tiene una mínima base de programación en C o C++.

//Juego Snake realizado por kaltorak para el manual Snake en SDL/C++
 
#include <cstdlib>
#include <vector>
#include <time.h>
#include <SDL/SDL.h>
 
//Prototipo de la funcion Colision.
int Colision(SDL_Rect,SDL_Rect);
 
//Prototipo de la funcion Iniciar.
void Iniciar(void);
 
/*definimos la direcciones que pude tomas la seriente con esto conseguimos que el codigo sea mucho mas
  mas comprensible*/
#define Arriba 1
#define Derecha 2
#define Abajo 3
#define Izquierda 4
 
/*Declaramos e inicializamos como constantes el ancho, el alto y la profundidad de color
  de la ventana principal.*/
const int ResolucionX = 640;
const int ResolucionY = 480;
const int PColor = 32;
 
const int DELAY = 85;
 
//Declaramos e inicializamos la varible LongitudSerpiente la cual contendra el tamaño de la serpiente.
int LongitudSerpiente = 0;
 
/*Declaramos e inicializamos la variable Direccion que contendra la direccion en la que se esta
  moviendo la Serpiente.*/
int Direccion = 0;
 
//Declaramos e inicializamos la variable control para controlar que la manzana no coincida con al cola.
int Control = 0;
 
/*Declaramos la variable memoria del tipoc SDL_Rect donde almacenaremos la posion anterior anterior
  de la cabeza de la serpiente para poder mover la cola*/
SDL_Rect Ultimo;
 
//Declaramos e inicializamos la variable Puntos que contendra los puntos del juego.
int Puntos = 0;
 
//Delcaramos e inicializamos la variable Titulo que contendra el titulo de la ventana y la puntuacion.
char Titulo[255];
 
using namespace std;
 
/*Declaramos la estructura Cuadro que sera la encargada de almacenar la posicion
  y el tamaño de cada una de las partes que formaran el cuerpo de la Serpiente*/
struct Cuadro
 {
   SDL_Rect Posicion;
   Cuadro(){Posicion.x = 0;Posicion.y = 0;Posicion.w = 20;Posicion.h = 20;}
 }Manzana;
 
//Declaramos el Vector Serpiente del tipo Cuadro.
vector <Cuadro> Serpiente;
 
int main ( int argc, char** argv )
{
 
    srand(time(NULL));
 
    //Inicializamos el modo de video de las SDL y comprobamos que se inicialize bien.
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
     {
      printf( "Imposible iniciar la libreria SDL: %s\n", SDL_GetError() );
      return 1;
     }
 
    //Itroducimos SDL_Quit en atexit para que se inice al finalizar el programa.
    atexit(SDL_Quit);
 
    /*Creamos la Surface principal del juego, la que se va a mostrar en pantalla.
      y comprobamos que se inicie correctamente.*/
    SDL_Surface* PantallaV = SDL_SetVideoMode(ResolucionX, ResolucionY, PColor,SDL_HWSURFACE|SDL_DOUBLEBUF);
    if ( !PantallaV )
     {
      printf("Imposible crear la ventana Principal: %s\n", SDL_GetError());
      return 1;
     }
 
    //Llamamos a la funcion Iniciar par poner todos los valores a cero.
    Iniciar();
 
    // program main loop
    bool done = false;
    while (!done)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            // check for messages
            switch (event.type)
            {
                // exit if the window is closed
            case SDL_QUIT:
                done = true;
                break;
 
                // check for keypresses
            case SDL_KEYDOWN:
                {
                    // exit if ESCAPE is pressed
                    if (event.key.keysym.sym == SDLK_ESCAPE)
                     {
                      done = true;
                      break;
                     }
                    if(event.key.keysym.sym == SDLK_UP && Direccion != Abajo)
                     {
                      Direccion = Arriba;
                      break;
                     }
                    if(event.key.keysym.sym == SDLK_DOWN && Direccion != Arriba)
                     {
                      Direccion = Abajo;
                      break;
                     }
                    if(event.key.keysym.sym == SDLK_LEFT && Direccion != Derecha)
                     {
                      Direccion = Izquierda;
                      break;
                     }
                    if(event.key.keysym.sym == SDLK_RIGHT && Direccion != Izquierda)
                     {
                      Direccion = Derecha;
                      break;
                     }
                }
            } // end switch
        } // end of message processing
 
        // DRAWING STARTS HERE
 
        if(Direccion != 0)
         {
          //Almacenamos la posicion del ultimo de los elementos que forman la cola en la variable Ultimo.
          Ultimo.x = Serpiente[LongitudSerpiente].Posicion.x;
          Ultimo.y = Serpiente[LongitudSerpiente].Posicion.y;
 
          //Movemos la cola de la serpiente.
          for(int I = LongitudSerpiente; I >= 1; I--)
           {
            Serpiente[I].Posicion.x = Serpiente[I-1].Posicion.x;
            Serpiente[I].Posicion.y = Serpiente[I-1].Posicion.y;
           }
         }
 
        if(Direccion == Arriba)
         {
          Serpiente[0].Posicion.y -= Serpiente[0].Posicion.h;
         }
        else if(Direccion == Abajo)
         {
          Serpiente[0].Posicion.y += Serpiente[0].Posicion.h;
         }
        else if(Direccion == Derecha)
         {
          Serpiente[0].Posicion.x += Serpiente[0].Posicion.w;
         }
        else if(Direccion == Izquierda)
         {
          Serpiente[0].Posicion.x -= Serpiente[0].Posicion.w;
         }
 
        //Comprobamos la colision de la serpiente con el borde.
        if(((Serpiente[0].Posicion.x + Serpiente[0].Posicion.w)  > ResolucionX)
             || (Serpiente[0].Posicion.x < 0)
             || ((Serpiente[0].Posicion.y + Serpiente[0].Posicion.h)  > ResolucionY)
             || (Serpiente[0].Posicion.y < 0))
         {
          Iniciar();
         }
 
        //Comprobamos la colision de la serpiente con la cola.
        for(int I = 1; I <= LongitudSerpiente; I++)
         {
          if(Colision(Serpiente[0].Posicion,Serpiente[I].Posicion))
           {
            Iniciar();
           }
         }
 
        //Comprobamos la colision de la serpiente con la Manzana.
        if(Colision(Serpiente[0].Posicion,Manzana.Posicion))
         {
          LongitudSerpiente++;
          Puntos += 10;
          Serpiente.push_back(Cuadro());
          Serpiente[LongitudSerpiente].Posicion.x = Ultimo.x;
          Serpiente[LongitudSerpiente].Posicion.y = Ultimo.y;
 
          //Metemos en la varible Titulo el titulo de la ventana seguido de la puntuacion del juego.
          sprintf(Titulo,"Snake -- Puntos: %d",Puntos);
 
          /*Posicionamos denuevo la manazana en pantalla y comprobamos que la nueva ubicacion
            no este ocupada por la cola de la Serpiente.*/
          do
           {
            Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);
            Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
            Control = 0;
            for(int I = 1; I <= LongitudSerpiente; I++)
             {
              if(Colision(Manzana.Posicion,Serpiente[I].Posicion))
               {
                Control = 1;
                I = LongitudSerpiente;
               }
             }
           }
          while(Control == 1);
         }
 
        //Borramos la surface principal
        SDL_FillRect(PantallaV, 0, SDL_MapRGB(PantallaV->format, 0, 0, 0));
 
        //Pintamos la serpiente en la Surface principal
        for(int I = 0; I <= LongitudSerpiente; I++)
         {
          SDL_FillRect(PantallaV,&Serpiente[I].Posicion,SDL_MapRGB(PantallaV->format, 255, 255, 255));
         }
 
        //Pintamos la manzana en la Surface principal
        SDL_FillRect(PantallaV,&Manzana.Posicion,SDL_MapRGB(PantallaV->format, 0, 255, 0));
 
        //Cambiamos el titulo de la ventana por Snake.
        SDL_WM_SetCaption (Titulo, NULL);
 
        //Mostramos la Surface principal en pantalla.
        SDL_Flip(PantallaV);
        SDL_Delay(DELAY);
    } // end main loop
 
 
    return 0;
}
 
//Funcion que compruba las colisiones entre los elementos de juego.
int Colision(SDL_Rect H,SDL_Rect M)
{
    if (((H.x + H.w) > M.x) && ((H.y + H.h) > M.y) &&
            ((M.x + M.w) > H.x) && ((M.y + M.h) > H.y))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
 
//Funcion que reinicia el juego cuando la serpiente colisiona con ella misma o el borde.
void Iniciar(void)
 {
  /*Ponemos el valor de la variable longitudSerpiente a 0 para que la serpiente solo este formada por
    la cabeza.*/ 
 LongitudSerpiente = 0;
  //Ponemos el valor de la variable Direccion a 0 para que la serpiente aparezca parada al comenzar el juego.
  Direccion = 0;
  //Ponemos el valor de la variable Puntos a 0 para reiniciar el marcador de puntos.
  Puntos = 0;
  //Metemos en la varible Titulo el titulo de la ventana seguido de la puntuacion del juego.
  sprintf(Titulo,"Snake -- Puntos: %d",Puntos);
  //Borramos todos los miembros que forman el vector Serpiente
  Serpiente.clear();
  //Añadimos un miembro en el vector serpiente que contendra la cabeza de la serpiente.
  Serpiente.push_back(Cuadro());
  //Posicionamos aleatoriamente la manzana en la pantalla.
  Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);
 
  Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
  //Posicionamos la cabeza de la serpiente en el centro de la pantalla.
  Serpiente[0].Posicion.x = (((ResolucionX/Serpiente[0].Posicion.w)/2)*Serpiente[0].Posicion.w);
  Serpiente[0].Posicion.y = (((ResolucionY/Serpiente[0].Posicion.h)/2)*Serpiente[0].Posicion.h);
 }
 

Para el que no lo conozca el videojuego Snake (o serpiente)  comentaros que fue lanzado a mediados de los 70 y ha mantenido su popularidad desde entonces, convirtiéndose en un clásico tras su salida en 1998 en todos los dispositivos móviles de Nokia.

Su argumento es muy sencillo pero enormemente adictivo, el jugador controla una larga y delgada criatura semejante a una serpiente, de hay el nombre del videojuego, que vaga por un plano delimitado por paredes, donde debe evitar a toda costa chocar contra las paredes o consigo misma mientras come manzanas las cuales la hacen crecer, lo cual complica el juego a medida que la serpiente va creciendo debido a la ingesta de las mencionadas manzanas, si esto no fuera suficiente la serpiente una vez que comienza a moverse no puede ser para por el jugador, este se tiene que limitar a cambiar el sentido de la marcha de la suso dicha serpiente mediante las flechas de dirección, para que se coma las manzanas y evite chocar.

Comencemos a analizar el código.

Comenzamos incluyendo las librerías que vamos a necesitar para el buen funcionamiento del código.

La librería estándar "cstdlib "

#include <cstdlib>

La librería “vector” para la creación de una lista de vectores, que controlen el tamaño de serpiente.

#include <vector>

La librería “time.h” para generar aleatoriamente la posición en la que va a aparecer la manzana en el juego, cada vez que esta sea devorada por la serpiente.

#include <time.h>

Y por ultimo la librería “SDL.h” la cual vamos usar para manejar el entorno gráfico y  las pulsaciones del teclado.

#include <SDL/SDL.h>

Las siguiente lineas de código son los prototipos de las funciones “Colision”  y “Iniciar”, de las cuales explicare su funcionamiento mas adelante.

int Colision(SDL_Rect,SDL_Rect);
 
void Iniciar(void);
 

Ahora vamos a usar la directiva “#define” para crear unas macros, las cuales nos ayudaran a entender mejor el código.
Lo que estas macros hacen es que trabajemos con las direcciones reales en las que se mueve la serpiente y no números pues tras un tiempo sin usar el código no sabríamos que significaba cada numero.

Mirar a la dirección Arriba le adjudicamos el numero 1, lo que hace esta macro es que en el código podemos poner Arriba y sabremos que significa 1, después el preprocesador cambiara las palabra Arriba por un 1 antes de compilar el código, como bien he dicho esto es solo por limpieza y para mejorar la compresión del código para futuras modificaciones o para que sea comprensible para otra persona que no sea el programador del mismo.

#define Arriba 1
#define Derecha 2
#define Abajo 3
#define Izquierda 4

Tras estas lineas vamos a definir el ancho y alto de la pantalla principal así como la profundidad de color de la misma.

const int ResolucionX = 640;
const int ResolucionY = 480;
const int PColor = 32;

Ahora vamos a definir el retardo en milisegundos que usaremos para que el programa funcione mas o menos igual en todas las maquinas aunque sean las rápidas

const int DELAY = 85;

Declaramos e inicializamos la variable LongitudSerpiente la cual contendrá el tamaño de la serpiente, la iniciamos con valor 0 para que en un principio solo contenga la cabeza de la serpiente.

int LongitudSerpiente = 0;

Declaramos e inicializamos la variable Dirección, que contendrá la dirección en la que se esta
moviendo la Serpiente en cada momento, principalmente la inicializamos a 0 para que la serpiente aparezca parada al comenzar el juego.

int Direccion = 0;

Declaramos e inicializamos la variable control para controlar la permanecía o la salida del bucle que  controla el chequeo de la manzana al ser creada, para que no coincida en una posición de la pantalla en la cual se encuentre la serpiente.

int Control = 0;

Declaramos la variable Ultimo del tipo SDL_Rect donde almacenaremos la posición del ultimo cuadro que forma la cola de la serpiente, para cuando tengamos que añadir un nuevo cuadro a la cola tras la ingesta de una manzana, sepamos donde posicionarlo con respecto al resto de la serpiente.

SDL_Rect Ultimo;

Declaramos e inicializamos la variable Puntos que contendrá los puntos del juego.

int Puntos = 0;

Declaramos la variable Titulo que contendrá el titulo de la ventana y la puntuación.

char Titulo[255];

la siguiente linea es la encargada de usar el ámbito std como namespace, esto se traduce en que no tendremos que usar std:: delante de las funciones estándar de C++

using namespace std;

Declaramos la estructura Cuadro que sera la encargada de almacenar la posición y el tamaño, de cada una de las partes que formaran el cuerpo de la Serpiente y la Manzana.

Si os fijáis también he creado un constructor para que la primera vez que creemos uno de los cuadros que formaran la serpiente o la manzana, se inicialicen con un tamaño de 20 píxeles.

struct Cuadro
{
  SDL_Rect Posicion;
  Cuadro(){Posicion.x = 0;Posicion.y = 0;Posicion.w = 20;Posicion.h = 20;}
}Manzana;

Declaramos el vector Serpiente del tipo Cuadro, un vector es muy similar a un array o lista, lo único que tendremos control total cobre los miembros que forman el vector, podremos incluir miembros nuevos cuando queramos o eliminar algún miembro que no no interese, como no sabremos que tamaño va a alcanzar nuestra serpiente en cada momento, la mejor forma de manejarlo es usando vector pues como os he comentado nos genera una array o lista, que podemos modificar libremente,  otra manera de hacerlo seria dividir el ancho y el alto de la pantalla por el tamaño de un cuadro y multiplicar los resultados, después le restamos 1 para poder posicionar la manzana y tendremos el tamaño total que podrá tener nuestra serpiente.

Por ejemplo si la pantalla midiera 640x480 y cada cuadro que forma la serpiente midiera 20 píxeles, la forma de saber el tamaño máximo que podrá alcanzar nuestra serpiente sera así:

640/20 = 32
480/20 = 24

32 * 24 = 768
768 – 1 = 767

Nuestra serpiente podría tener un tamaño máximo de 767 cuadros y podríamos generar un array de 767 elementos y evitar usar vectores, pero de esta manera estaríamos desperdiciando mucha memoria que mas de un 90% de las veces no sera usada, por este motivo y como es una buena practica de programación ahorrar memoria vamos a usar vectores.

vector <Cuadro> Serpiente;

la función main no necesita presentación

int main ( int argc, char** argv )
{

Usaremos la función srand con time como semilla para la generación de numeros aleatorios para posicionar la manzana en pantalla.

srand(time(NULL));

Inicializamos el modo de vídeo de las SDL y comprobamos que se inicialice bien.

if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
 {
   printf( "Imposible iniciar la libreria SDL: %s\n", SDL_GetError() );
   return 1;
 }

Introducimos SDL_Quit en atexit para que se inicie al finalizar el programa, saliendo así de la librería SDL siempre que el programa finalice.

atexit(SDL_Quit);

Creamos la Surface principal del juego, la que se va a mostrar en pantalla y comprobamos que se inicie correctamente.

SDL_Surface* PantallaV = SDL_SetVideoMode(ResolucionX, ResolucionY,PColor,SDL_HWSURFACE|SDL_DOUBLEBUF);
   if ( !PantallaV )
    {
     printf("Imposible crear la ventana Principal: %s\n", SDL_GetError());
     return 1;
    }

Llamamos a la función Iniciar para poner todos los valores a cero.

Iniciar();

A continuación voy a pasar a explicar la función Iniciar y después regresare al código en la linea siguiente a Iniciar();.

La función Iniciar es la encargada de poner todas las variables con los valores originales del juego para de esta manera poder reiniciarlo cuando colisionemos y la serpiente muera.

void Iniciar(void)
{
 /*Ponemos el valor de la variable longitudSerpiente a 0 para que la serpiente solo este formada por
   la cabeza.*/ 
 LongitudSerpiente = 0;
 /*Ponemos el valor de la variable Direccion a 0 para que la serpiente aparezca parada al comenzar  el juego.*/
 Direccion = 0;
 //Ponemos el valor de la variable Puntos a 0 para reiniciar el marcador de puntos.
 Puntos = 0;
 //Metemos en la variable Titulo el titulo de la ventana seguido de la puntuación del juego.
 sprintf(Titulo,"Snake -- Puntos: %d",Puntos);
 //Borramos todos los miembros que forman el vector Serpiente
 Serpiente.clear();
 //Añadimos un miembro en el vector serpiente que contendrá la cabeza de la serpiente.
 Serpiente.push_back(Cuadro());
 //Posicionamos aleatoriamente la manzana en la pantalla.
Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);  
 Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
 //Posicionamos la cabeza de la serpiente en el centro de la pantalla.
 Serpiente[0].Posicion.x = (((ResolucionX/Serpiente[0].Posicion.w)/2)*Serpiente[0].Posicion.w);
 Serpiente[0].Posicion.y = (((ResolucionY/Serpiente[0].Posicion.h)/2)*Serpiente[0].Posicion.h);
}
 

Analicemos mas profundamente la manera de posicionar la manzana aleatoriamente en la pantalla

 Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);  
 Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);

Sabemos que las medidas de la pantalla están almacenadas dentro de las variables ResolucionX para el ancho y ResolucionY para el alto, las coordenadas que definen la posición de la manzana se posicionan en la esquina superior izquierda de la misma.


Así que si por un casual el ancho aleatorio que nos saliera fuera 640, la manzana se colocaría fuera de la pantalla por el lado derecho de la misma o si el valor para el alto generado aleatoriamente coincidiera con 480, pasaría lo mismo que en el caso anterior pero esta vez la manzana se dibujaría fuera de la pantalla por el lado inferior de la misma, para solucionar este problema debemos restarle el ancho y el alto de la manzana a las dimensiones de la pantalla para asegurarnos de que dicha manzana cuando sea dibujada no se muestre fuera de los limites de la pantalla, el ancho de la manzana se encuentran en Manzana.Posicion.w y el alto en Manzana.Posicion.h.

(ResolucionX-Manzana.Posicion.w)
(ResolucionY-Manzana.Posicion.h)

Para asegurarnos que el numero aleatorio que va a ser generado para colocar la manzana esta centrado con respecto a la pantalla y al movimiento de la serpiente, debemos dividir el resultado nuevamente por el ancho o el alto de la manzana de esta manera la manzana solo se podrá colocar en posiciones multiplicas de 20 que es el ancho y al alto de la manzana, quedando siempre centrada con el movimiento de la serpiente.

(ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w)
(ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h)

Y por ultimo ya solo nos queda multiplicar el resultado de la operación aleatoria por el ancho y el alto de la manzana para sacar las coordenadas reales de la pantalla en que va a ser dibujada la manzana.

Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);  
 Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);

Para posicionar la serpiente en el centro de la pantalla usamos el mismo método que para posicionar la manzana, pero lógicamente sin usar números aleatorios, así nos aseguramos que tanto la manzana como la serpiente se encuentren centradas una con respecto a la otra, de esta manera cuando la serpiente se coma la manzana la posición de la cabeza y la manzana corresponderán perfectamente.

Serpiente[0].Posicion.x = (((ResolucionX/Serpiente[0].Posicion.w)/2)*Serpiente[0].Posicion.w);
Serpiente[0].Posicion.y = (((ResolucionY/Serpiente[0].Posicion.h)/2)*Serpiente[0].Posicion.h);

Una vez explicada la función Iniciar vamos a continuar con el código.

Ahora Declaramos e inicializamos la variable done del tipo bool la cual usaremos como bandera de control para abandonar el bucle principal del juego una vez que pulsemos la tecla Escape o la X que cierra la ventana, tras la declaración creamos el bucle principal del juego que se repetirá siempre que el valor de la variable done se a false (o 0).

bool done = false;
while (!done)
  {

Lo primero que vamos a encontrar dentro del bucle principal del juego es el método para leer los mensajes que el programa recibe del exterior, como pueden ser las teclas que han sido pulsadas o los mensajes recibidos de la ventana.

       SDL_Event event;
       while (SDL_PollEvent(&event))
       {
           switch (event.type)
           {
             case SDL_QUIT:
               done = true;
               break;
 
           case SDL_KEYDOWN:
               {
                   if (event.key.keysym.sym == SDLK_ESCAPE)
                    {
                     done = true;
                     break;
                    }
                   if(event.key.keysym.sym == SDLK_UP && Direccion != Abajo)
                    {
                     Direccion = Arriba;
                     break;
                    }
                   if(event.key.keysym.sym == SDLK_DOWN && Direccion != Arriba)
                    {
                     Direccion = Abajo;
                     break;
                    }
                   if(event.key.keysym.sym == SDLK_LEFT && Direccion != Derecha)
                    {
                     Direccion = Izquierda;
                     break;
                    }
                   if(event.key.keysym.sym == SDLK_RIGHT && Direccion != Izquierda)
                    {
                     Direccion = Derecha;
                     break;
                    }
               }
           }
       } 

Declaramos event del tipo SDL_Event, que es donde almacenaremos los mensajes que recibamos del sistema.

SDL_Event event;

Después crearemos un bucle que se repetirá siempre que queden mensajes del sistema por procesar, al mismo tiempo almacenamos dichos mensajes en la variable event creada anteriormente.

while (SDL_PollEvent(&event))
       {

Tras lo cual procederemos a leer el mensaje del sistema almacenado en la variable event

switch (event.type)
           {

Si el mensaje almacenado en la variable event es  SDL_QUIT, esto nos informa de que la X de la ventana a sido pulsado y por tanto el programa debe finalizar, así que ponemos el valor de la variable done a true(o 1) para salir del bucle principal de programa y de este modo finalizar el mismo.

case SDL_QUIT:
               done = true;
               break;

Otro de los mensajes del sistema que vamos a monitorizar, sera si una tecla a sido pulsada para ello usaremos

case SDL_KEYDOWN:
               {

Y tras saber que una tecla a sido pulsada debemos ver cual y si nos interesa para que el programa reaccione en concordancia a la tecla pulsada, la primera tecla que vamos a comprobar si ha sido pulsada es Escape y lo haremos  mediante.

if (event.key.keysym.sym == SDLK_ESCAPE)
                    {

En caso de que el resultado sea 1 o mayor de 1 eso quiere decir que la tecla Escape a sido pulsada y se procederá a realizar lo que hay en el interior del bloque que no es otra cosa que poner el valor de la variable done a true (o 1) para salir del bucle principal de programa y de este modo finalizar el mismo.

done = true;
break;
}

Después realizaremos la comprobación con las teclas de dirección, empezando por la tecla de dirección Arriba o lo que es lo mismo SDLK_UP,  pero además de comprobar que la tecla haya sido pulsada podremos ver en el código que se realiza otra comprobación,Esta comprobación es que la variable Dirección no contenga el valor Abajo, esto lo hacemos por que la serpiente no puede andar hacia atrás y si la variable Dirección contiene el valor Abajo, la serpiente esta yendo hacia abajo en la pantalla, por lo tanto la tecla de dirección Arriba no tiene que tener efecto;  Para que entremos en el bloque del if ambas comprobaciones deben ser correctas, en caso de que las dos comprobaciones sean correctas cambiamos el valor de la variable Dirección por Arriba y de este modo le decimos a la serpiente la dirección que debe tomar a partir de ahora.

if(event.key.keysym.sym == SDLK_UP && Direccion != Abajo)
  {
    Direccion = Arriba;
    break;
  }

Explicado esto el resto de las comprobaciones que se realizan a las teclas de dirección son iguales a la comprobación de la tecla de dirección Arriba, pero obviamente cambiando la dirección del movimiento de la serpiente.

                   if(event.key.keysym.sym == SDLK_DOWN && Direccion != Arriba)
                    {
                     Direccion = Abajo;
                     break;
                    }
                   if(event.key.keysym.sym == SDLK_LEFT && Direccion != Derecha)
                    {
                     Direccion = Izquierda;
                     break;
                    }
                   if(event.key.keysym.sym == SDLK_RIGHT && Direccion != Izquierda)
                    {
                     Direccion = Derecha;
                     break;
                    }
               }
           }
       } 

Una vez hemos comprobado todos los mensajes del sistema y realizados las acciones que mejor se ajustan a dichos mensajes, salimos del bucle que procesa los mensajes y continuamos.

Si la serpiente esta en movimiento quiere decir que la variable Dirección no vale 0 por tanto tenemos que empezar a mover dicha serpiente por la pantalla y para hacer esto lo primero que vamos a hacer es almacenar en la variable Ultimo del tipo SDL_Rect la posición del ultimo cuadro que forma la cola de la serpiente antes de que este sea movido de su posición actual esto lo hacemos para saber la posición en la que tendremos que colocar un nuevo cuadro si la serpiente se come la manzana

if(Direccion != 0)
{
  Ultimo.x = Serpiente[LongitudSerpiente].Posicion.x;
  Ultimo.y = Serpiente[LongitudSerpiente].Posicion.y;

Después de almacenar la posición del ultimo cuadro que forma la cola de la serpiente,  vamos a mover la posición de los cuadros que forman la cola de la serpiente mediante el siguiente for, empezando por el ultimo a la posición del cuadro que se encuentra una posición mas arriba en la lista de elementos del vector Serpiente, como podemos ver Declaramos la variable I la cual vamos a usar como contador y la Inicializamos con el valor de la variable LongitudSerpiente que contiene el tamaño actual de la serpiente y recorreremos los elementos que forman el vector Serpiente, hasta alcanzar el cuadro mas próximo a la cabeza de la serpiente que no es otro que el elemento del vector 1, pues como vimos antes la cabeza de la serpiente se encuentra en el elemento del vector 0.con esto conseguimos que la cola de la serpiente avance una posición o lo que es lo mismo 20 píxeles por la pantalla.

         //Movemos la cola de la serpiente.
         for(int I = LongitudSerpiente; I >= 1; I--)
          {
           Serpiente[I].Posicion.x = Serpiente[I-1].Posicion.x;
           Serpiente[I].Posicion.y = Serpiente[I-1].Posicion.y;
          }
        }

Una vez llegados a este punto nos tiene que surgir una duda, bien si movemos todos los cuadros que forman la cola de la serpiente a la posición inmediata siguiente que pasa con la cabeza de la serpiente?

Pues vamos a resolver esta duda ahora mismo, como la cabeza de la serpiente es la que dirige al resto de la serpiente es la que tiene que moverse en concordancia con la dirección que le digamos usando el teclado por ese motivo la movemos con los siguientes if,

       if(Direccion == Arriba)
        {
         Serpiente[0].Posicion.y -= Serpiente[0].Posicion.h;
        }
       else if(Direccion == Abajo)
        {
        Serpiente[0].Posicion.y += Serpiente[0].Posicion.h;
        }
       else if(Direccion == Derecha)
        {
         Serpiente[0].Posicion.x += Serpiente[0].Posicion.w;
        }
       else if(Direccion == Izquierda)
        {
         Serpiente[0].Posicion.x -= Serpiente[0].Posicion.w;
        }

Si la variable Dirección contiene Arriba eso significa por lo que vimos antes que hemos usado la tecla de dirección Arriba entonces debemos mover la serpiente por la pantalla hacia arriba esto lo hacemos modificando la variable que contiene la dirección y de la cabeza de la serpiente que no es otra que Serpiente[0].Posicion.y y para ello le restamos el alto del cuadro que forma la cabeza de la serpiente que se encuentra en la variable Serpiente[0].Posicion.h, que son 20 pixeles.

       if(Direccion == Arriba)
        {
         Serpiente[0].Posicion.y -= Serpiente[0].Posicion.h;
        }

El resto de los else if son exactamente iguales pero lógicamente alterando la los variables en concordancia en la dirección en que deba ser movida la serpiente

       else if(Direccion == Abajo)
        {
         Serpiente[0].Posicion.y += Serpiente[0].Posicion.h;
        }
       else if(Direccion == Derecha)
        {
         Serpiente[0].Posicion.x += Serpiente[0].Posicion.w;
        }
       else if(Direccion == Izquierda)
        {
         Serpiente[0].Posicion.x -= Serpiente[0].Posicion.w;
        }

Ahora vamos a comprobar la colisión de la cabeza de la serpiente con el borde, para ello tenemos que comprobar que la posición x e y de la serpiente se encuentre dentro de los limites de la pantalla, fijaros bien pues pasa lo mismo que cuando queríamos colocar la manzana dentro de los limites de la pantalla, como los puntos de posición del cuadro que forma la cabeza de la serpiente están en la esquina superior izquierda del cuadro, para comprobar que la colisión se realiza correctamente con la parte inferior y la parte derecha de la pantalla, tenemos que sumar el ancho y el alto del cuadro que forma la cabeza de la serpiente, a la variable respectiva, en caso de que se produzca la colisión reiniciaremos el juego llamando a la función Iniciar la cual os explique su funcionamiento anteriormente.

       if(((Serpiente[0].Posicion.x + Serpiente[0].Posicion.w)  > ResolucionX)
            || (Serpiente[0].Posicion.x < 0)
            || ((Serpiente[0].Posicion.y + Serpiente[0].Posicion.h)  > ResolucionY)
            || (Serpiente[0].Posicion.y < 0))
        {
         Iniciar();
        }
 

Una vez hemos realizado la comprobación de la colisión con el borde de la pantalla, vamos a realizar la comprobación de la colisión de la cabeza de la serpiente con la cola, para ello vamos a usar la función Colision la cual os explicare a continuación y después seguiremos viendo el código  

Como podéis ver la función Colision es muy simple lo que hace es comprobar si el cuadro que le pasamos como primer miembro de la función se encuentra dentro o en contacto con el cuadro que le pasamos como segundo miembro de la función, si están en contacto devuelve 1 y en caso contrario devuelve 0.

int Colision(SDL_Rect H,SDL_Rect M)
{
   if (((H.x + H.w) > M.x) && ((H.y + H.h) > M.y) &&
           ((M.x + M.w) > H.x) && ((M.y + M.h) > H.y))
   {
       return 1;
   }
   else
   {
       return 0;
   }
}

Vamos a recorrer los elementos que forman el vector Serpiente usando un for, empezaremos por el elemento 1 del vector Serpiente, de este modo nos saltamos la cabeza de la serpiente pues esta es la que colisiona con la cola, y lógicamente no puede colisionar consigo misma,  cuando Declaramos la variable I que vamos a usar como contador, la Inicializamos con el valor 1, de este modo  recorreremos todos los elementos que forman el vector Serpiente saltándonos la cabeza de la serpiente y comprobaremos mediante la función Colision si existe colisión con la cabeza de la serpiente que es el elemento 0 del vector, en caso de que la función Colision devuelva 1 quiere decir como vimos antes que la colisión se a producido y entramos dentro del bloque del if donde mediante la función Iniciar reiniciamos el juego .

       //Comprobamos la colision de la serpiente con la cola.
       for(int I = 1; I <= LongitudSerpiente; I++)
        {
         if(Colision(Serpiente[0].Posicion,Serpiente[I].Posicion))
          {
           Iniciar();
          }
        }

Ya solo nos queda comprobar si la serpiente se a comido la manzana lo cual haremos nuevamente con la función Colision y un if, esta vez comprobaremos la cabeza de la serpiente y la manzana como podemos ver , en caso de que la colisión se produzca entraremos en el bloque del if.

       if(Colision(Serpiente[0].Posicion,Manzana.Posicion))
        {

Como sabemos que cuando la serpiente se come un manzana su cola crece un cuadro debemos incrementar en uno el valor de la variable LongitudSerpiente y lo haremos así.

LongitudSerpiente++;

También sabemos que cuando nos comemos una manzana debemos aumentar los puntos, yo en este caso he decidido que cada manzana valga 10 puntos, así que aumento en 10 el valor de la variable Puntos.

Puntos += 10;

Al aumentar el tamaño de la serpiente, debemos incluir un nuevo elemento en el vector Serpiente y lo haremos con la siguiente linea.

Serpiente.push_back(Cuadro());

Una vez hemos creado el nuevo elemento en el vector Serpiente, debemos darle una posición en la pantalla y para eso usaremos la posición del ultimo elemento de la cola de la serpiente, que si recordáis habíamos almacenado en la variable Ultimo.

Serpiente[LongitudSerpiente].Posicion.x = Ultimo.x;
Serpiente[LongitudSerpiente].Posicion.y = Ultimo.y;

Como hemos modificado el valor de la variable Puntos debemos actualizar el titulo de ventana para que nos muestre la nueva puntuación.

sprintf(Titulo,"Snake -- Puntos: %d",Puntos);

Y finalmente ya solo nos queda posicionar la manzana nuevamente en una posición aleatoria de la pantalla,  como podemos ver aparte de colocar la manzana, debemos comprobar que no la ponemos sobre ninguno de los elementos que forman la serpiente, lo cual comprobaremos nuevamente con la función Colision, y en caso de que la colisión se produzca introduciremos 1 como valor de la Variable Control para que el bucle se vuelva a realizar y se genere otra posición aleatoria para la manzana.

do {
 Manzana.Posicion.x = ((rand() %  ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);
 Manzana.Posicion.y = ((rand() %  ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
 Control = 0;
 for(int I = 1; I <= LongitudSerpiente; I++)
    {
      if(Colision(Manzana.Posicion,Serpiente[I].Posicion))
        {
          Control = 1;
          I = LongitudSerpiente;
        }
     }
   }
  while(Control == 1);
}
 

Ya casi hemos terminado solo nos queda el tema gráfico y lo primero que vamos a hacer es limpiar la surface PantallaV pintándola del color del fondo en este caso negro.

SDL_FillRect(PantallaV, 0, SDL_MapRGB(PantallaV->format, 0, 0, 0));

Después posicionamos el dibujo de cada uno de los elementos que forman la serpiente en la surface PantallaV.

for(int I = 0; I <= LongitudSerpiente; I++)
 {
   SDL_FillRect(PantallaV,&Serpiente[I].Posicion,SDL_MapRGB(PantallaV->format, 255, 255,   255));
  }

Posicionamos el dibujo de la manzana en la surface PantallaV.

SDL_FillRect(PantallaV,&Manzana.Posicion,SDL_MapRGB(PantallaV->format, 0, 255, 0));

Refrescamos el titulo de la ventana, por si la puntuación a sido modificada.

SDL_WM_SetCaption (Titulo, NULL);

Ahora  mostramos la surface PantallaV en la pantalla y esperamos los milisegundos necesarios para que el programa funcione mas o menos igual en todas las maquinas aunque sean mas rápidas.

 SDL_Flip(PantallaV);
 SDL_Delay(DELAY);
} 
 

Y por ultimo cuando el programa finalice devolvemos 0, esto hoy en día casi no se usa pero es una buena practica de programación y nos puede ayudar a mantener la compatibilidad del código con otros sistemas.

   return 0;
}

Bueno con esto terminamos el manual espero que os haya gustado y os sirva.

Para cualquier duda os podéis poner en contacto conmigo en el foro o en mi email.

kaltorak_@hotmail.com

La versión en pdf del manual la tenis en el siguiente enlace, junto con el archivo compilado para windows y linux, así como el código fuente:

http://ultrashare.net/hosting/fl/6a05538c64

Un saludo
Kaltorak.

Hola a todos comienzo esta serie de tutoriales sobre programación en java sobre Windows a la vez que yo mismo voy aprendiendo el lenguaje, espero que no seáis muy críticos si se me cuela algún gazapo y que me ayudéis a mejorar los tutoriales y corregir dichos fallos si se producen,podéis poneros en contacto conmigo por medio del foro o en el siguiente email:


Java es un sistema de programaron orientado a objetos creado por sun microsystems a principios de los 90, la principal ventaja de usar el sistema de programación java es que corre sobre una maquina virtual lo cual nos permite poder correr nuestro código en casi cualquier sistema sin tener a penas que tocar el código, siempre y cuando exista una versión de la maquina virtual java para ese sistema, por supuesto la maquina virtual java se encuentra con descarga gratuita en la pagina de Sun microsystem para casi cualquier plataforma imaginable, otras ventajas de programar en java son por ejemplo poder hacer applets para paginas web, poder crear código de java para el lado del servidor, etc...
Aprender java hoy en día es muy importante por que nos va abrir las puertas de muchos medios y dispositivos por este motivo me he decidido a aparcar un poco C/C++, y ponerme a aprender java, también por ese motivo he comenzado esta serie de tutoriales para que todos lo que queráis iniciaros en el mundo de la programación en java tengáis por donde empezar.

El desarrollo un programa en java podemos hacerlo de 2 modos, usando el bloc de notas o usando un entorno de desarrollo (o IDE).

Voy a explicar los 2 métodos de trabajo, aun que yo os recomiendo usar un entorno de desarrollo (o IDE) por que desarrollar un programa en java usando solo el bloc de notas, puede ser una tarea bastante tediosa, se que a muchos de vosotros os gusta mantener el control sobre lo que hacéis y no dejárselo al entorno de desarrollo, o simplemente por que vuestro equipo no es lo suficientemente potente para correr el entorno de desarrollo (o IDE), por este motivo voy a explicar los 2 métodos.

Vamos a comenzar por el método de trabajo usando el bloc de notas.

 


Lo primero que tenemos que hacer para desarrollar programas java en nuestro equipo usando el bloc de notas, es asegurarnos de que tenemos el software correcto, así que iremos  al siguiente enlace donde encontraremos el Java jdk (Java Development Kit) o lo que es lo mismo el kit de desarrollo de java.


como podemos ver vamos a bajar el Java SE, (el java estándar edition) que es la versión del kit de desarrollo de java que vamos a usar en esta serie de tutoriales.


Al hacer clic en el enlace se nos mostrara la pagina de descarga de Java SE, en la que  hay 2 enlaces de descarga, uno es el Java Platform (JDK) 7u25 y el otro el JDL 7 + NetBeans,

Vamos a descargar el Java Platform (JDK) 7u25 que es únicamente la plataforma de desarrollo de java sin IDE, que es la que nos interesa para usar el Bloc de notas.


Hacemos clic en la imagen Java Platform (JDK) 7u25 y nos aparecerá la siguiente ventana.


Donde deberemos aceptar el acuerdo de licencia "Accept License Agreemeat" para a continuación descargar el paquete que mejor se adapte al equipo en el que estamos desarrollando, una vez que aceptemos el acuerdo de licencia, la información en el cuadro gris cambiara para darnos las gracias por aceptar el acuerdo de licencia y nos informara de que ya podemos descargar la plataforma de desarrollo que mejor se adapte a nuestro equipo.

Para estos tutoriales voy a usar Windows 7 de 23 bits, por lo tanto voy a descargar la versión de Windows x86.


Una vez que el archivo jdk-7u25-windows-i586 este descargado completamente en vuestro equipo hacemos doble clic sobre el mismo para comenzar la instalación.


En esta primera ventana nos informan  de que vamos a instalar el kit de desarrollo de Java SE, y como es lo que queremos instalar pues hacemos clic en “Next->” en caso de no quererlo instalar haríamos clic en “Cancel”, tras hacer clic en “Next->” nos  aparecerá  la siguiente pantalla.


Donde el programa de instalación nos informa de la ruta donde va a instalar el kit de desarrollo de Java SE os aconsejo no cambiar dicha ruta, así que hacemos clic en “Next->” para continuar con la instalación.


Una vez todo los datos han sido instalados nos mostrara la siguiente ventana informándonos de que la instalación se a completado


Hacemos clic en “Close” y listo ya tendremos el  kit de desarrollo de Java SE instalado en nuestro equipo.

Ahora vamos a comprobar que todo se a instalado donde le dijimos en mi caso en la ruta por defecto del instalador.


Una vez en dicha carpeta vamos a abrir la carpeta “bin” y buscaremos el archivo “javac.exe”, este programa es el compilador de java, hasta aquí todo bien pero tenemos un problema este archivo solo es visible desde esta ubicación, esto es un engorro por que para compilar el código que hagamos, este código a de estar archivado en esta misma carpeta, cosa que fervientemente os desaconsejo, el código que hagamos debe estar en una carpeta completamente distinta a la del compilador.

Por este motivo vamos a crear una nueva variable de entorno para hacer visibles todos los archivos que hay dentro de la ruta


y de esta manera poder usar cualquier archivo de la mencionada ruta, nos encontremos en la carpeta que nos encontremos.

Para hacer esto vamos a inicio y en Equipo hacemos clic con el botón derecho del ratón y en el menú desplegable escogemos la opción “Propiedades”


Tras lo cual se nos abrirá esta ventana.


En la parte izquierda de la ventana podemos ver 4 opciones, tenemos que hacer clic en la ultima de ella “configuración avanzada del sistema”

Tras hacer clic en “configuración avanzada del sistema” se nos mostrara esta ventana.


Si no fijamos un poco en la pestaña “Opciones avanzadas”,podremos ver un botón que se llama "Variables de entorno" y en el que tendremos que hacer clic para ver las variables que tiene ahora mismo creadas el sistema y para crear una nueva variable.

En la ventana que nos aparece hacemos clic en el botón “Nueva...” que se encuentra debajo del cuadro “Variables de usuario para ….”


Tras lo cual se nos abrirá una nueva ventana con 2 cuadros de dialogo uno en el que pone “Nombre de la variable:” en el que tendremos que poner “Path” y otro en el que pone “Valor de la variable” en el que pondremos la ruta donde instalamos el "javac.exe" en mi caso “C:\Program Files (x86)\Java\jdk1.7.0_25\bin” la ventana tras introducir los datos nos tiene que quedar así.


Hacemos clic en “Aceptar” y ya tendremos creada nuestra nueva variable de entorno ya solo nos queda probarla, vamos inicio y en el cuadro de búsqueda de programas ponemos “cmd”, cargamos el archivo “cmd.exe” haciendo clic sobre el y se nos abrirá una consola en modo dos.


Tecleamos  “javac” y pulsamos enter.


Si todo a salido bien nos tiene que salir la información de ayuda del compilador de java.


Con esto ya tenemos configurada la variable de usuario.

Ahora vamos a hacer nuestro primer programa con el bloc de notas, nos vamos al disco duro “C” y creamos una carpeta la vamos a llamar “Hola Mundo”, dentro de esta carpeta hacemos clic con el botón derecho del ratón y en el menú de opciones escogemos “Nuevo” y en el menú desplegables escogemos “Documento de texto”


Tras lo cual se nos creara un archivo del bloc de notas en la carpeta “Hola Mundo”, le cambiamos el nombre por “Hola” y la extensión tiene que ser “java”, al tratarse de un archivo que va a contener código en java la extensión tiene que ser siempre “java”, el nombre del archivo puede ser cualquiera pero la extensión tiene que ser "java".


Abrimos el archivo que acabamos de crear con el bloc de notas y introducimos el siguiente código, no os preocupéis si no lo entendéis es solo como ejemplo para ver como se puede programar con el bloc de notas sin necesidad de un entorno de desarrollo (o IDE) en sucesivos tutoriales os iré mostrando que significa cada parte del código.

class Hola
 {
   public static void main(String args[])
    {
     System.out.println("Hola Mundo");
    }
 }

Este código lo que hace es mostrar el mensaje “Hola Mundo” en pantalla, todos los que hayáis programado en algún otro lenguaje de programación, sabréis que es el primer programa que siempre se realiza cuando se esta aprendiendo.


Una vez que hemos introducido el código en el archivo Hola.java lo grabamos y volvemos a sacar la consola en modo dos como Hicimos antes.

Vamos inicio y en el cuadro de búsqueda de programas ponemos “cmd” , cargamos el archivo “cmd.exe” haciendo clic sobre el.


Una vez abierta la consola en modo dos tenemos que ir a la carpeta que contiene el archivo de código que acabamos de crear para ello introducimos “cd c:\Hola Mundo” y pulsamos enter.


Ahora que ya nos encontramos en la carpeta que contiene nuestro código tenemos que compilarlo para que pueda ser ejecutado esto lo haremos tecleando lo siguiente.


Si todo sale bien no nos tiene que mostrar nada, en caso de que haya algún error en el código nos saldrá la lista de dichos errores.

En este caso si lo habéis copiado bien no tiene que saliros nada.


Tras realizar la compilación se nos habrá creado en la carpeta "Hola Mundo" un archivo de extensión “.class”, que es el archivo ejecutable de la clase class de java.


Ahora nos toda ejecutar el programa y ver si todo a salido bien, para hacer funcionar el archivo “Hola.class” tecleamos “java Hola” en la consola de modo dos y tras pulsar enter si todo lo hemos echo bien nos mostrara el mensaje Hola Mundo en pantalla.


Ya solo me queda comentaros que cada vez que hagáis un cambio en archivo “.java” lo tendréis que compilar para crear el ejecutable, de lo contrario los cambios no se verán reflejados en el archivo ejecutable y por tanto no se realizaran.

Con esto terminamos el tutorial sobre como programar en java usando el Bloc de notas en el próximo tutorial os enseñare a usar el entorno de desarrollo (o IDE)  NetBeans para crear nuestro código en java.

Pagina del proyecto.

http://programacion.eclipseforo.com/

Un saludo
Kaltorak.

Bueno pues doy por finalizado el reto de este mes, la verdad se ha notado que estáis de vacaciones por la poca afluencia que ha tenido el reto   

Un saludo
Kaltorak.

No entiendo que tiene que ver que Winrar use cifrados militares, con lo que yo he dicho, lo que yo he dicho simplemente es que si alguien quiere de verdad romper un código lo terminara haciendo da igual el cifrado empleado.

También os pongo un ejemplo de lo atrasada que va la gente normal con respecto a los ejércitos y gobiernos, cuantos de vosotros tenéis los indicadores de vuestro coche en la luna delantera del mismo???

Pues la tecnología que hace que se vean en la luna del coche es una tecnología que tiene más de 5 años y hace 1 o 2 que se está empezando a ver en coches de muy alta gama.

Con esto solo quiero daros a entender, que una cosa es la tecnologia a la que la gente normal tiene acceso y otra la que hay.


Lo de la ingeniería inversa lo he puesto como ejemplo, porque yo llevo aproximadamente 3 meses con la ingeniería inversa y ya puedo romper protecciones bastante avanzadas, pues imaginaros alguien que lleve años estudiando y realizando ingeniería inversa.

Pues lo mismo es aplicable a la criptografia.

No he dicho que no vallamos a mirar la idea de hacer retos distintos a la creación de videojuegos, te pongo lo que he dicho.

El Mappy es un editor de mapas de tiles como te ha puesto el compañero amchacon, yo antes para cada juego creaba su propio editor de niveles y era un coñazo, pero desde que descubrí el Mappy soy feliz, es súper intuitivo de usar.

Lo que este programa hace es crear las matrices que usáis vosotros para hacer los mapas, pero de modo visual, así puedes ver cómo va a quedar antes de usarlo en el juego, después genera un archivo con los datos del nivel que acabas de crear, el cual tienes que leer desde tu programa, más o menos de la misma manera que haces en tu juego con la matriz que genera el escenario.

Por mi perfecto SrCooper cuando estés por aquí pégame un toque, estaré encantado de que miremos esos fallos y ayudarte en lo que me sea posible.

Con respecto a lo de hacer un proyecto todos juntos esa era la idea cuando formamos Retrodev cuando estés de vuelta pásate por nuestro foro y vemos entre todos que podemos hacer.


Se agradece mucho la propuesta aun que Retrodev se formó principalmente para el desarrollo de videojuegos, podríamos mirar otras cosas.

Lo único que por mucha criptografía que usemos, si alguien desea de verdad romper nuestra seguridad lo hará, la prueba la tenemos en este magistral foro, yo mismo con unos conocimientos bastante básicos sobre ingeniería inversa adquiridos en este foro, he sido capaz de saltarme la protección de programas que han costado cientos de euros en seguridad.

Pues imaginaros que no podrán hacer los expertos a los que nuestros gobiernos pagan un pastizal

Un saludo
Kaltorak.

BlackM4ster me alegro mucho de que te haya gustado, la verdad es que la idea de usar los sprites del Mario bros surgió de repente    los tenía en el escritorio muertos de asco los vi y dije coño para el snake    lo que pasa es que me he liado mucho con el juego y se a vuelto muy complejo y no sé si podre terminar todo lo que quiero incluirle de aquí al día 30.

SrCooper un trabajo magnifico si señor tiene algunos pequeños fallos, pero está muy muy bien