send world to client

src/server/IServerSocket.cpp

@@ -19,10 +19,11 @@ void IServerSocket::UnregisterHandler(const PlayerPacketHandler& a_Handler) {
 void IServerSocket::OnConnectPeer(PeerID a_PeerId) {
 	// here, the client is not a player yet (we need to wait for auth)
 	m_Ids.AddConnection(a_PeerId);
+	OnPlayerConnect(m_Ids.GetPlayerId(a_PeerId));
 }
 
 void IServerSocket::OnDisconnectPeer(PeerID a_PeerId) {
-	OnPlayerLeave(m_Ids.GetPlayerId(a_PeerId));
+	OnPlayerDisconnect(m_Ids.GetPlayerId(a_PeerId));
 	m_Ids.RemovePeer(a_PeerId);
 }
 

src/server/PlayerManager.cpp

@@ -6,48 +6,52 @@
 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) {}
+PlayerManager::ConnectionHandler::ConnectionHandler(PlayerManager& a_PlayerManager, PlayerID a_Player) :
+	m_PlayerManager(a_PlayerManager), 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);
+	auto& socket = *m_PlayerManager.m_Socket;
+	auto& players = m_PlayerManager.m_Players;
+
+	std::vector<PlayerInfo> playerInfos;
+	playerInfos.reserve(players.size());
+	for (auto& [id, player] : players) {
+		playerInfos.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));
+	socket.Send(m_Player, protocol::packets::LoggingSuccessPacket(m_Player));
+	socket.Send(m_Player, protocol::packets::PlayerListPacket(playerInfos));
+	socket.Broadcast(protocol::packets::PlayerJoinPacket(pInfo));
 
-	m_Players.emplace(m_Player, pInfo);
-	m_Socket.OnPlayerJoin(m_Player, pInfo);
+	players.emplace(m_Player, pInfo);
+	m_PlayerManager.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";
-	Disconnect(m_Players, m_Socket, m_Player);
+	m_PlayerManager.Disconnect(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); });
+	a_Socket->RegisterHandler([this](PlayerID a_PlayerId) { return std::make_unique<ConnectionHandler>(*this, a_PlayerId); });
+	a_Socket->OnPlayerDisconnect.Connect(std::bind(&PlayerManager::RemovePlayer, this, std::placeholders::_1));
 }
 
