add basic texture

.vscode/c_cpp_properties.json

@@ -0,0 +1,13 @@
+{
+  "configurations": [
+    {
+      "name": "TD2",
+      "cppStandard": "c++20",
+      "includePath": [
+        "include"
+      ],
+      "compileCommands": ".vscode/compile_commands.json"
+    }
+  ],
+  "version": 4
+}

README.md

@@ -0,0 +1,3 @@
+# (CubeCraft) Tower Defense
+
+## Currently in contruction 🏗️👷⚙️

include/client/Client.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <client/IClientSocket.h>
+#include <client/PlayerManager.h>
+#include <td/common/StateMachine.h>
+#include <optional>
+
+namespace td {
+namespace client {
+
+class ClientState;
+class LoggingState;
+
+class Client : public StateMachine<Client, void, float> {
+  private:
+	std::shared_ptr<IClientSocket> m_Socket;
+	PlayerManager m_Players;
+	std::optional<PlayerID> m_Id;
+
+  public:
+	Client(const std::shared_ptr<IClientSocket>& a_Socket);
+	~Client();
+
+	void SendPacket(const protocol::PacketBase& a_Packet);
+
+	void Disconnect();
+
+	const PlayerManager& GetPlayers() const {
+		return m_Players;
+	}
+
+	const std::optional<PlayerID> GetId() const {
+		return m_Id;
+	}
+
+	friend class ClientState;
+	friend class LoggingState;
+};
+
+}  // namespace client
+}  // namespace td

include/client/ClientState.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <client/Client.h>
+#include <td/misc/SlotGuard.h>
+
+namespace td {
+namespace client {
+
+class ClientState : public Client::State, public protocol::PacketHandler, private utils::SlotGuard {
+  public:
+	ClientState(Client& a_Client);
+	virtual ~ClientState() {}
+
+  protected:
+	void SendPacket(const protocol::PacketBase& a_Packet);
+};
+
+}  // namespace server
+}  // namespace td

include/client/IClientSocket.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <td/Types.h>
+#include <td/misc/Signal.h>
+#include <td/protocol/packet/Packets.h>
+
+namespace td {
+namespace client {
+
+class IClientSocket {
+  public:
+	utils::Signal<> OnConnect;
+	utils::Signal<> OnDisconnect;
+	utils::Signal<const protocol::PacketBase&> OnReceive;
+
+	virtual void Send(const protocol::PacketBase& a_Packet) = 0;
+	virtual void Disconnect() = 0;
+
+	IClientSocket() {}
+	virtual ~IClientSocket() {}
+};
+
+}  // namespace client
+}  // namespace td

include/client/PlayerManager.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <td/protocol/packet/Packets.h>
+#include <td/misc/Signal.h>
+
+namespace td {
+namespace client {
+
+class IClientSocket;
+
+class PlayerManager : public protocol::PacketHandler {
+  private:
+	std::map<PlayerID, PlayerInfo> m_Players;
+	std::shared_ptr<IClientSocket> m_Socket;
+
+  public:
+	utils::Signal<const PlayerInfo&> OnPlayerJoin;
+	utils::Signal<PlayerID> OnPlayerLeave;
+
+	PlayerManager(const std::shared_ptr<IClientSocket>& a_Socket);
+	~PlayerManager();
+
+	PlayerInfo GetPlayer(PlayerID a_Player);
+
+	auto begin() const {
+		return m_Players.begin();
+	}
+
+	auto end() const {
+		return m_Players.end();
+	}
+
+	virtual void Handle(const protocol::packets::PlayerJoinPacket&) override;
+	virtual void Handle(const protocol::packets::PlayerListPacket&) override;
+	virtual void Handle(const protocol::packets::PlayerLeavePacket&) override;
+};
+
+}  // namespace client
+}  // namespace td

include/client/socket/FakeSocket.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <client/IClientSocket.h>
+
+namespace td {
+
+namespace server {
+class FakeSocket;
+}  // namespace server
+
+
+namespace client {
+
+class FakeSocket : public IClientSocket {
+  private:
+	std::shared_ptr<server::FakeSocket> m_Server;
+	PeerID m_PeerId;
+
+	struct Private{ explicit Private() = default; };
+
+  public:
+	FakeSocket(Private) {}
+	~FakeSocket() {}
+
+	static std::shared_ptr<FakeSocket> Connect(const std::shared_ptr<server::FakeSocket>& a_Server);
+
+	void ReceiveFromFakePeer(PeerID a_Peer, const protocol::PacketBase& a_Packet);
+
+	virtual void Send(const protocol::PacketBase& a_Packet) override;
+	virtual void Disconnect() override;
+};
+
+}  // namespace client
+}  // namespace td

include/client/state/GameState.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <client/ClientState.h>
+#include <td/game/World.h>
+#include <td/simulation/ClientSimulation.h>
+
+namespace td {
+namespace client {
+
+class GameState : public ClientState {
+  private:
+	game::WorldPtr m_World;
+	sim::ClientSimulation m_Simulation;
+	float m_CurrentLerp;
+	float m_ElapsedTime;
+
+  public:
+	GameState(Client& a_Client, const game::WorldPtr& a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep> a_FirstSteps);
+	~GameState() {}
+
+	virtual void Update(float a_Delta) override;
+
+	float GetCurrentLerp() const {
+		return m_CurrentLerp;
+	}
+
+	float GetElapsedTime() const {
+		return m_ElapsedTime;
+	}
+
+	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;
+};
+
+}  // namespace client
+}  // namespace td

include/client/state/LobbyState.h

@@ -0,0 +1,25 @@
+#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;
+	virtual void Handle(const protocol::packets::BeginGamePacket& a_Packet) override;
+};
+
+}  // namespace client
+}  // namespace td

include/client/state/LoggingState.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <client/ClientState.h>
+#include <td/game/World.h>
+#include <td/simulation/ClientSimulation.h>
+
+namespace td {
+namespace client {
+
+class LoggingState : public ClientState {
+  public:
+	LoggingState(Client& a_Client, const std::string& a_PlayerName);
+	~LoggingState();
+
+	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;
+};
+
+}  // namespace client
+}  // namespace td

include/server/IServerSocket.h

@@ -9,18 +9,27 @@ namespace server {
 
 class IServerSocket {
   public:
-	utils::Signal<PlayerID> OnConnect;
+	using PlayerPacketHandlerType = std::unique_ptr<protocol::PacketHandler>(PlayerID);
-	utils::Signal<PlayerID> OnDisconnect;
+	using PlayerPacketHandler = std::function<PlayerPacketHandlerType>;
+
+	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);
 	void Broadcast(const protocol::PacketBase& a_Packet);
 
-	IServerSocket() {}
+	void Disconnect(PlayerID a_PlayerId);
+
+	void RegisterHandler(const PlayerPacketHandler& a_Handler);
+	void UnregisterHandler(const PlayerPacketHandler& a_Handler);
+
+	IServerSocket();
 	virtual ~IServerSocket() {}
 
   private:
 	PlayerIds m_Ids;
+	std::vector<PlayerPacketHandler> m_Handlers;
 
   protected:
 	void OnConnectPeer(PeerID a_PeerId);

include/server/IServerState.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <server/IServerSocket.h>
-#include <td/misc/SlotGuard.h>
-
-namespace td {
-namespace server {
-
-class Server;
-
-class IServerState : 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) = 0;
-	virtual void OnPlayerLeave(PlayerID a_Id) = 0;
-
-	IServerState();
-	virtual ~IServerState();
-
-  protected:
-	void SendPacket(PlayerID a_Id, const protocol::PacketBase& a_Packet);
-	void BroadcastPacket(const protocol::PacketBase& a_Packet);
-	void SetNewState(const std::shared_ptr<IServerState>& a_NewState);
-	virtual void Init() {}
-
-  private:
-	Server* m_Server;
-
-	void SetServer(Server* a_Server);
-
-	friend class Server;
-};
-
-}  // namespace server
-}  // namespace td

include/server/PlayerManager.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <td/misc/Signal.h>
+#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:
+	utils::Signal<PlayerID, const PlayerInfo&> OnPlayerJoin;
+	utils::Signal<PlayerID> OnPlayerLeave;
+
+	PlayerManager(const std::shared_ptr<IServerSocket>& a_Socket);
+	~PlayerManager();
+
+	void RemovePlayer(PlayerID a_Player);
+	PlayerInfo GetPlayer(PlayerID a_Player);
+
+  private:
+	void Disconnect(PlayerID a_Player);
+	
+	class ConnectionHandler : public protocol::PacketHandler {
+	  private:
+		PlayerManager& m_PlayerManager;
+		PlayerID m_Player;
+
+	  public:
+		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;
+	};
+};
+
+}  // namespace server
+}  // namespace td

include/server/Server.h

@@ -1,35 +1,30 @@
 #pragma once
 
-#include <memory>
 #include <server/IServerSocket.h>
