server state test

include/server/IServerState.h

@@ -18,16 +18,13 @@ class IServerState {
 	virtual void OnPlayerJoin(PlayerID a_Id) = 0;
 	virtual void OnPlayerLeave(PlayerID a_Id) = 0;
 
-	IServerState(IServerSocket& a_Server);
-	virtual ~IServerState() {}
+	IServerState();
+	virtual ~IServerState();
 
   private:
-	IServerSocket& m_Socket;
 	Server* m_Server;
 
-	void SetServer(Server* a_Server) {
-		m_Server = a_Server;
-	}
+	void SetServer(Server* a_Server);
 
 	friend class Server;
 };

include/server/Server.h

@@ -9,11 +9,11 @@ namespace server {
 
 class Server {
   private:
+	std::shared_ptr<IServerSocket> m_Socket;
 	std::shared_ptr<IServerState> m_State;
-	std::unique_ptr<IServerSocket> m_Socket;
 
   public:
-	Server(std::unique_ptr<IServerSocket>&& a_Socket) : m_Socket(std::move(a_Socket)) {}
+	Server(const std::shared_ptr<IServerSocket>& a_Socket) : m_Socket(a_Socket) {}
 
 	void Update(float a_Delta) {
 		m_State->Update(a_Delta);
@@ -24,6 +24,7 @@ class Server {
 		m_State->SetServer(this);
 	}
 
+	friend class IServerState;
 };
 
 }  // namespace server

include/server/socket/TcpSocket.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <server/IServerSocket.h>
+
+namespace td {
+namespace server {
+
+class TcpSocket : public IServerSocket {
+  private:
+	/* data */
+  public:
+	TcpSocket(/* args */) {}
+	~TcpSocket() {}
+
+	virtual void Send(PlayerID, const protocol::PacketBase&) {}
+};
+
+}  // namespace server
+}  // namespace td

include/server/state/EndGameState.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <server/IServerState.h>
+
+namespace td {
+namespace server {
+
+class EndGameState : public IServerState {
+  private:
+	/* data */
+  public:
+	EndGameState(/* args */) {}
+	~EndGameState() {}
+};
+
+}  // namespace server
+}  // namespace td

include/server/state/GameState.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <server/IServerState.h>
+
+namespace td {
+namespace server {
+
+class GameState : public IServerState{
+  private:
+	/* data */
+  public:
+	GameState(/* args */) {}
+	~GameState() {}
+
+	virtual void HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) override;
+	virtual void Update(float a_Delta) override;
+	virtual void OnPlayerJoin(PlayerID a_Id) override;
+	virtual void OnPlayerLeave(PlayerID a_Id) override;
+};
+
+}  // namespace server
+}  // namespace td

include/server/state/LobbyState.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <server/IServerState.h>
+
+namespace td {
+namespace server {
+
+class LobbyState : public IServerState {
+  private:
+	/* data */
+  public:
+	LobbyState(/* args */) {}
+	~LobbyState() {}
+
+	virtual void HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) override;
+	virtual void Update(float a_Delta) override;
+	virtual void OnPlayerJoin(PlayerID a_Id) override;
+	virtual void OnPlayerLeave(PlayerID a_Id) override;
+};
+
+}  // namespace server
+}  // namespace td

include/td/misc/Signal.h

