Mensajes

Te recomiendo que hagas algunas prácticas con hilos... Si tienes linux mejor (ahí tienes la librería pthread que es más fácil que Windows API).

Eso voy a hacer la verdad, porque es la primer vez que oigo de su existencia y me podrían ser muy útiles. Sí, tengo linux, pero por alguna razón no me funciona bien allegro así que utilizaré windows.
Un saludo y gracias por todo

Vale, entonces cuando en el while yo ejecute Funcion, esta se ejecutará automáticamente en segundo plano, ¿no?

La verdad es que no entiendo muy bien todo eso de DWORD, LPVOID y lpParam. ¿Qué significan exactamente?

Ya verás, ahora con esto mi juego del Snake va a mejorar mucho xDD
Un saludo y gracias

Pues no xD.

Aver, main llama a funcion_principal(). En funcion_principal() llama a funcion1(), espera 3 segundos y después llama a funcion2().

Si es eso, solo tendrías que poner rest(3000), si no es eso entonces no te entiendo... A no ser que quieras que la función y el main se ejecuten al mismo tiempo (¿Es eso?)

Exacto, lo has entendido perfectamente. Es justo eso lo que quiero que haga, pero NO puedo usar el rest porque entonces se para TODO el juego y yo solo quiero que se pare esa función.

Mi idea es que mientras se esperan 3 segundos el while se ejecute normalmente las veces que haga falta y cuando haya pasado el tiempo se ejecute funcion2.

Un saludo

¡Allegro! Por fin alguien lo usa ^^

Aunque no acabo de entender bien tú código, no sé, es un poco extraño (¿Que es retraso?)

Ahora que lo veo, en realidad es un poco retorcido pero es útil. Retraso es una variable que aumenta cada vez que se realiza un ciclo. Y solo cuando esta variable es igual a 10 (se han completado 10 ciclos) se realizan las acciones de mover a la serpiente y se resetea el valor. Si te fijas las acciones que no son de movimiento están fuera de este if.

La función de este valor es bajar un poco la velocidad del juego. También podría haberse hecho aumentando el valor del rest del final, pero con esta variable se concreta que solo queremos bajarle el "ritmo" al movimiento de la serpiente. Prueba a quitarla y se hace injugable, te lo aseguro  
Un saludo

¿Te refieres a una función que se ejecute cada 3 segundos?

Ya encontré como hacer eso, pero no es a lo que me refiero. Lo que me gustaría es algo como así:

Código (cpp) [Seleccionar] Expandir


void funcion_principal(){
       funcion1();
       esperar(3);
       funcion2();
}

Y luego en el main poder llamar a "funcion_principal" y que esta se ejecute en ese orden y con ese tiempo. No se si me explico...
Un saludo

[rest(3000)]

Buenas, estoy haciendo un videojuego en C++ con allegro, y me gustaría ejecutar una función 3 segundos después de que se haya ejecutado otra. (Es decir ejecutar una función, esperar tres segundos, y ejecutar la otra.)

No quiero usar la función rest(3000), porque esto ralentiza el juego al estar ejecutandose en un bucle while.
Quisiera saber si hay alguna libreria o algún truco que me sirva. He buscado en google un poco, pero no encuentro mi problema en particular.

Un saludo y gracias de antemano

[PD:]

Ya está lista la ALPHA de mi juego. Aquí el código:

Código (cpp) [Seleccionar] Expandir

#include <allegro.h>
#include <list>
#include <cstdlib>
#include <time.h>
#include <string>
using namespace std;

const int XTAM = 60, YTAM = 40;
const int SZ = 12;

int vx = 1, vy = 0;
int al, score = 0;

BITMAP *cuadrado1;
BITMAP *cuadradobmp;
BITMAP *buffer;
BITMAP *fruta;
BITMAP *manzanabmp;
BITMAP *fresabmp;
BITMAP *bombabmp;

void draw_score()
{
   rectfill(screen, 0,0,200,14,0);
   textprintf(screen, font, 0, 0, -1, "SCORE:  %d", score);
}

void pantalla(){
   blit(buffer, screen, 0,0,0,0, XTAM*SZ, YTAM*SZ);
}
struct Punto{
   int x,y;
};

void cuadrado(const Punto& p){
   blit(cuadradobmp, cuadrado1, 0, 0, 0, 0, 12, 12);
   draw_sprite(buffer, cuadrado1, p.x*SZ, p.y*SZ);
}

