elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado:


  Mostrar Temas
Páginas: [1]
1  Media / Diseño Gráfico / Graficos para el mini juego hackear tiendas de saint row 4 en: 27 Agosto 2013, 02:22 am
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.
2  Media / Diseño Gráfico / Busco Grafista para realizar juegos En c++ para windows y linux en: 18 Agosto 2013, 17:28 pm
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.

KOPBANPSP



KOPITETRIS





KOPFROG




Un saludo
Kaltorak.
3  Programación / Programación C/C++ / [Tutorial] Snake en C++/SDL en: 13 Agosto 2013, 04:49 am
SNAKE
EN C++/SDL




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++.

Código
  1. //Juego Snake realizado por kaltorak para el manual Snake en SDL/C++
  2.  
  3. #include <cstdlib>
  4. #include <vector>
  5. #include <time.h>
  6. #include <SDL/SDL.h>
  7.  
  8. //Prototipo de la funcion Colision.
  9. int Colision(SDL_Rect,SDL_Rect);
  10.  
  11. //Prototipo de la funcion Iniciar.
  12. void Iniciar(void);
  13.  
  14. /*definimos la direcciones que pude tomas la seriente con esto conseguimos que el codigo sea mucho mas
  15.   mas comprensible*/
  16. #define Arriba 1
  17. #define Derecha 2
  18. #define Abajo 3
  19. #define Izquierda 4
  20.  
  21. /*Declaramos e inicializamos como constantes el ancho, el alto y la profundidad de color
  22.   de la ventana principal.*/
  23. const int ResolucionX = 640;
  24. const int ResolucionY = 480;
  25. const int PColor = 32;
  26.  
  27. const int DELAY = 85;
  28.  
  29. //Declaramos e inicializamos la varible LongitudSerpiente la cual contendra el tamaño de la serpiente.
  30. int LongitudSerpiente = 0;
  31.  
  32. /*Declaramos e inicializamos la variable Direccion que contendra la direccion en la que se esta
  33.   moviendo la Serpiente.*/
  34. int Direccion = 0;
  35.  
  36. //Declaramos e inicializamos la variable control para controlar que la manzana no coincida con al cola.
  37. int Control = 0;
  38.  
  39. /*Declaramos la variable memoria del tipoc SDL_Rect donde almacenaremos la posion anterior anterior
  40.   de la cabeza de la serpiente para poder mover la cola*/
  41. SDL_Rect Ultimo;
  42.  
  43. //Declaramos e inicializamos la variable Puntos que contendra los puntos del juego.
  44. int Puntos = 0;
  45.  
  46. //Delcaramos e inicializamos la variable Titulo que contendra el titulo de la ventana y la puntuacion.
  47. char Titulo[255];
  48.  
  49. using namespace std;
  50.  
  51. /*Declaramos la estructura Cuadro que sera la encargada de almacenar la posicion
  52.   y el tamaño de cada una de las partes que formaran el cuerpo de la Serpiente*/
  53. struct Cuadro
  54. {
  55.   SDL_Rect Posicion;
  56.   Cuadro(){Posicion.x = 0;Posicion.y = 0;Posicion.w = 20;Posicion.h = 20;}
  57. }Manzana;
  58.  
  59. //Declaramos el Vector Serpiente del tipo Cuadro.
  60. vector <Cuadro> Serpiente;
  61.  
  62. int main ( int argc, char** argv )
  63. {
  64.  
  65.    srand(time(NULL));
  66.  
  67.    //Inicializamos el modo de video de las SDL y comprobamos que se inicialize bien.
  68.    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  69.     {
  70.      printf( "Imposible iniciar la libreria SDL: %s\n", SDL_GetError() );
  71.      return 1;
  72.     }
  73.  
  74.    //Itroducimos SDL_Quit en atexit para que se inice al finalizar el programa.
  75.    atexit(SDL_Quit);
  76.  
  77.    /*Creamos la Surface principal del juego, la que se va a mostrar en pantalla.
  78.       y comprobamos que se inicie correctamente.*/
  79.    SDL_Surface* PantallaV = SDL_SetVideoMode(ResolucionX, ResolucionY, PColor,SDL_HWSURFACE|SDL_DOUBLEBUF);
  80.    if ( !PantallaV )
  81.     {
  82.      printf("Imposible crear la ventana Principal: %s\n", SDL_GetError());
  83.      return 1;
  84.     }
  85.  
  86.    //Llamamos a la funcion Iniciar par poner todos los valores a cero.
  87.    Iniciar();
  88.  
  89.    // program main loop
  90.    bool done = false;
  91.    while (!done)
  92.    {
  93.        // message processing loop
  94.        SDL_Event event;
  95.        while (SDL_PollEvent(&event))
  96.        {
  97.            // check for messages
  98.            switch (event.type)
  99.            {
  100.                // exit if the window is closed
  101.            case SDL_QUIT:
  102.                done = true;
  103.                break;
  104.  
  105.                // check for keypresses
  106.            case SDL_KEYDOWN:
  107.                {
  108.                    // exit if ESCAPE is pressed
  109.                    if (event.key.keysym.sym == SDLK_ESCAPE)
  110.                     {
  111.                      done = true;
  112.                      break;
  113.                     }
  114.                    if(event.key.keysym.sym == SDLK_UP && Direccion != Abajo)
  115.                     {
  116.                      Direccion = Arriba;
  117.                      break;
  118.                     }
  119.                    if(event.key.keysym.sym == SDLK_DOWN && Direccion != Arriba)
  120.                     {
  121.                      Direccion = Abajo;
  122.                      break;
  123.                     }
  124.                    if(event.key.keysym.sym == SDLK_LEFT && Direccion != Derecha)
  125.                     {
  126.                      Direccion = Izquierda;
  127.                      break;
  128.                     }
  129.                    if(event.key.keysym.sym == SDLK_RIGHT && Direccion != Izquierda)
  130.                     {
  131.                      Direccion = Derecha;
  132.                      break;
  133.                     }
  134.                }
  135.            } // end switch
  136.        } // end of message processing
  137.  
  138.        // DRAWING STARTS HERE
  139.  
  140.        if(Direccion != 0)
  141.         {
  142.          //Almacenamos la posicion del ultimo de los elementos que forman la cola en la variable Ultimo.
  143.          Ultimo.x = Serpiente[LongitudSerpiente].Posicion.x;
  144.          Ultimo.y = Serpiente[LongitudSerpiente].Posicion.y;
  145.  
  146.          //Movemos la cola de la serpiente.
  147.          for(int I = LongitudSerpiente; I >= 1; I--)
  148.           {
  149.            Serpiente[I].Posicion.x = Serpiente[I-1].Posicion.x;
  150.            Serpiente[I].Posicion.y = Serpiente[I-1].Posicion.y;
  151.           }
  152.         }
  153.  
  154.        if(Direccion == Arriba)
  155.         {
  156.          Serpiente[0].Posicion.y -= Serpiente[0].Posicion.h;
  157.         }
  158.        else if(Direccion == Abajo)
  159.         {
  160.          Serpiente[0].Posicion.y += Serpiente[0].Posicion.h;
  161.         }
  162.        else if(Direccion == Derecha)
  163.         {
  164.          Serpiente[0].Posicion.x += Serpiente[0].Posicion.w;
  165.         }
  166.        else if(Direccion == Izquierda)
  167.         {
  168.          Serpiente[0].Posicion.x -= Serpiente[0].Posicion.w;
  169.         }
  170.  
  171.        //Comprobamos la colision de la serpiente con el borde.
  172.        if(((Serpiente[0].Posicion.x + Serpiente[0].Posicion.w)  > ResolucionX)
  173.             || (Serpiente[0].Posicion.x < 0)
  174.             || ((Serpiente[0].Posicion.y + Serpiente[0].Posicion.h)  > ResolucionY)
  175.             || (Serpiente[0].Posicion.y < 0))
  176.         {
  177.          Iniciar();
  178.         }
  179.  
  180.        //Comprobamos la colision de la serpiente con la cola.
  181.        for(int I = 1; I <= LongitudSerpiente; I++)
  182.         {
  183.          if(Colision(Serpiente[0].Posicion,Serpiente[I].Posicion))
  184.           {
  185.            Iniciar();
  186.           }
  187.         }
  188.  
  189.        //Comprobamos la colision de la serpiente con la Manzana.
  190.        if(Colision(Serpiente[0].Posicion,Manzana.Posicion))
  191.         {
  192.          LongitudSerpiente++;
  193.          Puntos += 10;
  194.          Serpiente.push_back(Cuadro());
  195.          Serpiente[LongitudSerpiente].Posicion.x = Ultimo.x;
  196.          Serpiente[LongitudSerpiente].Posicion.y = Ultimo.y;
  197.  
  198.          //Metemos en la varible Titulo el titulo de la ventana seguido de la puntuacion del juego.
  199.          sprintf(Titulo,"Snake -- Puntos: %d",Puntos);
  200.  
  201.          /*Posicionamos denuevo la manazana en pantalla y comprobamos que la nueva ubicacion
  202.             no este ocupada por la cola de la Serpiente.*/
  203.          do
  204.           {
  205.            Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);
  206.            Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
  207.            Control = 0;
  208.            for(int I = 1; I <= LongitudSerpiente; I++)
  209.             {
  210.              if(Colision(Manzana.Posicion,Serpiente[I].Posicion))
  211.               {
  212.                Control = 1;
  213.                I = LongitudSerpiente;
  214.               }
  215.             }
  216.           }
  217.          while(Control == 1);
  218.         }
  219.  
  220.        //Borramos la surface principal
  221.        SDL_FillRect(PantallaV, 0, SDL_MapRGB(PantallaV->format, 0, 0, 0));
  222.  
  223.        //Pintamos la serpiente en la Surface principal
  224.        for(int I = 0; I <= LongitudSerpiente; I++)
  225.         {
  226.          SDL_FillRect(PantallaV,&Serpiente[I].Posicion,SDL_MapRGB(PantallaV->format, 255, 255, 255));
  227.         }
  228.  
  229.        //Pintamos la manzana en la Surface principal
  230.        SDL_FillRect(PantallaV,&Manzana.Posicion,SDL_MapRGB(PantallaV->format, 0, 255, 0));
  231.  
  232.        //Cambiamos el titulo de la ventana por Snake.
  233.        SDL_WM_SetCaption (Titulo, NULL);
  234.  
  235.        //Mostramos la Surface principal en pantalla.
  236.        SDL_Flip(PantallaV);
  237.        SDL_Delay(DELAY);
  238.    } // end main loop
  239.  
  240.  
  241.    return 0;
  242. }
  243.  
  244. //Funcion que compruba las colisiones entre los elementos de juego.
  245. int Colision(SDL_Rect H,SDL_Rect M)
  246. {
  247.    if (((H.x + H.w) > M.x) && ((H.y + H.h) > M.y) &&
  248.            ((M.x + M.w) > H.x) && ((M.y + M.h) > H.y))
  249.    {
  250.        return 1;
  251.    }
  252.    else
  253.    {
  254.        return 0;
  255.    }
  256. }
  257.  
  258. //Funcion que reinicia el juego cuando la serpiente colisiona con ella misma o el borde.
  259. void Iniciar(void)
  260. {
  261.  /*Ponemos el valor de la variable longitudSerpiente a 0 para que la serpiente solo este formada por
  262.     la cabeza.*/
  263. LongitudSerpiente = 0;
  264.  //Ponemos el valor de la variable Direccion a 0 para que la serpiente aparezca parada al comenzar el juego.
  265.  Direccion = 0;
  266.  //Ponemos el valor de la variable Puntos a 0 para reiniciar el marcador de puntos.
  267.  Puntos = 0;
  268.  //Metemos en la varible Titulo el titulo de la ventana seguido de la puntuacion del juego.
  269.  sprintf(Titulo,"Snake -- Puntos: %d",Puntos);
  270.  //Borramos todos los miembros que forman el vector Serpiente
  271.  Serpiente.clear();
  272.  //Añadimos un miembro en el vector serpiente que contendra la cabeza de la serpiente.
  273.  Serpiente.push_back(Cuadro());
  274.  //Posicionamos aleatoriamente la manzana en la pantalla.
  275.  Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);
  276.  
  277.  Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
  278.  //Posicionamos la cabeza de la serpiente en el centro de la pantalla.
  279.  Serpiente[0].Posicion.x = (((ResolucionX/Serpiente[0].Posicion.w)/2)*Serpiente[0].Posicion.w);
  280.  Serpiente[0].Posicion.y = (((ResolucionY/Serpiente[0].Posicion.h)/2)*Serpiente[0].Posicion.h);
  281. }
  282.  

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 "

