Persson-dev/Tower-Defense2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

send world to client

Browse Source
This commit is contained in:
Simon Pribylski
2025-08-22 11:41:58 +02:00
parent 20acbc0499
commit 7d58b881b2
22 changed files with 217 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/client/state/GameState.h
View File

@@ -9,12 +9,12 @@ namespace client {
class GameState : public ClientState {
private:
std::shared_ptr<game::World> m_World;
game::WorldPtr m_World;
sim::ClientSimulation m_Simulation;
float m_CurrentLerp;
public:
GameState(Client& a_Client, const std::shared_ptr<game::World>& a_World, std::uint64_t a_StepTime);
GameState(Client& a_Client, const game::WorldPtr& a_World, std::uint64_t a_StepTime);
~GameState() {}
virtual void Update(float a_Delta) override;
@@ -23,6 +23,10 @@ class GameState : public ClientState {
return m_CurrentLerp;
}
game::WorldPtr GetWorld() const {
return m_World;
}
virtual void Handle(const protocol::packets::LockStepsPacket& a_LockStep) override;
virtual void Handle(const protocol::packets::LockStepResponsePacket& a_LockStep) override;
};

24
include/client/state/LobbyState.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include <client/ClientState.h>
#include <td/game/World.h>
#include <td/simulation/ClientSimulation.h>
namespace td {
namespace client {
class LobbyState : public ClientState {
private:
std::shared_ptr<game::World> m_World;
public:
LobbyState(Client& a_Client);
~LobbyState();
virtual void Update(float a_Delta) override;
virtual void Handle(const protocol::packets::WorldHeaderPacket& a_Packet) override;
virtual void Handle(const protocol::packets::WorldDataPacket& a_Packet) override;
};
} // namespace client
} // namespace td

2
include/client/state/LoggingState.h
View File

@@ -12,7 +12,7 @@ class LoggingState : public ClientState {
LoggingState(Client& a_Client, const std::string& a_PlayerName);
~LoggingState();
virtual void Update(float a_Delta) override {}
virtual void Update(float a_Delta) override;
virtual void Handle(const protocol::packets::PlayerJoinPacket& a_Packet) override;
virtual void Handle(const protocol::packets::LoggingSuccessPacket& a_Packet) override;

4
include/server/IServerSocket.h
View File

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

13
include/server/PlayerManager.h
View File

@@ -1,5 +1,6 @@
#pragma once
#include <td/misc/Signal.h>
#include <td/protocol/packet/Packets.h>
namespace td {
@@ -13,6 +14,9 @@ class PlayerManager {
std::shared_ptr<IServerSocket> m_Socket;
public:
utils::Signal<PlayerID, const PlayerInfo&> OnPlayerJoin;
utils::Signal<PlayerID> OnPlayerLeave;
PlayerManager(const std::shared_ptr<IServerSocket>& a_Socket);
~PlayerManager();
@@ -20,20 +24,19 @@ class PlayerManager {
PlayerInfo GetPlayer(PlayerID a_Player);
private:
void Disconnect(PlayerID a_Player);
class ConnectionHandler : public protocol::PacketHandler {
private:
std::map<PlayerID, PlayerInfo>& m_Players;
IServerSocket& m_Socket;
PlayerManager& m_PlayerManager;
PlayerID m_Player;
public:
ConnectionHandler(std::map<PlayerID, PlayerInfo>& a_Players, IServerSocket& a_Socket, PlayerID a_Player);
ConnectionHandler(PlayerManager& a_PlayerManager, 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;
static void Disconnect(std::map<PlayerID, PlayerInfo>&, IServerSocket& m_Socket, PlayerID m_Player);
};
};

4
include/server/Server.h
View File

@@ -20,6 +20,10 @@ class Server : public StateMachine<Server, void, float> {
virtual void Update(float a_Delta);
const PlayerManager& GetPlayers() const {
return m_Players;
}
friend class ServerState;
};

4
include/server/state/LobbyState.h
View File

@@ -10,9 +10,11 @@ class LobbyState : public ServerState {
private:
std::shared_ptr<game::World> m_World;
public:
LobbyState(Server& a_Server, const std::shared_ptr<game::World>& a_World);
LobbyState(Server& a_Server);
~LobbyState() {}
virtual void OnPlayerJoin(PlayerID a_Id, const td::PlayerInfo& a_Info) override;
virtual void HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) override;
virtual void Update(float a_Delta) override;
};

17
include/td/common/StateMachine.h
View File

@@ -1,7 +1,7 @@
#pragma once
#include <cassert>
#include <memory>
#include <td/misc/Signal.h>
namespace td {
@@ -16,7 +16,7 @@ class StateMachine {
virtual TReturn Update(TArgs... args) = 0;
template <typename T, typename... Args>
T* ChangeState(Args&&... args) {
T* ChangeState(Args... args) {
return m_StateMachine.template ChangeState<T>(std::forward<Args>(args)...);
}
@@ -24,18 +24,25 @@ class StateMachine {
TDerived& m_StateMachine;
};
utils::Signal<State&> OnStateChange;
StateMachine() {}
StateMachine(StateMachine&&) = default;
virtual ~StateMachine() {}
virtual TReturn Update(TArgs... args) {
assert(m_State && "You must change state at least once before updating !");
return m_State->Update(args...);
return m_State->Update(std::forward<TArgs>(args)...);
}
template <typename T, typename... Args>
T* ChangeState(Args&&... args) {
m_State = std::make_unique<T>(static_cast<TDerived&>(*this), std::forward<Args>(args)...);
T* ChangeState(Args... args) {
auto* currentState = m_State.get();
auto newState = std::make_unique<T>(static_cast<TDerived&>(*this), std::forward<Args>(args)...);
// This allows chaining
if (m_State.get() == currentState)
m_State = std::move(newState);
OnStateChange(*m_State);
return static_cast<T*>(m_State.get());
}

3
include/td/display/DisplayState.h
View File

@@ -2,8 +2,10 @@
#include <td/display/Display.h>
#include <td/misc/SlotGuard.h>
#include <client/ClientState.h>
namespace td {
class DisplayState : public Display::State, private utils::SlotGuard {
public:
DisplayState(Display& a_Display);
@@ -13,4 +15,5 @@ class DisplayState : public Display::State, private utils::SlotGuard {
virtual void OnAspectRatioChange(float a_Ratio) {}
virtual void OnKeyDown(SDL_Keycode a_Key) {}
};
} // namespace td

3
include/td/game/World.h
View File

@@ -33,6 +33,9 @@ class World {
bool LoadMap(const protocol::pdata::WorldHeader& worldHeader);
bool LoadMap(const protocol::pdata::WorldData& worldData);
protocol::packets::WorldHeaderPacket GetPacketHeader() const;
protocol::packets::WorldDataPacket GetPacketData() const;
bool LoadMapFromFile(const std::string& fileName);
bool SaveMap(const std::string& fileName) const;

2
src/client/Client.cpp
View File

@@ -6,7 +6,7 @@ namespace td {
namespace client {
Client::Client(const std::shared_ptr<IClientSocket>& a_Socket, const std::string& a_PlayerName) : m_Socket(a_Socket), m_Players(a_Socket) {
ChangeState<LoggingState>(a_PlayerName);
// ChangeState<LoggingState>(a_PlayerName);
}
void Client::SendPacket(const protocol::PacketBase& a_Packet) {

2
src/client/PlayerManager.cpp
View File

@@ -10,7 +10,7 @@ namespace client {
PlayerManager::PlayerManager(const std::shared_ptr<IClientSocket>& a_Socket) : m_Socket(a_Socket) {
a_Socket->OnReceive.Connect(std::bind(&PlayerManager::HandleBase, this, std::placeholders::_1));
OnPlayerJoin.Connect([this](const PlayerInfo& a_Player){
std::cout << "[Client " << this << "] " << a_Player.m_PlayerName << "(" << +a_Player.m_PlayerId << ") joined !\n";
std::cout << "[Client " << this << "] " << a_Player.m_PlayerName << " joined !\n";
});
OnPlayerLeave.Connect([this](const PlayerID a_Player){
std::cout << "[Client " << this << "] " << GetPlayer(a_Player).m_PlayerName << "(" << +a_Player << ") left !\n";

24
src/client/state/LobbyState.cpp Normal file
View File

@@ -0,0 +1,24 @@
#include <client/state/LobbyState.h>
#include <client/state/GameState.h>
namespace td {
namespace client {
LobbyState::LobbyState(Client& a_Client) : ClientState(a_Client), m_World(std::make_shared<game::World>()) {}
LobbyState::~LobbyState() {}
void LobbyState::Handle(const protocol::packets::WorldHeaderPacket& a_Packet) {
m_World->LoadMap(*a_Packet);
}
void LobbyState::Handle(const protocol::packets::WorldDataPacket& a_Packet) {
m_World->LoadMap(*a_Packet);
ChangeState<GameState>(m_World, STEP_TIME);
}
void LobbyState::Update(float a_Delta) {}
} // namespace client
} // namespace td

7
src/client/state/LoggingState.cpp
View File

@@ -1,6 +1,6 @@
#include <client/state/LoggingState.h>
#include <iostream>
#include <client/state/LobbyState.h>
namespace td {
namespace client {
@@ -9,6 +9,9 @@ LoggingState::LoggingState(Client& a_Client, const std::string& a_PlayerName) :
SendPacket(td::protocol::packets::PlayerLoginPacket(a_PlayerName));
}
void LoggingState::Update(float a_Delta) {
}
LoggingState::~LoggingState() {}
void LoggingState::Handle(const protocol::packets::PlayerJoinPacket& a_Packet) {
@@ -16,7 +19,7 @@ void LoggingState::Handle(const protocol::packets::PlayerJoinPacket& a_Packet) {
}
void LoggingState::Handle(const protocol::packets::LoggingSuccessPacket& a_Packet) {
// TODO: switch state
ChangeState<LobbyState>();
}
} // namespace client

3
src/server/IServerSocket.cpp
View File

@@ -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);
}

46
src/server/PlayerManager.cpp
View File

@@ -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) {

6
src/server/Server.cpp
View File

@@ -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();

4
src/server/ServerState.cpp
View File

@@ -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() {}

5
src/server/state/GameState.cpp
View File

@@ -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());
}

50
src/server/state/LobbyState.cpp
View File

@@ -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

72
src/td/display/state/DebugWorldState.cpp
View File

@@ -1,100 +1,68 @@
#include <td/display/state/DebugWorldState.h>
#include <chrono>
#include <fstream>
#include <iostream>
#include <td/game/World.h>
#include <td/protocol/packet/PacketSerialize.h>
#include <td/protocol/packet/Packets.h>
#include <td/render/renderer/EntityRenderer.h>
#include <td/render/renderer/TowerRenderer.h>
#include <td/render/renderer/WorldRenderer.h>
#include <sp/common/DataBuffer.h>
#include <sp/extensions/Compress.h>
#include <sp/io/MessageStream.h>
#include <sp/io/StdIo.h>
#include <server/Server.h>
#include <server/socket/FakeSocket.h>
#include <server/state/GameState.h>
#include <server/state/LobbyState.h>
#include <client/Client.h>
#include <client/socket/FakeSocket.h>
#include <client/state/GameState.h>
#include <client/state/LoggingState.h>
#include <td/display/Display.h>
#include <td/display/state/DebugWorldState.h>
namespace td {
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);
}
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;
}
DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display) {
// server
game::WorldPtr serverWorld = GetWorld();
auto serverFakeSocket = std::make_shared<server::FakeSocket>();
m_Server = std::make_unique<server::Server>(serverFakeSocket);
// client
game::WorldPtr clientWorld = GetWorld();
auto clientFakeSocket = client::FakeSocket::Connect(serverFakeSocket);
m_Client = std::make_unique<client::Client>(clientFakeSocket, "Player0");
// client2
auto clientFakeSocket2 = client::FakeSocket::Connect(serverFakeSocket);
m_Client2 = std::make_unique<client::Client>(clientFakeSocket2, "Player1");
// TODO: make it better
m_Client->OnStateChange.Connect([this](client::Client::State& a_State) {
if (auto gameState = dynamic_cast<client::GameState*>(&a_State)) {
// render
auto clientWorld = gameState->GetWorld();
m_Renderer.AddRenderer<render::WorldRenderer>(m_Camera, clientWorld);
m_Renderer.AddRenderer<render::EntityRenderer>(m_Camera, clientWorld);
m_Renderer.AddRenderer<render::TowerRenderer>(m_Camera, clientWorld);
// update state
m_ClientState = gameState;
}
});
m_Client->ChangeState<client::LoggingState>("Player0");
std::cout << "Switched to login!\n";
// // client2
// auto clientFakeSocket2 = client::FakeSocket::Connect(serverFakeSocket);
// m_Client2 = std::make_unique<client::Client>(clientFakeSocket2, "Player1");
// m_Client2->ChangeState<client::LoggingState>("Player1");
// camera
m_Camera.SetCamPos({77, 7, 13});
m_Camera.UpdatePerspective(m_StateMachine.GetAspectRatio());
// states
m_ClientState = m_Client->ChangeState<client::GameState>(clientWorld, STEP_TIME);
m_Server->ChangeState<server::GameState>(serverWorld);
}
void DebugWorldState::Update(float a_Delta) {
m_Server->Update(a_Delta);
m_Client->Update(a_Delta);
// TODO: m_ClientState might be invalid !
if (m_ClientState)
m_Renderer.Render(m_ClientState->GetCurrentLerp());
}

11
src/td/game/World.cpp
View File

@@ -1,6 +1,7 @@
#include <td/game/World.h>
#include <td/simulation/WorldTicker.h>
#include <td/protocol/packet/PacketSerialize.h>
namespace td {
namespace game {
@@ -62,6 +63,16 @@ bool World::LoadMap(const protocol::pdata::WorldHeader& a_WorldHeader) {
return true;
}
protocol::packets::WorldHeaderPacket World::GetPacketHeader() const {
return protocol::packets::WorldHeaderPacket(m_TowerPlacePalette, m_WalkablePalette, m_DecorationPalette, m_Background,
m_SpawnColorPalette, m_TilePalette, GetRedTeam().GetSpawn(), GetBlueTeam().GetSpawn(), GetRedTeam().GetCastle(),
GetBlueTeam().GetCastle());
}
protocol::packets::WorldDataPacket World::GetPacketData() const {
return protocol::packets::WorldDataPacket(m_Chunks);
}
bool World::LoadMap(const protocol::pdata::WorldData& a_WorldData) {
m_Chunks = a_WorldData.m_Chunks;
return true;