Merge protocolo a server

Protocolo
Los-Socketes · Oct 26, 2023 · 06b3091 · 06b3091
2 parents 3573123 + 8d56bca
commit 06b3091
Show file tree

Hide file tree

Showing 3 changed files with 215 additions and 13 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,14 +1,14 @@
  # Pongo esta version simplemente porque es la ultima version estable
  # en Gentoo (y es la que tengo instalada).
  # Entiendo que se podria cambiar por otra si llega a haber drama
-cmake_minimum_required(VERSION 3.26.5)
+cmake_minimum_required(VERSION 3.25.1)
 
 # Cuando este listo ponemos la version VERSION 1.0 B)
 project(worms VERSION 0.1 HOMEPAGE_URL
   https://github.com/Los-Socketes/Worms LANGUAGES CXX)
 
 # Usamos el estandar iso 11 porque lo dice la consigna
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 
 # Seteamos las flags de compilacion
 add_compile_options(-Wall -Wextra -Wpedantic)

diff --git a/src/server/protocolo.cpp b/src/server/protocolo.cpp
@@ -3,20 +3,191 @@
 Protocolo::Protocolo(Socket&& socket):
     socket(std::move(socket)){};
 
-void Protocolo::mostrarMapas(std::vector<std::string> mapasDisponibles) {
-    //Como diria sisop "Your code here"
 
+int8_t Protocolo::obtenerCodigo() {
+    bool was_closed = false;
+    int8_t codigo;
+    socket.recvall(&codigo, sizeof(codigo), &was_closed);
+    return codigo;
 }
 
-void Protocolo::mostrarPartidas(std::vector<std::string> partidasDisponibles) {
-    //Como diria sisop "Your code here"
+std::vector<id> Protocolo::obtenerVector() {
+    bool was_closed = false;
+    int16_t cant;
+    socket.recvall(&cant, sizeof(cant), &was_closed);
+    // TODO: verificar
+    cant = ntohs(cant);
 
+    std::vector<id> partidas(cant, 0);
+    socket.recvall(partidas.data(), cant*sizeof(id), &was_closed);
+    // TODO: verificar
+
+    for (int i = 0; i < (int)cant; i++) {
+        partidas.at(i) = ntohl(partidas[i]);
+    }
+    return partidas;
+}
+
+std::vector<id> Protocolo::obtenerPartidas() {
+    int8_t codigo = obtenerCodigo();
+    // TODO: verificar (codigo)
+
+    return obtenerVector();
+}
+
+
+std::vector<id> Protocolo::obtenerMapas() {
+    int8_t codigo = obtenerCodigo();
+    // TODO: verificar (codigo)
+
+    return obtenerVector();
+}
+
+id Protocolo::verificarConexion() {
+    bool was_closed = false;
+    int8_t codigo;
+    socket.recvall(&codigo, sizeof(codigo), &was_closed);
+    // TODO: verificar
+
+    id idPartida = -1;
+    if ((int)codigo == ERROR) {
+        return idPartida;
+    }
+    // TODO: quizas ver si no es exito -> tirar excepcion
+    socket.recvall(&idPartida, sizeof(idPartida), &was_closed);
+    // TODO: verificar
+
+    idPartida = ntohl(idPartida);
+    return idPartida;
+}
+
+id Protocolo::crearPartida(id mapaSeleccionado) {
+    int8_t codigo = CREAR;
+    int32_t mapa = htonl(mapaSeleccionado);
+
+    bool was_closed = false;
+    socket.sendall((char*)&codigo, sizeof(codigo), &was_closed);
+    socket.sendall((char*)&mapa, sizeof(mapa), &was_closed);
+    // TODO: verificar
+
+    return verificarConexion();
+}
+
+
+bool Protocolo::unirseAPartida(id id) {
+    int8_t codigo = UNIRSE;
+    int32_t idPartida = htonl(id);
+
+    bool was_closed = false;
+    socket.sendall((char*)&codigo, sizeof(codigo), &was_closed);
+    // TODO: verificar
+    socket.sendall((char*)idPartida, sizeof(idPartida), &was_closed);
+    // TODO: verificar
+
+    return verificarConexion();
+}
+
+void Protocolo::moverGusano(id gusano, Direccion direccion) {
+    int8_t codigo = MOV;
+    id idGusano = htonl(gusano);
+    int8_t dir = direccion;
+
+    bool was_closed = false;
+    socket.sendall((char*)&codigo, sizeof(codigo), &was_closed);
+    socket.sendall((char*)&idGusano, sizeof(idGusano), &was_closed);
+    socket.sendall((char*)&dir, sizeof(dir), &was_closed);
+}
+
+
+std::vector<char*> Protocolo::vectorListoParaEnviar(std::vector<id> vectorAEnviar) {
+    std::vector<char*> paraEnviar;
+    for (auto &&elemento : vectorAEnviar) {
+        int32_t valorAEnviar = htonl(elemento);
+        paraEnviar.push_back((char*)&valorAEnviar);
+    }
+    return paraEnviar;
+}
+
+void Protocolo::enviarMapas(std::vector<std::string> mapasDisponibles) {
+    int8_t codigo = MAPAS;
+    int cantMapas = mapasDisponibles.size();
+    uint16_t cant = htons(cantMapas);
+
+    // por ahora solo enviamos ids, despues vemos de mandar mas info (nombre)
+    std::vector<char*> paraEnviar;
+    for (int32_t i = 0; i < (int32_t)cantMapas; i++) {
+        id idMapa = htonl(i);
+        paraEnviar.push_back((char*)&idMapa);
+    }
+
+
+    bool was_closed = false;
+    socket.sendall((char*)&codigo, sizeof(codigo), &was_closed);
+    socket.sendall((char*)&cant, sizeof(cant), &was_closed);
+    socket.sendall(paraEnviar.data(), sizeof(id)*cantMapas, &was_closed);
+}
+
+void Protocolo::enviarPartidas(TSList<Partida*> 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);
+
+        }
+    }
+
+    bool was_closed = false;
+    /* TODO: agregar ifs para ver si se cerro el socket
+            mover estos sendall a otro metodo
+            hacer que este metodo devuelva 1 string/algo con toda la info para hacer
+                mas facil el testeo
+    */
+    socket.sendall((char*)&codigo, sizeof(codigo), &was_closed);
+    socket.sendall((char*)&cant, sizeof(cant), &was_closed);
+    socket.sendall(paraEnviar.data(), sizeof(int32_t)*cantPartidas, &was_closed);
+
+}
+
+id Protocolo::obtenerId() {
+    bool was_closed = false;
+    id idEnviada;
+    socket.recvall(&idEnviada, sizeof(idEnviada), &was_closed);
+    // TODO: verificar
+    idEnviada = ntohl(idEnviada);
+    return idEnviada;
 }