-void PlayerManager::ConnectionHandler::Disconnect(std::map<PlayerID, PlayerInfo>& a_Players, IServerSocket& a_Socket, PlayerID a_Player) {
-	a_Socket.Disconnect(a_Player);
-	a_Socket.Broadcast(protocol::packets::PlayerLeavePacket(a_Player));
-	a_Players.erase(a_Player);
+void PlayerManager::Disconnect(PlayerID a_Player) {
+	if (!m_Players.contains(a_Player))
+		return;
+	std::cout << "[Server] " << +a_Player << " wants to disconnect !\n";
+	m_Socket->Disconnect(a_Player);
+	m_Socket->Broadcast(protocol::packets::PlayerLeavePacket(a_Player));
+	m_Players.erase(a_Player);
 }
 
 PlayerManager::~PlayerManager() {}
 
 void PlayerManager::RemovePlayer(PlayerID a_Player) {
-	ConnectionHandler::Disconnect(m_Players, *m_Socket, a_Player);
+	Disconnect(a_Player);
 }
 
 PlayerInfo PlayerManager::GetPlayer(PlayerID a_Player) {

src/server/Server.cpp

@@ -2,10 +2,14 @@
 
 #include <chrono>
 
+#include <server/state/LobbyState.h>
+
 namespace td {
 namespace server {
 
-Server::Server(const std::shared_ptr<IServerSocket>& a_Socket) : m_Socket(a_Socket), m_Players(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) {
+	ChangeState<LobbyState>();
+}
 
 void Server::Update(float a_Delta) {
 	auto before = std::chrono::system_clock::now();

src/server/ServerState.cpp

@@ -8,8 +8,8 @@ namespace server {
 
 ServerState::ServerState(Server& a_Server) : Server::State(a_Server) {
 	Connect(m_StateMachine.m_Socket->OnReceive, std::bind(&ServerState::HandlePacket, this, std::placeholders::_1, std::placeholders::_2));
-	Connect(m_StateMachine.m_Socket->OnPlayerJoin, std::bind(&ServerState::OnPlayerJoin, this, std::placeholders::_1, std::placeholders::_2));
-	Connect(m_StateMachine.m_Socket->OnPlayerLeave, std::bind(&ServerState::OnPlayerLeave, this, std::placeholders::_1));
+	Connect(m_StateMachine.m_Players.OnPlayerJoin, std::bind(&ServerState::OnPlayerJoin, this, std::placeholders::_1, std::placeholders::_2));
+	Connect(m_StateMachine.m_Players.OnPlayerLeave, std::bind(&ServerState::OnPlayerLeave, this, std::placeholders::_1));
 }
 
 ServerState::~ServerState() {}

src/server/state/GameState.cpp

@@ -1,5 +1,6 @@
 #include <server/state/GameState.h>
 #include <server/state/GameStateHandler.h>
+#include <td/protocol/packet/PacketSerialize.h>
 
 #include <iostream>
 
@@ -7,7 +8,9 @@ namespace td {
 namespace server {
 
 GameState::GameState(Server& a_Server, const std::shared_ptr<game::World>& a_World) : ServerState(a_Server), m_World(a_World), m_Simulation(*m_World, STEP_TIME), m_Time(0) {
-	std::cout << "Switched to Game state !\n";
+	std::cout << "[Server] Switched to Game state !\n";
+	BroadcastPacket(a_World->GetPacketHeader());
+	BroadcastPacket(a_World->GetPacketData());
 	BroadcastPacket(m_Simulation.MakePacket());
 }
 

src/server/state/LobbyState.cpp

@@ -1,18 +1,60 @@
-#include <server/state/LobbyState.h>
 #include <server/state/GameState.h>
+#include <server/state/LobbyState.h>
 
 #include <iostream>
+#include <fstream>
+#include <td/protocol/packet/PacketSerialize.h>
+
+#include <sp/common/DataBuffer.h>
+#include <sp/extensions/Compress.h>
+#include <sp/io/MessageStream.h>
+#include <sp/io/StdIo.h>
 
 namespace td {
 namespace server {
 
-void LobbyState::HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) {
+void Save(const protocol::PacketBase& header, const protocol::PacketBase& data) {
+	auto comp = std::make_shared<sp::ZlibCompress>();
 
+	std::ofstream fStream("test/tdmap.tdmap3");
+	auto out = std::make_shared<sp::StdOuput>(fStream);
+
+	sp::MessageStream<protocol::PacketFactory> stream(std::move(out), std::move(comp));
+
+	stream.WriteMessage(header, false);
+	stream.WriteMessage(data, false);
 }
 
-void LobbyState::Update(float a_Delta) {
-	m_StateMachine.ChangeState<GameState>(m_World);
+game::WorldPtr GetWorld() {
+	auto comp = std::make_shared<sp::ZlibCompress>();
+
+	std::ifstream fStream("test/tdmap.tdmap2");
+	auto out = std::make_shared<sp::StdInput>(fStream);
+
+	sp::MessageStream<protocol::PacketFactory> stream(std::move(out), std::move(comp));
+
+	auto header = stream.ReadConcreteMessage<protocol::packets::WorldHeaderPacket>();
+	auto data = stream.ReadConcreteMessage<protocol::packets::WorldDataPacket>();
+
+	auto w = std::make_shared<game::World>();
+
+	w->LoadMap(**header);
+	w->LoadMap(**data);
+
+	// Save(*header, *data);
+
+	return w;
 }
 
+LobbyState::LobbyState(Server& a_Server) : ServerState(a_Server) {}
+
+void LobbyState::HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) {}
+
+void LobbyState::OnPlayerJoin(PlayerID a_Id, const td::PlayerInfo& a_Info) {
+	m_StateMachine.ChangeState<GameState>(GetWorld());
+}
+
+void LobbyState::Update(float a_Delta) {}
+
 }  // namespace server
 }  // namespace td