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