fix: Added user manual

README.md

@@ -2,6 +2,8 @@
 
 Repositorio del Grupo 7 para la materia Taller de Programación 1 - Curso Veiga
 
+Se presenta el manual de usuario en el archivo [./docs/Manual_de_usuario.md](./docs/Manual_de_usuario.md), que explica cómo usar este proyecto.
+
 #### Tabla de contenidos
 
 1. [Setup para desarrollo](#Setup-para-desarrollo)
@@ -184,4 +186,4 @@ Una vez que se tiene la VM creada, es mejor levantarla solamente, `vagrant up` n
 
 El Vagrantfile usa sintaxis del lenguaje de programación Ruby para declarar las configuraciones.
 
-Por default, todo lo que está en la carpeta donde el Vagrantfile se encuentra ubicado será compartido con la VM como una carpeta compartida. Ésta será la carpeta `/vagrant`, o sea, ubicada en el root de la VM. Desde aquí se harán los manejos necesarios de archivos, es decir, la build se guardará en esta carpeta así como también se ejecutarán los binarios ejecutables.
+Por default, todo lo que está en la carpeta donde el Vagrantfile se encuentra ubicado será compartido con la VM como una carpeta compartida. Ésta será la carpeta `/vagrant`, o sea, ubicada en el root de la VM. Desde aquí se harán los manejos necesarios de archivos, es decir, la build se guardará en esta carpeta así como también se ejecutarán los binarios ejecutables.

Vagrantfile

@@ -8,7 +8,7 @@ Vagrant.configure('2') do |config|
     machine.vm.box = 'bento/ubuntu-22.04'
 
     # Make available port 3500, forward 3500->3500
-    config.vm.network "forwarded_port", guest: 3500, host:3500
+    #config.vm.network "forwarded_port", guest: 3500, host:3500
 
     # Disable ssh so no ssh key is required to interact with the system
     config.ssh.insert_key = false

docs/Manual_de_usuario.md

@@ -0,0 +1,186 @@
+# Manual de usuario
+
+Este documento cubre cómo instalar las dependencias y el juego, cómo correrlo y cómo usarlo.
+
+Tabla de contenidos:
+
+1. [Cómo buildear y correr en local](#Cómo-buildear-y-correr-en-local)
+1. [Cómo setupear y correr con Vagrant](#Cómo-setupear-y-correr-con-Vagrant)
+
+## Cómo buildear y correr en local
+
+Para instalar los paquetes necesarios correr el script:
+
+```shell
+./scripts/setup_libs.sh
+```
+
+Para crear los ejecutables (cliente y servidor) correr el script:
+
+```shell
+./scripts/build.sh
+```
+
+### Ejecución sin Valgrind
+
+Los ejecutables se encontrarán en la carpeta recién creada build por lo que para ejecutarlos hay que correr el siguiente comando estando con la terminal situada en la carpeta del root del proyecto:
+
+```shell
+./build/client
+```
+
+```shell
+./build/server
+```
+
+### Ejecución con Valgrind
+
+Disclaimer: los archivos de supresión no están del todos optimizados para la máquina de Vagrant.
+
+Los ejecutables se encontrarán en la carpeta recién creada build por lo que para ejecutarlos con Valgrind y los archivos de supresión hay que correr:
+
+```shell
+valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes --track-fds=yes --track-origins=yes --gen-suppressions=all --suppressions=./valgrind/memcheck.supp --suppressions=./valgrind/qt.supp --suppressions=./valgrind/sdl.supp ./build/client
+```
+
+```shell
+valgrind --tool=memcheck --leak-check=full --show-reachable=yes --trace-children=yes --track-fds=yes --track-origins=yes --gen-suppressions=all --suppressions=./valgrind/memcheck.supp ./build/sever
+```
+
+## Cómo setupear y correr con Vagrant
+
+### Vagrant setup
+
+Para instalar los paquetes necesarios para levantar la virtual machine (vm) con Vagrant de acuerdo a las configuraciones declaradas al Vagrantfile hay que correr los siguientes comandos.
+
+Utilizaremos VirtualBox como VM Provider, para instalarlo hay que correr:
+
+```shell
+sudo apt-get --yes install virtualbox
+```
+
+```shell
+sudo apt-get --yes install virtualbox-ext-pac
+```
+
+> Probado con VirtualBox version 7.0.14
+
+Para instalar Vagrant hay que correr:
+
+```shell
+sudo apt-get --yes install vagrant
+```
+
+> Probado con Vagrant version 2.3.6
+
+Utilizaremos un plugin de Vagrant para reiniciar la VM en provision time y así realizar un setup correcto. Para instalarlo hay que correr:
+
+```shell
+vagrant plugin install vagrant-reload
+```
+
+### Cómo correr la VM
+
+Para ejecutar y provisionar la VM hay que correr:
+
+```shell
+vagrant up
+```
+
+De esta manera se realizarán todos los pasos para realizar un correcto provisioning de una VM corriendo Ubuntu 22.04 con el entorno gráfico xubuntu-desktop.
+
+Una vez que en la consola donde Vagrant corre se puede observar el mensaje "Provisioning complete", es decir, la VM tiene el juego listo para correr (en esta etapa la VM se reinició dos veces), hay que logearse en la VM con la contraseña `vagrant` y correr el cliente o servidor de la siguiente manera. El proceso de provisioning puede tardar 10 minutos con una PC y conexión a internet buena buena o más dependiendo del estado de la conexión y los recursos de la computadora host que instalará las dependencias.
+
+Primero abrir una terminal, con `CTRL + ALT + T` por ejemplo. Y luego situarse en la carpeta root del proyecto con el comando:
+
+```shell
+cd /vagrant/
+```
+
+Luego, para ejecutar el servidor correr:
+
+```shell
+/vagrant/build/server <puerto>
+```
+
+Y para ejecutar un cliente correr:
+
+```shell
+/vagrant/build/client
+```
+
+### Comandos útles de Vagrant
+
+1. Si se actualizaron los scripts de provisioning, se puede correr el siguiente comando para aplicar los scripts sobre la misma VM actual:
+
+```shell
+vagrant reload --provision
+```
+
+2. Si sólo se quiere reiniciar la VM:
+
+```shell
+vagrant reload
+```
+
+3. Si se cambió la estructura de la VM, es decir, se editó el Vagrantfile, hay que correr (preferentemente antes de guardar los cambios del Vagrantfile) el siguiente comando para destruir la VM (la para y luego la elimina):
+
+```shell
+vagrant destroy
+```
+
+Luego levantar una nueva VM con la nueva configuración con el comando:
+
+```shell
+vagrant up
+```
+
+4. Si se quiere apagar la VM:
+
+```shell
+vagrant halt
+```
+
+5. Para acceder a una terminal dentro del sistema operativo de la VM:
+
+```shell
+vagrant ssh
+```
+
+## Cómo funciona la interfaz del juego
+
+### Interfaz del servidor
+
+El servidor se lanza por terminal corriendo el binario con un parámetro que es el puerto, y correrá en el hostname `localhost`.
+
+### Interfaz del cliente
+
+El cliente primero lanza una UI construida con Qt que llamaremos `Lobby`, una vez finalazas las acciones del lobby e iniciada la conexión para comenzar a jugar, el lobby se cerrará y se abrirá el `Juego`, construido íntegramente con SDL2.
+
+#### Lobby
+
+La primera acción a realizar es ejecutar la conexión del cliente con el servidor. Esto se hace rellenando el hostname y el puerto, posteriormente apretando el botón de conexión. Si se habilitan los botones de la ventana inicial la conexión fue exitosa. Por defecto el servidor espera una conexión en localhost, así que en el campo de hostname poner `localhost` y luego el puerto correspondiente.
+
+Todos los campos de texto tienen validación de input así que si un dato se puso de manera incorrecta o la conexión falla, se mostrará un mensaje con lo que está ocurriendo.
+
+En la ventana inicial podemos elegir entre crear una partida o unirse a una de las partidas ya creadas.
+
+Si creamos una nueva partida debemos ingresar nuestro nombre de usuario, las configuraciones de una partida como ser la duración de la partida y la cantidad de jugadores de la misma está definida en el archivo de configuración del juego, ubicado en el root del proyecto y usado en todos los componentes del juego llamado `games_config.yaml`. Luego se selecciona el personaje que uno quiera utilizar y se quedará en la ventana de espera hasta que se conecten todos los jugadores y se llene la partida.
+
+Si se seleccionó ingresar a un juego ya existente, la partida se visualizará con el nombre del usuario que la creó. Hay un botón para refrescar las partidas que están en vivo en el momento. Luego de ingresar a la partida deseada con el botón `Join` correspondiente se verán las opciones del juego y se debe ingresar el nombre de usuario. Una vez completado ese paso se procede a la pantalla de espera.
+
+#### Juego
+
+Cuando todos los jugadores entraron a la partida, la ventana del Lobby se cierra y se abre el Juego.
+
+Los controles son los siguientes:
+
+- `FLECHA DERECHA`: mueve el jugador a la derecha
+- `FLECHA IZQUIERDA:` mueve el jugador a la izquierda
+- `FLECHA ARRIBA`: ejecuta la acción de salto
+- `BARRA ESPACIADORA`: ejecuta la acción de disparo
+- `Q`: cierra el juego
+- `ESCAPE`: cierra el juego
+- `F1`: muestra el panel de información debug, como los FPS
+
+La cámara del juego sigue al personaje que el jugador está controlando.

src/client/client_main.cpp

@@ -83,7 +83,7 @@ int main(int argc, char *argv[]) {
     GraphicEngine graphicEngine;
     graphicEngine.preloadTextures();
 
-    debugPrint(hostname, port, username, userCharacter, gameConfig);
+    // debugPrint(hostname, port, username, userCharacter, gameConfig);
 
     SnapshotWrapper initialSnapshot(initialSnapshotDto);
 

src/engine/base_player.cpp

@@ -25,11 +25,7 @@ void BasePlayer::change_state(std::unique_ptr<BaseState> new_state) {
 void BasePlayer::move_right() {
   Rectangle new_rectangle = rectangle;
   new_rectangle.move_right();
-  std::cout << "Moving Right afuera del if"
-            << "\n";
   if (state->can_move() && map.available_position(new_rectangle)) {
-    std::cout << "Moving Right"
-              << "\n";
 
     rectangle = new_rectangle;
     facing_direction = FacingDirectionsIds::Right;
@@ -48,11 +44,7 @@ void BasePlayer::move_right() {
 void BasePlayer::move_left() {
   Rectangle new_rectangle = rectangle;
   new_rectangle.move_left();
-  std::cout << "Moving Left afuera del if"
-            << "\n";
   if (state->can_move() && map.available_position(new_rectangle)) {
-    std::cout << "Moving Left"
-              << "\n";
     rectangle = new_rectangle;
     facing_direction = FacingDirectionsIds::Left;
 

src/server/server_protocol.cpp

@@ -80,9 +80,6 @@ PlayerInfo ServerProtocol::getGameInfo() {
   bool wasClose = this->getTemporalWasClose();
   PlayerInfo info;
   this->skt.recvall_bytewise(&info, sizeof(info), &wasClose);
-  std::cout << "code: " << info.character_code
-            << "| game name: " << info.game_name[0]
-            << "player name: " << info.player_name[0] << "\n";
   this->throwIfClosed(wasClose);
   return info;
 }
@@ -130,7 +127,6 @@ CommandCodeDto ServerProtocol::asyncGetEventCode() {
   CommandCodeDto code;
   bool wasClose = this->getTemporalWasClose();
   this->skt.recvall_bytewise(&code, sizeof(CommandCodeDto), &wasClose);
-  std::cout << "code: " << std::to_string(code.code) << "\n";
   this->throwIfClosed(wasClose);
   return code;
 }