999 lines
25 KiB
C++
999 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.
|
|
*
|
|
****/
|
|
|
|
//=========================================================
|
|
// hassassin - Human assassin, fast and stealthy
|
|
//=========================================================
|
|
|
|
#include "extdll.h"
|
|
#include "util.h"
|
|
#include "cbase.h"
|
|
#include "monsters.h"
|
|
#include "schedule.h"
|
|
#include "squadmonster.h"
|
|
#include "weapons.h"
|
|
#include "soundent.h"
|
|
#include "game.h"
|
|
|
|
//=========================================================
|
|
// monster-specific schedule types
|
|
//=========================================================
|
|
enum
|
|
{
|
|
SCHED_ASSASSIN_EXPOSED = LAST_COMMON_SCHEDULE + 1, // cover was blown.
|
|
SCHED_ASSASSIN_JUMP, // fly through the air
|
|
SCHED_ASSASSIN_JUMP_ATTACK, // fly through the air and shoot
|
|
SCHED_ASSASSIN_JUMP_LAND, // hit and run away
|
|
};
|
|
|
|
//=========================================================
|
|
// monster-specific tasks
|
|
//=========================================================
|
|
|
|
enum
|
|
{
|
|
TASK_ASSASSIN_FALL_TO_GROUND = LAST_COMMON_TASK + 1, // falling and waiting to hit ground
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// Monster's Anim Events Go Here
|
|
//=========================================================
|
|
#define ASSASSIN_AE_SHOOT1 1
|
|
#define ASSASSIN_AE_TOSS1 2
|
|
#define ASSASSIN_AE_JUMP 3
|
|
|
|
|
|
#define bits_MEMORY_BADJUMP (bits_MEMORY_CUSTOM1)
|
|
|
|
class CHAssassin : public CBaseMonster
|
|
{
|
|
public:
|
|
void Spawn() override;
|
|
void Precache() override;
|
|
void SetYawSpeed() override;
|
|
int Classify() override;
|
|
int ISoundMask() override;
|
|
void Shoot();
|
|
void HandleAnimEvent(MonsterEvent_t* pEvent) override;
|
|
Schedule_t* GetSchedule() override;
|
|
Schedule_t* GetScheduleOfType(int Type) override;
|
|
bool CheckMeleeAttack1(float flDot, float flDist) override; // jump
|
|
// bool CheckMeleeAttack2 ( float flDot, float flDist ) override;
|
|
bool CheckRangeAttack1(float flDot, float flDist) override; // shoot
|
|
bool CheckRangeAttack2(float flDot, float flDist) override; // throw grenade
|
|
void StartTask(Task_t* pTask) override;
|
|
void RunAI() override;
|
|
void RunTask(Task_t* pTask) override;
|
|
void DeathSound() override;
|
|
void IdleSound() override;
|
|
CUSTOM_SCHEDULES;
|
|
|
|
bool Save(CSave& save) override;
|
|
bool Restore(CRestore& restore) override;
|
|
static TYPEDESCRIPTION m_SaveData[];
|
|
|
|
float m_flLastShot;
|
|
float m_flDiviation;
|
|
|
|
float m_flNextJump;
|
|
Vector m_vecJumpVelocity;
|
|
|
|
float m_flNextGrenadeCheck;
|
|
Vector m_vecTossVelocity;
|
|
bool m_fThrowGrenade;
|
|
|
|
int m_iTargetRanderamt;
|
|
|
|
int m_iFrustration;
|
|
|
|
int m_iShell;
|
|
};
|
|
LINK_ENTITY_TO_CLASS(monster_human_assassin, CHAssassin);
|
|
|
|
|
|
TYPEDESCRIPTION CHAssassin::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD(CHAssassin, m_flLastShot, FIELD_TIME),
|
|
DEFINE_FIELD(CHAssassin, m_flDiviation, FIELD_FLOAT),
|
|
|
|
DEFINE_FIELD(CHAssassin, m_flNextJump, FIELD_TIME),
|
|
DEFINE_FIELD(CHAssassin, m_vecJumpVelocity, FIELD_VECTOR),
|
|
|
|
DEFINE_FIELD(CHAssassin, m_flNextGrenadeCheck, FIELD_TIME),
|
|
DEFINE_FIELD(CHAssassin, m_vecTossVelocity, FIELD_VECTOR),
|
|
DEFINE_FIELD(CHAssassin, m_fThrowGrenade, FIELD_BOOLEAN),
|
|
|
|
DEFINE_FIELD(CHAssassin, m_iTargetRanderamt, FIELD_INTEGER),
|
|
DEFINE_FIELD(CHAssassin, m_iFrustration, FIELD_INTEGER),
|
|
};
|
|
|
|
IMPLEMENT_SAVERESTORE(CHAssassin, CBaseMonster);
|
|
|
|
|
|
//=========================================================
|
|
// DieSound
|
|
//=========================================================
|
|
void CHAssassin::DeathSound()
|
|
{
|
|
}
|
|
|
|
//=========================================================
|
|
// IdleSound
|
|
//=========================================================
|
|
void CHAssassin::IdleSound()
|
|
{
|
|
}
|
|
|
|
//=========================================================
|
|
// ISoundMask - returns a bit mask indicating which types
|
|
// of sounds this monster regards.
|
|
//=========================================================
|
|
int CHAssassin::ISoundMask()
|
|
{
|
|
return bits_SOUND_WORLD |
|
|
bits_SOUND_COMBAT |
|
|
bits_SOUND_DANGER |
|
|
bits_SOUND_PLAYER;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// Classify - indicates this monster's place in the
|
|
// relationship table.
|
|
//=========================================================
|
|
int CHAssassin::Classify()
|
|
{
|
|
return CLASS_HUMAN_MILITARY;
|
|
}
|
|
|
|
//=========================================================
|
|
// SetYawSpeed - allows each sequence to have a different
|
|
// turn rate associated with it.
|
|
//=========================================================
|
|
void CHAssassin::SetYawSpeed()
|
|
{
|
|
int ys;
|
|
|
|
switch (m_Activity)
|
|
{
|
|
case ACT_TURN_LEFT:
|
|
case ACT_TURN_RIGHT:
|
|
ys = 360;
|
|
break;
|
|
default:
|
|
ys = 360;
|
|
break;
|
|
}
|
|
|
|
pev->yaw_speed = ys;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// Shoot
|
|
//=========================================================
|
|
void CHAssassin::Shoot()
|
|
{
|
|
if (m_hEnemy == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Vector vecShootOrigin = GetGunPosition();
|
|
Vector vecShootDir = ShootAtEnemy(vecShootOrigin);
|
|
|
|
if (m_flLastShot + 2 < gpGlobals->time)
|
|
{
|
|
m_flDiviation = 0.10;
|
|
}
|
|
else
|
|
{
|
|
m_flDiviation -= 0.01;
|
|
if (m_flDiviation < 0.02)
|
|
m_flDiviation = 0.02;
|
|
}
|
|
m_flLastShot = gpGlobals->time;
|
|
|
|
UTIL_MakeVectors(pev->angles);
|
|
|
|
Vector vecShellVelocity = gpGlobals->v_right * RANDOM_FLOAT(40, 90) + gpGlobals->v_up * RANDOM_FLOAT(75, 200) + gpGlobals->v_forward * RANDOM_FLOAT(-40, 40);
|
|
EjectBrass(pev->origin + gpGlobals->v_up * 32 + gpGlobals->v_forward * 12, vecShellVelocity, pev->angles.y, m_iShell, TE_BOUNCE_SHELL);
|
|
FireBullets(1, vecShootOrigin, vecShootDir, Vector(m_flDiviation, m_flDiviation, m_flDiviation), 2048, BULLET_MONSTER_9MM); // shoot +-8 degrees
|
|
|
|
switch (RANDOM_LONG(0, 1))
|
|
{
|
|
case 0:
|
|
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/pl_gun1.wav", RANDOM_FLOAT(0.6, 0.8), ATTN_NORM);
|
|
break;
|
|
case 1:
|
|
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "weapons/pl_gun2.wav", RANDOM_FLOAT(0.6, 0.8), ATTN_NORM);
|
|
break;
|
|
}
|
|
|
|
pev->effects |= EF_MUZZLEFLASH;
|
|
|
|
Vector angDir = UTIL_VecToAngles(vecShootDir);
|
|
SetBlending(0, angDir.x);
|
|
|
|
m_cAmmoLoaded--;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// HandleAnimEvent - catches the monster-specific messages
|
|
// that occur when tagged animation frames are played.
|
|
//
|
|
// Returns number of events handled, 0 if none.
|
|
//=========================================================
|
|
void CHAssassin::HandleAnimEvent(MonsterEvent_t* pEvent)
|
|
{
|
|
switch (pEvent->event)
|
|
{
|
|
case ASSASSIN_AE_SHOOT1:
|
|
Shoot();
|
|
break;
|
|
case ASSASSIN_AE_TOSS1:
|
|
{
|
|
UTIL_MakeVectors(pev->angles);
|
|
CGrenade::ShootTimed(pev, pev->origin + gpGlobals->v_forward * 34 + Vector(0, 0, 32), m_vecTossVelocity, 2.0);
|
|
|
|
m_flNextGrenadeCheck = gpGlobals->time + 6; // wait six seconds before even looking again to see if a grenade can be thrown.
|
|
m_fThrowGrenade = false;
|
|
// !!!LATER - when in a group, only try to throw grenade if ordered.
|
|
}
|
|
break;
|
|
case ASSASSIN_AE_JUMP:
|
|
{
|
|
// ALERT( at_console, "jumping");
|
|
UTIL_MakeAimVectors(pev->angles);
|
|
pev->movetype = MOVETYPE_TOSS;
|
|
pev->flags &= ~FL_ONGROUND;
|
|
pev->velocity = m_vecJumpVelocity;
|
|
m_flNextJump = gpGlobals->time + 3.0;
|
|
}
|
|
return;
|
|
default:
|
|
CBaseMonster::HandleAnimEvent(pEvent);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// Spawn
|
|
//=========================================================
|
|
void CHAssassin::Spawn()
|
|
{
|
|
Precache();
|
|
|
|
SET_MODEL(ENT(pev), "models/hassassin.mdl");
|
|
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
|
|
|
|
pev->solid = SOLID_SLIDEBOX;
|
|
pev->movetype = MOVETYPE_STEP;
|
|
m_bloodColor = BLOOD_COLOR_RED;
|
|
pev->effects = 0;
|
|
pev->health = gSkillData.hassassinHealth;
|
|
m_flFieldOfView = VIEW_FIELD_WIDE; // indicates the width of this monster's forward view cone ( as a dotproduct result )
|
|
m_MonsterState = MONSTERSTATE_NONE;
|
|
m_afCapability = bits_CAP_MELEE_ATTACK1 | bits_CAP_DOORS_GROUP;
|
|
pev->friction = 1;
|
|
|
|
m_HackedGunPos = Vector(0, 24, 48);
|
|
|
|
m_iTargetRanderamt = 20;
|
|
pev->renderamt = 20;
|
|
pev->rendermode = kRenderTransTexture;
|
|
|
|
MonsterInit();
|
|
}
|
|
|
|
//=========================================================
|
|
// Precache - precaches all resources this monster needs
|
|
//=========================================================
|
|
void CHAssassin::Precache()
|
|
{
|
|
PRECACHE_MODEL("models/hassassin.mdl");
|
|
|
|
PRECACHE_SOUND("weapons/pl_gun1.wav");
|
|
PRECACHE_SOUND("weapons/pl_gun2.wav");
|
|
|
|
PRECACHE_SOUND("debris/beamstart1.wav");
|
|
|
|
m_iShell = PRECACHE_MODEL("models/shell.mdl"); // brass shell
|
|
}
|
|
|
|
|
|
|
|
//=========================================================
|
|
// AI Schedules Specific to this monster
|
|
//=========================================================
|
|
|
|
//=========================================================
|
|
// Fail Schedule
|
|
//=========================================================
|
|
Task_t tlAssassinFail[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT_FACE_ENEMY, (float)2},
|
|
// { TASK_WAIT_PVS, (float)0 },
|
|
{TASK_SET_SCHEDULE, (float)SCHED_CHASE_ENEMY},
|
|
};
|
|
|
|
Schedule_t slAssassinFail[] =
|
|
{
|
|
{tlAssassinFail,
|
|
ARRAYSIZE(tlAssassinFail),
|
|
bits_COND_LIGHT_DAMAGE |
|
|
bits_COND_HEAVY_DAMAGE |
|
|
bits_COND_PROVOKED |
|
|
bits_COND_CAN_RANGE_ATTACK1 |
|
|
bits_COND_CAN_RANGE_ATTACK2 |
|
|
bits_COND_CAN_MELEE_ATTACK1 |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER |
|
|
bits_SOUND_PLAYER,
|
|
"AssassinFail"},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// Enemy exposed Agrunt's cover
|
|
//=========================================================
|
|
Task_t tlAssassinExposed[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_RANGE_ATTACK1, (float)0},
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_ASSASSIN_JUMP},
|
|
{TASK_SET_SCHEDULE, (float)SCHED_TAKE_COVER_FROM_ENEMY},
|
|
};
|
|
|
|
Schedule_t slAssassinExposed[] =
|
|
{
|
|
{
|
|
tlAssassinExposed,
|
|
ARRAYSIZE(tlAssassinExposed),
|
|
bits_COND_CAN_MELEE_ATTACK1,
|
|
0,
|
|
"AssassinExposed",
|
|
},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// Take cover from enemy! Tries lateral cover before node
|
|
// cover!
|
|
//=========================================================
|
|
Task_t tlAssassinTakeCoverFromEnemy[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_WAIT, (float)0.2},
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_RANGE_ATTACK1},
|
|
{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_FACE_ENEMY, (float)0},
|
|
};
|
|
|
|
Schedule_t slAssassinTakeCoverFromEnemy[] =
|
|
{
|
|
{tlAssassinTakeCoverFromEnemy,
|
|
ARRAYSIZE(tlAssassinTakeCoverFromEnemy),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_CAN_MELEE_ATTACK1 |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"AssassinTakeCoverFromEnemy"},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// Take cover from enemy! Tries lateral cover before node
|
|
// cover!
|
|
//=========================================================
|
|
Task_t tlAssassinTakeCoverFromEnemy2[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_WAIT, (float)0.2},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_RANGE_ATTACK1, (float)0},
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_RANGE_ATTACK2},
|
|
{TASK_FIND_FAR_NODE_COVER_FROM_ENEMY, (float)384},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_INCOVER},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
};
|
|
|
|
Schedule_t slAssassinTakeCoverFromEnemy2[] =
|
|
{
|
|
{tlAssassinTakeCoverFromEnemy2,
|
|
ARRAYSIZE(tlAssassinTakeCoverFromEnemy2),
|
|
bits_COND_NEW_ENEMY |
|
|
bits_COND_CAN_MELEE_ATTACK2 |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"AssassinTakeCoverFromEnemy2"},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// hide from the loudest sound source
|
|
//=========================================================
|
|
Task_t tlAssassinTakeCoverFromBestSound[] =
|
|
{
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_MELEE_ATTACK1},
|
|
{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 slAssassinTakeCoverFromBestSound[] =
|
|
{
|
|
{tlAssassinTakeCoverFromBestSound,
|
|
ARRAYSIZE(tlAssassinTakeCoverFromBestSound),
|
|
bits_COND_NEW_ENEMY,
|
|
0,
|
|
"AssassinTakeCoverFromBestSound"},
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//=========================================================
|
|
// AlertIdle Schedules
|
|
//=========================================================
|
|
Task_t tlAssassinHide[] =
|
|
{
|
|
{TASK_STOP_MOVING, 0},
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_WAIT, (float)2},
|
|
{TASK_SET_SCHEDULE, (float)SCHED_CHASE_ENEMY},
|
|
};
|
|
|
|
Schedule_t slAssassinHide[] =
|
|
{
|
|
{tlAssassinHide,
|
|
ARRAYSIZE(tlAssassinHide),
|
|
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_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"AssassinHide"},
|
|
};
|
|
|
|
|
|
|
|
//=========================================================
|
|
// HUNT Schedules
|
|
//=========================================================
|
|
Task_t tlAssassinHunt[] =
|
|
{
|
|
{TASK_GET_PATH_TO_ENEMY, (float)0},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
};
|
|
|
|
Schedule_t slAssassinHunt[] =
|
|
{
|
|
{tlAssassinHunt,
|
|
ARRAYSIZE(tlAssassinHunt),
|
|
bits_COND_NEW_ENEMY |
|
|
// bits_COND_SEE_ENEMY |
|
|
bits_COND_CAN_RANGE_ATTACK1 |
|
|
bits_COND_HEAR_SOUND,
|
|
|
|
bits_SOUND_DANGER,
|
|
"AssassinHunt"},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// Jumping Schedules
|
|
//=========================================================
|
|
Task_t tlAssassinJump[] =
|
|
{
|
|
{TASK_STOP_MOVING, (float)0},
|
|
{TASK_PLAY_SEQUENCE, (float)ACT_HOP},
|
|
{TASK_SET_SCHEDULE, (float)SCHED_ASSASSIN_JUMP_ATTACK},
|
|
};
|
|
|
|
Schedule_t slAssassinJump[] =
|
|
{
|
|
{tlAssassinJump,
|
|
ARRAYSIZE(tlAssassinJump),
|
|
0,
|
|
0,
|
|
"AssassinJump"},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// repel
|
|
//=========================================================
|
|
Task_t tlAssassinJumpAttack[] =
|
|
{
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_ASSASSIN_JUMP_LAND},
|
|
// { TASK_SET_ACTIVITY, (float)ACT_FLY },
|
|
{TASK_ASSASSIN_FALL_TO_GROUND, (float)0},
|
|
};
|
|
|
|
|
|
Schedule_t slAssassinJumpAttack[] =
|
|
{
|
|
{tlAssassinJumpAttack,
|
|
ARRAYSIZE(tlAssassinJumpAttack),
|
|
0,
|
|
0,
|
|
"AssassinJumpAttack"},
|
|
};
|
|
|
|
|
|
//=========================================================
|
|
// repel
|
|
//=========================================================
|
|
Task_t tlAssassinJumpLand[] =
|
|
{
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_ASSASSIN_EXPOSED},
|
|
// { TASK_SET_FAIL_SCHEDULE, (float)SCHED_MELEE_ATTACK1 },
|
|
{TASK_SET_ACTIVITY, (float)ACT_IDLE},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_BADJUMP},
|
|
{TASK_FIND_NODE_COVER_FROM_ENEMY, (float)0},
|
|
{TASK_RUN_PATH, (float)0},
|
|
{TASK_FORGET, (float)bits_MEMORY_BADJUMP},
|
|
{TASK_WAIT_FOR_MOVEMENT, (float)0},
|
|
{TASK_REMEMBER, (float)bits_MEMORY_INCOVER},
|
|
{TASK_FACE_ENEMY, (float)0},
|
|
{TASK_SET_FAIL_SCHEDULE, (float)SCHED_RANGE_ATTACK1},
|
|
};
|
|
|
|
Schedule_t slAssassinJumpLand[] =
|
|
{
|
|
{tlAssassinJumpLand,
|
|
ARRAYSIZE(tlAssassinJumpLand),
|
|
0,
|
|
0,
|
|
"AssassinJumpLand"},
|
|
};
|
|
|
|
DEFINE_CUSTOM_SCHEDULES(CHAssassin){
|
|
slAssassinFail,
|
|
slAssassinExposed,
|
|
slAssassinTakeCoverFromEnemy,
|
|
slAssassinTakeCoverFromEnemy2,
|
|
slAssassinTakeCoverFromBestSound,
|
|
slAssassinHide,
|
|
slAssassinHunt,
|
|
slAssassinJump,
|
|
slAssassinJumpAttack,
|
|
slAssassinJumpLand,
|
|
};
|
|
|
|
IMPLEMENT_CUSTOM_SCHEDULES(CHAssassin, CBaseMonster);
|
|
|
|
|
|
//=========================================================
|
|
// CheckMeleeAttack1 - jump like crazy if the enemy gets too close.
|
|
//=========================================================
|
|
bool CHAssassin::CheckMeleeAttack1(float flDot, float flDist)
|
|
{
|
|
if (m_flNextJump < gpGlobals->time && (flDist <= 128 || HasMemory(bits_MEMORY_BADJUMP)) && m_hEnemy != NULL)
|
|
{
|
|
TraceResult tr;
|
|
|
|
Vector vecDest = pev->origin + Vector(RANDOM_FLOAT(-64, 64), RANDOM_FLOAT(-64, 64), 160);
|
|
|
|
UTIL_TraceHull(pev->origin + Vector(0, 0, 36), vecDest + Vector(0, 0, 36), dont_ignore_monsters, human_hull, ENT(pev), &tr);
|
|
|
|
if (0 != tr.fStartSolid || tr.flFraction < 1.0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float flGravity = g_psv_gravity->value;
|
|
|
|
float time = sqrt(160 / (0.5 * flGravity));
|
|
float speed = flGravity * time / 160;
|
|
m_vecJumpVelocity = (vecDest - pev->origin) * speed;
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//=========================================================
|
|
// CheckRangeAttack1 - drop a cap in their ass
|
|
//
|
|
//=========================================================
|
|
bool CHAssassin::CheckRangeAttack1(float flDot, float flDist)
|
|
{
|
|
if (!HasConditions(bits_COND_ENEMY_OCCLUDED) && flDist > 64 && flDist <= 2048 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */)
|
|
{
|
|
TraceResult tr;
|
|
|
|
Vector vecSrc = GetGunPosition();
|
|
|
|
// verify that a bullet fired from the gun will hit the enemy before the world.
|
|
UTIL_TraceLine(vecSrc, m_hEnemy->BodyTarget(vecSrc), dont_ignore_monsters, ENT(pev), &tr);
|
|
|
|
if (tr.flFraction == 1 || tr.pHit == m_hEnemy->edict())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//=========================================================
|
|
// CheckRangeAttack2 - toss grenade is enemy gets in the way and is too close.
|
|
//=========================================================
|
|
bool CHAssassin::CheckRangeAttack2(float flDot, float flDist)
|
|
{
|
|
m_fThrowGrenade = false;
|
|
if (!FBitSet(m_hEnemy->pev->flags, FL_ONGROUND))
|
|
{
|
|
// don't throw grenades at anything that isn't on the ground!
|
|
return false;
|
|
}
|
|
|
|
// don't get grenade happy unless the player starts to piss you off
|
|
if (m_iFrustration <= 2)
|
|
return false;
|
|
|
|
if (m_flNextGrenadeCheck < gpGlobals->time && !HasConditions(bits_COND_ENEMY_OCCLUDED) && flDist <= 512 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */)
|
|
{
|
|
Vector vecToss = VecCheckThrow(pev, GetGunPosition(), m_hEnemy->Center(), flDist, 0.5); // use dist as speed to get there in 1 second
|
|
|
|
if (vecToss != g_vecZero)
|
|
{
|
|
m_vecTossVelocity = vecToss;
|
|
|
|
// throw a hand grenade
|
|
m_fThrowGrenade = true;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// RunAI
|
|
//=========================================================
|
|
void CHAssassin::RunAI()
|
|
{
|
|
CBaseMonster::RunAI();
|
|
|
|
// always visible if moving
|
|
// always visible is not on hard
|
|
if (g_iSkillLevel != SKILL_HARD || m_hEnemy == NULL || pev->deadflag != DEAD_NO || m_Activity == ACT_RUN || m_Activity == ACT_WALK || (pev->flags & FL_ONGROUND) == 0)
|
|
m_iTargetRanderamt = 255;
|
|
else
|
|
m_iTargetRanderamt = 20;
|
|
|
|
if (pev->renderamt > m_iTargetRanderamt)
|
|
{
|
|
if (pev->renderamt == 255)
|
|
{
|
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "debris/beamstart1.wav", 0.2, ATTN_NORM);
|
|
}
|
|
|
|
pev->renderamt = V_max(pev->renderamt - 50, m_iTargetRanderamt);
|
|
pev->rendermode = kRenderTransTexture;
|
|
}
|
|
else if (pev->renderamt < m_iTargetRanderamt)
|
|
{
|
|
pev->renderamt = V_min(pev->renderamt + 50, m_iTargetRanderamt);
|
|
if (pev->renderamt == 255)
|
|
pev->rendermode = kRenderNormal;
|
|
}
|
|
|
|
if (m_Activity == ACT_RUN || m_Activity == ACT_WALK)
|
|
{
|
|
static bool iStep = false;
|
|
iStep = !iStep;
|
|
if (iStep)
|
|
{
|
|
switch (RANDOM_LONG(0, 3))
|
|
{
|
|
case 0:
|
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_step1.wav", 0.5, ATTN_NORM);
|
|
break;
|
|
case 1:
|
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_step3.wav", 0.5, ATTN_NORM);
|
|
break;
|
|
case 2:
|
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_step2.wav", 0.5, ATTN_NORM);
|
|
break;
|
|
case 3:
|
|
EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_step4.wav", 0.5, ATTN_NORM);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// StartTask
|
|
//=========================================================
|
|
void CHAssassin::StartTask(Task_t* pTask)
|
|
{
|
|
switch (pTask->iTask)
|
|
{
|
|
case TASK_RANGE_ATTACK2:
|
|
if (!m_fThrowGrenade)
|
|
{
|
|
TaskComplete();
|
|
}
|
|
else
|
|
{
|
|
CBaseMonster::StartTask(pTask);
|
|
}
|
|
break;
|
|
case TASK_ASSASSIN_FALL_TO_GROUND:
|
|
break;
|
|
default:
|
|
CBaseMonster::StartTask(pTask);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// RunTask
|
|
//=========================================================
|
|
void CHAssassin::RunTask(Task_t* pTask)
|
|
{
|
|
switch (pTask->iTask)
|
|
{
|
|
case TASK_ASSASSIN_FALL_TO_GROUND:
|
|
MakeIdealYaw(m_vecEnemyLKP);
|
|
ChangeYaw(pev->yaw_speed);
|
|
|
|
if (m_fSequenceFinished)
|
|
{
|
|
if (pev->velocity.z > 0)
|
|
{
|
|
pev->sequence = LookupSequence("fly_up");
|
|
}
|
|
else if (HasConditions(bits_COND_SEE_ENEMY))
|
|
{
|
|
pev->sequence = LookupSequence("fly_attack");
|
|
pev->frame = 0;
|
|
}
|
|
else
|
|
{
|
|
pev->sequence = LookupSequence("fly_down");
|
|
pev->frame = 0;
|
|
}
|
|
|
|
ResetSequenceInfo();
|
|
SetYawSpeed();
|
|
}
|
|
if ((pev->flags & FL_ONGROUND) != 0)
|
|
{
|
|
// ALERT( at_console, "on ground\n");
|
|
TaskComplete();
|
|
}
|
|
break;
|
|
default:
|
|
CBaseMonster::RunTask(pTask);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// GetSchedule - Decides which type of schedule best suits
|
|
// the monster's current state and conditions. Then calls
|
|
// monster's member function to get a pointer to a schedule
|
|
// of the proper type.
|
|
//=========================================================
|
|
Schedule_t* CHAssassin::GetSchedule()
|
|
{
|
|
switch (m_MonsterState)
|
|
{
|
|
case MONSTERSTATE_IDLE:
|
|
case MONSTERSTATE_ALERT:
|
|
{
|
|
if (HasConditions(bits_COND_HEAR_SOUND))
|
|
{
|
|
CSound* pSound;
|
|
pSound = PBestSound();
|
|
|
|
ASSERT(pSound != NULL);
|
|
if (pSound && (pSound->m_iType & bits_SOUND_DANGER) != 0)
|
|
{
|
|
return GetScheduleOfType(SCHED_TAKE_COVER_FROM_BEST_SOUND);
|
|
}
|
|
if (pSound && (pSound->m_iType & bits_SOUND_COMBAT) != 0)
|
|
{
|
|
return GetScheduleOfType(SCHED_INVESTIGATE_SOUND);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MONSTERSTATE_COMBAT:
|
|
{
|
|
// dead enemy
|
|
if (HasConditions(bits_COND_ENEMY_DEAD))
|
|
{
|
|
// call base class, all code to handle dead enemies is centralized there.
|
|
return CBaseMonster::GetSchedule();
|
|
}
|
|
|
|
// flying?
|
|
if (pev->movetype == MOVETYPE_TOSS)
|
|
{
|
|
if ((pev->flags & FL_ONGROUND) != 0)
|
|
{
|
|
// ALERT( at_console, "landed\n");
|
|
// just landed
|
|
pev->movetype = MOVETYPE_STEP;
|
|
return GetScheduleOfType(SCHED_ASSASSIN_JUMP_LAND);
|
|
}
|
|
else
|
|
{
|
|
// ALERT( at_console, "jump\n");
|
|
// jump or jump/shoot
|
|
if (m_MonsterState == MONSTERSTATE_COMBAT)
|
|
return GetScheduleOfType(SCHED_ASSASSIN_JUMP);
|
|
else
|
|
return GetScheduleOfType(SCHED_ASSASSIN_JUMP_ATTACK);
|
|
}
|
|
}
|
|
|
|
if (HasConditions(bits_COND_HEAR_SOUND))
|
|
{
|
|
CSound* pSound;
|
|
pSound = PBestSound();
|
|
|
|
ASSERT(pSound != NULL);
|
|
if (pSound && (pSound->m_iType & bits_SOUND_DANGER) != 0)
|
|
{
|
|
return GetScheduleOfType(SCHED_TAKE_COVER_FROM_BEST_SOUND);
|
|
}
|
|
}
|
|
|
|
if (HasConditions(bits_COND_LIGHT_DAMAGE))
|
|
{
|
|
m_iFrustration++;
|
|
}
|
|
if (HasConditions(bits_COND_HEAVY_DAMAGE))
|
|
{
|
|
m_iFrustration++;
|
|
}
|
|
|
|
// jump player!
|
|
if (HasConditions(bits_COND_CAN_MELEE_ATTACK1))
|
|
{
|
|
// ALERT( at_console, "melee attack 1\n");
|
|
return GetScheduleOfType(SCHED_MELEE_ATTACK1);
|
|
}
|
|
|
|
// throw grenade
|
|
if (HasConditions(bits_COND_CAN_RANGE_ATTACK2))
|
|
{
|
|
// ALERT( at_console, "range attack 2\n");
|
|
return GetScheduleOfType(SCHED_RANGE_ATTACK2);
|
|
}
|
|
|
|
// spotted
|
|
if (HasConditions(bits_COND_SEE_ENEMY) && HasConditions(bits_COND_ENEMY_FACING_ME))
|
|
{
|
|
// ALERT( at_console, "exposed\n");
|
|
m_iFrustration++;
|
|
return GetScheduleOfType(SCHED_ASSASSIN_EXPOSED);
|
|
}
|
|
|
|
// can attack
|
|
if (HasConditions(bits_COND_CAN_RANGE_ATTACK1))
|
|
{
|
|
// ALERT( at_console, "range attack 1\n");
|
|
m_iFrustration = 0;
|
|
return GetScheduleOfType(SCHED_RANGE_ATTACK1);
|
|
}
|
|
|
|
if (HasConditions(bits_COND_SEE_ENEMY))
|
|
{
|
|
// ALERT( at_console, "face\n");
|
|
return GetScheduleOfType(SCHED_COMBAT_FACE);
|
|
}
|
|
|
|
// new enemy
|
|
if (HasConditions(bits_COND_NEW_ENEMY))
|
|
{
|
|
// ALERT( at_console, "take cover\n");
|
|
return GetScheduleOfType(SCHED_TAKE_COVER_FROM_ENEMY);
|
|
}
|
|
|
|
// ALERT( at_console, "stand\n");
|
|
return GetScheduleOfType(SCHED_ALERT_STAND);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return CBaseMonster::GetSchedule();
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
Schedule_t* CHAssassin::GetScheduleOfType(int Type)
|
|
{
|
|
// ALERT( at_console, "%d\n", m_iFrustration );
|
|
switch (Type)
|
|
{
|
|
case SCHED_TAKE_COVER_FROM_ENEMY:
|
|
if (pev->health > 30)
|
|
return slAssassinTakeCoverFromEnemy;
|
|
else
|
|
return slAssassinTakeCoverFromEnemy2;
|
|
case SCHED_TAKE_COVER_FROM_BEST_SOUND:
|
|
return slAssassinTakeCoverFromBestSound;
|
|
case SCHED_ASSASSIN_EXPOSED:
|
|
return slAssassinExposed;
|
|
case SCHED_FAIL:
|
|
if (m_MonsterState == MONSTERSTATE_COMBAT)
|
|
return slAssassinFail;
|
|
break;
|
|
case SCHED_ALERT_STAND:
|
|
if (m_MonsterState == MONSTERSTATE_COMBAT)
|
|
return slAssassinHide;
|
|
break;
|
|
case SCHED_CHASE_ENEMY:
|
|
return slAssassinHunt;
|
|
case SCHED_MELEE_ATTACK1:
|
|
if ((pev->flags & FL_ONGROUND) != 0)
|
|
{
|
|
if (m_flNextJump > gpGlobals->time)
|
|
{
|
|
// can't jump yet, go ahead and fail
|
|
return slAssassinFail;
|
|
}
|
|
else
|
|
{
|
|
return slAssassinJump;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return slAssassinJumpAttack;
|
|
}
|
|
case SCHED_ASSASSIN_JUMP:
|
|
case SCHED_ASSASSIN_JUMP_ATTACK:
|
|
return slAssassinJumpAttack;
|
|
case SCHED_ASSASSIN_JUMP_LAND:
|
|
return slAssassinJumpLand;
|
|
}
|
|
|
|
return CBaseMonster::GetScheduleOfType(Type);
|
|
}
|