Debian Codegraph @

Sources/Jazz2/Actors/Multiplayer/RemotePlayerOnServer.cpp

raw
1 #include "RemotePlayerOnServer.h"
2
3 #if defined(WITH_MULTIPLAYER)
4
5 #include "../Weapons/ShotBase.h"
6 #include "../../Multiplayer/MpLevelHandler.h"
7 #include "../../../nCine/Base/Clock.h"
8
9 namespace Jazz2::Actors::Multiplayer
10 {
11 RemotePlayerOnServer::RemotePlayerOnServer(std::shared_ptr<PeerDescriptor> peerDesc)
12 : _stateBufferPos(0), Flags(PlayerFlags::None), PressedKeys(0),
13 PressedKeysLast(0), UpdatedFrame(0)
14 {
15 _peerDesc = std::move(peerDesc);
16 _peerDesc->Player = this;
17 }
18
19 Task<bool> RemotePlayerOnServer::OnActivatedAsync(const ActorActivationDetails& details)
20 {
21 Clock& c = nCine::clock();
22 std::uint64_t now = c.now() * 1000 / c.frequency();
23 for (std::int32_t i = 0; i < std::int32_t(arraySize(_stateBuffer)); i++) {
24 _stateBuffer[i].Time = now - arraySize(_stateBuffer) + i;
25 _stateBuffer[i].Pos = Vector2f(details.Pos.X, details.Pos.Y);
26 }
27
28 async_return async_await PlayerOnServer::OnActivatedAsync(details);
29 }
30
31 void RemotePlayerOnServer::OnUpdate(float timeMult)
32 {
33 Clock& c = nCine::clock();
34 std::int64_t now = c.now() * 1000 / c.frequency();
35 std::int64_t renderTime = now - ServerDelay;
36
37 std::int32_t nextIdx = _stateBufferPos - 1;
38 if (nextIdx < 0) {
39 nextIdx += std::int32_t(arraySize(_stateBuffer));
40 }
41
42 if (renderTime <= _stateBuffer[nextIdx].Time) {
43 std::int32_t prevIdx;
44 while (true) {
45 prevIdx = nextIdx - 1;
46 if (prevIdx < 0) {
47 prevIdx += std::int32_t(arraySize(_stateBuffer));
48 }
49
50 if (prevIdx == _stateBufferPos || _stateBuffer[prevIdx].Time <= renderTime) {
51 break;
52 }
53
54 nextIdx = prevIdx;
55 }
56
57 std::int64_t timeRange = (_stateBuffer[nextIdx].Time - _stateBuffer[prevIdx].Time);
58 if (timeRange > 0) {
59 float lerp = (float)(renderTime - _stateBuffer[prevIdx].Time) / timeRange;
60 _displayPos = _stateBuffer[prevIdx].Pos + (_stateBuffer[nextIdx].Pos - _stateBuffer[prevIdx].Pos) * lerp;
61 } else {
62 _displayPos = _stateBuffer[nextIdx].Pos;
63 }
64 }
65
66 PlayerOnServer::OnUpdate(timeMult);
67
68 _renderer.setPosition(_displayPos);
69 }
70
71 bool RemotePlayerOnServer::IsContinuousJumpAllowed() const
72 {
73 return (Flags & PlayerFlags::EnableContinuousJump) == PlayerFlags::EnableContinuousJump;
74 }
75
76 bool RemotePlayerOnServer::IsLedgeClimbAllowed() const
77 {
78 return (_peerDesc->EnableLedgeClimb && PlayerOnServer::IsLedgeClimbAllowed());
79 }
80
81 bool RemotePlayerOnServer::OnHandleCollision(std::shared_ptr<ActorBase> other)
82 {
83 // TODO: Remove this override
84 return PlayerOnServer::OnHandleCollision(other);
85 }
86
87 bool RemotePlayerOnServer::OnLevelChanging(Actors::ActorBase* initiator, ExitType exitType)
88 {
89 LevelExitingState lastState = _levelExiting;
90 bool success = PlayerOnServer::OnLevelChanging(initiator, exitType);
91
92 if (lastState == LevelExitingState::None && _health > 0) {
93 // Level changing just started, send the request to the player as WarpIn packet
94 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerLevelChanging(this, exitType);
95 }
96
97 return success;
98 }
99
100 PlayerCarryOver RemotePlayerOnServer::PrepareLevelCarryOver()
101 {
102 // Skip all remote players
103 return PlayerCarryOver{};
104 }
105
106 void RemotePlayerOnServer::SyncWithServer(Vector2f pos, Vector2f speed, PlayerFlags flags)
107 {
108 if (_health <= 0) {
109 // Don't sync dead players to avoid cheating
110 return;
111 }
112
113 Clock& c = nCine::clock();
114 std::int64_t now = c.now() * 1000 / c.frequency();
115
116 Flags = flags;
117
118 bool wasVisible = _renderer.isDrawEnabled();
119 // Visibility is not synced from the client, because it should be already almost in sync on the server
120 //_renderer.setDrawEnabled((flags & PlayerFlags::IsVisible) == PlayerFlags::IsVisible);
121 SetFacingLeft((flags & PlayerFlags::IsFacingLeft) == PlayerFlags::IsFacingLeft);
122 _isActivelyPushing = (flags & PlayerFlags::IsActivelyPushing) == PlayerFlags::IsActivelyPushing;
123
124 if (wasVisible) {
125 // Actor is still visible, enable interpolation
126 _stateBuffer[_stateBufferPos].Time = now;
127 _stateBuffer[_stateBufferPos].Pos = pos;
128 } else {
129 // Actor was hidden before, reset state buffer to disable interpolation
130 std::int32_t stateBufferPrevPos = _stateBufferPos - 1;
131 if (stateBufferPrevPos < 0) {
132 stateBufferPrevPos += std::int32_t(arraySize(_stateBuffer));
133 }
134
135 std::int64_t renderTime = now - ServerDelay;
136
137 _stateBuffer[stateBufferPrevPos].Time = renderTime;
138 _stateBuffer[stateBufferPrevPos].Pos = pos;
139 _stateBuffer[_stateBufferPos].Time = renderTime;
140 _stateBuffer[_stateBufferPos].Pos = pos;
141 }
142
143 _stateBufferPos++;
144 if (_stateBufferPos >= std::int32_t(arraySize(_stateBuffer))) {
145 _stateBufferPos = 0;
146 }
147
148 // TODO: Set actual pos and speed to the newest value
149 _pos = pos;
150 _speed = speed;
151 }
152
153 void RemotePlayerOnServer::ForceResyncWithServer(Vector2f pos, Vector2f speed)
154 {
155 Clock& c = nCine::clock();
156 std::int64_t now = c.now() * 1000 / c.frequency();
157
158 _pos = pos;
159 _speed = speed;
160
161 for (std::size_t i = 0; i < arraySize(_stateBuffer); i++) {
162 _stateBuffer[i].Time = now;
163 _stateBuffer[i].Pos = pos;
164 }
165 }
166
167 void RemotePlayerOnServer::OnPushSolidObject(float timeMult, float pushSpeedX)
168 {
169 if (!static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerPush(this, pushSpeedX)) {
170 return;
171 }
172
173 PlayerOnServer::OnPushSolidObject(timeMult, pushSpeedX);
174 }
175
176 void RemotePlayerOnServer::OnHitSpring(Vector2f pos, Vector2f force, bool keepSpeedX, bool keepSpeedY, bool& removeSpecialMove)
177 {
178 if (!static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSpring(this, pos, force, keepSpeedX, keepSpeedY)) {
179 return;
180 }
181
182 PlayerOnServer::OnHitSpring(pos, force, keepSpeedX, keepSpeedY, removeSpecialMove);
183 }
184
185 void RemotePlayerOnServer::WarpToPosition(Vector2f pos, WarpFlags flags)
186 {
187 PlayerOnServer::WarpToPosition(pos, flags);
188
189 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerBeforeWarp(this, pos, flags);
190 }
191
192 bool RemotePlayerOnServer::SetModifier(Modifier modifier, const std::shared_ptr<ActorBase>& decor)
193 {
194 if (!PlayerOnServer::SetModifier(modifier, decor)) {
195 return false;
196 }
197
198 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetModifier(this, modifier, decor);
199
200 return true;
201 }
202
203 bool RemotePlayerOnServer::Freeze(float timeLeft)
204 {
205 if (!PlayerOnServer::Freeze(timeLeft)) {
206 return false;
207 }
208
209 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerFreeze(this, timeLeft);
210
211 return true;
212 }
213
214 void RemotePlayerOnServer::SetInvulnerability(float timeLeft, InvulnerableType type)
215 {
216 PlayerOnServer::SetInvulnerability(timeLeft, type);
217
218 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetInvulnerability(this, timeLeft, type);
219 }
220
221 void RemotePlayerOnServer::AddScore(std::int32_t amount)
222 {
223 PlayerOnServer::AddScore(amount);
224
225 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetScore(this, _score);
226 }
227
228 bool RemotePlayerOnServer::AddHealth(std::int32_t amount)
229 {
230 if (!PlayerOnServer::AddHealth(amount)) {
231 return false;
232 }
233
234 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetHealth(this, _health);
235
236 return true;
237 }
238
239 bool RemotePlayerOnServer::AddLives(std::int32_t count)
240 {
241 if (!PlayerOnServer::AddLives(count)) {
242 return false;
243 }
244
245 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetLives(this, _lives);
246
247 return true;
248 }
249
250 bool RemotePlayerOnServer::AddAmmo(WeaponType weaponType, std::int16_t count)
251 {
252 if (!PlayerOnServer::AddAmmo(weaponType, count)) {
253 return false;
254 }
255
256 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerRefreshAmmo(this, weaponType);
257
258 return true;
259 }
260
261 void RemotePlayerOnServer::AddWeaponUpgrade(WeaponType weaponType, std::uint8_t upgrade)
262 {
263 PlayerOnServer::AddWeaponUpgrade(weaponType, upgrade);
264
265 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerRefreshWeaponUpgrades(this, weaponType);
266 }
267
268 bool RemotePlayerOnServer::SetDizzy(float timeLeft)
269 {
270 bool success = PlayerOnServer::SetDizzy(timeLeft);
271
272 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetDizzy(this, timeLeft);
273
274 return success;
275 }
276
277 bool RemotePlayerOnServer::SetShield(ShieldType shieldType, float timeLeft)
278 {
279 if (!PlayerOnServer::SetShield(shieldType, timeLeft)) {
280 return false;
281 }
282
283 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetShield(this, shieldType, timeLeft);
284
285 return true;
286 }
287
288 bool RemotePlayerOnServer::IncreaseShieldTime(float timeLeft)
289 {
290 if (!PlayerOnServer::IncreaseShieldTime(timeLeft)) {
291 return false;
292 }
293
294 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerSetShield(this, _activeShield, _activeShieldTime);
295
296 return true;
297 }
298
299 bool RemotePlayerOnServer::FireCurrentWeapon(WeaponType weaponType)
300 {
301 std::uint16_t prevAmmo = _weaponAmmo[(std::int32_t)weaponType];
302 bool success = PlayerOnServer::FireCurrentWeapon(weaponType);
303
304 if (prevAmmo != _weaponAmmo[(std::int32_t)weaponType]) {
305 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerRefreshAmmo(this, weaponType);
306 }
307
308 return success;
309 }
310
311 void RemotePlayerOnServer::EmitWeaponFlare()
312 {
313 PlayerOnServer::EmitWeaponFlare();
314
315 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerEmitWeaponFlare(this);
316 }
317
318 void RemotePlayerOnServer::SetCurrentWeapon(WeaponType weaponType, SetCurrentWeaponReason reason)
319 {
320 PlayerOnServer::SetCurrentWeapon(weaponType, reason);
321
322 static_cast<Jazz2::Multiplayer::MpLevelHandler*>(_levelHandler)->HandlePlayerWeaponChanged(this, reason);
323 }
324 }
325
326 #endif