FWGS
/
hlsdk-xash3d
mirror of https://github.com/FWGS/hlsdk-xash3d
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
hlsdk-xash3d/dlls/asheep/toad.cpp

732 lines
17 KiB
C++
Raw Blame History

/***
*
* 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.
*
* Use, distribution, and modification of this source code and/or resulting
* object code is restricted to non-commercial enhancements to products from
* Valve LLC. All other use, distribution, or modification is prohibited
* without written permission from Valve LLC.
*
****/
#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "weapons.h"
#include "nodes.h"
#include "player.h"
#include "soundent.h"
#include "gamerules.h"
enum w_toad_e {
WTOAD_IDLE1 = 0,
WTOAD_FIDGET,
WTOAD_JUMP,
WTOAD_RUN
};
enum toad_e {
TOAD_IDLE1 = 0,
TOAD_IDLE2,
TOAD_FIDGETFIT,
TOAD_FIDGETNIP,
TOAD_DOWN,
TOAD_UP,
TOAD_THROW
};
#ifndef CLIENT_DLL
class CToadGrenade : public CGrenade
{
void Spawn( void );
void Precache( void );
int Classify( void );
void EXPORT SuperBounceTouch( CBaseEntity *pOther );
void EXPORT HuntThink( void );
int BloodColor( void ) { return BLOOD_COLOR_YELLOW; }
void Killed( entvars_t *pevAttacker, int iGib );
void GibMonster( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
static float m_flNextBounceSoundTime;
// CBaseEntity *m_pTarget;
float m_flDie;
Vector m_vecTarget;
float m_flNextHunt;
float m_flNextHit;
Vector m_posPrev;
EHANDLE m_hOwner;
int m_iMyClass;
};
extern int gEvilImpulse101;
float CToadGrenade::m_flNextBounceSoundTime = 0;
LINK_ENTITY_TO_CLASS( monster_toad, CToadGrenade );
TYPEDESCRIPTION CToadGrenade::m_SaveData[] =
{
DEFINE_FIELD( CToadGrenade, m_flDie, FIELD_TIME ),
DEFINE_FIELD( CToadGrenade, m_vecTarget, FIELD_VECTOR ),
DEFINE_FIELD( CToadGrenade, m_flNextHunt, FIELD_TIME ),
DEFINE_FIELD( CToadGrenade, m_flNextHit, FIELD_TIME ),
DEFINE_FIELD( CToadGrenade, m_posPrev, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CToadGrenade, m_hOwner, FIELD_EHANDLE ),
};
IMPLEMENT_SAVERESTORE( CToadGrenade, CGrenade );
#define TOAD_DETONATE_DELAY 15.0
int CToadGrenade :: Classify ( void )
{
if (m_iMyClass != 0)
return m_iMyClass; // protect against recursion
if (m_hEnemy != NULL)
{
m_iMyClass = CLASS_INSECT; // no one cares about it
switch( m_hEnemy->Classify( ) )
{
case CLASS_PLAYER:
case CLASS_HUMAN_PASSIVE:
case CLASS_HUMAN_MILITARY:
m_iMyClass = 0;
return CLASS_ALIEN_MILITARY; // barney's get mad, grunts get mad at it
}
m_iMyClass = 0;
}
return CLASS_ALIEN_BIOWEAPON;
}
void CToadGrenade :: Spawn( void )
{
Precache( );
// motor
pev->movetype = MOVETYPE_BOUNCE;
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/w_toad.mdl");
UTIL_SetSize(pev, Vector( -4, -4, 0), Vector(4, 4, 8));
UTIL_SetOrigin( pev, pev->origin );
SetTouch( &CToadGrenade::SuperBounceTouch );
SetThink( &CToadGrenade::HuntThink );
pev->nextthink = gpGlobals->time + 0.1;
m_flNextHunt = gpGlobals->time + 1E6;
pev->flags |= FL_MONSTER;
pev->takedamage = DAMAGE_AIM;
pev->health = gSkillData.toadHealth;
pev->gravity = 0.5;
pev->friction = 0.5;
pev->dmg = gSkillData.toadDmgPop;
m_flDie = gpGlobals->time + TOAD_DETONATE_DELAY;
m_flFieldOfView = 0; // 180 degrees
if ( pev->owner )
m_hOwner = Instance( pev->owner );
m_flNextBounceSoundTime = gpGlobals->time;// reset each time a snark is spawned.
pev->sequence = WTOAD_RUN;
ResetSequenceInfo( );
}
void CToadGrenade::Precache( void )
{
PRECACHE_MODEL("models/w_toad.mdl");
PRECACHE_SOUND("toad/toad_blast1.wav");
PRECACHE_SOUND("common/bodysplat.wav");
PRECACHE_SOUND("toad/toad_die1.wav");
PRECACHE_SOUND("toad/toad_hunt1.wav");
PRECACHE_SOUND("toad/toad_hunt2.wav");
PRECACHE_SOUND("toad/toad_hunt3.wav");
PRECACHE_SOUND("toad/toad_deploy1.wav");
}
void CToadGrenade :: Killed( entvars_t *pevAttacker, int iGib )
{
pev->model = iStringNull;// make invisible
SetThink( &CToadGrenade::SUB_Remove );
// ResetTouch( );
SetTouch( NULL );
pev->nextthink = gpGlobals->time + 0.1;
// since toad grenades never leave a body behind, clear out their takedamage now.
// Squeaks do a bit of radius damage when they pop, and that radius damage will
// continue to call this function unless we acknowledge the Squeak's death now. (sjb)
pev->takedamage = DAMAGE_NO;
// play squeek blast
EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, "toad/toad_blast1.wav", 1, 0.5, 0, PITCH_NORM);
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, SMALL_EXPLOSION_VOLUME, 3.0 );
UTIL_BloodDrips( pev->origin, g_vecZero, BloodColor(), 80 );
if (m_hOwner != NULL)
RadiusDamage ( pev, m_hOwner->pev, pev->dmg, CLASS_NONE, DMG_BLAST );
else
RadiusDamage ( pev, pev, pev->dmg, CLASS_NONE, DMG_BLAST );
// reset owner so death message happens
if (m_hOwner != NULL)
pev->owner = m_hOwner->edict();
CBaseMonster :: Killed( pevAttacker, GIB_ALWAYS );
}
void CToadGrenade :: GibMonster( void )
{
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200);
}
void CToadGrenade::HuntThink( void )
{
// ALERT( at_console, "think\n" );
if (!IsInWorld())
{
// ResetTouch( );
SetTouch( NULL );
UTIL_Remove( this );
return;
}
StudioFrameAdvance( );
pev->nextthink = gpGlobals->time + 0.1;
// explode when ready
if (gpGlobals->time >= m_flDie)
{
g_vecAttackDir = pev->velocity.Normalize( );
pev->health = -1;
Killed( pev, 0 );
return;
}
// float
if (pev->waterlevel != 0)
{
if (pev->movetype == MOVETYPE_BOUNCE)
{
pev->movetype = MOVETYPE_FLY;
}
pev->velocity = pev->velocity * 0.9;
pev->velocity.z += 8.0;
}
else if (pev->movetype == MOVETYPE_FLY)
{
pev->movetype = MOVETYPE_BOUNCE;
}
// return if not time to hunt
if (m_flNextHunt > gpGlobals->time)
return;
m_flNextHunt = gpGlobals->time + 2.0;
CBaseEntity *pOther = NULL;
Vector vecDir;
TraceResult tr;
Vector vecFlat = pev->velocity;
vecFlat.z = 0;
vecFlat = vecFlat.Normalize( );
UTIL_MakeVectors( pev->angles );
if (m_hEnemy == NULL || !m_hEnemy->IsAlive())
{
// find target, bounce a bit towards it.
Look( 512 );
m_hEnemy = BestVisibleEnemy( );
}
// squeek if it's about time blow up
if ((m_flDie - gpGlobals->time <= 0.5) && (m_flDie - gpGlobals->time >= 0.3))
{
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_die1.wav", 1, ATTN_NORM, 0, 100 + RANDOM_LONG(0,0x3F));
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 256, 0.25 );
}
// higher pitch as squeeker gets closer to detonation time
float flpitch = 155.0 - 60.0 * ((m_flDie - gpGlobals->time) / TOAD_DETONATE_DELAY);
if (flpitch < 80)
flpitch = 80;
if (m_hEnemy != NULL)
{
if (FVisible( m_hEnemy ))
{
vecDir = m_hEnemy->EyePosition() - pev->origin;
m_vecTarget = vecDir.Normalize( );
}
float flVel = pev->velocity.Length();
float flAdj = 50.0 / (flVel + 10.0);
if (flAdj > 1.2)
flAdj = 1.2;
// ALERT( at_console, "think : enemy\n");
// ALERT( at_console, "%.0f %.2f %.2f %.2f\n", flVel, m_vecTarget.x, m_vecTarget.y, m_vecTarget.z );
pev->velocity = pev->velocity * flAdj + m_vecTarget * 300;
}
if (pev->flags & FL_ONGROUND)
{
pev->avelocity = Vector( 0, 0, 0 );
}
else
{
if (pev->avelocity == Vector( 0, 0, 0))
{
pev->avelocity.x = RANDOM_FLOAT( -100, 100 );
pev->avelocity.z = RANDOM_FLOAT( -100, 100 );
}
}
if ((pev->origin - m_posPrev).Length() < 1.0)
{
pev->velocity.x = RANDOM_FLOAT( -100, 100 );
pev->velocity.y = RANDOM_FLOAT( -100, 100 );
}
m_posPrev = pev->origin;
pev->angles = UTIL_VecToAngles( pev->velocity );
pev->angles.z = 0;
pev->angles.x = 0;
}
void CToadGrenade::SuperBounceTouch( CBaseEntity *pOther )
{
float flpitch;
TraceResult tr = UTIL_GetGlobalTrace( );
// don't hit the guy that launched this grenade
if ( pev->owner && pOther->edict() == pev->owner )
return;
// at least until we've bounced once
pev->owner = NULL;
pev->angles.x = 0;
pev->angles.z = 0;
// avoid bouncing too much
if (m_flNextHit > gpGlobals->time)
return;
// higher pitch as squeeker gets closer to detonation time
flpitch = 155.0 - 60.0 * ((m_flDie - gpGlobals->time) / TOAD_DETONATE_DELAY);
if ( pOther->pev->takedamage && m_flNextAttack < gpGlobals->time )
{
// attack!
// make sure it's me who has touched them
if (tr.pHit == pOther->edict())
{
// and it's not another toadgrenade
if (tr.pHit->v.modelindex != pev->modelindex)
{
// ALERT( at_console, "hit enemy\n");
ClearMultiDamage( );
pOther->TraceAttack(pev, gSkillData.toadDmgBite, gpGlobals->v_forward, &tr, DMG_SLASH );
if (m_hOwner != NULL)
ApplyMultiDamage( pev, m_hOwner->pev );
else
ApplyMultiDamage( pev, pev );
pev->dmg += gSkillData.toadDmgPop; // add more explosion damage
// m_flDie += 2.0; // add more life
// make bite sound
EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, "toad/toad_deploy1.wav", 1.0, ATTN_NORM, 0, (int)flpitch);
m_flNextAttack = gpGlobals->time + 0.5;
}
}
else
{
// ALERT( at_console, "been hit\n");
}
}
m_flNextHit = gpGlobals->time + 0.1;
m_flNextHunt = gpGlobals->time;
if ( g_pGameRules->IsMultiplayer() )
{
// in multiplayer, we limit how often snarks can make their bounce sounds to prevent overflows.
if ( gpGlobals->time < m_flNextBounceSoundTime )
{
// too soon!
return;
}
}
if (!(pev->flags & FL_ONGROUND))
{
// play bounce sound
float flRndSound = RANDOM_FLOAT ( 0 , 1 );
if ( flRndSound <= 0.33 )
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_hunt1.wav", 1, ATTN_NORM, 0, (int)flpitch);
else if (flRndSound <= 0.66)
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_hunt2.wav", 1, ATTN_NORM, 0, (int)flpitch);
else
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_hunt3.wav", 1, ATTN_NORM, 0, (int)flpitch);
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 256, 0.25 );
}
else
{
// skittering sound
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 100, 0.1 );
}
m_flNextBounceSoundTime = gpGlobals->time + 0.5;// half second.
}
#endif
LINK_ENTITY_TO_CLASS( weapon_toad, CToad );
void CToad::Spawn( )
{
Precache( );
m_iId = WEAPON_TOAD;
SET_MODEL(ENT(pev), "models/toad_nest.mdl");
FallInit();//get ready to fall down.
m_iDefaultAmmo = TOAD_DEFAULT_GIVE;
pev->sequence = 1;
pev->animtime = gpGlobals->time;
pev->framerate = 1.0;
SetThink( &CToad::ToadIdle );
pev->nextthink = gpGlobals->time + 0.2f;
m_flNextTrace = 0;
m_flNextHunt = 0;
m_flDie = 0;
}
void CToad::Precache( void )
{
PRECACHE_MODEL("models/toad_nest.mdl");
PRECACHE_MODEL("models/v_toad.mdl");
PRECACHE_MODEL("models/p_toad.mdl");
PRECACHE_SOUND("toad/toad_hunt2.wav");
PRECACHE_SOUND("toad/toad_hunt3.wav");
UTIL_PrecacheOther("monster_toad");
}
int CToad::GetItemInfo(ItemInfo *p)
{
p->pszName = STRING(pev->classname);
p->pszAmmo1 = "Toads";
p->iMaxAmmo1 = TOAD_MAX_CARRY;
p->pszAmmo2 = NULL;
p->iMaxAmmo2 = -1;
p->iMaxClip = WEAPON_NOCLIP;
p->iSlot = 4;
p->iPosition = 5;
p->iId = m_iId = WEAPON_TOAD;
p->iWeight = SNARK_WEIGHT;
p->iFlags = ITEM_FLAG_LIMITINWORLD | ITEM_FLAG_EXHAUSTIBLE;
return 1;
}
BOOL CToad::Deploy( )
{
if( !gEvilImpulse101 )
{
// play hunt sound
float flRndSound = RANDOM_FLOAT( 0, 1 );
if ( flRndSound <= 0.5 )
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_hunt2.wav", 1, ATTN_NORM, 0, 100);
else
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_hunt3.wav", 1, ATTN_NORM, 0, 100);
m_pPlayer->m_iWeaponVolume = QUIET_GUN_VOLUME;
}
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 1.1;
return DefaultDeploy( "models/v_toad.mdl", "models/p_toad.mdl", TOAD_UP, "toad" );
}
void CToad::Holster( int skiplocal /* = 0 */ )
{
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
if ( !m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] )
{
m_pPlayer->pev->weapons &= ~(1<<WEAPON_TOAD);
SetThink( &CToad::DestroyItem );
pev->nextthink = gpGlobals->time + 0.1;
return;
}
DefaultHolster( TOAD_DOWN, 1.5 );
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM);
}
void CToad::PrimaryAttack()
{
if( m_pPlayer->m_bIsHolster )
{
WeaponIdle();
return;
}
if ( m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] )
{
UTIL_MakeVectors( m_pPlayer->pev->v_angle );
TraceResult tr;
Vector trace_origin;
// HACK HACK: Ugly hacks to handle change in origin based on new physics code for players
// Move origin up if crouched and start trace a bit outside of body ( 20 units instead of 16 )
trace_origin = m_pPlayer->pev->origin;
if ( m_pPlayer->pev->flags & FL_DUCKING )
{
trace_origin = trace_origin - ( VEC_HULL_MIN - VEC_DUCK_HULL_MIN );
}
// find place to toss monster
UTIL_TraceLine( trace_origin + gpGlobals->v_forward * 20, trace_origin + gpGlobals->v_forward * 64, dont_ignore_monsters, NULL, &tr );
if ( tr.fAllSolid == 0 && tr.fStartSolid == 0 && tr.flFraction > 0.25 )
{
SendWeaponAnim( TOAD_THROW );
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
#ifndef CLIENT_DLL
CBaseEntity *pToad = CBaseEntity::Create( "monster_toad", tr.vecEndPos, m_pPlayer->pev->v_angle, m_pPlayer->edict() );
pToad->pev->velocity = gpGlobals->v_forward * 200 + m_pPlayer->pev->velocity;
#endif
// play hunt sound
float flRndSound = RANDOM_FLOAT ( 0 , 1 );
if ( flRndSound <= 0.5 )
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_hunt2.wav", 1, ATTN_NORM, 0, 105);
else
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "toad/toad_hunt3.wav", 1, ATTN_NORM, 0, 105);
m_pPlayer->m_iWeaponVolume = QUIET_GUN_VOLUME;
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;
m_fJustThrown = 1;
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.3;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 1.0;
}
}
}
void CToad::SecondaryAttack( void )
{
if( m_pPlayer->m_bIsHolster )
{
WeaponIdle();
return;
}
}
void CToad::WeaponIdle( void )
{
if( m_pPlayer->m_bIsHolster )
{
if( m_flTimeWeaponIdle <= UTIL_WeaponTimeBase() )
{
m_pPlayer->m_bIsHolster = FALSE;
Deploy();
}
return;
}
if ( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
if (m_fJustThrown)
{
m_fJustThrown = 0;
if ( !m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] )
{
RetireWeapon();
return;
}
SendWeaponAnim( TOAD_UP );
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
return;
}
int iAnim, iRand = RANDOM_LONG( 0, 5 );
switch( iRand )
{
case 0:
iAnim = TOAD_IDLE2;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 2.2f;
break;
case 1:
iAnim = TOAD_FIDGETFIT;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 2.18f;
break;
case 2:
iAnim = TOAD_FIDGETNIP;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 2.9f;
break;
default:
iAnim = TOAD_IDLE1;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 2.2f;
break;
}
SendWeaponAnim( iAnim );
}
void CToad::ToadIdle()
{
int i;
float flDist;
CBaseEntity *pPlayer = UTIL_PlayerByIndex( 1 );
if( !pPlayer )
return;
flDist = ( pPlayer->Center() - this->Center() ).Length();
if( !pPlayer->FVisible( this ) || flDist >= 256.0f )
{
if( pev->sequence != 1 )
{
pev->sequence = 1;
pev->framerate = 0.5;
ResetSequenceInfo();
}
if( !RANDOM_LONG( 0, 10 ) )
HuntSound( true );
pev->nextthink = gpGlobals->time + 0.2f;
return;
}
if( flDist >= 50.0f )
{
TraceResult tr;
m_flDie = 1;
pev->movetype = MOVETYPE_STEP;
StudioFrameAdvance( 0.0 );
if( pev->sequence != 1 )
{
if( m_flNextTrace <= gpGlobals->time )
{
Vector vecSrc, vecEnd;
Vector vecDist2D = ( Center() - pPlayer->Center() ).Normalize();
vecDist2D.z = 0;
m_posNext = pev->origin + vecDist2D * 128;
vecSrc = EyePosition();
vecEnd = vecSrc + vecDist2D * 68;
UTIL_TraceLine( vecSrc, vecEnd, ignore_monsters, 0, &tr );
if( tr.flFraction < 1.0f )
{
Vector vecDist, vecForward, vecAngle;
vecDist = ( EyePosition() - tr.vecEndPos ).Normalize();
vecAngle = Vector( 0, UTIL_AngleMod( UTIL_VecToAngles( vecDist ).y ) + 195.0f, 0 );
UTIL_MakeVectorsPrivate( vecAngle, vecForward, 0, 0 );
m_posNext = pev->origin - vecForward * 128;
}
m_flNextTrace = gpGlobals->time + 0.5f;
}
Vector newPos = m_posNext - Center();
newPos.z = 0;
pev->angles = UTIL_VecToAngles( newPos );
UTIL_MoveToOrigin( ENT( pev ), newPos * 256.0f, 200.0f / m_flGroundSpeed, MOVE_STRAFE );
HuntSound( false );
pev->nextthink = gpGlobals->time + 0.2f;
return;
}
pev->sequence = 0;
pev->frame = 0;
ResetSequenceInfo();
pev->framerate = 3.0;
HuntSound( true );
pev->nextthink = gpGlobals->time + 0.2f;
return;
}
if( m_flDie == 1 )
{
for( i = 0; i < m_iDefaultAmmo; i++ )
( (CBasePlayer*)pPlayer )->GiveNamedItem( "weapon_toad" );
SetThink( &CBaseEntity::SUB_Remove );
pev->nextthink = gpGlobals->time + 0.1f;
}
}
void CToad::HuntSound( bool force )
{
const char *pszSound;
if( ( m_flNextHunt <= gpGlobals->time ) || force )
{
int iRand = RANDOM_LONG( 0, 2 );
if( iRand == 2 )
{
pszSound = "toad/toad_hunt3.wav";
}
else if( iRand == 1 )
{
pszSound = "toad/toad_hunt2.wav";
}
else
{
pszSound = "toad/toad_hunt1.wav";
}
EMIT_SOUND( ENT( pev ), CHAN_VOICE, pszSound, RANDOM_FLOAT( 0.5, 0.8 ), ATTN_NORM );
m_flNextHunt = gpGlobals->time + RANDOM_FLOAT( 3.0, 4.0 );
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink