void moverEnemigoEnDireccion(t_enemigo * enemigo, char * orientacion1, int orientacion2){
/*//TODO no estaría esquivando la caja
if(orientacion1 == horizontal)
enemigo->posicion->posX = enemigo->posicion->posX + orientacion2;
else if(orientacion1 == vertical)
enemigo->posicion->posY = enemigo->posicion->posY + orientacion2;
*/
if(orientacion1 == horizontal){
if(hayCajaOExcedeLimite(enemigo->posicion->posX + orientacion2, enemigo->posicion->posY)){
enemigo->cantTurnosEnL = -1;
enemigo->posicion->posX = enemigo->posicion->posX + (orientacion2 * -1);
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}else{
enemigo->posicion->posX = enemigo->posicion->posX + orientacion2;
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}
}else if(orientacion1 == vertical){
if(hayCajaOExcedeLimite(enemigo->posicion->posX, enemigo->posicion->posY + orientacion2)){
enemigo->cantTurnosEnL = -1;
enemigo->posicion->posY = enemigo->posicion->posY + (orientacion2 * -1);
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}else{
enemigo->posicion->posY = enemigo->posicion->posY + orientacion2;
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}
}
if(graficar)
nivel_gui_dibujar(items,nombre);
if(IMPRIMIR_INFO_ENEMIGO){
pthread_mutex_lock(&mutex_log);
log_info(logger,"Posicion del enemigo. PosX: %d, PosY: %d ", enemigo->posicion->posX, enemigo->posicion->posY);
pthread_mutex_unlock(&mutex_log);
}
}
void CGame::JugandoActualizar(){
keys = (Uint8 *)SDL_GetKeyboardState(NULL);
for (int i = 0; i < nivel[nivelActual].Enemigos_VisiblesAlMismoTiempo; i++)
{
enemigoArreglo[i]->GetNaveObjeto()->Actualizar();
}
MoverEnemigo();
if (keys[SDL_SCANCODE_UP])
{
if (!LimitePantalla(nave->GetNaveObjeto(), BORDE_SUPERIOR))
nave->MoverArriba(nivel[nivelActual].Nave_Velocidad);
}
if (keys[SDL_SCANCODE_DOWN])
{
if (!LimitePantalla(nave->GetNaveObjeto(), BORDE_INFERIOR))
nave->MoverAbajo(nivel[nivelActual].Nave_Velocidad);
}
if (keys[SDL_SCANCODE_LEFT])
{
if (!LimitePantalla(nave->GetNaveObjeto(), BORDE_IZQUIERDO))
nave->MoverIzquierda(nivel[nivelActual].Nave_Velocidad);
}
if (keys[SDL_SCANCODE_RIGHT])
{
if (!LimitePantalla(nave->GetNaveObjeto(), BORDE_DERECHO))
nave->MoverDerecha(nivel[nivelActual].Nave_Velocidad);
}
if (keys[SDL_SCANCODE_ESCAPE])
{
estadoJuego = ESTADO_MENU;
}
if (keys[SDL_SCANCODE_SPACE])
{
nave->Disparar(nivel[nivelActual].Nave_BalasMaximas);
}
if (keys[SDL_SCANCODE_C]){//nuestra bala / nave enemigo
int enemigoAEliminar = rand() % nivel[nivelActual].Enemigos_VisiblesAlMismoTiempo;
//enemigoArreglo[enemigoAEliminar]->simularColision(true);
}
if (keys[SDL_SCANCODE_V]){//nuestra nave / nave enemigo
}
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
int salirJuego = false;
//int i=0;
while (salirJuego == false){
//Maquina de estados
switch(estado){
case Estado::Estado_Iniciando: //INICIALIZAR
Iniciando();
estado= Estado_Jugando;
//estado=Estado::Estado_Menu;
break;
case Estado::Estado_Menu:
menu->Pintar();
textos->Pintar(MODULO_TEXTO_TITULO,169,50);
textos->Pintar(MODULO_TEXTO_NOMBRE,300,390);
Menu();
//textos->Pintar(MODULO_TEXTO_MENU_OPCION1,300,220);
//textos->Pintar(MODULO_TEXTO_MENU_OPCION2,300,270);
break;
case Estado::Estado_Jugando: //JUGAR
//estado=Estado_Jugando;
for(int i=0;i<10;i++)
{
enemigoArreglo[i]->Actualizar();
}
//enemigo->Actualizar();
MoverEnemigo();
fondo->Pintar();
//SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format,0,0,0));
Keys = SDL_GetKeyState(NULL);
if (Keys[SDLK_RIGHT])
{
if(!EsLimitePantalla(nave, BORDE_DERECHO))
nave->Mover(10);
}
if (Keys[SDLK_LEFT])
{
if(!EsLimitePantalla(nave, BORDE_IZQUIERDO))
nave->Mover(-10);
}
nave->Pintar();
//enemigo->Pintar();
for(int i=0;i<10;i++)
{
enemigoArreglo[i]->Pintar();
}
break;
case Estado::Estado_Terminando: //SALIR
salirJuego = true;
break;
case Estado::Estado_Finalizando:
break;
};
while (SDL_PollEvent(&event)) // aqui SDL creara una lista de eventos ocurridos
{
if (event.type == SDL_QUIT) { salirJuego = true;} // si se detecta una salida de SDL o....
if (event.type==SDL_KEYDOWN) { }
}
// este codigo estara provicionalmente aqui
SDL_Flip(screen);
//calculando FPS
tiempoFrameFinal=SDL_GetTicks();
while(tiempoFrameFinal < (tiempoFrameInicial + FPS_DELAY))
{
tiempoFrameFinal=SDL_GetTicks();
SDL_Delay(1);
}
printf("Frames:%d Tiempo:%d Tiempo Promedio:%f Tiempo por Frame:%d FPS:%f\n",tick,SDL_GetTicks(), (float)SDL_GetTicks()/(float)tick,tiempoFrameFinal-tiempoFrameInicial,1000.0f /(float)(tiempoFrameFinal-tiempoFrameInicial));
tiempoFrameInicial=tiempoFrameFinal; // marcamos el inicio nuevamente
tick++;
}
return true;
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
int salirJuego = false;
while (salirJuego == false){
//Maquina de estados
switch(estado){
case Estado::ESTADO_INICIANDO:
Iniciando();
estado = ESTADO_MENU;
break;
case Estado::ESTADO_MENU:
menu->Pintar();
textos->Pintar(MODULO_TEXTO_TITULO,150,50);
textos->Pintar(MODULO_TEXTOS_NOMBRE,200,440);
Menu();
estado=ESTADO_JUGANDO;
break;
case Estado::ESTADO_JUGANDO:
printf("\n3. ESTADO_JUGANDO");
for(int i=0;i<10;i++){
enemigoArreglo[i]->Actualizar();
}
MoverEnemigo();
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format,0,0,0)); // Color de pantalla y velocidad
keys = SDL_GetKeyState(NULL);
if(keys[SDLK_RIGHT]){
if(!EsLimitePantalla(nave, BORDE_DERECHO))
nave->Mover(1);
}
if(keys[SDLK_LEFT]){
nave->Mover(-1);
}
nave->Pintar();
for(int i=0; i<10;i++)
enemigoArreglo[i]->Pintar();
break;
getchar();
break;
case Estado::ESTADO_TERMINANDO:
printf("\n4. ESTADO_TERMINANDO");
getchar();
break;
case Estado::ESTADO_FINALIZANDO:
printf("\n5. ESTADO_FINALIZANDO");
getchar();
salirJuego = false;
Finalize();
break;
}
while(SDL_PollEvent(&event)) // aqui se creara una lista de events ocurridos
{
if(event.type == SDL_QUIT) {salirJuego = true;} // si se detecta una salida de SDL
if(event.type == SDL_KEYDOWN) { }
}
//Este codigo estara provicionalmente aqui.
SDL_Flip(screen);
//Calculando FPS
tiempoFrameFinal=SDL_GetTicks();
printf("Frames:%d Tiempo:%d Tiempo Promedio:%f Tiempo por Frame:%d \n",tick,SDL_GetTicks(),(float)SDL_GetTicks()/(float)tick,tiempoFrameFinal-tiempoFrameInicial);
tiempoFrameInicial=tiempoFrameFinal;//Marcamos el inicio nuevamente
tick++;
}
return true;
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
//bool bandera = false;
int salirJuego = false;
while (salirJuego == false)
{
//Maquina de estados
switch (estado)
{
case Estado::ESTADO_INICIANDO:
Iniciando();
estado = ESTADO_MENU;
//printf("\nEstado Iniciando");
break;
//{
//
// /* nave = SDL_LoadBMP("../Data/Eddie.bmp");
// SDL_Rect Fuente;
// Fuente.x = 90;
// Fuente.y = 152;
// Fuente.w = 242;
// Fuente.h = 76;
// SDL_Rect destino;
// destino.x = 100;
// destino.y = 100;
// destino.w = 100;
// destino.h = 100;
// SDL_BlitSurface(nave, &Fuente, screen, &destino);
// SDL_BlitSurface(nave, NULL, screen, NULL);
// SDL_FreeSurface(nave);*/
//}
case Estado::ESTADO_MENU:
menu->Pintar();
texto->Pintar(MODULO_TEXTO_TITULO, 250, 30);
texto->Pintar(MODULO_TEXTO_NOMBRE, 300, 400);
Menu();
//titulos->Pintar();
//SDL_FillRect(screen, NULL, 0000000);
SDL_Flip(screen);
keys = SDL_GetKeyState(NULL);
//botonInicio->Pintar();
if (keys[SDLK_UP])
{
estado = ESTADO_JUGANDO;
}
//botonInicio->Pintar();
if (keys[SDLK_DOWN]){
//btnSalir= new Nave(screen,"../Data/btnSalir.bmp",0,0,1);
//botonSalir->Pintar();
estado = ESTADO_FINALIZADO;
//salirJuego = true;
}
break;
/*if (keys[SDLK_UP])
{
nave->PintarModulo(0, 200, 100);
}
if (keys[SDLK_RIGHT])
{
nave->PintarModulo(0, 400, 200);
}
if (keys[SDLK_LEFT])
{
nave->PintarModulo(0, 0, 200);
}*/
/*if (bandera==false)
{
estado = ESTADO_JUGANDO;
printf("\nEstado Menu");
}
else
{
estado = ESTADO_TERMINANDO;
printf("\nEstado Menu");
}*/
case Estado::ESTADO_JUGANDO:
//SDL_FillRect(screen, NULL, 0x000000);
SDL_FillRect(screen, NULL, 0x000000);
keys = SDL_GetKeyState(NULL);
for (int i = 0; i<10; i++)
enemigoArreglo[i]->Actualizar();
MoverEnemigo();
if (keys[SDLK_RIGHT] && !esLimitePantalla(nave, BORDE_DERECHO))
{
//nave->PintarModulo(0, 0, 0, 64, 64);
nave->Mover(7);
if (esLimitePantalla(nave, BORDE_DERECHO))
{
nave->MoverIzquierda(7);
}
/*Iniciando();
estado = ESTADO_MENU;*/
}
if (keys[SDLK_LEFT] && !esLimitePantalla(nave, BORDE_IZQUIERDO))
{
//nave->PintarModulo(0, 0, 0, 64, 64);
nave->MoverIzquierda(7);
if (esLimitePantalla(nave, BORDE_IZQUIERDO))
{
nave->Mover(7);
}
/*Iniciando();
estado = ESTADO_MENU;*/
}
if (keys[SDLK_UP] && !esLimitePantalla(nave, BORDE_SUPERIOR))
{
nave->MoverArriba(7);
if (esLimitePantalla(nave, BORDE_SUPERIOR))
{
nave->MoverAbajo(7);
}
}
if (keys[SDLK_DOWN] && !esLimitePantalla(nave, BORDE_INFERIOR))
{
nave->MoverAbajo(7);
if (esLimitePantalla(nave, BORDE_INFERIOR))
{
nave->MoverArriba(7);
}
}
fondo->Pintar();
nave->Pintar();
//MoverEnemigo();
for (int i = 0; i<10; i++)
enemigoArreglo[i]->Pintar();
MoverEnemigo();
nave->Pintar();
break;
case Estado::ESTADO_FINALIZADO:
/*estado = ESTADO_MENU;
printf("\nEstado Finalizado");
bandera = true;*/
break;
case Estado::ESTADO_TERMINANDO:
/*printf("\nEstado Terminando");
getchar();*/
salirJuego = true;
break;
};
while (SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT) { salirJuego = true; }
if (event.type == SDL_KEYDOWN) {}
}
SDL_Flip(screen);// imprimir en pantalla la variable screen
frames++;
tiempoFrameFinal = SDL_GetTicks();
while (tiempoFrameFinal<(tiempoFrameInicio + FPS_DELAY)){
tiempoFrameFinal = SDL_GetTicks();
SDL_Delay(1);
}
//printf("Frame:%d Tiempo:%d TiempoPorFrame:%d FPS:%f\n", frames, tiempoFrameInicio, tiempoFrameFinal - tiempoFrameInicio, 1000.0f / (float)(tiempoFrameFinal - tiempoFrameInicio));
tiempoFrameInicio = tiempoFrameFinal;
}
return true;
}
void moverEnemigoEn(t_enemigo * enemigo, t_personaje_niv1 * personaje, char * orientacion){
/* //TODO no estaría esquivando la caja
if(orientacion == horizontal)
if(enemigo->posicion->posX > personaje->posicion->posX)
enemigo->posicion->posX = enemigo->posicion->posX - 1;
else
enemigo->posicion->posX = enemigo->posicion->posX + 1;
else if(orientacion == vertical){
if(enemigo->posicion->posY > personaje->posicion->posY)
enemigo->posicion->posY = enemigo->posicion->posY - 1;
else
enemigo->posicion->posY = enemigo->posicion->posY + 1;
}*/
if(orientacion == horizontal){
if(enemigo->posicion->posX > personaje->posicion->posX){
if(hayCaja(enemigo->posicion->posX - 1, enemigo->posicion->posY) || (enemigo->posicion->posX - 1 == 0 && enemigo->posicion->posY == 0)){
orientacion = vertical;
enemigo->posicion->posY = enemigo->posicion->posY + obtenerDireccionCercaniaEn(orientacion,enemigo,personaje);
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}else{
enemigo->posicion->posX = enemigo->posicion->posX - 1;
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}
}else{
if(hayCaja(enemigo->posicion->posX + 1, enemigo->posicion->posY) || (enemigo->posicion->posX + 1 == 0 && enemigo->posicion->posY == 0)){
orientacion = vertical;
enemigo->posicion->posY = enemigo->posicion->posY + obtenerDireccionCercaniaEn(orientacion,enemigo,personaje);
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}else{
enemigo->posicion->posX = enemigo->posicion->posX + 1;
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}
}
}else if(orientacion == vertical){
if(enemigo->posicion->posY > personaje->posicion->posY)
if(hayCaja(enemigo->posicion->posX, enemigo->posicion->posY - 1) || (enemigo->posicion->posX == 0 && enemigo->posicion->posY - 1 == 0)){
orientacion = horizontal;
enemigo->posicion->posX = enemigo->posicion->posX + obtenerDireccionCercaniaEn(orientacion,enemigo,personaje);
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}else{
enemigo->posicion->posY = enemigo->posicion->posY - 1;
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}
else if(hayCaja(enemigo->posicion->posX, enemigo->posicion->posY + 1) || (enemigo->posicion->posX == 0 && enemigo->posicion->posY + 1 == 0)){
orientacion = horizontal;
enemigo->posicion->posX = enemigo->posicion->posX + obtenerDireccionCercaniaEn(orientacion,enemigo,personaje);
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}else
enemigo->posicion->posY = enemigo->posicion->posY + 1;
pthread_mutex_lock(&mx_lista_items);
MoverEnemigo(items, enemigo->id, enemigo->posicion->posX,enemigo->posicion->posY);
pthread_mutex_unlock(&mx_lista_items);
}
if(graficar)
nivel_gui_dibujar(items,nombre);
if(IMPRIMIR_INFO_ENEMIGO){
pthread_mutex_lock(&mutex_log);
log_info(logger,"Posicion del enemigo. PosX: %d, PosY: %d ", enemigo->posicion->posX, enemigo->posicion->posY);
pthread_mutex_unlock(&mutex_log);
}
//TODO alcanza con esto o tengo q usar una funcion list_replace?
enemigo->ultimoMovimiento = orientacion;
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
int salirJuego = false;
while (salirJuego == false){
//Maquina de estados
switch(estado){
case Estado::ESTADO_INICIANDO:
Iniciando();
//estado =ESTADO_JUGANDO;
inicialicializandoStage();
estado=ESTADO_MENU;
break;
case Estado ::ESTADO_MENU:
menu->Pintar();
textos->Pintar(MODULO_TEXTOS_TITULO,150,50);
textos->Pintar(MODULO_TEXTOS_NOMBRE,0,450);
Menu();
//estado=ESTADO_JUGANDO;
break;
case Estado::ESTADO_PREJUGANDO:
nivelActual=0;
vida =1;
enemigosEliminados=0;
estado=ESTADO_JUGANDO;
break;
case Estado ::ESTADO_JUGANDO:
//enemigo->Actualizar();
for (int i = 0; i < nivel[nivelActual].numeroEnemigosVisibles; i++)
{
enemigoArreglo[i]->GetNaveObjeto()->Actualizar();
}
MoverEnemigo();
fondo->Pintar();
//SDL_FillRect(screen,NULL,SDL_MapRGB(screen->format,0,0,0)); //limpia la imagen
keys= SDL_GetKeyState(NULL);
if(keys[SDLK_RIGHT])
{
if(!EsLimitePantalla(nave->GetNaveObjeto(),BORDE_DERECHO))
nave->MoverDerecha(nivel[nivelActual].velocidadNavePropia);
}//Los 3 casos siguientes son el primero aplicando a las demas direcciones
if(keys[SDLK_LEFT])
{
if(!EsLimitePantalla(nave->GetNaveObjeto(),BORDE_IZQUIERDO))
nave->MoverIzquierda(nivel[nivelActual].velocidadNavePropia);
}
if(keys[SDLK_UP])
{
if(!EsLimitePantalla(nave->GetNaveObjeto(),BORDE_SUPERIOR))
nave->MoverArriba(nivel[nivelActual].velocidadNavePropia);
}
if(keys[SDLK_DOWN])
{
if(!EsLimitePantalla(nave->GetNaveObjeto(),BORDE_INFERIOR))
nave->MoverAbajo(nivel[nivelActual].velocidadNavePropia);
}
if (keys[SDLK_SPACE])
{
nave->Disparar(NAVE_PROPIA,nivel[nivelActual].balasMaximas);
}
///////////////////SIMULACION COLISIONES///////////////////////
if(keys[SDLK_x])//BALA ENEMIGO / NUESTRA NAVE
{
nave->simularColision(true);
}
if (keys[SDLK_c])//NUESTRA BALA / NAVE ENEMIGO
{
int enemigoAEliminar = rand() % nivel[nivelActual].numeroEnemigosVisibles;
enemigoArreglo[enemigoAEliminar]->simularColision(true);
}
if (keys[SDLK_v])//NUESTRA NAVE / NAVE ENEMIGO
{
}
////////////////////////////////////////////////////////////////
/////////////////////CONTROL DE COLISIONES//////////////////////
for (int i = 0; i < nivel[nivelActual].numeroEnemigosVisibles; i++)
{
if (enemigoArreglo[i]->estaColisionandoConBala(nave))
{
vida--;
}
if (nave->estaColisionandoConBala(enemigoArreglo[i]))
{
enemigoArreglo[i]->setVisible(false);
enemigosEliminados++;
nave->simularColision(false);
if (enemigosEliminados < nivel[nivelActual].numeroEnemigosAEliminar)
{
enemigoArreglo[i]->CrearNuevo();
}
}
/*if (nave->estaColisionandoConNaveEnemigo())
{
}*/
}
////////////////////////////////////////////////////////////////
if (vida<=0)
{
estado=ESTADO_TERMINANDO;
}
if (enemigosEliminados>=nivel[nivelActual].numeroEnemigosAEliminar)
{
nivelActual++;
//Cargar otro fondo;
}
nave->Pintar(NAVE_PROPIA);
// enemigo->Pintar();
for(int i=0;i<nivel[nivelActual].numeroEnemigosVisibles;i++)
{
enemigoArreglo[i]->Pintar(NAVE_ENEMIGO);
enemigoArreglo[i]->AutoDisparar(nivel[nivelActual].balasMaximas);
}
//nave->Pintar();
break;
case Estado ::ESTADO_TERMINANDO:
estado=ESTADO_JUGANDO;
break;
case Estado ::ESTADO_FINALIZANDO:
salirJuego = true;
break;
};
while(SDL_PollEvent(&event))//Aque SDL creara una lista de eventes ocurridos
{
if(event.type==SDL_QUIT){salirJuego=true;}//Si se detecta una salida de SDL o...
if(event.type==SDL_KEYDOWN){}
}
SDL_Flip(screen);//Este codigo esta provicionalmente aqui
//calculando FPS
tiempoFrameFinal=SDL_GetTicks();
while(tiempoFrameFinal<(tiempoFrameInicial+FPS_DELAY))
{
tiempoFrameFinal=SDL_GetTicks();
SDL_Delay(1);
}
printf("Frames:%d Tiempo:%d Tiempo promedio:%f Tiempo por frame:%d FPS:%f\n",tick,SDL_GetTicks(),(float)SDL_GetTicks()/(float)tick,tiempoFrameFinal- tiempoFrameInicial,1000.0f/(float)(tiempoFrameFinal-tiempoFrameInicial));
tiempoFrameInicial=tiempoFrameFinal;
tick++;
}
return true;
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
int salirJuego = false;
int i = 0;
while (salirJuego == false)
{
//Maquina de estados
switch (estado)
{
case Estado::ESTADO_INICIANDO: //inicializando
printf("1.- Estado_Iniciando");
Iniciando();
InicializandoStage();
estado = ESTADO_MENU; //estado = ESTADO_MENU
break;
case Estado::ESTADO_MENU: //MENU
menu->Pintar();
textos->Pintar(MODULO_FondoTexto_TITULO,160,50);
textos->Pintar(MODULO_FondoMenu_NOMBRE,400, 410);
Menu();
//estado= ESTADO_JUGANDO
break;
case ESTADO_PRE_JUGANDO:
NivelActual = 0;
vida = 1;
enemigosEliminados = 0;
estado = ESTADO_JUGANDO;
break;
case Estado::ESTADO_JUGANDO: //JUGAR
for (int i = 0; i < nivel[NivelActual].NumeroEnemigosVisibles; i++)
{
enemigoArreglo[i]->GetNaveObjeto()->Actualizar();
}
MoverEnemigo();
fondo->Pintar();
//SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
keys = SDL_GetKeyState(NULL);
if (keys[SDLK_RIGHT])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_DERECHO))
nave->MoverDerecha(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_LEFT])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_IZQUIERDO))
nave->MoverIzquierda(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_UP])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_SUPERIOR))
nave->MoverArriba(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_DOWN])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_INFERIOR))
nave->MoverAbajo(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_SPACE])
{
nave->Disparar(NAVE_PROPIA, nivel[NivelActual].BalasMaximas);
}
//////////////simulacion de coliciones
if (keys[SDLK_x]){//bala enemigo a nuestra nave
nave->simularColision(true);
}
if (keys[SDLK_c]){//nuestra bala a nave enemigo
int enemigoAEliminar = rand() % nivel[NivelActual].NumeroEnemigosVisibles;
enemigoArreglo[enemigoAEliminar]->simularColision(true);
}
if (keys[SDLK_v]){//nuestra nave a nave enemigo
}
///////////////////////////////////////////////
//control de coliciones
for (int i = 0; i<nivel[NivelActual].NumeroEnemigosVisibles; i++){
if (enemigoArreglo[i]->estaColicionandoConBala(nave))
vida--;
if (nave->estaColicionandoConBala(enemigoArreglo[i])){
enemigoArreglo[i]->setVisible(false);
enemigosEliminados++;
nave->simularColision(false);
if (enemigosEliminados < nivel[NivelActual].NumeroEnemigoAEliminar){
enemigoArreglo[i]->CrearNuevo();
}
}
}
///////////////////////////////////////
if (vida <= 0)
estado = ESTADO_TERMINANDO;
if (enemigosEliminados >= nivel[NivelActual].NumeroEnemigoAEliminar){
NivelActual++;
}
nave->Pintar(NAVE_PROPIA);
for (int i = 0; i < nivel[NivelActual].NumeroEnemigosVisibles; i++)
{
enemigoArreglo[i]->Pintar(NAVE_ENEMIGO);
enemigoArreglo[i]->AutoDispara(nivel[NivelActual].BalasMaximas);
}
if (keys[SDLK_ESCAPE])
{
}
break;
case Estado::ESTADO_TERMINANDO: //TERMINAR
break;
case Estado::ESTADO_FINALIZADO: //FINALIZAR
break;
}
while (SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT) { salirJuego = true; } // Si se detecta una salida
if (event.type == SDL_KEYDOWN) {} // una dirección (abajo) del teclado.
}
SDL_Flip(screen); //guarda en memoria buffer
//calculando FPS
tiempoFrameFinal = SDL_GetTicks();
while (tiempoFrameFinal < (tiempoFrameInicial + FPS_DELAY)){
tiempoFrameFinal = SDL_GetTicks();
SDL_Delay(1);
}
printf("Frames:%d Tiempo:%d Tiempo Promedio:%f Tiempo Por Frame:%d FPS:%f\n", tick, SDL_GetTicks(), (float)SDL_GetTicks() / (float)tick, tiempoFrameFinal - tiempoFrameInicial,1000.0f / (float) (tiempoFrameFinal-tiempoFrameInicial));
tiempoFrameInicial = tiempoFrameFinal; //Marcamos el inicio nuevamente
tick++;
}
return true;
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
int salirJuego = false;
while (salirJuego == false){
//Maquina de estados
switch(estado){
case Estado::ESTADO_INICIANDO:
Iniciando();
InicializandoStage();
estado = ESTADO_PRE_JUGANDO;
//estado = ESTADO_MENU;
break;
case Estado::ESTADO_MENU:
menu->Pintar(); //Pinta el fondo del menú
textos->Pintar(MODULO_TEXTOS_TITULO, 275, 150); //Pinta los textos del menú
textos->Pintar(MODULO_TEXTOS_MENU_OPCION1, 265, 190);
textos->Pintar(MODULO_TEXTOS_MENU_OPCION2, 278, 230);
//textos->Pintar(MODULO_TEXTOS_MENU_OPCION1_SELECCIONADO, 380, 190);
//textos->Pintar(MODULO_TEXTOS_MENU_OPCION2_SELECCIONADO, 393, 230);
Menu();
//estado = ESTADO_JUGANDO;
break;
case Estado::ESTADO_PRE_JUGANDO: //Estado que nos permite inicializar las variables antes de empezar a jugar
NivelActual = 0;
vida = 1;
enemigosEliminados = 0;
estado = ESTADO_JUGANDO;
break;
case Estado::ESTADO_JUGANDO:
for (int i = 0; i < nivel[NivelActual].NumeroEnemigosVisibles; i++)
{
enemigoArreglo[i]->GetNaveObjeto()->Actualizar();
}
MoverEnemigo();
fondo->Pintar();
//SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
keys = SDL_GetKeyState(NULL);
if (keys[SDLK_RIGHT])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_DERECHO)) //Si no está dentro del límite de la pantalla, no mover (! para negarlo)
nave->MoverDerecha(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_LEFT])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_IZQUIERDO))
nave->MoverIzquierda(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_UP])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_SUPERIOR))
nave->MoverArriba(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_DOWN])
{
if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_INFERIOR))
nave->MoverAbajo(nivel[NivelActual].VelocidadNavePropia);
}
if (keys[SDLK_SPACE])
{
nave->Disparar(NAVE_PROPIA, nivel[NivelActual].balasMaximas); //Con la barra espaciadora se manda llamar el método disparar
}
nave->Pintar(NAVE_PROPIA);
for (int i = 0; i < nivel[NivelActual].NumeroEnemigosVisibles; i++)
{
enemigoArreglo[i]->Pintar(NAVE_ENEMIGO);
enemigoArreglo[i]->AutoDisparar(nivel[NivelActual].balasMaximas);
}
/////////////////////SIMULACIÓN COLISIONES/////////////////////
if (keys[SDLK_x])
{
//Bala enemigo-Nuestra nave
nave->simularColision(true);
}
if (keys[SDLK_c])
{
//Nuestra bala - Nave enemigo
int enemigoAEliminar = rand() % nivel[NivelActual].NumeroEnemigosVisibles;
enemigoArreglo[enemigoAEliminar]->simularColision(true);
}
if (keys[SDLK_v])
{
//Nuestra nave - Nave enemigo
}
///////////////////////////////////////////////////////////////
/////////////////////CONTROL DE COLISIONES/////////////////////
for (int i = 0; i < nivel[NivelActual].NumeroEnemigosVisibles; i++)
{
if (enemigoArreglo[1]->estaColisionandoConBala(nave)) //Una bala del enemigo le pega a nuestra nave
vida--;
if (nave->estaColisionandoConBala(enemigoArreglo[i]))//Una bala de nuestra nave le pega al enemigo
{
enemigoArreglo[i]->setVisible(false);
enemigosEliminados++;
nave->simularColision(false);
if (enemigosEliminados < nivel[NivelActual].NumeroEnemigosAEliminar)
{
enemigoArreglo[i]->CrearNuevo();
}
}
}
///////////////////////////////////////////////////////////////
if (vida <= 0) //Cuando la vida se acaba, se va al estado Terminando
estado = ESTADO_TERMINANDO;
if (enemigosEliminados >= nivel[NivelActual].NumeroEnemigosAEliminar)
{
NivelActual++;
//Se puede cargar otro fondo
}
//Los 3 casos siguientes son el primero aplicado a las demás direcciones
//break;
break;
case Estado::ESTADO_TERMINANDO:
estado = ESTADO_MENU;
break;
case Estado::ESTADO_FINALIZANDO:
break;
};
while (SDL_PollEvent(&event))//Aquí SDL creará una lista de eventos ocurridos
{
if (event.type == SDL_QUIT) {salirJuego = true;}//Si se detecta una salida de SDL o...
if (event.type == SDL_KEYDOWN){}
}
//Este código estará provicionalmente aquí
SDL_Flip(screen); //La memoria principal no tiene nada hasta que llega aquí. Aquí se pinta
//Calculando FPS
tiempoFrameFinal = SDL_GetTicks();
while (tiempoFrameFinal < (tiempoFrameInicial + FPS_DELAY))
tiempoFrameFinal = SDL_GetTicks();
SDL_Delay(2); //Hacer una pausa de 1 milisegundo en el sistema para tener un procesador no tan ocupado
printf("Frames: %d Tiempo: %d Tiempo promedio: %f Tiempo por frame: %d FPS: %f\n", tick, SDL_GetTicks(), (float)SDL_GetTicks() / (float)tick, tiempoFrameFinal - tiempoFrameInicial, 1000.0f / (float)(tiempoFrameFinal - tiempoFrameInicial));
tiempoFrameInicial = tiempoFrameFinal;//Marcamos el inicio
tick++;
}
return true;
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
int salirJuego = false;
while (salirJuego == false){
//Maquina de estados
switch(estado){
case Estado::ESTADO_INICIANDO: //INICIALIZAR
//switch(estado){
Iniciando();
estado=ESTADO_MENU;
break;
/* nave = SDL_LoadBMP("../Data/MiNave.bmp");
SDL_Rect Fuente;
Fuente.x =90;
Fuente.y =152;
Fuente.w =242;
Fuente.h =76;
SDL_Rect destino;
destino.x =100;
destino.y =100;
destino.w =100;
destino.h =100;
SDL_BlitSurface(nave, &Fuente, screen, &destino);
SDL_BlitSurface(nave, NULL, screen, NULL);
SDL_FreeSurface(nave);
*/
case Estado::ESTADO_MENU:
//MENU
////nave->PintarModulo (0,0,0,64,64);
SDL_FillRect(screen, NULL, 0x000000);
keys = SDL_GetKeyState(NULL);
for (int i =0; i < 10; i++)
enemigoArreglo[i] -> Actualizar();
MoverEnemigo();
if(keys[SDLK_RIGHT]&& !esLimitePantalla(nave,BORDE_DERECHO)){
//nave->PintarModulo(0,100,100);
nave->MoverDerecha(1);
///Iniciando();
///estado=ESTADO_MENU;
}
nave->Pintar();
for (int i =0; i < 10; i++)
enemigoArreglo[i] -> Pintar();
break;
case Estado::ESTADO_JUGANDO: //JUGAR
break;
case Estado::ESTADO_TERMINADO: //TERMINAR
break;
case Estado::ESTADO_FINALIZADO: //SALIR
salirJuego = true;
break;
};
while (SDL_PollEvent(&event))//aqui SDL creara una lista de eventos ocurr
{
if (event.type == SDL_QUIT){salirJuego =true;}//si se detecta una
if (event.type == SDL_KEYDOWN){}
}
SDL_Flip(screen); //imprime en pantalla variable screen
frames++;
tiempoFrameFinal = SDL_GetTicks();
while(tiempoFrameFinal < (tiempoFrameInicio + FPS_DELAY))
tiempoFrameFinal = SDL_GetTicks();
printf("Frame:%d Tiempo:%d TiempoPorFrame:%d FPS:%f\n", frames,tiempoFrameInicio,tiempoFrameFinal-tiempoFrameInicio,1000.0f / (float)(tiempoFrameFinal-tiempoFrameInicio));
tiempoFrameInicio = tiempoFrameFinal;
}
return true;
}
bool CGame::Start()
{
// Esta variable nos ayudara a controlar la salida del juego...
int salirJuego = false;
int Bandera=0;
while (salirJuego == false){
//Maquina de estados
switch(estado){
case Estado::ESTADO_INICIANDO:
Iniciando();//ACT3: Bien.
InicializandoStage();
//estado= ESTADO_JUGANDO;
estado= ESTADO_MENU;
break;
case Estado:: ESTADO_MENU:
menu->Pintar();
textos->Pintar(MODULE_TEXTO_TITULO,100,50);
textos->Pintar(MODULE_TEXTO_NOMBRE,0,400);
Menu();
//estado=ESTADO_JUGANDO;
break;
case Estado::ESTADO_PRE_JUGANDO:
nivelActual=0;
Vida=1;
enemigosEliminados=0;
estado=ESTADO_JUGANDO;
break;
case Estado::ESTADO_JUGANDO:
//enemigo->Actualizar();
for (int i = 0; i <nivel[nivelActual].NumeroEnemigosVisibles; i++)
{
enemigoArreglo[i]->GetNaveObjeto()->Actualizar();
}
MoverEnemigo();
fondo->Pintar();
//SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format,0,0,0));//Limpia la imagen
keys=SDL_GetKeyState(NULL);
if(keys[SDLK_RIGHT]){
if(!EsLimitePantalla(nave->GetNaveObjeto(),BORDE_DERECHO))
nave->MoverDerecho(nivel[nivelActual].VelocidadNavePropia);
}
if (keys[SDLK_LEFT])
{
nave->MoverIzquierdo(nivel[nivelActual].VelocidadNavePropia);
}
if(keys[SDLK_UP])
{
nave->MoverArriba(nivel[nivelActual].VelocidadNavePropia);
}
if(keys[SDLK_DOWN])
{
nave->MoverAbajo(nivel[nivelActual].VelocidadNavePropia);
}
if (keys[SDLK_SPACE])
{
nave->Disparar(NAVE_PROPIA, nivel[nivelActual].balasMaximas);
}
//////SIMULACION COLICIONES////////////
if (keys[SDLK_x])//BALA ENEMIGO/NUESTRA NAVE
{
nave->simularColision(true);
}
if (keys[SDLK_c])//NUESTRA VALA/NAVE ENEMIGO
{
int enemigoAEliminar=rand()%nivel[nivelActual].NumeroEnemigosVisibles;
enemigoArreglo[enemigoAEliminar]->simularColision(true);
}
if (keys[SDLK_v])//NUESTRA NAVE/NAVE ENEMIGO
{
}
//////////CONTROL DE COLICIONES//////////
for(int i=0;i<nivel[nivelActual].NumeroEnemigosVisibles;i++)
{
if(enemigoArreglo[i]->estaColisionandoConBala(nave))
Vida--;
if(nave->estaColisionandoConBala(enemigoArreglo[i]))
{
enemigoArreglo[i]->setVisible(false);
enemigosEliminados++;
nave->simularColision(false);
if (enemigosEliminados < nivel[nivelActual].NumeroEnemigosAEliminar)
{
enemigoArreglo[i]->CrearNuevo();
}
}
}
////////////////////////////////////////
if (Vida<=0)
estado=ESTADO_TERMINANDO;
if(enemigosEliminados>=nivel[nivelActual].NumeroEnemigosAEliminar){
nivelActual++;
//CARGAR OTRO FONDO;
}
nave->Pintar(NAVE_PROPIA);
//enemigo->Pintar();
for(int i=0; i<nivel[nivelActual].NumeroEnemigosVisibles; i++)
{
enemigoArreglo[i]->Pintar(NAVE_ENEMIGO);
enemigoArreglo[i]->AutoDisparar(nivel[nivelActual].balasMaximas);
}
if (keys[SDLK_0])
{
printf("\n3.EstadoJugando");
estado=ESTADO_TERMINANDO;
}
break;
case Estado::ESTADO_TERMINANDO:
printf("\n4.EstadoTerminando");
estado=ESTADO_MENU;
break;
case Estado::ESTADO_FINALIZANDO:
/*printf("\n5.EstadoFinalizando");
getchar();*/
salirJuego = true;
break;
};
while (SDL_PollEvent(&event))//Aqui SDL creara una lista de eventos ocurridos
{
if (event.type==SDL_QUIT) {salirJuego=true;}//Si se detecta una salida de SDL o...
if(event.type==SDL_KEYDOWN){ }
}
SDL_Flip(screen);
tiempoFrameFinal=SDL_GetTicks();
while(tiempoFrameFinal<(tiempoFrameInicial + FPS_DELAY))
{
tiempoFrameFinal=SDL_GetTicks();
SDL_Delay(1);
}
printf("Frames:%dTiempo: %dTiempo promedio: %fTiempo por frame: %d FPS:%f\n",tick,SDL_GetTicks(),(float)SDL_GetTicks()/(float)tick,tiempoFrameFinal-tiempoFrameInicial,1000.0f/(float)(tiempoFrameFinal-tiempoFrameInicial));
tiempoFrameInicial=tiempoFrameFinal;
tick++;
}
return true;
}
