void CGrenade :: UseSatchelCharges( entvars_t *pevOwner, SATCHELCODE code )
{
edict_t *pentFind;
edict_t *pentOwner;
if ( !pevOwner )
return;
CBaseEntity *pOwner = CBaseEntity::Instance( pevOwner );
pentOwner = pOwner->edict();
pentFind = FIND_ENTITY_BY_CLASSNAME( NULL, "grenade" );
while ( !FNullEnt( pentFind ) )
{
CBaseEntity *pEnt = Instance( pentFind );
if ( pEnt )
{
if ( FBitSet( pEnt->pev->spawnflags, SF_DETONATE ) && pEnt->pev->owner == pentOwner )
{
if ( code == SATCHEL_DETONATE )
pEnt->Use( pOwner, pOwner, USE_ON, 0 );
else // SATCHEL_RELEASE
pEnt->pev->owner = NULL;
}
}
pentFind = FIND_ENTITY_BY_CLASSNAME( pentFind, "grenade" );
}
}
BOOL CGrenade::IsInGaz ( void )
{
Vector vecPlayer = Center ();
CBaseEntity *pFind = NULL;
edict_t *pTrigger = NULL;
pTrigger = FIND_ENTITY_BY_CLASSNAME( NULL, "trigger_gaz" );
while ( !FNullEnt ( pTrigger ) )
{
pFind = CBaseEntity::Instance ( pTrigger );
if ( vecPlayer.x > pFind->pev->absmin.x && vecPlayer.x < pFind->pev->absmax.x &&
vecPlayer.y > pFind->pev->absmin.y && vecPlayer.y < pFind->pev->absmax.y &&
vecPlayer.z > pFind->pev->absmin.z && vecPlayer.z < pFind->pev->absmax.z ) // Player est ds le trigger
{
return TRUE;
}
else
{
pTrigger = FIND_ENTITY_BY_CLASSNAME( pTrigger, "trigger_gaz" );
}
}
return FALSE;
}
int GetTeam (edict_t *ent)
{
// SyPB Pro P.1
// new get team off set, return player true team
int client = ENTINDEX (ent) - 1, player_team;
// SyPB Pro P.5
if (!IsValidPlayer (ent))
{
player_team = 0;
edict_t *entity = null;
ITERATE_ARRAY (g_entityName, j)
{
while (!FNullEnt (entity = FIND_ENTITY_BY_CLASSNAME (entity, g_entityName[j])))
{
if (ent == entity)
{
player_team = g_entityTeam[j];
break;
}
}
}
player_team--;
if (GetGameMod () == 99 && g_DelayTimer > engine->GetTime ())
player_team = 2;
return player_team;
}
void DeactivateBiomass( CBasePlayer *pOwner )
{
edict_t *pFind;
pFind = FIND_ENTITY_BY_CLASSNAME( NULL, "biomass" );
while ( !FNullEnt( pFind ) )
{
CBaseEntity *pEnt = CBaseEntity::Instance( pFind );
CBiomass *pBioCharge = (CBiomass *)pEnt;
if ( pBioCharge)
{
if ( pBioCharge->pev->owner == pOwner->edict() )
pBioCharge->Deactivate();
}
pFind = FIND_ENTITY_BY_CLASSNAME( pFind, "biomass" );
}
}
//=========================================================
// DeactivateSatchels - removes all satchels owned by
// the provided player. Should only be used upon death.
//
// Made this global on purpose.
//=========================================================
void DeactivateSatchels(CBasePlayer *pOwner)
{
edict_t *pFind;
pFind = FIND_ENTITY_BY_CLASSNAME(NULL, "monster_satchel");
while (!FNullEnt(pFind))
{
CBaseEntity *pEnt = CBaseEntity::Instance(pFind);
CSatchelCharge *pSatchel = (CSatchelCharge *)pEnt;
if (pSatchel)
{
if (pSatchel->pev->owner == pOwner->edict())
pSatchel->Deactivate();
}
pFind = FIND_ENTITY_BY_CLASSNAME(pFind, "monster_satchel");
}
}
/*
================
SpectatorImpulseCommand
Called by SpectatorThink if the spectator entered an impulse
================
*/
void CBaseSpectator::SpectatorImpulseCommand(void)
{
static edict_t *pGoal = nullptr;
edict_t *pPreviousGoal;
edict_t *pCurrentGoal;
BOOL bFound;
switch (pev->impulse)
{
case 1:
// teleport the spectator to the next spawn point
// note that if the spectator is tracking, this doesn't do
// much
pPreviousGoal = pGoal;
pCurrentGoal = pGoal;
// Start at the current goal, skip the world, and stop if we looped
// back around
bFound = FALSE;
while (1)
{
pCurrentGoal = FIND_ENTITY_BY_CLASSNAME(pCurrentGoal, "info_player_deathmatch");
// Looped around, failure
if (pCurrentGoal == pPreviousGoal)
{
ALERT(at_console, "Could not find a spawn spot.\n");
break;
}
// Found a non-world entity, set success, otherwise, look for the next one.
if (!FNullEnt(pCurrentGoal))
{
bFound = TRUE;
break;
}
}
if (!bFound) // Didn't find a good spot.
break;
pGoal = pCurrentGoal;
UTIL_SetOrigin( pev, pGoal->v.origin );
pev->angles = pGoal->v.angles;
pev->fixangle = FALSE;
break;
default:
ALERT(at_console, "Unknown spectator impulse\n");
break;
}
pev->impulse = 0;
}
static cell AMX_NATIVE_CALL get_grenade_id(AMX *amx, cell *params) /* 4 param */
{
int index = params[1];
const char *szModel;
CHECK_ENTITY(index);
edict_t* pentFind = INDEXENT2(params[4]);
edict_t* pentOwner = INDEXENT2(index);
pentFind = FIND_ENTITY_BY_CLASSNAME( pentFind, "grenade" );
while (!FNullEnt(pentFind)) {
if (pentFind->v.owner == pentOwner) {
if (params[3]>0) {
szModel = (char*)STRING(pentFind->v.model);
MF_SetAmxString(amx, params[2], szModel, params[3]);
return ENTINDEX(pentFind);
}
}
pentFind = FIND_ENTITY_BY_CLASSNAME( pentFind, "grenade" );
}
return 0;
}
int CTankBSP :: Classify( void )
{
// trouve le model
edict_t *pent = FIND_ENTITY_BY_CLASSNAME ( NULL, "info_tank_model" );
if ( pent == NULL )
return CLASS_NONE;
CTank *pTank = (CTank*) CBaseEntity::Instance(pent);
// classe selon l'état du tank
if ( pTank->bTankOn == 1 )
return CLASS_PLAYER_ALLY;
return CLASS_NONE;
};
void CTank :: UseTank ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
edict_t *pentFind;
CBaseEntity *pFind;
pentFind = FIND_ENTITY_BY_CLASSNAME( NULL, "info_teleport_destination" );
if ( pentFind == NULL )
{
ALERT ( at_console , "info_tank_model : pas de teleport destination !!!\n" );
return;
}
else
{
pFind = CBaseEntity :: Instance ( pentFind );
Vector vecTeleport = pFind->pev->origin;
UTIL_SetOrigin( pActivator->pev, vecTeleport );
m_pPlayer = (CBasePlayer*) pActivator;
m_pPlayer->m_iDrivingTank = TRUE;
m_pPlayer->m_iHideHUD |= HIDEHUD_ALL;
m_pCam = GetClassPtr( (CTankCam*)NULL );
UTIL_SetOrigin( m_pCam->pev, vecCamOrigin() );
m_pCam->pev->angles = TourelleAngle();
m_pCam->Spawn();
m_pCam->pev->velocity = ( UpdateCam () - vecCamOrigin() ) /2;
m_pCam->m_pTankModel = this;
UpdateCamAngle ( UpdateCam (), 2 );
m_pCam->SetPlayerTankView ( TRUE );
SetThink( DriveThink );
pev->nextthink = gpGlobals->time + 2;
}
}
// Find an entity that I'm interested in and precache the sounds he'll need in the sequence.
void CCineMonster::Activate(void)
{
edict_t * pentTarget;
CBaseMonster *pTarget;
// The entity name could be a target name or a classname
// Check the targetname
pentTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(m_iszEntity));
pTarget = NULL;
while(!pTarget && !FNullEnt(pentTarget))
{
if(FBitSet(VARS(pentTarget)->flags, FL_MONSTER))
{
pTarget = GetMonsterPointer(pentTarget);
}
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
}
// If no entity with that targetname, check the classname
if(!pTarget)
{
pentTarget = FIND_ENTITY_BY_CLASSNAME(NULL, STRING(m_iszEntity));
while(!pTarget && !FNullEnt(pentTarget))
{
pTarget = GetMonsterPointer(pentTarget);
pentTarget = FIND_ENTITY_BY_TARGETNAME(pentTarget, STRING(m_iszEntity));
}
}
// Found a compatible entity
if(pTarget)
{
void *pmodel;
pmodel = GET_MODEL_PTR(pTarget->edict());
if(pmodel)
{
// Look through the event list for stuff to precache
SequencePrecache(pmodel, STRING(m_iszIdle));
SequencePrecache(pmodel, STRING(m_iszPlay));
}
}
}
void CTankBSP :: TouchPlayer ( CBaseEntity *pOther )
{
if ( !pOther->IsPlayer() )
return;
// le joueur n active le tank que s il le touche et qu il est a peu pres au meme niveau que le tank pour eviter que le joueur sortant sur le toit du tank ne l active a nouveau
if ( pOther->pev->origin.z > pev->origin.z + 48 )
return;
// m_pTankModel->UseTank( pOther, pOther, USE_TOGGLE, 0 );
edict_t *pent = FIND_ENTITY_BY_CLASSNAME ( NULL, "info_tank_model" );
if ( pent == NULL )
return;
CTank *pTank = (CTank*) CBaseEntity::Instance(pent);
pTank->UseTank( pOther, pOther, USE_TOGGLE, 0 );
}
int GetTeam (edict_t *ent)
{
// SyPB Pro P.1
// new get team off set, return player true team
int client = ENTINDEX (ent) - 1, player_team;
// SyPB Pro P.5
if (!IsValidPlayer (ent))
{
player_team = 0;
edict_t *entity = null;
ITERATE_ARRAY (g_entityName, j)
{
while (!FNullEnt (entity = FIND_ENTITY_BY_CLASSNAME (entity, g_entityName[j])))
{
if (ent == entity)
{
player_team = g_entityTeam[j];
break;
}
}
}
// SyPB Pro P.40 - AMXX API
ITERATE_ARRAY(g_entityIdAPI, j)
{
if (ent == INDEXENT(g_entityIdAPI[j]))
{
player_team = g_entityTeamAPI[j];
break;
}
}
player_team--;
return player_team;
}
// SyPB Pro P.29 - new Look UP Enemy
bool Bot::LookupEnemy(void)
{
m_visibility = 0;
m_enemyOrigin = nullvec;
if (m_blindTime > engine->GetTime() || sypb_noshots.GetBool())
return false;
if (!FNullEnt(m_lastEnemy))
{
if (IsNotAttackLab(m_lastEnemy) || !IsAlive(m_lastEnemy) || (GetTeam(m_lastEnemy) == GetTeam(GetEntity())))
{
m_lastEnemy = null;
m_lastEnemyOrigin = nullvec;
}
}
if (!FNullEnt(m_lastVictim))
{
if (!IsAlive(m_lastVictim) || (GetTeam(m_lastVictim) == GetTeam(GetEntity())))
m_lastVictim = null;
}
m_states &= ~STATE_SUSPECTENEMY;
int team = GetTeam(GetEntity()), i;
edict_t *entity = null, *targetEntity = null;
float enemy_distance = 9999.0f;
// SyPB Pro P.30 - AMXX API
if (m_blockCheckEnemyTime > engine->GetTime())
{
if (!FNullEnt(m_moveTargetEntityAPI))
{
if (GetTeam(GetEntity()) != GetTeam(m_moveTargetEntityAPI) && IsAlive(m_moveTargetEntityAPI))
SetMoveTarget(m_moveTargetEntityAPI);
else
{
// SyPB Pro P.32 - API Fixed
SetMoveTarget(null);
m_moveTargetEntityAPI = null;
}
}
else if (!FNullEnt(m_enemyAPI))
{
if (GetTeam(GetEntity()) != GetTeam(m_enemyAPI) && IsAlive(m_enemyAPI))
{
m_targetEntity = null;
m_enemy = m_enemyAPI;
m_lastEnemy = m_enemy;
m_lastEnemyOrigin = GetEntityOrigin(m_enemy);
m_enemyReachableTimer = 0.0f;
m_seeEnemyTime = engine->GetTime();
if (!IsEnemyViewable(m_enemy, 1))
m_enemyOrigin = GetEntityOrigin(m_enemy);
return true;
}
else
m_enemyAPI = null;
}
return false;
}
m_enemyAPI = null;
m_moveTargetEntityAPI = null;
if (!FNullEnt(m_enemy))
{
if (GetTeam(GetEntity()) == GetTeam(m_enemy) || IsNotAttackLab(m_enemy) || !IsAlive(m_enemy))
return false;
if (m_enemyUpdateTime > engine->GetTime() && !(m_states & STATE_SUSPECTENEMY))
{
m_aimFlags |= AIM_ENEMY;
return true;
}
if (IsEnemyViewable(m_enemy, 1))
{
targetEntity = m_enemy;
enemy_distance = GetEntityDistance(m_enemy);
}
}
else if (!FNullEnt(m_moveTargetEntity))
{
if (GetTeam(GetEntity()) == GetTeam(m_moveTargetEntity) || !IsAlive(m_moveTargetEntity))
{
SetMoveTarget(null);
return false;
}
targetEntity = m_moveTargetEntity;
m_moveTargetOrigin = GetEntityOrigin(m_moveTargetEntity);
enemy_distance = GetEntityDistance(m_moveTargetEntity);
}
// SyPB Pro P.34 - Zombie mode
if (IsZombieBot(GetEntity()))
{
if (!FNullEnt(m_moveTargetEntity))
{
if (m_enemyUpdateTime > engine->GetTime())
return false;
}
if (FNullEnt (m_enemy))
m_enemyUpdateTime = engine->GetTime() + 0.15f;
}
for (i = 1; i <= engine->GetMaxClients(); i++)
{
entity = INDEXENT(i);
if (FNullEnt(entity) || !IsAlive(entity) || GetTeam(entity) == team || entity == GetEntity())
continue;
if (IsBehindSmokeClouds(entity) && m_blindRecognizeTime < engine->GetTime())
m_blindRecognizeTime = engine->GetTime() + engine->RandomFloat(2.0, 3.0f);
if (m_blindRecognizeTime >= engine->GetTime())
continue;
float distance = GetEntityDistance(entity);
if (distance >= enemy_distance)
continue;
if (IsEnemyProtectedByShield(entity))
continue;
if (IsEnemyViewable(entity))
{
enemy_distance = distance;
targetEntity = entity;
if ((g_mapType & MAP_AS) && *(INFOKEY_VALUE(GET_INFOKEYBUFFER(entity), "model")) == 'v')
break;
}
}
ITERATE_ARRAY(g_entityName, j)
{
if (g_entityAction[j] != 1 || (GetTeam(GetEntity()) == (g_entityTeam[j] - 1) && g_entityTeam[j] != 0))
continue;
while (!FNullEnt(entity = FIND_ENTITY_BY_CLASSNAME(entity, g_entityName[j])))
{
if (FNullEnt(entity) || entity == m_enemy)
continue;
float distance = GetEntityDistance(entity);
if (distance >= enemy_distance)
continue;
if (IsBehindSmokeClouds(entity) && m_blindRecognizeTime < engine->GetTime())
m_blindRecognizeTime = engine->GetTime() + engine->RandomFloat(2.0, 3.0f);
// SyPB Pro P.30 - NPC Fixed
if (IsEnemyViewable(entity))
{
enemy_distance = distance;
targetEntity = entity;
}
}
}
if (!FNullEnt(targetEntity)) // Last Checking
{
enemy_distance = GetEntityDistance(targetEntity);
if (GetTeam(targetEntity) == team || !IsEnemyViewable(targetEntity, 1))
targetEntity = null;
}
if (!FNullEnt(m_enemy) && IsZombieBot(GetEntity()))
{
if (FNullEnt(targetEntity)) // Has not new enemy, and cannot see old enemy
{
g_botsCanPause = false;
// SyPB Pro P.32 - Zombie Ai
int botSrcIndex = g_waypoint->FindNearest(pev->origin);
int targetSrcIndex = g_waypoint->FindNearest(GetEntityOrigin (m_enemy));
int botStartIndex = *(g_waypoint->m_pathMatrix + (botSrcIndex * g_numWaypoints) + targetSrcIndex);
if (!(botStartIndex < 0))
ChangeWptIndex(botStartIndex);
RemoveCertainTask(TASK_MOVETOTARGET);
SetMoveTarget(m_enemy);
return false;
}
// SyPB Pro P.30 - Zombie Ai
else if (targetEntity != m_enemy)
{
float distance = GetEntityDistance(m_enemy);
if (enemy_distance + 50.0f >= distance)
{
targetEntity = m_enemy;
enemy_distance = distance;
}
}
}
if (!FNullEnt(targetEntity))
{
// SyPB Pro P.34 - Zombie Ai
if (IsZombieBot(GetEntity()))
{
// SyPB Pro P.36 - Zombie Ai
float distance = GetEntityDistance(targetEntity);
enemy_distance = (GetEntityOrigin (targetEntity) - pev->origin).GetLength();
bool moveTotarget = false;
if (enemy_distance >= 150.0f)
{
moveTotarget = true;
if (targetEntity == m_moveTargetEntity)
{
if (m_navNode == null || (m_navNode != null && m_navNode->next == null))
{
moveTotarget = false;
// SyPB Pro P.37 - Zombie Ai
m_enemyUpdateTime = engine->GetTime() + 4.0f;
}
}
}
else if (enemy_distance >= 80.0f && distance >= (enemy_distance * 2))
moveTotarget = true;
//else if (m_navNode != null && enemy_distance > 20.0f && distance >= 30.0f)//&& enemy_distance > 40.0f)
else if (m_navNode != null && enemy_distance >= 20.0f)// && distance >= 30.0f)
{
PathNode *navid = &m_navNode[0];
Path *path;
while (navid != null)
{
path = g_waypoint->GetPath(navid->index);
navid = navid->next;
if (navid != null)
{
if (path->connectionFlags[navid->index] & PATHFLAG_JUMP)
{
moveTotarget = true;
navid = null;
}
}
}
}
if (moveTotarget)
{
// SyPB Pro P.35 - Fixed
if (enemy_distance <= 80.0f)
//if (moveTotarget <= 80.0f)
pev->button |= IN_ATTACK;
if (targetEntity != m_moveTargetEntity)
{
g_botsCanPause = false;
// SyPB Pro P.32 - Zombie Ai
int botSrcIndex = g_waypoint->FindNearest(pev->origin);
int targetSrcIndex = g_waypoint->FindNearest(GetEntityOrigin (targetEntity));
int botStartIndex = *(g_waypoint->m_pathMatrix + (botSrcIndex * g_numWaypoints) + targetSrcIndex);
if (!(botStartIndex < 0))
ChangeWptIndex(botStartIndex);
SetMoveTarget(targetEntity);
}
return false;
}
// SyPB Pro P.37 - Zombie Ai
if (m_enemyUpdateTime < engine->GetTime() + 3.0f)
m_enemyUpdateTime = engine->GetTime() + 2.5f;
}
g_botsCanPause = true;
m_aimFlags |= AIM_ENEMY;
if (targetEntity == m_enemy)
{
m_seeEnemyTime = engine->GetTime();
m_actualReactionTime = 0.0f;
m_lastEnemy = targetEntity;
m_lastEnemyOrigin = GetEntityOrigin(targetEntity);
return true;
}
if (m_seeEnemyTime + 3.0f < engine->GetTime() && (pev->weapons & (1 << WEAPON_C4) || HasHostage() || !FNullEnt(m_targetEntity)))
RadioMessage(Radio_EnemySpotted);
m_targetEntity = null;
if (engine->RandomInt(0, 100) < m_skill)
m_enemySurpriseTime = engine->GetTime() + (m_actualReactionTime / 3);
else
m_enemySurpriseTime = engine->GetTime() + m_actualReactionTime;
m_actualReactionTime = 0.0f;
m_enemy = targetEntity;
m_lastEnemy = m_enemy;
m_lastEnemyOrigin = GetEntityOrigin(m_enemy);
m_enemyReachableTimer = 0.0f;
m_seeEnemyTime = engine->GetTime();
if (!IsZombieBot(GetEntity()))
m_enemyUpdateTime = engine->GetTime() + 0.6f;
//m_enemyUpdateTime = (IsZombieBot(GetEntity()) ? engine->GetTime() + 2.5f : engine->GetTime() + 0.6f);
return true;
}
if ((m_aimFlags <= AIM_PREDICTENEMY && m_seeEnemyTime + 4.0f < engine->GetTime() && !(m_states & (STATE_SEEINGENEMY | STATE_HEARENEMY)) && FNullEnt(m_lastEnemy) && FNullEnt(m_enemy) && GetCurrentTask()->taskID != TASK_DESTROYBREAKABLE && GetCurrentTask()->taskID != TASK_PLANTBOMB && GetCurrentTask()->taskID != TASK_DEFUSEBOMB) || g_roundEnded)
{
if (!m_reloadState)
m_reloadState = RSTATE_PRIMARY;
}
if ((UsesSniper() || UsesZoomableRifle()) && m_zoomCheckTime + 1.0f < engine->GetTime())
{
if (pev->fov < 90)
pev->button |= IN_ATTACK2;
else
m_zoomCheckTime = 0.0f;
}
return false;
}
int CTank::Restore( CRestore &restore ) // s execute lors du chargement rapide
{
if ( !CBaseMonster::Restore(restore) )
return 0;
int status = restore.ReadFields( "CTank", this, m_SaveData, ARRAYSIZE(m_SaveData) );
//-----------------------
ALERT ( at_console,"TANK RESTORE -----------------\n" );
// restoration de la camera
bSetView = 1;
// restoration du tank
CBaseEntity *pFind = UTIL_FindEntityByClassname( NULL, "info_tank_model" );
while ( pFind != NULL && pFind == this )
pFind = UTIL_FindEntityByClassname( pFind, "info_tank_model" );
// chargement
if ( pFind == NULL )
{
ALERT ( at_console, "TANK RESTORE : il n'y a qu'un tankmodel : simple chargement\n" );
return status;
}
// changement de niveau
ALERT ( at_console, "TANK RESTORE : autre tankmodel : changement de niveau\n" );
CTank *pModelFound = (CTank*)pFind;
m_pTankBSP = pModelFound->m_pTankBSP; // changement de tankbsp
m_pTankBSP->m_pTankModel = this;
pModelFound->SetThink ( SUB_Remove ); // destruction du tankmodel inutile
pModelFound->pev->nextthink = gpGlobals->time + 0.1;
pModelFound->pev->rendermode = kRenderTransTexture;
pModelFound->pev->renderamt = 0;
m_pTankBSP->pev->angles = pev->angles;
m_pTankBSP->pev->origin = pev->origin;
// tite boite
edict_t *pentTrouve;
CBaseEntity *pTrouve;
CBasePlayer *pPlayer = (CBasePlayer*) UTIL_FindEntityByClassname ( NULL, "player" );
pentTrouve = FIND_ENTITY_BY_CLASSNAME( NULL, "info_teleport_destination" );
if ( pentTrouve == NULL )
{
ALERT ( at_console , "info_tank_model : pas de teleport destination !!!\n" );
return status;
}
else
{
pTrouve = CBaseEntity :: Instance ( pentTrouve );
Vector vecTeleport = pTrouve->pev->origin;
UTIL_SetOrigin( pPlayer->pev, vecTeleport );
}
return status;
}
/* <18b0fb> ../cstrike/dlls/training_gamerules.cpp:202 */
void CHalfLifeTraining::__MAKE_VHOOK(CheckWinConditions)()
{
CBaseEntity *pHostage = NULL;
if (m_bBombDefused)
{
CGrenade *pBomb = NULL;
while ((pBomb = (CGrenade *)UTIL_FindEntityByClassname(pBomb, "grenade")) != NULL)
{
if (!pBomb->m_bIsC4 || !pBomb->m_bJustBlew)
continue;
pBomb->m_bJustBlew = false;
m_bBombDefused = false;
FireTargets(STRING(pBomb->pev->target), CBaseEntity::Instance(pBomb->pev->owner), CBaseEntity::Instance(pBomb->pev->owner), USE_TOGGLE, 0);
break;
}
}
else if (m_bTargetBombed)
{
CGrenade *pBomb = NULL;
while ((pBomb = (CGrenade *)UTIL_FindEntityByClassname(pBomb, "grenade")) != NULL)
{
if (!pBomb->m_bIsC4 || !pBomb->m_bJustBlew)
continue;
if (FStringNull(pBomb->pev->noise1))
continue;
pBomb->m_bJustBlew = false;
m_bTargetBombed = false;
FireTargets(STRING(pBomb->pev->noise1), CBaseEntity::Instance(pBomb->pev->owner), CBaseEntity::Instance(pBomb->pev->owner), USE_TOGGLE, 0);
break;
}
}
pHostage = CBaseEntity::Instance(FIND_ENTITY_BY_CLASSNAME(NULL, "hostage_entity"));
while (pHostage != NULL)
{
if (pHostage->pev->deadflag != DEAD_RESPAWNABLE || !FStringNull(pHostage->pev->noise1))
continue;
UTIL_SetSize(pHostage->pev, Vector(-16, -16, 0), Vector(16, 16, 72));
CBaseEntity *pRescueArea;
CBaseEntity *pFirstRescueArea;
pFirstRescueArea = CBaseEntity::Instance(FIND_ENTITY_BY_CLASSNAME(NULL, "func_hostage_rescue"));
pRescueArea = pFirstRescueArea;
if (pFirstRescueArea != NULL)
{
while (pRescueArea != pFirstRescueArea)
{
if (!pRescueArea->Intersects(pHostage))
break;
pRescueArea = UTIL_FindEntityByClassname(pRescueArea, "func_hostage_rescue");
if (!pRescueArea)
break;
}
if (pRescueArea != NULL)
{
pHostage->pev->noise1 = 1;
FireTargets(STRING(pRescueArea->pev->target), NULL, NULL, USE_TOGGLE, 0);
}
}
pHostage = UTIL_FindEntityByClassname(pHostage, "hostage_entity");
}
}
// Use CMD_ARGV, CMD_ARGV, and CMD_ARGC to get pointers the character string command.
void ClientCommand( edict_t *pEntity )
{
const char *pcmd = CMD_ARGV(0);
const char *pstr;
// Is the client spawned yet?
if ( !pEntity->pvPrivateData )
return;
entvars_t *pev = &pEntity->v;
if ( FStrEq(pcmd, "say" ) )
{
Host_Say( pEntity, 0 );
}
else if ( FStrEq(pcmd, "say_team" ) )
{
Host_Say( pEntity, 1 );
}
else if ( FStrEq(pcmd, "give" ) )
{
if ( g_flWeaponCheat != 0.0)
{
int iszItem = ALLOC_STRING( CMD_ARGV(1) ); // Make a copy of the classname
GetClassPtr((CBasePlayer *)pev)->GiveNamedItem( STRING(iszItem) );
}
}
else if ( FStrEq(pcmd, "drop" ) )
{
// player is dropping an item.
GetClassPtr((CBasePlayer *)pev)->DropPlayerItem((char *)CMD_ARGV(1));
}
else if ( FStrEq(pcmd, "fov" ) )
{
if ( g_flWeaponCheat && CMD_ARGC() > 1)
{
GetClassPtr((CBasePlayer *)pev)->m_iFOV = atoi( CMD_ARGV(1) );
}
else
{
CLIENT_PRINTF( pEntity, print_console, UTIL_VarArgs( "\"fov\" is \"%d\"\n", (int)GetClassPtr((CBasePlayer *)pev)->m_iFOV ) );
}
}
else if ( FStrEq(pcmd, "use" ) )
{
GetClassPtr((CBasePlayer *)pev)->SelectItem((char *)CMD_ARGV(1));
}
else if (((pstr = strstr(pcmd, "weapon_")) != NULL) && (pstr == pcmd))
{
GetClassPtr((CBasePlayer *)pev)->SelectItem(pcmd);
}
else if (FStrEq(pcmd, "lastinv" ))
{
GetClassPtr((CBasePlayer *)pev)->SelectLastItem();
}
//modif de Julien
else if (FStrEq(pcmd, "test" ))
{
ALERT ( at_console , "testmode ON\n" );
g_testmode = 1;
int i = 0;
while ( i < 5 )
{
GetClassPtr((CBasePlayer *)pev)->CheatImpulseCommands( 101 );
i++;
}
}
//modif de Julien
else if (FStrEq(pcmd, "testmode" ))
{
ALERT ( at_console , "testmode ON\n" );
g_testmode = 1;
}
// SCHED_DIE
//modif de Julien
else if (FStrEq(pcmd, "flybee" ))
{
/* CBaseMonster *pFlybee = ( CBaseMonster *) UTIL_FindEntityByClassname ( NULL, "monster_flybee" );
if ( pFlybee != NULL )
{
pFlybee->GetScheduleOfType ( SCHED_DIE );
}*/
CBaseEntity *pMe = CBaseEntity::Instance ( pEntity );
CBaseEntity *pE = FindEntityForward( pMe );
if ( pE )
{
if ( pE->pev->takedamage )
pE->TakeDamage ( pev, pev, pE->pev->health, DMG_GENERIC );
}
}
//modif de Julien
else if (FStrEq(pcmd, "ordimenu" ))
{
if ( atoi(CMD_ARGV(1)) == 2 )
{
EMIT_SOUND( ENT(pev), CHAN_ITEM, "buttons/blip2.wav", 1, ATTN_NORM );
//désactive les caméras
edict_t* pentCherche = NULL;
for ( int i = 0 ; i<15 ; i++ )
{
pentCherche = FIND_ENTITY_BY_CLASSNAME ( pentCherche, "monster_camera" );
if (!FNullEnt(pentCherche))
{
CBaseEntity *pTarget = CBaseEntity::Instance(pentCherche);
pTarget->Use( CBaseEntity::Instance(pEntity), CBaseEntity::Instance(pEntity), USE_ON, 1 );
//la valeur 1 désactive la camera, 0 la déclenche
}
}
// détruit certains triggers
pentCherche = NULL;
for ( int j = 0 ; j<5 ; j++ )
{
pentCherche = FIND_ENTITY_BY_TARGETNAME ( pentCherche, "security" );
if (!FNullEnt(pentCherche))
UTIL_Remove( CBaseEntity::Instance(pentCherche) );
}
for ( int k = 0 ; k<5 ; k++ )
{
pentCherche = FIND_ENTITY_BY_TARGETNAME ( pentCherche, "security_2" );
if (!FNullEnt(pentCherche))
UTIL_Remove( CBaseEntity::Instance(pentCherche) );
}
for ( int l = 0 ; l<5 ; l++ )
{
pentCherche = FIND_ENTITY_BY_TARGETNAME ( pentCherche, "security_3" );
if (!FNullEnt(pentCherche))
UTIL_Remove( CBaseEntity::Instance(pentCherche) );
}
}
else if ( atoi(CMD_ARGV(1)) == 1 )
EMIT_SOUND( ENT(pev), CHAN_ITEM, "sentences/blip.wav", 1, ATTN_NORM );
}
//modif de Julien
else if (FStrEq(pcmd, "ordicontrol" ))
{
CBaseEntity *pEnt = UTIL_FindEntityByClassname ( NULL, "func_conveyorcontrol" );
if ( pEnt != NULL )
{
pEnt->Use ( GetClassPtr((CBasePlayer *)pev), GetClassPtr((CBasePlayer *)pev), USE_OFF, atoi(CMD_ARGV(1)) );
}
}
else if (FStrEq(pcmd, "keypad" ))
{
if ( atoi(CMD_ARGV(1)) == 0 )
{
EMIT_SOUND( ENT(pev), CHAN_ITEM, "buttons/button10.wav", 1, ATTN_NORM );
return;
}
CBaseEntity *pEntity = UTIL_FindEntityByClassname ( NULL, "func_keypad" );
while ( pEntity != NULL )
{
if ( ENTINDEX(pEntity->edict()) == atoi(CMD_ARGV(1)) )
{
FireTargets ( STRING(pEntity->pev->target), pEntity, GetClassPtr((CBasePlayer *)pev), USE_ON, 0 );
break;
}
pEntity = UTIL_FindEntityByClassname ( pEntity, "func_keypad" );
}
EMIT_SOUND( ENT(pev), CHAN_ITEM, "buttons/blip2.wav", 1, ATTN_NORM );
}
else if (FStrEq(pcmd, "medkit" ))
{
GetClassPtr((CBasePlayer *)pev)->UseMedkit();
}
else if (FStrEq(pcmd, "battery" ))
{
GetClassPtr((CBasePlayer *)pev)->UseBattery(0);
}
else if (FStrEq(pcmd, "soin" ))
{
int commande = atoi(CMD_ARGV(1));
GetClassPtr((CBasePlayer *)pev)->UseBattery(commande);
}
else if ( g_pGameRules->ClientCommand( GetClassPtr((CBasePlayer *)pev), pcmd ) )
{
// MenuSelect returns true only if the command is properly handled, so don't print a warning
}
else
{
// tell the user they entered an unknown command
ClientPrint( &pEntity->v, HUD_PRINTCONSOLE, UTIL_VarArgs( "Unknown command: %s\n", pcmd ) );
}
}
// UNDONE: temporary scorching for PreAlpha - find a less sleazy permenant solution.
void CGrenade::Explode( TraceResult *pTrace, int bitsDamageType )
{
float flRndSound;// sound randomizer
pev->model = iStringNull;//invisible
pev->solid = SOLID_NOT;// intangible
pev->takedamage = DAMAGE_NO;
// Pull out of the wall a bit
if ( pTrace->flFraction != 1.0 )
{
pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6);
}
int iContents = UTIL_PointContents ( pev->origin );
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_EXPLOSION ); // This makes a dynamic light and the explosion sprites/sound
WRITE_COORD( pev->origin.x ); // Send to PAS because of the sound
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z );
if (iContents != CONTENTS_WATER)
{
WRITE_SHORT( g_sModelIndexFireball );
}
else
{
WRITE_SHORT( g_sModelIndexWExplosion );
}
WRITE_BYTE( (pev->dmg - 50) * .60 ); // scale * 10
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, NORMAL_EXPLOSION_VOLUME, 3.0 );
entvars_t *pevOwner;
if ( pev->owner )
pevOwner = VARS( pev->owner );
else
pevOwner = NULL;
pev->owner = NULL; // can't traceline attack owner if this is set
RadiusDamage ( pev, pevOwner, pev->dmg, CLASS_NONE, bitsDamageType );
if ( RANDOM_FLOAT( 0 , 1 ) < 0.5 )
{
UTIL_DecalTrace( pTrace, DECAL_SCORCH1 );
}
else
{
UTIL_DecalTrace( pTrace, DECAL_SCORCH2 );
}
flRndSound = RANDOM_FLOAT( 0 , 1 );
switch ( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris1.wav", 0.55, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris2.wav", 0.55, ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris3.wav", 0.55, ATTN_NORM); break;
}
//modif de Julien
UTIL_ScreenShake( pev->origin, 100, 85, 1.0, 500 );
//====================
pev->effects |= EF_NODRAW;
SetThink( Smoke );
pev->velocity = g_vecZero;
pev->nextthink = gpGlobals->time + 0.3;
if (iContents != CONTENTS_WATER)
{
int sparkCount = RANDOM_LONG(0,3);
for ( int i = 0; i < sparkCount; i++ )
Create( "spark_shower", pev->origin, pTrace->vecPlaneNormal, NULL );
}
if ( IsInGaz () )
{
edict_t *pFind = FIND_ENTITY_BY_CLASSNAME( NULL, "player" );
CBaseEntity *pPlayer = CBaseEntity::Instance ( pFind );
pPlayer->m_bFireInGaz = TRUE;
}
}
//=========================================================
// Start task - selects the correct activity and performs
// any necessary calculations to start the next task on the
// schedule.
//=========================================================
void CBaseMonster :: StartTask ( Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_TURN_RIGHT:
{
float flCurrentYaw;
flCurrentYaw = UTIL_AngleMod( pev->angles.y );
pev->ideal_yaw = UTIL_AngleMod( flCurrentYaw - pTask->flData );
SetTurnActivity();
break;
}
case TASK_TURN_LEFT:
{
float flCurrentYaw;
flCurrentYaw = UTIL_AngleMod( pev->angles.y );
pev->ideal_yaw = UTIL_AngleMod( flCurrentYaw + pTask->flData );
SetTurnActivity();
break;
}
case TASK_REMEMBER:
{
Remember ( (int)pTask->flData );
TaskComplete();
break;
}
case TASK_FORGET:
{
Forget ( (int)pTask->flData );
TaskComplete();
break;
}
case TASK_FIND_HINTNODE:
{
m_iHintNode = FindHintNode();
if ( m_iHintNode != NO_NODE )
{
TaskComplete();
}
else
{
TaskFail();
}
break;
}
case TASK_STORE_LASTPOSITION:
{
m_vecLastPosition = pev->origin;
TaskComplete();
break;
}
case TASK_CLEAR_LASTPOSITION:
{
m_vecLastPosition = g_vecZero;
TaskComplete();
break;
}
case TASK_CLEAR_HINTNODE:
{
m_iHintNode = NO_NODE;
TaskComplete();
break;
}
case TASK_STOP_MOVING:
{
if ( m_IdealActivity == m_movementActivity )
{
m_IdealActivity = GetStoppedActivity();
}
RouteClear();
TaskComplete();
break;
}
case TASK_PLAY_SEQUENCE_FACE_ENEMY:
case TASK_PLAY_SEQUENCE_FACE_TARGET:
case TASK_PLAY_SEQUENCE:
{
m_IdealActivity = ( Activity )( int )pTask->flData;
break;
}
case TASK_PLAY_ACTIVE_IDLE:
{
// monsters verify that they have a sequence for the node's activity BEFORE
// moving towards the node, so it's ok to just set the activity without checking here.
m_IdealActivity = ( Activity )WorldGraph.m_pNodes[ m_iHintNode ].m_sHintActivity;
break;
}
case TASK_SET_SCHEDULE:
{
Schedule_t *pNewSchedule;
pNewSchedule = GetScheduleOfType( (int)pTask->flData );
if ( pNewSchedule )
{
ChangeSchedule( pNewSchedule );
}
else
{
TaskFail();
}
break;
}
case TASK_FIND_NEAR_NODE_COVER_FROM_ENEMY:
{
if ( m_hEnemy == NULL )
{
TaskFail();
return;
}
if ( FindCover( m_hEnemy->pev->origin, m_hEnemy->pev->view_ofs, 0, pTask->flData ) )
{
// try for cover farther than the FLData from the schedule.
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_FAR_NODE_COVER_FROM_ENEMY:
{
if ( m_hEnemy == NULL )
{
TaskFail();
return;
}
if ( FindCover( m_hEnemy->pev->origin, m_hEnemy->pev->view_ofs, pTask->flData, CoverRadius() ) )
{
// try for cover farther than the FLData from the schedule.
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_NODE_COVER_FROM_ENEMY:
{
if ( m_hEnemy == NULL )
{
TaskFail();
return;
}
if ( FindCover( m_hEnemy->pev->origin, m_hEnemy->pev->view_ofs, 0, CoverRadius() ) )
{
// try for cover farther than the FLData from the schedule.
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_COVER_FROM_ENEMY:
{
entvars_t *pevCover;
if ( m_hEnemy == NULL )
{
// Find cover from self if no enemy available
pevCover = pev;
// TaskFail();
// return;
}
else
pevCover = m_hEnemy->pev;
if ( FindLateralCover( pevCover->origin, pevCover->view_ofs ) )
{
// try lateral first
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else if ( FindCover( pevCover->origin, pevCover->view_ofs, 0, CoverRadius() ) )
{
// then try for plain ole cover
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_COVER_FROM_ORIGIN:
{
if ( FindCover( pev->origin, pev->view_ofs, 0, CoverRadius() ) )
{
// then try for plain ole cover
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else
{
// no cover!
TaskFail();
}
}
break;
case TASK_FIND_COVER_FROM_BEST_SOUND:
{
CSound *pBestSound;
pBestSound = PBestSound();
ASSERT( pBestSound != NULL );
/*
if ( pBestSound && FindLateralCover( pBestSound->m_vecOrigin, g_vecZero ) )
{
// try lateral first
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
*/
if ( pBestSound && FindCover( pBestSound->m_vecOrigin, g_vecZero, pBestSound->m_iVolume, CoverRadius() ) )
{
// then try for plain ole cover
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else
{
// no coverwhatsoever. or no sound in list
TaskFail();
}
break;
}
case TASK_FACE_HINTNODE:
{
pev->ideal_yaw = WorldGraph.m_pNodes[ m_iHintNode ].m_flHintYaw;
SetTurnActivity();
break;
}
case TASK_FACE_LASTPOSITION:
MakeIdealYaw ( m_vecLastPosition );
SetTurnActivity();
break;
case TASK_FACE_TARGET:
if ( m_hTargetEnt != NULL )
{
MakeIdealYaw ( m_hTargetEnt->pev->origin );
SetTurnActivity();
}
else
TaskFail();
break;
case TASK_FACE_ENEMY:
{
MakeIdealYaw ( m_vecEnemyLKP );
SetTurnActivity();
break;
}
case TASK_FACE_IDEAL:
{
SetTurnActivity();
break;
}
case TASK_FACE_ROUTE:
{
if (FRouteClear())
{
ALERT(at_aiconsole, "No route to face!\n");
TaskFail();
}
else
{
MakeIdealYaw(m_Route[m_iRouteIndex].vecLocation);
SetTurnActivity();
}
break;
}
case TASK_WAIT_PVS:
case TASK_WAIT_INDEFINITE:
{
// don't do anything.
break;
}
case TASK_WAIT:
case TASK_WAIT_FACE_ENEMY:
{// set a future time that tells us when the wait is over.
m_flWaitFinished = gpGlobals->time + pTask->flData;
break;
}
case TASK_WAIT_RANDOM:
{// set a future time that tells us when the wait is over.
m_flWaitFinished = gpGlobals->time + RANDOM_FLOAT( 0.1, pTask->flData );
break;
}
case TASK_MOVE_TO_TARGET_RANGE:
{
if ( (m_hTargetEnt->pev->origin - pev->origin).Length() < 1 )
TaskComplete();
else
{
m_vecMoveGoal = m_hTargetEnt->pev->origin;
if ( !MoveToTarget( ACT_WALK, 2 ) )
TaskFail();
}
break;
}
case TASK_RUN_TO_TARGET:
case TASK_WALK_TO_TARGET:
{
Activity newActivity;
if ( (m_hTargetEnt->pev->origin - pev->origin).Length() < 1 )
TaskComplete();
else
{
if ( pTask->iTask == TASK_WALK_TO_TARGET )
newActivity = ACT_WALK;
else
newActivity = ACT_RUN;
// This monster can't do this!
if ( LookupActivity( newActivity ) == ACTIVITY_NOT_AVAILABLE )
TaskComplete();
else
{
if ( m_hTargetEnt == NULL || !MoveToTarget( newActivity, 2 ) )
{
TaskFail();
ALERT( at_aiconsole, "%s Failed to reach target!!!\n", STRING(pev->classname) );
RouteClear();
}
}
}
TaskComplete();
break;
}
case TASK_CLEAR_MOVE_WAIT:
{
m_flMoveWaitFinished = gpGlobals->time;
TaskComplete();
break;
}
case TASK_MELEE_ATTACK1_NOTURN:
case TASK_MELEE_ATTACK1:
{
m_IdealActivity = ACT_MELEE_ATTACK1;
break;
}
case TASK_MELEE_ATTACK2_NOTURN:
case TASK_MELEE_ATTACK2:
{
m_IdealActivity = ACT_MELEE_ATTACK2;
break;
}
case TASK_RANGE_ATTACK1_NOTURN:
case TASK_RANGE_ATTACK1:
{
m_IdealActivity = ACT_RANGE_ATTACK1;
break;
}
case TASK_RANGE_ATTACK2_NOTURN:
case TASK_RANGE_ATTACK2:
{
m_IdealActivity = ACT_RANGE_ATTACK2;
break;
}
case TASK_RELOAD_NOTURN:
case TASK_RELOAD:
{
m_IdealActivity = ACT_RELOAD;
break;
}
case TASK_SPECIAL_ATTACK1:
{
m_IdealActivity = ACT_SPECIAL_ATTACK1;
break;
}
case TASK_SPECIAL_ATTACK2:
{
m_IdealActivity = ACT_SPECIAL_ATTACK2;
break;
}
case TASK_SET_ACTIVITY:
{
m_IdealActivity = (Activity)(int)pTask->flData;
TaskComplete();
break;
}
case TASK_GET_PATH_TO_ENEMY_LKP:
{
if ( BuildRoute ( m_vecEnemyLKP, bits_MF_TO_LOCATION, NULL ) )
{
TaskComplete();
}
else if (BuildNearestRoute( m_vecEnemyLKP, pev->view_ofs, 0, (m_vecEnemyLKP - pev->origin).Length() ))
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToEnemyLKP failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_ENEMY:
{
CBaseEntity *pEnemy = m_hEnemy;
if ( pEnemy == NULL )
{
TaskFail();
return;
}
if ( BuildRoute ( pEnemy->pev->origin, bits_MF_TO_ENEMY, pEnemy ) )
{
TaskComplete();
}
else if (BuildNearestRoute( pEnemy->pev->origin, pEnemy->pev->view_ofs, 0, (pEnemy->pev->origin - pev->origin).Length() ))
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToEnemy failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_ENEMY_CORPSE:
{
UTIL_MakeVectors( pev->angles );
if ( BuildRoute ( m_vecEnemyLKP - gpGlobals->v_forward * 64, bits_MF_TO_LOCATION, NULL ) )
{
TaskComplete();
}
else
{
ALERT ( at_aiconsole, "GetPathToEnemyCorpse failed!!\n" );
TaskFail();
}
}
break;
case TASK_GET_PATH_TO_SPOT:
{
CBaseEntity *pPlayer = CBaseEntity::Instance( FIND_ENTITY_BY_CLASSNAME( NULL, "player" ) );
if ( BuildRoute ( m_vecMoveGoal, bits_MF_TO_LOCATION, pPlayer ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToSpot failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_TARGET:
{
RouteClear();
if ( m_hTargetEnt != NULL && MoveToTarget( m_movementActivity, 1 ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToSpot failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_HINTNODE:// for active idles!
{
if ( MoveToLocation( m_movementActivity, 2, WorldGraph.m_pNodes[ m_iHintNode ].m_vecOrigin ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToHintNode failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_LASTPOSITION:
{
m_vecMoveGoal = m_vecLastPosition;
if ( MoveToLocation( m_movementActivity, 2, m_vecMoveGoal ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToLastPosition failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_BESTSOUND:
{
CSound *pSound;
pSound = PBestSound();
if ( pSound && MoveToLocation( m_movementActivity, 2, pSound->m_vecOrigin ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToBestSound failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_BESTSCENT:
{
CSound *pScent;
pScent = PBestScent();
if ( pScent && MoveToLocation( m_movementActivity, 2, pScent->m_vecOrigin ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToBestScent failed!!\n" );
TaskFail();
}
break;
}
case TASK_RUN_PATH:
{
// UNDONE: This is in some default AI and some monsters can't run? -- walk instead?
if ( LookupActivity( ACT_RUN ) != ACTIVITY_NOT_AVAILABLE )
{
m_movementActivity = ACT_RUN;
}
else
{
m_movementActivity = ACT_WALK;
}
TaskComplete();
break;
}
case TASK_WALK_PATH:
{
if ( pev->movetype == MOVETYPE_FLY )
{
m_movementActivity = ACT_FLY;
}
if ( LookupActivity( ACT_WALK ) != ACTIVITY_NOT_AVAILABLE )
{
m_movementActivity = ACT_WALK;
}
else
{
m_movementActivity = ACT_RUN;
}
TaskComplete();
break;
}
case TASK_STRAFE_PATH:
{
Vector2D vec2DirToPoint;
Vector2D vec2RightSide;
// to start strafing, we have to first figure out if the target is on the left side or right side
UTIL_MakeVectors ( pev->angles );
vec2DirToPoint = ( m_Route[ 0 ].vecLocation - pev->origin ).Make2D().Normalize();
vec2RightSide = gpGlobals->v_right.Make2D().Normalize();
if ( DotProduct ( vec2DirToPoint, vec2RightSide ) > 0 )
{
// strafe right
m_movementActivity = ACT_STRAFE_RIGHT;
}
else
{
// strafe left
m_movementActivity = ACT_STRAFE_LEFT;
}
TaskComplete();
break;
}
case TASK_WAIT_FOR_MOVEMENT:
{
if (FRouteClear())
{
TaskComplete();
}
break;
}
case TASK_EAT:
{
Eat( pTask->flData );
TaskComplete();
break;
}
case TASK_SMALL_FLINCH:
{
m_IdealActivity = GetSmallFlinchActivity();
break;
}
case TASK_DIE:
{
RouteClear();
m_IdealActivity = GetDeathActivity();
pev->deadflag = DEAD_DYING;
break;
}
case TASK_SOUND_WAKE:
{
AlertSound();
TaskComplete();
break;
}
case TASK_SOUND_DIE:
{
DeathSound();
TaskComplete();
break;
}
case TASK_SOUND_IDLE:
{
IdleSound();
TaskComplete();
break;
}
case TASK_SOUND_PAIN:
{
PainSound();
TaskComplete();
break;
}
case TASK_SOUND_DEATH:
{
DeathSound();
TaskComplete();
break;
}
case TASK_SOUND_ANGRY:
{
// sounds are complete as soon as we get here, cause we've already played them.
ALERT ( at_aiconsole, "SOUND\n" );
TaskComplete();
break;
}
case TASK_WAIT_FOR_SCRIPT:
{
if (m_pCine->m_iszIdle)
{
m_pCine->StartSequence( (CBaseMonster *)this, m_pCine->m_iszIdle, FALSE );
if (FStrEq( STRING(m_pCine->m_iszIdle), STRING(m_pCine->m_iszPlay)))
{
pev->framerate = 0;
}
}
else
m_IdealActivity = ACT_IDLE;
break;
}
case TASK_PLAY_SCRIPT:
{
pev->movetype = MOVETYPE_FLY;
ClearBits(pev->flags, FL_ONGROUND);
m_scriptState = SCRIPT_PLAYING;
break;
}
case TASK_ENABLE_SCRIPT:
{
m_pCine->DelayStart( 0 );
TaskComplete();
break;
}
case TASK_PLANT_ON_SCRIPT:
{
if ( m_hTargetEnt != NULL )
{
pev->origin = m_hTargetEnt->pev->origin; // Plant on target
}
TaskComplete();
break;
}
case TASK_FACE_SCRIPT:
{
if ( m_hTargetEnt != NULL )
{
pev->ideal_yaw = UTIL_AngleMod( m_hTargetEnt->pev->angles.y );
}
TaskComplete();
m_IdealActivity = ACT_IDLE;
RouteClear();
break;
}
case TASK_SUGGEST_STATE:
{
m_IdealMonsterState = (MONSTERSTATE)(int)pTask->flData;
TaskComplete();
break;
}
case TASK_SET_FAIL_SCHEDULE:
m_failSchedule = (int)pTask->flData;
TaskComplete();
break;
case TASK_CLEAR_FAIL_SCHEDULE:
m_failSchedule = SCHED_NONE;
TaskComplete();
break;
default:
{
ALERT ( at_aiconsole, "No StartTask entry for %d\n", (SHARED_TASKS)pTask->iTask );
break;
}
}
}
