imagenes:http://www.facebook.com/media/set/fbx/?set=a.1354381197591.40718.1773298651&l=ad16da3fba
pido excusas por aquello de la privacidad, pero he creado una cuanta para colocar imagenes en facebook, de este mdo mis imagenes estan ahi y de alli las descargo.
el juego se trata de una liebre que quiere atravezar un bosque y 4 lobos no desean quedarce sin almuerzo, el bosque es un tablero de ajedrez y cada animal puede moverce solo por los cuadros blancos uno en diagonal a la vez, la liebre no es tonta así que no se puede lanzar al lobo, los lobos no saben donde esta la liebre asi que avanzan aleatoriamente un cuadro hacia arriba mientras la liebre lo hace hacia abajo, cada vez que un lobo juega se imprime en pantalla quien jugó y el orden de los siguientes lobos, es decir si juega el lobo3 la lista es así 3 4 1 2, pero si juega el lobo4 la lista es 4 1 2 3 y debe ser así siempre, tambien se muesttra que la liebre jugó, otra cosa es que cuando alguien gana se muestra quien ganó, me falta colocar en cuantos turnos, ademas tengo que colocar el cuadro donde alguno de ellos pasó pero aun no lo he hecho.
tengo que hacer varias modificaciones pero ya lo hare antes de terminar este mes (si no no aprovaré la materia jejejeje) bueno aqui les dejó el codigo desde colombia y un fuerte abrazo a aquellos que brindan de su consejo y ayuda a los que estamos aprendiendo.
dejo un link en youtube.com de como se ve el video juego.
http://www.youtube.com/watch?v=hq_ethJ0Dxc
un poco de codigo: y para la seleccion de imagenes fijense en colocar las que mas os guste, claro viendo los nombres, ya sean los que coloque o los que le tengan a sus imagenes.
el audio esta comentado porque no encuentro una pista acorde para hacerlo funcionar.
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <iostream>
#include <string>
#include <time.h>
/*#include <SDL/SDL_mixer.h>*/
using namespace::std;
int main(int argc, char *argv[])
{
void limpiar (SDL_Surface *screen);
void imprimir(SDL_Surface *vector_lobo1,SDL_Surface *vector_lobo2,SDL_Surface *vector_lobo3,SDL_Surface *vector_lobo4,int vector1,SDL_Surface *turno,SDL_Surface *screen, SDL_Surface *ima, SDL_Surface *liebre, SDL_Surface *lobo1, SDL_Surface *lobo2, SDL_Surface *lobo3, SDL_Surface *lobo4, int *nivel_liebre, int *pos_liebre, int x, int y, int *pos_lobo1, int *nivel_lobo1, int *pos_lobo2, int *nivel_lobo2, int *pos_lobo3, int *nivel_lobo3, int *pos_lobo4, int *nivel_lobo4);
int fun_liebre(SDL_Surface *liebre,int f,int *nivel_liebre, int *pos_liebre);
int fun_lobo1( int *nivel_lobo1, int *pos_lobo1);
int fun_lobo2( int *nivel_lobo2, int *pos_lobo2);
int fun_lobo3( int *nivel_lobo3, int *pos_lobo3);
int fun_lobo4( int *nivel_lobo4, int *pos_lobo4);
int turnoliebre(SDL_Surface *screen,SDL_Surface *liebre,int f, int vector1, int *nivel_liebre, int *pos_liebre,int *pos_lobo1 ,int *pos_lobo2 ,int *pos_lobo3 ,int *pos_lobo4, int *nivel_lobo1, int *nivel_lobo2, int *nivel_lobo3, int *nivel_lobo4);
int turnolobo(int f,int x, int y,SDL_Surface *lobo1,SDL_Surface *lobo2,SDL_Surface *lobo3,SDL_Surface *lobo4,SDL_Surface *screen,SDL_Surface *vector_lobo1,SDL_Surface *vector_lobo2,SDL_Surface *vector_lobo3,SDL_Surface *vector_lobo4, int vector1, int *nivel_lobo1, int *pos_lobo1, int *nivel_lobo2, int *pos_lobo2,int *nivel_lobo3, int *pos_lobo3,int *nivel_lobo4, int *pos_lobo4, int *vector);
int ganador(int salir,int *loboganador,SDL_Surface *screen,int f, int vector1, int *nivel_liebre, int *pos_liebre,int *pos_lobo1, int *pos_lobo2 ,int *pos_lobo3 ,int *pos_lobo4 ,int *nivel_lobo1,int *nivel_lobo2,int *nivel_lobo3,int *nivel_lobo4);
srand(time(0));
SDL_Surface *screen;
SDL_Surface *ima;
SDL_Surface *liebre;
SDL_Surface *lobo1;
SDL_Surface *lobo2;
SDL_Surface *lobo3;
SDL_Surface *lobo4;
SDL_Surface *vector_lobo1;
SDL_Surface *vector_lobo2;
SDL_Surface *vector_lobo3;
SDL_Surface *vector_lobo4;
SDL_Surface *gana_lobo;
SDL_Surface *gana_liebre;
SDL_Surface *turno;
// SDL_Surface **vector;
int dado=rand()%1000;
cout<<"dado="<<dado<<endl; //decide quien comienza la partida
int vector1;
int *g;
int *vector;
int *nivel_liebre;
int *pos_liebre;
int *pos_lobo1;
int *nivel_lobo1;
int *pos_lobo2;
int *nivel_lobo2;
int *pos_lobo3;
int *nivel_lobo3;
int *pos_lobo4;
int *nivel_lobo4;
int *loboganador;
//****************************************************************************************************************************************
struct coordenadas_lobo
{
int nivellobo;
int poslobo;
struct coordenadas_lobo *siguiente;
} *clobo1, *clobo2, *clobo3, *clobo4;
clobo1=new struct coordenadas_lobo;
clobo2=new struct coordenadas_lobo;
clobo3=new struct coordenadas_lobo;
clobo4=new struct coordenadas_lobo;
(*clobo1).nivellobo=7;
(*clobo1).poslobo=0;
(*clobo2).nivellobo=7;
(*clobo2).poslobo=2;
(*clobo3).nivellobo=7;
(*clobo3).poslobo=4;
(*clobo4).nivellobo=7;
(*clobo4).poslobo=6;
pos_lobo1= &(*clobo1).poslobo;
nivel_lobo1= &(*clobo1).nivellobo;
pos_lobo2= &(*clobo2).poslobo;
nivel_lobo2= &(*clobo2).nivellobo;
pos_lobo3= &(*clobo3).poslobo;
nivel_lobo3= &(*clobo3).nivellobo;
pos_lobo4= &(*clobo4).poslobo;
nivel_lobo4= &(*clobo4).nivellobo;
loboganador=&vector1;
//**********************************************************************************************************************************************************************
struct coordenadas_liebre
{
int nivelliebre; //coordenada y
int posliebre; // coordenada x
struct coordenadas_liebre *siguiente;
}*cliebre;
cliebre=new struct coordenadas_liebre;
(*cliebre).posliebre=rand()%8; // coordenada x
(*cliebre).nivelliebre=rand()%6 ; //coordenada y
pos_liebre=&(*cliebre).posliebre; //inicializar los apuntadores que tendran la posicion de las imagenes
nivel_liebre=&(*cliebre).nivelliebre;
//**********************************************************************************************************************************************************************************************************************************************************
/* Mix_Music *cancion; */
SDL_Event event;
/*eventos*/
int salir = 0;
int x = 0;
int y = 0;
int i = 0;
int j = 0;
int f=0;
int a=0;
SDL_Rect rect;
//**********************************************************************************************************************************************************************************************************************************************************
//arreglos dinamicos
int *posliebre1;
posliebre1=new int[8];
if(posliebre1==NULL){cout<<"no hay espacio Disponible";}
for (i=0; i<8; i++, posliebre1++ ) {
*posliebre1 = i*53+5;
cout<<*posliebre1<<endl;
}
//**********************************************************************************************************************************************************************************************************************************************************
if(*pos_liebre==7)
{*pos_liebre-=1;}
int e= *pos_liebre + *nivel_liebre;
cout<<"e="<<e<<" *pos_liebre="<<*pos_liebre<<" *nivel_liebre="<<*nivel_liebre<<endl;
if(e%2==0){
cout<<"e="<<e<<" *pos_liebre="<<*pos_liebre<<" *nivel_liebre="<<*nivel_liebre<<" en el if"<<endl;
*pos_liebre+=1; //verificando que no caiga la liebre en un cuadro que no le corresponde (negro)
cout<<"e="<<e<<" *pos_liebre="<<*pos_liebre<<" *nivel_liebre="<<*nivel_liebre<<" saliendo del if"<<endl;
}
//**********************************************************************************************************************************************************************************************************************************************************
if (dado%2==0) //random hasta 2 cae casi siempre en 0, por tanto así se evita el minimo en valores
{dado=0;}
else
{dado=1;};
//**********************************************************************************************************************************************************************************************************************************************************
if (SDL_Init(SDL_INIT_VIDEO)) /*| SDL_INIT_AUDIO) == -1)*/
{
printf("Error: %s\n", SDL_GetError());
return 1;
}
if (screen == NULL)
{
printf("Error: %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
/* if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 1024) == -1)
{
printf("Error en Mix_OpenAudio: %s\n", Mix_GetError());
return 1;
}*/
//**********************************************************************************************************************************************************************************************************************************************************
SDL_WM_SetCaption("Atrapame si puedes", NULL);
// /**********************************************************************************************************************************************************************************************************************************************************
ima = IMG_Load("imagenes/ajedrez.bmp");
if (ima == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
liebre = IMG_Load("imagenes/liebre.png");
if (liebre == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
lobo1 = IMG_Load("imagenes/lobo.png");
if (lobo1 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
lobo2 = IMG_Load("imagenes/lobo2.png");
if (lobo2 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
lobo3 = IMG_Load("imagenes/lobo3.png");
if (lobo3 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
lobo4 = IMG_Load("imagenes/lobo4.png");
if (lobo4 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
vector_lobo1 = IMG_Load("imagenes/v1.bmp");
if (vector_lobo1 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
vector_lobo2 = IMG_Load("imagenes/v2.bmp");
if (vector_lobo2 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
vector_lobo3 = IMG_Load("imagenes/v3.bmp");
if (vector_lobo3 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
vector_lobo4 = IMG_Load("imagenes/v4.bmp");
if (vector_lobo4 == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
turno = IMG_Load("imagenes/turno.bmp");
if (turno == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
//**********************************************************************************************************************************************************************************************************************************************************
screen = SDL_SetVideoMode( 530, 487, 16, SDL_HWSURFACE | SDL_DOUBLEBUF);
if(screen == NULL) {
printf( "Error al entrar a modo grafico: %s\n", SDL_GetError() );
SDL_Quit();
return -1;
}
//**********************************************************************************************************************************************************************************************************************************************************
/* cancion = Mix_LoadMUS("sonido/cancion.xm");
if (!cancion)
printf("Error en Mix_LoadMUS: %s\n", Mix_GetError());
if (cancion)
{
if (Mix_PlayMusic(cancion, -1) == -1)
printf("Error en Mix_PlayMusic: %s\n", Mix_GetError());
}*/
//**********************************************************************************************************************************************************************************************************************************************************
while (salir==0)
{
SDL_PollEvent(&event);
if (event.type == SDL_QUIT)
{ salir = 1;}
/* ajustar la tecla flecha arriba para ser la unica en funcionar */
// Cerrar la ventana
if (event.type == SDL_QUIT) {
// código que se ejecuta al cerrar la ventana
}
// Pulsando una tecla
if (event.type == SDL_KEYDOWN) {
// Comprobamos la tecla pulsada
if (event.key.keysym.sym==SDLK_UP) {
// código que se ejecuta al pulsar una tecla
// cout<<"registra el teclado como evento";
//**********************************************************************************************************************************************************************************************************************************************************
cout<<"entra al switch con dado : "<<dado<<endl;
switch(dado)
{
case 0:
dado=1;
cout<<"dado en el caso 0, juega el lobo primero"<<endl;
turnolobo(f,x,y,lobo1,lobo2,lobo3,lobo4,screen,vector_lobo1, vector_lobo2, vector_lobo3, vector_lobo4, vector1, nivel_lobo1, pos_lobo1, nivel_lobo2,pos_lobo2,nivel_lobo3,pos_lobo3,nivel_lobo4, pos_lobo4, vector);
ganador(salir,loboganador,screen,f, vector1, nivel_liebre, pos_liebre,pos_lobo1, pos_lobo2, pos_lobo3, pos_lobo4,nivel_lobo1,nivel_lobo2,nivel_lobo3,nivel_lobo4);
break;
case 1:
dado=0;
cout<<"dado en el caso 1, juega la liebre primero"<<endl;
turnoliebre(screen,liebre,f, vector1, nivel_liebre, pos_liebre,pos_lobo1 ,pos_lobo2 ,pos_lobo3 ,pos_lobo4,nivel_lobo1,nivel_lobo2,nivel_lobo3,nivel_lobo4);
ganador(salir,loboganador,screen,f, vector1, nivel_liebre, pos_liebre,pos_lobo1, pos_lobo2 ,pos_lobo3 ,pos_lobo4,nivel_lobo1,nivel_lobo2,nivel_lobo3,nivel_lobo4);
break;
}
SDL_Flip(screen);
SDL_Delay(100);
delete(posliebre1);}}
SDL_Flip(screen);
SDL_Delay(100);
//*************************************************************************************************************************************************************************************************
imprimir(vector_lobo1, vector_lobo2,vector_lobo3, vector_lobo4,vector1,turno,screen, ima, liebre, lobo1, lobo2, lobo3, lobo4, nivel_liebre, pos_liebre, x, y, pos_lobo1, nivel_lobo1, pos_lobo2, nivel_lobo2, pos_lobo3, nivel_lobo3, pos_lobo4, nivel_lobo4);
}
cout<<"sale del switch(dado)"<<endl;//sale del juego
// salir=ganador(screen,f, vector1, nivel_liebre, pos_liebre,pos_lobo1, pos_lobo2 ,pos_lobo3 ,pos_lobo4 ,nivel_lobo1,nivel_lobo2,nivel_lobo3,nivel_lobo4);
//**********************************************************************************************************************************************************************************************************************************************************
limpiar(screen);
//**********************************************************************************************************************************************************************************************************************************************************
/* if (cancion)
{
Mix_HaltMusic();
Mix_FreeMusic(cancion);
}
Mix_CloseAudio();*/
SDL_Quit();
return 0;
//**********************************************************************************************************************************************************************************************************************************************************
freopen ("CON", "w", stdout ); /*para no ocultar los errores de compilacion*/
freopen ("CON", "w", stderr );
}
//**********************************************************************************************************************************************************************************************************************************************************
void limpiar (SDL_Surface *screen)
{
Uint32 a = SDL_MapRGB(screen->format, 120, 120, 120);
SDL_FillRect(screen, NULL, a);
}
//**********************************************************************************************************************************************************************************************************************************************************
void imprimir(SDL_Surface *vector_lobo1,SDL_Surface *vector_lobo2,SDL_Surface *vector_lobo3,SDL_Surface *vector_lobo4,int vector1,SDL_Surface *turno, SDL_Surface *screen, SDL_Surface *ima, SDL_Surface *liebre, SDL_Surface *lobo1, SDL_Surface *lobo2, SDL_Surface *lobo3, SDL_Surface *lobo4, int *nivel_liebre, int *pos_liebre, int x, int y, int *pos_lobo1, int *nivel_lobo1, int *pos_lobo2, int *nivel_lobo2, int *pos_lobo3, int *nivel_lobo3, int *pos_lobo4, int *nivel_lobo4/*, SDL_Surface *vector*/)
{
SDL_Rect rect = {x, y, 0, 0};
SDL_BlitSurface(ima, NULL, screen, &rect);
/* Dibujamos los protagonistas */
rect.x = (*pos_liebre * 53)+5; /*coordenadas de donde aparecera en pantalla la imagen del lobo# o la liebre*/
rect.y = (*nivel_liebre * 53)+5;
SDL_BlitSurface(liebre, NULL, screen, &rect);
rect.x = (*pos_lobo1 * 53)+5;
rect.y = (*nivel_lobo1 * 53)+5;
SDL_BlitSurface(lobo1, NULL, screen, &rect);
rect.x = (*pos_lobo2 * 53)+5;
rect.y = (*nivel_lobo2 * 53)+5;
SDL_BlitSurface(lobo2, NULL, screen, &rect);
rect.x = (*pos_lobo3 * 53)+5;
rect.y = (*nivel_lobo3 * 53)+5;
SDL_BlitSurface(lobo3, NULL, screen, &rect);
rect.x = (*pos_lobo4 * 53)+5;
rect.y = (*nivel_lobo4 * 53)+5;
SDL_BlitSurface(lobo4, NULL, screen, &rect);
/*
rect.x = 435;
rect.y = 0;
SDL_BlitSurface(turno, NULL, screen, &rect);
*/
SDL_Flip(screen);
SDL_Delay(10);
// cout<<"impresion correcta"; //hasta aqui esta llegando sin problemas
}
//**********************************************************************************************************************************************************************************************************************************************************
int fun_liebre( int f, int *nivel_liebre, int *pos_liebre)
{ cout<<"juega liebre";
f=rand()%1000;
if (f%2==0) //random hasta 2 cae casi siempre en 0, por tanto así se evita el minimo en valores
{f=0;}
else
{f=1;};
cout<<" f="<<f<<endl;
cout<<"nivel_liebre="<<*nivel_liebre<<endl;
*nivel_liebre+=1; // una vez se cree el escalon no se salga de los laterales
cout<<" nivel_liebre="<<*nivel_liebre<<endl;
if(f==1) //*segun el random que escogimos 1 es incrementar
{cout<<" pos_liebre="<<*pos_liebre<<endl;
if(*pos_liebre==7) //si *pos_lobo=7 no lo puede incrementar mas
{cout<<" pos_liebre="<<*pos_liebre<<", antes"<<endl;
*pos_liebre-=1;
cout<<" pos_liebre="<<*pos_liebre<<", despues"<<endl;}
else
{*pos_liebre+=1;};
}
else
{
cout<<" *pos_liebre="<<*pos_liebre<<endl;
if(*pos_liebre==0)
{*pos_liebre+=1;}
else
{*pos_liebre-=1;};
};
}
//**********************************************************************************************************************************************************************************************************************************************************
int fun_lobo1( int *nivel_lobo1, int *pos_lobo1)
{
cout<<"juega lobo1";
int f=rand()%1000;
if (f%2==0) //random hasta 2 cae casi siempre en 0, por tanto así se evita el minimo en valores
{f=0;}
else
{f=1;};
cout<<" f="<<f<<endl;
cout<<"nivel_lobo="<<*nivel_lobo1<<endl;
*nivel_lobo1-=1; // una vez se cree el escalon no se salga de los laterales
cout<<" nivel_lobo="<<*nivel_lobo1<<endl;
if(f==1) //*segun el random que escogimos 1 es incrementar
{cout<<" pos_lobo="<<*pos_lobo1<<endl;
if(*pos_lobo1==7) //si *pos_lobo=7 no lo puede incrementar mas
{cout<<" pos_lobo="<<*pos_lobo1<<", antes"<<endl;
*pos_lobo1-=1;
cout<<" pos_lobo="<<*pos_lobo1<<", despues"<<endl;}
else
{*pos_lobo1+=1;};
}
else
{
cout<<" *pos_lobo="<<*pos_lobo1<<endl;
if(*pos_lobo1==0)
{*pos_lobo1+=1;}
else
{*pos_lobo1-=1;};
};
}
//**********************************************************************************************************************************************************************************************************************************************************
int fun_lobo2( int *nivel_lobo2, int *pos_lobo2)
{cout<<"juega lobo2";
int f=rand()%1000;
if (f%2==0) //random hasta 2 cae casi siempre en 0, por tanto así se evita el minimo en valores
{f=0;}
else
{f=1;};
cout<<" f="<<f<<endl;
cout<<"nivel_lobo="<<*nivel_lobo2<<endl;
*nivel_lobo2-=1; // una vez se cree el escalon no se salga de los laterales
cout<<" nivel_lobo="<<*nivel_lobo2<<endl;
if(f==1) //*segun el random que escogimos 1 es incrementar
{cout<<" *pos_lobo="<<*pos_lobo2<<endl;
if(*pos_lobo2==7) //si *pos_lobo=7 no lo puede incrementar mas
{cout<<" pos_lobo="<<*pos_lobo2<<", antes"<<endl;
*pos_lobo2-=1;
cout<<" pos_lobo="<<*pos_lobo2<<", despues"<<endl;}
else
{*pos_lobo2+=1;};
}
else
{
cout<<" *pos_lobo="<<*pos_lobo2<<endl;
if(*pos_lobo2==0)
{*pos_lobo2+=1;}
else
{*pos_lobo2-=1;};
};
}
//**********************************************************************************************************************************************************************************************************************************************************
int fun_lobo3(int *nivel_lobo3, int *pos_lobo3)
{ cout<<"juega lobo3";
int f=rand()%1000;
if (f%2==0) //random hasta 2 cae casi siempre en 0, por tanto así se evita el minimo en valores
{f=0;}
else
{f=1;};
cout<<" f="<<f<<endl;
cout<<"nivel_lobo="<<*nivel_lobo3<<endl;
*nivel_lobo3-=1; // una vez se cree el escalon no se salga de los laterales
cout<<" nivel_lobo="<<*nivel_lobo3<<endl;
if(f==1) //*segun el random que escogimos 1 es incrementar
{cout<<" *pos_lobo="<<*pos_lobo3<<endl;
if(*pos_lobo3==7) //si *pos_lobo=7 no lo puede incrementar mas
{cout<<" pos_lobo="<<*pos_lobo3<<", antes"<<endl;
*pos_lobo3-=1;
cout<<" pos_lobo="<<*pos_lobo3<<", despues"<<endl;}
else
{*pos_lobo3+=1;};
}
else
{
cout<<" *pos_lobo="<<*pos_lobo3<<endl;
if(*pos_lobo3==0)
{*pos_lobo3+=1;}
else
{*pos_lobo3-=1;};
};
}
//**********************************************************************************************************************************************************************************************************************************************************
int fun_lobo4( int *nivel_lobo4, int *pos_lobo4)
{ cout<<"juega lobo4";
int f=rand()%1000;
if (f%2==0) //random hasta 2 cae casi siempre en 0, por tanto así se evita el minimo en valores
{f=0;}
else
{f=1;};
cout<<" f="<<f<<endl;
cout<<"nivel_lobo="<<*nivel_lobo4<<endl;
*nivel_lobo4-=1; // una vez se cree el escalon no se salga de los laterales
cout<<" nivel_lobo="<<*nivel_lobo4<<endl;
if(f==1) //*segun el random que escogimos 1 es incrementar
{cout<<" *pos_lobo="<<*pos_lobo4<<endl;
if(*pos_lobo4==7) //si *pos_lobo=7 no lo puede incrementar mas
{cout<<" pos_lobo="<<*pos_lobo4<<", antes"<<endl;
*pos_lobo4-=1;
cout<<" pos_lobo="<<*pos_lobo4<<" ,despues"<<endl;}
else
{*pos_lobo4+=1;};
}
else
{
cout<<" *pos_lobo="<<*pos_lobo4<<endl;
if(*pos_lobo4==0)
{*pos_lobo4+=1;}
else
{*pos_lobo4-=1;};
};
}
//**********************************************************************************************************************************************************************************************************************************************************
int turnolobo(int f,int x, int y,SDL_Surface *lobo1,SDL_Surface *lobo2,SDL_Surface *lobo3,SDL_Surface *lobo4,SDL_Surface *screen,SDL_Surface *vector_lobo1,SDL_Surface *vector_lobo2,SDL_Surface *vector_lobo3,SDL_Surface *vector_lobo4, int vector1, int *nivel_lobo1, int *pos_lobo1, int *nivel_lobo2, int *pos_lobo2,int *nivel_lobo3, int *pos_lobo3,int *nivel_lobo4, int *pos_lobo4,int *vector)
{
//imprimir vectores lobo
int *nivel_liebre,*pos_liebre;
vector1=rand()%4;
short cont=0;
cout<<"el lobo que juega es el numero: "<<vector1+1<<"vector="<<vector1<<endl;
SDL_Rect rect = {x, y, 0, 0};
do{
switch(vector1){
case 0 : fun_lobo1(nivel_lobo1, pos_lobo1);
rect.x = 10;
rect.y = 430;
SDL_BlitSurface(vector_lobo1, NULL, screen, &rect);
rect.x = 452;
rect.y = 70;
SDL_BlitSurface(lobo1, NULL, screen, &rect);
SDL_Flip(screen);
SDL_Delay(1000);
break;
case 1 : fun_lobo2(nivel_lobo2, pos_lobo2); // pensar como usar solo una fun lobo para los 4
rect.x = 10;
rect.y = 430;
SDL_BlitSurface(vector_lobo2, NULL, screen, &rect);
rect.x = 452;
rect.y = 70;
SDL_BlitSurface(lobo2, NULL, screen, &rect);
SDL_Flip(screen);
SDL_Delay(1000);
break;
case 2 : fun_lobo3(nivel_lobo3, pos_lobo3);
rect.x = 10;
rect.y = 430;
SDL_BlitSurface(vector_lobo3, NULL, screen, &rect);
rect.x = 452;
rect.y = 70;
SDL_BlitSurface(lobo3, NULL, screen, &rect);
SDL_Flip(screen);
SDL_Delay(1000);
break;
case 3 : fun_lobo4(nivel_lobo4, pos_lobo4);
rect.x = 10;
rect.y = 430;
SDL_BlitSurface(vector_lobo4, NULL, screen, &rect);
rect.x = 452;
rect.y = 70;
SDL_BlitSurface(lobo4, NULL, screen, &rect);
SDL_Flip(screen);
SDL_Delay(1000);
break;
}
if((*nivel_lobo1==*nivel_lobo2)&&(*pos_lobo1==*pos_lobo2))
{
cout<<endl<<endl<<endl<<"no puede mover el lobo "<<vector1+1<<"vector="<<vector1<<endl<<endl<<endl;
if(vector1==0)
{
*nivel_lobo1+=1;
if(f==1){
*pos_lobo1+=1;
}
else{
*pos_lobo1-=1;
};
}
if(vector1==1)
{
*nivel_lobo2+=1;
if(f==1){
*pos_lobo2+=1;
}
else{
*pos_lobo2-=1;
};
}
vector1++;
}
if((*nivel_lobo1==*nivel_lobo3)&&(*pos_lobo1==*pos_lobo3))
{
cout<<endl<<endl<<endl<<"no puede mover el lobo "<<vector1+1<<"vector="<<vector1<<endl<<endl<<endl;
if(vector1==0)
{
*nivel_lobo1+=1;
if(f==1){
*pos_lobo1+=1;
}
else{
*pos_lobo1-=1;
};
}
if(vector1==2)
{
*nivel_lobo3+=1;
if(f==1){
*pos_lobo3+=1;
}
else{
*pos_lobo3-=1;
};
}
vector1++;
}
if((*nivel_lobo1==*nivel_lobo4)&&(*pos_lobo1==*pos_lobo4))
{
cout<<endl<<endl<<endl<<"no puede mover el lobo "<<vector1+1<<"vector="<<vector1<<endl<<endl<<endl;
if(vector1==0)
{
*nivel_lobo1+=1;
if(f==1){
*pos_lobo1+=1;
}
else{
*pos_lobo1-=1;
};
}
if(vector1==3)
{
*nivel_lobo4+=1;
if(f==1){
*pos_lobo4+=1;
}
else{
*pos_lobo4-=1;
};
}
vector1++;
}
if((*nivel_lobo2==*nivel_lobo3)&&(*pos_lobo2==*pos_lobo3))
{
cout<<endl<<endl<<endl<<"no puede mover el lobo "<<vector1+1<<"vector="<<vector1<<endl<<endl<<endl;
if(vector1==1)
{
*nivel_lobo2+=1;
if(f==1){
*pos_lobo2+=1;
}
else{
*pos_lobo2-=1;
};
}
if(vector1==2)
{
*nivel_lobo3+=1;
if(f==1){
*pos_lobo3+=1;
}
else{
*pos_lobo3-=1;
};
}
vector1++;
}
if((*nivel_lobo2==*nivel_lobo4)&&(*pos_lobo2==*pos_lobo4 ))
{
cout<<endl<<endl<<endl<<"no puede mover el lobo "<<vector1+1<<"vector="<<vector1<<endl<<endl<<endl;
if(vector1==1)
{
*nivel_lobo2+=1;
if(f==1){
*pos_lobo2+=1;
}
else{
*pos_lobo2-=1;
};
}
if(vector1==3)
{
*nivel_lobo4+=1;
if(f==1){
*pos_lobo4+=1;
}
else{
*pos_lobo4-=1;
};
}
vector1++;
}
if((*nivel_lobo3==*nivel_lobo4)&&(*pos_lobo3==*pos_lobo4))
{
cout<<endl<<endl<<endl<<"no puede mover el lobo "<<vector1+1<<"vector="<<vector1<<endl<<endl<<endl;
if(vector1==2)
{
*nivel_lobo3+=1;
if(f==1){
*pos_lobo3+=1;
}
else{
*pos_lobo3-=1;
};
}
if(vector1==3)
{
*nivel_lobo4+=1;
if(f==1){
*pos_lobo4+=1;
}
else{
*pos_lobo4-=1;
};
}
vector1++;
}
if(vector1==4)
{
vector1=0;
cont++;
if(cont==2)
{return 2; }
}
}
while((*nivel_lobo1==*nivel_lobo2 &&*pos_lobo1==*pos_lobo2 ) || (*nivel_lobo1==*nivel_lobo3&& *pos_lobo1==*pos_lobo3 )||(*nivel_lobo1==*nivel_lobo4&&*pos_lobo1==*pos_lobo4 )||(*nivel_lobo2==*nivel_lobo3 && *pos_lobo2==*pos_lobo3)|| (*nivel_lobo2==*nivel_lobo4&&*pos_lobo2==*pos_lobo4 ) ||(*nivel_lobo3==*nivel_lobo4&&*pos_lobo3==*pos_lobo4));
//el While anterior se encarga de verificar que los lobos no esten en la misma casilla
}
//**********************************************************************************************************************************************************************************************************************************************************
int turnoliebre(SDL_Surface *screen,SDL_Surface *liebre,int f, int vector1, int *nivel_liebre, int *pos_liebre,int *pos_lobo1, int *pos_lobo2 ,int *pos_lobo3 ,int *pos_lobo4 , int *nivel_lobo1, int *nivel_lobo2, int *nivel_lobo3, int *nivel_lobo4)
{
int x_init, y_init;
x_init=*pos_liebre;
y_init=*nivel_liebre;
fun_liebre(f, nivel_liebre,pos_liebre);
int contador=0;
contador++;
if (contador==7)
{
return 1;
}
if(SDL_MUSTLOCK(liebre))
SDL_LockSurface(liebre);
SDL_Rect rect;
rect.x = 452;
rect.y = 70;
SDL_BlitSurface(liebre, NULL, screen, &rect);
if(SDL_MUSTLOCK(liebre))
SDL_UnlockSurface(liebre);
/*
short paso=0;
//while(paso<=10)
{
paso++;
cout<<"f="<<f<<"dentro de turno liebre"<<endl;
if(((*nivel_liebre==*nivel_lobo1 )&&(*pos_liebre==*pos_lobo1)))
{if(f==1)
{
*pos_liebre-=2;
if (*pos_liebre==-1)
{
*pos_liebre+=1;
*nivel_liebre-=1;
}
}
else
{
*pos_liebre+=2;
if (*pos_liebre==8)
{
*pos_liebre-=1;
*nivel_liebre-=1;
}
};
fun_liebre(f, nivel_liebre,pos_liebre);
}
if(((*nivel_liebre==*nivel_lobo2)&&(*pos_liebre==*pos_lobo2)))
{if(f==1)
{
*pos_liebre-=2;
if (*pos_liebre==-1)
{
*pos_liebre+=1;
*nivel_liebre-=1;
}
}
else
{
*pos_liebre+=2;
if (*pos_liebre==8)
{
*pos_liebre-=1;
*nivel_liebre-=1;
}
};
fun_liebre(f, nivel_liebre,pos_liebre);
}
if((*nivel_liebre==*nivel_lobo3)&&(*pos_liebre==*pos_lobo3))
{if(f==1)
{
*pos_liebre-=2;
if (*pos_liebre==-1)
{
*pos_liebre+=1;
*nivel_liebre-=1;
}
}
else
{
*pos_liebre+=2;
if (*pos_liebre==8)
{
*pos_liebre-=1;
*nivel_liebre-=1;
}
};
fun_liebre(f, nivel_liebre,pos_liebre);
}
if((*nivel_liebre==*nivel_lobo4)&&(*pos_liebre==*pos_lobo4))
{ if(f==1)
{
*pos_liebre-=2;
if (*pos_liebre==-1)
{
*pos_liebre+=1;
*nivel_liebre-=1;
}
}
else
{
*pos_liebre+=2;
if (*pos_liebre==8)
{
*pos_liebre-=1;
*nivel_liebre-=1;
}
};
fun_liebre(f, nivel_liebre,pos_liebre);
}
/*}*/
SDL_Flip(screen);
SDL_Delay(1000);
}
//******************************************************************************************************************************************************************************************************************************************************************************
int ganador(int salir,int *loboganador, SDL_Surface *screen,int f, int vector1, int *nivel_liebre, int *pos_liebre,int *pos_lobo1, int *pos_lobo2 ,int *pos_lobo3 ,int *pos_lobo4 , int *nivel_lobo1, int *nivel_lobo2, int *nivel_lobo3, int *nivel_lobo4)
{ int gana=2;
if(((*nivel_liebre==*nivel_lobo1 &&*pos_liebre==*pos_lobo1)|| (*nivel_liebre==*nivel_lobo2&&*pos_liebre==*pos_lobo2 )||(*nivel_liebre==*nivel_lobo3&&*pos_liebre==*pos_lobo3) ||(*nivel_liebre==*nivel_lobo4&&*pos_liebre==*pos_lobo4)))
{
gana=0;
cout<<endl<<endl<<endl<<"ganó el Lobo "<<*loboganador+1<<", gana="<<gana<<endl<<endl<<endl;
}
if((*nivel_liebre==7)&&(((*nivel_liebre==*nivel_lobo1 )&&(*pos_liebre==*pos_lobo1))|| ((*nivel_liebre==*nivel_lobo2)&&(*pos_liebre==*pos_lobo2))||((*nivel_liebre==*nivel_lobo3)&&(*pos_liebre==*pos_lobo3))||((*nivel_liebre==*nivel_lobo4)&&(*pos_liebre==*pos_lobo4))))
{
//*loboganador+=1;
gana=0;
cout<<endl<<endl<<endl<<"ganó el Lobo "<<*loboganador<<", gana="<<gana<<endl<<endl<<endl;
}
if((*nivel_liebre==7)&&((*nivel_liebre!=*nivel_lobo1) &&(*pos_liebre!=*pos_lobo1)))
{
//*loboganador+=1;
gana=1;
cout<<endl<<endl<<endl<<"ganó la Liebre "<<", gana="<<gana<<endl<<endl<<endl<<endl;
}
if((*nivel_liebre==7)&&((*nivel_liebre!=*nivel_lobo2)&&(*pos_liebre!=*pos_lobo2)))
{
//*loboganador+=1;
gana=1;
cout<<endl<<endl<<endl<<"ganó la Liebre "<<", gana="<<gana<<endl<<endl<<endl<<endl;
}
if((*nivel_liebre==7)&&((*nivel_liebre!=*nivel_lobo3)&&(*pos_liebre!=*pos_lobo3)))
{
//*loboganador+=1;
gana=1;
cout<<endl<<endl<<endl<<"ganó la Liebre "<<", gana="<<gana<<endl<<endl<<endl<<endl;
}
if((*nivel_liebre==7)&&((*nivel_liebre!=*nivel_lobo4)&&(*pos_liebre!=*pos_lobo4)))
{
//*loboganador+=1;
gana=1;
cout<<endl<<endl<<endl<<"ganó la Liebre "<<", gana="<<gana<<endl<<endl<<endl<<endl;
}
/* if(turnolobo( vector1, nivel_lobo1, pos_lobo1, nivel_lobo2,pos_lobo2,nivel_lobo3,pos_lobo3,nivel_lobo4, pos_lobo4, vector)==1)
{
cout<<endl<<endl<<endl<<"ganó el Lobo "<<vector1+1<<", gana="<<gana<<endl<<endl<<endl;
gana=0;
}*/
if(((*nivel_liebre==*nivel_lobo1 )&&(*pos_liebre==*pos_lobo1))|| ((*nivel_liebre==*nivel_lobo2)&&(*pos_liebre==*pos_lobo2))||((*nivel_liebre==*nivel_lobo3)&&(*pos_liebre==*pos_lobo3))||((*nivel_liebre==*nivel_lobo4)&&(*pos_liebre==*pos_lobo4)))
{
gana=0;
cout<<endl<<endl<<endl<<"ganó el Lobo "<<(*loboganador)+1<<", gana="<<gana<<endl<<endl<<endl;
}
if (*pos_liebre==8)
{
*pos_liebre-=1;
*nivel_liebre-=1;
gana=0;
}
SDL_Rect rect;
SDL_Surface *gana_liebre;
SDL_Surface *gana_lobo;
gana_liebre = IMG_Load("imagenes/gana_liebre.png");
if (gana_liebre == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
gana_lobo = IMG_Load("imagenes/gana_lobo.png");
if (gana_lobo == NULL)
{
printf("Error en IMG_Load= %s\n", SDL_GetError());
return 1;
}
switch(gana)
{
case 0:
rect.x = 10;
rect.y = 120;
SDL_BlitSurface(gana_lobo, NULL, screen, &rect);
SDL_Flip(screen);
SDL_Delay(5000);
return 1;
salir=1;
break;
case 1:
rect.x = 10;
rect.y = 120;
SDL_BlitSurface(gana_liebre, NULL, screen, &rect);
SDL_Flip(screen);
SDL_Delay(5000);
return 1;
salir=1;
break;
case 2: cout<<"no hay ganador"<<endl<<endl;
}
SDL_Flip(screen);
//SDL_Delay(10);
}
//******/ //************************************************************************************************************************************************************************************************************************************************************************