@@ -11,7 +11,8 @@ namespace utils {
 template <typename... Args>
 class Signal : private NonCopyable {
   private:
-	using CallBack = std::function<void(Args...)>;
+	using FnType = void(Args...);
+	using CallBack = std::function<FnType>;
 
 	std::vector<CallBack> m_Callbacks;
 
@@ -20,6 +21,12 @@ class Signal : private NonCopyable {
 		m_Callbacks.push_back(std::move(a_Callback));
 	}
 
+	void Disconnect(const CallBack& a_Callback) {
+		auto it = std::find_if(m_Callbacks.begin(), m_Callbacks.end(),
+			[&a_Callback](CallBack& callback) { return a_Callback.template target<FnType>() == callback.template target<FnType>(); });
+		m_Callbacks.erase(it);
+	}
+
 	void operator()(Args... args) const {
 		for (const CallBack& callback : m_Callbacks) {
 			callback(args...);

src/main.cpp

@@ -15,6 +15,10 @@
 #include <sp/io/MessageStream.h>
 #include <sp/io/StdIo.h>
 
+#include <server/Server.h>
+#include <server/socket/TcpSocket.h>
+#include <server/state/LobbyState.h>
+
 class WorldApply : public td::protocol::PacketHandler {
   private:
 	td::game::World& m_World;
@@ -92,7 +96,6 @@ td::sim::GameHistory GetCustomHistory() {
 	return gh;
 }
 
-
 int main(int argc, char** argv) {
 	td::game::World w = GetWorld();
 
@@ -128,6 +131,15 @@ int main(int argc, char** argv) {
 		}
 	});
 
+
+	// server
+	auto socket = std::make_shared<td::server::TcpSocket>();
+	td::server::Server server(socket);
+	server.UpdateState(std::make_shared<td::server::LobbyState>());
+	server.Update(1.0f);
+	server.Update(1.0f);
+	socket->OnDisconnect(0);
+
 	while (!display.IsCloseRequested()) {
 		display.PollEvents();
 		float lerp = simulation.Update();

src/server/IServerState.cpp

@@ -4,21 +4,26 @@
 namespace td {
 namespace server {
 
-IServerState::IServerState(IServerSocket& a_Socket) : m_Socket(a_Socket) {
-	// TODO: don't do it like this
-	m_Socket.OnConnect.Connect([this](PlayerID a_Player){
-		OnPlayerJoin(a_Player);
-	});
-	m_Socket.OnDisconnect.Connect([this](PlayerID a_Player){
-		OnPlayerLeave(a_Player);
-	});
-	m_Socket.OnReceive.Connect([this](PlayerID a_Player, const protocol::PacketBase& a_Packet){
-		HandlePacket(a_Player, a_Packet);
-	});
+void IServerState::SetServer(Server* a_Server) {
+	assert(a_Server);
+	m_Server = a_Server;
+	m_Server->m_Socket->OnConnect.Connect(std::bind(&IServerState::OnPlayerJoin, this, std::placeholders::_1));
+	m_Server->m_Socket->OnDisconnect.Connect(std::bind(&IServerState::OnPlayerLeave, this, std::placeholders::_1));
+	m_Server->m_Socket->OnReceive.Connect(std::bind(&IServerState::HandlePacket, this, std::placeholders::_1, std::placeholders::_2));
+}
+
+IServerState::IServerState() : m_Server(nullptr) {}
+
+IServerState::~IServerState() {
+	if (!m_Server)
+		return;
+	m_Server->m_Socket->OnConnect.Disconnect(std::bind(&IServerState::OnPlayerJoin, this, std::placeholders::_1));
+	m_Server->m_Socket->OnDisconnect.Disconnect(std::bind(&IServerState::OnPlayerLeave, this, std::placeholders::_1));
+	m_Server->m_Socket->OnReceive.Disconnect(std::bind(&IServerState::HandlePacket, this, std::placeholders::_1, std::placeholders::_2));
 }
 
 void IServerState::SendPacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) {
-	m_Socket.Send(a_Id, a_Packet);
+	m_Server->m_Socket->Send(a_Id, a_Packet);
 }
 
 void IServerState::SetNewState(const std::shared_ptr<IServerState>& a_NewState) {

src/server/socket/TcpSocket.cpp

@@ -0,0 +1,8 @@
+#include <server/socket/TcpSocket.h>
+
+namespace td {
+namespace server {
+
+
+}  // namespace server
+}  // namespace td

src/server/state/GameState.cpp

@@ -0,0 +1,25 @@
+#include <server/state/GameState.h>
+
+#include <iostream>
+
+namespace td {
+namespace server {
+
+void GameState::HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) {
+
+}
+
+void GameState::Update(float a_Delta) {
+	
+}
+
+void GameState::OnPlayerJoin(PlayerID a_Id) {
+
+}
+
+void GameState::OnPlayerLeave(PlayerID a_Id) {
+	std::cout << "Game leave !" << std::endl;
+}
+
+}  // namespace server
+}  // namespace td

src/server/state/LobbyState.cpp

@@ -0,0 +1,26 @@
+#include <server/state/LobbyState.h>
+#include <server/state/GameState.h>
+
+#include <iostream>
+
+namespace td {
+namespace server {
+
+void LobbyState::HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) {
+
+}
+
+void LobbyState::Update(float a_Delta) {
+	SetNewState(std::make_shared<GameState>());
+}
+
+void LobbyState::OnPlayerJoin(PlayerID a_Id) {
+
+}
+
+void LobbyState::OnPlayerLeave(PlayerID a_Id) {
+	std::cout << "Lobby leave !" << std::endl;
+}
+
+}  // namespace server
+}  // namespace td