1/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
2/* If you are missing that file, acquire a complete release at teeworlds.com. */
3#include "character.h"
4
5#include "laser.h"
6#include "pickup.h"
7#include "projectile.h"
8
9#include <antibot/antibot_data.h>
10
11#include <base/log.h>
12#include <base/time.h>
13
14#include <engine/antibot.h>
15#include <engine/shared/config.h>
16
17#include <generated/protocol.h>
18#include <generated/server_data.h>
19
20#include <game/mapitems.h>
21#include <game/server/gamecontext.h>
22#include <game/server/gamecontroller.h>
23#include <game/server/player.h>
24#include <game/server/score.h>
25#include <game/server/teams.h>
26#include <game/team_state.h>
27
28MACRO_ALLOC_POOL_ID_IMPL(CCharacter, MAX_CLIENTS)
29
30// Character, "physical" player's part
31CCharacter::CCharacter(CGameWorld *pWorld, CNetObj_PlayerInput LastInput) :
32 CEntity(pWorld, CGameWorld::ENTTYPE_CHARACTER, false, vec2(0, 0), CCharacterCore::PhysicalSize())
33{
34 m_Health = 0;
35 m_Armor = 0;
36 m_TriggeredEvents7 = 0;
37 m_StrongWeakId = 0;
38
39 m_Input = LastInput;
40 // never initialize both to zero
41 m_Input.m_TargetX = 0;
42 m_Input.m_TargetY = -1;
43
44 m_LatestPrevPrevInput = m_LatestPrevInput = m_LatestInput = m_PrevInput = m_SavedInput = m_Input;
45
46 m_LastTimeCp = -1;
47 m_LastTimeCpBroadcasted = -1;
48 for(float &CurrentTimeCp : m_aCurrentTimeCp)
49 {
50 CurrentTimeCp = 0.0f;
51 }
52}
53
54void CCharacter::Reset()
55{
56 StopRecording();
57 Destroy();
58}
59
60bool CCharacter::Spawn(CPlayer *pPlayer, vec2 Pos)
61{
62 m_EmoteStop = -1;
63 m_LastAction = -1;
64 m_LastWeapon = WEAPON_HAMMER;
65 m_QueuedWeapon = -1;
66 m_LastRefillJumps = false;
67 m_LastPenalty = false;
68 m_LastBonus = false;
69
70 m_TeleGunTeleport = false;
71 m_IsBlueTeleGunTeleport = false;
72
73 m_pPlayer = pPlayer;
74 m_Pos = Pos;
75
76 mem_zero(block: &m_LatestPrevPrevInput, size: sizeof(m_LatestPrevPrevInput));
77 m_LatestPrevPrevInput.m_TargetY = -1;
78 m_NumInputs = 0;
79 m_SpawnTick = Server()->Tick();
80 m_WeaponChangeTick = Server()->Tick();
81 Antibot()->OnSpawn(ClientId: m_pPlayer->GetCid());
82
83 m_Core.Reset();
84 m_Core.Init(pWorld: &GameServer()->m_World.m_Core, pCollision: Collision());
85 m_Core.m_ActiveWeapon = WEAPON_GUN;
86 m_Core.m_Pos = m_Pos;
87 m_Core.m_Id = m_pPlayer->GetCid();
88 int TuneZone = Collision()->IsTune(Index: Collision()->GetMapIndex(Pos));
89 m_Core.m_Tuning = TuningList()[TuneZone];
90 GameServer()->m_World.m_Core.m_apCharacters[m_pPlayer->GetCid()] = &m_Core;
91
92 m_ReckoningTick = 0;
93 m_SendCore = CCharacterCore();
94 m_ReckoningCore = CCharacterCore();
95
96 GameServer()->m_World.InsertEntity(pEntity: this);
97 m_Alive = true;
98
99 GameServer()->m_pController->OnCharacterSpawn(pChr: this);
100
101 DDRaceInit();
102
103 m_TuneZone = TuneZone;
104 m_TuneZoneOld = -1; // no zone leave msg on spawn
105 m_NeededFaketuning = 0; // reset fake tunings on respawn and send the client
106 SendZoneMsgs(); // we want a entermessage also on spawn
107 GameServer()->SendTuningParams(ClientId: m_pPlayer->GetCid(), Zone: m_TuneZone);
108
109 TrySetRescue(RescueMode: RESCUEMODE_MANUAL);
110 Server()->StartRecord(ClientId: m_pPlayer->GetCid());
111
112 int Team = GameServer()->m_aTeamMapping[m_pPlayer->GetCid()];
113
114 if(Team != -1)
115 {
116 GameServer()->m_pController->Teams().SetForceCharacterTeam(ClientId: m_pPlayer->GetCid(), Team);
117 GameServer()->m_aTeamMapping[m_pPlayer->GetCid()] = -1;
118
119 if(GameServer()->m_apSavedTeams[Team])
120 {
121 GameServer()->m_apSavedTeams[Team]->Load(pGameServer: GameServer(), Team, KeepCurrentWeakStrong: true, IgnorePlayers: true);
122 delete GameServer()->m_apSavedTeams[Team];
123 GameServer()->m_apSavedTeams[Team] = nullptr;
124 }
125
126 if(GameServer()->m_apSavedTees[m_pPlayer->GetCid()])
127 {
128 GameServer()->m_apSavedTees[m_pPlayer->GetCid()]->Load(pChr: m_pPlayer->GetCharacter(), Team);
129 delete GameServer()->m_apSavedTees[m_pPlayer->GetCid()];
130 GameServer()->m_apSavedTees[m_pPlayer->GetCid()] = nullptr;
131 }
132 }
133
134 return true;
135}
136
137void CCharacter::Destroy()
138{
139 GameServer()->m_World.m_Core.m_apCharacters[m_pPlayer->GetCid()] = nullptr;
140 m_Alive = false;
141 SetSolo(false);
142}
143
144void CCharacter::SetWeapon(int W)
145{
146 if(W == m_Core.m_ActiveWeapon)
147 return;
148
149 m_LastWeapon = m_Core.m_ActiveWeapon;
150 m_QueuedWeapon = -1;
151 m_Core.m_ActiveWeapon = W;
152 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_WEAPON_SWITCH, Mask: TeamMask());
153
154 if(m_Core.m_ActiveWeapon < 0 || m_Core.m_ActiveWeapon >= NUM_WEAPONS)
155 m_Core.m_ActiveWeapon = 0;
156}
157
158void CCharacter::SetJetpack(bool Active)
159{
160 m_Core.m_Jetpack = Active;
161}
162
163void CCharacter::SetEndlessJump(bool Active)
164{
165 m_Core.m_EndlessJump = Active;
166}
167
168void CCharacter::SetJumps(int Jumps)
169{
170 m_Core.m_Jumps = Jumps;
171}
172
173void CCharacter::SetSolo(bool Solo)
174{
175 m_Core.m_Solo = Solo;
176 Teams()->m_Core.SetSolo(ClientId: m_pPlayer->GetCid(), Value: Solo);
177}
178
179void CCharacter::SetSuper(bool Super)
180{
181 // Disable invincible mode before activating super mode. Both modes active at the same time wouldn't necessarily break anything but it's not useful.
182 if(Super)
183 SetInvincible(false);
184
185 bool WasSuper = m_Core.m_Super;
186 m_Core.m_Super = Super;
187 if(Super && !WasSuper)
188 {
189 m_TeamBeforeSuper = Team();
190 char aError[512];
191 if(!Teams()->SetCharacterTeam(ClientId: GetPlayer()->GetCid(), Team: TEAM_SUPER, pError: aError, ErrorSize: sizeof(aError)))
192 log_error("character", "failed to set super: %s", aError);
193 m_DDRaceState = ERaceState::CHEATED;
194 }
195 else if(!Super && WasSuper)
196 {
197 Teams()->SetForceCharacterTeam(ClientId: GetPlayer()->GetCid(), Team: m_TeamBeforeSuper);
198 }
199}
200
201void CCharacter::SetInvincible(bool Invincible)
202{
203 // Disable super mode before activating invincible mode. Both modes active at the same time wouldn't necessarily break anything but it's not useful.
204 if(Invincible)
205 SetSuper(false);
206
207 m_Core.m_Invincible = Invincible;
208 if(Invincible)
209 Unfreeze();
210
211 SetEndlessJump(Invincible);
212}
213
214void CCharacter::SetCollisionDisabled(bool CollisionDisabled)
215{
216 m_Core.m_CollisionDisabled = CollisionDisabled;
217}
218
219void CCharacter::SetHookHitDisabled(bool HookHitDisabled)
220{
221 m_Core.m_HookHitDisabled = HookHitDisabled;
222}
223
224void CCharacter::SetLiveFrozen(bool Active)
225{
226 m_Core.m_LiveFrozen = Active;
227}
228
229void CCharacter::SetDeepFrozen(bool Active)
230{
231 m_Core.m_DeepFrozen = Active;
232}
233
234bool CCharacter::IsGrounded()
235{
236 if(Collision()->IsOnGround(Pos: m_Pos, Size: GetProximityRadius()))
237 return true;
238
239 int MoveRestrictionsBelow = Collision()->GetMoveRestrictions(Pos: m_Pos + vec2(0, GetProximityRadius() / 2 + 4), Distance: 0.0f);
240 return (MoveRestrictionsBelow & CANTMOVE_DOWN) != 0;
241}
242
243void CCharacter::HandleJetpack()
244{
245 if(m_Core.m_ActiveWeapon < 0)
246 return;
247
248 vec2 Direction = normalize(v: vec2(m_LatestInput.m_TargetX, m_LatestInput.m_TargetY));
249
250 bool FullAuto = false;
251 if(m_Core.m_ActiveWeapon == WEAPON_GRENADE || m_Core.m_ActiveWeapon == WEAPON_SHOTGUN || m_Core.m_ActiveWeapon == WEAPON_LASER)
252 FullAuto = true;
253 if(m_Core.m_Jetpack && m_Core.m_ActiveWeapon == WEAPON_GUN)
254 FullAuto = true;
255
256 // check if we gonna fire
257 bool WillFire = false;
258 if(CountInput(Prev: m_LatestPrevInput.m_Fire, Cur: m_LatestInput.m_Fire).m_Presses)
259 WillFire = true;
260
261 if(FullAuto && (m_LatestInput.m_Fire & 1) && m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_Ammo)
262 WillFire = true;
263
264 if(!WillFire)
265 return;
266
267 // check for ammo
268 if(!m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_Ammo || m_FreezeTime)
269 {
270 return;
271 }
272
273 switch(m_Core.m_ActiveWeapon)
274 {
275 case WEAPON_GUN:
276 {
277 if(m_Core.m_Jetpack)
278 {
279 float Strength = GetTuning(Zone: m_TuneZone)->m_JetpackStrength;
280 TakeDamage(Force: Direction * -1.0f * (Strength / 100.0f / 6.11f), Dmg: 0, From: m_pPlayer->GetCid(), Weapon: m_Core.m_ActiveWeapon);
281 }
282 }
283 }
284}
285
286void CCharacter::HandleNinja()
287{
288 if(m_Core.m_ActiveWeapon != WEAPON_NINJA)
289 return;
290
291 if((Server()->Tick() - m_Core.m_Ninja.m_ActivationTick) > (g_pData->m_Weapons.m_Ninja.m_Duration * Server()->TickSpeed() / 1000))
292 {
293 // time's up, return
294 RemoveNinja();
295 return;
296 }
297
298 int NinjaTime = m_Core.m_Ninja.m_ActivationTick + (g_pData->m_Weapons.m_Ninja.m_Duration * Server()->TickSpeed() / 1000) - Server()->Tick();
299
300 if(NinjaTime % Server()->TickSpeed() == 0 && NinjaTime / Server()->TickSpeed() <= 5)
301 {
302 GameServer()->CreateDamageInd(Pos: m_Pos, AngleMod: 0, Amount: NinjaTime / Server()->TickSpeed(), Mask: TeamMask() & GameServer()->ClientsMaskExcludeClientVersionAndHigher(Version: VERSION_DDNET_NEW_HUD));
303 }
304
305 GameServer()->m_pController->SetArmorProgress(pCharacter: this, Progress: NinjaTime);
306
307 // force ninja Weapon
308 SetWeapon(WEAPON_NINJA);
309
310 m_Core.m_Ninja.m_CurrentMoveTime--;
311
312 if(m_Core.m_Ninja.m_CurrentMoveTime == 0)
313 {
314 // reset velocity
315 m_Core.m_Vel = m_Core.m_Ninja.m_ActivationDir * m_Core.m_Ninja.m_OldVelAmount;
316 }
317
318 if(m_Core.m_Ninja.m_CurrentMoveTime > 0)
319 {
320 // Set velocity
321 m_Core.m_Vel = m_Core.m_Ninja.m_ActivationDir * g_pData->m_Weapons.m_Ninja.m_Velocity;
322 vec2 OldPos = m_Pos;
323 vec2 GroundElasticity = vec2(
324 GetTuning(Zone: m_TuneZone)->m_GroundElasticityX,
325 GetTuning(Zone: m_TuneZone)->m_GroundElasticityY);
326
327 Collision()->MoveBox(pInoutPos: &m_Core.m_Pos, pInoutVel: &m_Core.m_Vel, Size: vec2(GetProximityRadius(), GetProximityRadius()), Elasticity: GroundElasticity);
328
329 // reset velocity so the client doesn't predict stuff
330 ResetVelocity();
331
332 // check if we Hit anything along the way
333 {
334 CEntity *apEnts[MAX_CLIENTS];
335 float Radius = GetProximityRadius() * 2.0f;
336 int Num = GameServer()->m_World.FindEntities(Pos: OldPos, Radius, ppEnts: apEnts, Max: MAX_CLIENTS, Type: CGameWorld::ENTTYPE_CHARACTER);
337
338 // check that we're not in solo part
339 if(Teams()->m_Core.GetSolo(ClientId: m_pPlayer->GetCid()))
340 return;
341
342 for(int i = 0; i < Num; ++i)
343 {
344 auto *pChr = static_cast<CCharacter *>(apEnts[i]);
345 if(pChr == this)
346 continue;
347
348 // Don't hit players in other teams
349 if(Team() != pChr->Team())
350 continue;
351
352 const int ClientId = pChr->m_pPlayer->GetCid();
353
354 // Don't hit players in solo parts
355 if(Teams()->m_Core.GetSolo(ClientId))
356 continue;
357
358 // make sure we haven't Hit this object before
359 bool AlreadyHit = false;
360 for(int j = 0; j < m_NumObjectsHit; j++)
361 {
362 if(m_aHitObjects[j] == ClientId)
363 AlreadyHit = true;
364 }
365 if(AlreadyHit)
366 continue;
367
368 // check so we are sufficiently close
369 if(distance(a: pChr->m_Pos, b: m_Pos) > Radius)
370 continue;
371
372 // Hit a player, give them damage and stuffs...
373 GameServer()->CreateSound(Pos: pChr->m_Pos, Sound: SOUND_NINJA_HIT, Mask: TeamMask());
374 // set their velocity to fast upward (for now)
375 dbg_assert(m_NumObjectsHit < MAX_CLIENTS, "m_aHitObjects overflow");
376 m_aHitObjects[m_NumObjectsHit++] = ClientId;
377
378 pChr->TakeDamage(Force: vec2(0, -10.0f), Dmg: g_pData->m_Weapons.m_Ninja.m_pBase->m_Damage, From: m_pPlayer->GetCid(), Weapon: WEAPON_NINJA);
379 }
380 }
381
382 return;
383 }
384}
385
386void CCharacter::DoWeaponSwitch()
387{
388 // make sure we can switch
389 if(m_ReloadTimer != 0 || m_QueuedWeapon == -1)
390 return;
391 if(m_Core.m_aWeapons[WEAPON_NINJA].m_Got || !m_Core.m_aWeapons[m_QueuedWeapon].m_Got)
392 return;
393
394 // switch Weapon
395 SetWeapon(m_QueuedWeapon);
396}
397
398void CCharacter::HandleWeaponSwitch()
399{
400 int WantedWeapon = m_Core.m_ActiveWeapon;
401 if(m_QueuedWeapon != -1)
402 WantedWeapon = m_QueuedWeapon;
403
404 bool Anything = false;
405 for(int i = 0; i < NUM_WEAPONS - 1; ++i)
406 if(m_Core.m_aWeapons[i].m_Got)
407 Anything = true;
408 if(!Anything)
409 return;
410 // select Weapon
411 int Next = CountInput(Prev: m_LatestPrevInput.m_NextWeapon, Cur: m_LatestInput.m_NextWeapon).m_Presses;
412 int Prev = CountInput(Prev: m_LatestPrevInput.m_PrevWeapon, Cur: m_LatestInput.m_PrevWeapon).m_Presses;
413
414 if(Next < 128) // make sure we only try sane stuff
415 {
416 while(Next) // Next Weapon selection
417 {
418 WantedWeapon = (WantedWeapon + 1) % NUM_WEAPONS;
419 if(m_Core.m_aWeapons[WantedWeapon].m_Got)
420 Next--;
421 }
422 }
423
424 if(Prev < 128) // make sure we only try sane stuff
425 {
426 while(Prev) // Prev Weapon selection
427 {
428 WantedWeapon = (WantedWeapon - 1) < 0 ? NUM_WEAPONS - 1 : WantedWeapon - 1;
429 if(m_Core.m_aWeapons[WantedWeapon].m_Got)
430 Prev--;
431 }
432 }
433
434 // Direct Weapon selection
435 if(m_LatestInput.m_WantedWeapon)
436 WantedWeapon = m_Input.m_WantedWeapon - 1;
437
438 // check for insane values
439 if(WantedWeapon >= 0 && WantedWeapon < NUM_WEAPONS && WantedWeapon != m_Core.m_ActiveWeapon && m_Core.m_aWeapons[WantedWeapon].m_Got)
440 m_QueuedWeapon = WantedWeapon;
441
442 DoWeaponSwitch();
443}
444
445void CCharacter::FireWeapon()
446{
447 if(m_ReloadTimer != 0)
448 {
449 if(m_LatestInput.m_Fire & 1)
450 {
451 Antibot()->OnHammerFireReloading(ClientId: m_pPlayer->GetCid());
452 }
453 return;
454 }
455
456 DoWeaponSwitch();
457 vec2 MouseTarget = vec2(m_LatestInput.m_TargetX, m_LatestInput.m_TargetY);
458 vec2 Direction = normalize(v: MouseTarget);
459
460 bool FullAuto = false;
461 if(m_Core.m_ActiveWeapon == WEAPON_GRENADE || m_Core.m_ActiveWeapon == WEAPON_SHOTGUN || m_Core.m_ActiveWeapon == WEAPON_LASER)
462 FullAuto = true;
463 if(m_Core.m_Jetpack && m_Core.m_ActiveWeapon == WEAPON_GUN)
464 FullAuto = true;
465 // allow firing directly after coming out of freeze or being unfrozen
466 // by something
467 if(m_FrozenLastTick)
468 FullAuto = true;
469
470 // don't fire hammer when player is deep and sv_deepfly is disabled
471 if(!g_Config.m_SvDeepfly && m_Core.m_ActiveWeapon == WEAPON_HAMMER && m_Core.m_DeepFrozen)
472 return;
473
474 // check if we gonna fire
475 bool WillFire = false;
476 if(CountInput(Prev: m_LatestPrevInput.m_Fire, Cur: m_LatestInput.m_Fire).m_Presses)
477 WillFire = true;
478
479 if(FullAuto && (m_LatestInput.m_Fire & 1) && m_Core.m_ActiveWeapon >= 0 && m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_Ammo)
480 WillFire = true;
481
482 if(!WillFire)
483 return;
484
485 if(m_FreezeTime)
486 {
487 // Timer stuff to avoid shrieking orchestra caused by unfreeze-plasma
488 if(m_PainSoundTimer <= 0 && !(m_LatestPrevInput.m_Fire & 1))
489 {
490 m_PainSoundTimer = 1 * Server()->TickSpeed();
491 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_PLAYER_PAIN_LONG, Mask: TeamMask()); // NOLINT(clang-analyzer-unix.Malloc)
492 }
493 return;
494 }
495
496 // check for ammo
497 if(m_Core.m_ActiveWeapon < 0 || !m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_Ammo)
498 return;
499
500 vec2 ProjStartPos = m_Pos + Direction * GetProximityRadius() * 0.75f;
501
502 switch(m_Core.m_ActiveWeapon)
503 {
504 case WEAPON_HAMMER:
505 {
506 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_HAMMER_FIRE, Mask: TeamMask()); // NOLINT(clang-analyzer-unix.Malloc)
507
508 Antibot()->OnHammerFire(ClientId: m_pPlayer->GetCid());
509
510 if(m_Core.m_HammerHitDisabled)
511 break;
512
513 CEntity *apEnts[MAX_CLIENTS];
514 int Hits = 0;
515 int Num = GameServer()->m_World.FindEntities(Pos: ProjStartPos, Radius: GetProximityRadius() * 0.5f, ppEnts: apEnts,
516 Max: MAX_CLIENTS, Type: CGameWorld::ENTTYPE_CHARACTER);
517
518 for(int i = 0; i < Num; ++i)
519 {
520 auto *pTarget = static_cast<CCharacter *>(apEnts[i]);
521
522 if((pTarget == this || (pTarget->IsAlive() && !CanCollide(ClientId: pTarget->GetPlayer()->GetCid()))))
523 continue;
524
525 // set their velocity to fast upward (for now)
526 if(length(a: pTarget->m_Pos - ProjStartPos) > 0.0f)
527 GameServer()->CreateHammerHit(Pos: pTarget->m_Pos - normalize(v: pTarget->m_Pos - ProjStartPos) * GetProximityRadius() * 0.5f, Mask: TeamMask());
528 else
529 GameServer()->CreateHammerHit(Pos: ProjStartPos, Mask: TeamMask());
530
531 vec2 Dir;
532 if(length(a: pTarget->m_Pos - m_Pos) > 0.0f)
533 Dir = normalize(v: pTarget->m_Pos - m_Pos);
534 else
535 Dir = vec2(0.f, -1.f);
536
537 float Strength = GetTuning(Zone: m_TuneZone)->m_HammerStrength;
538
539 vec2 Temp = pTarget->m_Core.m_Vel + normalize(v: Dir + vec2(0.f, -1.1f)) * 10.0f;
540 Temp = ClampVel(MoveRestriction: pTarget->m_MoveRestrictions, Vel: Temp);
541 Temp -= pTarget->m_Core.m_Vel;
542 pTarget->TakeDamage(Force: (vec2(0.f, -1.0f) + Temp) * Strength, Dmg: g_pData->m_Weapons.m_Hammer.m_pBase->m_Damage,
543 From: m_pPlayer->GetCid(), Weapon: m_Core.m_ActiveWeapon);
544 pTarget->Unfreeze();
545
546 Antibot()->OnHammerHit(ClientId: m_pPlayer->GetCid(), TargetId: pTarget->GetPlayer()->GetCid());
547
548 Hits++;
549 }
550
551 // if we Hit anything, we have to wait for the reload
552 if(Hits)
553 {
554 float FireDelay = GetTuning(Zone: m_TuneZone)->m_HammerHitFireDelay;
555 m_ReloadTimer = FireDelay * Server()->TickSpeed() / 1000;
556 }
557 }
558 break;
559
560 case WEAPON_GUN:
561 {
562 if(!m_Core.m_Jetpack || !m_pPlayer->m_NinjaJetpack || m_Core.m_HasTelegunGun)
563 {
564 int Lifetime = (int)(Server()->TickSpeed() * GetTuning(Zone: m_TuneZone)->m_GunLifetime);
565
566 new CProjectile(
567 GameWorld(),
568 WEAPON_GUN, //Type
569 m_pPlayer->GetCid(), //Owner
570 ProjStartPos, //Pos
571 Direction, //Dir
572 Lifetime, //Span
573 false, //Freeze
574 false, //Explosive
575 -1, //SoundImpact
576 MouseTarget //InitDir
577 );
578
579 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_GUN_FIRE, Mask: TeamMask()); // NOLINT(clang-analyzer-unix.Malloc)
580 }
581 }
582 break;
583
584 case WEAPON_SHOTGUN:
585 {
586 float LaserReach = GetTuning(Zone: m_TuneZone)->m_LaserReach;
587
588 new CLaser(&GameServer()->m_World, m_Pos, Direction, LaserReach, m_pPlayer->GetCid(), WEAPON_SHOTGUN);
589 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_SHOTGUN_FIRE, Mask: TeamMask()); // NOLINT(clang-analyzer-unix.Malloc)
590 }
591 break;
592
593 case WEAPON_GRENADE:
594 {
595 int Lifetime = (int)(Server()->TickSpeed() * GetTuning(Zone: m_TuneZone)->m_GrenadeLifetime);
596
597 new CProjectile(
598 GameWorld(),
599 WEAPON_GRENADE, //Type
600 m_pPlayer->GetCid(), //Owner
601 ProjStartPos, //Pos
602 Direction, //Dir
603 Lifetime, //Span
604 false, //Freeze
605 true, //Explosive
606 SOUND_GRENADE_EXPLODE, //SoundImpact
607 MouseTarget // MouseTarget
608 );
609
610 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_GRENADE_FIRE, Mask: TeamMask()); // NOLINT(clang-analyzer-unix.Malloc)
611 }
612 break;
613
614 case WEAPON_LASER:
615 {
616 float LaserReach = GetTuning(Zone: m_TuneZone)->m_LaserReach;
617
618 new CLaser(GameWorld(), m_Pos, Direction, LaserReach, m_pPlayer->GetCid(), WEAPON_LASER);
619 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_LASER_FIRE, Mask: TeamMask()); // NOLINT(clang-analyzer-unix.Malloc)
620 }
621 break;
622
623 case WEAPON_NINJA:
624 {
625 // reset Hit objects
626 m_NumObjectsHit = 0;
627
628 m_Core.m_Ninja.m_ActivationDir = Direction;
629 m_Core.m_Ninja.m_CurrentMoveTime = g_pData->m_Weapons.m_Ninja.m_Movetime * Server()->TickSpeed() / 1000;
630
631 // clamp to prevent massive MoveBox calculation lag with SG bug
632 m_Core.m_Ninja.m_OldVelAmount = std::clamp(val: length(a: m_Core.m_Vel), lo: 0.0f, hi: 6000.0f);
633
634 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_NINJA_FIRE, Mask: TeamMask()); // NOLINT(clang-analyzer-unix.Malloc)
635 }
636 break;
637 }
638
639 m_AttackTick = Server()->Tick();
640
641 // -1 is no weapon, handled here so pain sound still plays when firing in freeze
642 if(!m_ReloadTimer && m_Core.m_ActiveWeapon != -1)
643 {
644 m_ReloadTimer = GetTuning(Zone: m_TuneZone)->GetWeaponFireDelay(Weapon: m_Core.m_ActiveWeapon) * Server()->TickSpeed();
645 }
646}
647
648void CCharacter::HandleWeapons()
649{
650 //ninja
651 HandleNinja();
652 HandleJetpack();
653
654 if(m_PainSoundTimer > 0)
655 m_PainSoundTimer--;
656
657 // check reload timer
658 if(m_ReloadTimer)
659 {
660 m_ReloadTimer--;
661 return;
662 }
663
664 // fire Weapon, if wanted
665 FireWeapon();
666}
667
668void CCharacter::GiveNinja()
669{
670 m_Core.m_Ninja.m_ActivationTick = Server()->Tick();
671 m_Core.m_aWeapons[WEAPON_NINJA].m_Got = true;
672 m_Core.m_aWeapons[WEAPON_NINJA].m_Ammo = -1;
673 if(m_Core.m_ActiveWeapon != WEAPON_NINJA)
674 m_LastWeapon = m_Core.m_ActiveWeapon;
675 m_Core.m_ActiveWeapon = WEAPON_NINJA;
676
677 // not used on ddrace
678 // GameServer()->CreateSound(m_Pos, SOUND_PICKUP_NINJA, TeamMask());
679}
680
681void CCharacter::RemoveNinja()
682{
683 m_Core.m_Ninja.m_ActivationDir = vec2(0, 0);
684 m_Core.m_Ninja.m_ActivationTick = 0;
685 m_Core.m_Ninja.m_CurrentMoveTime = 0;
686 m_Core.m_Ninja.m_OldVelAmount = 0;
687 m_Core.m_aWeapons[WEAPON_NINJA].m_Got = false;
688 m_Core.m_aWeapons[WEAPON_NINJA].m_Ammo = 0;
689 m_Core.m_ActiveWeapon = m_LastWeapon;
690
691 SetWeapon(m_Core.m_ActiveWeapon);
692}
693
694void CCharacter::SetEmote(int Emote, int Tick)
695{
696 m_EmoteType = Emote;
697 m_EmoteStop = Tick;
698}
699
700int CCharacter::DetermineEyeEmote()
701{
702 const bool IsFrozen = m_Core.m_DeepFrozen || m_FreezeTime > 0 || m_Core.m_LiveFrozen;
703 const bool HasNinjajetpack = m_pPlayer->m_NinjaJetpack && m_Core.m_Jetpack && m_Core.m_ActiveWeapon == WEAPON_GUN;
704
705 if(GetPlayer()->IsAfk() || GetPlayer()->IsPaused())
706 return (m_Core.m_DeepFrozen || m_FreezeTime > 0) ? EMOTE_NORMAL : EMOTE_BLINK;
707 if(m_EmoteType != EMOTE_NORMAL) // user manually set an eye emote using /emote
708 return m_EmoteType;
709 if(IsFrozen)
710 return (m_Core.m_DeepFrozen || m_Core.m_LiveFrozen) ? EMOTE_PAIN : EMOTE_BLINK;
711 if(HasNinjajetpack && !m_Core.m_DeepFrozen && m_FreezeTime == 0 && !m_Core.m_HasTelegunGun)
712 return EMOTE_HAPPY;
713 if(5 * Server()->TickSpeed() - ((Server()->Tick() - m_LastAction) % (5 * Server()->TickSpeed())) < 5)
714 return EMOTE_BLINK;
715 return EMOTE_NORMAL;
716}
717
718void CCharacter::OnPredictedInput(const CNetObj_PlayerInput *pNewInput)
719{
720 // check for changes
721 if(mem_comp(a: &m_SavedInput, b: pNewInput, size: sizeof(CNetObj_PlayerInput)) != 0)
722 m_LastAction = Server()->Tick();
723
724 // copy new input
725 mem_copy(dest: &m_Input, source: pNewInput, size: sizeof(m_Input));
726
727 // it is not allowed to aim in the center
728 if(m_Input.m_TargetX == 0 && m_Input.m_TargetY == 0)
729 m_Input.m_TargetY = -1;
730
731 mem_copy(dest: &m_SavedInput, source: &m_Input, size: sizeof(m_SavedInput));
732}
733
734void CCharacter::OnDirectInput(const CNetObj_PlayerInput *pNewInput)
735{
736 mem_copy(dest: &m_LatestPrevInput, source: &m_LatestInput, size: sizeof(m_LatestInput));
737 mem_copy(dest: &m_LatestInput, source: pNewInput, size: sizeof(m_LatestInput));
738 m_NumInputs++;
739
740 // it is not allowed to aim in the center
741 if(m_LatestInput.m_TargetX == 0 && m_LatestInput.m_TargetY == 0)
742 m_LatestInput.m_TargetY = -1;
743
744 Antibot()->OnDirectInput(ClientId: m_pPlayer->GetCid());
745
746 if(m_NumInputs > 1 && m_pPlayer->GetTeam() != TEAM_SPECTATORS)
747 {
748 HandleWeaponSwitch();
749 FireWeapon();
750 }
751
752 mem_copy(dest: &m_LatestPrevPrevInput, source: &m_LatestPrevInput, size: sizeof(m_LatestInput));
753 mem_copy(dest: &m_LatestPrevInput, source: &m_LatestInput, size: sizeof(m_LatestInput));
754}
755
756void CCharacter::ReleaseHook()
757{
758 m_Core.SetHookedPlayer(-1);
759 m_Core.m_HookState = HOOK_RETRACTED;
760 m_Core.m_TriggeredEvents |= COREEVENT_HOOK_RETRACT;
761}
762
763void CCharacter::ResetHook()
764{
765 ReleaseHook();
766 m_Core.m_HookPos = m_Core.m_Pos;
767}
768
769void CCharacter::ResetInput()
770{
771 m_Input.m_Direction = 0;
772 // simulate releasing the fire button
773 if((m_Input.m_Fire & 1) != 0)
774 m_Input.m_Fire++;
775 m_Input.m_Fire &= INPUT_STATE_MASK;
776 m_Input.m_Jump = 0;
777 m_LatestPrevInput = m_LatestInput = m_Input;
778}
779
780void CCharacter::PreTick()
781{
782 if(m_StartTime > Server()->Tick())
783 {
784 // Prevent the player from getting a negative time
785 // The main reason why this can happen is because of time penalty tiles
786 // However, other reasons are hereby also excluded
787 GameServer()->SendChatTarget(To: m_pPlayer->GetCid(), pText: "You died of old age");
788 Die(Killer: m_pPlayer->GetCid(), Weapon: WEAPON_WORLD);
789 }
790
791 if(m_Paused)
792 return;
793
794 // set emote
795 if(m_EmoteStop < Server()->Tick())
796 {
797 SetEmote(Emote: m_pPlayer->GetDefaultEmote(), Tick: -1);
798 }
799
800 DDRaceTick();
801
802 Antibot()->OnCharacterTick(ClientId: m_pPlayer->GetCid());
803
804 m_Core.m_Input = m_Input;
805 m_Core.Tick(UseInput: true, DoDeferredTick: !g_Config.m_SvNoWeakHook);
806}
807
808void CCharacter::Tick()
809{
810 if(g_Config.m_SvNoWeakHook)
811 {
812 if(m_Paused)
813 return;
814
815 m_Core.TickDeferred();
816 }
817 else
818 {
819 PreTick();
820 }
821
822 if(!m_PrevInput.m_Hook && m_Input.m_Hook && !(m_Core.m_TriggeredEvents & COREEVENT_HOOK_ATTACH_PLAYER))
823 {
824 Antibot()->OnHookAttach(ClientId: m_pPlayer->GetCid(), Player: false);
825 }
826
827 // handle Weapons
828 HandleWeapons();
829
830 DDRacePostCoreTick();
831
832 if(m_Core.m_TriggeredEvents & COREEVENT_HOOK_ATTACH_PLAYER)
833 {
834 const int HookedPlayer = m_Core.HookedPlayer();
835 if(HookedPlayer != -1 && GameServer()->m_apPlayers[HookedPlayer]->GetTeam() != TEAM_SPECTATORS)
836 {
837 Antibot()->OnHookAttach(ClientId: m_pPlayer->GetCid(), Player: true);
838 }
839 }
840
841 // Previnput
842 m_PrevInput = m_Input;
843
844 m_PrevPos = m_Core.m_Pos;
845}
846
847void CCharacter::TickDeferred()
848{
849 // advance the dummy
850 {
851 CWorldCore TempWorld;
852 m_ReckoningCore.Init(pWorld: &TempWorld, pCollision: Collision(), pTeams: &Teams()->m_Core);
853 m_ReckoningCore.m_Id = m_pPlayer->GetCid();
854 m_ReckoningCore.m_Tuning = CTuningParams();
855 m_ReckoningCore.Tick(UseInput: false);
856 m_ReckoningCore.Move();
857 m_ReckoningCore.Quantize();
858 }
859
860 //lastsentcore
861 vec2 StartPos = m_Core.m_Pos;
862 vec2 StartVel = m_Core.m_Vel;
863 bool StuckBefore = Collision()->TestBox(Pos: m_Core.m_Pos, Size: CCharacterCore::PhysicalSizeVec2());
864
865 m_Core.m_Id = m_pPlayer->GetCid();
866 m_Core.Move();
867 bool StuckAfterMove = Collision()->TestBox(Pos: m_Core.m_Pos, Size: CCharacterCore::PhysicalSizeVec2());
868 m_Core.Quantize();
869 bool StuckAfterQuant = Collision()->TestBox(Pos: m_Core.m_Pos, Size: CCharacterCore::PhysicalSizeVec2());
870 m_Pos = m_Core.m_Pos;
871
872 if(!StuckBefore && (StuckAfterMove || StuckAfterQuant))
873 {
874 // Hackish solution to get rid of strict-aliasing warning
875 union
876 {
877 float f;
878 unsigned u;
879 } StartPosX, StartPosY, StartVelX, StartVelY;
880
881 StartPosX.f = StartPos.x;
882 StartPosY.f = StartPos.y;
883 StartVelX.f = StartVel.x;
884 StartVelY.f = StartVel.y;
885
886 char aBuf[256];
887 str_format(buffer: aBuf, buffer_size: sizeof(aBuf), format: "STUCK!!! %d %d %d %f %f %f %f %x %x %x %x",
888 StuckBefore,
889 StuckAfterMove,
890 StuckAfterQuant,
891 StartPos.x, StartPos.y,
892 StartVel.x, StartVel.y,
893 StartPosX.u, StartPosY.u,
894 StartVelX.u, StartVelY.u);
895 GameServer()->Console()->Print(Level: IConsole::OUTPUT_LEVEL_DEBUG, pFrom: "game", pStr: aBuf);
896 }
897
898 {
899 int Events = m_Core.m_TriggeredEvents;
900 int CID = m_pPlayer->GetCid();
901
902 // Some sounds are triggered client-side for the acting player (or for all players on Sixup)
903 // so we need to avoid duplicating them
904 CClientMask TeamMaskExceptSelfAndSixup = Teams()->TeamMask(Team: Team(), ExceptId: CID, Asker: CID, VersionFlags: CGameContext::FLAG_SIX);
905 // Some are triggered client-side but only on Sixup
906 CClientMask TeamMaskExceptSixup = Teams()->TeamMask(Team: Team(), ExceptId: -1, Asker: CID, VersionFlags: CGameContext::FLAG_SIX);
907
908 if(Events & COREEVENT_GROUND_JUMP)
909 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_PLAYER_JUMP, Mask: TeamMaskExceptSelfAndSixup);
910
911 if(Events & COREEVENT_HOOK_ATTACH_PLAYER)
912 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_HOOK_ATTACH_PLAYER, Mask: TeamMaskExceptSixup);
913
914 if(Events & COREEVENT_HOOK_ATTACH_GROUND)
915 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_HOOK_ATTACH_GROUND, Mask: TeamMaskExceptSelfAndSixup);
916
917 if(Events & COREEVENT_HOOK_HIT_NOHOOK)
918 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_HOOK_NOATTACH, Mask: TeamMaskExceptSelfAndSixup);
919
920 if(Events & COREEVENT_GROUND_JUMP)
921 m_TriggeredEvents7 |= protocol7::COREEVENTFLAG_GROUND_JUMP;
922 if(Events & COREEVENT_AIR_JUMP)
923 m_TriggeredEvents7 |= protocol7::COREEVENTFLAG_AIR_JUMP;
924 if(Events & COREEVENT_HOOK_ATTACH_PLAYER)
925 m_TriggeredEvents7 |= protocol7::COREEVENTFLAG_HOOK_ATTACH_PLAYER;
926 if(Events & COREEVENT_HOOK_ATTACH_GROUND)
927 m_TriggeredEvents7 |= protocol7::COREEVENTFLAG_HOOK_ATTACH_GROUND;
928 if(Events & COREEVENT_HOOK_HIT_NOHOOK)
929 m_TriggeredEvents7 |= protocol7::COREEVENTFLAG_HOOK_HIT_NOHOOK;
930 }
931
932 if(m_pPlayer->GetTeam() == TEAM_SPECTATORS)
933 {
934 m_Pos.x = m_Input.m_TargetX;
935 m_Pos.y = m_Input.m_TargetY;
936 }
937
938 // update the m_SendCore if needed
939 {
940 CNetObj_Character Predicted;
941 CNetObj_Character Current;
942 mem_zero(block: &Predicted, size: sizeof(Predicted));
943 mem_zero(block: &Current, size: sizeof(Current));
944 m_ReckoningCore.Write(pObjCore: &Predicted);
945 m_Core.Write(pObjCore: &Current);
946
947 // only allow dead reckoning for a top of 3 seconds
948 if(m_Core.m_Reset || m_ReckoningTick + Server()->TickSpeed() * 3 < Server()->Tick() || mem_comp(a: &Predicted, b: &Current, size: sizeof(CNetObj_Character)) != 0)
949 {
950 m_ReckoningTick = Server()->Tick();
951 m_SendCore = m_Core;
952 m_ReckoningCore = m_Core;
953 m_Core.m_Reset = false;
954 }
955 }
956}
957
958void CCharacter::TickPaused()
959{
960 ++m_AttackTick;
961 ++m_DamageTakenTick;
962 ++m_Core.m_Ninja.m_ActivationTick;
963 ++m_ReckoningTick;
964 if(m_LastAction != -1)
965 ++m_LastAction;
966 if(m_Core.m_ActiveWeapon >= 0 && m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_AmmoRegenStart > -1)
967 ++m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_AmmoRegenStart;
968 if(m_EmoteStop > -1)
969 ++m_EmoteStop;
970}
971
972bool CCharacter::IncreaseHealth(int Amount)
973{
974 if(m_Health >= 10)
975 return false;
976 m_Health = std::clamp(val: m_Health + Amount, lo: 0, hi: 10);
977 return true;
978}
979
980bool CCharacter::IncreaseArmor(int Amount)
981{
982 if(m_Armor >= 10)
983 return false;
984 m_Armor = std::clamp(val: m_Armor + Amount, lo: 0, hi: 10);
985 return true;
986}
987
988void CCharacter::StopRecording()
989{
990 if(Server()->IsRecording(ClientId: m_pPlayer->GetCid()))
991 {
992 CPlayerData *pData = GameServer()->Score()->PlayerData(Id: m_pPlayer->GetCid());
993
994 if(pData->m_RecordStopTick - Server()->Tick() <= Server()->TickSpeed() && pData->m_RecordStopTick != -1)
995 Server()->SaveDemo(ClientId: m_pPlayer->GetCid(), Time: pData->m_RecordFinishTime);
996 else
997 Server()->StopRecord(ClientId: m_pPlayer->GetCid());
998
999 pData->m_RecordStopTick = -1;
1000 }
1001}
1002
1003void CCharacter::Die(int Killer, int Weapon, bool SendKillMsg)
1004{
1005 if(Killer != WEAPON_GAME && m_SetSavePos[RESCUEMODE_AUTO])
1006 GetPlayer()->m_LastDeath = m_RescueTee[RESCUEMODE_AUTO];
1007 StopRecording();
1008 int ModeSpecial = GameServer()->m_pController->OnCharacterDeath(pVictim: this, pKiller: GameServer()->m_apPlayers[Killer], Weapon);
1009
1010 log_info("game", "kill killer='%d:%s' victim='%d:%s' weapon=%d special=%d",
1011 Killer, Server()->ClientName(Killer),
1012 m_pPlayer->GetCid(), Server()->ClientName(m_pPlayer->GetCid()), Weapon, ModeSpecial);
1013
1014 if(SendKillMsg)
1015 {
1016 SendDeathMessageIfNotInLockedTeam(Killer, Weapon, ModeSpecial);
1017 }
1018
1019 // a nice sound, and bursting tee death effect
1020 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_PLAYER_DIE, Mask: TeamMask());
1021 GameServer()->CreateDeath(Pos: m_Pos, ClientId: m_pPlayer->GetCid(), Mask: TeamMask());
1022
1023 // this is to rate limit respawning to 3 secs
1024 m_pPlayer->m_PreviousDieTick = m_pPlayer->m_DieTick;
1025 m_pPlayer->m_DieTick = Server()->Tick();
1026
1027 m_Alive = false;
1028 SetSolo(false);
1029
1030 GameServer()->m_World.RemoveEntity(pEntity: this);
1031 GameServer()->m_World.m_Core.m_apCharacters[m_pPlayer->GetCid()] = nullptr;
1032 Teams()->OnCharacterDeath(ClientId: GetPlayer()->GetCid(), Weapon);
1033 CancelSwapRequests();
1034}
1035
1036bool CCharacter::TakeDamage(vec2 Force, int Dmg, int From, int Weapon)
1037{
1038 if(Dmg)
1039 {
1040 SetEmote(Emote: EMOTE_PAIN, Tick: Server()->Tick() + 500 * Server()->TickSpeed() / 1000);
1041 }
1042
1043 vec2 Temp = m_Core.m_Vel + Force;
1044 m_Core.m_Vel = ClampVel(MoveRestriction: m_MoveRestrictions, Vel: Temp);
1045
1046 return true;
1047}
1048
1049void CCharacter::SendDeathMessageIfNotInLockedTeam(int Killer, int Weapon, int ModeSpecial)
1050{
1051 if((Team() == TEAM_FLOCK || Teams()->TeamFlock(Team: Team()) || Teams()->TeamSize(Team: Team()) == 1 || Teams()->GetTeamState(Team: Team()) == ETeamState::OPEN || !Teams()->TeamLocked(Team: Team())))
1052 {
1053 CNetMsg_Sv_KillMsg Msg;
1054 Msg.m_Killer = Killer;
1055 Msg.m_Victim = m_pPlayer->GetCid();
1056 Msg.m_Weapon = Weapon;
1057 Msg.m_ModeSpecial = ModeSpecial;
1058 Server()->SendPackMsg(pMsg: &Msg, Flags: MSGFLAG_VITAL, ClientId: -1);
1059 }
1060}
1061
1062void CCharacter::CancelSwapRequests()
1063{
1064 for(auto &pPlayer : GameServer()->m_apPlayers)
1065 {
1066 if(pPlayer && pPlayer->m_SwapTargetsClientId == GetPlayer()->GetCid())
1067 pPlayer->m_SwapTargetsClientId = -1;
1068 }
1069 GetPlayer()->m_SwapTargetsClientId = -1;
1070}
1071
1072void CCharacter::SnapCharacter(int SnappingClient, int Id)
1073{
1074 int SnappingClientVersion = GameServer()->GetClientVersion(ClientId: SnappingClient);
1075 CCharacterCore *pCore;
1076 int Weapon = m_Core.m_ActiveWeapon, AmmoCount = 0,
1077 Health = 0, Armor = 0;
1078 int Emote = DetermineEyeEmote();
1079 int Tick;
1080 if(!m_ReckoningTick || GameServer()->m_pController->IsGamePaused())
1081 {
1082 Tick = 0;
1083 pCore = &m_Core;
1084 }
1085 else
1086 {
1087 Tick = m_ReckoningTick;
1088 pCore = &m_SendCore;
1089 }
1090
1091 // use ninja graphic for old clients if player is frozen
1092 if((m_Core.m_DeepFrozen || m_FreezeTime > 0) && SnappingClientVersion < VERSION_DDNET_NEW_HUD)
1093 Weapon = WEAPON_NINJA;
1094
1095 // solo, collision, jetpack and ninjajetpack prediction
1096 if(m_pPlayer->GetCid() == SnappingClient)
1097 {
1098 int Faketuning = 0;
1099 if(m_pPlayer->GetClientVersion() < VERSION_DDNET_NEW_HUD)
1100 {
1101 if(m_Core.m_Jetpack && Weapon != WEAPON_NINJA)
1102 Faketuning |= FAKETUNE_JETPACK;
1103 if(m_Core.m_Solo)
1104 Faketuning |= FAKETUNE_SOLO;
1105 if(m_Core.m_HammerHitDisabled)
1106 Faketuning |= FAKETUNE_NOHAMMER;
1107 if(m_Core.m_CollisionDisabled)
1108 Faketuning |= FAKETUNE_NOCOLL;
1109 if(m_Core.m_HookHitDisabled)
1110 Faketuning |= FAKETUNE_NOHOOK;
1111 if(!m_Core.m_EndlessJump && m_Core.m_Jumps == 0)
1112 Faketuning |= FAKETUNE_NOJUMP;
1113 }
1114 if(Faketuning != m_NeededFaketuning)
1115 {
1116 m_NeededFaketuning = Faketuning;
1117 GameServer()->SendTuningParams(ClientId: m_pPlayer->GetCid(), Zone: m_TuneZone); // update tunings
1118 }
1119 }
1120
1121 // use ninja graphic and set ammo count if player has ninjajetpack
1122 if(m_pPlayer->m_NinjaJetpack && m_Core.m_Jetpack && m_Core.m_ActiveWeapon == WEAPON_GUN && !m_Core.m_DeepFrozen && m_FreezeTime == 0 && !m_Core.m_HasTelegunGun)
1123 {
1124 Weapon = WEAPON_NINJA;
1125 AmmoCount = 10;
1126 }
1127
1128 if(m_pPlayer->GetCid() == SnappingClient || SnappingClient == SERVER_DEMO_CLIENT ||
1129 (!g_Config.m_SvStrictSpectateMode && m_pPlayer->GetCid() == GameServer()->m_apPlayers[SnappingClient]->SpectatorId()))
1130 {
1131 Health = m_Health;
1132 Armor = m_Armor;
1133 AmmoCount = (m_FreezeTime == 0 && m_Core.m_ActiveWeapon >= 0) ? m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_Ammo : 0;
1134 }
1135
1136 if(!Server()->IsSixup(ClientId: SnappingClient))
1137 {
1138 CNetObj_Character Character = {};
1139
1140 pCore->Write(pObjCore: &Character);
1141
1142 Character.m_Tick = Tick;
1143 Character.m_Emote = Emote;
1144
1145 if(Character.m_HookedPlayer != -1)
1146 {
1147 if(!Server()->Translate(Target&: Character.m_HookedPlayer, Client: SnappingClient))
1148 Character.m_HookedPlayer = -1;
1149 }
1150
1151 Character.m_AttackTick = m_AttackTick;
1152 Character.m_Direction = m_Input.m_Direction;
1153 Character.m_Weapon = Weapon;
1154 Character.m_AmmoCount = AmmoCount;
1155 Character.m_Health = Health;
1156 Character.m_Armor = Armor;
1157 Character.m_PlayerFlags = GetPlayer()->m_PlayerFlags;
1158
1159 Server()->SnapNewItem(Id, Data: Character);
1160 }
1161 else
1162 {
1163 protocol7::CNetObj_Character Character = {};
1164
1165 pCore->Write(pObjCore: reinterpret_cast<CNetObj_CharacterCore *>(static_cast<protocol7::CNetObj_CharacterCore *>(&Character)));
1166 if(Character.m_Angle > (int)(pi * 256.0f))
1167 {
1168 Character.m_Angle -= (int)(2.0f * pi * 256.0f);
1169 }
1170
1171 // m_HookTick can be negative when using the hook_duration tune, which 0.7 clients
1172 // will consider invalid. https://github.com/ddnet/ddnet/issues/3915
1173 Character.m_HookTick = std::max(a: 0, b: Character.m_HookTick);
1174
1175 Character.m_Tick = Tick;
1176 Character.m_Emote = Emote;
1177 Character.m_AttackTick = m_AttackTick;
1178 Character.m_Direction = m_Input.m_Direction;
1179 Character.m_Weapon = Weapon;
1180 Character.m_AmmoCount = AmmoCount;
1181
1182 if(m_FreezeTime > 0 || m_Core.m_DeepFrozen)
1183 Character.m_AmmoCount = m_Core.m_FreezeStart + g_Config.m_SvFreezeDelay * Server()->TickSpeed();
1184 else if(Weapon == WEAPON_NINJA)
1185 Character.m_AmmoCount = m_Core.m_Ninja.m_ActivationTick + g_pData->m_Weapons.m_Ninja.m_Duration * Server()->TickSpeed() / 1000;
1186
1187 Character.m_Health = Health;
1188 Character.m_Armor = Armor;
1189 Character.m_TriggeredEvents = m_TriggeredEvents7;
1190
1191 Server()->SnapNewItem(Id, Data: Character);
1192 }
1193}
1194
1195bool CCharacter::CanSnapCharacter(int SnappingClient)
1196{
1197 if(SnappingClient == SERVER_DEMO_CLIENT)
1198 return true;
1199
1200 CCharacter *pSnapChar = GameServer()->GetPlayerChar(ClientId: SnappingClient);
1201 CPlayer *pSnapPlayer = GameServer()->m_apPlayers[SnappingClient];
1202
1203 if(pSnapPlayer->GetTeam() == TEAM_SPECTATORS || pSnapPlayer->IsPaused())
1204 {
1205 if(pSnapPlayer->SpectatorId() != SPEC_FREEVIEW && !CanCollide(ClientId: pSnapPlayer->SpectatorId()) && (pSnapPlayer->m_ShowOthers == SHOW_OTHERS_OFF || (pSnapPlayer->m_ShowOthers == SHOW_OTHERS_ONLY_TEAM && !SameTeam(ClientId: pSnapPlayer->SpectatorId()))))
1206 return false;
1207 else if(pSnapPlayer->SpectatorId() == SPEC_FREEVIEW && !CanCollide(ClientId: SnappingClient) && pSnapPlayer->m_SpecTeam && !SameTeam(ClientId: SnappingClient))
1208 return false;
1209 }
1210 else if(pSnapChar && !pSnapChar->m_Core.m_Super && !CanCollide(ClientId: SnappingClient) && (pSnapPlayer->m_ShowOthers == SHOW_OTHERS_OFF || (pSnapPlayer->m_ShowOthers == SHOW_OTHERS_ONLY_TEAM && !SameTeam(ClientId: SnappingClient))))
1211 return false;
1212
1213 return true;
1214}
1215
1216bool CCharacter::IsSnappingCharacterInView(int SnappingClientId)
1217{
1218 int Id = m_pPlayer->GetCid();
1219
1220 // A player may not be clipped away if their hook or a hook attached to them is in the field of view
1221 bool PlayerAndHookNotInView = NetworkClippedLine(SnappingClient: SnappingClientId, StartPos: m_Pos, EndPos: m_Core.m_HookPos);
1222 bool AttachedHookInView = false;
1223 if(PlayerAndHookNotInView)
1224 {
1225 for(const auto &AttachedPlayerId : m_Core.m_AttachedPlayers)
1226 {
1227 const CCharacter *pOtherPlayer = GameServer()->GetPlayerChar(ClientId: AttachedPlayerId);
1228 if(pOtherPlayer && pOtherPlayer->m_Core.HookedPlayer() == Id)
1229 {
1230 if(!NetworkClippedLine(SnappingClient: SnappingClientId, StartPos: m_Pos, EndPos: pOtherPlayer->m_Pos))
1231 {
1232 AttachedHookInView = true;
1233 break;
1234 }
1235 }
1236 }
1237 }
1238 if(PlayerAndHookNotInView && !AttachedHookInView)
1239 {
1240 return false;
1241 }
1242 return true;
1243}
1244
1245void CCharacter::Snap(int SnappingClient)
1246{
1247 int Id = m_pPlayer->GetCid();
1248
1249 if(!Server()->Translate(Target&: Id, Client: SnappingClient))
1250 return;
1251
1252 if(!CanSnapCharacter(SnappingClient))
1253 {
1254 return;
1255 }
1256
1257 // always snap the snapping client, even if it is not in view
1258 if(!IsSnappingCharacterInView(SnappingClientId: SnappingClient) && Id != SnappingClient)
1259 return;
1260
1261 SnapCharacter(SnappingClient, Id);
1262
1263 CNetObj_DDNetCharacter DDNetCharacter = {};
1264
1265 DDNetCharacter.m_Flags = 0;
1266 if(m_Core.m_Solo)
1267 DDNetCharacter.m_Flags |= CHARACTERFLAG_SOLO;
1268 if(m_Core.m_Super)
1269 DDNetCharacter.m_Flags |= CHARACTERFLAG_SUPER;
1270 if(m_Core.m_Invincible)
1271 DDNetCharacter.m_Flags |= CHARACTERFLAG_INVINCIBLE;
1272 if(m_Core.m_EndlessHook)
1273 DDNetCharacter.m_Flags |= CHARACTERFLAG_ENDLESS_HOOK;
1274 if(m_Core.m_CollisionDisabled || !GetTuning(Zone: m_TuneZone)->m_PlayerCollision)
1275 DDNetCharacter.m_Flags |= CHARACTERFLAG_COLLISION_DISABLED;
1276 if(m_Core.m_HookHitDisabled || !GetTuning(Zone: m_TuneZone)->m_PlayerHooking)
1277 DDNetCharacter.m_Flags |= CHARACTERFLAG_HOOK_HIT_DISABLED;
1278 if(m_Core.m_EndlessJump)
1279 DDNetCharacter.m_Flags |= CHARACTERFLAG_ENDLESS_JUMP;
1280 if(m_Core.m_Jetpack)
1281 DDNetCharacter.m_Flags |= CHARACTERFLAG_JETPACK;
1282 if(m_Core.m_HammerHitDisabled)
1283 DDNetCharacter.m_Flags |= CHARACTERFLAG_HAMMER_HIT_DISABLED;
1284 if(m_Core.m_ShotgunHitDisabled)
1285 DDNetCharacter.m_Flags |= CHARACTERFLAG_SHOTGUN_HIT_DISABLED;
1286 if(m_Core.m_GrenadeHitDisabled)
1287 DDNetCharacter.m_Flags |= CHARACTERFLAG_GRENADE_HIT_DISABLED;
1288 if(m_Core.m_LaserHitDisabled)
1289 DDNetCharacter.m_Flags |= CHARACTERFLAG_LASER_HIT_DISABLED;
1290 if(m_Core.m_HasTelegunGun)
1291 DDNetCharacter.m_Flags |= CHARACTERFLAG_TELEGUN_GUN;
1292 if(m_Core.m_HasTelegunGrenade)
1293 DDNetCharacter.m_Flags |= CHARACTERFLAG_TELEGUN_GRENADE;
1294 if(m_Core.m_HasTelegunLaser)
1295 DDNetCharacter.m_Flags |= CHARACTERFLAG_TELEGUN_LASER;
1296 if(m_Core.m_aWeapons[WEAPON_HAMMER].m_Got)
1297 DDNetCharacter.m_Flags |= CHARACTERFLAG_WEAPON_HAMMER;
1298 if(m_Core.m_aWeapons[WEAPON_GUN].m_Got)
1299 DDNetCharacter.m_Flags |= CHARACTERFLAG_WEAPON_GUN;
1300 if(m_Core.m_aWeapons[WEAPON_SHOTGUN].m_Got)
1301 DDNetCharacter.m_Flags |= CHARACTERFLAG_WEAPON_SHOTGUN;
1302 if(m_Core.m_aWeapons[WEAPON_GRENADE].m_Got)
1303 DDNetCharacter.m_Flags |= CHARACTERFLAG_WEAPON_GRENADE;
1304 if(m_Core.m_aWeapons[WEAPON_LASER].m_Got)
1305 DDNetCharacter.m_Flags |= CHARACTERFLAG_WEAPON_LASER;
1306 if(m_Core.m_ActiveWeapon == WEAPON_NINJA)
1307 DDNetCharacter.m_Flags |= CHARACTERFLAG_WEAPON_NINJA;
1308 if(m_Core.m_LiveFrozen)
1309 DDNetCharacter.m_Flags |= CHARACTERFLAG_MOVEMENTS_DISABLED;
1310
1311 DDNetCharacter.m_FreezeEnd = m_Core.m_DeepFrozen ? -1 : (m_FreezeTime == 0 ? 0 : Server()->Tick() + m_FreezeTime);
1312 DDNetCharacter.m_Jumps = m_Core.m_Jumps;
1313 DDNetCharacter.m_TeleCheckpoint = m_TeleCheckpoint;
1314 DDNetCharacter.m_StrongWeakId = m_StrongWeakId;
1315
1316 // Display Information
1317 DDNetCharacter.m_JumpedTotal = m_Core.m_JumpedTotal;
1318 DDNetCharacter.m_NinjaActivationTick = m_Core.m_Ninja.m_ActivationTick;
1319 DDNetCharacter.m_FreezeStart = m_Core.m_FreezeStart;
1320 if(m_Core.m_IsInFreeze)
1321 {
1322 DDNetCharacter.m_Flags |= CHARACTERFLAG_IN_FREEZE;
1323 }
1324 if(Teams()->IsPractice(Team: Team()))
1325 {
1326 DDNetCharacter.m_Flags |= CHARACTERFLAG_PRACTICE_MODE;
1327 }
1328 if(Teams()->TeamLocked(Team: Team()))
1329 {
1330 DDNetCharacter.m_Flags |= CHARACTERFLAG_LOCK_MODE;
1331 }
1332 if(Teams()->TeamFlock(Team: Team()))
1333 {
1334 DDNetCharacter.m_Flags |= CHARACTERFLAG_TEAM0_MODE;
1335 }
1336 DDNetCharacter.m_TargetX = m_Core.m_Input.m_TargetX;
1337 DDNetCharacter.m_TargetY = m_Core.m_Input.m_TargetY;
1338
1339 // OVERRIDE_NONE is the default value, the object is zeroed, so it would incorrectly become 0
1340 DDNetCharacter.m_TuneZoneOverride = TuneZone::OVERRIDE_NONE;
1341
1342 Server()->SnapNewItem(Id, Data: DDNetCharacter);
1343}
1344
1345void CCharacter::PostGlobalSnap()
1346{
1347 m_TriggeredEvents7 = 0;
1348}
1349
1350// DDRace
1351
1352bool CCharacter::CanCollide(int ClientId)
1353{
1354 return Teams()->m_Core.CanCollide(ClientId1: GetPlayer()->GetCid(), ClientId2: ClientId);
1355}
1356bool CCharacter::SameTeam(int ClientId)
1357{
1358 return Teams()->m_Core.SameTeam(ClientId1: GetPlayer()->GetCid(), ClientId2: ClientId);
1359}
1360
1361int CCharacter::Team()
1362{
1363 return Teams()->m_Core.Team(ClientId: m_pPlayer->GetCid());
1364}
1365
1366void CCharacter::FillAntibot(CAntibotCharacterData *pData)
1367{
1368 pData->m_Pos = m_Pos;
1369 pData->m_Vel = m_Core.m_Vel;
1370 pData->m_Angle = m_Core.m_Angle;
1371 pData->m_HookedPlayer = m_Core.HookedPlayer();
1372 pData->m_SpawnTick = m_SpawnTick;
1373 pData->m_WeaponChangeTick = m_WeaponChangeTick;
1374
1375 // 0
1376 pData->m_aLatestInputs[0].m_Direction = m_LatestInput.m_Direction;
1377 pData->m_aLatestInputs[0].m_TargetX = m_LatestInput.m_TargetX;
1378 pData->m_aLatestInputs[0].m_TargetY = m_LatestInput.m_TargetY;
1379 pData->m_aLatestInputs[0].m_Jump = m_LatestInput.m_Jump;
1380 pData->m_aLatestInputs[0].m_Fire = m_LatestInput.m_Fire;
1381 pData->m_aLatestInputs[0].m_Hook = m_LatestInput.m_Hook;
1382 pData->m_aLatestInputs[0].m_PlayerFlags = m_LatestInput.m_PlayerFlags;
1383 pData->m_aLatestInputs[0].m_WantedWeapon = m_LatestInput.m_WantedWeapon;
1384 pData->m_aLatestInputs[0].m_NextWeapon = m_LatestInput.m_NextWeapon;
1385 pData->m_aLatestInputs[0].m_PrevWeapon = m_LatestInput.m_PrevWeapon;
1386
1387 // 1
1388 pData->m_aLatestInputs[1].m_Direction = m_LatestPrevInput.m_Direction;
1389 pData->m_aLatestInputs[1].m_TargetX = m_LatestPrevInput.m_TargetX;
1390 pData->m_aLatestInputs[1].m_TargetY = m_LatestPrevInput.m_TargetY;
1391 pData->m_aLatestInputs[1].m_Jump = m_LatestPrevInput.m_Jump;
1392 pData->m_aLatestInputs[1].m_Fire = m_LatestPrevInput.m_Fire;
1393 pData->m_aLatestInputs[1].m_Hook = m_LatestPrevInput.m_Hook;
1394 pData->m_aLatestInputs[1].m_PlayerFlags = m_LatestPrevInput.m_PlayerFlags;
1395 pData->m_aLatestInputs[1].m_WantedWeapon = m_LatestPrevInput.m_WantedWeapon;
1396 pData->m_aLatestInputs[1].m_NextWeapon = m_LatestPrevInput.m_NextWeapon;
1397 pData->m_aLatestInputs[1].m_PrevWeapon = m_LatestPrevInput.m_PrevWeapon;
1398
1399 // 2
1400 pData->m_aLatestInputs[2].m_Direction = m_LatestPrevPrevInput.m_Direction;
1401 pData->m_aLatestInputs[2].m_TargetX = m_LatestPrevPrevInput.m_TargetX;
1402 pData->m_aLatestInputs[2].m_TargetY = m_LatestPrevPrevInput.m_TargetY;
1403 pData->m_aLatestInputs[2].m_Jump = m_LatestPrevPrevInput.m_Jump;
1404 pData->m_aLatestInputs[2].m_Fire = m_LatestPrevPrevInput.m_Fire;
1405 pData->m_aLatestInputs[2].m_Hook = m_LatestPrevPrevInput.m_Hook;
1406 pData->m_aLatestInputs[2].m_PlayerFlags = m_LatestPrevPrevInput.m_PlayerFlags;
1407 pData->m_aLatestInputs[2].m_WantedWeapon = m_LatestPrevPrevInput.m_WantedWeapon;
1408 pData->m_aLatestInputs[2].m_NextWeapon = m_LatestPrevPrevInput.m_NextWeapon;
1409 pData->m_aLatestInputs[2].m_PrevWeapon = m_LatestPrevPrevInput.m_PrevWeapon;
1410}
1411
1412void CCharacter::HandleBroadcast()
1413{
1414 CPlayerData *pData = GameServer()->Score()->PlayerData(Id: m_pPlayer->GetCid());
1415
1416 if(m_DDRaceState == ERaceState::STARTED && m_pPlayer->GetClientVersion() == VERSION_VANILLA && !Server()->IsSixup(ClientId: m_pPlayer->GetCid()) &&
1417 m_LastTimeCpBroadcasted != m_LastTimeCp && m_LastTimeCp > -1 &&
1418 m_TimeCpBroadcastEndTick > Server()->Tick() && pData->m_BestTime && pData->m_aBestTimeCp[m_LastTimeCp] != 0)
1419 {
1420 char aBroadcast[128];
1421 float Diff = m_aCurrentTimeCp[m_LastTimeCp] - pData->m_aBestTimeCp[m_LastTimeCp];
1422 str_format(buffer: aBroadcast, buffer_size: sizeof(aBroadcast), format: "Checkpoint | Diff : %+5.2f", Diff);
1423 GameServer()->SendBroadcast(pText: aBroadcast, ClientId: m_pPlayer->GetCid());
1424 m_LastTimeCpBroadcasted = m_LastTimeCp;
1425 m_LastBroadcast = Server()->Tick();
1426 }
1427 else if((m_pPlayer->m_TimerType == CPlayer::TIMERTYPE_BROADCAST || m_pPlayer->m_TimerType == CPlayer::TIMERTYPE_GAMETIMER_AND_BROADCAST) && m_DDRaceState == ERaceState::STARTED && m_LastBroadcast + Server()->TickSpeed() * g_Config.m_SvTimeInBroadcastInterval <= Server()->Tick())
1428 {
1429 char aBuf[32];
1430 int Time = (int64_t)100 * ((float)(Server()->Tick() - m_StartTime) / ((float)Server()->TickSpeed()));
1431 str_time(centisecs: Time, format: ETimeFormat::HOURS, buffer: aBuf, buffer_size: sizeof(aBuf));
1432 GameServer()->SendBroadcast(pText: aBuf, ClientId: m_pPlayer->GetCid(), IsImportant: false);
1433 m_LastTimeCpBroadcasted = m_LastTimeCp;
1434 m_LastBroadcast = Server()->Tick();
1435 }
1436}
1437
1438void CCharacter::HandleSkippableTiles(int Index)
1439{
1440 // handle death-tiles and leaving gamelayer
1441 if((Collision()->GetCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
1442 Collision()->GetCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH ||
1443 Collision()->GetCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
1444 Collision()->GetCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH ||
1445 Collision()->GetFrontCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
1446 Collision()->GetFrontCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH ||
1447 Collision()->GetFrontCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
1448 Collision()->GetFrontCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH) &&
1449 !m_Core.m_Super && !m_Core.m_Invincible && !(Team() && Teams()->TeeFinished(ClientId: m_pPlayer->GetCid())))
1450 {
1451 if(Teams()->IsPractice(Team: Team()))
1452 {
1453 Freeze();
1454 // Rate limit death effects to once per second
1455 if(Server()->Tick() - m_pPlayer->m_DieTick >= Server()->TickSpeed())
1456 {
1457 m_pPlayer->m_DieTick = Server()->Tick();
1458 GameServer()->CreateSound(Pos: m_Pos, Sound: SOUND_PLAYER_DIE, Mask: TeamMask());
1459 GameServer()->CreateDeath(Pos: m_Pos, ClientId: m_pPlayer->GetCid(), Mask: TeamMask());
1460 }
1461 }
1462 else
1463 {
1464 Die(Killer: m_pPlayer->GetCid(), Weapon: WEAPON_WORLD);
1465 return;
1466 }
1467 }
1468
1469 if(GameLayerClipped(CheckPos: m_Pos))
1470 {
1471 Die(Killer: m_pPlayer->GetCid(), Weapon: WEAPON_WORLD);
1472 return;
1473 }
1474
1475 if(Index < 0)
1476 return;
1477
1478 // handle speedup tiles
1479 if(Collision()->IsSpeedup(Index))
1480 {
1481 vec2 Direction, TempVel = m_Core.m_Vel;
1482 int Force, Type, MaxSpeed = 0;
1483 Collision()->GetSpeedup(Index, pDir: &Direction, pForce: &Force, pMaxSpeed: &MaxSpeed, pType: &Type);
1484
1485 if(Type == TILE_SPEED_BOOST_OLD)
1486 {
1487 float TeeAngle, SpeederAngle, DiffAngle, SpeedLeft, TeeSpeed;
1488 if(Force == 255 && MaxSpeed)
1489 {
1490 m_Core.m_Vel = Direction * (MaxSpeed / 5);
1491 }
1492 else
1493 {
1494 if(MaxSpeed > 0 && MaxSpeed < 5)
1495 MaxSpeed = 5;
1496 if(MaxSpeed > 0)
1497 {
1498 if(Direction.x > 0.0000001f)
1499 SpeederAngle = -std::atan(x: Direction.y / Direction.x);
1500 else if(Direction.x < 0.0000001f)
1501 SpeederAngle = std::atan(x: Direction.y / Direction.x) + 2.0f * std::asin(x: 1.0f);
1502 else if(Direction.y > 0.0000001f)
1503 SpeederAngle = std::asin(x: 1.0f);
1504 else
1505 SpeederAngle = std::asin(x: -1.0f);
1506
1507 if(SpeederAngle < 0)
1508 SpeederAngle = 4.0f * std::asin(x: 1.0f) + SpeederAngle;
1509
1510 if(TempVel.x > 0.0000001f)
1511 TeeAngle = -std::atan(x: TempVel.y / TempVel.x);
1512 else if(TempVel.x < 0.0000001f)
1513 TeeAngle = std::atan(x: TempVel.y / TempVel.x) + 2.0f * std::asin(x: 1.0f);
1514 else if(TempVel.y > 0.0000001f)
1515 TeeAngle = std::asin(x: 1.0f);
1516 else
1517 TeeAngle = std::asin(x: -1.0f);
1518
1519 if(TeeAngle < 0)
1520 TeeAngle = 4.0f * std::asin(x: 1.0f) + TeeAngle;
1521
1522 TeeSpeed = std::sqrt(x: std::pow(x: TempVel.x, y: 2) + std::pow(x: TempVel.y, y: 2));
1523
1524 DiffAngle = SpeederAngle - TeeAngle;
1525 SpeedLeft = MaxSpeed / 5.0f - std::cos(x: DiffAngle) * TeeSpeed;
1526 if(absolute(a: (int)SpeedLeft) > Force && SpeedLeft > 0.0000001f)
1527 TempVel += Direction * Force;
1528 else if(absolute(a: (int)SpeedLeft) > Force)
1529 TempVel += Direction * -Force;
1530 else
1531 TempVel += Direction * SpeedLeft;
1532 }
1533 else
1534 TempVel += Direction * Force;
1535
1536 m_Core.m_Vel = ClampVel(MoveRestriction: m_MoveRestrictions, Vel: TempVel);
1537 }
1538 }
1539 else if(Type == TILE_SPEED_BOOST)
1540 {
1541 constexpr float MaxSpeedScale = 5.0f;
1542 if(MaxSpeed == 0)
1543 {
1544 float MaxRampSpeed = GetTuning(Zone: m_TuneZone)->m_VelrampRange / (50 * log(x: std::max(a: (float)GetTuning(Zone: m_TuneZone)->m_VelrampCurvature, b: 1.01f)));
1545 MaxSpeed = std::max(a: MaxRampSpeed, b: GetTuning(Zone: m_TuneZone)->m_VelrampStart / 50) * MaxSpeedScale;
1546 }
1547
1548 // (signed) length of projection
1549 float CurrentDirectionalSpeed = dot(a: Direction, b: m_Core.m_Vel);
1550 float TempMaxSpeed = MaxSpeed / MaxSpeedScale;
1551 if(CurrentDirectionalSpeed + Force > TempMaxSpeed)
1552 TempVel += Direction * (TempMaxSpeed - CurrentDirectionalSpeed);
1553 else
1554 TempVel += Direction * Force;
1555
1556 m_Core.m_Vel = ClampVel(MoveRestriction: m_MoveRestrictions, Vel: TempVel);
1557 }
1558 }
1559}
1560
1561bool CCharacter::IsSwitchActiveCb(unsigned char Number, void *pUser)
1562{
1563 CCharacter *pThis = (CCharacter *)pUser;
1564 auto &aSwitchers = pThis->Switchers();
1565 return !aSwitchers.empty() && pThis->Team() != TEAM_SUPER && aSwitchers[Number].m_aStatus[pThis->Team()];
1566}
1567
1568void CCharacter::SetTimeCheckpoint(int TimeCheckpoint)
1569{
1570 if(TimeCheckpoint > -1 && m_DDRaceState == ERaceState::STARTED && m_aCurrentTimeCp[TimeCheckpoint] == 0.0f && m_Time != 0.0f)
1571 {
1572 m_LastTimeCp = TimeCheckpoint;
1573 m_aCurrentTimeCp[m_LastTimeCp] = m_Time;
1574 m_TimeCpBroadcastEndTick = Server()->Tick() + Server()->TickSpeed() * 2;
1575 if(m_pPlayer->GetClientVersion() >= VERSION_DDRACE || Server()->IsSixup(ClientId: m_pPlayer->GetCid()))
1576 {
1577 CPlayerData *pData = GameServer()->Score()->PlayerData(Id: m_pPlayer->GetCid());
1578 if(pData->m_aBestTimeCp[m_LastTimeCp] != 0.0f)
1579 {
1580 if(Server()->IsSixup(ClientId: m_pPlayer->GetCid()))
1581 {
1582 protocol7::CNetMsg_Sv_Checkpoint Msg;
1583 float Diff = (m_aCurrentTimeCp[m_LastTimeCp] - pData->m_aBestTimeCp[m_LastTimeCp]) * 1000;
1584 Msg.m_Diff = (int)Diff;
1585 Server()->SendPackMsg(pMsg: &Msg, Flags: MSGFLAG_VITAL, ClientId: m_pPlayer->GetCid());
1586 }
1587 else
1588 {
1589 CNetMsg_Sv_DDRaceTime Msg;
1590 Msg.m_Time = (int)(m_Time * 100.0f);
1591 Msg.m_Finish = 0;
1592 float Diff = (m_aCurrentTimeCp[m_LastTimeCp] - pData->m_aBestTimeCp[m_LastTimeCp]) * 100;
1593 Msg.m_Check = (int)Diff;
1594 Server()->SendPackMsg(pMsg: &Msg, Flags: MSGFLAG_VITAL, ClientId: m_pPlayer->GetCid());
1595 }
1596 }
1597 }
1598 }
1599}
1600
1601void CCharacter::HandleTiles(int Index)
1602{
1603 int MapIndex = Index;
1604 m_TileIndex = Collision()->GetTileIndex(Index: MapIndex);
1605 m_TileFIndex = Collision()->GetFrontTileIndex(Index: MapIndex);
1606 m_MoveRestrictions = Collision()->GetMoveRestrictions(pfnSwitchActive: IsSwitchActiveCb, pUser: this, Pos: m_Pos, Distance: 18.0f, OverrideCenterTileIndex: MapIndex);
1607 if(Index < 0)
1608 {
1609 m_LastRefillJumps = false;
1610 m_LastPenalty = false;
1611 m_LastBonus = false;
1612 return;
1613 }
1614 SetTimeCheckpoint(Collision()->IsTimeCheckpoint(Index: MapIndex));
1615 SetTimeCheckpoint(Collision()->IsFrontTimeCheckpoint(Index: MapIndex));
1616 int TeleCheckpoint = Collision()->IsTeleCheckpoint(Index: MapIndex);
1617 if(TeleCheckpoint)
1618 m_TeleCheckpoint = TeleCheckpoint;
1619
1620 GameServer()->m_pController->HandleCharacterTiles(pChr: this, MapIndex: Index);
1621 if(!m_Alive)
1622 return;
1623
1624 // freeze
1625 if(((m_TileIndex == TILE_FREEZE) || (m_TileFIndex == TILE_FREEZE)) && !m_Core.m_Super && !m_Core.m_Invincible && !m_Core.m_DeepFrozen)
1626 {
1627 Freeze();
1628 }
1629 else if(((m_TileIndex == TILE_UNFREEZE) || (m_TileFIndex == TILE_UNFREEZE)) && !m_Core.m_DeepFrozen)
1630 Unfreeze();
1631
1632 // deep freeze
1633 if(((m_TileIndex == TILE_DFREEZE) || (m_TileFIndex == TILE_DFREEZE)) && !m_Core.m_Super && !m_Core.m_Invincible && !m_Core.m_DeepFrozen)
1634 m_Core.m_DeepFrozen = true;
1635 else if(((m_TileIndex == TILE_DUNFREEZE) || (m_TileFIndex == TILE_DUNFREEZE)) && !m_Core.m_Super && !m_Core.m_Invincible && m_Core.m_DeepFrozen)
1636 m_Core.m_DeepFrozen = false;
1637
1638 // live freeze
1639 if(((m_TileIndex == TILE_LFREEZE) || (m_TileFIndex == TILE_LFREEZE)) && !m_Core.m_Super && !m_Core.m_Invincible)
1640 {
1641 m_Core.m_LiveFrozen = true;
1642 }
1643 else if(((m_TileIndex == TILE_LUNFREEZE) || (m_TileFIndex == TILE_LUNFREEZE)) && !m_Core.m_Super && !m_Core.m_Invincible)
1644 {
1645 m_Core.m_LiveFrozen = false;
1646 }
1647
1648 // endless hook
1649 if(((m_TileIndex == TILE_EHOOK_ENABLE) || (m_TileFIndex == TILE_EHOOK_ENABLE)))
1650 {
1651 SetEndlessHook(true);
1652 }
1653 else if(((m_TileIndex == TILE_EHOOK_DISABLE) || (m_TileFIndex == TILE_EHOOK_DISABLE)))
1654 {
1655 SetEndlessHook(false);
1656 }
1657
1658 // hit others
1659 if(((m_TileIndex == TILE_HIT_DISABLE) || (m_TileFIndex == TILE_HIT_DISABLE)) && (!m_Core.m_HammerHitDisabled || !m_Core.m_ShotgunHitDisabled || !m_Core.m_GrenadeHitDisabled || !m_Core.m_LaserHitDisabled))
1660 {
1661 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can't hit others");
1662 m_Core.m_HammerHitDisabled = true;
1663 m_Core.m_ShotgunHitDisabled = true;
1664 m_Core.m_GrenadeHitDisabled = true;
1665 m_Core.m_LaserHitDisabled = true;
1666 }
1667 else if(((m_TileIndex == TILE_HIT_ENABLE) || (m_TileFIndex == TILE_HIT_ENABLE)) && (m_Core.m_HammerHitDisabled || m_Core.m_ShotgunHitDisabled || m_Core.m_GrenadeHitDisabled || m_Core.m_LaserHitDisabled))
1668 {
1669 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can hit others");
1670 m_Core.m_ShotgunHitDisabled = false;
1671 m_Core.m_GrenadeHitDisabled = false;
1672 m_Core.m_HammerHitDisabled = false;
1673 m_Core.m_LaserHitDisabled = false;
1674 }
1675
1676 // collide with others
1677 if(((m_TileIndex == TILE_NPC_DISABLE) || (m_TileFIndex == TILE_NPC_DISABLE)) && !m_Core.m_CollisionDisabled)
1678 {
1679 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can't collide with others");
1680 m_Core.m_CollisionDisabled = true;
1681 }
1682 else if(((m_TileIndex == TILE_NPC_ENABLE) || (m_TileFIndex == TILE_NPC_ENABLE)) && m_Core.m_CollisionDisabled)
1683 {
1684 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can collide with others");
1685 m_Core.m_CollisionDisabled = false;
1686 }
1687
1688 // hook others
1689 if(((m_TileIndex == TILE_NPH_DISABLE) || (m_TileFIndex == TILE_NPH_DISABLE)) && !m_Core.m_HookHitDisabled)
1690 {
1691 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can't hook others");
1692 m_Core.m_HookHitDisabled = true;
1693 }
1694 else if(((m_TileIndex == TILE_NPH_ENABLE) || (m_TileFIndex == TILE_NPH_ENABLE)) && m_Core.m_HookHitDisabled)
1695 {
1696 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can hook others");
1697 m_Core.m_HookHitDisabled = false;
1698 }
1699
1700 // unlimited air jumps
1701 if(((m_TileIndex == TILE_UNLIMITED_JUMPS_ENABLE) || (m_TileFIndex == TILE_UNLIMITED_JUMPS_ENABLE)) && !m_Core.m_EndlessJump)
1702 {
1703 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You have unlimited air jumps");
1704 m_Core.m_EndlessJump = true;
1705 }
1706 else if(((m_TileIndex == TILE_UNLIMITED_JUMPS_DISABLE) || (m_TileFIndex == TILE_UNLIMITED_JUMPS_DISABLE)) && m_Core.m_EndlessJump)
1707 {
1708 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You don't have unlimited air jumps");
1709 m_Core.m_EndlessJump = false;
1710 }
1711
1712 // walljump
1713 if((m_TileIndex == TILE_WALLJUMP) || (m_TileFIndex == TILE_WALLJUMP))
1714 {
1715 if(m_Core.m_Vel.y > 0 && m_Core.m_Colliding && m_Core.m_LeftWall)
1716 {
1717 m_Core.m_LeftWall = false;
1718 m_Core.m_JumpedTotal = m_Core.m_Jumps >= 2 ? m_Core.m_Jumps - 2 : 0;
1719 m_Core.m_Jumped = 1;
1720 }
1721 }
1722
1723 // jetpack gun
1724 if(((m_TileIndex == TILE_JETPACK_ENABLE) || (m_TileFIndex == TILE_JETPACK_ENABLE)) && !m_Core.m_Jetpack)
1725 {
1726 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You have a jetpack gun");
1727 m_Core.m_Jetpack = true;
1728 }
1729 else if(((m_TileIndex == TILE_JETPACK_DISABLE) || (m_TileFIndex == TILE_JETPACK_DISABLE)) && m_Core.m_Jetpack)
1730 {
1731 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You lost your jetpack gun");
1732 m_Core.m_Jetpack = false;
1733 }
1734
1735 // refill jumps
1736 if(((m_TileIndex == TILE_REFILL_JUMPS) || (m_TileFIndex == TILE_REFILL_JUMPS)) && !m_LastRefillJumps)
1737 {
1738 m_Core.m_JumpedTotal = 0;
1739 m_Core.m_Jumped = 0;
1740 m_LastRefillJumps = true;
1741 }
1742 if((m_TileIndex != TILE_REFILL_JUMPS) && (m_TileFIndex != TILE_REFILL_JUMPS))
1743 {
1744 m_LastRefillJumps = false;
1745 }
1746
1747 // Teleport gun
1748 if(((m_TileIndex == TILE_TELE_GUN_ENABLE) || (m_TileFIndex == TILE_TELE_GUN_ENABLE)) && !m_Core.m_HasTelegunGun)
1749 {
1750 m_Core.m_HasTelegunGun = true;
1751
1752 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "Teleport gun enabled");
1753 }
1754 else if(((m_TileIndex == TILE_TELE_GUN_DISABLE) || (m_TileFIndex == TILE_TELE_GUN_DISABLE)) && m_Core.m_HasTelegunGun)
1755 {
1756 m_Core.m_HasTelegunGun = false;
1757
1758 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "Teleport gun disabled");
1759 }
1760
1761 if(((m_TileIndex == TILE_TELE_GRENADE_ENABLE) || (m_TileFIndex == TILE_TELE_GRENADE_ENABLE)) && !m_Core.m_HasTelegunGrenade)
1762 {
1763 m_Core.m_HasTelegunGrenade = true;
1764
1765 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "Teleport grenade enabled");
1766 }
1767 else if(((m_TileIndex == TILE_TELE_GRENADE_DISABLE) || (m_TileFIndex == TILE_TELE_GRENADE_DISABLE)) && m_Core.m_HasTelegunGrenade)
1768 {
1769 m_Core.m_HasTelegunGrenade = false;
1770
1771 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "Teleport grenade disabled");
1772 }
1773
1774 if(((m_TileIndex == TILE_TELE_LASER_ENABLE) || (m_TileFIndex == TILE_TELE_LASER_ENABLE)) && !m_Core.m_HasTelegunLaser)
1775 {
1776 m_Core.m_HasTelegunLaser = true;
1777
1778 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "Teleport laser enabled");
1779 }
1780 else if(((m_TileIndex == TILE_TELE_LASER_DISABLE) || (m_TileFIndex == TILE_TELE_LASER_DISABLE)) && m_Core.m_HasTelegunLaser)
1781 {
1782 m_Core.m_HasTelegunLaser = false;
1783
1784 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "Teleport laser disabled");
1785 }
1786
1787 // stopper
1788 if(m_Core.m_Vel.y > 0 && (m_MoveRestrictions & CANTMOVE_DOWN))
1789 {
1790 m_Core.m_Jumped = 0;
1791 m_Core.m_JumpedTotal = 0;
1792 }
1793 ApplyMoveRestrictions();
1794
1795 // handle switch tiles
1796 const int SwitchType = Collision()->GetSwitchType(Index: MapIndex);
1797 const int SwitchNumber = Collision()->GetSwitchNumber(Index: MapIndex);
1798 const int SwitchDelay = Collision()->GetSwitchDelay(Index: MapIndex);
1799 if(SwitchType == TILE_SWITCHOPEN && Team() != TEAM_SUPER && SwitchNumber > 0)
1800 {
1801 Switchers()[SwitchNumber].m_aStatus[Team()] = true;
1802 Switchers()[SwitchNumber].m_aEndTick[Team()] = 0;
1803 Switchers()[SwitchNumber].m_aType[Team()] = TILE_SWITCHOPEN;
1804 Switchers()[SwitchNumber].m_aLastUpdateTick[Team()] = Server()->Tick();
1805 }
1806 else if(SwitchType == TILE_SWITCHTIMEDOPEN && Team() != TEAM_SUPER && SwitchNumber > 0)
1807 {
1808 Switchers()[SwitchNumber].m_aStatus[Team()] = true;
1809 Switchers()[SwitchNumber].m_aEndTick[Team()] = Server()->Tick() + 1 + SwitchDelay * Server()->TickSpeed();
1810 Switchers()[SwitchNumber].m_aType[Team()] = TILE_SWITCHTIMEDOPEN;
1811 Switchers()[SwitchNumber].m_aLastUpdateTick[Team()] = Server()->Tick();
1812 }
1813 else if(SwitchType == TILE_SWITCHTIMEDCLOSE && Team() != TEAM_SUPER && SwitchNumber > 0)
1814 {
1815 Switchers()[SwitchNumber].m_aStatus[Team()] = false;
1816 Switchers()[SwitchNumber].m_aEndTick[Team()] = Server()->Tick() + 1 + SwitchDelay * Server()->TickSpeed();
1817 Switchers()[SwitchNumber].m_aType[Team()] = TILE_SWITCHTIMEDCLOSE;
1818 Switchers()[SwitchNumber].m_aLastUpdateTick[Team()] = Server()->Tick();
1819 }
1820 else if(SwitchType == TILE_SWITCHCLOSE && Team() != TEAM_SUPER && SwitchNumber > 0)
1821 {
1822 Switchers()[SwitchNumber].m_aStatus[Team()] = false;
1823 Switchers()[SwitchNumber].m_aEndTick[Team()] = 0;
1824 Switchers()[SwitchNumber].m_aType[Team()] = TILE_SWITCHCLOSE;
1825 Switchers()[SwitchNumber].m_aLastUpdateTick[Team()] = Server()->Tick();
1826 }
1827 else if(SwitchType == TILE_FREEZE && Team() != TEAM_SUPER && !m_Core.m_Invincible)
1828 {
1829 if(SwitchNumber == 0 || Switchers()[SwitchNumber].m_aStatus[Team()])
1830 {
1831 Freeze(Seconds: SwitchDelay);
1832 }
1833 }
1834 else if(SwitchType == TILE_DFREEZE && Team() != TEAM_SUPER && !m_Core.m_Invincible)
1835 {
1836 if(SwitchNumber == 0 || Switchers()[SwitchNumber].m_aStatus[Team()])
1837 m_Core.m_DeepFrozen = true;
1838 }
1839 else if(SwitchType == TILE_DUNFREEZE && Team() != TEAM_SUPER && !m_Core.m_Invincible)
1840 {
1841 if(SwitchNumber == 0 || Switchers()[SwitchNumber].m_aStatus[Team()])
1842 m_Core.m_DeepFrozen = false;
1843 }
1844 else if(SwitchType == TILE_LFREEZE && Team() != TEAM_SUPER && !m_Core.m_Invincible)
1845 {
1846 if(SwitchNumber == 0 || Switchers()[SwitchNumber].m_aStatus[Team()])
1847 {
1848 m_Core.m_LiveFrozen = true;
1849 }
1850 }
1851 else if(SwitchType == TILE_LUNFREEZE && Team() != TEAM_SUPER && !m_Core.m_Invincible)
1852 {
1853 if(SwitchNumber == 0 || Switchers()[SwitchNumber].m_aStatus[Team()])
1854 {
1855 m_Core.m_LiveFrozen = false;
1856 }
1857 }
1858 else if(SwitchType == TILE_HIT_ENABLE && m_Core.m_HammerHitDisabled && SwitchDelay == WEAPON_HAMMER)
1859 {
1860 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can hammer hit others");
1861 m_Core.m_HammerHitDisabled = false;
1862 }
1863 else if(SwitchType == TILE_HIT_DISABLE && !(m_Core.m_HammerHitDisabled) && SwitchDelay == WEAPON_HAMMER)
1864 {
1865 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can't hammer hit others");
1866 m_Core.m_HammerHitDisabled = true;
1867 }
1868 else if(SwitchType == TILE_HIT_ENABLE && m_Core.m_ShotgunHitDisabled && SwitchDelay == WEAPON_SHOTGUN)
1869 {
1870 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can shoot others with shotgun");
1871 m_Core.m_ShotgunHitDisabled = false;
1872 }
1873 else if(SwitchType == TILE_HIT_DISABLE && !(m_Core.m_ShotgunHitDisabled) && SwitchDelay == WEAPON_SHOTGUN)
1874 {
1875 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can't shoot others with shotgun");
1876 m_Core.m_ShotgunHitDisabled = true;
1877 }
1878 else if(SwitchType == TILE_HIT_ENABLE && m_Core.m_GrenadeHitDisabled && SwitchDelay == WEAPON_GRENADE)
1879 {
1880 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can shoot others with grenade");
1881 m_Core.m_GrenadeHitDisabled = false;
1882 }
1883 else if(SwitchType == TILE_HIT_DISABLE && !(m_Core.m_GrenadeHitDisabled) && SwitchDelay == WEAPON_GRENADE)
1884 {
1885 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can't shoot others with grenade");
1886 m_Core.m_GrenadeHitDisabled = true;
1887 }
1888 else if(SwitchType == TILE_HIT_ENABLE && m_Core.m_LaserHitDisabled && SwitchDelay == WEAPON_LASER)
1889 {
1890 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can shoot others with laser");
1891 m_Core.m_LaserHitDisabled = false;
1892 }
1893 else if(SwitchType == TILE_HIT_DISABLE && !(m_Core.m_LaserHitDisabled) && SwitchDelay == WEAPON_LASER)
1894 {
1895 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: "You can't shoot others with laser");
1896 m_Core.m_LaserHitDisabled = true;
1897 }
1898 else if(SwitchType == TILE_JUMP)
1899 {
1900 int NewJumps = SwitchDelay;
1901 if(NewJumps == 255)
1902 {
1903 NewJumps = -1;
1904 }
1905
1906 if(NewJumps != m_Core.m_Jumps)
1907 {
1908 char aBuf[256];
1909 if(NewJumps == -1)
1910 str_copy(dst&: aBuf, src: "You only have your ground jump now");
1911 else if(NewJumps == 1)
1912 str_format(buffer: aBuf, buffer_size: sizeof(aBuf), format: "You can jump %d time", NewJumps);
1913 else
1914 str_format(buffer: aBuf, buffer_size: sizeof(aBuf), format: "You can jump %d times", NewJumps);
1915 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: aBuf);
1916 m_Core.m_Jumps = NewJumps;
1917 }
1918 }
1919 else if(SwitchType == TILE_ADD_TIME && !m_LastPenalty)
1920 {
1921 const int Minutes = SwitchDelay;
1922 const int Seconds = SwitchNumber;
1923 int Team = Teams()->m_Core.Team(ClientId: m_Core.m_Id);
1924
1925 m_StartTime -= (Minutes * 60 + Seconds) * Server()->TickSpeed();
1926
1927 if((g_Config.m_SvTeam == SV_TEAM_FORCED_SOLO || (Team != TEAM_FLOCK && !Teams()->TeamFlock(Team))) && Team != TEAM_SUPER)
1928 {
1929 for(int i = 0; i < MAX_CLIENTS; i++)
1930 {
1931 if(Teams()->m_Core.Team(ClientId: i) == Team && i != m_Core.m_Id && GameServer()->m_apPlayers[i])
1932 {
1933 CCharacter *pChar = GameServer()->m_apPlayers[i]->GetCharacter();
1934
1935 if(pChar)
1936 pChar->m_StartTime = m_StartTime;
1937 }
1938 }
1939 }
1940
1941 m_LastPenalty = true;
1942 }
1943 else if(SwitchType == TILE_SUBTRACT_TIME && !m_LastBonus)
1944 {
1945 const int Minutes = SwitchDelay;
1946 const int Seconds = SwitchNumber;
1947 int Team = Teams()->m_Core.Team(ClientId: m_Core.m_Id);
1948
1949 m_StartTime += (Minutes * 60 + Seconds) * Server()->TickSpeed();
1950 if(m_StartTime > Server()->Tick())
1951 m_StartTime = Server()->Tick();
1952
1953 if((g_Config.m_SvTeam == SV_TEAM_FORCED_SOLO || (Team != TEAM_FLOCK && !Teams()->TeamFlock(Team))) && Team != TEAM_SUPER)
1954 {
1955 for(int i = 0; i < MAX_CLIENTS; i++)
1956 {
1957 if(Teams()->m_Core.Team(ClientId: i) == Team && i != m_Core.m_Id && GameServer()->m_apPlayers[i])
1958 {
1959 CCharacter *pChar = GameServer()->m_apPlayers[i]->GetCharacter();
1960
1961 if(pChar)
1962 pChar->m_StartTime = m_StartTime;
1963 }
1964 }
1965 }
1966
1967 m_LastBonus = true;
1968 }
1969
1970 if(SwitchType != TILE_ADD_TIME)
1971 {
1972 m_LastPenalty = false;
1973 }
1974
1975 if(SwitchType != TILE_SUBTRACT_TIME)
1976 {
1977 m_LastBonus = false;
1978 }
1979
1980 int z = Collision()->IsTeleport(Index: MapIndex);
1981 if(!g_Config.m_SvOldTeleportHook && !g_Config.m_SvOldTeleportWeapons && z && !Collision()->TeleOuts(Number: z - 1).empty())
1982 {
1983 if(m_Core.m_Super || m_Core.m_Invincible)
1984 return;
1985 int TeleOut = GameWorld()->m_Core.RandomOr0(BelowThis: Collision()->TeleOuts(Number: z - 1).size());
1986 m_Core.m_Pos = Collision()->TeleOuts(Number: z - 1)[TeleOut];
1987 if(!g_Config.m_SvTeleportHoldHook)
1988 {
1989 ResetHook();
1990 }
1991 if(g_Config.m_SvTeleportLoseWeapons)
1992 ResetPickups();
1993 return;
1994 }
1995 const int EvilTeleport = Collision()->IsEvilTeleport(Index: MapIndex);
1996 if(EvilTeleport && !Collision()->TeleOuts(Number: EvilTeleport - 1).empty())
1997 {
1998 if(m_Core.m_Super || m_Core.m_Invincible)
1999 return;
2000 int TeleOut = GameWorld()->m_Core.RandomOr0(BelowThis: Collision()->TeleOuts(Number: EvilTeleport - 1).size());
2001 m_Core.m_Pos = Collision()->TeleOuts(Number: EvilTeleport - 1)[TeleOut];
2002 if(!g_Config.m_SvOldTeleportHook && !g_Config.m_SvOldTeleportWeapons)
2003 {
2004 m_Core.m_Vel = vec2(0, 0);
2005
2006 if(!g_Config.m_SvTeleportHoldHook)
2007 {
2008 ResetHook();
2009 GameWorld()->ReleaseHooked(ClientId: GetPlayer()->GetCid());
2010 }
2011 if(g_Config.m_SvTeleportLoseWeapons)
2012 {
2013 ResetPickups();
2014 }
2015 }
2016 return;
2017 }
2018 if(Collision()->IsCheckEvilTeleport(Index: MapIndex))
2019 {
2020 if(m_Core.m_Super || m_Core.m_Invincible)
2021 return;
2022 // first check if there is a TeleCheckOut for the current recorded checkpoint, if not check previous checkpoints
2023 for(int k = m_TeleCheckpoint - 1; k >= 0; k--)
2024 {
2025 if(!Collision()->TeleCheckOuts(Number: k).empty())
2026 {
2027 int TeleOut = GameWorld()->m_Core.RandomOr0(BelowThis: Collision()->TeleCheckOuts(Number: k).size());
2028 m_Core.m_Pos = Collision()->TeleCheckOuts(Number: k)[TeleOut];
2029 m_Core.m_Vel = vec2(0, 0);
2030
2031 if(!g_Config.m_SvTeleportHoldHook)
2032 {
2033 ResetHook();
2034 GameWorld()->ReleaseHooked(ClientId: GetPlayer()->GetCid());
2035 }
2036
2037 return;
2038 }
2039 }
2040 // if no checkpointout have been found (or if there no recorded checkpoint), teleport to start
2041 vec2 SpawnPos;
2042 if(GameServer()->m_pController->CanSpawn(Team: m_pPlayer->GetTeam(), pOutPos: &SpawnPos, ClientId: GetPlayer()->GetCid()))
2043 {
2044 m_Core.m_Pos = SpawnPos;
2045 m_Core.m_Vel = vec2(0, 0);
2046
2047 if(!g_Config.m_SvTeleportHoldHook)
2048 {
2049 ResetHook();
2050 GameWorld()->ReleaseHooked(ClientId: GetPlayer()->GetCid());
2051 }
2052 }
2053 return;
2054 }
2055 if(Collision()->IsCheckTeleport(Index: MapIndex))
2056 {
2057 if(m_Core.m_Super || m_Core.m_Invincible)
2058 return;
2059 // first check if there is a TeleCheckOut for the current recorded checkpoint, if not check previous checkpoints
2060 for(int k = m_TeleCheckpoint - 1; k >= 0; k--)
2061 {
2062 if(!Collision()->TeleCheckOuts(Number: k).empty())
2063 {
2064 int TeleOut = GameWorld()->m_Core.RandomOr0(BelowThis: Collision()->TeleCheckOuts(Number: k).size());
2065 m_Core.m_Pos = Collision()->TeleCheckOuts(Number: k)[TeleOut];
2066
2067 if(!g_Config.m_SvTeleportHoldHook)
2068 {
2069 ResetHook();
2070 }
2071
2072 return;
2073 }
2074 }
2075 // if no checkpointout have been found (or if there no recorded checkpoint), teleport to start
2076 vec2 SpawnPos;
2077 if(GameServer()->m_pController->CanSpawn(Team: m_pPlayer->GetTeam(), pOutPos: &SpawnPos, ClientId: GetPlayer()->GetCid()))
2078 {
2079 m_Core.m_Pos = SpawnPos;
2080
2081 if(!g_Config.m_SvTeleportHoldHook)
2082 {
2083 ResetHook();
2084 }
2085 }
2086 return;
2087 }
2088}
2089
2090void CCharacter::HandleTuneLayer()
2091{
2092 m_TuneZoneOld = m_TuneZone;
2093 int CurrentIndex = Collision()->GetMapIndex(Pos: m_Pos);
2094 m_TuneZone = Collision()->IsTune(Index: CurrentIndex);
2095 m_Core.m_Tuning = TuningList()[m_TuneZone]; // throw tunings from specific zone into gamecore
2096
2097 if(m_TuneZone != m_TuneZoneOld) // don't send tunigs all the time
2098 {
2099 // send zone msgs
2100 SendZoneMsgs();
2101 }
2102}
2103
2104void CCharacter::SendZoneMsgs()
2105{
2106 // send zone leave msg
2107 // (m_TuneZoneOld >= 0: avoid zone leave msgs on spawn)
2108 if(m_TuneZoneOld >= 0 && GameServer()->m_aaZoneLeaveMsg[m_TuneZoneOld][0])
2109 {
2110 const char *pCur = GameServer()->m_aaZoneLeaveMsg[m_TuneZoneOld];
2111 const char *pPos;
2112 while((pPos = str_find(haystack: pCur, needle: "\\n")))
2113 {
2114 char aBuf[256];
2115 str_copy(dst: aBuf, src: pCur, dst_size: pPos - pCur + 1);
2116 aBuf[pPos - pCur + 1] = '\0';
2117 pCur = pPos + 2;
2118 GameServer()->SendChatTarget(To: m_pPlayer->GetCid(), pText: aBuf);
2119 }
2120 GameServer()->SendChatTarget(To: m_pPlayer->GetCid(), pText: pCur);
2121 }
2122 // send zone enter msg
2123 if(GameServer()->m_aaZoneEnterMsg[m_TuneZone][0])
2124 {
2125 const char *pCur = GameServer()->m_aaZoneEnterMsg[m_TuneZone];
2126 const char *pPos;
2127 while((pPos = str_find(haystack: pCur, needle: "\\n")))
2128 {
2129 char aBuf[256];
2130 str_copy(dst: aBuf, src: pCur, dst_size: pPos - pCur + 1);
2131 aBuf[pPos - pCur + 1] = '\0';
2132 pCur = pPos + 2;
2133 GameServer()->SendChatTarget(To: m_pPlayer->GetCid(), pText: aBuf);
2134 }
2135 GameServer()->SendChatTarget(To: m_pPlayer->GetCid(), pText: pCur);
2136 }
2137}
2138
2139IAntibot *CCharacter::Antibot()
2140{
2141 return GameServer()->Antibot();
2142}
2143
2144void CCharacter::SetTeams(CGameTeams *pTeams)
2145{
2146 m_pTeams = pTeams;
2147 m_Core.SetTeamsCore(&m_pTeams->m_Core);
2148}
2149
2150bool CCharacter::TrySetRescue(int RescueMode)
2151{
2152 bool Set = false;
2153 if(g_Config.m_SvRescue || ((g_Config.m_SvTeam == SV_TEAM_FORCED_SOLO || Team() > TEAM_FLOCK) && Teams()->IsValidTeamNumber(Team: Team())))
2154 {
2155 // check for nearby health pickups (also freeze)
2156 bool InHealthPickup = false;
2157 if(!m_Core.m_IsInFreeze)
2158 {
2159 CEntity *apEnts[9];
2160 int Num = GameWorld()->FindEntities(Pos: m_Pos, Radius: GetProximityRadius() + CPickup::ms_CollisionExtraSize, ppEnts: apEnts, Max: std::size(apEnts), Type: CGameWorld::ENTTYPE_PICKUP);
2161 for(int i = 0; i < Num; ++i)
2162 {
2163 CPickup *pPickup = static_cast<CPickup *>(apEnts[i]);
2164 if(pPickup->Type() == POWERUP_HEALTH)
2165 {
2166 // This uses a separate variable InHealthPickup instead of setting m_Core.m_IsInFreeze
2167 // as the latter causes freezebars to flicker when standing in the freeze range of a
2168 // health pickup. When the same code for client prediction is added, the freezebars
2169 // still flicker, but only when standing at the edge of the health pickup's freeze range.
2170 InHealthPickup = true;
2171 break;
2172 }
2173 }
2174 }
2175
2176 if(!m_Core.m_IsInFreeze && IsGrounded() && !m_Core.m_DeepFrozen && !InHealthPickup)
2177 {
2178 ForceSetRescue(RescueMode);
2179 Set = true;
2180 }
2181 }
2182
2183 return Set;
2184}
2185
2186void CCharacter::ForceSetRescue(int RescueMode)
2187{
2188 m_RescueTee[RescueMode].Save(pChr: this);
2189 m_SetSavePos[RescueMode] = true;
2190}
2191
2192void CCharacter::DDRaceTick()
2193{
2194 mem_copy(dest: &m_Input, source: &m_SavedInput, size: sizeof(m_Input));
2195 GameServer()->m_pController->SetArmorProgress(pCharacter: this, Progress: m_FreezeTime);
2196 if(m_Input.m_Direction != 0 || m_Input.m_Jump != 0)
2197 m_LastMove = Server()->Tick();
2198
2199 if(m_Core.m_LiveFrozen && !m_Core.m_Super && !m_Core.m_Invincible)
2200 {
2201 m_Input.m_Direction = 0;
2202 m_Input.m_Jump = 0;
2203 // Hook is possible in live freeze
2204 }
2205 if(m_FreezeTime > 0)
2206 {
2207 if(m_FreezeTime % Server()->TickSpeed() == Server()->TickSpeed() - 1)
2208 {
2209 GameServer()->CreateDamageInd(Pos: m_Pos, AngleMod: 0, Amount: (m_FreezeTime + 1) / Server()->TickSpeed(), Mask: TeamMask() & GameServer()->ClientsMaskExcludeClientVersionAndHigher(Version: VERSION_DDNET_NEW_HUD));
2210 }
2211 m_FreezeTime--;
2212 m_Input.m_Direction = 0;
2213 m_Input.m_Jump = 0;
2214 m_Input.m_Hook = 0;
2215 if(m_FreezeTime == 1)
2216 Unfreeze();
2217 }
2218
2219 HandleTuneLayer(); // need this before coretick
2220
2221 // check if the tee is in any type of freeze
2222 int Index = Collision()->GetPureMapIndex(Pos: m_Pos);
2223 const int aTiles[] = {
2224 Collision()->GetTileIndex(Index),
2225 Collision()->GetFrontTileIndex(Index),
2226 Collision()->GetSwitchType(Index)};
2227 m_Core.m_IsInFreeze = false;
2228 for(const int Tile : aTiles)
2229 {
2230 if(Tile == TILE_FREEZE || Tile == TILE_DFREEZE || Tile == TILE_LFREEZE || Tile == TILE_DEATH)
2231 {
2232 m_Core.m_IsInFreeze = true;
2233 break;
2234 }
2235 }
2236 m_Core.m_IsInFreeze |= (Collision()->GetCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
2237 Collision()->GetCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH ||
2238 Collision()->GetCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
2239 Collision()->GetCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH ||
2240 Collision()->GetFrontCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
2241 Collision()->GetFrontCollisionAt(x: m_Pos.x + GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH ||
2242 Collision()->GetFrontCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y - GetProximityRadius() / 3.f) == TILE_DEATH ||
2243 Collision()->GetFrontCollisionAt(x: m_Pos.x - GetProximityRadius() / 3.f, y: m_Pos.y + GetProximityRadius() / 3.f) == TILE_DEATH);
2244
2245 // look for save position for rescue feature
2246 // always update auto rescue
2247 TrySetRescue(RescueMode: RESCUEMODE_AUTO);
2248
2249 m_Core.m_Id = GetPlayer()->GetCid();
2250}
2251
2252void CCharacter::DDRacePostCoreTick()
2253{
2254 m_Time = (float)(Server()->Tick() - m_StartTime) / ((float)Server()->TickSpeed());
2255
2256 if(m_Core.m_EndlessHook || (m_Core.m_Super && g_Config.m_SvEndlessSuperHook))
2257 m_Core.m_HookTick = 0;
2258
2259 m_FrozenLastTick = false;
2260
2261 if(m_Core.m_DeepFrozen && !m_Core.m_Super && !m_Core.m_Invincible)
2262 Freeze();
2263
2264 // following jump rules can be overridden by tiles, like Refill Jumps, Stopper and Wall Jump
2265 if(m_Core.m_Jumps == -1)
2266 {
2267 // The player has only one ground jump, so their feet are always dark
2268 m_Core.m_Jumped |= 2;
2269 }
2270 else if(m_Core.m_Jumps == 0)
2271 {
2272 // The player has no jumps at all, so their feet are always dark
2273 m_Core.m_Jumped |= 2;
2274 }
2275 else if(m_Core.m_Jumps == 1 && m_Core.m_Jumped > 0)
2276 {
2277 // If the player has only one jump, each jump is the last one
2278 m_Core.m_Jumped |= 2;
2279 }
2280 else if(m_Core.m_JumpedTotal < m_Core.m_Jumps - 1 && m_Core.m_Jumped > 1)
2281 {
2282 // The player has not yet used up all their jumps, so their feet remain light
2283 m_Core.m_Jumped = 1;
2284 }
2285
2286 if((m_Core.m_Super || m_Core.m_EndlessJump) && m_Core.m_Jumped > 1)
2287 {
2288 // Super players and players with infinite jumps always have light feet
2289 m_Core.m_Jumped = 1;
2290 }
2291
2292 int CurrentIndex = Collision()->GetMapIndex(Pos: m_Pos);
2293 HandleSkippableTiles(Index: CurrentIndex);
2294 if(!m_Alive)
2295 return;
2296
2297 // handle Anti-Skip tiles
2298 std::vector<int> vIndices = Collision()->GetMapIndices(PrevPos: m_PrevPos, Pos: m_Pos);
2299 if(!vIndices.empty())
2300 {
2301 for(int &Index : vIndices)
2302 {
2303 HandleTiles(Index);
2304 if(!m_Alive)
2305 return;
2306 }
2307 }
2308 else
2309 {
2310 HandleTiles(Index: CurrentIndex);
2311 if(!m_Alive)
2312 return;
2313 }
2314
2315 // teleport gun
2316 if(m_TeleGunTeleport)
2317 {
2318 GameServer()->CreateDeath(Pos: m_Pos, ClientId: m_pPlayer->GetCid(), Mask: TeamMask());
2319 m_Core.m_Pos = m_TeleGunPos;
2320 if(!m_IsBlueTeleGunTeleport)
2321 m_Core.m_Vel = vec2(0, 0);
2322 GameServer()->CreateDeath(Pos: m_TeleGunPos, ClientId: m_pPlayer->GetCid(), Mask: TeamMask());
2323 GameServer()->CreateSound(Pos: m_TeleGunPos, Sound: SOUND_WEAPON_SPAWN, Mask: TeamMask());
2324 m_TeleGunTeleport = false;
2325 m_IsBlueTeleGunTeleport = false;
2326 }
2327
2328 HandleBroadcast();
2329}
2330
2331bool CCharacter::Freeze(int Seconds)
2332{
2333 if(Seconds <= 0 || m_Core.m_Super || m_Core.m_Invincible || m_FreezeTime > Seconds * Server()->TickSpeed())
2334 return false;
2335 if(m_FreezeTime == 0 || m_Core.m_FreezeStart < Server()->Tick() - Server()->TickSpeed())
2336 {
2337 m_Armor = 0;
2338 m_FreezeTime = Seconds * Server()->TickSpeed();
2339 m_Core.m_FreezeStart = Server()->Tick();
2340 return true;
2341 }
2342 return false;
2343}
2344
2345bool CCharacter::Freeze()
2346{
2347 return Freeze(Seconds: g_Config.m_SvFreezeDelay);
2348}
2349
2350bool CCharacter::Unfreeze()
2351{
2352 if(m_FreezeTime > 0)
2353 {
2354 m_Armor = 10;
2355 if(m_Core.m_ActiveWeapon >= 0 && !m_Core.m_aWeapons[m_Core.m_ActiveWeapon].m_Got)
2356 m_Core.m_ActiveWeapon = WEAPON_GUN;
2357 m_FreezeTime = 0;
2358 m_Core.m_FreezeStart = 0;
2359 m_FrozenLastTick = true;
2360 return true;
2361 }
2362 return false;
2363}
2364
2365void CCharacter::ResetJumps()
2366{
2367 m_Core.m_JumpedTotal = 0;
2368 m_Core.m_Jumped = 0;
2369}
2370
2371void CCharacter::GiveWeapon(int Weapon, bool Remove)
2372{
2373 if(Weapon == WEAPON_NINJA)
2374 {
2375 if(Remove)
2376 RemoveNinja();
2377 else
2378 GiveNinja();
2379 return;
2380 }
2381
2382 if(Remove)
2383 {
2384 if(GetActiveWeapon() == Weapon)
2385 SetActiveWeapon(WEAPON_GUN);
2386 }
2387 else
2388 {
2389 m_Core.m_aWeapons[Weapon].m_Ammo = -1;
2390 }
2391
2392 m_Core.m_aWeapons[Weapon].m_Got = !Remove;
2393}
2394
2395void CCharacter::GiveAllWeapons()
2396{
2397 for(int i = WEAPON_GUN; i < NUM_WEAPONS - 1; i++)
2398 {
2399 GiveWeapon(Weapon: i);
2400 }
2401}
2402
2403void CCharacter::ResetPickups()
2404{
2405 for(int i = WEAPON_SHOTGUN; i < NUM_WEAPONS - 1; i++)
2406 {
2407 m_Core.m_aWeapons[i].m_Got = false;
2408 if(m_Core.m_ActiveWeapon == i)
2409 m_Core.m_ActiveWeapon = WEAPON_GUN;
2410 }
2411}
2412
2413void CCharacter::SetEndlessHook(bool Enable)
2414{
2415 if(m_Core.m_EndlessHook == Enable)
2416 {
2417 return;
2418 }
2419 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: Enable ? "Endless hook has been activated" : "Endless hook has been deactivated");
2420
2421 m_Core.m_EndlessHook = Enable;
2422}
2423
2424void CCharacter::Pause(bool Pause)
2425{
2426 m_Paused = Pause;
2427 if(Pause)
2428 {
2429 GameServer()->m_World.m_Core.m_apCharacters[m_pPlayer->GetCid()] = nullptr;
2430 GameServer()->m_World.RemoveEntity(pEntity: this);
2431
2432 if(m_Core.HookedPlayer() != -1) // Keeping hook would allow cheats
2433 {
2434 ResetHook();
2435 GameWorld()->ReleaseHooked(ClientId: GetPlayer()->GetCid());
2436 }
2437 m_PausedTick = Server()->Tick();
2438 }
2439 else
2440 {
2441 m_Core.m_Vel = vec2(0, 0);
2442 GameServer()->m_World.m_Core.m_apCharacters[m_pPlayer->GetCid()] = &m_Core;
2443 GameServer()->m_World.InsertEntity(pEntity: this);
2444 if(m_Core.m_FreezeStart > 0 && m_PausedTick >= 0)
2445 {
2446 m_Core.m_FreezeStart += Server()->Tick() - m_PausedTick;
2447 }
2448 }
2449}
2450
2451void CCharacter::DDRaceInit()
2452{
2453 m_Paused = false;
2454 m_DDRaceState = ERaceState::NONE;
2455 m_PrevPos = m_Pos;
2456 for(bool &Set : m_SetSavePos)
2457 Set = false;
2458 m_LastBroadcast = 0;
2459 m_TeamBeforeSuper = 0;
2460 m_Core.m_Id = GetPlayer()->GetCid();
2461 m_TeleCheckpoint = 0;
2462 m_Core.m_EndlessHook = g_Config.m_SvEndlessDrag;
2463 if(g_Config.m_SvHit)
2464 {
2465 m_Core.m_HammerHitDisabled = false;
2466 m_Core.m_ShotgunHitDisabled = false;
2467 m_Core.m_GrenadeHitDisabled = false;
2468 m_Core.m_LaserHitDisabled = false;
2469 }
2470 else
2471 {
2472 m_Core.m_HammerHitDisabled = true;
2473 m_Core.m_ShotgunHitDisabled = true;
2474 m_Core.m_GrenadeHitDisabled = true;
2475 m_Core.m_LaserHitDisabled = true;
2476 }
2477 m_Core.m_Jumps = 2;
2478
2479 int Team = Teams()->m_Core.Team(ClientId: m_Core.m_Id);
2480
2481 if(Teams()->TeamLocked(Team) && !Teams()->TeamFlock(Team))
2482 {
2483 for(int i = 0; i < MAX_CLIENTS; i++)
2484 {
2485 if(Teams()->m_Core.Team(ClientId: i) == Team && i != m_Core.m_Id && GameServer()->m_apPlayers[i])
2486 {
2487 CCharacter *pChar = GameServer()->m_apPlayers[i]->GetCharacter();
2488
2489 if(pChar)
2490 {
2491 m_DDRaceState = pChar->m_DDRaceState;
2492 m_StartTime = pChar->m_StartTime;
2493 }
2494 }
2495 }
2496 }
2497
2498 if(g_Config.m_SvTeam == SV_TEAM_MANDATORY && Team == TEAM_FLOCK)
2499 {
2500 GameServer()->SendStartWarning(ClientId: GetPlayer()->GetCid(), pMessage: "Please join a team before you start");
2501 }
2502}
2503
2504void CCharacter::Rescue()
2505{
2506 if(m_SetSavePos[GetPlayer()->m_RescueMode] && !m_Core.m_Super && !m_Core.m_Invincible)
2507 {
2508 if(m_LastRescue + (int64_t)g_Config.m_SvRescueDelay * Server()->TickSpeed() > Server()->Tick() && !Teams()->IsPractice(Team: Team()))
2509 {
2510 char aBuf[256];
2511 str_format(buffer: aBuf, buffer_size: sizeof(aBuf), format: "You have to wait %d seconds until you can rescue yourself", (int)((m_LastRescue + (int64_t)g_Config.m_SvRescueDelay * Server()->TickSpeed() - Server()->Tick()) / Server()->TickSpeed()));
2512 GameServer()->SendChatTarget(To: GetPlayer()->GetCid(), pText: aBuf);
2513 return;
2514 }
2515
2516 m_LastRescue = Server()->Tick();
2517 int StartTime = m_StartTime;
2518 m_RescueTee[GetPlayer()->m_RescueMode].Load(pChr: this);
2519 // Don't load these from saved tee:
2520 m_Core.m_Vel = vec2(0, 0);
2521 m_Core.m_HookState = HOOK_IDLE;
2522 m_StartTime = StartTime;
2523 m_SavedInput.m_Direction = 0;
2524 m_SavedInput.m_Jump = 0;
2525 // simulate releasing the fire button
2526 if((m_SavedInput.m_Fire & 1) != 0)
2527 m_SavedInput.m_Fire++;
2528 m_SavedInput.m_Fire &= INPUT_STATE_MASK;
2529 m_SavedInput.m_Hook = 0;
2530 m_pPlayer->Pause(State: CPlayer::PAUSE_NONE, Force: true);
2531 }
2532}
2533
2534CClientMask CCharacter::TeamMask()
2535{
2536 return Teams()->TeamMask(Team: Team(), ExceptId: -1, Asker: GetPlayer()->GetCid());
2537}
2538
2539void CCharacter::SetPosition(const vec2 &Position)
2540{
2541 m_Core.m_Pos = Position;
2542}
2543
2544void CCharacter::Move(vec2 RelPos)
2545{
2546 m_Core.m_Pos += RelPos;
2547}
2548
2549void CCharacter::ResetVelocity()
2550{
2551 m_Core.m_Vel = vec2(0, 0);
2552}
2553
2554void CCharacter::SetVelocity(vec2 NewVelocity)
2555{
2556 m_Core.m_Vel = ClampVel(MoveRestriction: m_MoveRestrictions, Vel: NewVelocity);
2557}
2558
2559// The method is needed only to reproduce 'shotgun bug' ddnet#5258
2560// Use SetVelocity() instead.
2561void CCharacter::SetRawVelocity(vec2 NewVelocity)
2562{
2563 m_Core.m_Vel = NewVelocity;
2564}
2565
2566void CCharacter::AddVelocity(vec2 Addition)
2567{
2568 SetVelocity(m_Core.m_Vel + Addition);
2569}
2570
2571void CCharacter::ApplyMoveRestrictions()
2572{
2573 m_Core.m_Vel = ClampVel(MoveRestriction: m_MoveRestrictions, Vel: m_Core.m_Vel);
2574}
2575
2576void CCharacter::SwapClients(int Client1, int Client2)
2577{
2578 const int HookedPlayer = m_Core.HookedPlayer();
2579 m_Core.SetHookedPlayer(HookedPlayer == Client1 ? Client2 : (HookedPlayer == Client2 ? Client1 : HookedPlayer));
2580}
2581