-#include <server/IServerState.h>
+#include <td/common/StateMachine.h>
-#include <chrono>
+#include <server/PlayerManager.h>
 
 namespace td {
 namespace server {
 
-class Server {
+class ServerState;
+
+class Server : public StateMachine<Server, void, float> {
   private:
 	std::shared_ptr<IServerSocket> m_Socket;
-	std::shared_ptr<IServerState> m_State;
+	PlayerManager m_Players;
-	std::chrono::time_point<std::chrono::system_clock> m_LastTime;
+	float m_LastMspt;
 
   public:
-	Server(const std::shared_ptr<IServerSocket>& a_Socket) : m_Socket(a_Socket), m_LastTime(std::chrono::system_clock::now()) {}
+	Server(const std::shared_ptr<IServerSocket>& a_Socket);
 
-	void Update();
+	virtual void Update(float a_Delta);
 
-	void UpdateState(const std::shared_ptr<IServerState>& a_State) {
+	const PlayerManager& GetPlayers() const {
-		m_State = a_State;
+		return m_Players;
-		m_State->SetServer(this);
 	}
 
-  private:
+	friend class ServerState;
-	void Update(float a_Delta) {
-		m_State->Update(a_Delta);
-	}
-
-	friend class IServerState;
 };
 
 }  // namespace server

include/server/ServerState.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <server/Server.h>
+#include <td/misc/SlotGuard.h>
+
+namespace td {
+namespace server {
+
+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::PlayerInfo& a_Info) {}
+	virtual void OnPlayerLeave(PlayerID a_Id) {}
+
+	ServerState(Server& a_Server);
+	virtual ~ServerState();
+
+  protected:
+	void SendPacket(PlayerID a_Id, const protocol::PacketBase& a_Packet);
+	void BroadcastPacket(const protocol::PacketBase& a_Packet);
+};
+
+}  // namespace server
+}  // namespace td

include/server/socket/FakeSocket.h

@@ -1,22 +1,34 @@
 #pragma once
 
+#include <client/socket/FakeSocket.h>
+#include <optional>
 #include <server/IServerSocket.h>
 
 namespace td {
 namespace server {
 
 class FakeSocket : public IServerSocket {
+  private:
+	std::vector<std::optional<std::weak_ptr<client::FakeSocket>>> m_Clients;
+
   public:
 	FakeSocket() {}
 	~FakeSocket() {}
 
-	utils::Signal<PeerID, const protocol::PacketBase&> OnSend;
+	PeerID ConnectFakePeer(const std::shared_ptr<client::FakeSocket>& a_Socket);
-
-	void ConnectFakePeer(PeerID a_Peer);
 	void DisconnectFakePeer(PeerID a_Peer);
+	void ReceiveFromFakePeer(PeerID a_Peer, const protocol::PacketBase& a_Packet);
 
   protected:
 	virtual void SendPeer(PeerID a_Peer, const protocol::PacketBase& a_Packet) override;
+
+  private:
+	/**
+	 * \return -1 if all previous ids are not free
+	 */
+	int GetNextFreeId();
+
+	friend class client::FakeSocket;
 };
 
 }  // namespace server

include/server/state/EndGameState.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <server/IServerState.h>
+#include <server/ServerState.h>
 
 namespace td {
 namespace server {
 
-class EndGameState : public IServerState {
+class EndGameState : public ServerState {
   private:
 	/* data */
   public:

include/server/state/GameState.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <server/IServerState.h>
+#include <server/ServerState.h>
 #include <td/game/World.h>
 #include <td/simulation/ServerSimulation.h>
 
@@ -9,23 +9,20 @@ namespace server {
 
 class GameStateHandler;
 
-class GameState : public IServerState {
+class GameState : public ServerState {
   private:
 	std::shared_ptr<game::World> m_World;
 	sim::ServerSimulation m_Simulation;
 	float m_Time;
 
   public:
-	GameState(const std::shared_ptr<game::World>& a_World);
+	GameState(Server& a_Server, const std::shared_ptr<game::World>& a_World);
 	~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;
 
-  protected:
+	virtual void OnPlayerJoin(PlayerID a_Id, const td::PlayerInfo& a_Info) override;
-	virtual void Init() override;
 
 	friend class GameStateHandler;
 };

include/server/state/LobbyState.h

@@ -1,22 +1,22 @@
 #pragma once
 
-#include <server/IServerState.h>
+#include <server/ServerState.h>
 
 namespace td {
 namespace server {
 
 // this class is temporary useless
-class LobbyState : public IServerState {
+class LobbyState : public ServerState {
   private:
 	std::shared_ptr<game::World> m_World;
   public:
-	LobbyState(const std::shared_ptr<game::World>& a_World) : m_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;
-	virtual void OnPlayerJoin(PlayerID a_Id) override;
-	virtual void OnPlayerLeave(PlayerID a_Id) override;
 };
 
 }  // namespace server

include/td/Maths.h

@@ -183,6 +183,51 @@ T Lerp(T v0, T v1, T t) {
 
 }  // namespace maths
 
+template<typename T>
+Vec2<T> operator+(const Vec2<T>& vect, const Vec2<T>& other) {
+	return {vect.x + other.x, vect.y + other.y};
+}
+
+template<typename T>
+Vec2<T> operator- (const Vec2<T>& vect) {
+	return { -vect.x, -vect.y };
+}
+
+template<typename T>
+Vec2<T> operator- (const Vec2<T>& vect, const Vec2<T>& other) {
+	return vect + (-other);
+}
+
+template<typename T>
+Vec3<T> operator- (const Vec3<T>& vect) {
+	return { -vect.x, -vect.y, -vect.z };
+}
+
+template<typename T>
+Vec3<T> operator+ (const Vec3<T>& vect, const Vec3<T>& other) {
+	return { vect.x + other.x, vect.y + other.y, vect.z + other.z };
+}
+
+template<typename T>
+Vec3<T> operator- (const Vec3<T>& vect, const Vec3<T>& other) {
+	return vect + (-other);
+}
+
+template<typename T>
+Vec4<T> operator- (const Vec4<T>& vect) {
+	return { -vect.x, -vect.y, -vect.z, -vect.w };
+}
+
+template<typename T>
+Vec4<T> operator+ (const Vec4<T>& vect, const Vec4<T>& other) {
+	return { vect.x + other.x, vect.y + other.y, vect.z + other.z, vect.w + other.w };
+}
+
+template<typename T>
+Vec4<T> operator- (const Vec4<T>& vect, const Vec4<T>& other) {
+	return vect + (-other);
+}
+
 template <typename T>
 sp::DataBuffer& operator<<(sp::DataBuffer& a_Buffer, const Vec2<T>& a_Vec) {
 	return a_Buffer << a_Vec.x << a_Vec.y;

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/common/StateMachine.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <cassert>
+#include <td/misc/Signal.h>
+
+namespace td {
+
+template <typename TDerived, typename TReturn, typename... TArgs>
+class StateMachine {
+  public:
+	class State {
+	  public:
+		State(TDerived& a_StateMachine) : m_StateMachine(a_StateMachine) {}
+		virtual ~State() {}
+
+		virtual TReturn Update(TArgs... args) = 0;
+
+		template <typename T, typename... Args>
+		void ChangeState(Args... args) {
+			m_StateMachine.template ChangeState<T>(std::forward<Args>(args)...);
+		}
+
+	  protected:
+		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(std::forward<TArgs>(args)...);
+	}
+
+	template <typename T, typename... Args>
+	void 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);
+		}
+	}
+
+  private:
+	std::unique_ptr<State> m_State;
+};
+
+
+}  // namespace td

include/td/common/StateStack.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <cassert>
+#include <vector>
+#include <memory>
+
+namespace td {
+
+template <typename TDerived, typename TReturn, typename... TArgs>
+class StateStack {
+  public:
+	class State {
+	  public:
+		State(TDerived& a_StateStack) : m_StateStack(a_StateStack) {}
+		virtual ~State() {}
+
+		virtual TReturn Update(TArgs... args) = 0;
+
+	  protected:
+		/**
+		 * \brief Called when enabled (can be used to connect signals)
+		 */
+		virtual void OnEnable() {}
+
+		/**
+		 * \brief Called when disabled (can be used to disconnect signals)
+		 */
+		virtual void OnDisable() {}
+
+	  protected:
+		TDerived& m_StateStack;
+
+		friend class StateStack;
+	};
+
+	StateStack() {}
+	StateStack(StateStack&&) = default;
+	virtual ~StateStack() {}
+
+	virtual TReturn Update(TArgs... args) {
+		assert(!m_States.empty() && "You must push at least one state before updating !");
+		return m_States.back()->Update(args...);
+	}
+
+	void PopState() {
+		assert(!m_States.empty() && "You must push at least one state before poping !");
+		m_States.back()->OnDisable();
+		m_States.pop_back();
+		if (m_States.empty())
+			return;
+		m_States.back()->OnEnable();
+	}
+
+	template <typename T, typename... Args>
+	T* PushState(Args&&... args) {
+		if (!m_States.empty())
+			m_States.back()->OnDisable();
+		auto newState = std::make_unique<T>(static_cast<TDerived&>(*this), std::forward<Args>(args)...);
+		newState->OnEnable();
+		m_States.push_back(std::move(newState));
+		return static_cast<T*>(newState.get());
+	}
+
+  private:
+	std::vector<std::unique_ptr<State>> m_States;
+};
+
+
+}  // namespace td

include/td/display/Display.h

@@ -2,39 +2,14 @@
 
 #include <string>
 
-#include <SDL3/SDL_video.h>
 #include <SDL3/SDL_keycode.h>
+#include <SDL3/SDL_video.h>
+#include <td/common/StateMachine.h>
 #include <td/misc/Signal.h>
 
 namespace td {
 
-class Display {
+class Display : public StateMachine<Display, void, float> {
-  public:
-	utils::Signal<float> OnAspectRatioChange;
-	utils::Signal<SDL_Keycode> OnKeyDown;
-
-	Display(int a_Width, int a_Height, const std::string& a_Title);
-	~Display();
-
-	void PollEvents();
-	void Update();
-
-	bool IsCloseRequested() {
-		return m_ShouldClose;
-	}
-
-	float GetAspectRatio() {
-		return m_AspectRatio;
-	}
-	
-	int GetWindowWidth() {
-		return m_LastWidth;
-	}
-
-	int GetWindowHeight() {
-		return m_LastHeight;
-	}
-
   private:
 	SDL_Window* m_Window;
 	SDL_GLContext m_GLContext;
@@ -43,6 +18,33 @@ class Display {
 	float m_AspectRatio;
 
 	bool m_ShouldClose;
+
+  public:
+	utils::Signal<float> OnAspectRatioChange;
+	utils::Signal<SDL_Keycode> OnKeyDown;
+
+	Display(int a_Width, int a_Height, const std::string& a_Title);
+	~Display();
+
+	void PollEvents();
+	void Update(float a_Delta) override;
+	void Close();
+
+	bool IsCloseRequested() {
+		return m_ShouldClose;
+	}
+
+	float GetAspectRatio() {
+		return m_AspectRatio;
+	}
+
+	int GetWindowWidth() {
+		return m_LastWidth;
+	}
+
+	int GetWindowHeight() {
+		return m_LastHeight;
+	}
 };
 
 }  // namespace td

include/td/display/DisplayState.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#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);
+	virtual ~DisplayState() {}
+
+  protected:
+	virtual void OnAspectRatioChange(float a_Ratio) {}
+	virtual void OnKeyDown(SDL_Keycode a_Key) {}
+};
+
+}  // namespace td

include/td/display/ImGuiTheme.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace td {
+
+void LoadTheme();
+
+}  // namespace td

include/td/display/menu/CreatePartyMenu.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <td/display/state/MainMenuState.h>
+
+namespace td {
+
+class CreatePartyMenu : public MainMenuState::Menu {
+  public:
+	CreatePartyMenu(MainMenuState& a_MainMenu);
+	~CreatePartyMenu();
+
+	virtual void Update() override;
+};
+
+}  // namespace td

include/td/display/menu/JoinPartyMenu.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <td/display/state/MainMenuState.h>
+
+namespace td {
+
+class JoinPartyMenu : public MainMenuState::Menu {
+  public:
+	JoinPartyMenu(MainMenuState& a_MainMenu);
+	~JoinPartyMenu();
+
+	virtual void Update() override;
+};
+
+}  // namespace td

include/td/display/menu/MainMenu.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <td/display/state/MainMenuState.h>
+
+namespace td {
+
+class MainMenu : public MainMenuState::Menu {
+  public:
+	MainMenu(MainMenuState& a_MainMenu);
+	~MainMenu();
+
+	virtual void Update() override;
+};
+
+}  // namespace td

include/td/display/menu/SettingsMenu.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <td/display/state/MainMenuState.h>
+
+namespace td {
+
+class SettingsMenu : public MainMenuState::Menu {
+  public:
+	SettingsMenu(MainMenuState& a_MainMenu);
+	~SettingsMenu();
+
+	virtual void Update() override;
+};
+
+}  // namespace td

include/td/display/state/DebugWorldState.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <client/Client.h>
+#include <server/Server.h>
+#include <td/display/DisplayState.h>
+#include <td/render/Renderer.h>
+#include <td/simulation/ClientSimulation.h>
+#include <client/state/GameState.h>
+#include <server/socket/FakeSocket.h>
+
+namespace td {
+
+class DebugWorldState : public DisplayState {
+  private:
+	render::RenderPipeline m_Renderer;
+	render::Camera m_Camera;
+	std::unique_ptr<server::Server> m_Server;
+	std::unique_ptr<client::Client> m_Client;
+	client::GameState* m_ClientState;
+
+	std::vector<std::unique_ptr<client::Client>> m_FakeClients;
+	std::shared_ptr<server::FakeSocket> m_ServerSocket;
+
+	unsigned int m_PlaySpeed = 1;
+
+  public:
+	DebugWorldState(Display& a_Display);
+	~DebugWorldState();
+
+	virtual void Update(float a_Delta) override;
+
+  protected:
+	virtual void OnAspectRatioChange(float a_Ratio) override;
+	virtual void OnKeyDown(SDL_Keycode a_Key) override;
+};
+
+}  // namespace td

include/td/display/state/MainMenuState.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <td/common/StateStack.h>
+#include <td/display/DisplayState.h>
+
+namespace td {
+
+class MainMenuState;
+
+using MainMenuStateStack = StateStack<MainMenuState, void>;
+
+class MainMenuState : public DisplayState, public MainMenuStateStack {
+  public:
+	using Menu = MainMenuStateStack::State;
+
+	MainMenuState(Display& a_Display);
+	~MainMenuState();
+
+	virtual void Update(float a_Delta) override;
+
+	void RenderBackButton();
+
+  protected:
+	virtual void OnKeyDown(SDL_Keycode a_Key) override;
+};
+
+}  // namespace td

include/td/game/Team.h

@@ -77,7 +77,7 @@ public:
 struct TeamList {
 	std::array<Team, 2> m_Teams;
 
-	TeamList() : m_Teams{Team{TeamColor::Red}, Team{TeamColor::Blue}}{
+	TeamList() : m_Teams{Team{TeamColor::Blue}, Team{TeamColor::Red}}{
 		
 	}
 

include/td/game/World.h

@@ -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;
 
@@ -102,7 +105,7 @@ class World {
 		return m_CurrentState->m_Teams[TeamColor::Blue];
 	}
 	const Team& GetBlueTeam() const {
-		return m_CurrentState->m_Teams[TeamColor::Red];
+		return m_CurrentState->m_Teams[TeamColor::Blue];
 	}
 
 	Team& GetTeam(TeamColor team) {

include/td/misc/Signal.h

@@ -2,17 +2,21 @@
 
 #include <algorithm>
 #include <functional>
+#include <memory>
 #include <td/common/NonCopyable.h>
 #include <vector>
 
 namespace td {
 namespace utils {
 
+/**
+ * \brief Signal class
+ */
 template <typename... Args>
-class Signal : private NonCopyable {
+class SignalRaw : private NonCopyable {
   public:
 	using FnType = void(Args...);
-	using CallBack = std::function<FnType>;
+	using CallBack = std::shared_ptr<std::function<FnType>>;
 
   private:
 	std::vector<CallBack> m_Callbacks;
@@ -23,17 +27,79 @@ class Signal : private NonCopyable {
 	}
 
 	void Disconnect(const CallBack& a_Callback) {
-		auto it = std::find_if(m_Callbacks.begin(), m_Callbacks.end(),
+		auto it = std::find(m_Callbacks.begin(), m_Callbacks.end(), a_Callback);
-			[&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...);
+			callback->operator()(args...);
 		}
 	}
 };
 
+/**
+ * \brief Memory managed Signal class
+ */
+template <typename... Args>
+class Signal {
+  public:
+	using SignalBase = SignalRaw<Args...>;
+	using CallBack = typename SignalBase::CallBack;
+	using CallBackRaw = typename CallBack::element_type;
+	using SignalPtr = std::shared_ptr<SignalBase>;
+	class ConnectionGuard;
+
+  private:
+	SignalPtr m_Signal;
+
+  public:
+	Signal() : m_Signal(std::make_shared<SignalBase>()) {}
+	Signal(const Signal&) = default;
+
+	/**
+	 * \warning The callback won't be disconnectable, use it wisely!
+	 */
+	void Connect(const CallBackRaw& a_Callback) {
+		m_Signal->Connect(std::make_shared<CallBackRaw>(a_Callback));
+	}
+
+	[[nodiscard]] std::unique_ptr<ConnectionGuard> ConnectSafe(const CallBack& a_Callback) {
+		m_Signal->Connect(a_Callback);
+		return std::make_unique<ConnectionGuard>(*this, a_Callback);
+	}
+
+	void Disconnect(const CallBack& a_Callback) {
+		m_Signal->Disconnect(a_Callback);
+	}
+
+	void operator()(Args... args) const {
+		m_Signal->operator()(args...);
+	}
+};
+
+class Connection {
+  public:
+	virtual ~Connection() {}
+};
+
+template <typename... Args>
+class Signal<Args...>::ConnectionGuard : public Connection {
+  private:
+	using CallBack = typename Signal<Args...>::CallBack;
+
+	std::weak_ptr<SignalRaw<Args...>> m_Signal;
+	CallBack m_Callback;
+
+  public:
+	ConnectionGuard(const Signal<Args...>& a_Signal, const CallBack& a_Callback) :
+		m_Signal(a_Signal.m_Signal), m_Callback(a_Callback) {}
+
+	~ConnectionGuard() {
+		if (!m_Signal.expired())
+			m_Signal.lock()->Disconnect(m_Callback);
+	}
+};
+
 }  // namespace utils
 }  // namespace td

include/td/misc/SlotGuard.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <td/misc/SlotGuard.h>
+#include <td/misc/Signal.h>
 
 namespace td {
 namespace utils {
@@ -12,22 +12,20 @@ namespace utils {
  */
 class SlotGuard {
   private:
-	std::vector<std::function<void()>> m_Deleters;
+	std::vector<std::unique_ptr<Connection>> m_Connections;
 
   public:
 	/**
 	 * \brief Connect a signal to a function (with the same signature)
 	 */
 	template <typename... Args>
-	void Connect(Signal<Args...>& a_Signal, const typename Signal<Args...>::CallBack& a_Callback) {
+	void Connect(Signal<Args...> a_Signal, const typename Signal<Args...>::CallBack::element_type& a_Callback) {
-		a_Signal.Connect(a_Callback);
+		auto ptr = std::make_shared<typename Signal<Args...>::CallBack::element_type>(a_Callback);
-		m_Deleters.push_back([&a_Signal, &a_Callback]() { a_Signal.Disconnect(a_Callback); });
+		m_Connections.push_back(a_Signal.ConnectSafe(ptr));
 	}
 
-	~SlotGuard() {
+	void Disconnect() {
-		for (auto& deleter : m_Deleters) {
+		m_Connections.clear();
-			deleter();
-		}
 	}
 };
 

include/td/misc/Time.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <chrono>
+
+namespace td {
+
+class Timer {
+  private:
+	std::chrono::time_point<std::chrono::system_clock> m_LastTime;
+
+  public:
+	Timer() : m_LastTime(std::chrono::system_clock::now()) {}
+
+	float GetDelta() {
+		auto timeElapsed = std::chrono::system_clock::now() - m_LastTime;
+		float timeSeconds = std::chrono::duration<float, std::chrono::seconds::period>(timeElapsed).count();
+		m_LastTime = std::chrono::system_clock::now();
+		return timeSeconds;
+	}
+};
+
+}  // namespace td

include/td/protocol/packet/PacketData.h

@@ -16,27 +16,22 @@
 namespace td {
 namespace protocol {
 
-struct PlayerInfo {
-	PlayerID m_PlayerId;
-	std::string m_PlayerName;
-};
-
 struct MapData {
 
 };
 
 namespace pdata {
 
-/** Client attempts to login (very basic) */
-struct PlayerLogin {
-	std::string m_PlayerName;
-};
-
 /** Server indicates success */
 struct LoggingSuccess {
 	PlayerID m_PlayerId;
 };
 
+/** Client attempts to login (very basic) */
+struct PlayerLogin {
+	std::string m_PlayerName;
+};
+
 /** Player joins the lobby */
 struct PlayerJoin {
 	PlayerInfo m_Player;
@@ -47,6 +42,11 @@ struct PlayerLeave {
 	PlayerID m_PlayerId;
 };
 
+/** List of players who joined before */
+struct PlayerList {
+	std::vector<PlayerInfo> m_Players;
+};
+
 struct PredictCommand {
 	CommandPtr m_Command;
 	StepTime m_FrameNumber;
@@ -67,8 +67,6 @@ struct ChatMessage {
 	std::string m_Text;
 };
 
-// TODO: handle players joining in the first second
-
 struct BeginGame {
 	std::vector<PlayerInfo> m_BlueTeam;
 	std::vector<PlayerInfo> m_RedTeam;

include/td/protocol/packet/Packets.h

@@ -29,6 +29,7 @@ enum class PacketID : std::uint8_t {
 	PlaceTower,
 	PlayerJoin,
 	PlayerLeave,
+	PlayerList,
 	PlayerLogin,
 	PredictCommand,
 	SpawnTroop,
@@ -58,6 +59,7 @@ using LoggingSuccessPacket = PacketMessage<pdata::LoggingSuccess, PacketID::Logg
 using PlaceTowerPacket = PacketMessage<pdata::PlaceTower, PacketID::PlaceTower>;
 using PlayerJoinPacket = PacketMessage<pdata::PlayerJoin, PacketID::PlayerJoin>;
 using PlayerLeavePacket = PacketMessage<pdata::PlayerLeave, PacketID::PlayerLeave>;
+using PlayerListPacket = PacketMessage<pdata::PlayerList, PacketID::PlayerList>;
 using PlayerLoginPacket = PacketMessage<pdata::PlayerLogin, PacketID::PlayerLogin>;
 using PredictCommandPacket = PacketMessage<pdata::PredictCommand, PacketID::PredictCommand>;
 using SpawnTroopPacket = PacketMessage<pdata::SpawnTroop, PacketID::SpawnTroop>;
@@ -67,11 +69,17 @@ using WorldDataPacket = PacketMessage<pdata::WorldData, PacketID::WorldData>;
 }  // namespace packets
 
 using AllPackets = std::tuple<packets::BeginGamePacket, packets::ChatMessagePacket, packets::DisconnectPacket,
-	packets::KeepAlivePacket, packets::LockStepRequestPacket, packets::LockStepResponsePacket, packets::LockStepsPacket, packets::LoggingSuccessPacket, packets::PlaceTowerPacket,
+	packets::KeepAlivePacket, packets::LockStepRequestPacket, packets::LockStepResponsePacket, packets::LockStepsPacket,
-	packets::PlayerJoinPacket, packets::PlayerLeavePacket, packets::PlayerLoginPacket, packets::PredictCommandPacket,
+	packets::LoggingSuccessPacket, packets::PlaceTowerPacket, packets::PlayerJoinPacket, packets::PlayerLeavePacket,
-	packets::SpawnTroopPacket, packets::WorldHeaderPacket, packets::WorldDataPacket>;
+	packets::PlayerListPacket, packets::PlayerLoginPacket, packets::PredictCommandPacket, packets::SpawnTroopPacket,
+	packets::WorldHeaderPacket, packets::WorldDataPacket>;
 
-class PacketHandler : public sp::GenericHandler<AllPackets> {};
+class PacketHandler : public sp::GenericHandler<AllPackets> {
+  public:
+	void HandleBase(const PacketBase& a_Packet) {
+		a_Packet.Dispatch(*this);
+	}
+};
 
 using PacketDispatcher = sp::MessageDispatcher<PacketBase>;
 

include/td/render/Camera.h

@@ -35,6 +35,7 @@ class Camera {
 	void UpdatePerspective(float a_AspectRatio);
 
 	void SetCamPos(const Vec3f& a_NewPos);
+	const Vec3f& GetCamPos() const;
 };
 
 }  // namespace render

include/td/render/Renderer.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <memory>
+#include <td/misc/SlotGuard.h>
 #include <td/render/Camera.h>
+#include <td/render/loader/FbxLoader.h>
 #include <td/render/loader/GLLoader.h>
 #include <td/render/shader/CameraShaderProgram.h>
-#include <td/misc/SlotGuard.h>
 
 namespace td {
 namespace render {
@@ -15,6 +16,7 @@ class BasicRenderer {
 	virtual ~BasicRenderer() {}
 
 	void Render(const GL::VertexArray& a_Vao);
+	void Render(const Model& a_Model);
 };
 
 template <typename TShader>
@@ -42,8 +44,11 @@ class RenderPipeline {
 	virtual ~RenderPipeline() {}
 
 	template <typename T, typename... Args>
-	void AddRenderer(Args&&... args) {
+	T& AddRenderer(Args&&... args) {
-		m_Renderers.push_back(std::make_unique<T>(args...));
+		auto ptr = std::make_unique<T>(args...);
+		auto rawPtr = ptr.get();
+		m_Renderers.push_back(std::move(ptr));
+		return *rawPtr;
 	}
 
 	void Clear() {
@@ -63,7 +68,7 @@ class RenderPipeline {
 
 template <typename TShader>
 Renderer<TShader>::Renderer(Camera& a_Camera) : m_Shader(std::make_unique<TShader>()), m_Camera(a_Camera) {
-	Connect(a_Camera.OnPerspectiveChange, [this](){
+	Connect(a_Camera.OnPerspectiveChange, [this]() {
 		m_Shader->Start();
 		m_Shader->SetProjectionMatrix(m_Camera.GetProjectionMatrix());
 	});

include/td/render/loader/FbxLoader.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <td/render/loader/GLLoader.h>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace td {
+
+struct Model {
+	std::vector<std::unique_ptr<GL::VertexArray>> m_Vaos;
+};
+
+namespace ModelLoader {
+
+Model LoadModel(const std::string& fileName);
+
+}
+}

include/td/render/loader/TextureLoader.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <sp/common/NonCopyable.h>
+#include <string>
+
+namespace td {
+namespace GL {
+
+class Texture : private sp::NonCopyable {
+  public:
+	Texture(const char* a_Data, int a_Width, int a_Height, int a_Comp);
+	Texture(Texture&& a_Other);
+
+	~Texture();
+
+	void Bind() const;
+	void Unbind() const;
+
+  private:
+	unsigned int m_ID;
+};
+
+}  // namespace GL
+
+namespace TextureLoader {
+
+GL::Texture LoadTexture(const std::string& fileName);
+
+}
+
+}  // namespace td

include/td/render/renderer/EntityRenderer.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <td/render/loader/TextureLoader.h>
+#include <td/render/loader/FbxLoader.h>
 #include <td/render/Renderer.h>
 #include <td/render/shader/EntityShader.h>
 #include <td/game/World.h>
@@ -9,11 +11,12 @@ namespace render {
 
 class EntityRenderer : public Renderer<shader::EntityShader> {
   private:
-	const game::World& m_World;
+	game::WorldPtr m_World;
-	std::unique_ptr<GL::VertexArray> m_EntityVao;
+	Model m_EntityModel;
+	std::unique_ptr<GL::Texture> m_EntityTexture;
 
   public:
-	EntityRenderer(Camera& a_Camera, const game::World& a_World);
+	EntityRenderer(Camera& a_Camera, const game::WorldPtr& a_World);
 	virtual ~EntityRenderer();
 
 	virtual void Render(float a_Lerp) override;

include/td/render/renderer/PlayerListRenderer.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <td/render/Renderer.h>
+#include <client/PlayerManager.h>
+
+namespace td {
+namespace render {
+
+/**
+ * \brief This is a debug class
+ */
+class PlayerListRenderer : public BasicRenderer {
+  private:
+	const client::PlayerManager& m_Players;
+  public:
+	utils::Signal<> OnPlayerCreate;
+	// utils::Signal<> OnRequestPOV;
+	utils::Signal<PlayerID> OnPlayerKick;
+
+	virtual void Render(float a_Lerp) override;
+
+	PlayerListRenderer(const client::PlayerManager& a_Players);
+	~PlayerListRenderer() {}
+};
+
+}  // namespace render
+}  // namespace td

include/td/render/renderer/TimerRenderer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "client/state/GameState.h"
+#include <td/render/Renderer.h>
+#include <client/PlayerManager.h>
+
+namespace td {
+namespace render {
+
+class TimerRenderer : public BasicRenderer {
+  private:
+	const client::GameState& m_State;
+  public:
+	virtual void Render(float a_Lerp) override;
+
+	TimerRenderer(const client::GameState& a_State);
+	~TimerRenderer() {}
+};
+
+}  // namespace render
+}  // namespace td

include/td/render/renderer/TowerRenderer.h

@@ -9,11 +9,11 @@ namespace render {
 
 class TowerRenderer : public Renderer<shader::EntityShader> {
   private:
-	const game::World& m_World;
+	game::WorldPtr m_World;
 	std::unique_ptr<GL::VertexArray> m_EntityVao;
 
   public:
-	TowerRenderer(Camera& a_Camera, const game::World& a_World);
+	TowerRenderer(Camera& a_Camera, const game::WorldPtr& a_World);
 	virtual ~TowerRenderer();
 
 	virtual void Render(float a_Lerp) override;

include/td/render/renderer/WorldRenderer.h

@@ -13,10 +13,13 @@ class WorldRenderer : public Renderer<shader::WorldShader> {
 	std::unique_ptr<GL::VertexArray> m_WorldVao;
 
   public:
-	WorldRenderer(Camera& a_Camera, const game::World& a_World);
+	WorldRenderer(Camera& a_Camera, const game::WorldPtr& a_World);
 	virtual ~WorldRenderer();
 
 	virtual void Render(float a_Lerp) override;
+
+  private:
+	void UpdateControls();
 };
 
 }  // namespace render

include/td/simulation/ClientSimulation.h

@@ -14,10 +14,9 @@ using GameBuffer = std::vector<std::optional<td::protocol::LockStep>>;
 class ClientSimulation : public protocol::PacketHandler {
   private:
 	std::uint64_t m_StepTime;
-	game::World& m_World;
+	std::shared_ptr<game::World> m_World;
 	GameBuffer m_History;
-	std::uint64_t m_CurrentTime;
+	float m_CurrentTime;
-	std::uint64_t m_LastTime;
 	StepTime m_CurrentStep;
 
 	std::shared_ptr<WorldSnapshot> m_LastSnapshot;
@@ -34,18 +33,18 @@ class ClientSimulation : public protocol::PacketHandler {
 	 * \brief Replay constructor
 	 * \param a_StepTime in ms
 	 */
-	ClientSimulation(game::World& a_World, GameHistory&& a_History, std::uint64_t a_StepTime);
+	ClientSimulation(std::shared_ptr<game::World> a_World, GameHistory&& a_History, std::uint64_t a_StepTime);
 
 	/**
 	 * \brief Live update constructor (continuous game updates)
 	 * \param a_StepTime in ms
 	 */
-	ClientSimulation(game::World& a_World, std::uint64_t a_StepTime);
+	ClientSimulation(std::shared_ptr<game::World> a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep>& a_FirstSteps);
 
 	/**
 	 * \return the progress [0-1] between two steps
 	 */
-	float Update();
+	float Update(float a_Delta);
 
 	virtual void Handle(const protocol::packets::LockStepsPacket& a_LockSteps) override;
 	virtual void Handle(const protocol::packets::LockStepResponsePacket& a_LockSteps) override;

include/td/simulation/ServerSimulation.h

@@ -16,7 +16,7 @@ class ServerSimulation : public protocol::CommandHandler {
 	game::World& m_World;
 	std::uint64_t m_StepTime;
 	std::uint64_t m_CurrentTime;
-	std::vector<td::protocol::LockStep> m_History;
+	std::vector<protocol::LockStep> m_History;
 
 	using protocol::CommandHandler::Handle;
 
@@ -27,6 +27,8 @@ class ServerSimulation : public protocol::CommandHandler {
 
 	protocol::packets::LockStepsPacket MakePacket();
 
+	std::vector<protocol::LockStep> GetFirstLocksteps();
+
 	// no checks are done !
 
 	virtual void Handle(const protocol::commands::SpawnTroopCommand& a_SpawnTroop) override;

src/client/Client.cpp

@@ -0,0 +1,25 @@
+#include <client/Client.h>
+
+#include <client/state/LoggingState.h>
+
+namespace td {
+namespace client {
+
+Client::Client(const std::shared_ptr<IClientSocket>& a_Socket) : m_Socket(a_Socket), m_Players(a_Socket) {
+	// ChangeState<LoggingState>(a_PlayerName);
+}
+
+Client::~Client() {
+	Disconnect();
+}
+
+void Client::SendPacket(const protocol::PacketBase& a_Packet) {
+	m_Socket->Send(a_Packet);
+}
+
+void Client::Disconnect() {
+	m_Socket->Disconnect();
+}
+
+}  // namespace client
+}  // namespace td

src/client/ClientState.cpp

@@ -0,0 +1,16 @@
+#include <client/ClientState.h>
+#include <client/Client.h>
+
+namespace td {
+namespace client {
+
+ClientState::ClientState(Client& a_Client) : Client::State(a_Client) {
+	Connect(m_StateMachine.m_Socket->OnReceive, std::bind(&ClientState::HandleBase, this, std::placeholders::_1));
+}
+
+void ClientState::SendPacket(const protocol::PacketBase& a_Packet) {
+	m_StateMachine.m_Socket->Send(a_Packet);
+}
+
+}  // namespace server
+}  // namespace td

src/client/PlayerManager.cpp

@@ -0,0 +1,44 @@
+#include <client/PlayerManager.h>
+
+#include <client/IClientSocket.h>
+
+#include <iostream>
+
+namespace td {
+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 << " joined !\n";
+	});
+	OnPlayerLeave.Connect([this](const PlayerID a_Player){
+		std::cout << "[Client " << this << "] " << GetPlayer(a_Player).m_PlayerName << "(" << +a_Player << ") left !\n";
+	});
+}
+
+PlayerManager::~PlayerManager() {}
+
+PlayerInfo PlayerManager::GetPlayer(PlayerID a_Player) {
+	return m_Players.at(a_Player);
+}
+
+void PlayerManager::Handle(const protocol::packets::PlayerJoinPacket& a_Packet) {
+	m_Players.emplace(a_Packet->m_Player.m_PlayerId, a_Packet->m_Player);
+	OnPlayerJoin(a_Packet->m_Player);
+}
+
+void PlayerManager::Handle(const protocol::packets::PlayerListPacket& a_Packet) {
+	for (auto pInfo : a_Packet->m_Players) {
+		m_Players.emplace(pInfo.m_PlayerId, pInfo);
+		OnPlayerJoin(pInfo);
+	}
+}
+
+void PlayerManager::Handle(const protocol::packets::PlayerLeavePacket& a_Packet) {
+	OnPlayerLeave(a_Packet->m_PlayerId);
+	m_Players.erase(a_Packet->m_PlayerId);
+}
+
+}  // namespace client
+}  // namespace td

src/client/socket/FakeSocket.cpp

@@ -0,0 +1,23 @@
+#include <client/socket/FakeSocket.h>
+#include <server/socket/FakeSocket.h>
+
+namespace td {
+namespace client {
+
+void FakeSocket::Send(const protocol::PacketBase& a_Packet) {
+	m_Server->OnReceivePeer(m_PeerId, a_Packet);
+}
+
+std::shared_ptr<FakeSocket> FakeSocket::Connect(const std::shared_ptr<server::FakeSocket>& a_Server) {
+	auto socket = std::make_shared<FakeSocket>(Private());
+	socket->m_Server = a_Server;
+	socket->m_PeerId = a_Server->ConnectFakePeer(socket);
+	return socket;
+}
+
+void FakeSocket::Disconnect() {
+	m_Server->DisconnectFakePeer(m_PeerId);
+}
+
+}  // namespace client
+}  // namespace td

src/client/state/GameState.cpp

@@ -0,0 +1,27 @@
+#include <client/state/GameState.h>
+
+namespace td {
+namespace client {
+
+GameState::GameState(Client& a_Client, const std::shared_ptr<game::World>& a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep> a_FirstSteps) :
+	ClientState(a_Client), m_World(a_World), m_Simulation(a_World, a_StepTime, a_FirstSteps) {
+	m_Simulation.OnMissingLockSteps.Connect([this](const std::vector<td::StepTime>& a_MissingSteps) {
+		SendPacket(protocol::packets::LockStepRequestPacket(a_MissingSteps));
+	});
+}
+
+void GameState::Handle(const protocol::packets::LockStepsPacket& a_LockStep) {
+	m_Simulation.Handle(a_LockStep);
+}
+
+void GameState::Handle(const protocol::packets::LockStepResponsePacket& a_LockStep) {
+	m_Simulation.Handle(a_LockStep);
+}
+
+void GameState::Update(float a_Delta) {
+	m_CurrentLerp = m_Simulation.Update(a_Delta);
+	m_ElapsedTime += a_Delta;
+}
+
+}  // namespace client
+}  // namespace td

src/client/state/LobbyState.cpp

@@ -0,0 +1,27 @@
+#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);
+}
+
+void LobbyState::Handle(const protocol::packets::BeginGamePacket& a_Packet) {
+	ChangeState<GameState>(m_World, STEP_TIME, a_Packet->m_FirstLocksteps);
+}
+
+void LobbyState::Update(float a_Delta) {}
+
+}  // namespace client
+}  // namespace td

src/client/state/LoggingState.cpp

@@ -0,0 +1,27 @@
+#include <client/state/LoggingState.h>
+
+#include <client/state/LobbyState.h>
+
+namespace td {
+namespace client {
+
+LoggingState::LoggingState(Client& a_Client, const std::string& a_PlayerName) : ClientState(a_Client) {
+	SendPacket(td::protocol::packets::PlayerLoginPacket(a_PlayerName));
+}
+
+void LoggingState::Update(float a_Delta) {
+}
+
+LoggingState::~LoggingState() {}
+
+void LoggingState::Handle(const protocol::packets::PlayerJoinPacket& a_Packet) {
+	// TODO: check if id matches client id
+}
+
+void LoggingState::Handle(const protocol::packets::LoggingSuccessPacket& a_Packet) {
+	m_StateMachine.m_Id = a_Packet->m_PlayerId;
+	ChangeState<LobbyState>();
+}
+
+}  // namespace client
+}  // namespace td

src/main.cpp

@@ -1,159 +1,17 @@
-#include <iostream>
+#include <chrono>
-
+#include <td/display/state/MainMenuState.h>
-#include <fstream>
+#include <td/misc/Time.h>
-#include <td/game/World.h>
-#include <td/input/Display.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 <td/simulation/ClientSimulation.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>
-
-class WorldApply : public td::protocol::PacketHandler {
-  private:
-	td::game::World& m_World;
-	using td::protocol::PacketHandler::Handle;
-
-  public:
-	WorldApply(td::game::World& a_World) : m_World(a_World) {}
-
-	void Handle(const td::protocol::packets::WorldHeaderPacket& a_Header) override {
-		m_World.LoadMap(*a_Header);
-	}
-
-	void Handle(const td::protocol::packets::WorldDataPacket& a_Data) override {
-		m_World.LoadMap(*a_Data);
-	}
-};
-
-class ClientHandler : public td::protocol::PacketHandler {
-  private:
-	td::sim::ClientSimulation& m_Simulation;
-
-	using td::protocol::PacketHandler::Handle;
-
-  public:
-	ClientHandler(td::sim::ClientSimulation& a_Simulation) : m_Simulation(a_Simulation) {}
-
-	void Handle(const td::protocol::packets::LockStepsPacket& a_LockStep) {
-		m_Simulation.Handle(a_LockStep);
-	}
-
-	void Handle(const td::protocol::packets::LockStepResponsePacket& a_LockStep) {
-		m_Simulation.Handle(a_LockStep);
-	}
-};
-
-void Save(const td::protocol::PacketBase& header, const td::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<td::protocol::PacketFactory> stream(std::move(out), std::move(comp));
-
-	stream.WriteMessage(header, false);
-	stream.WriteMessage(data, false);
-}
-
-td::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<td::protocol::PacketFactory> stream(std::move(out), std::move(comp));
-
-	auto header = stream.ReadMessage(td::protocol::PacketID::WorldHeader);
-	auto data = stream.ReadMessage(td::protocol::PacketID::WorldData);
-
-	auto w = std::make_shared<td::game::World>();
-	auto wa = std::make_shared<WorldApply>(*w);
-
-	td::protocol::PacketDispatcher d;
-	d.RegisterHandler(wa);
-
-	d.Dispatch(*header);
-	d.Dispatch(*data);
-
-	Save(*header, *data);
-
-	return w;
-}
-
-void FastForward(td::game::World& a_World, const td::sim::GameHistory& a_LockSteps) {
-	const td::FpFloat delta = td::FpFloat(1) / td::FpFloat(75);
-	for (const auto& lockstep : a_LockSteps) {
-		a_World.Tick(lockstep, delta);
-	}
-}
 
 int main(int argc, char** argv) {
-	td::game::WorldPtr serverWorld = GetWorld();
-
-	// server
-	auto fakeSocket = std::make_shared<td::server::FakeSocket>();
-	td::server::Server server(fakeSocket);
-
 	// init GL context
 	td::Display display(1920, 1080, "Tower-Defense 2");
 
-	td::render::Camera cam;
+	display.ChangeState<td::MainMenuState>();
-
-	display.OnAspectRatioChange.Connect([&cam](float a_AspectRatio) { cam.UpdatePerspective(a_AspectRatio); });
-
-	td::game::WorldPtr clientWorld = GetWorld();
-
-	td::render::RenderPipeline renderer;
-	renderer.AddRenderer<td::render::WorldRenderer>(cam, *clientWorld);
-	renderer.AddRenderer<td::render::EntityRenderer>(cam, *clientWorld);
-	renderer.AddRenderer<td::render::TowerRenderer>(cam, *clientWorld);
-
-	cam.SetCamPos({77, 7, 13});
-	cam.UpdatePerspective(display.GetAspectRatio());
-
-	td::sim::ClientSimulation simulation(*clientWorld, td::STEP_TIME);
-	ClientHandler clientHandler(simulation);
-
-	simulation.OnMissingLockSteps.Connect([&fakeSocket](const std::vector<td::StepTime>& a_MissingSteps){
-		fakeSocket->OnReceive(0, td::protocol::packets::LockStepRequestPacket(a_MissingSteps));
-	});
-
-	// temporary tests
-	display.OnKeyDown.Connect([&fakeSocket](SDL_Keycode key) {
-		if (key == SDLK_A) {
-			fakeSocket->OnReceive(0, td::protocol::packets::SpawnTroopPacket(td::EntityType::Zombie, 1));
-		} else if (key == SDLK_Z) {
-			fakeSocket->OnReceive(0, td::protocol::packets::PlaceTowerPacket(td::TowerType::Archer, td::TowerCoords(77, 13)));
-		}
-	});
-
-	// make a fake player join
-	fakeSocket->ConnectFakePeer(0);
-
-	// packets from the server to the client
-	fakeSocket->OnSend.Connect([&clientHandler](td::PeerID a_Peer, const td::protocol::PacketBase& a_Packet) {
-		a_Packet.Dispatch(clientHandler);
-	});
-
-	server.UpdateState(std::make_shared<td::server::GameState>(serverWorld));
 
+	td::Timer timer;
 	while (!display.IsCloseRequested()) {
 		display.PollEvents();
-		server.Update();
+		display.Update(timer.GetDelta());
-		float lerp = simulation.Update();
-		renderer.Render(lerp);
-		display.Update();
 	}
 
 	return 0;

src/server/IServerSocket.cpp

@@ -3,18 +3,39 @@
 namespace td {
 namespace server {
 
+IServerSocket::IServerSocket() {
+}
+
+void IServerSocket::RegisterHandler(const PlayerPacketHandler& a_Handler) {
+	m_Handlers.push_back(a_Handler);
+}
+
+void IServerSocket::UnregisterHandler(const PlayerPacketHandler& a_Handler) {
+	auto it = std::find_if(m_Handlers.begin(), m_Handlers.end(),
+		[&a_Handler](PlayerPacketHandler& handler) { return a_Handler.template target<PlayerPacketHandlerType>() == handler.template target<PlayerPacketHandlerType>(); });
+	m_Handlers.erase(it);
+}
+
 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);
-	OnConnect(m_Ids.GetPlayerId(a_PeerId));
+	OnPlayerConnect(m_Ids.GetPlayerId(a_PeerId));
 }
 
 void IServerSocket::OnDisconnectPeer(PeerID a_PeerId) {
-	OnDisconnect(m_Ids.GetPlayerId(a_PeerId));
+	OnPlayerDisconnect(m_Ids.GetPlayerId(a_PeerId));
 	m_Ids.RemovePeer(a_PeerId);
 }
 
 void IServerSocket::OnReceivePeer(PeerID a_PeerId, const protocol::PacketBase& a_Packet) {
-	OnReceive(m_Ids.GetPlayerId(a_PeerId), a_Packet);
+	auto playerId = m_Ids.GetPlayerId(a_PeerId);
+
+	for (const auto& factory : m_Handlers) {
+		auto handler = factory(playerId);
+		a_Packet.Dispatch(*handler);
+	}
+
+	OnReceive(playerId, a_Packet);
 }
 
 void IServerSocket::Send(PlayerID a_PlayerId, const protocol::PacketBase& a_Packet) {
@@ -27,5 +48,9 @@ void IServerSocket::Broadcast(const protocol::PacketBase& a_Packet) {
 	}
 }
 
+void IServerSocket::Disconnect(PlayerID a_PlayerId) {
+	OnDisconnectPeer(m_Ids.GetPeerId(a_PlayerId));
+}
+
 }  // namespace server
 }  // namespace td

src/server/IServerState.cpp

@@ -1,33 +0,0 @@
-#include <server/IServerState.h>
-#include <server/Server.h>
-
-namespace td {
-namespace server {
-
-void IServerState::SetServer(Server* a_Server) {
-	assert(a_Server);
-	m_Server = a_Server;
-	Connect(m_Server->m_Socket->OnConnect, std::bind(&IServerState::OnPlayerJoin, this, std::placeholders::_1));
-	Connect(m_Server->m_Socket->OnDisconnect, std::bind(&IServerState::OnPlayerLeave, this, std::placeholders::_1));
-	Connect(m_Server->m_Socket->OnReceive, std::bind(&IServerState::HandlePacket, this, std::placeholders::_1, std::placeholders::_2));
-	Init();
-}
-
-IServerState::IServerState() : m_Server(nullptr) {}
-
-IServerState::~IServerState() {}
-
-void IServerState::SendPacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) {
-	m_Server->m_Socket->Send(a_Id, a_Packet);
-}
-
-void IServerState::BroadcastPacket(const protocol::PacketBase& a_Packet) {
-	m_Server->m_Socket->Broadcast(a_Packet);
-}
-
-void IServerState::SetNewState(const std::shared_ptr<IServerState>& a_NewState) {
-	m_Server->UpdateState(a_NewState);
-}
-
-}  // namespace server
-}  // namespace td

src/server/PlayerManager.cpp

@@ -0,0 +1,62 @@
+#include <server/PlayerManager.h>
+
+#include <iostream>
+#include <server/IServerSocket.h>
+
+namespace td {
+namespace server {
+
+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};
+
+	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);
+	}
+
+	socket.Send(m_Player, protocol::packets::LoggingSuccessPacket(m_Player));
+	socket.Send(m_Player, protocol::packets::PlayerListPacket(playerInfos));
+	socket.Broadcast(protocol::packets::PlayerJoinPacket(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) {
+	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>(*this, a_PlayerId); });
+	a_Socket->OnPlayerDisconnect.Connect(std::bind(&PlayerManager::Disconnect, this, std::placeholders::_1));
+}
+
+void PlayerManager::Disconnect(PlayerID a_Player) {
+	if (!m_Players.contains(a_Player))
+		return;
+	std::cout << "[Server] " << +a_Player << " wants to disconnect !\n";
+	m_Socket->Broadcast(protocol::packets::PlayerLeavePacket(a_Player));
+	m_Players.erase(a_Player);
+}
+
+PlayerManager::~PlayerManager() {}
+
+void PlayerManager::RemovePlayer(PlayerID a_Player) {
+	m_Socket->Disconnect(a_Player);
+	Disconnect(a_Player);
+}
+
+PlayerInfo PlayerManager::GetPlayer(PlayerID a_Player) {
+	return m_Players.at(a_Player);
+}
+
+}  // namespace server
+}  // namespace td

src/server/Server.cpp

@@ -1,13 +1,21 @@
 #include <server/Server.h>
 
+#include <chrono>
+
+#include <server/state/LobbyState.h>
+
 namespace td {
 namespace server {
 
-void Server::Update() {
+Server::Server(const std::shared_ptr<IServerSocket>& a_Socket) : m_Socket(a_Socket), m_Players(a_Socket), m_LastMspt(0) {
-	auto timeElapsed = std::chrono::system_clock::now() - m_LastTime;
+	ChangeState<LobbyState>();
-	float timeSeconds = std::chrono::duration<float, std::chrono::seconds::period>(timeElapsed).count();
+}
-	Update(timeSeconds);
+
-	m_LastTime = std::chrono::system_clock::now();
+void Server::Update(float a_Delta) {
+	auto before = std::chrono::system_clock::now();
+	StateMachine<Server, void, float>::Update(a_Delta);
+	m_LastMspt = std::chrono::duration<float, std::chrono::milliseconds::period>(std::chrono::system_clock::now() - before).count();
+	// std::cout << "Tick : " << m_LastMspt << "ms\n";
 }
 
 }  // namespace server

src/server/ServerState.cpp

@@ -0,0 +1,26 @@
+#include <server/Server.h>
+#include <server/ServerState.h>
+
+#include <td/common/StateMachine.h>
+
+namespace td {
+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_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() {}
+
+void ServerState::SendPacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) {
+	m_StateMachine.m_Socket->Send(a_Id, a_Packet);
+}
+
+void ServerState::BroadcastPacket(const protocol::PacketBase& a_Packet) {
+	m_StateMachine.m_Socket->Broadcast(a_Packet);
+}
+
+}  // namespace server
+}  // namespace td

src/server/socket/FakeSocket.cpp

@@ -4,16 +4,45 @@ namespace td {
 namespace server {
 
 void FakeSocket::SendPeer(PeerID a_Peer, const protocol::PacketBase& a_Packet) {
-	OnSend(a_Peer, a_Packet);
+	auto socket = m_Clients.at(a_Peer);
+	assert(socket.has_value());
+	assert(!socket.value().expired());
+	socket.value().lock()->OnReceive(a_Packet);
 }
 
-void FakeSocket::ConnectFakePeer(PeerID a_Peer) {
+void FakeSocket::ReceiveFromFakePeer(PeerID a_Peer, const protocol::PacketBase& a_Packet) {
-	OnConnectPeer(a_Peer);
+	OnReceivePeer(a_Peer, a_Packet);
+}
+
+PeerID FakeSocket::ConnectFakePeer(const std::shared_ptr<client::FakeSocket>& a_Socket) {
+	int peerId = GetNextFreeId();
+	if (peerId == -1) {
+		peerId = m_Clients.size();
+		m_Clients.push_back(a_Socket);
+	} else {
+		m_Clients.emplace(m_Clients.begin() + peerId, a_Socket);
+	}
+	a_Socket->OnConnect();
+	OnConnectPeer(peerId);
+	return peerId;
 }
 
 void FakeSocket::DisconnectFakePeer(PeerID a_Peer) {
+	auto socket = m_Clients.at(a_Peer);
+	assert(socket.has_value());
+	assert(!socket.value().expired());
+	socket.value().lock()->OnDisconnect();
 	OnDisconnectPeer(a_Peer);
 }
 
+int FakeSocket::GetNextFreeId() {
+	auto it = std::find_if(m_Clients.begin(), m_Clients.end(), [](const auto& a_Value) { return !a_Value.has_value(); });
+
+	if (it == m_Clients.end())
+		return -1;
+
+	return std::distance(m_Clients.begin(), it);
+}
+
 }  // namespace server
 }  // namespace td

src/server/state/GameState.cpp

@@ -1,15 +1,18 @@
 #include <server/state/GameState.h>
 #include <server/state/GameStateHandler.h>
+#include <td/protocol/packet/PacketSerialize.h>
 
 #include <iostream>
 
 namespace td {
 namespace server {
 
-GameState::GameState(const std::shared_ptr<game::World>& a_World) : m_World(a_World), m_Simulation(*m_World, STEP_TIME), m_Time(0) {}
+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) {
-void GameState::Init() {
+	std::cout << "[Server] Switched to Game state !\n";
-	std::cout << "Switched to Game state !\n";
+	BroadcastPacket(a_World->GetPacketHeader());
+	BroadcastPacket(a_World->GetPacketData());
+	BroadcastPacket(protocol::packets::BeginGamePacket());
 	BroadcastPacket(m_Simulation.MakePacket());
 }
 
@@ -19,18 +22,26 @@ void GameState::HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet
 }
 
 void GameState::Update(float a_Delta) {
+	// TODO: don't make STEP_TIME constant
 	static const float stepTimeSecond = static_cast<float>(STEP_TIME) / 1000.0f;
 	m_Time += a_Delta;
-	if (m_Time > stepTimeSecond) {
+	while (m_Time > stepTimeSecond) {
-		m_Time = std::fmod(m_Time, stepTimeSecond);
+		m_Time -= stepTimeSecond;
 		auto lockStepPacket = m_Simulation.Update();
 		BroadcastPacket(lockStepPacket);
 	}
 }
 
-void GameState::OnPlayerJoin(PlayerID a_Id) {}
+void GameState::OnPlayerJoin(PlayerID a_Id, const td::PlayerInfo& a_Info) {
+	SendPacket(a_Id, m_World->GetPacketHeader());
+	SendPacket(a_Id, m_World->GetPacketData());
 
-void GameState::OnPlayerLeave(PlayerID a_Id) {}
+	// TODO: real teams
+	std::vector<PlayerInfo> team;
+	std::vector<protocol::LockStep> locksteps = m_Simulation.GetFirstLocksteps();
+
+	BroadcastPacket(protocol::packets::BeginGamePacket(team, team, locksteps));
+}
 
 }  // namespace server
 }  // namespace td

src/server/state/LobbyState.cpp

@@ -1,26 +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) {
+game::WorldPtr GetWorld() {
-	SetNewState(std::make_shared<GameState>(m_World));
+	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;
 }
 
-void LobbyState::OnPlayerJoin(PlayerID a_Id) {
+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::OnPlayerLeave(PlayerID a_Id) {
+void LobbyState::Update(float a_Delta) {}
-
-}
 
 }  // namespace server
 }  // namespace td

src/td/display/Display.cpp

@@ -1,4 +1,4 @@
-#include <td/input/Display.h>
+#include <td/display/Display.h>
 
 #include <GL/glew.h>
 #include <SDL3/SDL.h>
@@ -8,11 +8,15 @@
 
 #include <td/misc/Format.h>
 #include <td/misc/Log.h>
+#include <td/display/ImGuiTheme.h>
 
 namespace td {
 
 Display::Display(int a_Width, int a_Height, const std::string& a_Title) :
 	m_LastWidth(0), m_LastHeight(0), m_AspectRatio(1), m_ShouldClose(false) {
+	if (!SDL_Init(SDL_INIT_VIDEO)) {
+		utils::LOGE(utils::Format("Could not initialize SDL! SDL error: %s", SDL_GetError()));
+	}
 
 	m_Window = SDL_CreateWindow(a_Title.c_str(), a_Width, a_Height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
 
@@ -80,8 +84,7 @@ Display::Display(int a_Width, int a_Height, const std::string& a_Title) :
 	utils::LOG(utils::Format(
 		"GL Context : %i.%i %s, Color : R:%i G:%i B:%i A:%i, Depth bits : %i", major, minor, mask_desc, r, g, b, a, depth));
 
-	utils::LOG(utils::Format(
+	utils::LOG(utils::Format("MultiSamples : Buffers : %i, Samples : %i", mBuffers, mSamples));
-		"MultiSamples : Buffers : %i, Samples : %i", mBuffers, mSamples));
 
 	SDL_GL_MakeCurrent(m_Window, m_GLContext);
 
@@ -110,9 +113,11 @@ Display::Display(int a_Width, int a_Height, const std::string& a_Title) :
 	// Setup scaling
 	float main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
 	// ImGuiStyle& style = ImGui::GetStyle();
-	// style.ScaleAllSizes(main_scale);  // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this
+	// style.ScaleAllSizes(main_scale);  // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing
+	// this
 	// 								  // requires resetting Style + calling this again)
-	// style.FontSizeBase = 13 * main_scale;  // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave
+	// style.FontSizeBase = 13 * main_scale;  // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We
+	// leave
 	// 								  // both here for documentation purpose)
 
 
@@ -123,8 +128,12 @@ Display::Display(int a_Width, int a_Height, const std::string& a_Title) :
 	// Setup Platform/Renderer backends
 	ImGui_ImplSDL3_InitForOpenGL(m_Window, m_GLContext);
 	ImGui_ImplOpenGL3_Init("#version 330");
+	LoadTheme();
 }
 
+void Display::Close() {
+	m_ShouldClose = true;
+}
 
 void Display::PollEvents() {
 	SDL_Event event;
@@ -145,7 +154,7 @@ void Display::PollEvents() {
 			}
 
 			case SDL_EVENT_KEY_DOWN: {
-				if(!event.key.repeat)
+				if (!event.key.repeat)
 					OnKeyDown(event.key.key);
 				break;
 			}
@@ -161,7 +170,11 @@ void Display::PollEvents() {
 	ImGui::NewFrame();
 }
 
-void Display::Update() {
+void Display::Update(float a_Delta) {
+	StateMachine::Update(a_Delta);
+#ifndef NDEBUG
+	ImGui::ShowDemoWindow();
+#endif
 	ImGui::Render();
 	ImGuiIO& io = ImGui::GetIO();
 	glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);

src/td/display/DisplayState.cpp

@@ -0,0 +1,10 @@
+#include <td/display/DisplayState.h>
+
+namespace td {
+
+DisplayState::DisplayState(Display& a_Display) : Display::State(a_Display) {
+	Connect(m_StateMachine.OnKeyDown, std::bind(&DisplayState::OnKeyDown, this, std::placeholders::_1));
+	Connect(m_StateMachine.OnAspectRatioChange, std::bind(&DisplayState::OnAspectRatioChange, this, std::placeholders::_1));
+}
+
+}  // namespace td

src/td/display/ImGuiTheme.cpp

@@ -0,0 +1,88 @@
+#include <td/display/ImGuiTheme.h>
+
+#include <imgui.h>
+
+namespace td {
+
+void LoadTheme() {
+
+	static const bool bStyleDark_ = true;
+	static const float alpha_ = 0.8f;
+
+	ImGuiStyle& style = ImGui::GetStyle();
+
+	// light style from Pacôme Danhiez (user itamago) https://github.com/ocornut/imgui/pull/511#issuecomment-175719267
+	style.Alpha = 1.0f;
+	style.FrameRounding = 3.0f;
+	style.Colors[ImGuiCol_Text] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
+	style.Colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
+	style.Colors[ImGuiCol_WindowBg] = ImVec4(0.94f, 0.94f, 0.94f, 0.94f);
+	// style.Colors[ImGuiCol_ChildWindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
+	style.Colors[ImGuiCol_PopupBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.94f);
+	style.Colors[ImGuiCol_Border] = ImVec4(0.00f, 0.00f, 0.00f, 0.39f);
+	style.Colors[ImGuiCol_BorderShadow] = ImVec4(1.00f, 1.00f, 1.00f, 0.10f);
+	style.Colors[ImGuiCol_FrameBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.94f);
+	style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
+	style.Colors[ImGuiCol_FrameBgActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
+	style.Colors[ImGuiCol_TitleBg] = ImVec4(0.96f, 0.96f, 0.96f, 1.00f);
+	style.Colors[ImGuiCol_TitleBgCollapsed] = ImVec4(1.00f, 1.00f, 1.00f, 0.51f);
+	style.Colors[ImGuiCol_TitleBgActive] = ImVec4(0.82f, 0.82f, 0.82f, 1.00f);
+	style.Colors[ImGuiCol_MenuBarBg] = ImVec4(0.86f, 0.86f, 0.86f, 1.00f);
+	style.Colors[ImGuiCol_ScrollbarBg] = ImVec4(0.98f, 0.98f, 0.98f, 0.53f);
+	style.Colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.69f, 0.69f, 0.69f, 1.00f);
+	style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.59f, 0.59f, 0.59f, 1.00f);
+	style.Colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.49f, 0.49f, 0.49f, 1.00f);
+	// style.Colors[ImGuiCol_ComboBg] = ImVec4(0.86f, 0.86f, 0.86f, 0.99f);
+	style.Colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
+	style.Colors[ImGuiCol_SliderGrab] = ImVec4(0.24f, 0.52f, 0.88f, 1.00f);
+	style.Colors[ImGuiCol_SliderGrabActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
+	style.Colors[ImGuiCol_Button] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
+	style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
+	style.Colors[ImGuiCol_ButtonActive] = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);
+	style.Colors[ImGuiCol_Header] = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
+	style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
+	style.Colors[ImGuiCol_HeaderActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
+	// style.Colors[ImGuiCol_Column] = ImVec4(0.39f, 0.39f, 0.39f, 1.00f);
+	// style.Colors[ImGuiCol_ColumnHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.78f);
+	// style.Colors[ImGuiCol_ColumnActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
+	style.Colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 0.50f);
+	style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
+	style.Colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
+	// style.Colors[ImGuiCol_CloseButton] = ImVec4(0.59f, 0.59f, 0.59f, 0.50f);
+	// style.Colors[ImGuiCol_CloseButtonHovered] = ImVec4(0.98f, 0.39f, 0.36f, 1.00f);
+	// style.Colors[ImGuiCol_CloseButtonActive] = ImVec4(0.98f, 0.39f, 0.36f, 1.00f);
+	style.Colors[ImGuiCol_PlotLines] = ImVec4(0.39f, 0.39f, 0.39f, 1.00f);
+	style.Colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
+	style.Colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
+	style.Colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
+	style.Colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
+	// style.Colors[ImGuiCol_ModalWindowDarkening] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
+
+	if (bStyleDark_) {
+		for (int i = 0; i <= ImGuiCol_COUNT; i++) {
+			ImVec4& col = style.Colors[i];
+			float H, S, V;
+			ImGui::ColorConvertRGBtoHSV(col.x, col.y, col.z, H, S, V);
+
+			if (S < 0.1f) {
+				V = 1.0f - V;
+			}
+			ImGui::ColorConvertHSVtoRGB(H, S, V, col.x, col.y, col.z);
+			if (col.w < 1.00f) {
+				col.w *= alpha_;
+			}
+		}
+	} else {
+		for (int i = 0; i <= ImGuiCol_COUNT; i++) {
+			ImVec4& col = style.Colors[i];
+			if (col.w < 1.00f) {
+				col.x *= alpha_;
+				col.y *= alpha_;
+				col.z *= alpha_;
+				col.w *= alpha_;
+			}
+		}
+	}
+}
+
+}  // namespace td

src/td/display/menu/CreatePartyMenu.cpp

@@ -0,0 +1,16 @@
+#include <td/display/menu/CreatePartyMenu.h>
+
+#include <imgui.h>
+
+namespace td {
+
+CreatePartyMenu::CreatePartyMenu(MainMenuState& a_MainMenu) : MainMenuState::Menu(a_MainMenu) {}
+
+CreatePartyMenu::~CreatePartyMenu() {}
+
+void CreatePartyMenu::Update() {
+	ImGui::Text("CreatePartyMenu");
+	m_StateStack.RenderBackButton();
+}
+
+}  // namespace td

src/td/display/menu/JoinPartyMenu.cpp

@@ -0,0 +1,16 @@
+#include <td/display/menu/JoinPartyMenu.h>
+
+#include <imgui.h>
+
+namespace td {
+
+JoinPartyMenu::JoinPartyMenu(MainMenuState& a_MainMenu) : MainMenuState::Menu(a_MainMenu) {}
+
+JoinPartyMenu::~JoinPartyMenu() {}
+
+void JoinPartyMenu::Update() {
+	ImGui::Text("JoinPartyMenu");
+	m_StateStack.RenderBackButton();
+}
+
+}  // namespace td

src/td/display/menu/MainMenu.cpp

@@ -0,0 +1,28 @@
+#include <td/display/menu/MainMenu.h>
+
+#include <imgui.h>
+#include <td/display/menu/CreatePartyMenu.h>
+#include <td/display/menu/JoinPartyMenu.h>
+#include <td/display/menu/SettingsMenu.h>
+#include <td/display/state/DebugWorldState.h>
+
+namespace td {
+
+MainMenu::MainMenu(MainMenuState& a_MainMenu) : MainMenuState::Menu(a_MainMenu) {}
+
+MainMenu::~MainMenu() {}
+
+void MainMenu::Update() {
+	if (ImGui::Button("Create Party"))
+		m_StateStack.PushState<CreatePartyMenu>();
+	if (ImGui::Button("Join Party"))
+		m_StateStack.PushState<JoinPartyMenu>();
+	if (ImGui::Button("Settings"))
+		m_StateStack.PushState<SettingsMenu>();
+#ifndef NDEBUG
+	if (ImGui::Button("Debug world"))
+		m_StateStack.ChangeState<DebugWorldState>();
+#endif
+}
+
+}  // namespace td

src/td/display/menu/SettingsMenu.cpp

@@ -0,0 +1,16 @@
+#include <td/display/menu/SettingsMenu.h>
+
+#include <imgui.h>
+
+namespace td {
+
+SettingsMenu::SettingsMenu(MainMenuState& a_MainMenu) : MainMenuState::Menu(a_MainMenu) {}
+
+SettingsMenu::~SettingsMenu() {}
+
+void SettingsMenu::Update() {
+	ImGui::Text("SettingsMenu");
+	m_StateStack.RenderBackButton();
+}
+
+}  // namespace td

src/td/display/state/DebugWorldState.cpp

@@ -0,0 +1,116 @@
+#include <td/display/state/DebugWorldState.h>
+
+#include <chrono>
+#include <iostream>
+
+#include <td/game/World.h>
+#include <td/protocol/packet/Packets.h>
+#include <td/render/renderer/EntityRenderer.h>
+#include <td/render/renderer/PlayerListRenderer.h>
+#include <td/render/renderer/TimerRenderer.h>
+#include <td/render/renderer/TowerRenderer.h>
+#include <td/render/renderer/WorldRenderer.h>
+
+#include <server/Server.h>
+#include <server/socket/FakeSocket.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 {
+
+DebugWorldState::DebugWorldState(Display& a_Display) : DisplayState(a_Display) {
+	// server
+	m_ServerSocket = std::make_shared<server::FakeSocket>();
+	m_Server = std::make_unique<server::Server>(m_ServerSocket);
+
+	// client
+	auto clientFakeSocket = client::FakeSocket::Connect(m_ServerSocket);
+	m_Client = std::make_unique<client::Client>(clientFakeSocket);
+
+	// 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);
+			m_Renderer.AddRenderer<render::TimerRenderer>(*gameState);
+
+			auto& list = m_Renderer.AddRenderer<render::PlayerListRenderer>(m_Client->GetPlayers());
+
+			list.OnPlayerCreate.Connect([this]() {
+				auto newSocket = client::FakeSocket::Connect(m_ServerSocket);
+				auto newClient = std::make_unique<client::Client>(newSocket);
+				newClient->ChangeState<client::LoggingState>("Bot");
+				m_FakeClients.push_back(std::move(newClient));
+			});
+
+			list.OnPlayerKick.Connect([this](PlayerID a_Player) {
+				auto it = std::find_if(m_FakeClients.begin(), m_FakeClients.end(), [a_Player](auto& clientPtr) {
+					if (!clientPtr->GetId().has_value())
+						return false;
+					return clientPtr->GetId().value() == a_Player;
+				});
+				m_FakeClients.erase(it);
+			});
+
+			// update state
+			m_ClientState = gameState;
+		}
+	});
+
+	m_Client->ChangeState<client::LoggingState>("Player0");
+
+	// camera
+	m_Camera.SetCamPos({77, 7, 13});
+	m_Camera.UpdatePerspective(m_StateMachine.GetAspectRatio());
+}
+
+void DebugWorldState::Update(float a_Delta) {
+	m_Server->Update(a_Delta * m_PlaySpeed);
+	m_Client->Update(a_Delta * m_PlaySpeed);
+	if (m_ClientState)
+		m_Renderer.Render(m_ClientState->GetCurrentLerp());
+}
+
+void DebugWorldState::OnAspectRatioChange(float a_Ratio) {
+	m_Camera.UpdatePerspective(a_Ratio);
+}
+
+void DebugWorldState::OnKeyDown(SDL_Keycode a_Key) {
+	// temporary tests
+	constexpr int SECONDS = 10;
+	switch (a_Key) {
+		case SDLK_A:
+			m_Client->SendPacket(td::protocol::packets::SpawnTroopPacket(td::EntityType::Zombie, 1));
+			break;
+
+		case SDLK_Z:
+			m_Client->SendPacket(td::protocol::packets::PlaceTowerPacket(td::TowerType::Archer, td::TowerCoords(77, 13)));
+			break;
+
+		case SDLK_F:
+			m_Server->Update(SECONDS);
+			m_Client->Update(SECONDS);
+			break;
+
+		case SDLK_P:
+			m_PlaySpeed = 1 - m_PlaySpeed;
+			break;
+
+		default:
+			break;
+	}
+}
+
+DebugWorldState::~DebugWorldState() {}
+
+}  // namespace td

src/td/display/state/MainMenuState.cpp

@@ -0,0 +1,42 @@
+#include <td/display/state/MainMenuState.h>
+
+#include <imgui.h>
+#include <td/display/menu/MainMenu.h>
+#include <td/display/state/DebugWorldState.h>
+
+namespace td {
+
+MainMenuState::MainMenuState(Display& a_Display) : DisplayState(a_Display) {
+	PushState<MainMenu>();
+}
+
+MainMenuState::~MainMenuState() {}
+
+static int GetWindowFullScreenFlags() {
+	return ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoBackground;
+}
+
+static void SetNextWindowFullScreen() {
+	const ImGuiViewport* viewport = ImGui::GetMainViewport();
+	ImGui::SetNextWindowPos(viewport->WorkPos);
+	ImGui::SetNextWindowSize(viewport->WorkSize);
+}
+
+void MainMenuState::Update(float a_Delta) {
+	SetNextWindowFullScreen();
+	ImGui::Begin("MainWindow", nullptr, GetWindowFullScreenFlags());
+	MainMenuStateStack::Update();
+	ImGui::End();
+}
+
+void MainMenuState::RenderBackButton() {
+	if (ImGui::Button("Back"))
+		PopState();
+}
+
+void MainMenuState::OnKeyDown(SDL_Keycode a_Key) {
+	if (a_Key == SDLK_ESCAPE)
+		PopState();
+}
+
+}  // namespace td

src/td/game/World.cpp

@@ -1,5 +1,9 @@
+#include <cassert>
+#include <td/Maths.h>
 #include <td/game/World.h>
+#include <td/game/WorldTypes.h>
 
+#include <td/protocol/packet/PacketSerialize.h>
 #include <td/simulation/WorldTicker.h>
 
 namespace td {
@@ -14,7 +18,7 @@ class ColorTileVisitor : public TileHandler {
 	ColorTileVisitor(const World& a_World) : m_World(a_World), m_Result(nullptr) {}
 
 	virtual void Handle(const EmptyTile& a_Tile) override {}
-	
+
 	virtual void Handle(const TowerTile& a_Tile) override {
 		m_Result = &m_World.GetTowerTileColorPalette()[a_Tile->m_ColorPaletteRef];
 	}
@@ -62,6 +66,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;
@@ -78,5 +92,14 @@ void World::ResetSnapshots(std::shared_ptr<sim::WorldSnapshot>& a_Current, std::
 	m_NextState = a_Next;
 }
 
+TilePtr World::GetTile(std::int32_t x, std::int32_t y) const {
+	ChunkCoord coords{static_cast<std::int16_t>(x / Chunk::ChunkWidth), static_cast<std::int16_t>(y / Chunk::ChunkHeight)};
+	auto it = m_Chunks.find(coords);
+	assert(it != m_Chunks.end());
+	auto chunk = it->second;
+	Vec2i inchunkCoords{x % Chunk::ChunkWidth, y % Chunk::ChunkHeight};
+	return GetTilePtr(chunk->GetTileIndex(inchunkCoords.y * Chunk::ChunkWidth + inchunkCoords.x));
+}
+
 }  // namespace game
 }  // namespace td

src/td/render/Camera.cpp

@@ -1,3 +1,4 @@
+#include "td/Maths.h"
 #include <td/render/Camera.h>
 
 #include <cmath>
@@ -24,5 +25,9 @@ void Camera::SetCamPos(const Vec3f& a_NewPos) {
 	OnViewChange();
 }
 
+const Vec3f& Camera::GetCamPos() const {
+	return m_CamPos;
+}
+
 }  // namespace render
 }  // namespace td

src/td/render/Renderer.cpp

@@ -8,10 +8,17 @@ namespace render {
 void BasicRenderer::Render(const GL::VertexArray& a_Vao) {
 	a_Vao.Bind();
 	glDrawArrays(GL_TRIANGLES, 0, a_Vao.GetVertexCount());
-	// glDrawElements(GL_TRIANGLES, a_Vao.GetVertexCount(), GL_UNSIGNED_INT, nullptr);
 	a_Vao.Unbind();
 }
 
+void BasicRenderer::Render(const Model& a_Model) {
+	for (const auto& vao : a_Model.m_Vaos) {
+		vao->Bind();
+		glDrawElements(GL_TRIANGLES, vao->GetVertexCount(), GL_UNSIGNED_INT, nullptr);
+		vao->Unbind();
+	}
+}
+
 RenderPipeline::RenderPipeline() {
 	glEnable(GL_TEXTURE_2D);
 	glEnable(GL_BLEND);

src/td/render/loader/FbxLoader.cpp

@@ -0,0 +1,128 @@
+#include <td/render/loader/FbxLoader.h>
+
+#include <assimp/Importer.hpp>	 // C++ importer interface
+#include <assimp/postprocess.h>	 // Post processing flags
+#include <assimp/scene.h>		 // Output data structure
+#include <iostream>
+#include <memory>
+#include <sp/common/DataBuffer.h>
+#include <td/render/loader/GLLoader.h>
+#include <vector>
+
+#define VERTEX_SIZE 3
+#define UV_SIZE 2
+
+#define VERTEX_POSITION_INDEX 0
+#define VERTEX_UV_INDEX 1
+#define VERTEX_NORMAL_INDEX 2
+
+namespace td {
+namespace ModelLoader {
+
+static std::unique_ptr<GL::VertexArray> ProcessMesh(aiMesh* mesh, const aiScene* scene, const aiMatrix4x4& transform) {
+	std::vector<float> positions;
+	std::vector<float> textureCoords;
+	std::vector<float> normals;
+
+	std::vector<unsigned int> indicies;
+
+	aiFace* faces = mesh->mFaces;
+	std::size_t faceNumber = mesh->mNumFaces;
+
+	for (std::size_t j = 0; j < faceNumber; j++) {
+		std::size_t offset = indicies.size();
+		std::size_t numIndices = faces[j].mNumIndices;
+
+		indicies.resize(indicies.size() + numIndices);
+		std::memcpy(indicies.data() + offset, faces[j].mIndices, numIndices * sizeof(unsigned int));
+	}
+
+	std::size_t vertNumber = mesh->mNumVertices;
+	aiVector3D* vertecies = mesh->mVertices;
+
+	for (std::size_t j = 0; j < vertNumber; j++) {
+		aiVector3D vertex = transform * vertecies[j];
+
+		positions.push_back(vertex.x);
+		positions.push_back(vertex.y);
+		positions.push_back(vertex.z);
+	}
+
+	if (mesh->HasNormals()) {
+		aiVector3D* vertexNormals = mesh->mNormals;
+
+		for (std::size_t j = 0; j < vertNumber; j++) {
+			aiVector3D normal = transform * vertexNormals[j];
+
+			normals.push_back(normal.x);
+			normals.push_back(normal.y);
+			normals.push_back(normal.z);
+		}
+	}
+
+	aiVector3D** vertexTexture = mesh->mTextureCoords;
+
+	for (std::size_t j = 0; j < vertNumber; j++) {
+		textureCoords.push_back(vertexTexture[0][j].x);
+		textureCoords.push_back(vertexTexture[0][j].y);
+	}
+
+	GL::VertexBuffer positionVBO(positions, VERTEX_SIZE);
+	positionVBO.AddVertexAttribPointer(VERTEX_POSITION_INDEX, VERTEX_SIZE, 0);
+
+	GL::VertexBuffer textureVBO(textureCoords, UV_SIZE);
+	textureVBO.AddVertexAttribPointer(VERTEX_UV_INDEX, UV_SIZE, 0);
+
+	GL::VertexBuffer normalVBO(normals, VERTEX_SIZE);
+	normalVBO.AddVertexAttribPointer(VERTEX_NORMAL_INDEX, VERTEX_SIZE, 0);
+
+	auto Vao = std::make_unique<GL::VertexArray>(GL::ElementBuffer{indicies});
+	Vao->Bind();
+	Vao->BindVertexBuffer(std::move(positionVBO));
+	Vao->BindVertexBuffer(std::move(textureVBO));
+	Vao->BindVertexBuffer(std::move(normalVBO));
+	Vao->Unbind();
+
+	return Vao;
+}
+
+static void ProcessNode(
+	aiNode* node, const aiScene* scene, std::vector<std::unique_ptr<GL::VertexArray>>& meshes, const aiMatrix4x4& transform) {
+	// recursive
+	for (unsigned int i = 0; i < node->mNumChildren; i++) {
+		ProcessNode(node->mChildren[i], scene, meshes, transform * node->mTransformation);
+	}
+
+	for (unsigned int i = 0; i < node->mNumMeshes; i++) {
+		aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
+		meshes.push_back(ProcessMesh(mesh, scene, transform * node->mTransformation));
+	}
+}
+
+Model LoadModel(const std::string& fileName) {
+	// DataBuffer fileData = utils::AssetsManager::GetAsset(fileName);
+	sp::DataBuffer fileData;
+	fileData.ReadFile(fileName);
+
+	Assimp::Importer importer;
+
+	const aiScene* scene = importer.ReadFile(fileName, aiProcess_CalcTangentSpace | aiProcess_Triangulate | aiProcess_SortByPType |
+														   aiProcess_OptimizeGraph | aiProcess_OptimizeMeshes | aiProcess_GlobalScale | aiProcess_FlipUVs);
+
+	if (!scene) {
+		std::cerr << "[ModelLoader] Failed to load model !\n";
+		return {};
+	}
+
+	// utils::LOGD(utils::Format("[ModelLoader]\tModel nodes : %i", scene->mRootNode->mNumMeshes));
+
+	Model model;
+	ProcessNode(scene->mRootNode, scene, model.m_Vaos, {});
+
+	std::cout << "Loaded " << model.m_Vaos.size() << " vaos !\n";
+
+	return model;
+}
+
+}  // namespace ModelLoader
+}  // namespace td

src/td/render/loader/TextureLoader.cpp

@@ -0,0 +1,89 @@
+/*
+ * TextureLoader.cpp
+ *
+ *  Created on: 15 nov. 2020
+ *      Author: simon
+ */
+
+// #include "render/loader/TextureLoader.h"
+// #include "render/loader/stb_image.h"
+// #include "render/GL.h"
+// #include "misc/Log.h"
+// #include "misc/Format.h"
+
+#include <td/render/loader/TextureLoader.h>
+
+#include <stdexcept>
+#include <td/misc/Log.h>
+#include <utility>
+
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb_image.h>
+
+#include <td/render/OpenGL.h>
+
+namespace td {
+namespace TextureLoader {
+
+GL::Texture LoadTexture(const std::string& fileName) {
+
+	int width, height, comp;
+
+	unsigned char* image = stbi_load(fileName.c_str(), &width, &height, &comp, STBI_rgb_alpha);
+
+	if (image == nullptr) {
+		utils::LOGE("Erreur lors du chargement de la texture !");
+		throw std::runtime_error("Failed to load texture");
+	}
+
+	GL::Texture texture(reinterpret_cast<const char*>(image), width, height, comp);
+
+	stbi_image_free(image);
+
+	// utils::LOGD(utils::format("Texture %s chargée !", fileName.c_str()));
+
+	return texture;
+}
+
+}  // namespace TextureLoader
+
+namespace GL {
+
+Texture::Texture(const char* textureData, int width, int height, int comp) {
+	glGenTextures(1, &m_ID);
+
+	Bind();
+
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	assert(comp == 3 || comp == 4);
+
+	if (comp == 3)
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, textureData);
+	else
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData);
+
+	Unbind();
+}
+
+Texture::Texture(Texture&& a_Other) {
+	std::swap(m_ID, a_Other.m_ID);
+}
+
+Texture::~Texture() {
+	glDeleteTextures(1, &m_ID);
+}
+
+void Texture::Bind() const {
+	glBindTexture(GL_TEXTURE_2D, m_ID);
+}
+
+void Texture::Unbind() const {
+	glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+
+}  // namespace GL
+
+}  // namespace td

src/td/render/renderer/EntityRenderer.cpp

@@ -1,3 +1,6 @@
+#include "td/render/Renderer.h"
+#include "td/render/loader/TextureLoader.h"
+#include <memory>
 #include <td/render/renderer/EntityRenderer.h>
 
 #include <td/render/loader/WorldLoader.h>
@@ -5,10 +8,11 @@
 namespace td {
 namespace render {
 
-EntityRenderer::EntityRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(a_Camera), m_World(a_World) {
+EntityRenderer::EntityRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World) {
-	m_EntityVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadMobModel());
+	m_EntityModel = ModelLoader::LoadModel("assets/zombie.fbx");
+	m_EntityTexture = std::make_unique<GL::Texture>(TextureLoader::LoadTexture("assets/zombie.png"));
 	m_Shader->Start();
-	m_Shader->SetColorEffect({1, 0, 1});
+	m_Shader->SetColorEffect({1, 1, 1});
 }
 
 EntityRenderer::~EntityRenderer() {}
@@ -17,13 +21,14 @@ EntityRenderer::~EntityRenderer() {}
 
 void EntityRenderer::Render(float a_Lerp) {
 	m_Shader->Start();
-	for (const auto& mob : m_World.GetMobList()) {
+	for (const auto& mob : m_World->GetMobList()) {
 
 		float x = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.x); });
 		float z = Lerp<game::Mob>(*mob, a_Lerp, [](const game::Mob& a_Mob) { return static_cast<float>(a_Mob.m_Position.y); });
 
-		m_Shader->SetModelPos({x, 1, z});
+		m_Shader->SetModelPos({x, .001, z});
-		Renderer::Render(*m_EntityVao);
+		m_EntityTexture->Bind();
+		Renderer::Render(m_EntityModel);
 	}
 }
 

src/td/render/renderer/PlayerListRenderer.cpp

@@ -0,0 +1,32 @@
+#include <td/render/renderer/PlayerListRenderer.h>
+
+#include <imgui.h>
+#include <optional>
+
+namespace td {
+namespace render {
+
+void PlayerListRenderer::Render(float a_Lerp) {
+	ImGui::Begin("Players");
+	if (ImGui::Button("Add player")) {
+		OnPlayerCreate();
+	}
+	std::optional<PlayerID> kick;
+	for (const auto& [id, player] : m_Players) {
+		ImGui::PushID(id);
+		ImGui::Text("[%i] %s", id, player.m_PlayerName.c_str());
+		ImGui::SameLine();
+		if (ImGui::Button("Kick")){
+			kick = id;
+		}
+		ImGui::PopID();
+	}
+	ImGui::End();
+	if (kick.has_value())
+		OnPlayerKick(*kick);
+}
+
+PlayerListRenderer::PlayerListRenderer(const client::PlayerManager& a_Players) : m_Players(a_Players) {}
+
+}  // namespace render
+}  // namespace td

src/td/render/renderer/TimerRenderer.cpp

@@ -0,0 +1,18 @@
+#include <client/state/GameState.h>
+#include <td/render/renderer/TimerRenderer.h>
+
+#include <imgui.h>
+
+namespace td {
+namespace render {
+
+void TimerRenderer::Render(float a_Lerp) {
+	ImGui::Begin("Timer");
+	ImGui::Text("Time : %02d:%02d", static_cast<int>(m_State.GetElapsedTime()) / 60, static_cast<int>(m_State.GetElapsedTime()) % 60);
+	ImGui::End();
+}
+
+TimerRenderer::TimerRenderer(const client::GameState& a_State) : m_State(a_State) {}
+
+}  // namespace render
+}  // namespace td

src/td/render/renderer/TowerRenderer.cpp

@@ -5,7 +5,7 @@
 namespace td {
 namespace render {
 
-TowerRenderer::TowerRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(a_Camera), m_World(a_World) {
+TowerRenderer::TowerRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera), m_World(a_World) {
 	m_EntityVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadMobModel());
 	m_Shader->Start();
 	m_Shader->SetColorEffect({0, 0, 1});
@@ -17,8 +17,8 @@ TowerRenderer::~TowerRenderer() {}
 
 void TowerRenderer::Render(float a_Lerp) {
 	m_Shader->Start();
-	for (const auto& tower : m_World.GetTowers()) {
+	for (const auto& tower : m_World->GetTowers()) {
-		m_Shader->SetModelPos({tower->GetCenterX(), 1, tower->GetCenterY()});
+		m_Shader->SetModelPos({tower->GetCenterX(), .001, tower->GetCenterY()});
 		Renderer::Render(*m_EntityVao);
 	}
 }

src/td/render/renderer/WorldRenderer.cpp

@@ -1,3 +1,4 @@
+#include <td/Maths.h>
 #include <td/render/renderer/WorldRenderer.h>
 
 #include <td/render/loader/WorldLoader.h>
@@ -7,16 +8,25 @@
 namespace td {
 namespace render {
 
-WorldRenderer::WorldRenderer(Camera& a_Camera, const game::World& a_World) : Renderer(a_Camera) {
+WorldRenderer::WorldRenderer(Camera& a_Camera, const game::WorldPtr& a_World) : Renderer(a_Camera) {
-	m_WorldVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadWorldModel(&a_World));
+	m_WorldVao = std::make_unique<GL::VertexArray>(WorldLoader::LoadWorldModel(a_World.get()));
 }
 
 WorldRenderer::~WorldRenderer() {}
 
+void WorldRenderer::UpdateControls() {
+	if (ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
+		constexpr float sensitivity = 1.0f;
+		float delta = ImGui::GetIO().DeltaTime;
+		auto mouseDelta = ImGui::GetIO().MouseDelta;
+		m_Camera.SetCamPos(m_Camera.GetCamPos() + Vec3f{-mouseDelta.x * delta * sensitivity, 0, -mouseDelta.y * delta * sensitivity});
+	}
+}
+
 void WorldRenderer::Render(float a_Lerp) {
+	UpdateControls();
 	m_Shader->Start();
 	Renderer::Render(*m_WorldVao);
-	ImGui::ShowDemoWindow();
 }
 
 }  // namespace render

src/td/render/shader/EntityShader.cpp

@@ -53,12 +53,16 @@ static const char vertexSource[] = R"(
 #version 330
 
 layout(location = 0) in vec3 position;
+layout(location = 1) in vec2 texCoords;
 
 uniform mat4 viewMatrix;
 uniform mat4 projectionMatrix;
 uniform vec3 modelPosition;
 
+out vec2 pass_textureCoords;
+
 void main(void){
+	pass_textureCoords = texCoords;
 	gl_Position = projectionMatrix * viewMatrix * vec4(position + modelPosition, 1.0);
 }
 )";
@@ -66,19 +70,23 @@ void main(void){
 static const char fragmentSource[] = R"(
 #version 330
 
+in vec2 pass_textureCoords;
+
 out vec4 out_color;
 
 uniform vec3 ColorEffect;
+uniform sampler2D textureSampler;
 
 void main(void){
 
-	vec4 color = vec4(ColorEffect, 1.0);
+	vec4 color = vec4(ColorEffect, 1.0) * texture(textureSampler, pass_textureCoords);
 
 	if (color.a <= 0.1)
 		discard;
 
 	out_color = color;
 
+
 }
 )";
 #endif

src/td/simulation/ClientSimulation.cpp

@@ -16,11 +16,10 @@ std::uint64_t GetTime() {
 		std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock().now().time_since_epoch()).count());
 }
 
-ClientSimulation::ClientSimulation(game::World& a_World, GameHistory&& a_History, std::uint64_t a_StepTime) :
+ClientSimulation::ClientSimulation(std::shared_ptr<game::World> a_World, GameHistory&& a_History, std::uint64_t a_StepTime) :
 	m_StepTime(a_StepTime),
 	m_World(a_World),
 	m_CurrentTime(0),
-	m_LastTime(GetTime()),
 	m_CurrentStep(0),
 	m_LastSnapshot(std::make_shared<WorldSnapshot>()),
 	m_LastValidStep(0) {
@@ -31,37 +30,44 @@ ClientSimulation::ClientSimulation(game::World& a_World, GameHistory&& a_History
 	Step();
 }
 
-ClientSimulation::ClientSimulation(game::World& a_World, std::uint64_t a_StepTime) :
+ClientSimulation::ClientSimulation(
+	std::shared_ptr<game::World> a_World, std::uint64_t a_StepTime, const std::vector<protocol::LockStep>& a_FirstSteps) :
 	m_StepTime(a_StepTime),
 	m_World(a_World),
 	m_History(std::numeric_limits<StepTime>::max()),
 	m_CurrentTime(0),
-	m_LastTime(GetTime()),
 	m_CurrentStep(0),
 	m_LastSnapshot(std::make_shared<WorldSnapshot>()),
-	m_LastValidStep(0) {}
+	m_LastValidStep(0) {
-
+	if (!a_FirstSteps.empty()) {
-float ClientSimulation::Update() {
+		for (std::size_t i = 0; i < a_FirstSteps.size(); i++) {
-	// TODO: handle freezes (m_CurrentTime > 2 * m_StepTime)
+			m_History[i] = a_FirstSteps[i];
-	m_CurrentTime += GetTime() - m_LastTime;
+		}
-	m_LastTime = GetTime();
+		FastForward(a_FirstSteps.size());
-	if (m_CurrentTime > m_StepTime) {
-		Step();
-		m_CurrentTime %= m_StepTime;
 	}
-	return (float)m_CurrentTime / (float)m_StepTime;
+}
+
+float ClientSimulation::Update(float a_Delta) {
+	// TODO: handle freezes (m_CurrentTime > 2 * m_StepTime)
+	static const float stepTimeSecond = static_cast<float>(m_StepTime) / 1000.0f;
+	m_CurrentTime += a_Delta;
+	while (m_CurrentTime > stepTimeSecond) {
+		m_CurrentTime -= stepTimeSecond;
+		Step();
+	}
+	return (float)m_CurrentTime / stepTimeSecond;
 }
 
 bool ClientSimulation::Step() {
 	const auto& step = m_History[m_CurrentStep];
 	if (step.has_value()) {
-		auto snapshot = m_World.Tick(step.value(), FpFloat(m_StepTime) / FpFloat(1000));
+		auto snapshot = m_World->Tick(step.value(), FpFloat(m_StepTime) / FpFloat(1000));
 		if (m_LastValidStep + 1 == m_CurrentStep) {
 			m_LastValidStep = m_CurrentStep;
 			m_LastSnapshot = snapshot;
 		}
 	} else {
-		m_World.Tick(EMPTY_LOCKSTEP, FpFloat(m_StepTime) / FpFloat(1000));
+		m_World->Tick(EMPTY_LOCKSTEP, FpFloat(m_StepTime) / FpFloat(1000));
 		std::cout << "Empty tick (" << m_CurrentStep << ") !\n";
 	}
 	m_CurrentStep++;
@@ -105,7 +111,7 @@ void ClientSimulation::FastReplay() {
 	if (m_LastValidStep + 1 >= m_CurrentStep)
 		return;
 
-	m_World.ResetSnapshots(m_LastSnapshot, m_LastSnapshot);
+	m_World->ResetSnapshots(m_LastSnapshot, m_LastSnapshot);
 
 	const std::size_t stepCount = m_CurrentStep - m_LastValidStep;
 	m_CurrentStep = m_LastValidStep;

src/td/simulation/CommandApply.cpp

@@ -1,3 +1,4 @@
+#include <td/Types.h>
 #include <td/simulation/CommandApply.h>
 
 namespace td {
@@ -6,7 +7,7 @@ namespace sim {
 CommandApply::CommandApply(const game::World& a_World, WorldSnapshot& a_Snapshot) : m_World(a_World), m_Snapshot(a_Snapshot) {}
 
 void CommandApply::Handle(const protocol::commands::EndCommand& a_End) {
-	(void) m_World;
+	(void)m_World;
 }
 
 void CommandApply::Handle(const protocol::commands::PlaceTowerCommand& a_PlaceTower) {
@@ -24,6 +25,10 @@ void CommandApply::Handle(const protocol::commands::PlayerJoinCommand& a_PlayerJ
 void CommandApply::Handle(const protocol::commands::SpawnTroopCommand& a_SpawnTroop) {
 	auto zombie = std::make_shared<game::Zombie>();
 	zombie->m_Position = a_SpawnTroop->m_Position;
+
+	// TODO: make it spawn dependant
+	zombie->m_Direction = Direction::PositiveY;
+
 	m_Snapshot.m_Mobs.push_back(zombie);
 }
 

src/td/simulation/ServerSimulation.cpp

@@ -47,6 +47,16 @@ protocol::packets::LockStepResponsePacket ServerSimulation::GetResponse(
 	return {result};
 }
 
+std::vector<protocol::LockStep> ServerSimulation::GetFirstLocksteps() {
+	std::vector<protocol::LockStep> result;
+	if (m_CurrentTime <= LOCKSTEP_BUFFER_SIZE)
+		return result;
+
+	result.reserve(m_CurrentTime);
+	result.insert(result.begin(), m_History.begin(), m_History.begin() + m_CurrentTime);
+	return result;
+}
+
 
 }  // namespace sim
 }  // namespace td

src/td/simulation/system/EntityMove.cpp

@@ -1,11 +1,61 @@
+#include <td/Maths.h>
+#include <td/Types.h>
+#include <td/game/WorldTypes.h>
 #include <td/simulation/system/EntityMove.h>
 
+#include <td/game/World.h>
+
 namespace td {
 namespace sim {
 
+static Vec2i GetUnitDirection(Direction a_Direction) {
+	switch (a_Direction) {
+		case Direction::PositiveX:
+			return {1, 0};
+		case Direction::NegativeX:
+			return {-1, 0};
+		case Direction::PositiveY:
+			return {0, 1};
+		case Direction::NegativeY:
+			return {0, -1};
+	}
+	return {0, 0};
+}
+
+class DirectionTileVisitor : public game::TileHandler {
+  private:
+	Direction m_Direction;
+
+  public:
+	DirectionTileVisitor() {}
+
+	virtual void Handle(const game::EmptyTile& a_Tile) override {}
+
+	virtual void Handle(const game::TowerTile& a_Tile) override {}
+
+	virtual void Handle(const game::DecorationTile& a_Tile) override {}
+
+	virtual void Handle(const game::WalkableTile& a_Tile) override {
+		m_Direction = a_Tile->m_Direction;
+	}
+
+	const Direction GetDirection() {
+		return m_Direction;
+	}
+};
+
 void EntityMove::Tick(const game::World& a_World, WorldSnapshot& a_State, FpFloat a_Delta) {
 	for (auto& mob : a_State.m_Mobs) {
-		mob->m_Position.x += a_Delta;
+		auto tile = a_World.GetTile(static_cast<std::int32_t>(mob->m_Position.x), static_cast<std::int32_t>(mob->m_Position.y));
+		Direction direction = mob->m_Direction;
+		if (tile) {
+			DirectionTileVisitor visitor;
+			tile->Dispatch(visitor);
+			direction = visitor.GetDirection();
+		}
+		auto directVector = GetUnitDirection(direction);
+		mob->m_Position.x += directVector.x * a_Delta;
+		mob->m_Position.y += directVector.y * a_Delta;
 	}
 }
 

xmake.lua

@@ -3,27 +3,29 @@ add_rules("mode.debug", "mode.release")
 add_repositories("persson-repo https://git.ale-pri.com/Persson-dev/xmake-repo.git")
 
 add_requires("imgui 1.92.0", {configs = {sdl3 = true, opengl3 = true}})
-add_requires("splib 2.3.0", "zlib")
+add_requires("libsdl3 3.2.16", "splib 2.3.2", "zlib", "glew", "fpm", "enet6", "assimp", "stb")
-add_requires("libsdl3 3.2.16", "glew", "fpm", "enet6")
 
-set_languages("c++17")
+set_languages("c++20")
 
 set_warnings("all")
 
 if is_mode("release") then
     set_warnings("all", "error")
+else
+    set_policy("build.sanitizer.address", true)
+    set_policy("build.sanitizer.leak", true)
+    set_policy("build.sanitizer.undefined", true)
 end
 
 target("Tower-Defense2")
     add_includedirs("include", {public = true})
     set_kind("binary")
     add_files("src/**.cpp")
-    add_packages("libsdl3", "imgui", "glew", "splib", "zlib", "fpm", "enet6", {public = true})
+    add_packages("libsdl3", "imgui", "glew", "splib", "zlib", "fpm", "assimp", "enet6", "stb", {public = true})
     set_rundir(".")
     add_defines("TD_GL_LOADER_GLEW")
 
 
-
 -- Tests
 for _, file in ipairs(os.files("test/**.cpp")) do
     local name = path.basename(file)