void CorpsePhysics( gentity_t *self )
{
// run the bot through the server like it was a real client
memset( &ucmd, 0, sizeof( ucmd ) );
ClientThink( self->s.number, &ucmd );
//VectorCopy( self->s.origin, self->s.origin2 );
//rww - don't get why this is happening.
if ( self->client->NPC_class == CLASS_GALAKMECH )
{
GM_Dying( self );
}
//FIXME: match my pitch and roll for the slope of my groundPlane
if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE && !(self->s.eFlags&EF_DISINTEGRATION) )
{//on the ground
//FIXME: check 4 corners
pitch_roll_for_slope( self, NULL );
}
if ( eventClearTime == level.time + ALERT_CLEAR_TIME )
{//events were just cleared out so add me again
if ( !(self->client->ps.eFlags&EF_NODRAW) )
{
AddSightEvent( self->enemy, &self->r.currentOrigin, 384, AEL_DISCOVERED, 0.0f );
}
}
if ( level.time - self->s.time > 3000 )
{//been dead for 3 seconds
if ( g_dismember.integer < 11381138 && !g_saberRealisticCombat.integer )
{//can't be dismembered once dead
if ( self->client->NPC_class != CLASS_PROTOCOL )
{
// self->client->dismembered = qtrue;
}
}
}
//if ( level.time - self->s.time > 500 )
if (self->client->respawnTime < (level.time+500))
{//don't turn "nonsolid" until about 1 second after actual death
if (self->client->ps.eFlags & EF_DISINTEGRATION)
{
self->r.contents = 0;
}
else if ((self->client->NPC_class != CLASS_MARK1) && (self->client->NPC_class != CLASS_INTERROGATOR)) // The Mark1 & Interrogator stays solid.
{
self->r.contents = CONTENTS_CORPSE;
//self->r.maxs[2] = -8;
}
if ( self->message )
{
self->r.contents |= CONTENTS_TRIGGER;
}
}
}
void Bot::CallGhostingClientThink(usercmd_t *ucmd)
{
// set approximate ping and show values
ucmd->serverTimeStamp = game.serverTime;
ucmd->msec = game.frametime;
self->r.client->r.ping = 0;
ClientThink( self, ucmd, 0 );
}
static void DeadThink ( void )
{
if ( !NPCInfo->timeOfDeath && NPC->client != NULL && NPCInfo != NULL )
{
//haven't finished death anim yet and were NOT given a specific amount of time to wait before removal
int legsAnim = (NPC->client->ps.legsAnim & ~ANIM_TOGGLEBIT);
animation_t *animations = knownAnimFileSets[NPC->client->clientInfo.animFileIndex].animations;
NPC->bounceCount = -1; // This is a cheap hack for optimizing the pointcontents check below
if ( NPC->client->renderInfo.legsFrame == animations[legsAnim].firstFrame + (animations[legsAnim].numFrames - 1) )
{
//reached the end of the death anim
NPCInfo->timeOfDeath = level.time + BodyRemovalPadTime( NPC );
}
}
else
{
//death anim done (or were given a specific amount of time to wait before removal), wait the requisite amount of time them remove
if ( level.time >= NPCInfo->timeOfDeath )
{
if ( NPC->client->ps.eFlags & EF_NODRAW )
{
NPC->e_ThinkFunc = thinkF_G_FreeEntity;
NPC->nextthink = level.time + FRAMETIME;
}
else
{
// Start the body effect first, then delay 400ms before ditching the corpse
NPC_RemoveBodyEffect();
NPC->e_ThinkFunc = thinkF_NPC_RemoveBody;
if ( NPC->client->playerTeam == TEAM_FORGE )
NPC->nextthink = level.time + FRAMETIME * 8;
else
NPC->nextthink = level.time + FRAMETIME * 4;
}
return;
}
}
// If the player is on the ground and the resting position contents haven't been set yet...(BounceCount tracks the contents)
if ( NPC->bounceCount < 0 && NPC->s.groundEntityNum >= 0 )
{
// if client is in a nodrop area, make him/her nodraw
int contents = NPC->bounceCount = gi.pointcontents( NPC->currentOrigin, -1 );
if ( ( contents & CONTENTS_NODROP ) )
{
NPC->client->ps.eFlags |= EF_NODRAW;
}
}
// run the bot through the server like it was a real client
ClientThink(NPC->s.number, &ucmd);
VectorCopy(NPC->s.origin, NPC->s.origin2 );
}
/*
===========
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( edict_s* ent )
{
int index;
char userinfo[MAX_INFO_STRING];
index = ent - g_entities;
if ( ent->ent == 0 )
{
// this should never happen
g_core->DropError( "ClientSpawn on edict without entity!" );
return;
}
Player* pl = dynamic_cast<Player*>( ent->ent );
pl->ps.clientNum = index;
pl->setHealth( 100 );
vec3_c spawnOrigin, spawnAngles;
spawnOrigin.zero();
spawnAngles.zero();
BaseEntity* spawnPoint = G_GetRandomEntityOfClass( "InfoPlayerStart" );
if ( spawnPoint )
{
spawnOrigin = spawnPoint->getOrigin();
spawnAngles = spawnPoint->getAngles();
}
pl->setOrigin( spawnOrigin );
pl->setAngles( spawnAngles );
g_server->GetUsercmd( index, &pl->pers.cmd );
pl->setClientViewAngle( spawnAngles );
// don't allow full run speed for a bit
#if 1
pl->setPlayerModel( "models/player/shina/body.md5mesh" );
#else
// load q3 player model (three .md3's)
pl->setPlayerModel( "$sarge" );
#endif
// run a pl frame to drop exactly to the floor,
// initialize animations and other things
pl->ps.commandTime = level.time - 100;
pl->pers.cmd.serverTime = level.time;
ClientThink( index );
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
//BG_PlayerStateToEntityState( &pl->ps, &ent->s, true );
}
void C_Strider::OnDataChanged( DataUpdateType_t updateType )
{
if ( updateType == DATA_UPDATE_CREATED )
{
// We need to have our render bounds defined or shadow creation won't work correctly
ClientThink();
ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
}
BaseClass::OnDataChanged( updateType );
m_cannonFX.Update( this, m_vecHitPos );
}
int baseq3_qagame_vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11 ) {
#else
int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11 ) {
#endif // IOS
switch ( command ) {
case GAME_INIT:
G_InitGame( arg0, arg1, arg2 );
return 0;
case GAME_SHUTDOWN:
G_ShutdownGame( arg0 );
return 0;
case GAME_CLIENT_CONNECT:
return (int)ClientConnect( arg0, arg1, arg2 );
case GAME_CLIENT_THINK:
ClientThink( arg0 );
return 0;
case GAME_CLIENT_USERINFO_CHANGED:
ClientUserinfoChanged( arg0 );
return 0;
case GAME_CLIENT_DISCONNECT:
ClientDisconnect( arg0 );
return 0;
case GAME_CLIENT_BEGIN:
ClientBegin( arg0 );
return 0;
case GAME_CLIENT_COMMAND:
ClientCommand( arg0 );
return 0;
case GAME_RUN_FRAME:
G_RunFrame( arg0 );
return 0;
case GAME_CONSOLE_COMMAND:
return ConsoleCommand();
case BOTAI_START_FRAME:
return BotAIStartFrame( arg0 );
}
return -1;
}
void QDECL G_Printf( const char *fmt, ... ) {
va_list argptr;
char text[1024];
va_start (argptr, fmt);
vsprintf (text, fmt, argptr);
va_end (argptr);
trap_Printf( text );
}
void Bot::CallActiveClientThink(usercmd_t *ucmd)
{
//set up for pmove
for (int i = 0; i < 3; i++)
ucmd->angles[i] = ANGLE2SHORT(self->s.angles[i]) - self->r.client->ps.pmove.delta_angles[i];
VectorSet(self->r.client->ps.pmove.delta_angles, 0, 0, 0);
// set approximate ping and show values
ucmd->msec = game.frametime;
ucmd->serverTimeStamp = game.serverTime;
// If this value is modified by ClientThink() callbacks, it will be kept until next frame reaches this line
jumppadMovementState.hasTouchedJumppad = false;
ClientThink( self, ucmd, 0 );
self->nextThink = level.time + 1;
}
//==========================================
// BOT_DMclass_DeadFrame
// ent is dead = run this think func
//==========================================
static void BOT_DMclass_GhostingFrame( edict_t *self )
{
usercmd_t ucmd;
AI_ClearGoal( self );
self->ai->blocked_timeout = level.time + 15000;
self->nextThink = level.time + 100;
// wait 4 seconds after entering the level
if( self->r.client->level.timeStamp + 4000 > level.time || !level.canSpawnEntities )
return;
if( self->r.client->team == TEAM_SPECTATOR )
{
// try to join a team
// note that G_Teams_JoinAnyTeam is quite slow so only call it per frame
if( !self->r.client->queueTimeStamp && self == level.think_client_entity )
G_Teams_JoinAnyTeam( self, false );
if( self->r.client->team == TEAM_SPECTATOR ) // couldn't join, delay the next think
self->nextThink = level.time + 2000 + (int)( 4000 * random() );
else
self->nextThink = level.time + 1;
return;
}
memset( &ucmd, 0, sizeof( ucmd ) );
// set approximate ping and show values
ucmd.serverTimeStamp = game.serverTime;
ucmd.msec = game.frametime;
self->r.client->r.ping = 0;
// ask for respawn if the minimum bot respawning time passed
if( level.time > self->deathTimeStamp + 3000 )
ucmd.buttons = BUTTON_ATTACK;
ClientThink( self, &ucmd, 0 );
}
/*
================
vmMain
This is the only way control passes into the module.
This must be the very first function compiled into the .q3vm file
================
*/
Q_EXPORT intptr_t vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11 ) {
switch ( command ) {
case GAME_INIT:
G_InitGame( arg0, arg1, arg2 );
return 0;
case GAME_SHUTDOWN:
G_ShutdownGame( arg0 );
return 0;
case GAME_CLIENT_CONNECT:
return (intptr_t)ClientConnect( arg0, arg1, arg2 );
case GAME_CLIENT_THINK:
ClientThink( arg0 );
return 0;
case GAME_CLIENT_USERINFO_CHANGED:
ClientUserinfoChanged( arg0 );
return 0;
case GAME_CLIENT_DISCONNECT:
ClientDisconnect( arg0 );
return 0;
case GAME_CLIENT_BEGIN:
ClientBegin( arg0 );
return 0;
case GAME_CLIENT_COMMAND:
ClientCommand( arg0 );
return 0;
case GAME_RUN_FRAME:
G_RunFrame( arg0 );
return 0;
case GAME_CONSOLE_COMMAND:
return ConsoleCommand();
case BOTAI_START_FRAME:
return BotAIStartFrame( arg0 );
}
return -1;
}
/*
===========
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) {
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;
int flags;
int savedPing;
int savedTeam;
qboolean update = qfalse;
save_position_t *pos = NULL;
index = ent - g_entities;
client = ent->client;
G_UpdateSpawnCounts();
client->pers.lastSpawnTime = level.time;
if (client->sess.sessionTeam != TEAM_AXIS && client->sess.sessionTeam != TEAM_ALLIES) {
spawnPoint = SelectSpectatorSpawnPoint(spawn_origin, spawn_angles);
} else {
spawnPoint = SelectPlayerSpawnPoint(client->sess.sessionTeam, spawn_origin, spawn_angles, client->sess.spawnObjectiveIndex);
}
client->pers.teamState.state = TEAM_ACTIVE;
// toggle the teleport bit so the client knows to not lerp
flags = ent->client->ps.eFlags & EF_TELEPORT_BIT;
flags ^= EF_TELEPORT_BIT;
flags |= (client->ps.eFlags & EF_VOTED);
// clear everything but the persistant data
ent->s.eFlags &= ~EF_MOUNTEDTANK;
// Nico, notify timerun_stop
notify_timerun_stop(ent, 0);
ent->client->sess.timerunActive = qfalse;
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
savedTeam = client->ps.teamNum;
for (i = 0 ; i < MAX_PERSISTANT ; i++) {
persistant[i] = client->ps.persistant[i];
}
memset(client, 0, sizeof (*client));
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
client->ps.teamNum = savedTeam;
for (i = 0 ; i < MAX_PERSISTANT ; i++) {
client->ps.persistant[i] = persistant[i];
}
// increment the spawncount so the client will detect the respawn
client->ps.persistant[PERS_SPAWN_COUNT]++;
client->ps.persistant[PERS_TEAM] = client->sess.sessionTeam;
client->ps.persistant[PERS_HWEAPON_USE] = 0;
client->airOutTime = level.time + 12000;
// clear entity values
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
client->ps.eFlags = flags;
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;
// DHM - Nerve :: Init to -1 on first spawn;
ent->props_frame_state = -1;
ent->die = player_die;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags = 0;
VectorCopy(playerMins, ent->r.mins);
VectorCopy(playerMaxs, ent->r.maxs);
// Ridah, setup the bounding boxes and viewheights for prediction
VectorCopy(ent->r.mins, client->ps.mins);
VectorCopy(ent->r.maxs, client->ps.maxs);
client->ps.crouchViewHeight = CROUCH_VIEWHEIGHT;
client->ps.standViewHeight = DEFAULT_VIEWHEIGHT;
client->ps.deadViewHeight = DEAD_VIEWHEIGHT;
client->ps.crouchMaxZ = client->ps.maxs[2] - (client->ps.standViewHeight - client->ps.crouchViewHeight);
client->ps.runSpeedScale = 0.8;
client->ps.sprintSpeedScale = 1.1;
client->ps.crouchSpeedScale = 0.25;
client->ps.weaponstate = WEAPON_READY;
// Rafael
client->ps.friction = 1.0;
// done.
// TTimo
// retrieve from the persistant storage (we use this in pmoveExt_t beause we need it in bg_*)
client->pmext.bAutoReload = client->pers.bAutoReloadAux;
// done
client->ps.clientNum = index;
trap_GetUsercmd(client - level.clients, &ent->client->pers.cmd); // NERVE - SMF - moved this up here
if (client->sess.playerType != client->sess.latchPlayerType) {
update = qtrue;
}
client->sess.playerType = client->sess.latchPlayerType;
if (client->sess.playerWeapon != client->sess.latchPlayerWeapon) {
client->sess.playerWeapon = client->sess.latchPlayerWeapon;
update = qtrue;
}
client->sess.playerWeapon2 = client->sess.latchPlayerWeapon2;
if (update) {
ClientUserinfoChanged(index);
}
G_UpdateCharacter(client);
SetWolfSpawnWeapons(client);
client->pers.maxHealth = 125;
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
client->pers.cmd.weapon = ent->client->ps.weapon;
// dhm - end
ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];
G_SetOrigin(ent, spawn_origin);
VectorCopy(spawn_origin, client->ps.origin);
// the respawned flag will be cleared after the attack and jump keys come up
client->ps.pm_flags |= PMF_RESPAWNED;
SetClientViewAngle(ent, spawn_angles);
if (ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
trap_LinkEntity(ent);
}
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
client->latched_wbuttons = 0; //----(SA) added
// fire the targets of the spawn point
G_UseTargets(spawnPoint, ent);
// 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 (ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
BG_PlayerStateToEntityState(&client->ps, &ent->s, qtrue);
VectorCopy(ent->client->ps.origin, ent->r.currentOrigin);
trap_LinkEntity(ent);
}
// run the presend to set anything else
ClientEndFrame(ent);
// set idle animation on weapon
ent->client->ps.weapAnim = ((ent->client->ps.weapAnim & ANIM_TOGGLEBIT) ^ ANIM_TOGGLEBIT) | PM_IdleAnimForWeapon(ent->client->ps.weapon);
// clear entity state values
BG_PlayerStateToEntityState(&client->ps, &ent->s, qtrue);
// show_bug.cgi?id=569
G_ResetMarkers(ent);
// RF, start the scripting system
if (client->sess.sessionTeam != TEAM_SPECTATOR) {
// RF, call entity scripting event
G_Script_ScriptEvent(ent, "playerstart", "");
}
// Nico, autoload position
if (ent->client->pers.autoLoad && !ent->client->sess.lastDieWasASelfkill && (ent->client->sess.sessionTeam == TEAM_AXIS || ent->client->sess.sessionTeam == TEAM_ALLIES)) {
if (ent->client->sess.sessionTeam == TEAM_ALLIES) {
pos = ent->client->sess.alliesSaves;
} else {
pos = ent->client->sess.axisSaves;
}
if (pos->valid) {
VectorCopy(pos->origin, ent->client->ps.origin);
// Nico, load angles if cg_loadViewAngles = 1
if (ent->client->pers.loadViewAngles) {
SetClientViewAngle(ent, pos->vangles);
}
// Nico, load saved weapon if cg_loadWeapon = 1
if (ent->client->pers.loadWeapon) {
ent->client->ps.weapon = pos->weapon;
}
VectorClear(ent->client->ps.velocity);
if (ent->client->ps.stats[STAT_HEALTH] < 100 && ent->client->ps.stats[STAT_HEALTH] > 0) {
ent->health = 100;
}
}
}
}
void NPC_Think ( gentity_t *self)//, int msec )
{
vector3 oldMoveDir;
int i = 0;
gentity_t *player;
self->nextthink = level.time + FRAMETIME;
SetNPCGlobals( self );
memset( &ucmd, 0, sizeof( ucmd ) );
VectorCopy( &self->client->ps.moveDir, &oldMoveDir );
if (self->s.NPC_class != CLASS_VEHICLE)
{ //YOU ARE BREAKING MY PREDICTION. Bad clear.
VectorClear( &self->client->ps.moveDir );
}
if(!self || !self->NPC || !self->client)
{
return;
}
// dead NPCs have a special think, don't run scripts (for now)
//FIXME: this breaks deathscripts
if ( self->health <= 0 )
{
DeadThink();
if ( NPCInfo->nextBStateThink <= level.time )
{
trap->ICARUS_MaintainTaskManager(self->s.number);
}
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
return;
}
// see if NPC ai is frozen
if ( d_npcfreeze.value || (NPC->r.svFlags&SVF_ICARUS_FREEZE) )
{
NPC_UpdateAngles( qtrue, qtrue );
ClientThink(self->s.number, &ucmd);
//VectorCopy(self->s.origin, self->s.origin2 );
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
return;
}
self->nextthink = level.time + FRAMETIME/2;
while (i < MAX_CLIENTS)
{
player = &g_entities[i];
if (player->inuse && player->client && player->client->sess.sessionTeam != TEAM_SPECTATOR &&
!(player->client->ps.pm_flags & PMF_FOLLOW))
{
//if ( player->client->ps.viewEntity == self->s.number )
if (0) //rwwFIXMEFIXME: Allow controlling ents
{//being controlled by player
G_DroidSounds( self );
//FIXME: might want to at least make sounds or something?
//NPC_UpdateAngles(qtrue, qtrue);
//Which ucmd should we send? Does it matter, since it gets overridden anyway?
NPCInfo->last_ucmd.serverTime = level.time - 50;
ClientThink( NPC->s.number, &ucmd );
//VectorCopy(self->s.origin, self->s.origin2 );
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
return;
}
}
i++;
}
if ( self->client->NPC_class == CLASS_VEHICLE)
{
if (self->client->ps.m_iVehicleNum)
{//we don't think on our own
//well, run scripts, though...
trap->ICARUS_MaintainTaskManager(self->s.number);
return;
}
else
{
VectorClear(&self->client->ps.moveDir);
self->client->pers.cmd.forwardmove = 0;
self->client->pers.cmd.rightmove = 0;
self->client->pers.cmd.upmove = 0;
self->client->pers.cmd.buttons = 0;
memcpy(&self->m_pVehicle->m_ucmd, &self->client->pers.cmd, sizeof(usercmd_t));
}
}
else if ( NPC->s.m_iVehicleNum )
{//droid in a vehicle?
G_DroidSounds( self );
}
if ( NPCInfo->nextBStateThink <= level.time
&& !NPC->s.m_iVehicleNum )//NPCs sitting in Vehicles do NOTHING
{
#if AI_TIMERS
int startTime = GetTime(0);
#endif// AI_TIMERS
if ( NPC->s.eType != ET_NPC )
{//Something drastic happened in our script
return;
}
if ( NPC->s.weapon == WP_SABER && g_spSkill.integer >= 2 && NPCInfo->rank > RANK_LT_JG )
{//Jedi think faster on hard difficulty, except low-rank (reborn)
NPCInfo->nextBStateThink = level.time + FRAMETIME/2;
}
else
{//Maybe even 200 ms?
NPCInfo->nextBStateThink = level.time + FRAMETIME;
}
//nextthink is set before this so something in here can override it
if (self->s.NPC_class != CLASS_VEHICLE ||
!self->m_pVehicle)
{ //ok, let's not do this at all for vehicles.
NPC_ExecuteBState( self );
}
#if AI_TIMERS
int addTime = GetTime( startTime );
if ( addTime > 50 )
{
Com_Printf( S_COLOR_RED"ERROR: NPC number %d, %s %s at %s, weaponnum: %d, using %d of AI time!!!\n", NPC->s.number, NPC->NPC_type, NPC->targetname, vtos(NPC->r.currentOrigin), NPC->s.weapon, addTime );
}
AITime += addTime;
#endif// AI_TIMERS
}
else
{
VectorCopy( &oldMoveDir, &self->client->ps.moveDir );
//or use client->pers.lastCommand?
NPCInfo->last_ucmd.serverTime = level.time - 50;
if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
{//If we were following a roff, we don't do normal pmoves.
//FIXME: firing angles (no aim offset) or regular angles?
NPC_UpdateAngles(qtrue, qtrue);
memcpy( &ucmd, &NPCInfo->last_ucmd, sizeof( usercmd_t ) );
ClientThink(NPC->s.number, &ucmd);
}
else
{
NPC_ApplyRoff();
}
//VectorCopy(self->s.origin, self->s.origin2 );
}
//must update icarus *every* frame because of certain animation completions in the pmove stuff that can leave a 50ms gap between ICARUS animation commands
trap->ICARUS_MaintainTaskManager(self->s.number);
VectorCopy(&self->r.currentOrigin, &self->client->ps.origin);
}
/*
===============
NPC_ExecuteBState
MCG
NPC Behavior state thinking
===============
*/
void NPC_ExecuteBState ( gentity_t *self)//, int msec )
{
bState_t bState;
NPC_HandleAIFlags();
//FIXME: these next three bits could be a function call, some sort of setup/cleanup func
//Lookmode must be reset every think cycle
if(NPC->delayScriptTime && NPC->delayScriptTime <= level.time)
{
G_ActivateBehavior( NPC, BSET_DELAYED);
NPC->delayScriptTime = 0;
}
//Clear this and let bState set it itself, so it automatically handles changing bStates... but we need a set bState wrapper func
NPCInfo->combatMove = qfalse;
//Execute our bState
if(NPCInfo->tempBehavior)
{//Overrides normal behavior until cleared
bState = NPCInfo->tempBehavior;
}
else
{
if(!NPCInfo->behaviorState)
NPCInfo->behaviorState = NPCInfo->defaultBehavior;
bState = NPCInfo->behaviorState;
}
//Pick the proper bstate for us and run it
NPC_RunBehavior( self->client->playerTeam, bState );
// if(bState != BS_POINT_COMBAT && NPCInfo->combatPoint != -1)
// {
//level.combatPoints[NPCInfo->combatPoint].occupied = qfalse;
//NPCInfo->combatPoint = -1;
// }
//Here we need to see what the scripted stuff told us to do
//Only process snapshot if independant and in combat mode- this would pick enemies and go after needed items
// ProcessSnapshot();
//Ignore my needs if I'm under script control- this would set needs for items
// CheckSelf();
//Back to normal? All decisions made?
//FIXME: don't walk off ledges unless we can get to our goal faster that way, or that's our goal's surface
//NPCPredict();
if ( NPC->enemy )
{
if ( !NPC->enemy->inuse )
{//just in case bState doesn't catch this
G_ClearEnemy( NPC );
}
}
if ( NPC->client->ps.saberLockTime && NPC->client->ps.saberLockEnemy != ENTITYNUM_NONE )
{
NPC_SetLookTarget( NPC, NPC->client->ps.saberLockEnemy, level.time+1000 );
}
else if ( !NPC_CheckLookTarget( NPC ) )
{
if ( NPC->enemy )
{
NPC_SetLookTarget( NPC, NPC->enemy->s.number, 0 );
}
}
if ( NPC->enemy )
{
if(NPC->enemy->flags & FL_DONT_SHOOT)
{
ucmd.buttons &= ~BUTTON_ATTACK;
ucmd.buttons &= ~BUTTON_ALT_ATTACK;
}
else if ( NPC->client->playerTeam != NPCTEAM_ENEMY && NPC->enemy->NPC && (NPC->enemy->NPC->surrenderTime > level.time || (NPC->enemy->NPC->scriptFlags&SCF_FORCED_MARCH)) )
{//don't shoot someone who's surrendering if you're a good guy
ucmd.buttons &= ~BUTTON_ATTACK;
ucmd.buttons &= ~BUTTON_ALT_ATTACK;
}
if(client->ps.weaponstate == WEAPON_IDLE)
{
client->ps.weaponstate = WEAPON_READY;
}
}
else
{
if(client->ps.weaponstate == WEAPON_READY)
{
client->ps.weaponstate = WEAPON_IDLE;
}
}
if(!(ucmd.buttons & BUTTON_ATTACK) && NPC->attackDebounceTime > level.time)
{//We just shot but aren't still shooting, so hold the gun up for a while
if(client->ps.weapon == WP_SABER )
{//One-handed
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY1,SETANIM_FLAG_NORMAL);
}
else if(client->ps.weapon == WP_BRYAR_PISTOL)
{//Sniper pose
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
}
/*//FIXME: What's the proper solution here?
else
{//heavy weapon
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
}
*/
}
else if ( !NPC->enemy )//HACK!
{
// if(client->ps.weapon != WP_TRICORDER)
{
if( NPC->s.torsoAnim == TORSO_WEAPONREADY1 || NPC->s.torsoAnim == TORSO_WEAPONREADY3 )
{//we look ready for action, using one of the first 2 weapon, let's rest our weapon on our shoulder
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
}
}
}
NPC_CheckAttackHold();
NPC_ApplyScriptFlags();
//cliff and wall avoidance
NPC_AvoidWallsAndCliffs();
// run the bot through the server like it was a real client
//=== Save the ucmd for the second no-think Pmove ============================
ucmd.serverTime = level.time - 50;
memcpy( &NPCInfo->last_ucmd, &ucmd, sizeof( usercmd_t ) );
if ( !NPCInfo->attackHoldTime )
{
NPCInfo->last_ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);//so we don't fire twice in one think
}
//============================================================================
NPC_CheckAttackScript();
NPC_KeepCurrentFacing();
if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
{//If we were following a roff, we don't do normal pmoves.
ClientThink( NPC->s.number, &ucmd );
}
else
{
NPC_ApplyRoff();
}
// end of thinking cleanup
NPCInfo->touchedByPlayer = NULL;
NPC_CheckPlayerAim();
NPC_CheckAllClear();
/*if( ucmd.forwardmove || ucmd.rightmove )
{
int i, la = -1, ta = -1;
for(i = 0; i < MAX_ANIMATIONS; i++)
{
if( NPC->client->ps.legsAnim == i )
{
la = i;
}
if( NPC->client->ps.torsoAnim == i )
{
ta = i;
}
if(la != -1 && ta != -1)
{
break;
}
}
if(la != -1 && ta != -1)
{//FIXME: should never play same frame twice or restart an anim before finishing it
Com_Printf("LegsAnim: %s(%d) TorsoAnim: %s(%d)\n", animTable[la].name, NPC->renderInfo.legsFrame, animTable[ta].name, NPC->client->renderInfo.torsoFrame);
}
}*/
}
void
ServerGame::clientThink( int clientNum ) const
{
ClientThink( clientNum );
}
void VM::VMHandleSyscall(uint32_t id, Util::Reader reader) {
int major = id >> 16;
int minor = id & 0xffff;
if (major == VM::QVM) {
switch (minor) {
case GAME_STATIC_INIT:
IPC::HandleMsg<GameStaticInitMsg>(VM::rootChannel, std::move(reader), [] (int milliseconds) {
VM::InitializeProxies(milliseconds);
FS::Initialize();
VM::VMInit();
});
break;
case GAME_INIT:
IPC::HandleMsg<GameInitMsg>(VM::rootChannel, std::move(reader), [](int levelTime, int randomSeed, bool cheats, bool inClient) {
g_cheats.integer = cheats;
G_InitGame(levelTime, randomSeed, inClient);
});
break;
case GAME_SHUTDOWN:
IPC::HandleMsg<GameShutdownMsg>(VM::rootChannel, std::move(reader), [](bool restart) {
G_ShutdownGame(restart);
});
break;
case GAME_CLIENT_CONNECT:
IPC::HandleMsg<GameClientConnectMsg>(VM::rootChannel, std::move(reader), [](int clientNum, bool firstTime, int isBot, bool& denied, std::string& reason) {
const char* deniedStr = isBot ? ClientBotConnect(clientNum, firstTime, TEAM_NONE) : ClientConnect(clientNum, firstTime);
denied = deniedStr != nullptr;
if (denied)
reason = deniedStr;
});
break;
case GAME_CLIENT_THINK:
IPC::HandleMsg<GameClientThinkMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientThink(clientNum);
});
break;
case GAME_CLIENT_USERINFO_CHANGED:
IPC::HandleMsg<GameClientUserinfoChangedMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientUserinfoChanged(clientNum, false);
});
break;
case GAME_CLIENT_DISCONNECT:
IPC::HandleMsg<GameClientDisconnectMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientDisconnect(clientNum);
});
break;
case GAME_CLIENT_BEGIN:
IPC::HandleMsg<GameClientBeginMsg>(VM::rootChannel, std::move(reader), [](int clientNum) {
ClientBegin(clientNum);
});
break;
case GAME_CLIENT_COMMAND:
IPC::HandleMsg<GameClientCommandMsg>(VM::rootChannel, std::move(reader), [](int clientNum, std::string command) {
Cmd::PushArgs(command);
ClientCommand(clientNum);
Cmd::PopArgs();
});
break;
case GAME_RUN_FRAME:
IPC::HandleMsg<GameRunFrameMsg>(VM::rootChannel, std::move(reader), [](int levelTime) {
G_RunFrame(levelTime);
});
break;
case GAME_SNAPSHOT_CALLBACK:
G_Error("GAME_SNAPSHOT_CALLBACK not implemented");
break;
case BOTAI_START_FRAME:
G_Error("BOTAI_START_FRAME not implemented");
break;
case GAME_MESSAGERECEIVED:
G_Error("GAME_MESSAGERECEIVED not implemented");
break;
default:
G_Error("VMMain(): unknown game command %i", minor);
}
} else if (major < VM::LAST_COMMON_SYSCALL) {
VM::HandleCommonSyscall(major, minor, std::move(reader), VM::rootChannel);
} else {
G_Error("unhandled VM major syscall number %i", major);
}
}
/*
===============
NPC_ExecuteBState
MCG
NPC Behavior state thinking
===============
*/
void NPC_ExecuteBState ( gentity_t *self)//, int msec )
{
bState_t bState;
NPC_HandleAIFlags();
//FIXME: these next three bits could be a function call, some sort of setup/cleanup func
//Lookmode must be reset every think cycle
if(NPC->aimDebounceTime < level.time)
{
NPCInfo->lookMode = LT_NONE;
}
if(NPC->delayScriptTime && NPC->delayScriptTime <= level.time)
{
G_ActivateBehavior( NPC, BSET_DELAYED);
NPC->delayScriptTime = 0;
}
//Clear this and let bState set it itself, so it automatically handles changing bStates... but we need a set bState wrapper func
NPCInfo->combatMove = qfalse;
//Execute our bState
if(NPCInfo->tempBehavior)
{//Overrides normal behavior until cleared
bState = NPCInfo->tempBehavior;
}
else
{
if(!NPCInfo->behaviorState)
NPCInfo->behaviorState = NPCInfo->defaultBehavior;
bState = NPCInfo->behaviorState;
}
//Pick the proper bstate for us and run it
NPC_RunBehavior( self->client->playerTeam, bState );
//FIXME: Make these a func call
if(bState != BS_FORMATION)
{//So we know to re-acquire our closest squadpath point
self->NPC->lastSquadPoint = -1;
// NPCInfo->aiFlags |= NPCAI_OFF_PATH;
}
if(bState != BS_POINT_COMBAT && NPCInfo->combatPoint != -1)
{
//level.combatPoints[NPCInfo->combatPoint].occupied = qfalse;
//NPCInfo->combatPoint = -1;
}
//Here we need to see what the scripted stuff told us to do
//Only process snapshot if independant and in combat mode- this would pick enemies and go after needed items
// ProcessSnapshot();
//Ignore my needs if I'm under script control- this would set needs for items
// CheckSelf();
//Back to normal? All decisions made?
//FIXME: don't walk off ledges unless we can get to our goal faster that way, or that's our goal's surface
//NPCPredict();
if ( NPC->enemy )
{
if ( !NPC->enemy->inuse )
{//just in case bState doesn't catch this
G_ClearEnemy( NPC );
}
}
if ( !NPC_CheckLookTarget( NPC ) )
{
if ( NPC->enemy )
{
if ( NPC->client->ps.weapon != WP_IMPERIAL_BLADE && NPC->client->ps.weapon != WP_KLINGON_BLADE )
{//looking right at enemy during melee looks odd
NPC_SetLookTarget( NPC, NPC->enemy->s.number, 0 );
}
}
}
if ( NPC->enemy )
{
if(NPC->enemy->flags & FL_DONT_SHOOT)
{
ucmd.buttons &= ~BUTTON_ATTACK;
}
if(client->ps.weaponstate == WEAPON_IDLE)
{
client->ps.weaponstate = WEAPON_READY;
}
}
else
{
if(client->ps.weaponstate == WEAPON_READY)
{
client->ps.weaponstate = WEAPON_IDLE;
}
}
if(!(ucmd.buttons & BUTTON_ATTACK) && NPC->attackDebounceTime > level.time)
{//We just shot but aren't still shooting, so hold the gun up for a while
if(client->ps.weapon == WP_PHASER )
{//One-handed
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY1,SETANIM_FLAG_NORMAL);
}
else if(client->ps.weapon == WP_COMPRESSION_RIFLE)
{//Sniper pose
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY2,SETANIM_FLAG_NORMAL);
}
/*//FIXME: What's the proper solution here?
else
{//heavy weapon
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
}
*/
}
else if (!NPC->enemy && bState != BS_FORMATION)//HACK!
{
if(client->ps.weapon != WP_TRICORDER)
{
if((NPC->s.torsoAnim&~ANIM_TOGGLEBIT) == TORSO_WEAPONREADY1 || (NPC->s.torsoAnim&~ANIM_TOGGLEBIT) == TORSO_WEAPONREADY2)
{//we look ready for action, using one of the first 2 weapon, let's rest our weapon on our shoulder
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONIDLE1,SETANIM_FLAG_NORMAL);
}
}
}
NPC_CheckAttackHold();
NPC_ApplyScriptFlags();
//cliff and wall avoidance
NPC_AvoidWallsAndCliffs();
// run the bot through the server like it was a real client
//=== Save the ucmd for the second no-think Pmove ============================
ucmd.serverTime = level.time - 50;
NPCInfo->last_ucmd = ucmd;
if ( !NPCInfo->attackHoldTime )
{
NPCInfo->last_ucmd.buttons &= ~BUTTON_ATTACK;//so we don't fire twice in one think
}
//============================================================================
NPC_CheckAttackScript();
NPC_KeepCurrentFacing();
if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
{//If we were following a roff, we don't do normal pmoves.
ClientThink( NPC->s.number, &ucmd );
}
else
{
NPC_ApplyRoff();
}
//Had to leave this in, some legacy code must still be using s.angles
//Shouldn't interfere with interpolation of angles, should it?
VectorCopy( client->ps.viewangles, NPC->currentAngles );
// end of thinking cleanup
NPCInfo->touchedByPlayer = NULL;
NPC_CheckPlayerAim();
NPC_CheckAllClear();
/*if( ucmd.forwardmove || ucmd.rightmove )
{
int i, la = -1, ta = -1;
for(i = 0; i < MAX_ANIMATIONS; i++)
{
if((NPC->client->ps.legsAnim&~ANIM_TOGGLEBIT) == i)
{
la = i;
}
if((NPC->client->ps.torsoAnim&~ANIM_TOGGLEBIT) == i)
{
ta = i;
}
if(la != -1 && ta != -1)
{
break;
}
}
if(la != -1 && ta != -1)
{//FIXME: should never play same frame twice or restart an anim before finishing it
gi.Printf("LegsAnim: %s(%d) TorsoAnim: %s(%d)\n", animTable[la].name, NPC->renderInfo.legsFrame, animTable[ta].name, NPC->client->renderInfo.torsoFrame);
}
}*/
}
//==========================================
// BOT_DMclass_RunFrame
// States Machine & call client movement
//==========================================
static void BOT_DMclass_RunFrame( edict_t *self )
{
usercmd_t ucmd;
float weapon_quality;
bool inhibitCombat = false;
int i;
if( G_ISGHOSTING( self ) )
{
BOT_DMclass_GhostingFrame( self );
return;
}
memset( &ucmd, 0, sizeof( ucmd ) );
//get ready if in the game
if( GS_MatchState() <= MATCH_STATE_WARMUP && !level.ready[PLAYERNUM(self)]
&& self->r.client->teamstate.timeStamp + 4000 < level.time )
G_Match_Ready( self );
if( level.gametype.dummyBots || bot_dummy->integer )
{
self->r.client->level.last_activity = level.time;
}
else
{
BOT_DMclass_FindEnemy( self );
weapon_quality = BOT_DMclass_ChooseWeapon( self );
inhibitCombat = ( AI_CurrentLinkType( self ) & (LINK_JUMPPAD|LINK_JUMP|LINK_ROCKETJUMP) ) != 0 ? true : false;
if( self->enemy && weapon_quality >= 0.3 && !inhibitCombat ) // don't fight with bad weapons
{
if( BOT_DMclass_FireWeapon( self, &ucmd ) )
self->ai->state_combat_timeout = level.time + AI_COMBATMOVE_TIMEOUT;
}
if( inhibitCombat )
self->ai->state_combat_timeout = 0;
if( self->ai->state_combat_timeout > level.time )
{
BOT_DMclass_CombatMovement( self, &ucmd );
}
else
{
BOT_DMclass_Move( self, &ucmd );
}
//set up for pmove
for( i = 0; i < 3; i++ )
ucmd.angles[i] = ANGLE2SHORT( self->s.angles[i] ) - self->r.client->ps.pmove.delta_angles[i];
VectorSet( self->r.client->ps.pmove.delta_angles, 0, 0, 0 );
}
// set approximate ping and show values
ucmd.msec = game.frametime;
ucmd.serverTimeStamp = game.serverTime;
ClientThink( self, &ucmd, 0 );
self->nextThink = level.time + 1;
BOT_DMclass_VSAYmessages( self );
}
/**
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)
{
int index;
vec3_t spawn_origin, spawn_angles;
gclient_t *client;
clientPersistant_t saved;
clientSession_t savedSess;
int persistant[MAX_PERSISTANT];
gentity_t *spawnPoint;
gentity_t *tent;
int flags;
int eventSequence;
char userinfo[MAX_INFO_STRING];
index = ent - g_entities;
client = ent->client;
// follow other players when eliminated
if (!level.warmupTime && g_gametype.integer == GT_ELIMINATION
&& client->sess.sessionTeam != TEAM_SPECTATOR)
{
if (level.roundStarted) {
client->sess.spectatorState = SPECTATOR_FREE;
client->eliminated = qtrue;
return;
} else {
client->sess.spectatorState = SPECTATOR_NOT;
client->eliminated = qfalse;
}
}
VectorClear(spawn_origin);
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if (client->sess.sessionTeam == TEAM_SPECTATOR) {
SelectSpectatorSpawnPoint(spawn_origin, spawn_angles);
} else if (g_gametype.integer == GT_DEFRAG) {
spawnPoint = SelectDefragSpawnPoint(spawn_origin, spawn_angles);
} else if (g_gametype.integer == GT_CTF) {
spawnPoint = SelectCTFSpawnPoint(client->sess.sessionTeam,
spawn_origin, spawn_angles, !!(ent->r.svFlags & SVF_BOT));
} else if (client->pers.lastKiller) {
spawnPoint = SelectSpawnPoint(client->pers.lastKiller->ps.origin, spawn_origin,
spawn_angles, ent->r.svFlags & SVF_BOT);
} else {
spawnPoint = SelectSpawnPoint(client->ps.origin, spawn_origin,
spawn_angles, ent->r.svFlags & SVF_BOT);
}
if (!spawnPoint) {
G_Error("Cannot find a spawn point.\n");
return;
}
// toggle the teleport bit so the client knows to not lerp
flags = ent->client->ps.eFlags & (EF_TELEPORT_BIT);
flags ^= EF_TELEPORT_BIT;
// unlagged - backward reconciliation #3
// we don't want players being backward-reconciled to the place they died
G_ResetHistory( ent );
// and this is as good a time as any to clear the saved state
ent->client->saved.leveltime = 0;
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
eventSequence = client->ps.eventSequence;
Com_Memcpy(persistant, client->ps.persistant, sizeof persistant);
Com_Memset(client, 0, sizeof(*client));
client->pers = saved;
client->sess = savedSess;
client->ps.eventSequence = eventSequence;
Com_Memcpy(client->ps.persistant, persistant, sizeof client->ps.persistant);
// increment the spawncount so the client will detect the respawn
client->ps.persistant[PERS_SPAWN_COUNT]++;
client->ps.persistant[PERS_TEAM] = client->sess.sessionTeam;
client->airOutTime = level.time + 12000;
trap_GetUserinfo(index, userinfo, sizeof(userinfo));
// set max health
client->pers.maxHealth = atoi(Info_ValueForKey(userinfo, "handicap"));
if (client->pers.maxHealth < 1 || client->pers.maxHealth > 100) {
client->pers.maxHealth = 100;
}
// clear entity values
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
client->ps.eFlags = flags;
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 &= ~FL_NO_KNOCKBACK;
ent->flags &= ~FL_FORCE_GESTURE;
VectorCopy(playerMins, ent->r.mins);
VectorCopy(playerMaxs, ent->r.maxs);
client->ps.clientNum = index;
ClientGiveWeapons(client);
if (g_gametype.integer == GT_ELIMINATION) {
client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] * 2;
client->ps.stats[STAT_ARMOR] = client->ps.stats[STAT_MAX_HEALTH] * 1.5;
} else {
client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] + 25;
}
ent->health = client->ps.stats[STAT_HEALTH];
G_SetOrigin(ent, spawn_origin);
VectorCopy(spawn_origin, client->ps.origin);
// 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);
SetClientViewAngle(ent, spawn_angles);
// 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;
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) {
// move players to intermission
MoveClientToIntermission(ent);
} else if (ent->client->sess.sessionTeam != TEAM_SPECTATOR) {
G_KillBox(ent);
// fire the targets of the spawn point
G_UseTargets(spawnPoint, ent);
// positively link the client, even if the command times are weird
VectorCopy(ent->client->ps.origin, ent->r.currentOrigin);
tent = G_TempEntity(ent->client->ps.origin, EV_PLAYER_TELEPORT_IN);
tent->s.clientNum = ent->s.clientNum;
trap_LinkEntity (ent);
}
// run a client frame to drop exactly to the floor,
// initialize animations and other things
client->ps.commandTime = level.totalTime - 100;
client->pers.cmd.serverTime = level.totalTime;
ClientThink(ent-g_entities);
// run the presend to set anything else, follow spectators wait
// until all clients have been reconnected after map_restart
if (ent->client->sess.spectatorState != SPECTATOR_FOLLOW) {
ClientEndFrame(ent);
}
// clear entity state values
BG_PlayerStateToEntityState(&client->ps, &ent->s, qtrue);
}
// Module RPC entry point
static void VMMain(int index, RPC::Reader& inputs, RPC::Writer& outputs)
{
switch (index) {
case GAME_INIT:
{
int levelTime = inputs.ReadInt();
int randomSeed = inputs.ReadInt();
qboolean restart = inputs.ReadInt();
G_InitGame(levelTime, randomSeed, restart);
break;
}
case GAME_SHUTDOWN:
G_ShutdownGame(inputs.ReadInt());
break;
case GAME_CLIENT_CONNECT:
{
int clientNum = inputs.ReadInt();
qboolean firstTime = inputs.ReadInt();
qboolean isBot = inputs.ReadInt();
const char* denied = isBot ? ClientBotConnect(clientNum, firstTime, TEAM_NONE) : ClientConnect(clientNum, firstTime);
outputs.WriteInt(denied ? qtrue : qfalse);
if (denied)
outputs.WriteString(denied);
break;
}
case GAME_CLIENT_THINK:
ClientThink(inputs.ReadInt());
break;
case GAME_CLIENT_USERINFO_CHANGED:
ClientUserinfoChanged(inputs.ReadInt(), qfalse);
break;
case GAME_CLIENT_DISCONNECT:
ClientDisconnect(inputs.ReadInt());
break;
case GAME_CLIENT_BEGIN:
ClientBegin(inputs.ReadInt());
break;
case GAME_CLIENT_COMMAND:
ClientCommand(inputs.ReadInt());
break;
case GAME_RUN_FRAME:
G_RunFrame(inputs.ReadInt());
break;
case GAME_CONSOLE_COMMAND:
outputs.WriteInt(ConsoleCommand());
break;
case GAME_SNAPSHOT_CALLBACK:
G_Error("GAME_SNAPSHOT_CALLBACK not implemented");
break;
case BOTAI_START_FRAME:
G_Error("BOTAI_START_FRAME not implemented");
break;
case GAME_MESSAGERECEIVED:
G_Error("GAME_MESSAGERECEIVED not implemented");
break;
default:
G_Error("VMMain(): unknown game command %i", index);
}
}
/*
===========
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) {
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;
int flags;
int savedPing;
// char *savedAreaBits;
int accuracy_hits, accuracy_shots;
int eventSequence;
// char userinfo[MAX_INFO_STRING];
forcedata_t savedForce;
void *ghoul2save;
int saveSaberNum = ENTITYNUM_NONE;
int wDisable = 0;
index = ent - g_entities;
client = ent->client;
if (client->ps.fd.forceDoInit)
{ //force a reread of force powers
WP_InitForcePowers( ent );
client->ps.fd.forceDoInit = 0;
}
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
spawnPoint = SelectSpectatorSpawnPoint (
spawn_origin, spawn_angles);
} else if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) {
// all base oriented team games use the CTF spawn points
spawnPoint = SelectCTFSpawnPoint (
client->sess.sessionTeam,
client->pers.teamState.state,
spawn_origin, spawn_angles);
}
else if (g_gametype.integer == GT_SAGA)
{
spawnPoint = SelectSagaSpawnPoint (
client->sess.sessionTeam,
client->pers.teamState.state,
spawn_origin, spawn_angles);
}
else {
do {
// the first spawn should be at a good looking spot
if ( !client->pers.initialSpawn && client->pers.localClient ) {
client->pers.initialSpawn = qtrue;
spawnPoint = SelectInitialSpawnPoint( spawn_origin, spawn_angles );
} else {
// don't spawn near existing origin if possible
spawnPoint = SelectSpawnPoint (
client->ps.origin,
spawn_origin, spawn_angles);
}
// Tim needs to prevent bots from spawning at the initial point
// on q3dm0...
if ( ( spawnPoint->flags & FL_NO_BOTS ) && ( ent->r.svFlags & SVF_BOT ) ) {
continue; // try again
}
// just to be symetric, we have a nohumans option...
if ( ( spawnPoint->flags & FL_NO_HUMANS ) && !( ent->r.svFlags & SVF_BOT ) ) {
continue; // try again
}
break;
} while ( 1 );
}
client->pers.teamState.state = TEAM_ACTIVE;
// toggle the teleport bit so the client knows to not lerp
// and never clear the voted flag
flags = ent->client->ps.eFlags & (EF_TELEPORT_BIT | EF_VOTED | EF_TEAMVOTED);
flags ^= EF_TELEPORT_BIT;
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
// savedAreaBits = client->areabits;
accuracy_hits = client->accuracy_hits;
accuracy_shots = client->accuracy_shots;
for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) {
persistant[i] = client->ps.persistant[i];
}
eventSequence = client->ps.eventSequence;
savedForce = client->ps.fd;
ghoul2save = client->ghoul2;
saveSaberNum = client->ps.saberEntityNum;
memset (client, 0, sizeof(*client)); // bk FIXME: Com_Memset?
//rww - Don't wipe the ghoul2 instance or the animation data
client->ghoul2 = ghoul2save;
//or the saber ent num
client->ps.saberEntityNum = saveSaberNum;
client->ps.fd = savedForce;
client->ps.duelIndex = ENTITYNUM_NONE;
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
// client->areabits = savedAreaBits;
client->accuracy_hits = accuracy_hits;
client->accuracy_shots = accuracy_shots;
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_TEAM] = client->sess.sessionTeam;
client->airOutTime = level.time + 12000;
// trap_GetUserinfo( index, userinfo, sizeof(userinfo) );
// set max health
client->pers.maxHealth = 100;//atoi( Info_ValueForKey( userinfo, "handicap" ) );
if ( client->pers.maxHealth < 1 || client->pers.maxHealth > 100 ) {
client->pers.maxHealth = 100;
}
// clear entity values
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
client->ps.eFlags = flags;
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;
VectorCopy (playerMins, ent->r.mins);
VectorCopy (playerMaxs, ent->r.maxs);
client->ps.clientNum = index;
//give default weapons
client->ps.stats[STAT_WEAPONS] = ( 1 << WP_NONE );
if (g_gametype.integer == GT_HOLOCRON)
{
//always get free saber level 1 in holocron
client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_SABER ); //these are precached in g_items, ClearRegisteredItems()
}
else
{
if (client->ps.fd.forcePowerLevel[FP_SABERATTACK])
{
client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_SABER ); //these are precached in g_items, ClearRegisteredItems()
}
else
{ //if you don't have saber attack rank then you don't get a saber
client->ps.stats[STAT_WEAPONS] |= (1 << WP_STUN_BATON);
}
}
if (g_gametype.integer == GT_TOURNAMENT)
{
wDisable = g_duelWeaponDisable.integer;
}
else
{
wDisable = g_weaponDisable.integer;
}
if (!wDisable || !(wDisable & (1 << WP_BRYAR_PISTOL)))
{
client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BRYAR_PISTOL );
}
else if (g_gametype.integer == GT_JEDIMASTER)
{
client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BRYAR_PISTOL );
}
if (g_gametype.integer == GT_JEDIMASTER)
{
client->ps.stats[STAT_WEAPONS] &= ~(1 << WP_SABER);
client->ps.stats[STAT_WEAPONS] |= (1 << WP_STUN_BATON);
}
if (client->ps.stats[STAT_WEAPONS] & (1 << WP_BRYAR_PISTOL))
{
client->ps.weapon = WP_BRYAR_PISTOL;
}
else if (client->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
{
client->ps.weapon = WP_SABER;
}
else
{
client->ps.weapon = WP_STUN_BATON;
}
/*
client->ps.stats[STAT_HOLDABLE_ITEMS] |= ( 1 << HI_BINOCULARS );
client->ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_BINOCULARS, IT_HOLDABLE);
*/
client->ps.stats[STAT_HOLDABLE_ITEMS] = 0;
client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
if ( client->sess.sessionTeam == TEAM_SPECTATOR )
{
client->ps.stats[STAT_WEAPONS] = 0;
client->ps.stats[STAT_HOLDABLE_ITEMS] = 0;
client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
}
client->ps.ammo[AMMO_BLASTER] = 100; //ammoData[AMMO_BLASTER].max; //100 seems fair.
// client->ps.ammo[AMMO_POWERCELL] = ammoData[AMMO_POWERCELL].max;
// client->ps.ammo[AMMO_FORCE] = ammoData[AMMO_FORCE].max;
// client->ps.ammo[AMMO_METAL_BOLTS] = ammoData[AMMO_METAL_BOLTS].max;
// client->ps.ammo[AMMO_ROCKETS] = ammoData[AMMO_ROCKETS].max;
/*
client->ps.stats[STAT_WEAPONS] = ( 1 << WP_BRYAR_PISTOL);
if ( g_gametype.integer == GT_TEAM ) {
client->ps.ammo[WP_BRYAR_PISTOL] = 50;
} else {
client->ps.ammo[WP_BRYAR_PISTOL] = 100;
}
*/
client->ps.rocketLockIndex = MAX_CLIENTS;
client->ps.rocketLockTime = 0;
//rww - Set here to initialize the circling seeker drone to off.
//A quick note about this so I don't forget how it works again:
//ps.genericEnemyIndex is kept in sync between the server and client.
//When it gets set then an entitystate value of the same name gets
//set along with an entitystate flag in the shared bg code. Which
//is why a value needs to be both on the player state and entity state.
//(it doesn't seem to just carry over the entitystate value automatically
//because entity state value is derived from player state data or some
//such)
client->ps.genericEnemyIndex = -1;
client->ps.isJediMaster = qfalse;
client->ps.fallingToDeath = 0;
//Do per-spawn force power initialization
WP_SpawnInitForcePowers( ent );
// health will count down towards max_health
ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];// * 1.25; Boot - no extra 25 hp on start.
// Start with a small amount of armor as well.
client->ps.stats[STAT_ARMOR] = client->ps.stats[STAT_MAX_HEALTH] * 0.25;
G_SetOrigin( ent, spawn_origin );
VectorCopy( spawn_origin, client->ps.origin );
// 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 );
SetClientViewAngle( ent, spawn_angles );
if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
} else {
G_KillBox( ent );
trap_LinkEntity (ent);
// force the base weapon up
client->ps.weapon = WP_BRYAR_PISTOL;
client->ps.weaponstate = FIRST_WEAPON;
}
// 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;
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
// set default animations
client->ps.torsoAnim = WeaponReadyAnim[client->ps.weapon];
client->ps.legsAnim = WeaponReadyAnim[client->ps.weapon];
if ( level.intermissiontime ) {
MoveClientToIntermission( ent );
} else {
// fire the targets of the spawn point
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 ( client->ps.stats[STAT_WEAPONS] & ( 1 << i ) ) {
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 ( ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
trap_LinkEntity( ent );
}
if (g_spawnInvulnerability.integer)
{
ent->client->ps.eFlags |= EF_INVULNERABLE;
ent->client->invulnerableTimer = level.time + g_spawnInvulnerability.integer;
}
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
}
/*
===============
NPC_ExecuteBState
MCG
NPC Behavior state thinking
===============
*/
void NPC_ExecuteBState ( gentity_t *self)//, int msec )
{
bState_t bState;
NPC_HandleAIFlags();
//FIXME: these next three bits could be a function call, some sort of setup/cleanup func
//Lookmode must be reset every think cycle
if(NPC->delayScriptTime && NPC->delayScriptTime <= level.time)
{
G_ActivateBehavior( NPC, BSET_DELAYED);
NPC->delayScriptTime = 0;
}
//Clear this and let bState set it itself, so it automatically handles changing bStates... but we need a set bState wrapper func
NPCInfo->combatMove = qfalse;
//Execute our bState
if(NPCInfo->tempBehavior)
{//Overrides normal behavior until cleared
bState = NPCInfo->tempBehavior;
}
else
{
if(!NPCInfo->behaviorState)
NPCInfo->behaviorState = NPCInfo->defaultBehavior;
bState = NPCInfo->behaviorState;
}
//Pick the proper bstate for us and run it
NPC_RunBehavior( self->client->playerTeam, bState );
if ( NPC->enemy )
{
if ( !NPC->enemy->inuse )
{//just in case bState doesn't catch this
G_ClearEnemy( NPC );
}
}
if ( NPC->client->ps.saberLockTime && NPC->client->ps.saberLockEnemy != ENTITYNUM_NONE )
{
NPC_SetLookTarget( NPC, NPC->client->ps.saberLockEnemy, level.time+1000 );
}
else if ( !NPC_CheckLookTarget( NPC ) )
{
if ( NPC->enemy )
{
NPC_SetLookTarget( NPC, NPC->enemy->s.number, 0 );
}
}
if ( NPC->enemy )
{
if(NPC->enemy->flags & FL_DONT_SHOOT)
{
ucmd.buttons &= ~BUTTON_ATTACK;
ucmd.buttons &= ~BUTTON_ALT_ATTACK;
}
else if ( NPC->client->playerTeam != NPCTEAM_ENEMY && NPC->enemy->NPC && (NPC->enemy->NPC->surrenderTime > level.time || (NPC->enemy->NPC->scriptFlags&SCF_FORCED_MARCH)) )
{//don't shoot someone who's surrendering if you're a good guy
ucmd.buttons &= ~BUTTON_ATTACK;
ucmd.buttons &= ~BUTTON_ALT_ATTACK;
}
if(client->ps.weaponstate == WEAPON_IDLE)
{
client->ps.weaponstate = WEAPON_READY;
}
}
else
{
if(client->ps.weaponstate == WEAPON_READY)
{
client->ps.weaponstate = WEAPON_IDLE;
}
}
if(!(ucmd.buttons & BUTTON_ATTACK) && NPC->attackDebounceTime > level.time)
{//We just shot but aren't still shooting, so hold the gun up for a while
if(client->ps.weapon == WP_SABER )
{//One-handed
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY1,SETANIM_FLAG_NORMAL);
}
else if(client->ps.weapon == WP_BRYAR_PISTOL)
{//Sniper pose
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
}
}
else if ( !NPC->enemy )//HACK!
{
{
if( NPC->s.torsoAnim == TORSO_WEAPONREADY1 || NPC->s.torsoAnim == TORSO_WEAPONREADY3 )
{//we look ready for action, using one of the first 2 weapon, let's rest our weapon on our shoulder
NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
}
}
}
NPC_CheckAttackHold();
NPC_ApplyScriptFlags();
//cliff and wall avoidance
NPC_AvoidWallsAndCliffs();
// run the bot through the server like it was a real client
//=== Save the ucmd for the second no-think Pmove ============================
ucmd.serverTime = level.time - 50;
memcpy( &NPCInfo->last_ucmd, &ucmd, sizeof( usercmd_t ) );
if ( !NPCInfo->attackHoldTime )
{
NPCInfo->last_ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);//so we don't fire twice in one think
}
//============================================================================
NPC_CheckAttackScript();
NPC_KeepCurrentFacing();
if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
{//If we were following a roff, we don't do normal pmoves.
ClientThink( NPC->s.number, &ucmd );
}
else
{
NPC_ApplyRoff();
}
// end of thinking cleanup
NPCInfo->touchedByPlayer = NULL;
NPC_CheckPlayerAim();
NPC_CheckAllClear();
}
/*
===========
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) {
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;
int flags;
int savedPing;
// char *savedAreaBits;
int accuracy_hits, accuracy_shots;
int eventSequence;
char userinfo[MAX_INFO_STRING];
index = ent - g_entities;
client = ent->client;
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
spawnPoint = SelectSpectatorSpawnPoint (
spawn_origin, spawn_angles);
} else {
do {
// the first spawn should be at a good looking spot
if ( !client->pers.initialSpawn && client->pers.localClient ) {
client->pers.initialSpawn = qtrue;
spawnPoint = SelectInitialSpawnPoint( spawn_origin, spawn_angles );
} else {
// don't spawn near existing origin if possible
spawnPoint = SelectSpawnPoint (
client->ps.origin,
spawn_origin, spawn_angles);
}
// Tim needs to prevent bots from spawning at the initial point
// on q3dm0...
if ( ( spawnPoint->flags & FL_NO_BOTS ) && ( ent->r.svFlags & SVF_BOT ) ) {
continue; // try again
}
// just to be symetric, we have a nohumans option...
if ( ( spawnPoint->flags & FL_NO_HUMANS ) && !( ent->r.svFlags & SVF_BOT ) ) {
continue; // try again
}
break;
} while ( 1 );
}
client->pers.teamState.state = TEAM_ACTIVE;
// always clear the kamikaze flag
// ent->s.eFlags &= ~EF_KAMIKAZE;
// toggle the teleport bit so the client knows to not lerp
// and never clear the voted flag
flags = ent->s.eFlags & (EF_TELEPORT_BIT | EF_VOTED | EF_TEAMVOTED);
flags ^= EF_TELEPORT_BIT;
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
// savedAreaBits = client->areabits;
accuracy_hits = client->accuracy_hits;
accuracy_shots = client->accuracy_shots;
Com_Memset (client, 0, sizeof(*client));
client->ps.stats[STAT_ATTACKERCLIENT] = -1;
client->ps.stats[STAT_INFOCLIENT] = -1;
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
// client->areabits = savedAreaBits;
client->accuracy_hits = accuracy_hits;
client->accuracy_shots = accuracy_shots;
client->lastkilled_client = -1;
client->airOutTime = level.time + 12000;
trap_GetUserinfo( index, userinfo, sizeof(userinfo) );
// set max health
client->pers.maxHealth = atoi( Info_ValueForKey( userinfo, "handicap" ) );
if ( client->pers.maxHealth < 1 || client->pers.maxHealth > 100 ) {
client->pers.maxHealth = 100;
}
// clear entity values
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
ent->s.eFlags = flags;
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;
VectorCopy (playerMins, ent->r.mins);
VectorCopy (playerMaxs, ent->r.maxs);
client->ps.clientNum = index;
// health will count down towards max_health
ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] + 25;
G_SetOrigin( ent, spawn_origin );
VectorCopy( spawn_origin, client->ps.origin );
// 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 );
SetClientViewAngle( ent, spawn_angles );
if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
} else {
G_KillBox( ent );
trap_LinkEntity (ent);
}
// 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;
client->inactivityTime = level.time + g_inactivity.integer * 1000;
client->latched_buttons = 0;
if ( level.intermissiontime ) {
MoveClientToIntermission( ent );
} else {
// fire the targets of the spawn point
G_UseTargets( spawnPoint, ent );
}
// 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 ( ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
trap_LinkEntity( ent );
}
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
ent->s.modelindex = G_ModelIndex("models/human/coxswain.tik");
}
/*
===========
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
Initializes all non-persistant parts of playerState
============
*/
void ClientSpawn(gentity_t *ent) {
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;
int flags;
int savedPing;
// char *savedAreaBits;
int accuracy_hits, accuracy_shots;
int eventSequence;
char userinfo[MAX_INFO_STRING];
int weapon;
index = ent - g_entities;
client = ent->client;
// find a spawn point
// do it before setting health back up, so farthest
// ranging doesn't count this client
if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
spawnPoint = SelectSpectatorSpawnPoint (
spawn_origin, spawn_angles);
} else if (g_gametype.integer >= GT_CTF ) {
// all base oriented team games use the CTF spawn points
spawnPoint = SelectCTFSpawnPoint (
client->sess.sessionTeam,
client->pers.teamState.state,
spawn_origin, spawn_angles);
} else {
do {
// the first spawn should be at a good looking spot
if ( !client->pers.initialSpawn && client->pers.localClient ) {
client->pers.initialSpawn = qtrue;
spawnPoint = SelectInitialSpawnPoint( spawn_origin, spawn_angles );
} else {
// don't spawn near existing origin if possible
spawnPoint = SelectSpawnPoint (
client->ps.origin,
spawn_origin, spawn_angles);
}
// Tim needs to prevent bots from spawning at the initial point
// on q3dm0...
if ( ( spawnPoint->flags & FL_NO_BOTS ) && ( ent->r.svFlags & SVF_BOT ) ) {
continue; // try again
}
// just to be symetric, we have a nohumans option...
if ( ( spawnPoint->flags & FL_NO_HUMANS ) && !( ent->r.svFlags & SVF_BOT ) ) {
continue; // try again
}
break;
} while ( 1 );
}
client->pers.teamState.state = TEAM_ACTIVE;
// always clear the kamikaze flag
ent->s.eFlags &= ~EF_KAMIKAZE;
// toggle the teleport bit so the client knows to not lerp
// and never clear the voted flag
flags = ent->client->ps.eFlags & (EF_TELEPORT_BIT | EF_VOTED | EF_TEAMVOTED);
flags ^= EF_TELEPORT_BIT;
// clear everything but the persistant data
saved = client->pers;
savedSess = client->sess;
savedPing = client->ps.ping;
// savedAreaBits = client->areabits;
accuracy_hits = client->accuracy_hits;
accuracy_shots = client->accuracy_shots;
for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) {
persistant[i] = client->ps.persistant[i];
}
eventSequence = client->ps.eventSequence;
memset (client, 0, sizeof(*client)); // bk FIXME: Com_Memset?
client->pers = saved;
client->sess = savedSess;
client->ps.ping = savedPing;
// client->areabits = savedAreaBits;
client->accuracy_hits = accuracy_hits;
client->accuracy_shots = accuracy_shots;
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_TEAM] = client->sess.sessionTeam;
client->airOutTime = level.time + 12000;
trap_GetUserinfo( index, userinfo, sizeof(userinfo) );
// set max health
client->pers.maxHealth = atoi( Info_ValueForKey( userinfo, "handicap" ) );
if ( client->pers.maxHealth < 1 || client->pers.maxHealth > 100 ) {
client->pers.maxHealth = 100;
}
// clear entity values
client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
client->ps.eFlags = flags;
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;
VectorCopy (playerMins, ent->r.mins);
VectorCopy (playerMaxs, ent->r.maxs);
client->ps.clientNum = index;
if (IsBot(client->ps.clientNum)) {
weapon = WP_LIGHTNING;
client->ps.stats[STAT_WEAPONS] = ( 1 << weapon );
client->ps.ammo[weapon] = -1;
} else {
weapon = WP_MACHINEGUN;
client->ps.stats[STAT_WEAPONS] = ( 1 << weapon );
client->ps.ammo[weapon] = 100;
client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_GAUNTLET );
client->ps.ammo[WP_GAUNTLET] = -1;
client->ps.ammo[WP_GRAPPLING_HOOK] = -1;
}
// health will count down towards max_health
ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] + 25;
G_SetOrigin( ent, spawn_origin );
VectorCopy( spawn_origin, client->ps.origin );
// 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 );
SetClientViewAngle( ent, spawn_angles );
if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
} else {
G_KillBox( ent );
trap_LinkEntity (ent);
// force the base weapon up
client->ps.weapon = 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;
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
G_UseTargets( spawnPoint, ent );
// select the highest weapon number available, after any
// spawn given items have fired
client->ps.weapon = weapon;
for ( i = WP_NUM_WEAPONS - 1 ; i > 0 ; i-- ) {
if ( client->ps.stats[STAT_WEAPONS] & ( 1 << i ) ) {
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 ( ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
trap_LinkEntity( ent );
}
// run the presend to set anything else
ClientEndFrame( ent );
// clear entity state values
BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
}
/*
===========
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 );
}
///////////////////////////////////////////////////////////////////////
// Main Think function for bot
///////////////////////////////////////////////////////////////////////
void ACEAI_Think (edict_t *self)
{
usercmd_t ucmd;
// Set up client movement
VectorCopy(self->client->ps.viewangles,self->s.angles);
VectorSet (self->client->ps.pmove.delta_angles, 0, 0, 0);
memset (&ucmd, 0, sizeof (ucmd));
self->enemy = NULL;
self->movetarget = NULL;
// Force respawn
if (self->deadflag)
{
self->client->buttons = 0;
ucmd.buttons = BUTTON_ATTACK;
}
if(self->state == STATE_WANDER && self->wander_timeout < level.time)
ACEAI_PickLongRangeGoal(self); // pick a new long range goal
// Kill the bot if completely stuck somewhere
if(VectorLength(self->velocity) > 37) //
self->suicide_timeout = level.time + 10.0;
if(self->suicide_timeout < level.time)
{
self->health = 0;
player_die (self, self, self, 100000, vec3_origin);
}
// Find any short range goal
ACEAI_PickShortRangeGoal(self);
// Look for enemies
if(ACEAI_FindEnemy(self))
{
ACEAI_ChooseWeapon(self);
ACEMV_Attack (self, &ucmd);
}
else
{
// Execute the move, or wander
if(self->state == STATE_WANDER)
ACEMV_Wander(self,&ucmd);
else if(self->state == STATE_MOVE)
ACEMV_Move(self,&ucmd);
}
//debug_printf("State: %d\n",self->state);
// set approximate ping
ucmd.msec = 75 + floor (random () * 25) + 1;
// show random ping values in scoreboard
self->client->ping = ucmd.msec;
// set bot's view angle
ucmd.angles[PITCH] = ANGLE2SHORT(self->s.angles[PITCH]);
ucmd.angles[YAW] = ANGLE2SHORT(self->s.angles[YAW]);
ucmd.angles[ROLL] = ANGLE2SHORT(self->s.angles[ROLL]);
// send command through id's code
ClientThink (self, &ucmd);
self->nextthink = level.time + FRAMETIME;
}
/*
===============
NPC_Think
Main NPC AI - called once per frame
===============
*/
void NPC_Think ( gentity_t *self)//, int msec )
{
self->nextthink = level.time + FRAMETIME;
SetNPCGlobals( self );
memset( &ucmd, 0, sizeof( ucmd ) );
// see if NPC ai is frozen
if ( debugNPCFreeze->value )
{
NPC_UpdateAngles( qtrue, qtrue );
ClientThink(self->s.number, &ucmd);
VectorCopy(self->s.origin, self->s.origin2 );
return;
}
if(!self || !self->NPC || !self->client)
{
return;
}
// dead NPCs have a special think, don't run scripts (for now)
//FIXME: this breaks deathscripts
if (self->health <= 0)
{
DeadThink();
if(NPCInfo->nextBStateThink <= level.time)
{
if( self->taskManager && !stop_icarus )
{
self->taskManager->Update( );
}
}
return;
}
self->nextthink = level.time + FRAMETIME/2;
if(NPCInfo->nextBStateThink <= level.time)
{
/*
if( self->taskManager && !stop_icarus )
{
self->taskManager->Update( );
}
*/
if(NPC->s.eType != ET_PLAYER)
{//Something drastic happened in our script
return;
}
NPC_ExecuteBState( self );
//Maybe even 200 ms?
NPCInfo->nextBStateThink = level.time + FRAMETIME;
if( self->taskManager && !stop_icarus )
{
self->taskManager->Update( );
}
}
else
{
//or use client->pers.lastCommand?
NPCInfo->last_ucmd.serverTime = level.time - 50;
if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
{//If we were following a roff, we don't do normal pmoves.
//FIXME: firing angles (no aim offset) or regular angles?
NPC_UpdateAngles(qtrue, qtrue);
ClientThink(NPC->s.number, &NPCInfo->last_ucmd);
}
else
{
NPC_ApplyRoff();
}
VectorCopy(self->s.origin, self->s.origin2 );
}
}
void Spawn() { ClientThink(); }
/*
===========
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 );
}
}
