add valgrind

include/server/ConnectionHandler.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <server/Server.h>
-
-namespace td {
-namespace server {
-
-class IServerSocket;
-
-class ConnectionHandler : public protocol::PacketHandler {
-  private:
-	IServerSocket& m_Server;
-	PlayerID m_Player;
-
-  public:
-	ConnectionHandler(IServerSocket& a_Server, PlayerID a_Player);
-	~ConnectionHandler() = default;
-
-	virtual void Handle(const protocol::packets::PlayerLoginPacket& a_Packet) override;
-	virtual void Handle(const protocol::packets::DisconnectPacket& a_Packet) override;
-};
-
-}  // namespace server
-}  // namespace td

include/server/IServerSocket.h

@@ -12,7 +12,7 @@ class IServerSocket {
 	using PlayerPacketHandlerType = std::unique_ptr<protocol::PacketHandler>(PlayerID);
 	using PlayerPacketHandler = std::function<PlayerPacketHandlerType>;
 
-	utils::Signal<PlayerID, const protocol::PlayerInfo&> OnPlayerJoin;
+	utils::Signal<PlayerID, const PlayerInfo&> OnPlayerJoin;
 	utils::Signal<PlayerID> OnPlayerLeave;
 	utils::Signal<PlayerID, const protocol::PacketBase&> OnReceive;
 

include/server/PlayerManager.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <td/protocol/packet/Packets.h>
+
+namespace td {
+namespace server {
+
+class IServerSocket;
+
+class PlayerManager {
+  private:
+	std::map<PlayerID, PlayerInfo> m_Players;
+	std::shared_ptr<IServerSocket> m_Socket;
+
+  public:
+	PlayerManager(const std::shared_ptr<IServerSocket>& a_Socket);
+	~PlayerManager();
+
+	void RemovePlayer(PlayerID a_Player);
+	PlayerInfo GetPlayer(PlayerID a_Player);
+
+  private:
+	class ConnectionHandler : public protocol::PacketHandler {
+	  private:
+		std::map<PlayerID, PlayerInfo>& m_Players;
+		IServerSocket& m_Socket;
+		PlayerID m_Player;
+
+	  public:
+		ConnectionHandler(std::map<PlayerID, PlayerInfo>& a_Players, IServerSocket& a_Socket, PlayerID a_Player);
+		~ConnectionHandler() = default;
+
+		virtual void Handle(const protocol::packets::PlayerLoginPacket& a_Packet) override;
+		virtual void Handle(const protocol::packets::DisconnectPacket& a_Packet) override;
+	};
+};
+
+}  // namespace server
+}  // namespace td

include/server/Server.h

@@ -2,6 +2,7 @@
 
 #include <server/IServerSocket.h>
 #include <td/common/StateMachine.h>
+#include <server/PlayerManager.h>
 
 namespace td {
 namespace server {
@@ -11,6 +12,7 @@ class ServerState;
 class Server : public StateMachine<Server, void, float> {
   private:
 	std::shared_ptr<IServerSocket> m_Socket;
+	PlayerManager m_Players;
 	float m_LastMspt;
 
   public:

include/server/ServerState.h

@@ -10,7 +10,7 @@ class ServerState : public Server::State, private utils::SlotGuard {
   public:
 	virtual void HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) = 0;
 	virtual void Update(float a_Delta) = 0;
-	virtual void OnPlayerJoin(PlayerID a_Id, const td::protocol::PlayerInfo& a_Info) {}
+	virtual void OnPlayerJoin(PlayerID a_Id, const td::PlayerInfo& a_Info) {}
 	virtual void OnPlayerLeave(PlayerID a_Id) {}
 
 	ServerState(Server& a_Server);

include/td/Types.h

@@ -78,6 +78,11 @@ enum class Direction : std::uint8_t {
 	NegativeY = 1 << 3,
 };
 
+struct PlayerInfo {
+	PlayerID m_PlayerId;
+	std::string m_PlayerName;
+};
+
 sp::DataBuffer& operator<<(sp::DataBuffer& a_Buffer, const EntityCoords& a_Coords);
 sp::DataBuffer& operator<<(sp::DataBuffer& a_Buffer, const FpFloat& a_Float);
 

include/td/protocol/packet/PacketData.h

@@ -16,11 +16,6 @@
 namespace td {
 namespace protocol {
 
-struct PlayerInfo {
-	PlayerID m_PlayerId;
-	std::string m_PlayerName;
-};
-
 struct MapData {
 
 };

src/server/ConnectionHandler.cpp

@@ -1,30 +0,0 @@
-#include <server/ConnectionHandler.h>
-
-#include <iostream>
-
-namespace td {
-namespace server {
-
-ConnectionHandler::ConnectionHandler(IServerSocket& a_Server, PlayerID a_Player) : m_Server(a_Server), m_Player(a_Player) {}
-
-void ConnectionHandler::Handle(const protocol::packets::PlayerLoginPacket& a_Packet) {
-	protocol::PlayerInfo pInfo{m_Player, a_Packet->m_PlayerName};
-	
-	// TODO
-	std::vector<protocol::PlayerInfo> players;
-	
-	m_Server.Send(m_Player, protocol::packets::LoggingSuccessPacket(m_Player));
-	m_Server.Send(m_Player, protocol::packets::PlayerListPacket(players));
-	m_Server.Broadcast(protocol::packets::PlayerJoinPacket(pInfo));
-	
-	m_Server.OnPlayerJoin(m_Player, pInfo);
-	std::cout << "[Server] " << a_Packet->m_PlayerName << " tried to join !\n";
-}
-
-void ConnectionHandler::Handle(const protocol::packets::DisconnectPacket& a_Packet) {
-	std::cout << "[Server] " << +m_Player << " wants to disconnect !\n";
-	m_Server.Disconnect(m_Player);
-}
-
-}  // namespace server
-}  // namespace td

src/server/IServerSocket.cpp

@@ -1,12 +1,9 @@
 #include <server/IServerSocket.h>
 
-#include <server/ConnectionHandler.h>
-
 namespace td {
 namespace server {
 
 IServerSocket::IServerSocket() {
-	RegisterHandler([this](PlayerID a_PlayerId) { return std::make_unique<ConnectionHandler>(*this, a_PlayerId); });
 }
 
 void IServerSocket::RegisterHandler(const PlayerPacketHandler& a_Handler) {

src/server/PlayerManager.cpp

@@ -0,0 +1,54 @@
+#include <server/PlayerManager.h>
+
+#include <iostream>
+#include <server/IServerSocket.h>
+
+namespace td {
+namespace server {
+
+PlayerManager::ConnectionHandler::ConnectionHandler(
+	std::map<PlayerID, PlayerInfo>& a_Players, IServerSocket& a_Socket, PlayerID a_Player) :
+	m_Players(a_Players), m_Socket(a_Socket), m_Player(a_Player) {}
+
+void PlayerManager::ConnectionHandler::Handle(const protocol::packets::PlayerLoginPacket& a_Packet) {
+	PlayerInfo pInfo{m_Player, a_Packet->m_PlayerName};
+
+	std::vector<PlayerInfo> players;
+	players.reserve(m_Players.size());
+	for (auto& [id, player] : m_Players) {
+		players.push_back(player);
+	}
+
+	m_Socket.Send(m_Player, protocol::packets::LoggingSuccessPacket(m_Player));
+	m_Socket.Send(m_Player, protocol::packets::PlayerListPacket(players));
+	m_Socket.Broadcast(protocol::packets::PlayerJoinPacket(pInfo));
+
+	m_Players.emplace(m_Player, pInfo);
+	m_Socket.OnPlayerJoin(m_Player, pInfo);
+	std::cout << "[Server] " << a_Packet->m_PlayerName << " joined !\n";
+}
+
+void PlayerManager::ConnectionHandler::Handle(const protocol::packets::DisconnectPacket& a_Packet) {
+	std::cout << "[Server] " << +m_Player << " wants to disconnect !\n";
+	m_Socket.Disconnect(m_Player);
+	m_Players.erase(m_Player);
+}
+
+PlayerManager::PlayerManager(const std::shared_ptr<IServerSocket>& a_Socket) : m_Socket(a_Socket) {
+	a_Socket->RegisterHandler(
+		[this](PlayerID a_PlayerId) { return std::make_unique<ConnectionHandler>(m_Players, *m_Socket, a_PlayerId); });
+}
+
+PlayerManager::~PlayerManager() {}
+
+void PlayerManager::RemovePlayer(PlayerID a_Player) {
+	m_Socket->Disconnect(a_Player);
+	m_Players.erase(a_Player);
+}
+
+PlayerInfo PlayerManager::GetPlayer(PlayerID a_Player) {
+	return m_Players.at(a_Player);
+}
+
+}  // namespace server
+}  // namespace td

src/server/Server.cpp

@@ -5,7 +5,7 @@
 namespace td {
 namespace server {
 
-Server::Server(const std::shared_ptr<IServerSocket>& a_Socket) : m_Socket(a_Socket), m_LastMspt(0) {}
+Server::Server(const std::shared_ptr<IServerSocket>& a_Socket) : m_Socket(a_Socket), m_Players(a_Socket), m_LastMspt(0) {}
 
 void Server::Update(float a_Delta) {
 	auto before = std::chrono::system_clock::now();

xmake.lua

@@ -13,6 +13,8 @@ if is_mode("release") then
     set_warnings("all", "error")
 end
 
+option("valgrind", {description = "Run binary with valgrind", default = false})
+
 target("Tower-Defense2")
     add_includedirs("include", {public = true})
     set_kind("binary")
@@ -21,6 +23,11 @@ target("Tower-Defense2")
     set_rundir(".")
     add_defines("TD_GL_LOADER_GLEW")
 
+    if has_config("valgrind") then
+        on_run(function (target)
+            os.execv("valgrind", {"-s", "--leak-check=full", target:targetfile()})
+        end)
+    end
 
 
 -- Tests