diff --git a/Client/src/Display/Display.cpp b/Client/src/Display/Display.cpp
index 7f46a50..d5f7afa 100644
--- a/Client/src/Display/Display.cpp
+++ b/Client/src/Display/Display.cpp
@@ -6,6 +6,7 @@
 //
 
 #include "Display.hpp"
+#include "Player/Player.hpp"
 #include <SFML/Graphics.hpp>
 #include <SFML/Graphics/Rect.hpp>
 #include <SFML/Graphics/Sprite.hpp>
@@ -24,7 +25,6 @@
 
 client::Display::Display()
 {
-    std::cout << "Init display" << std::endl;
     this->_window =
         std::make_unique<sf::RenderWindow>(sf::VideoMode({1920, 1080}), "");
     if (!this->_window)
@@ -34,7 +34,6 @@ client::Display::Display()
 
 client::Display::~Display()
 {
-    std::cout << "Destroy display" << std::endl;
     if (this->_window)
         this->_window->close();
 }
@@ -52,7 +51,7 @@ void client::Display::deactivateWindow()
 bool client::Display::handleEvent()
 {
     sf::Event sfmlEvent;
-    bool Event;
+    static bool Event = false;
 
     while (this->_window->pollEvent(sfmlEvent)) {
         switch (sfmlEvent.type) {
@@ -62,6 +61,10 @@ bool client::Display::handleEvent()
                 Event = true;
                 break;
             }
+            case sf::Event::KeyReleased: {
+                Event = false;
+                break;
+            }
             default:
                 break;
         }
@@ -71,7 +74,6 @@ bool client::Display::handleEvent()
 
 void client::Display::_loadAssets()
 {
-    std::cout << "Loading assets" << std::endl;
     this->_font = std::make_unique<sf::Font>();
     this->_font->loadFromFile(
         "./assets/fonts/JetBrainsMonoNerdFont-Medium.ttf");
@@ -82,7 +84,6 @@ void client::Display::_loadAssets()
     this->_loadCoinAssets();
     this->_loadPlayerAssets();
     this->_loadLaserAssets();
-    std::cout << "Done loading assets" << std::endl;
 }
 
 void client::Display::_loadBackgroundAsset()
@@ -200,40 +201,46 @@ void client::Display::_loadPlayerDieAssets()
 }
 
 void client::Display::renderFrame(
-    const Player &player, const std::vector<std::string> &map)
+    const Player &player, const Player &player2, const std::vector<std::string> &map)
 {
-    // this->_startX = player.getPosX();
     this->_startX = player.getPosX() - (this->_endX - this->_startX) / 2.0;
     this->_endX = this->_startX + 10;
 
     this->_window->clear();
     this->_drawBackground();
     this->_drawProps(player, map);
+    this->_drawPlayer(player2, map);
     this->_drawPlayer(player, map);
-    this->_drawAth(player);
+    this->_drawAth(player, player2);
     this->_window->display();
 }
 
-void client::Display::renderEndGame(const Player &player)
+void client::Display::renderEndGame(const Player &player, const Player &player2)
 {
     this->_window->clear();
-    this->_drawEnd(player);
+    this->_drawEnd(player, player2);
     this->_window->display();
 }
 
