1146 lines
25 KiB
C++
1146 lines
25 KiB
C++
/***
|
|
*
|
|
* Copyright (c) 1996-2001, Valve LLC. All rights reserved.
|
|
*
|
|
* This product contains software technology licensed from Id
|
|
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* This source code contains proprietary and confidential information of
|
|
* Valve LLC and its suppliers. Access to this code is restricted to
|
|
* persons who have executed a written SDK license with Valve. Any access,
|
|
* use or distribution of this code by or to any unlicensed person is illegal.
|
|
*
|
|
****/
|
|
//=========================================================
|
|
// Default behaviors.
|
|
//=========================================================
|
|
#include "extdll.h"
|
|
#include "util.h"
|
|
#include "cbase.h"
|
|
#include "monsters.h"
|
|
#include "schedule.h"
|
|
#include "defaultai.h"
|
|
#include "soundent.h"
|
|
#include "scripted.h"
|
|
|
|
//=========================================================
|
|
// Fail
|
|
//=========================================================
|
|
Task_t tlFail[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT, (float)2},
|
|
{TASK_WAIT_PVS, (float)0},
|
|
};
|
|
|
|
Schedule_t slFail[] =
|
|
{
|
|
{tlFail,
|
|
ARRAYSIZE(tlFail),
|
|
bits_COND_CAN_ATTACK,
|
|
0,
|
|
"Fail"},
|
|
};
|
|
|
|
//=========================================================
|
|
// Idle Schedules
|
|
//=========================================================
|
|
Task_t tlIdleStand1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT, (float)5}, // repick IDLESTAND every five seconds. gives us a chance to pick an active idle, fidget, etc.
|
|
};
|
|
|
|
Schedule_t slIdleStand[] =
|
|
{
|
|
{tlIdleStand1,
|
|
ARRAYSIZE(tlIdleStand1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_SEE_FEAR |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_HEAR_SOUND |
|
|
bits_COND_SMELL_FOOD |
|
|
bits_COND_SMELL |
|
|
bits_COND_PROVOKED,
|
|
|
|
bits_SOUND_COMBAT | // sound flags
|
|
bits_SOUND_WORLD |
|
|
bits_SOUND_PLAYER |
|
|
bits_SOUND_DANGER |
|
|
|
|
bits_SOUND_MEAT | // scents
|
|
bits_SOUND_CARCASS |
|
|
bits_SOUND_GARBAGE,
|
|
"IdleStand"},
|
|
};
|
|
|
|
Schedule_t slIdleTrigger[] =
|
|
{
|
|
{tlIdleStand1,
|
|
ARRAYSIZE(tlIdleStand1),
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE,
|
|
0,
|
|
"Idle Trigger"},
|
|
};
|
|
|
|
|
|
Task_t tlIdleWalk1[] =
|
|
{
|
|
{TASK_WALK_PATH, (float)9999},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
};
|
|
|
|
Schedule_t slIdleWalk[] =
|
|
{
|
|
{tlIdleWalk1,
|
|
ARRAYSIZE(tlIdleWalk1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_HEAR_SOUND |
|
|
bits_COND_SMELL_FOOD |
|
|
bits_COND_SMELL |
|
|
bits_COND_PROVOKED,
|
|
|
|
bits_SOUND_COMBAT | // sound flags
|
|
|
|
bits_SOUND_MEAT | // scents
|
|
bits_SOUND_CARCASS |
|
|
bits_SOUND_GARBAGE,
|
|
"Idle Walk"},
|
|
};
|
|
|
|
//=========================================================
|
|
// Ambush - monster stands in place and waits for a new
|
|
// enemy, or chance to attack an existing enemy.
|
|
//=========================================================
|
|
Task_t tlAmbush[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT_INDEFINITE, (float)0},
|
|
};
|
|
|
|
Schedule_t slAmbush[] =
|
|
{
|
|
{tlAmbush,
|
|
ARRAYSIZE(tlAmbush),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_PROVOKED,
|
|
|
|
0,
|
|
"Ambush"},
|
|
};
|
|
|
|
//=========================================================
|
|
// ActiveIdle schedule - !!!BUGBUG - if this schedule doesn't
|
|
// complete on its own, the monster's HintNode will not be
|
|
// cleared, and the rest of the monster's group will avoid
|
|
// that node because they think the group member that was
|
|
// previously interrupted is still using that node to active
|
|
// idle.
|
|
///=========================================================
|
|
Task_t tlActiveIdle[] =
|
|
{
|
|
{TASK_FIND_HINTNODE, (float)0},
|
|
{TASK_GET_PATH_TO_HINTNODE, (float)0},
|
|
{TASK_STORE_LASTPOSITION, (float)0},
|
|
{TASK_WALK_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_FACE_HINTNODE, (float)0},
|
|
{TASK_PLAY_ACTIVE_IDLE, (float)0},
|
|
{TASK_GET_PATH_TO_LASTPOSITION, (float)0},
|
|
{TASK_WALK_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_CLEAR_LASTPOSITION, (float)0},
|
|
{TASK_CLEAR_HINTNODE, (float)0},
|
|
};
|
|
|
|
Schedule_t slActiveIdle[] =
|
|
{
|
|
{tlActiveIdle,
|
|
ARRAYSIZE(tlActiveIdle),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_PROVOKED |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_COMBAT |
|
|
bits_SOUND_WORLD |
|
|
bits_SOUND_PLAYER |
|
|
bits_SOUND_DANGER,
|
|
"Active Idle"}};
|
|
|
|
//=========================================================
|
|
// Wake Schedules
|
|
//=========================================================
|
|
Task_t tlWakeAngry1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_SOUND_WAKE, (float)0},
|
|
{TASK_FACE_IDEAL, (float)0},
|
|
};
|
|
|
|
Schedule_t slWakeAngry[] =
|
|
{
|
|
{tlWakeAngry1,
|
|
ARRAYSIZE(tlWakeAngry1),
|
|
0,
|
|
0,
|
|
"Wake Angry"}};
|
|
|
|
//=========================================================
|
|
// AlertFace Schedules
|
|
//=========================================================
|
|
Task_t tlAlertFace1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_FACE_IDEAL, (float)0},
|
|
};
|
|
|
|
Schedule_t slAlertFace[] =
|
|
{
|
|
{tlAlertFace1,
|
|
ARRAYSIZE(tlAlertFace1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_SEE_FEAR |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_PROVOKED,
|
|
0,
|
|
"Alert Face"},
|
|
};
|
|
|
|
//=========================================================
|
|
// AlertSmallFlinch Schedule - shot, but didn't see attacker,
|
|
// flinch then face
|
|
//=========================================================
|
|
Task_t tlAlertSmallFlinch[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_FLINCHED},
|
|
{TASK_SMALL_FLINCH, (float)0},
|
|
{TASK_SET_SCHEDULE, (float)SCHED_ALERT_FACE},
|
|
};
|
|
|
|
Schedule_t slAlertSmallFlinch[] =
|
|
{
|
|
{tlAlertSmallFlinch,
|
|
ARRAYSIZE(tlAlertSmallFlinch),
|
|
0,
|
|
0,
|
|
"Alert Small Flinch"},
|
|
};
|
|
|
|
//=========================================================
|
|
// AlertIdle Schedules
|
|
//=========================================================
|
|
Task_t tlAlertStand1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT, (float)20},
|
|
{TASK_SUGGEST_STATE, (float)MONSTERSTATE_IDLE},
|
|
};
|
|
|
|
Schedule_t slAlertStand[] =
|
|
{
|
|
{tlAlertStand1,
|
|
ARRAYSIZE(tlAlertStand1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_SEE_ENEMY |
|
|
bits_COND_SEE_FEAR |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_PROVOKED |
|
|
bits_COND_SMELL |
|
|
bits_COND_SMELL_FOOD |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_COMBAT | // sound flags
|
|
bits_SOUND_WORLD |
|
|
bits_SOUND_PLAYER |
|
|
bits_SOUND_DANGER |
|
|
|
|
bits_SOUND_MEAT | // scent flags
|
|
bits_SOUND_CARCASS |
|
|
bits_SOUND_GARBAGE,
|
|
"Alert Stand"},
|
|
};
|
|
|
|
//=========================================================
|
|
// InvestigateSound - sends a monster to the location of the
|
|
// sound that was just heard, to check things out.
|
|
//=========================================================
|
|
Task_t tlInvestigateSound[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_STORE_LASTPOSITION, (float)0},
|
|
{TASK_GET_PATH_TO_BESTSOUND, (float)0},
|
|
{TASK_FACE_IDEAL, (float)0},
|
|
{TASK_WALK_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_PLAY_SEQUENCE, (float)ACT_IDLE},
|
|
{TASK_WAIT, (float)10},
|
|
{TASK_GET_PATH_TO_LASTPOSITION, (float)0},
|
|
{TASK_WALK_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_CLEAR_LASTPOSITION, (float)0},
|
|
};
|
|
|
|
Schedule_t slInvestigateSound[] =
|
|
{
|
|
{tlInvestigateSound,
|
|
ARRAYSIZE(tlInvestigateSound),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_SEE_FEAR |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"InvestigateSound"},
|
|
};
|
|
|
|
//=========================================================
|
|
// CombatIdle Schedule
|
|
//=========================================================
|
|
Task_t tlCombatStand1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT_INDEFINITE, (float)0},
|
|
};
|
|
|
|
Schedule_t slCombatStand[] =
|
|
{
|
|
{tlCombatStand1,
|
|
ARRAYSIZE(tlCombatStand1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_CAN_ATTACK,
|
|
0,
|
|
"Combat Stand"},
|
|
};
|
|
|
|
//=========================================================
|
|
// CombatFace Schedule
|
|
//=========================================================
|
|
Task_t tlCombatFace1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
};
|
|
|
|
Schedule_t slCombatFace[] =
|
|
{
|
|
{tlCombatFace1,
|
|
ARRAYSIZE(tlCombatFace1),
|
|
bits_COND_CAN_ATTACK |
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD,
|
|
0,
|
|
"Combat Face"},
|
|
};
|
|
|
|
//=========================================================
|
|
// Standoff schedule. Used in combat when a monster is
|
|
// hiding in cover or the enemy has moved out of sight.
|
|
// Should we look around in this schedule?
|
|
//=========================================================
|
|
Task_t tlStandoff[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT_FACE_ENEMY, (float)2},
|
|
};
|
|
|
|
Schedule_t slStandoff[] =
|
|
{
|
|
{tlStandoff,
|
|
ARRAYSIZE(tlStandoff),
|
|
bits_COND_CAN_RANGE_ATTACK1 |
|
|
bits_COND_CAN_RANGE_ATTACK2 |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"Standoff"}};
|
|
|
|
//=========================================================
|
|
// Arm weapon (draw gun)
|
|
//=========================================================
|
|
Task_t tlArmWeapon[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_PLAY_SEQUENCE, (float)ACT_ARM}};
|
|
|
|
Schedule_t slArmWeapon[] =
|
|
{
|
|
{tlArmWeapon,
|
|
ARRAYSIZE(tlArmWeapon),
|
|
0,
|
|
0,
|
|
"Arm Weapon"}};
|
|
|
|
//=========================================================
|
|
// reload schedule
|
|
//=========================================================
|
|
Task_t tlReload[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_PLAY_SEQUENCE, float(ACT_RELOAD)},
|
|
};
|
|
|
|
Schedule_t slReload[] =
|
|
{
|
|
{tlReload,
|
|
ARRAYSIZE(tlReload),
|
|
bits_COND_HEAVY_DAMAGE,
|
|
0,
|
|
"Reload"}};
|
|
|
|
//=========================================================
|
|
// Attack Schedules
|
|
//=========================================================
|
|
|
|
// primary range attack
|
|
Task_t tlRangeAttack1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_RANGE_ATTACK1, (float)0},
|
|
};
|
|
|
|
Schedule_t slRangeAttack1[] =
|
|
{
|
|
{tlRangeAttack1,
|
|
ARRAYSIZE(tlRangeAttack1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_ENEMY_OCCLUDED |
|
|
bits_COND_NO_AMMO_LOADED |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"Range Attack1"},
|
|
};
|
|
|
|
// secondary range attack
|
|
Task_t tlRangeAttack2[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_RANGE_ATTACK2, (float)0},
|
|
};
|
|
|
|
Schedule_t slRangeAttack2[] =
|
|
{
|
|
{tlRangeAttack2,
|
|
ARRAYSIZE(tlRangeAttack2),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_ENEMY_OCCLUDED |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"Range Attack2"},
|
|
};
|
|
|
|
// primary melee attack
|
|
Task_t tlPrimaryMeleeAttack1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_MELEE_ATTACK1, (float)0},
|
|
};
|
|
|
|
Schedule_t slPrimaryMeleeAttack[] =
|
|
{
|
|
{tlPrimaryMeleeAttack1,
|
|
ARRAYSIZE(tlPrimaryMeleeAttack1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_ENEMY_OCCLUDED,
|
|
0,
|
|
"Primary Melee Attack"},
|
|
};
|
|
|
|
// secondary melee attack
|
|
Task_t tlSecondaryMeleeAttack1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_MELEE_ATTACK2, (float)0},
|
|
};
|
|
|
|
Schedule_t slSecondaryMeleeAttack[] =
|
|
{
|
|
{tlSecondaryMeleeAttack1,
|
|
ARRAYSIZE(tlSecondaryMeleeAttack1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_ENEMY_OCCLUDED,
|
|
0,
|
|
"Secondary Melee Attack"},
|
|
};
|
|
|
|
// special attack1
|
|
Task_t tlSpecialAttack1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_SPECIAL_ATTACK1, (float)0},
|
|
};
|
|
|
|
Schedule_t slSpecialAttack1[] =
|
|
{
|
|
{tlSpecialAttack1,
|
|
ARRAYSIZE(tlSpecialAttack1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_ENEMY_OCCLUDED |
|
|
bits_COND_NO_AMMO_LOADED |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"Special Attack1"},
|
|
};
|
|
|
|
// special attack2
|
|
Task_t tlSpecialAttack2[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_SPECIAL_ATTACK2, (float)0},
|
|
};
|
|
|
|
Schedule_t slSpecialAttack2[] =
|
|
{
|
|
{tlSpecialAttack2,
|
|
ARRAYSIZE(tlSpecialAttack2),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_ENEMY_DEAD |
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_ENEMY_OCCLUDED |
|
|
bits_COND_NO_AMMO_LOADED |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"Special Attack2"},
|
|
};
|
|
|
|
// Chase enemy schedule
|
|
Task_t tlChaseEnemy1[] =
|
|
{
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_CHASE_ENEMY_FAILED},
|
|
{TASK_GET_PATH_TO_ENEMY, (float)0},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
};
|
|
|
|
Schedule_t slChaseEnemy[] =
|
|
{
|
|
{tlChaseEnemy1,
|
|
ARRAYSIZE(tlChaseEnemy1),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_CAN_RANGE_ATTACK1 |
|
|
bits_COND_CAN_MELEE_ATTACK1 |
|
|
bits_COND_CAN_RANGE_ATTACK2 |
|
|
bits_COND_CAN_MELEE_ATTACK2 |
|
|
bits_COND_TASK_FAILED |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"Chase Enemy"},
|
|
};
|
|
|
|
|
|
// Chase enemy failure schedule
|
|
Task_t tlChaseEnemyFailed[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_WAIT, (float)0.2},
|
|
{TASK_FIND_COVER_FROM_ENEMY, (float)0},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_INCOVER},
|
|
// { TASK_TURN_LEFT, (float)179 },
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_WAIT, (float)1},
|
|
};
|
|
|
|
Schedule_t slChaseEnemyFailed[] =
|
|
{
|
|
{tlChaseEnemyFailed,
|
|
ARRAYSIZE(tlChaseEnemyFailed),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_CAN_RANGE_ATTACK1 |
|
|
bits_COND_CAN_MELEE_ATTACK1 |
|
|
bits_COND_CAN_RANGE_ATTACK2 |
|
|
bits_COND_CAN_MELEE_ATTACK2 |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"tlChaseEnemyFailed"},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// small flinch, played when minor damage is taken.
|
|
//=========================================================
|
|
Task_t tlSmallFlinch[] =
|
|
{
|
|
{TASK_REMEMBER, (float)bits_MEMORY_FLINCHED},
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SMALL_FLINCH, 0},
|
|
};
|
|
|
|
Schedule_t slSmallFlinch[] =
|
|
{
|
|
{tlSmallFlinch,
|
|
ARRAYSIZE(tlSmallFlinch),
|
|
0,
|
|
0,
|
|
"Small Flinch"},
|
|
};
|
|
|
|
//=========================================================
|
|
// Die!
|
|
//=========================================================
|
|
Task_t tlDie1[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SOUND_DIE, (float)0},
|
|
{TASK_DIE, (float)0},
|
|
};
|
|
|
|
Schedule_t slDie[] =
|
|
{
|
|
{tlDie1,
|
|
ARRAYSIZE(tlDie1),
|
|
0,
|
|
0,
|
|
"Die"},
|
|
};
|
|
|
|
//=========================================================
|
|
// Victory Dance
|
|
//=========================================================
|
|
Task_t tlVictoryDance[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_PLAY_SEQUENCE, (float)ACT_VICTORY_DANCE},
|
|
{TASK_WAIT, (float)0},
|
|
};
|
|
|
|
Schedule_t slVictoryDance[] =
|
|
{
|
|
{tlVictoryDance,
|
|
ARRAYSIZE(tlVictoryDance),
|
|
0,
|
|
0,
|
|
"Victory Dance"},
|
|
};
|
|
|
|
//=========================================================
|
|
// BarnacleVictimGrab - barnacle tongue just hit the monster,
|
|
// so play a hit animation, then play a cycling pull animation
|
|
// as the creature is hoisting the monster.
|
|
//=========================================================
|
|
Task_t tlBarnacleVictimGrab[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_PLAY_SEQUENCE, (float)ACT_BARNACLE_HIT},
|
|
{TASK_SET_ACTIVITY, (float)ACT_BARNACLE_PULL},
|
|
{TASK_WAIT_INDEFINITE, (float)0}, // just cycle barnacle pull anim while barnacle hoists.
|
|
};
|
|
|
|
Schedule_t slBarnacleVictimGrab[] =
|
|
{
|
|
{tlBarnacleVictimGrab,
|
|
ARRAYSIZE(tlBarnacleVictimGrab),
|
|
0,
|
|
0,
|
|
"Barnacle Victim"}};
|
|
|
|
//=========================================================
|
|
// BarnacleVictimChomp - barnacle has pulled the prey to its
|
|
// mouth. Victim should play the BARNCLE_CHOMP animation
|
|
// once, then loop the BARNACLE_CHEW animation indefinitely
|
|
//=========================================================
|
|
Task_t tlBarnacleVictimChomp[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_PLAY_SEQUENCE, (float)ACT_BARNACLE_CHOMP},
|
|
{TASK_SET_ACTIVITY, (float)ACT_BARNACLE_CHEW},
|
|
{TASK_WAIT_INDEFINITE, (float)0}, // just cycle barnacle pull anim while barnacle hoists.
|
|
};
|
|
|
|
Schedule_t slBarnacleVictimChomp[] =
|
|
{
|
|
{tlBarnacleVictimChomp,
|
|
ARRAYSIZE(tlBarnacleVictimChomp),
|
|
0,
|
|
0,
|
|
"Barnacle Chomp"}};
|
|
|
|
|
|
// Universal Error Schedule
|
|
Task_t tlError[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_WAIT_INDEFINITE, (float)0},
|
|
};
|
|
|
|
Schedule_t slError[] =
|
|
{
|
|
{tlError,
|
|
ARRAYSIZE(tlError),
|
|
0,
|
|
0,
|
|
"Error"},
|
|
};
|
|
|
|
Task_t tlScriptedWalk[] =
|
|
{
|
|
{TASK_WALK_TO_TARGET, (float)TARGET_MOVE_SCRIPTED},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_PLANT_ON_SCRIPT, (float)0},
|
|
{TASK_FACE_SCRIPT, (float)0},
|
|
{TASK_FACE_IDEAL, (float)0},
|
|
{TASK_ENABLE_SCRIPT, (float)0},
|
|
{TASK_WAIT_FOR_SCRIPT, (float)0},
|
|
{TASK_PLAY_SCRIPT, (float)0},
|
|
};
|
|
|
|
Schedule_t slWalkToScript[] =
|
|
{
|
|
{tlScriptedWalk,
|
|
ARRAYSIZE(tlScriptedWalk),
|
|
SCRIPT_BREAK_CONDITIONS,
|
|
0,
|
|
"WalkToScript"},
|
|
};
|
|
|
|
|
|
Task_t tlScriptedRun[] =
|
|
{
|
|
{TASK_RUN_TO_TARGET, (float)TARGET_MOVE_SCRIPTED},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_PLANT_ON_SCRIPT, (float)0},
|
|
{TASK_FACE_SCRIPT, (float)0},
|
|
{TASK_FACE_IDEAL, (float)0},
|
|
{TASK_ENABLE_SCRIPT, (float)0},
|
|
{TASK_WAIT_FOR_SCRIPT, (float)0},
|
|
{TASK_PLAY_SCRIPT, (float)0},
|
|
};
|
|
|
|
Schedule_t slRunToScript[] =
|
|
{
|
|
{tlScriptedRun,
|
|
ARRAYSIZE(tlScriptedRun),
|
|
SCRIPT_BREAK_CONDITIONS,
|
|
0,
|
|
"RunToScript"},
|
|
};
|
|
|
|
Task_t tlScriptedWait[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_WAIT_FOR_SCRIPT, (float)0},
|
|
{TASK_PLAY_SCRIPT, (float)0},
|
|
};
|
|
|
|
Schedule_t slWaitScript[] =
|
|
{
|
|
{tlScriptedWait,
|
|
ARRAYSIZE(tlScriptedWait),
|
|
SCRIPT_BREAK_CONDITIONS,
|
|
0,
|
|
"WaitForScript"},
|
|
};
|
|
|
|
Task_t tlScriptedFace[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_FACE_SCRIPT, (float)0},
|
|
{TASK_FACE_IDEAL, (float)0},
|
|
{TASK_WAIT_FOR_SCRIPT, (float)0},
|
|
{TASK_PLAY_SCRIPT, (float)0},
|
|
};
|
|
|
|
Schedule_t slFaceScript[] =
|
|
{
|
|
{tlScriptedFace,
|
|
ARRAYSIZE(tlScriptedFace),
|
|
SCRIPT_BREAK_CONDITIONS,
|
|
0,
|
|
"FaceScript"},
|
|
};
|
|
|
|
//=========================================================
|
|
// Cower - this is what is usually done when attempts
|
|
// to escape danger fail.
|
|
//=========================================================
|
|
Task_t tlCower[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_PLAY_SEQUENCE, (float)ACT_COWER},
|
|
};
|
|
|
|
Schedule_t slCower[] =
|
|
{
|
|
{tlCower,
|
|
ARRAYSIZE(tlCower),
|
|
0,
|
|
0,
|
|
"Cower"},
|
|
};
|
|
|
|
//=========================================================
|
|
// move away from where you're currently standing.
|
|
//=========================================================
|
|
Task_t tlTakeCoverFromOrigin[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_FIND_COVER_FROM_ORIGIN, (float)0},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_INCOVER},
|
|
{TASK_TURN_LEFT, (float)179},
|
|
};
|
|
|
|
Schedule_t slTakeCoverFromOrigin[] =
|
|
{
|
|
{tlTakeCoverFromOrigin,
|
|
ARRAYSIZE(tlTakeCoverFromOrigin),
|
|
bits_COND_NEW_ENEMY,
|
|
0,
|
|
"TakeCoverFromOrigin"},
|
|
};
|
|
|
|
//=========================================================
|
|
// hide from the loudest sound source
|
|
//=========================================================
|
|
Task_t tlTakeCoverFromBestSound[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_FIND_COVER_FROM_BEST_SOUND, (float)0},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_INCOVER},
|
|
{TASK_TURN_LEFT, (float)179},
|
|
};
|
|
|
|
Schedule_t slTakeCoverFromBestSound[] =
|
|
{
|
|
{tlTakeCoverFromBestSound,
|
|
ARRAYSIZE(tlTakeCoverFromBestSound),
|
|
bits_COND_NEW_ENEMY,
|
|
0,
|
|
"TakeCoverFromBestSound"},
|
|
};
|
|
|
|
//=========================================================
|
|
// Take cover from enemy! Tries lateral cover before node
|
|
// cover!
|
|
//=========================================================
|
|
Task_t tlTakeCoverFromEnemy[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_WAIT, (float)0.2},
|
|
{TASK_FIND_COVER_FROM_ENEMY, (float)0},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_INCOVER},
|
|
// { TASK_TURN_LEFT, (float)179 },
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_WAIT, (float)1},
|
|
};
|
|
|
|
Schedule_t slTakeCoverFromEnemy[] =
|
|
{
|
|
{tlTakeCoverFromEnemy,
|
|
ARRAYSIZE(tlTakeCoverFromEnemy),
|
|
bits_COND_NEW_ENEMY,
|
|
0,
|
|
"tlTakeCoverFromEnemy"},
|
|
};
|
|
|
|
Schedule_t* CBaseMonster::m_scheduleList[] =
|
|
{
|
|
slIdleStand,
|
|
slIdleTrigger,
|
|
slIdleWalk,
|
|
slAmbush,
|
|
slActiveIdle,
|
|
slWakeAngry,
|
|
slAlertFace,
|
|
slAlertSmallFlinch,
|
|
slAlertStand,
|
|
slInvestigateSound,
|
|
slCombatStand,
|
|
slCombatFace,
|
|
slStandoff,
|
|
slArmWeapon,
|
|
slReload,
|
|
slRangeAttack1,
|
|
slRangeAttack2,
|
|
slPrimaryMeleeAttack,
|
|
slSecondaryMeleeAttack,
|
|
slSpecialAttack1,
|
|
slSpecialAttack2,
|
|
slChaseEnemy,
|
|
slChaseEnemyFailed,
|
|
slSmallFlinch,
|
|
slDie,
|
|
slVictoryDance,
|
|
slBarnacleVictimGrab,
|
|
slBarnacleVictimChomp,
|
|
slError,
|
|
slWalkToScript,
|
|
slRunToScript,
|
|
slWaitScript,
|
|
slFaceScript,
|
|
slCower,
|
|
slTakeCoverFromOrigin,
|
|
slTakeCoverFromBestSound,
|
|
slTakeCoverFromEnemy,
|
|
slFail};
|
|
|
|
Schedule_t* CBaseMonster::ScheduleFromName(const char* pName)
|
|
{
|
|
return ScheduleInList(pName, m_scheduleList, ARRAYSIZE(m_scheduleList));
|
|
}
|
|
|
|
|
|
Schedule_t* CBaseMonster::ScheduleInList(const char* pName, Schedule_t** pList, int listCount)
|
|
{
|
|
int i;
|
|
|
|
if (!pName)
|
|
{
|
|
ALERT(at_console, "%s set to unnamed schedule!\n", STRING(pev->classname));
|
|
return NULL;
|
|
}
|
|
|
|
|
|
for (i = 0; i < listCount; i++)
|
|
{
|
|
if (!pList[i]->pName)
|
|
{
|
|
ALERT(at_console, "Unnamed schedule!\n");
|
|
continue;
|
|
}
|
|
if (stricmp(pName, pList[i]->pName) == 0)
|
|
return pList[i];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//=========================================================
|
|
// GetScheduleOfType - returns a pointer to one of the
|
|
// monster's available schedules of the indicated type.
|
|
//=========================================================
|
|
Schedule_t* CBaseMonster::GetScheduleOfType(int Type)
|
|
{
|
|
// ALERT ( at_console, "Sched Type:%d\n", Type );
|
|
switch (Type)
|
|
{
|
|
// This is the schedule for scripted sequences AND scripted AI
|
|
case SCHED_AISCRIPT:
|
|
{
|
|
ASSERT(m_pCine != NULL);
|
|
if (!m_pCine)
|
|
{
|
|
ALERT(at_aiconsole, "Script failed for %s\n", STRING(pev->classname));
|
|
CineCleanup();
|
|
return GetScheduleOfType(SCHED_IDLE_STAND);
|
|
}
|
|
// else
|
|
// ALERT( at_aiconsole, "Starting script %s for %s\n", STRING( m_pCine->m_iszPlay ), STRING(pev->classname) );
|
|
|
|
switch (m_pCine->m_fMoveTo)
|
|
{
|
|
case 0:
|
|
case 4:
|
|
return slWaitScript;
|
|
case 1:
|
|
return slWalkToScript;
|
|
case 2:
|
|
return slRunToScript;
|
|
case 5:
|
|
return slFaceScript;
|
|
}
|
|
break;
|
|
}
|
|
case SCHED_IDLE_STAND:
|
|
{
|
|
if (RANDOM_LONG(0, 14) == 0 && FCanActiveIdle())
|
|
{
|
|
return &slActiveIdle[0];
|
|
}
|
|
|
|
return &slIdleStand[0];
|
|
}
|
|
case SCHED_IDLE_WALK:
|
|
{
|
|
return &slIdleWalk[0];
|
|
}
|
|
case SCHED_WAIT_TRIGGER:
|
|
{
|
|
return &slIdleTrigger[0];
|
|
}
|
|
case SCHED_WAKE_ANGRY:
|
|
{
|
|
return &slWakeAngry[0];
|
|
}
|
|
case SCHED_ALERT_FACE:
|
|
{
|
|
return &slAlertFace[0];
|
|
}
|
|
case SCHED_ALERT_STAND:
|
|
{
|
|
return &slAlertStand[0];
|
|
}
|
|
case SCHED_COMBAT_STAND:
|
|
{
|
|
return &slCombatStand[0];
|
|
}
|
|
case SCHED_COMBAT_FACE:
|
|
{
|
|
return &slCombatFace[0];
|
|
}
|
|
case SCHED_CHASE_ENEMY:
|
|
{
|
|
return &slChaseEnemy[0];
|
|
}
|
|
case SCHED_CHASE_ENEMY_FAILED:
|
|
{
|
|
return &slFail[0];
|
|
}
|
|
case SCHED_SMALL_FLINCH:
|
|
{
|
|
return &slSmallFlinch[0];
|
|
}
|
|
case SCHED_ALERT_SMALL_FLINCH:
|
|
{
|
|
return &slAlertSmallFlinch[0];
|
|
}
|
|
case SCHED_RELOAD:
|
|
{
|
|
return &slReload[0];
|
|
}
|
|
case SCHED_ARM_WEAPON:
|
|
{
|
|
return &slArmWeapon[0];
|
|
}
|
|
case SCHED_STANDOFF:
|
|
{
|
|
return &slStandoff[0];
|
|
}
|
|
case SCHED_RANGE_ATTACK1:
|
|
{
|
|
return &slRangeAttack1[0];
|
|
}
|
|
case SCHED_RANGE_ATTACK2:
|
|
{
|
|
return &slRangeAttack2[0];
|
|
}
|
|
case SCHED_MELEE_ATTACK1:
|
|
{
|
|
return &slPrimaryMeleeAttack[0];
|
|
}
|
|
case SCHED_MELEE_ATTACK2:
|
|
{
|
|
return &slSecondaryMeleeAttack[0];
|
|
}
|
|
case SCHED_SPECIAL_ATTACK1:
|
|
{
|
|
return &slSpecialAttack1[0];
|
|
}
|
|
case SCHED_SPECIAL_ATTACK2:
|
|
{
|
|
return &slSpecialAttack2[0];
|
|
}
|
|
case SCHED_TAKE_COVER_FROM_BEST_SOUND:
|
|
{
|
|
return &slTakeCoverFromBestSound[0];
|
|
}
|
|
case SCHED_TAKE_COVER_FROM_ENEMY:
|
|
{
|
|
return &slTakeCoverFromEnemy[0];
|
|
}
|
|
case SCHED_COWER:
|
|
{
|
|
return &slCower[0];
|
|
}
|
|
case SCHED_AMBUSH:
|
|
{
|
|
return &slAmbush[0];
|
|
}
|
|
case SCHED_BARNACLE_VICTIM_GRAB:
|
|
{
|
|
return &slBarnacleVictimGrab[0];
|
|
}
|
|
case SCHED_BARNACLE_VICTIM_CHOMP:
|
|
{
|
|
return &slBarnacleVictimChomp[0];
|
|
}
|
|
case SCHED_INVESTIGATE_SOUND:
|
|
{
|
|
return &slInvestigateSound[0];
|
|
}
|
|
case SCHED_DIE:
|
|
{
|
|
return &slDie[0];
|
|
}
|
|
case SCHED_TAKE_COVER_FROM_ORIGIN:
|
|
{
|
|
return &slTakeCoverFromOrigin[0];
|
|
}
|
|
case SCHED_VICTORY_DANCE:
|
|
{
|
|
return &slVictoryDance[0];
|
|
}
|
|
case SCHED_FAIL:
|
|
{
|
|
return slFail;
|
|
}
|
|
default:
|
|
{
|
|
ALERT(at_console, "GetScheduleOfType()\nNo CASE for Schedule Type %d!\n", Type);
|
|
|
|
return &slIdleStand[0];
|
|
break;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|