Hola a todos

Me gustaría portar el minijuego de hackear las tiendas del saint row 4 a pc, alguno me ayuda con los gráficos son muy simples, no os llevaran mucho tiempo, los haria yo pero soy muy negado con el photoshop y demás programas de dibujo.

Aquí os pongo una captura de de dicho minijuego .


Un saludo
Kaltorak.

Hola a todos

Estoy buscando a alguien que me ayude con la carga gráfica que supone hacer un juego, ya he realizado algunos juegos para psp y pc, que quizás conozcáis.

Aquí os dejo algunas capturas de dichos juegos.

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.

Hola a todos.

Aquí os presento el juego que estoy desarrollando, empezó siendo un remake del ninja twins.
Pero al final he optado por cambiar completamente el diseño gráfico del juego, es más si hacemos niveles originales en vez de usar los del ninja twins sería totalmente original


Bunny And Shadow





Versión 0.03.

-Sustitución completa de los Gráficos del juego.
-Carga completa de los gráficos en memoria.
-implementada carga de niveles hechos en mappy.
-Diseño del nivel 1.
-Mostrado Nivel 1 en pantalla.
-Implementado movimiento de los conejos por la pantalla usando las teclas de dirección.
-Implementado Movimiento simultaneo de los Conejos.
-Implementado algoritmo de colisión con el decorado.

Binario: No se permite el publicar enlaces a programas compilados.

Versión 0.04

-Incluida animación de la explosión de polvo.
-Mejorada la posición de los gráficos.
-Implementada la posibilidad de reiniciar el juego pulsando la tecla R.
-Implementada la muerte de los conejos cuando colisionan entre ellos.
-Mejorada la velocidad de las animaciones.
-Solucionados bugs menores en el código.

Binario: No se permite el publicar enlaces a programas compilados.

Versión 0.05

-Corregido Fallo en la disposición de los elementos del nivel 1.
-Añadido mapa del Nivel 2.
-Implementada la captura de la zanahoria y la posibilidad de pasar de nivel.
-Corregido Fallo a la hora de Centrar en pantalla la explosión de polvo.
-Implementado loop entre los niveles disponibles.
-Cambiada la imagen del árbol, por que no gustaba mucho
-Cambiado El titulo de la ventana de juego.

Binario: No se permite el publicar enlaces a programas compilados.

Versión 0.06

-Corregido fallo en la lectura del mapa.
-Ampliación del Tileset.
-Mejorada la creación de mapas.
-Implementadas las burbujas en el juego.
-Implementado el rebote de los conejos contra las burbujas.
-Implementado Carro Vertical.
-Implementado movimiento del carro Vertical cuando los conejos chocan con él.
-Implementado Carro Horizontal.
-Implementado movimiento del Carro Horizontal cuando los conejos chocan con él.
-Implementado el Agujero del suelo.
-Implementada la muerte de los conejos al caer por el agujero del suelo.
-Implementada Caja rota.
-Implementada la rotura de la caja cuando un conejo choca contra ella.
-Implementada Rana.
-Implementada colisión de los conejos con la rana.
-Implementado movimiento de la rana.
-Añadido mapa del Nivel 3.
-Añadido mapa del Nivel 4.
-Añadido mapa del Nivel 5.
-Añadido mapa del Nivel 6.
-Añadido mapa del Nivel 7.
-Añadido mapa del Nivel 8.
-Añadido mapa del Nivel 9.
-Añadido mapa del Nivel 10.
-Corregido fallo a la hora de romper las caja próximas a los árboles.
-Corregido fallo en el movimiento del Carro Vertical y del Carro Horizontal.
-Implementada la posibilidad de que la rana se suba en el Carro Horizontal.
-Implementada la posibilidad de que la rana se mueva al mismo tiempo que el Carro Horizontal cuando va subida.
-Modificado Loop entre niveles para que soporte los nuevos niveles.
-Corregido fallo al reiniciar nivel.

Binario: No se permite el publicar enlaces a programas compilados.

