/*
================
AIFunc_WarriorZombieMeleeStart
================
*/
char *AIFunc_WarriorZombieMeleeStart( cast_state_t *cs ) {
gentity_t *ent;
ent = &g_entities[cs->entityNum];
ent->s.effect1Time = level.time;
cs->ideal_viewangles[YAW] = cs->viewangles[YAW];
cs->weaponFireTimes[cs->weaponNum] = level.time;
cs->animHitCount = 0;
// face them
AICast_AimAtEnemy( cs );
// audible sound
AIChar_AttackSound( cs );
// play an anim
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_WEAPON, cs->weaponNum, qtrue );
BG_AnimScriptEvent( &ent->client->ps, ANIM_ET_FIREWEAPON, qfalse, qtrue );
// stop charging
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_CHARGING, 0, qfalse );
ent->flags &= ~FL_WARZOMBIECHARGE;
cs->aifunc = AIFunc_WarriorZombieMelee;
return "AIFunc_WarriorZombieMelee";
}
/*
================
AIFunc_WarriorZombieDefenseStart
================
*/
char *AIFunc_WarriorZombieDefenseStart( cast_state_t *cs ) {
gentity_t *ent, *enemy;
vec3_t enemyDir, vec;
float dist;
static int lastWarriorDefense;
if ( lastWarriorDefense <= level.time && lastWarriorDefense > level.time - 3000 ) {
return NULL; // dont all go into defense at once
}
lastWarriorDefense = level.time;
ent = &g_entities[cs->entityNum];
enemy = &g_entities[cs->enemyNum];
// if our enemy isn't using a dangerous weapon
if ( enemy->client->ps.weapon < WP_LUGER || enemy->client->ps.weapon > WP_CLASS_SPECIAL ) {
return NULL;
}
// if we are doing a goto
if ( cs->followEntity >= 0 ) {
return NULL;
}
// if our enemy isn't looking right at us, abort
VectorSubtract( ent->client->ps.origin, enemy->client->ps.origin, vec );
dist = VectorNormalize( vec );
if ( dist > 512 ) {
dist = 512;
}
if ( dist < 128 ) {
return NULL;
}
AngleVectors( enemy->client->ps.viewangles, enemyDir, NULL, NULL );
if ( DotProduct( vec, enemyDir ) < ( 0.98 - 0.2 * ( dist / 512 ) ) ) {
return NULL;
}
cs->weaponFireTimes[cs->weaponNum] = level.time;
// face them
AICast_AimAtEnemy( cs );
// anim
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_WEAPON, cs->weaponNum, qtrue );
BG_AnimScriptEvent( &ent->client->ps, ANIM_ET_FIREWEAPON, qfalse, qtrue );
ent->client->ps.torsoTimer = 3000;
ent->client->ps.legsTimer = 3000;
ent->flags |= FL_DEFENSE_GUARD;
// when they come out of defense mode, go into charge mode
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_CHARGING, 1, qfalse );
ent->flags |= FL_WARZOMBIECHARGE;
cs->aifunc = AIFunc_WarriorZombieDefense;
return "AIFunc_WarriorZombieDefense";
}
static void PM_BeginWeaponReload() { //works for kar98 sniper? rest not? mmhm
pmove_t *xm = *(pmove_t**)(int)pm;
int clientNum = *(int*)((int)xm->ps + 172);
xclient_t *xcl = &xclients[clientNum];
int *weapons = *(int**)((int)xm->ps + 796);
int weapon = *(int*)((int)xm->ps + 176);
int *weaponTime = (int*)((int)xm->ps + 44);
int *weaponDelay = (int*)((int)xm->ps + 48);
int weaponinfo = BG_GetInfoForWeapon(weapon);
int *weaponstate = (int*)((int)xm->ps + 180);
if(*weaponstate == WEAPON_READY || *weaponstate == WEAPON_FIRING || *weaponstate == WEAPON_RECHAMBERING) {
int weapon = *(int*)((int)xm->ps + 176);
if(weapon) {
if(weapon <= BG_GetNumWeapons()) {
int weaponinfo = BG_GetInfoForWeapon(weapon);
if(!*(int*)(weaponinfo + 724))
BG_AnimScriptEvent(xm->ps, 10, 0, 1);
int v2 = *(int*)((int)pml + 132);
if(*(int*)(v2 + 748) && *(int*)(v2 + 500)) {
if(xm->ps->pm_type <= 5) {
if(*(unsigned char*)((int)xm + 10)) {
int v4 = *(int*)((int)xm->ps + 980) & 0x200;
BYTE1(v4) ^= 2u;
LOBYTE(v4) = 13;
*(int*)((int)xm->ps + 980) = v4;
}
}
if(xcl->perks[PERK_QUICK_RELOAD])
*weaponTime = (int)(*(int*)(v2 + 500) / QUICK_RELOAD_FRACTION);
else
*weaponTime = *(int*)(v2 + 500);
*weaponstate = WEAPON_RELOAD_START; //7
PM_AddEvent(EV_RELOAD_START);
PM_SetWeaponReloadAddAmmoDelay();//sub_377B8
if(xcl->perks[PERK_QUICK_RELOAD])
*weaponDelay = (int)(*weaponDelay / QUICK_RELOAD_FRACTION);
} else {
PM_SetReloadingState();//sub_378BC
}
}
}
}
}
char *AIFunc_Helga_SpiritAttack_Start(cast_state_t *cs) {
gentity_t *ent;
ent = &g_entities[cs->entityNum];
ent->s.otherEntityNum2 = cs->enemyNum;
ent->s.effect1Time = level.time;
cs->aiFlags |= AIFL_SPECIAL_FUNC;
// dont turn
cs->ideal_viewangles[YAW] = cs->viewangles[YAW];
// play an anim
BG_UpdateConditionValue(cs->entityNum, ANIM_COND_WEAPON, WP_MONSTER_ATTACK2, qtrue);
BG_AnimScriptEvent(&ent->client->ps, ANIM_ET_FIREWEAPON, qfalse, qtrue);
cs->aifunc = AIFunc_Helga_SpiritAttack;
return "AIFunc_Helga_SpiritAttack";
}
char *AIFunc_LoperAttack1Start( cast_state_t *cs ) {
gentity_t *ent;
//
ent = &g_entities[cs->entityNum];
// face them
AICast_AimAtEnemy( cs );
// start the animation
//ent->client->ps.legsAnim =
// ( ( ent->client->ps.legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | loperMeleeAnims[rand()%NUM_LOPER_MELEE_ANIMS];
//ent->client->ps.legsTimer = LOPER_MELEE_DURATION;
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_WEAPON, cs->bs->weaponnum, qtrue );
BG_AnimScriptEvent( &ent->client->ps, ANIM_ET_FIREWEAPON, qfalse, qtrue );
// play the sound
// TODO
//
cs->aifunc = AIFunc_LoperAttack1;
return "AIFunc_LoperAttack1";
}
/*
================
AIFunc_ZombieMeleeStart
================
*/
char *AIFunc_ZombieMeleeStart( cast_state_t *cs ) {
gentity_t *ent;
ent = &g_entities[cs->entityNum];
cs->weaponFireTimes[cs->weaponNum] = level.time;
cs->animHitCount = 0;
// face them
AICast_AimAtEnemy( cs );
// audible sound
AIChar_AttackSound( cs );
// play an anim
BG_UpdateConditionValue( cs->entityNum, ANIM_COND_WEAPON, cs->weaponNum, qtrue );
BG_AnimScriptEvent( &ent->client->ps, ANIM_ET_FIREWEAPON, qfalse, qtrue );
cs->aifunc = AIFunc_ZombieMelee;
return "AIFunc_ZombieMelee";
}
/*
================
AIFunc_WarriorZombieSightStart
================
*/
char *AIFunc_WarriorZombieSightStart( cast_state_t *cs ) {
gentity_t *ent;
// RF, disabled
return NULL;
ent = &g_entities[cs->entityNum];
cs->ideal_viewangles[YAW] = cs->viewangles[YAW];
cs->weaponFireTimes[cs->weaponNum] = level.time;
// face them
AICast_AimAtEnemy( cs );
// anim
BG_AnimScriptEvent( &ent->client->ps, ANIM_ET_FIRSTSIGHT, qfalse, qtrue );
//BG_PlayAnimName( &ent->client->ps, "first_sight", ANIM_BP_BOTH, qtrue, qfalse, qtrue );
cs->aifunc = AIFunc_WarriorZombieSight;
return "AIFunc_WarriorZombieSight";
}
/*
=======================================================================================================================================
AIFunc_Helga_MeleeStart
=======================================================================================================================================
*/
char *AIFunc_Helga_MeleeStart(cast_state_t *cs) {
gentity_t *ent;
ent = &g_entities[cs->entityNum];
ent->s.effect1Time = level.time;
cs->ideal_viewangles[YAW] = cs->viewangles[YAW];
cs->weaponFireTimes[cs->weaponNum] = level.time;
cs->animHitCount = 0;
cs->aiFlags |= AIFL_SPECIAL_FUNC;
// face them
AICast_AimAtEnemy(cs);
// play an anim
BG_UpdateConditionValue(cs->entityNum, ANIM_COND_WEAPON, cs->weaponNum, qtrue);
BG_AnimScriptEvent(&ent->client->ps, ANIM_ET_FIREWEAPON, qfalse, qtrue);
// play a sound
G_AddEvent(ent, EV_GENERAL_SOUND, G_SoundIndex(aiDefaults[ent->aiCharacter].soundScripts[ATTACKSOUNDSCRIPT]));
cs->aifunc = AIFunc_Helga_Melee;
cs->aifunc(cs); // think once now, to prevent a delay
return "AIFunc_Helga_Melee";
}
void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
int contents = 0, i, killer = ENTITYNUM_WORLD;
char *killerName = "<world>";
qboolean nogib = qtrue;
gitem_t *item = NULL;
gentity_t *ent;
qboolean killedintank = qfalse;
//float timeLived;
weapon_t weap = BG_WeaponForMOD( meansOfDeath );
// G_Printf( "player_die\n" );
if(attacker == self) {
if(self->client) {
self->client->pers.playerStats.suicides++;
trap_PbStat ( self - g_entities , "suicide" ,
va ( "%d %d %d" , self->client->sess.sessionTeam , self->client->sess.playerType , weap ) ) ;
}
} else if(OnSameTeam( self, attacker )) {
G_LogTeamKill( attacker, weap );
} else {
G_LogDeath( self, weap );
G_LogKill( attacker, weap );
if( g_gamestate.integer == GS_PLAYING ) {
if( attacker->client ) {
attacker->client->combatState |= (1<<COMBATSTATE_KILLEDPLAYER);
}
}
}
// RF, record this death in AAS system so that bots avoid areas which have high death rates
if( !OnSameTeam( self, attacker ) )
{
// LC - not needed
// BotRecordTeamDeath( self->s.number );
self->isProp = qfalse; // were we teamkilled or not?
} else {
self->isProp = qtrue;
}
// if we got killed by a landmine, update our map
if( self->client && meansOfDeath == MOD_LANDMINE ) {
// if it's an enemy mine, update both teamlists
/*int teamNum;
mapEntityData_t *mEnt;
mapEntityData_Team_t *teamList;
teamNum = inflictor->s.teamNum % 4;
teamList = self->client->sess.sessionTeam == TEAM_AXIS ? &mapEntityData[0] : &mapEntityData[1];
if((mEnt = G_FindMapEntityData(teamList, inflictor-g_entities)) != NULL) {
G_FreeMapEntityData( teamList, mEnt );
}
if( teamNum != self->client->sess.sessionTeam ) {
teamList = self->client->sess.sessionTeam == TEAM_AXIS ? &mapEntityData[1] : &mapEntityData[0];
if((mEnt = G_FindMapEntityData(teamList, inflictor-g_entities)) != NULL) {
G_FreeMapEntityData( teamList, mEnt );
}
}*/
mapEntityData_t *mEnt;
if((mEnt = G_FindMapEntityData(&mapEntityData[0], inflictor-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[0], mEnt );
}
if((mEnt = G_FindMapEntityData(&mapEntityData[1], inflictor-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[1], mEnt );
}
}
{
mapEntityData_t *mEnt;
mapEntityData_Team_t *teamList = self->client->sess.sessionTeam == TEAM_AXIS ? &mapEntityData[1] : &mapEntityData[0]; // swapped, cause enemy team
mEnt = G_FindMapEntityDataSingleClient( teamList, NULL, self->s.number, -1 );
while( mEnt ) {
if( mEnt->type == ME_PLAYER_DISGUISED ) {
mapEntityData_t* mEntFree = mEnt;
mEnt = G_FindMapEntityDataSingleClient( teamList, mEnt, self->s.number, -1 );
G_FreeMapEntityData( teamList, mEntFree );
} else {
mEnt = G_FindMapEntityDataSingleClient( teamList, mEnt, self->s.number, -1 );
}
}
}
if( self->tankLink ) {
G_LeaveTank( self, qfalse );
killedintank = qtrue;
}
if( self->client->ps.pm_type == PM_DEAD || g_gamestate.integer == GS_INTERMISSION ) {
return;
}
// OSP - death stats handled out-of-band of G_Damage for external calls
G_addStats(self, attacker, damage, meansOfDeath);
// OSP
self->client->ps.pm_type = PM_DEAD;
G_AddEvent( self, EV_STOPSTREAMINGSOUND, 0);
if(attacker) {
killer = attacker->s.number;
killerName = (attacker->client) ? attacker->client->pers.netname : "<non-client>";
}
if(attacker == 0 || killer < 0 || killer >= MAX_CLIENTS) {
killer = ENTITYNUM_WORLD;
killerName = "<world>";
}
if(g_gamestate.integer == GS_PLAYING) {
char *obit;
if(meansOfDeath < 0 || meansOfDeath >= sizeof(modNames) / sizeof(modNames[0])) {
obit = "<bad obituary>";
} else {
obit = modNames[meansOfDeath];
}
G_LogPrintf("Kill: %i %i %i: %s killed %s by %s\n", killer, self->s.number, meansOfDeath, killerName, self->client->pers.netname, obit );
}
// broadcast the death event to everyone
ent = G_TempEntity( self->r.currentOrigin, EV_OBITUARY );
ent->s.eventParm = meansOfDeath;
ent->s.otherEntityNum = self->s.number;
ent->s.otherEntityNum2 = killer;
ent->r.svFlags = SVF_BROADCAST; // send to everyone
self->enemy = attacker;
self->client->ps.persistant[PERS_KILLED]++;
// JPW NERVE -- if player is holding ticking grenade, drop it
if ((self->client->ps.grenadeTimeLeft) && (self->s.weapon != WP_DYNAMITE) && (self->s.weapon != WP_LANDMINE) && (self->s.weapon != WP_SATCHEL) && (self->s.weapon != WP_TRIPMINE)) {
vec3_t launchvel, launchspot;
launchvel[0] = crandom();
launchvel[1] = crandom();
launchvel[2] = random();
VectorScale( launchvel, 160, launchvel );
VectorCopy(self->r.currentOrigin, launchspot);
launchspot[2] += 40;
{
// Gordon: fixes premature grenade explosion, ta bani ;)
gentity_t *m = fire_grenade(self, launchspot, launchvel, self->s.weapon);
m->damage = 0;
}
}
if (attacker && attacker->client) {
if ( attacker == self || OnSameTeam (self, attacker ) ) {
// DHM - Nerve :: Complaint lodging
if( attacker != self && level.warmupTime <= 0 && g_gamestate.integer == GS_PLAYING) {
if( attacker->client->pers.localClient ) {
trap_SendServerCommand( self-g_entities, "complaint -4" );
} else {
if( meansOfDeath != MOD_CRUSH_CONSTRUCTION && meansOfDeath != MOD_CRUSH_CONSTRUCTIONDEATH && meansOfDeath != MOD_CRUSH_CONSTRUCTIONDEATH_NOATTACKER ) {
if( g_complaintlimit.integer ) {
if( !(meansOfDeath == MOD_LANDMINE && g_disableComplaints.integer & TKFL_MINES ) &&
!((meansOfDeath == MOD_ARTY || meansOfDeath == MOD_AIRSTRIKE) && g_disableComplaints.integer & TKFL_AIRSTRIKE ) &&
!(meansOfDeath == MOD_MORTAR && g_disableComplaints.integer & TKFL_MORTAR ) ) {
trap_SendServerCommand( self-g_entities, va( "complaint %i", attacker->s.number ) );
self->client->pers.complaintClient = attacker->s.clientNum;
self->client->pers.complaintEndTime = level.time + 20500;
}
}
}
}
}
// high penalty to offset medic heal
/* AddScore( attacker, WOLF_FRIENDLY_PENALTY ); */
if( g_gametype.integer == GT_WOLF_LMS ) {
AddKillScore( attacker, WOLF_FRIENDLY_PENALTY );
}
} else {
//G_AddExperience( attacker, 1 );
// JPW NERVE -- mostly added as conveneience so we can tweak from the #defines all in one place
AddScore(attacker, WOLF_FRAG_BONUS);
if( g_gametype.integer == GT_WOLF_LMS ) {
if( level.firstbloodTeam == -1 )
level.firstbloodTeam = attacker->client->sess.sessionTeam;
AddKillScore( attacker, WOLF_FRAG_BONUS );
}
attacker->client->lastKillTime = level.time;
}
} else {
AddScore( self, -1 );
if( g_gametype.integer == GT_WOLF_LMS )
AddKillScore( self, -1 );
}
// Add team bonuses
Team_FragBonuses(self, inflictor, attacker);
// drop flag regardless
if (self->client->ps.powerups[PW_REDFLAG]) {
item = BG_FindItem("Red Flag");
if (!item)
item = BG_FindItem("Objective");
self->client->ps.powerups[PW_REDFLAG] = 0;
}
if (self->client->ps.powerups[PW_BLUEFLAG]) {
item = BG_FindItem("Blue Flag");
if (!item)
item = BG_FindItem("Objective");
self->client->ps.powerups[PW_BLUEFLAG] = 0;
}
if (item) {
vec3_t launchvel = { 0, 0, 0 };
gentity_t *flag = LaunchItem(item, self->r.currentOrigin, launchvel, self->s.number);
flag->s.modelindex2 = self->s.otherEntityNum2;// JPW NERVE FIXME set player->otherentitynum2 with old modelindex2 from flag and restore here
flag->message = self->message; // DHM - Nerve :: also restore item name
// Clear out player's temp copies
self->s.otherEntityNum2 = 0;
self->message = NULL;
}
// send a fancy "MEDIC!" scream. Sissies, ain' they?
if (self->client != NULL) {
if( self->health > GIB_HEALTH && meansOfDeath != MOD_SUICIDE && meansOfDeath != MOD_SWITCHTEAM ) {
G_AddEvent( self, EV_MEDIC_CALL, 0 );
}
}
Cmd_Score_f( self ); // show scores
// send updated scores to any clients that are following this one,
// or they would get stale scoreboards
for(i=0; i<level.numConnectedClients; i++) {
gclient_t *client = &level.clients[level.sortedClients[i]];
if(client->pers.connected != CON_CONNECTED) continue;
if(client->sess.sessionTeam != TEAM_SPECTATOR) continue;
if(client->sess.spectatorClient == self->s.number) {
Cmd_Score_f(g_entities + level.sortedClients[i]);
}
}
self->takedamage = qtrue; // can still be gibbed
self->r.contents = CONTENTS_CORPSE;
//self->s.angles[2] = 0;
self->s.powerups = 0;
self->s.loopSound = 0;
self->client->limboDropWeapon = self->s.weapon; // store this so it can be dropped in limbo
LookAtKiller( self, inflictor, attacker );
self->client->ps.viewangles[0] = 0;
self->client->ps.viewangles[2] = 0;
//VectorCopy( self->s.angles, self->client->ps.viewangles );
// trap_UnlinkEntity( self );
self->r.maxs[2] = self->client->ps.crouchMaxZ; //% 0; // ydnar: so bodies don't clip into world
self->client->ps.maxs[2] = self->client->ps.crouchMaxZ; //% 0; // ydnar: so bodies don't clip into world
trap_LinkEntity( self );
// don't allow respawn until the death anim is done
// g_forcerespawn may force spawning at some later time
self->client->respawnTime = level.timeCurrent + 800;
// remove powerups
memset( self->client->ps.powerups, 0, sizeof(self->client->ps.powerups) );
// never gib in a nodrop
// FIXME: contents is always 0 here
if ( self->health <= GIB_HEALTH && !(contents & CONTENTS_NODROP) ) {
GibEntity( self, killer );
nogib = qfalse;
}
if(nogib){
// normal death
// for the no-blood option, we need to prevent the health
// from going to gib level
if ( self->health <= GIB_HEALTH ) {
self->health = GIB_HEALTH + 1;
}
// Arnout: re-enable this for flailing
/* if( self->client->ps.groundEntityNum == ENTITYNUM_NONE ) {
self->client->ps.pm_flags |= PMF_FLAILING;
self->client->ps.pm_time = 750;
BG_AnimScriptAnimation( &self->client->ps, ANIM_MT_FLAILING, qtrue );
// Face explosion directory
{
vec3_t angles;
vectoangles( self->client->ps.velocity, angles );
self->client->ps.viewangles[YAW] = angles[YAW];
SetClientViewAngle( self, self->client->ps.viewangles );
}
} else*/
// DHM - Play death animation, and set pm_time to delay 'fallen' animation
//if( G_IsSinglePlayerGame() && self->client->sess.sessionTeam == TEAM_ALLIES ) {
// // play "falldown" animation since allies bots won't ever die completely
// self->client->ps.pm_time = BG_AnimScriptEvent( &self->client->ps, self->client->pers.character->animModelInfo, ANIM_ET_FALLDOWN, qfalse, qtrue );
// G_StartPlayerAppropriateSound(self, "death");
//} else {
self->client->ps.pm_time = BG_AnimScriptEvent( &self->client->ps, self->client->pers.character->animModelInfo, ANIM_ET_DEATH, qfalse, qtrue );
// death animation script already contains sound
//}
// record the death animation to be used later on by the corpse
self->client->torsoDeathAnim = self->client->ps.torsoAnim;
self->client->legsDeathAnim = self->client->ps.legsAnim;
G_AddEvent( self, EV_DEATH1 + 1, killer );
// the body can still be gibbed
self->die = body_die;
}
if( meansOfDeath == MOD_MACHINEGUN ) {
switch( self->client->sess.sessionTeam ) {
case TEAM_AXIS:
level.axisMG42Counter = level.time;
break;
case TEAM_ALLIES:
level.alliesMG42Counter = level.time;
break;
}
}
G_FadeItems( self, MOD_SATCHEL );
CalculateRanks();
if( killedintank /*Gordon: automatically go to limbo from tank*/ ) {
limbo( self, qfalse ); // but no corpse
} else if ( (meansOfDeath == MOD_SUICIDE && g_gamestate.integer == GS_PLAYING) ) {
limbo( self, qtrue );
} else if( g_gametype.integer == GT_WOLF_LMS ) {
if( !G_CountTeamMedics( self->client->sess.sessionTeam, qtrue ) ) {
limbo( self, qtrue );
}
}
}
/*
============
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] ) );
}
}
void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
gentity_t *ent;
// TTimo might be used uninitialized
int contents = 0;
int killer;
int i;
const char *killerName, *obit;
qboolean nogib = qtrue;
gitem_t *item = NULL; // JPW NERVE for flag drop
vec3_t launchvel,launchspot; // JPW NERVE
gentity_t *flag; // JPW NERVE
if ( self->client->ps.pm_type == PM_DEAD ) {
return;
}
if ( level.intermissiontime ) {
return;
}
self->client->ps.pm_type = PM_DEAD;
G_AddEvent( self, EV_STOPSTREAMINGSOUND, 0 );
if ( attacker ) {
killer = attacker->s.number;
if ( attacker->client ) {
killerName = attacker->client->pers.netname;
} else {
killerName = "<non-client>";
}
} else {
killer = ENTITYNUM_WORLD;
killerName = "<world>";
}
if ( killer < 0 || killer >= MAX_CLIENTS ) {
killer = ENTITYNUM_WORLD;
killerName = "<world>";
}
if ( meansOfDeath < 0 || meansOfDeath >= sizeof( modNames ) / sizeof( modNames[0] ) ) {
obit = "<bad obituary>";
} else {
obit = modNames[ meansOfDeath ];
}
G_LogPrintf( "Kill: %i %i %i: %s killed %s by %s\n",
killer, self->s.number, meansOfDeath, killerName,
self->client->pers.netname, obit );
// broadcast the death event to everyone
ent = G_TempEntity( self->r.currentOrigin, EV_OBITUARY );
ent->s.eventParm = meansOfDeath;
ent->s.otherEntityNum = self->s.number;
ent->s.otherEntityNum2 = killer;
ent->r.svFlags = SVF_BROADCAST; // send to everyone
self->enemy = attacker;
self->client->ps.persistant[PERS_KILLED]++;
// JPW NERVE -- if player is holding ticking grenade, drop it
if ( g_gametype.integer != GT_SINGLE_PLAYER ) {
if ( ( self->client->ps.grenadeTimeLeft ) && ( self->s.weapon != WP_DYNAMITE ) ) {
launchvel[0] = crandom();
launchvel[1] = crandom();
launchvel[2] = random();
VectorScale( launchvel, 160, launchvel );
VectorCopy( self->r.currentOrigin, launchspot );
launchspot[2] += 40;
fire_grenade( self, launchspot, launchvel, self->s.weapon );
}
}
// jpw
if ( attacker && attacker->client ) {
if ( attacker == self || OnSameTeam( self, attacker ) ) {
// DHM - Nerve :: Complaint lodging
if ( attacker != self && level.warmupTime <= 0 ) {
if ( attacker->client->pers.localClient ) {
trap_SendServerCommand( self - g_entities, "complaint -4" );
} else {
trap_SendServerCommand( self - g_entities, va( "complaint %i", attacker->s.number ) );
self->client->pers.complaintClient = attacker->s.clientNum;
self->client->pers.complaintEndTime = level.time + 20500;
}
}
// dhm
// JPW NERVE
if ( g_gametype.integer >= GT_WOLF ) { // high penalty to offset medic heal
AddScore( attacker, WOLF_FRIENDLY_PENALTY );
} else {
// jpw
AddScore( attacker, -1 );
}
} else {
// JPW NERVE -- mostly added as conveneience so we can tweak from the #defines all in one place
if ( g_gametype.integer >= GT_WOLF ) {
AddScore( attacker, WOLF_FRAG_BONUS );
} else {
// jpw
AddScore( attacker, 1 );
}
attacker->client->lastKillTime = level.time;
}
} else {
AddScore( self, -1 );
}
// Add team bonuses
Team_FragBonuses( self, inflictor, attacker );
// if client is in a nodrop area, don't drop anything
// JPW NERVE new drop behavior
if ( g_gametype.integer == GT_SINGLE_PLAYER ) { // only drop here in single player; in multiplayer, drop @ limbo
contents = trap_PointContents( self->r.currentOrigin, -1 );
if ( !( contents & CONTENTS_NODROP ) ) {
TossClientItems( self );
}
}
// drop flag regardless
if ( g_gametype.integer != GT_SINGLE_PLAYER ) {
if ( self->client->ps.powerups[PW_REDFLAG] ) {
item = BG_FindItem( "Red Flag" );
if ( !item ) {
item = BG_FindItem( "Objective" );
}
self->client->ps.powerups[PW_REDFLAG] = 0;
}
if ( self->client->ps.powerups[PW_BLUEFLAG] ) {
item = BG_FindItem( "Blue Flag" );
if ( !item ) {
item = BG_FindItem( "Objective" );
}
self->client->ps.powerups[PW_BLUEFLAG] = 0;
}
if ( item ) {
launchvel[0] = crandom() * 20;
launchvel[1] = crandom() * 20;
launchvel[2] = 10 + random() * 10;
flag = LaunchItem( item,self->r.currentOrigin,launchvel,self->s.number );
flag->s.modelindex2 = self->s.otherEntityNum2; // JPW NERVE FIXME set player->otherentitynum2 with old modelindex2 from flag and restore here
flag->message = self->message; // DHM - Nerve :: also restore item name
// Clear out player's temp copies
self->s.otherEntityNum2 = 0;
self->message = NULL;
}
// send a fancy "MEDIC!" scream. Sissies, ain' they?
if ( self->client != NULL ) {
if ( self->health > GIB_HEALTH && meansOfDeath != MOD_SUICIDE ) {
if ( self->client->sess.sessionTeam == TEAM_RED ) {
if ( random() > 0.5 ) {
G_AddEvent( self, EV_GENERAL_SOUND, G_SoundIndex( "sound/multiplayer/axis/g-medic2.wav" ) );
} else {
G_AddEvent( self, EV_GENERAL_SOUND, G_SoundIndex( "sound/multiplayer/axis/g-medic3.wav" ) );
}
} else {
if ( random() > 0.5 ) {
G_AddEvent( self, EV_GENERAL_SOUND, G_SoundIndex( "sound/multiplayer/allies/a-medic3.wav" ) );
} else {
G_AddEvent( self, EV_GENERAL_SOUND, G_SoundIndex( "sound/multiplayer/allies/a-medic2.wav" ) );
}
}
}
}
}
// jpw
Cmd_Score_f( self ); // show scores
// send updated scores to any clients that are following this one,
// or they would get stale scoreboards
for ( i = 0 ; i < level.maxclients ; i++ ) {
gclient_t *client;
client = &level.clients[i];
if ( client->pers.connected != CON_CONNECTED ) {
continue;
}
if ( client->sess.sessionTeam != TEAM_SPECTATOR ) {
continue;
}
if ( client->sess.spectatorClient == self->s.number ) {
Cmd_Score_f( g_entities + i );
}
}
self->takedamage = qtrue; // can still be gibbed
self->r.contents = CONTENTS_CORPSE;
self->s.powerups = 0;
// JPW NERVE -- only corpse in SP; in MP, need CONTENTS_BODY so medic can operate
if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
self->s.weapon = WP_NONE;
self->s.angles[0] = 0;
} else {
self->client->limboDropWeapon = self->s.weapon; // store this so it can be dropped in limbo
}
// jpw
self->s.angles[2] = 0;
LookAtKiller( self, inflictor, attacker );
VectorCopy( self->s.angles, self->client->ps.viewangles );
self->s.loopSound = 0;
trap_UnlinkEntity( self );
self->r.maxs[2] = 0;
self->client->ps.maxs[2] = 0;
trap_LinkEntity( self );
// don't allow respawn until the death anim is done
// g_forcerespawn may force spawning at some later time
self->client->respawnTime = level.time + 800;
// remove powerups
memset( self->client->ps.powerups, 0, sizeof( self->client->ps.powerups ) );
// never gib in a nodrop
if ( self->health <= GIB_HEALTH && !( contents & CONTENTS_NODROP ) ) {
GibEntity( self, killer );
nogib = qfalse;
}
if ( nogib ) {
// normal death
// for the no-blood option, we need to prevent the health
// from going to gib level
if ( self->health <= GIB_HEALTH ) {
self->health = GIB_HEALTH + 1;
}
// JPW NERVE for medic
self->client->medicHealAmt = 0;
// jpw
// DHM - Play death animation, and set pm_time to delay 'fallen' animation
self->client->ps.pm_time = BG_AnimScriptEvent( &self->client->ps, ANIM_ET_DEATH, qfalse, qtrue );
G_AddEvent( self, EV_DEATH1 + 1, killer );
// the body can still be gibbed
self->die = body_die;
}
trap_LinkEntity( self );
if ( g_gametype.integer >= GT_WOLF && meansOfDeath == MOD_SUICIDE ) {
limbo( self, qtrue );
}
}
/*
============
AICast_Die
============
*/
void AICast_Die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
int contents;
int killer;
cast_state_t *cs;
qboolean nogib = qtrue;
// print debugging message
if ( aicast_debug.integer == 2 && attacker->s.number == 0 ) {
G_Printf( "killed %s\n", self->aiName );
}
cs = AICast_GetCastState( self->s.number );
if ( attacker ) {
killer = attacker->s.number;
} else {
killer = ENTITYNUM_WORLD;
}
// record the sighting (FIXME: silent weapons shouldn't do this, but the AI should react in some way)
if ( attacker->client ) {
AICast_UpdateVisibility( self, attacker, qtrue, qtrue );
}
// the zombie should show special effect instead of gibbing
if ( self->aiCharacter == AICHAR_ZOMBIE && cs->secondDeadTime ) {
if ( cs->secondDeadTime > 1 ) {
// we are already totally dead
self->health += damage; // don't drop below gib_health if we weren't already below it
return;
}
/*
if (!cs->rebirthTime)
{
self->health = -999;
damage = 999;
} else if ( self->health >= GIB_HEALTH ) {
// while waiting for rebirth, we only "die" if we drop below gib health
return;
}
*/
// always gib
self->health = -999;
damage = 999;
}
// Zombies are very fragile against highly explosives
if ( self->aiCharacter == AICHAR_ZOMBIE && damage > 20 && inflictor != attacker ) {
self->health = -999;
damage = 999;
}
// process the event
if ( self->client->ps.pm_type == PM_DEAD ) {
// already dead
if ( self->health < GIB_HEALTH ) {
if ( self->aiCharacter == AICHAR_ZOMBIE ) {
// RF, changed this so Zombies always gib now
GibEntity( self, killer );
nogib = qfalse;
/*
// Zombie has special exploding cloud effect
if (attacker != inflictor || attacker->s.weapon == WP_VENOM)
{
GibEntity( self, killer );
nogib = qfalse;
} else {
// Zombie will decompose upon dying
self->client->ps.eFlags |= EF_MONSTER_EFFECT2;
self->s.effect2Time = level.time+200;
self->health = -1;
}
*/
self->takedamage = qfalse;
self->r.contents = 0;
cs->secondDeadTime = 2;
cs->rebirthTime = 0;
cs->revivingTime = 0;
} else {
body_die( self, inflictor, attacker, damage, meansOfDeath );
return;
}
}
} else { // this is our first death, so set everything up
if ( level.intermissiontime ) {
return;
}
self->client->ps.pm_type = PM_DEAD;
self->enemy = attacker;
// drop a weapon?
// if client is in a nodrop area, don't drop anything
contents = trap_PointContents( self->r.currentOrigin, -1 );
if ( !( contents & CONTENTS_NODROP ) ) {
TossClientItems( self );
}
// make sure the client doesn't forget about this entity until it's set to "dead" frame
// otherwise it might replay it's death animation if it goes out and into client view
self->r.svFlags |= SVF_BROADCAST;
self->takedamage = qtrue; // can still be gibbed
self->s.weapon = WP_NONE;
self->s.powerups = 0;
self->r.contents = CONTENTS_CORPSE;
self->s.angles[0] = 0;
self->s.angles[1] = self->client->ps.viewangles[1];
self->s.angles[2] = 0;
VectorCopy( self->s.angles, self->client->ps.viewangles );
self->s.loopSound = 0;
self->r.maxs[2] = -8;
self->client->ps.maxs[2] = self->r.maxs[2];
// remove powerups
memset( self->client->ps.powerups, 0, sizeof( self->client->ps.powerups ) );
//cs->rebirthTime = 0;
// never gib in a nodrop
if ( self->health <= GIB_HEALTH ) {
if ( self->aiCharacter == AICHAR_ZOMBIE ) {
// RF, changed this so Zombies always gib now
GibEntity( self, killer );
nogib = qfalse;
/*
// Zombie has special exploding cloud effect
if (attacker != inflictor || attacker->s.weapon == WP_VENOM)
{
GibEntity( self, killer );
nogib = qfalse;
self->takedamage = qfalse;
self->r.contents = 0;
cs->secondDeadTime = 2;
} else {
self->client->ps.eFlags |= EF_MONSTER_EFFECT2;
self->s.effect2Time = level.time+200;
self->takedamage = qfalse;
self->r.contents = 0;
self->health = -1;
cs->secondDeadTime = 2;
}
*/
} else if ( !( contents & CONTENTS_NODROP ) ) {
body_die( self, inflictor, attacker, damage, meansOfDeath );
//GibEntity( self, killer );
nogib = qfalse;
}
}
// if we are a zombie, and lying down during our first death, then we should just die
if ( !( self->aiCharacter == AICHAR_ZOMBIE && cs->secondDeadTime && cs->rebirthTime ) ) {
// set enemy weapon
BG_UpdateConditionValue( self->s.number, ANIM_COND_ENEMY_WEAPON, 0, qfalse );
if ( attacker->client ) {
BG_UpdateConditionValue( self->s.number, ANIM_COND_ENEMY_WEAPON, inflictor->s.weapon, qtrue );
} else {
BG_UpdateConditionValue( self->s.number, ANIM_COND_ENEMY_WEAPON, 0, qfalse );
}
// set enemy location
BG_UpdateConditionValue( self->s.number, ANIM_COND_ENEMY_POSITION, 0, qfalse );
if ( infront( self, inflictor ) ) {
BG_UpdateConditionValue( self->s.number, ANIM_COND_ENEMY_POSITION, POSITION_INFRONT, qtrue );
} else {
BG_UpdateConditionValue( self->s.number, ANIM_COND_ENEMY_POSITION, POSITION_BEHIND, qtrue );
}
// play the animation
BG_AnimScriptEvent( &self->client->ps, ANIM_ET_DEATH, qfalse, qtrue );
// set this flag so no other anims override us
self->client->ps.eFlags |= EF_DEAD;
self->s.eFlags |= EF_DEAD;
}
}
if ( nogib ) {
// set for rebirth
if ( self->aiCharacter == AICHAR_ZOMBIE ) {
if ( !cs->secondDeadTime ) {
cs->rebirthTime = level.time + 5000 + rand() % 2000;
cs->secondDeadTime = qtrue;
cs->revivingTime = 0;
} else if ( cs->secondDeadTime > 1 ) {
cs->rebirthTime = 0;
cs->revivingTime = 0;
cs->deathTime = level.time;
}
} else {
// the body can still be gibbed
self->die = body_die;
}
}
trap_LinkEntity( self );
// mark the time of death
cs->deathTime = level.time;
// dying ai's can trigger a target
if ( !cs->rebirthTime ) {
G_UseTargets( self, self );
// really dead now, so call the script
AICast_ScriptEvent( cs, "death", "" );
// call the deathfunc for this cast, so we can play associated sounds, or do any character-specific things
if ( !( cs->aiFlags & AIFL_DENYACTION ) && cs->deathfunc ) {
cs->deathfunc( self, attacker, damage, meansOfDeath ); //----(SA) added mod
}
} else {
// really dead now, so call the script
AICast_ScriptEvent( cs, "fakedeath", "" );
// call the deathfunc for this cast, so we can play associated sounds, or do any character-specific things
if ( !( cs->aiFlags & AIFL_DENYACTION ) && cs->deathfunc ) {
cs->deathfunc( self, attacker, damage, meansOfDeath ); //----(SA) added mod
}
}
}
/*
==============
AICast_UpdateVisibility
==============
*/
void AICast_UpdateVisibility( gentity_t *srcent, gentity_t *destent, qboolean shareVis, qboolean directview ) {
cast_visibility_t *vis, *ovis, *svis, oldvis;
cast_state_t *cs, *ocs;
qboolean shareRange;
int cnt, i;
if ( destent->flags & FL_NOTARGET ) {
return;
}
cs = AICast_GetCastState( srcent->s.number );
ocs = AICast_GetCastState( destent->s.number );
if ( cs->castScriptStatus.scriptNoSightTime >= level.time ) {
return; // absolutely no sight (or hear) information allowed
}
shareRange = ( VectorDistance( srcent->client->ps.origin, destent->client->ps.origin ) < AIVIS_SHARE_RANGE );
vis = &cs->vislist[destent->s.number];
vis->chase_marker_count = 0;
if ( aicast_debug.integer == 1 ) {
if ( !vis->visible_timestamp || vis->visible_timestamp < level.time - 5000 ) {
if ( directview ) {
G_Printf( "SIGHT (direct): %s sees %s\n", srcent->aiName, destent->aiName );
} else {
G_Printf( "SIGHT (non-direct/audible): %s sees %s\n", srcent->aiName, destent->aiName );
}
}
}
// trigger the sight event
AICast_Sight( srcent, destent, vis->visible_timestamp );
// update the values
vis->lastcheck_timestamp = level.time;
vis->visible_timestamp = level.time;
VectorCopy( destent->client->ps.origin, vis->visible_pos );
VectorCopy( destent->client->ps.velocity, vis->visible_vel );
vis->lastcheck_health = destent->health - 1;
// we may need to process this visibility at some point, even after they become not visible again
vis->flags |= AIVIS_PROCESS_SIGHTING;
if ( directview ) {
vis->real_visible_timestamp = level.time;
VectorCopy( destent->client->ps.origin, vis->real_visible_pos );
vis->real_update_timestamp = level.time;
}
// if we are on fire, then run away from anything we see
if ( cs->attributes[AGGRESSION] < 1.0 && srcent->s.onFireEnd > level.time && ( !destent->s.number || cs->dangerEntityValidTime < level.time + 2000 ) && !( cs->aiFlags & AIFL_NO_FLAME_DAMAGE ) ) {
cs->dangerEntity = destent->s.number;
VectorCopy( destent->r.currentOrigin, cs->dangerEntityPos );
cs->dangerEntityValidTime = level.time + 5000;
cs->dangerDist = 99999;
cs->dangerEntityTimestamp = level.time;
}
// Look for reasons to make this character an enemy of ours
// if they are an enemy and inside the detection radius, go hostile
if ( !( vis->flags & AIVIS_ENEMY ) && !AICast_SameTeam( cs, destent->s.number ) ) {
float idr;
idr = cs->attributes[INNER_DETECTION_RADIUS];
if ( cs->aiFlags & AIFL_ZOOMING ) {
idr *= 10;
}
if ( !( vis->flags & AIVIS_ENEMY ) && VectorDistance( vis->visible_pos, g_entities[cs->entityNum].r.currentOrigin ) < idr ) {
// RF, moved them over to AICast_ScanForEnemies()
//AICast_ScriptEvent( cs, "enemysight", destent->aiName );
vis->flags |= AIVIS_ENEMY;
}
// if we are in (or above) ALERT mode, then we now know this is an enemy
else if ( cs->aiState >= AISTATE_ALERT ) {
// RF, moved them over to AICast_ScanForEnemies()
//AICast_ScriptEvent( cs, "enemysight", destent->aiName );
vis->flags |= AIVIS_ENEMY;
}
}
// if they are friendly, then we should help them out if they are in trouble
if ( AICast_SameTeam( cs, destent->s.number ) && ( srcent->aiTeam == AITEAM_ALLIES || srcent->aiTeam == AITEAM_NAZI ) ) {
// if they are dead, we should check them out
if ( destent->health <= 0 ) {
// if we haven't already checked them out
if ( !( vis->flags & AIVIS_INSPECTED ) ) {
vis->flags |= AIVIS_INSPECT;
}
// if they are mad, we should help, or at least act concerned
} else if ( cs->aiState < AISTATE_COMBAT && ocs->aiState >= AISTATE_COMBAT && ocs->bs && ( ocs->enemyNum >= 0 ) ) {
// if we haven't already checked them out
if ( !( vis->flags & AIVIS_INSPECTED ) ) {
vis->flags |= AIVIS_INSPECT;
}
// if they are alert, we should also go alert
} else if ( cs->aiState < AISTATE_ALERT && ocs->aiState == AISTATE_ALERT && ocs->bs ) {
AICast_StateChange( cs, AISTATE_ALERT );
}
}
// if this is a friendly, then check them for hostile's that we currently haven't upgraded so
if ( ( destent->health > 0 ) &&
( srcent->aiTeam == destent->aiTeam ) && // only share with exact same team, and non-neutrals
( srcent->aiTeam != AITEAM_NEUTRAL ) ) {
ocs = AICast_GetCastState( destent->s.number );
cnt = 0;
//
for ( i = 0; i < aicast_maxclients && cnt < level.numPlayingClients; i++ ) {
if ( !g_entities[i].inuse ) {
continue;
}
//
cnt++;
//
if ( i == srcent->s.number ) {
continue;
}
if ( i == destent->s.number ) {
continue;
}
//
ovis = &ocs->vislist[i];
svis = &cs->vislist[i];
//
// if we are close to the friendly, then we should share their visibility info
if ( destent->health > 0 && shareRange ) {
oldvis = *svis;
// if they have seen this character more recently than us, share
if ( ( ovis->visible_timestamp > svis->visible_timestamp ) ||
( ( ovis->visible_timestamp > level.time - 5000 ) && ( ovis->flags & AIVIS_ENEMY ) && !( svis->flags & AIVIS_ENEMY ) ) ) {
// trigger an EVENT
// trigger the sight event
AICast_Sight( srcent, destent, ovis->visible_timestamp );
// we may need to process this visibility at some point, even after they become not visible again
svis->flags |= AIVIS_PROCESS_SIGHTING;
// if we are sharing information about an enemy, then trigger a scripted event
if ( !svis->real_visible_timestamp && ovis->real_visible_timestamp && ( ovis->flags & AIVIS_ENEMY ) ) {
// setup conditions
BG_UpdateConditionValue( ocs->entityNum, ANIM_COND_ENEMY_TEAM, g_entities[i].aiTeam, qfalse );
// call the event
BG_AnimScriptEvent( &g_entities[ocs->entityNum].client->ps, ANIM_ET_INFORM_FRIENDLY_OF_ENEMY, qfalse, qfalse );
}
// copy the whole structure
*svis = *ovis;
// minus the flags
svis->flags = oldvis.flags;
// keep our sight time if it's sooner
if ( oldvis.visible_timestamp > ovis->visible_timestamp ) {
svis->visible_timestamp = oldvis.visible_timestamp;
}
// check to see if we just made this character an enemy of ours
if ( /*(cs->aiState == AISTATE_COMBAT) &&*/ ( ovis->flags & AIVIS_ENEMY ) && !( oldvis.flags & AIVIS_ENEMY ) ) {
svis->flags |= AIVIS_ENEMY;
if ( !( cs->vislist[i].flags & AIVIS_SIGHT_SCRIPT_CALLED ) ) {
AICast_ScriptEvent( cs, "enemysight", g_entities[i].aiName );
cs->vislist[i].flags |= AIVIS_SIGHT_SCRIPT_CALLED;
if ( !( cs->aiFlags & AIFL_DENYACTION ) ) {
G_AddEvent( srcent, EV_GENERAL_SOUND, G_SoundIndex( aiDefaults[cs->aiCharacter].soundScripts[SIGHTSOUNDSCRIPT] ) );
}
}
}
}
} else {
// if either of us haven't seen this character yet, then ignore it
if ( !svis->visible_timestamp || !ovis->visible_timestamp ) {
continue;
}
}
//
// if they have marked this character as hostile, then we should also
if ( ( cs->aiState == AISTATE_COMBAT ) && AICast_HostileEnemy( ocs, i ) && !AICast_HostileEnemy( cs, i ) ) {
if ( !( cs->vislist[i].flags & AIVIS_SIGHT_SCRIPT_CALLED ) ) {
AICast_ScriptEvent( cs, "enemysight", g_entities[i].aiName );
cs->vislist[i].flags |= AIVIS_SIGHT_SCRIPT_CALLED;
if ( !( cs->aiFlags & AIFL_DENYACTION ) ) {
G_AddEvent( srcent, EV_GENERAL_SOUND, G_SoundIndex( aiDefaults[cs->aiCharacter].soundScripts[SIGHTSOUNDSCRIPT] ) );
}
}
svis->flags |= AIVIS_ENEMY;
}
}
}
}
