/***
*
*	Copyright (c) 1996-2002, 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	"nodes.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;
}