From 80656b3c2adbe8a2470e9f1c186179bd83dc8ede Mon Sep 17 00:00:00 2001
From: Bruno Grassano <grassanobruno@gmail.com>
Date: Tue, 26 Jan 2021 13:11:05 -0300
Subject: [PATCH 1/7] Ref: Se pasa a usar un solo entidad_t

---
 .../DibujadoresJuego/DibujadorJuego.cpp       | 54 +++++++-------
 src/Client/App/JuegoCliente/JuegoCliente.cpp  | 66 +++++++----------
 src/Client/App/JuegoCliente/JuegoCliente.hpp  | 24 +++---
 src/Client/Escuchadores/EscuchadorRonda.cpp   | 20 ++---
 src/Client/Escuchadores/EscuchadorRonda.hpp   | 10 +--
 .../Modelo/Juego/Nivel/Bloques/Bloque.cpp     | 12 +--
 .../Modelo/Juego/Nivel/Bloques/Bloque.hpp     |  2 +-
 .../Modelo/Juego/Nivel/Bloques/Tuberia.cpp    | 11 ++-
 .../Modelo/Juego/Nivel/Bloques/Tuberia.hpp    |  2 +-
 .../Modelo/Juego/Nivel/Enemigos/Enemigo.cpp   | 16 ++--
 .../Modelo/Juego/Nivel/Enemigos/Enemigo.hpp   |  4 +-
 .../Modelo/Juego/Nivel/Enemigos/Goomba.cpp    |  2 +-
 .../Modelo/Juego/Nivel/Enemigos/Goomba.hpp    |  2 +-
 .../Modelo/Juego/Nivel/Enemigos/Koopa.cpp     |  2 +-
 .../Modelo/Juego/Nivel/Enemigos/Koopa.hpp     |  2 +-
 src/Server/Modelo/Juego/Nivel/Moneda.cpp      | 11 ++-
 src/Server/Modelo/Juego/Nivel/Moneda.hpp      |  2 +-
 src/Server/Modelo/Juego/Nivel/Nivel.cpp       | 33 ++++-----
 src/Server/Modelo/Juego/Nivel/Nivel.hpp       | 14 ++--
 src/Server/Modelo/Juego/Nivel/Piso/Piso.cpp   |  6 +-
 src/Server/Modelo/Juego/Nivel/Piso/Piso.hpp   |  4 +-
 src/Server/Modelo/Juego/Nivel/Piso/Pozo.cpp   |  8 +-
 src/Server/Modelo/Juego/Nivel/Piso/Pozo.hpp   |  2 +-
 src/Utils/Utils.hpp                           | 74 ++++++-------------
 24 files changed, 174 insertions(+), 209 deletions(-)

