void AlienBuildableComponent::HandleDamage(float amount, gentity_t* source, Util::optional<Vec3> location,
Util::optional<Vec3> direction, int flags, meansOfDeath_t meansOfDeath) {
if (GetBuildableComponent().GetState() != BuildableComponent::CONSTRUCTED) return;
// TODO: Move animation code to BuildableComponent.
G_SetBuildableAnim(entity.oldEnt, BANIM_PAIN1, false);
}
void BuildableComponent::SetPowerState(bool powered) {
// TODO: Make power state a member variable.
bool wasPowered = entity.oldEnt->powered;
entity.oldEnt->powered = powered;
if ( powered && !wasPowered) {
G_SetBuildableAnim(entity.oldEnt, BANIM_POWERUP, false);
G_SetIdleBuildableAnim(entity.oldEnt, BANIM_IDLE1);
entity.PowerUp();
} else if (!powered && wasPowered) {
G_SetBuildableAnim(entity.oldEnt, BANIM_POWERDOWN, false);
G_SetIdleBuildableAnim(entity.oldEnt, BANIM_IDLE_UNPOWERED);
entity.PowerDown();
}
}
void TurretComponent::HandleDie(gentity_t* killer, meansOfDeath_t meansOfDeath) {
if (entity.oldEnt->target) entity.oldEnt->target->numTrackedBy--;
// TODO: This assumes HumanBuildableComponent's HandleDie is called first, validate this.
if (entity.Get<BuildableComponent>()->GetState() == BuildableComponent::PRE_BLAST) {
// Rocketpod: The safe mode has the same idle as the unpowered state.
// TODO: Move to RocketPodComponent.
if (entity.oldEnt->turretSafeMode) {
// TODO: Move animation code to BuildableComponent.
G_SetBuildableAnim(entity.oldEnt, BANIM_DESTROY_UNPOWERED, true);
}
// Do some last movements before entering blast state.
entity.oldEnt->think = HTurret_PreBlast;
entity.oldEnt->nextthink = level.time;
}
}
void BuildableComponent::HandleDie(gentity_t* killer, meansOfDeath_t meansOfDeath) {
// Note that this->state is adjusted in (Alien|Human)BuildableComponent::HandleDie so they have
// access to its current value.
TeamComponent::team_t team = GetTeamComponent().Team();
// TODO: Move animation code to BuildableComponent.
G_SetBuildableAnim(entity.oldEnt, Powered() ? BANIM_DESTROY : BANIM_DESTROY_UNPOWERED, true);
G_SetIdleBuildableAnim(entity.oldEnt, BANIM_DESTROYED);
entity.oldEnt->killedBy = killer->s.number;
G_LogDestruction(entity.oldEnt, killer, meansOfDeath);
// TODO: Handle in TaggableComponent.
Beacon::DetachTags(entity.oldEnt);
// Report an attack to the defending team if the buildable was powered and there is a main
// buildable that can report it. Note that the main buildables itself issues its own warnings.
if (Powered() && entity.Get<MainBuildableComponent>() == nullptr &&
G_IsWarnableMOD(meansOfDeath) && G_ActiveMainBuildable(team)) {
// Get a nearby location entity.
gentity_t *location = GetCloseLocationEntity(entity.oldEnt);
// Fall back to fake location entity if necessary.
if (!location) location = level.fakeLocation;
// Warn if there was no warning for this location recently.
if (level.time > location->warnTimer) {
bool inBase = G_InsideBase(entity.oldEnt);
G_BroadcastEvent(EV_WARN_ATTACK, inBase ? 0 : location->s.number, team);
Beacon::NewArea(BCT_DEFEND, entity.oldEnt->s.origin, team);
location->warnTimer = level.time + ATTACKWARN_NEARBY_PERIOD;
}
}
// If not deconstructed, add all build points to queue.
if (meansOfDeath != MOD_DECONSTRUCT && meansOfDeath != MOD_REPLACE) {
G_FreeBudget(team, 0, BG_Buildable(entity.oldEnt->s.modelindex)->buildPoints);
}
}
void SpawnerComponent::Think(int timeDelta) {
BuildableComponent *buildableComponent = entity.Get<BuildableComponent>();
if (buildableComponent && !buildableComponent->Active()) return;
Entity* blocker = GetBlocker();
if (blocker) {
if (!blocker->oldEnt) {
logger.Warn("Spawn blocking entity has oldEnt == nullptr");
return;
}
// Suicide if blocked by the map.
if (blocker->oldEnt->s.number == ENTITYNUM_WORLD
|| blocker->oldEnt->s.eType == entityType_t::ET_MOVER) {
Entities::Kill(entity, nullptr, MOD_SUICIDE);
}
// Free a blocking corpse.
else if (blocker->oldEnt->s.eType == entityType_t::ET_CORPSE) {
G_FreeEntity(blocker->oldEnt);
}
else if (Entities::OnSameTeam(entity, *blocker)) {
// Suicide if blocked by own main buildable.
if (blocker->Get<MainBuildableComponent>()) {
Entities::Kill(entity, nullptr, MOD_SUICIDE);
}
// Kill a friendly blocking buildable.
else if (blocker->Get<BuildableComponent>()) {
Entities::Kill(*blocker, nullptr, MOD_SUICIDE);
// Play an animation so it's clear what destroyed the buildable.
G_SetBuildableAnim(entity.oldEnt, BANIM_SPAWN1, true);
}
// Do periodic damage to a friendly client.
// TODO: Externalize constants.
else if (blocker->Get<ClientComponent>() && g_antiSpawnBlock.integer) {
blockTime += timeDelta;
if (blockTime > BLOCKER_GRACE_PERIOD
&& blockTime - timeDelta <= BLOCKER_GRACE_PERIOD) {
WarnBlocker(*blocker, false);
}
if (blockTime > BLOCKER_GRACE_PERIOD + BLOCKER_WARN_PERIOD) {
if (blockTime - timeDelta <= BLOCKER_GRACE_PERIOD + BLOCKER_WARN_PERIOD) {
WarnBlocker(*blocker, true);
}
blocker->Damage(
BLOCKER_DAMAGE * ((float)timeDelta / 1000.0f), entity.oldEnt, {}, {},
DAMAGE_PURE, MOD_TRIGGER_HURT
);
}
}
}
} else if (g_antiSpawnBlock.integer) {
blockTime = Math::Clamp(blockTime - timeDelta, 0, BLOCKER_GRACE_PERIOD);
}
}
/*
===========
ClientSpawn
Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn
Initializes all non-persistant parts of playerState
============
*/
void ClientSpawn( gentity_t *ent, gentity_t *spawn, vec3_t origin, vec3_t angles )
{
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
int i;
clientPersistant_t saved;
clientSession_t savedSess;
int persistant[ MAX_PERSISTANT ];
gentity_t *spawnPoint = NULL;
int flags;
int savedPing;
int teamLocal;
int eventSequence;
char userinfo[ MAX_INFO_STRING ];
vec3_t up = { 0.0f, 0.0f, 1.0f };
int maxAmmo, maxClips;
weapon_t weapon;
index = ent - g_entities;
client = ent->client;
teamLocal = client->pers.teamSelection;
//if client is dead and following teammate, stop following before spawning
if( client->sess.spectatorClient != -1 )
{
client->sess.spectatorClient = -1;
client->sess.spectatorState = SPECTATOR_FREE;
}
// only start client if chosen a class and joined a team
if( client->pers.classSelection == PCL_NONE && teamLocal == TEAM_NONE )
client->sess.spectatorState = SPECTATOR_FREE;
else if( client->pers.classSelection == PCL_NONE )
client->sess.spectatorState = SPECTATOR_LOCKED;
// if client is dead and following teammate, stop following before spawning
if( ent->client->sess.spectatorState == SPECTATOR_FOLLOW )
G_StopFollowing( ent );
if( origin != NULL )
VectorCopy( origin, spawn_origin );
if( angles != NULL )
VectorCopy( angles, spawn_angles );
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if( client->sess.spectatorState != SPECTATOR_NOT )
{
if( teamLocal == TEAM_NONE )
spawnPoint = G_SelectSpectatorSpawnPoint( spawn_origin, spawn_angles );
else if( teamLocal == TEAM_ALIENS )
spawnPoint = G_SelectAlienLockSpawnPoint( spawn_origin, spawn_angles );
else if( teamLocal == TEAM_HUMANS )
spawnPoint = G_SelectHumanLockSpawnPoint( spawn_origin, spawn_angles );
}
else
{
if( spawn == NULL )
{
G_Error( "ClientSpawn: spawn is NULL\n" );
return;
}
spawnPoint = spawn;
if( ent != spawn )
{
//start spawn animation on spawnPoint
G_SetBuildableAnim( spawnPoint, BANIM_SPAWN1, qtrue );
if( spawnPoint->buildableTeam == TEAM_ALIENS )
spawnPoint->clientSpawnTime = ALIEN_SPAWN_REPEAT_TIME;
else if( spawnPoint->buildableTeam == TEAM_HUMANS )
spawnPoint->clientSpawnTime = HUMAN_SPAWN_REPEAT_TIME;
}
}
// toggle the teleport bit so the client knows to not lerp
flags = ( ent->client->ps.eFlags & EF_TELEPORT_BIT ) ^ EF_TELEPORT_BIT;
G_UnlaggedClear( ent );
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
for( i = 0; i < MAX_PERSISTANT; i++ )
persistant[ i ] = client->ps.persistant[ i ];
eventSequence = client->ps.eventSequence;
memset( client, 0, sizeof( *client ) );
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
client->lastkilled_client = -1;
for( i = 0; i < MAX_PERSISTANT; i++ )
client->ps.persistant[ i ] = persistant[ i ];
client->ps.eventSequence = eventSequence;
// increment the spawncount so the client will detect the respawn
client->ps.persistant[ PERS_SPAWN_COUNT ]++;
client->ps.persistant[ PERS_SPECSTATE ] = client->sess.spectatorState;
client->airOutTime = level.time + 12000;
trap_GetUserinfo( index, userinfo, sizeof( userinfo ) );
client->ps.eFlags = flags;
//Com_Printf( "ent->client->pers->pclass = %i\n", ent->client->pers.classSelection );
ent->s.groundEntityNum = ENTITYNUM_NONE;
ent->client = &level.clients[ index ];
ent->takedamage = qtrue;
ent->inuse = qtrue;
ent->classname = "player";
ent->r.contents = CONTENTS_BODY;
ent->clipmask = MASK_PLAYERSOLID;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags = 0;
// calculate each client's acceleration
ent->evaluateAcceleration = qtrue;
client->ps.stats[ STAT_MISC ] = 0;
client->ps.eFlags = flags;
client->ps.clientNum = index;
BG_ClassBoundingBox( ent->client->pers.classSelection, ent->r.mins, ent->r.maxs, NULL, NULL, NULL );
if( client->sess.spectatorState == SPECTATOR_NOT )
client->ps.stats[ STAT_MAX_HEALTH ] =
BG_Class( ent->client->pers.classSelection )->health;
else
client->ps.stats[ STAT_MAX_HEALTH ] = 100;
// clear entity values
if( ent->client->pers.classSelection == PCL_HUMAN )
{
BG_AddUpgradeToInventory( UP_MEDKIT, client->ps.stats );
weapon = client->pers.humanItemSelection;
}
else if( client->sess.spectatorState == SPECTATOR_NOT )
weapon = BG_Class( ent->client->pers.classSelection )->startWeapon;
else
weapon = WP_NONE;
maxAmmo = BG_Weapon( weapon )->maxAmmo;
maxClips = BG_Weapon( weapon )->maxClips;
client->ps.stats[ STAT_WEAPON ] = weapon;
client->ps.ammo = maxAmmo;
client->ps.clips = maxClips;
// We just spawned, not changing weapons
client->ps.persistant[ PERS_NEWWEAPON ] = 0;
ent->client->ps.stats[ STAT_CLASS ] = ent->client->pers.classSelection;
ent->client->ps.stats[ STAT_TEAM ] = ent->client->pers.teamSelection;
ent->client->ps.stats[ STAT_BUILDABLE ] = BA_NONE;
ent->client->ps.stats[ STAT_STATE ] = 0;
VectorSet( ent->client->ps.grapplePoint, 0.0f, 0.0f, 1.0f );
// health will count down towards max_health
ent->health = client->ps.stats[ STAT_HEALTH ] = client->ps.stats[ STAT_MAX_HEALTH ]; //* 1.25;
//if evolving scale health
if( ent == spawn )
{
ent->health *= ent->client->pers.evolveHealthFraction;
client->ps.stats[ STAT_HEALTH ] *= ent->client->pers.evolveHealthFraction;
}
//clear the credits array
for( i = 0; i < MAX_CLIENTS; i++ )
ent->credits[ i ] = 0;
client->ps.stats[ STAT_STAMINA ] = STAMINA_MAX;
G_SetOrigin( ent, spawn_origin );
VectorCopy( spawn_origin, client->ps.origin );
#define UP_VEL 150.0f
#define F_VEL 50.0f
//give aliens some spawn velocity
if( client->sess.spectatorState == SPECTATOR_NOT &&
client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
if( ent == spawn )
{
//evolution particle system
G_AddPredictableEvent( ent, EV_ALIEN_EVOLVE, DirToByte( up ) );
}
else
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
if( spawnPoint->s.origin2[ 2 ] > 0.0f )
{
vec3_t forward, dir;
AngleVectors( spawn_angles, forward, NULL, NULL );
VectorScale( forward, F_VEL, forward );
VectorAdd( spawnPoint->s.origin2, forward, dir );
VectorNormalize( dir );
VectorScale( dir, UP_VEL, client->ps.velocity );
}
G_AddPredictableEvent( ent, EV_PLAYER_RESPAWN, 0 );
}
}
else if( client->sess.spectatorState == SPECTATOR_NOT &&
client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
}
// the respawned flag will be cleared after the attack and jump keys come up
client->ps.pm_flags |= PMF_RESPAWNED;
trap_GetUsercmd( client - level.clients, &ent->client->pers.cmd );
G_SetClientViewAngle( ent, spawn_angles );
if( client->sess.spectatorState == SPECTATOR_NOT )
{
trap_LinkEntity( ent );
// force the base weapon up
if( client->pers.teamSelection == TEAM_HUMANS )
G_ForceWeaponChange( ent, weapon );
client->ps.weaponstate = WEAPON_READY;
}
// don't allow full run speed for a bit
client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
client->ps.pm_time = 100;
client->respawnTime = level.time;
ent->nextRegenTime = level.time;
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
// set default animations
client->ps.torsoAnim = TORSO_STAND;
client->ps.legsAnim = LEGS_IDLE;
if( level.intermissiontime )
MoveClientToIntermission( ent );
else
{
// fire the targets of the spawn point
if( !spawn )
G_UseTargets( spawnPoint, ent );
client->ps.weapon = client->ps.stats[ STAT_WEAPON ];
}
// run a client frame to drop exactly to the floor,
// initialize animations and other things
client->ps.commandTime = level.time - 100;
ent->client->pers.cmd.serverTime = level.time;
ClientThink( ent-g_entities );
// positively link the client, even if the command times are weird
if( client->sess.spectatorState == SPECTATOR_NOT )
{
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
trap_LinkEntity( ent );
}
// must do this here so the number of active clients is calculated
CalculateRanks( );
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
client->pers.infoChangeTime = level.time;
}
/*
===========
ClientSpawn
Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn and evolve
Initializes all non-persistent parts of playerState
============
*/
void ClientSpawn( gentity_t *ent, gentity_t *spawn, const vec3_t origin, const vec3_t angles )
{
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
int i;
clientPersistant_t saved;
clientSession_t savedSess;
bool savedNoclip, savedCliprcontents;
int persistant[ MAX_PERSISTANT ];
gentity_t *spawnPoint = nullptr;
int flags;
int savedPing;
int teamLocal;
int eventSequence;
char userinfo[ MAX_INFO_STRING ];
vec3_t up = { 0.0f, 0.0f, 1.0f };
int maxAmmo, maxClips;
weapon_t weapon;
ClientSpawnCBSE(ent, ent == spawn);
index = ent - g_entities;
client = ent->client;
teamLocal = client->pers.team;
//if client is dead and following teammate, stop following before spawning
if ( client->sess.spectatorClient != -1 )
{
client->sess.spectatorClient = -1;
client->sess.spectatorState = SPECTATOR_FREE;
}
// only start client if chosen a class and joined a team
if ( client->pers.classSelection == PCL_NONE && teamLocal == TEAM_NONE )
{
client->sess.spectatorState = SPECTATOR_FREE;
}
else if ( client->pers.classSelection == PCL_NONE )
{
client->sess.spectatorState = SPECTATOR_LOCKED;
}
// if client is dead and following teammate, stop following before spawning
if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW )
{
G_StopFollowing( ent );
}
if ( origin != nullptr )
{
VectorCopy( origin, spawn_origin );
}
if ( angles != nullptr )
{
VectorCopy( angles, spawn_angles );
}
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if ( client->sess.spectatorState != SPECTATOR_NOT )
{
if ( teamLocal == TEAM_NONE )
{
spawnPoint = G_SelectSpectatorSpawnPoint( spawn_origin, spawn_angles );
}
else if ( teamLocal == TEAM_ALIENS )
{
spawnPoint = G_SelectAlienLockSpawnPoint( spawn_origin, spawn_angles );
}
else if ( teamLocal == TEAM_HUMANS )
{
spawnPoint = G_SelectHumanLockSpawnPoint( spawn_origin, spawn_angles );
}
}
else
{
if ( spawn == nullptr )
{
Com_Error(errorParm_t::ERR_DROP, "ClientSpawn: spawn is NULL" );
}
spawnPoint = spawn;
if ( spawnPoint->s.eType == entityType_t::ET_BUILDABLE )
{
G_SetBuildableAnim( spawnPoint, BANIM_SPAWN1, true );
if ( spawnPoint->buildableTeam == TEAM_ALIENS )
{
spawnPoint->clientSpawnTime = ALIEN_SPAWN_REPEAT_TIME;
}
else if ( spawnPoint->buildableTeam == TEAM_HUMANS )
{
spawnPoint->clientSpawnTime = HUMAN_SPAWN_REPEAT_TIME;
}
}
}
// toggle the teleport bit so the client knows to not lerp
flags = ( ent->client->ps.eFlags & EF_TELEPORT_BIT ) ^ EF_TELEPORT_BIT;
G_UnlaggedClear( ent );
// clear everything but the persistent data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
savedNoclip = client->noclip;
savedCliprcontents = client->cliprcontents;
for ( i = 0; i < MAX_PERSISTANT; i++ )
{
persistant[ i ] = client->ps.persistant[ i ];
}
eventSequence = client->ps.eventSequence;
memset( client, 0, sizeof( *client ) );
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
client->noclip = savedNoclip;
client->cliprcontents = savedCliprcontents;
for ( i = 0; i < MAX_PERSISTANT; i++ )
{
client->ps.persistant[ i ] = persistant[ i ];
}
client->ps.eventSequence = eventSequence;
// increment the spawncount so the client will detect the respawn
client->ps.persistant[ PERS_SPAWN_COUNT ]++;
client->ps.persistant[ PERS_SPECSTATE ] = client->sess.spectatorState;
client->airOutTime = level.time + 12000;
trap_GetUserinfo( index, userinfo, sizeof( userinfo ) );
client->ps.eFlags = flags;
//Log::Notice( "ent->client->pers->pclass = %i\n", ent->client->pers.classSelection );
ent->s.groundEntityNum = ENTITYNUM_NONE;
ent->client = &level.clients[ index ];
ent->classname = S_PLAYER_CLASSNAME;
if ( client->noclip )
{
client->cliprcontents = CONTENTS_BODY;
}
else
{
ent->r.contents = CONTENTS_BODY;
}
ent->clipmask = MASK_PLAYERSOLID;
ent->die = G_PlayerDie;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags &= FL_GODMODE | FL_NOTARGET;
// calculate each client's acceleration
ent->evaluateAcceleration = true;
client->ps.stats[ STAT_MISC ] = 0;
client->ps.eFlags = flags;
client->ps.clientNum = index;
BG_ClassBoundingBox( ent->client->pers.classSelection, ent->r.mins, ent->r.maxs, nullptr, nullptr, nullptr );
// clear entity values
if ( ent->client->pers.classSelection == PCL_HUMAN_NAKED )
{
BG_AddUpgradeToInventory( UP_MEDKIT, client->ps.stats );
weapon = client->pers.humanItemSelection;
}
else if ( client->sess.spectatorState == SPECTATOR_NOT )
{
weapon = BG_Class( ent->client->pers.classSelection )->startWeapon;
}
else
{
weapon = WP_NONE;
}
maxAmmo = BG_Weapon( weapon )->maxAmmo;
maxClips = BG_Weapon( weapon )->maxClips;
client->ps.stats[ STAT_WEAPON ] = weapon;
client->ps.ammo = maxAmmo;
client->ps.clips = maxClips;
// We just spawned, not changing weapons
client->ps.persistant[ PERS_NEWWEAPON ] = 0;
client->ps.persistant[ PERS_TEAM ] = client->pers.team;
// TODO: Check whether stats can be cleared at once instead of per field
client->ps.stats[ STAT_STAMINA ] = STAMINA_MAX;
client->ps.stats[ STAT_FUEL ] = JETPACK_FUEL_MAX;
client->ps.stats[ STAT_CLASS ] = ent->client->pers.classSelection;
client->ps.stats[ STAT_BUILDABLE ] = BA_NONE;
client->ps.stats[ STAT_PREDICTION ] = 0;
client->ps.stats[ STAT_STATE ] = 0;
VectorSet( client->ps.grapplePoint, 0.0f, 0.0f, 1.0f );
//clear the credits array
// TODO: Handle in HealthComponent or ClientComponent.
for ( i = 0; i < MAX_CLIENTS; i++ )
{
ent->credits[ i ].value = 0.0f;
ent->credits[ i ].time = 0;
ent->credits[ i ].team = TEAM_NONE;
}
G_SetOrigin( ent, spawn_origin );
VectorCopy( spawn_origin, client->ps.origin );
//give aliens some spawn velocity
if ( client->sess.spectatorState == SPECTATOR_NOT &&
client->pers.team == TEAM_ALIENS )
{
if ( ent == spawn )
{
//evolution particle system
G_AddPredictableEvent( ent, EV_ALIEN_EVOLVE, DirToByte( up ) );
}
else
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
if ( spawnPoint->s.origin2[ 2 ] > 0.0f )
{
vec3_t forward, dir;
AngleVectors( spawn_angles, forward, nullptr, nullptr );
VectorAdd( spawnPoint->s.origin2, forward, dir );
VectorNormalize( dir );
VectorScale( dir, BG_Class( ent->client->pers.classSelection )->jumpMagnitude,
client->ps.velocity );
}
G_AddPredictableEvent( ent, EV_PLAYER_RESPAWN, 0 );
}
}
else if ( client->sess.spectatorState == SPECTATOR_NOT &&
client->pers.team == TEAM_HUMANS )
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
}
// the respawned flag will be cleared after the attack and jump keys come up
client->ps.pm_flags |= PMF_RESPAWNED;
trap_GetUsercmd( client - level.clients, &ent->client->pers.cmd );
G_SetClientViewAngle( ent, spawn_angles );
if ( client->sess.spectatorState == SPECTATOR_NOT )
{
trap_LinkEntity( ent );
// force the base weapon up
if ( client->pers.team == TEAM_HUMANS )
{
G_ForceWeaponChange( ent, weapon );
}
client->ps.weaponstate = WEAPON_READY;
}
// don't allow full run speed for a bit
client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
client->ps.pm_time = 100;
client->respawnTime = level.time;
ent->nextRegenTime = level.time;
client->inactivityTime = level.time + g_inactivity.integer * 1000;
usercmdClearButtons( client->latched_buttons );
// set default animations
client->ps.torsoAnim = TORSO_STAND;
client->ps.legsAnim = LEGS_IDLE;
if ( level.intermissiontime )
{
MoveClientToIntermission( ent );
}
else
{
// fire the targets of the spawn point
if ( !spawn && spawnPoint )
{
G_EventFireEntity( spawnPoint, ent, ON_SPAWN );
}
// select the highest weapon number available, after any
// spawn given items have fired
client->ps.weapon = 1;
for ( i = WP_NUM_WEAPONS - 1; i > 0; i-- )
{
if ( BG_InventoryContainsWeapon( i, client->ps.stats ) )
{
client->ps.weapon = i;
break;
}
}
}
// run a client frame to drop exactly to the floor,
// initialize animations and other things
client->ps.commandTime = level.time - 100;
ent->client->pers.cmd.serverTime = level.time;
ClientThink( ent - g_entities );
// positively link the client, even if the command times are weird
if ( client->sess.spectatorState == SPECTATOR_NOT )
{
BG_PlayerStateToEntityState( &client->ps, &ent->s, true );
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
trap_LinkEntity( ent );
}
// must do this here so the number of active clients is calculated
CalculateRanks();
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
BG_PlayerStateToEntityState( &client->ps, &ent->s, true );
client->pers.infoChangeTime = level.time;
// (re)tag the client for its team
Beacon::DeleteTags( ent );
Beacon::Tag( ent, (team_t)ent->client->ps.persistant[ PERS_TEAM ], true );
}
bool SpikerComponent::Fire() {
gentity_t *self = entity.oldEnt;
// Check if still resting.
if (restUntil > level.time) {
logger.Verbose("Spiker #%i wanted to fire but wasn't ready.", entity.oldEnt->s.number);
return false;
} else {
logger.Verbose("Spiker #%i is firing!", entity.oldEnt->s.number);
}
// Play shooting animation.
G_SetBuildableAnim(self, BANIM_ATTACK1, false);
GetBuildableComponent().ProtectAnimation(5000);
// TODO: Add a particle effect.
//G_AddEvent(self, EV_ALIEN_SPIKER, DirToByte(self->s.origin2));
// Calculate total perimeter of all spike rows to allow for a more even spike distribution.
// A "row" is a group of missile launch directions with a common base altitude (angle measured
// from the Spiker's horizon to its zenith) which is slightly adjusted for each new missile in
// the row (at most halfway to the base altitude of a neighbouring row).
float totalPerimeter = 0.0f;
for (int row = 0; row < MISSILEROWS; row++) {
float rowAltitude = (((float)row + 0.5f) * M_PI_2) / (float)MISSILEROWS;
float rowPerimeter = 2.0f * M_PI * cos(rowAltitude);
totalPerimeter += rowPerimeter;
}
// TODO: Use new vector library.
vec3_t dir, zenith, rotAxis;
// As rotation axis for setting the altitude, any vector perpendicular to the zenith works.
VectorCopy(self->s.origin2, zenith);
PerpendicularVector(rotAxis, zenith);
// Distribute and launch missiles.
for (int row = 0; row < MISSILEROWS; row++) {
// Set the base altitude and get the perimeter for the current row.
float rowAltitude = (((float)row + 0.5f) * M_PI_2) / (float)MISSILEROWS;
float rowPerimeter = 2.0f * M_PI * cos(rowAltitude);
// Attempt to distribute spikes with equal expected angular distance on all rows.
int spikes = (int)round(((float)MISSILES * rowPerimeter) / totalPerimeter);
// Launch missiles in the current row.
for (int spike = 0; spike < spikes; spike++) {
float spikeAltitude = rowAltitude + (0.5f * crandom() * M_PI_2 / (float)MISSILEROWS);
float spikeAzimuth = 2.0f * M_PI * (((float)spike + 0.5f * crandom()) / (float)spikes);
// Set launch direction altitude.
RotatePointAroundVector(dir, rotAxis, zenith, RAD2DEG(M_PI_2 - spikeAltitude));
// Set launch direction azimuth.
RotatePointAroundVector(dir, zenith, dir, RAD2DEG(spikeAzimuth));
// Trace in the shooting direction and do not shoot spikes that are likely to harm
// friendly entities.
bool fire = SafeToShoot(Vec3::Load(dir));
logger.Debug("Spiker #%d %s: Row %d/%d: Spike %2d/%2d: "
"( Alt %2.0f°, Az %3.0f° → %.2f, %.2f, %.2f )", self->s.number,
fire ? "fires" : "skips", row + 1, MISSILEROWS, spike + 1, spikes,
RAD2DEG(spikeAltitude), RAD2DEG(spikeAzimuth), dir[0], dir[1], dir[2]);
if (!fire) {
continue;
}
G_SpawnMissile(
MIS_SPIKER, self, self->s.origin, dir, nullptr, G_FreeEntity,
level.time + (int)(1000.0f * SPIKE_RANGE / (float)BG_Missile(MIS_SPIKER)->speed));
}
}
restUntil = level.time + COOLDOWN;
RegisterSlowThinker();
return true;
}
/*
===========
ClientSpawn
Called every time a client is placed fresh in the world:
after the first ClientBegin, and after each respawn
Initializes all non-persistant parts of playerState
============
*/
void ClientSpawn( gentity_t *ent, gentity_t *spawn, vec3_t origin, vec3_t angles )
{
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
int i;
clientPersistant_t saved;
clientSession_t savedSess;
int persistant[ MAX_PERSISTANT ];
gentity_t *spawnPoint = NULL, *event;
int flags;
int savedPing;
int teamLocal;
int eventSequence;
char userinfo[ MAX_INFO_STRING ];
vec3_t up = { 0.0f, 0.0f, 1.0f }, implant_dir, implant_angles, spawnPoint_velocity;
int maxAmmo, maxClips;
weapon_t weapon;
qboolean fromImplant = qfalse, hatchingFailed = qfalse;
index = ent - g_entities;
client = ent->client;
teamLocal = client->pers.teamSelection;
//if client is dead and following teammate, stop following before spawning
if( client->sess.spectatorClient != -1 )
{
client->sess.spectatorClient = -1;
client->sess.spectatorState = SPECTATOR_FREE;
}
// only start client if chosen a class and joined a team
if( client->pers.classSelection == PCL_NONE && teamLocal == TEAM_NONE )
client->sess.spectatorState = SPECTATOR_FREE;
else if( client->pers.classSelection == PCL_NONE )
client->sess.spectatorState = SPECTATOR_LOCKED;
// if client is dead and following teammate, stop following before spawning
if( ent->client->sess.spectatorState == SPECTATOR_FOLLOW )
G_StopFollowing( ent );
if( origin != NULL )
VectorCopy( origin, spawn_origin );
if( angles != NULL )
VectorCopy( angles, spawn_angles );
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if( client->sess.spectatorState != SPECTATOR_NOT )
{
if( teamLocal == TEAM_NONE )
spawnPoint = G_SelectSpectatorSpawnPoint( spawn_origin, spawn_angles );
else if( teamLocal == TEAM_ALIENS )
spawnPoint = G_SelectAlienLockSpawnPoint( spawn_origin, spawn_angles );
else if( teamLocal == TEAM_HUMANS )
spawnPoint = G_SelectHumanLockSpawnPoint( spawn_origin, spawn_angles );
}
else
{
if( spawn == NULL )
{
G_Error( "ClientSpawn: spawn is NULL\n" );
return;
}
spawnPoint = spawn;
if( ent != spawn )
{
if( !spawnPoint->client ) //might be a human
{
//start spawn animation on spawnPoint
G_SetBuildableAnim( spawnPoint, BANIM_SPAWN1, qtrue );
if( spawnPoint->buildableTeam == TEAM_ALIENS )
spawnPoint->clientSpawnTime = ALIEN_SPAWN_REPEAT_TIME;
else if( spawnPoint->buildableTeam == TEAM_HUMANS )
spawnPoint->clientSpawnTime = HUMAN_SPAWN_REPEAT_TIME;
}
else
{
qboolean crouch;
int i;
float zoffs = 0.0f;
trace_t tr;
vec3_t neworigin, mins, maxs;
fromImplant = qtrue; //spawning from a human
// move the origin a bit on the Z axis so the aliens jumps out of the chest, not knees
// also prevents grangers from getting stuck in ceilings and floors
crouch = spawnPoint->client->ps.pm_flags & PMF_DUCKED;
switch( client->pers.classSelection )
{
case PCL_ALIEN_BUILDER0:
if( !crouch )
zoffs = 19.0f;
else
zoffs = -4.0f;
break;
case PCL_ALIEN_BUILDER0_UPG:
if( !crouch )
zoffs = 16.5f;
else
zoffs = -4.0f;
break;
case PCL_ALIEN_LEVEL0:
if( !crouch )
zoffs = 15.0f;
else
zoffs = -9.1f;
break;
}
spawn_origin[ 2 ] += zoffs;
// check if the spot would block
BG_ClassBoundingBox( client->pers.classSelection, mins, maxs, NULL, NULL, NULL );
trap_Trace( &tr, spawn_origin, mins, maxs, spawn_origin, spawnPoint->s.number, MASK_PLAYERSOLID );
// try to unblock the player
if( tr.startsolid )
{
Com_Printf("DEBUG: player is stuck!\n");
for( i = 0; i < 16*2; i++ )
{
float a, r;
VectorCopy( spawn_origin, neworigin );
a = (float)i / 16.0f * 2.0f * M_PI;
#define fmod(a,n) ((a)-(n)*floor((a)/(n)))
r = ( i < 16 ? 5.5f : 11.0f ) * 1.0f / cos( fmod( a+0.25f*M_PI, 0.5f*M_PI ) - 0.25f*M_PI );
neworigin[ 0 ] += cos( a ) * r;
neworigin[ 1 ] += sin( a ) * r;
trap_Trace( &tr, neworigin, mins, maxs, neworigin, spawnPoint->s.number, MASK_PLAYERSOLID );
if( !tr.startsolid )
{
Com_Printf("DEBUG: player position fixed at iteration %i\n",i);
VectorCopy( neworigin, spawn_origin );
break;
}
}
}
//reward the player that implanted this one
if( spawnPoint->client->impregnatedBy >= 0 )
{
gentity_t *granger;
granger = &g_entities[ spawnPoint->client->impregnatedBy ];
G_AddCreditToClient( granger->client, ALIEN_IMPREGNATION_REWARD, qtrue );
AddScore( granger, ALIEN_IMPREGNATION_REWARD_SCORE );
}
// kill the human, set up angles and velocity for the new alien
if( !BG_InventoryContainsUpgrade( UP_BATTLESUIT, spawnPoint->client->ps.stats ) //humans without battlesuits always die
|| spawnPoint->client->ps.stats[ STAT_HEALTH ] < ALIEN_HATCHING_MAX_BATTLESUIT_HEALTH ) //battlesuits survive if high hp
{
//save viewangles and spawn velocity for velocity calculation
VectorCopy( spawnPoint->client->ps.viewangles, implant_angles );
AngleVectors( implant_angles, implant_dir, NULL, NULL );
VectorCopy( spawnPoint->client->ps.velocity, spawnPoint_velocity );
//fire a nice chest exploding effect
event = G_TempEntity( spawnPoint->s.pos.trBase, EV_ALIEN_HATCH );
VectorCopy( implant_dir, event->s.angles );
//kill the player
G_Damage( spawnPoint, NULL, ent, NULL, NULL, spawnPoint->client->ps.stats[ STAT_HEALTH ], DAMAGE_NO_ARMOR, MOD_ALIEN_HATCH );
}
else //human survives
{
//clear impregnation so the human won't explode again
spawnPoint->client->isImpregnated = qfalse;
spawnPoint->client->isImplantMature = qfalse;
//make a sound
event = G_TempEntity( spawnPoint->s.pos.trBase, EV_ALIEN_HATCH_FAILURE );
//damage the human
G_Damage( spawnPoint, NULL, ent, NULL, NULL, ALIEN_FAILED_HATCH_DAMAGE, DAMAGE_NO_ARMOR, MOD_ALIEN_HATCH );
//kill the newly spawned alien
VectorCopy( spawnPoint->client->ps.viewangles, implant_angles );
implant_dir[0] = 0.0f;
implant_dir[1] = 0.0f;
implant_dir[2] = 0.0f;
hatchingFailed = qtrue;
}
}
}
}
// toggle the teleport bit so the client knows to not lerp
flags = ( ent->client->ps.eFlags & EF_TELEPORT_BIT ) ^ EF_TELEPORT_BIT;
G_UnlaggedClear( ent );
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
for( i = 0; i < MAX_PERSISTANT; i++ )
persistant[ i ] = client->ps.persistant[ i ];
eventSequence = client->ps.eventSequence;
memset( client, 0, sizeof( *client ) );
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
client->lastkilled_client = -1;
for( i = 0; i < MAX_PERSISTANT; i++ )
client->ps.persistant[ i ] = persistant[ i ];
client->ps.eventSequence = eventSequence;
// increment the spawncount so the client will detect the respawn
client->ps.persistant[ PERS_SPAWN_COUNT ]++;
client->ps.persistant[ PERS_SPECSTATE ] = client->sess.spectatorState;
client->airOutTime = level.time + 12000;
trap_GetUserinfo( index, userinfo, sizeof( userinfo ) );
client->ps.eFlags = flags;
//Com_Printf( "ent->client->pers->pclass = %i\n", ent->client->pers.classSelection );
ent->s.groundEntityNum = ENTITYNUM_NONE;
ent->client = &level.clients[ index ];
ent->takedamage = qtrue;
ent->inuse = qtrue;
ent->classname = "player";
ent->r.contents = CONTENTS_BODY;
ent->clipmask = MASK_PLAYERSOLID;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags = 0;
// calculate each client's acceleration
ent->evaluateAcceleration = qtrue;
client->ps.stats[ STAT_MISC ] = 0;
client->buildTimer = 0;
client->ps.eFlags = flags;
client->ps.clientNum = index;
BG_ClassBoundingBox( ent->client->pers.classSelection, ent->r.mins, ent->r.maxs, NULL, NULL, NULL );
if( client->sess.spectatorState == SPECTATOR_NOT )
client->ps.stats[ STAT_MAX_HEALTH ] =
BG_Class( ent->client->pers.classSelection )->health;
else
client->ps.stats[ STAT_MAX_HEALTH ] = 100;
// clear entity values
if( ent->client->pers.classSelection == PCL_HUMAN )
{
BG_AddUpgradeToInventory( UP_MEDKIT, client->ps.stats );
weapon = client->pers.humanItemSelection;
}
else if( client->sess.spectatorState == SPECTATOR_NOT )
weapon = BG_Class( ent->client->pers.classSelection )->startWeapon;
else
weapon = WP_NONE;
maxAmmo = BG_Weapon( weapon )->maxAmmo;
maxClips = BG_Weapon( weapon )->maxClips;
client->ps.stats[ STAT_WEAPON ] = weapon;
client->ps.ammo = maxAmmo;
client->ps.clips = maxClips;
// We just spawned, not changing weapons
client->ps.persistant[ PERS_NEWWEAPON ] = 0;
ent->client->ps.stats[ STAT_CLASS ] = ent->client->pers.classSelection;
ent->client->ps.stats[ STAT_TEAM ] = ent->client->pers.teamSelection;
ent->client->ps.stats[ STAT_BUILDABLE ] = BA_NONE;
ent->client->ps.stats[ STAT_STATE ] = 0;
VectorSet( ent->client->ps.grapplePoint, 0.0f, 0.0f, 1.0f );
// health will count down towards max_health
ent->health = client->ps.stats[ STAT_HEALTH ] = client->ps.stats[ STAT_MAX_HEALTH ]; //* 1.25;
//if evolving scale health
if( ent == spawn )
{
ent->health *= ent->client->pers.evolveHealthFraction;
client->ps.stats[ STAT_HEALTH ] *= ent->client->pers.evolveHealthFraction;
}
//clear the credits array
for( i = 0; i < MAX_CLIENTS; i++ )
ent->credits[ i ] = 0;
client->ps.stats[ STAT_STAMINA ] = STAMINA_MAX;
//never impregnated after respawning
client->isImpregnated = qfalse;
client->isImplantMature = qfalse;
G_SetOrigin( ent, spawn_origin );
VectorCopy( spawn_origin, client->ps.origin );
#define UP_VEL 150.0f
#define F_VEL 50.0f
//give aliens some spawn velocity
if( client->sess.spectatorState == SPECTATOR_NOT &&
client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
if( ent == spawn )
{
//evolution particle system
G_AddPredictableEvent( ent, EV_ALIEN_EVOLVE, DirToByte( up ) );
}
else if( !fromImplant ) //regular egg
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
if( spawnPoint->s.origin2[ 2 ] > 0.0f )
{
vec3_t forward, dir;
AngleVectors( spawn_angles, forward, NULL, NULL );
VectorScale( forward, F_VEL, forward );
VectorAdd( spawnPoint->s.origin2, forward, dir );
VectorNormalize( dir );
VectorScale( dir, UP_VEL, client->ps.velocity );
}
G_AddPredictableEvent( ent, EV_PLAYER_RESPAWN, 0 );
}
else //implanted egg
{
VectorCopy( implant_angles, spawn_angles );
VectorScale( implant_dir, ALIEN_HATCHING_VELOCITY, client->ps.velocity );
VectorAdd( client->ps.velocity, spawnPoint_velocity, client->ps.velocity );
}
}
else if( client->sess.spectatorState == SPECTATOR_NOT &&
client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
spawn_angles[ YAW ] += 180.0f;
AngleNormalize360( spawn_angles[ YAW ] );
}
// the respawned flag will be cleared after the attack and jump keys come up
client->ps.pm_flags |= PMF_RESPAWNED;
trap_GetUsercmd( client - level.clients, &ent->client->pers.cmd );
G_SetClientViewAngle( ent, spawn_angles );
if( client->sess.spectatorState == SPECTATOR_NOT )
{
trap_LinkEntity( ent );
// force the base weapon up
if( client->pers.teamSelection == TEAM_HUMANS )
G_ForceWeaponChange( ent, weapon );
client->ps.weaponstate = WEAPON_READY;
}
// don't allow full run speed for a bit
client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
client->ps.pm_time = 100;
client->respawnTime = level.time;
ent->nextRegenTime = level.time;
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
// set default animations
client->ps.torsoAnim = TORSO_STAND;
client->ps.legsAnim = LEGS_IDLE;
if( level.intermissiontime )
MoveClientToIntermission( ent );
else
{
// fire the targets of the spawn point
if( !spawn )
G_UseTargets( spawnPoint, ent );
// select the highest weapon number available, after any
// spawn given items have fired
client->ps.weapon = 1;
for( i = WP_NUM_WEAPONS - 1; i > 0 ; i-- )
{
if( BG_InventoryContainsWeapon( i, client->ps.stats ) )
{
client->ps.weapon = i;
break;
}
}
}
client->lastRantBombTime = level.time;
// run a client frame to drop exactly to the floor,
// initialize animations and other things
client->ps.commandTime = level.time - 100;
ent->client->pers.cmd.serverTime = level.time;
ClientThink( ent-g_entities );
// positively link the client, even if the command times are weird
if( client->sess.spectatorState == SPECTATOR_NOT )
{
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
trap_LinkEntity( ent );
}
// must do this here so the number of active clients is calculated
CalculateRanks( );
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
// kill him instantly after respawning if hatching failed
if( fromImplant && hatchingFailed )
{
VectorCopy( spawnPoint->client->ps.velocity, client->ps.velocity );
client->ps.stats[ STAT_HEALTH ] = ent->health = 0;
player_die( ent, NULL, spawnPoint, 0, MOD_ALIEN_HATCH_FAILED );
}
}