void pinta_comida(const Punto& p){
   srand(time(0));
   if (al==0) blit(manzanabmp, fruta, 0, 0, 0, 0, 12, 12);
   if (al==1) blit(fresabmp, fruta, 0, 0, 0, 0, 12, 12);
   draw_sprite(buffer, fruta, p.x*SZ, p.y*SZ);
}

Punto al_azar(){
   srand(time(0));
   Punto p = {rand() % XTAM, rand() % YTAM};
   al = rand() % 2;
   return p;
}

void teclas(){
       if (key[KEY_UP] && vy != 1){
           vx = 0, vy = -1;
      }else if (key[KEY_DOWN] && vy != -1){
           vx = 0; vy = 1;
      }else if (key[KEY_LEFT] && vx != 1){
           vx = -1, vy = 0;
      }else if (key[KEY_RIGHT] && vx != -1){
           vx = 1, vy = 0;
      }
}

bool hay_choque(const Punto& cabeza, const list<Punto>& cola){
   if (cabeza.x >= XTAM  || cabeza.x < 0) return true;
   if (cabeza.y >= YTAM  || cabeza.y < 0) return true;
   list <Punto>::const_iterator it = cola.begin();
   for (; it != cola.end(); it++){
       if (cabeza.x == it->x && cabeza.y == it->y){
           return true;
       }
   }
   return false;
}

int main(){
   allegro_init();
   install_keyboard();

   set_color_depth(32);
   set_gfx_mode(GFX_AUTODETECT_WINDOWED, XTAM * SZ, YTAM * SZ, 0, 0);

   buffer = create_bitmap(XTAM * SZ, YTAM * SZ);
   cuadrado1 = create_bitmap(12,12);
   cuadradobmp = load_bitmap("imagenes/cabeza.bmp", NULL);
   fruta = create_bitmap(12,12);
   fresabmp = load_bitmap("imagenes/fresa.bmp", NULL);
   manzanabmp = load_bitmap("imagenes/manzana.bmp", NULL);
   bombabmp = load_bitmap("imagenes/bomba.bmp", NULL); //Ya desvelo lo que incluire proximamente ;D

   list<Punto> cola;
   int engorda = 0;
   int retraso = 0;

   bool choque = false;
   Punto cara = {30, 30};
   Punto comida = al_azar();

   while(!key[KEY_ESC] && !choque ){
       pantalla();
       retraso++;
       teclas();
       draw_score();

        if (retraso==8){
           cola.push_front(cara);
           if (engorda > 0){
               engorda--;
           }else {
               cola.pop_back();
           }
           cara.x += vx;
           cara.y += vy;
           if (hay_choque(cara, cola)){
               choque = true;

           } else if (cara.x == comida.x && cara.y == comida.y){
               engorda = 5;
               if (al==0) score += 5;
               else if (al==1) score +=10;
               comida = al_azar();
               while (hay_choque(comida, cola) ||
                   comida.x == cara.x && comida.y == cara.y ||
                   comida.y < 5){
                       comida = al_azar();
                   }
           }

           retraso = 0;
       }
   if (!choque){
           clear(buffer);
           list<Punto>::const_iterator it;
           for (it = cola.begin(); it != cola.end(); it++){
               cuadrado(*it);
           }
           cuadrado(cara);
           pinta_comida(comida);

       }
       rest(10);
   }

   rectfill(screen, 0,0,200,14,0);
   textprintf(screen, font, 200, 200, -1, "Tu puntuacion ha sido de:  %d", score);
   rest(2000);
   return 0;
}
END_OF_MAIN();


He usado Allegro, una lista para crear a mi serpiente y estructuras en lugar de clases. El juego de momento solo tiene una fruta cada vez, aunque hay varios tipos de fruta (cada una da diferentes puntos).
El juego funciona perfectamente, aunque aún me queda incluirle un menú, más frutas y algún tipo de jefe o algo así  

PD: Cuando pueda subiré los archivos compilados en linux y windows

no me da tiempo :/ buena suerte a los participantes =D

A mi me pasa lo mismo. Pero bueno, será el año que viene 
Un saludo

Conseguí pasarme el Mayhem 



Aunque Warz0n3 te recomiendo que cambies los controles pues son bastante incomodos.
Un saludo y felicidades por el juego 

[Vigenère Cryptochat]

Se te ha olvidado poner Vigenère Cryptochat en la encuesta y en la lista de participantes.
Un saludo