/*
===========
AICast_DBG_RouteTable_f
===========
*/
void AICast_DBG_RouteTable_f( vec3_t org, char *param ) {
static int srcarea = 0, dstarea = 0;
// extern botlib_export_t botlib; // TTimo: unused
if ( !param || strlen( param ) < 1 ) {
trap_Print( "You must specify 'src', 'dest' or 'show'\n" );
return;
}
trap_AAS_SetCurrentWorld( 0 ); // use the default world, which should have a routetable
if ( Q_stricmp( param, "toggle" ) == 0 ) {
trap_AAS_RT_ShowRoute( vec3_origin, -666, -666 ); // stupid toggle hack
return;
}
if ( Q_stricmp( param, "src" ) == 0 ) { // set the src
srcarea = 1 + trap_AAS_PointAreaNum( org );
return;
} else if ( Q_stricmp( param, "dest" ) == 0 ) {
dstarea = 1 + trap_AAS_PointAreaNum( org );
}
if ( srcarea && dstarea ) { // show the path
trap_AAS_RT_ShowRoute( org, srcarea - 1, dstarea - 1 );
} else
{
trap_Print( "You must specify 'src' & 'dest' first\n" );
}
}
void AICast_Init (void)
{
vmCvar_t cvar;
int i;
numSecrets = 0;
numcast = 0;
numSpawningCast = 0;
saveGamePending = qtrue;
trap_Cvar_Register( &aicast_debug, "aicast_debug", "0", 0 );
trap_Cvar_Register( &aicast_debugname, "aicast_debugname", "", 0 );
trap_Cvar_Register( &aicast_scripts, "aicast_scripts", "1", 0 );
// (aicast_thinktime / sv_fps) * aicast_maxthink = number of cast's to think between each aicast frame
// so..
// (100 / 20) * 6 = 30
//
// so if the level has more than 30 AI cast's, they could start to bunch up, resulting in slower thinks
trap_Cvar_Register( &cvar, "aicast_thinktime", "50", 0 );
aicast_thinktime = trap_Cvar_VariableIntegerValue( "aicast_thinktime" );
trap_Cvar_Register( &cvar, "aicast_maxthink", "12", 0 );
aicast_maxthink = trap_Cvar_VariableIntegerValue( "aicast_maxthink" );
aicast_maxclients = trap_Cvar_VariableIntegerValue( "sv_maxclients" );
aicast_skillscale = (float)trap_Cvar_VariableIntegerValue( "g_gameSkill" ) / (float)GSKILL_MAX;
caststates = G_Alloc( aicast_maxclients * sizeof(cast_state_t) );
memset( caststates, 0, sizeof(caststates) );
for (i=0; i<MAX_CLIENTS; i++) {
caststates[i].entityNum = i;
}
// try and load in the AAS now, so we can interact with it during spawning of entities
i = 0;
trap_AAS_SetCurrentWorld(0);
while (!trap_AAS_Initialized() && (i++ < 10)) {
trap_BotLibStartFrame((float) level.time / 1000);
}
}
/*
==================
BotAIStartFrame
==================
*/
int BotAIStartFrame( int time ) {
int i;
gentity_t *ent;
bot_entitystate_t state;
//entityState_t entitystate;
//vec3_t mins = {-15, -15, -24}, maxs = {15, 15, 32};
int elapsed_time, thinktime;
static int local_time;
static int botlib_residual;
static int lastbotthink_time;
if ( g_gametype.integer != GT_SINGLE_PLAYER ) {
G_CheckBotSpawn();
}
trap_Cvar_Update( &bot_rocketjump );
trap_Cvar_Update( &bot_grapple );
trap_Cvar_Update( &bot_fastchat );
trap_Cvar_Update( &bot_nochat );
trap_Cvar_Update( &bot_testrchat );
trap_Cvar_Update( &bot_thinktime );
// Ridah, set the default AAS world
trap_AAS_SetCurrentWorld( 0 );
trap_Cvar_Update( &memorydump );
if ( memorydump.integer ) {
trap_BotLibVarSet( "memorydump", "1" );
trap_Cvar_Set( "memorydump", "0" );
}
//if the bot think time changed we should reschedule the bots
if ( bot_thinktime.integer != lastbotthink_time ) {
lastbotthink_time = bot_thinktime.integer;
BotScheduleBotThink();
}
elapsed_time = time - local_time;
local_time = time;
botlib_residual += elapsed_time;
if ( elapsed_time > bot_thinktime.integer ) {
thinktime = elapsed_time;
} else { thinktime = bot_thinktime.integer;}
// update the bot library
if ( botlib_residual >= thinktime ) {
botlib_residual -= thinktime;
trap_BotLibStartFrame( (float) time / 1000 );
// Ridah, only check the default world
trap_AAS_SetCurrentWorld( 0 );
if ( !trap_AAS_Initialized() ) {
return BLERR_NOERROR;
}
//update entities in the botlib
for ( i = 0; i < MAX_GENTITIES; i++ ) {
// Ridah, in single player, we only need client entity information
if ( g_gametype.integer == GT_SINGLE_PLAYER && i > level.maxclients ) {
break;
}
ent = &g_entities[i];
if ( !ent->inuse ) {
continue;
}
if ( !ent->r.linked ) {
continue;
}
if ( ent->r.svFlags & SVF_NOCLIENT ) {
continue;
}
//
memset( &state, 0, sizeof( bot_entitystate_t ) );
//
VectorCopy( ent->r.currentOrigin, state.origin );
VectorCopy( ent->r.currentAngles, state.angles );
VectorCopy( ent->s.origin2, state.old_origin );
VectorCopy( ent->r.mins, state.mins );
VectorCopy( ent->r.maxs, state.maxs );
state.type = ent->s.eType;
state.flags = ent->s.eFlags;
if ( ent->r.bmodel ) {
state.solid = SOLID_BSP;
} else { state.solid = SOLID_BBOX;}
state.groundent = ent->s.groundEntityNum;
state.modelindex = ent->s.modelindex;
state.modelindex2 = ent->s.modelindex2;
state.frame = ent->s.frame;
//state.event = ent->s.event;
//state.eventParm = ent->s.eventParm;
state.powerups = ent->s.powerups;
state.legsAnim = ent->s.legsAnim;
state.torsoAnim = ent->s.torsoAnim;
// state.weapAnim = ent->s.weapAnim; //----(SA)
//----(SA) didn't want to comment in as I wasn't sure of any implications of changing the aas_entityinfo_t and bot_entitystate_t structures.
state.weapon = ent->s.weapon;
/*
if (!BotAI_GetEntityState(i, &entitystate)) continue;
//
memset(&state, 0, sizeof(bot_entitystate_t));
//
VectorCopy(entitystate.pos.trBase, state.origin);
VectorCopy(entitystate.angles, state.angles);
VectorCopy(ent->s.origin2, state.old_origin);
//VectorCopy(ent->r.mins, state.mins);
//VectorCopy(ent->r.maxs, state.maxs);
state.type = entitystate.eType;
state.flags = entitystate.eFlags;
if (ent->r.bmodel) state.solid = SOLID_BSP;
else state.solid = SOLID_BBOX;
state.modelindex = entitystate.modelindex;
state.modelindex2 = entitystate.modelindex2;
state.frame = entitystate.frame;
state.event = entitystate.event;
state.eventParm = entitystate.eventParm;
state.powerups = entitystate.powerups;
state.legsAnim = entitystate.legsAnim;
state.torsoAnim = entitystate.torsoAnim;
state.weapon = entitystate.weapon;
*/
//
trap_BotLibUpdateEntity( i, &state );
}
BotAIRegularUpdate();
}
// Ridah, in single player, don't need bot's thinking
if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
return BLERR_NOERROR;
}
// execute scheduled bot AI
for ( i = 0; i < MAX_CLIENTS; i++ ) {
if ( !botstates[i] || !botstates[i]->inuse ) {
continue;
}
// Ridah
if ( g_entities[i].r.svFlags & SVF_CASTAI ) {
continue;
}
// done.
//
botstates[i]->botthink_residual += elapsed_time;
//
if ( botstates[i]->botthink_residual >= thinktime ) {
botstates[i]->botthink_residual -= thinktime;
if ( !trap_AAS_Initialized() ) {
return BLERR_NOERROR;
}
if ( g_entities[i].client->pers.connected == CON_CONNECTED ) {
BotAI( i, (float) thinktime / 1000 );
}
}
}
// execute bot user commands every frame
for ( i = 0; i < MAX_CLIENTS; i++ ) {
if ( !botstates[i] || !botstates[i]->inuse ) {
continue;
}
// Ridah
if ( g_entities[i].r.svFlags & SVF_CASTAI ) {
continue;
}
// done.
if ( g_entities[i].client->pers.connected != CON_CONNECTED ) {
continue;
}
BotUpdateInput( botstates[i], time );
trap_BotUserCommand( botstates[i]->client, &botstates[i]->lastucmd );
}
return BLERR_NOERROR;
}
/*
============
AICast_Think
entry point for all cast AI
============
*/
void AICast_Think( int client, float thinktime ) {
gentity_t *ent;
cast_state_t *cs;
int i;
int animIndex;
animation_t *anim;
// if (saveGamePending || (strlen( g_missionStats.string ) > 2 )) {
// return;
// }
//
// get the cast ready for processing
//
cs = AICast_GetCastState( client );
ent = &g_entities[client];
//
// make sure we are using the right AAS data for this entity (one's that don't get set will default to the player's AAS data)
trap_AAS_SetCurrentWorld( cs->aasWorldIndex );
//
// make sure we have a valid navigation system
//
if ( !trap_AAS_Initialized() ) {
return;
}
//
trap_EA_ResetInput( client, NULL );
cs->aiFlags &= ~AIFL_VIEWLOCKED;
//cs->bs->weaponnum = ent->client->ps.weapon;
//
// turn off flags that are set each frame if needed
ent->client->ps.eFlags &= ~( EF_NOSWINGANGLES | EF_MONSTER_EFFECT | EF_MONSTER_EFFECT2 | EF_MONSTER_EFFECT3 );
// conditional flags
if ( ent->aiCharacter == AICHAR_ZOMBIE ) {
if ( COM_BitCheck( ent->client->ps.weapons, WP_MONSTER_ATTACK1 ) ) {
cs->aiFlags |= AIFL_NO_FLAME_DAMAGE;
SET_FLAMING_ZOMBIE( ent->s, 1 );
} else {
SET_FLAMING_ZOMBIE( ent->s, 0 );
}
}
//
// if we're dead, do special stuff only
if ( ent->health <= 0 || cs->revivingTime || cs->rebirthTime ) {
//
if ( cs->revivingTime && cs->revivingTime < level.time ) {
// start us thinking again
ent->client->ps.pm_type = PM_NORMAL;
cs->revivingTime = 0;
}
//
if ( cs->rebirthTime && cs->rebirthTime < level.time ) {
vec3_t mins, maxs;
int touch[10], numTouch;
float oldmaxZ;
oldmaxZ = ent->r.maxs[2];
// make sure the area is clear
AIChar_SetBBox( ent, cs );
VectorAdd( ent->r.currentOrigin, ent->r.mins, mins );
VectorAdd( ent->r.currentOrigin, ent->r.maxs, maxs );
trap_UnlinkEntity( ent );
numTouch = trap_EntitiesInBox( mins, maxs, touch, 10 );
if ( numTouch ) {
for ( i = 0; i < numTouch; i++ ) {
//if (!g_entities[touch[i]].client || g_entities[touch[i]].r.contents == CONTENTS_BODY)
if ( g_entities[touch[i]].r.contents & MASK_PLAYERSOLID ) {
break;
}
}
if ( i == numTouch ) {
numTouch = 0;
}
}
if ( numTouch == 0 ) { // ok to spawn
// give them health when they start reviving, so we won't gib after
// just a couple shots while reviving
ent->health =
ent->client->ps.stats[STAT_HEALTH] =
ent->client->ps.stats[STAT_MAX_HEALTH] =
( ( cs->attributes[STARTING_HEALTH] - 50 ) > 30 ? ( cs->attributes[STARTING_HEALTH] - 50 ) : 30 );
ent->r.contents = CONTENTS_BODY;
ent->clipmask = MASK_PLAYERSOLID;
ent->takedamage = qtrue;
ent->waterlevel = 0;
ent->watertype = 0;
ent->flags = 0;
ent->die = AICast_Die;
ent->client->ps.eFlags &= ~EF_DEAD;
ent->s.eFlags &= ~EF_DEAD;
cs->rebirthTime = 0;
cs->deathTime = 0;
// play the revive animation
cs->revivingTime = level.time + BG_AnimScriptEvent( &ent->client->ps, ANIM_ET_REVIVE, qfalse, qtrue );;
} else {
// can't spawn yet, so set bbox back, and wait
ent->r.maxs[2] = oldmaxZ;
ent->client->ps.maxs[2] = ent->r.maxs[2];
}
trap_LinkEntity( ent );
}
// ZOMBIE should set effect flag if really dead
if ( cs->aiCharacter == AICHAR_ZOMBIE && !ent->r.contents ) {
ent->client->ps.eFlags |= EF_MONSTER_EFFECT2;
}
//
if ( ent->health > GIB_HEALTH && cs->deathTime && cs->deathTime < ( level.time - 3000 ) ) {
/*
// been dead for long enough, set our animation to the end frame
switch ( ent->s.legsAnim & ~ANIM_TOGGLEBIT ) {
case BOTH_DEATH1:
case BOTH_DEAD1:
anim = BOTH_DEAD1;
break;
case BOTH_DEATH2:
case BOTH_DEAD2:
anim = BOTH_DEAD2;
break;
case BOTH_DEATH3:
case BOTH_DEAD3:
anim = BOTH_DEAD3;
break;
default:
G_Error( "%s has unknown death animation\n", ent->classname);
}
ent->client->ps.torsoAnim = ( ( ent->client->ps.torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
ent->client->ps.legsAnim = ( ( ent->client->ps.legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
*/
cs->deathTime = 0;
ent->r.svFlags &= ~SVF_BROADCAST;
}
//
// no more thinking required
return;
}
//
// set some anim conditions
if ( cs->secondDeadTime ) {
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_SECONDLIFE, qtrue, qfalse );
} else {
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_SECONDLIFE, qfalse, qfalse );
}
// set health value
if ( ent->health <= 0.25 * cs->attributes[STARTING_HEALTH] ) {
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_HEALTH_LEVEL, 3, qfalse );
} else if ( ent->health <= 0.5 * cs->attributes[STARTING_HEALTH] ) {
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_HEALTH_LEVEL, 2, qfalse );
} else {
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_HEALTH_LEVEL, 1, qfalse );
}
//
cs->speedScale = 1.0; // reset each frame, set if required
cs->actionFlags = 0; // FIXME: move this to a Cast AI movement init function!
//retrieve the current client state
BotAI_GetClientState( client, &( cs->bs->cur_ps ) );
//
// setup movement speeds for the given state
// walking
animIndex = BG_GetAnimScriptAnimation( cs->entityNum, ent->client->ps.aiState, ANIM_MT_WALK );
if ( animIndex >= 0 ) {
anim = BG_GetAnimationForIndex( cs->entityNum, animIndex );
cs->attributes[WALKING_SPEED] = anim->moveSpeed;
}
// crouching
animIndex = BG_GetAnimScriptAnimation( cs->entityNum, ent->client->ps.aiState, ANIM_MT_WALKCR );
if ( animIndex >= 0 ) {
anim = BG_GetAnimationForIndex( cs->entityNum, animIndex );
cs->attributes[CROUCHING_SPEED] = anim->moveSpeed;
}
// running
animIndex = BG_GetAnimScriptAnimation( cs->entityNum, ent->client->ps.aiState, ANIM_MT_RUN );
if ( animIndex >= 0 ) {
anim = BG_GetAnimationForIndex( cs->entityNum, animIndex );
cs->attributes[RUNNING_SPEED] = anim->moveSpeed;
}
// update crouch speed scale
ent->client->ps.crouchSpeedScale = cs->attributes[CROUCHING_SPEED] / cs->attributes[RUNNING_SPEED];
//
// only enable headlook if we want to this frame
ent->client->ps.eFlags &= ~EF_HEADLOOK;
if ( cs->bs->enemy >= 0 ) {
ent->client->ps.eFlags &= ~EF_STAND_IDLE2; // never use alt idle if fighting
}
//
// check for dead leader
if ( cs->leaderNum >= 0 && g_entities[cs->leaderNum].health <= 0 ) {
cs->leaderNum = -1;
}
//
#if 0
// HACK for village2, if they are stuck, find a good position (there is a friendly guy placed inside a table)
{
trace_t tr;
vec3_t org;
trap_Trace( &tr, cs->bs->cur_ps.origin, cs->bs->cur_ps.mins, cs->bs->cur_ps.maxs, cs->bs->cur_ps.origin, cs->entityNum, CONTENTS_SOLID );
while ( tr.startsolid ) {
VectorCopy( cs->bs->cur_ps.origin, org );
org[0] += 96 * crandom();
org[1] += 96 * crandom();
org[2] += 16 * crandom();
trap_Trace( &tr, org, cs->bs->cur_ps.mins, cs->bs->cur_ps.maxs, org, cs->entityNum, CONTENTS_SOLID );
G_SetOrigin( &g_entities[cs->entityNum], org );
VectorCopy( org, g_entities[cs->entityNum].client->ps.origin );
}
}
#endif
//add the delta angles to the cast's current view angles
for ( i = 0; i < 3; i++ ) {
cs->bs->viewangles[i] = AngleMod( cs->bs->viewangles[i] + SHORT2ANGLE( cs->bs->cur_ps.delta_angles[i] ) );
}
//
//increase the local time of the cast
cs->bs->ltime += thinktime;
//
cs->bs->thinktime = thinktime;
//origin of the cast
VectorCopy( cs->bs->cur_ps.origin, cs->bs->origin );
//eye coordinates of the cast
VectorCopy( cs->bs->cur_ps.origin, cs->bs->eye );
cs->bs->eye[2] += cs->bs->cur_ps.viewheight;
//get the area the cast is in
cs->bs->areanum = BotPointAreaNum( cs->bs->origin );
// clear flags each frame
cs->bs->flags = 0;
//
// check enemy health
if ( cs->bs->enemy >= 0 && g_entities[cs->bs->enemy].health <= 0 ) {
cs->bs->enemy = -1;
}
//
// if the previous movetype was temporary, set it back
if ( cs->movestateType == MSTYPE_TEMPORARY ) {
cs->movestate = MS_DEFAULT;
cs->movestateType = MSTYPE_NONE;
}
// crouching?
if ( ( cs->bs->attackcrouch_time > trap_AAS_Time() ) &&
( ( cs->lastAttackCrouch > level.time - 500 ) || ( cs->thinkFuncChangeTime < level.time - 1000 ) ) ) {
// if we are not moving, and we are firing, always stand, unless we are allowed to crouch + fire
if ( VectorLength( cs->bs->cur_ps.velocity ) || ( cs->lastWeaponFired < level.time - 2000 ) || ( cs->aiFlags & AIFL_ATTACK_CROUCH ) ) {
cs->lastAttackCrouch = level.time;
trap_EA_Crouch( cs->bs->client );
}
}
//
//if (cs->bs->enemy >= 0) {
//update the attack inventory values
AICast_UpdateBattleInventory( cs, cs->bs->enemy );
//}
//
// if we don't have ammo for the current weapon, get rid of it
if ( !( COM_BitCheck( cs->bs->cur_ps.weapons, cs->bs->weaponnum ) ) || !AICast_GotEnoughAmmoForWeapon( cs, cs->bs->weaponnum ) ) {
// select a weapon
AICast_ChooseWeapon( cs, qfalse );
// if still no ammo, select a blank weapon
//if (!AICast_GotEnoughAmmoForWeapon( cs, cs->bs->weaponnum )) {
// cs->bs->weaponnum = WP_NONE;
//}
}
//
// in query mode, we do special handling (pause scripting, check for transition to alert/combat, etc)
if ( cs->aiState == AISTATE_QUERY ) {
AICast_QueryThink( cs );
} else if ( cs->pauseTime < level.time ) {
// do the thinking
AICast_ProcessAIFunctions( cs, thinktime );
//
// make sure the correct weapon is selected
trap_EA_SelectWeapon( cs->bs->client, cs->bs->weaponnum );
//
// process current script if it exists
cs->castScriptStatusCurrent = cs->castScriptStatus;
AICast_ScriptRun( cs, qfalse );
}
//
// set special movestate if necessary
if ( cs->movestateType != MSTYPE_NONE ) {
switch ( cs->movestate ) {
case MS_WALK:
cs->actionFlags |= CASTACTION_WALK;
break;
case MS_CROUCH:
trap_EA_Crouch( cs->entityNum );
break;
default:
break; // TTimo gcc: MS_DEFAULT MS_RUN not handled in switch
}
}
//
//subtract the delta angles
for ( i = 0; i < 3; i++ ) {
cs->bs->viewangles[i] = AngleMod( cs->bs->viewangles[i] - SHORT2ANGLE( cs->bs->cur_ps.delta_angles[i] ) );
}
}
/*
================
AICast_EvaluatePmove
Avoidance after the event (leaders instruct AI's to get out the way, AI's instruct other non-moving AI's to get out the way)
================
*/
void AICast_EvaluatePmove( int clientnum, pmove_t *pm ) {
cast_state_t *cs, *ocs;
int i, ent;
bot_goal_t ogoal;
//vec3_t pos, dir;
cs = AICast_GetCastState( clientnum );
// make sure we are using the right AAS data for this entity (one's that don't get set will default to the player's AAS data)
trap_AAS_SetCurrentWorld( cs->aasWorldIndex );
// NOTE: this is only enabled for real clients, so their followers get out of their way
//if (cs->bs)
// return;
// look through the touchent's to see if we've bumped into something we should avoid, or react to
for ( i = 0; i < pm->numtouch; i++ )
{
// mark the time, so they can deal with the obstruction in their own think functions
cs->blockedTime = level.time;
if ( pm->touchents[i] == pm->ps->groundEntityNum ) {
continue;
}
// if they are an AI Cast, inform them of our disposition, and hope that they are reasonable
// enough to assist us in our desire to move beyond our current position
if ( pm->touchents[i] < aicast_maxclients ) {
if ( !AICast_EntityVisible( cs, pm->touchents[i], qtrue ) ) {
continue;
}
// if we are inspecting the body, abort if we touch anything
if ( cs->bs && cs->bs->enemy >= 0 && g_entities[cs->bs->enemy].health <= 0 ) {
cs->bs->enemy = -1;
}
// anything we touch, should see us
AICast_UpdateVisibility( &g_entities[pm->touchents[i]], &g_entities[cs->entityNum], qfalse, qtrue );
ocs = AICast_GetCastState( pm->touchents[i] );
if ( ( ocs->bs ) &&
( !( ocs->aiFlags & AIFL_NOAVOID ) ) &&
( ( ocs->leaderNum == cs->entityNum ) || ( VectorLength( ocs->bs->velocity ) < 5 ) ) &&
( ocs->obstructingTime < ( level.time + 100 ) ) ) {
// if they are moving away from us already, let them go
if ( VectorLength( ocs->bs->cur_ps.velocity ) > 10 ) {
vec3_t v1, v2;
VectorSubtract( ocs->bs->origin, g_entities[clientnum].client->ps.velocity, v2 );
VectorNormalize( v2 );
VectorNormalize2( ocs->bs->cur_ps.velocity, v1 );
if ( DotProduct( v1, v2 ) > 0.0 ) {
continue;
}
}
if ( ocs->leaderNum >= 0 ) {
VectorCopy( g_entities[ocs->leaderNum].r.currentOrigin, ogoal.origin );
ogoal.areanum = BotPointAreaNum( ogoal.origin );
ogoal.entitynum = ocs->leaderNum;
if ( ocs->bs && AICast_GetAvoid( ocs, &ogoal, ocs->obstructingPos, qfalse, cs->entityNum ) ) { // give them time to move somewhere else
ocs->obstructingTime = level.time + 1000;
}
} else {
if ( ocs->bs && AICast_GetAvoid( ocs, NULL, ocs->obstructingPos, qfalse, cs->entityNum ) ) { // give them time to move somewhere else
ocs->obstructingTime = level.time + 1000;
}
}
}
} else if ( cs->bs ) {
// if we are blocked by a brush entity, see if we can activate it
ent = pm->touchents[i];
if ( g_entities[ent].s.modelindex > 0 && g_entities[ent].s.eType == ET_MOVER ) {
//find the bsp entity which should be activated in order to remove
//the blocking entity
if ( !g_entities[ent].isProp
&& Q_stricmp( g_entities[ent].classname, "func_static" )
&& Q_stricmp( g_entities[ent].classname, "func_button" )
&& Q_stricmp( g_entities[ent].classname, "func_tram" ) ) {
G_Activate( &g_entities[ent], &g_entities[cs->entityNum] );
}
}
}
}
}
void AICast_SightUpdate( int numchecks ) {
int count = 0, destcount, srccount;
int src, dest;
gentity_t *srcent, *destent;
cast_state_t *cs, *dcs;
//static int lastNumUpdated; // TTimo: unused
cast_visibility_t *vis;
#define SIGHT_MIN_DELAY 200
src = 0;
dest = 0;
if ( numchecks < 5 ) {
numchecks = 5;
}
if ( trap_Cvar_VariableIntegerValue( "savegame_loading" ) ) {
return;
}
if ( saveGamePending ) {
return;
}
// First, check all REAL clients, so sighting player is only effected by reaction_time, not
// effected by framerate also
for ( srccount = 0, src = 0, srcent = &g_entities[0];
src < aicast_maxclients && srccount < level.numPlayingClients;
src++, srcent++ )
{
if ( !srcent->inuse ) {
continue;
}
srccount++;
if ( srcent->aiInactive ) {
continue;
}
if ( srcent->health <= 0 ) {
continue;
}
if ( !( srcent->r.svFlags & SVF_CASTAI ) ) { // only source check AI Cast
continue;
}
cs = AICast_GetCastState( src );
if ( cs->castScriptStatus.scriptNoSightTime >= level.time ) {
continue;
}
// make sure we are using the right AAS data for this entity (one's that don't get set will default to the player's AAS data)
trap_AAS_SetCurrentWorld( cs->aasWorldIndex );
for ( destcount = 0, dest = 0, destent = g_entities;
//dest < aicast_maxclients && destcount < level.numPlayingClients;
destent == g_entities; // only check the player
dest++, destent++ )
{
if ( !destent->inuse ) {
continue;
}
destcount++;
if ( destent->health <= 0 ) {
continue;
}
if ( destent->r.svFlags & SVF_CASTAI ) { // only dest check REAL clients
continue;
}
if ( src == dest ) {
continue;
}
vis = &cs->vislist[destent->s.number];
// OPTIMIZATION: if we have seen the player, abort checking each frame
//if (vis->real_visible_timestamp && cs->aiState > AISTATE_QUERY && AICast_HostileEnemy(cs, destent->s.number))
// continue;
// if we saw them last frame, skip this test, so we only check initial sightings each frame
if ( vis->lastcheck_timestamp == vis->real_visible_timestamp ) {
continue;
}
// if we recently checked this vis, skip
if ( vis->lastcheck_timestamp >= level.time - ( 40 + rand() % 40 ) ) {
continue;
}
// check for visibility
if ( !( destent->flags & FL_NOTARGET )
&& ( AICast_CheckVisibility( srcent, destent ) ) ) {
// record the sighting
AICast_UpdateVisibility( srcent, destent, qtrue, qtrue );
} else // if (vis->lastcheck_timestamp == vis->real_update_timestamp)
{
AICast_UpdateNonVisibility( srcent, destent, qtrue );
}
}
}
// Now do the normal timeslice checks
for ( srccount = 0, src = lastsrc, srcent = &g_entities[lastsrc];
src < aicast_maxclients; // && srccount < level.numPlayingClients;
src++, srcent++ )
{
if ( !srcent->inuse ) {
continue;
}
srccount++;
if ( srcent->aiInactive ) {
continue;
}
if ( srcent->health <= 0 ) {
continue;
}
cs = AICast_GetCastState( src );
if ( cs->castScriptStatus.scriptNoSightTime >= level.time ) {
continue;
}
// make sure we are using the right AAS data for this entity (one's that don't get set will default to the player's AAS data)
trap_AAS_SetCurrentWorld( cs->aasWorldIndex );
if ( lastdest < 0 ) {
lastdest = 0;
}
for ( destcount = 0, dest = lastdest, destent = &g_entities[lastdest];
dest < aicast_maxclients; // && destcount < level.numPlayingClients;
dest++, destent++ )
{
if ( !destent->inuse ) {
continue;
}
destcount++;
if ( destent->aiInactive ) {
continue;
}
if ( src == dest ) {
continue;
}
dcs = AICast_GetCastState( destent->s.number );
vis = &cs->vislist[destent->s.number];
// don't check too often
if ( vis->lastcheck_timestamp > ( level.time - SIGHT_MIN_DELAY ) ) {
continue;
}
if ( destent->health <= 0 ) {
// only check dead guys until they are sighted
if ( vis->lastcheck_health < 0 ) {
continue;
}
}
if ( vis->lastcheck_timestamp > level.time ) {
continue; // let the loadgame settle down
}
// if they are friends, only check very infrequently
if ( AICast_SameTeam( cs, destent->s.number ) && ( vis->lastcheck_timestamp == vis->visible_timestamp )
&& ( destent->health == vis->lastcheck_health + 1 ) ) {
if ( dcs->aiState < AISTATE_COMBAT ) {
if ( vis->lastcheck_timestamp > ( level.time - ( 2000 + rand() % 1000 ) ) ) {
continue; // dont check too often
}
} else { // check a little more frequently
if ( vis->lastcheck_timestamp > ( level.time - ( 500 + rand() % 500 ) ) ) {
continue; // dont check too often
}
}
}
// check for visibility
if ( !( destent->flags & FL_NOTARGET )
&& ( AICast_CheckVisibility( srcent, destent ) ) ) {
// make sure they are still with us
if ( destent->inuse ) {
// record the sighting
AICast_UpdateVisibility( srcent, destent, qtrue, qtrue );
}
} else // if (vis->lastcheck_timestamp == vis->real_update_timestamp)
{
AICast_UpdateNonVisibility( srcent, destent, qtrue );
}
// break if we've processed the maximum visibilities
if ( ++count > numchecks ) {
dest++;
if ( dest >= aicast_maxclients ) {
src++;
}
goto escape;
}
}
lastdest = 0;
}
escape:
if ( src >= aicast_maxclients ) {
src = 0;
}
lastsrc = src;
if ( dest >= aicast_maxclients ) {
dest = 0;
}
lastdest = dest;
}
