edg-l/ddnet
1
0
Fork 0
mirror of https://github.com/ddnet/ddnet.git synced 2024-09-20 09:34:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix: Guns and draggers work for each player in a solo part individually

Browse source
This commit is contained in:
def 2014-05-08 00:53:21 +02:00
parent c8712fa394
commit ba909bc498
3 changed files with 289 additions and 190 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

458
src/game/server/entities/dragger.cpp
View file

@ -21,6 +21,11 @@ CDragger::CDragger(CGameWorld *pGameWorld, vec2 Pos, float Strength, bool NW,
m_NW = NW; m_NW = NW;
m_CatchedTeam = CatchedTeam; m_CatchedTeam = CatchedTeam;
GameWorld()->InsertEntity(this); GameWorld()->InsertEntity(this);
for (int i = 0; i < MAX_CLIENTS; i++)
{
m_SoloIDs[i] = -1;
}
} }
void CDragger::Move() void CDragger::Move()
@ -30,177 +35,214 @@ void CDragger::Move()
|| (m_Layer == LAYER_SWITCH || (m_Layer == LAYER_SWITCH
&& !GameServer()->Collision()->m_pSwitchers[m_Number].m_Status[m_Target->Team()]))) && !GameServer()->Collision()->m_pSwitchers[m_Number].m_Status[m_Target->Team()])))
m_Target = 0; m_Target = 0;
if (m_Target) mem_zero(m_SoloEnts, sizeof(m_SoloEnts));
return;
CCharacter *Ents[MAX_CLIENTS];
int Num = GameServer()->m_World.FindEntities(m_Pos, LENGTH, int Num = GameServer()->m_World.FindEntities(m_Pos, LENGTH,
(CEntity**) Ents, MAX_CLIENTS, CGameWorld::ENTTYPE_CHARACTER); (CEntity**) m_SoloEnts, MAX_CLIENTS, CGameWorld::ENTTYPE_CHARACTER);
int Id = -1; int Id = -1;
int MinLen = 0; int MinLen = 0;
CCharacter *Temp;
for (int i = 0; i < Num; i++) for (int i = 0; i < Num; i++)
{ {
m_Target = Ents[i]; Temp = m_SoloEnts[i];
if (m_Target->Team() != m_CatchedTeam) if (Temp->Team() != m_CatchedTeam)
{
m_SoloEnts[i] = 0;
continue; continue;
}
if (m_Layer == LAYER_SWITCH if (m_Layer == LAYER_SWITCH
&& !GameServer()->Collision()->m_pSwitchers[m_Number].m_Status[m_Target->Team()]) && !GameServer()->Collision()->m_pSwitchers[m_Number].m_Status[Temp->Team()])
{
m_SoloEnts[i] = 0;
continue; continue;
}
int Res = int Res =
m_NW ? GameServer()->Collision()->IntersectNoLaserNW(m_Pos, m_NW ? GameServer()->Collision()->IntersectNoLaserNW(m_Pos,
m_Target->m_Pos, 0, 0) : Temp->m_Pos, 0, 0) :
GameServer()->Collision()->IntersectNoLaser(m_Pos, GameServer()->Collision()->IntersectNoLaser(m_Pos,
m_Target->m_Pos, 0, 0); Temp->m_Pos, 0, 0);
if (Res == 0) if (Res == 0)
{ {
int Len = length(m_Target->m_Pos - m_Pos); int Len = length(Temp->m_Pos - m_Pos);
if (MinLen == 0 || MinLen > Len) if (MinLen == 0 || MinLen > Len)
{ {
MinLen = Len; MinLen = Len;
Id = i; Id = i;
} }
if (!Temp->Teams()->m_Core.GetSolo(Temp->GetPlayer()->GetCID()))
m_SoloEnts[i] = 0;
}
else
{
m_SoloEnts[i] = 0;
}
}
if (!m_Target)
m_Target = Id != -1 ? m_SoloEnts[Id] : 0;
if (m_Target)
{
for (int i = 0; i < MAX_CLIENTS; i++)
{
if (m_SoloEnts[i] == m_Target)
m_SoloEnts[i] = 0;
} }
} }
m_Target = Id != -1 ? Ents[Id] : 0;
} }
void CDragger::Drag() void CDragger::Drag()
{ {
if (m_Target) if (m_Target)
{ {
CCharacter *Target = m_Target;
int Res = 0; for (int i = -1; i < MAX_CLIENTS; i++)
if (!m_NW)
Res = GameServer()->Collision()->IntersectNoLaser(m_Pos,
m_Target->m_Pos, 0, 0);
else
Res = GameServer()->Collision()->IntersectNoLaserNW(m_Pos,
m_Target->m_Pos, 0, 0);
if (Res || length(m_Pos - m_Target->m_Pos) > 700)
{ {
m_Target = 0; if (i >= 0)
} Target = m_SoloEnts[i];
else if (length(m_Pos - m_Target->m_Pos) > 28)
{ if (!Target)
vec2 Temp = m_Target->Core()->m_Vel continue;
+ (normalize(m_Pos - m_Target->m_Pos) * m_Strength);
if (Temp.x > 0 int Res = 0;
&& ((m_Target->m_TileIndex == TILE_STOP if (!m_NW)
&& m_Target->m_TileFlags == ROTATION_270) Res = GameServer()->Collision()->IntersectNoLaser(m_Pos,
|| (m_Target->m_TileIndexL == TILE_STOP Target->m_Pos, 0, 0);
&& m_Target->m_TileFlagsL == ROTATION_270) else
|| (m_Target->m_TileIndexL == TILE_STOPS Res = GameServer()->Collision()->IntersectNoLaserNW(m_Pos,
&& (m_Target->m_TileFlagsL == ROTATION_90 Target->m_Pos, 0, 0);
|| m_Target->m_TileFlagsL if (Res || length(m_Pos - Target->m_Pos) > 700)
== ROTATION_270)) {
|| (m_Target->m_TileIndexL == TILE_STOPA) Target = 0;
|| (m_Target->m_TileFIndex == TILE_STOP if (i == -1)
&& m_Target->m_TileFFlags == ROTATION_270) m_Target = 0;
|| (m_Target->m_TileFIndexL == TILE_STOP else
&& m_Target->m_TileFFlagsL == ROTATION_270) m_SoloEnts[i] = 0;
|| (m_Target->m_TileFIndexL == TILE_STOPS }
&& (m_Target->m_TileFFlagsL == ROTATION_90 else if (length(m_Pos - Target->m_Pos) > 28)
|| m_Target->m_TileFFlagsL {
== ROTATION_270)) vec2 Temp = Target->Core()->m_Vel
|| (m_Target->m_TileFIndexL == TILE_STOPA) + (normalize(m_Pos - Target->m_Pos) * m_Strength);
|| (m_Target->m_TileSIndex == TILE_STOP if (Temp.x > 0
&& m_Target->m_TileSFlags == ROTATION_270) && ((Target->m_TileIndex == TILE_STOP
|| (m_Target->m_TileSIndexL == TILE_STOP && Target->m_TileFlags == ROTATION_270)
&& m_Target->m_TileSFlagsL == ROTATION_270) || (Target->m_TileIndexL == TILE_STOP
|| (m_Target->m_TileSIndexL == TILE_STOPS && Target->m_TileFlagsL == ROTATION_270)
&& (m_Target->m_TileSFlagsL == ROTATION_90 || (Target->m_TileIndexL == TILE_STOPS
|| m_Target->m_TileSFlagsL && (Target->m_TileFlagsL == ROTATION_90
== ROTATION_270)) || Target->m_TileFlagsL
|| (m_Target->m_TileSIndexL == TILE_STOPA))) == ROTATION_270))
Temp.x = 0; || (Target->m_TileIndexL == TILE_STOPA)
if (Temp.x < 0 || (Target->m_TileFIndex == TILE_STOP
&& ((m_Target->m_TileIndex == TILE_STOP && Target->m_TileFFlags == ROTATION_270)
&& m_Target->m_TileFlags == ROTATION_90) || (Target->m_TileFIndexL == TILE_STOP
|| (m_Target->m_TileIndexR == TILE_STOP && Target->m_TileFFlagsL == ROTATION_270)
&& m_Target->m_TileFlagsR == ROTATION_90) || (Target->m_TileFIndexL == TILE_STOPS
|| (m_Target->m_TileIndexR == TILE_STOPS && (Target->m_TileFFlagsL == ROTATION_90
&& (m_Target->m_TileFlagsR == ROTATION_90 || Target->m_TileFFlagsL
|| m_Target->m_TileFlagsR == ROTATION_270))
== ROTATION_270)) || (Target->m_TileFIndexL == TILE_STOPA)
|| (m_Target->m_TileIndexR == TILE_STOPA) || (Target->m_TileSIndex == TILE_STOP
|| (m_Target->m_TileFIndex == TILE_STOP && Target->m_TileSFlags == ROTATION_270)
&& m_Target->m_TileFFlags == ROTATION_90) || (Target->m_TileSIndexL == TILE_STOP
|| (m_Target->m_TileFIndexR == TILE_STOP && Target->m_TileSFlagsL == ROTATION_270)
&& m_Target->m_TileFFlagsR == ROTATION_90) || (Target->m_TileSIndexL == TILE_STOPS
|| (m_Target->m_TileFIndexR == TILE_STOPS && (Target->m_TileSFlagsL == ROTATION_90
&& (m_Target->m_TileFFlagsR == ROTATION_90 || Target->m_TileSFlagsL
|| m_Target->m_TileFFlagsR == ROTATION_270))
== ROTATION_270)) || (Target->m_TileSIndexL == TILE_STOPA)))
|| (m_Target->m_TileFIndexR == TILE_STOPA) Temp.x = 0;
|| (m_Target->m_TileSIndex == TILE_STOP if (Temp.x < 0
&& m_Target->m_TileSFlags == ROTATION_90) && ((Target->m_TileIndex == TILE_STOP
|| (m_Target->m_TileSIndexR == TILE_STOP && Target->m_TileFlags == ROTATION_90)
&& m_Target->m_TileSFlagsR == ROTATION_90) || (Target->m_TileIndexR == TILE_STOP
|| (m_Target->m_TileSIndexR == TILE_STOPS && Target->m_TileFlagsR == ROTATION_90)
&& (m_Target->m_TileSFlagsR == ROTATION_90 || (Target->m_TileIndexR == TILE_STOPS
|| m_Target->m_TileSFlagsR && (Target->m_TileFlagsR == ROTATION_90
== ROTATION_270)) || Target->m_TileFlagsR
|| (m_Target->m_TileSIndexR == TILE_STOPA))) == ROTATION_270))
Temp.x = 0; || (Target->m_TileIndexR == TILE_STOPA)
if (Temp.y < 0 || (Target->m_TileFIndex == TILE_STOP
&& ((m_Target->m_TileIndex == TILE_STOP && Target->m_TileFFlags == ROTATION_90)
&& m_Target->m_TileFlags == ROTATION_180) || (Target->m_TileFIndexR == TILE_STOP
|| (m_Target->m_TileIndexB == TILE_STOP && Target->m_TileFFlagsR == ROTATION_90)
&& m_Target->m_TileFlagsB == ROTATION_180) || (Target->m_TileFIndexR == TILE_STOPS
|| (m_Target->m_TileIndexB == TILE_STOPS && (Target->m_TileFFlagsR == ROTATION_90
&& (m_Target->m_TileFlagsB == ROTATION_0 || Target->m_TileFFlagsR
|| m_Target->m_TileFlagsB == ROTATION_270))
== ROTATION_180)) || (Target->m_TileFIndexR == TILE_STOPA)
|| (m_Target->m_TileIndexB == TILE_STOPA) || (Target->m_TileSIndex == TILE_STOP
|| (m_Target->m_TileFIndex == TILE_STOP && Target->m_TileSFlags == ROTATION_90)
&& m_Target->m_TileFFlags == ROTATION_180) || (Target->m_TileSIndexR == TILE_STOP
|| (m_Target->m_TileFIndexB == TILE_STOP && Target->m_TileSFlagsR == ROTATION_90)
&& m_Target->m_TileFFlagsB == ROTATION_180) || (Target->m_TileSIndexR == TILE_STOPS
|| (m_Target->m_TileFIndexB == TILE_STOPS && (Target->m_TileSFlagsR == ROTATION_90
&& (m_Target->m_TileFFlagsB == ROTATION_0 || Target->m_TileSFlagsR
|| m_Target->m_TileFFlagsB == ROTATION_270))
== ROTATION_180)) || (Target->m_TileSIndexR == TILE_STOPA)))
|| (m_Target->m_TileFIndexB == TILE_STOPA) Temp.x = 0;
|| (m_Target->m_TileSIndex == TILE_STOP if (Temp.y < 0
&& m_Target->m_TileSFlags == ROTATION_180) && ((Target->m_TileIndex == TILE_STOP
|| (m_Target->m_TileSIndexB == TILE_STOP && Target->m_TileFlags == ROTATION_180)
&& m_Target->m_TileSFlagsB == ROTATION_180) || (Target->m_TileIndexB == TILE_STOP
|| (m_Target->m_TileSIndexB == TILE_STOPS && Target->m_TileFlagsB == ROTATION_180)
&& (m_Target->m_TileSFlagsB == ROTATION_0 || (Target->m_TileIndexB == TILE_STOPS
|| m_Target->m_TileSFlagsB && (Target->m_TileFlagsB == ROTATION_0
== ROTATION_180)) || Target->m_TileFlagsB
|| (m_Target->m_TileSIndexB == TILE_STOPA))) == ROTATION_180))
Temp.y = 0; || (Target->m_TileIndexB == TILE_STOPA)
if (Temp.y > 0 || (Target->m_TileFIndex == TILE_STOP
&& ((m_Target->m_TileIndex == TILE_STOP && Target->m_TileFFlags == ROTATION_180)
&& m_Target->m_TileFlags == ROTATION_0) || (Target->m_TileFIndexB == TILE_STOP
|| (m_Target->m_TileIndexT == TILE_STOP && Target->m_TileFFlagsB == ROTATION_180)
&& m_Target->m_TileFlagsT == ROTATION_0) || (Target->m_TileFIndexB == TILE_STOPS
|| (m_Target->m_TileIndexT == TILE_STOPS && (Target->m_TileFFlagsB == ROTATION_0
&& (m_Target->m_TileFlagsT == ROTATION_0 || Target->m_TileFFlagsB
|| m_Target->m_TileFlagsT == ROTATION_180))
== ROTATION_180)) || (Target->m_TileFIndexB == TILE_STOPA)
|| (m_Target->m_TileIndexT == TILE_STOPA) || (Target->m_TileSIndex == TILE_STOP
|| (m_Target->m_TileFIndex == TILE_STOP && Target->m_TileSFlags == ROTATION_180)
&& m_Target->m_TileFFlags == ROTATION_0) || (Target->m_TileSIndexB == TILE_STOP
|| (m_Target->m_TileFIndexT == TILE_STOP && Target->m_TileSFlagsB == ROTATION_180)
&& m_Target->m_TileFFlagsT == ROTATION_0) || (Target->m_TileSIndexB == TILE_STOPS
|| (m_Target->m_TileFIndexT == TILE_STOPS && (Target->m_TileSFlagsB == ROTATION_0
&& (m_Target->m_TileFFlagsT == ROTATION_0 || Target->m_TileSFlagsB
|| m_Target->m_TileFFlagsT == ROTATION_180))
== ROTATION_180)) || (Target->m_TileSIndexB == TILE_STOPA)))
|| (m_Target->m_TileFIndexT == TILE_STOPA) Temp.y = 0;
|| (m_Target->m_TileSIndex == TILE_STOP if (Temp.y > 0
&& m_Target->m_TileSFlags == ROTATION_0) && ((Target->m_TileIndex == TILE_STOP
|| (m_Target->m_TileSIndexT == TILE_STOP && Target->m_TileFlags == ROTATION_0)
&& m_Target->m_TileSFlagsT == ROTATION_0) || (Target->m_TileIndexT == TILE_STOP
|| (m_Target->m_TileSIndexT == TILE_STOPS && Target->m_TileFlagsT == ROTATION_0)
&& (m_Target->m_TileSFlagsT == ROTATION_0 || (Target->m_TileIndexT == TILE_STOPS
|| m_Target->m_TileSFlagsT && (Target->m_TileFlagsT == ROTATION_0
== ROTATION_180)) || Target->m_TileFlagsT
|| (m_Target->m_TileSIndexT == TILE_STOPA))) == ROTATION_180))
Temp.y = 0; || (Target->m_TileIndexT == TILE_STOPA)
m_Target->Core()->m_Vel = Temp; || (Target->m_TileFIndex == TILE_STOP
&& Target->m_TileFFlags == ROTATION_0)
|| (Target->m_TileFIndexT == TILE_STOP
&& Target->m_TileFFlagsT == ROTATION_0)
|| (Target->m_TileFIndexT == TILE_STOPS
&& (Target->m_TileFFlagsT == ROTATION_0
|| Target->m_TileFFlagsT
== ROTATION_180))
|| (Target->m_TileFIndexT == TILE_STOPA)
|| (Target->m_TileSIndex == TILE_STOP
&& Target->m_TileSFlags == ROTATION_0)
|| (Target->m_TileSIndexT == TILE_STOP
&& Target->m_TileSFlagsT == ROTATION_0)
|| (Target->m_TileSIndexT == TILE_STOPS
&& (Target->m_TileSFlagsT == ROTATION_0
|| Target->m_TileSFlagsT
== ROTATION_180))
|| (Target->m_TileSIndexT == TILE_STOPA)))
Temp.y = 0;
Target->Core()->m_Vel = Temp;
}
} }
} }
} }
@ -238,63 +280,99 @@ void CDragger::Snap(int SnappingClient)
if (((CGameControllerDDRace*) GameServer()->m_pController)->m_Teams.GetTeamState( if (((CGameControllerDDRace*) GameServer()->m_pController)->m_Teams.GetTeamState(
m_CatchedTeam) == CGameTeams::TEAMSTATE_EMPTY) m_CatchedTeam) == CGameTeams::TEAMSTATE_EMPTY)
return; return;
if (m_Target)
CCharacter *Target= m_Target;
for (int i = 0; i < MAX_CLIENTS; i++)
{ {
if (NetworkClipped(SnappingClient, m_Pos) if (m_SoloIDs[i] == -1)
&& NetworkClipped(SnappingClient, m_Target->m_Pos)) break;
Server()->SnapFreeID(m_SoloIDs[i]);
m_SoloIDs[i] = -1;
}
int pos = 0;
for (int i = -1; i < MAX_CLIENTS; i++)
{
if (i >= 0)
Target = m_SoloEnts[i];
if (!Target)
continue;
if (Target)
{
if (NetworkClipped(SnappingClient, m_Pos)
&& NetworkClipped(SnappingClient, Target->m_Pos))
return;
}
else if (NetworkClipped(SnappingClient, m_Pos))
return; return;
}
else if (NetworkClipped(SnappingClient, m_Pos))
return;
CCharacter * Char = GameServer()->GetPlayerChar(SnappingClient); CCharacter * Char = GameServer()->GetPlayerChar(SnappingClient);
if((GameServer()->m_apPlayers[SnappingClient]->GetTeam() == -1 if((GameServer()->m_apPlayers[SnappingClient]->GetTeam() == -1
|| GameServer()->m_apPlayers[SnappingClient]->m_Paused) || GameServer()->m_apPlayers[SnappingClient]->m_Paused)
&& GameServer()->m_apPlayers[SnappingClient]->m_SpectatorID != SPEC_FREEVIEW) && GameServer()->m_apPlayers[SnappingClient]->m_SpectatorID != SPEC_FREEVIEW)
Char = GameServer()->GetPlayerChar(GameServer()->m_apPlayers[SnappingClient]->m_SpectatorID); Char = GameServer()->GetPlayerChar(GameServer()->m_apPlayers[SnappingClient]->m_SpectatorID);
int Tick = (Server()->Tick() % Server()->TickSpeed()) % 11; int Tick = (Server()->Tick() % Server()->TickSpeed()) % 11;
if (Char && Char->IsAlive() if (Char && Char->IsAlive()
&& (m_Layer == LAYER_SWITCH && (m_Layer == LAYER_SWITCH
&& !GameServer()->Collision()->m_pSwitchers[m_Number].m_Status[Char->Team()] && !GameServer()->Collision()->m_pSwitchers[m_Number].m_Status[Char->Team()]
&& (!Tick))) && (!Tick)))
return;
if (Char && Char->IsAlive())
{
if (Char->Team() != m_CatchedTeam)
return; return;
} if (Char && Char->IsAlive())
else {
{ if (Char->Team() != m_CatchedTeam)
// send to spectators only active draggers and some inactive from team 0 return;
if (!((m_Target && m_Target->IsAlive()) || m_CatchedTeam == 0)) }
else
{
// send to spectators only active draggers and some inactive from team 0
if (!((Target && Target->IsAlive()) || m_CatchedTeam == 0))
return;
}
CNetObj_Laser *obj;
if (i == -1)
{
obj = static_cast<CNetObj_Laser *>(Server()->SnapNewItem(
NETOBJTYPE_LASER, m_ID, sizeof(CNetObj_Laser)));
}
else
{
m_SoloIDs[pos] = Server()->SnapNewID();
obj = static_cast<CNetObj_Laser *>(Server()->SnapNewItem( // TODO: Have to free IDs again?
NETOBJTYPE_LASER, m_SoloIDs[pos], sizeof(CNetObj_Laser)));
pos++;
}
if (!obj)
return; return;
} obj->m_X = (int) m_Pos.x;
obj->m_Y = (int) m_Pos.y;
if (Target)
{
obj->m_FromX = (int) Target->m_Pos.x;
obj->m_FromY = (int) Target->m_Pos.y;
}
else
{
obj->m_FromX = (int) m_Pos.x;
obj->m_FromY = (int) m_Pos.y;
}
CNetObj_Laser *obj = static_cast<CNetObj_Laser *>(Server()->SnapNewItem( int StartTick = m_EvalTick;
NETOBJTYPE_LASER, m_ID, sizeof(CNetObj_Laser))); if (StartTick < Server()->Tick() - 4)
if (!obj) StartTick = Server()->Tick() - 4;
return; else if (StartTick > Server()->Tick())
obj->m_X = (int) m_Pos.x; StartTick = Server()->Tick();
obj->m_Y = (int) m_Pos.y; obj->m_StartTick = StartTick;
if (m_Target)
{
obj->m_FromX = (int) m_Target->m_Pos.x;
obj->m_FromY = (int) m_Target->m_Pos.y;
} }
else
{
obj->m_FromX = (int) m_Pos.x;
obj->m_FromY = (int) m_Pos.y;
}
int StartTick = m_EvalTick;
if (StartTick < Server()->Tick() - 4)
StartTick = Server()->Tick() - 4;
else if (StartTick > Server()->Tick())
StartTick = Server()->Tick();
obj->m_StartTick = StartTick;
} }
CDraggerTeam::CDraggerTeam(CGameWorld *pGameWorld, vec2 Pos, float Strength, CDraggerTeam::CDraggerTeam(CGameWorld *pGameWorld, vec2 Pos, float Strength,

3
src/game/server/entities/dragger.h
View file

@ -15,6 +15,9 @@ class CDragger: public CEntity
CCharacter * m_Target; CCharacter * m_Target;
bool m_NW; bool m_NW;
int m_CatchedTeam; int m_CatchedTeam;
CCharacter * m_SoloEnts[MAX_CLIENTS];
int m_SoloIDs[MAX_CLIENTS];
public: public:
CDragger(CGameWorld *pGameWorld, vec2 Pos, float Strength, bool NW, CDragger(CGameWorld *pGameWorld, vec2 Pos, float Strength, bool NW,

18
src/game/server/entities/gun.cpp
View file

@ -3,6 +3,8 @@
#include <engine/shared/config.h> #include <engine/shared/config.h>
#include <game/generated/protocol.h> #include <game/generated/protocol.h>
#include <game/server/gamecontext.h> #include <game/server/gamecontext.h>
#include <game/server/teams.h>
#include "gun.h" #include "gun.h"
#include "plasma.h" #include "plasma.h"
@ -66,6 +68,22 @@ void CGun::Fire()
m_LastFire = Server()->Tick(); m_LastFire = Server()->Tick();
} }
} }
for (int i = 0; i < Num; i++)
{
CCharacter *Target = Ents[i];
if (Target->Teams()->m_Core.GetSolo(Target->GetPlayer()->GetCID()))
{
if (IdInTeam[Target->Team()] != i)
{
int res = GameServer()->Collision()->IntersectLine(m_Pos, Target->m_Pos,0,0,false);
if (!res)
{
new CPlasma(&GameServer()->m_World, m_Pos, normalize(Target->m_Pos - m_Pos), m_Freeze, m_Explosive, Target->Team());
m_LastFire = Server()->Tick();
}
}
}
}
} }