/*
============
AICast_CreateCharacter
returns 0 if unable to create the character
============
*/
gentity_t *AICast_CreateCharacter( gentity_t *ent, float *attributes, cast_weapon_info_t *weaponInfo, char *castname, char *model, char *head, char *sex, char *color, char *handicap )
{
gentity_t *newent;
gclient_t *client;
cast_state_t *cs;
char **ppStr;
int j;
if (g_gametype.integer != GT_SINGLE_PLAYER)
{ // no cast AI in multiplayer
return NULL;
}
// are bots enabled?
if ( !trap_Cvar_VariableIntegerValue( "bot_enable" ) ) {
G_Printf( S_COLOR_RED "ERROR: Unable to spawn %s, 'bot_enable' is not set\n", ent->classname );
return NULL;
}
//
// make sure we have a free slot for them
//
if (level.numPlayingClients+1 > aicast_maxclients)
{
G_Error( "Exceeded sv_maxclients (%d), unable to create %s\n", aicast_maxclients, ent->classname );
return NULL;
}
//
// add it to the list (only do this if everything else passed)
//
newent = AICast_AddCastToGame( ent, castname, model, head, sex, color, handicap );
if (!newent) {
return NULL;
}
client = newent->client;
//
// setup the character..
//
cs = AICast_GetCastState( newent->s.number );
//
// setup the attributes
memcpy( cs->attributes, attributes, sizeof(cs->attributes) );
ppStr = &ent->aiAttributes;
AICast_CheckLevelAttributes( cs, ent, ppStr );
//
AICast_SetAASIndex( cs );
// make sure they face the right direction
VectorCopy( ent->s.angles, cs->bs->ideal_viewangles );
// factor in the delta_angles
for (j = 0; j < 3; j++) {
cs->bs->viewangles[j] = AngleMod(newent->s.angles[j] - SHORT2ANGLE(newent->client->ps.delta_angles[j]));
}
VectorCopy( ent->s.angles, newent->s.angles );
VectorCopy( ent->s.origin, cs->startOrigin );
//
cs->lastEnemy = -1;
cs->bs->enemy = -1;
cs->leaderNum = -1;
cs->castScriptStatus.scriptGotoEnt = -1;
cs->aiCharacter = ent->aiCharacter;
//
newent->aiName = ent->aiName;
newent->aiTeam = ent->aiTeam;
newent->targetname = ent->targetname;
//
newent->AIScript_AlertEntity = ent->AIScript_AlertEntity;
newent->aiInactive = ent->aiInactive;
newent->aiCharacter = cs->aiCharacter;
//
// parse the AI script for this character (if applicable)
cs->aiFlags |= AIFL_CORPSESIGHTING; // this is on by default for all characters, disabled if they have a "friendlysightcorpse" script event
AICast_ScriptParse( cs );
//
// setup bounding boxes
//VectorCopy( mins, client->ps.mins );
//VectorCopy( maxs, client->ps.maxs );
AIChar_SetBBox( newent, cs );
client->ps.friction = cs->attributes[RUNNING_SPEED]/300.0;
//
// clear weapons/ammo
client->ps.weapon = 0;
memcpy( client->ps.weapons, weaponInfo->startingWeapons, sizeof(weaponInfo->startingWeapons) );
memcpy( client->ps.ammo, weaponInfo->startingAmmo, sizeof(client->ps.ammo) );
//
// starting health
if (ent->health) {
newent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] = ent->health;
} else {
newent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] = cs->attributes[STARTING_HEALTH];
}
//
cs->weaponInfo = weaponInfo;
//
cs->lastThink = level.time;
//
newent->pain = AICast_Pain;
newent->die = AICast_Die;
//
//update the attack inventory values
AICast_UpdateBattleInventory(cs, cs->bs->enemy);
//----(SA) make sure all clips are loaded so we don't hear everyone loading up
// (we don't want to do this inside AICast_UpdateBattleInventory(), only on spawn or giveweapon)
for (j=0; j<MAX_WEAPONS; j++) {
Fill_Clip (&client->ps, j);
}
//----(SA) end
// select a weapon
AICast_ChooseWeapon( cs, qfalse );
//
// set the default function, overwrite if necessary
cs->aiFlags |= AIFL_JUST_SPAWNED;
AIFunc_DefaultStart( cs );
//
numcast++;
//
return newent;
}
/*
============
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] ) );
}
}