-int Protocolo::obtenerPartidaDeseada() {
-    //Como diria sisop "Your code here"
+
+id Protocolo::obtenerMapaDeseado() {
+    int8_t codigo = obtenerCodigo();
+    // TODO: verificar
+    return obtenerId();
+}
+
+id Protocolo::obtenerPartidaDeseada() {
     //Tenemos que ponernos de acuerdo en que devolver cuando el cliente
     //elige crear una partida nueva
+    int8_t codigo = obtenerCodigo();
+    // TODO: verificar
+    return obtenerId();
+}
+
+void Protocolo::enviarConfirmacion(id idPartida) {
+    int8_t codigo = EXITO;
+    int32_t idAEnviar = htonl(idPartida);
+
+    bool was_closed = false;
+    socket.sendall((char*)&codigo, sizeof(codigo), &was_closed);
+    socket.sendall((char*)&idAEnviar, sizeof(idAEnviar), &was_closed);
+}
+
+void Protocolo::enviarError() {
+    int8_t codigo = ERROR;
 
-    // return "Devuelvo esto solamente para que compile";
-    return 0;
+    bool was_closed = false;
+    socket.sendall((char*)&codigo, sizeof(codigo), &was_closed);
 }
diff --git a/src/server/protocolo.h b/src/server/protocolo.h
@@ -2,22 +2,53 @@
 #define PROTOCOLO_HEADER
 
 #include "socket.h"
+#include "partida.h"
+#include "threadSafeList.h"
+#include <arpa/inet.h>
 #include <string>
 #include <vector>
 
 //TODO Poner todos los types defs en un header file juntos
+typedef int32_t id;
+enum Direccion {IZQUIERDA, DERECHA, SALTO, PIRUETA};
+#define PARTIDAS 1
+#define MAPAS 2
+#define CREAR 3
+#define UNIRSE 4
+#define EXITO 5
+#define ERROR 6
+
+// Codigos para acciones 
+// mov + direccion -> izq, der, salto, pirueta
+// 
+#define MOV 7
 
 class Protocolo {
 private:
     Socket socket;
+
+    id obtenerId();
+    int8_t obtenerCodigo();
+    std::vector<id> obtenerVector();
+    std::vector<char*> vectorListoParaEnviar(std::vector<id> vectorAEnviar);
+    id verificarConexion();
 public:
     // Pongo estas para que compile nomas. Ponele el nombre/encaralas de
     // la forma que te parezca
-    void mostrarMapas(std::vector<std::string> mapasDisponibles); 
+    std::vector<id> obtenerPartidas();
+    std::vector<id> obtenerMapas();
+    id crearPartida(id mapaSeleccionado);
+    bool unirseAPartida(id id);
+    void moverGusano(id gusano, Direccion direccion);
+
+    void enviarMapas(std::vector<std::string> mapasDisponibles);
 
-    void mostrarPartidas(std::vector<std::string> partidasDisponibles); 
+    void enviarPartidas(TSList<Partida*> partidasDisponibles); 
+    id obtenerMapaDeseado();
+    [[nodiscard]] id obtenerPartidaDeseada();
 
-    [[nodiscard]] int obtenerPartidaDeseada();
+    void enviarConfirmacion(id idPartida);
+    void enviarError();
 
     Protocolo(Socket&& socket);