//--------------------------------------------------------- //--------------------------------------------------------- void CZombie::GatherConditions( void ) { BaseClass::GatherConditions(); static int conditionsToClear[] = { COND_BLOCKED_BY_DOOR, COND_DOOR_OPENED, COND_ZOMBIE_CHARGE_TARGET_MOVED, }; ClearConditions( conditionsToClear, ARRAYSIZE( conditionsToClear ) ); if ( m_hBlockingDoor == NULL || ( m_hBlockingDoor->m_toggle_state == TS_AT_TOP || m_hBlockingDoor->m_toggle_state == TS_GOING_UP ) ) { ClearCondition( COND_BLOCKED_BY_DOOR ); if ( m_hBlockingDoor != NULL ) { SetCondition( COND_DOOR_OPENED ); m_hBlockingDoor = NULL; } } else SetCondition( COND_BLOCKED_BY_DOOR ); if ( ConditionInterruptsCurSchedule( COND_ZOMBIE_CHARGE_TARGET_MOVED ) ) { if ( GetNavigator()->IsGoalActive() ) { const float CHARGE_RESET_TOLERANCE = 60.0; if ( !GetEnemy() || ( m_vPositionCharged - GetEnemyLKP() ).Length() > CHARGE_RESET_TOLERANCE ) { SetCondition( COND_ZOMBIE_CHARGE_TARGET_MOVED ); } } } }
//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CAI_OperatorBehavior::GatherConditionsNotActive() { if( m_hPositionEnt ) { // If we're not currently the active behavior, we have a position ent, and the // NPC can see it, coax the AI out of IDLE/ALERT schedules with this condition. if( CanSeePositionEntity() ) { SetCondition( COND_IDLE_INTERRUPT ); } } }
void SpawnConditionManager::ExecEvent(SpawnEvent &event, bool send_update) { std::map<uint16, SpawnCondition>::iterator condi; condi = spawn_conditions.find(event.condition_id); if(condi == spawn_conditions.end()) { Log(Logs::Detail, Logs::Spawns, "Event %d: Unable to find condition %d to execute on.", event.id, event.condition_id); return; //unable to find the spawn condition to operate on } TimeOfDay_Struct tod; zone->zone_time.GetCurrentEQTimeOfDay(&tod); if(event.strict && (event.next.hour != tod.hour || event.next.day != tod.day || event.next.month != tod.month || event.next.year != tod.year)) { Log(Logs::Detail, Logs::Spawns, "Event %d: Unable to execute. Condition is strict, and event time has already passed.", event.id); return; } SpawnCondition &cond = condi->second; int16 new_value = cond.value; //we have our event and our condition, do our stuff. switch(event.action) { case SpawnEvent::ActionSet: new_value = event.argument; Log(Logs::Detail, Logs::Spawns, "Event %d: Executing. Setting condition %d to %d.", event.id, event.condition_id, event.argument); break; case SpawnEvent::ActionAdd: new_value += event.argument; Log(Logs::Detail, Logs::Spawns, "Event %d: Executing. Adding %d to condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value); break; case SpawnEvent::ActionSubtract: new_value -= event.argument; Log(Logs::Detail, Logs::Spawns, "Event %d: Executing. Subtracting %d from condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value); break; case SpawnEvent::ActionMultiply: new_value *= event.argument; Log(Logs::Detail, Logs::Spawns, "Event %d: Executing. Multiplying condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value); break; case SpawnEvent::ActionDivide: new_value /= event.argument; Log(Logs::Detail, Logs::Spawns, "Event %d: Executing. Dividing condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value); break; default: Log(Logs::Detail, Logs::Spawns, "Event %d: Invalid event action type %d", event.id, event.action); return; } //now set the condition to the new value if(send_update) //full blown update SetCondition(zone->GetShortName(), zone->GetInstanceID(), cond.condition_id, new_value); else //minor update done while loading cond.value = new_value; }
void CNPC_Cremator::RunTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_CREMATOR_RANGE_ATTACK1: { SetActivity( ACT_RANGE_ATTACK1 ); Vector flEnemyLKP = GetEnemyLKP(); GetMotor()->SetIdealYawToTargetAndUpdate( flEnemyLKP ); if( m_iAmmo < 1 && IsActivityFinished() ) { SetCondition( COND_CREMATOR_OUT_OF_AMMO ); DevMsg( "NO PRIMARY AMMO\n" ); StopParticleEffects(this); StopSound( "Weapon_Immolator.Single" ); EmitSound( "Weapon_Immolator.Stop" ); TaskComplete(); SetNextThink( gpGlobals->curtime + 0.1f ); } // THIS fixes the combat issue with the Cremator continuing to fire at a target that moved out of his reach if( GetEnemyLKP().DistTo( GetAbsOrigin()) > CREMATOR_MAX_RANGE ) { // Cremator stops firing and attempts to close the distance. SetActivity( ACT_CREMATOR_DISARM ); TaskComplete(); Msg( "Enemy is too far\n" ); SetNextThink( gpGlobals->curtime + 0.1f ); return; } /* // This is bugged and shouldn't be used. Necessary checks are made below, in OnChangeActivity( ). if( IsActivityMovementPhased( ACT_WALK ) || IsActivityMovementPhased( ACT_RUN ) ) { TaskFail( NULL ); SetActivity( ACT_CREMATOR_DISARM ); DevMsg( "ACT_CREMATOR_DISARM\n" ); return; } */ break; } default: BaseClass::RunTask( pTask ); break; } }
// Handle incoming data from USB void FfbOnUsbData(uint8_t* data, uint16_t len) { uint8_t effectId = data[1]; // effectBlockIndex is always the second byte. switch (data[0]) // reportID { case 1: FfbHandle_SetEffect((USB_FFBReport_SetEffect_Output_Data_t*)data); break; case 2: SetEnvelope((USB_FFBReport_SetEnvelope_Output_Data_t*)data, &gEffectStates[effectId]); break; case 3: SetCondition((USB_FFBReport_SetCondition_Output_Data_t*)data, &gEffectStates[effectId]); break; case 4: SetPeriodic((USB_FFBReport_SetPeriodic_Output_Data_t*)data, &gEffectStates[effectId]); break; case 5: SetConstantForce((USB_FFBReport_SetConstantForce_Output_Data_t*)data, &gEffectStates[effectId]); break; case 6: SetRampForce((USB_FFBReport_SetRampForce_Output_Data_t*)data, &gEffectStates[effectId]); break; case 7: FfbHandle_SetCustomForceData((USB_FFBReport_SetCustomForceData_Output_Data_t*)data); break; case 8: FfbHandle_SetDownloadForceSample((USB_FFBReport_SetDownloadForceSample_Output_Data_t*)data); break; case 9: break; case 10: FfbHandle_EffectOperation((USB_FFBReport_EffectOperation_Output_Data_t*)data); break; case 11: FfbHandle_BlockFree((USB_FFBReport_BlockFree_Output_Data_t*)data); break; case 12: FfbHandle_DeviceControl((USB_FFBReport_DeviceControl_Output_Data_t*)data); break; case 13: FfbHandle_DeviceGain((USB_FFBReport_DeviceGain_Output_Data_t*)data); break; case 14: FfbHandle_SetCustomForce((USB_FFBReport_SetCustomForce_Output_Data_t*)data); break; default: break; }; }
//----------------------------------------------------------------------------- // Purpose: Move the zombie to the vehicle //----------------------------------------------------------------------------- int CAI_PassengerBehaviorZombie::SelectSchedule( void ) { // See if our enemy got out if ( GetOuter()->GetEnemy() != NULL && EnemyInVehicle() == false ) { if ( GetPassengerState() == PASSENGER_STATE_INSIDE ) { // Exit the vehicle SetCondition( COND_PASSENGER_EXITING ); } else if ( GetPassengerState() == PASSENGER_STATE_OUTSIDE ) { // Our target has left the vehicle and we're outside as well, so give up Disable(); return BaseClass::SelectSchedule(); } } // Entering schedule if ( HasCondition( COND_PASSENGER_ENTERING ) ) { ClearCondition( COND_PASSENGER_ENTERING ); return SCHED_PASSENGER_ZOMBIE_ENTER_VEHICLE; } // Exiting schedule if ( HasCondition( COND_PASSENGER_EXITING ) ) { ClearCondition( COND_PASSENGER_EXITING ); return SCHED_PASSENGER_ZOMBIE_EXIT_VEHICLE; } // Select different schedules based on our state PassengerState_e nState = GetPassengerState(); int nNewSchedule = SCHED_NONE; if ( nState == PASSENGER_STATE_INSIDE ) { nNewSchedule = SelectInsideSchedule(); if ( nNewSchedule != SCHED_NONE ) return nNewSchedule; } else if ( nState == PASSENGER_STATE_OUTSIDE ) { nNewSchedule = SelectOutsideSchedule(); if ( nNewSchedule != SCHED_NONE ) return nNewSchedule; } // Worst case he just stands here Assert(0); return SCHED_IDLE_STAND; }
//----------------------------------------------------------------------------- // Purpose: Override so can handle LOS to m_pScriptedTarget // Input : // Output : //----------------------------------------------------------------------------- bool CNPC_Stalker::InnateWeaponLOSCondition( const Vector &ownerPos, const Vector &targetPos, bool bSetConditions ) { // -------------------- // Check for occlusion // -------------------- // Base class version assumes innate weapon position is at eye level Vector barrelPos = LaserStartPosition(ownerPos); trace_t tr; AI_TraceLine( barrelPos, targetPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr); if ( tr.fraction == 1.0 ) { return true; } CBaseEntity *pBE = tr.m_pEnt; CBaseCombatCharacter *pBCC = ToBaseCombatCharacter( pBE ); if ( pBE == GetEnemy() ) { return true; } else if (pBCC) { if (IRelationType( pBCC ) == D_HT) { return true; } else if (bSetConditions) { SetCondition(COND_WEAPON_BLOCKED_BY_FRIEND); } } else if (bSetConditions) { SetCondition(COND_WEAPON_SIGHT_OCCLUDED); SetEnemyOccluder(pBE); } return false; }
//----------------------------------------------------------------------------- // Purpose: // Input : // Output : //----------------------------------------------------------------------------- void CBaseHelicopter::GatherEnemyConditions( CBaseEntity *pEnemy ) { // ------------------- // If enemy is dead // ------------------- if ( !pEnemy->IsAlive() ) { SetCondition( COND_ENEMY_DEAD ); ClearCondition( COND_SEE_ENEMY ); ClearCondition( COND_ENEMY_OCCLUDED ); return; } }
//----------------------------------------------------------------------------- // Purpose: This is a generic function (to be implemented by sub-classes) to // handle specific interactions between different types of characters // (For example the barnacle grabbing an NPC) // Input : Constant for the type of interaction // Output : true - if sub-class has a response for the interaction // false - if sub-class has no response //----------------------------------------------------------------------------- bool CNPC_Houndeye::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter* sourceEnt) { if (interactionType == g_interactionHoundeyeGroupAttack) { SetCondition(COND_HOUND_GROUP_ATTACK); return true; } else if (interactionType == g_interactionHoundeyeGroupRetreat) { SetCondition(COND_HOUND_GROUP_RETREAT); return true; } else if (interactionType == g_interactionHoundeyeGroupRalley) { SetCondition(COND_HOUND_GROUP_RALLEY); SetTarget(sourceEnt); m_bLoopClockwise = false; return true; } return false; }
//------------------------------------------------------------------------------ // Purpose: sets / clears conditions for when the behavior is not active. this is // mainly to have a smaller set of conditions to wake up the behavior. //------------------------------------------------------------------------------ void CAI_ASW_FlickBehavior::GatherConditionsNotActive( ) { BaseClass::GatherConditionsNotActive(); if ( m_flNextFlickCheck < gpGlobals->curtime ) { if ( GetFlickActivity() != NULL ) { SetCondition( COND_SHIELD_CAN_FLICK ); } m_flNextFlickCheck = gpGlobals->curtime + 1.0f; } }
//------------------------------------------------------------------------------ // Purpose: sets / clears conditions for when the behavior is active. this is // generally a larger set of conditions to interrupt any tasks. //------------------------------------------------------------------------------ void CAI_ASW_HealOtherBehavior::GatherConditions( ) { BaseClass::GatherConditions(); ClearCondition( COND_HEAL_OTHER_HAS_FULL_HEALTH ); // needed? if ( GetTarget() != NULL ) { if ( GetTarget()->m_iHealth == GetTarget()->m_iMaxHealth ) { SetCondition( COND_HEAL_OTHER_HAS_FULL_HEALTH ); } } }
//----------------------------------------------------------------------------- // Purpose: Force the driver to pickup a specific entity // Input : &inputdata - //----------------------------------------------------------------------------- void CNPC_CraneDriver::InputForcePickup( inputdata_t &inputdata ) { string_t iszPickupName = inputdata.value.StringID(); if ( iszPickupName != NULL_STRING ) { // Turn the magnet off now to drop anything we might have already on the magnet m_hCrane->TurnMagnetOff(); m_hPickupTarget = gEntList.FindEntityByName( NULL, iszPickupName, NULL ); m_bForcedPickup = true; m_bForcedDropoff = false; SetCondition( COND_PROVOKED ); CLEARBITS( m_spawnflags, SF_VEHICLEDRIVER_INACTIVE ); } }
//----------------------------------------------------------------------------- // Purpose: Soldiers use CAN_RANGE_ATTACK2 to indicate whether they can throw // a grenade. Because they check only every half-second or so, this // condition must persist until it is updated again by the code // that determines whether a grenade can be thrown, so prevent the // base class from clearing it out. (sjb) //----------------------------------------------------------------------------- void CNPC_CombineShot::ClearAttackConditions() { bool fCanRangeAttack2 = HasCondition( COND_CAN_RANGE_ATTACK2 ); // Call the base class. BaseClass::ClearAttackConditions(); if( fCanRangeAttack2 ) { // We don't allow the base class to clear this condition because we // don't sense for it every frame. SetCondition( COND_CAN_RANGE_ATTACK2 ); } }
//----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CAI_AssaultBehavior::CanSelectSchedule() { if ( !GetOuter()->IsInterruptable() ) return false; if ( GetOuter()->HasCondition( COND_RECEIVED_ORDERS ) ) return false; // We're letting other AI run for a little while because the assault AI failed recently. if ( m_flTimeDeferScheduleSelection > gpGlobals->curtime ) return false; // No schedule selection if no assault is being conducted. if( m_AssaultCue == CUE_NO_ASSAULT ) return false; if ( !m_hAssaultPoint || !m_hRallyPoint ) { Disable(); return false; } // Remember when we last saw an enemy if ( GetEnemy() ) { m_flLastSawAnEnemyAt = gpGlobals->curtime; } // If we've seen an enemy in the last few seconds, and we're allowed to divert, // let the base AI decide what I should do. if ( IsAllowedToDivert() ) { // Return true, but remember that we're actually allowing them to divert // This is done because we don't want the assault behaviour to think it's finished with the assault. m_bDiverting = true; } else if ( m_bDiverting ) { // If we were diverting, provoke us to make a new schedule selection SetCondition( COND_PROVOKED ); m_bDiverting = false; } // If we're diverting, let the base AI decide everything if ( m_bDiverting ) return false; return true; }
void CNPC_Dog::CleanCatchAndThrow( bool bClearTimers ) { if ( m_hPhysicsEnt ) { if ( m_bHasObject == true ) { IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject(); m_hPhysicsEnt->SetParent( NULL ); m_hPhysicsEnt->SetOwnerEntity( NULL ); Vector vGunPos; QAngle angGunAngles; GetAttachment( m_iPhysGunAttachment, vGunPos, angGunAngles ); if ( pPhysObj ) { pPhysObj->Wake(); pPhysObj->RemoveShadowController(); pPhysObj->SetPosition( vGunPos, angGunAngles, true ); } else { Warning( "CleanCatchAndThrow: m_hPhysicsEnt->VPhysicsGetObject == NULL!\n" ); } m_hPhysicsEnt->SetMoveType( (MoveType_t)m_iContainerMoveType ); if ( pPhysObj ) { pPhysObj->RecheckCollisionFilter(); } ClearBeams(); } m_hPhysicsEnt = NULL; } if ( bClearTimers == true ) { m_bDoCatchThrowBehavior = false; m_bDoWaitforObjectBehavior = false; m_flTimeToCatch = 0.0f; m_flNextSwat = 0.0f; SetCondition( COND_DOG_LOST_PHYSICS_ENTITY ); } }
//----------------------------------------------------------------------------- // Purpose: // Input : interactionType - // *data - // *sourceEnt - // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CNPC_AntlionGrub::HandleInteraction( int interactionType, void *data, CBaseCombatCharacter *sourceEnt ) { //Handle squeals from our peers if ( interactionType == g_interactionAntlionGrubAlert ) { SetCondition( COND_ANTLIONGRUB_HEARD_SQUEAL ); //float envDuration = PlayEnvelope( m_pVoiceSound, SOUNDCTRL_CHANGE_VOLUME, envScared, ARRAYSIZE(envScared) ); //float envDuration = CSoundEnvelopeController::GetController().SoundPlayEnvelope( m_pVoiceSound, SOUNDCTRL_CHANGE_VOLUME, envMidSustain, ARRAYSIZE(envMidSustain) ); //m_flNextVoiceChange = gpGlobals->curtime + envDuration + random->RandomFloat( 4.0f, 8.0f ); return true; } return false; }
//----------------------------------------------------------------------------- // Purpose: // Input : *pOther - //----------------------------------------------------------------------------- void CNPC_AntlionGrub::GrubTouch( CBaseEntity *pOther ) { //Don't consider the world if ( FClassnameIs( pOther, "worldspawn" ) ) return; //Allow a crusing velocity to kill them in one go (or they're already dead) if ( ( pOther->GetAbsVelocity().Length() > 200 ) || ( IsAlive() == false ) ) { //TakeDamage( CTakeDamageInfo( pOther, pOther, vec3_origin, GetAbsOrigin(), 100, DMG_CRUSH ) ); return; } //Need to know we're being squashed SetCondition( COND_ANTLIONGRUB_BEING_SQUASHED ); }
void SpawnConditionManager::ExecEvent(SpawnEvent &event, bool send_update) { map<uint16, SpawnCondition>::iterator condi; condi = spawn_conditions.find(event.condition_id); if(condi == spawn_conditions.end()) { _log(SPAWNS__CONDITIONS, "Event %d: Unable to find condition %d to execute on.", event.id, event.condition_id); return; //unable to find the spawn condition to operate on } SpawnCondition &cond = condi->second; int16 new_value = cond.value; //we have our event and our condition, do our stuff. switch(event.action) { case SpawnEvent::ActionSet: new_value = event.argument; _log(SPAWNS__CONDITIONS, "Event %d: Executing. Setting condition %d to %d.", event.id, event.condition_id, event.argument); break; case SpawnEvent::ActionAdd: new_value += event.argument; _log(SPAWNS__CONDITIONS, "Event %d: Executing. Adding %d to condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value); break; case SpawnEvent::ActionSubtract: new_value -= event.argument; _log(SPAWNS__CONDITIONS, "Event %d: Executing. Subtracting %d from condition %d, yeilding %d.", event.id, event.argument, event.condition_id, new_value); break; case SpawnEvent::ActionMultiply: new_value *= event.argument; _log(SPAWNS__CONDITIONS, "Event %d: Executing. Multiplying condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value); break; case SpawnEvent::ActionDivide: new_value /= event.argument; _log(SPAWNS__CONDITIONS, "Event %d: Executing. Dividing condition %d by %d, yeilding %d.", event.id, event.condition_id, event.argument, new_value); break; default: _log(SPAWNS__CONDITIONS, "Event %d: Invalid event action type %d", event.id, event.action); return; } //now set the condition to the new value if(send_update) //full blown update SetCondition(zone->GetShortName(), zone->GetInstanceID(), cond.condition_id, new_value); else //minor update done while loading cond.value = new_value; }
//----------------------------------------------------------------------------- // Purpose: Force the driver to drop his held entity at a specific point // Input : &inputdata - //----------------------------------------------------------------------------- void CNPC_CraneDriver::InputForceDrop( inputdata_t &inputdata ) { string_t iszDropName = inputdata.value.StringID(); if ( iszDropName != NULL_STRING ) { CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, iszDropName, NULL ); if ( !pEntity ) { Warning("Crane couldn't find entity named %s\n", STRING(iszDropName) ); return; } m_bForcedPickup = false; m_bForcedDropoff = true; SetDesiredPosition( pEntity->GetAbsOrigin() ); SetCondition( COND_PROVOKED ); CLEARBITS( m_spawnflags, SF_VEHICLEDRIVER_INACTIVE ); } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- bool CNPC_Bug_Warrior::StartPatrolling( string_t iszPatrolPathName ) { // If I'm not idle, I can't patrol if ( m_NPCState != NPC_STATE_IDLE && m_NPCState != NPC_STATE_ALERT && m_NPCState != NPC_STATE_NONE ) return false; // If I'm patrolling already, I can't patrol if ( IsPatrolling() ) return false; SetState( NPC_STATE_ALERT ); SetCondition( COND_PROVOKED ); // Store off my patrol name m_iszPatrolPathName = iszPatrolPathName; m_iPatrolPoint = 0; return true; }
//----------------------------------------------------------------------------- // Purpose: // // // Output : //----------------------------------------------------------------------------- void CNPC_RollerDozer::GatherConditions( void ) { BaseClass::GatherConditions(); if( gpGlobals->curtime > m_flTimeDebrisSearch && m_hDebris == NULL ) { m_flTimeDebrisSearch = gpGlobals->curtime + ROLLERDOZER_DEBRIS_FREQUENCY; m_hDebris = FindDebris(); if( m_hDebris == NULL) { ClearCondition( COND_ROLLERDOZER_FOUND_DEBRIS ); } else { SetCondition( COND_ROLLERDOZER_FOUND_DEBRIS ); } } }
void CASW_Alien_Jumper::PrescheduleThink( void ) { //New Enemy? Try to jump at him. if ( HasCondition( COND_NEW_ENEMY ) ) { m_flJumpTime = 0.0f; } if ( ShouldJump() ) { SetCondition( COND_ASW_ALIEN_CAN_JUMP ); } else { ClearCondition( COND_ASW_ALIEN_CAN_JUMP ); } BaseClass::PrescheduleThink(); }
void CAI_LeadBehavior::LeadPlayer( const AI_LeadArgs_t &leadArgs, CAI_LeadBehaviorHandler *pSink ) { CAI_PlayerAlly *pOuter = dynamic_cast<CAI_PlayerAlly*>(GetOuter()); if ( pOuter && AI_IsSinglePlayer() ) { pOuter->SetSpeechTarget( UTIL_GetLocalPlayer() ); } if( SetGoal( leadArgs ) ) { SetCondition( COND_PROVOKED ); Connect( pSink ); NotifyChangeBehaviorStatus(); } else { DevMsg( "*** Warning! LeadPlayer() has a NULL Goal Ent\n" ); } }
//----------------------------------------------------------------------------- //----------------------------------------------------------------------------- void CAI_RappelBehavior::BeginRappel() { // Send the message to begin rappeling! SetCondition( COND_BEGIN_RAPPEL ); m_vecRopeAnchor = GetOuter()->GetAbsOrigin(); trace_t tr; UTIL_TraceEntity( GetOuter(), GetAbsOrigin(), GetAbsOrigin()-Vector(0,0,4096), MASK_SHOT, GetOuter(), COLLISION_GROUP_NONE, &tr ); if( tr.m_pEnt != NULL && tr.m_pEnt->IsNPC() ) { Vector forward; GetOuter()->GetVectors( &forward, NULL, NULL ); CSoundEnt::InsertSound( SOUND_DANGER, tr.m_pEnt->EarPosition() - forward * 12.0f, 32, 0.2f, GetOuter() ); } }
int CNPC_Gargantua::OnTakeDamage_Alive( const CTakeDamageInfo &info ) { CTakeDamageInfo subInfo = info; float flDamage = subInfo.GetDamage(); if ( IsAlive() ) { if ( !(subInfo.GetDamageType() & GARG_DAMAGE) ) { flDamage *= 0.01; subInfo.SetDamage( flDamage ); } if ( subInfo.GetDamageType() & DMG_BLAST ) { SetCondition( COND_LIGHT_DAMAGE ); } } return BaseClass::OnTakeDamage_Alive( subInfo ); }
//----------------------------------------------------------------------------- // Purpose: Handle specific interactions with other NPCs //----------------------------------------------------------------------------- bool CNPC_Bug_Warrior::HandleInteraction( int interactionType, void *data, CBaseCombatCharacter *sender ) { // Check for a target found while burrowed if ( interactionType == g_interactionBugSquadAttacking ) { // Ignore ones sent by me if ( sender == this ) return false; // Interrupt me if I'm fleeing if ( IsCurSchedule(SCHED_WBUG_FLEE_ENEMY) || IsCurSchedule(SCHED_WBUG_CHASE_ENEMY_FAILED) ) { SetCondition( COND_WBUG_STOP_FLEEING ); } return true; } return false; }
//----------------------------------------------------------------------------- // Purpose: // Input : // Output : //----------------------------------------------------------------------------- bool CBaseHelicopter::ChooseEnemy( void ) { // See if there's a new enemy. CBaseEntity *pNewEnemy; pNewEnemy = BestEnemy(); if( ( pNewEnemy != GetEnemy() ) && pNewEnemy != NULL ) { //New enemy! Clear the timers and set conditions. SetCondition(COND_NEW_ENEMY); SetEnemy( pNewEnemy ); m_flLastSeen = m_flPrevSeen = gpGlobals->curtime; return true; } else { ClearCondition( COND_NEW_ENEMY ); return false; } }
void CASW_Parasite::Leap( const Vector &vecVel ) { SetTouch( &CASW_Parasite::LeapTouch ); SetCondition( COND_FLOATING_OFF_GROUND ); SetGroundEntity( NULL ); m_flIgnoreWorldCollisionTime = gpGlobals->curtime + PARASITE_IGNORE_WORLD_COLLISION_TIME; if( HasHeadroom() ) { // Take him off ground so engine doesn't instantly reset FL_ONGROUND. UTIL_SetOrigin( this, GetLocalOrigin() + Vector( 0, 0, 1 ) ); } SetAbsVelocity( vecVel ); // Think every frame so the player sees the headcrab where he actually is... m_bMidJump = true; SetThink( &CASW_Parasite::LeapThink ); SetNextThink( gpGlobals->curtime ); }
//----------------------------------------------------------------------------- // Purpose: // Input : flDot - // flDist - // Output : int //----------------------------------------------------------------------------- int CNPC_AntlionGrub::MeleeAttack1Conditions( float flDot, float flDist ) { ClearCondition( COND_ANTLIONGRUB_IN_HEAL_RANGE ); //If we're outside the heal range, then reset our timer if ( flDist > ANTLIONGRUB_HEAL_RANGE ) { m_flNearTime = gpGlobals->curtime + 2.0f; return COND_TOO_FAR_TO_ATTACK; } //Otherwise if we've been in range for long enough signal it if ( m_flNearTime < gpGlobals->curtime ) { if ( ( m_nHealthReserve > 0 ) && ( GetEnemy()->m_iHealth < GetEnemy()->m_iMaxHealth ) ) { SetCondition( COND_ANTLIONGRUB_IN_HEAL_RANGE ); } } return COND_CAN_MELEE_ATTACK1; }
//========================================================= // OnListened - monsters dig through the active sound list for // any sounds that may interest them. (smells, too!) //========================================================= void CNPC_Bullsquid::OnListened( void ) { AISoundIter_t iter; CSound *pCurrentSound; static int conditionsToClear[] = { COND_SQUID_SMELL_FOOD, }; ClearConditions( conditionsToClear, ARRAYSIZE( conditionsToClear ) ); pCurrentSound = GetSenses()->GetFirstHeardSound( &iter ); while ( pCurrentSound ) { // the npc cares about this sound, and it's close enough to hear. int condition = COND_NONE; if ( !pCurrentSound->FIsSound() ) { // if not a sound, must be a smell - determine if it's just a scent, or if it's a food scent if ( pCurrentSound->IsSoundType( SOUND_MEAT | SOUND_CARCASS ) ) { // the detected scent is a food item condition = COND_SQUID_SMELL_FOOD; } } if ( condition != COND_NONE ) SetCondition( condition ); pCurrentSound = GetSenses()->GetNextHeardSound( &iter ); } BaseClass::OnListened(); }