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

add StateMachine

Browse Source
This commit is contained in:
Simon Pribylski
2025-08-09 11:23:17 +02:00
parent ac3e949323
commit cba790f804
23 changed files with 174 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/client/Client.h
View File

@@ -1,29 +1,21 @@
#pragma once
#include <client/IClientSocket.h>
#include <client/IClientState.h>
#include <chrono>
#include <td/common/StateMachine.h>
namespace td {
namespace client {
class Client {
class ClientState;
class Client : public StateMachine<Client, void, float> {
private:
std::shared_ptr<IClientSocket> m_Socket;
std::shared_ptr<IClientState> m_State;
std::chrono::time_point<std::chrono::system_clock> m_LastTime;
public:
Client(const std::shared_ptr<IClientSocket>& a_Socket) : m_Socket(a_Socket), m_LastTime(std::chrono::system_clock::now()) {}
Client(const std::shared_ptr<IClientSocket>& a_Socket) : m_Socket(a_Socket) {}
void Update();
void UpdateState(const std::shared_ptr<IClientState>& a_State);
private:
void Update(float a_Delta);
friend class IClientState;
friend class ClientState;
};
} // namespace client

20
include/client/ClientState.h Normal file
View File

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

33
include/client/IClientState.h
View File

@@ -1,33 +0,0 @@
#pragma once
#include <client/IClientSocket.h>
#include <td/misc/SlotGuard.h>
namespace td {
namespace client {
class Client;
class IClientState : private utils::SlotGuard {
public:
virtual void HandlePacket(const protocol::PacketBase& a_Packet) = 0;
virtual void Update(float a_Delta) = 0;
IClientState();
virtual ~IClientState();
protected:
void SendPacket(const protocol::PacketBase& a_Packet);
void SetNewState(const std::shared_ptr<IClientState>& a_NewState);
virtual void Init() {}
private:
Client* m_Client;
void SetClient(Client* a_Client);
friend class Client;
};
} // namespace server
} // namespace td

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

@@ -1,25 +1,24 @@
#pragma once
#include <client/IClientState.h>
#include <client/ClientState.h>
#include <td/game/World.h>
#include <td/simulation/ServerSimulation.h>
namespace td {
namespace client {
class GameState : public IClientState {
class GameState : public ClientState {
private:
std::shared_ptr<game::World> m_World;
public:
GameState(const std::shared_ptr<game::World>& a_World);
GameState(Client& a_Client, const std::shared_ptr<game::World>& a_World);
~GameState() {}
virtual void HandlePacket(const protocol::PacketBase& a_Packet) override;
virtual void Update(float a_Delta) override;
protected:
virtual void Init() override;
virtual void HandlePacket(const protocol::PacketBase& a_Packet) override;
};
} // namespace client

36
include/server/IServerState.h
View File

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

21
include/server/Server.h
View File

@@ -1,30 +1,21 @@
#pragma once
#include <memory>
#include <server/IServerSocket.h>
#include <server/IServerState.h>
#include <chrono>
#include <td/common/StateMachine.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;
std::chrono::time_point<std::chrono::system_clock> m_LastTime;
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) : m_Socket(a_Socket) {}
void Update();
void UpdateState(const std::shared_ptr<IServerState>& a_State);
private:
void Update(float a_Delta);
friend class IServerState;
friend class ServerState;
};
} // namespace server

23
include/server/ServerState.h Normal file
View File

@@ -0,0 +1,23 @@
#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;
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

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

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

11
include/server/state/GameState.h
View File

@@ -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,18 @@ 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 Init() override;
friend class GameStateHandler;
};

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

@@ -1,22 +1,20 @@
#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, const std::shared_ptr<game::World>& a_World);
~LobbyState() {}
virtual void HandlePacket(PlayerID a_Id, const protocol::PacketBase& a_Packet) override;
virtual void Update(float a_Delta) override;
virtual void OnPlayerJoin(PlayerID a_Id) override;
virtual void OnPlayerLeave(PlayerID a_Id) override;
};
} // namespace server

39
include/td/common/StateMachine.h Normal file
View File

@@ -0,0 +1,39 @@
#pragma once
#include <memory>
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;
protected:
TDerived& m_StateMachine;
};
StateMachine() {}
virtual ~StateMachine() {}
TReturn Update(TArgs... args) {
assert(m_State);
return m_State->Update(args...);
}
template <typename T, typename... Args>
void ChangeState(Args&&... args) {
m_State = std::make_unique<T>(static_cast<TDerived&>(*this), args...);
}
private:
std::unique_ptr<State> m_State;
};
} // namespace td

5
include/td/simulation/ClientSimulation.h
View File

@@ -16,8 +16,7 @@ class ClientSimulation : public protocol::PacketHandler {
std::uint64_t m_StepTime;
game::World& m_World;
GameBuffer m_History;
std::uint64_t m_CurrentTime;
std::uint64_t m_LastTime;
float m_CurrentTime;
StepTime m_CurrentStep;
std::shared_ptr<WorldSnapshot> m_LastSnapshot;
@@ -45,7 +44,7 @@ class ClientSimulation : public protocol::PacketHandler {
/**
* \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;