Merge branch 'master' of https://github.com/nledesma/1942oldenait

Author: Arkenan

src/accesorios/codigo.hpp

@@ -37,7 +37,7 @@
 #define PRESIONA_X 12
 #define PRESIONA_L 13
 #define PRESIONA_P 14
-
+#define PRESIONA_C 15
 /* Dimensiones */
 
 #define ANCHO_ESCENARIO 800
@@ -272,4 +272,11 @@
 #define COLISION_AVION_CON_POWERUP 14
 
 #define VALOR_POWERUP_1500 1500
+
+/* Eventos del escenarioJuego */
+
+#define CONTINUA_PARTIDA 0
+#define RESETEA_PARTIDA 1
+#define CIERRA_PARTIDA 2
+
 #endif //INC_1942OLDENAIT_CODIGO_HPP

src/accesorios/colisiones/colisionable.cpp

@@ -28,20 +28,20 @@ Colisionable::Colisionable(float x, float y, float angulo, int tipoDeElemento){
             this->crearDisparoEnemigo(x, y, angulo);
             break;
         case TIPO_POWERUP_BONIFICACION:
-             this->crearPowerUp(x,y,0);
-             break;
-         case TIPO_POWERUP_DESTRUIR_ENEMIGOS:
-             this->crearPowerUp(x,y,0);
-             break;
-         case TIPO_POWERUP_DOS_AMETRALLADORAS:
-             this->crearPowerUp(x,y,0);
-             break;
-         case TIPO_POWERUP_AVIONES_SECUNDARIOS:
-             this->crearPowerUp(x,y,0);
-             break;
-         case TIPO_POWERUP_BONIFICACION_1500:
-             this->crearPowerUp(x,y,0);
-             break;
+            this->crearPowerUp(x,y,0);
+            break;
+        case TIPO_POWERUP_DESTRUIR_ENEMIGOS:
+            this->crearPowerUp(x,y,0);
+            break;
+        case TIPO_POWERUP_DOS_AMETRALLADORAS:
+            this->crearPowerUp(x,y,0);
+            break;
+        case TIPO_POWERUP_AVIONES_SECUNDARIOS:
+            this->crearPowerUp(x,y,0);
+            break;
+        case TIPO_POWERUP_BONIFICACION_1500:
+            this->crearPowerUp(x,y,0);
+            break;
     }
 }
 
@@ -151,11 +151,11 @@ void Colisionable::crearPowerUp(float posX, float posY, float angulo){
     this->superficiePrincipal->rotar(angulo, xCentro, yCentro, TIPO_POWERUP);
 }
 
-
 void Colisionable::mover(float posX, float posY, float angulo, int tipoElemento){
     this->superficiePrincipal->mover(posX, posY);
     float xCentral = posX + (this->superficiePrincipal->getAncho() / 2);
     float yCentral = posY + (this->superficiePrincipal->getAlto() / 2);
+    //this->superficiePrincipal->rotar(angulo, xCentral, yCentral);
     for(unsigned int i = 0; i < this->superficiesSecundarias.size(); i++){
         this->superficiesSecundarias[i]->mover(posX, posY);
         this->superficiesSecundarias[i]->rotar(angulo, xCentral, yCentral, tipoElemento);
@@ -277,6 +277,7 @@ float Colisionable::getExtremoSuperior(){
         extremoSuperior  = superficiePrincipal->getIzqArriba()->getPosY();
     }
 
+
     if(extremoSuperior < superficiePrincipal->getDerArriba()->getPosY()){
         extremoSuperior = superficiePrincipal->getDerArriba()->getPosY();
     }
@@ -316,4 +317,4 @@ void Colisionable::proyectarColisionable(float timeStep) {
     posY += posY * timeStep;
     this->superficiePrincipal->getDerArriba()->setPosY(posY);
     this->superficiePrincipal->getIzqArriba()->setPosY(posY);
-}
+}

src/accesorios/colisiones/dimensionSuperficies.hpp

@@ -37,14 +37,14 @@
 #define DISPARO_ENEMIGO_SUPERFICIE_ANCHO 10
 #define DISPARO_ENEMIGO_SUPERFICIE_ALTO 10
 
-#define AVION_ENEMIGO_MEDIANO_ANCHO_1 25
-#define AVION_ENEMIGO_MEDIANO_ALTO_1 40
-#define OFFSET_AVION_ENEMIGO_MEDIANO_ANCHO_1 15
-#define OFFSET_AVION_ENEMIGO_MEDIANO_ALTO_1 5
-#define AVION_ENEMIGO_MEDIANO_ANCHO_2 55
-#define AVION_ENEMIGO_MEDIANO_ALTO_2 6
-#define OFFSET_AVION_ENEMIGO_ALTO_2 25
-#define OFFSET_ALTO_AVION_MEDIANO_DEFAULT 15
-#define OFFSET_ANCHO_AVION_MEDIANO_DEFAULT 6
-
-#endif //INC_1942OLDENAIT_DIMENSIONSUPERFICIES_HPP_H
+#define AVION_ENEMIGO_MEDIANO_ANCHO_1 20
+#define AVION_ENEMIGO_MEDIANO_ALTO_1 20
+#define OFFSET_AVION_ENEMIGO_MEDIANO_ANCHO_1 25
+#define OFFSET_AVION_ENEMIGO_MEDIANO_ALTO_1 12
+#define AVION_ENEMIGO_MEDIANO_ANCHO_2 65
+#define AVION_ENEMIGO_MEDIANO_ALTO_2 5
+#define OFFSET_AVION_ENEMIGO_ALTO_2 41
+#define OFFSET_ALTO_AVION_MEDIANO_DEFAULT 20
+#define OFFSET_ANCHO_AVION_MEDIANO_DEFAULT 5
+
+#endif //INC_1942OLDENAIT_DIMENSIONSUPERFICIES_HPP_H

src/juego/modelo/escenarioJuego.cpp

@@ -116,12 +116,12 @@ void EscenarioJuego::agregarEtapa(Etapa * etapa) {
     this->etapas.push_back(etapa);
 }
 
-bool EscenarioJuego::manejarEvento(int nroAvion, int evento) {
+int EscenarioJuego::manejarEvento(int nroAvion, int evento) {
     vector<Disparo *> disparo;
-    bool resetea = false;
+    int eventoIteracion = CONTINUA_PARTIDA;
     switch (evento) {
         case PRESIONA_R:
-            resetea = true;
+            eventoIteracion = RESETEA_PARTIDA;
             break;
         case PRESIONA_ESPACIO:
             disparo = avion(nroAvion)->disparar();
@@ -141,11 +141,13 @@ bool EscenarioJuego::manejarEvento(int nroAvion, int evento) {
         case PRESIONA_P:
             this->togglePausa();
             break;
+        case PRESIONA_C:
+            eventoIteracion = CIERRA_PARTIDA;
         default:
             avion(nroAvion)->manejarEvento(evento);
             break;
     }
-    return resetea;
+    return eventoIteracion;
 }
 
 void EscenarioJuego::avanzarEtapa() {
@@ -189,6 +191,29 @@ void EscenarioJuego::reiniciarEtapas() {
 
 }
 
+void EscenarioJuego::terminarEtapas() {
+    desactivar();
+    pthread_mutex_lock(&mutexPowerUps);
+    this->powerUps.clear();
+    pthread_mutex_unlock(&mutexPowerUps);
+    pthread_mutex_lock(&mutexListaEnemigos);
+    this->enemigos.clear();
+    pthread_mutex_unlock(&mutexListaEnemigos);
+    pthread_mutex_lock(&mutexListaDisparosEnemigos);this->disparos.clear();
+    this->disparosEnemigos.clear();
+    pthread_mutex_unlock(&mutexListaDisparosEnemigos);
+    pthread_mutex_lock(&mutexListaDisparos);this->disparos.clear();
+    this->disparos.clear();
+    pthread_mutex_unlock(&mutexListaDisparos);
+
+    while (!this->colaEventos.vacia()) {
+        this->colaEventos.pop();
+    }
+    temporizador.detener();
+
+    this->etapas.clear();
+}
+
 int EscenarioJuego::comenzarEtapa() {
     this->activar();
     scrollingOffset = 0;
@@ -234,7 +259,7 @@ int EscenarioJuego::mainLoop() {
 }
 
 int EscenarioJuego::actualizarEstado(float timeStep) {
-    bool resetear = false;
+    int eventoIteracion = CONTINUA_PARTIDA;
     int eventoFinal = AVANZAR_ETAPA;
     if (this->posicionY < this->etapaActual()->getLongitud() - 800) {
         if (!this->pausado) {
@@ -253,7 +278,7 @@ int EscenarioJuego::actualizarEstado(float timeStep) {
             this->moverDisparos(timeStep);
             this->getProximoEnemigo();
         }
-        resetear = this->manejarProximoEvento();
+        eventoIteracion = this->manejarProximoEvento();
     } else {
         this->moverEnemigos(timeStep);
         this->moverDisparosEnemigos(timeStep);
@@ -282,9 +307,12 @@ int EscenarioJuego::actualizarEstado(float timeStep) {
             }
         }
     }
-    if (resetear){
+    if (eventoIteracion == RESETEA_PARTIDA){
         this->reiniciarEtapas();
         eventoFinal = REINICIAR_ESCENARIO;
+    } else if (eventoIteracion == CIERRA_PARTIDA){
+        this->terminarEtapas();
+        eventoFinal = FINALIZAR_JUEGO;
     }
     return eventoFinal;
 }
@@ -351,19 +379,19 @@ int EscenarioJuego::jugar(bool serverActivo) {
     return comenzarEtapa();
 }
 
-bool EscenarioJuego::manejarProximoEvento() {
-    bool resetear = false;
+int EscenarioJuego::manejarProximoEvento() {
+    int eventoIteracion = CONTINUA_PARTIDA;
     if (!this->colaEventos.vacia()) {
         pair<int, int> evento = this->colaEventos.pop();
         if (!this->pausado){
-            resetear = this->manejarEvento(evento.first, evento.second);
+            eventoIteracion = this->manejarEvento(evento.first, evento.second);
         } else {
             if (evento.second == PRESIONA_P || evento.second == PRESIONA_R){
-                resetear = this->manejarEvento(evento.first, evento.second);
+                eventoIteracion = this->manejarEvento(evento.first, evento.second);
             }
         }
     }
-    return resetear;
+    return eventoIteracion;
 }
 
 void EscenarioJuego::pushEvento(pair<int, int> evento) {

src/juego/modelo/escenarioJuego.hpp

@@ -85,13 +85,14 @@ class EscenarioJuego {
     void agregarEtapa(Etapa * etapa);
     void avanzarEtapa();
     void reiniciarEtapas();
+    void terminarEtapas();
     int comenzarEtapa();
     bool quedanEtapas();
     /* Enemigos */
     void getProximoEnemigo();
     /* Eventos */
-    bool manejarProximoEvento();
-    bool manejarEvento(int nroAvion, int evento);
+    int manejarProximoEvento();
+    int manejarEvento(int nroAvion, int evento);
     void pushEvento(pair<int, int> evento);
     /* mainLoop */
     int jugar(bool serverActivo);

src/juego/vista/escenarioVista.cpp

@@ -328,6 +328,8 @@ void EscenarioVista::pushEvento(SDL_Event evento){
             case SDLK_p:
                 this->colaEventos.push((int)PRESIONA_P);
                 break;
+            case SDLK_c:
+                this->colaEventos.push((int)PRESIONA_C);
         }
     } else if( evento.type == SDL_KEYUP && evento.key.repeat == 0 ) {
         switch( evento.key.keysym.sym )

src/net/servidor/servidor.cpp

@@ -225,16 +225,18 @@ int Servidor::aceptar() {
 }
 
 void Servidor::cerrar() {
-    this->desactivarServidor();
-    for (map<int, datosCliente>::iterator iterador = getClientes().begin(); iterador != getClientes().end(); iterador++) {
-        int clienteActual = iterador->first;
-        shutdown(clienteActual, 0);
-        close(clienteActual);
-        iterador->second.colaSalida.avisar();
+    if (this->servidorActivo()) {
+        this->desactivarServidor();
+        for (map<int, datosCliente>::iterator iterador = getClientes().begin();
+             iterador != getClientes().end(); iterador++) {
+            int clienteActual = iterador->first;
+            shutdown(clienteActual, 0);
+            close(clienteActual);
+            iterador->second.colaSalida.avisar();
+        }
+        cerrarSocket();
     }
 
-    cerrarSocket();
-
     // Cerramos las colas.
     colaDeMensajes.avisar();
     this->escenario->desactivar();
@@ -407,9 +409,10 @@ void Servidor::desencolar() {
         int intEvento = Decodificador::popInt(clienteMensaje.second);
         int intJugador = clientes[clienteMensaje.first].nroJugador;
         pair <int, int> evento(intJugador, intEvento);
-        if(intEvento != PRESIONA_X){
+        if(intEvento != PRESIONA_X && intEvento != PRESIONA_C){
             this->escenario->pushEvento(evento);
         } else {
+            this->escenario->pushEvento(evento);
             this->cerrar();
         }
     }