1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
#pragma once
#include <queue>
#include <map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <variant>
#include <functional>
#include "Vector.hpp"
#include "Packet.hpp"
#include "FSM.hpp"
enum class EventType {
Echo,
ChunkChanged,
ConnectToServer,
ConnectionSuccessfull,
GlobalAppState,
Disconnect,
RequestNetworkClient,
RegisterNetworkClient,
PlayerConnected,
RemoveLoadingScreen,
ConnectionFailed,
};
struct EchoData {
std::chrono::time_point<std::chrono::high_resolution_clock> time;
};
struct ChunkChangedData {
Vector chunkPosition;
};
struct ConnectToServerData {
std::string address;
unsigned short port;
};
class NetworkClient;
struct ConnectionSuccessfullData {
NetworkClient *ptr;
};
enum class GlobalState {
InitialLoading,
MainMenu,
Connecting,
Loading,
Playing,
PauseMenu,
Exiting,
};
void SetGlobalState(GlobalState state);
struct GlobalAppStateData {
GlobalState state;
};
struct DisconnectData {
};
struct SendPacketData {
std::shared_ptr<Packet> packet;
};
struct ReceivePacketData {
std::shared_ptr<Packet> packet;
};
struct RequestNetworkClientData {
};
struct RegisterNetworkClientData {
NetworkClient *ptr;
};
class GameState;
struct PlayerConnectedData {
GameState *ptr;
};
struct RemoveLoadingScreenData {
};
struct ConnectionFailedData {
std::string reason;
};
using EventData = std::variant<EchoData, ChunkChangedData, ConnectToServerData, ConnectionSuccessfullData,
GlobalAppStateData, DisconnectData, SendPacketData, ReceivePacketData, RequestNetworkClientData,
RegisterNetworkClientData, PlayerConnectedData, RemoveLoadingScreenData, ConnectionFailedData>;
struct Event {
EventType type;
EventData data;
};
class EventListener {
friend class EventAgregator;
using HandlerFunc = std::function<void(EventData)>;
std::map<EventType, HandlerFunc> handlers; //TODO: There must be more elegant solution than std::variant of all data
std::mutex handlersMutex;
std::queue<Event> events;
std::mutex eventsMutex;
void PushEvent(Event event);
public:
EventListener();
~EventListener();
bool IsEventsQueueIsNotEmpty();
void RegisterHandler(EventType type, HandlerFunc handler);
void HandleEvent();
};
class EventAgregator {
friend EventListener;
EventAgregator() = default;
static std::queue<Event> eventsToHandle;
static std::mutex queueMutex;
static bool isStarted;
static std::vector<EventListener *> listeners;
static std::mutex listenersMutex;
static void EventHandlingLoop();
static void RegisterListener(EventListener &listener);
static void UnregisterListener(EventListener &listener);
public:
static void PushEvent(EventType type, EventData data);
};
|