diff --git a/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp b/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
index 57dd9cef..1e89902d 100644
--- a/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
+++ b/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
@@ -55,54 +55,54 @@ void DibujadorJuego::dibujar(){
 }
 
 void DibujadorJuego::dibujarEnemigos(){
-	list<enemigo_t> enemigos = juegoCliente->obtenerEnemigos();
+	list<entidad_t> enemigos = juegoCliente->obtenerEnemigos();
 	string tipo;
 	SDL_Texture* texturaEnemigo = nullptr;
 	for (auto const& enemigo : enemigos) {
 		SDL_Rect recorteTextura;
-		if(enemigo.tipoEnemigo==GOOMBA){
-			recorteTextura = recorteSpriteGoomba->obtenerRecorte(enemigo.numeroRecorteX,enemigo.numeroRecorteY);
+		if(enemigo.tipo==GOOMBA){
+			recorteTextura = recorteSpriteGoomba->obtenerRecorte(enemigo.recorteX,enemigo.recorteY);
             texturaEnemigo = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_GOOMBA);
 		}
 		else{
-			recorteTextura = recorteSpriteKoopa->obtenerRecorte(enemigo.numeroRecorteX,enemigo.numeroRecorteY);
+			recorteTextura = recorteSpriteKoopa->obtenerRecorte(enemigo.recorteX,enemigo.recorteY);
             texturaEnemigo = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_KOOPAS);
 		}
 
-		SDL_Rect rectanguloEnemigo = {enemigo.posX-rectanguloCamara.x,
-									alto_pantalla - enemigo.posY - ALTO_ENEMIGOS,
+		SDL_Rect rectanguloEnemigo = {enemigo.x-rectanguloCamara.x,
+									alto_pantalla - enemigo.y - ALTO_ENEMIGOS,
 									ANCHO_ENEMIGOS, ALTO_ENEMIGOS};
 
         //SDL_SetRenderDrawColor(renderizador, 0, 0, 0, 0x0F );
 		//SDL_RenderDrawRect(renderizador, &rectanguloEnemigo);
 
 		SDL_RenderCopyEx(renderizador,texturaEnemigo,&recorteTextura,&rectanguloEnemigo,0,
-                         nullptr,enemigo.espejar?SDL_FLIP_HORIZONTAL:SDL_FLIP_NONE);
+                         nullptr,enemigo.espejado?SDL_FLIP_HORIZONTAL:SDL_FLIP_NONE);
     }
 }
 
 void DibujadorJuego::dibujarPlataformas(){
-	list<bloque_t> bloques = juegoCliente->obtenerBloques();
+	list<entidad_t> bloques = juegoCliente->obtenerBloques();
     SDL_Texture* texturaBloques = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_BLOQUES);
 	for (auto const& bloque : bloques) {
 
-		SDL_Rect rectanguloBloque = {bloque.posX - rectanguloCamara.x,
-									alto_pantalla - bloque.posY - LARGO_BLOQUE,
+		SDL_Rect rectanguloBloque = {bloque.x - rectanguloCamara.x,
+									alto_pantalla - bloque.y - LARGO_BLOQUE,
 									LARGO_BLOQUE, LARGO_BLOQUE};
-		SDL_Rect recorteBloque = recorteSpriteBloque->obtenerRecorte(bloque.numeroRecorteX,bloque.numeroRecorteY);
+		SDL_Rect recorteBloque = recorteSpriteBloque->obtenerRecorte(bloque.recorteX,bloque.recorteY);
 		SDL_RenderCopy( renderizador, texturaBloques, &recorteBloque, &rectanguloBloque);
 	}
 
 }
 
 void DibujadorJuego::dibujarFondoPozos() {
-    list<pozo_t> pozos = juegoCliente->obtenerPozos();
+    list<entidad_t> pozos = juegoCliente->obtenerPozos();
     SDL_Texture* texturaFondoPozos = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_FONDO_POZO);
     for (auto const& pozo : pozos) {
-        SDL_Rect rectanguloPozo = {pozo.posX - rectanguloCamara.x,
+        SDL_Rect rectanguloPozo = {pozo.x - rectanguloCamara.x,
                                    alto_pantalla - (int)(alto_pantalla*0.12),
                                    ANCHO_POZO, (int)(alto_pantalla*0.12)};
-        SDL_Rect recortePozo = recortes[POZO_RECORTE]->obtenerRecorte(0,pozo.fondo);
+        SDL_Rect recortePozo = recortes[POZO_RECORTE]->obtenerRecorte(0,pozo.tipo);
         recortePozo.y += 1; // TODO acomodar o crear un nuevo recorte, agarra una parte de la imagen de arriba
         SDL_RenderCopy( renderizador, texturaFondoPozos, &recortePozo, &rectanguloPozo);
     }
@@ -110,38 +110,38 @@ void DibujadorJuego::dibujarFondoPozos() {
 
 
 void DibujadorJuego::dibujarPozos(){
-    list<pozo_t> pozos = juegoCliente->obtenerPozos();
+    list<entidad_t> pozos = juegoCliente->obtenerPozos();
     SDL_Texture* texturaPozos = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_POZO);
     for (auto const& pozo : pozos) {
-        SDL_Rect rectanguloPozo = {pozo.posX - rectanguloCamara.x,
+        SDL_Rect rectanguloPozo = {pozo.x - rectanguloCamara.x,
                                      alto_pantalla - ALTO_POZO,
                                      ANCHO_POZO, ALTO_POZO};
-        SDL_Rect recortePozo = recortes[POZO_RECORTE]->obtenerRecorte(0,pozo.tipo);
+        SDL_Rect recortePozo = recortes[POZO_RECORTE]->obtenerRecorte(0,pozo.recorteY);
         SDL_RenderCopy( renderizador, texturaPozos, &recortePozo, &rectanguloPozo);
     }
 }
 
 void DibujadorJuego::dibujarMonedas(){
-	list<moneda_t> monedas = juegoCliente->obtenerMonedas();
+	list<entidad_t> monedas = juegoCliente->obtenerMonedas();
     SDL_Texture* texturaMoneda = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_MONEDA);
 	for (auto const& moneda : monedas) {
-		SDL_Rect rectanguloMoneda = {moneda.posX - rectanguloCamara.x,
-									alto_pantalla - moneda.posY - LARGO_MONEDA,
+		SDL_Rect rectanguloMoneda = {moneda.x - rectanguloCamara.x,
+									alto_pantalla - moneda.y - LARGO_MONEDA,
                                      LARGO_MONEDA, LARGO_MONEDA};
-		SDL_Rect recorteMoneda = recorteSpriteMoneda->obtenerRecorte(moneda.numeroRecorte);
+		SDL_Rect recorteMoneda = recorteSpriteMoneda->obtenerRecorte(moneda.recorteX);
 		SDL_RenderCopy( renderizador, texturaMoneda, &recorteMoneda, &rectanguloMoneda);
 	}
 }
 
 void DibujadorJuego::dibujarTuberias() {
-    list<tuberia_t> tuberias = juegoCliente->obtenerTuberias();
+    list<entidad_t> tuberias = juegoCliente->obtenerTuberias();
     SDL_Texture* texturaTuberia = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_TUBERIAS);
     for (auto const& tuberia : tuberias) {
-        SDL_Rect recorteTuberia = recorteSpriteTuberia->obtenerRecorte(tuberia.tipo,tuberia.color);
-        SDL_Rect rectanguloTuberia = {tuberia.posX - rectanguloCamara.x,
-                                      alto_pantalla - recorteSpriteTuberia->obtenerAlturaParaDibujarImagen(tuberia.tipo) - tuberia.posY,
-                                      recorteSpriteTuberia->obtenerAnchuraParaDibujarImagen(tuberia.tipo),
-                                      recorteSpriteTuberia->obtenerAlturaParaDibujarImagen(tuberia.tipo)};
+        SDL_Rect recorteTuberia = recorteSpriteTuberia->obtenerRecorte(tuberia.recorteX,tuberia.recorteY);
+        SDL_Rect rectanguloTuberia = {tuberia.x - rectanguloCamara.x,
+                                      alto_pantalla - recorteSpriteTuberia->obtenerAlturaParaDibujarImagen(tuberia.recorteX) - tuberia.y,
+                                      recorteSpriteTuberia->obtenerAnchuraParaDibujarImagen(tuberia.recorteX),
+                                      recorteSpriteTuberia->obtenerAlturaParaDibujarImagen(tuberia.recorteX)};
         SDL_RenderCopy( renderizador, texturaTuberia, &recorteTuberia, &rectanguloTuberia);
     }
 }
diff --git a/src/Client/App/JuegoCliente/JuegoCliente.cpp b/src/Client/App/JuegoCliente/JuegoCliente.cpp
index e56e66e3..c32d3716 100644
--- a/src/Client/App/JuegoCliente/JuegoCliente.cpp
+++ b/src/Client/App/JuegoCliente/JuegoCliente.cpp
@@ -7,8 +7,8 @@
 
 pthread_mutex_t mutexJuegoCliente = PTHREAD_MUTEX_INITIALIZER;
 
-bool operator == (const bloque_t &bloque1, const bloque_t &bloque2){
-    return bloque1.posX == bloque2.posX && bloque1.posY == bloque2.posY && bloque1.numeroRecorteY == bloque2.numeroRecorteY;
+bool operator == (const entidad_t &bloque1, const entidad_t &bloque2){
+    return bloque1.x == bloque2.x && bloque1.y == bloque2.y && bloque1.recorteY == bloque2.recorteY;
 }
 
 
@@ -59,6 +59,13 @@ SDL_Rect JuegoCliente::obtenerCamara()const{
 	return rectanguloCamara;
 }
 
+void JuegoCliente::cargarLista(list<entidad_t>* listaACargar, entidad_t *vector, unsigned short tope) {
+    listaACargar->clear();
+    for(int i=0;i<tope;i++){
+        listaACargar->push_front(vector[i]);
+    }
+}
+
 void JuegoCliente::actualizar(){
 	if(rondas.empty()){
 		return;
@@ -81,21 +88,12 @@ void JuegoCliente::actualizar(){
 	ganaron = ronda.ganaron;
 	perdieron = ronda.perdieron;
 
-	bloques.clear();
-	enemigos.clear();
 	jugadores.clear();
-	monedas.clear();
 	efectos.clear();
 
-	for(int i=0;i<ronda.topeBloques;i++){
-		bloques.push_front(ronda.bloques[i]);
-	}
-	for(int i=0;i<ronda.topeEnemigos;i++){
-		enemigos.push_front(ronda.enemigos[i]);
-	}
-	for(int i=0;i<ronda.topeMonedas;i++){
-		monedas.push_front(ronda.monedas[i]);
-	}
+	cargarLista(&bloques,ronda.bloques,ronda.topeBloques);
+    cargarLista(&enemigos,ronda.enemigos,ronda.topeEnemigos);
+    cargarLista(&monedas,ronda.monedas,ronda.topeMonedas);
 	for(int i=0;i<cantidadJugadores;i++){
 		jugadores[i]=ronda.jugadores[i];
 	}
@@ -103,11 +101,11 @@ void JuegoCliente::actualizar(){
         efectos.push_front(ronda.efectos[i]);
     }
 
-    list<bloque_t> ladrillosASacar;
-    list<bloque_t> ladrillosNuevos;
+    list<entidad_t> ladrillosASacar;
+    list<entidad_t> ladrillosNuevos;
     bool agregado = false;
     for(auto ladrillo: ladrillos){
-        if(enRango(ladrillo.posX, LARGO_BLOQUE)){
+        if(enRango(ladrillo.x, LARGO_BLOQUE)){
             for(auto bloque : bloques) {
                 if(ladrillo == bloque){
                     ladrillosASacar.push_front(ladrillo);
@@ -138,11 +136,11 @@ map<int,jugador_t> JuegoCliente::obtenerJugadores(){
 	return jugadores;
 }
 
-list<enemigo_t> JuegoCliente::obtenerEnemigos(){
+list<entidad_t> JuegoCliente::obtenerEnemigos(){
 	return enemigos;
 }
 
-list<bloque_t> JuegoCliente::obtenerBloques(){
+list<entidad_t> JuegoCliente::obtenerBloques(){
 	return bloques;
 }
 
@@ -150,7 +148,7 @@ bool JuegoCliente::enRango(int posX, int w) const {
     return (rectanguloCamara.x - RANGO_VISTA) <= posX + w && posX <= (rectanguloCamara.x + anchoVista + RANGO_VISTA);
 }
 
-list<moneda_t> JuegoCliente::obtenerMonedas(){
+list<entidad_t> JuegoCliente::obtenerMonedas(){
 	return monedas;
 }
 
@@ -166,10 +164,10 @@ int JuegoCliente::obtenerMundoActual() const{
 	return numeroMundo;
 }
 
-list<pozo_t> JuegoCliente::obtenerPozos() {
-    list<pozo_t> pozosAMostrar;
+list<entidad_t> JuegoCliente::obtenerPozos() {
+    list<entidad_t> pozosAMostrar;
     for(auto pozo:pozos){
-        if(enRango(pozo.posX, ANCHO_POZO)){
+        if(enRango(pozo.x, ANCHO_POZO)){
             pozosAMostrar.push_front(pozo);
         }
     }
@@ -177,11 +175,11 @@ list<pozo_t> JuegoCliente::obtenerPozos() {
 }
 
 
-list<tuberia_t> JuegoCliente::obtenerTuberias() {
-    list<tuberia_t> tuberiasAMostrar;
+list<entidad_t> JuegoCliente::obtenerTuberias() {
+    list<entidad_t> tuberiasAMostrar;
     for(auto tuberia:tuberias){
         int ancho = tuberia.tipo==TUBERIA_CHICA?ANCHO_TUBERIA_CHICA:ANCHO_TUBERIA_GRANDE;
-        if(enRango(tuberia.posX, ancho)){
+        if(enRango(tuberia.x, ancho)){
             tuberiasAMostrar.push_front(tuberia);
         }
     }
@@ -198,18 +196,10 @@ void JuegoCliente::agregarNivel(nivel_t nivel) {
         this->hayQueMostrarPuntosDeNivel = true;
     }
     numeroMundo = nivel.mundo;
-    ladrillos.clear();
-    tuberias.clear();
-    pozos.clear();
-    for(int i=0;i<nivel.topeBloques;i++){
-        ladrillos.push_front(nivel.bloques[i]);
-    }
-    for(int i=0;i<nivel.topeTuberias;i++){
-        tuberias.push_front(nivel.tuberias[i]);
-    }
-    for(int i=0;i<nivel.topePozos;i++){
-        pozos.push_front(nivel.pozos[i]);
-    }
+
+    cargarLista(&ladrillos,nivel.bloques,nivel.topeBloques);
+    cargarLista(&tuberias,nivel.tuberias,nivel.topeTuberias);
+    cargarLista(&pozos,nivel.pozos,nivel.topePozos);
 
     if(!hayQueCargarPodioNivel){
         hayQueCargarPodioNivel = true;
diff --git a/src/Client/App/JuegoCliente/JuegoCliente.hpp b/src/Client/App/JuegoCliente/JuegoCliente.hpp
index 99ae12bc..452ec92b 100644
--- a/src/Client/App/JuegoCliente/JuegoCliente.hpp
+++ b/src/Client/App/JuegoCliente/JuegoCliente.hpp
@@ -20,12 +20,12 @@ class JuegoCliente{
 		void agregarRonda(info_ronda_t ronda);
 		void actualizar();
 		map<int,jugador_t> obtenerJugadores();
-		list<enemigo_t> obtenerEnemigos();
-		list<bloque_t> obtenerBloques();
-		list<moneda_t> obtenerMonedas();
-        list<tuberia_t> obtenerTuberias();
+		list<entidad_t> obtenerEnemigos();
+		list<entidad_t> obtenerBloques();
+		list<entidad_t> obtenerMonedas();
+        list<entidad_t> obtenerTuberias();
         list<efecto_t> obtenerEfectos();
-        list<pozo_t> obtenerPozos();
+        list<entidad_t> obtenerPozos();
         SDL_Rect rectanguloCamara{};
 		int obtenerTiempoFaltante() const;
 		int obtenerMundoActual() const;
@@ -43,12 +43,12 @@ class JuegoCliente{
         bool enRango(int posX, int w) const;
 		queue<info_ronda_t> rondas;
 		map<int,jugador_t> jugadores;
-		list<bloque_t> bloques;
-        list<bloque_t> ladrillos;
-        list<pozo_t> pozos;
-		list<enemigo_t> enemigos;
-		list<moneda_t> monedas;
-        list<tuberia_t> tuberias;
+		list<entidad_t> bloques;
+        list<entidad_t> ladrillos;
+        list<entidad_t> pozos;
+		list<entidad_t> enemigos;
+		list<entidad_t> monedas;
+        list<entidad_t> tuberias;
         list<efecto_t> efectos;
         vector<podio_t> podios;
         podio_t podioPuntosTotales{};
@@ -61,6 +61,8 @@ class JuegoCliente{
 		bool perdieron;
         bool hayQueCargarPodioNivel;
 		int nivelesJugados;
+
+        static void cargarLista(list<entidad_t>* listaACargar, entidad_t *vector, unsigned short tope);
 };
 
 
diff --git a/src/Client/Escuchadores/EscuchadorRonda.cpp b/src/Client/Escuchadores/EscuchadorRonda.cpp
index b74d9e72..1ccccb74 100644
--- a/src/Client/Escuchadores/EscuchadorRonda.cpp
+++ b/src/Client/Escuchadores/EscuchadorRonda.cpp
@@ -21,31 +21,31 @@ void EscuchadorRonda::casoSocketCerrado(){
 }
 
 
-bool EscuchadorRonda::bloquesValidos(bloque_t bloques[MAX_SORPRESAS], int tope){
+bool EscuchadorRonda::bloquesValidos(entidad_t bloques[MAX_SORPRESAS], int tope){
 	for(int i = 0; i < tope; i++){
-		if(bloques[i].numeroRecorteX > ESTADOS_BLOQUE ||
-		   bloques[i].numeroRecorteY > COLORES_BLOQUES_POSIBLES){
+		if(bloques[i].recorteX > ESTADOS_BLOQUE ||
+		   bloques[i].recorteY > COLORES_BLOQUES_POSIBLES){
 			return false;
 		}
 	}
 	return true;
 }
 
-bool EscuchadorRonda::monedasValidas(moneda_t monedas[MAX_MONEDAS], int tope){
+bool EscuchadorRonda::monedasValidas(entidad_t monedas[MAX_MONEDAS], int tope){
 	for(int i = 0; i < tope; i++){
-		if(monedas[i].numeroRecorte > ESTADOS_MONEDA){
+		if(monedas[i].recorteX > ESTADOS_MONEDA){
 			return false;
 		}
 	}
 	return true;
 }
 
-bool EscuchadorRonda::enemigosValidos(enemigo_t enemigos[MAX_ENEMIGOS], int tope){
+bool EscuchadorRonda::enemigosValidos(entidad_t enemigos[MAX_ENEMIGOS], int tope){
 	for(int i = 0; i < tope; i++){
-		enemigo_t enemigo = enemigos[i];
-		if((enemigo.tipoEnemigo != TIPO_GOOMBA && enemigo.tipoEnemigo != TIPO_KOOPA)||
-			((enemigo.tipoEnemigo == TIPO_GOOMBA && (enemigo.numeroRecorteX > ESTADOS_GOOMBA || enemigo.numeroRecorteY > COLORES_GOOMBA_POSIBLES)) ||
-			(enemigo.tipoEnemigo == TIPO_KOOPA && (enemigo.numeroRecorteX > ESTADOS_KOOPA || enemigo.numeroRecorteY > COLORES_KOOPA_POSIBLES)))){
+        entidad_t enemigo = enemigos[i];
+		if((enemigo.tipo != TIPO_GOOMBA && enemigo.tipo != TIPO_KOOPA)||
+			((enemigo.tipo == TIPO_GOOMBA && (enemigo.recorteX > ESTADOS_GOOMBA || enemigo.recorteY > COLORES_GOOMBA_POSIBLES)) ||
+			(enemigo.tipo == TIPO_KOOPA && (enemigo.recorteX > ESTADOS_KOOPA || enemigo.recorteY > COLORES_KOOPA_POSIBLES)))){
 			return false;
 		}
 	}
diff --git a/src/Client/Escuchadores/EscuchadorRonda.hpp b/src/Client/Escuchadores/EscuchadorRonda.hpp
index 93f53a8f..794f9b3d 100644
--- a/src/Client/Escuchadores/EscuchadorRonda.hpp
+++ b/src/Client/Escuchadores/EscuchadorRonda.hpp
@@ -15,12 +15,12 @@ class EscuchadorRonda: public Escuchador{
 		void casoSocketCerrado()override;
 		void casoExitoso()override;
 
-		static bool bloquesValidos(bloque_t bloques[MAX_SORPRESAS], int tope);
-		static bool monedasValidas(moneda_t monedas[MAX_MONEDAS], int tope);
-		static bool enemigosValidos(enemigo_t enemigos[MAX_ENEMIGOS], int tope);
-
-		bool recibioMensajeValido();
 	private:
+        static bool bloquesValidos(entidad_t bloques[MAX_SORPRESAS], int tope);
+        static bool monedasValidas(entidad_t monedas[MAX_MONEDAS], int tope);
+        static bool enemigosValidos(entidad_t enemigos[MAX_ENEMIGOS], int tope);
+
+        bool recibioMensajeValido();
 		Cliente* cliente;
 		info_ronda_t info_ronda{};
 		string error;
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.cpp b/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.cpp
index e170da97..719c813a 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.cpp
@@ -16,12 +16,12 @@ int Bloque::normalizarCoordenadaIngresada(int coordenada) {
     return (coordenada/40)*40;
 }
 
-bloque_t Bloque::serializar() {
-    bloque_t bloqueSerializado = {0, 0, 0, 0};
-    bloqueSerializado.posX = posicion.obtenerPosX();
-    bloqueSerializado.posY = posicion.obtenerPosY();
-    bloqueSerializado.numeroRecorteX = spriteBloque->obtenerEstadoActual();
-    bloqueSerializado.numeroRecorteY = tipoBloque;
+entidad_t Bloque::serializar() {
+    entidad_t bloqueSerializado = {0, 0, 0, 0,0,false};
+    bloqueSerializado.x = posicion.obtenerPosX();
+    bloqueSerializado.y = posicion.obtenerPosY();
+    bloqueSerializado.recorteX = spriteBloque->obtenerEstadoActual();
+    bloqueSerializado.recorteY = tipoBloque;
     return bloqueSerializado;
 }
 
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.hpp b/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.hpp
index d34ef557..cd4acb6a 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/Bloque.hpp
@@ -23,7 +23,7 @@ class Bloque : public Colisionable{
 		int obtenerPosicionY();
 
         virtual ObjetoSorpresa* colisionaronAbajo();
-        virtual bloque_t serializar();
+        virtual entidad_t serializar();
         string obtenerColisionID() override = 0;
         rectangulo_t obtenerRectangulo() override;
         bool debeColisionar() override;
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.cpp b/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.cpp
index 52364077..1f9845b7 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.cpp
@@ -39,10 +39,13 @@ SDL_Rect Tuberia::obtenerDimensiones() {
     return dimensiones;
 }
 
-tuberia_t Tuberia::serializar(){
-    unsigned short x = posicion.obtenerPosX();
-    unsigned short y = posicion.obtenerPosY();
-    return {x, y, color, tipo};
+entidad_t Tuberia::serializar(){
+    entidad_t tuberiaSerializada = {0,0,0,0,0,false};
+    tuberiaSerializada.x = posicion.obtenerPosX();
+    tuberiaSerializada.y = posicion.obtenerPosY();
+    tuberiaSerializada.recorteX = tipo;
+    tuberiaSerializada.recorteY = color;
+    return tuberiaSerializada;
 }
 
 void Tuberia::elevar(int y) {
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.hpp b/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.hpp
index d4fa6895..d5442a67 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/Tuberia.hpp
@@ -14,7 +14,7 @@ class Tuberia{
         unsigned short obtenerPosicionX() const;
         void elevar(int y);
         SDL_Rect obtenerDimensiones();
-        tuberia_t serializar();
+        entidad_t serializar();
         list<PiezaDeTuberia*> obtenerPiezas();
     private:
         void crearColisionables(int x, int tipo);
diff --git a/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.cpp b/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.cpp
index 3d2a548d..d1cda210 100644
--- a/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.cpp
@@ -39,14 +39,14 @@ void Enemigo::cambiarOrientacion() {
     spriteEnemigo->espejar();
 }
 
-enemigo_t Enemigo::serializarEnemigo(int tipo) {
-    enemigo_t enemigoSerializado;
-    enemigoSerializado.posX = this->obtenerPosicionX();
-    enemigoSerializado.posY = this->obtenerPosicionY();
-    enemigoSerializado.numeroRecorteX = spriteEnemigo->obtenerEstadoActual();
-    enemigoSerializado.numeroRecorteY = tipoColor;
-    enemigoSerializado.tipoEnemigo = tipo;
-    enemigoSerializado.espejar = spriteEnemigo->debeEspejarse();
+entidad_t Enemigo::serializarEnemigo(int tipo) {
+    entidad_t enemigoSerializado = {0,0,0,0,0,false};;
+    enemigoSerializado.x = this->obtenerPosicionX();
+    enemigoSerializado.y = this->obtenerPosicionY();
+    enemigoSerializado.recorteX = spriteEnemigo->obtenerEstadoActual();
+    enemigoSerializado.recorteY = tipoColor;
+    enemigoSerializado.tipo = tipo;
+    enemigoSerializado.espejado = spriteEnemigo->debeEspejarse();
     return enemigoSerializado;
 }
 
diff --git a/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.hpp b/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.hpp
index a003720a..bd50dd22 100644
--- a/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Enemigos/Enemigo.hpp
@@ -16,7 +16,7 @@ class Enemigo : public Colisionable{
 
 	public:
         ~Enemigo() override = default;
-        virtual enemigo_t serializar() =0 ;
+        virtual entidad_t serializar() =0 ;
         void morir(void* ptr = nullptr);
 		int obtenerPosicionX();
 		int obtenerPosicionY();
@@ -36,7 +36,7 @@ class Enemigo : public Colisionable{
         void empujarEnX(rectangulo_t rectanguloBloque, int direccion);
         void inicializarMapasDeColision() override;
         void cambiarOrientacion();
-        enemigo_t serializarEnemigo(int tipo);
+        entidad_t serializarEnemigo(int tipo);
 		PosicionMovil posicionActual = PosicionMovil(0,0);
         SpriteEnemigo* spriteEnemigo{};
         MovimientoEnemigo movimientoEnemigo = MovimientoEnemigo(VELOCIDAD_EXTRA_DEFAULT);
diff --git a/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.cpp b/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.cpp
index cc40f310..faa2a60f 100644
--- a/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.cpp
@@ -11,7 +11,7 @@ Goomba::Goomba(int tipoColor){
     posicionActual = PosicionMovil(DEFAULT, DEFAULT);
 }
 
-enemigo_t Goomba::serializar() {
+entidad_t Goomba::serializar() {
     return serializarEnemigo(TIPO_GOOMBA);
 }
 
diff --git a/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.hpp b/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.hpp
index b3457f37..3d7d0770 100644
--- a/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Enemigos/Goomba.hpp
@@ -6,7 +6,7 @@
 class Goomba : public Enemigo{
 	public:
 		explicit Goomba(int tipoColor);
-		enemigo_t serializar() override;
+        entidad_t serializar() override;
 		~Goomba() override;
         string obtenerColisionID() override;
 };
diff --git a/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.cpp b/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.cpp
index fe543adc..350f9e98 100644
--- a/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.cpp
@@ -18,7 +18,7 @@ Koopa::~Koopa() {
     delete spriteEnemigo;
 }
 
-enemigo_t Koopa::serializar() {
+entidad_t Koopa::serializar() {
     return serializarEnemigo(TIPO_KOOPA);
 }
 
diff --git a/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.hpp b/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.hpp
index dfccf8e2..e4780471 100644
--- a/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Enemigos/Koopa.hpp
@@ -7,7 +7,7 @@ class Koopa : public Enemigo{
 	public:
 		explicit Koopa(int tipoColor);
 		~Koopa() override;
-		enemigo_t serializar() override;
+        entidad_t serializar() override;
         string obtenerColisionID() override;
 };
 
diff --git a/src/Server/Modelo/Juego/Nivel/Moneda.cpp b/src/Server/Modelo/Juego/Nivel/Moneda.cpp
index 4fea451c..e7d42198 100644
--- a/src/Server/Modelo/Juego/Nivel/Moneda.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Moneda.cpp
@@ -13,12 +13,11 @@ void Moneda::actualizar() {
     this->sprite.actualizarSprite();
 }
 
-moneda_t Moneda::serializar() {
-    moneda_t monedaSerializada;
-
-    monedaSerializada.posX = posicion.obtenerPosX();
-    monedaSerializada.posY = posicion.obtenerPosY();
-    monedaSerializada.numeroRecorte = sprite.obtenerEstadoActual();
+entidad_t Moneda::serializar() {
+    entidad_t monedaSerializada = {0,0,0,0,0,false};
+    monedaSerializada.x = posicion.obtenerPosX();
+    monedaSerializada.y = posicion.obtenerPosY();
+    monedaSerializada.recorteX = sprite.obtenerEstadoActual();
     return monedaSerializada;
 }
 
diff --git a/src/Server/Modelo/Juego/Nivel/Moneda.hpp b/src/Server/Modelo/Juego/Nivel/Moneda.hpp
index 65968d1f..ca82af6d 100644
--- a/src/Server/Modelo/Juego/Nivel/Moneda.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Moneda.hpp
@@ -13,7 +13,7 @@ class Moneda : public Colisionable{
         Moneda(int coordenadaX, int coordenadaY);
         ~Moneda() override = default;
         void actualizar();
-        moneda_t serializar();
+        entidad_t serializar();
         int obtenerPosicionX();
         int obtenerPosicionY();
         void elevar(int y);
diff --git a/src/Server/Modelo/Juego/Nivel/Nivel.cpp b/src/Server/Modelo/Juego/Nivel/Nivel.cpp
index 596a45ea..22bfacd3 100644
--- a/src/Server/Modelo/Juego/Nivel/Nivel.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Nivel.cpp
@@ -15,7 +15,7 @@ Nivel::Nivel(int mundo, string direccionFondo, int tiempo, int cantidadMonedas,
     this->cantidadMonedas = cantidadMonedas;
     this->puntoBanderaFin = ANCHO_FONDO* (float) puntoBanderaFin /100;
     this->contador = Contador(tiempo, SEGUNDOS);
-    this->meta = Meta(this->puntoBanderaFin);
+    this->meta = Meta((int)this->puntoBanderaFin);
     this->podio = new Podio();
 }
 
@@ -48,7 +48,7 @@ void Nivel::actualizarObjetosFugaces() {
 }
 
 
-void Nivel::actualizarModelo(map<int, Mario*> jugadores, rectangulo_t rectanguloEscena){
+void Nivel::actualizarModelo(const map<int, Mario*>& jugadores, rectangulo_t rectanguloEscena){
     actualizarPosicionesEnemigos(rectanguloEscena);
 
     imponerPosicionDeReaparicion(jugadores, rectanguloEscena);
@@ -65,7 +65,7 @@ void Nivel::actualizarModelo(map<int, Mario*> jugadores, rectangulo_t rectangulo
     resolverGanadores(jugadores);
 }
 
-void Nivel::resolverColisiones(map<int, Mario *> jugadores) {
+void Nivel::resolverColisiones(const map<int, Mario *>& jugadores) {
     list<Colisionable*> plataformasPiso = piso.obtenerPiso();
 
     //todo: mejorar esto:
@@ -98,7 +98,7 @@ void Nivel::resolverColisiones(map<int, Mario *> jugadores) {
     }
 }
 
-void Nivel::resolverGanadores(map<int, Mario *> mapaJugadores) {
+void Nivel::resolverGanadores(const map<int, Mario *>& mapaJugadores) {
     for(auto const& parClaveJugador:mapaJugadores)
         meta.agregarSiPasoLaMeta(parClaveJugador.second);
 }
@@ -315,7 +315,7 @@ void Nivel::completarInformacionRonda(info_ronda_t *ptrInfoRonda, bool (* deboAg
 
     int numeroBloque = 0;
     for(auto const& bloque: plataformas){
-        bloque_t bloqueSerializado = bloque->serializar();
+        entidad_t bloqueSerializado = bloque->serializar();
         if(bloque->cambioElSprite() && deboAgregarlo(contexto, bloque->obtenerRectangulo()) && numeroBloque < MAX_SORPRESAS){
             ptrInfoRonda->bloques[numeroBloque] = bloqueSerializado;
             numeroBloque++;
@@ -325,8 +325,7 @@ void Nivel::completarInformacionRonda(info_ronda_t *ptrInfoRonda, bool (* deboAg
 
     int numeroEnemigo = 0;
     for(auto const& enemigo: enemigos){
-        if(deboAgregarlo(contexto, enemigo->obtenerRectangulo()) &&
-           numeroEnemigo<MAX_ENEMIGOS){
+        if(deboAgregarlo(contexto, enemigo->obtenerRectangulo()) && numeroEnemigo<MAX_ENEMIGOS){
             ptrInfoRonda->enemigos[numeroEnemigo] = enemigo->serializar();
             numeroEnemigo++;
         }
@@ -335,8 +334,7 @@ void Nivel::completarInformacionRonda(info_ronda_t *ptrInfoRonda, bool (* deboAg
 
     int numeroMoneda = 0;
     for(auto const& moneda: monedas){
-        if(deboAgregarlo(contexto, moneda->obtenerRectangulo()) &&
-           numeroMoneda<MAX_MONEDAS){
+        if(deboAgregarlo(contexto, moneda->obtenerRectangulo()) && numeroMoneda<MAX_MONEDAS){
             ptrInfoRonda->monedas[numeroMoneda] = moneda->serializar();
             numeroMoneda++;
         }
@@ -345,8 +343,7 @@ void Nivel::completarInformacionRonda(info_ronda_t *ptrInfoRonda, bool (* deboAg
     ptrInfoRonda->topeMonedas = numeroMoneda;
     int numeroEfecto = 0;
     for(auto const& disparo : objetosFugaces){
-        if(deboAgregarlo(contexto, disparo->obtenerRectangulo()) &&
-            numeroEfecto<MAX_EFECTOS){
+        if(deboAgregarlo(contexto, disparo->obtenerRectangulo()) && numeroEfecto<MAX_EFECTOS){
             ptrInfoRonda->efectos[numeroEfecto] = disparo->serializar();
             numeroEfecto++;
         }
@@ -358,7 +355,7 @@ void Nivel::agregarPozo(int posicionX, int tipoPozo, int fondo) {
     piso.agregarPozo(posicionX, tipoPozo, fondo);
 }
 
-void Nivel::terminar(map<int, Mario *> jugadores) {
+void Nivel::terminar(const map<int, Mario *>& jugadores) {
     meta.sumarPuntos(contador.tiempoRestante());
 
     for(auto const& parJugador:jugadores){
@@ -366,7 +363,7 @@ void Nivel::terminar(map<int, Mario *> jugadores) {
     }
 }
 
-bool Nivel::todosEnLaMeta(map<int, Mario *> jugadores) {
+bool Nivel::todosEnLaMeta(const map<int, Mario *>& jugadores) {
     return meta.todosEnLaMeta(jugadores);
 }
 
@@ -379,7 +376,7 @@ void Nivel::completarInformacionNivel(nivel_t *nivel) {
         }
     }
 
-    list<pozo_t> pozos = piso.serializar();
+    list<entidad_t> pozos = piso.serializar();
     for(auto const& pozo: pozos){
         if(nivel->topePozos<MAX_POZOS){
             nivel->pozos[nivel->topePozos] = pozo;
@@ -388,8 +385,8 @@ void Nivel::completarInformacionNivel(nivel_t *nivel) {
     }
 
     for(auto const& bloque: plataformas){
-        bloque_t  bloquesSerializado = bloque->serializar();
-        if(nivel->topeBloques<MAX_LADRILLOS && bloquesSerializado.numeroRecorteY!=SORPRESA){
+        entidad_t  bloquesSerializado = bloque->serializar();
+        if(nivel->topeBloques<MAX_LADRILLOS && bloquesSerializado.recorteY!=SORPRESA){
             nivel->bloques[nivel->topeBloques] = bloquesSerializado;
             nivel->topeBloques++;
         }
@@ -417,7 +414,7 @@ Nivel::~Nivel (){
     delete this->podio;
 }
 
-void Nivel::iniciar(map<int, Mario*> jugadores) {
+void Nivel::iniciar(const map<int, Mario*>& jugadores) {
     contador.iniciar();
     podio->recibirJugadores(jugadores);
     for(auto const& parJugador:jugadores){
@@ -478,7 +475,7 @@ void Nivel::buscarBloqueParaCaer(rectangulo_t rectanguloEscena, PosicionFija* po
 }
 
 
-void Nivel::imponerPosicionDeReaparicion(map<int, Mario*> jugadores, rectangulo_t rectanguloEscena) {
+void Nivel::imponerPosicionDeReaparicion(const map<int, Mario*>& jugadores, rectangulo_t rectanguloEscena) {
     PosicionFija posicionDeReaparicion(rectanguloEscena.x1, piso.obtenerAltura());
 
     bool hayPiso = piso.obtenerRespawn(rectanguloEscena, &posicionDeReaparicion);
diff --git a/src/Server/Modelo/Juego/Nivel/Nivel.hpp b/src/Server/Modelo/Juego/Nivel/Nivel.hpp
index 4b814503..d75d27a6 100644
--- a/src/Server/Modelo/Juego/Nivel/Nivel.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Nivel.hpp
@@ -37,15 +37,15 @@ class Nivel{
 		void agregarMoneda(Moneda* unaMoneda);
 		int obtenerMundo() const;
 		int tiempoRestante();
-		void iniciar(map<int, Mario*> jugadores);
+		void iniciar(const map<int, Mario*>& jugadores);
 
         /* Completará la información de los siguientes campos:
          * tiempoFaltante, mundo, bloques[], enemigos[], monedas[],tuberias[], y sus respectivos topes */
 		void completarInformacionRonda(info_ronda_t* ptrInfoRonda, bool (* deboAgregarlo)(void*, rectangulo_t), void* contexto);
-        void actualizarModelo(map<int, Mario*> jugadores, rectangulo_t rectanguloEscena);
-        bool todosEnLaMeta(map<int, Mario*> jugadores);
+        void actualizarModelo(const map<int, Mario*>& jugadores, rectangulo_t rectanguloEscena);
+        bool todosEnLaMeta(const map<int, Mario*>& jugadores);
 		string obtenerDireccionFondoActual();
-        void terminar(map<int, Mario*> jugadores);
+        void terminar(const map<int, Mario*>& jugadores);
         void completarInformacionNivel(nivel_t *nivel);
         void aparecerDisparo(ObjetoFugaz* disparo);
         Podio* obtenerPodio();
@@ -56,10 +56,10 @@ class Nivel{
         void actualizarPosicionesEnemigos(rectangulo_t rectangulo);
         void actualizarMonedas();
         void actualizarObjetosFugaces();
-        void resolverColisiones(map<int,Mario*> jugadores);
+        void resolverColisiones(const map<int,Mario*>& jugadores);
         bool esUnaPosicionXValidaEnemigo(int coordenadaX);
         bool esUnaPosicionValidaMoneda(int numeroPosicionX, int numeroPosicionY);
-        void resolverGanadores(map<int, Mario *> map);
+        void resolverGanadores(const map<int, Mario *>& map);
         void elevarObstaculos();
         void inicializarPosicionEnemigo();
         void inicializarPosicionMonedas();
@@ -90,7 +90,7 @@ class Nivel{
         void sacarObjetosFugaces();
         void actualizarBloques();
 
-        void imponerPosicionDeReaparicion(map<int, Mario*> jugadores, rectangulo_t rectanguloEscena);
+        void imponerPosicionDeReaparicion(const map<int, Mario*>& jugadores, rectangulo_t rectanguloEscena);
         void buscarBloqueParaCaer(rectangulo_t rectanguloEscena, PosicionFija* pos);
 };
 
diff --git a/src/Server/Modelo/Juego/Nivel/Piso/Piso.cpp b/src/Server/Modelo/Juego/Nivel/Piso/Piso.cpp
index 54a6c678..cbe7e051 100644
--- a/src/Server/Modelo/Juego/Nivel/Piso/Piso.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Piso/Piso.cpp
@@ -33,10 +33,10 @@ list<Colisionable*> Piso::obtenerPiso() {
     return plataformas;
 }
 
-list<pozo_t> Piso::serializar() {
-    list<pozo_t> pozosSerializados;
+list<entidad_t> Piso::serializar() {
+    list<entidad_t> pozosSerializados;
     for(auto pozo: pozos){
-        pozo_t pozo_serializado = pozo.serializar();
+        entidad_t pozo_serializado = pozo.serializar();
         pozosSerializados.push_back(pozo_serializado);
     }
     return pozosSerializados;
diff --git a/src/Server/Modelo/Juego/Nivel/Piso/Piso.hpp b/src/Server/Modelo/Juego/Nivel/Piso/Piso.hpp
index 859ee834..613babde 100644
--- a/src/Server/Modelo/Juego/Nivel/Piso/Piso.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Piso/Piso.hpp
@@ -14,11 +14,11 @@ class Piso {
         ~Piso();
         void agregarPozo(int posicionPozo, int tipoPozo, int fondo);
         list<Colisionable*> obtenerPiso();
-        list<pozo_t> serializar();
+        list<entidad_t> serializar();
         int obtenerAltura() const;
         bool obtenerRespawn(rectangulo_t rectangulo, Posicion* posicion);
 
-private:
+    private:
         int alto;
         list<Pozo> pozos;
         list<Colisionable*> plataformas;
diff --git a/src/Server/Modelo/Juego/Nivel/Piso/Pozo.cpp b/src/Server/Modelo/Juego/Nivel/Piso/Pozo.cpp
index 58c577a7..39e766cd 100644
--- a/src/Server/Modelo/Juego/Nivel/Piso/Pozo.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Piso/Pozo.cpp
@@ -10,6 +10,10 @@ unsigned short Pozo::obtenerPosicionX() const {
     return posicionX;
 }
 
-pozo_t Pozo::serializar(){
-    return {posicionX,fondo,tipo};
+entidad_t Pozo::serializar() const{
+    entidad_t pozoSerializado = {0,0,0,0,0,false};
+    pozoSerializado.x = posicionX;
+    pozoSerializado.recorteY = tipo; // Los tipos pinches, agua lava son de la misma imagen (recorte)
+    pozoSerializado.tipo = fondo; // Usamos el tipo para elegir el fondo del pozo?
+    return pozoSerializado;
 }
\ No newline at end of file
diff --git a/src/Server/Modelo/Juego/Nivel/Piso/Pozo.hpp b/src/Server/Modelo/Juego/Nivel/Piso/Pozo.hpp
index 7fc3b257..335eed39 100644
--- a/src/Server/Modelo/Juego/Nivel/Piso/Pozo.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Piso/Pozo.hpp
@@ -8,7 +8,7 @@ class Pozo {
     public:
         Pozo(int posicionX, int tipo, int fondo);
         unsigned short obtenerPosicionX() const;
-        pozo_t serializar();
+        entidad_t serializar() const;
 
     private:
         unsigned short posicionX;
diff --git a/src/Utils/Utils.hpp b/src/Utils/Utils.hpp
index bb945dc3..89adddff 100644
--- a/src/Utils/Utils.hpp
+++ b/src/Utils/Utils.hpp
@@ -3,10 +3,8 @@
 
 #include <string>
 #include <cstdint>
-
 using namespace std;
-/* PALABRAS RESERVADAS */
-/*
+/* PALABRAS RESERVADAS
  * V: Verificacion
  * U: Actualizacion sobre la cantidad de jugadores.
  * L: Mensaje para el log.
@@ -18,19 +16,17 @@ using namespace std;
  * N: Informacion del nivel nuevo (bloques fijos)
  */
 
-
 const int MAX_NOMBRE = 20,MAX_CONTRASENIA = 25;
 
-const int MAX_CANT_NIVELES = 10,MAX_LARGO_NOMBRE_NIVEL= 30; // Solo el nombre, nosotros concatenamos la direccion
-															// correspondiente a la carpeta en la que tiene que estar esta imagen
+// Solo el nombre, nosotros concatenamos la direccion correspondiente a la carpeta en la que tiene que estar esta imagen
+const int MAX_CANT_NIVELES = 10,MAX_LARGO_NOMBRE_NIVEL= 30;
 
 const int MAX_SORPRESAS=15,MAX_ENEMIGOS=25,MAX_MONEDAS=25,MAX_TUBERIAS = 30,MAX_POZOS = 30, MAX_LADRILLOS = 400,MAX_EFECTOS = 20;
 
 const int MAX_JUGADORES = 4;
 const int MAX_MENSAJE = 75;
 
-const int TIPO_GOOMBA = 1;
-const int TIPO_KOOPA = 2;
+const int TIPO_GOOMBA = 1,TIPO_KOOPA = 2;
 
 typedef struct rectangulo{
     int x1;
@@ -49,22 +45,6 @@ typedef struct mensaje_log{
 	char mensajeParaElLog[MAX_MENSAJE];
 }mensaje_log_t;
 
-typedef struct enemigo{
-    unsigned short posX;
-    unsigned short posY;
-	uint8_t numeroRecorteX;	// 1|2|3|4|5|6|...|
-	uint8_t numeroRecorteY;	// 1: marrón, 2: azul, 3: blanco , 4: fuego
-	uint8_t tipoEnemigo;	// 1 GOOMBA - 2 KOOPA
-	bool espejar;
-}enemigo_t;
-
-typedef struct bloque{
-    int posX;
-    int posY;
-	uint8_t numeroRecorteX;
-	uint8_t numeroRecorteY;
-}bloque_t;
-
 typedef struct mario{
 	uint8_t idImagen;    //1 ROJO - 2 VERDE - 3 VIOLETA - 4 CELESTE
 	uint8_t modificador; // 0 Nada - 1 Fuego
@@ -74,31 +54,12 @@ typedef struct mario{
     uint8_t vidas;		  //el recorte correspondiente es el gris
 }mario_t;
 
-typedef struct moneda{
-	unsigned short posX;
-	unsigned short posY;
-	uint8_t numeroRecorte;
-}moneda_t;
-
 typedef struct jugador{
 	char nombreJugador[MAX_NOMBRE];
 	unsigned short puntos;
 	mario_t mario;
 }jugador_t;
 
-typedef struct tuberia {
-    unsigned short posX;
-    unsigned short posY;
-    uint8_t color;
-    uint8_t tipo;
-}tuberia_t;
-
-typedef struct pozo {
-    unsigned short posX;
-    uint8_t fondo;
-    uint8_t tipo;
-}pozo_t;
-
 typedef struct podio {
     unsigned short puntosNivel[MAX_JUGADORES];
     unsigned short cantidadJugadores;
@@ -117,6 +78,15 @@ typedef struct efecto{
     uint8_t tipoDeEfecto;
 }efecto_t;
 
+typedef struct entidad {
+    unsigned short x;
+    unsigned short y;
+    uint8_t tipo; // Cambio de imagen, ejemplo Goomba-Koopa o que se toma algo de otra imagen, ej. El fondo de los pozos
+    uint8_t recorteX;
+    uint8_t recorteY;
+    bool espejado;
+} entidad_t;
+
 #define CREDENCIAL 'C'
 typedef struct credencial{
 	char nombre[MAX_NOMBRE];
@@ -181,22 +151,22 @@ typedef struct ronda{
 	bool perdieron;
 	unsigned short posXCamara;
 	unsigned short tiempoFaltante;
-	bloque_t bloques[MAX_SORPRESAS];
-	enemigo_t enemigos[MAX_ENEMIGOS];
-	moneda_t monedas[MAX_MONEDAS];
-	jugador_t jugadores[MAX_JUGADORES];
-	efecto_t efectos[MAX_EFECTOS];
+    entidad_t bloques[MAX_SORPRESAS];
+    entidad_t enemigos[MAX_ENEMIGOS];
+    entidad_t monedas[MAX_MONEDAS];
+    efecto_t efectos[MAX_EFECTOS];
+    jugador_t jugadores[MAX_JUGADORES];
 }info_ronda_t;
 
 #define NIVEL 'N'
 typedef struct nivel{
     uint8_t mundo;
-    short topeBloques;
+    unsigned short topeBloques;
     uint8_t topePozos;
     uint8_t topeTuberias;
-    bloque_t bloques[MAX_LADRILLOS];
-    tuberia_t tuberias[MAX_TUBERIAS];
-    pozo_t pozos[MAX_POZOS];
+    entidad_t bloques[MAX_LADRILLOS];
+    entidad_t tuberias[MAX_TUBERIAS];
+    entidad_t pozos[MAX_POZOS];
     podio_t podio;
     podio_t podioPuntosAcumulados;
 }nivel_t;

From 3fd2104265aace4ae8b1e3b9487ba69ebfb53a00 Mon Sep 17 00:00:00 2001
From: Bruno Grassano <grassanobruno@gmail.com>
Date: Tue, 26 Jan 2021 15:02:21 -0300
Subject: [PATCH 2/7] Ref: efecto_t ahora es tambien entidad_t

---
 .../DibujadoresJuego/DibujadorJuego.cpp          | 16 ++++++++--------
 src/Client/App/JuegoCliente/JuegoCliente.cpp     | 10 +++-------
 src/Client/App/JuegoCliente/JuegoCliente.hpp     |  4 ++--
 .../Bloques/ObjetosSorpresa/FlorDeFuego.cpp      | 11 +++++++----
 .../Bloques/ObjetosSorpresa/FlorDeFuego.hpp      |  2 +-
 .../Bloques/ObjetosSorpresa/MonedaSorpresa.cpp   | 12 +++++++-----
 .../Bloques/ObjetosSorpresa/MonedaSorpresa.hpp   |  2 +-
 .../Bloques/ObjetosSorpresa/ObjetoSorpresa.hpp   |  2 +-
 .../Bloques/ObjetosSorpresa/SinSorpresa.hpp      |  2 +-
 src/Server/Modelo/Juego/Objetos/BolaDeFuego.cpp  | 11 +++++++----
 src/Server/Modelo/Juego/Objetos/BolaDeFuego.hpp  |  2 +-
 src/Server/Modelo/Juego/Objetos/Chispa.cpp       | 11 +++++++----
 src/Server/Modelo/Juego/Objetos/Chispa.hpp       |  2 +-
 src/Server/Modelo/Juego/Objetos/Nada.cpp         |  4 ++--
 src/Server/Modelo/Juego/Objetos/Nada.hpp         |  2 +-
 src/Server/Modelo/Juego/Objetos/ObjetoFugaz.hpp  |  2 +-
 src/Utils/Utils.hpp                              |  8 +-------
 17 files changed, 52 insertions(+), 51 deletions(-)

diff --git a/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp b/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
index 1e89902d..45e5f1aa 100644
--- a/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
+++ b/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
@@ -186,18 +186,18 @@ void DibujadorJuego::dibujarMarios(){
 }
 
 void DibujadorJuego::dibujarEfectos() {
-    list<efecto_t> efectos = juegoCliente->obtenerEfectos();
+    list<entidad_t> efectos = juegoCliente->obtenerEfectos();
     for (auto const& efecto : efectos) {
-        if(efecto.tipoDeEfecto == BOLA_DE_FUEGO || efecto.tipoDeEfecto == CHISPA || efecto.tipoDeEfecto == FLOR || efecto.tipoDeEfecto == MONEDA_FLOTANTE) {
-            SDL_Texture* textura = cargadorTexturas->obtenerTextura(clavesEfectos[efecto.tipoDeEfecto]);
-            Recorte* recorteEfecto = recortes[efecto.tipoDeEfecto];
-            SDL_Rect rectanguloRecorte = recorteEfecto->obtenerRecorte(efecto.numeroRecorte);
-            SDL_Rect rectanguloEfecto = {efecto.posX - rectanguloCamara.x,
-                                         alto_pantalla - efecto.posY -
+        if(efecto.tipo == BOLA_DE_FUEGO || efecto.tipo == CHISPA || efecto.tipo == FLOR || efecto.tipo == MONEDA_FLOTANTE) {
+            SDL_Texture* textura = cargadorTexturas->obtenerTextura(clavesEfectos[efecto.tipo]);
+            Recorte* recorteEfecto = recortes[efecto.tipo];
+            SDL_Rect rectanguloRecorte = recorteEfecto->obtenerRecorte(efecto.recorteX);
+            SDL_Rect rectanguloEfecto = {efecto.x - rectanguloCamara.x,
+                                         alto_pantalla - efecto.y -
                                                  recorteEfecto->obtenerAlturaParaDibujarImagen(0),
                                          recorteEfecto->obtenerAnchuraParaDibujarImagen(0),
                                          recorteEfecto->obtenerAlturaParaDibujarImagen(0)};
-            SDL_RendererFlip flip = recorteEfecto->direccion(efecto.numeroRecorte) == DERECHA?SDL_FLIP_NONE:SDL_FLIP_HORIZONTAL;
+            SDL_RendererFlip flip = recorteEfecto->direccion(efecto.recorteX) == DERECHA?SDL_FLIP_NONE:SDL_FLIP_HORIZONTAL; // todo usar el espejado
             SDL_RenderCopyEx(renderizador, textura, &rectanguloRecorte, &rectanguloEfecto, 0, nullptr, flip);
         }
     }
diff --git a/src/Client/App/JuegoCliente/JuegoCliente.cpp b/src/Client/App/JuegoCliente/JuegoCliente.cpp
index c32d3716..7ab37f2c 100644
--- a/src/Client/App/JuegoCliente/JuegoCliente.cpp
+++ b/src/Client/App/JuegoCliente/JuegoCliente.cpp
@@ -88,18 +88,14 @@ void JuegoCliente::actualizar(){
 	ganaron = ronda.ganaron;
 	perdieron = ronda.perdieron;
 
-	jugadores.clear();
-	efectos.clear();
-
 	cargarLista(&bloques,ronda.bloques,ronda.topeBloques);
     cargarLista(&enemigos,ronda.enemigos,ronda.topeEnemigos);
     cargarLista(&monedas,ronda.monedas,ronda.topeMonedas);
+    cargarLista(&efectos,ronda.efectos,ronda.topeEfectos);
+    jugadores.clear();
 	for(int i=0;i<cantidadJugadores;i++){
 		jugadores[i]=ronda.jugadores[i];
 	}
-    for(int i=0;i<ronda.topeEfectos;i++){
-        efectos.push_front(ronda.efectos[i]);
-    }
 
     list<entidad_t> ladrillosASacar;
     list<entidad_t> ladrillosNuevos;
@@ -186,7 +182,7 @@ list<entidad_t> JuegoCliente::obtenerTuberias() {
     return tuberiasAMostrar;
 }
 
-list<efecto_t> JuegoCliente::obtenerEfectos() {
+list<entidad_t> JuegoCliente::obtenerEfectos() {
     return efectos;
 }
 
diff --git a/src/Client/App/JuegoCliente/JuegoCliente.hpp b/src/Client/App/JuegoCliente/JuegoCliente.hpp
index 452ec92b..9451166b 100644
--- a/src/Client/App/JuegoCliente/JuegoCliente.hpp
+++ b/src/Client/App/JuegoCliente/JuegoCliente.hpp
@@ -24,7 +24,7 @@ class JuegoCliente{
 		list<entidad_t> obtenerBloques();
 		list<entidad_t> obtenerMonedas();
         list<entidad_t> obtenerTuberias();
-        list<efecto_t> obtenerEfectos();
+        list<entidad_t> obtenerEfectos();
         list<entidad_t> obtenerPozos();
         SDL_Rect rectanguloCamara{};
 		int obtenerTiempoFaltante() const;
@@ -49,7 +49,7 @@ class JuegoCliente{
 		list<entidad_t> enemigos;
 		list<entidad_t> monedas;
         list<entidad_t> tuberias;
-        list<efecto_t> efectos;
+        list<entidad_t> efectos;
         vector<podio_t> podios;
         podio_t podioPuntosTotales{};
 		int cantidadJugadores;
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.cpp b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.cpp
index 94e974a2..e401bdae 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.cpp
@@ -16,10 +16,13 @@ FlorDeFuego::FlorDeFuego(int posX, int posY) {
 
 void FlorDeFuego::usarse(Mario *mario){}
 
-efecto_t FlorDeFuego::serializar() {
-    unsigned short x = posicionFija.obtenerPosX();
-    unsigned short y = posicionFija.obtenerPosY();
-    return {x,y, color,FLOR};
+entidad_t FlorDeFuego::serializar() {
+    entidad_t florSerializada = {0,0,0,0,0,false};
+    florSerializada.x = posicionFija.obtenerPosX();
+    florSerializada.y = posicionFija.obtenerPosY();
+    florSerializada.recorteX = color;
+    florSerializada.tipo = FLOR;
+    return florSerializada;
 }
 
 void FlorDeFuego::actualizar() {}
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.hpp b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.hpp
index 9e4442ee..22670e76 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/FlorDeFuego.hpp
@@ -12,7 +12,7 @@ class FlorDeFuego : public ObjetoSorpresa{
     public:
         FlorDeFuego(int posicionBloque, int altoBloque);
         void usarse(Mario* mario)override;
-        efecto_t serializar() override;
+        entidad_t serializar() override;
         void actualizar() override;
         int obtenerPosicionX() override;
         int tipoDeEfecto() override;
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.cpp b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.cpp
index 73713d8f..da5c5248 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.cpp
@@ -23,11 +23,13 @@ void MonedaSorpresa::usarse(Mario *mario) {
     mario->agregarMoneda();
 }
 
-efecto_t MonedaSorpresa::serializar() {
-    unsigned short x = posicion.obtenerPosX();
-    unsigned short y = posicion.obtenerPosY();
-    uint8_t recorte = sprite.obtenerEstadoActual();
-    return {x, y, recorte, MONEDA_FLOTANTE};
+entidad_t MonedaSorpresa::serializar() {
+    entidad_t monedaSorpresaSerializada = {0,0,0,0,0,false};
+    monedaSorpresaSerializada.x = posicion.obtenerPosX();
+    monedaSorpresaSerializada.y = posicion.obtenerPosY();
+    monedaSorpresaSerializada.recorteX = sprite.obtenerEstadoActual();
+    monedaSorpresaSerializada.tipo = MONEDA_FLOTANTE;
+    return monedaSorpresaSerializada;
 }
 
 void MonedaSorpresa::actualizar() {
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.hpp b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.hpp
index 002f11ed..177f77a6 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/MonedaSorpresa.hpp
@@ -12,7 +12,7 @@ class MonedaSorpresa : public ObjetoSorpresa{
     public:
         explicit MonedaSorpresa(Posicion* posicionInicial);
         void usarse(Mario* mario)override;
-        efecto_t serializar() override;
+        entidad_t serializar() override;
         void actualizar() override;
         int obtenerPosicionX() override;
         int tipoDeEfecto() override;
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/ObjetoSorpresa.hpp b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/ObjetoSorpresa.hpp
index 7a60d692..33edfe9b 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/ObjetoSorpresa.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/ObjetoSorpresa.hpp
@@ -12,7 +12,7 @@ class ObjetoSorpresa : public ObjetoFugaz{
         virtual void usarse(Mario* mario) {};
 
         bool debeDesaparecer() override;
-        efecto_t serializar() override = 0;
+        entidad_t serializar() override = 0;
         void actualizar() override = 0;
         int obtenerPosicionX() override = 0;
         int tipoDeEfecto() override = 0;
diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/SinSorpresa.hpp b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/SinSorpresa.hpp
index 6a7d749b..1bdd2ae1 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/SinSorpresa.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/ObjetosSorpresa/SinSorpresa.hpp
@@ -9,7 +9,7 @@ class SinSorpresa : public ObjetoSorpresa{
         SinSorpresa() {
             _debeDesaparecer = true;
         }
-        efecto_t serializar() override {return {0, 0, 0, 0};}
+        entidad_t serializar() override {return {0, 0, 0, 0,0,false};}
         void actualizar() override {}
         int obtenerPosicionX() override {return 0;}
         string obtenerColisionID() override {return  COLISION_ID_NADA;}
diff --git a/src/Server/Modelo/Juego/Objetos/BolaDeFuego.cpp b/src/Server/Modelo/Juego/Objetos/BolaDeFuego.cpp
index 4b0fb7ac..993dff41 100644
--- a/src/Server/Modelo/Juego/Objetos/BolaDeFuego.cpp
+++ b/src/Server/Modelo/Juego/Objetos/BolaDeFuego.cpp
@@ -39,10 +39,13 @@ BolaDeFuego::~BolaDeFuego() {
     delete sprite;
 }
 
-efecto_t BolaDeFuego::serializar() {
-    auto posX = (unsigned short ) posicion->obtenerPosX();
-    auto posY = (unsigned short ) posicion->obtenerPosY();
-    return {posX, posY, static_cast<uint8_t>(sprite->obtenerEstadoActual()), BOLA_DE_FUEGO};
+entidad_t BolaDeFuego::serializar() {
+    entidad_t bolaDeFuegoSerializada = {0,0,0,0,0, false};
+    bolaDeFuegoSerializada.x = posicion->obtenerPosX();
+    bolaDeFuegoSerializada.y = posicion->obtenerPosY();
+    bolaDeFuegoSerializada.recorteX = sprite->obtenerEstadoActual();
+    bolaDeFuegoSerializada.tipo = BOLA_DE_FUEGO;
+    return bolaDeFuegoSerializada;
 }
 
 int BolaDeFuego::obtenerPosicionX() {
diff --git a/src/Server/Modelo/Juego/Objetos/BolaDeFuego.hpp b/src/Server/Modelo/Juego/Objetos/BolaDeFuego.hpp
index ecfbcaba..df1ac821 100644
--- a/src/Server/Modelo/Juego/Objetos/BolaDeFuego.hpp
+++ b/src/Server/Modelo/Juego/Objetos/BolaDeFuego.hpp
@@ -16,7 +16,7 @@ class BolaDeFuego : public ObjetoFugaz{
         explicit BolaDeFuego(const PosicionFija& posicionInicial, int direccion, float velocidadDeInercia, Mario* marioQueDisparo);
 
         void actualizar() override;
-        efecto_t serializar() override;
+        entidad_t serializar() override;
         int obtenerPosicionX() override;
         bool debeDesaparecer() override;
         int tipoDeEfecto() override;
diff --git a/src/Server/Modelo/Juego/Objetos/Chispa.cpp b/src/Server/Modelo/Juego/Objetos/Chispa.cpp
index 1c310c4a..0081d354 100644
--- a/src/Server/Modelo/Juego/Objetos/Chispa.cpp
+++ b/src/Server/Modelo/Juego/Objetos/Chispa.cpp
@@ -18,10 +18,13 @@ void Chispa::actualizar() {
     sprite->actualizarSprite();
 }
 
-efecto_t Chispa::serializar() {
-    auto posX = (unsigned short ) posicion->obtenerPosX();
-    auto posY = (unsigned short ) posicion->obtenerPosY();
-    return {posX, posY, static_cast<uint8_t>(sprite->obtenerEstadoActual()), CHISPA};
+entidad_t Chispa::serializar() {
+    entidad_t chispaSerializada = {0,0,0,0,0, false};
+    chispaSerializada.x = posicion->obtenerPosX();
+    chispaSerializada.y = posicion->obtenerPosY();
+    chispaSerializada.recorteX = sprite->obtenerEstadoActual();
+    chispaSerializada.tipo = CHISPA;
+    return chispaSerializada;
 }
 
 int Chispa::obtenerPosicionX() {
diff --git a/src/Server/Modelo/Juego/Objetos/Chispa.hpp b/src/Server/Modelo/Juego/Objetos/Chispa.hpp
index 313b1d6e..815b5e72 100644
--- a/src/Server/Modelo/Juego/Objetos/Chispa.hpp
+++ b/src/Server/Modelo/Juego/Objetos/Chispa.hpp
@@ -11,7 +11,7 @@ class Chispa : public ObjetoFugaz{
     public:
         explicit Chispa(const Posicion& posicionInicial, int direccion);
         void actualizar() override;
-        efecto_t serializar() override;
+        entidad_t serializar() override;
         int obtenerPosicionX() override;
         bool debeDesaparecer() override;
         int tipoDeEfecto() override;
diff --git a/src/Server/Modelo/Juego/Objetos/Nada.cpp b/src/Server/Modelo/Juego/Objetos/Nada.cpp
index 5d45e0a4..e9d52f86 100644
--- a/src/Server/Modelo/Juego/Objetos/Nada.cpp
+++ b/src/Server/Modelo/Juego/Objetos/Nada.cpp
@@ -5,8 +5,8 @@ Nada::~Nada() = default;
 
 void Nada::actualizar() {}
 
-efecto_t Nada::serializar() {
-    return {0, 0, 0, 0};
+entidad_t Nada::serializar() {
+    return {0, 0, 0, 0,0,false};
 }
 
 int Nada::obtenerPosicionX() {
diff --git a/src/Server/Modelo/Juego/Objetos/Nada.hpp b/src/Server/Modelo/Juego/Objetos/Nada.hpp
index d9b053bc..941655aa 100644
--- a/src/Server/Modelo/Juego/Objetos/Nada.hpp
+++ b/src/Server/Modelo/Juego/Objetos/Nada.hpp
@@ -8,7 +8,7 @@ class Nada : public ObjetoFugaz{
     public:
         explicit Nada();
         void actualizar() override;
-        efecto_t serializar() override;
+        entidad_t serializar() override;
         int obtenerPosicionX() override;
         int tipoDeEfecto() override;
         ~Nada() override;
diff --git a/src/Server/Modelo/Juego/Objetos/ObjetoFugaz.hpp b/src/Server/Modelo/Juego/Objetos/ObjetoFugaz.hpp
index dc3f8f4c..204869d2 100644
--- a/src/Server/Modelo/Juego/Objetos/ObjetoFugaz.hpp
+++ b/src/Server/Modelo/Juego/Objetos/ObjetoFugaz.hpp
@@ -7,7 +7,7 @@
 class ObjetoFugaz : public Colisionable{
     public:
         virtual bool debeDesaparecer() = 0;
-        virtual efecto_t serializar() = 0;
+        virtual entidad_t serializar() = 0;
         virtual void actualizar() = 0;
         virtual int obtenerPosicionX() = 0;
         virtual int tipoDeEfecto() = 0;
diff --git a/src/Utils/Utils.hpp b/src/Utils/Utils.hpp
index 89adddff..6b54fb7d 100644
--- a/src/Utils/Utils.hpp
+++ b/src/Utils/Utils.hpp
@@ -71,12 +71,6 @@ typedef struct podio {
 #define CHISPA 2
 #define FLOR 3
 #define MONEDA_FLOTANTE 4
-typedef struct efecto{
-    unsigned short posX;
-    unsigned short posY;
-    uint8_t numeroRecorte;
-    uint8_t tipoDeEfecto;
-}efecto_t;
 
 typedef struct entidad {
     unsigned short x;
@@ -154,7 +148,7 @@ typedef struct ronda{
     entidad_t bloques[MAX_SORPRESAS];
     entidad_t enemigos[MAX_ENEMIGOS];
     entidad_t monedas[MAX_MONEDAS];
-    efecto_t efectos[MAX_EFECTOS];
+    entidad_t efectos[MAX_EFECTOS];
     jugador_t jugadores[MAX_JUGADORES];
 }info_ronda_t;
 

From 09d7aaa7e0ff7999eea6266445cb8071d4c9561e Mon Sep 17 00:00:00 2001
From: Bruno Grassano <grassanobruno@gmail.com>
Date: Tue, 26 Jan 2021 15:18:20 -0300
Subject: [PATCH 3/7] Ref: el nombre de los jugadores ya no se manda en ronda_t

---
 .../Dibujadores/DibujadoresFinales/DibujadorPuntos.cpp   | 6 +++---
 .../App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp  | 2 +-
 src/Client/App/JuegoCliente/JuegoCliente.cpp             | 4 ++--
 src/Server/Modelo/AplicacionServidor.cpp                 | 6 +++---
 src/Server/Modelo/AplicacionServidor.hpp                 | 2 +-
 src/Server/Modelo/Juego/Juego.cpp                        | 8 +++-----
 src/Server/Modelo/Juego/Juego.hpp                        | 2 +-
 src/Server/Modelo/Juego/Mario/Mario.cpp                  | 9 +++------
 src/Server/Modelo/Juego/Mario/Mario.hpp                  | 2 +-
 src/Utils/Utils.hpp                                      | 4 ++--
 10 files changed, 20 insertions(+), 25 deletions(-)

diff --git a/src/Client/App/Dibujadores/DibujadoresFinales/DibujadorPuntos.cpp b/src/Client/App/Dibujadores/DibujadoresFinales/DibujadorPuntos.cpp
index 8a35dbb0..33e8284e 100644
--- a/src/Client/App/Dibujadores/DibujadoresFinales/DibujadorPuntos.cpp
+++ b/src/Client/App/Dibujadores/DibujadoresFinales/DibujadorPuntos.cpp
@@ -180,14 +180,14 @@ void DibujadorPuntos::dibujarPuntosTotalesGameOver(JuegoCliente *juegoCliente) {
                                      ancho_puntosJugador,
                                      alto_puntosJugador};
 
-    renderizarTexto(cuadradoTituloPuntos, tituloPuntos.str().c_str(), colorDefault);
+    renderizarTexto(cuadradoTituloPuntos, tituloPuntos.str(), colorDefault);
     int indiceJugador = 0;
     for (auto const& parIdJugador : juegoCliente->obtenerJugadores()){
 
         puntosJugador.str("");
         //int id;
         string nombreJugador = parIdJugador.second.nombreJugador;
-        puntosJugador << "Puntos de "<< nombreJugador <<": " << parIdJugador.second.puntos;
+        puntosJugador << "Puntos de "<< nombreJugador <<": " << parIdJugador.second.mario.puntos;
 
         cuadradoPuntos = {ancho_pantalla/4 - ancho_puntosJugador/2,
                           alto_pantalla/2 - alto_puntosJugador/2 + desfase_puntosJugador - 100,
@@ -200,7 +200,7 @@ void DibujadorPuntos::dibujarPuntosTotalesGameOver(JuegoCliente *juegoCliente) {
             idColor = MARIO_GRIS;
         }
 
-        renderizarTexto(cuadradoPuntos, puntosJugador.str().c_str(), colores[idColor]);
+        renderizarTexto(cuadradoPuntos, puntosJugador.str(), colores[idColor]);
 
         desfase_puntosJugador +=40;
         indiceJugador++;
diff --git a/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp b/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
index 45e5f1aa..9e8b7cbb 100644
--- a/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
+++ b/src/Client/App/Dibujadores/DibujadoresJuego/DibujadorJuego.cpp
@@ -219,7 +219,7 @@ void DibujadorJuego::dibujarTexto(){
 	SDL_Texture* texturaCorazon = cargadorTexturas->obtenerTextura(CLAVE_TEXTURA_CORAZON);
 	for(auto const& parClaveJugador:jugadores){
 		textoDePuntos.str("");
-		textoDePuntos << parClaveJugador.second.nombreJugador << ": "<<parClaveJugador.second.puntos;
+		textoDePuntos << parClaveJugador.second.nombreJugador << ": "<<parClaveJugador.second.mario.puntos;
 		SDL_Rect cuadradoPuntos = { 10 + espacioX, 10, 140, 30 };
         SDL_Rect cuadradoCorazon = { 20 + espacioX, 50, 20, 20 };
 		int id = parClaveJugador.first;
diff --git a/src/Client/App/JuegoCliente/JuegoCliente.cpp b/src/Client/App/JuegoCliente/JuegoCliente.cpp
index 7ab37f2c..bf8f6182 100644
--- a/src/Client/App/JuegoCliente/JuegoCliente.cpp
+++ b/src/Client/App/JuegoCliente/JuegoCliente.cpp
@@ -92,9 +92,9 @@ void JuegoCliente::actualizar(){
     cargarLista(&enemigos,ronda.enemigos,ronda.topeEnemigos);
     cargarLista(&monedas,ronda.monedas,ronda.topeMonedas);
     cargarLista(&efectos,ronda.efectos,ronda.topeEfectos);
-    jugadores.clear();
+
 	for(int i=0;i<cantidadJugadores;i++){
-		jugadores[i]=ronda.jugadores[i];
+		jugadores[i].mario=ronda.jugadores[i];
 	}
 
     list<entidad_t> ladrillosASacar;
diff --git a/src/Server/Modelo/AplicacionServidor.cpp b/src/Server/Modelo/AplicacionServidor.cpp
index c68c9dae..2b3d58e8 100644
--- a/src/Server/Modelo/AplicacionServidor.cpp
+++ b/src/Server/Modelo/AplicacionServidor.cpp
@@ -18,9 +18,9 @@ info_partida_t AplicacionServidor::obtenerInfoPartida(map<int,string> mapaIDNomb
 	return juego->obtenerInfoPartida(mapaIDNombre, IDJugador);
 }
 
-info_ronda_t AplicacionServidor::obtenerInfoRonda(map<int,string> mapaIDNombre){
+info_ronda_t AplicacionServidor::obtenerInfoRonda() {
 	Log::getInstance()->mostrarAccion("Se prepara la informacion de la ronda para ejecutar.");
-    return juego->obtenerInfoRonda(std::move(mapaIDNombre));
+    return juego->obtenerInfoRonda();
 }
 
 nivel_t AplicacionServidor::obtenerInfoNivel(){
@@ -71,7 +71,7 @@ void AplicacionServidor::ejecutar(){
 			terminoElJuego = juego->ganaron() || juego->perdieron();
 		}
 		revisarSiMandarInfoNivel(&cantidadNivelesRestantes);
-		info_ronda_t ronda = obtenerInfoRonda(servidor->obtenerMapaJugadores());
+		info_ronda_t ronda = obtenerInfoRonda();
 		servidor->guardarRondaParaEnvio(ronda);
         enviarSonidos();
 
diff --git a/src/Server/Modelo/AplicacionServidor.hpp b/src/Server/Modelo/AplicacionServidor.hpp
index f4820628..01440bc5 100644
--- a/src/Server/Modelo/AplicacionServidor.hpp
+++ b/src/Server/Modelo/AplicacionServidor.hpp
@@ -25,7 +25,7 @@ class AplicacionServidor : public Thread{
         nivel_t obtenerInfoNivel();
 		void encolarEntradaUsuario(entrada_usuario_id_t entradaUsuario);
 		info_partida_t obtenerInfoPartida(map<int,string> mapaIDNombre, int IDJugador);
-		info_ronda_t obtenerInfoRonda(map<int,string> mapaIDNombre);
+		info_ronda_t obtenerInfoRonda();
 		void ejecutar() override;
 		void activarJugador(int idMarioConectandose);
 		bool empezoElJuego() const;
diff --git a/src/Server/Modelo/Juego/Juego.cpp b/src/Server/Modelo/Juego/Juego.cpp
index fdcd4ac3..ca8eca3d 100644
--- a/src/Server/Modelo/Juego/Juego.cpp
+++ b/src/Server/Modelo/Juego/Juego.cpp
@@ -155,7 +155,7 @@ info_partida_t Juego::obtenerInfoPartida(map<int,string> mapaIDNombre, int IDJug
 
 
     for(int i=0;i<jugadores.size();i++){
-        info_partida.jugadores[i].puntos = 0;
+        info_partida.jugadores[i].mario.puntos = 0;
         info_partida.jugadores[i].mario.idImagen = i;
         info_partida.jugadores[i].mario.posX = jugadores[i]->obtenerPosicionX();
         info_partida.jugadores[i].mario.posY = jugadores[i]->obtenerPosicionY();
@@ -174,7 +174,7 @@ info_partida_t Juego::obtenerInfoPartida(map<int,string> mapaIDNombre, int IDJug
     return info_partida;
 }
 
-info_ronda_t Juego::obtenerInfoRonda(map<int,string> mapaIDNombre) {
+info_ronda_t Juego::obtenerInfoRonda() {
     info_ronda_t info_ronda;
     memset(&info_ronda,0,sizeof(info_ronda_t));
 
@@ -182,10 +182,8 @@ info_ronda_t Juego::obtenerInfoRonda(map<int,string> mapaIDNombre) {
     info_ronda.ganaron = ganaron();
     info_ronda.perdieron = perdieron();
 
-    jugador_t jugadorSerializado;
     for(int i=0; i<jugadores.size(); i++){
-        jugadorSerializado = jugadores[i]->serializar(mapaIDNombre[i].c_str(), i);
-        info_ronda.jugadores[i] = jugadorSerializado;
+        info_ronda.jugadores[i] = jugadores[i]->serializar(i);
     }
 
     if(!niveles.empty())
diff --git a/src/Server/Modelo/Juego/Juego.hpp b/src/Server/Modelo/Juego/Juego.hpp
index 02e20925..c3b23ee0 100644
--- a/src/Server/Modelo/Juego/Juego.hpp
+++ b/src/Server/Modelo/Juego/Juego.hpp
@@ -52,7 +52,7 @@ class Juego{
 		void conectarJugador(int idMarioConectandose);
 
         info_partida_t obtenerInfoPartida(map<int,string> mapaIDNombre,int IDJugador);
-        info_ronda_t obtenerInfoRonda(map<int,string> mapaIDNombre);
+        info_ronda_t obtenerInfoRonda();
         nivel_t serializarNivel();
 
         int cantidadDeNiveles();
diff --git a/src/Server/Modelo/Juego/Mario/Mario.cpp b/src/Server/Modelo/Juego/Mario/Mario.cpp
index e12e9105..1aaa587c 100644
--- a/src/Server/Modelo/Juego/Mario/Mario.cpp
+++ b/src/Server/Modelo/Juego/Mario/Mario.cpp
@@ -110,11 +110,9 @@ void Mario::agregarMoneda(){
     puntos+=PUNTOS_POR_MONEDA;
 }
 
-jugador_t Mario::serializar(const char nombreJugador[MAX_NOMBRE], unsigned short idImagen){
-	jugador_t jugadorSerializado;
-	strcpy(jugadorSerializado.nombreJugador, nombreJugador);
-	jugadorSerializado.puntos = puntos;
+mario_t Mario::serializar(unsigned short idImagen){
 	mario_t marioSerializado;
+    marioSerializado.puntos = puntos;
 	marioSerializado.idImagen = idImagen;
 	marioSerializado.posX = posicion->obtenerPosX();
 	marioSerializado.posY = posicion->obtenerPosY();
@@ -124,8 +122,7 @@ jugador_t Mario::serializar(const char nombreJugador[MAX_NOMBRE], unsigned short
 	if(!estaConectadoElJugador){
 		marioSerializado.recorteImagen = MARIO_DESCONECTADO;
 	}
-	jugadorSerializado.mario = marioSerializado;
-	return jugadorSerializado;
+	return marioSerializado;
 }
 
 
diff --git a/src/Server/Modelo/Juego/Mario/Mario.hpp b/src/Server/Modelo/Juego/Mario/Mario.hpp
index bc8de6e7..1e98e024 100644
--- a/src/Server/Modelo/Juego/Mario/Mario.hpp
+++ b/src/Server/Modelo/Juego/Mario/Mario.hpp
@@ -46,7 +46,7 @@ class Mario: public Colisionable, public Observable{
         int obtenerNumeroJugador() const;
         ObjetoFugaz* dispararFuego();
 
-		jugador_t serializar(const char nombreJugador[MAX_NOMBRE], unsigned short idImagen);
+		mario_t serializar(unsigned short idImagen);
 		void desconectar();
 		void conectar();
 		void serArrastrado(int corrimiento);
diff --git a/src/Utils/Utils.hpp b/src/Utils/Utils.hpp
index 6b54fb7d..9665aa1a 100644
--- a/src/Utils/Utils.hpp
+++ b/src/Utils/Utils.hpp
@@ -50,13 +50,13 @@ typedef struct mario{
 	uint8_t modificador; // 0 Nada - 1 Fuego
 	unsigned short posX;
 	unsigned short posY;
+    unsigned short puntos;
 	int8_t recorteImagen; // Si el recorte de la imagen viene en un valor (-1) se indica que el jugador se desconecto y
     uint8_t vidas;		  //el recorte correspondiente es el gris
 }mario_t;
 
 typedef struct jugador{
 	char nombreJugador[MAX_NOMBRE];
-	unsigned short puntos;
 	mario_t mario;
 }jugador_t;
 
@@ -149,7 +149,7 @@ typedef struct ronda{
     entidad_t enemigos[MAX_ENEMIGOS];
     entidad_t monedas[MAX_MONEDAS];
     entidad_t efectos[MAX_EFECTOS];
-    jugador_t jugadores[MAX_JUGADORES];
+    mario_t jugadores[MAX_JUGADORES];
 }info_ronda_t;
 
 #define NIVEL 'N'

From a730ed390687fe50c3480d094fc5e09cbdd7e038 Mon Sep 17 00:00:00 2001
From: Bruno Grassano <grassanobruno@gmail.com>
Date: Tue, 26 Jan 2021 15:46:27 -0300
Subject: [PATCH 4/7] Ref: emprolijo codigo

---
 src/Server/Modelo/Juego/Nivel/Nivel.cpp           | 15 ++++++---------
 src/Server/Modelo/Juego/Nivel/Nivel.hpp           |  6 +++---
 src/Server/Modelo/Juego/Nivel/Piso/Plataforma.hpp |  2 +-
 src/Server/Modelo/Juego/Nivel/Podio.hpp           |  2 +-
 4 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/Server/Modelo/Juego/Nivel/Nivel.cpp b/src/Server/Modelo/Juego/Nivel/Nivel.cpp
index 22bfacd3..3384f33e 100644
--- a/src/Server/Modelo/Juego/Nivel/Nivel.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Nivel.cpp
@@ -9,14 +9,11 @@ const int TAMANIO_BLOQUE = 40;
 const int TAMANIO_ENEMIGO = 40;
 
 Nivel::Nivel(int mundo, string direccionFondo, int tiempo, int cantidadMonedas, int puntoBanderaFin, int altoPiso)
-      : piso(altoPiso){
+      : piso(altoPiso), meta(ANCHO_FONDO* (float) puntoBanderaFin /100),contador(tiempo, SEGUNDOS){
     this->mundo = mundo;
     this->direccionFondo = std::move(direccionFondo);
     this->cantidadMonedas = cantidadMonedas;
     this->puntoBanderaFin = ANCHO_FONDO* (float) puntoBanderaFin /100;
-    this->contador = Contador(tiempo, SEGUNDOS);
-    this->meta = Meta((int)this->puntoBanderaFin);
-    this->podio = new Podio();
 }
 
 void Nivel::actualizarPosicionesEnemigos(rectangulo_t rectangulo) {
@@ -359,7 +356,7 @@ void Nivel::terminar(const map<int, Mario *>& jugadores) {
     meta.sumarPuntos(contador.tiempoRestante());
 
     for(auto const& parJugador:jugadores){
-        parJugador.second->eliminar(podio);
+        parJugador.second->eliminar(&podio);
     }
 }
 
@@ -411,19 +408,19 @@ Nivel::~Nivel (){
     plataformas.clear();
     enemigos.clear();
     monedas.clear();
-    delete this->podio;
+
 }
 
 void Nivel::iniciar(const map<int, Mario*>& jugadores) {
     contador.iniciar();
-    podio->recibirJugadores(jugadores);
+    podio.recibirJugadores(jugadores);
     for(auto const& parJugador:jugadores){
-        parJugador.second->agregar(podio);
+        parJugador.second->agregar(&podio);
     }
 }
 
 Podio* Nivel::obtenerPodio(){
-    return this->podio;
+    return &podio;
 }
 
 int Nivel::tiempoRestante() {
diff --git a/src/Server/Modelo/Juego/Nivel/Nivel.hpp b/src/Server/Modelo/Juego/Nivel/Nivel.hpp
index d75d27a6..dcdc9dd5 100644
--- a/src/Server/Modelo/Juego/Nivel/Nivel.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Nivel.hpp
@@ -78,9 +78,9 @@ class Nivel{
         list<ObjetoFugaz*> objetosFugaces;
         Piso piso;
 
-        Meta meta = Meta(0);
-        Contador contador = Contador(0, 0);
-        Podio* podio;
+        Meta meta;
+        Contador contador;
+        Podio podio;
 
         int mundo;
         string direccionFondo;
diff --git a/src/Server/Modelo/Juego/Nivel/Piso/Plataforma.hpp b/src/Server/Modelo/Juego/Nivel/Piso/Plataforma.hpp
index 74e9e098..405ba838 100644
--- a/src/Server/Modelo/Juego/Nivel/Piso/Plataforma.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Piso/Plataforma.hpp
@@ -14,7 +14,7 @@ class Plataforma : public Colisionable{
 
     private:
         void inicializarMapasDeColision() override;
-        rectangulo_t rangoPlataforma;
+        rectangulo_t rangoPlataforma{};
 
 };
 
diff --git a/src/Server/Modelo/Juego/Nivel/Podio.hpp b/src/Server/Modelo/Juego/Nivel/Podio.hpp
index 0b37adb7..817edfe4 100644
--- a/src/Server/Modelo/Juego/Nivel/Podio.hpp
+++ b/src/Server/Modelo/Juego/Nivel/Podio.hpp
@@ -14,7 +14,7 @@ class Podio: public Observador {
         void actualizar(Observable* observable) override;
         vector<pair<Mario*, int>> getPodioNivel();
         vector<pair<Mario*, int>>  getPodioTotal();
-        ~Podio()=default;
+        ~Podio() override =default;
     private:
         vector<pair<Mario*, int>> puntajeTotal;
         vector<pair<Mario*, int>> puntajeParcial;

From 81fc00a5f281c67db771dd836b543de372915648 Mon Sep 17 00:00:00 2001
From: Bruno Grassano <grassanobruno@gmail.com>
Date: Wed, 27 Jan 2021 13:03:19 -0300
Subject: [PATCH 5/7] ref: Se eliminan conexiones perdidas durante el
 transcurso del server

-m "Antes lo haciamos al terminar el servidor solamente"
---
 .../Servidor/IntentadorIniciarModelo.cpp      | 27 ++++++++++
 .../Servidor/IntentadorIniciarModelo.hpp      | 28 +++++++++++
 src/Server/Servidor/Servidor.cpp              | 50 +++++++++----------
 src/Server/Servidor/Servidor.hpp              |  4 +-
 4 files changed, 82 insertions(+), 27 deletions(-)
 create mode 100644 src/Server/Servidor/IntentadorIniciarModelo.cpp
 create mode 100644 src/Server/Servidor/IntentadorIniciarModelo.hpp

diff --git a/src/Server/Servidor/IntentadorIniciarModelo.cpp b/src/Server/Servidor/IntentadorIniciarModelo.cpp
new file mode 100644
index 00000000..0642ebef
--- /dev/null
+++ b/src/Server/Servidor/IntentadorIniciarModelo.cpp
@@ -0,0 +1,27 @@
+#include "IntentadorIniciarModelo.hpp"
+
+IntentadorIniciarModelo::IntentadorIniciarModelo(const unsigned int cantidadConexiones,AplicacionServidor *aplicacionServidor,
+                                                 std::map<int, ConexionCliente*> *mapaClientesJugando,
+                                                 std::map<int, string> *mapaIDNombre)
+        : cantidadConexiones(cantidadConexiones) {
+    this->aplicacionServidor = aplicacionServidor;
+    this->mapaClientesJugando = mapaClientesJugando;
+    this->mapaIDNombre = mapaIDNombre;
+}
+
+void IntentadorIniciarModelo::ejecutar() {
+    info_partida_t info_partida[cantidadConexiones];
+    while(mapaIDNombre->size() < cantidadConexiones){
+        dormirHilo();
+    }
+
+    Log::getInstance()->mostrarMensajeDeInfo("Se va a iniciar el envio de informacion inicial a los jugadores.");
+
+    for(auto parIDCliente:(*mapaClientesJugando)){
+        int id = parIDCliente.first;
+        info_partida[id] = aplicacionServidor->obtenerInfoPartida(*mapaIDNombre,id);
+        parIDCliente.second->agregarMensajeAEnviar(PARTIDA,&info_partida[id]);
+    }
+
+    aplicacionServidor->iniciarJuego();
+}
diff --git a/src/Server/Servidor/IntentadorIniciarModelo.hpp b/src/Server/Servidor/IntentadorIniciarModelo.hpp
new file mode 100644
index 00000000..784056c1
--- /dev/null
+++ b/src/Server/Servidor/IntentadorIniciarModelo.hpp
@@ -0,0 +1,28 @@
+#ifndef TP_TALLER_DE_PROGRAMACION_FIUBA_INTENTADORINICIARMODELO_H
+#define TP_TALLER_DE_PROGRAMACION_FIUBA_INTENTADORINICIARMODELO_H
+
+#include <map>
+#include <string>
+
+#include "src/Server/Modelo/AplicacionServidor.hpp"
+#include "src/Utils/Thread.hpp"
+#include "ConexionCliente.hpp"
+
+
+class IntentadorIniciarModelo : public Thread{
+
+    public:
+        IntentadorIniciarModelo(unsigned int cantidadConexiones, AplicacionServidor* aplicacionServidor,
+                                std::map<int,ConexionCliente*>* mapaClientesJugando,
+                                std::map<int,std::string> *mapaIDNombre);
+        void ejecutar() override;
+
+    private:
+        AplicacionServidor* aplicacionServidor{};
+        std::map<int,ConexionCliente*>* mapaClientesJugando;
+        std::map<int,std::string> *mapaIDNombre;
+        const unsigned int cantidadConexiones;
+};
+
+
+#endif //TP_TALLER_DE_PROGRAMACION_FIUBA_INTENTADORINICIARMODELO_H
diff --git a/src/Server/Servidor/Servidor.cpp b/src/Server/Servidor/Servidor.cpp
index 76674aac..dfa38405 100644
--- a/src/Server/Servidor/Servidor.cpp
+++ b/src/Server/Servidor/Servidor.cpp
@@ -3,8 +3,9 @@
 #include <cstring>
 
 Servidor::Servidor(const ArchivoLeido& archivoLeido, const list<string>& mensajesErrorOtroArchivo, int puerto, char* ip)
-                    : aplicacionServidor(this, archivoLeido.niveles, archivoLeido.cantidadConexiones, archivoLeido.anchoVentana, archivoLeido.altoVentana)
-	                , reconectador(this){
+                    : reconectador(this),
+                      iniciadorModelo(archivoLeido.cantidadConexiones,&aplicacionServidor,&clientesJugando,&mapaIDNombre),
+                      aplicacionServidor(this, archivoLeido.niveles, archivoLeido.cantidadConexiones, archivoLeido.anchoVentana, archivoLeido.altoVentana){
     terminoJuego = false;
 	manejadorIDs = ManejadorIdentificadores();
 	log = Log::getInstance(archivoLeido.tipoLog);
@@ -44,6 +45,7 @@ void Servidor::agregarUsuarioDesconectado(ConexionCliente* conexionPerdida,int i
 	pthread_mutex_unlock(&mutex);
 
     mandarActualizacionAClientes();
+    despertarHilo();
 }
 
 void Servidor::notificarClientesDeLaDesconexion(const ConexionCliente *conexionPerdida, string &nombre) {
@@ -85,11 +87,25 @@ void Servidor::ejecutar(){
 	::empezarHilo(&aplicacionServidor,"GameLoop");
 	::empezarHilo(&aceptadorDeConexiones,"AceptadorDeConexiones");
 	::empezarHilo(&reconectador,"ReconectadorDeConexiones");
-	intentarIniciarModelo();
-    aplicacionServidor.join("GameLoop");
+	::empezarHilo(&iniciadorModelo,"IniciadorDelModelo");
+    eliminarConexionesPerdidas();
 }
 
-actualizacion_cantidad_jugadores_t Servidor::crearActualizacionJugadores(){ //PASAR A USAR EL MANEJADOR DE KEYS
+void Servidor::eliminarConexionesPerdidas() {
+    while (!terminoJuego){
+        while (conexionesPerdidas.empty() && !terminoJuego){
+            dormirHilo();
+        }
+        for(auto const& cliente:conexionesPerdidas){
+            delete cliente;
+        }
+        pthread_mutex_lock(&mutex);
+        conexionesPerdidas.clear();
+        pthread_mutex_unlock(&mutex);
+    }
+}
+
+actualizacion_cantidad_jugadores_t Servidor::crearActualizacionJugadores(){
 	actualizacion_cantidad_jugadores_t actualizacion;
 	memset(&actualizacion, 0, sizeof(actualizacion_cantidad_jugadores_t));
 	int i = 0;
@@ -109,7 +125,6 @@ actualizacion_cantidad_jugadores_t Servidor::crearActualizacionJugadores(){ //PA
 	return actualizacion;
 }
 
-
 bool Servidor::esUsuarioDesconectado(const usuario_t& posibleUsuario, ConexionCliente* conexionClienteConPosibleUsuario){
     int idJugador;
     bool seConecto = false;
@@ -145,7 +160,7 @@ bool Servidor::esUsuarioSinConectarse(const usuario_t& posibleUsuario,ConexionCl
 			for(auto const& cliente:clientes){
 				cliente->agregarMensajeAEnviar(ACTUALIZACION_JUGADORES,&actualizacion);
 			}
-			despertarHilo();
+            iniciadorModelo.despertarHilo();
 			return true;
 		}
 	}
@@ -161,24 +176,6 @@ bool Servidor::esUsuarioValido(const usuario_t& posibleUsuario,ConexionCliente*
 		   esUsuarioDesconectado(posibleUsuario,conexionClienteConPosibleUsuario);
 }
 
-
-void Servidor::intentarIniciarModelo(){
-	info_partida_t info_partida[cantidadConexiones];
-	while(mapaIDNombre.size() < cantidadConexiones){
-	    dormirHilo();
-	}
-
-	log->mostrarMensajeDeInfo("Se va a iniciar el envio de informacion inicial a los jugadores.");
-
-	for(auto parIDCliente:clientesJugando){
-		int id = parIDCliente.first;
-		info_partida[id] = aplicacionServidor.obtenerInfoPartida(mapaIDNombre,id);
-        parIDCliente.second->agregarMensajeAEnviar(PARTIDA,&info_partida[id]);
-	}
-
-	aplicacionServidor.iniciarJuego();
-}
-
 void Servidor::encolarEntradaUsuario(entrada_usuario_id_t entradaUsuario){
 	this->aplicacionServidor.encolarEntradaUsuario(entradaUsuario);
 }
@@ -188,6 +185,7 @@ void Servidor::terminarElJuego(){
         cliente->terminarElJuego();
 	}
 	terminoJuego = true;
+	despertarHilo();
 }
 
 bool Servidor::terminoElJuego() const{
@@ -235,4 +233,4 @@ Servidor::~Servidor(){
     reconectador.despertarHilo();
 	while(!aceptadorDeConexiones.terminoAceptar() || !reconectador.terminoHiloReconectar()){}
 	delete log;
-}
\ No newline at end of file
+}
diff --git a/src/Server/Servidor/Servidor.hpp b/src/Server/Servidor/Servidor.hpp
index bf9e5dcf..3f124169 100644
--- a/src/Server/Servidor/Servidor.hpp
+++ b/src/Server/Servidor/Servidor.hpp
@@ -27,6 +27,7 @@
 #include "ManejadorIdentificadores.hpp"
 #include "AceptadorDeConexiones.hpp"
 #include "ReconectadorDeConexiones.hpp"
+#include "IntentadorIniciarModelo.hpp"
 
 class Servidor : public Thread{
 
@@ -35,7 +36,6 @@ class Servidor : public Thread{
 		~Servidor() override;
 
 		bool esUsuarioValido(const usuario_t& posibleUsuario,ConexionCliente* conexionClienteConPosibleUsuario);
-		void intentarIniciarModelo();
 		void encolarEntradaUsuario(entrada_usuario_id_t entradaUsuario);
 		void agregarUsuarioDesconectado(ConexionCliente* conexionPerdida,int idJugador,string nombre,const string& contrasenia);
 		void ejecutar() override;
@@ -57,6 +57,7 @@ class Servidor : public Thread{
 
     private:
         ReconectadorDeConexiones reconectador;
+        IntentadorIniciarModelo iniciadorModelo;
         AceptadorDeConexiones aceptadorDeConexiones = AceptadorDeConexiones(nullptr, 0);
 		map<int,string> mapaIDNombre;
 		Log* log;
@@ -72,6 +73,7 @@ class Servidor : public Thread{
 		bool esUsuarioDesconectado(const usuario_t& posibleUsuario,ConexionCliente* conexionClienteConPosibleUsuario);
 		bool esUsuarioSinConectarse(const usuario_t& posibleUsuario,ConexionCliente* conexionClienteConPosibleUsuario);
         void notificarClientesDeLaDesconexion(const ConexionCliente *conexionPerdida, string &nombre);
+        void eliminarConexionesPerdidas();
 
         bool terminoJuego;
 		list<ConexionCliente*> clientes;

From 40ed331a1f070f73df4acac1800e581f6c74f993 Mon Sep 17 00:00:00 2001
From: Bruno Grassano <grassanobruno@gmail.com>
Date: Wed, 27 Jan 2021 13:25:51 -0300
Subject: [PATCH 6/7] ref: Las flores son mas raras ahora

---
 src/Server/Modelo/Juego/Nivel/Bloques/Sorpresa.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Server/Modelo/Juego/Nivel/Bloques/Sorpresa.cpp b/src/Server/Modelo/Juego/Nivel/Bloques/Sorpresa.cpp
index cf6e6eaa..85bf3030 100644
--- a/src/Server/Modelo/Juego/Nivel/Bloques/Sorpresa.cpp
+++ b/src/Server/Modelo/Juego/Nivel/Bloques/Sorpresa.cpp
@@ -4,6 +4,7 @@
 
 #include "src/Server/Modelo/Juego/Sprites/SpriteSorpresa.hpp"
 
+#define PROBABILIDAD_NECESARIA_PARA_FLOR 80
 
 Sorpresa::Sorpresa(int coordenadaX, int coordenadaY) {
     tipoBloque = SORPRESA;
@@ -26,7 +27,8 @@ void Sorpresa::inicializarMapasDeColision(){
 
 ObjetoSorpresa* Sorpresa::obtenerObjetoSorpresa(int posX, int posY) {
     ObjetoSorpresa* objeto;
-    if(rand()%2 == 0){
+    unsigned int probabilidad = rand()%101;
+    if(probabilidad > PROBABILIDAD_NECESARIA_PARA_FLOR){
         objeto = new FlorDeFuego(posX,posY);
     }
     else{

From 8ef1e8434bfa007b36909a87a3d49333eb84271d Mon Sep 17 00:00:00 2001
From: Bruno Grassano <grassanobruno@gmail.com>
Date: Wed, 27 Jan 2021 13:39:25 -0300
Subject: [PATCH 7/7] Docs: Completo algo el readme

---
 README.md | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index edebaf58..ef9e7be5 100644
--- a/README.md
+++ b/README.md
@@ -17,8 +17,21 @@ Tablero de Trello - [link](https://trello.com/b/sdukQHiL/tp-taller)
 ### Pre-requisitos
 Listado de software/herramientas necesarias para el proyecto
 
+* C++
+* SDL2 / SDL2_image / SDL2_ttf / SDL2_mixer
+* CMake
+* Sistema operativo basado en Linux
+
 ## Ejecutando las pruebas
-Para ejecutar las pruebas...
+A lo largo del desarrollo del trabajo se han hecho algunas
+pruebas para poder evaluar el correcto funcionamiento del modelo.
+ Estas se pueden ejecutar de las siguientes maneras.
+```
+./Mario -t
+./Mario --test
+
+* Siendo Mario el nombre del ejecutable que se tenga
+```
 
 ## Ejecutando la aplicación
 Para ejecutar la aplicación...