Código
  1. #include <cstdlib>

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

Código
  1. #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.

Código
  1. #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.

Código
  1. #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.

Código
  1. int Colision(SDL_Rect,SDL_Rect);
  2.  
  3. void Iniciar(void);
  4.  

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.

Código
  1. #define Arriba 1
  2. #define Derecha 2
  3. #define Abajo 3
  4. #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.

Código
  1. const int ResolucionX = 640;
  2. const int ResolucionY = 480;
  3. 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

Código
  1. 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.

Código
  1. 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.

Código
  1. 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.

Código
  1. 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.

Código
  1. SDL_Rect Ultimo;

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

Código
  1. int Puntos = 0;

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

Código
  1. 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++

Código
  1. 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.

Código
  1. struct Cuadro
  2. {
  3.  SDL_Rect Posicion;
  4.  Cuadro(){Posicion.x = 0;Posicion.y = 0;Posicion.w = 20;Posicion.h = 20;}
  5. }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.

Código
  1. vector <Cuadro> Serpiente;

la función main no necesita presentación ;)

Código
  1. int main ( int argc, char** argv )
  2. {

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

Código
  1. srand(time(NULL));

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

Código
  1. if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  2. {
  3.   printf( "Imposible iniciar la libreria SDL: %s\n", SDL_GetError() );
  4.   return 1;
  5. }

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.

Código
  1. atexit(SDL_Quit);

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

Código
  1. SDL_Surface* PantallaV = SDL_SetVideoMode(ResolucionX, ResolucionY,PColor,SDL_HWSURFACE|SDL_DOUBLEBUF);
  2.   if ( !PantallaV )
  3.    {
  4.     printf("Imposible crear la ventana Principal: %s\n", SDL_GetError());
  5.     return 1;
  6.    }

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

Código
  1. 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.

Código
  1. void Iniciar(void)
  2. {
  3. /*Ponemos el valor de la variable longitudSerpiente a 0 para que la serpiente solo este formada por
  4.    la cabeza.*/
  5. LongitudSerpiente = 0;
  6. /*Ponemos el valor de la variable Direccion a 0 para que la serpiente aparezca parada al comenzar  el juego.*/
  7. Direccion = 0;
  8. //Ponemos el valor de la variable Puntos a 0 para reiniciar el marcador de puntos.
  9. Puntos = 0;
  10. //Metemos en la variable Titulo el titulo de la ventana seguido de la puntuación del juego.
  11. sprintf(Titulo,"Snake -- Puntos: %d",Puntos);
  12. //Borramos todos los miembros que forman el vector Serpiente
  13. Serpiente.clear();
  14. //Añadimos un miembro en el vector serpiente que contendrá la cabeza de la serpiente.
  15. Serpiente.push_back(Cuadro());
  16. //Posicionamos aleatoriamente la manzana en la pantalla.
  17. Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);  
  18. Manzana.Posicion.y = ((rand() % ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
  19. //Posicionamos la cabeza de la serpiente en el centro de la pantalla.
  20. Serpiente[0].Posicion.x = (((ResolucionX/Serpiente[0].Posicion.w)/2)*Serpiente[0].Posicion.w);
  21. Serpiente[0].Posicion.y = (((ResolucionY/Serpiente[0].Posicion.h)/2)*Serpiente[0].Posicion.h);
  22. }
  23.  

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

Código
  1. Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);  
  2. 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.

Código
  1. (ResolucionX-Manzana.Posicion.w)
  2. (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.

Código
  1. (ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w)
  2. (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.

Código
  1. Manzana.Posicion.x = ((rand() % ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);  
  2. 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.

Código
  1. Serpiente[0].Posicion.x = (((ResolucionX/Serpiente[0].Posicion.w)/2)*Serpiente[0].Posicion.w);
  2. 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).

Código
  1. bool done = false;
  2. while (!done)
  3.  {

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.

Código
  1.       SDL_Event event;
  2.       while (SDL_PollEvent(&event))
  3.       {
  4.           switch (event.type)
  5.           {
  6.             case SDL_QUIT:
  7.               done = true;
  8.               break;
  9.  
  10.           case SDL_KEYDOWN:
  11.               {
  12.                   if (event.key.keysym.sym == SDLK_ESCAPE)
  13.                    {
  14.                     done = true;
  15.                     break;
  16.                    }
  17.                   if(event.key.keysym.sym == SDLK_UP && Direccion != Abajo)
  18.                    {
  19.                     Direccion = Arriba;
  20.                     break;
  21.                    }
  22.                   if(event.key.keysym.sym == SDLK_DOWN && Direccion != Arriba)
  23.                    {
  24.                     Direccion = Abajo;
  25.                     break;
  26.                    }
  27.                   if(event.key.keysym.sym == SDLK_LEFT && Direccion != Derecha)
  28.                    {
  29.                     Direccion = Izquierda;
  30.                     break;
  31.                    }
  32.                   if(event.key.keysym.sym == SDLK_RIGHT && Direccion != Izquierda)
  33.                    {
  34.                     Direccion = Derecha;
  35.                     break;
  36.                    }
  37.               }
  38.           }
  39.       }

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

Código
  1. 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.

Código
  1. while (SDL_PollEvent(&event))
  2.       {

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

Código
  1. switch (event.type)
  2.           {

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.

Código
  1. case SDL_QUIT:
  2.               done = true;
  3.               break;

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

Código
  1. case SDL_KEYDOWN:
  2.               {

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.

Código
  1. if (event.key.keysym.sym == SDLK_ESCAPE)
  2.                    {

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.

Código
  1. done = true;
  2. break;
  3. }

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.

Código
  1. if(event.key.keysym.sym == SDLK_UP && Direccion != Abajo)
  2.  {
  3.    Direccion = Arriba;
  4.    break;
  5.  }

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.

Código
  1.                   if(event.key.keysym.sym == SDLK_DOWN && Direccion != Arriba)
  2.                    {
  3.                     Direccion = Abajo;
  4.                     break;
  5.                    }
  6.                   if(event.key.keysym.sym == SDLK_LEFT && Direccion != Derecha)
  7.                    {
  8.                     Direccion = Izquierda;
  9.                     break;
  10.                    }
  11.                   if(event.key.keysym.sym == SDLK_RIGHT && Direccion != Izquierda)
  12.                    {
  13.                     Direccion = Derecha;
  14.                     break;
  15.                    }
  16.               }
  17.           }
  18.       }

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

Código
  1. if(Direccion != 0)
  2. {
  3.  Ultimo.x = Serpiente[LongitudSerpiente].Posicion.x;
  4.  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.

Código
  1.         //Movemos la cola de la serpiente.
  2.         for(int I = LongitudSerpiente; I >= 1; I--)
  3.          {
  4.           Serpiente[I].Posicion.x = Serpiente[I-1].Posicion.x;
  5.           Serpiente[I].Posicion.y = Serpiente[I-1].Posicion.y;
  6.          }
  7.        }

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,

Código
  1.       if(Direccion == Arriba)
  2.        {
  3.         Serpiente[0].Posicion.y -= Serpiente[0].Posicion.h;
  4.        }
  5.       else if(Direccion == Abajo)
  6.        {
  7.        Serpiente[0].Posicion.y += Serpiente[0].Posicion.h;
  8.        }
  9.       else if(Direccion == Derecha)
  10.        {
  11.         Serpiente[0].Posicion.x += Serpiente[0].Posicion.w;
  12.        }
  13.       else if(Direccion == Izquierda)
  14.        {
  15.         Serpiente[0].Posicion.x -= Serpiente[0].Posicion.w;
  16.        }

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.

Código
  1.       if(Direccion == Arriba)
  2.        {
  3.         Serpiente[0].Posicion.y -= Serpiente[0].Posicion.h;
  4.        }

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

Código
  1.       else if(Direccion == Abajo)
  2.        {
  3.         Serpiente[0].Posicion.y += Serpiente[0].Posicion.h;
  4.        }
  5.       else if(Direccion == Derecha)
  6.        {
  7.         Serpiente[0].Posicion.x += Serpiente[0].Posicion.w;
  8.        }
  9.       else if(Direccion == Izquierda)
  10.        {
  11.         Serpiente[0].Posicion.x -= Serpiente[0].Posicion.w;
  12.        }

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.

Código
  1.       if(((Serpiente[0].Posicion.x + Serpiente[0].Posicion.w)  > ResolucionX)
  2.            || (Serpiente[0].Posicion.x < 0)
  3.            || ((Serpiente[0].Posicion.y + Serpiente[0].Posicion.h)  > ResolucionY)
  4.            || (Serpiente[0].Posicion.y < 0))
  5.        {
  6.         Iniciar();
  7.        }
  8.  

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.

Código
  1. int Colision(SDL_Rect H,SDL_Rect M)
  2. {
  3.   if (((H.x + H.w) > M.x) && ((H.y + H.h) > M.y) &&
  4.           ((M.x + M.w) > H.x) && ((M.y + M.h) > H.y))
  5.   {
  6.       return 1;
  7.   }
  8.   else
  9.   {
  10.       return 0;
  11.   }
  12. }

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 .

Código
  1.       //Comprobamos la colision de la serpiente con la cola.
  2.       for(int I = 1; I <= LongitudSerpiente; I++)
  3.        {
  4.         if(Colision(Serpiente[0].Posicion,Serpiente[I].Posicion))
  5.          {
  6.           Iniciar();
  7.          }
  8.        }

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.

Código
  1.       if(Colision(Serpiente[0].Posicion,Manzana.Posicion))
  2.        {

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í.

Código
  1. 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.

Código
  1. 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.

Código
  1. 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.

Código
  1. Serpiente[LongitudSerpiente].Posicion.x = Ultimo.x;
  2. 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.

Código
  1. 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.

Código
  1. do {
  2. Manzana.Posicion.x = ((rand() %  ((ResolucionX-Manzana.Posicion.w)/Manzana.Posicion.w))*Manzana.Posicion.w);
  3. Manzana.Posicion.y = ((rand() %  ((ResolucionY-Manzana.Posicion.h)/Manzana.Posicion.h))*Manzana.Posicion.h);
  4. Control = 0;
  5. for(int I = 1; I <= LongitudSerpiente; I++)
  6.    {
  7.      if(Colision(Manzana.Posicion,Serpiente[I].Posicion))
  8.        {
  9.          Control = 1;
  10.          I = LongitudSerpiente;
  11.        }
  12.     }
  13.   }
  14.  while(Control == 1);
  15. }
  16.  

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.

Código
  1. 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.

Código
  1. for(int I = 0; I <= LongitudSerpiente; I++)
  2. {
  3.   SDL_FillRect(PantallaV,&Serpiente[I].Posicion,SDL_MapRGB(PantallaV->format, 255, 255,   255));
  4.  }

Posicionamos el dibujo de la manzana en la surface PantallaV.

Código
  1. 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.

Código
  1. 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.

Código
  1. SDL_Flip(PantallaV);
  2. SDL_Delay(DELAY);
  3. }
  4.  

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.

Código
  1.   return 0;
  2. }

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.
4  Programación / Java / [Tutorial] Aprendiendo a Programar En Java 7 -- Capitulo 1 en: 5 Agosto 2013, 11:55 am
Aprendiendo a Programar en Java 7
Capitulo 1

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.

 
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.

C:\Program Files (x86)\Java\jdk1.7.0_25

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

C:\Program Files (x86)\Java\jdk1.7.0_25\bin

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.

Código
  1. class Hola
  2. {
  3.   public static void main(String args[])
  4.    {
  5.     System.out.println("Hola Mundo");
  6.    }
  7. }

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.

javac Hola.java

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.
5  Programación / Programación C/C++ / [Juego] Bunny And Shadow en: 26 Julio 2013, 01:46 am
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 :D


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.
6  Programación / Ingeniería Inversa / Retos Julio 2013 De reversing en: 2 Julio 2013, 10:23 am
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


Lista de Ganadores
-----------------------------------------------------------------
|     Usuario        |      Reto    |                Logro             |
-----------------------------------------------------------------
|    nanodiLL0     |       4       |               Resuelto          |
----------------------------------------------------------------
|TrashAmbishion |       5      |               Tutorial             |
----------------------------------------------------------------

nanodiLL0

-----------------------------------------------------------
4 - SerialMes
-----------------------------------------------------------

Name : Hack the Hacker
S/N  : (F!-4.5/(..T]

Aquí va un mini-tutorial (No muy bien explicado) :

Los objetivos son :

Eliminar el nag.
Encontrar el Nombre de usuario.
Encontrar el Serial para activar el programa.


Eliminando el nag

Hay bastantes método para esto, pero elejí el que me facilito todo a mí.
Es un rtcMsgBox (Parecido al MessageBoxA), entonces ponemos un Bp en esa API.

Bp rtcMessageBox Iniciamos el programa.


Miramos el stack y vemos donde retorna,  damos clic derecho y follow in dissambler.

Código
  1. LEA EAX,DWORD PTR SS:[EBP-58]

Caemos ahí, Ahora quitamos el Bp de la API rtcMsgBox y lo ponemos en ese "LEA".
Reiniciamos y damos Run.

Nos muestra el Message y para en el Breakpoint que agregamos.
Veamos los Registros Especialmente EAX
Esta en 1.

Bueno estoy algo me dice que por EAX se ejecutó el nag de la discordia.
Bueno tengo fiaca. Así que nopeamos a ver el call de rtcMsgBox

Código
  1. CALL DWORD PTR DS:[<&MSVBVM60.#595>]     ;  MSVBVM60.rtcMsgBox

Guardamos los cambios Clic derecho -> Copy to executable->All modifications-> Save File.

Bam! Hemos vencido al nag.

Encontrando el nombre y el serial:

Bueno no quiero que gasten tiempo en buscar un decompilador para Visual basic, usaremos nada más ollydbg en este mini-tute.

Búsquemos en los strings references.
Bajamos un poco buscando nuestro mensaje querido "Bad boy".

A fatal error happened while trying to register!

Un poco arriba vemos algunos strings sospechosos y tambien el mensaje de felicitaciones "Good boy".

Damos doble clic en el de Chico bueno y miremos a ver que encontramos.
Código
  1.     CMP SI,BX
  2.       JE SHORT SerialMe.00402453 ; Salta si el Flag Z = 0
  3.  

Eso no nos dice mucho, subamos un poco y miramos algo sospechoso :

Código
  1. PUSH SerialMe.00401A00                   ;  UNICODE "(F!-4.5/(..T]"
  2. CALL DWORD PTR DS:[<&MSVBVM60.__vbaStrCm>;  MSVBVM60.__vbaStrCmp

Nota : Recordemos que la API __vbaStrCmp compara dos cadenas de texto


Ollydbg nos aclara el String que va enviar al stack, entonces hagamosnos una pregunta ¿Con qué compara ese string?

veamos a ver como está esta odisea...

Pongamos un Bp en esa APi, además, ingresemos los siguientes datos para ir iguales.

Name : Ricardo
S/N    : N          ; Al escribir en el tedit de el serial se detiene el Breakpoint de la API.

y Si nos fijamos en el Stack :

Código
  1. 0012F378   00402844  RETURN to nag.00402844 from MSVBVM60.__vbaStrCmp
  2. 0012F37C   004019DC  UNICODE "Hack the Hacker"
  3. 0012F380   001846EC  UNICODE "Ricardo"
  4.  

si vemos en el stack retorna a una direccion de memoria, damos Follow in dissambler.
Código
  1.  
  2. 00402838        PUSH EAX
  3. 00402839    PUSH nag.004019DC                        ;  UNICODE "Hack the Hacker"
  4. 0040283E     CALL DWORD PTR DS:[<&MSVBVM60.__vbaStrCm>;  MSVBVM60.__vbaStrCmp
  5. 00402844   .  MOV EDI,EAX
  6.  
  7.  


Si nos fijamos en EAX tiene el nombre que ingresamos "Ricardo" y abajo mueve al stack el nombre sospechoso.

Entonces no queda más que decir que compara nuestor nombre con ese.
condicion_{
NAME FALSE == NAME TRUE
return 0
}
Reiniciemis el Ollydbg y ponemos ese nombre con el Bp en __vbaStrCmp.

Se detiene nuevamente y si nos fijamos en el stack estan iguales.

Entonces ya encontramos el nombre, solo falta encontrar el serial.

Ok no reinicien el ollydbg y demos F9 nuevamente.


Código
  1. 0012F378   004028AE  RETURN to nag.004028AE from MSVBVM60.__vbaStrCmp
  2. 0012F37C   00401A00  UNICODE "(F!-4.5/(..T]"
  3.  

Vemos ese string y Bam...

Tiene el mismo procedimiento de comparación que el nombre, entonces no queda nada mas que decir : Ese es el serial verdadero.

condicion{
SN == SN TRUE
return 0
}


Entonces tenemos el resultado :


Name : Hack the Hacker
S/N  : (F!-4.5/(..T]




-----------------------------------------------------------

TrashAmbishion

-----------------------------------------------------------
5 - mayhemious_Crack_me
-----------------------------------------------------------

Usuario: Hole_System
Serial: motakukukufuarichikurin

Tutorial: http://www.4shared.com/file/3jOCKDxG/Tuto_Mayhemio.html

-----------------------------------------------------------

Un saludo
Kaltorak.
7  Programación / Programación C/C++ / 1º Reto de Retrodev en: 18 Junio 2013, 14:53 pm
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.
 

BlackMaster



-----------------------------------------------------------
Binario Windows: https://www.dropbox.com/s/uxjoyc872t4yudg/Juego%20Isc%20Snake.zip  
Binario Linux: ??
Codigo: http://ultrashare.net/hosting/fl/9aa5f7a47b
-----------------------------------------------------------

Ferreter



-----------------------------------------------------------
Binario Windows: http://www.mediafire.com/?k56fd69g82paglj
Binario Linux: ??
Codigo: ??
-----------------------------------------------------------

SrCooper



-----------------------------------------------------------
Codigo y Binario Windows: http://www.mediafire.com/?2bktsm8qoi087z8
Binario Linux: ??
-----------------------------------------------------------


Puntoinfinito



-----------------------------------------------------------
Binario Windows: ??
Binario Linux: https://docs.google.com/file/d/0B_bICudPUUcpcmh5UmtveHM5TTg/edit?usp=sharing
Codigo: https://docs.google.com/file/d/0B_bICudPUUcpdElUUDFuVXc2Szg/edit?usp=sharing
-----------------------------------------------------------


Kaltorak



-----------------------------------------------------------
Binario Windows: http://ultrashare.net/hosting/fl/62ce21b834
Binario Linux: http://ultrashare.net/hosting/fl/28a0c065f5
Codigo: http://ultrashare.net/hosting/fl/df1913ec96
-----------------------------------------------------------




 Un saludo
 Kaltorak.
8  Programación / Ingeniería Inversa / Retos Junio 2013 De reversing en: 30 Mayo 2013, 18:47 pm
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


Lista de Ganadores
-----------------------------------------------------------------
|  Usuario        |      Reto    |                Logro               |
-----------------------------------------------------------------
|   FaQuiVer     |       2       |                 serial               |
----------------------------------------------------------------
|   FaQuiVer     |       3       |         Tutorial y Keygen     |
----------------------------------------------------------------
|   FaQuiVer     |       6       |                Tutorial            |
----------------------------------------------------------------
| PeterPunk77  |       1       |               Serial               |
----------------------------------------------------------------
| PeterPunk77  |       2       |               Resuelto           |
----------------------------------------------------------------
| PeterPunk77  |       3       |               Resuelto           |
----------------------------------------------------------------
| PeterPunk77  |       4       |               Resuelto           |
----------------------------------------------------------------
| PeterPunk77  |       5       |               Resuelto           |
----------------------------------------------------------------
| PeterPunk77  |       6       |               Resuelto           |
----------------------------------------------------------------
| CraZy7BiTS   |       1       |               Serial               |
----------------------------------------------------------------
| CraZy7BiTS   |       6       |               Resuelto           |
----------------------------------------------------------------


Soluciones FaQuiVer

-----------------------------------------------------------
2 - crackme#1.LightHash
-----------------------------------------------------------
Name:  FaQuiVer
Serial:  227378-30-3871
-----------------------------------------------------------

-----------------------------------------------------------
3 - Crackme5.
-----------------------------------------------------------

KeyGen:

    
Código
  1.    Private Sub Form_Load()
  2.    Dim Valor As Integer
  3.    Dim Nombre As String
  4.    Dim Serial As String
  5.    Dim RegCode As String
  6.    Dim ID As String
  7.    Nombre = InputBox("Nombre:", "Arkantos Crackme5 *KeyGen*")
  8.    Serial = vbNullString
  9.    RegCode = vbNullString
  10.    ID = vbNullString
  11.    If Len(Nombre) <= 4 Then MsgBox "Nombre demasiado corto", 16, "": End: Exit Sub
  12.    Nombre = StrReverse(Nombre)
  13.    For x = 1 To Len(Nombre)
  14.    Valor = Asc(Mid(Nombre, x, 1))
  15.    Serial = Serial & Hex(Valor)
  16.    Next x
  17.    RegCode = "210579ioO-avB-pM"
  18.    ID = "ua921N" & Serial & "pnqVTm"
  19.    MsgBox "Nombre: " & StrReverse(Nombre) & vbNewLine & "Serial: " & Serial & vbNewLine & _
  20.          "RegCode: " & RegCode & vbNewLine & "ID: " & ID, 64, "Done!"
  21.    End
  22.    End Sub
   


-----------------------------------------------------------
6 - YourFirst Crackme
-----------------------------------------------------------

Citar
vamos por partes, lo que necesitamos es ollydbg 1.10 sin cambios ni plugin

los objetivos son:

- nag
- AntiDebug
- PassCdCheck

Primero la nag!

al abrir el crackme en ollydbg caemos directamente aquí:

Código
  1.    00401000 >/$ 6A 00          PUSH 0                                   ; /Style = MB_OK|MB_APPLMODAL
  2.    00401002  |. 68 00304000    PUSH YourFirs.00403000                   ; |Title = "YourFirstCrackme"
  3.    00401007  |. 68 43304000    PUSH YourFirs.00403043                   ; |Text = "I'm an ugly nag screen. REMOVE ME!"
  4.    0040100C  |. 6A 00          PUSH 0                                   ; |hOwner = NULL
  5.    0040100E  |. E8 0D020000    CALL <JMP.&user32.MessageBoxA>           ; \MessageBoxA
  6.    00401013  |. 6A 00          PUSH 0                                   ; /pModule = NULL
  7.    00401015  |. E8 42020000    CALL <JMP.&kernel32.GetModuleHandleA>    ; \GetModuleHandleA


No tenemos que esforzarnos mucho verdad?  para eliminar la nag aplicamos NOP's en:


Código
  1.    0040100E  |. E8 0D020000    CALL <JMP.&user32.MessageBoxA>           ; \MessageBoxA


Con esto nos libramos de la nag, guardamos cambios y seguimos con el Antidebug

Al correr el crackme nos salta un mensaje con este texto:

---------------------------
YourFirstCrackme
---------------------------
Debugger found!
---------------------------
Aceptar  
---------------------------

que hacemos? pues... buscamos todas las referencias de texto, ubicamos "Debugger found!"

ENTER en la cadena para caer en el desensamblado

Caemos directamente aqui



Código
  1.    00401178   . 68 22304000    PUSH YourFirs.00403022                   ; |Text = "Debugger found!"


Subimos lineas mas arriba y analizamos el codigo


Código
  1.    00401119   . E8 44010000    CALL <JMP.&kernel32.IsDebuggerPresent>   ; [IsDebuggerPresent
  2.    0040111E   . 83F8 01        CMP EAX,1
  3.    00401121   . 74 4E          JE SHORT YourFirs.00401171
  4.    00401123   . 8B45 0C        MOV EAX,DWORD PTR SS:[EBP+C]
  5.    00401126   . 3D 10010000    CMP EAX,110
   



Observamos IsDebuggerPresent que es una funcion de windows para detectar debugeo

ese call nos devuelve 0 si no hay y 1 si hay un debugger presente

0040111E   . 83F8 01        CMP EAX,1 <--- aqui la condición

EAX almacena el resultado ( 0 o 1 ) y compara, si se cumple salta directamente al msgbox de "Debugger found!"

00401121   . 74 4E          JE SHORT YourFirs.00401171

Solucion!

NOP's Aqui:


Código
  1.    00401119     E8 44010000    CALL <JMP.&kernel32.IsDebuggerPresent>   ; [IsDebuggerPresent

o aqui:


Código
  1.    00401121   . 74 4E          JE SHORT YourFirs.00401171


Cualquiera de las dos opciones es valida, guardamos cambios y listo!

------------------------------------------------------------------------------------

Ahora PassCdCheck

Igual para este vemos que nos muestra un mensaje con este texto:

---------------------------
YourFirstCrackme
---------------------------
CD check failed!
---------------------------
Aceptar  
---------------------------

Buscamos referencias, ubicamos CD check failed! ENTER para caer en el desensamblado


Código
  1.    004011A7   > 6A 10          PUSH 10                                  ; /Style = MB_OK|MB_ICONHAND|MB_APPLMODAL
  2.    004011A9   . 68 00304000    PUSH YourFirs.00403000                   ; |Title = "YourFirstCrackme"
  3.    004011AE   . 68 11304000    PUSH YourFirs.00403011                   ; |Text = "CD check failed!"

Lineas mas arriba vemos el código y observamos desde donde salta


Código
  1.    00401188     E8 C9000000    CALL <JMP.&kernel32.GetDriveTypeA>
  2.    0040118D   . 83F8 05        CMP EAX,5
  3.    00401190   . 75 15          JNZ SHORT YourFirs.004011A7


Al tracear observo que esta función "GetDriveTypeA" me devuelve un valor de 3 el cual se almacena en EAX y se compara con 5. Obviamente no se cumple asi que salta al mensaje de error

3 Soluciones! aplicar cualquiera da el mismo resultado.

1.
Código
  1.    00401188     E8 C9000000    CALL <JMP.&kernel32.GetDriveTypeA>

Cambiar por:

Código
  1.    00401188     B8 05000000    MOV EAX,5

--------------------------------------------------------------------------------------

2.

Código
  1. 0040118D     83F8 05        CMP EAX,5

Cambiar por:


Código
  1.    0040118D     3BC0           CMP EAX,EAX
  2.    0040118F     90             NOP

--------------------------------------------------------------------------------------

3.
Aplicar NOP's Aqui:

Código
  1. 00401190   . 75 15          JNZ SHORT YourFirs.004011A7


--------------------------------------------------------------------------------------


Guardamos cambios utilizando cualquiera de las 3 soluciones y ya se nos muestra el mensaje bueno! aun que observo un detalle, luego de aceptar el mensaje bueno el Crackme rompe o crashea!


vuelvo al olly y luego del mensaje bueno observo esto:


Código
  1.   004011A5   . EB 4E          JMP SHORT YourFirs.004011F5


salta donde no debe asi que Redireccionamos quedando asi:


Código
  1.    004011A5     EB 48          JMP SHORT YourFirs.004011EF


y listo eso seria todo!


Soluciones PeterPunk77

-----------------------------------------------------------
1 - Simple CrackMe #1-Bloc.
-----------------------------------------------------------
User:  |Usuario|
Pass:  |J5L2C-K4B8L-D2K9S|

-----------------------------------------------------------

-----------------------------------------------------------
2 - crackme#1.LightHash.

3 - Crackme5.

4 - InjectMe_#2.

5 - LeeviON__sCrackme.

6 - YourFirst.
-----------------------------------------------------------

Soluciones: http://ultrashare.net/hosting/fl/a6bdccb84c
pass: "elhackerforum" (sin comillas).

-----------------------------------------------------------

Soluciones CraZy7BiTS

-----------------------------------------------------------
1 - Simple CrackMe #1-Bloc.
-----------------------------------------------------------

User:  |Usuario|
Pass:  |J5L2C-K4B8L-D2K9S|

-----------------------------------------------------------



Un Saludo
Kaltorak.
9  Programación / Programación C/C++ / Creacion de un grupo de programacion de videojuegos en: 30 Mayo 2013, 03:07 am
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
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines