Servernuevo

CMakeLists.txt

@@ -38,6 +38,9 @@ add_executable(server
   # "${SERVERDIR}/recibidor.cpp"
   "${SERVERDIR}/server.cpp"
   "${SERVERDIR}/cliente.cpp"
+  "${SERVERDIR}/jugador.cpp"
+  "${SERVERDIR}/partida.cpp"
+
   "${SERVERDIR}/protocolo.cpp"
 
   # Socket

src/common/threadSafeList.h

@@ -36,7 +36,7 @@ class TSList {
     // no una copia. Yo le hubiese puesto "get", pero _etimologicamente_
     // get implica que vos lo obtenes (llamese, te pasan copia) y eso
     // no es lo que hace.
-    T& at(int pos) {
+    [[nodiscard]] T& at(int pos) {
         //Lockeamos porque obtener es una RC*
         //Entendo que es una race condition, porque si alguien esta
         //modificando la lista; vos podrias llegar a ver una vision
@@ -58,7 +58,7 @@ class TSList {
         this->lista.erase(this->lista.begin() + pos);
     }
 
-    int size() {
+    [[nodiscard]] int size() {
         std::unique_lock<std::mutex> lck(mtx);
 
         int longitud;

src/server/cliente.cpp

@@ -1,4 +1,6 @@
 #include "cliente.h"
+#include "jugador.h"
+#include "partida.h"
 #include "socket.h"
 #include <string>
 
@@ -7,23 +9,44 @@
 //     void anadirJugadorAPartida(Protocolo&& socketDeJugador, id idPartida);
 // };
 
+
 Cliente::Cliente(Socket&& socket, std::vector<std::string> mapasDisponibles,
-	       TSList<Partida>& avisar) 
+	       TSList<Partida*>& avisar) 
     : protocolo(std::move(socket)), avisar(avisar) {
     this->conectadoAPartida = false;
     this->mapasDisponibles = mapasDisponibles;
 };
 
 //Esto corre en un thread
 void Cliente::elegirPartida() {
-    this->protocolo.mostrarMapas(this->mapasDisponibles);
+    //Paso 1: Envio los mapas
+    this->protocolo.enviarMapas(this->mapasDisponibles);
+
+    //Paso 2: Envio las partidas
+    std::vector<RepresentacionPartida> partidasAEnviar;
+    for (int i = 0; i < this->avisar.size() ; i++) {
+        Partida* partida = this->avisar.at(i);
+
+        if (partida == nullptr)
+	  continue;
+
+
+        RepresentacionPartida repreActual;
+        repreActual.ID = i;
 
-    // this->protocolo.mostrarPartidas(this->partidasPosibles);
+        partidasAEnviar.push_back(repreActual);
+    }
 
+    this->protocolo.enviarPartidas(partidasAEnviar);
+
+    //Paso 3: Obtengo la partida deseada
     int partidaElejida = this->protocolo.obtenerPartidaDeseada();
 
-    // this->avisar->anadirJugadorAPartida(std::move(this->protocolo), partidaElejida);
-    this->avisar.at(partidaElejida);
+    Partida *partidaElegida = this->avisar.at(partidaElejida);
+
+    Jugador *jugadorNuevo = new Jugador(std::move(this->protocolo));
+
+    partidaElegida->anadirJugador(jugadorNuevo);
 
     this->conectadoAPartida = true;
 }

src/server/cliente.h

@@ -27,11 +27,11 @@ class Cliente : public Thread { //-- Notas Relacion Cliente - Jugador
     std::vector<std::string> mapasDisponibles;
 
     //Este nombre es una mierda. Cambiar
-    TSList<Partida>& avisar;
+    TSList<Partida*>& avisar;
 
 public:
     Cliente(Socket&& socket, std::vector<std::string> mapasDisponibles,
-	  TSList<Partida>& avisar);
+	  TSList<Partida*>& avisar);
 
     void run();
 

src/server/jugador.cpp

@@ -0,0 +1,6 @@
+#include "jugador.h"
+#include "protocolo.h"
+
+Jugador::Jugador(Protocolo &&):
+    protocolo(std::move(protocolo)){
+}

src/server/partida.cpp

@@ -1,4 +1,5 @@
 #include "partida.h"
+#include "jugador.h"
 
 Partida::Partida() {
 }
@@ -12,24 +13,28 @@ Partida::Partida() {
 
  */
 
+void Partida::anadirJugador(Jugador *jugadorNuevo) {
+
+}
+
 
 void Partida::gameLoop() {
-    int posJugadorActual = 0;
+    // int posJugadorActual = 0;
 
-    while (true) {
-        Jugador& jugadorActual = jugadores.at(posJugadorActual);
-        Gusano& gusanoActual = jugadorActual.getGusanoActual();
+    // while (true) {
+    //     Jugador& jugadorActual = jugadores.at(posJugadorActual);
+    //     Gusano& gusanoActual = jugadorActual.getGusanoActual();
 
-        //TODO: Cambiar a algo mas generico cuando tengamos las armas
-        // int jugadorActual.getAccion();
+    //     //TODO: Cambiar a algo mas generico cuando tengamos las armas
+    //     // int jugadorActual.getAccion();
 
-        //TODO: Implementar "calcular cambios"
-        //std::list<std::pair<posX,posY> areasAfectadas = this.calcularCambios(Accion);
+    //     //TODO: Implementar "calcular cambios"
+    //     //std::list<std::pair<posX,posY> areasAfectadas = this.calcularCambios(Accion);
 
-        //TODO: Implementar "actualizar"
-        //this.actualizar();
+    //     //TODO: Implementar "actualizar"
+    //     //this.actualizar();
 
 
-        posJugadorActual += 1;
-    }
+    //     posJugadorActual += 1;
+    // }
 };

src/server/partida.h

@@ -3,7 +3,6 @@
 
 #include "gusano.h"
 #include "jugador.h"
-#include "protocolo.h"
 #include "thread.h"
 #include <cstdint>
 #include <sys/types.h>
@@ -19,15 +18,15 @@ enum class Accion { Mover, Saltar, Disparar };
 class Partida : public Thread {
     int32_t id;
 
-    std::vector<Jugador> jugadores;
+    std::vector<Jugador *> jugadores;
 
     std::vector<Gusano*> gusanos;
 
     void turnoJugador();
 public:
     Partida();
 
-    void anadirJugador(Protocolo&& jugadorNuevo);
+    void anadirJugador(Jugador  *jugadorNuevo);
 
     void gameLoop();
 };

src/server/protocolo.cpp

@@ -1,4 +1,5 @@
 #include "protocolo.h"
+#include <vector>
 
 Protocolo::Protocolo(Socket&& socket):
     socket(std::move(socket)){};
@@ -127,18 +128,18 @@ void Protocolo::enviarMapas(std::vector<std::string> mapasDisponibles) {
     socket.sendall(paraEnviar.data(), sizeof(id)*cantMapas, &was_closed);
 }
 
-void Protocolo::enviarPartidas(TSList<Partida*> partidasDisponibles) {
+void Protocolo::enviarPartidas(std::vector<RepresentacionPartida> partidasDisponibles) {
     int8_t codigo = PARTIDAS;
     int cantPartidas = partidasDisponibles.size();
     uint16_t cant = htons(cantPartidas);
 
     std::vector<char*> paraEnviar;
-    for (int32_t i = 0; i < (int32_t)cantMapas; i++) {
-        if (partidasDisponibles) {
-            id idMapa = htonl(i);
-            paraEnviar.push_back((char*)&idMapa);
+    for (int32_t i = 0; i < (int32_t)cantPartidas; i++) {
+        // if (partidasDisponibles) {
+        id idMapa = htonl(i);
+        paraEnviar.push_back((char*)&idMapa);
 
-        }
+        // }
     }
 
     bool was_closed = false;

src/server/protocolo.h

@@ -1,8 +1,9 @@
+#include <vector>
 #ifndef PROTOCOLO_HEADER
 #define PROTOCOLO_HEADER
 
 #include "socket.h"
-#include "partida.h"
+// #include "partida.h"
 #include "threadSafeList.h"
 #include <arpa/inet.h>
 #include <string>
@@ -23,6 +24,10 @@ enum Direccion {IZQUIERDA, DERECHA, SALTO, PIRUETA};
 // 
 #define MOV 7
 
+struct RepresentacionPartida {
+    int ID;
+};
+
 class Protocolo {
 private:
     Socket socket;
@@ -43,7 +48,8 @@ class Protocolo {
 
     void enviarMapas(std::vector<std::string> mapasDisponibles);
 
-    void enviarPartidas(TSList<Partida*> partidasDisponibles); 
+    // void enviarPartidas(TSList<Partida*> partidasDisponibles); 
+    void enviarPartidas(std::vector<RepresentacionPartida> partidasDisponibles); 
     id obtenerMapaDeseado();
     [[nodiscard]] id obtenerPartidaDeseada();
 

src/server/server.h

@@ -41,7 +41,7 @@ class Server {
     // nos asegura que no va a haber espacios vacios en el
     //medio, lo cual facilita el obtener y modificar sus id
     // std::vector<Partida> partidas;
-    TSList<Partida> partidas;
+    TSList<Partida*> partidas;
 
     // [[nodiscard]] std::vector<RepresentacionPartida> getRepresentacionPartidas();