-void client::Display::_drawEnd(const Player &player)
+void client::Display::_drawEnd(const Player &player, const Player &player2)
 {
     sf::Text text;
     text.setFont(*this->_font);
     text.setCharacterSize(24);
 
     std::stringstream stream;
-    if (player.getPlayerWin()) {
+    if (player.getPlayerWin() == WIN_STATE::WIN) {
         stream << "WIN :)\n";
         stream << "SCORE: " << player.getScore() << "\n";
-    } else {
+        stream << "Opponent player: " << player2.getScore() << '\n';
+    } else if (player.getPlayerWin() == WIN_STATE::LOSE ){
         stream << "Lose (Skill Issue)\n";
         stream << "FINAL SCORE: " << player.getScore() << "\n";
+        stream << "Opponent player: " << player2.getScore() << '\n';
+    } else {
+        stream << "Draw (please be better next time)\n";
+        stream << "FINAL SCORE: " << player.getScore() << "\n";
+        stream << "Opponent player: " << player2.getScore() << '\n';
     }
 
     text.setString(stream.str());
@@ -242,14 +249,15 @@ void client::Display::_drawEnd(const Player &player)
     this->_window->draw(text);
 }
 
-void client::Display::_drawAth(const Player &player)
+void client::Display::_drawAth(const Player &player, const Player &player2)
 {
     sf::Text text;
     text.setFont(*this->_font);
     text.setCharacterSize(24);
 
     std::stringstream stream;
-    stream << "SCORE: " << player.getScore() << "\n";
+    stream << "SCORE: " << player.getScore() << '\n';
+    stream << "OPPONENT SCORE: " << player2.getScore() << '\n';
 
     text.setString(stream.str());
     text.setPosition(20, 20);
@@ -365,7 +373,10 @@ void client::Display::_drawPlayer(
     }
     playerSprite->setPosition(playerStartX - (tileWidth / 2),
         (map.size() - 1 - player.getPosY()) * tileHeight);
+    if (player.getPlayerTransparency())
+        playerSprite->setColor(sf::Color(0,0,0, 120));
     this->_window->draw(*playerSprite);
+    playerSprite->setColor(sf::Color(255, 255, 255, 255));
 
     if (player.getPosY() > 0) {
         this->_playerFlight[flightFrame] = std::move(playerSprite);
diff --git a/Client/src/Display/Display.hpp b/Client/src/Display/Display.hpp
index 54bcce8..11ef11e 100644
--- a/Client/src/Display/Display.hpp
+++ b/Client/src/Display/Display.hpp
@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include "Inputs/Inputs.hpp"
 #include "Player/Player.hpp"
 #include <SFML/Graphics.hpp>
 #include <SFML/Graphics/Sprite.hpp>
@@ -35,8 +34,8 @@ namespace client {
         ~Display();
 
         void renderFrame(
-            const Player &player, const std::vector<std::string> &map);
-        void renderEndGame(const Player &player);
+            const Player &player, const Player &player2, const std::vector<std::string> &map);
+        void renderEndGame(const Player &player, const Player &player2);
 
         bool handleEvent();
 
@@ -52,7 +51,6 @@ namespace client {
 
         std::unique_ptr<sf::RenderWindow> _window = nullptr;
         std::unique_ptr<sf::Font> _font = nullptr;
-        std::vector<client::Inputs> _events;
 
         sf::Texture _coinTexture;
         sf::Texture _laserTexture;
@@ -82,7 +80,7 @@ namespace client {
             const Player &player, const std::vector<std::string> &map);
         void _drawProps(
             const Player &player, const std::vector<std::string> &map);
-        void _drawAth(const Player &player);
-        void _drawEnd(const Player &player);
+        void _drawAth(const Player &player, const Player &player2);
+        void _drawEnd(const Player &player, const Player &player2);
     };
 }  // namespace client
diff --git a/Client/src/Inputs/Inputs.hpp b/Client/src/Inputs/Inputs.hpp
deleted file mode 100644
index 12ea02c..0000000
--- a/Client/src/Inputs/Inputs.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//
-// EPITECH PROJECT, 2025
-// Jetpack
-// File description:
-// Inputs.hpp
-//
-
-#pragma once
-
-#include <optional>
-
-namespace client {
-    enum class ev_keys {
-        KEY_NULL,
-        KEY_SPACE,
-        KEY_A,
-        KEY_B,
-        KEY_C,
-        KEY_D,
-        KEY_E,
-        KEY_F,
-        KEY_G,
-        KEY_H,
-        KEY_I,
-        KEY_J,
-        KEY_K,
-        KEY_L,
-        KEY_M,
-        KEY_N,
-        KEY_O,
-        KEY_P,
-        KEY_Q,
-        KEY_R,
-        KEY_S,
-        KEY_T,
-        KEY_U,
-        KEY_V,
-        KEY_W,
-        KEY_X,
-        KEY_Y,
-        KEY_Z,
-        KEY_0,
-        KEY_1,
-        KEY_2,
-        KEY_3,
-        KEY_4,
-        KEY_5,
-        KEY_6,
-        KEY_7,
-        KEY_8,
-        KEY_9,
-        SPECIAL_KEY_SPACE,
-        SPECIAL_KEY_BACKSPACE,
-        SPECIAL_KEY_ENTER,
-        ARROW_LEFT,
-        ARROW_RIGHT,
-        ARROW_DOWN,
-        ARROW_UP,
-        CLOSE,
-    };
-
-    enum class ev_state {
-        PRESSED,
-        RELEASED,
-    };
-
-    class Inputs {
-       public:
-        std::optional<ev_keys> key;
-        std::optional<ev_state> state;
-    };
-}  // namespace client
diff --git a/Client/src/JetpackClient/JetpackClient.cpp b/Client/src/JetpackClient/JetpackClient.cpp
index 5851efa..f4ce72d 100644
--- a/Client/src/JetpackClient/JetpackClient.cpp
+++ b/Client/src/JetpackClient/JetpackClient.cpp
@@ -14,8 +14,8 @@
 #include <thread>
 
 client::JetpackClient::JetpackClient(
-    const std::string &ip, const std::string &port)
-    : _ip(ip), _port(port), _running(true), _network(ip, port),
+    const std::string &ip, const std::string &port, bool debugMode)
+    : _ip(ip), _port(port), _debugMode(debugMode), _running(true), _network(ip, port),
       _state(CLIENT_STATE::UNDEFIDED), _MapIsRetrieve(false)
 {}
 
diff --git a/Client/src/JetpackClient/JetpackClient.hpp b/Client/src/JetpackClient/JetpackClient.hpp
index 292ac03..1984d71 100644
--- a/Client/src/JetpackClient/JetpackClient.hpp
+++ b/Client/src/JetpackClient/JetpackClient.hpp
@@ -34,7 +34,7 @@ namespace client {
             std::string _msg;
         };
 
-        JetpackClient(const std::string &ip, const std::string &port);
+        JetpackClient(const std::string &ip, const std::string &port, bool debugMode);
         ~JetpackClient();
 
         std::uint8_t runClient();
@@ -42,6 +42,7 @@ namespace client {
        private:
         std::string _ip;
         std::string _port;
+        bool _debugMode;
         bool _running;
         CLIENT_STATE _state;
         std::queue<std::string> _data;
@@ -50,6 +51,7 @@ namespace client {
         client::Network _network;
         client::Display _displayEngine;
         Player _player;
+        Player _player2;
         bool _MapIsRetrieve;
         std::vector<std::string> _map;
 
@@ -65,7 +67,8 @@ namespace client {
         void _startMap();
         void _retrieveMap(const std::string &map);
         void _endMap();
-        void _startGame();
+        void _startGamePlayerOne();
+        void _startGamePlayerTwo();
         void _updatePlayerPosition(const std::string &pos);
         void _retrieveCoin();
     };
diff --git a/Client/src/JetpackClient/ThreadDisplay.cpp b/Client/src/JetpackClient/ThreadDisplay.cpp
index 2a8f712..b98870b 100644
--- a/Client/src/JetpackClient/ThreadDisplay.cpp
+++ b/Client/src/JetpackClient/ThreadDisplay.cpp
@@ -6,25 +6,23 @@
 //
 
 #include "JetpackClient.hpp"
+#include "Player/Player.hpp"
 #include "client.hpp"
 #include <cmath>
 #include <cstddef>
 #include <cstdlib>
 #include <cstring>
 #include <functional>
-#include <iostream>
 #include <map>
 #include <string>
 
 void client::JetpackClient::_handleWaitingPlayers()
 {
-    std::cout << "Waiting Player\n";
     this->_state = CLIENT_STATE::WAITING;
 }
 
 void client::JetpackClient::_startMap()
 {
-    std::cout << "MAP START\n";
     this->_MapIsRetrieve = true;
 }
 
@@ -47,28 +45,52 @@ void client::JetpackClient::_retrieveMap(const std::string &map)
 
 void client::JetpackClient::_endMap()
 {
-    std::cout << "MAP END\n";
     this->_MapIsRetrieve = false;
 }
 
-void client::JetpackClient::_startGame()
+void client::JetpackClient::_startGamePlayerOne()
 {
-    std::cout << "START GAME\n";
+    this->_player.setPlayerNumber(1);
+    this->_player.setPlayerTransparency(false);
+    this->_player2.setPlayerNumber(2);
+    this->_player2.setPlayerTransparency(true);
     this->_state = CLIENT_STATE::PLAYING;
 }
 
+void client::JetpackClient::_startGamePlayerTwo()
+{
+    this->_player.setPlayerNumber(2);
+    this->_player.setPlayerTransparency(false);
+    this->_player2.setPlayerNumber(1);
+    this->_player2.setPlayerTransparency(true);
+    this->_state = CLIENT_STATE::PLAYING;
+
+}
+
 void client::JetpackClient::_updatePlayerPosition(const std::string &pos)
 {
     if (pos.find("position:") != std::string::npos) {
         size_t value = pos.find(":x=");
         size_t value2 = pos.find(":y=");
-        size_t value3 = pos.find(":s=");
+        size_t value3 = pos.find(":y2=");
+        size_t value4 = pos.find(":s1=");
+        size_t value5 = pos.find(",s2=");
         std::string posX = pos.substr(value + 3, value2 - value - 3);
         std::string posY = pos.substr(value2 + 3, value3 - value2 - 3);
-        std::string score = pos.substr(value3 + 3);
+        std::string posY2 = pos.substr(value3 + 4, value4 - value3 - 4);
+        std::string scorePlayerOne = pos.substr(value4 + 4, value5 - value4 - 4);
+        std::string scorePlayerTwo = pos.substr(value5 + 4);
         this->_player.setPosX(std::atof(posX.c_str()));
+        this->_player2.setPosX(std::atof(posX.c_str()));
         this->_player.setPosY(std::atof(posY.c_str()));
-        this->_player.setScore(std::atoi(score.c_str()));
+        this->_player2.setPosY(std::atof(posY2.c_str()));
+        if (this->_player.getPlayerNumber() == 1) {
+            this->_player.setScore(std::atoi(scorePlayerOne.c_str()));
+            this->_player2.setScore(std::atoi(scorePlayerTwo.c_str()));
+        } else {
+            this->_player.setScore(std::atoi(scorePlayerTwo.c_str()));
+            this->_player2.setScore(std::atoi(scorePlayerOne.c_str()));
+        }
     }
 }
 
@@ -109,19 +131,25 @@ void client::JetpackClient::_gameRunning(const std::string &currentData)
     if (this->_state == CLIENT_STATE::PLAYING) {
         this->_updatePlayerPosition(currentData);
         if (currentData.find("WIN") != std::string::npos) {
-            this->_player.setPlayerWin(true);
-            this->_displayEngine.renderEndGame(this->_player);
+            this->_player.setPlayerWin(WIN_STATE::WIN);
+            this->_displayEngine.renderEndGame(this->_player, this->_player2);
             this->_displayEngine.handleEvent();
             return;
         }
         if (currentData.find("LOSE") != std::string::npos) {
-            this->_player.setPlayerWin(false);
-            this->_displayEngine.renderEndGame(this->_player);
+            this->_player.setPlayerWin(WIN_STATE::LOSE);
+            this->_displayEngine.renderEndGame(this->_player, this->_player2);
+            this->_displayEngine.handleEvent();
+            return;
+        }
+        if (currentData.find("DRAW") != std::string::npos) {
+            this->_player.setPlayerWin(WIN_STATE::DRAW);
+            this->_displayEngine.renderEndGame(this->_player, this->_player2);
             this->_displayEngine.handleEvent();
             return;
         }
         this->_retrieveCoin();
-        this->_displayEngine.renderFrame(this->_player, this->_map);
+        this->_displayEngine.renderFrame(this->_player, this->_player2 ,this->_map);
         this->_data.pop();
         if (this->_displayEngine.handleEvent())
             this->_msg.push("PRESSED");
@@ -147,11 +175,11 @@ void client::JetpackClient::_handleDisplay()
             }},
         {"GAME_START:0",
             [this] {
-                _startGame();
+                _startGamePlayerOne();
             }},
         {"GAME_START:1",
             [this] {
-                _startGame();
+                _startGamePlayerTwo();
             }},
     };
     {
diff --git a/Client/src/JetpackClient/ThreadNetwork.cpp b/Client/src/JetpackClient/ThreadNetwork.cpp
index 432ebf9..a6ce46c 100644
--- a/Client/src/JetpackClient/ThreadNetwork.cpp
+++ b/Client/src/JetpackClient/ThreadNetwork.cpp
@@ -21,7 +21,8 @@ void client::JetpackClient::_runNetworkThread()
             auto data = this->_network.getCommand();
 
             if (!data.empty()) {
-                std::cout << "data = " << data << '\n';
+                if (this->_debugMode)
+                    std::cout << data << '\n';
                 std::lock_guard<std::mutex> lock(this->data_mutex);
                 this->_data.push(data);
             }
diff --git a/Client/src/Network/socket/Socket.hpp b/Client/src/Network/socket/Socket.hpp
index 07f8d3e..dea4dc3 100644
--- a/Client/src/Network/socket/Socket.hpp
+++ b/Client/src/Network/socket/Socket.hpp
@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include "Inputs/Inputs.hpp"
 #include <exception>
 #include <memory>
 #include <netinet/in.h>
diff --git a/Client/src/Player/Player.hpp b/Client/src/Player/Player.hpp
index 3f9a7f2..e6dc5bf 100644
--- a/Client/src/Player/Player.hpp
+++ b/Client/src/Player/Player.hpp
@@ -8,9 +8,12 @@
 #pragma once
 
 #include <cstddef>
-#include <vector>
+#include <cstdint>
+#include <sys/types.h>
 
 namespace client {
+    enum class WIN_STATE : std::uint8_t { WIN, LOSE, DRAW, UNDEFINED };
+
     class Player {
        public:
         Player() = default;
@@ -22,7 +25,11 @@ namespace client {
 
         void setScore(size_t value) { this->_score = value; };
 
-        void setPlayerWin(bool value) { this->_hasWin = value; }
+        void setPlayerWin(WIN_STATE value) { this->_hasWin = value; }
+
+        void setPlayerNumber(ssize_t value) { this->_playerNumber = value; }
+
+        void setPlayerTransparency(bool value) { this->_playerTransparency = value; }
 
         [[nodiscard]] float getPosX() const { return this->_posX; };
 
@@ -30,13 +37,18 @@ namespace client {
 
         [[nodiscard]] size_t getScore() const { return this->_score; };
 
-        [[nodiscard]] bool getPlayerWin() const { return this->_hasWin; };
+        [[nodiscard]] WIN_STATE getPlayerWin() const { return this->_hasWin; };
+
+        [[nodiscard]] ssize_t getPlayerNumber() const { return this->_playerNumber; };
+
+        [[nodiscard]] bool getPlayerTransparency() const { return this->_playerTransparency; };
 
        private:
         float _posX = 0;
         float _posY = 0;
         size_t _score = 0;
-        bool _hasWin = false;
-        std::vector<size_t> _otherScore;
+        WIN_STATE _hasWin = WIN_STATE::UNDEFINED;
+        ssize_t _playerNumber = 0;
+        bool _playerTransparency = false;
     };
 }  // namespace client
diff --git a/Client/src/client.cpp b/Client/src/client.cpp
index 0c731ac..6572270 100644
--- a/Client/src/client.cpp
+++ b/Client/src/client.cpp
@@ -15,6 +15,22 @@
 #include <iostream>
 #include <string>
 
+static int checkEnv(char **env)
+{
+    size_t envChecker = 0;
+    if (env == nullptr)
+        return RET_FAILURE;
+    for (int i = 0; env[i] != nullptr; i += 1) {
+        if (strncmp(env[i], "DISPLAY=", 8) == 0)
+            envChecker += 1;
+        if (strncmp(env[i], "TERM=", 5) == 0)
+            envChecker += 1;
+    }
+    if (envChecker < 2)
+        return RET_FAILURE;
+    return RET_SUCCESS;
+}
+
 static std::string retrievePort(const char *argv[])
 {
     std::string str;
@@ -33,6 +49,22 @@ static std::string retrievePort(const char *argv[])
     return str;
 }
 
+static bool retrieveDebug(const char *argv[])
+{
+    std::string str;
+    bool debugFound = false;
+
+    if (argv == nullptr)
+        return false;
+    for (size_t i = 0; argv[i] != nullptr; i += 1) {
+        if (strcmp(argv[i], "-d") == 0) {
+            debugFound = true;
+            break;
+        }
+    }
+    return debugFound;
+}
+
 static std::string retrieveIP(const char *argv[])
 {
     std::string str;
@@ -51,14 +83,17 @@ static std::string retrieveIP(const char *argv[])
     return str;
 }
 
-uint8_t launchClient(const int argc, char const *argv[])
+uint8_t launchClient(const int argc, char const *argv[], char **env)
 {
     if (argc < 5)
         return RET_FAILURE;
     std::string ip = retrieveIP(argv);
     std::string port = retrievePort(argv);
+    bool debugMode = retrieveDebug(argv);
+    if (checkEnv(env) == RET_FAILURE)
+        return RET_FAILURE;
     try {
-        client::JetpackClient NewClient(ip, port);
+        client::JetpackClient NewClient(ip, port, debugMode);
         NewClient.runClient();
     } catch (client::Socket::SocketError &e) {
         std::cerr << e.what() << '\n';
diff --git a/Client/src/client.hpp b/Client/src/client.hpp
index fe0e605..340115a 100644
--- a/Client/src/client.hpp
+++ b/Client/src/client.hpp
@@ -11,4 +11,4 @@
 #define RET_SUCCESS 0
 #define RET_FAILURE -1
 
-uint8_t launchClient(int argc, char const *argv[]);
+uint8_t launchClient(int argc, char const *argv[], char **env);
diff --git a/Client/src/main.cpp b/Client/src/main.cpp
index 3b288ba..b7d4453 100644
--- a/Client/src/main.cpp
+++ b/Client/src/main.cpp
@@ -6,7 +6,7 @@
 //
 
 #include "client.hpp"
-int main(const int argc, char const *argv[])
+int main(const int argc, char const *argv[], char **env)
 {
-    return launchClient(argc, argv);
+    return launchClient(argc, argv, env);
 }
diff --git a/Server/src/instructions.c b/Server/src/instructions.c
index 14aad84..abdb4b4 100644
--- a/Server/src/instructions.c
+++ b/Server/src/instructions.c
@@ -19,7 +19,6 @@
 const command_t commands[] = {
     {"PRESSED\r\n", move_up}, {"GETPOS\r\n", send_pos}, {NULL, NULL}};
 
-
 static void send_death(server_t *server)
 {
     const char msgWin[] = "WIN\r\n";
@@ -42,42 +41,84 @@ static void send_draw(server_t *server)
 {
     const char msgDraw[] = "DRAW\r\n";
 
-    send(server->players[1]->socket->fd, msgDraw, strlen(msgDraw), 0);
-    send(server->players[0]->socket->fd, msgDraw, strlen(msgDraw), 0);
+    if (server->players[1])
+        send(server->players[1]->socket->fd, msgDraw, strlen(msgDraw), 0);
+    if (server->players[0])
+        send(server->players[0]->socket->fd, msgDraw, strlen(msgDraw), 0);
 }
 
-static void send_end(server_t *server)
+static void send_winner(server_t *server, size_t score1, size_t score2)
 {
     const char msgWin[] = "WIN\r\n";
     const char msgLose[] = "LOSE\r\n";
-    const size_t score1 = server->players[0]->score;
-    const size_t score2 = server->players[1]->score;
 
-    for (size_t i = 0; i < server->nb_player; i += 1)
-        if (server->players[i]->is_alive == TRUE)
-            return;
     if (score1 > score2) {
-        send(server->players[0]->socket->fd, msgWin, strlen(msgWin), 0);
-        send(server->players[1]->socket->fd, msgLose, strlen(msgLose), 0);
+        if (server->players[0])
+            send(server->players[0]->socket->fd, msgWin, strlen(msgWin), 0);
+        if (server->players[1])
+            send(server->players[1]->socket->fd, msgLose, strlen(msgLose), 0);
         return;
     }
     if (score1 < score2) {
-        send(server->players[1]->socket->fd, msgWin, strlen(msgWin), 0);
-        send(server->players[0]->socket->fd, msgLose, strlen(msgLose), 0);
+        if (server->players[1])
+            send(server->players[1]->socket->fd, msgWin, strlen(msgWin), 0);
+        if (server->players[0])
+            send(server->players[0]->socket->fd, msgLose, strlen(msgLose), 0);
         return;
     }
     send_draw(server);
 }
 
+static void send_end(server_t *server)
+{
+    size_t score1 = 0;
+    size_t score2 = 0;
+
+    if (server->players[0])
+        score1 = server->players[0]->score;
+    if (server->players[1])
+        score2 = server->players[1]->score;
+    for (size_t i = 0; i < server->nb_player; i += 1)
+        if (server->players[i]->is_alive == TRUE &&
+            server->players[i]->ended != TRUE)
+            return;
+    send_winner(server, score1, score2);
+}
+
+static int check_line_laser(server_t *server, player_t *player, int line)
+{
+    const float hitbox_width = 0.9;
+    const float left = player->position.x - (hitbox_width / 2.0);
+    const float right = player->position.x + (hitbox_width / 2.0);
+    const int start_x = (int)left;
+    const size_t end_x = right < 0 ? 0 : (size_t)right;
+    size_t map_y = MAP_HEIGHT - 1 - line;
+
+    for (size_t x = start_x; x <= end_x; x += 1) {
+        if (line < 0 || x >= strlen(server->map[0]) || line >= MAP_HEIGHT)
+            continue;
+        if (server->map[map_y][x] == 'e') {
+            player->is_alive = FALSE;
+            player->ended = TRUE;
+            server->game_state = ENDED;
+            send_death(server);
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
 static int check_collision(server_t *server, player_t *player)
 {
-    if (server->map[MAP_HEIGHT - 1 - (size_t)player->position.y]
-        [(size_t)player->position.x] == 'e') {
-        player->is_alive = FALSE;
-        player->ended = TRUE;
-        server->game_state = ENDED;
-        send_death(server);
-        return TRUE;
+    const float hitbox_height = 0.7;
+    const float bottom = player->position.y - (hitbox_height / 2.0);
+    const float top = player->position.y + (hitbox_height / 2.0);
+    const int start_y = (int)bottom;
+    const int end_y = (int)top;
+
+    for (int y = start_y; y <= end_y; y += 1) {
+        if (check_line_laser(server, player, y))
+            return TRUE;
     }
     return FALSE;
 }
@@ -109,10 +150,10 @@ int execute_instructions(server_t *server, player_t *player, size_t i)
     for (size_t i = 0; commands[i].name != NULL; i += 1) {
         if (strcmp(commands[i].name, buff) == 0) {
             commands[i].function(server, player);
+            send_end(server);
             return SUCCESS;
         }
     }
-    send_end(server);
     send(player->socket->fd, unknown, strlen(unknown), 0);
     return SUCCESS;
 }
diff --git a/Server/src/move.c b/Server/src/move.c
index eb9c02c..0363af7 100644
--- a/Server/src/move.c
+++ b/Server/src/move.c
@@ -25,7 +25,7 @@ static void check_line_coin(player_t *player, int line)
     const size_t end_x = right < 0 ? 0 : (size_t)right;
     size_t map_y = 0;
 
-    for (size_t x = start_x; x <= end_x; ++x) {
+    for (size_t x = start_x; x <= end_x; x += 1) {
         if (line < 0 || x >= strlen(player->map[0]) || line >= MAP_HEIGHT)
             continue;
         map_y = MAP_HEIGHT - 1 - (size_t)line;
@@ -44,7 +44,7 @@ static void check_coin(player_t *player)
     const int start_y = (int)bottom;
     const int end_y = (int)top;
 
-    for (int y = start_y; y <= end_y; ++y) {
+    for (int y = start_y; y <= end_y; y += 1) {
         check_line_coin(player, y);
     }
 }
@@ -63,10 +63,6 @@ static long compute_last_time(player_t *player, struct timespec *current_time)
 static void set_up_pos(
     server_t *server, player_t *player, long time_since_last_ask)
 {
-    char msg[BUFFSIZE] = {0};
-    const size_t p1_score = server->players[0] ? server->players[0]->score : 0;
-    const size_t p2_score = server->players[1] ? server->players[1]->score : 0;
-
     player->position.y += 0.05 * time_since_last_ask;
     player->position.x += 0.02 * time_since_last_ask;
     if (player->position.y > MAP_HEIGHT - 1) {
@@ -75,19 +71,12 @@ static void set_up_pos(
     if (player->position.x > strlen(server->map[0]) - 1) {
         player->position.x = strlen(server->map[0]) - 1;
         player->ended = TRUE;
-        snprintf(
-            msg, BUFFSIZE, "GAME_END:p1%lu:p2%lu\r\n", p1_score, p2_score);
-        send(player->socket->fd, msg, strlen(msg), 0);
     }
 }
 
 static void set_down_pos(
     server_t *server, player_t *player, long time_since_last_ask)
 {
-    char msg[BUFFSIZE] = {0};
-    const size_t p1_score = server->players[0] ? server->players[0]->score : 0;
-    const size_t p2_score = server->players[1] ? server->players[1]->score : 0;
-
     player->position.y -= 0.05 * time_since_last_ask;
     player->position.x += 0.02 * time_since_last_ask;
     if (player->position.y < 0)
@@ -98,27 +87,44 @@ static void set_down_pos(
     if (player->position.x > (double)strlen(server->map[0]) - 1) {
         player->position.x = (double)strlen(server->map[0]) - 1;
         player->ended = TRUE;
-        snprintf(
-            msg, BUFFSIZE, "GAME_END:p1%lu:p2%lu\r\n", p1_score, p2_score);
-        send(player->socket->fd, msg, strlen(msg), 0);
     }
 }
 
+static double get_other_data(
+    server_t *server, player_t *player, size_t *score1, size_t *score2)
+{
+    double posY2 = 0;
+
+    if (server->players[0]) {
+        if (server->players[0] != player)
+            posY2 = server->players[0]->position.y;
+        *score1 = server->players[0]->score;
+    }
+    if (server->players[1]) {
+        if (server->players[1] != player)
+            posY2 = server->players[1]->position.y;
+        *score2 = server->players[1]->score;
+    }
+    return posY2;
+}
+
 void move_up(server_t *server, player_t *player)
 {
     char buff[BUFFSIZE];
     struct timespec current_time = {0};
     long time_since_last_ask = 0;
-    size_t score1 = server->players[0]->score;
-    size_t score2 = server->players[1]->score;
+    size_t score1 = 0;
+    size_t score2 = 0;
+    double posY2 = 0;
 
+    posY2 = get_other_data(server, player, &score1, &score2);
     clock_gettime(CLOCK_MONOTONIC, &current_time);
     time_since_last_ask = compute_last_time(player, &current_time);
     set_up_pos(server, player, time_since_last_ask);
     check_coin(player);
     player->time_last_ask = current_time;
-    snprintf(buff, BUFFSIZE, "position:x=%f:y=%f:s1=%zu,s2=%zu\r\n",
-        player->position.x, player->position.y, score1, score2);
+    snprintf(buff, BUFFSIZE, "position:x=%f:y=%f:y2=%f:s1=%zu,s2=%zu\r\n",
+        player->position.x, player->position.y, posY2, score1, score2);
     send(player->socket->fd, buff, strlen(buff), 0);
 }
 
@@ -127,13 +133,17 @@ void send_pos(server_t *server, player_t *player)
     char buff[BUFFSIZE];
     struct timespec current_time = {0};
     long time_since_last_ask = 0;
+    size_t score1 = 0;
+    size_t score2 = 0;
+    double posY2 = 0;
 
+    posY2 = get_other_data(server, player, &score1, &score2);
     clock_gettime(CLOCK_MONOTONIC, &current_time);
     time_since_last_ask = compute_last_time(player, &current_time);
     set_down_pos(server, player, time_since_last_ask);
     check_coin(player);
     player->time_last_ask = current_time;
-    snprintf(buff, BUFFSIZE, "position:x=%f:y=%f:s=%zu\r\n",
-        player->position.x, player->position.y, player->score);
+    snprintf(buff, BUFFSIZE, "position:x=%f:y=%f:y2=%f:s1=%zu,s2=%zu\r\n",
+        player->position.x, player->position.y, posY2, score1, score2);
     send(player->socket->fd, buff, strlen(buff), 0);
 }