Un saludo
Kaltorak.

Hola a todos

Nuevo mes nuevos retos, aquí os traigo los retos de ingeniería inversa de este mes.

1 - X-KGNME#3

2 - VBCrackme2 by main

3 - Simple Math Keygenme

4 - SerialMes

5 - mayhemious_Crack_me

6 - Crackme_by_mausy

Retos:
http://ultrashare.net/hosting/dl/5a58d57055

Reglas:
http://foro.elhacker.net/ingenieria_inversa/retos_mensuales_de_reversing-t371874.0.html



Un saludo
Kaltorak.

Hola a todos.

Aquí tenemos el Primer reto del Grupo de programación retrodev.

Mientras decidimos que juego va a ser el siguiente que realicemos, os propongo este reto el cual nos servirá para no perder el interés en el proyecto, también nos servirá para pulir un poco más nuestras actitudes y que los programadores noveles practiquen con la librería SDL.

Reto:

Juego de la Serpiente.



Participantes:

Apolo.
Dato000.
Ferreter17.
SrCooper.
BlackMaster.
Puntoinfinito.
Kaltorak.

 
 Normas del Reto:

1-Todo el que quiera participar en el reto tiene que enviar un privado apuntándose o postear su inscripción en este post.
 
 2-Una vez finalizado el tiempo de inscripción se dispondrá de 15 días para subir una versión Alpha del juego y luego 15 días más para subir la versión definitiva de dicho juego.

3-se puede usar cualquier lenguaje de programación (Pero primara el uso de C/C++ y la librería SDL, pues son los que usaremos en los sucesivos proyectos).

4-Se podrán usar cualquier tipo de gráficos y sonidos, no hay por qué ceñirse a los originales del juego.

5-Se puede incluir cualquier mejora en la mecánica del juego que consideremos oportuna.

6-Se debe compilar tanto para Windows como para Linux.

7-Deben subirse el código fuente y el binario para Windows y Linux, así como todos los archivos que sean necesarios para su compilación y ejecución.

8-Los Binarios y el código fuente deben tener un Link Activo, que deberemos mantener durante mínimo una semana después de finalizado el concurso.

9-Tras la finalización del reto se posteara una encuesta para ver quien a resuelto mejor el reto.
 




 Un saludo
 Kaltorak.

Hola a todos.

Este mes me encargo yo de subir los retos y gestionar la lista de los participantes, así Flamer se puede relajar un poco.
Espero que participéis muchos este mes, recordar que tenéis que enviarme a mí los retos resueltos para que los poste a final de mes.

1 - cc14 --> 1- Simple CrackMe #1-Bloc.

2 - crackme#1.LightHash.

3 - Crackme5.

4 - InjectMe_#2.

5 - LeeviON__sCrackme.

6 - YourFirst.

Retos:
ultrashare.net/hosting/fl/95d86db57a

Reglas:
http://foro.elhacker.net/ingenieria_inversa/retos_mensuales_de_reversing-t371874.0.html


Debido a que el Crackme cc14 no puede ser resulto lo hemos cambiado por el Simple CrackMe #1-Bloc
Siento las molestias que os haya podido ocasionar el problema con el cc14
Aquí tenéis el enlace de descarga del nuevo Crackme.

Simple CrackMe #1-Bloc: http://ultrashare.net/hosting/fl/69df35b9f4

Hola a todos

Me preguntaba, si estaríais interesados en que formáramos un grupo de programación de videojuegos en C / C++?
En un principio programaríamos en C / C++ con SDL, para plataformas windows y linux, pero no se descartaría portar lo que hiciéramos a psp , ps3 ,Etc...
Los que estéis interesados comentar y vamos viendo como nos organizamos.

Necesitariamos gente para programacion,Graficos,Sonido y betatesters.

Programacion:

-- Kaltorak
-- amchacon

Graficos:

-- dato000

Sonido:

-- OmarHack

Betatesters:

-- Paterniana



Un saludo
Kaltorak