You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1050 lines
27 KiB
1050 lines
27 KiB
/*** |
|
* |
|
* 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. |
|
* |
|
****/ |
|
#ifndef OEM_BUILD |
|
|
|
#include "extdll.h" |
|
#include "util.h" |
|
#include "cbase.h" |
|
#include "monsters.h" |
|
#include "weapons.h" |
|
#include "nodes.h" |
|
#include "effects.h" |
|
|
|
extern DLL_GLOBAL int g_iSkillLevel; |
|
|
|
#define SF_WAITFORTRIGGER (0x04 | 0x40) // UNDONE: Fix! |
|
#define SF_NOWRECKAGE 0x08 |
|
|
|
class CApache : public CBaseMonster |
|
{ |
|
int Save( CSave &save ); |
|
int Restore( CRestore &restore ); |
|
static TYPEDESCRIPTION m_SaveData[]; |
|
|
|
void Spawn( void ); |
|
void Precache( void ); |
|
int Classify( void ) { return CLASS_HUMAN_MILITARY; }; |
|
int BloodColor( void ) { return DONT_BLEED; } |
|
void Killed( entvars_t *pevAttacker, int iGib ); |
|
void GibMonster( void ); |
|
|
|
void SetObjectCollisionBox( void ) |
|
{ |
|
pev->absmin = pev->origin + Vector( -300, -300, -172); |
|
pev->absmax = pev->origin + Vector(300, 300, 8); |
|
} |
|
|
|
void EXPORT HuntThink( void ); |
|
void EXPORT FlyTouch( CBaseEntity *pOther ); |
|
void EXPORT CrashTouch( CBaseEntity *pOther ); |
|
void EXPORT DyingThink( void ); |
|
void EXPORT StartupUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); |
|
void EXPORT NullThink( void ); |
|
|
|
void ShowDamage( void ); |
|
void Flight( void ); |
|
void FireRocket( void ); |
|
BOOL FireGun( void ); |
|
|
|
int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType ); |
|
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType); |
|
|
|
int m_iRockets; |
|
float m_flForce; |
|
float m_flNextRocket; |
|
|
|
Vector m_vecTarget; |
|
Vector m_posTarget; |
|
|
|
Vector m_vecDesired; |
|
Vector m_posDesired; |
|
|
|
Vector m_vecGoal; |
|
|
|
Vector m_angGun; |
|
float m_flLastSeen; |
|
float m_flPrevSeen; |
|
|
|
int m_iSoundState; // don't save this |
|
|
|
int m_iSpriteTexture; |
|
int m_iExplode; |
|
int m_iBodyGibs; |
|
|
|
float m_flGoalSpeed; |
|
|
|
int m_iDoSmokePuff; |
|
CBeam *m_pBeam; |
|
}; |
|
LINK_ENTITY_TO_CLASS( monster_apache, CApache ); |
|
|
|
TYPEDESCRIPTION CApache::m_SaveData[] = |
|
{ |
|
DEFINE_FIELD( CApache, m_iRockets, FIELD_INTEGER ), |
|
DEFINE_FIELD( CApache, m_flForce, FIELD_FLOAT ), |
|
DEFINE_FIELD( CApache, m_flNextRocket, FIELD_TIME ), |
|
DEFINE_FIELD( CApache, m_vecTarget, FIELD_VECTOR ), |
|
DEFINE_FIELD( CApache, m_posTarget, FIELD_POSITION_VECTOR ), |
|
DEFINE_FIELD( CApache, m_vecDesired, FIELD_VECTOR ), |
|
DEFINE_FIELD( CApache, m_posDesired, FIELD_POSITION_VECTOR ), |
|
DEFINE_FIELD( CApache, m_vecGoal, FIELD_VECTOR ), |
|
DEFINE_FIELD( CApache, m_angGun, FIELD_VECTOR ), |
|
DEFINE_FIELD( CApache, m_flLastSeen, FIELD_TIME ), |
|
DEFINE_FIELD( CApache, m_flPrevSeen, FIELD_TIME ), |
|
// DEFINE_FIELD( CApache, m_iSoundState, FIELD_INTEGER ), // Don't save, precached |
|
// DEFINE_FIELD( CApache, m_iSpriteTexture, FIELD_INTEGER ), |
|
// DEFINE_FIELD( CApache, m_iExplode, FIELD_INTEGER ), |
|
// DEFINE_FIELD( CApache, m_iBodyGibs, FIELD_INTEGER ), |
|
DEFINE_FIELD( CApache, m_pBeam, FIELD_CLASSPTR ), |
|
DEFINE_FIELD( CApache, m_flGoalSpeed, FIELD_FLOAT ), |
|
DEFINE_FIELD( CApache, m_iDoSmokePuff, FIELD_INTEGER ), |
|
}; |
|
IMPLEMENT_SAVERESTORE( CApache, CBaseMonster ); |
|
|
|
|
|
void CApache :: Spawn( void ) |
|
{ |
|
Precache( ); |
|
// motor |
|
pev->movetype = MOVETYPE_FLY; |
|
pev->solid = SOLID_BBOX; |
|
|
|
SET_MODEL(ENT(pev), "models/apache.mdl"); |
|
UTIL_SetSize( pev, Vector( -32, -32, -64 ), Vector( 32, 32, 0 ) ); |
|
UTIL_SetOrigin( pev, pev->origin ); |
|
|
|
pev->flags |= FL_MONSTER; |
|
pev->takedamage = DAMAGE_AIM; |
|
pev->health = gSkillData.apacheHealth; |
|
|
|
m_flFieldOfView = -0.707; // 270 degrees |
|
|
|
pev->sequence = 0; |
|
ResetSequenceInfo( ); |
|
pev->frame = RANDOM_LONG(0, 0xFF); |
|
|
|
InitBoneControllers(); |
|
|
|
if (pev->spawnflags & SF_WAITFORTRIGGER) |
|
{ |
|
SetUse( &StartupUse ); |
|
} |
|
else |
|
{ |
|
SetThink( &HuntThink ); |
|
SetTouch( &FlyTouch ); |
|
pev->nextthink = gpGlobals->time + 1.0; |
|
} |
|
|
|
m_iRockets = 10; |
|
} |
|
|
|
|
|
void CApache::Precache( void ) |
|
{ |
|
PRECACHE_MODEL("models/apache.mdl"); |
|
|
|
PRECACHE_SOUND("apache/ap_rotor1.wav"); |
|
PRECACHE_SOUND("apache/ap_rotor2.wav"); |
|
PRECACHE_SOUND("apache/ap_rotor3.wav"); |
|
PRECACHE_SOUND("apache/ap_whine1.wav"); |
|
|
|
PRECACHE_SOUND("weapons/mortarhit.wav"); |
|
|
|
m_iSpriteTexture = PRECACHE_MODEL( "sprites/white.spr" ); |
|
|
|
PRECACHE_SOUND("turret/tu_fire1.wav"); |
|
|
|
PRECACHE_MODEL("sprites/lgtning.spr"); |
|
|
|
m_iExplode = PRECACHE_MODEL( "sprites/fexplo.spr" ); |
|
m_iBodyGibs = PRECACHE_MODEL( "models/metalplategibs_green.mdl" ); |
|
|
|
UTIL_PrecacheOther( "hvr_rocket" ); |
|
} |
|
|
|
|
|
|
|
void CApache::NullThink( void ) |
|
{ |
|
StudioFrameAdvance( ); |
|
pev->nextthink = gpGlobals->time + 0.5; |
|
} |
|
|
|
|
|
void CApache::StartupUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) |
|
{ |
|
SetThink( &HuntThink ); |
|
SetTouch( &FlyTouch ); |
|
pev->nextthink = gpGlobals->time + 0.1; |
|
SetUse( NULL ); |
|
} |
|
|
|
void CApache :: Killed( entvars_t *pevAttacker, int iGib ) |
|
{ |
|
pev->movetype = MOVETYPE_TOSS; |
|
pev->gravity = 0.3; |
|
|
|
STOP_SOUND( ENT(pev), CHAN_STATIC, "apache/ap_rotor2.wav" ); |
|
|
|
UTIL_SetSize( pev, Vector( -32, -32, -64), Vector( 32, 32, 0) ); |
|
SetThink( &DyingThink ); |
|
SetTouch( &CrashTouch ); |
|
pev->nextthink = gpGlobals->time + 0.1; |
|
pev->health = 0; |
|
pev->takedamage = DAMAGE_NO; |
|
|
|
if (pev->spawnflags & SF_NOWRECKAGE) |
|
{ |
|
m_flNextRocket = gpGlobals->time + 4.0; |
|
} |
|
else |
|
{ |
|
m_flNextRocket = gpGlobals->time + 15.0; |
|
} |
|
} |
|
|
|
void CApache :: DyingThink( void ) |
|
{ |
|
StudioFrameAdvance( ); |
|
pev->nextthink = gpGlobals->time + 0.1; |
|
|
|
pev->avelocity = pev->avelocity * 1.02; |
|
|
|
// still falling? |
|
if (m_flNextRocket > gpGlobals->time ) |
|
{ |
|
// random explosions |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin ); |
|
WRITE_BYTE( TE_EXPLOSION); // This just makes a dynamic light now |
|
WRITE_COORD( pev->origin.x + RANDOM_FLOAT( -150, 150 )); |
|
WRITE_COORD( pev->origin.y + RANDOM_FLOAT( -150, 150 )); |
|
WRITE_COORD( pev->origin.z + RANDOM_FLOAT( -150, -50 )); |
|
WRITE_SHORT( g_sModelIndexFireball ); |
|
WRITE_BYTE( RANDOM_LONG(0,29) + 30 ); // scale * 10 |
|
WRITE_BYTE( 12 ); // framerate |
|
WRITE_BYTE( TE_EXPLFLAG_NONE ); |
|
MESSAGE_END(); |
|
|
|
// lots of smoke |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin ); |
|
WRITE_BYTE( TE_SMOKE ); |
|
WRITE_COORD( pev->origin.x + RANDOM_FLOAT( -150, 150 )); |
|
WRITE_COORD( pev->origin.y + RANDOM_FLOAT( -150, 150 )); |
|
WRITE_COORD( pev->origin.z + RANDOM_FLOAT( -150, -50 )); |
|
WRITE_SHORT( g_sModelIndexSmoke ); |
|
WRITE_BYTE( 100 ); // scale * 10 |
|
WRITE_BYTE( 10 ); // framerate |
|
MESSAGE_END(); |
|
|
|
Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5; |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot ); |
|
WRITE_BYTE( TE_BREAKMODEL); |
|
|
|
// position |
|
WRITE_COORD( vecSpot.x ); |
|
WRITE_COORD( vecSpot.y ); |
|
WRITE_COORD( vecSpot.z ); |
|
|
|
// size |
|
WRITE_COORD( 400 ); |
|
WRITE_COORD( 400 ); |
|
WRITE_COORD( 132 ); |
|
|
|
// velocity |
|
WRITE_COORD( pev->velocity.x ); |
|
WRITE_COORD( pev->velocity.y ); |
|
WRITE_COORD( pev->velocity.z ); |
|
|
|
// randomization |
|
WRITE_BYTE( 50 ); |
|
|
|
// Model |
|
WRITE_SHORT( m_iBodyGibs ); //model id# |
|
|
|
// # of shards |
|
WRITE_BYTE( 4 ); // let client decide |
|
|
|
// duration |
|
WRITE_BYTE( 30 );// 3.0 seconds |
|
|
|
// flags |
|
|
|
WRITE_BYTE( BREAK_METAL ); |
|
MESSAGE_END(); |
|
|
|
// don't stop it we touch a entity |
|
pev->flags &= ~FL_ONGROUND; |
|
pev->nextthink = gpGlobals->time + 0.2; |
|
return; |
|
} |
|
else |
|
{ |
|
Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5; |
|
|
|
/* |
|
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY ); |
|
WRITE_BYTE( TE_EXPLOSION); // This just makes a dynamic light now |
|
WRITE_COORD( vecSpot.x ); |
|
WRITE_COORD( vecSpot.y ); |
|
WRITE_COORD( vecSpot.z + 300 ); |
|
WRITE_SHORT( g_sModelIndexFireball ); |
|
WRITE_BYTE( 250 ); // scale * 10 |
|
WRITE_BYTE( 8 ); // framerate |
|
MESSAGE_END(); |
|
*/ |
|
|
|
// fireball |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot ); |
|
WRITE_BYTE( TE_SPRITE ); |
|
WRITE_COORD( vecSpot.x ); |
|
WRITE_COORD( vecSpot.y ); |
|
WRITE_COORD( vecSpot.z + 256 ); |
|
WRITE_SHORT( m_iExplode ); |
|
WRITE_BYTE( 120 ); // scale * 10 |
|
WRITE_BYTE( 255 ); // brightness |
|
MESSAGE_END(); |
|
|
|
// big smoke |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot ); |
|
WRITE_BYTE( TE_SMOKE ); |
|
WRITE_COORD( vecSpot.x ); |
|
WRITE_COORD( vecSpot.y ); |
|
WRITE_COORD( vecSpot.z + 512 ); |
|
WRITE_SHORT( g_sModelIndexSmoke ); |
|
WRITE_BYTE( 250 ); // scale * 10 |
|
WRITE_BYTE( 5 ); // framerate |
|
MESSAGE_END(); |
|
|
|
// blast circle |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin ); |
|
WRITE_BYTE( TE_BEAMCYLINDER ); |
|
WRITE_COORD( pev->origin.x); |
|
WRITE_COORD( pev->origin.y); |
|
WRITE_COORD( pev->origin.z); |
|
WRITE_COORD( pev->origin.x); |
|
WRITE_COORD( pev->origin.y); |
|
WRITE_COORD( pev->origin.z + 2000 ); // reach damage radius over .2 seconds |
|
WRITE_SHORT( m_iSpriteTexture ); |
|
WRITE_BYTE( 0 ); // startframe |
|
WRITE_BYTE( 0 ); // framerate |
|
WRITE_BYTE( 4 ); // life |
|
WRITE_BYTE( 32 ); // width |
|
WRITE_BYTE( 0 ); // noise |
|
WRITE_BYTE( 255 ); // r, g, b |
|
WRITE_BYTE( 255 ); // r, g, b |
|
WRITE_BYTE( 192 ); // r, g, b |
|
WRITE_BYTE( 128 ); // brightness |
|
WRITE_BYTE( 0 ); // speed |
|
MESSAGE_END(); |
|
|
|
EMIT_SOUND(ENT(pev), CHAN_STATIC, "weapons/mortarhit.wav", 1.0, 0.3); |
|
|
|
RadiusDamage( pev->origin, pev, pev, 300, CLASS_NONE, DMG_BLAST ); |
|
|
|
if (/*!(pev->spawnflags & SF_NOWRECKAGE) && */(pev->flags & FL_ONGROUND)) |
|
{ |
|
CBaseEntity *pWreckage = Create( "cycler_wreckage", pev->origin, pev->angles ); |
|
// SET_MODEL( ENT(pWreckage->pev), STRING(pev->model) ); |
|
UTIL_SetSize( pWreckage->pev, Vector( -200, -200, -128 ), Vector( 200, 200, -32 ) ); |
|
pWreckage->pev->frame = pev->frame; |
|
pWreckage->pev->sequence = pev->sequence; |
|
pWreckage->pev->framerate = 0; |
|
pWreckage->pev->dmgtime = gpGlobals->time + 5; |
|
} |
|
|
|
// gibs |
|
vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5; |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot ); |
|
WRITE_BYTE( TE_BREAKMODEL); |
|
|
|
// position |
|
WRITE_COORD( vecSpot.x ); |
|
WRITE_COORD( vecSpot.y ); |
|
WRITE_COORD( vecSpot.z + 64); |
|
|
|
// size |
|
WRITE_COORD( 400 ); |
|
WRITE_COORD( 400 ); |
|
WRITE_COORD( 128 ); |
|
|
|
// velocity |
|
WRITE_COORD( 0 ); |
|
WRITE_COORD( 0 ); |
|
WRITE_COORD( 200 ); |
|
|
|
// randomization |
|
WRITE_BYTE( 30 ); |
|
|
|
// Model |
|
WRITE_SHORT( m_iBodyGibs ); //model id# |
|
|
|
// # of shards |
|
WRITE_BYTE( 200 ); |
|
|
|
// duration |
|
WRITE_BYTE( 200 );// 10.0 seconds |
|
|
|
// flags |
|
|
|
WRITE_BYTE( BREAK_METAL ); |
|
MESSAGE_END(); |
|
|
|
SetThink( &SUB_Remove ); |
|
pev->nextthink = gpGlobals->time + 0.1; |
|
} |
|
} |
|
|
|
|
|
void CApache::FlyTouch( CBaseEntity *pOther ) |
|
{ |
|
// bounce if we hit something solid |
|
if ( pOther->pev->solid == SOLID_BSP) |
|
{ |
|
TraceResult tr = UTIL_GetGlobalTrace( ); |
|
|
|
// UNDONE, do a real bounce |
|
pev->velocity = pev->velocity + tr.vecPlaneNormal * (pev->velocity.Length() + 200); |
|
} |
|
} |
|
|
|
|
|
void CApache::CrashTouch( CBaseEntity *pOther ) |
|
{ |
|
// only crash if we hit something solid |
|
if ( pOther->pev->solid == SOLID_BSP) |
|
{ |
|
SetTouch( NULL ); |
|
m_flNextRocket = gpGlobals->time; |
|
pev->nextthink = gpGlobals->time; |
|
} |
|
} |
|
|
|
|
|
|
|
void CApache :: GibMonster( void ) |
|
{ |
|
// EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200); |
|
} |
|
|
|
|
|
void CApache :: HuntThink( void ) |
|
{ |
|
StudioFrameAdvance( ); |
|
pev->nextthink = gpGlobals->time + 0.1; |
|
|
|
ShowDamage( ); |
|
|
|
if ( m_pGoalEnt == NULL && !FStringNull(pev->target) )// this monster has a target |
|
{ |
|
m_pGoalEnt = UTIL_FindEntityByTargetname( NULL, STRING( pev->target ) ); |
|
if (m_pGoalEnt) |
|
{ |
|
m_posDesired = m_pGoalEnt->pev->origin; |
|
UTIL_MakeAimVectors( m_pGoalEnt->pev->angles ); |
|
m_vecGoal = gpGlobals->v_forward; |
|
} |
|
} |
|
|
|
// if (m_hEnemy == NULL) |
|
{ |
|
Look( 4092 ); |
|
m_hEnemy = BestVisibleEnemy( ); |
|
} |
|
|
|
// generic speed up |
|
if (m_flGoalSpeed < 800) |
|
m_flGoalSpeed += 5; |
|
|
|
if (m_hEnemy != NULL) |
|
{ |
|
// ALERT( at_console, "%s\n", STRING( m_hEnemy->pev->classname ) ); |
|
if (FVisible( m_hEnemy )) |
|
{ |
|
if (m_flLastSeen < gpGlobals->time - 5) |
|
m_flPrevSeen = gpGlobals->time; |
|
m_flLastSeen = gpGlobals->time; |
|
m_posTarget = m_hEnemy->Center( ); |
|
} |
|
else |
|
{ |
|
m_hEnemy = NULL; |
|
} |
|
} |
|
|
|
m_vecTarget = (m_posTarget - pev->origin).Normalize(); |
|
|
|
float flLength = (pev->origin - m_posDesired).Length(); |
|
|
|
if (m_pGoalEnt) |
|
{ |
|
// ALERT( at_console, "%.0f\n", flLength ); |
|
|
|
if (flLength < 128) |
|
{ |
|
m_pGoalEnt = UTIL_FindEntityByTargetname( NULL, STRING( m_pGoalEnt->pev->target ) ); |
|
if (m_pGoalEnt) |
|
{ |
|
m_posDesired = m_pGoalEnt->pev->origin; |
|
UTIL_MakeAimVectors( m_pGoalEnt->pev->angles ); |
|
m_vecGoal = gpGlobals->v_forward; |
|
flLength = (pev->origin - m_posDesired).Length(); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
m_posDesired = pev->origin; |
|
} |
|
|
|
if (flLength > 250) // 500 |
|
{ |
|
// float flLength2 = (m_posTarget - pev->origin).Length() * (1.5 - DotProduct((m_posTarget - pev->origin).Normalize(), pev->velocity.Normalize() )); |
|
// if (flLength2 < flLength) |
|
if (m_flLastSeen + 90 > gpGlobals->time && DotProduct( (m_posTarget - pev->origin).Normalize(), (m_posDesired - pev->origin).Normalize( )) > 0.25) |
|
{ |
|
m_vecDesired = (m_posTarget - pev->origin).Normalize( ); |
|
} |
|
else |
|
{ |
|
m_vecDesired = (m_posDesired - pev->origin).Normalize( ); |
|
} |
|
} |
|
else |
|
{ |
|
m_vecDesired = m_vecGoal; |
|
} |
|
|
|
Flight( ); |
|
|
|
// ALERT( at_console, "%.0f %.0f %.0f\n", gpGlobals->time, m_flLastSeen, m_flPrevSeen ); |
|
if ((m_flLastSeen + 1 > gpGlobals->time) && (m_flPrevSeen + 2 < gpGlobals->time)) |
|
{ |
|
if (FireGun( )) |
|
{ |
|
// slow down if we're fireing |
|
if (m_flGoalSpeed > 400) |
|
m_flGoalSpeed = 400; |
|
} |
|
|
|
// don't fire rockets and gun on easy mode |
|
if (g_iSkillLevel == SKILL_EASY) |
|
m_flNextRocket = gpGlobals->time + 10.0; |
|
} |
|
|
|
UTIL_MakeAimVectors( pev->angles ); |
|
Vector vecEst = (gpGlobals->v_forward * 800 + pev->velocity).Normalize( ); |
|
// ALERT( at_console, "%d %d %d %4.2f\n", pev->angles.x < 0, DotProduct( pev->velocity, gpGlobals->v_forward ) > -100, m_flNextRocket < gpGlobals->time, DotProduct( m_vecTarget, vecEst ) ); |
|
|
|
if ((m_iRockets % 2) == 1) |
|
{ |
|
FireRocket( ); |
|
m_flNextRocket = gpGlobals->time + 0.5; |
|
if (m_iRockets <= 0) |
|
{ |
|
m_flNextRocket = gpGlobals->time + 10; |
|
m_iRockets = 10; |
|
} |
|
} |
|
else if (pev->angles.x < 0 && DotProduct( pev->velocity, gpGlobals->v_forward ) > -100 && m_flNextRocket < gpGlobals->time) |
|
{ |
|
if (m_flLastSeen + 60 > gpGlobals->time) |
|
{ |
|
if (m_hEnemy != NULL) |
|
{ |
|
// make sure it's a good shot |
|
if (DotProduct( m_vecTarget, vecEst) > .965) |
|
{ |
|
TraceResult tr; |
|
|
|
UTIL_TraceLine( pev->origin, pev->origin + vecEst * 4096, ignore_monsters, edict(), &tr ); |
|
if ((tr.vecEndPos - m_posTarget).Length() < 512) |
|
FireRocket( ); |
|
} |
|
} |
|
else |
|
{ |
|
TraceResult tr; |
|
|
|
UTIL_TraceLine( pev->origin, pev->origin + vecEst * 4096, dont_ignore_monsters, edict(), &tr ); |
|
// just fire when close |
|
if ((tr.vecEndPos - m_posTarget).Length() < 512) |
|
FireRocket( ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
void CApache :: Flight( void ) |
|
{ |
|
// tilt model 5 degrees |
|
Vector vecAdj = Vector( 5.0, 0, 0 ); |
|
|
|
// estimate where I'll be facing in one seconds |
|
UTIL_MakeAimVectors( pev->angles + pev->avelocity * 2 + vecAdj); |
|
// Vector vecEst1 = pev->origin + pev->velocity + gpGlobals->v_up * m_flForce - Vector( 0, 0, 384 ); |
|
// float flSide = DotProduct( m_posDesired - vecEst1, gpGlobals->v_right ); |
|
|
|
float flSide = DotProduct( m_vecDesired, gpGlobals->v_right ); |
|
|
|
if (flSide < 0) |
|
{ |
|
if (pev->avelocity.y < 60) |
|
{ |
|
pev->avelocity.y += 8; // 9 * (3.0/2.0); |
|
} |
|
} |
|
else |
|
{ |
|
if (pev->avelocity.y > -60) |
|
{ |
|
pev->avelocity.y -= 8; // 9 * (3.0/2.0); |
|
} |
|
} |
|
pev->avelocity.y *= 0.98; |
|
|
|
// estimate where I'll be in two seconds |
|
UTIL_MakeAimVectors( pev->angles + pev->avelocity * 1 + vecAdj); |
|
Vector vecEst = pev->origin + pev->velocity * 2.0 + gpGlobals->v_up * m_flForce * 20 - Vector( 0, 0, 384 * 2 ); |
|
|
|
// add immediate force |
|
UTIL_MakeAimVectors( pev->angles + vecAdj); |
|
pev->velocity.x += gpGlobals->v_up.x * m_flForce; |
|
pev->velocity.y += gpGlobals->v_up.y * m_flForce; |
|
pev->velocity.z += gpGlobals->v_up.z * m_flForce; |
|
// add gravity |
|
pev->velocity.z -= 38.4; // 32ft/sec |
|
|
|
|
|
float flSpeed = pev->velocity.Length(); |
|
float flDir = DotProduct( Vector( gpGlobals->v_forward.x, gpGlobals->v_forward.y, 0 ), Vector( pev->velocity.x, pev->velocity.y, 0 ) ); |
|
if (flDir < 0) |
|
flSpeed = -flSpeed; |
|
|
|
float flDist = DotProduct( m_posDesired - vecEst, gpGlobals->v_forward ); |
|
|
|
// float flSlip = DotProduct( pev->velocity, gpGlobals->v_right ); |
|
float flSlip = -DotProduct( m_posDesired - vecEst, gpGlobals->v_right ); |
|
|
|
// fly sideways |
|
if (flSlip > 0) |
|
{ |
|
if (pev->angles.z > -30 && pev->avelocity.z > -15) |
|
pev->avelocity.z -= 4; |
|
else |
|
pev->avelocity.z += 2; |
|
} |
|
else |
|
{ |
|
|
|
if (pev->angles.z < 30 && pev->avelocity.z < 15) |
|
pev->avelocity.z += 4; |
|
else |
|
pev->avelocity.z -= 2; |
|
} |
|
|
|
// sideways drag |
|
pev->velocity.x = pev->velocity.x * (1.0 - fabs( gpGlobals->v_right.x ) * 0.05); |
|
pev->velocity.y = pev->velocity.y * (1.0 - fabs( gpGlobals->v_right.y ) * 0.05); |
|
pev->velocity.z = pev->velocity.z * (1.0 - fabs( gpGlobals->v_right.z ) * 0.05); |
|
|
|
// general drag |
|
pev->velocity = pev->velocity * 0.995; |
|
|
|
// apply power to stay correct height |
|
if (m_flForce < 80 && vecEst.z < m_posDesired.z) |
|
{ |
|
m_flForce += 12; |
|
} |
|
else if (m_flForce > 30) |
|
{ |
|
if (vecEst.z > m_posDesired.z) |
|
m_flForce -= 8; |
|
} |
|
|
|
// pitch forward or back to get to target |
|
if (flDist > 0 && flSpeed < m_flGoalSpeed /* && flSpeed < flDist */ && pev->angles.x + pev->avelocity.x > -40) |
|
{ |
|
// ALERT( at_console, "F " ); |
|
// lean forward |
|
pev->avelocity.x -= 12.0; |
|
} |
|
else if (flDist < 0 && flSpeed > -50 && pev->angles.x + pev->avelocity.x < 20) |
|
{ |
|
// ALERT( at_console, "B " ); |
|
// lean backward |
|
pev->avelocity.x += 12.0; |
|
} |
|
else if (pev->angles.x + pev->avelocity.x > 0) |
|
{ |
|
// ALERT( at_console, "f " ); |
|
pev->avelocity.x -= 4.0; |
|
} |
|
else if (pev->angles.x + pev->avelocity.x < 0) |
|
{ |
|
// ALERT( at_console, "b " ); |
|
pev->avelocity.x += 4.0; |
|
} |
|
|
|
// ALERT( at_console, "%.0f %.0f : %.0f %.0f : %.0f %.0f : %.0f\n", pev->origin.x, pev->velocity.x, flDist, flSpeed, pev->angles.x, pev->avelocity.x, m_flForce ); |
|
// ALERT( at_console, "%.0f %.0f : %.0f %0.f : %.0f\n", pev->origin.z, pev->velocity.z, vecEst.z, m_posDesired.z, m_flForce ); |
|
|
|
// make rotor, engine sounds |
|
if (m_iSoundState == 0) |
|
{ |
|
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_rotor2.wav", 1.0, 0.3, 0, 110 ); |
|
// EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_whine1.wav", 0.5, 0.2, 0, 110 ); |
|
|
|
m_iSoundState = SND_CHANGE_PITCH; // hack for going through level transitions |
|
} |
|
else |
|
{ |
|
CBaseEntity *pPlayer = NULL; |
|
|
|
pPlayer = UTIL_FindEntityByClassname( NULL, "player" ); |
|
// UNDONE: this needs to send different sounds to every player for multiplayer. |
|
if (pPlayer) |
|
{ |
|
|
|
float pitch = DotProduct( pev->velocity - pPlayer->pev->velocity, (pPlayer->pev->origin - pev->origin).Normalize() ); |
|
|
|
pitch = (int)(100 + pitch / 50.0); |
|
|
|
if (pitch > 250) |
|
pitch = 250; |
|
if (pitch < 50) |
|
pitch = 50; |
|
if (pitch == 100) |
|
pitch = 101; |
|
|
|
float flVol = (m_flForce / 100.0) + .1; |
|
if (flVol > 1.0) |
|
flVol = 1.0; |
|
|
|
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_rotor2.wav", 1.0, 0.3, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch); |
|
} |
|
// EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_whine1.wav", flVol, 0.2, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch); |
|
|
|
// ALERT( at_console, "%.0f %.2f\n", pitch, flVol ); |
|
} |
|
} |
|
|
|
|
|
void CApache :: FireRocket( void ) |
|
{ |
|
static float side = 1.0; |
|
static int count; |
|
|
|
if (m_iRockets <= 0) |
|
return; |
|
|
|
UTIL_MakeAimVectors( pev->angles ); |
|
Vector vecSrc = pev->origin + 1.5 * (gpGlobals->v_forward * 21 + gpGlobals->v_right * 70 * side + gpGlobals->v_up * -79); |
|
|
|
switch( m_iRockets % 5) |
|
{ |
|
case 0: vecSrc = vecSrc + gpGlobals->v_right * 10; break; |
|
case 1: vecSrc = vecSrc - gpGlobals->v_right * 10; break; |
|
case 2: vecSrc = vecSrc + gpGlobals->v_up * 10; break; |
|
case 3: vecSrc = vecSrc - gpGlobals->v_up * 10; break; |
|
case 4: break; |
|
} |
|
|
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc ); |
|
WRITE_BYTE( TE_SMOKE ); |
|
WRITE_COORD( vecSrc.x ); |
|
WRITE_COORD( vecSrc.y ); |
|
WRITE_COORD( vecSrc.z ); |
|
WRITE_SHORT( g_sModelIndexSmoke ); |
|
WRITE_BYTE( 20 ); // scale * 10 |
|
WRITE_BYTE( 12 ); // framerate |
|
MESSAGE_END(); |
|
|
|
CBaseEntity *pRocket = CBaseEntity::Create( "hvr_rocket", vecSrc, pev->angles, edict() ); |
|
if (pRocket) |
|
pRocket->pev->velocity = pev->velocity + gpGlobals->v_forward * 100; |
|
|
|
m_iRockets--; |
|
|
|
side = - side; |
|
} |
|
|
|
|
|
|
|
BOOL CApache :: FireGun( ) |
|
{ |
|
UTIL_MakeAimVectors( pev->angles ); |
|
|
|
Vector posGun, angGun; |
|
GetAttachment( 1, posGun, angGun ); |
|
|
|
Vector vecTarget = (m_posTarget - posGun).Normalize( ); |
|
|
|
Vector vecOut; |
|
|
|
vecOut.x = DotProduct( gpGlobals->v_forward, vecTarget ); |
|
vecOut.y = -DotProduct( gpGlobals->v_right, vecTarget ); |
|
vecOut.z = DotProduct( gpGlobals->v_up, vecTarget ); |
|
|
|
Vector angles = UTIL_VecToAngles (vecOut); |
|
|
|
angles.x = -angles.x; |
|
if (angles.y > 180) |
|
angles.y = angles.y - 360; |
|
if (angles.y < -180) |
|
angles.y = angles.y + 360; |
|
if (angles.x > 180) |
|
angles.x = angles.x - 360; |
|
if (angles.x < -180) |
|
angles.x = angles.x + 360; |
|
|
|
if (angles.x > m_angGun.x) |
|
m_angGun.x = min( angles.x, m_angGun.x + 12 ); |
|
if (angles.x < m_angGun.x) |
|
m_angGun.x = max( angles.x, m_angGun.x - 12 ); |
|
if (angles.y > m_angGun.y) |
|
m_angGun.y = min( angles.y, m_angGun.y + 12 ); |
|
if (angles.y < m_angGun.y) |
|
m_angGun.y = max( angles.y, m_angGun.y - 12 ); |
|
|
|
m_angGun.y = SetBoneController( 0, m_angGun.y ); |
|
m_angGun.x = SetBoneController( 1, m_angGun.x ); |
|
|
|
Vector posBarrel, angBarrel; |
|
GetAttachment( 0, posBarrel, angBarrel ); |
|
Vector vecGun = (posBarrel - posGun).Normalize( ); |
|
|
|
if (DotProduct( vecGun, vecTarget ) > 0.98) |
|
{ |
|
#if 1 |
|
FireBullets( 1, posGun, vecGun, VECTOR_CONE_4DEGREES, 8192, BULLET_MONSTER_12MM, 1 ); |
|
EMIT_SOUND(ENT(pev), CHAN_WEAPON, "turret/tu_fire1.wav", 1, 0.3); |
|
#else |
|
static float flNext; |
|
TraceResult tr; |
|
UTIL_TraceLine( posGun, posGun + vecGun * 8192, dont_ignore_monsters, ENT( pev ), &tr ); |
|
|
|
if (!m_pBeam) |
|
{ |
|
m_pBeam = CBeam::BeamCreate( "sprites/lgtning.spr", 80 ); |
|
m_pBeam->PointEntInit( pev->origin, entindex( ) ); |
|
m_pBeam->SetEndAttachment( 1 ); |
|
m_pBeam->SetColor( 255, 180, 96 ); |
|
m_pBeam->SetBrightness( 192 ); |
|
} |
|
|
|
if (flNext < gpGlobals->time) |
|
{ |
|
flNext = gpGlobals->time + 0.5; |
|
m_pBeam->SetStartPos( tr.vecEndPos ); |
|
} |
|
#endif |
|
return TRUE; |
|
} |
|
else |
|
{ |
|
if (m_pBeam) |
|
{ |
|
UTIL_Remove( m_pBeam ); |
|
m_pBeam = NULL; |
|
} |
|
} |
|
return FALSE; |
|
} |
|
|
|
|
|
|
|
void CApache :: ShowDamage( void ) |
|
{ |
|
if (m_iDoSmokePuff > 0 || RANDOM_LONG(0,99) > pev->health) |
|
{ |
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin ); |
|
WRITE_BYTE( TE_SMOKE ); |
|
WRITE_COORD( pev->origin.x ); |
|
WRITE_COORD( pev->origin.y ); |
|
WRITE_COORD( pev->origin.z - 32 ); |
|
WRITE_SHORT( g_sModelIndexSmoke ); |
|
WRITE_BYTE( RANDOM_LONG(0,9) + 20 ); // scale * 10 |
|
WRITE_BYTE( 12 ); // framerate |
|
MESSAGE_END(); |
|
} |
|
if (m_iDoSmokePuff > 0) |
|
m_iDoSmokePuff--; |
|
} |
|
|
|
|
|
int CApache :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType ) |
|
{ |
|
if (pevInflictor->owner == edict()) |
|
return 0; |
|
|
|
if (bitsDamageType & DMG_BLAST) |
|
{ |
|
flDamage *= 2; |
|
} |
|
|
|
/* |
|
if ( (bitsDamageType & DMG_BULLET) && flDamage > 50) |
|
{ |
|
// clip bullet damage at 50 |
|
flDamage = 50; |
|
} |
|
*/ |
|
|
|
// ALERT( at_console, "%.0f\n", flDamage ); |
|
return CBaseEntity::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType ); |
|
} |
|
|
|
|
|
|
|
void CApache::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) |
|
{ |
|
// ALERT( at_console, "%d %.0f\n", ptr->iHitgroup, flDamage ); |
|
|
|
// ignore blades |
|
if (ptr->iHitgroup == 6 && (bitsDamageType & (DMG_ENERGYBEAM|DMG_BULLET|DMG_CLUB))) |
|
return; |
|
|
|
// hit hard, hits cockpit, hits engines |
|
if (flDamage > 50 || ptr->iHitgroup == 1 || ptr->iHitgroup == 2) |
|
{ |
|
// ALERT( at_console, "%.0f\n", flDamage ); |
|
AddMultiDamage( pevAttacker, this, flDamage, bitsDamageType ); |
|
m_iDoSmokePuff = 3 + (flDamage / 5.0); |
|
} |
|
else |
|
{ |
|
// do half damage in the body |
|
// AddMultiDamage( pevAttacker, this, flDamage / 2.0, bitsDamageType ); |
|
UTIL_Ricochet( ptr->vecEndPos, 2.0 ); |
|
} |
|
} |
|
|
|
|
|
|
|
|
|
|
|
class CApacheHVR : public CGrenade |
|
{ |
|
void Spawn( void ); |
|
void Precache( void ); |
|
void EXPORT IgniteThink( void ); |
|
void EXPORT AccelerateThink( void ); |
|
|
|
int Save( CSave &save ); |
|
int Restore( CRestore &restore ); |
|
static TYPEDESCRIPTION m_SaveData[]; |
|
|
|
int m_iTrail; |
|
Vector m_vecForward; |
|
}; |
|
LINK_ENTITY_TO_CLASS( hvr_rocket, CApacheHVR ); |
|
|
|
TYPEDESCRIPTION CApacheHVR::m_SaveData[] = |
|
{ |
|
// DEFINE_FIELD( CApacheHVR, m_iTrail, FIELD_INTEGER ), // Dont' save, precache |
|
DEFINE_FIELD( CApacheHVR, m_vecForward, FIELD_VECTOR ), |
|
}; |
|
|
|
IMPLEMENT_SAVERESTORE( CApacheHVR, CGrenade ); |
|
|
|
void CApacheHVR :: Spawn( void ) |
|
{ |
|
Precache( ); |
|
// motor |
|
pev->movetype = MOVETYPE_FLY; |
|
pev->solid = SOLID_BBOX; |
|
|
|
SET_MODEL(ENT(pev), "models/HVR.mdl"); |
|
UTIL_SetSize(pev, Vector( 0, 0, 0), Vector(0, 0, 0)); |
|
UTIL_SetOrigin( pev, pev->origin ); |
|
|
|
SetThink( &IgniteThink ); |
|
SetTouch( &ExplodeTouch ); |
|
|
|
UTIL_MakeAimVectors( pev->angles ); |
|
m_vecForward = gpGlobals->v_forward; |
|
pev->gravity = 0.5; |
|
|
|
pev->nextthink = gpGlobals->time + 0.1; |
|
|
|
pev->dmg = 150; |
|
} |
|
|
|
|
|
void CApacheHVR :: Precache( void ) |
|
{ |
|
PRECACHE_MODEL("models/HVR.mdl"); |
|
m_iTrail = PRECACHE_MODEL("sprites/smoke.spr"); |
|
PRECACHE_SOUND ("weapons/rocket1.wav"); |
|
} |
|
|
|
|
|
void CApacheHVR :: IgniteThink( void ) |
|
{ |
|
// pev->movetype = MOVETYPE_TOSS; |
|
|
|
// pev->movetype = MOVETYPE_FLY; |
|
pev->effects |= EF_LIGHT; |
|
|
|
// make rocket sound |
|
EMIT_SOUND( ENT(pev), CHAN_VOICE, "weapons/rocket1.wav", 1, 0.5 ); |
|
|
|
// rocket trail |
|
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY ); |
|
|
|
WRITE_BYTE( TE_BEAMFOLLOW ); |
|
WRITE_SHORT(entindex()); // entity |
|
WRITE_SHORT(m_iTrail ); // model |
|
WRITE_BYTE( 15 ); // life |
|
WRITE_BYTE( 5 ); // width |
|
WRITE_BYTE( 224 ); // r, g, b |
|
WRITE_BYTE( 224 ); // r, g, b |
|
WRITE_BYTE( 255 ); // r, g, b |
|
WRITE_BYTE( 255 ); // brightness |
|
|
|
MESSAGE_END(); // move PHS/PVS data sending into here (SEND_ALL, SEND_PVS, SEND_PHS) |
|
|
|
// set to accelerate |
|
SetThink( &AccelerateThink ); |
|
pev->nextthink = gpGlobals->time + 0.1; |
|
} |
|
|
|
|
|
void CApacheHVR :: AccelerateThink( void ) |
|
{ |
|
// check world boundaries |
|
if (pev->origin.x < -4096 || pev->origin.x > 4096 || pev->origin.y < -4096 || pev->origin.y > 4096 || pev->origin.z < -4096 || pev->origin.z > 4096) |
|
{ |
|
UTIL_Remove( this ); |
|
return; |
|
} |
|
|
|
// accelerate |
|
float flSpeed = pev->velocity.Length(); |
|
if (flSpeed < 1800) |
|
{ |
|
pev->velocity = pev->velocity + m_vecForward * 200; |
|
} |
|
|
|
// re-aim |
|
pev->angles = UTIL_VecToAngles( pev->velocity ); |
|
|
|
pev->nextthink = gpGlobals->time + 0.1; |
|
} |
|
|
|
|
|
#endif |