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

Server format.

This commit is contained in:
Night Owl 2016-07-31 18:48:50 +05:00
parent 7b24b6a6db
commit 5890ff41ee
125 changed files with 20171 additions and 19881 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
dlls/activity.h
View File

@ -16,7 +16,6 @@
#ifndef ACTIVITY_H
#define ACTIVITY_H
typedef enum {
ACT_RESET = 0, // Set m_Activity to this invalid value to force a reset to m_IdealActivity
ACT_IDLE = 1,
@ -97,13 +96,11 @@ typedef enum {
ACT_FLINCH_RIGHTLEG
} Activity;
typedef struct {
typedef struct
{
int type;
char *name;
} activity_map_t;
extern activity_map_t activity_map[];
#endif //ACTIVITY_H

303
dlls/aflock.cpp
View File

@ -14,6 +14,7 @@
****/
//=========================================================
//=========================================================
#include "extdll.h"
#include "util.h"
#include "cbase.h"
@ -123,59 +124,59 @@ TYPEDESCRIPTION CFlockingFlyer::m_SaveData[] =
DEFINE_FIELD( CFlockingFlyer, m_flLastBlockedTime, FIELD_TIME ),
DEFINE_FIELD( CFlockingFlyer, m_flFakeBlockedTime, FIELD_TIME ),
DEFINE_FIELD( CFlockingFlyer, m_flAlertTime, FIELD_TIME ),
// DEFINE_FIELD( CFlockingFlyer, m_flFlockNextSoundTime, FIELD_TIME ), // don't need to save
//DEFINE_FIELD( CFlockingFlyer, m_flFlockNextSoundTime, FIELD_TIME ), // don't need to save
};
IMPLEMENT_SAVERESTORE( CFlockingFlyer, CBaseMonster )
//=========================================================
//=========================================================
void CFlockingFlyerFlock :: KeyValue( KeyValueData *pkvd )
void CFlockingFlyerFlock::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "iFlockSize"))
if( FStrEq( pkvd->szKeyName, "iFlockSize" ) )
{
m_cFlockSize = atoi(pkvd->szValue);
m_cFlockSize = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "flFlockRadius"))
else if( FStrEq( pkvd->szKeyName, "flFlockRadius" ) )
{
m_flFlockRadius = atof(pkvd->szValue);
m_flFlockRadius = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
}
//=========================================================
//=========================================================
void CFlockingFlyerFlock :: Spawn( )
void CFlockingFlyerFlock::Spawn()
{
Precache( );
Precache();
SpawnFlock();
REMOVE_ENTITY(ENT(pev)); // dump the spawn ent
REMOVE_ENTITY( ENT( pev ) ); // dump the spawn ent
}
//=========================================================
//=========================================================
void CFlockingFlyerFlock :: Precache( )
void CFlockingFlyerFlock::Precache()
{
//PRECACHE_MODEL("models/aflock.mdl");
PRECACHE_MODEL("models/boid.mdl");
//PRECACHE_MODEL( "models/aflock.mdl" );
PRECACHE_MODEL( "models/boid.mdl ");
PrecacheFlockSounds();
}
void CFlockingFlyerFlock :: PrecacheFlockSounds( void )
void CFlockingFlyerFlock::PrecacheFlockSounds( void )
{
PRECACHE_SOUND("boid/boid_alert1.wav" );
PRECACHE_SOUND("boid/boid_alert2.wav" );
PRECACHE_SOUND( "boid/boid_alert1.wav" );
PRECACHE_SOUND( "boid/boid_alert2.wav" );
PRECACHE_SOUND("boid/boid_idle1.wav" );
PRECACHE_SOUND("boid/boid_idle2.wav" );
PRECACHE_SOUND( "boid/boid_idle1.wav" );
PRECACHE_SOUND( "boid/boid_idle2.wav" );
}
//=========================================================
//=========================================================
void CFlockingFlyerFlock :: SpawnFlock( void )
void CFlockingFlyerFlock::SpawnFlock( void )
{
float R = m_flFlockRadius;
int iCount;
@ -184,11 +185,11 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
pLeader = pBoid = NULL;
for ( iCount = 0 ; iCount < m_cFlockSize ; iCount++ )
for( iCount = 0; iCount < m_cFlockSize; iCount++ )
{
pBoid = GetClassPtr( (CFlockingFlyer *)NULL );
if ( !pLeader )
if( !pLeader )
{
// make this guy the leader.
pLeader = pBoid;
@ -202,7 +203,7 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
vecSpot.z = RANDOM_FLOAT( 0, 16 );
vecSpot = pev->origin + vecSpot;
UTIL_SetOrigin(pBoid->pev, vecSpot);
UTIL_SetOrigin( pBoid->pev, vecSpot );
pBoid->pev->movetype = MOVETYPE_FLY;
pBoid->SpawnCommonCode();
pBoid->pev->flags &= ~FL_ONGROUND;
@ -211,9 +212,9 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
pBoid->pev->frame = 0;
pBoid->pev->nextthink = gpGlobals->time + 0.2;
pBoid->SetThink( &CFlockingFlyer :: IdleThink );
pBoid->SetThink( &CFlockingFlyer::IdleThink );
if ( pBoid != pLeader )
if( pBoid != pLeader )
{
pLeader->SquadAdd( pBoid );
}
@ -222,9 +223,9 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
//=========================================================
//=========================================================
void CFlockingFlyer :: Spawn( )
void CFlockingFlyer::Spawn()
{
Precache( );
Precache();
SpawnCommonCode();
pev->frame = 0;
@ -234,52 +235,60 @@ void CFlockingFlyer :: Spawn( )
//=========================================================
//=========================================================
void CFlockingFlyer :: Precache( )
void CFlockingFlyer::Precache()
{
//PRECACHE_MODEL("models/aflock.mdl");
PRECACHE_MODEL("models/boid.mdl");
//PRECACHE_MODEL( "models/aflock.mdl" );
PRECACHE_MODEL( "models/boid.mdl" );
CFlockingFlyerFlock::PrecacheFlockSounds();
}
//=========================================================
//=========================================================
void CFlockingFlyer :: MakeSound( void )
void CFlockingFlyer::MakeSound( void )
{
if ( m_flAlertTime > gpGlobals->time )
if( m_flAlertTime > gpGlobals->time )
{
// make agitated sounds
switch ( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_alert1.wav", 1, ATTN_NORM ); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_alert2.wav", 1, ATTN_NORM ); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "boid/boid_alert1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "boid/boid_alert2.wav", 1, ATTN_NORM );
break;
}
return;
}
// make normal sound
switch ( RANDOM_LONG( 0, 1 ) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle1.wav", 1, ATTN_NORM ); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle2.wav", 1, ATTN_NORM ); break;
case 0:
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "boid/boid_idle2.wav", 1, ATTN_NORM );
break;
}
}
//=========================================================
//=========================================================
void CFlockingFlyer :: Killed( entvars_t *pevAttacker, int iGib )
void CFlockingFlyer::Killed( entvars_t *pevAttacker, int iGib )
{
CFlockingFlyer *pSquad;
pSquad = (CFlockingFlyer *)m_pSquadLeader;
while ( pSquad )
while( pSquad )
{
pSquad->m_flAlertTime = gpGlobals->time + 15;
pSquad = (CFlockingFlyer *)pSquad->m_pSquadNext;
}
if ( m_pSquadLeader )
if( m_pSquadLeader )
{
m_pSquadLeader->SquadRemove( this );
}
@ -289,18 +298,18 @@ void CFlockingFlyer :: Killed( entvars_t *pevAttacker, int iGib )
pev->framerate = 0;
pev->effects = EF_NOINTERP;
UTIL_SetSize( pev, Vector(0,0,0), Vector(0,0,0) );
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
pev->movetype = MOVETYPE_TOSS;
SetThink( &CFlockingFlyer::FallHack );
pev->nextthink = gpGlobals->time + 0.1;
}
void CFlockingFlyer :: FallHack( void )
void CFlockingFlyer::FallHack( void )
{
if ( pev->flags & FL_ONGROUND )
if( pev->flags & FL_ONGROUND )
{
if ( !FClassnameIs ( pev->groundentity, "worldspawn" ) )
if( !FClassnameIs ( pev->groundentity, "worldspawn" ) )
{
pev->flags &= ~FL_ONGROUND;
pev->nextthink = gpGlobals->time + 0.1;
@ -315,10 +324,10 @@ void CFlockingFlyer :: FallHack( void )
//=========================================================
//=========================================================
void CFlockingFlyer :: SpawnCommonCode( )
void CFlockingFlyer::SpawnCommonCode()
{
pev->deadflag = DEAD_NO;
pev->classname = MAKE_STRING("monster_flyer");
pev->classname = MAKE_STRING( "monster_flyer" );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_FLY;
pev->takedamage = DAMAGE_NO;
@ -327,31 +336,34 @@ void CFlockingFlyer :: SpawnCommonCode( )
m_fPathBlocked = FALSE;// obstacles will be detected
m_flFieldOfView = 0.2;
//SET_MODEL(ENT(pev), "models/aflock.mdl");
SET_MODEL(ENT(pev), "models/boid.mdl");
//SET_MODEL( ENT( pev ), "models/aflock.mdl" );
SET_MODEL( ENT( pev ), "models/boid.mdl" );
// UTIL_SetSize(pev, Vector(0,0,0), Vector(0,0,0));
UTIL_SetSize(pev, Vector(-5,-5,0), Vector(5,5,2));
//UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
UTIL_SetSize( pev, Vector( -5, -5, 0 ), Vector( 5, 5, 2 ) );
}
//=========================================================
//=========================================================
void CFlockingFlyer :: BoidAdvanceFrame ( )
void CFlockingFlyer::BoidAdvanceFrame()
{
float flapspeed = (pev->speed - pev->armorvalue) / AFLOCK_ACCELERATE;
float flapspeed = ( pev->speed - pev->armorvalue ) / AFLOCK_ACCELERATE;
pev->armorvalue = pev->armorvalue * .8 + pev->speed * .2;
if (flapspeed < 0) flapspeed = -flapspeed;
if (flapspeed < 0.25) flapspeed = 0.25;
if (flapspeed > 1.9) flapspeed = 1.9;
if( flapspeed < 0 )
flapspeed = -flapspeed;
if( flapspeed < 0.25 )
flapspeed = 0.25;
if( flapspeed > 1.9 )
flapspeed = 1.9;
pev->framerate = flapspeed;
// lean
pev->avelocity.x = - (pev->angles.x + flapspeed * 5);
pev->avelocity.x = -( pev->angles.x + flapspeed * 5 );
// bank
pev->avelocity.z = - (pev->angles.z + pev->avelocity.y);
pev->avelocity.z = -( pev->angles.z + pev->avelocity.y );
// pev->framerate = flapspeed;
StudioFrameAdvance( 0.1 );
@ -359,12 +371,12 @@ void CFlockingFlyer :: BoidAdvanceFrame ( )
//=========================================================
//=========================================================
void CFlockingFlyer :: IdleThink( void )
void CFlockingFlyer::IdleThink( void )
{
pev->nextthink = gpGlobals->time + 0.2;
// see if there's a client in the same pvs as the monster
if ( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
if( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
{
SetThink( &CFlockingFlyer::Start );
pev->nextthink = gpGlobals->time + 0.1;
@ -374,11 +386,11 @@ void CFlockingFlyer :: IdleThink( void )
//=========================================================
// Start - player enters the pvs, so get things going.
//=========================================================
void CFlockingFlyer :: Start( void )
void CFlockingFlyer::Start( void )
{
pev->nextthink = gpGlobals->time + 0.1;
if ( IsLeader() )
if( IsLeader() )
{
SetThink( &CFlockingFlyer::FlockLeaderThink );
}
@ -386,24 +398,22 @@ void CFlockingFlyer :: Start( void )
{
SetThink( &CFlockingFlyer::FlockFollowerThink );
}
/*
Vector vecTakeOff;
vecTakeOff = Vector ( 0 , 0 , 0 );
vecTakeOff = Vector( 0, 0, 0 );
vecTakeOff.z = 50 + RANDOM_FLOAT ( 0, 100 );
vecTakeOff.x = 20 - RANDOM_FLOAT ( 0, 40);
vecTakeOff.y = 20 - RANDOM_FLOAT ( 0, 40);
vecTakeOff.z = 50 + RANDOM_FLOAT( 0, 100 );
vecTakeOff.x = 20 - RANDOM_FLOAT( 0, 40 );
vecTakeOff.y = 20 - RANDOM_FLOAT( 0, 40 );
pev->velocity = vecTakeOff;
pev->speed = pev->velocity.Length();
pev->sequence = 0;
*/
SetActivity ( ACT_FLY );
ResetSequenceInfo( );
BoidAdvanceFrame( );
SetActivity( ACT_FLY );
ResetSequenceInfo();
BoidAdvanceFrame();
pev->speed = AFLOCK_FLY_SPEED;// no delay!
}
@ -411,9 +421,9 @@ void CFlockingFlyer :: Start( void )
//=========================================================
// Leader boid calls this to form a flock from surrounding boids
//=========================================================
void CFlockingFlyer :: FormFlock( void )
void CFlockingFlyer::FormFlock( void )
{
if ( !InSquad() )
if( !InSquad() )
{
// I am my own leader
m_pSquadLeader = this;
@ -422,14 +432,14 @@ void CFlockingFlyer :: FormFlock( void )
CBaseEntity *pEntity = NULL;
while ((pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, AFLOCK_MAX_RECRUIT_RADIUS )) != NULL)
while( ( pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, AFLOCK_MAX_RECRUIT_RADIUS ) ) != NULL )
{
CBaseMonster *pRecruit = pEntity->MyMonsterPointer( );
CBaseMonster *pRecruit = pEntity->MyMonsterPointer();
if ( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_pCine )
if( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_pCine )
{
// Can we recruit this guy?
if ( FClassnameIs ( pRecruit->pev, "monster_flyer" ) )
if( FClassnameIs ( pRecruit->pev, "monster_flyer" ) )
{
squadCount++;
SquadAdd( (CFlockingFlyer *)pRecruit );
@ -445,18 +455,18 @@ void CFlockingFlyer :: FormFlock( void )
//=========================================================
// Searches for boids that are too close and pushes them away
//=========================================================
void CFlockingFlyer :: SpreadFlock( )
void CFlockingFlyer::SpreadFlock()
{
Vector vecDir;
float flSpeed;// holds vector magnitude while we fiddle with the direction
CFlockingFlyer *pList = m_pSquadLeader;
while ( pList )
while( pList )
{
if ( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
if( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
{
// push the other away
vecDir = ( pList->pev->origin - pev->origin );
vecDir = pList->pev->origin - pev->origin;
vecDir = vecDir.Normalize();
// store the magnitude of the other boid's velocity, and normalize it so we
@ -476,19 +486,19 @@ void CFlockingFlyer :: SpreadFlock( )
//
// This function should **ONLY** be called when Caller's velocity is normalized!!
//=========================================================
void CFlockingFlyer :: SpreadFlock2 ( )
void CFlockingFlyer::SpreadFlock2()
{
Vector vecDir;
CFlockingFlyer *pList = m_pSquadLeader;
while ( pList )
while( pList )
{
if ( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
if( pList != this && ( pev->origin - pList->pev->origin ).Length() <= AFLOCK_TOO_CLOSE )
{
vecDir = ( pev->origin - pList->pev->origin );
vecDir = pev->origin - pList->pev->origin;
vecDir = vecDir.Normalize();
pev->velocity = (pev->velocity + vecDir);
pev->velocity = pev->velocity + vecDir;
}
pList = pList->m_pSquadNext;
@ -498,14 +508,14 @@ void CFlockingFlyer :: SpreadFlock2 ( )
//=========================================================
// FBoidPathBlocked - returns TRUE if there is an obstacle ahead
//=========================================================
BOOL CFlockingFlyer :: FPathBlocked( )
BOOL CFlockingFlyer::FPathBlocked()
{
TraceResult tr;
Vector vecDist;// used for general measurements
Vector vecDir;// used for general measurements
BOOL fBlocked;
if ( m_flFakeBlockedTime > gpGlobals->time )
if( m_flFakeBlockedTime > gpGlobals->time )
{
m_flLastBlockedTime = gpGlobals->time;
return TRUE;
@ -518,32 +528,32 @@ BOOL CFlockingFlyer :: FPathBlocked( )
fBlocked = FALSE;// assume the way ahead is clear
// check for obstacle ahead
UTIL_TraceLine(pev->origin, pev->origin + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( pev->origin, pev->origin + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
m_flLastBlockedTime = gpGlobals->time;
fBlocked = TRUE;
}
// extra wide checks
UTIL_TraceLine(pev->origin + gpGlobals->v_right * 12, pev->origin + gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( pev->origin + gpGlobals->v_right * 12, pev->origin + gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
m_flLastBlockedTime = gpGlobals->time;
fBlocked = TRUE;
}
UTIL_TraceLine(pev->origin - gpGlobals->v_right * 12, pev->origin - gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( pev->origin - gpGlobals->v_right * 12, pev->origin - gpGlobals->v_right * 12 + gpGlobals->v_forward * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
m_flLastBlockedTime = gpGlobals->time;
fBlocked = TRUE;
}
if ( !fBlocked && gpGlobals->time - m_flLastBlockedTime > 6 )
if( !fBlocked && gpGlobals->time - m_flLastBlockedTime > 6 )
{
// not blocked, and it's been a few seconds since we've actually been blocked.
m_flFakeBlockedTime = gpGlobals->time + RANDOM_LONG(1, 3);
m_flFakeBlockedTime = gpGlobals->time + RANDOM_LONG( 1, 3 );
}
return fBlocked;
@ -552,7 +562,7 @@ BOOL CFlockingFlyer :: FPathBlocked( )
//=========================================================
// Leader boids use this think every tenth
//=========================================================
void CFlockingFlyer :: FlockLeaderThink( void )
void CFlockingFlyer::FlockLeaderThink( void )
{
TraceResult tr;
Vector vecDist;// used for general measurements
@ -561,16 +571,15 @@ void CFlockingFlyer :: FlockLeaderThink( void )
float flLeftSide;
float flRightSide;
pev->nextthink = gpGlobals->time + 0.1;
UTIL_MakeVectors ( pev->angles );
UTIL_MakeVectors( pev->angles );
// is the way ahead clear?
if ( !FPathBlocked () )
if( !FPathBlocked () )
{
// if the boid is turning, stop the trend.
if ( m_fTurning )
if( m_fTurning )
{
m_fTurning = FALSE;
pev->avelocity.y = 0;
@ -578,12 +587,12 @@ void CFlockingFlyer :: FlockLeaderThink( void )
m_fPathBlocked = FALSE;
if (pev->speed <= AFLOCK_FLY_SPEED )
pev->speed+= 5;
if( pev->speed <= AFLOCK_FLY_SPEED )
pev->speed += 5;
pev->velocity = gpGlobals->v_forward * pev->speed;
BoidAdvanceFrame( );
BoidAdvanceFrame();
return;
}
@ -591,25 +600,25 @@ void CFlockingFlyer :: FlockLeaderThink( void )
// IF we get this far in the function, the leader's path is blocked!
m_fPathBlocked = TRUE;
if ( !m_fTurning)// something in the way and boid is not already turning to avoid
if( !m_fTurning )// something in the way and boid is not already turning to avoid
{
// measure clearance on left and right to pick the best dir to turn
UTIL_TraceLine(pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
vecDist = (tr.vecEndPos - pev->origin);
UTIL_TraceLine( pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
vecDist = ( tr.vecEndPos - pev->origin );
flRightSide = vecDist.Length();
UTIL_TraceLine(pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
vecDist = (tr.vecEndPos - pev->origin);
UTIL_TraceLine( pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
vecDist = tr.vecEndPos - pev->origin;
flLeftSide = vecDist.Length();
// turn right if more clearance on right side
if ( flRightSide > flLeftSide )
if( flRightSide > flLeftSide )
{
pev->avelocity.y = -AFLOCK_TURN_RATE;
m_fTurning = TRUE;
}
// default to left turn :)
else if ( flLeftSide > flRightSide )
else if( flLeftSide > flRightSide )
{
pev->avelocity.y = AFLOCK_TURN_RATE;
m_fTurning = TRUE;
@ -619,7 +628,7 @@ void CFlockingFlyer :: FlockLeaderThink( void )
// equidistant. Pick randomly between left and right.
m_fTurning = TRUE;
if ( RANDOM_LONG( 0, 1 ) == 0 )
if( RANDOM_LONG( 0, 1 ) == 0 )
{
pev->avelocity.y = AFLOCK_TURN_RATE;
}
@ -629,23 +638,23 @@ void CFlockingFlyer :: FlockLeaderThink( void )
}
}
}
SpreadFlock( );
SpreadFlock();
pev->velocity = gpGlobals->v_forward * pev->speed;
// check and make sure we aren't about to plow into the ground, don't let it happen
UTIL_TraceLine(pev->origin, pev->origin - gpGlobals->v_up * 16, ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0 && pev->velocity.z < 0 )
UTIL_TraceLine( pev->origin, pev->origin - gpGlobals->v_up * 16, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 && pev->velocity.z < 0 )
pev->velocity.z = 0;
// maybe it did, though.
if ( FBitSet (pev->flags, FL_ONGROUND) )
if( FBitSet( pev->flags, FL_ONGROUND ) )
{
UTIL_SetOrigin (pev, pev->origin + Vector ( 0 , 0 , 1 ) );
UTIL_SetOrigin( pev, pev->origin + Vector( 0, 0, 1 ) );
pev->velocity.z = 0;
}
if ( m_flFlockNextSoundTime < gpGlobals->time )
if( m_flFlockNextSoundTime < gpGlobals->time )
{
MakeSound();
m_flFlockNextSoundTime = gpGlobals->time + RANDOM_FLOAT( 1, 3 );
@ -659,7 +668,7 @@ void CFlockingFlyer :: FlockLeaderThink( void )
//=========================================================
// follower boids execute this code when flocking
//=========================================================
void CFlockingFlyer :: FlockFollowerThink( void )
void CFlockingFlyer::FlockFollowerThink( void )
{
TraceResult tr;
Vector vecDist;
@ -669,7 +678,7 @@ void CFlockingFlyer :: FlockFollowerThink( void )
pev->nextthink = gpGlobals->time + 0.1;
if ( IsLeader() || !InSquad() )
if( IsLeader() || !InSquad() )
{
// the leader has been killed and this flyer suddenly finds himself the leader.
SetThink( &CFlockingFlyer::FlockLeaderThink );
@ -685,16 +694,16 @@ void CFlockingFlyer :: FlockFollowerThink( void )
//
// We can see the leader, so try to catch up to it
//
if ( FInViewCone ( m_pSquadLeader ) )
if( FInViewCone ( m_pSquadLeader ) )
{
// if we're too far away, speed up
if ( flDistToLeader > AFLOCK_TOO_FAR )
if( flDistToLeader > AFLOCK_TOO_FAR )
{
m_flGoalSpeed = m_pSquadLeader->pev->velocity.Length() * 1.5;
}
// if we're too close, slow down
else if ( flDistToLeader < AFLOCK_TOO_CLOSE )
else if( flDistToLeader < AFLOCK_TOO_CLOSE )
{
m_flGoalSpeed = m_pSquadLeader->pev->velocity.Length() * 0.5;
}
@ -711,23 +720,23 @@ void CFlockingFlyer :: FlockFollowerThink( void )
pev->velocity = pev->velocity.Normalize();
// if we are too far from leader, average a vector towards it into our current velocity
if ( flDistToLeader > AFLOCK_TOO_FAR )
if( flDistToLeader > AFLOCK_TOO_FAR )
{
vecDirToLeader = vecDirToLeader.Normalize();
pev->velocity = (pev->velocity + vecDirToLeader) * 0.5;
}
// clamp speeds and handle acceleration
if ( m_flGoalSpeed > AFLOCK_FLY_SPEED * 2 )
if( m_flGoalSpeed > AFLOCK_FLY_SPEED * 2 )
{
m_flGoalSpeed = AFLOCK_FLY_SPEED * 2;
}
if ( pev->speed < m_flGoalSpeed )
if( pev->speed < m_flGoalSpeed )
{
pev->speed += AFLOCK_ACCELERATE;
}
else if ( pev->speed > m_flGoalSpeed )
else if( pev->speed > m_flGoalSpeed )
{
pev->speed -= AFLOCK_ACCELERATE;
}
@ -739,11 +748,11 @@ void CFlockingFlyer :: FlockFollowerThink( void )
/*
// Is this boid's course blocked?
if ( FBoidPathBlocked (pev) )
if( FBoidPathBlocked( pev ) )
{
// course is still blocked from last time. Just keep flying along adjusted
// velocity
if ( m_fCourseAdjust )
if( m_fCourseAdjust )
{
pev->velocity = m_vecAdjustedVelocity * pev->speed;
return;
@ -754,21 +763,21 @@ void CFlockingFlyer :: FlockFollowerThink( void )
// use VELOCITY, not angles, not all boids point the direction they are flying
//vecDir = UTIL_VecToAngles( pev->velocity );
//UTIL_MakeVectors ( vecDir );
//UTIL_MakeVectors( vecDir );
UTIL_MakeVectors ( pev->angles );
UTIL_MakeVectors( pev->angles );
// measure clearance on left and right to pick the best dir to turn
UTIL_TraceLine(pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
vecDist = (tr.vecEndPos - pev->origin);
UTIL_TraceLine( pev->origin, pev->origin + gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
vecDist = tr.vecEndPos - pev->origin;
flRightSide = vecDist.Length();
UTIL_TraceLine(pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT(pev), &tr);
vecDist = (tr.vecEndPos - pev->origin);
UTIL_TraceLine( pev->origin, pev->origin - gpGlobals->v_right * AFLOCK_CHECK_DIST, ignore_monsters, ENT( pev ), &tr );
vecDist = tr.vecEndPos - pev->origin;
flLeftSide = vecDist.Length();
// slide right if more clearance on right side
if ( flRightSide > flLeftSide )
if( flRightSide > flLeftSide )
{
m_vecAdjustedVelocity = gpGlobals->v_right;
}
@ -790,7 +799,7 @@ void CFlockingFlyer :: FlockFollowerThink( void )
// SquadUnlink(), Unlink the squad pointers.
//
//=========================================================
void CFlockingFlyer :: SquadUnlink( void )
void CFlockingFlyer::SquadUnlink( void )
{
m_pSquadLeader = NULL;
m_pSquadNext = NULL;
@ -801,9 +810,9 @@ void CFlockingFlyer :: SquadUnlink( void )
// SquadAdd(), add pAdd to my squad
//
//=========================================================
void CFlockingFlyer :: SquadAdd( CFlockingFlyer *pAdd )
void CFlockingFlyer::SquadAdd( CFlockingFlyer *pAdd )
{
ASSERT( pAdd!=NULL );
ASSERT( pAdd != NULL );
ASSERT( !pAdd->InSquad() );
ASSERT( this->IsLeader() );
@ -818,27 +827,27 @@ void CFlockingFlyer :: SquadAdd( CFlockingFlyer *pAdd )
// If I am pRemove, promote m_pSquadNext to leader
//
//=========================================================
void CFlockingFlyer :: SquadRemove( CFlockingFlyer *pRemove )
void CFlockingFlyer::SquadRemove( CFlockingFlyer *pRemove )
{
ASSERT( pRemove!=NULL );
ASSERT( pRemove != NULL );
ASSERT( this->IsLeader() );
ASSERT( pRemove->m_pSquadLeader == this );
if ( SquadCount() > 2 )
if( SquadCount() > 2 )
{
// Removing the leader, promote m_pSquadNext to leader
if ( pRemove == this )
if( pRemove == this )
{
CFlockingFlyer *pLeader = m_pSquadNext;
// copy the enemy LKP to the new leader
pLeader->m_vecEnemyLKP = m_vecEnemyLKP;
if ( pLeader )
if( pLeader )
{
CFlockingFlyer *pList = pLeader;
while ( pList )
while( pList )
{
pList->m_pSquadLeader = pLeader;
pList = pList->m_pSquadNext;
@ -852,7 +861,7 @@ void CFlockingFlyer :: SquadRemove( CFlockingFlyer *pRemove )
CFlockingFlyer *pList = this;
// Find the node before pRemove
while ( pList->m_pSquadNext != pRemove )
while( pList->m_pSquadNext != pRemove )
{
// assert to test valid list construction
ASSERT( pList->m_pSquadNext != NULL );
@ -878,11 +887,11 @@ void CFlockingFlyer :: SquadRemove( CFlockingFlyer *pRemove )
// callable from leaders & followers
//
//=========================================================
int CFlockingFlyer :: SquadCount( void )
int CFlockingFlyer::SquadCount( void )
{
CFlockingFlyer *pList = m_pSquadLeader;
int squadCount = 0;
while ( pList )
while( pList )
{
squadCount++;
pList = pList->m_pSquadNext;
@ -896,12 +905,12 @@ int CFlockingFlyer :: SquadCount( void )
// SquadDisband(), Unlink all squad members
//
//=========================================================
void CFlockingFlyer :: SquadDisband( void )
void CFlockingFlyer::SquadDisband( void )
{
CFlockingFlyer *pList = m_pSquadLeader;
CFlockingFlyer *pNext;
while ( pList )
while( pList )
{
pNext = pList->m_pSquadNext;
pList->SquadUnlink();

374
dlls/agrunt.cpp
View File

@ -64,8 +64,6 @@ int iAgruntMuzzleFlash;
#define AGRUNT_AE_LEFT_PUNCH ( 12 )
#define AGRUNT_AE_RIGHT_PUNCH ( 13 )
#define AGRUNT_MELEE_DIST 100
class CAGrunt : public CSquadMonster
@ -73,9 +71,9 @@ class CAGrunt : public CSquadMonster
public:
void Spawn( void );
void Precache( void );
void SetYawSpeed ( void );
int Classify ( void );
int ISoundMask ( void );
void SetYawSpeed( void );
int Classify( void );
int ISoundMask( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
void SetObjectCollisionBox( void )
{
@ -83,20 +81,20 @@ public:
pev->absmax = pev->origin + Vector( 32, 32, 85 );
}
Schedule_t* GetSchedule ( void );
Schedule_t* GetScheduleOfType ( int Type );
BOOL FCanCheckAttacks ( void );
BOOL CheckMeleeAttack1 ( float flDot, float flDist );
BOOL CheckRangeAttack1 ( float flDot, float flDist );
void StartTask ( Task_t *pTask );
Schedule_t *GetSchedule( void );
Schedule_t *GetScheduleOfType( int Type );
BOOL FCanCheckAttacks( void );
BOOL CheckMeleeAttack1( float flDot, float flDist );
BOOL CheckRangeAttack1( float flDot, float flDist );
void StartTask( Task_t *pTask );
void AlertSound( void );
void DeathSound ( void );
void PainSound ( void );
void AttackSound ( void );
void PrescheduleThink ( void );
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
void DeathSound( void );
void PainSound( void );
void AttackSound( void );
void PrescheduleThink( void );
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
int IRelationship( CBaseEntity *pTarget );
void StopTalking ( void );
void StopTalking( void );
BOOL ShouldSpeak( void );
CUSTOM_SCHEDULES
@ -193,42 +191,39 @@ const char *CAGrunt::pAlertSounds[] =
// IRelationship - overridden because Human Grunts are
// Alien Grunt's nemesis.
//=========================================================
int CAGrunt::IRelationship ( CBaseEntity *pTarget )
int CAGrunt::IRelationship( CBaseEntity *pTarget )
{
if ( FClassnameIs( pTarget->pev, "monster_human_grunt" ) )
if( FClassnameIs( pTarget->pev, "monster_human_grunt" ) )
{
return R_NM;
}
return CSquadMonster :: IRelationship( pTarget );
return CSquadMonster::IRelationship( pTarget );
}
//=========================================================
// ISoundMask
//=========================================================
int CAGrunt :: ISoundMask ( void )
int CAGrunt::ISoundMask( void )
{
return bits_SOUND_WORLD |
bits_SOUND_COMBAT |
bits_SOUND_PLAYER |
bits_SOUND_DANGER;
return ( bits_SOUND_WORLD | bits_SOUND_COMBAT | bits_SOUND_PLAYER | bits_SOUND_DANGER );
}
//=========================================================
// TraceAttack
//=========================================================
void CAGrunt :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
void CAGrunt::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
{
if ( ptr->iHitgroup == 10 && (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_CLUB)))
if( ptr->iHitgroup == 10 && ( bitsDamageType & ( DMG_BULLET | DMG_SLASH | DMG_CLUB ) ) )
{
// hit armor
if ( pev->dmgtime != gpGlobals->time || (RANDOM_LONG(0,10) < 1) )
if( pev->dmgtime != gpGlobals->time || ( RANDOM_LONG( 0, 10 ) < 1 ) )
{
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT( 1, 2) );
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT( 1, 2 ) );
pev->dmgtime = gpGlobals->time;
}
if ( RANDOM_LONG( 0, 1 ) == 0 )
if( RANDOM_LONG( 0, 1 ) == 0 )
{
Vector vecTracerDir = vecDir;
@ -251,12 +246,12 @@ void CAGrunt :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecD
}
flDamage -= 20;
if (flDamage <= 0)
if( flDamage <= 0 )
flDamage = 0.1;// don't hurt the monster much, but allow bits_COND_LIGHT_DAMAGE to be generated
}
else
{
SpawnBlood(ptr->vecEndPos, BloodColor(), flDamage);// a little surface blood.
SpawnBlood( ptr->vecEndPos, BloodColor(), flDamage );// a little surface blood.
TraceBleed( flDamage, vecDir, ptr, bitsDamageType );
}
@ -268,7 +263,7 @@ void CAGrunt :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecD
//=========================================================
void CAGrunt::StopTalking( void )
{
m_flNextWordTime = m_flNextSpeakTime = gpGlobals->time + 10 + RANDOM_LONG(0, 10);
m_flNextWordTime = m_flNextSpeakTime = gpGlobals->time + 10 + RANDOM_LONG( 0, 10 );
}
//=========================================================
@ -276,15 +271,15 @@ void CAGrunt::StopTalking( void )
//=========================================================
BOOL CAGrunt::ShouldSpeak( void )
{
if ( m_flNextSpeakTime > gpGlobals->time )
if( m_flNextSpeakTime > gpGlobals->time )
{
// my time to talk is still in the future.
return FALSE;
}
if ( pev->spawnflags & SF_MONSTER_GAG )
if( pev->spawnflags & SF_MONSTER_GAG )
{
if ( m_MonsterState != MONSTERSTATE_COMBAT )
if( m_MonsterState != MONSTERSTATE_COMBAT )
{
// if gagged, don't talk outside of combat.
// if not going to talk because of this, put the talk time
@ -301,26 +296,26 @@ BOOL CAGrunt::ShouldSpeak( void )
//=========================================================
// PrescheduleThink
//=========================================================
void CAGrunt :: PrescheduleThink ( void )
void CAGrunt::PrescheduleThink( void )
{
if ( ShouldSpeak() )
if( ShouldSpeak() )
{
if ( m_flNextWordTime < gpGlobals->time )
if( m_flNextWordTime < gpGlobals->time )
{
int num = -1;
do
{
num = RANDOM_LONG(0,ARRAYSIZE(pIdleSounds)-1);
num = RANDOM_LONG( 0, ARRAYSIZE( pIdleSounds ) - 1 );
} while( num == m_iLastWord );
m_iLastWord = num;
// play a new sound
EMIT_SOUND ( ENT(pev), CHAN_VOICE, pIdleSounds[ num ], 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, pIdleSounds[num], 1.0, ATTN_NORM );
// is this word our last?
if ( RANDOM_LONG( 1, 10 ) <= 1 )
if( RANDOM_LONG( 1, 10 ) <= 1 )
{
// stop talking.
StopTalking();
@ -336,39 +331,39 @@ void CAGrunt :: PrescheduleThink ( void )
//=========================================================
// DieSound
//=========================================================
void CAGrunt :: DeathSound ( void )
void CAGrunt::DeathSound( void )
{
StopTalking();
EMIT_SOUND ( ENT(pev), CHAN_VOICE, pDieSounds[RANDOM_LONG(0,ARRAYSIZE(pDieSounds)-1)], 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, pDieSounds[RANDOM_LONG( 0, ARRAYSIZE( pDieSounds ) - 1 )], 1.0, ATTN_NORM );
}
//=========================================================
// AlertSound
//=========================================================
void CAGrunt :: AlertSound ( void )
void CAGrunt::AlertSound( void )
{
StopTalking();
EMIT_SOUND ( ENT(pev), CHAN_VOICE, pAlertSounds[RANDOM_LONG(0,ARRAYSIZE(pAlertSounds)-1)], 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, pAlertSounds[RANDOM_LONG( 0, ARRAYSIZE( pAlertSounds ) - 1 )], 1.0, ATTN_NORM );
}
//=========================================================
// AttackSound
//=========================================================
void CAGrunt :: AttackSound ( void )
void CAGrunt::AttackSound( void )
{
StopTalking();
EMIT_SOUND ( ENT(pev), CHAN_VOICE, pAttackSounds[RANDOM_LONG(0,ARRAYSIZE(pAttackSounds)-1)], 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, pAttackSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackSounds ) - 1 )], 1.0, ATTN_NORM );
}
//=========================================================
// PainSound
//=========================================================
void CAGrunt :: PainSound ( void )
void CAGrunt::PainSound( void )
{
if ( m_flNextPainTime > gpGlobals->time )
if( m_flNextPainTime > gpGlobals->time )
{
return;
}
@ -377,14 +372,14 @@ void CAGrunt :: PainSound ( void )
StopTalking();
EMIT_SOUND ( ENT(pev), CHAN_VOICE, pPainSounds[RANDOM_LONG(0,ARRAYSIZE(pPainSounds)-1)], 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, pPainSounds[RANDOM_LONG( 0, ARRAYSIZE( pPainSounds ) - 1 )], 1.0, ATTN_NORM );
}
//=========================================================
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CAGrunt :: Classify ( void )
int CAGrunt::Classify( void )
{
return CLASS_ALIEN_MILITARY;
}
@ -393,17 +388,19 @@ int CAGrunt :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CAGrunt :: SetYawSpeed ( void )
void CAGrunt::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_TURN_LEFT:
case ACT_TURN_RIGHT:
ys = 110;
break;
default: ys = 100;
default:
ys = 100;
break;
}
pev->yaw_speed = ys;
@ -415,7 +412,7 @@ void CAGrunt :: SetYawSpeed ( void )
//
// Returns number of events handled, 0 if none.
//=========================================================
void CAGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CAGrunt::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -430,7 +427,7 @@ void CAGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent )
Vector vecDirToEnemy;
Vector angDir;
if (HasConditions( bits_COND_SEE_ENEMY))
if( HasConditions( bits_COND_SEE_ENEMY ) )
{
vecDirToEnemy = ( ( m_vecEnemyLKP ) - pev->origin );
angDir = UTIL_VecToAngles( vecDirToEnemy );
@ -446,7 +443,7 @@ void CAGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent )
pev->effects = EF_MUZZLEFLASH;
// make angles +-180
if (angDir.x > 180)
if( angDir.x > 180 )
{
angDir.x = angDir.x - 360;
}
@ -469,38 +466,49 @@ void CAGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent )
UTIL_MakeVectors ( pHornet->pev->angles );
pHornet->pev->velocity = gpGlobals->v_forward * 300;
switch ( RANDOM_LONG ( 0 , 2 ) )
switch( RANDOM_LONG ( 0 , 2 ) )
{
case 0: EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, "agrunt/ag_fire1.wav", 1.0, ATTN_NORM, 0, 100 ); break;
case 1: EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, "agrunt/ag_fire2.wav", 1.0, ATTN_NORM, 0, 100 ); break;
case 2: EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, "agrunt/ag_fire3.wav", 1.0, ATTN_NORM, 0, 100 ); break;
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "agrunt/ag_fire1.wav", 1.0, ATTN_NORM, 0, 100 );
break;
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "agrunt/ag_fire2.wav", 1.0, ATTN_NORM, 0, 100 );
break;
case 2:
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "agrunt/ag_fire3.wav", 1.0, ATTN_NORM, 0, 100 );
break;
}
CBaseMonster *pHornetMonster = pHornet->MyMonsterPointer();
if ( pHornetMonster )
if( pHornetMonster )
{
pHornetMonster->m_hEnemy = m_hEnemy;
}
}
break;
case AGRUNT_AE_LEFT_FOOT:
switch (RANDOM_LONG(0,1))
switch( RANDOM_LONG( 0, 1 ) )
{
// left foot
case 0: EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder2.wav", 1, ATTN_NORM, 0, 70 ); break;
case 1: EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder4.wav", 1, ATTN_NORM, 0, 70 ); break;
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "player/pl_ladder2.wav", 1, ATTN_NORM, 0, 70 );
break;
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "player/pl_ladder4.wav", 1, ATTN_NORM, 0, 70 );
break;
}
break;
case AGRUNT_AE_RIGHT_FOOT:
// right foot
switch (RANDOM_LONG(0,1))
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder1.wav", 1, ATTN_NORM, 0, 70 ); break;
case 1: EMIT_SOUND_DYN ( ENT(pev), CHAN_BODY, "player/pl_ladder3.wav", 1, ATTN_NORM, 0 ,70); break;
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "player/pl_ladder1.wav", 1, ATTN_NORM, 0, 70 );
break;
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "player/pl_ladder3.wav", 1, ATTN_NORM, 0 ,70);
break;
}
break;
@ -508,62 +516,60 @@ void CAGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent )
{
CBaseEntity *pHurt = CheckTraceHullAttack( AGRUNT_MELEE_DIST, gSkillData.agruntDmgPunch, DMG_CLUB );
if ( pHurt )
if( pHurt )
{
pHurt->pev->punchangle.y = -25;
pHurt->pev->punchangle.x = 8;
// OK to use gpGlobals without calling MakeVectors, cause CheckTraceHullAttack called it above.
if ( pHurt->IsPlayer() )
if( pHurt->IsPlayer() )
{
// this is a player. Knock him around.
pHurt->pev->velocity = pHurt->pev->velocity + gpGlobals->v_right * 250;
}
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pAttackHitSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackHitSounds ) - 1 )], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG( -5, 5 ) );
Vector vecArmPos, vecArmAng;
GetAttachment( 0, vecArmPos, vecArmAng );
SpawnBlood(vecArmPos, pHurt->BloodColor(), 25);// a little surface blood.
SpawnBlood( vecArmPos, pHurt->BloodColor(), 25 );// a little surface blood.
}
else
{
// Play a random attack miss sound
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pAttackMissSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackMissSounds ) - 1 )], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG( -5, 5 ) );
}
}
break;
case AGRUNT_AE_RIGHT_PUNCH:
{
CBaseEntity *pHurt = CheckTraceHullAttack( AGRUNT_MELEE_DIST, gSkillData.agruntDmgPunch, DMG_CLUB );
if ( pHurt )
if( pHurt )
{
pHurt->pev->punchangle.y = 25;
pHurt->pev->punchangle.x = 8;
// OK to use gpGlobals without calling MakeVectors, cause CheckTraceHullAttack called it above.
if ( pHurt->IsPlayer() )
if( pHurt->IsPlayer() )
{
// this is a player. Knock him around.
pHurt->pev->velocity = pHurt->pev->velocity + gpGlobals->v_right * -250;
}
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pAttackHitSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackHitSounds ) - 1 )], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG( -5, 5 ) );
Vector vecArmPos, vecArmAng;
GetAttachment( 0, vecArmPos, vecArmAng );
SpawnBlood(vecArmPos, pHurt->BloodColor(), 25);// a little surface blood.
SpawnBlood( vecArmPos, pHurt->BloodColor(), 25 );// a little surface blood.
}
else
{
// Play a random attack miss sound
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pAttackMissSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackMissSounds ) - 1 )], 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG( -5, 5 ) );
}
}
break;
default:
CSquadMonster::HandleAnimEvent( pEvent );
break;
@ -573,12 +579,12 @@ void CAGrunt :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CAGrunt :: Spawn()
void CAGrunt::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/agrunt.mdl");
UTIL_SetSize(pev, Vector(-32, -32, 0), Vector(32, 32, 64));
SET_MODEL( ENT( pev ), "models/agrunt.mdl" );
UTIL_SetSize( pev, Vector( -32, -32, 0 ), Vector( 32, 32, 64 ) );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
@ -592,8 +598,7 @@ void CAGrunt :: Spawn()
m_HackedGunPos = Vector( 24, 64, 48 );
m_flNextSpeakTime = m_flNextWordTime = gpGlobals->time + 10 + RANDOM_LONG(0, 10);
m_flNextSpeakTime = m_flNextWordTime = gpGlobals->time + 10 + RANDOM_LONG( 0, 10 );
MonsterInit();
}
@ -601,32 +606,32 @@ void CAGrunt :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CAGrunt :: Precache()
void CAGrunt::Precache()
{
int i;
PRECACHE_MODEL("models/agrunt.mdl");
PRECACHE_MODEL( "models/agrunt.mdl" );
for ( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
PRECACHE_SOUND((char *)pAttackHitSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackHitSounds[i] );
for ( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
PRECACHE_SOUND((char *)pAttackMissSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackMissSounds[i] );
for ( i = 0; i < ARRAYSIZE( pIdleSounds ); i++ )
PRECACHE_SOUND((char *)pIdleSounds[i]);
for( i = 0; i < ARRAYSIZE( pIdleSounds ); i++ )
PRECACHE_SOUND( (char *)pIdleSounds[i] );
for ( i = 0; i < ARRAYSIZE( pDieSounds ); i++ )
PRECACHE_SOUND((char *)pDieSounds[i]);
for( i = 0; i < ARRAYSIZE( pDieSounds ); i++ )
PRECACHE_SOUND( (char *)pDieSounds[i] );
for ( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
PRECACHE_SOUND((char *)pPainSounds[i]);
for( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
PRECACHE_SOUND( (char *)pPainSounds[i] );
for ( i = 0; i < ARRAYSIZE( pAttackSounds ); i++ )
PRECACHE_SOUND((char *)pAttackSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackSounds[i] );
for ( i = 0; i < ARRAYSIZE( pAlertSounds ); i++ )
PRECACHE_SOUND((char *)pAlertSounds[i]);
for( i = 0; i < ARRAYSIZE( pAlertSounds ); i++ )
PRECACHE_SOUND( (char *)pAlertSounds[i] );
PRECACHE_SOUND( "hassault/hw_shoot1.wav" );
@ -654,7 +659,7 @@ Schedule_t slAGruntFail[] =
{
{
tlAGruntFail,
ARRAYSIZE ( tlAGruntFail ),
ARRAYSIZE( tlAGruntFail ),
bits_COND_CAN_RANGE_ATTACK1 |
bits_COND_CAN_MELEE_ATTACK1,
0,
@ -677,7 +682,7 @@ Schedule_t slAGruntCombatFail[] =
{
{
tlAGruntCombatFail,
ARRAYSIZE ( tlAGruntCombatFail ),
ARRAYSIZE( tlAGruntCombatFail ),
bits_COND_CAN_RANGE_ATTACK1 |
bits_COND_CAN_MELEE_ATTACK1,
0,
@ -701,13 +706,12 @@ Schedule_t slAGruntStandoff[] =
{
{
tlAGruntStandoff,
ARRAYSIZE ( tlAGruntStandoff ),
ARRAYSIZE( tlAGruntStandoff ),
bits_COND_CAN_RANGE_ATTACK1 |
bits_COND_CAN_MELEE_ATTACK1 |
bits_COND_SEE_ENEMY |
bits_COND_NEW_ENEMY |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"Agrunt Standoff"
}
@ -726,7 +730,7 @@ Schedule_t slAGruntSuppress[] =
{
{
tlAGruntSuppressHornet,
ARRAYSIZE ( tlAGruntSuppressHornet ),
ARRAYSIZE( tlAGruntSuppressHornet ),
0,
0,
"AGrunt Suppress Hornet",
@ -747,11 +751,10 @@ Schedule_t slAGruntRangeAttack1[] =
{
{
tlAGruntRangeAttack1,
ARRAYSIZE ( tlAGruntRangeAttack1 ),
ARRAYSIZE( tlAGruntRangeAttack1 ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD |
bits_COND_HEAVY_DAMAGE,
0,
"AGrunt Range Attack1"
},
@ -774,7 +777,6 @@ Schedule_t slAGruntHiddenRangeAttack[] =
bits_COND_NEW_ENEMY |
bits_COND_HEAVY_DAMAGE |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"AGrunt Hidden Range Attack1"
},
@ -799,7 +801,7 @@ Schedule_t slAGruntTakeCoverFromEnemy[] =
{
{
tlAGruntTakeCoverFromEnemy,
ARRAYSIZE ( tlAGruntTakeCoverFromEnemy ),
ARRAYSIZE( tlAGruntTakeCoverFromEnemy ),
bits_COND_NEW_ENEMY,
0,
"AGruntTakeCoverFromEnemy"
@ -836,7 +838,7 @@ Schedule_t slAGruntVictoryDance[] =
{
{
tlAGruntVictoryDance,
ARRAYSIZE ( tlAGruntVictoryDance ),
ARRAYSIZE( tlAGruntVictoryDance ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE,
@ -858,11 +860,10 @@ Schedule_t slAGruntThreatDisplay[] =
{
{
tlAGruntThreatDisplay,
ARRAYSIZE ( tlAGruntThreatDisplay ),
ARRAYSIZE( tlAGruntThreatDisplay ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE,
bits_SOUND_PLAYER |
bits_SOUND_COMBAT |
bits_SOUND_WORLD,
@ -890,9 +891,9 @@ IMPLEMENT_CUSTOM_SCHEDULES( CAGrunt, CSquadMonster )
// because they can use their smart weapons against unseen
// enemies. Base class doesn't attack anyone it can't see.
//=========================================================
BOOL CAGrunt :: FCanCheckAttacks ( void )
BOOL CAGrunt::FCanCheckAttacks( void )
{
if ( !HasConditions( bits_COND_ENEMY_TOOFAR ) )
if( !HasConditions( bits_COND_ENEMY_TOOFAR ) )
{
return TRUE;
}
@ -906,9 +907,9 @@ BOOL CAGrunt :: FCanCheckAttacks ( void )
// CheckMeleeAttack1 - alien grunts zap the crap out of
// any enemy that gets too close.
//=========================================================
BOOL CAGrunt :: CheckMeleeAttack1 ( float flDot, float flDist )
BOOL CAGrunt::CheckMeleeAttack1( float flDot, float flDist )
{
if ( HasConditions ( bits_COND_SEE_ENEMY ) && flDist <= AGRUNT_MELEE_DIST && flDot >= 0.6 && m_hEnemy != NULL )
if( HasConditions( bits_COND_SEE_ENEMY ) && flDist <= AGRUNT_MELEE_DIST && flDot >= 0.6 && m_hEnemy != NULL )
{
return TRUE;
}
@ -922,14 +923,14 @@ BOOL CAGrunt :: CheckMeleeAttack1 ( float flDot, float flDist )
// tracelines are done, so we may not want to do this every
// server frame. Definitely not while firing.
//=========================================================
BOOL CAGrunt :: CheckRangeAttack1 ( float flDot, float flDist )
BOOL CAGrunt::CheckRangeAttack1( float flDot, float flDist )
{
if ( gpGlobals->time < m_flNextHornetAttackCheck )
if( gpGlobals->time < m_flNextHornetAttackCheck )
{
return m_fCanHornetAttack;
}
if ( HasConditions( bits_COND_SEE_ENEMY ) && flDist >= AGRUNT_MELEE_DIST && flDist <= 1024 && flDot >= 0.5 && NoFriendlyFire() )
if( HasConditions( bits_COND_SEE_ENEMY ) && flDist >= AGRUNT_MELEE_DIST && flDist <= 1024 && flDot >= 0.5 && NoFriendlyFire() )
{
TraceResult tr;
Vector vecArmPos, vecArmDir;
@ -938,10 +939,10 @@ BOOL CAGrunt :: CheckRangeAttack1 ( float flDot, float flDist )
// !!!LATER - we may wish to do something different for projectile weapons as opposed to instant-hit
UTIL_MakeVectors( pev->angles );
GetAttachment( 0, vecArmPos, vecArmDir );
// UTIL_TraceLine( vecArmPos, vecArmPos + gpGlobals->v_forward * 256, ignore_monsters, ENT(pev), &tr);
UTIL_TraceLine( vecArmPos, m_hEnemy->BodyTarget(vecArmPos), dont_ignore_monsters, ENT(pev), &tr);
//UTIL_TraceLine( vecArmPos, vecArmPos + gpGlobals->v_forward * 256, ignore_monsters, ENT( pev ), &tr );
UTIL_TraceLine( vecArmPos, m_hEnemy->BodyTarget( vecArmPos ), dont_ignore_monsters, ENT( pev ), &tr );
if ( tr.flFraction == 1.0 || tr.pHit == m_hEnemy->edict() )
if( tr.flFraction == 1.0 || tr.pHit == m_hEnemy->edict() )
{
m_flNextHornetAttackCheck = gpGlobals->time + RANDOM_FLOAT( 2, 5 );
m_fCanHornetAttack = TRUE;
@ -957,35 +958,33 @@ BOOL CAGrunt :: CheckRangeAttack1 ( float flDot, float flDist )
//=========================================================
// StartTask
//=========================================================
void CAGrunt :: StartTask ( Task_t *pTask )
void CAGrunt::StartTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_AGRUNT_GET_PATH_TO_ENEMY_CORPSE:
{
UTIL_MakeVectors( pev->angles );
if ( BuildRoute ( m_vecEnemyLKP - gpGlobals->v_forward * 50, bits_MF_TO_LOCATION, NULL ) )
if( BuildRoute( m_vecEnemyLKP - gpGlobals->v_forward * 50, bits_MF_TO_LOCATION, NULL ) )
{
TaskComplete();
}
else
{
ALERT ( at_aiconsole, "AGruntGetPathToEnemyCorpse failed!!\n" );
ALERT( at_aiconsole, "AGruntGetPathToEnemyCorpse failed!!\n" );
TaskFail();
}
}
break;
case TASK_AGRUNT_SETUP_HIDE_ATTACK:
// alien grunt shoots hornets back out into the open from a concealed location.
// try to find a spot to throw that gives the smart weapon a good chance of finding the enemy.
// ideally, this spot is along a line that is perpendicular to a line drawn from the agrunt to the enemy.
CBaseMonster *pEnemyMonsterPtr;
pEnemyMonsterPtr = m_hEnemy->MyMonsterPointer();
if ( pEnemyMonsterPtr )
if( pEnemyMonsterPtr )
{
Vector vecCenter;
TraceResult tr;
@ -996,61 +995,60 @@ void CAGrunt :: StartTask ( Task_t *pTask )
UTIL_VecToAngles( m_vecEnemyLKP - pev->origin );
UTIL_TraceLine( Center() + gpGlobals->v_forward * 128, m_vecEnemyLKP, ignore_monsters, ENT(pev), &tr);
if ( tr.flFraction == 1.0 )
UTIL_TraceLine( Center() + gpGlobals->v_forward * 128, m_vecEnemyLKP, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction == 1.0 )
{
MakeIdealYaw ( pev->origin + gpGlobals->v_right * 128 );
MakeIdealYaw( pev->origin + gpGlobals->v_right * 128 );
fSkip = TRUE;
TaskComplete();
}
if ( !fSkip )
if( !fSkip )
{
UTIL_TraceLine( Center() - gpGlobals->v_forward * 128, m_vecEnemyLKP, ignore_monsters, ENT(pev), &tr);
if ( tr.flFraction == 1.0 )
UTIL_TraceLine( Center() - gpGlobals->v_forward * 128, m_vecEnemyLKP, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction == 1.0 )
{
MakeIdealYaw ( pev->origin - gpGlobals->v_right * 128 );
MakeIdealYaw( pev->origin - gpGlobals->v_right * 128 );
fSkip = TRUE;
TaskComplete();
}
}
if ( !fSkip )
if( !fSkip )
{
UTIL_TraceLine( Center() + gpGlobals->v_forward * 256, m_vecEnemyLKP, ignore_monsters, ENT(pev), &tr);
if ( tr.flFraction == 1.0 )
UTIL_TraceLine( Center() + gpGlobals->v_forward * 256, m_vecEnemyLKP, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction == 1.0 )
{
MakeIdealYaw ( pev->origin + gpGlobals->v_right * 256 );
MakeIdealYaw( pev->origin + gpGlobals->v_right * 256 );
fSkip = TRUE;
TaskComplete();
}
}
if ( !fSkip )
if( !fSkip )
{
UTIL_TraceLine( Center() - gpGlobals->v_forward * 256, m_vecEnemyLKP, ignore_monsters, ENT(pev), &tr);
if ( tr.flFraction == 1.0 )
UTIL_TraceLine( Center() - gpGlobals->v_forward * 256, m_vecEnemyLKP, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction == 1.0 )
{
MakeIdealYaw ( pev->origin - gpGlobals->v_right * 256 );
MakeIdealYaw( pev->origin - gpGlobals->v_right * 256 );
fSkip = TRUE;
TaskComplete();
}
}
if ( !fSkip )
if( !fSkip )
{
TaskFail();
}
}
else
{
ALERT ( at_aiconsole, "AGRunt - no enemy monster ptr!!!\n" );
ALERT( at_aiconsole, "AGRunt - no enemy monster ptr!!!\n" );
TaskFail();
}
break;
default:
CSquadMonster :: StartTask ( pTask );
CSquadMonster::StartTask( pTask );
break;
}
}
@ -1061,128 +1059,120 @@ void CAGrunt :: StartTask ( Task_t *pTask )
// monster's member function to get a pointer to a schedule
// of the proper type.
//=========================================================
Schedule_t *CAGrunt :: GetSchedule ( void )
Schedule_t *CAGrunt::GetSchedule( void )
{
if ( HasConditions(bits_COND_HEAR_SOUND) )
if( HasConditions( bits_COND_HEAR_SOUND ) )
{
CSound *pSound;
pSound = PBestSound();
ASSERT( pSound != NULL );
if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
if( pSound && ( pSound->m_iType & bits_SOUND_DANGER ) )
{
// dangerous sound nearby!
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
}
}
switch ( m_MonsterState )
switch( m_MonsterState )
{
case MONSTERSTATE_COMBAT:
{
// dead enemy
if ( HasConditions( bits_COND_ENEMY_DEAD ) )
if( HasConditions( bits_COND_ENEMY_DEAD ) )
{
// call base class, all code to handle dead enemies is centralized there.
return CBaseMonster :: GetSchedule();
return CBaseMonster::GetSchedule();
}
if ( HasConditions(bits_COND_NEW_ENEMY) )
if( HasConditions( bits_COND_NEW_ENEMY ) )
{
return GetScheduleOfType( SCHED_WAKE_ANGRY );
}
// zap player!
if ( HasConditions ( bits_COND_CAN_MELEE_ATTACK1 ) )
if( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
{
AttackSound();// this is a total hack. Should be parto f the schedule
return GetScheduleOfType ( SCHED_MELEE_ATTACK1 );
return GetScheduleOfType( SCHED_MELEE_ATTACK1 );
}
if ( HasConditions ( bits_COND_HEAVY_DAMAGE ) )
if( HasConditions( bits_COND_HEAVY_DAMAGE ) )
{
return GetScheduleOfType( SCHED_SMALL_FLINCH );
}
// can attack
if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) && OccupySlot ( bits_SLOTS_AGRUNT_HORNET ) )
if( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) && OccupySlot ( bits_SLOTS_AGRUNT_HORNET ) )
{
return GetScheduleOfType ( SCHED_RANGE_ATTACK1 );
return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
}
if ( OccupySlot ( bits_SLOT_AGRUNT_CHASE ) )
if( OccupySlot ( bits_SLOT_AGRUNT_CHASE ) )
{
return GetScheduleOfType ( SCHED_CHASE_ENEMY );
return GetScheduleOfType( SCHED_CHASE_ENEMY );
}
return GetScheduleOfType ( SCHED_STANDOFF );
return GetScheduleOfType( SCHED_STANDOFF );
}
break;
default:
break;
}
return CSquadMonster :: GetSchedule();
return CSquadMonster::GetSchedule();
}
//=========================================================
//=========================================================
Schedule_t* CAGrunt :: GetScheduleOfType ( int Type )
Schedule_t *CAGrunt::GetScheduleOfType( int Type )
{
switch( Type )
{
case SCHED_TAKE_COVER_FROM_ENEMY:
return &slAGruntTakeCoverFromEnemy[ 0 ];
return &slAGruntTakeCoverFromEnemy[0];
break;
case SCHED_RANGE_ATTACK1:
if ( HasConditions( bits_COND_SEE_ENEMY ) )
if( HasConditions( bits_COND_SEE_ENEMY ) )
{
//normal attack
return &slAGruntRangeAttack1[ 0 ];
return &slAGruntRangeAttack1[0];
}
else
{
// attack an unseen enemy
// return &slAGruntHiddenRangeAttack[ 0 ];
return &slAGruntRangeAttack1[ 0 ];
// return &slAGruntHiddenRangeAttack[0];
return &slAGruntRangeAttack1[0];
}
break;
case SCHED_AGRUNT_THREAT_DISPLAY:
return &slAGruntThreatDisplay[ 0 ];
return &slAGruntThreatDisplay[0];
break;
case SCHED_AGRUNT_SUPPRESS:
return &slAGruntSuppress[ 0 ];
return &slAGruntSuppress[0];
break;
case SCHED_STANDOFF:
return &slAGruntStandoff[ 0 ];
return &slAGruntStandoff[0];
break;
case SCHED_VICTORY_DANCE:
return &slAGruntVictoryDance[ 0 ];
return &slAGruntVictoryDance[0];
break;
case SCHED_FAIL:
// no fail schedule specified, so pick a good generic one.
{
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
// I have an enemy
// !!!LATER - what if this enemy is really far away and i'm chasing him?
// this schedule will make me stop, face his last known position for 2
// seconds, and then try to move again
return &slAGruntCombatFail[ 0 ];
return &slAGruntCombatFail[0];
}
return &slAGruntFail[ 0 ];
return &slAGruntFail[0];
}
break;
}
return CSquadMonster :: GetScheduleOfType( Type );
return CSquadMonster::GetScheduleOfType( Type );
}

22
dlls/airtank.cpp
View File

@ -46,15 +46,15 @@ TYPEDESCRIPTION CAirtank::m_SaveData[] =
IMPLEMENT_SAVERESTORE( CAirtank, CGrenade )
void CAirtank :: Spawn( void )
void CAirtank::Spawn( void )
{
Precache( );
Precache();
// motor
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/w_oxygen.mdl");
UTIL_SetSize(pev, Vector( -16, -16, 0), Vector(16, 16, 36));
SET_MODEL( ENT( pev ), "models/w_oxygen.mdl" );
UTIL_SetSize( pev, Vector( -16, -16, 0), Vector( 16, 16, 36 ) );
UTIL_SetOrigin( pev, pev->origin );
SetTouch( &CAirtank::TankTouch );
@ -69,11 +69,11 @@ void CAirtank :: Spawn( void )
void CAirtank::Precache( void )
{
PRECACHE_MODEL("models/w_oxygen.mdl");
PRECACHE_SOUND("doors/aliendoor3.wav");
PRECACHE_MODEL( "models/w_oxygen.mdl" );
PRECACHE_SOUND( "doors/aliendoor3.wav" );
}
void CAirtank :: Killed( entvars_t *pevAttacker, int iGib )
void CAirtank::Killed( entvars_t *pevAttacker, int iGib )
{
pev->owner = ENT( pevAttacker );
@ -91,13 +91,13 @@ void CAirtank::TankThink( void )
void CAirtank::TankTouch( CBaseEntity *pOther )
{
if ( !pOther->IsPlayer() )
if( !pOther->IsPlayer() )
return;
if (!m_state)
if( !m_state )
{
// "no oxygen" sound
EMIT_SOUND( ENT(pev), CHAN_BODY, "player/pl_swim2.wav", 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_BODY, "player/pl_swim2.wav", 1.0, ATTN_NORM );
return;
}
@ -105,7 +105,7 @@ void CAirtank::TankTouch( CBaseEntity *pOther )
pOther->pev->air_finished = gpGlobals->time + 12;
// suit recharge sound
EMIT_SOUND( ENT(pev), CHAN_VOICE, "doors/aliendoor3.wav", 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "doors/aliendoor3.wav", 1.0, ATTN_NORM );
// recharge airtank in 30 seconds
pev->nextthink = gpGlobals->time + 30;

131
dlls/animating.cpp
View File

@ -41,29 +41,29 @@ IMPLEMENT_SAVERESTORE( CBaseAnimating, CBaseDelay )
// StudioFrameAdvance - advance the animation frame up to the current time
// if an flInterval is passed in, only advance animation that number of seconds
//=========================================================
float CBaseAnimating :: StudioFrameAdvance ( float flInterval )
float CBaseAnimating::StudioFrameAdvance( float flInterval )
{
if (flInterval == 0.0)
if( flInterval == 0.0 )
{
flInterval = (gpGlobals->time - pev->animtime);
if (flInterval <= 0.001)
flInterval = gpGlobals->time - pev->animtime;
if( flInterval <= 0.001 )
{
pev->animtime = gpGlobals->time;
return 0.0;
}
}
if (! pev->animtime)
if( !pev->animtime )
flInterval = 0.0;
pev->frame += flInterval * m_flFrameRate * pev->framerate;
pev->animtime = gpGlobals->time;
if (pev->frame < 0.0 || pev->frame >= 256.0)
if( pev->frame < 0.0 || pev->frame >= 256.0 )
{
if (m_fSequenceLoops)
pev->frame -= (int)(pev->frame / 256.0) * 256.0;
if( m_fSequenceLoops )
pev->frame -= (int)( pev->frame / 256.0 ) * 256.0;
else
pev->frame = (pev->frame < 0.0) ? 0 : 255;
pev->frame = ( pev->frame < 0.0 ) ? 0 : 255;
m_fSequenceFinished = TRUE; // just in case it wasn't caught in GetEvents
}
@ -73,10 +73,10 @@ float CBaseAnimating :: StudioFrameAdvance ( float flInterval )
//=========================================================
// LookupActivity
//=========================================================
int CBaseAnimating :: LookupActivity ( int activity )
int CBaseAnimating::LookupActivity( int activity )
{
ASSERT( activity != 0 );
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
return ::LookupActivity( pmodel, pev, activity );
}
@ -87,30 +87,30 @@ int CBaseAnimating :: LookupActivity ( int activity )
// Get activity with highest 'weight'
//
//=========================================================
int CBaseAnimating :: LookupActivityHeaviest ( int activity )
int CBaseAnimating::LookupActivityHeaviest( int activity )
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
return ::LookupActivityHeaviest( pmodel, pev, activity );
}
//=========================================================
//=========================================================
int CBaseAnimating :: LookupSequence ( const char *label )
int CBaseAnimating::LookupSequence( const char *label )
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
return ::LookupSequence( pmodel, label );
}
//=========================================================
//=========================================================
void CBaseAnimating :: ResetSequenceInfo ( )
void CBaseAnimating::ResetSequenceInfo()
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
GetSequenceInfo( pmodel, pev, &m_flFrameRate, &m_flGroundSpeed );
m_fSequenceLoops = ((GetSequenceFlags() & STUDIO_LOOPING) != 0);
m_fSequenceLoops = ( ( GetSequenceFlags() & STUDIO_LOOPING ) != 0 );
pev->animtime = gpGlobals->time;
pev->framerate = 1.0;
m_fSequenceFinished = FALSE;
@ -119,9 +119,9 @@ void CBaseAnimating :: ResetSequenceInfo ( )
//=========================================================
//=========================================================
BOOL CBaseAnimating :: GetSequenceFlags( )
BOOL CBaseAnimating::GetSequenceFlags()
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
return ::GetSequenceFlags( pmodel, pev );
}
@ -129,13 +129,13 @@ BOOL CBaseAnimating :: GetSequenceFlags( )
//=========================================================
// DispatchAnimEvents
//=========================================================
void CBaseAnimating :: DispatchAnimEvents ( float flInterval )
void CBaseAnimating::DispatchAnimEvents( float flInterval )
{
MonsterEvent_t event;
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
if ( !pmodel )
if( !pmodel )
{
ALERT( at_aiconsole, "Gibbed monster is thinking!\n" );
return;
@ -145,17 +145,17 @@ void CBaseAnimating :: DispatchAnimEvents ( float flInterval )
flInterval = 0.1;
// FIX: this still sometimes hits events twice
float flStart = pev->frame + (m_flLastEventCheck - pev->animtime) * m_flFrameRate * pev->framerate;
float flStart = pev->frame + ( m_flLastEventCheck - pev->animtime ) * m_flFrameRate * pev->framerate;
float flEnd = pev->frame + flInterval * m_flFrameRate * pev->framerate;
m_flLastEventCheck = pev->animtime + flInterval;
m_fSequenceFinished = FALSE;
if (flEnd >= 256 || flEnd <= 0.0)
if( flEnd >= 256 || flEnd <= 0.0 )
m_fSequenceFinished = TRUE;
int index = 0;
while ( (index = GetAnimationEvent( pmodel, pev, &event, flStart, flEnd, index ) ) != 0 )
while( ( index = GetAnimationEvent( pmodel, pev, &event, flStart, flEnd, index ) ) != 0 )
{
HandleAnimEvent( &event );
}
@ -163,18 +163,18 @@ void CBaseAnimating :: DispatchAnimEvents ( float flInterval )
//=========================================================
//=========================================================
float CBaseAnimating :: SetBoneController ( int iController, float flValue )
float CBaseAnimating::SetBoneController( int iController, float flValue )
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
return SetController( pmodel, pev, iController, flValue );
}
//=========================================================
//=========================================================
void CBaseAnimating :: InitBoneControllers ( void )
void CBaseAnimating::InitBoneControllers( void )
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
SetController( pmodel, pev, 0, 0.0 );
SetController( pmodel, pev, 1, 0.0 );
@ -184,38 +184,38 @@ void CBaseAnimating :: InitBoneControllers ( void )
//=========================================================
//=========================================================
float CBaseAnimating :: SetBlending ( int iBlender, float flValue )
float CBaseAnimating::SetBlending( int iBlender, float flValue )
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
return ::SetBlending( pmodel, pev, iBlender, flValue );
}
//=========================================================
//=========================================================
void CBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles )
void CBaseAnimating::GetBonePosition( int iBone, Vector &origin, Vector &angles )
{
GET_BONE_POSITION( ENT(pev), iBone, origin, angles );
GET_BONE_POSITION( ENT( pev ), iBone, origin, angles );
}
//=========================================================
//=========================================================
void CBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles )
void CBaseAnimating::GetAttachment( int iAttachment, Vector &origin, Vector &angles )
{
GET_ATTACHMENT( ENT(pev), iAttachment, origin, angles );
GET_ATTACHMENT( ENT( pev ), iAttachment, origin, angles );
}
//=========================================================
//=========================================================
int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir )
int CBaseAnimating::FindTransition( int iEndingSequence, int iGoalSequence, int *piDir )
{
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
if (piDir == NULL)
if( piDir == NULL )
{
int iDir;
int sequence = ::FindTransition( pmodel, iEndingSequence, iGoalSequence, &iDir );
if (iDir != 1)
if( iDir != 1 )
return -1;
else
return sequence;
@ -226,45 +226,45 @@ int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, in
//=========================================================
//=========================================================
void CBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval )
void CBaseAnimating::GetAutomovement( Vector &origin, Vector &angles, float flInterval )
{
}
void CBaseAnimating :: SetBodygroup( int iGroup, int iValue )
void CBaseAnimating::SetBodygroup( int iGroup, int iValue )
{
::SetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup, iValue );
::SetBodygroup( GET_MODEL_PTR( ENT( pev ) ), pev, iGroup, iValue );
}
int CBaseAnimating :: GetBodygroup( int iGroup )
int CBaseAnimating::GetBodygroup( int iGroup )
{
return ::GetBodygroup( GET_MODEL_PTR( ENT(pev) ), pev, iGroup );
return ::GetBodygroup( GET_MODEL_PTR( ENT( pev ) ), pev, iGroup );
}
int CBaseAnimating :: ExtractBbox( int sequence, float *mins, float *maxs )
int CBaseAnimating::ExtractBbox( int sequence, float *mins, float *maxs )
{
return ::ExtractBbox( GET_MODEL_PTR( ENT(pev) ), sequence, mins, maxs );
return ::ExtractBbox( GET_MODEL_PTR( ENT( pev ) ), sequence, mins, maxs );
}
//=========================================================
//=========================================================
void CBaseAnimating :: SetSequenceBox( void )
void CBaseAnimating::SetSequenceBox( void )
{
Vector mins, maxs;
// Get sequence bbox
if ( ExtractBbox( pev->sequence, mins, maxs ) )
if( ExtractBbox( pev->sequence, mins, maxs ) )
{
// expand box for rotation
// find min / max for rotations
float yaw = pev->angles.y * (M_PI / 180.0);
float yaw = pev->angles.y * ( M_PI / 180.0 );
Vector xvector, yvector;
xvector.x = cos(yaw);
xvector.y = sin(yaw);
yvector.x = -sin(yaw);
yvector.y = cos(yaw);
xvector.x = cos( yaw );
xvector.y = sin( yaw );
yvector.x = -sin( yaw );
yvector.y = cos( yaw );
Vector bounds[2];
bounds[0] = mins;
@ -274,32 +274,32 @@ void CBaseAnimating :: SetSequenceBox( void )
Vector rmax( -9999, -9999, -9999 );
Vector base, transformed;
for (int i = 0; i <= 1; i++ )
for( int i = 0; i <= 1; i++ )
{
base.x = bounds[i].x;
for ( int j = 0; j <= 1; j++ )
for( int j = 0; j <= 1; j++ )
{
base.y = bounds[j].y;
for ( int k = 0; k <= 1; k++ )
for( int k = 0; k <= 1; k++ )
{
base.z = bounds[k].z;
// transform the point
transformed.x = xvector.x*base.x + yvector.x*base.y;
transformed.y = xvector.y*base.x + yvector.y*base.y;
transformed.x = xvector.x * base.x + yvector.x * base.y;
transformed.y = xvector.y * base.x + yvector.y * base.y;
transformed.z = base.z;
if (transformed.x < rmin.x)
if( transformed.x < rmin.x )
rmin.x = transformed.x;
if (transformed.x > rmax.x)
if( transformed.x > rmax.x )
rmax.x = transformed.x;
if (transformed.y < rmin.y)
if( transformed.y < rmin.y )
rmin.y = transformed.y;
if (transformed.y > rmax.y)
if( transformed.y > rmax.y )
rmax.y = transformed.y;
if (transformed.z < rmin.z)
if( transformed.z < rmin.z )
rmin.z = transformed.z;
if (transformed.z > rmax.z)
if( transformed.z > rmax.z )
rmax.z = transformed.z;
}
}
@ -309,4 +309,3 @@ void CBaseAnimating :: SetSequenceBox( void )
UTIL_SetSize( pev, rmin, rmax );
}
}

222
dlls/animation.cpp
View File

@ -12,6 +12,7 @@
* without written permission from Valve LLC.
*
****/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@ -58,20 +59,20 @@ int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return 0;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
mins[0] = pseqdesc[ sequence ].bbmin[0];
mins[1] = pseqdesc[ sequence ].bbmin[1];
mins[2] = pseqdesc[ sequence ].bbmin[2];
mins[0] = pseqdesc[sequence].bbmin[0];
mins[1] = pseqdesc[sequence].bbmin[1];
mins[2] = pseqdesc[sequence].bbmin[2];
maxs[0] = pseqdesc[ sequence ].bbmax[0];
maxs[1] = pseqdesc[ sequence ].bbmax[1];
maxs[2] = pseqdesc[ sequence ].bbmax[2];
maxs[0] = pseqdesc[sequence].bbmax[0];
maxs[1] = pseqdesc[sequence].bbmax[1];
maxs[2] = pseqdesc[sequence].bbmax[2];
return 1;
}
@ -81,21 +82,21 @@ int LookupActivity( void *pmodel, entvars_t *pev, int activity )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return 0;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
int weighttotal = 0;
int seq = ACTIVITY_NOT_AVAILABLE;
for (int i = 0; i < pstudiohdr->numseq; i++)
for( int i = 0; i < pstudiohdr->numseq; i++ )
{
if (pseqdesc[i].activity == activity)
if( pseqdesc[i].activity == activity )
{
weighttotal += pseqdesc[i].actweight;
if (!weighttotal || RANDOM_LONG(0,weighttotal-1) < pseqdesc[i].actweight)
if( !weighttotal || RANDOM_LONG( 0, weighttotal - 1 ) < pseqdesc[i].actweight )
seq = i;
}
}
@ -108,20 +109,20 @@ int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if ( !pstudiohdr )
if( !pstudiohdr )
return 0;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
int weight = 0;
int seq = ACTIVITY_NOT_AVAILABLE;
for (int i = 0; i < pstudiohdr->numseq; i++)
for( int i = 0; i < pstudiohdr->numseq; i++ )
{
if (pseqdesc[i].activity == activity)
if( pseqdesc[i].activity == activity )
{
if ( pseqdesc[i].actweight > weight )
if( pseqdesc[i].actweight > weight )
{
weight = pseqdesc[i].actweight;
seq = i;
@ -132,19 +133,19 @@ int LookupActivityHeaviest( void *pmodel, entvars_t *pev, int activity )
return seq;
}
void GetEyePosition ( void *pmodel, float *vecEyePosition )
void GetEyePosition( void *pmodel, float *vecEyePosition )
{
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if ( !pstudiohdr )
if( !pstudiohdr )
{
ALERT ( at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n" );
ALERT( at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n" );
return;
}
VectorCopy ( pstudiohdr->eyeposition, vecEyePosition );
VectorCopy( pstudiohdr->eyeposition, vecEyePosition );
}
int LookupSequence( void *pmodel, const char *label )
@ -152,16 +153,16 @@ int LookupSequence( void *pmodel, const char *label )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return 0;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
for (int i = 0; i < pstudiohdr->numseq; i++)
for( int i = 0; i < pstudiohdr->numseq; i++ )
{
if (stricmp( pseqdesc[i].label, label ) == 0)
if( stricmp( pseqdesc[i].label, label ) == 0 )
return i;
}
@ -170,7 +171,7 @@ int LookupSequence( void *pmodel, const char *label )
int IsSoundEvent( int eventNumber )
{
if ( eventNumber == SCRIPT_EVENT_SOUND || eventNumber == SCRIPT_EVENT_SOUND_VOICE )
if( eventNumber == SCRIPT_EVENT_SOUND || eventNumber == SCRIPT_EVENT_SOUND_VOICE )
return 1;
return 0;
}
@ -178,36 +179,36 @@ int IsSoundEvent( int eventNumber )
void SequencePrecache( void *pmodel, const char *pSequenceName )
{
int index = LookupSequence( pmodel, pSequenceName );
if ( index >= 0 )
if( index >= 0 )
{
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if ( !pstudiohdr || index >= pstudiohdr->numseq )
if( !pstudiohdr || index >= pstudiohdr->numseq )
return;
mstudioseqdesc_t *pseqdesc;
mstudioevent_t *pevent;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + index;
pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + index;
pevent = (mstudioevent_t *)( (byte *)pstudiohdr + pseqdesc->eventindex );
for (int i = 0; i < pseqdesc->numevents; i++)
for( int i = 0; i < pseqdesc->numevents; i++ )
{
// Don't send client-side events to the server AI
if ( pevent[i].event >= EVENT_CLIENT )
if( pevent[i].event >= EVENT_CLIENT )
continue;
// UNDONE: Add a callback to check to see if a sound is precached yet and don't allocate a copy
// of it's name if it is.
if ( IsSoundEvent( pevent[i].event ) )
if( IsSoundEvent( pevent[i].event ) )
{
if ( !strlen(pevent[i].options) )
if( !strlen( pevent[i].options ) )
{
ALERT( at_error, "Bad sound event %d in sequence %s :: %s (sound is \"%s\")\n", pevent[i].event, pstudiohdr->name, pSequenceName, pevent[i].options );
}
PRECACHE_SOUND( (char *)(gpGlobals->pStringBase + ALLOC_STRING(pevent[i].options) ) );
PRECACHE_SOUND( (char *)( gpGlobals->pStringBase + ALLOC_STRING( pevent[i].options ) ) );
}
}
}
@ -218,25 +219,25 @@ void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return;
mstudioseqdesc_t *pseqdesc;
if (pev->sequence >= pstudiohdr->numseq)
if( pev->sequence >= pstudiohdr->numseq )
{
*pflFrameRate = 0.0;
*pflGroundSpeed = 0.0;
return;
}
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
if (pseqdesc->numframes > 1)
if( pseqdesc->numframes > 1 )
{
*pflFrameRate = 256 * pseqdesc->fps / (pseqdesc->numframes - 1);
*pflGroundSpeed = sqrt( pseqdesc->linearmovement[0]*pseqdesc->linearmovement[0]+ pseqdesc->linearmovement[1]*pseqdesc->linearmovement[1]+ pseqdesc->linearmovement[2]*pseqdesc->linearmovement[2] );
*pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / (pseqdesc->numframes - 1);
*pflFrameRate = 256 * pseqdesc->fps / ( pseqdesc->numframes - 1 );
*pflGroundSpeed = sqrt( pseqdesc->linearmovement[0] * pseqdesc->linearmovement[0] + pseqdesc->linearmovement[1] * pseqdesc->linearmovement[1] + pseqdesc->linearmovement[2] * pseqdesc->linearmovement[2] );
*pflGroundSpeed = *pflGroundSpeed * pseqdesc->fps / ( pseqdesc->numframes - 1 );
}
else
{
@ -250,11 +251,11 @@ int GetSequenceFlags( void *pmodel, entvars_t *pev )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
if( !pstudiohdr || pev->sequence >= pstudiohdr->numseq )
return 0;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
return pseqdesc->flags;
}
@ -264,7 +265,7 @@ int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEve
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if ( !pstudiohdr || pev->sequence >= pstudiohdr->numseq || !pMonsterEvent )
if( !pstudiohdr || pev->sequence >= pstudiohdr->numseq || !pMonsterEvent )
return 0;
int events = 0;
@ -272,15 +273,15 @@ int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEve
mstudioseqdesc_t *pseqdesc;
mstudioevent_t *pevent;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
pevent = (mstudioevent_t *)( (byte *)pstudiohdr + pseqdesc->eventindex );
if (pseqdesc->numevents == 0 || index > pseqdesc->numevents )
if( pseqdesc->numevents == 0 || index > pseqdesc->numevents )
return 0;
if (pseqdesc->numframes > 1)
if( pseqdesc->numframes > 1 )
{
flStart *= (pseqdesc->numframes - 1) / 256.0;
flStart *= ( pseqdesc->numframes - 1 ) / 256.0;
flEnd *= (pseqdesc->numframes - 1) / 256.0;
}
else
@ -289,14 +290,14 @@ int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEve
flEnd = 1.0;
}
for (; index < pseqdesc->numevents; index++)
for( ; index < pseqdesc->numevents; index++ )
{
// Don't send client-side events to the server AI
if ( pevent[index].event >= EVENT_CLIENT )
if( pevent[index].event >= EVENT_CLIENT )
continue;
if ( (pevent[index].frame >= flStart && pevent[index].frame < flEnd) ||
((pseqdesc->flags & STUDIO_LOOPING) && flEnd >= pseqdesc->numframes - 1 && pevent[index].frame < flEnd - pseqdesc->numframes + 1) )
if( ( pevent[index].frame >= flStart && pevent[index].frame < flEnd ) ||
( ( pseqdesc->flags & STUDIO_LOOPING ) && flEnd >= pseqdesc->numframes - 1 && pevent[index].frame < flEnd - pseqdesc->numframes + 1 ) )
{
pMonsterEvent->event = pevent[index].event;
pMonsterEvent->options = pevent[index].options;
@ -312,52 +313,53 @@ float SetController( void *pmodel, entvars_t *pev, int iController, float flValu
int i;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return flValue;
mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)((byte *)pstudiohdr + pstudiohdr->bonecontrollerindex);
mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)( (byte *)pstudiohdr + pstudiohdr->bonecontrollerindex );
// find first controller that matches the index
for (i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++)
for( i = 0; i < pstudiohdr->numbonecontrollers; i++, pbonecontroller++ )
{
if (pbonecontroller->index == iController)
if( pbonecontroller->index == iController )
break;
}
if (i >= pstudiohdr->numbonecontrollers)
if( i >= pstudiohdr->numbonecontrollers )
return flValue;
// wrap 0..360 if it's a rotational controller
if (pbonecontroller->type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
if( pbonecontroller->type & ( STUDIO_XR | STUDIO_YR | STUDIO_ZR ) )
{
// ugly hack, invert value if end < start
if (pbonecontroller->end < pbonecontroller->start)
if( pbonecontroller->end < pbonecontroller->start )
flValue = -flValue;
// does the controller not wrap?
if (pbonecontroller->start + 359.0 >= pbonecontroller->end)
if( pbonecontroller->start + 359.0 >= pbonecontroller->end )
{
if (flValue > ((pbonecontroller->start + pbonecontroller->end) / 2.0) + 180)
if( flValue > ( ( pbonecontroller->start + pbonecontroller->end ) / 2.0 ) + 180 )
flValue = flValue - 360;
if (flValue < ((pbonecontroller->start + pbonecontroller->end) / 2.0) - 180)
if( flValue < ( ( pbonecontroller->start + pbonecontroller->end) / 2.0 ) - 180 )
flValue = flValue + 360;
}
else
{
if (flValue > 360)
flValue = flValue - (int)(flValue / 360.0) * 360.0;
else if (flValue < 0)
flValue = flValue + (int)((flValue / -360.0) + 1) * 360.0;
if( flValue > 360 )
flValue = flValue - (int)( flValue / 360.0 ) * 360.0;
else if( flValue < 0 )
flValue = flValue + (int)( ( flValue / -360.0 ) + 1 ) * 360.0;
}
}
int setting = 255 * (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);
int setting = 255 * ( flValue - pbonecontroller->start ) / ( pbonecontroller->end - pbonecontroller->start );
if (setting < 0) setting = 0;
if (setting > 255) setting = 255;
if( setting < 0 )
setting = 0;
if( setting > 255 )
setting = 255;
pev->controller[iController] = setting;
return setting * (1.0 / 255.0) * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
return setting * ( 1.0 / 255.0 ) * (pbonecontroller->end - pbonecontroller->start ) + pbonecontroller->start;
}
float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue )
@ -365,40 +367,42 @@ float SetBlending( void *pmodel, entvars_t *pev, int iBlender, float flValue )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return flValue;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
if (pseqdesc->blendtype[iBlender] == 0)
if( pseqdesc->blendtype[iBlender] == 0 )
return flValue;
if (pseqdesc->blendtype[iBlender] & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
if( pseqdesc->blendtype[iBlender] & ( STUDIO_XR | STUDIO_YR | STUDIO_ZR ) )
{
// ugly hack, invert value if end < start
if (pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender])
if( pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender] )
flValue = -flValue;
// does the controller not wrap?
if (pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender])
if( pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender] )
{
if (flValue > ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) + 180)
if( flValue > ( ( pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender] ) / 2.0 ) + 180 )
flValue = flValue - 360;
if (flValue < ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) - 180)
if( flValue < ( ( pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender] ) / 2.0 ) - 180 )
flValue = flValue + 360;
}
}
int setting = 255 * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]);
int setting = 255 * ( flValue - pseqdesc->blendstart[iBlender] ) / ( pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender] );
if (setting < 0) setting = 0;
if (setting > 255) setting = 255;
if( setting < 0 )
setting = 0;
if(setting > 255)
setting = 255;
pev->blending[iBlender] = setting;
return setting * (1.0 / 255.0) * (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]) + pseqdesc->blendstart[iBlender];
return setting * ( 1.0 / 255.0 ) * ( pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender] ) + pseqdesc->blendstart[iBlender];
}
int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
@ -406,14 +410,14 @@ int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return iGoalAnim;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
// bail if we're going to or from a node 0
if (pseqdesc[iEndingAnim].entrynode == 0 || pseqdesc[iGoalAnim].entrynode == 0)
if( pseqdesc[iEndingAnim].entrynode == 0 || pseqdesc[iGoalAnim].entrynode == 0 )
{
return iGoalAnim;
}
@ -422,7 +426,7 @@ int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
// ALERT( at_console, "from %d to %d: ", pEndNode->iEndNode, pGoalNode->iStartNode );
if (*piDir > 0)
if( *piDir > 0 )
{
iEndNode = pseqdesc[iEndingAnim].exitnode;
}
@ -431,32 +435,32 @@ int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
iEndNode = pseqdesc[iEndingAnim].entrynode;
}
if (iEndNode == pseqdesc[iGoalAnim].entrynode)
if( iEndNode == pseqdesc[iGoalAnim].entrynode )
{
*piDir = 1;
return iGoalAnim;
}
byte *pTransition = ((byte *)pstudiohdr + pstudiohdr->transitionindex);
byte *pTransition = ( (byte *)pstudiohdr + pstudiohdr->transitionindex );
int iInternNode = pTransition[(iEndNode-1)*pstudiohdr->numtransitions + (pseqdesc[iGoalAnim].entrynode-1)];
int iInternNode = pTransition[( iEndNode - 1 ) * pstudiohdr->numtransitions + ( pseqdesc[iGoalAnim].entrynode - 1 )];
if (iInternNode == 0)
if( iInternNode == 0 )
return iGoalAnim;
int i;
// look for someone going
for (i = 0; i < pstudiohdr->numseq; i++)
for( i = 0; i < pstudiohdr->numseq; i++ )
{
if (pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode)
if( pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode )
{
*piDir = 1;
return i;
}
if (pseqdesc[i].nodeflags)
if( pseqdesc[i].nodeflags )
{
if (pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode)
if( pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode )
{
*piDir = -1;
return i;
@ -473,20 +477,20 @@ void SetBodygroup( void *pmodel, entvars_t *pev, int iGroup, int iValue )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return;
if (iGroup > pstudiohdr->numbodyparts)
if( iGroup > pstudiohdr->numbodyparts )
return;
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)( (byte *)pstudiohdr + pstudiohdr->bodypartindex ) + iGroup;
if (iValue >= pbodypart->nummodels)
if( iValue >= pbodypart->nummodels )
return;
int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
int iCurrent = ( pev->body / pbodypart->base ) % pbodypart->nummodels;
pev->body = (pev->body - (iCurrent * pbodypart->base) + (iValue * pbodypart->base));
pev->body = ( pev->body - ( iCurrent * pbodypart->base ) + ( iValue * pbodypart->base ) );
}
int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup )
@ -494,18 +498,18 @@ int GetBodygroup( void *pmodel, entvars_t *pev, int iGroup )
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return 0;
if (iGroup > pstudiohdr->numbodyparts)
if( iGroup > pstudiohdr->numbodyparts )
return 0;
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)( (byte *)pstudiohdr + pstudiohdr->bodypartindex ) + iGroup;
if (pbodypart->nummodels <= 1)
if( pbodypart->nummodels <= 1 )
return 0;
int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
int iCurrent = ( pev->body / pbodypart->base ) % pbodypart->nummodels;
return iCurrent;
}

2
dlls/animation.h
View File

@ -42,6 +42,4 @@ int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs );
// From /engine/studio.h
#define STUDIO_LOOPING 0x0001
#endif //ANIMATION_H

393
dlls/apache.cpp
View File

@ -42,8 +42,8 @@ class CApache : public CBaseMonster
void SetObjectCollisionBox( void )
{
pev->absmin = pev->origin + Vector( -300, -300, -172);
pev->absmax = pev->origin + Vector(300, 300, 8);
pev->absmin = pev->origin + Vector( -300, -300, -172 );
pev->absmax = pev->origin + Vector( 300, 300, 8 );
}
void EXPORT HuntThink( void );
@ -59,7 +59,7 @@ class CApache : public CBaseMonster
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);
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
int m_iRockets;
float m_flForce;
@ -104,10 +104,10 @@ TYPEDESCRIPTION CApache::m_SaveData[] =
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_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 ),
@ -115,14 +115,14 @@ TYPEDESCRIPTION CApache::m_SaveData[] =
IMPLEMENT_SAVERESTORE( CApache, CBaseMonster )
void CApache :: Spawn( void )
void CApache::Spawn( void )
{
Precache( );
Precache();
// motor
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/apache.mdl");
SET_MODEL( ENT( pev ), "models/apache.mdl" );
UTIL_SetSize( pev, Vector( -32, -32, -64 ), Vector( 32, 32, 0 ) );
UTIL_SetOrigin( pev, pev->origin );
@ -133,12 +133,12 @@ void CApache :: Spawn( void )
m_flFieldOfView = -0.707; // 270 degrees
pev->sequence = 0;
ResetSequenceInfo( );
pev->frame = RANDOM_LONG(0, 0xFF);
ResetSequenceInfo();
pev->frame = RANDOM_LONG( 0, 0xFF );
InitBoneControllers();
if (pev->spawnflags & SF_WAITFORTRIGGER)
if( pev->spawnflags & SF_WAITFORTRIGGER )
{
SetUse( &CApache::StartupUse );
}
@ -154,20 +154,20 @@ void CApache :: Spawn( void )
void CApache::Precache( void )
{
PRECACHE_MODEL("models/apache.mdl");
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( "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");
PRECACHE_SOUND( "weapons/mortarhit.wav" );
m_iSpriteTexture = PRECACHE_MODEL( "sprites/white.spr" );
PRECACHE_SOUND("turret/tu_fire1.wav");
PRECACHE_SOUND( "turret/tu_fire1.wav" );
PRECACHE_MODEL("sprites/lgtning.spr");
PRECACHE_MODEL( "sprites/lgtning.spr" );
m_iExplode = PRECACHE_MODEL( "sprites/fexplo.spr" );
m_iBodyGibs = PRECACHE_MODEL( "models/metalplategibs_green.mdl" );
@ -177,7 +177,7 @@ void CApache::Precache( void )
void CApache::NullThink( void )
{
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.5;
}
@ -189,21 +189,21 @@ void CApache::StartupUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYP
SetUse( NULL );
}
void CApache :: Killed( entvars_t *pevAttacker, int iGib )
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" );
STOP_SOUND( ENT( pev ), CHAN_STATIC, "apache/ap_rotor2.wav" );
UTIL_SetSize( pev, Vector( -32, -32, -64), Vector( 32, 32, 0) );
UTIL_SetSize( pev, Vector( -32, -32, -64 ), Vector( 32, 32, 0 ) );
SetThink( &CApache::DyingThink );
SetTouch( &CApache::CrashTouch );
pev->nextthink = gpGlobals->time + 0.1;
pev->health = 0;
pev->takedamage = DAMAGE_NO;
if (pev->spawnflags & SF_NOWRECKAGE)
if( pev->spawnflags & SF_NOWRECKAGE )
{
m_flNextRocket = gpGlobals->time + 4.0;
}
@ -213,24 +213,24 @@ void CApache :: Killed( entvars_t *pevAttacker, int iGib )
}
}
void CApache :: DyingThink( void )
void CApache::DyingThink( void )
{
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1;
pev->avelocity = pev->avelocity * 1.02;
// still falling?
if (m_flNextRocket > gpGlobals->time )
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_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( RANDOM_LONG( 0, 29 ) + 30 ); // scale * 10
WRITE_BYTE( 12 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
@ -238,17 +238,17 @@ void CApache :: DyingThink( void )
// 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_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;
Vector vecSpot = pev->origin + ( pev->mins + pev->maxs ) * 0.5;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_BREAKMODEL);
WRITE_BYTE( TE_BREAKMODEL );
// position
WRITE_COORD( vecSpot.x );
@ -278,7 +278,6 @@ void CApache :: DyingThink( void )
WRITE_BYTE( 30 );// 3.0 seconds
// flags
WRITE_BYTE( BREAK_METAL );
MESSAGE_END();
@ -289,7 +288,7 @@ void CApache :: DyingThink( void )
}
else
{
Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
Vector vecSpot = pev->origin + ( pev->mins + pev->maxs ) * 0.5;
/*
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
@ -328,11 +327,11 @@ void CApache :: DyingThink( void )
// 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.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
@ -347,14 +346,14 @@ void CApache :: DyingThink( void )
WRITE_BYTE( 0 ); // speed
MESSAGE_END();
EMIT_SOUND(ENT(pev), CHAN_STATIC, "weapons/mortarhit.wav", 1.0, 0.3);
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))
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) );
// 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;
@ -363,14 +362,14 @@ void CApache :: DyingThink( void )
}
// gibs
vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
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);
WRITE_COORD( vecSpot.z + 64 );
// size
WRITE_COORD( 400 );
@ -395,7 +394,6 @@ void CApache :: DyingThink( void )
WRITE_BYTE( 200 );// 10.0 seconds
// flags
WRITE_BYTE( BREAK_METAL );
MESSAGE_END();
@ -407,19 +405,19 @@ void CApache :: DyingThink( void )
void CApache::FlyTouch( CBaseEntity *pOther )
{
// bounce if we hit something solid
if ( pOther->pev->solid == SOLID_BSP)
if( pOther->pev->solid == SOLID_BSP )
{
TraceResult tr = UTIL_GetGlobalTrace( );
TraceResult tr = UTIL_GetGlobalTrace();
// UNDONE, do a real bounce
pev->velocity = pev->velocity + tr.vecPlaneNormal * (pev->velocity.Length() + 200);
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)
if( pOther->pev->solid == SOLID_BSP )
{
SetTouch( NULL );
m_flNextRocket = gpGlobals->time;
@ -427,22 +425,22 @@ void CApache::CrashTouch( CBaseEntity *pOther )
}
}
void CApache :: GibMonster( void )
void CApache::GibMonster( void )
{
// EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200);
// EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200 );
}
void CApache :: HuntThink( void )
void CApache::HuntThink( void )
{
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1;
ShowDamage( );
ShowDamage();
if ( m_pGoalEnt == NULL && !FStringNull(pev->target) )// this monster has a target
if( m_pGoalEnt == NULL && !FStringNull( pev->target ) )// this monster has a target
{
m_pGoalEnt = UTIL_FindEntityByTargetname( NULL, STRING( pev->target ) );
if (m_pGoalEnt)
if( m_pGoalEnt )
{
m_posDesired = m_pGoalEnt->pev->origin;
UTIL_MakeAimVectors( m_pGoalEnt->pev->angles );
@ -450,25 +448,25 @@ void CApache :: HuntThink( void )
}
}
// if (m_hEnemy == NULL)
// if( m_hEnemy == NULL )
{
Look( 4092 );
m_hEnemy = BestVisibleEnemy( );
m_hEnemy = BestVisibleEnemy();
}
// generic speed up
if (m_flGoalSpeed < 800)
if( m_flGoalSpeed < 800 )
m_flGoalSpeed += 5;
if (m_hEnemy != NULL)
if( m_hEnemy != NULL )
{
// ALERT( at_console, "%s\n", STRING( m_hEnemy->pev->classname ) );
if (FVisible( m_hEnemy ))
if( FVisible( m_hEnemy ) )
{
if (m_flLastSeen < gpGlobals->time - 5)
if( m_flLastSeen < gpGlobals->time - 5 )
m_flPrevSeen = gpGlobals->time;
m_flLastSeen = gpGlobals->time;
m_posTarget = m_hEnemy->Center( );
m_posTarget = m_hEnemy->Center();
}
else
{
@ -476,23 +474,23 @@ void CApache :: HuntThink( void )
}
}
m_vecTarget = (m_posTarget - pev->origin).Normalize();
m_vecTarget = ( m_posTarget - pev->origin ).Normalize();
float flLength = (pev->origin - m_posDesired).Length();
float flLength = ( pev->origin - m_posDesired ).Length();
if (m_pGoalEnt)
if( m_pGoalEnt )
{
// ALERT( at_console, "%.0f\n", flLength );
if (flLength < 128)
if( flLength < 128 )
{
m_pGoalEnt = UTIL_FindEntityByTargetname( NULL, STRING( m_pGoalEnt->pev->target ) );
if (m_pGoalEnt)
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();
flLength = ( pev->origin - m_posDesired ).Length();
}
}
}
@ -501,17 +499,17 @@ void CApache :: HuntThink( void )
m_posDesired = pev->origin;
}
if (flLength > 250) // 500
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)
// 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( );
m_vecDesired = ( m_posTarget - pev->origin ).Normalize();
}
else
{
m_vecDesired = (m_posDesired - pev->origin).Normalize( );
m_vecDesired = ( m_posDesired - pev->origin ).Normalize();
}
}
else
@ -519,51 +517,51 @@ void CApache :: HuntThink( void )
m_vecDesired = m_vecGoal;
}
Flight( );
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( ( m_flLastSeen + 1 > gpGlobals->time ) && ( m_flPrevSeen + 2 < gpGlobals->time ) )
{
if (FireGun( ))
if( FireGun() )
{
// slow down if we're fireing
if (m_flGoalSpeed > 400)
if( m_flGoalSpeed > 400 )
m_flGoalSpeed = 400;
}
// don't fire rockets and gun on easy mode
if (g_iSkillLevel == SKILL_EASY)
if( g_iSkillLevel == SKILL_EASY )
m_flNextRocket = gpGlobals->time + 10.0;
}
UTIL_MakeAimVectors( pev->angles );
Vector vecEst = (gpGlobals->v_forward * 800 + pev->velocity).Normalize( );
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)
if( ( m_iRockets % 2 ) == 1 )
{
FireRocket( );
FireRocket();
m_flNextRocket = gpGlobals->time + 0.5;
if (m_iRockets <= 0)
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)
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_flLastSeen + 60 > gpGlobals->time )
{
if (m_hEnemy != NULL)
if( m_hEnemy != NULL )
{
// make sure it's a good shot
if (DotProduct( m_vecTarget, vecEst) > .965)
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( );
if( (tr.vecEndPos - m_posTarget ).Length() < 512 )
FireRocket();
}
}
else
@ -572,47 +570,47 @@ void CApache :: HuntThink( void )
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( );
if( ( tr.vecEndPos - m_posTarget ).Length() < 512 )
FireRocket();
}
}
}
}
void CApache :: Flight( void )
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);
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( flSide < 0 )
{
if (pev->avelocity.y < 60)
if( pev->avelocity.y < 60 )
{
pev->avelocity.y += 8; // 9 * (3.0/2.0);
pev->avelocity.y += 8; // 9 * ( 3.0 / 2.0 );
}
}
else
{
if (pev->avelocity.y > -60)
if( pev->avelocity.y > -60 )
{
pev->avelocity.y -= 8; // 9 * (3.0/2.0);
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);
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);
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;
@ -622,7 +620,7 @@ void CApache :: Flight( void )
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)
if( flDir < 0 )
flSpeed = -flSpeed;
float flDist = DotProduct( m_posDesired - vecEst, gpGlobals->v_forward );
@ -631,60 +629,59 @@ void CApache :: Flight( void )
float flSlip = -DotProduct( m_posDesired - vecEst, gpGlobals->v_right );
// fly sideways
if (flSlip > 0)
if( flSlip > 0 )
{
if (pev->angles.z > -30 && pev->avelocity.z > -15)
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)
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);
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)
if( m_flForce < 80 && vecEst.z < m_posDesired.z )
{
m_flForce += 12;
}
else if (m_flForce > 30)
else if( m_flForce > 30 )
{
if (vecEst.z > m_posDesired.z)
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)
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)
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)
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)
else if( pev->angles.x + pev->avelocity.x < 0 )
{
// ALERT( at_console, "b " );
pev->avelocity.x += 4.0;
@ -694,10 +691,10 @@ void CApache :: Flight( void )
// 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)
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 );
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
}
@ -707,50 +704,58 @@ void CApache :: Flight( void )
pPlayer = UTIL_FindEntityByClassname( NULL, "player" );
// UNDONE: this needs to send different sounds to every player for multiplayer.
if (pPlayer)
if( pPlayer )
{
float pitch = DotProduct( pev->velocity - pPlayer->pev->velocity, ( pPlayer->pev->origin - pev->origin ).Normalize() );
float pitch = DotProduct( pev->velocity - pPlayer->pev->velocity, (pPlayer->pev->origin - pev->origin).Normalize() );
pitch = (int)( 100 + pitch / 50.0 );
pitch = (int)(100 + pitch / 50.0);
if (pitch > 250)
if( pitch > 250 )
pitch = 250;
if (pitch < 50)
if( pitch < 50 )
pitch = 50;
if (pitch == 100)
if( pitch == 100 )
pitch = 101;
float flVol = (m_flForce / 100.0) + .1;
if (flVol > 1.0)
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_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);
// 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 )
void CApache::FireRocket( void )
{
static float side = 1.0;
static int count;
if (m_iRockets <= 0)
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);
Vector vecSrc = pev->origin + 1.5 * ( gpGlobals->v_forward * 21 + gpGlobals->v_right * 70 * side + gpGlobals->v_up * -79 );
switch( m_iRockets % 5)
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;
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 );
@ -764,7 +769,7 @@ void CApache :: FireRocket( void )
MESSAGE_END();
CBaseEntity *pRocket = CBaseEntity::Create( "hvr_rocket", vecSrc, pev->angles, edict() );
if (pRocket)
if( pRocket )
pRocket->pev->velocity = pev->velocity + gpGlobals->v_forward * 100;
m_iRockets--;
@ -772,14 +777,14 @@ void CApache :: FireRocket( void )
side = - side;
}
BOOL CApache :: FireGun( )
BOOL CApache::FireGun()
{
UTIL_MakeAimVectors( pev->angles );
Vector posGun, angGun;
GetAttachment( 1, posGun, angGun );
Vector vecTarget = (m_posTarget - posGun).Normalize( );
Vector vecTarget = ( m_posTarget - posGun ).Normalize();
Vector vecOut;
@ -787,25 +792,25 @@ BOOL CApache :: FireGun( )
vecOut.y = -DotProduct( gpGlobals->v_right, vecTarget );
vecOut.z = DotProduct( gpGlobals->v_up, vecTarget );
Vector angles = UTIL_VecToAngles (vecOut);
Vector angles = UTIL_VecToAngles( vecOut );
angles.x = -angles.x;
if (angles.y > 180)
if( angles.y > 180 )
angles.y = angles.y - 360;
if (angles.y < -180)
if( angles.y < -180 )
angles.y = angles.y + 360;
if (angles.x > 180)
if( angles.x > 180 )
angles.x = angles.x - 360;
if (angles.x < -180)
if( angles.x < -180 )
angles.x = angles.x + 360;
if (angles.x > m_angGun.x)
if( angles.x > m_angGun.x )
m_angGun.x = min( angles.x, m_angGun.x + 12 );
if (angles.x < m_angGun.x)
if( angles.x < m_angGun.x )
m_angGun.x = max( angles.x, m_angGun.x - 12 );
if (angles.y > m_angGun.y)
if( angles.y > m_angGun.y )
m_angGun.y = min( angles.y, m_angGun.y + 12 );
if (angles.y < m_angGun.y)
if( angles.y < m_angGun.y )
m_angGun.y = max( angles.y, m_angGun.y - 12 );
m_angGun.y = SetBoneController( 0, m_angGun.y );
@ -813,28 +818,28 @@ BOOL CApache :: FireGun( )
Vector posBarrel, angBarrel;
GetAttachment( 0, posBarrel, angBarrel );
Vector vecGun = (posBarrel - posGun).Normalize( );
Vector vecGun = ( posBarrel - posGun ).Normalize();
if (DotProduct( vecGun, vecTarget ) > 0.98)
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);
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)
if( !m_pBeam )
{
m_pBeam = CBeam::BeamCreate( "sprites/lgtning.spr", 80 );
m_pBeam->PointEntInit( pev->origin, entindex( ) );
m_pBeam->PointEntInit( pev->origin, entindex() );
m_pBeam->SetEndAttachment( 1 );
m_pBeam->SetColor( 255, 180, 96 );
m_pBeam->SetBrightness( 192 );
}
if (flNext < gpGlobals->time)
if( flNext < gpGlobals->time )
{
flNext = gpGlobals->time + 0.5;
m_pBeam->SetStartPos( tr.vecEndPos );
@ -844,7 +849,7 @@ BOOL CApache :: FireGun( )
}
else
{
if (m_pBeam)
if( m_pBeam )
{
UTIL_Remove( m_pBeam );
m_pBeam = NULL;
@ -853,9 +858,9 @@ BOOL CApache :: FireGun( )
return FALSE;
}
void CApache :: ShowDamage( void )
void CApache::ShowDamage( void )
{
if (m_iDoSmokePuff > 0 || RANDOM_LONG(0,99) > pev->health)
if( m_iDoSmokePuff > 0 || RANDOM_LONG( 0, 99 ) > pev->health )
{
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_SMOKE );
@ -863,26 +868,26 @@ void CApache :: ShowDamage( void )
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( RANDOM_LONG( 0, 9 ) + 20 ); // scale * 10
WRITE_BYTE( 12 ); // framerate
MESSAGE_END();
}
if (m_iDoSmokePuff > 0)
if( m_iDoSmokePuff > 0 )
m_iDoSmokePuff--;
}
int CApache :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
int CApache::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if (pevInflictor->owner == edict())
if( pevInflictor->owner == edict() )
return 0;
if (bitsDamageType & DMG_BLAST)
if( bitsDamageType & DMG_BLAST )
{
flDamage *= 2;
}
/*
if ( (bitsDamageType & DMG_BULLET) && flDamage > 50)
if( ( bitsDamageType & DMG_BULLET ) && flDamage > 50 )
{
// clip bullet damage at 50
flDamage = 50;
@ -893,20 +898,20 @@ int CApache :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, floa
return CBaseEntity::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}
void CApache::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int 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)))
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)
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);
m_iDoSmokePuff = 3 + ( flDamage / 5.0 );
}
else
{
@ -935,21 +940,21 @@ 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_iTrail, FIELD_INTEGER ), // Dont' save, precache
DEFINE_FIELD( CApacheHVR, m_vecForward, FIELD_VECTOR ),
};
IMPLEMENT_SAVERESTORE( CApacheHVR, CGrenade )
void CApacheHVR :: Spawn( void )
void CApacheHVR::Spawn( void )
{
Precache( );
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));
SET_MODEL( ENT( pev ), "models/HVR.mdl" );
UTIL_SetSize( pev, Vector( 0, 0, 0), Vector(0, 0, 0) );
UTIL_SetOrigin( pev, pev->origin );
SetThink( &CApacheHVR::IgniteThink );
@ -964,14 +969,14 @@ void CApacheHVR :: Spawn( void )
pev->dmg = 150;
}
void CApacheHVR :: Precache( void )
void CApacheHVR::Precache( void )
{
PRECACHE_MODEL("models/HVR.mdl");
m_iTrail = PRECACHE_MODEL("sprites/smoke.spr");
PRECACHE_SOUND ("weapons/rocket1.wav");
PRECACHE_MODEL( "models/HVR.mdl" );
m_iTrail = PRECACHE_MODEL( "sprites/smoke.spr" );
PRECACHE_SOUND("weapons/rocket1.wav");
}
void CApacheHVR :: IgniteThink( void )
void CApacheHVR::IgniteThink( void )
{
// pev->movetype = MOVETYPE_TOSS;
@ -979,21 +984,19 @@ void CApacheHVR :: IgniteThink( void )
pev->effects |= EF_LIGHT;
// make rocket sound
EMIT_SOUND( ENT(pev), CHAN_VOICE, "weapons/rocket1.wav", 1, 0.5 );
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_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
@ -1001,10 +1004,10 @@ void CApacheHVR :: IgniteThink( void )
pev->nextthink = gpGlobals->time + 0.1;
}
void CApacheHVR :: AccelerateThink( void )
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)
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;
@ -1012,7 +1015,7 @@ void CApacheHVR :: AccelerateThink( void )
// accelerate
float flSpeed = pev->velocity.Length();
if (flSpeed < 1800)
if( flSpeed < 1800 )
{
pev->velocity = pev->velocity + m_vecForward * 200;
}

174
dlls/barnacle.cpp
View File

@ -36,11 +36,11 @@ class CBarnacle : public CBaseMonster
public:
void Spawn( void );
void Precache( void );
CBaseEntity *TongueTouchEnt ( float *pflLength );
int Classify ( void );
CBaseEntity *TongueTouchEnt( float *pflLength );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
void EXPORT BarnacleThink ( void );
void EXPORT WaitTillDead ( void );
void EXPORT BarnacleThink( void );
void EXPORT WaitTillDead( void );
void Killed( entvars_t *pevAttacker, int iGib );
int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
virtual int Save( CSave &save );
@ -85,7 +85,7 @@ IMPLEMENT_SAVERESTORE( CBarnacle, CBaseMonster )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CBarnacle :: Classify ( void )
int CBarnacle::Classify( void )
{
return CLASS_ALIEN_MONSTER;
}
@ -96,7 +96,7 @@ int CBarnacle :: Classify ( void )
//
// Returns number of events handled, 0 if none.
//=========================================================
void CBarnacle :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CBarnacle::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -112,12 +112,12 @@ void CBarnacle :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CBarnacle :: Spawn()
void CBarnacle::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/barnacle.mdl");
UTIL_SetSize( pev, Vector(-16, -16, -32), Vector(16, 16, 0) );
SET_MODEL( ENT( pev ), "models/barnacle.mdl" );
UTIL_SetSize( pev, Vector( -16, -16, -32 ), Vector( 16, 16, 0 ) );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE;
@ -135,17 +135,17 @@ void CBarnacle :: Spawn()
InitBoneControllers();
SetActivity ( ACT_IDLE );
SetActivity( ACT_IDLE );
SetThink( &CBarnacle::BarnacleThink );
pev->nextthink = gpGlobals->time + 0.5;
UTIL_SetOrigin ( pev, pev->origin );
UTIL_SetOrigin( pev, pev->origin );
}
int CBarnacle::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if ( bitsDamageType & DMG_CLUB )
if( bitsDamageType & DMG_CLUB )
{
flDamage = pev->health;
}
@ -155,26 +155,25 @@ int CBarnacle::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, floa
//=========================================================
//=========================================================
void CBarnacle :: BarnacleThink ( void )
void CBarnacle::BarnacleThink( void )
{
CBaseEntity *pTouchEnt;
CBaseMonster *pVictim;
float flLength;
#ifdef BARNACLE_FIX_VISIBILITY
if( m_flCachedLength != ( m_flAltitude + m_flTongueAdj ) || ( pev->absmin.z != pev->origin.z + -m_flCachedLength ))
if( m_flCachedLength != ( m_flAltitude + m_flTongueAdj ) || ( pev->absmin.z != pev->origin.z + -m_flCachedLength ) )
{
// recalc collision box here to avoid barnacle disappears bug
m_flCachedLength = (m_flAltitude + m_flTongueAdj);
m_flCachedLength = m_flAltitude + m_flTongueAdj;
UTIL_SetOrigin( pev, pev->origin );
}
#endif
pev->nextthink = gpGlobals->time + 0.1;
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
// barnacle has prey.
if ( !m_hEnemy->IsAlive() )
if( !m_hEnemy->IsAlive() )
{
// someone (maybe even the barnacle) killed the prey. Reset barnacle.
m_fLiftingPrey = FALSE;// indicate that we're not lifting prey.
@ -182,9 +181,9 @@ void CBarnacle :: BarnacleThink ( void )
return;
}
if ( m_fLiftingPrey )
if( m_fLiftingPrey )
{
if ( m_hEnemy != NULL && m_hEnemy->pev->deadflag != DEAD_NO )
if( m_hEnemy != NULL && m_hEnemy->pev->deadflag != DEAD_NO )
{
// crap, someone killed the prey on the way up.
m_hEnemy = NULL;
@ -198,43 +197,43 @@ void CBarnacle :: BarnacleThink ( void )
vecNewEnemyOrigin.y = pev->origin.y;
// guess as to where their neck is
vecNewEnemyOrigin.x -= 6 * cos(m_hEnemy->pev->angles.y * M_PI/180.0);
vecNewEnemyOrigin.y -= 6 * sin(m_hEnemy->pev->angles.y * M_PI/180.0);
vecNewEnemyOrigin.x -= 6 * cos( m_hEnemy->pev->angles.y * M_PI / 180.0 );
vecNewEnemyOrigin.y -= 6 * sin( m_hEnemy->pev->angles.y * M_PI / 180.0 );
m_flAltitude -= BARNACLE_PULL_SPEED;
vecNewEnemyOrigin.z += BARNACLE_PULL_SPEED;
if ( fabs( pev->origin.z - ( vecNewEnemyOrigin.z + m_hEnemy->pev->view_ofs.z - 8 ) ) < BARNACLE_BODY_HEIGHT )
if( fabs( pev->origin.z - ( vecNewEnemyOrigin.z + m_hEnemy->pev->view_ofs.z - 8 ) ) < BARNACLE_BODY_HEIGHT )
{
// prey has just been lifted into position ( if the victim origin + eye height + 8 is higher than the bottom of the barnacle, it is assumed that the head is within barnacle's body )
m_fLiftingPrey = FALSE;
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_bite3.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_bite3.wav", 1, ATTN_NORM );
pVictim = m_hEnemy->MyMonsterPointer();
m_flKillVictimTime = gpGlobals->time + 10;// now that the victim is in place, the killing bite will be administered in 10 seconds.
if ( pVictim )
if( pVictim )
{
pVictim->BarnacleVictimBitten( pev );
SetActivity ( ACT_EAT );
SetActivity( ACT_EAT );
}
}
UTIL_SetOrigin ( m_hEnemy->pev, vecNewEnemyOrigin );
UTIL_SetOrigin( m_hEnemy->pev, vecNewEnemyOrigin );
}
else
{
// prey is lifted fully into feeding position and is dangling there.
pVictim = m_hEnemy->MyMonsterPointer();
if ( m_flKillVictimTime != -1 && gpGlobals->time > m_flKillVictimTime )
if( m_flKillVictimTime != -1 && gpGlobals->time > m_flKillVictimTime )
{
// kill!
if ( pVictim )
if( pVictim )
{
pVictim->TakeDamage ( pev, pev, pVictim->pev->health, DMG_SLASH | DMG_ALWAYSGIB );
pVictim->TakeDamage( pev, pev, pVictim->pev->health, DMG_SLASH | DMG_ALWAYSGIB );
m_cGibs = 3;
}
@ -242,58 +241,69 @@ void CBarnacle :: BarnacleThink ( void )
}
// bite prey every once in a while
if ( pVictim && ( RANDOM_LONG(0,49) == 0 ) )
if( pVictim && ( RANDOM_LONG( 0, 49 ) == 0 ) )
{
switch ( RANDOM_LONG(0,2) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM ); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM ); break;
case 2: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM ); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM );
break;
}
pVictim->BarnacleVictimBitten( pev );
}
}
}
else
{
// barnacle has no prey right now, so just idle and check to see if anything is touching the tongue.
// If idle and no nearby client, don't think so often
if ( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
pev->nextthink = gpGlobals->time + RANDOM_FLOAT(1,1.5); // Stagger a bit to keep barnacles from thinking on the same frame
if( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
pev->nextthink = gpGlobals->time + RANDOM_FLOAT( 1, 1.5 ); // Stagger a bit to keep barnacles from thinking on the same frame
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
// this is done so barnacle will fidget.
SetActivity ( ACT_IDLE );
m_flTongueAdj = -100;
}
if ( m_cGibs && RANDOM_LONG(0,99) == 1 )
if( m_cGibs && RANDOM_LONG( 0, 99 ) == 1 )
{
// cough up a gib.
CGib::SpawnRandomGibs( pev, 1, 1 );
m_cGibs--;
switch ( RANDOM_LONG(0,2) )
switch ( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM ); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM ); break;
case 2: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM ); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_chew3.wav", 1, ATTN_NORM );
break;
}
}
pTouchEnt = TongueTouchEnt( &flLength );
if ( pTouchEnt != NULL && m_fTongueExtended )
if( pTouchEnt != NULL && m_fTongueExtended )
{
// tongue is fully extended, and is touching someone.
if ( pTouchEnt->FBecomeProne() )
if( pTouchEnt->FBecomeProne() )
{
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_alert2.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_alert2.wav", 1, ATTN_NORM );
SetSequenceByName ( "attack1" );
SetSequenceByName( "attack1" );
m_flTongueAdj = -20;
m_hEnemy = pTouchEnt;
@ -307,13 +317,13 @@ void CBarnacle :: BarnacleThink ( void )
m_fLiftingPrey = TRUE;// indicate that we should be lifting prey.
m_flKillVictimTime = -1;// set this to a bogus time while the victim is lifted.
m_flAltitude = (pev->origin.z - pTouchEnt->EyePosition().z);
m_flAltitude = pev->origin.z - pTouchEnt->EyePosition().z;
}
}
else
{
// calculate a new length for the tongue to be clear of anything else that moves under it.
if ( m_flAltitude < flLength )
if( m_flAltitude < flLength )
{
// if tongue is higher than is should be, lower it kind of slowly.
m_flAltitude += BARNACLE_PULL_SPEED;
@ -324,45 +334,47 @@ void CBarnacle :: BarnacleThink ( void )
m_flAltitude = flLength;
m_fTongueExtended = TRUE;
}
}
}
// ALERT( at_console, "tounge %f\n", m_flAltitude + m_flTongueAdj );
SetBoneController( 0, -(m_flAltitude + m_flTongueAdj) );
SetBoneController( 0, -( m_flAltitude + m_flTongueAdj ) );
StudioFrameAdvance( 0.1 );
}
//=========================================================
// Killed.
//=========================================================
void CBarnacle :: Killed( entvars_t *pevAttacker, int iGib )
void CBarnacle::Killed( entvars_t *pevAttacker, int iGib )
{
CBaseMonster *pVictim;
pev->solid = SOLID_NOT;
pev->takedamage = DAMAGE_NO;
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
pVictim = m_hEnemy->MyMonsterPointer();
if ( pVictim )
if( pVictim )
{
pVictim->BarnacleVictimReleased();
}
}
// CGib::SpawnRandomGibs( pev, 4, 1 );
//CGib::SpawnRandomGibs( pev, 4, 1 );
switch ( RANDOM_LONG ( 0, 1 ) )
switch( RANDOM_LONG ( 0, 1 ) )
{
case 0: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_die1.wav", 1, ATTN_NORM ); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_WEAPON, "barnacle/bcl_die3.wav", 1, ATTN_NORM ); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_die1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "barnacle/bcl_die3.wav", 1, ATTN_NORM );
break;
}
SetActivity ( ACT_DIESIMPLE );
SetActivity( ACT_DIESIMPLE );
SetBoneController( 0, 0 );
StudioFrameAdvance( 0.1 );
@ -373,14 +385,14 @@ void CBarnacle :: Killed( entvars_t *pevAttacker, int iGib )
//=========================================================
//=========================================================
void CBarnacle :: WaitTillDead ( void )
void CBarnacle::WaitTillDead( void )
{
pev->nextthink = gpGlobals->time + 0.1;
float flInterval = StudioFrameAdvance( 0.1 );
DispatchAnimEvents ( flInterval );
DispatchAnimEvents( flInterval );
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
// death anim finished.
StopAnimation();
@ -391,17 +403,17 @@ void CBarnacle :: WaitTillDead ( void )
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CBarnacle :: Precache()
void CBarnacle::Precache()
{
PRECACHE_MODEL("models/barnacle.mdl");
PRECACHE_MODEL( "models/barnacle.mdl" );
PRECACHE_SOUND("barnacle/bcl_alert2.wav");//happy, lifting food up
PRECACHE_SOUND("barnacle/bcl_bite3.wav");//just got food to mouth
PRECACHE_SOUND("barnacle/bcl_chew1.wav");
PRECACHE_SOUND("barnacle/bcl_chew2.wav");
PRECACHE_SOUND("barnacle/bcl_chew3.wav");
PRECACHE_SOUND("barnacle/bcl_die1.wav" );
PRECACHE_SOUND("barnacle/bcl_die3.wav" );
PRECACHE_SOUND( "barnacle/bcl_alert2.wav" );//happy, lifting food up
PRECACHE_SOUND( "barnacle/bcl_bite3.wav" );//just got food to mouth
PRECACHE_SOUND( "barnacle/bcl_chew1.wav" );
PRECACHE_SOUND( "barnacle/bcl_chew2.wav" );
PRECACHE_SOUND( "barnacle/bcl_chew3.wav" );
PRECACHE_SOUND( "barnacle/bcl_die1.wav" );
PRECACHE_SOUND( "barnacle/bcl_die3.wav" );
}
//=========================================================
@ -410,15 +422,15 @@ void CBarnacle :: Precache()
// of the trace in the int pointer provided.
//=========================================================
#define BARNACLE_CHECK_SPACING 8
CBaseEntity *CBarnacle :: TongueTouchEnt ( float *pflLength )
CBaseEntity *CBarnacle::TongueTouchEnt( float *pflLength )
{
TraceResult tr;
float length;
// trace once to hit architecture and see if the tongue needs to change position.
UTIL_TraceLine ( pev->origin, pev->origin - Vector ( 0 , 0 , 2048 ), ignore_monsters, ENT(pev), &tr );
UTIL_TraceLine( pev->origin, pev->origin - Vector ( 0, 0, 2048 ), ignore_monsters, ENT( pev ), &tr );
length = fabs( pev->origin.z - tr.vecEndPos.z );
if ( pflLength )
if( pflLength )
{
*pflLength = length;
}
@ -430,13 +442,13 @@ CBaseEntity *CBarnacle :: TongueTouchEnt ( float *pflLength )
mins.z -= length;
CBaseEntity *pList[10];
int count = UTIL_EntitiesInBox( pList, 10, mins, maxs, (FL_CLIENT|FL_MONSTER) );
if ( count )
int count = UTIL_EntitiesInBox( pList, 10, mins, maxs, ( FL_CLIENT | FL_MONSTER ) );
if( count )
{
for ( int i = 0; i < count; i++ )
for( int i = 0; i < count; i++ )
{
// only clients and monsters
if ( pList[i] != this && IRelationship( pList[i] ) > R_NO && pList[ i ]->pev->deadflag == DEAD_NO ) // this ent is one of our enemies. Barnacle tries to eat it.
if( pList[i] != this && IRelationship( pList[i] ) > R_NO && pList[ i ]->pev->deadflag == DEAD_NO ) // this ent is one of our enemies. Barnacle tries to eat it.
{
return pList[i];
}

236
dlls/barney.cpp
View File

@ -49,21 +49,21 @@ public:
int ISoundMask( void );
void BarneyFirePistol( void );
void AlertSound( void );
int Classify ( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
void RunTask( Task_t *pTask );
void StartTask( Task_t *pTask );
virtual int ObjectCaps( void ) { return CTalkMonster :: ObjectCaps() | FCAP_IMPULSE_USE; }
int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType);
BOOL CheckRangeAttack1 ( float flDot, float flDist );
BOOL CheckRangeAttack1( float flDot, float flDist );
void DeclineFollowing( void );
// Override these to set behavior
Schedule_t *GetScheduleOfType ( int Type );
Schedule_t *GetSchedule ( void );
MONSTERSTATE GetIdealState ( void );
Schedule_t *GetScheduleOfType( int Type );
Schedule_t *GetSchedule( void );
MONSTERSTATE GetIdealState( void );
void DeathSound( void );
void PainSound( void );
@ -106,7 +106,7 @@ IMPLEMENT_SAVERESTORE( CBarney, CTalkMonster )
//=========================================================
Task_t tlBaFollow[] =
{
{ TASK_MOVE_TO_TARGET_RANGE,(float)128 }, // Move within 128 of target ent (client)
{ TASK_MOVE_TO_TARGET_RANGE, (float)128 }, // Move within 128 of target ent (client)
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
};
@ -114,7 +114,7 @@ Schedule_t slBaFollow[] =
{
{
tlBaFollow,
ARRAYSIZE ( tlBaFollow ),
ARRAYSIZE( tlBaFollow ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
@ -126,7 +126,7 @@ Schedule_t slBaFollow[] =
};
//=========================================================
// BarneyDraw- much better looking draw schedule for when
// BarneyDraw - much better looking draw schedule for when
// barney knows who he's gonna attack.
//=========================================================
Task_t tlBarneyEnemyDraw[] =
@ -140,7 +140,7 @@ Schedule_t slBarneyEnemyDraw[] =
{
{
tlBarneyEnemyDraw,
ARRAYSIZE ( tlBarneyEnemyDraw ),
ARRAYSIZE( tlBarneyEnemyDraw ),
0,
0,
"Barney Enemy Draw"
@ -159,7 +159,7 @@ Schedule_t slBaFaceTarget[] =
{
{
tlBaFaceTarget,
ARRAYSIZE ( tlBaFaceTarget ),
ARRAYSIZE( tlBaFaceTarget ),
bits_COND_CLIENT_PUSH |
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
@ -183,18 +183,16 @@ Schedule_t slIdleBaStand[] =
{
{
tlIdleBaStand,
ARRAYSIZE ( tlIdleBaStand ),
ARRAYSIZE( tlIdleBaStand ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_HEAR_SOUND |
bits_COND_SMELL |
bits_COND_PROVOKED,
bits_SOUND_COMBAT |// sound flags - change these, and you'll break the talking code.
//bits_SOUND_PLAYER |
//bits_SOUND_WORLD |
bits_SOUND_DANGER |
bits_SOUND_MEAT |// scents
bits_SOUND_CARCASS |
@ -213,17 +211,17 @@ DEFINE_CUSTOM_SCHEDULES( CBarney )
IMPLEMENT_CUSTOM_SCHEDULES( CBarney, CTalkMonster )
void CBarney :: StartTask( Task_t *pTask )
void CBarney::StartTask( Task_t *pTask )
{
CTalkMonster::StartTask( pTask );
}
void CBarney :: RunTask( Task_t *pTask )
void CBarney::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_RANGE_ATTACK1:
if (m_hEnemy != NULL && (m_hEnemy->IsPlayer()))
if( m_hEnemy != NULL && ( m_hEnemy->IsPlayer() ) )
{
pev->framerate = 1.5;
}
@ -239,7 +237,7 @@ void CBarney :: RunTask( Task_t *pTask )
// ISoundMask - returns a bit mask indicating which types
// of sounds this monster regards.
//=========================================================
int CBarney :: ISoundMask ( void)
int CBarney::ISoundMask( void)
{
return bits_SOUND_WORLD |
bits_SOUND_COMBAT |
@ -254,7 +252,7 @@ int CBarney :: ISoundMask ( void)
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CBarney :: Classify ( void )
int CBarney::Classify( void )
{
return CLASS_PLAYER_ALLY;
}
@ -262,13 +260,13 @@ int CBarney :: Classify ( void )
//=========================================================
// ALertSound - barney says "Freeze!"
//=========================================================
void CBarney :: AlertSound( void )
void CBarney::AlertSound( void )
{
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
if ( FOkToSpeak() )
if( FOkToSpeak() )
{
PlaySentence( "BA_ATTACK", RANDOM_FLOAT(2.8, 3.2), VOL_NORM, ATTN_IDLE );
PlaySentence( "BA_ATTACK", RANDOM_FLOAT( 2.8, 3.2 ), VOL_NORM, ATTN_IDLE );
}
}
}
@ -277,7 +275,7 @@ void CBarney :: AlertSound( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CBarney :: SetYawSpeed ( void )
void CBarney::SetYawSpeed( void )
{
int ys;
@ -305,20 +303,20 @@ void CBarney :: SetYawSpeed ( void )
//=========================================================
// CheckRangeAttack1
//=========================================================
BOOL CBarney :: CheckRangeAttack1 ( float flDot, float flDist )
BOOL CBarney::CheckRangeAttack1( float flDot, float flDist )
{
if ( flDist <= 1024 && flDot >= 0.5 )
if( flDist <= 1024 && flDot >= 0.5 )
{
if ( gpGlobals->time > m_checkAttackTime )
if( gpGlobals->time > m_checkAttackTime )
{
TraceResult tr;
Vector shootOrigin = pev->origin + Vector( 0, 0, 55 );
CBaseEntity *pEnemy = m_hEnemy;
Vector shootTarget = ( (pEnemy->BodyTarget( shootOrigin ) - pEnemy->pev->origin) + m_vecEnemyLKP );
UTIL_TraceLine( shootOrigin, shootTarget, dont_ignore_monsters, ENT(pev), &tr );
Vector shootTarget = ( ( pEnemy->BodyTarget( shootOrigin ) - pEnemy->pev->origin ) + m_vecEnemyLKP );
UTIL_TraceLine( shootOrigin, shootTarget, dont_ignore_monsters, ENT( pev ), &tr );
m_checkAttackTime = gpGlobals->time + 1;
if ( tr.flFraction == 1.0 || (tr.pHit != NULL && CBaseEntity::Instance(tr.pHit) == pEnemy) )
if( tr.flFraction == 1.0 || ( tr.pHit != NULL && CBaseEntity::Instance( tr.pHit ) == pEnemy ) )
m_lastAttackCheck = TRUE;
else
m_lastAttackCheck = FALSE;
@ -333,11 +331,11 @@ BOOL CBarney :: CheckRangeAttack1 ( float flDot, float flDist )
// BarneyFirePistol - shoots one round from the pistol at
// the enemy barney is facing.
//=========================================================
void CBarney :: BarneyFirePistol ( void )
void CBarney::BarneyFirePistol( void )
{
Vector vecShootOrigin;
UTIL_MakeVectors(pev->angles);
UTIL_MakeVectors( pev->angles );
vecShootOrigin = pev->origin + Vector( 0, 0, 55 );
Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
@ -345,18 +343,18 @@ void CBarney :: BarneyFirePistol ( void )
SetBlending( 0, angDir.x );
pev->effects = EF_MUZZLEFLASH;
FireBullets(1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_9MM );
FireBullets( 1, vecShootOrigin, vecShootDir, VECTOR_CONE_2DEGREES, 1024, BULLET_MONSTER_9MM );
int pitchShift = RANDOM_LONG( 0, 20 );
// Only shift about half the time
if ( pitchShift > 10 )
if( pitchShift > 10 )
pitchShift = 0;
else
pitchShift -= 5;
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "barney/ba_attack2.wav", 1, ATTN_NORM, 0, 100 + pitchShift );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "barney/ba_attack2.wav", 1, ATTN_NORM, 0, 100 + pitchShift );
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
CSoundEnt::InsertSound( bits_SOUND_COMBAT, pev->origin, 384, 0.3 );
// UNDONE: Reload?
m_cAmmoLoaded--;// take away a bullet!
@ -368,26 +366,23 @@ void CBarney :: BarneyFirePistol ( void )
//
// Returns number of events handled, 0 if none.
//=========================================================
void CBarney :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CBarney::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
case BARNEY_AE_SHOOT:
BarneyFirePistol();
break;
case BARNEY_AE_DRAW:
// barney's bodygroup switches here so he can pull gun from holster
pev->body = BARNEY_BODY_GUNDRAWN;
m_fGunDrawn = TRUE;
break;
case BARNEY_AE_HOLSTER:
// change bodygroup to replace gun in holster
pev->body = BARNEY_BODY_GUNHOLSTERED;
m_fGunDrawn = FALSE;
break;
default:
CTalkMonster::HandleAnimEvent( pEvent );
}
@ -396,12 +391,12 @@ void CBarney :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CBarney :: Spawn()
void CBarney::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/barney.mdl");
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
SET_MODEL( ENT( pev ), "models/barney.mdl" );
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
@ -423,20 +418,20 @@ void CBarney :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CBarney :: Precache()
void CBarney::Precache()
{
PRECACHE_MODEL("models/barney.mdl");
PRECACHE_MODEL( "models/barney.mdl" );
PRECACHE_SOUND("barney/ba_attack1.wav" );
PRECACHE_SOUND("barney/ba_attack2.wav" );
PRECACHE_SOUND( "barney/ba_attack1.wav" );
PRECACHE_SOUND( "barney/ba_attack2.wav" );
PRECACHE_SOUND("barney/ba_pain1.wav");
PRECACHE_SOUND("barney/ba_pain2.wav");
PRECACHE_SOUND("barney/ba_pain3.wav");
PRECACHE_SOUND( "barney/ba_pain1.wav" );
PRECACHE_SOUND( "barney/ba_pain2.wav" );
PRECACHE_SOUND( "barney/ba_pain3.wav" );
PRECACHE_SOUND("barney/ba_die1.wav");
PRECACHE_SOUND("barney/ba_die2.wav");
PRECACHE_SOUND("barney/ba_die3.wav");
PRECACHE_SOUND( "barney/ba_die1.wav" );
PRECACHE_SOUND( "barney/ba_die2.wav" );
PRECACHE_SOUND( "barney/ba_die3.wav" );
// every new barney must call this, otherwise
// when a level is loaded, nobody will talk (time is reset to 0)
@ -445,12 +440,11 @@ void CBarney :: Precache()
}
// Init talk data
void CBarney :: TalkInit()
void CBarney::TalkInit()
{
CTalkMonster::TalkInit();
// scientists speach group names (group names are in sentences.txt)
m_szGrp[TLK_ANSWER] = "BA_ANSWER";
m_szGrp[TLK_QUESTION] = "BA_QUESTION";
m_szGrp[TLK_IDLE] = "BA_IDLE";
@ -481,7 +475,7 @@ void CBarney :: TalkInit()
static BOOL IsFacing( entvars_t *pevTest, const Vector &reference )
{
Vector vecDir = (reference - pevTest->origin);
Vector vecDir = reference - pevTest->origin;
vecDir.z = 0;
vecDir = vecDir.Normalize();
Vector forward, angle;
@ -490,30 +484,30 @@ static BOOL IsFacing( entvars_t *pevTest, const Vector &reference )
UTIL_MakeVectorsPrivate( angle, forward, NULL, NULL );
// He's facing me, he meant it
if ( DotProduct( forward, vecDir ) > 0.96 ) // +/- 15 degrees or so
if( DotProduct( forward, vecDir ) > 0.96 ) // +/- 15 degrees or so
{
return TRUE;
}
return FALSE;
}
int CBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType)
int CBarney::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
// make sure friends talk about it if player hurts talkmonsters...
int ret = CTalkMonster::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
if ( !IsAlive() || pev->deadflag == DEAD_DYING )
int ret = CTalkMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
if( !IsAlive() || pev->deadflag == DEAD_DYING )
return ret;
if ( m_MonsterState != MONSTERSTATE_PRONE && (pevAttacker->flags & FL_CLIENT) )
if( m_MonsterState != MONSTERSTATE_PRONE && ( pevAttacker->flags & FL_CLIENT ) )
{
m_flPlayerDamage += flDamage;
// This is a heurstic to determine if the player intended to harm me
// If I have an enemy, we can't establish intent (may just be crossfire)
if ( m_hEnemy == NULL )
if( m_hEnemy == NULL )
{
// If the player was facing directly at me, or I'm already suspicious, get mad
if ( (m_afMemory & bits_MEMORY_SUSPICIOUS) || IsFacing( pevAttacker, pev->origin ) )
if( ( m_afMemory & bits_MEMORY_SUSPICIOUS ) || IsFacing( pevAttacker, pev->origin ) )
{
// Alright, now I'm pissed!
PlaySentence( "BA_MAD", 4, VOL_NORM, ATTN_NORM );
@ -528,7 +522,7 @@ int CBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, floa
Remember( bits_MEMORY_SUSPICIOUS );
}
}
else if ( !(m_hEnemy->IsPlayer()) && pev->deadflag == DEAD_NO )
else if( !( m_hEnemy->IsPlayer()) && pev->deadflag == DEAD_NO )
{
PlaySentence( "BA_SHOT", 4, VOL_NORM, ATTN_NORM );
}
@ -540,51 +534,62 @@ int CBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, floa
//=========================================================
// PainSound
//=========================================================
void CBarney :: PainSound ( void )
void CBarney::PainSound( void )
{
if (gpGlobals->time < m_painTime)
if( gpGlobals->time < m_painTime )
return;
m_painTime = gpGlobals->time + RANDOM_FLOAT(0.5, 0.75);
m_painTime = gpGlobals->time + RANDOM_FLOAT( 0.5, 0.75 );
switch (RANDOM_LONG(0,2))
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_pain3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_pain1.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
break;
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_pain2.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
break;
case 2:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_pain3.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
break;
}
}
//=========================================================
// DeathSound
//=========================================================
void CBarney :: DeathSound ( void )
void CBarney::DeathSound( void )
{
switch (RANDOM_LONG(0,2))
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die1.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
case 1: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die2.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
case 2: EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "barney/ba_die3.wav", 1, ATTN_NORM, 0, GetVoicePitch()); break;
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_die1.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
break;
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_die2.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
break;
case 2:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "barney/ba_die3.wav", 1, ATTN_NORM, 0, GetVoicePitch() );
break;
}
}
void CBarney::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
void CBarney::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
{
switch( ptr->iHitgroup)
switch( ptr->iHitgroup )
{
case HITGROUP_CHEST:
case HITGROUP_STOMACH:
if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_BLAST))
if (bitsDamageType & ( DMG_BULLET | DMG_SLASH | DMG_BLAST ) )
{
flDamage = flDamage / 2;
}
break;
case 10:
if (bitsDamageType & (DMG_BULLET | DMG_SLASH | DMG_CLUB))
if( bitsDamageType & ( DMG_BULLET | DMG_SLASH | DMG_CLUB ) )
{
flDamage -= 20;
if (flDamage <= 0)
if( flDamage <= 0 )
{
UTIL_Ricochet( ptr->vecEndPos, 1.0 );
flDamage = 0.01;
@ -601,7 +606,7 @@ void CBarney::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir
void CBarney::Killed( entvars_t *pevAttacker, int iGib )
{
if ( pev->body < BARNEY_BODY_GUNGONE )
if( pev->body < BARNEY_BODY_GUNGONE )
{
// drop the gun!
Vector vecGunPos;
@ -621,41 +626,37 @@ void CBarney::Killed( entvars_t *pevAttacker, int iGib )
//=========================================================
// AI Schedules Specific to this monster
//=========================================================
Schedule_t* CBarney :: GetScheduleOfType ( int Type )
Schedule_t *CBarney::GetScheduleOfType( int Type )
{
Schedule_t *psched;
switch( Type )
{
case SCHED_ARM_WEAPON:
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
// face enemy, then draw.
return slBarneyEnemyDraw;
}
break;
// Hook these to make a looping schedule
case SCHED_TARGET_FACE:
// call base class default so that barney will talk
// when 'used'
psched = CTalkMonster::GetScheduleOfType(Type);
psched = CTalkMonster::GetScheduleOfType( Type );
if (psched == slIdleStand)
if( psched == slIdleStand )
return slBaFaceTarget; // override this for different target face behavior
else
return psched;
case SCHED_TARGET_CHASE:
return slBaFollow;
case SCHED_IDLE_STAND:
// call base class default so that scientist will talk
// when standing during idle
psched = CTalkMonster::GetScheduleOfType(Type);
psched = CTalkMonster::GetScheduleOfType( Type );
if (psched == slIdleStand)
if( psched == slIdleStand )
{
// just look straight ahead.
return slIdleBaStand;
@ -673,18 +674,18 @@ Schedule_t* CBarney :: GetScheduleOfType ( int Type )
// monster's member function to get a pointer to a schedule
// of the proper type.
//=========================================================
Schedule_t *CBarney :: GetSchedule ( void )
Schedule_t *CBarney::GetSchedule( void )
{
if ( HasConditions( bits_COND_HEAR_SOUND ) )
if( HasConditions( bits_COND_HEAR_SOUND ) )
{
CSound *pSound;
pSound = PBestSound();
ASSERT( pSound != NULL );
if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
if( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
}
if ( HasConditions( bits_COND_ENEMY_DEAD ) && FOkToSpeak() )
if( HasConditions( bits_COND_ENEMY_DEAD ) && FOkToSpeak() )
{
PlaySentence( "BA_KILL", 4, VOL_NORM, ATTN_NORM );
}
@ -694,36 +695,35 @@ Schedule_t *CBarney :: GetSchedule ( void )
case MONSTERSTATE_COMBAT:
{
// dead enemy
if ( HasConditions( bits_COND_ENEMY_DEAD ) )
if( HasConditions( bits_COND_ENEMY_DEAD ) )
{
// call base class, all code to handle dead enemies is centralized there.
return CBaseMonster :: GetSchedule();
return CBaseMonster::GetSchedule();
}
// always act surprized with a new enemy
if ( HasConditions( bits_COND_NEW_ENEMY ) && HasConditions( bits_COND_LIGHT_DAMAGE) )
if( HasConditions( bits_COND_NEW_ENEMY ) && HasConditions( bits_COND_LIGHT_DAMAGE ) )
return GetScheduleOfType( SCHED_SMALL_FLINCH );
// wait for one schedule to draw gun
if (!m_fGunDrawn )
if( !m_fGunDrawn )
return GetScheduleOfType( SCHED_ARM_WEAPON );
if ( HasConditions( bits_COND_HEAVY_DAMAGE ) )
if( HasConditions( bits_COND_HEAVY_DAMAGE ) )
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
}
break;
case MONSTERSTATE_ALERT:
case MONSTERSTATE_IDLE:
if ( HasConditions(bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE))
if( HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )
{
// flinch if hurt
return GetScheduleOfType( SCHED_SMALL_FLINCH );
}
if ( m_hEnemy == NULL && IsFollowing() )
if( m_hEnemy == NULL && IsFollowing() )
{
if ( !m_hTargetEnt->IsAlive() )
if( !m_hTargetEnt->IsAlive() )
{
// UNDONE: Comment about the recently dead player here?
StopFollowing( FALSE );
@ -731,7 +731,7 @@ Schedule_t *CBarney :: GetSchedule ( void )
}
else
{
if ( HasConditions( bits_COND_CLIENT_PUSH ) )
if( HasConditions( bits_COND_CLIENT_PUSH ) )
{
return GetScheduleOfType( SCHED_MOVE_AWAY_FOLLOW );
}
@ -739,7 +739,7 @@ Schedule_t *CBarney :: GetSchedule ( void )
}
}
if ( HasConditions( bits_COND_CLIENT_PUSH ) )
if( HasConditions( bits_COND_CLIENT_PUSH ) )
{
return GetScheduleOfType( SCHED_MOVE_AWAY );
}
@ -754,7 +754,7 @@ Schedule_t *CBarney :: GetSchedule ( void )
return CTalkMonster::GetSchedule();
}
MONSTERSTATE CBarney :: GetIdealState ( void )
MONSTERSTATE CBarney::GetIdealState( void )
{
return CTalkMonster::GetIdealState();
}
@ -778,7 +778,7 @@ class CDeadBarney : public CBaseMonster
{
public:
void Spawn( void );
int Classify ( void ) { return CLASS_PLAYER_ALLY; }
int Classify( void ) { return CLASS_PLAYER_ALLY; }
void KeyValue( KeyValueData *pkvd );
@ -790,9 +790,9 @@ char *CDeadBarney::m_szPoses[] = { "lying_on_back", "lying_on_side", "lying_on_s
void CDeadBarney::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "pose"))
if( FStrEq( pkvd->szKeyName, "pose" ) )
{
m_iPose = atoi(pkvd->szValue);
m_iPose = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -804,10 +804,10 @@ LINK_ENTITY_TO_CLASS( monster_barney_dead, CDeadBarney )
//=========================================================
// ********** DeadBarney SPAWN **********
//=========================================================
void CDeadBarney :: Spawn( )
void CDeadBarney::Spawn()
{
PRECACHE_MODEL("models/barney.mdl");
SET_MODEL(ENT(pev), "models/barney.mdl");
PRECACHE_MODEL( "models/barney.mdl" );
SET_MODEL( ENT( pev ), "models/barney.mdl" );
pev->effects = 0;
pev->yaw_speed = 8;
@ -815,9 +815,9 @@ void CDeadBarney :: Spawn( )
m_bloodColor = BLOOD_COLOR_RED;
pev->sequence = LookupSequence( m_szPoses[m_iPose] );
if (pev->sequence == -1)
if( pev->sequence == -1 )
{
ALERT ( at_console, "Dead barney with bad pose\n" );
ALERT( at_console, "Dead barney with bad pose\n" );
}
// Corpses have less health
pev->health = 8;//gSkillData.barneyHealth;

146
dlls/basemonster.h
View File

@ -34,13 +34,11 @@ public:
SCRIPT_RUN_TO_MARK
} SCRIPTSTATE;
// these fields have been added in the process of reworking the state machine. (sjb)
EHANDLE m_hEnemy; // the entity that the monster is fighting.
EHANDLE m_hTargetEnt; // the entity that the monster is trying to reach
EHANDLE m_hOldEnemy[ MAX_OLD_ENEMIES ];
Vector m_vecOldEnemy[ MAX_OLD_ENEMIES ];
EHANDLE m_hOldEnemy[MAX_OLD_ENEMIES];
Vector m_vecOldEnemy[MAX_OLD_ENEMIES];
float m_flFieldOfView;// width of monster's field of view ( dot product )
float m_flWaitFinished;// if we're told to wait, this is the time that the wait will be over.
@ -58,7 +56,7 @@ public:
Schedule_t *m_pSchedule;
int m_iScheduleIndex;
WayPoint_t m_Route[ ROUTE_SIZE ]; // Positions of movement
WayPoint_t m_Route[ROUTE_SIZE]; // Positions of movement
int m_movementGoal; // Goal that defines route
int m_iRouteIndex; // index into m_Route[]
float m_moveWaitTime; // How long I should wait for something to move
@ -110,7 +108,6 @@ public:
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
void KeyValue( KeyValueData *pkvd );
@ -120,38 +117,37 @@ public:
void EXPORT CorpseUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
// overrideable Monster member functions
virtual int BloodColor( void ) { return m_bloodColor; }
virtual CBaseMonster *MyMonsterPointer( void ) { return this; }
virtual void Look ( int iDistance );// basic sight function for monsters
virtual void RunAI ( void );// core ai function!
void Listen ( void );
virtual void Look( int iDistance );// basic sight function for monsters
virtual void RunAI( void );// core ai function!
void Listen( void );
virtual BOOL IsAlive( void ) { return (pev->deadflag != DEAD_DEAD); }
virtual BOOL IsAlive( void ) { return ( pev->deadflag != DEAD_DEAD ); }
virtual BOOL ShouldFadeOnDeath( void );
// Basic Monster AI functions
virtual float ChangeYaw ( int speed );
virtual float ChangeYaw( int speed );
float VecToYaw( Vector vecDir );
float FlYawDiff ( void );
float FlYawDiff( void );
float DamageForce( float damage );
// stuff written for new state machine
virtual void MonsterThink( void );
void EXPORT CallMonsterThink( void ) { this->MonsterThink(); }
virtual int IRelationship ( CBaseEntity *pTarget );
virtual void MonsterInit ( void );
virtual int IRelationship( CBaseEntity *pTarget );
virtual void MonsterInit( void );
virtual void MonsterInitDead( void ); // Call after animation/pose is set up
virtual void BecomeDead( void );
void EXPORT CorpseFallThink( void );
void EXPORT MonsterInitThink ( void );
virtual void StartMonster ( void );
virtual CBaseEntity* BestVisibleEnemy ( void );// finds best visible enemy for attack
virtual BOOL FInViewCone ( CBaseEntity *pEntity );// see if pEntity is in monster's view cone
virtual BOOL FInViewCone ( Vector *pOrigin );// see if given location is in monster's view cone
void EXPORT MonsterInitThink( void );
virtual void StartMonster( void );
virtual CBaseEntity *BestVisibleEnemy( void );// finds best visible enemy for attack
virtual BOOL FInViewCone( CBaseEntity *pEntity );// see if pEntity is in monster's view cone
virtual BOOL FInViewCone( Vector *pOrigin );// see if given location is in monster's view cone
virtual void HandleAnimEvent( MonsterEvent_t *pEvent );
virtual int CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist );// check validity of a straight move through space
@ -172,19 +168,19 @@ public:
virtual BOOL CheckMeleeAttack2( float flDot, float flDist );
BOOL FHaveSchedule( void );
BOOL FScheduleValid ( void );
BOOL FScheduleValid( void );
void ClearSchedule( void );
BOOL FScheduleDone ( void );
void ChangeSchedule ( Schedule_t *pNewSchedule );
void NextScheduledTask ( void );
BOOL FScheduleDone( void );
void ChangeSchedule( Schedule_t *pNewSchedule );
void NextScheduledTask( void );
Schedule_t *ScheduleInList( const char *pName, Schedule_t **pList, int listCount );
virtual Schedule_t *ScheduleFromName( const char *pName );
static Schedule_t *m_scheduleList[];
void MaintainSchedule ( void );
virtual void StartTask ( Task_t *pTask );
virtual void RunTask ( Task_t *pTask );
void MaintainSchedule( void );
virtual void StartTask( Task_t *pTask );
virtual void RunTask( Task_t *pTask );
virtual Schedule_t *GetScheduleOfType( int Type );
virtual Schedule_t *GetSchedule( void );
virtual void ScheduleChange( void ) {}
@ -196,49 +192,49 @@ public:
virtual void SentenceStop( void );
Task_t *GetTask ( void );
virtual MONSTERSTATE GetIdealState ( void );
virtual void SetActivity ( Activity NewActivity );
void SetSequenceByName ( char *szSequence );
void SetState ( MONSTERSTATE State );
Task_t *GetTask( void );
virtual MONSTERSTATE GetIdealState( void );
virtual void SetActivity( Activity NewActivity );
void SetSequenceByName( char *szSequence );
void SetState( MONSTERSTATE State );
virtual void ReportAIState( void );
void CheckAttacks ( CBaseEntity *pTarget, float flDist );
virtual int CheckEnemy ( CBaseEntity *pEnemy );
void CheckAttacks( CBaseEntity *pTarget, float flDist );
virtual int CheckEnemy( CBaseEntity *pEnemy );
void PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos );
BOOL PopEnemy( void );
BOOL FGetNodeRoute ( Vector vecDest );
BOOL FGetNodeRoute( Vector vecDest );
inline void TaskComplete( void ) { if ( !HasConditions(bits_COND_TASK_FAILED) ) m_iTaskStatus = TASKSTATUS_COMPLETE; }
inline void TaskComplete( void ) { if ( !HasConditions( bits_COND_TASK_FAILED ) ) m_iTaskStatus = TASKSTATUS_COMPLETE; }
void MovementComplete( void );
inline void TaskFail( void ) { SetConditions(bits_COND_TASK_FAILED); }
inline void TaskFail( void ) { SetConditions( bits_COND_TASK_FAILED ); }
inline void TaskBegin( void ) { m_iTaskStatus = TASKSTATUS_RUNNING; }
int TaskIsRunning( void );
inline int TaskIsComplete( void ) { return (m_iTaskStatus == TASKSTATUS_COMPLETE); }
inline int MovementIsComplete( void ) { return (m_movementGoal == MOVEGOAL_NONE); }
inline int TaskIsComplete( void ) { return ( m_iTaskStatus == TASKSTATUS_COMPLETE ); }
inline int MovementIsComplete( void ) { return ( m_movementGoal == MOVEGOAL_NONE ); }
int IScheduleFlags ( void );
int IScheduleFlags( void );
BOOL FRefreshRoute( void );
BOOL FRouteClear ( void );
BOOL FRouteClear( void );
void RouteSimplify( CBaseEntity *pTargetEnt );
void AdvanceRoute ( float distance );
virtual BOOL FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex );
void AdvanceRoute( float distance );
virtual BOOL FTriangulate( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex );
void MakeIdealYaw( Vector vecTarget );
virtual void SetYawSpeed ( void ) { return; };// allows different yaw_speeds for each activity
BOOL BuildRoute ( const Vector &vecGoal, int iMoveFlag, CBaseEntity *pTarget );
virtual BOOL BuildNearestRoute ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
virtual void SetYawSpeed( void ) { return; };// allows different yaw_speeds for each activity
BOOL BuildRoute( const Vector &vecGoal, int iMoveFlag, CBaseEntity *pTarget );
virtual BOOL BuildNearestRoute( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
int RouteClassify( int iMoveFlag );
void InsertWaypoint ( Vector vecLocation, int afMoveFlags );
void InsertWaypoint( Vector vecLocation, int afMoveFlags );
BOOL FindLateralCover ( const Vector &vecThreat, const Vector &vecViewOffset );
virtual BOOL FindCover ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
virtual BOOL FValidateCover ( const Vector &vecCoverLocation ) { return TRUE; };
BOOL FindLateralCover( const Vector &vecThreat, const Vector &vecViewOffset );
virtual BOOL FindCover( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist );
virtual BOOL FValidateCover( const Vector &vecCoverLocation ) { return TRUE; };
virtual float CoverRadius( void ) { return 784; } // Default cover radius
virtual BOOL FCanCheckAttacks ( void );
virtual BOOL FCanCheckAttacks( void );
virtual void CheckAmmo( void ) { return; };
virtual int IgnoreConditions ( void );
virtual int IgnoreConditions( void );
inline void SetConditions( int iConditions ) { m_afConditions |= iConditions; }
inline void ClearConditions( int iConditions ) { m_afConditions &= ~iConditions; }
@ -246,10 +242,10 @@ public:
inline BOOL HasAllConditions( int iConditions ) { if ( (m_afConditions & iConditions) == iConditions ) return TRUE; return FALSE; }
virtual BOOL FValidateHintType( short sHint );
int FindHintNode ( void );
virtual BOOL FCanActiveIdle ( void );
void SetTurnActivity ( void );
float FLSoundVolume ( CSound *pSound );
int FindHintNode( void );
virtual BOOL FCanActiveIdle( void );
void SetTurnActivity( void );
float FLSoundVolume( CSound *pSound );
BOOL MoveToNode( Activity movementAct, float waitTime, const Vector &goal );
BOOL MoveToTarget( Activity movementAct, float waitTime );
@ -260,18 +256,18 @@ public:
float OpenDoorAndWait( entvars_t *pevDoor );
virtual int ISoundMask( void );
virtual CSound* PBestSound ( void );
virtual CSound* PBestScent ( void );
virtual CSound* PBestSound( void );
virtual CSound* PBestScent( void );
virtual float HearingSensitivity( void ) { return 1.0; };
BOOL FBecomeProne ( void );
BOOL FBecomeProne( void );
virtual void BarnacleVictimBitten( entvars_t *pevBarnacle );
virtual void BarnacleVictimReleased( void );
void SetEyePosition ( void );
void SetEyePosition( void );
BOOL FShouldEat( void );// see if a monster is 'hungry'
void Eat ( float flFullDuration );// make the monster 'full' for a while.
void Eat( float flFullDuration );// make the monster 'full' for a while.
CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
BOOL FacingIdeal( void );
@ -284,13 +280,13 @@ public:
// PrescheduleThink
virtual void PrescheduleThink( void ) { return; };
BOOL GetEnemy ( void );
void MakeDamageBloodDecal ( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir );
BOOL GetEnemy( void );
void MakeDamageBloodDecal( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir );
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
// combat functions
float UpdateTarget ( entvars_t *pevTarget );
virtual Activity GetDeathActivity ( void );
float UpdateTarget( entvars_t *pevTarget );
virtual Activity GetDeathActivity( void );
Activity GetSmallFlinchActivity( void );
virtual void Killed( entvars_t *pevAttacker, int iGib );
virtual void GibMonster( void );
@ -301,25 +297,25 @@ public:
virtual void FadeMonster( void ); // Called instead of GibMonster() when gibs are disabled
Vector ShootAtEnemy( const Vector &shootOrigin );
virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ) * 0.75 + EyePosition() * 0.25; }; // position to shoot at
virtual Vector BodyTarget( const Vector &posSrc ) { return Center() * 0.75 + EyePosition() * 0.25; }; // position to shoot at
virtual Vector GetGunPosition( void );
virtual int TakeHealth( float flHealth, int bitsDamageType );
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType);
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
int DeadTakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
void RadiusDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
void RadiusDamage(Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
void RadiusDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
void RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType );
virtual int IsMoving( void ) { return m_movementGoal != MOVEGOAL_NONE; }
void RouteClear( void );
void RouteNew( void );
virtual void DeathSound ( void ) { return; };
virtual void AlertSound ( void ) { return; };
virtual void IdleSound ( void ) { return; };
virtual void PainSound ( void ) { return; };
virtual void DeathSound( void ) { return; };
virtual void AlertSound( void ) { return; };
virtual void IdleSound( void ) { return; };
virtual void PainSound( void ) { return; };
virtual void StopFollowing( BOOL clearSchedule ) {}
@ -328,8 +324,8 @@ public:
inline BOOL HasMemory( int iMemory ) { if ( m_afMemory & iMemory ) return TRUE; return FALSE; }
inline BOOL HasAllMemories( int iMemory ) { if ( (m_afMemory & iMemory) == iMemory ) return TRUE; return FALSE; }
BOOL ExitScriptedSequence( );
BOOL CineCleanup( );
BOOL ExitScriptedSequence();
BOOL CineCleanup();
CBaseEntity* DropItem ( char *pszItemName, const Vector &vecPos, const Vector &vecAng );// drop an item.
};

316
dlls/bigmomma.cpp
View File

@ -17,6 +17,7 @@
//=========================================================
// monster template
//=========================================================
#include "extdll.h"
#include "util.h"
#include "cbase.h"
@ -66,29 +67,29 @@ void CInfoBM::Spawn( void )
void CInfoBM::KeyValue( KeyValueData* pkvd )
{
if (FStrEq(pkvd->szKeyName, "radius"))
if( FStrEq( pkvd->szKeyName, "radius" ) )
{
pev->scale = atof(pkvd->szValue);
pev->scale = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "reachdelay"))
else if( FStrEq( pkvd->szKeyName, "reachdelay" ) )
{
pev->speed = atof(pkvd->szValue);
pev->speed = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "reachtarget"))
else if( FStrEq( pkvd->szKeyName, "reachtarget" ) )
{
pev->message = ALLOC_STRING(pkvd->szValue);
pev->message = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "reachsequence"))
else if( FStrEq( pkvd->szKeyName, "reachsequence" ) )
{
pev->netname = ALLOC_STRING(pkvd->szValue);
pev->netname = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "presequence"))
else if( FStrEq( pkvd->szKeyName, "presequence" ) )
{
m_preSequence = ALLOC_STRING(pkvd->szValue);
m_preSequence = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -153,10 +154,10 @@ IMPLEMENT_SAVERESTORE( CBMortar, CBaseEntity )
#define BIG_MORTARDIST 800
#define BIG_MAXCHILDREN 20 // Max # of live headcrab children
#define bits_MEMORY_CHILDPAIR (bits_MEMORY_CUSTOM1)
#define bits_MEMORY_ADVANCE_NODE (bits_MEMORY_CUSTOM2)
#define bits_MEMORY_COMPLETED_NODE (bits_MEMORY_CUSTOM3)
#define bits_MEMORY_FIRED_NODE (bits_MEMORY_CUSTOM4)
#define bits_MEMORY_CHILDPAIR ( bits_MEMORY_CUSTOM1 )
#define bits_MEMORY_ADVANCE_NODE ( bits_MEMORY_CUSTOM2 )
#define bits_MEMORY_COMPLETED_NODE ( bits_MEMORY_CUSTOM3 )
#define bits_MEMORY_FIRED_NODE ( bits_MEMORY_CUSTOM4 )
int gSpitSprite, gSpitDebrisSprite;
Vector VecCheckSplatToss( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float maxHeight );
@ -186,25 +187,24 @@ public:
BOOL ShouldGoToNode( void );
void SetYawSpeed( void );
int Classify ( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
void LayHeadcrab( void );
int GetNodeSequence( void )
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( pTarget )
if( pTarget )
{
return pTarget->pev->netname; // netname holds node sequence
}
return 0;
}
int GetNodePresequence( void )
{
CInfoBM *pTarget = (CInfoBM *)(CBaseEntity *)m_hTargetEnt;
if ( pTarget )
if( pTarget )
{
return pTarget->m_preSequence;
}
@ -214,7 +214,7 @@ public:
float GetNodeDelay( void )
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( pTarget )
if( pTarget )
{
return pTarget->pev->speed; // Speed holds node delay
}
@ -224,7 +224,7 @@ public:
float GetNodeRange( void )
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( pTarget )
if( pTarget )
{
return pTarget->pev->scale; // Scale holds node delay
}
@ -234,9 +234,9 @@ public:
float GetNodeYaw( void )
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( pTarget )
if( pTarget )
{
if ( pTarget->pev->angles.y != 0 )
if( pTarget->pev->angles.y != 0 )
return pTarget->pev->angles.y;
}
return pev->angles.y;
@ -252,7 +252,7 @@ public:
BOOL CanLayCrab( void )
{
if ( m_crabTime < gpGlobals->time && m_crabCount < BIG_MAXCHILDREN )
if( m_crabTime < gpGlobals->time && m_crabCount < BIG_MAXCHILDREN )
{
// Don't spawn crabs inside each other
Vector mins = pev->origin - Vector( 32, 32, 0 );
@ -260,9 +260,9 @@ public:
CBaseEntity *pList[2];
int count = UTIL_EntitiesInBox( pList, 2, mins, maxs, FL_MONSTER );
for ( int i = 0; i < count; i++ )
for( int i = 0; i < count; i++ )
{
if ( pList[i] != this ) // Don't hurt yourself!
if( pList[i] != this ) // Don't hurt yourself!
return FALSE;
}
return TRUE;
@ -381,12 +381,12 @@ const char *CBigMomma::pFootSounds[] =
"gonarch/gon_step3.wav",
};
void CBigMomma :: KeyValue( KeyValueData *pkvd )
void CBigMomma::KeyValue( KeyValueData *pkvd )
{
#if 0
if (FStrEq(pkvd->szKeyName, "volume"))
if( FStrEq( pkvd->szKeyName, "volume" ) )
{
m_volume = atof(pkvd->szValue);
m_volume = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -398,7 +398,7 @@ void CBigMomma :: KeyValue( KeyValueData *pkvd )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CBigMomma :: Classify ( void )
int CBigMomma::Classify( void )
{
return CLASS_ALIEN_MONSTER;
}
@ -407,7 +407,7 @@ int CBigMomma :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CBigMomma :: SetYawSpeed ( void )
void CBigMomma::SetYawSpeed( void )
{
int ys;
@ -428,7 +428,7 @@ void CBigMomma :: SetYawSpeed ( void )
//
// Returns number of events handled, 0 if none.
//=========================================================
void CBigMomma :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CBigMomma::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -445,117 +445,101 @@ void CBigMomma :: HandleAnimEvent( MonsterEvent_t *pEvent )
Vector maxs = center + Vector( 64, 64, 64 );
CBaseEntity *pList[8];
int count = UTIL_EntitiesInBox( pList, 8, mins, maxs, FL_MONSTER|FL_CLIENT );
int count = UTIL_EntitiesInBox( pList, 8, mins, maxs, FL_MONSTER | FL_CLIENT );
CBaseEntity *pHurt = NULL;
for ( int i = 0; i < count && !pHurt; i++ )
for( int i = 0; i < count && !pHurt; i++ )
{
if ( pList[i] != this )
if( pList[i] != this )
{
if ( pList[i]->pev->owner != edict() )
if( pList[i]->pev->owner != edict() )
pHurt = pList[i];
}
}
if ( pHurt )
if( pHurt )
{
pHurt->TakeDamage( pev, pev, gSkillData.bigmommaDmgSlash, DMG_CRUSH | DMG_SLASH );
pHurt->pev->punchangle.x = 15;
switch( pEvent->event )
{
case BIG_AE_MELEE_ATTACKBR:
pHurt->pev->velocity = pHurt->pev->velocity + (forward * 150) + Vector(0,0,250) - (right * 200);
pHurt->pev->velocity = pHurt->pev->velocity + ( forward * 150 ) + Vector( 0, 0, 250 ) - ( right * 200 );
break;
case BIG_AE_MELEE_ATTACKBL:
pHurt->pev->velocity = pHurt->pev->velocity + (forward * 150) + Vector(0,0,250) + (right * 200);
pHurt->pev->velocity = pHurt->pev->velocity + ( forward * 150 ) + Vector( 0, 0, 250 ) + ( right * 200 );
break;
case BIG_AE_MELEE_ATTACK1:
pHurt->pev->velocity = pHurt->pev->velocity + (forward * 220) + Vector(0,0,200);
pHurt->pev->velocity = pHurt->pev->velocity + ( forward * 220 ) + Vector( 0, 0, 200 );
break;
}
pHurt->pev->flags &= ~FL_ONGROUND;
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY(pAttackHitSounds), 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY( pAttackHitSounds ), 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG( -5, 5 ) );
}
}
break;
case BIG_AE_SCREAM:
EMIT_SOUND_ARRAY_DYN( CHAN_VOICE, pAlertSounds );
break;
case BIG_AE_PAIN_SOUND:
EMIT_SOUND_ARRAY_DYN( CHAN_VOICE, pPainSounds );
break;
case BIG_AE_ATTACK_SOUND:
EMIT_SOUND_ARRAY_DYN( CHAN_WEAPON, pAttackSounds );
break;
case BIG_AE_BIRTH_SOUND:
EMIT_SOUND_ARRAY_DYN( CHAN_BODY, pBirthSounds );
break;
case BIG_AE_SACK:
if ( RANDOM_LONG(0,100) < 30 )
if( RANDOM_LONG( 0, 100 ) < 30 )
EMIT_SOUND_ARRAY_DYN( CHAN_BODY, pSackSounds );
break;
case BIG_AE_DEATHSOUND:
EMIT_SOUND_ARRAY_DYN( CHAN_VOICE, pDeathSounds );
break;
case BIG_AE_STEP1: // Footstep left
case BIG_AE_STEP3: // Footstep back left
EMIT_SOUND_ARRAY_DYN( CHAN_ITEM, pFootSounds );
break;
case BIG_AE_STEP4: // Footstep back right
case BIG_AE_STEP2: // Footstep right
EMIT_SOUND_ARRAY_DYN( CHAN_BODY, pFootSounds );
break;
case BIG_AE_MORTAR_ATTACK1:
LaunchMortar();
break;
case BIG_AE_LAY_CRAB:
LayHeadcrab();
break;
case BIG_AE_JUMP_FORWARD:
ClearBits( pev->flags, FL_ONGROUND );
UTIL_SetOrigin (pev, pev->origin + Vector ( 0 , 0 , 1) );// take him off ground so engine doesn't instantly reset onground
UTIL_MakeVectors ( pev->angles );
UTIL_SetOrigin( pev, pev->origin + Vector( 0, 0, 1) );// take him off ground so engine doesn't instantly reset onground
UTIL_MakeVectors( pev->angles );
pev->velocity = (gpGlobals->v_forward * 200) + gpGlobals->v_up * 500;
pev->velocity = gpGlobals->v_forward * 200 + gpGlobals->v_up * 500;
break;
case BIG_AE_EARLY_TARGET:
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( pTarget && pTarget->pev->message )
FireTargets( STRING(pTarget->pev->message), this, this, USE_TOGGLE, 0 );
if( pTarget && pTarget->pev->message )
FireTargets( STRING( pTarget->pev->message ), this, this, USE_TOGGLE, 0 );
Remember( bits_MEMORY_FIRED_NODE );
}
break;
default:
CBaseMonster::HandleAnimEvent( pEvent );
break;
}
}
void CBigMomma :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
void CBigMomma::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
{
if ( ptr->iHitgroup != 1 )
if( ptr->iHitgroup != 1 )
{
// didn't hit the sack?
if ( pev->dmgtime != gpGlobals->time || (RANDOM_LONG(0,10) < 1) )
if( pev->dmgtime != gpGlobals->time || ( RANDOM_LONG( 0, 10 ) < 1 ) )
{
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT( 1, 2) );
pev->dmgtime = gpGlobals->time;
@ -563,24 +547,24 @@ void CBigMomma :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector ve
flDamage = 0.1;// don't hurt the monster much, but allow bits_COND_LIGHT_DAMAGE to be generated
}
else if ( gpGlobals->time > m_painSoundTime )
else if( gpGlobals->time > m_painSoundTime )
{
m_painSoundTime = gpGlobals->time + RANDOM_LONG(1, 3);
m_painSoundTime = gpGlobals->time + RANDOM_LONG( 1, 3 );
EMIT_SOUND_ARRAY_DYN( CHAN_VOICE, pPainSounds );
}
CBaseMonster::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
}
int CBigMomma :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
int CBigMomma::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
// Don't take any acid damage -- BigMomma's mortar is acid
if ( bitsDamageType & DMG_ACID )
if( bitsDamageType & DMG_ACID )
flDamage = 0;
if ( !HasMemory(bits_MEMORY_PATH_FINISHED) )
if( !HasMemory( bits_MEMORY_PATH_FINISHED ) )
{
if ( pev->health <= flDamage )
if( pev->health <= flDamage )
{
pev->health = flDamage + 1;
Remember( bits_MEMORY_ADVANCE_NODE | bits_MEMORY_COMPLETED_NODE );
@ -591,14 +575,14 @@ int CBigMomma :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, fl
return CBaseMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}
void CBigMomma :: LayHeadcrab( void )
void CBigMomma::LayHeadcrab( void )
{
CBaseEntity *pChild = CBaseEntity::Create( BIG_CHILDCLASS, pev->origin, pev->angles, edict() );
pChild->pev->spawnflags |= SF_MONSTER_FALL_TO_GROUND;
// Is this the second crab in a pair?
if ( HasMemory( bits_MEMORY_CHILDPAIR ) )
if( HasMemory( bits_MEMORY_CHILDPAIR ) )
{
m_crabTime = gpGlobals->time + RANDOM_FLOAT( 5, 10 );
Forget( bits_MEMORY_CHILDPAIR );
@ -610,18 +594,18 @@ void CBigMomma :: LayHeadcrab( void )
}
TraceResult tr;
UTIL_TraceLine( pev->origin, pev->origin - Vector(0,0,100), ignore_monsters, edict(), &tr);
UTIL_TraceLine( pev->origin, pev->origin - Vector( 0, 0, 100 ), ignore_monsters, edict(), &tr );
UTIL_DecalTrace( &tr, DECAL_MOMMABIRTH );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY(pBirthSounds), 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY( pBirthSounds ), 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG( -5, 5 ) );
m_crabCount++;
}
void CBigMomma::DeathNotice( entvars_t *pevChild )
{
if ( m_crabCount > 0 ) // Some babies may cross a transition, but we reset the count then
if( m_crabCount > 0 ) // Some babies may cross a transition, but we reset the count then
m_crabCount--;
if ( IsAlive() )
if( IsAlive() )
{
// Make the "my baby's dead" noise!
EMIT_SOUND_ARRAY_DYN( CHAN_WEAPON, pChildDieSounds );
@ -635,27 +619,27 @@ void CBigMomma::LaunchMortar( void )
Vector startPos = pev->origin;
startPos.z += 180;
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY(pSackSounds), 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG(-5,5) );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY( pSackSounds ), 1.0, ATTN_NORM, 0, 100 + RANDOM_LONG( -5, 5 ) );
CBMortar *pBomb = CBMortar::Shoot( edict(), startPos, pev->movedir );
pBomb->pev->gravity = 1.0;
MortarSpray( startPos, Vector(0,0,1), gSpitSprite, 24 );
MortarSpray( startPos, Vector( 0, 0, 1 ), gSpitSprite, 24 );
}
//=========================================================
// Spawn
//=========================================================
void CBigMomma :: Spawn()
void CBigMomma::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/big_mom.mdl");
SET_MODEL( ENT( pev ), "models/big_mom.mdl" );
UTIL_SetSize( pev, Vector( -32, -32, 0 ), Vector( 32, 32, 64 ) );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->health = 150 * gSkillData.bigmommaHealthFactor;
pev->view_ofs = Vector ( 0, 0, 128 );// position of the eyes relative to monster's origin.
pev->view_ofs = Vector( 0, 0, 128 );// position of the eyes relative to monster's origin.
m_flFieldOfView = 0.3;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
@ -665,9 +649,9 @@ void CBigMomma :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CBigMomma :: Precache()
void CBigMomma::Precache()
{
PRECACHE_MODEL("models/big_mom.mdl");
PRECACHE_MODEL( "models/big_mom.mdl" );
PRECACHE_SOUND_ARRAY( pChildDieSounds );
PRECACHE_SOUND_ARRAY( pSackSounds );
@ -682,9 +666,9 @@ void CBigMomma :: Precache()
UTIL_PrecacheOther( BIG_CHILDCLASS );
// TEMP: Squid
PRECACHE_MODEL("sprites/mommaspit.spr");// spit projectile.
gSpitSprite = PRECACHE_MODEL("sprites/mommaspout.spr");// client side spittle.
gSpitDebrisSprite = PRECACHE_MODEL("sprites/mommablob.spr" );
PRECACHE_MODEL( "sprites/mommaspit.spr" );// spit projectile.
gSpitSprite = PRECACHE_MODEL( "sprites/mommaspout.spr" );// client side spittle.
gSpitDebrisSprite = PRECACHE_MODEL( "sprites/mommablob.spr" );
PRECACHE_SOUND( "bullchicken/bc_acid1.wav" );
PRECACHE_SOUND( "bullchicken/bc_spithit1.wav" );
@ -693,7 +677,7 @@ void CBigMomma :: Precache()
void CBigMomma::Activate( void )
{
if ( m_hTargetEnt == NULL )
if( m_hTargetEnt == NULL )
Remember( bits_MEMORY_ADVANCE_NODE ); // Start 'er up
}
@ -703,16 +687,15 @@ void CBigMomma::NodeStart( int iszNextNode )
CBaseEntity *pTarget = NULL;
if ( pev->netname )
if( pev->netname )
{
edict_t *pentTarget = FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(pev->netname) );
edict_t *pentTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING( pev->netname ) );
if ( !FNullEnt(pentTarget) )
if( !FNullEnt( pentTarget ) )
pTarget = Instance( pentTarget );
}
if ( !pTarget )
if( !pTarget )
{
ALERT( at_aiconsole, "BM: Finished the path!!\n" );
Remember( bits_MEMORY_PATH_FINISHED );
@ -728,30 +711,30 @@ void CBigMomma::NodeReach( void )
Forget( bits_MEMORY_ADVANCE_NODE );
if ( !pTarget )
if( !pTarget )
return;
if ( pTarget->pev->health )
if( pTarget->pev->health )
pev->max_health = pev->health = pTarget->pev->health * gSkillData.bigmommaHealthFactor;
if ( !HasMemory( bits_MEMORY_FIRED_NODE ) )
if( !HasMemory( bits_MEMORY_FIRED_NODE ) )
{
if ( pTarget->pev->message )
FireTargets( STRING(pTarget->pev->message), this, this, USE_TOGGLE, 0 );
if( pTarget->pev->message )
FireTargets( STRING( pTarget->pev->message ), this, this, USE_TOGGLE, 0 );
}
Forget( bits_MEMORY_FIRED_NODE );
pev->netname = pTarget->pev->target;
if ( pTarget->pev->health == 0 )
if( pTarget->pev->health == 0 )
Remember( bits_MEMORY_ADVANCE_NODE ); // Move on if no health at this node
}
// Slash
BOOL CBigMomma::CheckMeleeAttack1( float flDot, float flDist )
{
if (flDot >= 0.7)
if( flDot >= 0.7 )
{
if ( flDist <= BIG_ATTACKDIST )
if( flDist <= BIG_ATTACKDIST )
return TRUE;
}
return FALSE;
@ -763,20 +746,19 @@ BOOL CBigMomma::CheckMeleeAttack2( float flDot, float flDist )
return CanLayCrab();
}
// Mortar launch
BOOL CBigMomma::CheckRangeAttack1( float flDot, float flDist )
{
if ( flDist <= BIG_MORTARDIST && m_mortarTime < gpGlobals->time )
if( flDist <= BIG_MORTARDIST && m_mortarTime < gpGlobals->time )
{
CBaseEntity *pEnemy = m_hEnemy;
if ( pEnemy )
if( pEnemy )
{
Vector startPos = pev->origin;
startPos.z += 180;
pev->movedir = VecCheckSplatToss( pev, startPos, pEnemy->BodyTarget( pev->origin ), RANDOM_FLOAT( 150, 500 ) );
if ( pev->movedir != g_vecZero )
if( pev->movedir != g_vecZero )
return TRUE;
}
}
@ -786,7 +768,6 @@ BOOL CBigMomma::CheckRangeAttack1( float flDot, float flDist )
//=========================================================
// AI Schedules Specific to this monster
//=========================================================
enum
{
SCHED_BIG_NODE = LAST_COMMON_SCHEDULE + 1,
@ -810,7 +791,7 @@ Task_t tlBigNode[] =
{ TASK_SET_FAIL_SCHEDULE, (float)SCHED_NODE_FAIL },
{ TASK_STOP_MOVING, (float)0 },
{ TASK_FIND_NODE, (float)0 }, // Find my next node
{ TASK_PLAY_NODE_PRESEQUENCE,(float)0 }, // Play the pre-approach sequence if any
{ TASK_PLAY_NODE_PRESEQUENCE, (float)0 }, // Play the pre-approach sequence if any
{ TASK_MOVE_TO_NODE_RANGE, (float)0 }, // Move within node range
{ TASK_STOP_MOVING, (float)0 },
{ TASK_NODE_YAW, (float)0 },
@ -825,7 +806,7 @@ Schedule_t slBigNode[] =
{
{
tlBigNode,
ARRAYSIZE ( tlBigNode ),
ARRAYSIZE( tlBigNode ),
0,
0,
"Big Node"
@ -842,7 +823,7 @@ Schedule_t slNodeFail[] =
{
{
tlNodeFail,
ARRAYSIZE ( tlNodeFail ),
ARRAYSIZE( tlNodeFail ),
0,
0,
"NodeFail"
@ -864,7 +845,6 @@ Schedule_t *CBigMomma::GetScheduleOfType( int Type )
case SCHED_BIG_NODE:
return slBigNode;
break;
case SCHED_NODE_FAIL:
return slNodeFail;
break;
@ -875,9 +855,9 @@ Schedule_t *CBigMomma::GetScheduleOfType( int Type )
BOOL CBigMomma::ShouldGoToNode( void )
{
if ( HasMemory( bits_MEMORY_ADVANCE_NODE ) )
if( HasMemory( bits_MEMORY_ADVANCE_NODE ) )
{
if ( m_nodeTime < gpGlobals->time )
if( m_nodeTime < gpGlobals->time )
return TRUE;
}
return FALSE;
@ -885,7 +865,7 @@ BOOL CBigMomma::ShouldGoToNode( void )
Schedule_t *CBigMomma::GetSchedule( void )
{
if ( ShouldGoToNode() )
if( ShouldGoToNode() )
{
return GetScheduleOfType( SCHED_BIG_NODE );
}
@ -895,107 +875,99 @@ Schedule_t *CBigMomma::GetSchedule( void )
void CBigMomma::StartTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_FIND_NODE:
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( !HasMemory( bits_MEMORY_ADVANCE_NODE ) )
if( !HasMemory( bits_MEMORY_ADVANCE_NODE ) )
{
if ( pTarget )
if( pTarget )
pev->netname = m_hTargetEnt->pev->target;
}
NodeStart( pev->netname );
TaskComplete();
ALERT( at_aiconsole, "BM: Found node %s\n", STRING(pev->netname) );
ALERT( at_aiconsole, "BM: Found node %s\n", STRING( pev->netname ) );
}
break;
case TASK_NODE_DELAY:
m_nodeTime = gpGlobals->time + pTask->flData;
TaskComplete();
ALERT( at_aiconsole, "BM: FAIL! Delay %.2f\n", pTask->flData );
break;
case TASK_PROCESS_NODE:
ALERT( at_aiconsole, "BM: Reached node %s\n", STRING(pev->netname) );
ALERT( at_aiconsole, "BM: Reached node %s\n", STRING( pev->netname ) );
NodeReach();
TaskComplete();
break;
case TASK_PLAY_NODE_PRESEQUENCE:
case TASK_PLAY_NODE_SEQUENCE:
{
int sequence;
if ( pTask->iTask == TASK_PLAY_NODE_SEQUENCE )
if( pTask->iTask == TASK_PLAY_NODE_SEQUENCE )
sequence = GetNodeSequence();
else
sequence = GetNodePresequence();
ALERT( at_aiconsole, "BM: Playing node sequence %s\n", STRING(sequence) );
if ( sequence )
ALERT( at_aiconsole, "BM: Playing node sequence %s\n", STRING( sequence ) );
if( sequence )
{
sequence = LookupSequence( STRING( sequence ) );
if ( sequence != -1 )
if( sequence != -1 )
{
pev->sequence = sequence;
pev->frame = 0;
ResetSequenceInfo( );
ALERT( at_aiconsole, "BM: Sequence %s\n", STRING(GetNodeSequence()) );
ResetSequenceInfo();
ALERT( at_aiconsole, "BM: Sequence %s\n", STRING( GetNodeSequence() ) );
return;
}
}
TaskComplete();
}
break;
case TASK_NODE_YAW:
pev->ideal_yaw = GetNodeYaw();
TaskComplete();
break;
case TASK_WAIT_NODE:
m_flWait = gpGlobals->time + GetNodeDelay();
if ( m_hTargetEnt->pev->spawnflags & SF_INFOBM_WAIT )
ALERT( at_aiconsole, "BM: Wait at node %s forever\n", STRING(pev->netname) );
if( m_hTargetEnt->pev->spawnflags & SF_INFOBM_WAIT )
ALERT( at_aiconsole, "BM: Wait at node %s forever\n", STRING( pev->netname ) );
else
ALERT( at_aiconsole, "BM: Wait at node %s for %.2f\n", STRING(pev->netname), GetNodeDelay() );
ALERT( at_aiconsole, "BM: Wait at node %s for %.2f\n", STRING( pev->netname ), GetNodeDelay() );
break;
case TASK_MOVE_TO_NODE_RANGE:
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( !pTarget )
if( !pTarget )
TaskFail();
else
{
if ( (pTarget->pev->origin - pev->origin).Length() < GetNodeRange() )
if( ( pTarget->pev->origin - pev->origin ).Length() < GetNodeRange() )
TaskComplete();
else
{
Activity act = ACT_WALK;
if ( pTarget->pev->spawnflags & SF_INFOBM_RUN )
if( pTarget->pev->spawnflags & SF_INFOBM_RUN )
act = ACT_RUN;
m_vecMoveGoal = pTarget->pev->origin;
if ( !MoveToTarget( act, 2 ) )
if( !MoveToTarget( act, 2 ) )
{
TaskFail();
}
}
}
}
ALERT( at_aiconsole, "BM: Moving to node %s\n", STRING(pev->netname) );
ALERT( at_aiconsole, "BM: Moving to node %s\n", STRING( pev->netname ) );
break;
case TASK_MELEE_ATTACK1:
// Play an attack sound here
EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, RANDOM_SOUND_ARRAY(pAttackSounds), 1.0, ATTN_NORM, 0, PITCH_NORM );
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, RANDOM_SOUND_ARRAY( pAttackSounds ), 1.0, ATTN_NORM, 0, PITCH_NORM );
CBaseMonster::StartTask( pTask );
break;
default:
CBaseMonster::StartTask( pTask );
break;
@ -1007,20 +979,20 @@ void CBigMomma::StartTask( Task_t *pTask )
//=========================================================
void CBigMomma::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_MOVE_TO_NODE_RANGE:
{
float distance;
if ( m_hTargetEnt == NULL )
if( m_hTargetEnt == NULL )
TaskFail();
else
{
distance = ( m_vecMoveGoal - pev->origin ).Length2D();
// Set the appropriate activity based on an overlapping range
// overlap the range to prevent oscillation
if ( (distance < GetNodeRange()) || MovementIsComplete() )
if( (distance < GetNodeRange() ) || MovementIsComplete() )
{
ALERT( at_aiconsole, "BM: Reached node!\n" );
TaskComplete();
@ -1030,16 +1002,16 @@ void CBigMomma::RunTask( Task_t *pTask )
}
break;
case TASK_WAIT_NODE:
if ( m_hTargetEnt != NULL && (m_hTargetEnt->pev->spawnflags & SF_INFOBM_WAIT) )
if( m_hTargetEnt != NULL && ( m_hTargetEnt->pev->spawnflags & SF_INFOBM_WAIT ) )
return;
if ( gpGlobals->time > m_flWaitFinished )
if( gpGlobals->time > m_flWaitFinished )
TaskComplete();
ALERT( at_aiconsole, "BM: The WAIT is over!\n" );
break;
case TASK_PLAY_NODE_PRESEQUENCE:
case TASK_PLAY_NODE_SEQUENCE:
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
m_Activity = ACT_RESET;
TaskComplete();
@ -1062,12 +1034,12 @@ Vector VecCheckSplatToss( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot
float flGravity = g_psv_gravity->value;
// calculate the midpoint and apex of the 'triangle'
vecMidPoint = vecSpot1 + (vecSpot2 - vecSpot1) * 0.5;
UTIL_TraceLine(vecMidPoint, vecMidPoint + Vector(0,0,maxHeight), ignore_monsters, ENT(pev), &tr);
vecMidPoint = vecSpot1 + ( vecSpot2 - vecSpot1 ) * 0.5;
UTIL_TraceLine( vecMidPoint, vecMidPoint + Vector( 0, 0, maxHeight ), ignore_monsters, ENT( pev ), &tr );
vecApex = tr.vecEndPos;
UTIL_TraceLine(vecSpot1, vecApex, dont_ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( vecSpot1, vecApex, dont_ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
// fail!
return g_vecZero;
@ -1076,13 +1048,13 @@ Vector VecCheckSplatToss( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot
// Don't worry about actually hitting the target, this won't hurt us!
// How high should the grenade travel (subtract 15 so the grenade doesn't hit the ceiling)?
float height = (vecApex.z - vecSpot1.z) - 15;
float height = vecApex.z - vecSpot1.z - 15;
// How fast does the grenade need to travel to reach that height given gravity?
float speed = sqrt( 2 * flGravity * height );
// How much time does it take to get there?
float time = speed / flGravity;
vecGrenadeVel = (vecSpot2 - vecSpot1);
vecGrenadeVel = vecSpot2 - vecSpot1;
vecGrenadeVel.z = 0;
float distance = vecGrenadeVel.Length();
@ -1103,12 +1075,12 @@ void MortarSpray( const Vector &position, const Vector &direction, int spriteMod
{
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, position );
WRITE_BYTE( TE_SPRITE_SPRAY );
WRITE_COORD( position.x); // pos
WRITE_COORD( position.y);
WRITE_COORD( position.z);
WRITE_COORD( direction.x); // dir
WRITE_COORD( direction.y);
WRITE_COORD( direction.z);
WRITE_COORD( position.x ); // pos
WRITE_COORD( position.y );
WRITE_COORD( position.z );
WRITE_COORD( direction.x ); // dir
WRITE_COORD( direction.y );
WRITE_COORD( direction.z );
WRITE_SHORT( spriteModel ); // model
WRITE_BYTE ( count ); // count
WRITE_BYTE ( 130 ); // speed
@ -1117,7 +1089,7 @@ void MortarSpray( const Vector &position, const Vector &direction, int spriteMod
}
// UNDONE: right now this is pretty much a copy of the squid spit with minor changes to the way it does damage
void CBMortar:: Spawn( void )
void CBMortar::Spawn( void )
{
pev->movetype = MOVETYPE_TOSS;
pev->classname = MAKE_STRING( "bmortar" );
@ -1126,11 +1098,11 @@ void CBMortar:: Spawn( void )
pev->rendermode = kRenderTransAlpha;
pev->renderamt = 255;
SET_MODEL(ENT(pev), "sprites/mommaspit.spr");
SET_MODEL( ENT( pev ), "sprites/mommaspit.spr" );
pev->frame = 0;
pev->scale = 0.5;
UTIL_SetSize( pev, Vector( 0, 0, 0), Vector(0, 0, 0) );
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
m_maxFrame = (float) MODEL_FRAMES( pev->modelindex ) - 1;
pev->dmgtime = gpGlobals->time + 0.4;
@ -1140,12 +1112,12 @@ void CBMortar::Animate( void )
{
pev->nextthink = gpGlobals->time + 0.1;
if ( gpGlobals->time > pev->dmgtime )
if( gpGlobals->time > pev->dmgtime )
{
pev->dmgtime = gpGlobals->time + 0.2;
MortarSpray( pev->origin, -pev->velocity.Normalize(), gSpitSprite, 3 );
}
if ( pev->frame++ )
if( pev->frame++ )
{
if ( pev->frame > m_maxFrame )
{
@ -1177,24 +1149,24 @@ void CBMortar::Touch( CBaseEntity *pOther )
// splat sound
iPitch = RANDOM_FLOAT( 90, 110 );
EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, "bullchicken/bc_acid1.wav", 1, ATTN_NORM, 0, iPitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "bullchicken/bc_acid1.wav", 1, ATTN_NORM, 0, iPitch );
switch ( RANDOM_LONG( 0, 1 ) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0:
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "bullchicken/bc_spithit1.wav", 1, ATTN_NORM, 0, iPitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "bullchicken/bc_spithit1.wav", 1, ATTN_NORM, 0, iPitch );
break;
case 1:
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "bullchicken/bc_spithit2.wav", 1, ATTN_NORM, 0, iPitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "bullchicken/bc_spithit2.wav", 1, ATTN_NORM, 0, iPitch );
break;
}
if ( pOther->IsBSPModel() )
if( pOther->IsBSPModel() )
{
// make a splat on the wall
UTIL_TraceLine( pev->origin, pev->origin + pev->velocity * 10, dont_ignore_monsters, ENT( pev ), &tr );
UTIL_DecalTrace(&tr, DECAL_MOMMASPLAT);
UTIL_DecalTrace( &tr, DECAL_MOMMASPLAT );
}
else
{
@ -1206,7 +1178,7 @@ void CBMortar::Touch( CBaseEntity *pOther )
MortarSpray( tr.vecEndPos, tr.vecPlaneNormal, gSpitSprite, 24 );
entvars_t *pevOwner = NULL;
if ( pev->owner )
if( pev->owner )
pevOwner = VARS(pev->owner);
RadiusDamage( pev->origin, pev, pevOwner, gSkillData.bigmommaDmgBlast, gSkillData.bigmommaRadiusBlast, CLASS_NONE, DMG_ACID );

72
dlls/bloater.cpp
View File

@ -33,7 +33,7 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int Classify ( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
void PainSound( void );
@ -42,8 +42,8 @@ public:
void AttackSnd( void );
// No range attacks
BOOL CheckRangeAttack1 ( float flDot, float flDist ) { return FALSE; }
BOOL CheckRangeAttack2 ( float flDot, float flDist ) { return FALSE; }
BOOL CheckRangeAttack1( float flDot, float flDist ) { return FALSE; }
BOOL CheckRangeAttack2( float flDot, float flDist ) { return FALSE; }
int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
};
@ -53,7 +53,7 @@ LINK_ENTITY_TO_CLASS( monster_bloater, CBloater )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CBloater :: Classify ( void )
int CBloater::Classify( void )
{
return CLASS_ALIEN_MONSTER;
}
@ -62,37 +62,37 @@ int CBloater :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CBloater :: SetYawSpeed ( void )
void CBloater::SetYawSpeed( void )
{
int ys;
ys = 120;
#if 0
switch ( m_Activity )
switch( m_Activity )
{
}
#endif
pev->yaw_speed = ys;
}
int CBloater :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
int CBloater::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
PainSound();
return CBaseMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}
void CBloater :: PainSound( void )
void CBloater::PainSound( void )
{
#if 0
int pitch = 95 + RANDOM_LONG(0,9);
int pitch = 95 + RANDOM_LONG( 0, 9 );
switch (RANDOM_LONG(0,5))
switch( RANDOM_LONG( 0, 5 ) )
{
case 0:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_pain1.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_pain1.wav", 1.0, ATTN_NORM, 0, pitch );
break;
case 1:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_pain2.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_pain2.wav", 1.0, ATTN_NORM, 0, pitch );
break;
default:
break;
@ -100,58 +100,58 @@ void CBloater :: PainSound( void )
#endif
}
void CBloater :: AlertSound( void )
void CBloater::AlertSound( void )
{
#if 0
int pitch = 95 + RANDOM_LONG(0,9);
int pitch = 95 + RANDOM_LONG( 0, 9 );
switch (RANDOM_LONG(0,2))
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_alert10.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_alert10.wav", 1.0, ATTN_NORM, 0, pitch );
break;
case 1:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_alert20.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_alert20.wav", 1.0, ATTN_NORM, 0, pitch );
break;
case 2:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_alert30.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_alert30.wav", 1.0, ATTN_NORM, 0, pitch );
break;
}
#endif
}
void CBloater :: IdleSound( void )
void CBloater::IdleSound( void )
{
#if 0
int pitch = 95 + RANDOM_LONG(0,9);
int pitch = 95 + RANDOM_LONG( 0, 9 );
switch (RANDOM_LONG(0,2))
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_idle1.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_idle1.wav", 1.0, ATTN_NORM, 0, pitch );
break;
case 1:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_idle2.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_idle2.wav", 1.0, ATTN_NORM, 0, pitch );
break;
case 2:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_idle3.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_idle3.wav", 1.0, ATTN_NORM, 0, pitch );
break;
}
#endif
}
void CBloater :: AttackSnd( void )
void CBloater::AttackSnd( void )
{
#if 0
int pitch = 95 + RANDOM_LONG(0,9);
int pitch = 95 + RANDOM_LONG( 0, 9 );
switch (RANDOM_LONG(0,1))
switch( RANDOM_LONG( 0, 1 ) )
{
case 0:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_attack1.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_attack1.wav", 1.0, ATTN_NORM, 0, pitch );
break;
case 1:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "zombie/zo_attack2.wav", 1.0, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "zombie/zo_attack2.wav", 1.0, ATTN_NORM, 0, pitch );
break;
}
#endif
@ -161,7 +161,7 @@ void CBloater :: AttackSnd( void )
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CBloater :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CBloater::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -171,7 +171,6 @@ void CBloater :: HandleAnimEvent( MonsterEvent_t *pEvent )
AttackSnd();
}
break;
default:
CBaseMonster::HandleAnimEvent( pEvent );
break;
@ -181,11 +180,11 @@ void CBloater :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CBloater :: Spawn()
void CBloater::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/floater.mdl");
SET_MODEL( ENT( pev ), "models/floater.mdl" );
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
pev->solid = SOLID_SLIDEBOX;
@ -203,12 +202,11 @@ void CBloater :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CBloater :: Precache()
void CBloater::Precache()
{
PRECACHE_MODEL("models/floater.mdl");
PRECACHE_MODEL( "models/floater.mdl" );
}
//=========================================================
// AI Schedules Specific to this monster
//=========================================================

362
dlls/bmodels.cpp
View File

@ -62,20 +62,20 @@ public:
LINK_ENTITY_TO_CLASS( func_wall, CFuncWall )
void CFuncWall :: Spawn( void )
void CFuncWall::Spawn( void )
{
pev->angles = g_vecZero;
pev->movetype = MOVETYPE_PUSH; // so it doesn't get pushed by anything
pev->solid = SOLID_BSP;
SET_MODEL( ENT(pev), STRING(pev->model) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
// If it can't move/go away, it's really part of the world
pev->flags |= FL_WORLDBRUSH;
}
void CFuncWall :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CFuncWall::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( ShouldToggle( useType, (int)(pev->frame)) )
if( ShouldToggle( useType, (int)( pev->frame ) ) )
pev->frame = 1 - pev->frame;
}
@ -93,41 +93,41 @@ public:
LINK_ENTITY_TO_CLASS( func_wall_toggle, CFuncWallToggle )
void CFuncWallToggle :: Spawn( void )
void CFuncWallToggle::Spawn( void )
{
CFuncWall::Spawn();
if ( pev->spawnflags & SF_WALL_START_OFF )
if( pev->spawnflags & SF_WALL_START_OFF )
TurnOff();
}
void CFuncWallToggle :: TurnOff( void )
void CFuncWallToggle::TurnOff( void )
{
pev->solid = SOLID_NOT;
pev->effects |= EF_NODRAW;
UTIL_SetOrigin( pev, pev->origin );
}
void CFuncWallToggle :: TurnOn( void )
void CFuncWallToggle::TurnOn( void )
{
pev->solid = SOLID_BSP;
pev->effects &= ~EF_NODRAW;
UTIL_SetOrigin( pev, pev->origin );
}
BOOL CFuncWallToggle :: IsOn( void )
BOOL CFuncWallToggle::IsOn( void )
{
if ( pev->solid == SOLID_NOT )
if( pev->solid == SOLID_NOT )
return FALSE;
return TRUE;
}
void CFuncWallToggle :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CFuncWallToggle::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
int status = IsOn();
if ( ShouldToggle( useType, status ) )
if( ShouldToggle( useType, status ) )
{
if ( status )
if( status )
TurnOff();
else
TurnOn();
@ -147,43 +147,43 @@ public:
LINK_ENTITY_TO_CLASS( func_conveyor, CFuncConveyor )
void CFuncConveyor :: Spawn( void )
void CFuncConveyor::Spawn( void )
{
SetMovedir( pev );
CFuncWall::Spawn();
if ( !(pev->spawnflags & SF_CONVEYOR_VISUAL) )
if( !( pev->spawnflags & SF_CONVEYOR_VISUAL ) )
SetBits( pev->flags, FL_CONVEYOR );
// HACKHACK - This is to allow for some special effects
if ( pev->spawnflags & SF_CONVEYOR_NOTSOLID )
if( pev->spawnflags & SF_CONVEYOR_NOTSOLID )
{
pev->solid = SOLID_NOT;
pev->skin = 0; // Don't want the engine thinking we've got special contents on this brush
}
if ( pev->speed == 0 )
if( pev->speed == 0 )
pev->speed = 100;
UpdateSpeed( pev->speed );
}
// HACKHACK -- This is ugly, but encode the speed in the rendercolor to avoid adding more data to the network stream
void CFuncConveyor :: UpdateSpeed( float speed )
void CFuncConveyor::UpdateSpeed( float speed )
{
// Encode it as an integer with 4 fractional bits
int speedCode = (int)(fabs(speed) * 16.0);
int speedCode = (int)( fabs( speed ) * 16.0 );
if ( speed < 0 )
if( speed < 0 )
pev->rendercolor.x = 1;
else
pev->rendercolor.x = 0;
pev->rendercolor.y = (speedCode >> 8);
pev->rendercolor.z = (speedCode & 0xFF);
pev->rendercolor.y = speedCode >> 8;
pev->rendercolor.z = speedCode & 0xFF;
}
void CFuncConveyor :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CFuncConveyor::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
pev->speed = -pev->speed;
UpdateSpeed( pev->speed );
@ -206,23 +206,23 @@ public:
LINK_ENTITY_TO_CLASS( func_illusionary, CFuncIllusionary )
void CFuncIllusionary :: KeyValue( KeyValueData *pkvd )
void CFuncIllusionary::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "skin"))//skin is used for content type
if( FStrEq( pkvd->szKeyName, "skin" ) )//skin is used for content type
{
pev->skin = atof(pkvd->szValue);
pev->skin = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
CBaseToggle::KeyValue( pkvd );
}
void CFuncIllusionary :: Spawn( void )
void CFuncIllusionary::Spawn( void )
{
pev->angles = g_vecZero;
pev->movetype = MOVETYPE_NONE;
pev->solid = SOLID_NOT;// always solid_not
SET_MODEL( ENT(pev), STRING(pev->model) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
// I'd rather eat the network bandwidth of this than figure out how to save/restore
// these entities after they have been moved to the client, or respawn them ala Quake
@ -253,7 +253,7 @@ LINK_ENTITY_TO_CLASS( func_monsterclip, CFuncMonsterClip )
void CFuncMonsterClip::Spawn( void )
{
CFuncWall::Spawn();
if ( CVAR_GET_FLOAT("showtriggers") == 0 )
if( CVAR_GET_FLOAT( "showtriggers" ) == 0 )
pev->effects = EF_NODRAW;
pev->flags |= FL_MONSTERCLIP;
}
@ -265,13 +265,13 @@ public:
// basic functions
void Spawn( void );
void Precache( void );
void EXPORT SpinUp ( void );
void EXPORT SpinDown ( void );
void EXPORT SpinUp( void );
void EXPORT SpinDown( void );
void KeyValue( KeyValueData* pkvd);
void EXPORT HurtTouch ( CBaseEntity *pOther );
void EXPORT HurtTouch( CBaseEntity *pOther );
void EXPORT RotatingUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT Rotate( void );
void RampPitchVol (int fUp );
void RampPitchVol(int fUp );
void Blocked( CBaseEntity *pOther );
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
@ -299,33 +299,33 @@ IMPLEMENT_SAVERESTORE( CFuncRotating, CBaseEntity )
LINK_ENTITY_TO_CLASS( func_rotating, CFuncRotating )
void CFuncRotating :: KeyValue( KeyValueData* pkvd)
void CFuncRotating::KeyValue( KeyValueData* pkvd )
{
if (FStrEq(pkvd->szKeyName, "fanfriction"))
if( FStrEq( pkvd->szKeyName, "fanfriction" ) )
{
m_flFanFriction = atof(pkvd->szValue)/100;
m_flFanFriction = atof( pkvd->szValue ) / 100;
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "Volume"))
else if( FStrEq( pkvd->szKeyName, "Volume" ) )
{
m_flVolume = atof(pkvd->szValue)/10.0;
m_flVolume = atof( pkvd->szValue ) / 10.0;
if (m_flVolume > 1.0)
if( m_flVolume > 1.0 )
m_flVolume = 1.0;
if (m_flVolume < 0.0)
if( m_flVolume < 0.0 )
m_flVolume = 0.0;
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "spawnorigin"))
else if( FStrEq( pkvd->szKeyName, "spawnorigin" ) )
{
Vector tmp;
UTIL_StringToVector( (float *)tmp, pkvd->szValue );
if ( tmp != g_vecZero )
if( tmp != g_vecZero )
pev->origin = tmp;
}
else if (FStrEq(pkvd->szKeyName, "sounds"))
else if( FStrEq( pkvd->szKeyName, "sounds" ) )
{
m_sounds = atoi(pkvd->szValue);
m_sounds = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -345,52 +345,51 @@ check either the X_AXIS or Y_AXIS box to change that.
REVERSE will cause the it to rotate in the opposite direction.
*/
void CFuncRotating :: Spawn( )
void CFuncRotating::Spawn()
{
// set final pitch. Must not be PITCH_NORM, since we
// plan on pitch shifting later.
m_pitch = PITCH_NORM - 1;
// maintain compatibility with previous maps
if (m_flVolume == 0.0)
if( m_flVolume == 0.0 )
m_flVolume = 1.0;
// if the designer didn't set a sound attenuation, default to one.
m_flAttenuation = ATTN_NORM;
if ( FBitSet ( pev->spawnflags, SF_BRUSH_ROTATE_SMALLRADIUS) )
if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_SMALLRADIUS) )
{
m_flAttenuation = ATTN_IDLE;
}
else if ( FBitSet ( pev->spawnflags, SF_BRUSH_ROTATE_MEDIUMRADIUS) )
else if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_MEDIUMRADIUS ) )
{
m_flAttenuation = ATTN_STATIC;
}
else if ( FBitSet ( pev->spawnflags, SF_BRUSH_ROTATE_LARGERADIUS) )
else if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_LARGERADIUS ) )
{
m_flAttenuation = ATTN_NORM;
}
// prevent divide by zero if level designer forgets friction!
if ( m_flFanFriction == 0 )
if( m_flFanFriction == 0 )
{
m_flFanFriction = 1;
}
if ( FBitSet(pev->spawnflags, SF_BRUSH_ROTATE_Z_AXIS) )
pev->movedir = Vector(0,0,1);
else if ( FBitSet(pev->spawnflags, SF_BRUSH_ROTATE_X_AXIS) )
pev->movedir = Vector(1,0,0);
if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_Z_AXIS ) )
pev->movedir = Vector( 0, 0, 1 );
else if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_X_AXIS ) )
pev->movedir = Vector( 1, 0, 0 );
else
pev->movedir = Vector(0,1,0); // y-axis
pev->movedir = Vector( 0, 1, 0 ); // y-axis
// check for reverse rotation
if ( FBitSet(pev->spawnflags, SF_BRUSH_ROTATE_BACKWARDS) )
if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_BACKWARDS ) )
pev->movedir = pev->movedir * -1;
// some rotating objects like fake volumetric lights will not be solid.
if ( FBitSet(pev->spawnflags, SF_ROTATING_NOT_SOLID) )
if( FBitSet( pev->spawnflags, SF_ROTATING_NOT_SOLID ) )
{
pev->solid = SOLID_NOT;
pev->skin = CONTENTS_EMPTY;
@ -402,90 +401,88 @@ void CFuncRotating :: Spawn( )
pev->movetype = MOVETYPE_PUSH;
}
UTIL_SetOrigin(pev, pev->origin);
UTIL_SetOrigin( pev, pev->origin );
SET_MODEL( ENT(pev), STRING(pev->model) );
SetUse( &CFuncRotating::RotatingUse );
// did level designer forget to assign speed?
if (pev->speed <= 0)
if( pev->speed <= 0 )
pev->speed = 0;
// Removed this per level designers request. -- JAY
// if (pev->dmg == 0)
// if( pev->dmg == 0 )
// pev->dmg = 2;
// instant-use brush?
if ( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_INSTANT) )
if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_INSTANT ) )
{
SetThink( &CBaseEntity::SUB_CallUseToggle );
pev->nextthink = pev->ltime + 1.5; // leave a magic delay for client to start up
}
// can this brush inflict pain?
if ( FBitSet (pev->spawnflags, SF_BRUSH_HURT) )
if( FBitSet( pev->spawnflags, SF_BRUSH_HURT ) )
{
SetTouch( &CFuncRotating::HurtTouch );
}
Precache( );
Precache();
}
void CFuncRotating :: Precache( void )
void CFuncRotating::Precache( void )
{
char* szSoundFile = (char*) STRING(pev->message);
char* szSoundFile = (char*)STRING( pev->message );
// set up fan sounds
if (!FStringNull( pev->message ) && strlen( szSoundFile ) > 0)
if( !FStringNull( pev->message ) && strlen( szSoundFile ) > 0 )
{
// if a path is set for a wave, use it
PRECACHE_SOUND( szSoundFile );
PRECACHE_SOUND(szSoundFile);
pev->noiseRunning = ALLOC_STRING(szSoundFile);
pev->noiseRunning = ALLOC_STRING( szSoundFile );
}
else
{
// otherwise use preset sound
switch (m_sounds)
switch( m_sounds )
{
case 1:
PRECACHE_SOUND ("fans/fan1.wav");
pev->noiseRunning = ALLOC_STRING("fans/fan1.wav");
PRECACHE_SOUND( "fans/fan1.wav" );
pev->noiseRunning = ALLOC_STRING( "fans/fan1.wav" );
break;
case 2:
PRECACHE_SOUND ("fans/fan2.wav");
pev->noiseRunning = ALLOC_STRING("fans/fan2.wav");
PRECACHE_SOUND( "fans/fan2.wav" );
pev->noiseRunning = ALLOC_STRING( "fans/fan2.wav" );
break;
case 3:
PRECACHE_SOUND ("fans/fan3.wav");
pev->noiseRunning = ALLOC_STRING("fans/fan3.wav");
PRECACHE_SOUND( "fans/fan3.wav" );
pev->noiseRunning = ALLOC_STRING( "fans/fan3.wav" );
break;
case 4:
PRECACHE_SOUND ("fans/fan4.wav");
pev->noiseRunning = ALLOC_STRING("fans/fan4.wav");
PRECACHE_SOUND( "fans/fan4.wav" );
pev->noiseRunning = ALLOC_STRING( "fans/fan4.wav" );
break;
case 5:
PRECACHE_SOUND ("fans/fan5.wav");
pev->noiseRunning = ALLOC_STRING("fans/fan5.wav");
PRECACHE_SOUND( "fans/fan5.wav" );
pev->noiseRunning = ALLOC_STRING( "fans/fan5.wav" );
break;
case 0:
default:
if (!FStringNull( pev->message ) && strlen( szSoundFile ) > 0)
if( !FStringNull( pev->message ) && strlen( szSoundFile ) > 0 )
{
PRECACHE_SOUND(szSoundFile);
PRECACHE_SOUND( szSoundFile );
pev->noiseRunning = ALLOC_STRING(szSoundFile);
pev->noiseRunning = ALLOC_STRING( szSoundFile );
break;
} else
}
else
{
pev->noiseRunning = ALLOC_STRING("common/null.wav");
pev->noiseRunning = ALLOC_STRING( "common/null.wav" );
break;
}
}
}
if (pev->avelocity != g_vecZero )
if( pev->avelocity != g_vecZero )
{
// if fan was spinning, and we went through transition or save/restore,
// make sure we restart the sound. 1.5 sec delay is magic number. KDB
@ -498,20 +495,20 @@ void CFuncRotating :: Precache( void )
//
// Touch - will hurt others based on how fast the brush is spinning
//
void CFuncRotating :: HurtTouch ( CBaseEntity *pOther )
void CFuncRotating::HurtTouch( CBaseEntity *pOther )
{
entvars_t *pevOther = pOther->pev;
// we can't hurt this thing, so we're not concerned with it
if ( !pevOther->takedamage )
if( !pevOther->takedamage )
return;
// calculate damage based on rotation speed
pev->dmg = pev->avelocity.Length() / 10;
pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH);
pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH );
pevOther->velocity = (pevOther->origin - VecBModelOrigin(pev) ).Normalize() * pev->dmg;
pevOther->velocity = ( pevOther->origin - VecBModelOrigin( pev ) ).Normalize() * pev->dmg;
}
//
@ -521,9 +518,8 @@ void CFuncRotating :: HurtTouch ( CBaseEntity *pOther )
#define FANPITCHMIN 30
#define FANPITCHMAX 100
void CFuncRotating :: RampPitchVol (int fUp)
void CFuncRotating::RampPitchVol( int fUp )
{
Vector vecAVel = pev->avelocity;
vec_t vecCur;
vec_t vecFinal;
@ -533,38 +529,35 @@ void CFuncRotating :: RampPitchVol (int fUp)
int pitch;
// get current angular velocity
vecCur = fabs(vecAVel.x != 0 ? vecAVel.x : (vecAVel.y != 0 ? vecAVel.y : vecAVel.z));
vecCur = fabs( vecAVel.x != 0 ? vecAVel.x : ( vecAVel.y != 0 ? vecAVel.y : vecAVel.z ) );
// get target angular velocity
vecFinal = (pev->movedir.x != 0 ? pev->movedir.x : (pev->movedir.y != 0 ? pev->movedir.y : pev->movedir.z));
vecFinal = ( pev->movedir.x != 0 ? pev->movedir.x : ( pev->movedir.y != 0 ? pev->movedir.y : pev->movedir.z ) );
vecFinal *= pev->speed;
vecFinal = fabs(vecFinal);
vecFinal = fabs( vecFinal );
// calc volume and pitch as % of final vol and pitch
fpct = vecCur / vecFinal;
// if (fUp)
// fvol = m_flVolume * (0.5 + fpct/2.0); // spinup volume ramps up from 50% max vol
// else
//if (fUp)
// fvol = m_flVolume * (0.5 + fpct/2.0); // spinup volume ramps up from 50% max vol
//else
fvol = m_flVolume * fpct; // slowdown volume ramps down to 0
fpitch = FANPITCHMIN + (FANPITCHMAX - FANPITCHMIN) * fpct;
fpitch = FANPITCHMIN + ( FANPITCHMAX - FANPITCHMIN ) * fpct;
pitch = (int) fpitch;
if (pitch == PITCH_NORM)
pitch = PITCH_NORM-1;
pitch = (int)fpitch;
if( pitch == PITCH_NORM )
pitch = PITCH_NORM - 1;
// change the fan's vol and pitch
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning),
fvol, m_flAttenuation, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_STATIC, (char *)STRING( pev->noiseRunning ),
fvol, m_flAttenuation, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch );
}
//
// SpinUp - accelerates a non-moving func_rotating up to it's speed
//
void CFuncRotating :: SpinUp( void )
void CFuncRotating::SpinUp( void )
{
Vector vecAVel;//rotational velocity
@ -579,22 +572,22 @@ void CFuncRotating :: SpinUp( void )
fabs( vecAVel.z ) >= fabs( pev->movedir.z * pev->speed ) )
{
pev->avelocity = pev->movedir * pev->speed;// set speed in case we overshot
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning),
m_flVolume, m_flAttenuation, SND_CHANGE_PITCH | SND_CHANGE_VOL, FANPITCHMAX);
EMIT_SOUND_DYN( ENT( pev ), CHAN_STATIC, (char *)STRING( pev->noiseRunning ),
m_flVolume, m_flAttenuation, SND_CHANGE_PITCH | SND_CHANGE_VOL, FANPITCHMAX );
SetThink( &CFuncRotating::Rotate );
Rotate();
}
else
{
RampPitchVol(TRUE);
RampPitchVol( TRUE );
}
}
//
// SpinDown - decelerates a moving func_rotating to a standstill.
//
void CFuncRotating :: SpinDown( void )
void CFuncRotating::SpinDown( void )
{
Vector vecAVel;//rotational velocity
vec_t vecdir;
@ -605,34 +598,34 @@ void CFuncRotating :: SpinDown( void )
vecAVel = pev->avelocity;// cache entity's rotational velocity
if (pev->movedir.x != 0)
if( pev->movedir.x != 0 )
vecdir = pev->movedir.x;
else if (pev->movedir.y != 0)
else if( pev->movedir.y != 0 )
vecdir = pev->movedir.y;
else
vecdir = pev->movedir.z;
// if we've met or exceeded target speed, set target speed and stop thinking
// (note: must check for movedir > 0 or < 0)
if (((vecdir > 0) && (vecAVel.x <= 0 && vecAVel.y <= 0 && vecAVel.z <= 0)) ||
((vecdir < 0) && (vecAVel.x >= 0 && vecAVel.y >= 0 && vecAVel.z >= 0)))
if( ( ( vecdir > 0 ) && ( vecAVel.x <= 0 && vecAVel.y <= 0 && vecAVel.z <= 0 ) ) ||
( ( vecdir < 0 ) && ( vecAVel.x >= 0 && vecAVel.y >= 0 && vecAVel.z >= 0 ) ) )
{
pev->avelocity = g_vecZero;// set speed in case we overshot
// stop sound, we're done
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning /* Stop */),
0, 0, SND_STOP, m_pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_STATIC, (char *)STRING( pev->noiseRunning /* Stop */ ),
0, 0, SND_STOP, m_pitch );
SetThink( &CFuncRotating::Rotate );
Rotate();
}
else
{
RampPitchVol(FALSE);
RampPitchVol( FALSE );
}
}
void CFuncRotating :: Rotate( void )
void CFuncRotating::Rotate( void )
{
pev->nextthink = pev->ltime + 10;
}
@ -640,46 +633,46 @@ void CFuncRotating :: Rotate( void )
//=========================================================
// Rotating Use - when a rotating brush is triggered
//=========================================================
void CFuncRotating :: RotatingUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CFuncRotating::RotatingUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// is this a brush that should accelerate and decelerate when turned on/off (fan)?
if ( FBitSet ( pev->spawnflags, SF_BRUSH_ACCDCC ) )
if( FBitSet ( pev->spawnflags, SF_BRUSH_ACCDCC ) )
{
// fan is spinning, so stop it.
if ( pev->avelocity != g_vecZero )
if( pev->avelocity != g_vecZero )
{
SetThink( &CFuncRotating::SpinDown );
//EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, (char *)STRING(pev->noiseStop),
// m_flVolume, m_flAttenuation, 0, m_pitch);
//EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, (char *)STRING( pev->noiseStop ),
// m_flVolume, m_flAttenuation, 0, m_pitch );
pev->nextthink = pev->ltime + 0.1;
}
else// fan is not moving, so start it
{
SetThink( &CFuncRotating::SpinUp );
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning),
0.01, m_flAttenuation, 0, FANPITCHMIN);
EMIT_SOUND_DYN( ENT( pev ), CHAN_STATIC, (char *)STRING( pev->noiseRunning ),
0.01, m_flAttenuation, 0, FANPITCHMIN );
pev->nextthink = pev->ltime + 0.1;
}
}
else if ( !FBitSet ( pev->spawnflags, SF_BRUSH_ACCDCC ) )//this is a normal start/stop brush.
else if( !FBitSet( pev->spawnflags, SF_BRUSH_ACCDCC ) )//this is a normal start/stop brush.
{
if ( pev->avelocity != g_vecZero )
if( pev->avelocity != g_vecZero )
{
// play stopping sound here
SetThink( &CFuncRotating::SpinDown );
// EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, (char *)STRING(pev->noiseStop),
// m_flVolume, m_flAttenuation, 0, m_pitch);
// EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, (char *)STRING( pev->noiseStop ),
// m_flVolume, m_flAttenuation, 0, m_pitch );
pev->nextthink = pev->ltime + 0.1;
// pev->avelocity = g_vecZero;
}
else
{
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char *)STRING(pev->noiseRunning),
m_flVolume, m_flAttenuation, 0, FANPITCHMAX);
EMIT_SOUND_DYN( ENT( pev ), CHAN_STATIC, (char *)STRING( pev->noiseRunning ),
m_flVolume, m_flAttenuation, 0, FANPITCHMAX );
pev->avelocity = pev->movedir * pev->speed;
SetThink( &CFuncRotating::Rotate );
@ -691,21 +684,21 @@ void CFuncRotating :: RotatingUse( CBaseEntity *pActivator, CBaseEntity *pCaller
//
// RotatingBlocked - An entity has blocked the brush
//
void CFuncRotating :: Blocked( CBaseEntity *pOther )
void CFuncRotating::Blocked( CBaseEntity *pOther )
{
pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH);
pOther->TakeDamage( pev, pev, pev->dmg, DMG_CRUSH );
}
//#endif
class CPendulum : public CBaseEntity
{
public:
void Spawn ( void );
void Spawn( void );
void KeyValue( KeyValueData *pkvd );
void EXPORT Swing( void );
void EXPORT PendulumUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT Stop( void );
void Touch( CBaseEntity *pOther );
void EXPORT RopeTouch ( CBaseEntity *pOther );// this touch func makes the pendulum a rope
void EXPORT RopeTouch( CBaseEntity *pOther );// this touch func makes the pendulum a rope
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
@ -714,7 +707,7 @@ public:
static TYPEDESCRIPTION m_SaveData[];
float m_accel; // Acceleration
float m_distance; //
float m_distance;
float m_time;
float m_damp;
float m_maxSpeed;
@ -739,47 +732,47 @@ TYPEDESCRIPTION CPendulum::m_SaveData[] =
IMPLEMENT_SAVERESTORE( CPendulum, CBaseEntity )
void CPendulum :: KeyValue( KeyValueData *pkvd )
void CPendulum::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "distance"))
if( FStrEq( pkvd->szKeyName, "distance" ) )
{
m_distance = atof(pkvd->szValue);
m_distance = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "damp"))
else if( FStrEq( pkvd->szKeyName, "damp" ) )
{
m_damp = atof(pkvd->szValue) * 0.001;
m_damp = atof( pkvd->szValue ) * 0.001;
pkvd->fHandled = TRUE;
}
else
CBaseEntity::KeyValue( pkvd );
}
void CPendulum :: Spawn( void )
void CPendulum::Spawn( void )
{
// set the axis of rotation
CBaseToggle :: AxisDir( pev );
CBaseToggle::AxisDir( pev );
if ( FBitSet (pev->spawnflags, SF_DOOR_PASSABLE) )
if( FBitSet( pev->spawnflags, SF_DOOR_PASSABLE ) )
pev->solid = SOLID_NOT;
else
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(pev, pev->origin);
SET_MODEL(ENT(pev), STRING(pev->model) );
UTIL_SetOrigin( pev, pev->origin );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
if ( m_distance == 0 )
if( m_distance == 0 )
return;
if (pev->speed == 0)
if( pev->speed == 0 )
pev->speed = 100;
m_accel = (pev->speed * pev->speed) / (2 * fabs(m_distance)); // Calculate constant acceleration from speed and distance
m_accel = ( pev->speed * pev->speed ) / ( 2 * fabs( m_distance ) ); // Calculate constant acceleration from speed and distance
m_maxSpeed = pev->speed;
m_start = pev->angles;
m_center = pev->angles + (m_distance * 0.5) * pev->movedir;
m_center = pev->angles + ( m_distance * 0.5 ) * pev->movedir;
if ( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_INSTANT) )
if( FBitSet( pev->spawnflags, SF_BRUSH_ROTATE_INSTANT ) )
{
SetThink( &CBaseEntity::SUB_CallUseToggle );
pev->nextthink = gpGlobals->time + 0.1;
@ -787,24 +780,24 @@ void CPendulum :: Spawn( void )
pev->speed = 0;
SetUse( &CPendulum::PendulumUse );
if ( FBitSet( pev->spawnflags, SF_PENDULUM_SWING ) )
if( FBitSet( pev->spawnflags, SF_PENDULUM_SWING ) )
{
SetTouch( &CPendulum::RopeTouch );
}
}
void CPendulum :: PendulumUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CPendulum::PendulumUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( pev->speed ) // Pendulum is moving, stop it and auto-return if necessary
if( pev->speed ) // Pendulum is moving, stop it and auto-return if necessary
{
if ( FBitSet( pev->spawnflags, SF_PENDULUM_AUTO_RETURN ) )
if( FBitSet( pev->spawnflags, SF_PENDULUM_AUTO_RETURN ) )
{
float delta;
delta = CBaseToggle :: AxisDelta( pev->spawnflags, pev->angles, m_start );
delta = CBaseToggle::AxisDelta( pev->spawnflags, pev->angles, m_start );
pev->avelocity = m_maxSpeed * pev->movedir;
pev->nextthink = pev->ltime + (delta / m_maxSpeed);
pev->nextthink = pev->ltime + ( delta / m_maxSpeed );
SetThink( &CPendulum::Stop );
}
else
@ -823,7 +816,7 @@ void CPendulum :: PendulumUse( CBaseEntity *pActivator, CBaseEntity *pCaller, US
}
}
void CPendulum :: Stop( void )
void CPendulum::Stop( void )
{
pev->angles = m_start;
pev->speed = 0;
@ -836,22 +829,22 @@ void CPendulum::Blocked( CBaseEntity *pOther )
m_time = gpGlobals->time;
}
void CPendulum :: Swing( void )
void CPendulum::Swing( void )
{
float delta, dt;
delta = CBaseToggle :: AxisDelta( pev->spawnflags, pev->angles, m_center );
delta = CBaseToggle::AxisDelta( pev->spawnflags, pev->angles, m_center );
dt = gpGlobals->time - m_time; // How much time has passed?
m_time = gpGlobals->time; // Remember the last time called
if ( delta > 0 && m_accel > 0 )
if( delta > 0 && m_accel > 0 )
pev->speed -= m_accel * dt; // Integrate velocity
else
pev->speed += m_accel * dt;
if ( pev->speed > m_maxSpeed )
if( pev->speed > m_maxSpeed )
pev->speed = m_maxSpeed;
else if ( pev->speed < -m_maxSpeed )
else if( pev->speed < -m_maxSpeed )
pev->speed = -m_maxSpeed;
// scale the destdelta vector by the time spent traveling to get velocity
pev->avelocity = pev->speed * pev->movedir;
@ -859,58 +852,59 @@ void CPendulum :: Swing( void )
// Call this again
pev->nextthink = pev->ltime + 0.1;
if ( m_damp )
if( m_damp )
{
m_dampSpeed -= m_damp * m_dampSpeed * dt;
if ( m_dampSpeed < 30.0 )
if( m_dampSpeed < 30.0 )
{
pev->angles = m_center;
pev->speed = 0;
SetThink( NULL );
pev->avelocity = g_vecZero;
}
else if ( pev->speed > m_dampSpeed )
else if( pev->speed > m_dampSpeed )
pev->speed = m_dampSpeed;
else if ( pev->speed < -m_dampSpeed )
else if( pev->speed < -m_dampSpeed )
pev->speed = -m_dampSpeed;
}
}
void CPendulum :: Touch ( CBaseEntity *pOther )
void CPendulum::Touch( CBaseEntity *pOther )
{
entvars_t *pevOther = pOther->pev;
if ( pev->dmg <= 0 )
if( pev->dmg <= 0 )
return;
// we can't hurt this thing, so we're not concerned with it
if ( !pevOther->takedamage )
if( !pevOther->takedamage )
return;
// calculate damage based on rotation speed
float damage = pev->dmg * pev->speed * 0.01;
if ( damage < 0 )
if( damage < 0 )
damage = -damage;
pOther->TakeDamage( pev, pev, damage, DMG_CRUSH );
pevOther->velocity = (pevOther->origin - VecBModelOrigin(pev) ).Normalize() * damage;
pevOther->velocity = ( pevOther->origin - VecBModelOrigin( pev ) ).Normalize() * damage;
}
void CPendulum :: RopeTouch ( CBaseEntity *pOther )
void CPendulum::RopeTouch( CBaseEntity *pOther )
{
entvars_t *pevOther = pOther->pev;
if ( !pOther->IsPlayer() )
{// not a player!
ALERT ( at_console, "Not a client\n" );
if( !pOther->IsPlayer() )
{
// not a player!
ALERT( at_console, "Not a client\n" );
return;
}
if ( ENT(pevOther) == pev->enemy )
{// this player already on the rope.
if( ENT( pevOther ) == pev->enemy )
{
// this player already on the rope.
return;
}

471
dlls/bullsquid.cpp
View File

File diff suppressed because it is too large Load Diff

672
dlls/buttons.cpp
View File

File diff suppressed because it is too large Load Diff

296
dlls/cbase.cpp
View File

@ -103,25 +103,25 @@ extern "C" {
#endif
int GetEntityAPI( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion )
{
if ( !pFunctionTable || interfaceVersion != INTERFACE_VERSION )
if( !pFunctionTable || interfaceVersion != INTERFACE_VERSION )
{
return FALSE;
}
memcpy( pFunctionTable, &gFunctionTable, sizeof( DLL_FUNCTIONS ) );
memcpy( pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS) );
return TRUE;
}
int GetEntityAPI2( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion )
{
if ( !pFunctionTable || *interfaceVersion != INTERFACE_VERSION )
if( !pFunctionTable || *interfaceVersion != INTERFACE_VERSION )
{
// Tell engine what version we had, so it can figure out who is out of date.
*interfaceVersion = INTERFACE_VERSION;
return FALSE;
}
memcpy( pFunctionTable, &gFunctionTable, sizeof( DLL_FUNCTIONS ) );
memcpy( pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS) );
return TRUE;
}
@ -131,40 +131,39 @@ int GetEntityAPI2( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion )
int DispatchSpawn( edict_t *pent )
{
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
if (pEntity)
if( pEntity )
{
// Initialize these or entities who don't link to the world won't have anything in here
pEntity->pev->absmin = pEntity->pev->origin - Vector(1,1,1);
pEntity->pev->absmax = pEntity->pev->origin + Vector(1,1,1);
pEntity->pev->absmin = pEntity->pev->origin - Vector( 1, 1, 1 );
pEntity->pev->absmax = pEntity->pev->origin + Vector( 1, 1, 1 );
pEntity->Spawn();
// Try to get the pointer again, in case the spawn function deleted the entity.
// UNDONE: Spawn() should really return a code to ask that the entity be deleted, but
// that would touch too much code for me to do that right now.
pEntity = (CBaseEntity *)GET_PRIVATE(pent);
pEntity = (CBaseEntity *)GET_PRIVATE( pent );
if ( pEntity )
if( pEntity )
{
if ( g_pGameRules && !g_pGameRules->IsAllowedToSpawn( pEntity ) )
if( g_pGameRules && !g_pGameRules->IsAllowedToSpawn( pEntity ) )
return -1; // return that this entity should be deleted
if ( pEntity->pev->flags & FL_KILLME )
if( pEntity->pev->flags & FL_KILLME )
return -1;
}
// Handle global stuff here
if ( pEntity && pEntity->pev->globalname )
if( pEntity && pEntity->pev->globalname )
{
const globalentity_t *pGlobal = gGlobalState.EntityFromTable( pEntity->pev->globalname );
if ( pGlobal )
if( pGlobal )
{
// Already dead? delete
if ( pGlobal->state == GLOBAL_DEAD )
if( pGlobal->state == GLOBAL_DEAD )
return -1;
else if ( !FStrEq( STRING(gpGlobals->mapname), pGlobal->levelName ) )
else if( !FStrEq( STRING( gpGlobals->mapname ), pGlobal->levelName ) )
pEntity->MakeDormant(); // Hasn't been moved to this level yet, wait but stay alive
// In this level & not dead, continue on as normal
}
@ -172,7 +171,7 @@ int DispatchSpawn( edict_t *pent )
{
// Spawned entities default to 'On'
gGlobalState.EntityAdd( pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON );
// ALERT( at_console, "Added global entity %s (%s)\n", STRING(pEntity->pev->classname), STRING(pEntity->pev->globalname) );
//ALERT( at_console, "Added global entity %s (%s)\n", STRING( pEntity->pev->classname ), STRING( pEntity->pev->globalname ) );
}
}
@ -183,10 +182,10 @@ int DispatchSpawn( edict_t *pent )
void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd )
{
if ( !pkvd || !pentKeyvalue )
if( !pkvd || !pentKeyvalue )
return;
EntvarsKeyvalue( VARS(pentKeyvalue), pkvd );
EntvarsKeyvalue( VARS( pentKeyvalue ), pkvd );
// If the key was an entity variable, or there's no class set yet, don't look for the object, it may
// not exist yet.
@ -194,9 +193,9 @@ void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd )
return;
// Get the actualy entity object
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentKeyvalue);
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentKeyvalue );
if ( !pEntity )
if( !pEntity )
return;
pEntity->KeyValue( pkvd );
@ -208,32 +207,32 @@ BOOL gTouchDisabled = FALSE;
void DispatchTouch( edict_t *pentTouched, edict_t *pentOther )
{
if ( gTouchDisabled )
if( gTouchDisabled )
return;
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentTouched);
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentTouched );
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
if ( pEntity && pOther && ! ((pEntity->pev->flags | pOther->pev->flags) & FL_KILLME) )
if( pEntity && pOther && ! ( ( pEntity->pev->flags | pOther->pev->flags ) & FL_KILLME ) )
pEntity->Touch( pOther );
}
void DispatchUse( edict_t *pentUsed, edict_t *pentOther )
{
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentUsed);
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE(pentOther);
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentUsed );
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
if (pEntity && !(pEntity->pev->flags & FL_KILLME) )
if( pEntity && !( pEntity->pev->flags & FL_KILLME ) )
pEntity->Use( pOther, pOther, USE_TOGGLE, 0 );
}
void DispatchThink( edict_t *pent )
{
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
if (pEntity)
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
if( pEntity )
{
if ( FBitSet( pEntity->pev->flags, FL_DORMANT ) )
ALERT( at_error, "Dormant entity %s is thinking!!\n", STRING(pEntity->pev->classname) );
if( FBitSet( pEntity->pev->flags, FL_DORMANT ) )
ALERT( at_error, "Dormant entity %s is thinking!!\n", STRING( pEntity->pev->classname ) );
pEntity->Think();
}
@ -244,26 +243,26 @@ void DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther )
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pentBlocked );
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE( pentOther );
if (pEntity)
if( pEntity )
pEntity->Blocked( pOther );
}
void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData )
{
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
if ( pEntity && pSaveData )
if( pEntity && pSaveData )
{
ENTITYTABLE *pTable = &pSaveData->pTable[ pSaveData->currentIndex ];
ENTITYTABLE *pTable = &pSaveData->pTable[pSaveData->currentIndex];
if ( pTable->pent != pent )
if( pTable->pent != pent )
ALERT( at_error, "ENTITY TABLE OR INDEX IS WRONG!!!!\n" );
if ( pEntity->ObjectCaps() & FCAP_DONT_SAVE )
if( pEntity->ObjectCaps() & FCAP_DONT_SAVE )
return;
// These don't use ltime & nextthink as times really, but we'll fudge around it.
if ( pEntity->pev->movetype == MOVETYPE_PUSH )
if( pEntity->pev->movetype == MOVETYPE_PUSH )
{
float delta = pEntity->pev->nextthink - pEntity->pev->ltime;
pEntity->pev->ltime = gpGlobals->time;
@ -284,13 +283,13 @@ void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData )
// different classes with the same global name
CBaseEntity *FindGlobalEntity( string_t classname, string_t globalname )
{
edict_t *pent = FIND_ENTITY_BY_STRING( NULL, "globalname", STRING(globalname) );
edict_t *pent = FIND_ENTITY_BY_STRING( NULL, "globalname", STRING( globalname ) );
CBaseEntity *pReturn = CBaseEntity::Instance( pent );
if ( pReturn )
if( pReturn )
{
if ( !FClassnameIs( pReturn->pev, STRING(classname) ) )
if( !FClassnameIs( pReturn->pev, STRING( classname ) ) )
{
ALERT( at_console, "Global entity found %s, wrong class %s\n", STRING(globalname), STRING(pReturn->pev->classname) );
ALERT( at_console, "Global entity found %s, wrong class %s\n", STRING( globalname ), STRING( pReturn->pev->classname ) );
pReturn = NULL;
}
}
@ -300,15 +299,15 @@ CBaseEntity *FindGlobalEntity( string_t classname, string_t globalname )
int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity )
{
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
if ( pEntity && pSaveData )
if( pEntity && pSaveData )
{
entvars_t tmpVars;
Vector oldOffset;
CRestore restoreHelper( pSaveData );
if ( globalEntity )
if( globalEntity )
{
CRestore tmpRestore( pSaveData );
tmpRestore.PrecacheMode( 0 );
@ -325,18 +324,18 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
// pSaveData->szCurrentMapName is the level this entity is coming from
// pGlobla->levelName is the last level the global entity was active in.
// If they aren't the same, then this global update is out of date.
if ( !FStrEq( pSaveData->szCurrentMapName, pGlobal->levelName ) )
if( !FStrEq( pSaveData->szCurrentMapName, pGlobal->levelName ) )
return 0;
// Compute the new global offset
oldOffset = pSaveData->vecLandmarkOffset;
CBaseEntity *pNewEntity = FindGlobalEntity( tmpVars.classname, tmpVars.globalname );
if ( pNewEntity )
if( pNewEntity )
{
// ALERT( at_console, "Overlay %s with %s\n", STRING(pNewEntity->pev->classname), STRING(tmpVars.classname) );
//ALERT( at_console, "Overlay %s with %s\n", STRING( pNewEntity->pev->classname ), STRING( tmpVars.classname ) );
// Tell the restore code we're overlaying a global entity from another level
restoreHelper.SetGlobalMode( 1 ); // Don't overwrite global fields
pSaveData->vecLandmarkOffset = (pSaveData->vecLandmarkOffset - pNewEntity->pev->mins) + tmpVars.mins;
pSaveData->vecLandmarkOffset = ( pSaveData->vecLandmarkOffset - pNewEntity->pev->mins ) + tmpVars.mins;
pEntity = pNewEntity;// we're going to restore this data OVER the old entity
pent = ENT( pEntity->pev );
// Update the global table to say that the global definition of this entity should come from this level
@ -348,10 +347,9 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
// or call EntityUpdate() to move it to this level, we haven't changed global state at all.
return 0;
}
}
if ( pEntity->ObjectCaps() & FCAP_MUST_SPAWN )
if( pEntity->ObjectCaps() & FCAP_MUST_SPAWN )
{
pEntity->Restore( restoreHelper );
pEntity->Spawn();
@ -359,37 +357,37 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
else
{
pEntity->Restore( restoreHelper );
pEntity->Precache( );
pEntity->Precache();
}
// Again, could be deleted, get the pointer again.
pEntity = (CBaseEntity *)GET_PRIVATE(pent);
pEntity = (CBaseEntity *)GET_PRIVATE( pent );
#if 0
if ( pEntity && pEntity->pev->globalname && globalEntity )
if( pEntity && pEntity->pev->globalname && globalEntity )
{
ALERT( at_console, "Global %s is %s\n", STRING(pEntity->pev->globalname), STRING(pEntity->pev->model) );
ALERT( at_console, "Global %s is %s\n", STRING( pEntity->pev->globalname ), STRING( pEntity->pev->model ) );
}
#endif
// Is this an overriding global entity (coming over the transition), or one restoring in a level
if ( globalEntity )
if( globalEntity )
{
// ALERT( at_console, "After: %f %f %f %s\n", pEntity->pev->origin.x, pEntity->pev->origin.y, pEntity->pev->origin.z, STRING(pEntity->pev->model) );
//ALERT( at_console, "After: %f %f %f %s\n", pEntity->pev->origin.x, pEntity->pev->origin.y, pEntity->pev->origin.z, STRING( pEntity->pev->model ) );
pSaveData->vecLandmarkOffset = oldOffset;
if ( pEntity )
if( pEntity )
{
UTIL_SetOrigin( pEntity->pev, pEntity->pev->origin );
pEntity->OverrideReset();
}
}
else if ( pEntity && pEntity->pev->globalname )
else if( pEntity && pEntity->pev->globalname )
{
const globalentity_t *pGlobal = gGlobalState.EntityFromTable( pEntity->pev->globalname );
if ( pGlobal )
if( pGlobal )
{
// Already dead? delete
if ( pGlobal->state == GLOBAL_DEAD )
if( pGlobal->state == GLOBAL_DEAD )
return -1;
else if ( !FStrEq( STRING(gpGlobals->mapname), pGlobal->levelName ) )
else if( !FStrEq( STRING( gpGlobals->mapname ), pGlobal->levelName ) )
{
pEntity->MakeDormant(); // Hasn't been moved to this level yet, wait but stay alive
}
@ -397,7 +395,7 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
}
else
{
ALERT( at_error, "Global Entity %s (%s) not in table!!!\n", STRING(pEntity->pev->globalname), STRING(pEntity->pev->classname) );
ALERT( at_error, "Global Entity %s (%s) not in table!!!\n", STRING( pEntity->pev->globalname ), STRING( pEntity->pev->classname ) );
// Spawned entities default to 'On'
gGlobalState.EntityAdd( pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON );
}
@ -408,8 +406,8 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
void DispatchObjectCollsionBox( edict_t *pent )
{
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
if (pEntity)
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
if( pEntity )
{
pEntity->SetObjectCollisionBox();
}
@ -429,11 +427,11 @@ void SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseD
restoreHelper.ReadFields( pname, pBaseData, pFields, fieldCount );
}
edict_t * EHANDLE::Get( void )
edict_t *EHANDLE::Get( void )
{
if (m_pent)
if( m_pent )
{
if (m_pent->serialnumber == m_serialnumber)
if( m_pent->serialnumber == m_serialnumber )
return m_pent;
else
return NULL;
@ -441,25 +439,25 @@ edict_t * EHANDLE::Get( void )
return NULL;
}
edict_t * EHANDLE::Set( edict_t *pent )
edict_t *EHANDLE::Set( edict_t *pent )
{
m_pent = pent;
if (pent)
if( pent )
m_serialnumber = m_pent->serialnumber;
return pent;
}
EHANDLE :: operator CBaseEntity *()
EHANDLE::operator CBaseEntity *()
{
return (CBaseEntity *)GET_PRIVATE( Get( ) );
return (CBaseEntity *)GET_PRIVATE( Get() );
}
CBaseEntity * EHANDLE :: operator = (CBaseEntity *pEntity)
CBaseEntity *EHANDLE::operator = ( CBaseEntity *pEntity )
{
if (pEntity)
if( pEntity )
{
m_pent = ENT( pEntity->pev );
if (m_pent)
if( m_pent )
m_serialnumber = m_pent->serialnumber;
}
else
@ -470,29 +468,29 @@ CBaseEntity * EHANDLE :: operator = (CBaseEntity *pEntity)
return pEntity;
}
EHANDLE :: operator int ()
EHANDLE::operator int ()
{
return Get() != NULL;
}
CBaseEntity * EHANDLE :: operator -> ()
CBaseEntity * EHANDLE::operator -> ()
{
return (CBaseEntity *)GET_PRIVATE( Get( ) );
return (CBaseEntity *)GET_PRIVATE( Get() );
}
// give health
int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType )
int CBaseEntity::TakeHealth( float flHealth, int bitsDamageType )
{
if (!pev->takedamage)
if( !pev->takedamage )
return 0;
// heal
if ( pev->health >= pev->max_health )
if( pev->health >= pev->max_health )
return 0;
pev->health += flHealth;
if (pev->health > pev->max_health)
if( pev->health > pev->max_health )
pev->health = pev->max_health;
return 1;
@ -500,25 +498,25 @@ int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType )
// inflict damage on this entity. bitsDamageType indicates type of damage inflicted, ie: DMG_CRUSH
int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
int CBaseEntity::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
Vector vecTemp;
if (!pev->takedamage)
if( !pev->takedamage )
return 0;
// UNDONE: some entity types may be immune or resistant to some bitsDamageType
// if Attacker == Inflictor, the attack was a melee or other instant-hit attack.
// (that is, no actual entity projectile was involved in the attack so use the shooter's origin).
if ( pevAttacker == pevInflictor )
if( pevAttacker == pevInflictor )
{
vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
vecTemp = pevInflictor->origin - VecBModelOrigin( pev );
}
else
// an actual missile was involved.
{
vecTemp = pevInflictor->origin - ( VecBModelOrigin(pev) );
vecTemp = pevInflictor->origin - VecBModelOrigin( pev );
}
// this global is still used for glass and other non-monster killables, along with decals.
@ -526,21 +524,21 @@ int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker,
// save damage based on the target's armor level
// figure momentum add (don't let hurt brushes or other triggers move player)
if ((!FNullEnt(pevInflictor)) && (pev->movetype == MOVETYPE_WALK || pev->movetype == MOVETYPE_STEP) && (pevAttacker->solid != SOLID_TRIGGER) )
if( ( !FNullEnt( pevInflictor ) ) && (pev->movetype == MOVETYPE_WALK || pev->movetype == MOVETYPE_STEP ) && ( pevAttacker->solid != SOLID_TRIGGER ) )
{
Vector vecDir = pev->origin - (pevInflictor->absmin + pevInflictor->absmax) * 0.5;
Vector vecDir = pev->origin - ( pevInflictor->absmin + pevInflictor->absmax ) * 0.5;
vecDir = vecDir.Normalize();
float flForce = flDamage * ((32 * 32 * 72.0) / (pev->size.x * pev->size.y * pev->size.z)) * 5;
float flForce = flDamage * ( ( 32 * 32 * 72.0 ) / ( pev->size.x * pev->size.y * pev->size.z ) ) * 5;
if (flForce > 1000.0)
if( flForce > 1000.0 )
flForce = 1000.0;
pev->velocity = pev->velocity + vecDir * flForce;
}
// do the damage
pev->health -= flDamage;
if (pev->health <= 0)
if( pev->health <= 0 )
{
Killed( pevAttacker, GIB_NORMAL );
return 0;
@ -549,7 +547,7 @@ int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker,
return 1;
}
void CBaseEntity :: Killed( entvars_t *pevAttacker, int iGib )
void CBaseEntity::Killed( entvars_t *pevAttacker, int iGib )
{
pev->takedamage = DAMAGE_NO;
pev->deadflag = DEAD_DEAD;
@ -558,10 +556,10 @@ void CBaseEntity :: Killed( entvars_t *pevAttacker, int iGib )
CBaseEntity *CBaseEntity::GetNextTarget( void )
{
if ( FStringNull( pev->target ) )
if( FStringNull( pev->target ) )
return NULL;
edict_t *pTarget = FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(pev->target) );
if ( FNullEnt(pTarget) )
edict_t *pTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING( pev->target ) );
if( FNullEnt( pTarget ) )
return NULL;
return Instance( pTarget );
@ -580,8 +578,8 @@ TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
int CBaseEntity::Save( CSave &save )
{
if ( save.WriteEntVars( "ENTVARS", pev ) )
return save.WriteFields( "BASE", this, m_SaveData, ARRAYSIZE(m_SaveData) );
if( save.WriteEntVars( "ENTVARS", pev ) )
return save.WriteFields( "BASE", this, m_SaveData, ARRAYSIZE( m_SaveData ) );
return 0;
}
@ -591,18 +589,18 @@ int CBaseEntity::Restore( CRestore &restore )
int status;
status = restore.ReadEntVars( "ENTVARS", pev );
if ( status )
status = restore.ReadFields( "BASE", this, m_SaveData, ARRAYSIZE(m_SaveData) );
if( status )
status = restore.ReadFields( "BASE", this, m_SaveData, ARRAYSIZE( m_SaveData ) );
if ( pev->modelindex != 0 && !FStringNull(pev->model) )
if( pev->modelindex != 0 && !FStringNull( pev->model ) )
{
Vector mins, maxs;
mins = pev->mins; // Set model is about to destroy these
maxs = pev->maxs;
PRECACHE_MODEL( (char *)STRING(pev->model) );
SET_MODEL(ENT(pev), STRING(pev->model));
UTIL_SetSize(pev, mins, maxs); // Reset them
PRECACHE_MODEL( (char *)STRING( pev->model ) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
UTIL_SetSize( pev, mins, maxs ); // Reset them
}
return status;
@ -611,26 +609,27 @@ int CBaseEntity::Restore( CRestore &restore )
// Initialize absmin & absmax to the appropriate box
void SetObjectCollisionBox( entvars_t *pev )
{
if ( (pev->solid == SOLID_BSP) &&
(pev->angles.x || pev->angles.y|| pev->angles.z) )
{ // expand for rotation
if( ( pev->solid == SOLID_BSP ) &&
( pev->angles.x || pev->angles.y || pev->angles.z ) )
{
// expand for rotation
float max, v;
int i;
max = 0;
for (i=0 ; i<3 ; i++)
for( i = 0; i < 3; i++ )
{
v = fabs( ((float *)pev->mins)[i]);
if (v > max)
v = fabs( ( (float *)pev->mins )[i] );
if( v > max )
max = v;
v = fabs( ((float *)pev->maxs)[i]);
if (v > max)
v = fabs( ( (float *)pev->maxs )[i] );
if( v > max )
max = v;
}
for (i=0 ; i<3 ; i++)
for( i = 0; i < 3; i++ )
{
((float *)pev->absmin)[i] = ((float *)pev->origin)[i] - max;
((float *)pev->absmax)[i] = ((float *)pev->origin)[i] + max;
( (float *)pev->absmin )[i] = ( (float *)pev->origin )[i] - max;
( (float *)pev->absmax )[i] = ( (float *)pev->origin )[i] + max;
}
}
else
@ -652,9 +651,9 @@ void CBaseEntity::SetObjectCollisionBox( void )
::SetObjectCollisionBox( pev );
}
int CBaseEntity :: Intersects( CBaseEntity *pOther )
int CBaseEntity::Intersects( CBaseEntity *pOther )
{
if ( pOther->pev->absmin.x > pev->absmax.x ||
if( pOther->pev->absmin.x > pev->absmax.x ||
pOther->pev->absmin.y > pev->absmax.y ||
pOther->pev->absmin.z > pev->absmax.z ||
pOther->pev->absmax.x < pev->absmin.x ||
@ -664,7 +663,7 @@ int CBaseEntity :: Intersects( CBaseEntity *pOther )
return 1;
}
void CBaseEntity :: MakeDormant( void )
void CBaseEntity::MakeDormant( void )
{
SetBits( pev->flags, FL_DORMANT );
@ -680,62 +679,73 @@ void CBaseEntity :: MakeDormant( void )
UTIL_SetOrigin( pev, pev->origin );
}
int CBaseEntity :: IsDormant( void )
int CBaseEntity::IsDormant( void )
{
return FBitSet( pev->flags, FL_DORMANT );
}
BOOL CBaseEntity :: IsInWorld( void )
BOOL CBaseEntity::IsInWorld( void )
{
// position
if (pev->origin.x >= 4096) return FALSE;
if (pev->origin.y >= 4096) return FALSE;
if (pev->origin.z >= 4096) return FALSE;
if (pev->origin.x <= -4096) return FALSE;
if (pev->origin.y <= -4096) return FALSE;
if (pev->origin.z <= -4096) return FALSE;
if( pev->origin.x >= 4096 )
return FALSE;
if( pev->origin.y >= 4096 )
return FALSE;
if( pev->origin.z >= 4096 )
return FALSE;
if( pev->origin.x <= -4096 )
return FALSE;
if( pev->origin.y <= -4096 )
return FALSE;
if( pev->origin.z <= -4096 )
return FALSE;
// speed
if (pev->velocity.x >= 2000) return FALSE;
if (pev->velocity.y >= 2000) return FALSE;
if (pev->velocity.z >= 2000) return FALSE;
if (pev->velocity.x <= -2000) return FALSE;
if (pev->velocity.y <= -2000) return FALSE;
if (pev->velocity.z <= -2000) return FALSE;
if( pev->velocity.x >= 2000 )
return FALSE;
if( pev->velocity.y >= 2000 )
return FALSE;
if( pev->velocity.z >= 2000 )
return FALSE;
if( pev->velocity.x <= -2000 )
return FALSE;
if( pev->velocity.y <= -2000 )
return FALSE;
if( pev->velocity.z <= -2000 )
return FALSE;
return TRUE;
}
int CBaseEntity::ShouldToggle( USE_TYPE useType, BOOL currentState )
{
if ( useType != USE_TOGGLE && useType != USE_SET )
if( useType != USE_TOGGLE && useType != USE_SET )
{
if ( (currentState && useType == USE_ON) || (!currentState && useType == USE_OFF) )
if( ( currentState && useType == USE_ON ) || ( !currentState && useType == USE_OFF ) )
return 0;
}
return 1;
}
int CBaseEntity :: DamageDecal( int bitsDamageType )
int CBaseEntity::DamageDecal( int bitsDamageType )
{
if ( pev->rendermode == kRenderTransAlpha )
if( pev->rendermode == kRenderTransAlpha )
return -1;
if ( pev->rendermode != kRenderNormal )
if( pev->rendermode != kRenderNormal )
return DECAL_BPROOF1;
return DECAL_GUNSHOT1 + RANDOM_LONG(0,4);
return DECAL_GUNSHOT1 + RANDOM_LONG( 0, 4 );
}
// NOTE: szName must be a pointer to constant memory, e.g. "monster_class" because the entity
// will keep a pointer to it after this call.
CBaseEntity * CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner )
CBaseEntity *CBaseEntity::Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner )
{
edict_t *pent;
CBaseEntity *pEntity;
pent = CREATE_NAMED_ENTITY( MAKE_STRING( szName ));
if ( FNullEnt( pent ) )
pent = CREATE_NAMED_ENTITY( MAKE_STRING( szName ) );
if( FNullEnt( pent ) )
{
ALERT ( at_console, "NULL Ent in Create!\n" );
return NULL;

173
dlls/cbase.h
View File

@ -72,13 +72,19 @@ extern void SaveGlobalState( SAVERESTOREDATA *pSaveData );
extern void RestoreGlobalState( SAVERESTOREDATA *pSaveData );
extern void ResetGlobalState( void );
typedef enum { USE_OFF = 0, USE_ON = 1, USE_SET = 2, USE_TOGGLE = 3 } USE_TYPE;
typedef enum
{
USE_OFF = 0,
USE_ON = 1,
USE_SET = 2,
USE_TOGGLE = 3
} USE_TYPE;
extern void FireTargets( const char *targetName, CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
typedef void (CBaseEntity::*BASEPTR)(void);
typedef void (CBaseEntity::*ENTITYFUNCPTR)(CBaseEntity *pOther );
typedef void (CBaseEntity::*USEPTR)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
typedef void(CBaseEntity::*BASEPTR)( void );
typedef void(CBaseEntity::*ENTITYFUNCPTR)( CBaseEntity *pOther );
typedef void(CBaseEntity::*USEPTR)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
// For CLASSIFY
#define CLASS_NONE 0
@ -102,7 +108,6 @@ class CBaseMonster;
class CBasePlayerItem;
class CSquadMonster;
#define SF_NORESPAWN ( 1 << 30 )// !!!set this bit on guns and stuff that should never respawn.
//
@ -121,11 +126,10 @@ public:
operator CBaseEntity *();
CBaseEntity * operator = (CBaseEntity *pEntity);
CBaseEntity * operator ->();
CBaseEntity *operator = ( CBaseEntity *pEntity );
CBaseEntity *operator ->();
};
//
// Base Entity. All entity types derive from this
//
@ -143,7 +147,7 @@ public:
// initialization functions
virtual void Spawn( void ) { return; }
virtual void Precache( void ) { return; }
virtual void KeyValue( KeyValueData* pkvd) { pkvd->fHandled = FALSE; }
virtual void KeyValue( KeyValueData* pkvd ) { pkvd->fHandled = FALSE; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
virtual int ObjectCaps( void ) { return FCAP_ACROSS_TRANSITION; }
@ -152,23 +156,22 @@ public:
// Setup the object->object collision box (pev->mins / pev->maxs is the object->world collision box)
virtual void SetObjectCollisionBox( void );
// Classify - returns the type of group (i.e, "houndeye", or "human military" so that monsters with different classnames
// still realize that they are teammates. (overridden for monsters that form groups)
virtual int Classify ( void ) { return CLASS_NONE; };
virtual void DeathNotice ( entvars_t *pevChild ) {}// monster maker children use this to tell the monster maker that they have died.
// Classify - returns the type of group (i.e, "houndeye", or "human military" so that monsters with different classnames
// still realize that they are teammates. (overridden for monsters that form groups)
virtual int Classify( void ) { return CLASS_NONE; };
virtual void DeathNotice( entvars_t *pevChild ) {}// monster maker children use this to tell the monster maker that they have died.
static TYPEDESCRIPTION m_SaveData[];
virtual void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
virtual int TakeHealth( float flHealth, int bitsDamageType );
virtual void Killed( entvars_t *pevAttacker, int iGib );
virtual int BloodColor( void ) { return DONT_BLEED; }
virtual void TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
virtual BOOL IsTriggered( CBaseEntity *pActivator ) {return TRUE;}
virtual CBaseMonster *MyMonsterPointer( void ) { return NULL;}
virtual CSquadMonster *MySquadMonsterPointer( void ) { return NULL;}
virtual BOOL IsTriggered( CBaseEntity *pActivator ) {return TRUE; }
virtual CBaseMonster *MyMonsterPointer( void ) { return NULL; }
virtual CSquadMonster *MySquadMonsterPointer( void ) { return NULL; }
virtual int GetToggleState( void ) { return TS_AT_TOP; }
virtual void AddPoints( int score, BOOL bAllowNegativeScore ) {}
virtual void AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
@ -194,34 +197,33 @@ public:
virtual BOOL IsNetClient( void ) { return FALSE; }
virtual const char *TeamID( void ) { return ""; }
// virtual void SetActivator( CBaseEntity *pActivator ) {}
//virtual void SetActivator( CBaseEntity *pActivator ) {}
virtual CBaseEntity *GetNextTarget( void );
// fundamental callbacks
void (CBaseEntity ::*m_pfnThink)(void);
void (CBaseEntity ::*m_pfnTouch)( CBaseEntity *pOther );
void (CBaseEntity ::*m_pfnUse)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void (CBaseEntity ::*m_pfnBlocked)( CBaseEntity *pOther );
void ( CBaseEntity ::*m_pfnThink )( void);
void ( CBaseEntity ::*m_pfnTouch )( CBaseEntity *pOther );
void ( CBaseEntity ::*m_pfnUse )( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void ( CBaseEntity ::*m_pfnBlocked )( CBaseEntity *pOther );
virtual void Think( void ) { if (m_pfnThink) (this->*m_pfnThink)(); };
virtual void Touch( CBaseEntity *pOther ) { if (m_pfnTouch) (this->*m_pfnTouch)( pOther ); };
virtual void Think( void ) { if( m_pfnThink ) ( this->*m_pfnThink )(); }
virtual void Touch( CBaseEntity *pOther ) { if( m_pfnTouch ) (this->*m_pfnTouch)( pOther ); }
virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if (m_pfnUse)
(this->*m_pfnUse)( pActivator, pCaller, useType, value );
if( m_pfnUse )
( this->*m_pfnUse )( pActivator, pCaller, useType, value );
}
virtual void Blocked( CBaseEntity *pOther ) { if (m_pfnBlocked) (this->*m_pfnBlocked)( pOther ); };
virtual void Blocked( CBaseEntity *pOther ) { if( m_pfnBlocked ) ( this->*m_pfnBlocked )( pOther ); };
// allow engine to allocate instance data
void *operator new( size_t stAllocateBlock, entvars_t *pev )
{
return (void *)ALLOC_PRIVATE(ENT(pev), stAllocateBlock);
return (void *)ALLOC_PRIVATE( ENT( pev ), stAllocateBlock );
};
// don't use this.
#if _MSC_VER >= 1200 // only build this code if MSVC++ 6.0 or higher
void operator delete(void *pMem, entvars_t *pev)
void operator delete( void *pMem, entvars_t *pev )
{
pev->flags |= FL_KILLME;
};
@ -233,7 +235,7 @@ public:
void EXPORT SUB_Remove( void );
void EXPORT SUB_DoNothing( void );
void EXPORT SUB_StartFadeOut ( void );
void EXPORT SUB_FadeOut ( void );
void EXPORT SUB_FadeOut( void );
void EXPORT SUB_CallUseToggle( void ) { this->Use( this, this, USE_TOGGLE, 0 ); }
int ShouldToggle( USE_TYPE useType, BOOL currentState );
void FireBullets( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL );
@ -250,9 +252,9 @@ public:
static CBaseEntity *Instance( edict_t *pent )
{
if ( !pent )
pent = ENT(0);
CBaseEntity *pEnt = (CBaseEntity *)GET_PRIVATE(pent);
if( !pent )
pent = ENT( 0 );
CBaseEntity *pEnt = (CBaseEntity *)GET_PRIVATE( pent );
return pEnt;
}
@ -262,78 +264,72 @@ public:
CBaseMonster *GetMonsterPointer( entvars_t *pevMonster )
{
CBaseEntity *pEntity = Instance( pevMonster );
if ( pEntity )
if( pEntity )
return pEntity->MyMonsterPointer();
return NULL;
}
CBaseMonster *GetMonsterPointer( edict_t *pentMonster )
{
CBaseEntity *pEntity = Instance( pentMonster );
if ( pEntity )
if( pEntity )
return pEntity->MyMonsterPointer();
return NULL;
}
// Ugly code to lookup all functions to make sure they are exported when set.
#ifdef _DEBUG
void FunctionCheck( void *pFunction, char *name )
{
if (pFunction && !NAME_FOR_FUNCTION((unsigned long)(pFunction)) )
ALERT( at_error, "No EXPORT: %s:%s (%08lx)\n", STRING(pev->classname), name, (unsigned long)pFunction );
if( pFunction && !NAME_FOR_FUNCTION( (unsigned long)( pFunction ) ) )
ALERT( at_error, "No EXPORT: %s:%s (%08lx)\n", STRING( pev->classname ), name, (unsigned long)pFunction );
}
BASEPTR ThinkSet( BASEPTR func, char *name )
{
m_pfnThink = func;
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnThink)))), name );
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnThink ) ) ) ), name );
return func;
}
ENTITYFUNCPTR TouchSet( ENTITYFUNCPTR func, char *name )
{
m_pfnTouch = func;
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnTouch)))), name );
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnTouch ) ) ) ), name );
return func;
}
USEPTR UseSet( USEPTR func, char *name )
{
m_pfnUse = func;
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnUse)))), name );
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnUse ) ) ) ), name );
return func;
}
ENTITYFUNCPTR BlockedSet( ENTITYFUNCPTR func, char *name )
{
m_pfnBlocked = func;
FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnBlocked)))), name );
FunctionCheck( (void *)*( (int *)( (char *)this + ( offsetof( CBaseEntity, m_pfnBlocked ) ) ) ), name );
return func;
}
#endif
// virtual functions used by a few classes
// used by monsters that are created by the MonsterMaker
virtual void UpdateOwner( void ) { return; };
//
static CBaseEntity *Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner = NULL );
virtual BOOL FBecomeProne( void ) {return FALSE;};
edict_t *edict() { return ENT( pev ); };
EOFFSET eoffset( ) { return OFFSET( pev ); };
int entindex( ) { return ENTINDEX( edict() ); };
EOFFSET eoffset() { return OFFSET( pev ); };
int entindex() { return ENTINDEX( edict() ); };
virtual Vector Center( ) { return (pev->absmax + pev->absmin) * 0.5; }; // center point of entity
virtual Vector EyePosition( ) { return pev->origin + pev->view_ofs; }; // position of eyes
virtual Vector EarPosition( ) { return pev->origin + pev->view_ofs; }; // position of ears
virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ); }; // position to shoot at
virtual Vector Center() { return ( pev->absmax + pev->absmin ) * 0.5; }; // center point of entity
virtual Vector EyePosition() { return pev->origin + pev->view_ofs; }; // position of eyes
virtual Vector EarPosition() { return pev->origin + pev->view_ofs; }; // position of ears
virtual Vector BodyTarget( const Vector &posSrc ) { return Center(); }; // position to shoot at
virtual int Illumination( ) { return GETENTITYILLUM( ENT( pev ) ); };
virtual int Illumination() { return GETENTITYILLUM( ENT( pev ) ); };
virtual BOOL FVisible ( CBaseEntity *pEntity );
virtual BOOL FVisible ( const Vector &vecOrigin );
virtual BOOL FVisible( CBaseEntity *pEntity );
virtual BOOL FVisible( const Vector &vecOrigin );
//We use this variables to store each ammo count.
int ammo_9mm;
@ -354,8 +350,6 @@ public:
int m_fireState;
};
// Ugly technique to override base member functions
// Normally it's illegal to cast a pointer to a member function of a derived class to a pointer to a
// member function of a base class. static_cast is a sleezy way around that problem.
@ -378,19 +372,16 @@ public:
#define ResetUse( ) m_pfnUse = static_cast <void (CBaseEntity::*)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )> (NULL)
#define ResetBlocked( ) m_pfnBlocked = static_cast <void (CBaseEntity::*)(CBaseEntity *)> (NULL)
#endif
class CPointEntity : public CBaseEntity
{
public:
void Spawn( void );
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int ObjectCaps( void ) { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
private:
};
typedef struct locksounds // sounds that doors and buttons make when locked/unlocked
{
string_t sLockedSound; // sound a door makes when it's locked
@ -407,7 +398,7 @@ typedef struct locksounds // sounds that doors and buttons make when locked/un
BYTE bEOFUnlocked; // true if hit end of list of unlocked sentences
} locksound_t;
void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton);
void PlayLockSounds( entvars_t *pev, locksound_t *pls, int flocked, int fbutton );
//
// MultiSouce
@ -419,15 +410,15 @@ void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fbutton);
class CMultiSource : public CPointEntity
{
public:
void Spawn( );
void Spawn();
void KeyValue( KeyValueData *pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
int ObjectCaps( void ) { return (CPointEntity::ObjectCaps() | FCAP_MASTER); }
int ObjectCaps( void ) { return ( CPointEntity::ObjectCaps() | FCAP_MASTER ); }
BOOL IsTriggered( CBaseEntity *pActivator );
void EXPORT Register( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
EHANDLE m_rgEntities[MS_MAX_TARGETS];
@ -447,41 +438,38 @@ public:
float m_flDelay;
int m_iszKillTarget;
virtual void KeyValue( KeyValueData* pkvd);
virtual void KeyValue( KeyValueData *pkvd );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
// common member functions
void SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value );
void EXPORT DelayThink( void );
};
class CBaseAnimating : public CBaseDelay
{
public:
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
// Basic Monster Animation functions
float StudioFrameAdvance( float flInterval = 0.0 ); // accumulate animation frame time from last time called until now
int GetSequenceFlags( void );
int LookupActivity ( int activity );
int LookupActivityHeaviest ( int activity );
int LookupSequence ( const char *label );
void ResetSequenceInfo ( );
void DispatchAnimEvents ( float flFutureInterval = 0.1 ); // Handle events that have happend since last time called up until X seconds into the future
int LookupActivity( int activity );
int LookupActivityHeaviest( int activity );
int LookupSequence( const char *label );
void ResetSequenceInfo();
void DispatchAnimEvents( float flFutureInterval = 0.1 ); // Handle events that have happend since last time called up until X seconds into the future
virtual void HandleAnimEvent( MonsterEvent_t *pEvent ) { return; };
float SetBoneController ( int iController, float flValue );
void InitBoneControllers ( void );
float SetBlending ( int iBlender, float flValue );
void GetBonePosition ( int iBone, Vector &origin, Vector &angles );
float SetBoneController( int iController, float flValue );
void InitBoneControllers( void );
float SetBlending( int iBlender, float flValue );
void GetBonePosition( int iBone, Vector &origin, Vector &angles );
void GetAutomovement( Vector &origin, Vector &angles, float flInterval = 0.1 );
int FindTransition( int iEndingSequence, int iGoalSequence, int *piDir );
void GetAttachment ( int iAttachment, Vector &origin, Vector &angles );
void GetAttachment( int iAttachment, Vector &origin, Vector &angles );
void SetBodygroup( int iGroup, int iValue );
int GetBodygroup( int iGroup );
int ExtractBbox( int sequence, float *mins, float *maxs );
@ -495,7 +483,6 @@ public:
BOOL m_fSequenceLoops; // true if the sequence loops
};
//
// generic Toggle entity.
//
@ -671,7 +658,6 @@ class CSound;
char *ButtonSound( int sound ); // get string of button sound number
//
// Generic Button
//
@ -683,16 +669,16 @@ public:
void RotSpawn( void );
virtual void KeyValue( KeyValueData* pkvd);
void ButtonActivate( );
void ButtonActivate();
void SparkSoundCache( void );
void EXPORT ButtonShot( void );
void EXPORT ButtonTouch( CBaseEntity *pOther );
void EXPORT ButtonSpark ( void );
void EXPORT ButtonSpark( void );
void EXPORT TriggerAndWait( void );
void EXPORT ButtonReturn( void );
void EXPORT ButtonBackHome( void );
void EXPORT ButtonUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT ButtonUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
@ -723,7 +709,6 @@ public:
//
// Weapons
//
#define BAD_WEAPON 0x00007FFF
//
@ -735,22 +720,21 @@ template <class T> T * GetClassPtr( T *a )
entvars_t *pev = (entvars_t *)a;
// allocate entity if necessary
if (pev == NULL)
pev = VARS(CREATE_ENTITY());
if( pev == NULL )
pev = VARS( CREATE_ENTITY() );
// get the private data
a = (T *)GET_PRIVATE(ENT(pev));
a = (T *)GET_PRIVATE( ENT( pev ) );
if (a == NULL)
if( a == NULL )
{
// allocate private data
a = new(pev) T;
a = new( pev ) T;
a->pev = pev;
}
return a;
}
/*
bit_PUSHBRUSH_DATA | bit_TOGGLE_DATA
bit_MONSTER_DATA
@ -784,7 +768,6 @@ typedef struct _SelAmmo
BYTE Ammo2;
} SelAmmo;
// this moved here from world.cpp, to allow classes to be derived from it
//=======================
// CWorld

1
dlls/cdll_dll.h
View File

@ -42,5 +42,4 @@
#define WEAPON_SUIT 31
#endif

771
dlls/client.cpp
View File

File diff suppressed because it is too large Load Diff

13
dlls/client.h
View File

@ -15,7 +15,7 @@
#ifndef CLIENT_H
#define CLIENT_H
extern void respawn( entvars_t* pev, BOOL fCopyCorpse );
extern void respawn( entvars_t *pev, BOOL fCopyCorpse );
extern BOOL ClientConnect( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
extern void ClientDisconnect( edict_t *pEntity );
extern void ClientKill( edict_t *pEntity );
@ -35,14 +35,14 @@ extern void ClientPrecache( void );
extern const char *GetGameDescription( void );
extern void PlayerCustomization( edict_t *pEntity, customization_t *pCust );
extern void SpectatorConnect ( edict_t *pEntity );
extern void SpectatorDisconnect ( edict_t *pEntity );
extern void SpectatorThink ( edict_t *pEntity );
extern void SpectatorConnect( edict_t *pEntity );
extern void SpectatorDisconnect( edict_t *pEntity );
extern void SpectatorThink( edict_t *pEntity );
extern void Sys_Error( const char *error_string );
extern void SetupVisibility( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas );
extern void UpdateClientData ( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
extern void UpdateClientData( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd );
extern int AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet );
extern void CreateBaseline( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs );
extern void RegisterEncoders( void );
@ -56,10 +56,9 @@ extern int ConnectionlessPacket( const struct netadr_s *net_from, const char *ar
extern int GetHullBounds( int hullnumber, float *mins, float *maxs );
extern void CreateInstancedBaselines ( void );
extern void CreateInstancedBaselines( void );
extern int InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message );
extern int AllowLagCompensation( void );
#endif // CLIENT_H

630
dlls/combat.cpp
View File

File diff suppressed because it is too large Load Diff

413
dlls/controller.cpp
View File

File diff suppressed because it is too large Load Diff

198
dlls/crossbow.cpp
View File

@ -36,7 +36,7 @@ class CCrossbowBolt : public CBaseEntity
{
void Spawn( void );
void Precache( void );
int Classify ( void );
int Classify( void );
void EXPORT BubbleThink( void );
void EXPORT BoltTouch( CBaseEntity *pOther );
void EXPORT ExplodeThink( void );
@ -53,44 +53,42 @@ CCrossbowBolt *CCrossbowBolt::BoltCreate( void )
{
// Create a new entity with CCrossbowBolt private data
CCrossbowBolt *pBolt = GetClassPtr( (CCrossbowBolt *)NULL );
pBolt->pev->classname = MAKE_STRING("crossbow_bolt"); // g-cont. enable save\restore
pBolt->pev->classname = MAKE_STRING( "crossbow_bolt" ); // g-cont. enable save\restore
pBolt->Spawn();
return pBolt;
}
void CCrossbowBolt::Spawn( )
void CCrossbowBolt::Spawn()
{
Precache( );
Precache();
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
pev->gravity = 0.5;
SET_MODEL(ENT(pev), "models/crossbow_bolt.mdl");
SET_MODEL( ENT( pev ), "models/crossbow_bolt.mdl" );
UTIL_SetOrigin( pev, pev->origin );
UTIL_SetSize(pev, Vector(0, 0, 0), Vector(0, 0, 0));
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
SetTouch( &CCrossbowBolt::BoltTouch );
SetThink( &CCrossbowBolt::BubbleThink );
pev->nextthink = gpGlobals->time + 0.2;
}
void CCrossbowBolt::Precache( )
void CCrossbowBolt::Precache()
{
PRECACHE_MODEL ("models/crossbow_bolt.mdl");
PRECACHE_SOUND("weapons/xbow_hitbod1.wav");
PRECACHE_SOUND("weapons/xbow_hitbod2.wav");
PRECACHE_SOUND("weapons/xbow_fly1.wav");
PRECACHE_SOUND("weapons/xbow_hit1.wav");
PRECACHE_SOUND("fvox/beep.wav");
m_iTrail = PRECACHE_MODEL("sprites/streak.spr");
PRECACHE_MODEL( "models/crossbow_bolt.mdl" );
PRECACHE_SOUND( "weapons/xbow_hitbod1.wav" );
PRECACHE_SOUND( "weapons/xbow_hitbod2.wav" );
PRECACHE_SOUND( "weapons/xbow_fly1.wav" );
PRECACHE_SOUND( "weapons/xbow_hit1.wav" );
PRECACHE_SOUND( "fvox/beep.wav" );
m_iTrail = PRECACHE_MODEL( "sprites/streak.spr" );
}
int CCrossbowBolt :: Classify ( void )
int CCrossbowBolt::Classify( void )
{
return CLASS_NONE;
}
@ -100,71 +98,73 @@ void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
SetTouch( NULL );
SetThink( NULL );
if (pOther->pev->takedamage)
if( pOther->pev->takedamage )
{
TraceResult tr = UTIL_GetGlobalTrace( );
TraceResult tr = UTIL_GetGlobalTrace();
entvars_t *pevOwner;
pevOwner = VARS( pev->owner );
// UNDONE: this needs to call TraceAttack instead
ClearMultiDamage( );
ClearMultiDamage();
if ( pOther->IsPlayer() )
if( pOther->IsPlayer() )
{
pOther->TraceAttack(pevOwner, gSkillData.plrDmgCrossbowClient, pev->velocity.Normalize(), &tr, DMG_NEVERGIB );
pOther->TraceAttack( pevOwner, gSkillData.plrDmgCrossbowClient, pev->velocity.Normalize(), &tr, DMG_NEVERGIB );
}
else
{
pOther->TraceAttack(pevOwner, gSkillData.plrDmgCrossbowMonster, pev->velocity.Normalize(), &tr, DMG_BULLET | DMG_NEVERGIB );
pOther->TraceAttack( pevOwner, gSkillData.plrDmgCrossbowMonster, pev->velocity.Normalize(), &tr, DMG_BULLET | DMG_NEVERGIB );
}
ApplyMultiDamage( pev, pevOwner );
pev->velocity = Vector( 0, 0, 0 );
// play body "thwack" sound
switch( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0:
EMIT_SOUND(ENT(pev), CHAN_BODY, "weapons/xbow_hitbod1.wav", 1, ATTN_NORM); break;
EMIT_SOUND( ENT( pev ), CHAN_BODY, "weapons/xbow_hitbod1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND(ENT(pev), CHAN_BODY, "weapons/xbow_hitbod2.wav", 1, ATTN_NORM); break;
EMIT_SOUND( ENT( pev ), CHAN_BODY, "weapons/xbow_hitbod2.wav", 1, ATTN_NORM );
break;
}
if ( !g_pGameRules->IsMultiplayer() )
if( !g_pGameRules->IsMultiplayer() )
{
Killed( pev, GIB_NEVER );
}
}
else
{
EMIT_SOUND_DYN(ENT(pev), CHAN_BODY, "weapons/xbow_hit1.wav", RANDOM_FLOAT(0.95, 1.0), ATTN_NORM, 0, 98 + RANDOM_LONG(0,7));
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "weapons/xbow_hit1.wav", RANDOM_FLOAT( 0.95, 1.0 ), ATTN_NORM, 0, 98 + RANDOM_LONG( 0, 7 ) );
SetThink( &CBaseEntity::SUB_Remove );
pev->nextthink = gpGlobals->time;// this will get changed below if the bolt is allowed to stick in what it hit.
if ( FClassnameIs( pOther->pev, "worldspawn" ) )
if( FClassnameIs( pOther->pev, "worldspawn" ) )
{
// if what we hit is static architecture, can stay around for a while.
Vector vecDir = pev->velocity.Normalize( );
Vector vecDir = pev->velocity.Normalize();
UTIL_SetOrigin( pev, pev->origin - vecDir * 12 );
pev->angles = UTIL_VecToAngles( vecDir );
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_FLY;
pev->velocity = Vector( 0, 0, 0 );
pev->avelocity.z = 0;
pev->angles.z = RANDOM_LONG(0,360);
pev->angles.z = RANDOM_LONG( 0, 360 );
pev->nextthink = gpGlobals->time + 10.0;
}
else if ( pOther->pev->movetype == MOVETYPE_PUSH || pOther->pev->movetype == MOVETYPE_PUSHSTEP )
else if( pOther->pev->movetype == MOVETYPE_PUSH || pOther->pev->movetype == MOVETYPE_PUSHSTEP )
{
Vector vecDir = pev->velocity.Normalize( );
Vector vecDir = pev->velocity.Normalize();
UTIL_SetOrigin( pev, pev->origin - vecDir * 12 );
pev->angles = UTIL_VecToAngles( vecDir );
pev->solid = SOLID_NOT;
pev->velocity = Vector( 0, 0, 0 );
pev->avelocity.z = 0;
pev->angles.z = RANDOM_LONG(0,360);
pev->angles.z = RANDOM_LONG( 0, 360 );
pev->nextthink = gpGlobals->time + 10.0;
// g-cont. Setup movewith feature
@ -172,13 +172,13 @@ void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
pev->aiment = ENT( pOther->pev ); // set parent
}
if (UTIL_PointContents(pev->origin) != CONTENTS_WATER)
if( UTIL_PointContents( pev->origin ) != CONTENTS_WATER )
{
UTIL_Sparks( pev->origin );
}
}
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
SetThink( &CCrossbowBolt::ExplodeThink );
pev->nextthink = gpGlobals->time + 0.1;
@ -189,7 +189,7 @@ void CCrossbowBolt::BubbleThink( void )
{
pev->nextthink = gpGlobals->time + 0.1;
if (pev->waterlevel == 0)
if( pev->waterlevel == 0 )
return;
UTIL_BubbleTrail( pev->origin - pev->velocity * 0.1, pev->origin, 1 );
@ -197,18 +197,18 @@ void CCrossbowBolt::BubbleThink( void )
void CCrossbowBolt::ExplodeThink( void )
{
int iContents = UTIL_PointContents ( pev->origin );
int iContents = UTIL_PointContents( pev->origin );
int iScale;
pev->dmg = 40;
iScale = 10;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_EXPLOSION);
WRITE_BYTE( TE_EXPLOSION );
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z );
if (iContents != CONTENTS_WATER)
if( iContents != CONTENTS_WATER )
{
WRITE_SHORT( g_sModelIndexFireball );
}
@ -223,7 +223,7 @@ void CCrossbowBolt::ExplodeThink( void )
entvars_t *pevOwner;
if ( pev->owner )
if( pev->owner )
pevOwner = VARS( pev->owner );
else
pevOwner = NULL;
@ -232,11 +232,12 @@ void CCrossbowBolt::ExplodeThink( void )
::RadiusDamage( pev->origin, pev, pevOwner, pev->dmg, 128, CLASS_NONE, DMG_BLAST | DMG_ALWAYSGIB );
UTIL_Remove(this);
UTIL_Remove( this );
}
#endif
enum crossbow_e {
enum crossbow_e
{
CROSSBOW_IDLE1 = 0, // full
CROSSBOW_IDLE2, // empty
CROSSBOW_FIDGET1, // full
@ -253,11 +254,11 @@ enum crossbow_e {
LINK_ENTITY_TO_CLASS( weapon_crossbow, CCrossbow )
void CCrossbow::Spawn( )
void CCrossbow::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_CROSSBOW;
SET_MODEL(ENT(pev), "models/w_crossbow.mdl");
SET_MODEL( ENT( pev ), "models/w_crossbow.mdl" );
m_iDefaultAmmo = CROSSBOW_DEFAULT_GIVE;
@ -266,7 +267,7 @@ void CCrossbow::Spawn( )
int CCrossbow::AddToPlayer( CBasePlayer *pPlayer )
{
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
WRITE_BYTE( m_iId );
@ -278,12 +279,12 @@ int CCrossbow::AddToPlayer( CBasePlayer *pPlayer )
void CCrossbow::Precache( void )
{
PRECACHE_MODEL("models/w_crossbow.mdl");
PRECACHE_MODEL("models/v_crossbow.mdl");
PRECACHE_MODEL("models/p_crossbow.mdl");
PRECACHE_MODEL( "models/w_crossbow.mdl" );
PRECACHE_MODEL( "models/v_crossbow.mdl" );
PRECACHE_MODEL( "models/p_crossbow.mdl" );
PRECACHE_SOUND("weapons/xbow_fire1.wav");
PRECACHE_SOUND("weapons/xbow_reload1.wav");
PRECACHE_SOUND( "weapons/xbow_fire1.wav" );
PRECACHE_SOUND( "weapons/xbow_reload1.wav" );
UTIL_PrecacheOther( "crossbow_bolt" );
@ -291,10 +292,9 @@ void CCrossbow::Precache( void )
m_usCrossbow2 = PRECACHE_EVENT( 1, "events/crossbow2.sc" );
}
int CCrossbow::GetItemInfo(ItemInfo *p)
int CCrossbow::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "bolts";
p->iMaxAmmo1 = BOLT_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -308,10 +308,9 @@ int CCrossbow::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CCrossbow::Deploy( )
BOOL CCrossbow::Deploy()
{
if (m_iClip)
if( m_iClip )
return DefaultDeploy( "models/v_crossbow.mdl", "models/p_crossbow.mdl", CROSSBOW_DRAW1, "bow" );
return DefaultDeploy( "models/v_crossbow.mdl", "models/p_crossbow.mdl", CROSSBOW_DRAW2, "bow" );
}
@ -320,13 +319,13 @@ void CCrossbow::Holster( int skiplocal /* = 0 */ )
{
m_fInReload = FALSE;// cancel any reload in progress.
if ( m_fInZoom )
if( m_fInZoom )
{
SecondaryAttack( );
SecondaryAttack();
}
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
if (m_iClip)
if( m_iClip )
SendWeaponAnim( CROSSBOW_HOLSTER1 );
else
SendWeaponAnim( CROSSBOW_HOLSTER2 );
@ -334,11 +333,10 @@ void CCrossbow::Holster( int skiplocal /* = 0 */ )
void CCrossbow::PrimaryAttack( void )
{
#ifdef CLIENT_DLL
if ( m_fInZoom && bIsMultiplayer() )
if( m_fInZoom && bIsMultiplayer() )
#else
if ( m_fInZoom && g_pGameRules->IsMultiplayer() )
if( m_fInZoom && g_pGameRules->IsMultiplayer() )
#endif
{
FireSniperBolt();
@ -353,9 +351,9 @@ void CCrossbow::FireSniperBolt()
{
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.75;
if (m_iClip == 0)
if( m_iClip == 0 )
{
PlayEmptySound( );
PlayEmptySound();
return;
}
@ -378,16 +376,16 @@ void CCrossbow::FireSniperBolt()
Vector anglesAim = m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle;
UTIL_MakeVectors( anglesAim );
Vector vecSrc = m_pPlayer->GetGunPosition( ) - gpGlobals->v_up * 2;
Vector vecSrc = m_pPlayer->GetGunPosition() - gpGlobals->v_up * 2;
Vector vecDir = gpGlobals->v_forward;
UTIL_TraceLine(vecSrc, vecSrc + vecDir * 8192, dont_ignore_monsters, m_pPlayer->edict(), &tr);
UTIL_TraceLine( vecSrc, vecSrc + vecDir * 8192, dont_ignore_monsters, m_pPlayer->edict(), &tr );
#ifndef CLIENT_DLL
if ( tr.pHit->v.takedamage )
if( tr.pHit->v.takedamage )
{
ClearMultiDamage( );
CBaseEntity::Instance(tr.pHit)->TraceAttack(m_pPlayer->pev, 120, vecDir, &tr, DMG_BULLET | DMG_NEVERGIB );
ClearMultiDamage();
CBaseEntity::Instance( tr.pHit )->TraceAttack( m_pPlayer->pev, 120, vecDir, &tr, DMG_BULLET | DMG_NEVERGIB );
ApplyMultiDamage( pev, m_pPlayer->pev );
}
#endif
@ -397,9 +395,9 @@ void CCrossbow::FireBolt()
{
TraceResult tr;
if (m_iClip == 0)
if( m_iClip == 0 )
{
PlayEmptySound( );
PlayEmptySound();
return;
}
@ -423,7 +421,7 @@ void CCrossbow::FireBolt()
UTIL_MakeVectors( anglesAim );
anglesAim.x = -anglesAim.x;
Vector vecSrc = m_pPlayer->GetGunPosition( ) - gpGlobals->v_up * 2;
Vector vecSrc = m_pPlayer->GetGunPosition() - gpGlobals->v_up * 2;
Vector vecDir = gpGlobals->v_forward;
#ifndef CLIENT_DLL
@ -432,7 +430,7 @@ void CCrossbow::FireBolt()
pBolt->pev->angles = anglesAim;
pBolt->pev->owner = m_pPlayer->edict();
if (m_pPlayer->pev->waterlevel == 3)
if( m_pPlayer->pev->waterlevel == 3 )
{
pBolt->pev->velocity = vecDir * BOLT_WATER_VELOCITY;
pBolt->pev->speed = BOLT_WATER_VELOCITY;
@ -445,29 +443,28 @@ void CCrossbow::FireBolt()
pBolt->pev->avelocity.z = 10;
#endif
if (!m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
if( !m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
// HEV suit - indicate out of ammo condition
m_pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
m_pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 );
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.75;
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 0.75;
if (m_iClip != 0)
if( m_iClip != 0 )
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 5.0;
else
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 0.75;
}
void CCrossbow::SecondaryAttack()
{
if ( m_pPlayer->pev->fov != 0 )
if( m_pPlayer->pev->fov != 0 )
{
m_pPlayer->pev->fov = m_pPlayer->m_iFOV = 0; // 0 means reset to default fov
m_fInZoom = 0;
}
else if ( m_pPlayer->pev->fov != 20 )
else if( m_pPlayer->pev->fov != 20 )
{
m_pPlayer->pev->fov = m_pPlayer->m_iFOV = 20;
m_fInZoom = 1;
@ -477,36 +474,34 @@ void CCrossbow::SecondaryAttack()
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 1.0;
}
void CCrossbow::Reload( void )
{
if ( m_pPlayer->ammo_bolts <= 0 )
if( m_pPlayer->ammo_bolts <= 0 )
return;
if ( m_pPlayer->pev->fov != 0 )
if( m_pPlayer->pev->fov != 0 )
{
SecondaryAttack();
}
if ( DefaultReload( 5, CROSSBOW_RELOAD, 4.5 ) )
if( DefaultReload( 5, CROSSBOW_RELOAD, 4.5 ) )
{
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/xbow_reload1.wav", RANDOM_FLOAT(0.95, 1.0), ATTN_NORM, 0, 93 + RANDOM_LONG(0,0xF));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/xbow_reload1.wav", RANDOM_FLOAT( 0.95, 1.0 ), ATTN_NORM, 0, 93 + RANDOM_LONG( 0, 0xF ) );
}
}
void CCrossbow::WeaponIdle( void )
{
m_pPlayer->GetAutoaimVector( AUTOAIM_2DEGREES ); // get the autoaim vector but ignore it; used for autoaim crosshair in DM
ResetEmptySound( );
ResetEmptySound();
if ( m_flTimeWeaponIdle < UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle < UTIL_WeaponTimeBase() )
{
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0, 1 );
if (flRand <= 0.75)
if( flRand <= 0.75 )
{
if (m_iClip)
if( m_iClip )
{
SendWeaponAnim( CROSSBOW_IDLE1 );
}
@ -518,7 +513,7 @@ void CCrossbow::WeaponIdle( void )
}
else
{
if (m_iClip)
if( m_iClip )
{
SendWeaponAnim( CROSSBOW_FIDGET1 );
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 90.0 / 30.0;
@ -533,26 +528,24 @@ void CCrossbow::WeaponIdle( void )
}
}
class CCrossbowAmmo : public CBasePlayerAmmo
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_crossbow_clip.mdl");
CBasePlayerAmmo::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_crossbow_clip.mdl" );
CBasePlayerAmmo::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_crossbow_clip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_crossbow_clip.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
}
BOOL AddAmmo( CBaseEntity *pOther )
{
if (pOther->GiveAmmo( AMMO_CROSSBOWCLIP_GIVE, "bolts", BOLT_MAX_CARRY ) != -1)
if( pOther->GiveAmmo( AMMO_CROSSBOWCLIP_GIVE, "bolts", BOLT_MAX_CARRY ) != -1 )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
return TRUE;
}
return FALSE;
@ -560,7 +553,4 @@ class CCrossbowAmmo : public CBasePlayerAmmo
};
LINK_ENTITY_TO_CLASS( ammo_crossbow, CCrossbowAmmo )
#endif

134
dlls/crowbar.cpp
View File

@ -22,13 +22,13 @@
#include "player.h"
#include "gamerules.h"
#define CROWBAR_BODYHIT_VOLUME 128
#define CROWBAR_WALLHIT_VOLUME 512
LINK_ENTITY_TO_CLASS( weapon_crowbar, CCrowbar )
enum gauss_e {
enum gauss_e
{
CROWBAR_IDLE = 0,
CROWBAR_DRAW,
CROWBAR_HOLSTER,
@ -43,33 +43,32 @@ enum gauss_e {
void CCrowbar::Spawn( )
{
Precache( );
Precache();
m_iId = WEAPON_CROWBAR;
SET_MODEL(ENT(pev), "models/w_crowbar.mdl");
SET_MODEL( ENT( pev ), "models/w_crowbar.mdl" );
m_iClip = -1;
FallInit();// get ready to fall down.
}
void CCrowbar::Precache( void )
{
PRECACHE_MODEL("models/v_crowbar.mdl");
PRECACHE_MODEL("models/w_crowbar.mdl");
PRECACHE_MODEL("models/p_crowbar.mdl");
PRECACHE_SOUND("weapons/cbar_hit1.wav");
PRECACHE_SOUND("weapons/cbar_hit2.wav");
PRECACHE_SOUND("weapons/cbar_hitbod1.wav");
PRECACHE_SOUND("weapons/cbar_hitbod2.wav");
PRECACHE_SOUND("weapons/cbar_hitbod3.wav");
PRECACHE_SOUND("weapons/cbar_miss1.wav");
PRECACHE_MODEL( "models/v_crowbar.mdl ");
PRECACHE_MODEL( "models/w_crowbar.mdl ");
PRECACHE_MODEL( "models/p_crowbar.mdl ");
PRECACHE_SOUND( "weapons/cbar_hit1.wav ");
PRECACHE_SOUND( "weapons/cbar_hit2.wav ");
PRECACHE_SOUND( "weapons/cbar_hitbod1.wav ");
PRECACHE_SOUND( "weapons/cbar_hitbod2.wav ");
PRECACHE_SOUND( "weapons/cbar_hitbod3.wav ");
PRECACHE_SOUND( "weapons/cbar_miss1.wav ");
m_usCrowbar = PRECACHE_EVENT ( 1, "events/crowbar.sc" );
m_usCrowbar = PRECACHE_EVENT( 1, "events/crowbar.sc" );
}
int CCrowbar::GetItemInfo(ItemInfo *p)
int CCrowbar::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = NULL;
p->iMaxAmmo1 = -1;
p->pszAmmo2 = NULL;
@ -82,9 +81,7 @@ int CCrowbar::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CCrowbar::Deploy( )
BOOL CCrowbar::Deploy()
{
return DefaultDeploy( "models/v_crowbar.mdl", "models/p_crowbar.mdl", CROWBAR_DRAW, "crowbar" );
}
@ -95,7 +92,6 @@ void CCrowbar::Holster( int skiplocal /* = 0 */ )
SendWeaponAnim( CROWBAR_HOLSTER );
}
void FindHullIntersection( const Vector &vecSrc, TraceResult &tr, float *mins, float *maxs, edict_t *pEntity )
{
int i, j, k;
@ -107,29 +103,29 @@ void FindHullIntersection( const Vector &vecSrc, TraceResult &tr, float *mins, f
distance = 1e6f;
vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
vecHullEnd = vecSrc + ( ( vecHullEnd - vecSrc ) * 2 );
UTIL_TraceLine( vecSrc, vecHullEnd, dont_ignore_monsters, pEntity, &tmpTrace );
if ( tmpTrace.flFraction < 1.0 )
if( tmpTrace.flFraction < 1.0 )
{
tr = tmpTrace;
return;
}
for ( i = 0; i < 2; i++ )
for( i = 0; i < 2; i++ )
{
for ( j = 0; j < 2; j++ )
for( j = 0; j < 2; j++ )
{
for ( k = 0; k < 2; k++ )
for( k = 0; k < 2; k++ )
{
vecEnd.x = vecHullEnd.x + minmaxs[i][0];
vecEnd.y = vecHullEnd.y + minmaxs[j][1];
vecEnd.z = vecHullEnd.z + minmaxs[k][2];
UTIL_TraceLine( vecSrc, vecEnd, dont_ignore_monsters, pEntity, &tmpTrace );
if ( tmpTrace.flFraction < 1.0 )
if( tmpTrace.flFraction < 1.0 )
{
float thisDistance = (tmpTrace.vecEndPos - vecSrc).Length();
if ( thisDistance < distance )
float thisDistance = ( tmpTrace.vecEndPos - vecSrc ).Length();
if( thisDistance < distance )
{
tr = tmpTrace;
distance = thisDistance;
@ -140,65 +136,59 @@ void FindHullIntersection( const Vector &vecSrc, TraceResult &tr, float *mins, f
}
}
void CCrowbar::PrimaryAttack()
{
if (! Swing( 1 ))
if( !Swing( 1 ) )
{
SetThink( &CCrowbar::SwingAgain );
pev->nextthink = gpGlobals->time + 0.1;
}
}
void CCrowbar::Smack( )
void CCrowbar::Smack()
{
DecalGunshot( &m_trHit, BULLET_PLAYER_CROWBAR );
}
void CCrowbar::SwingAgain( void )
{
Swing( 0 );
}
int CCrowbar::Swing( int fFirst )
{
int fDidHit = FALSE;
TraceResult tr;
UTIL_MakeVectors (m_pPlayer->pev->v_angle);
Vector vecSrc = m_pPlayer->GetGunPosition( );
UTIL_MakeVectors( m_pPlayer->pev->v_angle );
Vector vecSrc = m_pPlayer->GetGunPosition();
Vector vecEnd = vecSrc + gpGlobals->v_forward * 32;
UTIL_TraceLine( vecSrc, vecEnd, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );
#ifndef CLIENT_DLL
if ( tr.flFraction >= 1.0 )
if( tr.flFraction >= 1.0 )
{
UTIL_TraceHull( vecSrc, vecEnd, dont_ignore_monsters, head_hull, ENT( m_pPlayer->pev ), &tr );
if ( tr.flFraction < 1.0 )
if( tr.flFraction < 1.0 )
{
// Calculate the point of intersection of the line (or hull) and the object we hit
// This is and approximation of the "best" intersection
CBaseEntity *pHit = CBaseEntity::Instance( tr.pHit );
if ( !pHit || pHit->IsBSPModel() )
if( !pHit || pHit->IsBSPModel() )
FindHullIntersection( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, m_pPlayer->edict() );
vecEnd = tr.vecEndPos; // This is the point on the actual surface (the hull could have hit space)
}
}
#endif
PLAYBACK_EVENT_FULL( FEV_NOTHOST, m_pPlayer->edict(), m_usCrowbar,
0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0, 0, 0,
0.0, 0, 0.0 );
if ( tr.flFraction >= 1.0 )
if( tr.flFraction >= 1.0 )
{
if (fFirst)
if( fFirst )
{
// miss
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.5;
@ -209,36 +199,38 @@ int CCrowbar::Swing( int fFirst )
}
else
{
switch( ((m_iSwing++) % 2) + 1 )
switch( ( ( m_iSwing++ ) % 2 ) + 1 )
{
case 0:
SendWeaponAnim( CROWBAR_ATTACK1HIT ); break;
SendWeaponAnim( CROWBAR_ATTACK1HIT );
break;
case 1:
SendWeaponAnim( CROWBAR_ATTACK2HIT ); break;
SendWeaponAnim( CROWBAR_ATTACK2HIT );
break;
case 2:
SendWeaponAnim( CROWBAR_ATTACK3HIT ); break;
SendWeaponAnim( CROWBAR_ATTACK3HIT );
break;
}
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
#ifndef CLIENT_DLL
// hit
fDidHit = TRUE;
CBaseEntity *pEntity = CBaseEntity::Instance(tr.pHit);
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
ClearMultiDamage( );
ClearMultiDamage();
if ( (m_flNextPrimaryAttack + 1 < UTIL_WeaponTimeBase() ) || g_pGameRules->IsMultiplayer() )
if( ( m_flNextPrimaryAttack + 1 < UTIL_WeaponTimeBase() ) || g_pGameRules->IsMultiplayer() )
{
// first swing does full damage
pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgCrowbar, gpGlobals->v_forward, &tr, DMG_CLUB );
pEntity->TraceAttack( m_pPlayer->pev, gSkillData.plrDmgCrowbar, gpGlobals->v_forward, &tr, DMG_CLUB );
}
else
{
// subsequent swings do half
pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgCrowbar / 2, gpGlobals->v_forward, &tr, DMG_CLUB );
pEntity->TraceAttack( m_pPlayer->pev, gSkillData.plrDmgCrowbar / 2, gpGlobals->v_forward, &tr, DMG_CLUB );
}
ApplyMultiDamage( m_pPlayer->pev, m_pPlayer->pev );
@ -246,22 +238,25 @@ int CCrowbar::Swing( int fFirst )
float flVol = 1.0;
int fHitWorld = TRUE;
if (pEntity)
if( pEntity )
{
if ( pEntity->Classify() != CLASS_NONE && pEntity->Classify() != CLASS_MACHINE )
if( pEntity->Classify() != CLASS_NONE && pEntity->Classify() != CLASS_MACHINE )
{
// play thwack or smack sound
switch( RANDOM_LONG(0,2) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hitbod1.wav", 1, ATTN_NORM); break;
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hitbod1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hitbod2.wav", 1, ATTN_NORM); break;
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hitbod2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hitbod3.wav", 1, ATTN_NORM); break;
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hitbod3.wav", 1, ATTN_NORM );
break;
}
m_pPlayer->m_iWeaponVolume = CROWBAR_BODYHIT_VOLUME;
if ( !pEntity->IsAlive() )
if( !pEntity->IsAlive() )
return TRUE;
else
flVol = 0.1;
@ -273,11 +268,11 @@ int CCrowbar::Swing( int fFirst )
// play texture hit sound
// UNDONE: Calculate the correct point of intersection when we hit with the hull instead of the line
if (fHitWorld)
if( fHitWorld )
{
float fvolbar = TEXTURETYPE_PlaySound(&tr, vecSrc, vecSrc + (vecEnd-vecSrc)*2, BULLET_PLAYER_CROWBAR);
float fvolbar = TEXTURETYPE_PlaySound( &tr, vecSrc, vecSrc + ( vecEnd - vecSrc ) * 2, BULLET_PLAYER_CROWBAR );
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
// override the volume here, cause we don't play texture sounds in multiplayer,
// and fvolbar is going to be 0 from the above call.
@ -286,13 +281,13 @@ int CCrowbar::Swing( int fFirst )
}
// also play crowbar strike
switch( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0:
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hit1.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG(0,3));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hit1.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG( 0, 3 ) );
break;
case 1:
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/cbar_hit2.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG(0,3));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/cbar_hit2.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG( 0, 3 ) );
break;
}
@ -306,11 +301,6 @@ int CCrowbar::Swing( int fFirst )
SetThink( &CCrowbar::Smack );
pev->nextthink = UTIL_WeaponTimeBase() + 0.2;
}
return fDidHit;
}

202
dlls/defaultai.cpp
View File

@ -40,7 +40,7 @@ Schedule_t slFail[] =
{
{
tlFail,
ARRAYSIZE ( tlFail ),
ARRAYSIZE( tlFail ),
bits_COND_CAN_ATTACK,
0,
"Fail"
@ -54,14 +54,14 @@ 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.
{ 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 ),
ARRAYSIZE( tlIdleStand1 ),
bits_COND_NEW_ENEMY |
bits_COND_SEE_FEAR |
bits_COND_LIGHT_DAMAGE |
@ -87,7 +87,7 @@ Schedule_t slIdleTrigger[] =
{
{
tlIdleStand1,
ARRAYSIZE ( tlIdleStand1 ),
ARRAYSIZE( tlIdleStand1 ),
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE,
0,
@ -95,7 +95,6 @@ Schedule_t slIdleTrigger[] =
},
};
Task_t tlIdleWalk1[] =
{
{ TASK_WALK_PATH, (float)9999 },
@ -106,7 +105,7 @@ Schedule_t slIdleWalk[] =
{
{
tlIdleWalk1,
ARRAYSIZE ( tlIdleWalk1 ),
ARRAYSIZE( tlIdleWalk1 ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
@ -139,12 +138,11 @@ Schedule_t slAmbush[] =
{
{
tlAmbush,
ARRAYSIZE ( tlAmbush ),
ARRAYSIZE( tlAmbush ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_PROVOKED,
0,
"Ambush"
},
@ -167,7 +165,7 @@ Task_t tlActiveIdle[] =
{ 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_GET_PATH_TO_LASTPOSITION, (float)0 },
{ TASK_WALK_PATH, (float)0 },
{ TASK_WAIT_FOR_MOVEMENT, (float)0 },
{ TASK_CLEAR_LASTPOSITION, (float)0 },
@ -184,7 +182,6 @@ Schedule_t slActiveIdle[] =
bits_COND_HEAVY_DAMAGE |
bits_COND_PROVOKED |
bits_COND_HEAR_SOUND,
bits_SOUND_COMBAT |
bits_SOUND_WORLD |
bits_SOUND_PLAYER |
@ -208,7 +205,7 @@ Schedule_t slWakeAngry[] =
{
{
tlWakeAngry1,
ARRAYSIZE ( tlWakeAngry1 ),
ARRAYSIZE( tlWakeAngry1 ),
0,
0,
"Wake Angry"
@ -229,7 +226,7 @@ Schedule_t slAlertFace[] =
{
{
tlAlertFace1,
ARRAYSIZE ( tlAlertFace1 ),
ARRAYSIZE( tlAlertFace1 ),
bits_COND_NEW_ENEMY |
bits_COND_SEE_FEAR |
bits_COND_LIGHT_DAMAGE |
@ -256,7 +253,7 @@ Schedule_t slAlertSmallFlinch[] =
{
{
tlAlertSmallFlinch,
ARRAYSIZE ( tlAlertSmallFlinch ),
ARRAYSIZE( tlAlertSmallFlinch ),
0,
0,
"Alert Small Flinch"
@ -278,7 +275,7 @@ Schedule_t slAlertStand[] =
{
{
tlAlertStand1,
ARRAYSIZE ( tlAlertStand1 ),
ARRAYSIZE( tlAlertStand1 ),
bits_COND_NEW_ENEMY |
bits_COND_SEE_ENEMY |
bits_COND_SEE_FEAR |
@ -288,12 +285,10 @@ Schedule_t slAlertStand[] =
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,
@ -325,13 +320,12 @@ Schedule_t slInvestigateSound[] =
{
{
tlInvestigateSound,
ARRAYSIZE ( 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"
},
@ -351,7 +345,7 @@ Schedule_t slCombatStand[] =
{
{
tlCombatStand1,
ARRAYSIZE ( tlCombatStand1 ),
ARRAYSIZE( tlCombatStand1 ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD |
bits_COND_LIGHT_DAMAGE |
@ -376,7 +370,7 @@ Schedule_t slCombatFace[] =
{
{
tlCombatFace1,
ARRAYSIZE ( tlCombatFace1 ),
ARRAYSIZE( tlCombatFace1 ),
bits_COND_CAN_ATTACK |
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD,
@ -401,13 +395,12 @@ Schedule_t slStandoff[] =
{
{
tlStandoff,
ARRAYSIZE ( 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"
}
@ -419,14 +412,14 @@ Schedule_t slStandoff[] =
Task_t tlArmWeapon[] =
{
{ TASK_STOP_MOVING, 0 },
{ TASK_PLAY_SEQUENCE, (float) ACT_ARM }
{ TASK_PLAY_SEQUENCE, (float)ACT_ARM }
};
Schedule_t slArmWeapon[] =
{
{
tlArmWeapon,
ARRAYSIZE ( tlArmWeapon ),
ARRAYSIZE( tlArmWeapon ),
0,
0,
"Arm Weapon"
@ -446,7 +439,7 @@ Schedule_t slReload[] =
{
{
tlReload,
ARRAYSIZE ( tlReload ),
ARRAYSIZE( tlReload ),
bits_COND_HEAVY_DAMAGE,
0,
"Reload"
@ -469,7 +462,7 @@ Schedule_t slRangeAttack1[] =
{
{
tlRangeAttack1,
ARRAYSIZE ( tlRangeAttack1 ),
ARRAYSIZE( tlRangeAttack1 ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD |
bits_COND_LIGHT_DAMAGE |
@ -477,7 +470,6 @@ Schedule_t slRangeAttack1[] =
bits_COND_ENEMY_OCCLUDED |
bits_COND_NO_AMMO_LOADED |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"Range Attack1"
},
@ -495,14 +487,13 @@ Schedule_t slRangeAttack2[] =
{
{
tlRangeAttack2,
ARRAYSIZE ( 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"
},
@ -520,7 +511,7 @@ Schedule_t slPrimaryMeleeAttack[] =
{
{
tlPrimaryMeleeAttack1,
ARRAYSIZE ( tlPrimaryMeleeAttack1 ),
ARRAYSIZE( tlPrimaryMeleeAttack1 ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD |
bits_COND_LIGHT_DAMAGE |
@ -536,14 +527,14 @@ Task_t tlSecondaryMeleeAttack1[] =
{
{ TASK_STOP_MOVING, 0 },
{ TASK_FACE_ENEMY, (float)0 },
{ TASK_MELEE_ATTACK2, (float)0 },
{ TASK_MELEE_ATTACK2, (float)0},
};
Schedule_t slSecondaryMeleeAttack[] =
{
{
tlSecondaryMeleeAttack1,
ARRAYSIZE ( tlSecondaryMeleeAttack1 ),
ARRAYSIZE( tlSecondaryMeleeAttack1 ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD |
bits_COND_LIGHT_DAMAGE |
@ -566,7 +557,7 @@ Schedule_t slSpecialAttack1[] =
{
{
tlSpecialAttack1,
ARRAYSIZE ( tlSpecialAttack1 ),
ARRAYSIZE( tlSpecialAttack1 ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD |
bits_COND_LIGHT_DAMAGE |
@ -574,7 +565,6 @@ Schedule_t slSpecialAttack1[] =
bits_COND_ENEMY_OCCLUDED |
bits_COND_NO_AMMO_LOADED |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"Special Attack1"
},
@ -592,7 +582,7 @@ Schedule_t slSpecialAttack2[] =
{
{
tlSpecialAttack2,
ARRAYSIZE ( tlSpecialAttack2 ),
ARRAYSIZE( tlSpecialAttack2 ),
bits_COND_NEW_ENEMY |
bits_COND_ENEMY_DEAD |
bits_COND_LIGHT_DAMAGE |
@ -600,7 +590,6 @@ Schedule_t slSpecialAttack2[] =
bits_COND_ENEMY_OCCLUDED |
bits_COND_NO_AMMO_LOADED |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"Special Attack2"
},
@ -619,7 +608,7 @@ Schedule_t slChaseEnemy[] =
{
{
tlChaseEnemy1,
ARRAYSIZE ( tlChaseEnemy1 ),
ARRAYSIZE( tlChaseEnemy1 ),
bits_COND_NEW_ENEMY |
bits_COND_CAN_RANGE_ATTACK1 |
bits_COND_CAN_MELEE_ATTACK1 |
@ -627,7 +616,6 @@ Schedule_t slChaseEnemy[] =
bits_COND_CAN_MELEE_ATTACK2 |
bits_COND_TASK_FAILED |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"Chase Enemy"
},
@ -643,7 +631,7 @@ Task_t tlChaseEnemyFailed[] =
{ TASK_RUN_PATH, (float)0 },
{ TASK_WAIT_FOR_MOVEMENT, (float)0 },
{ TASK_REMEMBER, (float)bits_MEMORY_INCOVER },
// { TASK_TURN_LEFT, (float)179 },
//{ TASK_TURN_LEFT, (float)179 },
{ TASK_FACE_ENEMY, (float)0 },
{ TASK_WAIT, (float)1 },
};
@ -652,20 +640,18 @@ Schedule_t slChaseEnemyFailed[] =
{
{
tlChaseEnemyFailed,
ARRAYSIZE ( 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.
//=========================================================
@ -680,7 +666,7 @@ Schedule_t slSmallFlinch[] =
{
{
tlSmallFlinch,
ARRAYSIZE ( tlSmallFlinch ),
ARRAYSIZE( tlSmallFlinch ),
0,
0,
"Small Flinch"
@ -746,7 +732,7 @@ Schedule_t slBarnacleVictimGrab[] =
{
{
tlBarnacleVictimGrab,
ARRAYSIZE ( tlBarnacleVictimGrab ),
ARRAYSIZE( tlBarnacleVictimGrab ),
0,
0,
"Barnacle Victim"
@ -770,14 +756,13 @@ Schedule_t slBarnacleVictimChomp[] =
{
{
tlBarnacleVictimChomp,
ARRAYSIZE ( tlBarnacleVictimChomp ),
ARRAYSIZE( tlBarnacleVictimChomp ),
0,
0,
"Barnacle Chomp"
}
};
// Universal Error Schedule
Task_t tlError[] =
{
@ -789,7 +774,7 @@ Schedule_t slError[] =
{
{
tlError,
ARRAYSIZE ( tlError ),
ARRAYSIZE( tlError ),
0,
0,
"Error"
@ -812,18 +797,17 @@ Schedule_t slWalkToScript[] =
{
{
tlScriptedWalk,
ARRAYSIZE ( 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_WAIT_FOR_MOVEMENT,(float)0 },
{ TASK_PLANT_ON_SCRIPT, (float)0 },
{ TASK_FACE_SCRIPT, (float)0 },
{ TASK_FACE_IDEAL, (float)0 },
@ -836,7 +820,7 @@ Schedule_t slRunToScript[] =
{
{
tlScriptedRun,
ARRAYSIZE ( tlScriptedRun ),
ARRAYSIZE( tlScriptedRun ),
SCRIPT_BREAK_CONDITIONS,
0,
"RunToScript"
@ -854,7 +838,7 @@ Schedule_t slWaitScript[] =
{
{
tlScriptedWait,
ARRAYSIZE ( tlScriptedWait ),
ARRAYSIZE( tlScriptedWait ),
SCRIPT_BREAK_CONDITIONS,
0,
"WaitForScript"
@ -874,7 +858,7 @@ Schedule_t slFaceScript[] =
{
{
tlScriptedFace,
ARRAYSIZE ( tlScriptedFace ),
ARRAYSIZE( tlScriptedFace ),
SCRIPT_BREAK_CONDITIONS,
0,
"FaceScript"
@ -895,7 +879,7 @@ Schedule_t slCower[] =
{
{
tlCower,
ARRAYSIZE ( tlCower ),
ARRAYSIZE( tlCower ),
0,
0,
"Cower"
@ -919,7 +903,7 @@ Schedule_t slTakeCoverFromOrigin[] =
{
{
tlTakeCoverFromOrigin,
ARRAYSIZE ( tlTakeCoverFromOrigin ),
ARRAYSIZE( tlTakeCoverFromOrigin ),
bits_COND_NEW_ENEMY,
0,
"TakeCoverFromOrigin"
@ -943,7 +927,7 @@ Schedule_t slTakeCoverFromBestSound[] =
{
{
tlTakeCoverFromBestSound,
ARRAYSIZE ( tlTakeCoverFromBestSound ),
ARRAYSIZE( tlTakeCoverFromBestSound ),
bits_COND_NEW_ENEMY,
0,
"TakeCoverFromBestSound"
@ -962,7 +946,7 @@ Task_t tlTakeCoverFromEnemy[] =
{ TASK_RUN_PATH, (float)0 },
{ TASK_WAIT_FOR_MOVEMENT, (float)0 },
{ TASK_REMEMBER, (float)bits_MEMORY_INCOVER },
// { TASK_TURN_LEFT, (float)179 },
//{ TASK_TURN_LEFT, (float)179 },
{ TASK_FACE_ENEMY, (float)0 },
{ TASK_WAIT, (float)1 },
};
@ -971,7 +955,7 @@ Schedule_t slTakeCoverFromEnemy[] =
{
{
tlTakeCoverFromEnemy,
ARRAYSIZE ( tlTakeCoverFromEnemy ),
ARRAYSIZE( tlTakeCoverFromEnemy ),
bits_COND_NEW_ENEMY,
0,
"tlTakeCoverFromEnemy"
@ -1022,29 +1006,27 @@ Schedule_t *CBaseMonster::m_scheduleList[] =
Schedule_t *CBaseMonster::ScheduleFromName( const char *pName )
{
return ScheduleInList( pName, m_scheduleList, ARRAYSIZE(m_scheduleList) );
return ScheduleInList( pName, m_scheduleList, ARRAYSIZE( m_scheduleList ) );
}
Schedule_t *CBaseMonster :: ScheduleInList( const char *pName, Schedule_t **pList, int listCount )
Schedule_t *CBaseMonster::ScheduleInList( const char *pName, Schedule_t **pList, int listCount )
{
int i;
if ( !pName )
if( !pName )
{
ALERT( at_console, "%s set to unnamed schedule!\n", STRING(pev->classname) );
ALERT( at_console, "%s set to unnamed schedule!\n", STRING( pev->classname ) );
return NULL;
}
for ( i = 0; i < listCount; i++ )
for( i = 0; i < listCount; i++ )
{
if ( !pList[i]->pName )
if( !pList[i]->pName )
{
ALERT( at_console, "Unnamed schedule!\n" );
continue;
}
if ( stricmp( pName, pList[i]->pName ) == 0 )
if( stricmp( pName, pList[i]->pName ) == 0 )
return pList[i];
}
return NULL;
@ -1054,25 +1036,25 @@ Schedule_t *CBaseMonster :: ScheduleInList( const char *pName, Schedule_t **pLis
// GetScheduleOfType - returns a pointer to one of the
// monster's available schedules of the indicated type.
//=========================================================
Schedule_t* CBaseMonster :: GetScheduleOfType ( int Type )
Schedule_t* CBaseMonster::GetScheduleOfType( int Type )
{
// ALERT ( at_console, "Sched Type:%d\n", Type );
switch ( 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 )
if( !m_pCine )
{
ALERT( at_aiconsole, "Script failed for %s\n", STRING(pev->classname) );
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) );
//else
// ALERT( at_aiconsole, "Starting script %s for %s\n", STRING( m_pCine->m_iszPlay ), STRING( pev->classname ) );
switch ( m_pCine->m_fMoveTo )
switch( m_pCine->m_fMoveTo )
{
case 0:
case 4:
@ -1088,132 +1070,132 @@ Schedule_t* CBaseMonster :: GetScheduleOfType ( int Type )
}
case SCHED_IDLE_STAND:
{
if ( RANDOM_LONG(0,14) == 0 && FCanActiveIdle() )
if( RANDOM_LONG( 0, 14 ) == 0 && FCanActiveIdle() )
{
return &slActiveIdle[ 0 ];
return &slActiveIdle[0];
}
return &slIdleStand[ 0 ];
return &slIdleStand[0];
}
case SCHED_IDLE_WALK:
{
return &slIdleWalk[ 0 ];
return &slIdleWalk[0];
}
case SCHED_WAIT_TRIGGER:
{
return &slIdleTrigger[ 0 ];
return &slIdleTrigger[0];
}
case SCHED_WAKE_ANGRY:
{
return &slWakeAngry[ 0 ];
return &slWakeAngry[0];
}
case SCHED_ALERT_FACE:
{
return &slAlertFace[ 0 ];
return &slAlertFace[0];
}
case SCHED_ALERT_STAND:
{
return &slAlertStand[ 0 ];
return &slAlertStand[0];
}
case SCHED_COMBAT_STAND:
{
return &slCombatStand[ 0 ];
return &slCombatStand[0];
}
case SCHED_COMBAT_FACE:
{
return &slCombatFace[ 0 ];
return &slCombatFace[0];
}
case SCHED_CHASE_ENEMY:
{
return &slChaseEnemy[ 0 ];
return &slChaseEnemy[0];
}
case SCHED_CHASE_ENEMY_FAILED:
{
return &slFail[ 0 ];
return &slFail[0];
}
case SCHED_SMALL_FLINCH:
{
return &slSmallFlinch[ 0 ];
return &slSmallFlinch[0];
}
case SCHED_ALERT_SMALL_FLINCH:
{
return &slAlertSmallFlinch[ 0 ];
return &slAlertSmallFlinch[0];
}
case SCHED_RELOAD:
{
return &slReload[ 0 ];
return &slReload[0];
}
case SCHED_ARM_WEAPON:
{
return &slArmWeapon[ 0 ];
return &slArmWeapon[0];
}
case SCHED_STANDOFF:
{
return &slStandoff[ 0 ];
return &slStandoff[0];
}
case SCHED_RANGE_ATTACK1:
{
return &slRangeAttack1[ 0 ];
return &slRangeAttack1[0];
}
case SCHED_RANGE_ATTACK2:
{
return &slRangeAttack2[ 0 ];
return &slRangeAttack2[0];
}
case SCHED_MELEE_ATTACK1:
{
return &slPrimaryMeleeAttack[ 0 ];
return &slPrimaryMeleeAttack[0];
}
case SCHED_MELEE_ATTACK2:
{
return &slSecondaryMeleeAttack[ 0 ];
return &slSecondaryMeleeAttack[0];
}
case SCHED_SPECIAL_ATTACK1:
{
return &slSpecialAttack1[ 0 ];
return &slSpecialAttack1[0];
}
case SCHED_SPECIAL_ATTACK2:
{
return &slSpecialAttack2[ 0 ];
return &slSpecialAttack2[0];
}
case SCHED_TAKE_COVER_FROM_BEST_SOUND:
{
return &slTakeCoverFromBestSound[ 0 ];
return &slTakeCoverFromBestSound[0];
}
case SCHED_TAKE_COVER_FROM_ENEMY:
{
return &slTakeCoverFromEnemy[ 0 ];
return &slTakeCoverFromEnemy[0];
}
case SCHED_COWER:
{
return &slCower[ 0 ];
return &slCower[0];
}
case SCHED_AMBUSH:
{
return &slAmbush[ 0 ];
return &slAmbush[0];
}
case SCHED_BARNACLE_VICTIM_GRAB:
{
return &slBarnacleVictimGrab[ 0 ];
return &slBarnacleVictimGrab[0];
}
case SCHED_BARNACLE_VICTIM_CHOMP:
{
return &slBarnacleVictimChomp[ 0 ];
return &slBarnacleVictimChomp[0];
}
case SCHED_INVESTIGATE_SOUND:
{
return &slInvestigateSound[ 0 ];
return &slInvestigateSound[0];
}
case SCHED_DIE:
{
return &slDie[ 0 ];
return &slDie[0];
}
case SCHED_TAKE_COVER_FROM_ORIGIN:
{
return &slTakeCoverFromOrigin[ 0 ];
return &slTakeCoverFromOrigin[0];
}
case SCHED_VICTORY_DANCE:
{
return &slVictoryDance[ 0 ];
return &slVictoryDance[0];
}
case SCHED_FAIL:
{
@ -1221,9 +1203,9 @@ Schedule_t* CBaseMonster :: GetScheduleOfType ( int Type )
}
default:
{
ALERT ( at_console, "GetScheduleOfType()\nNo CASE for Schedule Type %d!\n", Type );
ALERT( at_console, "GetScheduleOfType()\nNo CASE for Schedule Type %d!\n", Type );
return &slIdleStand[ 0 ];
return &slIdleStand[0];
break;
}
}

601
dlls/doors.cpp
View File

File diff suppressed because it is too large Load Diff

3
dlls/doors.h
View File

@ -27,7 +27,4 @@
#define SF_DOOR_USE_ONLY 256 // door must be opened by player's use button.
#define SF_DOOR_NOMONSTERS 512 // Monster can't open
#define SF_DOOR_SILENT 0x80000000
#endif //DOORS_H

778
dlls/effects.cpp
View File

File diff suppressed because it is too large Load Diff

208
dlls/effects.h
View File

@ -39,9 +39,9 @@ public:
int ObjectCaps( void )
{
int flags = 0;
if ( pev->spawnflags & SF_SPRITE_TEMPORARY )
if( pev->spawnflags & SF_SPRITE_TEMPORARY )
flags = FCAP_DONT_SAVE;
return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags;
return ( CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION ) | flags;
}
void EXPORT AnimateThink( void );
void EXPORT ExpandThink( void );
@ -52,9 +52,9 @@ public:
inline void SetAttachment( edict_t *pEntity, int attachment )
{
if ( pEntity )
if( pEntity )
{
pev->skin = ENTINDEX(pEntity);
pev->skin = ENTINDEX( pEntity );
pev->body = attachment;
pev->aiment = pEntity;
pev->movetype = MOVETYPE_FOLLOW;
@ -62,7 +62,11 @@ public:
}
void TurnOff( void );
void TurnOn( void );
inline float Frames( void ) { return m_maxFrame; }
inline float Frames( void )
{
return m_maxFrame;
}
inline void SetTransparency( int rendermode, int r, int g, int b, int a, int fx )
{
pev->rendermode = rendermode;
@ -72,16 +76,34 @@ public:
pev->renderamt = a;
pev->renderfx = fx;
}
inline void SetTexture( int spriteIndex ) { pev->modelindex = spriteIndex; }
inline void SetScale( float scale ) { pev->scale = scale; }
inline void SetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
inline void SetBrightness( int brightness ) { pev->renderamt = brightness; }
inline void SetTexture( int spriteIndex )
{
pev->modelindex = spriteIndex;
}
inline void SetScale( float scale )
{
pev->scale = scale;
}
inline void SetColor( int r, int g, int b )
{
pev->rendercolor.x = r;
pev->rendercolor.y = g;
pev->rendercolor.z = b;
}
inline void SetBrightness( int brightness )
{
pev->renderamt = brightness;
}
inline void AnimateAndDie( float framerate )
{
SetThink( &CSprite::AnimateUntilDead);
SetThink( &CSprite::AnimateUntilDead );
pev->framerate = framerate;
pev->dmgtime = gpGlobals->time + (m_maxFrame / framerate);
pev->dmgtime = gpGlobals->time + ( m_maxFrame / framerate );
pev->nextthink = gpGlobals->time;
}
@ -93,12 +115,10 @@ public:
static CSprite *SpriteCreate( const char *pSpriteName, const Vector &origin, BOOL animate );
private:
float m_lastTime;
float m_maxFrame;
};
class CBeam : public CBaseEntity
{
public:
@ -107,54 +127,150 @@ public:
int ObjectCaps( void )
{
int flags = 0;
if ( pev->spawnflags & SF_BEAM_TEMPORARY )
if( pev->spawnflags & SF_BEAM_TEMPORARY )
flags = FCAP_DONT_SAVE;
return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags;
return ( CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION ) | flags;
}
void EXPORT TriggerTouch( CBaseEntity *pOther );
// These functions are here to show the way beams are encoded as entities.
// Encoding beams as entities simplifies their management in the client/server architecture
inline void SetType( int type ) { pev->rendermode = (pev->rendermode & 0xF0) | (type&0x0F); }
inline void SetFlags( int flags ) { pev->rendermode = (pev->rendermode & 0x0F) | (flags&0xF0); }
inline void SetStartPos( const Vector& pos ) { pev->origin = pos; }
inline void SetEndPos( const Vector& pos ) { pev->angles = pos; }
inline void SetType( int type )
{
pev->rendermode = ( pev->rendermode & 0xF0 ) | ( type & 0x0F );
}
inline void SetFlags( int flags )
{
pev->rendermode = ( pev->rendermode & 0x0F ) | ( flags & 0xF0 );
}
inline void SetStartPos( const Vector& pos )
{
pev->origin = pos;
}
inline void SetEndPos( const Vector& pos )
{
pev->angles = pos;
}
void SetStartEntity( int entityIndex );
void SetEndEntity( int entityIndex );
inline void SetStartAttachment( int attachment ) { pev->sequence = (pev->sequence & 0x0FFF) | ((attachment&0xF)<<12); }
inline void SetEndAttachment( int attachment ) { pev->skin = (pev->skin & 0x0FFF) | ((attachment&0xF)<<12); }
inline void SetStartAttachment( int attachment )
{
pev->sequence = ( pev->sequence & 0x0FFF ) | ( ( attachment & 0xF ) << 12 );
}
inline void SetTexture( int spriteIndex ) { pev->modelindex = spriteIndex; }
inline void SetWidth( int width ) { pev->scale = width; }
inline void SetNoise( int amplitude ) { pev->body = amplitude; }
inline void SetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
inline void SetBrightness( int brightness ) { pev->renderamt = brightness; }
inline void SetFrame( float frame ) { pev->frame = frame; }
inline void SetScrollRate( int speed ) { pev->animtime = speed; }
inline void SetEndAttachment( int attachment )
{
pev->skin = ( pev->skin & 0x0FFF ) | ( ( attachment & 0xF ) << 12 );
}
inline int GetType( void ) { return pev->rendermode & 0x0F; }
inline int GetFlags( void ) { return pev->rendermode & 0xF0; }
inline int GetStartEntity( void ) { return pev->sequence & 0xFFF; }
inline int GetEndEntity( void ) { return pev->skin & 0xFFF; }
inline void SetTexture( int spriteIndex )
{
pev->modelindex = spriteIndex;
}
inline void SetWidth( int width )
{
pev->scale = width;
}
inline void SetNoise( int amplitude )
{
pev->body = amplitude;
}
inline void SetColor( int r, int g, int b )
{
pev->rendercolor.x = r;
pev->rendercolor.y = g;
pev->rendercolor.z = b;
}
inline void SetBrightness( int brightness )
{
pev->renderamt = brightness;
}
inline void SetFrame( float frame )
{
pev->frame = frame;
}
inline void SetScrollRate( int speed )
{
pev->animtime = speed;
}
inline int GetType( void )
{
return pev->rendermode & 0x0F;
}
inline int GetFlags( void )
{
return pev->rendermode & 0xF0;
}
inline int GetStartEntity( void )
{
return pev->sequence & 0xFFF;
}
inline int GetEndEntity( void )
{
return pev->skin & 0xFFF;
}
const Vector &GetStartPos( void );
const Vector &GetEndPos( void );
Vector Center( void ) { return (GetStartPos() + GetEndPos()) * 0.5; }; // center point of beam
inline int GetTexture( void ) { return pev->modelindex; }
inline int GetWidth( void ) { return pev->scale; }
inline int GetNoise( void ) { return pev->body; }
// inline void GetColor( int r, int g, int b ) { pev->rendercolor.x = r; pev->rendercolor.y = g; pev->rendercolor.z = b; }
inline int GetBrightness( void ) { return pev->renderamt; }
inline int GetFrame( void ) { return pev->frame; }
inline int GetScrollRate( void ) { return pev->animtime; }
inline int GetTexture( void )
{
return pev->modelindex;
}
inline int GetWidth( void )
{
return pev->scale;
}
inline int GetNoise( void )
{
return pev->body;
}
/* inline void GetColor( int r, int g, int b )
{
pev->rendercolor.x = r;
pev->rendercolor.y = g;
pev->rendercolor.z = b;
}*/
inline int GetBrightness( void )
{
return pev->renderamt;
}
inline int GetFrame( void )
{
return pev->frame;
}
inline int GetScrollRate( void )
{
return pev->animtime;
}
// Call after you change start/end positions
void RelinkBeam( void );
// void SetObjectCollisionBox( void );
//void SetObjectCollisionBox( void );
void DoSparks( const Vector &start, const Vector &end );
CBaseEntity *RandomTargetname( const char *szName );
@ -168,20 +284,23 @@ public:
static CBeam *BeamCreate( const char *pSpriteName, int width );
inline void LiveForTime( float time ) { SetThink( &CBaseEntity::SUB_Remove); pev->nextthink = gpGlobals->time + time; }
inline void LiveForTime( float time )
{
SetThink( &CBaseEntity::SUB_Remove );
pev->nextthink = gpGlobals->time + time;
}
inline void BeamDamageInstant( TraceResult *ptr, float damage )
{
pev->dmg = damage;
pev->dmgtime = gpGlobals->time - 1;
BeamDamage(ptr);
BeamDamage( ptr );
}
};
#define SF_MESSAGE_ONCE 0x0001 // Fade in, not out
#define SF_MESSAGE_ALL 0x0002 // Send to all clients
class CLaser : public CBeam
{
public:
@ -205,5 +324,4 @@ public:
int m_iszSpriteName;
Vector m_firePosition;
};
#endif //EFFECTS_H

172
dlls/egon.cpp
View File

@ -51,11 +51,11 @@ enum egon_e {
LINK_ENTITY_TO_CLASS( weapon_egon, CEgon )
void CEgon::Spawn( )
void CEgon::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_EGON;
SET_MODEL(ENT(pev), "models/w_egon.mdl");
SET_MODEL( ENT( pev ), "models/w_egon.mdl" );
m_iDefaultAmmo = EGON_DEFAULT_GIVE;
@ -64,12 +64,12 @@ void CEgon::Spawn( )
void CEgon::Precache( void )
{
PRECACHE_MODEL("models/w_egon.mdl");
PRECACHE_MODEL("models/v_egon.mdl");
PRECACHE_MODEL("models/p_egon.mdl");
PRECACHE_MODEL( "models/w_egon.mdl" );
PRECACHE_MODEL( "models/v_egon.mdl" );
PRECACHE_MODEL( "models/p_egon.mdl" );
PRECACHE_MODEL("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_9mmclip.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
PRECACHE_SOUND( EGON_SOUND_OFF );
PRECACHE_SOUND( EGON_SOUND_RUN );
@ -78,13 +78,12 @@ void CEgon::Precache( void )
PRECACHE_MODEL( EGON_BEAM_SPRITE );
PRECACHE_MODEL( EGON_FLARE_SPRITE );
PRECACHE_SOUND ("weapons/357_cock1.wav");
PRECACHE_SOUND( "weapons/357_cock1.wav" );
m_usEgonFire = PRECACHE_EVENT ( 1, "events/egon_fire.sc" );
m_usEgonStop = PRECACHE_EVENT ( 1, "events/egon_stop.sc" );
m_usEgonFire = PRECACHE_EVENT( 1, "events/egon_fire.sc" );
m_usEgonStop = PRECACHE_EVENT( 1, "events/egon_stop.sc" );
}
BOOL CEgon::Deploy( void )
{
m_deployed = FALSE;
@ -94,7 +93,7 @@ BOOL CEgon::Deploy( void )
int CEgon::AddToPlayer( CBasePlayer *pPlayer )
{
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
WRITE_BYTE( m_iId );
@ -104,8 +103,6 @@ int CEgon::AddToPlayer( CBasePlayer *pPlayer )
return FALSE;
}
void CEgon::Holster( int skiplocal /* = 0 */ )
{
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
@ -114,9 +111,9 @@ void CEgon::Holster( int skiplocal /* = 0 */ )
EndAttack();
}
int CEgon::GetItemInfo(ItemInfo *p)
int CEgon::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "uranium";
p->iMaxAmmo1 = URANIUM_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -146,7 +143,7 @@ float CEgon::GetDischargeInterval( void )
BOOL CEgon::HasAmmo( void )
{
if ( m_pPlayer->ammo_uranium <= 0 )
if( m_pPlayer->ammo_uranium <= 0 )
return FALSE;
return TRUE;
@ -154,7 +151,7 @@ BOOL CEgon::HasAmmo( void )
void CEgon::UseAmmo( int count )
{
if ( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] >= count )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] >= count )
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] -= count;
else
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] = 0;
@ -163,23 +160,22 @@ void CEgon::UseAmmo( int count )
void CEgon::Attack( void )
{
// don't fire underwater
if ( m_pPlayer->pev->waterlevel == 3 )
if( m_pPlayer->pev->waterlevel == 3 )
{
if ( m_fireState != FIRE_OFF || m_pBeam )
if( m_fireState != FIRE_OFF || m_pBeam )
{
EndAttack();
}
else
{
PlayEmptySound( );
PlayEmptySound();
}
return;
}
UTIL_MakeVectors( m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle );
Vector vecAiming = gpGlobals->v_forward;
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecSrc = m_pPlayer->GetGunPosition();
int flags;
#if defined( CLIENT_WEAPONS )
@ -192,7 +188,7 @@ void CEgon::Attack( void )
{
case FIRE_OFF:
{
if ( !HasAmmo() )
if( !HasAmmo() )
{
m_flNextPrimaryAttack = m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 0.25;
PlayEmptySound( );
@ -211,36 +207,33 @@ void CEgon::Attack( void )
pev->dmgtime = gpGlobals->time + GetPulseInterval();
m_fireState = FIRE_CHARGE;
}
break;
}
case FIRE_CHARGE:
{
Fire( vecSrc, vecAiming );
m_pPlayer->m_iWeaponVolume = EGON_PRIMARY_VOLUME;
if ( pev->fuser1 <= UTIL_WeaponTimeBase() )
if( pev->fuser1 <= UTIL_WeaponTimeBase() )
{
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usEgonFire, 0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, m_fireState, m_fireMode, 0, 0 );
pev->fuser1 = 1000;
}
if ( !HasAmmo() )
if( !HasAmmo() )
{
EndAttack();
m_flNextPrimaryAttack = m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 1.0;
}
}
break;
}
}
}
void CEgon::PrimaryAttack( void )
{
m_fireMode = FIRE_WIDE;
Attack();
}
void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
@ -256,22 +249,22 @@ void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
UTIL_TraceLine( vecOrigSrc, vecDest, dont_ignore_monsters, pentIgnore, &tr );
if (tr.fAllSolid)
if( tr.fAllSolid )
return;
#ifndef CLIENT_DLL
CBaseEntity *pEntity = CBaseEntity::Instance(tr.pHit);
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
if (pEntity == NULL)
if( pEntity == NULL )
return;
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
if ( m_pSprite && pEntity->pev->takedamage )
if( m_pSprite && pEntity->pev->takedamage )
{
m_pSprite->pev->effects &= ~EF_NODRAW;
}
else if ( m_pSprite )
else if( m_pSprite )
{
m_pSprite->pev->effects |= EF_NODRAW;
}
@ -279,24 +272,24 @@ void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
#endif
float timedist;
switch ( m_fireMode )
switch( m_fireMode )
{
case FIRE_NARROW:
#ifndef CLIENT_DLL
if ( pev->dmgtime < gpGlobals->time )
if( pev->dmgtime < gpGlobals->time )
{
// Narrow mode only does damage to the entity it hits
ClearMultiDamage();
if (pEntity->pev->takedamage)
if( pEntity->pev->takedamage )
{
pEntity->TraceAttack( m_pPlayer->pev, gSkillData.plrDmgEgonNarrow, vecDir, &tr, DMG_ENERGYBEAM );
}
ApplyMultiDamage(m_pPlayer->pev, m_pPlayer->pev);
ApplyMultiDamage( m_pPlayer->pev, m_pPlayer->pev );
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
// multiplayer uses 1 ammo every 1/10th second
if ( gpGlobals->time >= m_flAmmoUseTime )
if( gpGlobals->time >= m_flAmmoUseTime )
{
UseAmmo( 1 );
m_flAmmoUseTime = gpGlobals->time + 0.1;
@ -305,7 +298,7 @@ void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
else
{
// single player, use 3 ammo/second
if ( gpGlobals->time >= m_flAmmoUseTime )
if( gpGlobals->time >= m_flAmmoUseTime )
{
UseAmmo( 1 );
m_flAmmoUseTime = gpGlobals->time + 0.166;
@ -317,32 +310,31 @@ void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
#endif
timedist = ( pev->dmgtime - gpGlobals->time ) / GetPulseInterval();
break;
case FIRE_WIDE:
#ifndef CLIENT_DLL
if ( pev->dmgtime < gpGlobals->time )
if( pev->dmgtime < gpGlobals->time )
{
// wide mode does damage to the ent, and radius damage
ClearMultiDamage();
if (pEntity->pev->takedamage)
if( pEntity->pev->takedamage )
{
pEntity->TraceAttack( m_pPlayer->pev, gSkillData.plrDmgEgonWide, vecDir, &tr, DMG_ENERGYBEAM | DMG_ALWAYSGIB);
pEntity->TraceAttack( m_pPlayer->pev, gSkillData.plrDmgEgonWide, vecDir, &tr, DMG_ENERGYBEAM | DMG_ALWAYSGIB );
}
ApplyMultiDamage(m_pPlayer->pev, m_pPlayer->pev);
ApplyMultiDamage( m_pPlayer->pev, m_pPlayer->pev );
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
// radius damage a little more potent in multiplayer.
::RadiusDamage( tr.vecEndPos, pev, m_pPlayer->pev, gSkillData.plrDmgEgonWide/4, 128, CLASS_NONE, DMG_ENERGYBEAM | DMG_BLAST | DMG_ALWAYSGIB );
}
if ( !m_pPlayer->IsAlive() )
if( !m_pPlayer->IsAlive() )
return;
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
//multiplayer uses 5 ammo/second
if ( gpGlobals->time >= m_flAmmoUseTime )
if( gpGlobals->time >= m_flAmmoUseTime )
{
UseAmmo( 1 );
m_flAmmoUseTime = gpGlobals->time + 0.2;
@ -351,7 +343,7 @@ void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
else
{
// Wide mode uses 10 charges per second in single player
if ( gpGlobals->time >= m_flAmmoUseTime )
if( gpGlobals->time >= m_flAmmoUseTime )
{
UseAmmo( 1 );
m_flAmmoUseTime = gpGlobals->time + 0.1;
@ -359,7 +351,7 @@ void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
}
pev->dmgtime = gpGlobals->time + GetDischargeInterval();
if ( m_shakeTime < gpGlobals->time )
if( m_shakeTime < gpGlobals->time )
{
UTIL_ScreenShake( tr.vecEndPos, 5.0, 150.0, 0.75, 250.0 );
m_shakeTime = gpGlobals->time + 1.5;
@ -370,37 +362,35 @@ void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
break;
}
if ( timedist < 0 )
if( timedist < 0 )
timedist = 0;
else if ( timedist > 1 )
else if( timedist > 1 )
timedist = 1;
timedist = 1-timedist;
timedist = 1 - timedist;
UpdateEffect( tmpSrc, tr.vecEndPos, timedist );
}
void CEgon::UpdateEffect( const Vector &startPoint, const Vector &endPoint, float timeBlend )
{
#ifndef CLIENT_DLL
if ( !m_pBeam )
if( !m_pBeam )
{
CreateEffect();
}
m_pBeam->SetStartPos( endPoint );
m_pBeam->SetBrightness( 255 - (timeBlend*180) );
m_pBeam->SetWidth( 40 - (timeBlend*20) );
m_pBeam->SetBrightness( 255 - ( timeBlend * 180 ) );
m_pBeam->SetWidth( 40 - ( timeBlend * 20 ) );
if ( m_fireMode == FIRE_WIDE )
m_pBeam->SetColor( 30 + (25*timeBlend), 30 + (30*timeBlend), 64 + 80*fabs(sin(gpGlobals->time*10)) );
if( m_fireMode == FIRE_WIDE )
m_pBeam->SetColor( 30 + ( 25 * timeBlend ), 30 + ( 30 * timeBlend ), 64 + 80 * fabs( sin( gpGlobals->time * 10 ) ) );
else
m_pBeam->SetColor( 60 + (25*timeBlend), 120 + (30*timeBlend), 64 + 80*fabs(sin(gpGlobals->time*10)) );
m_pBeam->SetColor( 60 + ( 25 * timeBlend ), 120 + ( 30 * timeBlend ), 64 + 80 * fabs( sin( gpGlobals->time *10 ) ) );
UTIL_SetOrigin( m_pSprite->pev, endPoint );
m_pSprite->pev->frame += 8 * gpGlobals->frametime;
if ( m_pSprite->pev->frame > m_pSprite->Frames() )
if( m_pSprite->pev->frame > m_pSprite->Frames() )
m_pSprite->pev->frame = 0;
m_pNoise->SetStartPos( endPoint );
@ -436,7 +426,7 @@ void CEgon::CreateEffect( void )
m_pSprite->pev->flags |= FL_SKIPLOCALHOST;
m_pSprite->pev->owner = m_pPlayer->edict();
if ( m_fireMode == FIRE_WIDE )
if( m_fireMode == FIRE_WIDE )
{
m_pBeam->SetScrollRate( 50 );
m_pBeam->SetNoise( 20 );
@ -455,21 +445,21 @@ void CEgon::CreateEffect( void )
void CEgon::DestroyEffect( void )
{
#ifndef CLIENT_DLL
if ( m_pBeam )
if( m_pBeam )
{
UTIL_Remove( m_pBeam );
m_pBeam = NULL;
}
if ( m_pNoise )
if( m_pNoise )
{
UTIL_Remove( m_pNoise );
m_pNoise = NULL;
}
if ( m_pSprite )
if( m_pSprite )
{
if ( m_fireMode == FIRE_WIDE )
if( m_fireMode == FIRE_WIDE )
m_pSprite->Expand( 10, 500 );
else
UTIL_Remove( m_pSprite );
@ -480,19 +470,19 @@ void CEgon::DestroyEffect( void )
void CEgon::WeaponIdle( void )
{
ResetEmptySound( );
ResetEmptySound();
if ( m_flTimeWeaponIdle > UTIL_WeaponTimeBase())
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
if ( m_fireState != FIRE_OFF )
if( m_fireState != FIRE_OFF )
EndAttack();
int iAnim;
float flRand = RANDOM_FLOAT(0,1);
float flRand = RANDOM_FLOAT( 0, 1 );
if ( flRand <= 0.5 )
if( flRand <= 0.5 )
{
iAnim = EGON_IDLE1;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
@ -507,13 +497,11 @@ void CEgon::WeaponIdle( void )
m_deployed = TRUE;
}
void CEgon::EndAttack( void )
{
bool bMakeNoise = false;
if ( m_fireState != FIRE_OFF ) //Checking the button just in case!.
if( m_fireState != FIRE_OFF ) //Checking the button just in case!.
bMakeNoise = true;
PLAYBACK_EVENT_FULL( FEV_GLOBAL | FEV_RELIABLE, m_pPlayer->edict(), m_usEgonStop, 0, (float *)&m_pPlayer->pev->origin, (float *)&m_pPlayer->pev->angles, 0.0, 0.0, bMakeNoise, 0, 0, 0 );
@ -526,31 +514,31 @@ void CEgon::EndAttack( void )
DestroyEffect();
}
class CEgonAmmo : public CBasePlayerAmmo
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_chainammo.mdl");
CBasePlayerAmmo::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_chainammo.mdl" );
CBasePlayerAmmo::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_chainammo.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_chainammo.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
}
BOOL AddAmmo( CBaseEntity *pOther )
{
if (pOther->GiveAmmo( AMMO_URANIUMBOX_GIVE, "uranium", URANIUM_MAX_CARRY ) != -1)
if( pOther->GiveAmmo( AMMO_URANIUMBOX_GIVE, "uranium", URANIUM_MAX_CARRY ) != -1 )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
return TRUE;
}
return FALSE;
}
};
LINK_ENTITY_TO_CLASS( ammo_egonclip, CEgonAmmo )
LINK_ENTITY_TO_CLASS( ammo_egonclip, CEgonAmmo )
#endif

6
dlls/enginecallback.h
View File

@ -69,7 +69,8 @@ extern enginefuncs_t g_engfuncs;
#define RANDOM_FLOAT (*g_engfuncs.pfnRandomFloat)
#define GETPLAYERAUTHID (*g_engfuncs.pfnGetPlayerAuthId)
inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin = NULL, edict_t *ed = NULL ) {
inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin = NULL, edict_t *ed = NULL )
{
(*g_engfuncs.pfnMessageBegin)(msg_dest, msg_type, pOrigin, ed);
}
#define MESSAGE_END (*g_engfuncs.pfnMessageEnd)
@ -90,9 +91,10 @@ inline void MESSAGE_BEGIN( int msg_dest, int msg_type, const float *pOrigin = NU
#define ALERT (*g_engfuncs.pfnAlertMessage)
#define ENGINE_FPRINTF (*g_engfuncs.pfnEngineFprintf)
#define ALLOC_PRIVATE (*g_engfuncs.pfnPvAllocEntPrivateData)
inline void *GET_PRIVATE( edict_t *pent )
{
if ( pent )
if( pent )
return pent->pvPrivateData;
return NULL;
}

64
dlls/explode.cpp
View File

@ -39,9 +39,9 @@ LINK_ENTITY_TO_CLASS( spark_shower, CShower )
void CShower::Spawn( void )
{
pev->velocity = RANDOM_FLOAT( 200, 300 ) * pev->angles;
pev->velocity.x += RANDOM_FLOAT(-100.f,100.f);
pev->velocity.y += RANDOM_FLOAT(-100.f,100.f);
if ( pev->velocity.z >= 0 )
pev->velocity.x += RANDOM_FLOAT( -100.f, 100.f );
pev->velocity.y += RANDOM_FLOAT( -100.f, 100.f );
if( pev->velocity.z >= 0 )
pev->velocity.z += 200;
else
pev->velocity.z -= 200;
@ -49,8 +49,8 @@ void CShower::Spawn( void )
pev->gravity = 0.5;
pev->nextthink = gpGlobals->time + 0.1;
pev->solid = SOLID_NOT;
SET_MODEL( edict(), "models/grenade.mdl"); // Need a model, just use the grenade, we don't draw it anyway
UTIL_SetSize(pev, g_vecZero, g_vecZero );
SET_MODEL( edict(), "models/grenade.mdl" ); // Need a model, just use the grenade, we don't draw it anyway
UTIL_SetSize( pev, g_vecZero, g_vecZero );
pev->effects |= EF_NODRAW;
pev->speed = RANDOM_FLOAT( 0.5, 1.5 );
@ -62,7 +62,7 @@ void CShower::Think( void )
UTIL_Sparks( pev->origin );
pev->speed -= 0.1;
if ( pev->speed > 0 )
if( pev->speed > 0 )
pev->nextthink = gpGlobals->time + 0.1;
else
UTIL_Remove( this );
@ -71,20 +71,20 @@ void CShower::Think( void )
void CShower::Touch( CBaseEntity *pOther )
{
if ( pev->flags & FL_ONGROUND )
if( pev->flags & FL_ONGROUND )
pev->velocity = pev->velocity * 0.1;
else
pev->velocity = pev->velocity * 0.6;
if ( (pev->velocity.x*pev->velocity.x+pev->velocity.y*pev->velocity.y) < 10.0 )
if( ( pev->velocity.x * pev->velocity.x + pev->velocity.y * pev->velocity.y ) < 10.0 )
pev->speed = 0;
}
class CEnvExplosion : public CBaseMonster
{
public:
void Spawn( );
void EXPORT Smoke ( void );
void Spawn();
void EXPORT Smoke( void );
void KeyValue( KeyValueData *pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
@ -107,9 +107,9 @@ LINK_ENTITY_TO_CLASS( env_explosion, CEnvExplosion )
void CEnvExplosion::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "iMagnitude"))
if( FStrEq( pkvd->szKeyName, "iMagnitude" ) )
{
m_iMagnitude = atoi(pkvd->szValue);
m_iMagnitude = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -123,22 +123,22 @@ void CEnvExplosion::Spawn( void )
pev->movetype = MOVETYPE_NONE;
/*
if ( m_iMagnitude > 250 )
if( m_iMagnitude > 250 )
{
m_iMagnitude = 250;
}
*/
float flSpriteScale;
flSpriteScale = ( m_iMagnitude - 50) * 0.6;
flSpriteScale = ( m_iMagnitude - 50 ) * 0.6;
/*
if ( flSpriteScale > 50 )
if( flSpriteScale > 50 )
{
flSpriteScale = 50;
}
*/
if ( flSpriteScale < 10 )
if( flSpriteScale < 10 )
{
flSpriteScale = 10;
}
@ -155,14 +155,14 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
Vector vecSpot;// trace starts here!
vecSpot = pev->origin + Vector ( 0 , 0 , 8 );
vecSpot = pev->origin + Vector( 0, 0, 8 );
UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -40 ), ignore_monsters, ENT(pev), & tr);
UTIL_TraceLine( vecSpot, vecSpot + Vector( 0, 0, -40 ), ignore_monsters, ENT( pev ), &tr );
// Pull out of the wall a bit
if ( tr.flFraction != 1.0 )
if( tr.flFraction != 1.0 )
{
pev->origin = tr.vecEndPos + (tr.vecPlaneNormal * (m_iMagnitude - 24) * 0.6);
pev->origin = tr.vecEndPos + ( tr.vecPlaneNormal * ( m_iMagnitude - 24 ) * 0.6 );
}
else
{
@ -170,9 +170,9 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
}
// draw decal
if (! ( pev->spawnflags & SF_ENVEXPLOSION_NODECAL))
if( !( pev->spawnflags & SF_ENVEXPLOSION_NODECAL ) )
{
if ( RANDOM_FLOAT( 0 , 1 ) < 0.5 )
if( RANDOM_FLOAT( 0, 1 ) < 0.5 )
{
UTIL_DecalTrace( &tr, DECAL_SCORCH1 );
}
@ -183,7 +183,7 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
}
// draw fireball
if ( !( pev->spawnflags & SF_ENVEXPLOSION_NOFIREBALL ) )
if( !( pev->spawnflags & SF_ENVEXPLOSION_NOFIREBALL ) )
{
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_EXPLOSION);
@ -199,7 +199,7 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
else
{
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_EXPLOSION);
WRITE_BYTE( TE_EXPLOSION );
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z );
@ -211,20 +211,20 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
}
// do damage
if ( !( pev->spawnflags & SF_ENVEXPLOSION_NODAMAGE ) )
if( !( pev->spawnflags & SF_ENVEXPLOSION_NODAMAGE ) )
{
RadiusDamage ( pev, pev, m_iMagnitude, CLASS_NONE, DMG_BLAST );
RadiusDamage( pev, pev, m_iMagnitude, CLASS_NONE, DMG_BLAST );
}
SetThink( &CEnvExplosion::Smoke );
pev->nextthink = gpGlobals->time + 0.3;
// draw sparks
if ( !( pev->spawnflags & SF_ENVEXPLOSION_NOSPARKS ) )
if( !( pev->spawnflags & SF_ENVEXPLOSION_NOSPARKS ) )
{
int sparkCount = RANDOM_LONG(0,3);
int sparkCount = RANDOM_LONG( 0, 3 );
for ( int i = 0; i < sparkCount; i++ )
for( int i = 0; i < sparkCount; i++ )
{
Create( "spark_shower", pev->origin, tr.vecPlaneNormal, NULL );
}
@ -233,7 +233,7 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
void CEnvExplosion::Smoke( void )
{
if ( !( pev->spawnflags & SF_ENVEXPLOSION_NOSMOKE ) )
if( !( pev->spawnflags & SF_ENVEXPLOSION_NOSMOKE ) )
{
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_SMOKE );
@ -246,7 +246,7 @@ void CEnvExplosion::Smoke( void )
MESSAGE_END();
}
if ( !(pev->spawnflags & SF_ENVEXPLOSION_REPEATABLE) )
if( !( pev->spawnflags & SF_ENVEXPLOSION_REPEATABLE ) )
{
UTIL_Remove( this );
}
@ -263,7 +263,7 @@ void ExplosionCreate( const Vector &center, const Vector &angles, edict_t *pOwne
kvd.szKeyName = "iMagnitude";
kvd.szValue = buf;
pExplosion->KeyValue( &kvd );
if ( !doDamage )
if( !doDamage )
pExplosion->pev->spawnflags |= SF_ENVEXPLOSION_NODAMAGE;
pExplosion->Spawn();

3
dlls/explode.h
View File

@ -15,7 +15,6 @@
#ifndef EXPLODE_H
#define EXPLODE_H
#define SF_ENVEXPLOSION_NODAMAGE ( 1 << 0 ) // when set, ENV_EXPLOSION will not actually inflict damage
#define SF_ENVEXPLOSION_REPEATABLE ( 1 << 1 ) // can this entity be refired?
#define SF_ENVEXPLOSION_NOFIREBALL ( 1 << 2 ) // don't draw the fireball
@ -26,7 +25,5 @@
extern DLL_GLOBAL short g_sModelIndexFireball;
extern DLL_GLOBAL short g_sModelIndexSmoke;
extern void ExplosionCreate( const Vector &center, const Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage );
#endif //EXPLODE_H

98
dlls/flyingmonster.cpp
View File

@ -25,12 +25,12 @@
extern DLL_GLOBAL edict_t *g_pBodyQueueHead;
int CFlyingMonster :: CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist )
int CFlyingMonster::CheckLocalMove( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist )
{
// UNDONE: need to check more than the endpoint
if (FBitSet(pev->flags, FL_SWIM) && (UTIL_PointContents(vecEnd) != CONTENTS_WATER))
if( FBitSet( pev->flags, FL_SWIM ) && ( UTIL_PointContents( vecEnd ) != CONTENTS_WATER ) )
{
// ALERT(at_aiconsole, "can't swim out of water\n");
// ALERT( at_aiconsole, "can't swim out of water\n" );
return FALSE;
}
@ -41,15 +41,15 @@ int CFlyingMonster :: CheckLocalMove ( const Vector &vecStart, const Vector &vec
// ALERT( at_console, "%.0f %.0f %.0f : ", vecStart.x, vecStart.y, vecStart.z );
// ALERT( at_console, "%.0f %.0f %.0f\n", vecEnd.x, vecEnd.y, vecEnd.z );
if (pflDist)
if( pflDist )
{
*pflDist = ( (tr.vecEndPos - Vector( 0, 0, 32 )) - vecStart ).Length();// get the distance.
*pflDist = ( ( tr.vecEndPos - Vector( 0, 0, 32 ) ) - vecStart ).Length();// get the distance.
}
// ALERT( at_console, "check %d %d %f\n", tr.fStartSolid, tr.fAllSolid, tr.flFraction );
if (tr.fStartSolid || tr.flFraction < 1.0)
if( tr.fStartSolid || tr.flFraction < 1.0 )
{
if ( pTarget && pTarget->edict() == gpGlobals->trace_ent )
if( pTarget && pTarget->edict() == gpGlobals->trace_ent )
return LOCALMOVE_VALID;
return LOCALMOVE_INVALID;
}
@ -57,23 +57,23 @@ int CFlyingMonster :: CheckLocalMove ( const Vector &vecStart, const Vector &vec
return LOCALMOVE_VALID;
}
BOOL CFlyingMonster :: FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex )
BOOL CFlyingMonster::FTriangulate( const Vector &vecStart, const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex )
{
return CBaseMonster::FTriangulate( vecStart, vecEnd, flDist, pTargetEnt, pApex );
}
Activity CFlyingMonster :: GetStoppedActivity( void )
Activity CFlyingMonster::GetStoppedActivity( void )
{
if ( pev->movetype != MOVETYPE_FLY ) // UNDONE: Ground idle here, IDLE may be something else
if( pev->movetype != MOVETYPE_FLY ) // UNDONE: Ground idle here, IDLE may be something else
return ACT_IDLE;
return ACT_HOVER;
}
void CFlyingMonster :: Stop( void )
void CFlyingMonster::Stop( void )
{
Activity stopped = GetStoppedActivity();
if ( m_IdealActivity != stopped )
if( m_IdealActivity != stopped )
{
m_flightSpeed = 0;
m_IdealActivity = stopped;
@ -83,18 +83,18 @@ void CFlyingMonster :: Stop( void )
m_vecTravel = g_vecZero;
}
float CFlyingMonster :: ChangeYaw( int speed )
float CFlyingMonster::ChangeYaw( int speed )
{
if ( pev->movetype == MOVETYPE_FLY )
if( pev->movetype == MOVETYPE_FLY )
{
float diff = FlYawDiff();
float target = 0;
if ( m_IdealActivity != GetStoppedActivity() )
if( m_IdealActivity != GetStoppedActivity() )
{
if ( diff < -20 )
if( diff < -20 )
target = 90;
else if ( diff > 20 )
else if( diff > 20 )
target = -90;
}
pev->angles.z = UTIL_Approach( target, pev->angles.z, 220.0 * gpGlobals->frametime );
@ -102,7 +102,7 @@ float CFlyingMonster :: ChangeYaw( int speed )
return CBaseMonster::ChangeYaw( speed );
}
void CFlyingMonster :: Killed( entvars_t *pevAttacker, int iGib )
void CFlyingMonster::Killed( entvars_t *pevAttacker, int iGib )
{
pev->movetype = MOVETYPE_STEP;
ClearBits( pev->flags, FL_ONGROUND );
@ -111,7 +111,7 @@ void CFlyingMonster :: Killed( entvars_t *pevAttacker, int iGib )
CBaseMonster::Killed( pevAttacker, iGib );
}
void CFlyingMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CFlyingMonster::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -119,7 +119,7 @@ void CFlyingMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
m_flightSpeed = 400;
break;
case FLYING_AE_FLAPSOUND:
if ( m_pFlapSound )
if( m_pFlapSound )
EMIT_SOUND( edict(), CHAN_BODY, m_pFlapSound, 1, ATTN_NORM );
break;
default:
@ -128,20 +128,20 @@ void CFlyingMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
}
}
void CFlyingMonster :: Move( float flInterval )
void CFlyingMonster::Move( float flInterval )
{
if ( pev->movetype == MOVETYPE_FLY )
if( pev->movetype == MOVETYPE_FLY )
m_flGroundSpeed = m_flightSpeed;
CBaseMonster::Move( flInterval );
}
BOOL CFlyingMonster:: ShouldAdvanceRoute( float flWaypointDist )
BOOL CFlyingMonster::ShouldAdvanceRoute( float flWaypointDist )
{
// Get true 3D distance to the goal so we actually reach the correct height
if ( m_Route[ m_iRouteIndex ].iType & bits_MF_IS_GOAL )
flWaypointDist = ( m_Route[ m_iRouteIndex ].vecLocation - pev->origin ).Length();
if( m_Route[m_iRouteIndex].iType & bits_MF_IS_GOAL )
flWaypointDist = ( m_Route[m_iRouteIndex].vecLocation - pev->origin ).Length();
if ( flWaypointDist <= 64 + (m_flGroundSpeed * gpGlobals->frametime) )
if( flWaypointDist <= 64 + ( m_flGroundSpeed * gpGlobals->frametime ) )
return TRUE;
return FALSE;
@ -149,32 +149,32 @@ BOOL CFlyingMonster:: ShouldAdvanceRoute( float flWaypointDist )
void CFlyingMonster::MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval )
{
if ( pev->movetype == MOVETYPE_FLY )
if( pev->movetype == MOVETYPE_FLY )
{
if ( gpGlobals->time - m_stopTime > 1.0 )
if( gpGlobals->time - m_stopTime > 1.0 )
{
if ( m_IdealActivity != m_movementActivity )
if( m_IdealActivity != m_movementActivity )
{
m_IdealActivity = m_movementActivity;
m_flGroundSpeed = m_flightSpeed = 200;
}
}
Vector vecMove = pev->origin + (( vecDir + (m_vecTravel * m_momentum) ).Normalize() * (m_flGroundSpeed * flInterval));
Vector vecMove = pev->origin + ( ( vecDir + ( m_vecTravel * m_momentum ) ).Normalize() * (m_flGroundSpeed * flInterval ) );
if ( m_IdealActivity != m_movementActivity )
if( m_IdealActivity != m_movementActivity )
{
m_flightSpeed = UTIL_Approach( 100, m_flightSpeed, 75 * gpGlobals->frametime );
if ( m_flightSpeed < 100 )
if( m_flightSpeed < 100 )
m_stopTime = gpGlobals->time;
}
else
m_flightSpeed = UTIL_Approach( 20, m_flightSpeed, 300 * gpGlobals->frametime );
if ( CheckLocalMove ( pev->origin, vecMove, pTargetEnt, NULL ) )
if( CheckLocalMove( pev->origin, vecMove, pTargetEnt, NULL ) )
{
m_vecTravel = (vecMove - pev->origin);
m_vecTravel = vecMove - pev->origin;
m_vecTravel = m_vecTravel.Normalize();
UTIL_MoveToOrigin(ENT(pev), vecMove, (m_flGroundSpeed * flInterval), MOVE_STRAFE);
UTIL_MoveToOrigin( ENT( pev ), vecMove, ( m_flGroundSpeed * flInterval ), MOVE_STRAFE );
}
else
{
@ -195,21 +195,21 @@ float CFlyingMonster::CeilingZ( const Vector &position )
Vector maxUp = position;
maxUp.z += 4096.0;
UTIL_TraceLine(position, maxUp, ignore_monsters, NULL, &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( position, maxUp, ignore_monsters, NULL, &tr );
if( tr.flFraction != 1.0 )
maxUp.z = tr.vecEndPos.z;
if ((pev->flags) & FL_SWIM)
if( ( pev->flags ) & FL_SWIM )
{
return UTIL_WaterLevel( position, minUp.z, maxUp.z );
}
return maxUp.z;
}
BOOL CFlyingMonster::ProbeZ( const Vector &position, const Vector &probe, float *pFraction)
BOOL CFlyingMonster::ProbeZ( const Vector &position, const Vector &probe, float *pFraction )
{
int conPosition = UTIL_PointContents(position);
if ( (((pev->flags) & FL_SWIM) == FL_SWIM) ^ (conPosition == CONTENTS_WATER))
int conPosition = UTIL_PointContents( position );
if( ( ( ( pev->flags ) & FL_SWIM ) == FL_SWIM ) ^ ( conPosition == CONTENTS_WATER ) )
{
// SWIMING & !WATER
// or FLYING & WATER
@ -217,8 +217,8 @@ BOOL CFlyingMonster::ProbeZ( const Vector &position, const Vector &probe, float
*pFraction = 0.0;
return TRUE; // We hit a water boundary because we are where we don't belong.
}
int conProbe = UTIL_PointContents(probe);
if (conProbe == conPosition)
int conProbe = UTIL_PointContents( probe );
if( conProbe == conPosition )
{
// The probe is either entirely inside the water (for fish) or entirely
// outside the water (for birds).
@ -227,17 +227,17 @@ BOOL CFlyingMonster::ProbeZ( const Vector &position, const Vector &probe, float
return FALSE;
}
Vector ProbeUnit = (probe-position).Normalize();
float ProbeLength = (probe-position).Length();
Vector ProbeUnit = ( probe - position ).Normalize();
float ProbeLength = ( probe - position ).Length();
float maxProbeLength = ProbeLength;
float minProbeLength = 0;
float diff = maxProbeLength - minProbeLength;
while (diff > 1.0)
while( diff > 1.0 )
{
float midProbeLength = minProbeLength + diff/2.0;
float midProbeLength = minProbeLength + diff / 2.0;
Vector midProbeVec = midProbeLength * ProbeUnit;
if (UTIL_PointContents(position+midProbeVec) == conPosition)
if( UTIL_PointContents( position + midProbeVec ) == conPosition )
{
minProbeLength = midProbeLength;
}
@ -261,7 +261,7 @@ float CFlyingMonster::FloorZ( const Vector &position )
UTIL_TraceLine( position, down, ignore_monsters, NULL, &tr );
if ( tr.flFraction != 1.0 )
if( tr.flFraction != 1.0 )
return tr.vecEndPos.z;
return down.z;

4
dlls/flyingmonster.h
View File

@ -20,8 +20,8 @@
class CFlyingMonster : public CBaseMonster
{
public:
int CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist );// check validity of a straight move through space
BOOL FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex );
int CheckLocalMove( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist );// check validity of a straight move through space
BOOL FTriangulate( const Vector &vecStart, const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex );
Activity GetStoppedActivity( void );
void Killed( entvars_t *pevAttacker, int iGib );
void Stop( void );

383
dlls/func_break.cpp
View File

@ -39,7 +39,7 @@ const char *CBreakable::pSpawnObjects[] =
NULL, // 0
"item_battery", // 1
"item_healthkit", // 2
"weapon_9mmhandgun",// 3
"weapon_9mmhandgun", // 3
"ammo_9mmclip", // 4
"weapon_9mmAR", // 5
"ammo_9mmAR", // 6
@ -53,7 +53,7 @@ const char *CBreakable::pSpawnObjects[] =
"weapon_rpg", // 14
"ammo_rpgclip", // 15
"ammo_gaussclip", // 16
"weapon_handgrenade",// 17
"weapon_handgrenade", // 17
"weapon_tripmine", // 18
"weapon_satchel", // 19
"weapon_snark", // 20
@ -63,63 +63,62 @@ const char *CBreakable::pSpawnObjects[] =
void CBreakable::KeyValue( KeyValueData* pkvd )
{
// UNDONE_WC: explicitly ignoring these fields, but they shouldn't be in the map file!
if (FStrEq(pkvd->szKeyName, "explosion"))
if( FStrEq( pkvd->szKeyName, "explosion" ) )
{
if (!stricmp(pkvd->szValue, "directed"))
if( !stricmp( pkvd->szValue, "directed" ) )
m_Explosion = expDirected;
else if (!stricmp(pkvd->szValue, "random"))
else if( !stricmp( pkvd->szValue, "random" ) )
m_Explosion = expRandom;
else
m_Explosion = expRandom;
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "material"))
else if( FStrEq( pkvd->szKeyName, "material" ) )
{
int i = atoi( pkvd->szValue);
int i = atoi( pkvd->szValue );
// 0:glass, 1:metal, 2:flesh, 3:wood
if ((i < 0) || (i >= matLastMaterial))
if( ( i < 0 ) || ( i >= matLastMaterial ) )
m_Material = matWood;
else
m_Material = (Materials)i;
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "deadmodel"))
else if( FStrEq( pkvd->szKeyName, "deadmodel" ) )
{
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "shards"))
else if( FStrEq( pkvd->szKeyName, "shards" ) )
{
//m_iShards = atof(pkvd->szValue);
//m_iShards = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "gibmodel") )
else if( FStrEq( pkvd->szKeyName, "gibmodel" ) )
{
m_iszGibModel = ALLOC_STRING(pkvd->szValue);
m_iszGibModel = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "spawnobject") )
else if( FStrEq( pkvd->szKeyName, "spawnobject" ) )
{
int object = atoi( pkvd->szValue );
if ( object > 0 && object < ARRAYSIZE(pSpawnObjects) )
if( object > 0 && object < ARRAYSIZE( pSpawnObjects ) )
m_iszSpawnObject = MAKE_STRING( pSpawnObjects[object] );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "explodemagnitude") )
else if( FStrEq( pkvd->szKeyName, "explodemagnitude" ) )
{
ExplosionSetMagnitude( atoi( pkvd->szValue ) );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "lip") )
else if( FStrEq( pkvd->szKeyName, "lip" ) )
pkvd->fHandled = TRUE;
else
CBaseDelay::KeyValue( pkvd );
}
//
// func_breakable - bmodel that breaks into pieces after taking damage
//
@ -144,9 +143,9 @@ IMPLEMENT_SAVERESTORE( CBreakable, CBaseEntity )
void CBreakable::Spawn( void )
{
Precache( );
Precache();
if ( FBitSet( pev->spawnflags, SF_BREAK_TRIGGER_ONLY ) )
if( FBitSet( pev->spawnflags, SF_BREAK_TRIGGER_ONLY ) )
pev->takedamage = DAMAGE_NO;
else
pev->takedamage = DAMAGE_YES;
@ -158,19 +157,19 @@ void CBreakable::Spawn( void )
// HACK: matGlass can receive decals, we need the client to know about this
// so use class to store the material flag
if ( m_Material == matGlass )
if( m_Material == matGlass )
{
pev->playerclass = 1;
}
SET_MODEL(ENT(pev), STRING(pev->model) );//set size and link into world.
SET_MODEL( ENT( pev ), STRING( pev->model ) );//set size and link into world.
SetTouch( &CBreakable::BreakTouch );
if ( FBitSet( pev->spawnflags, SF_BREAK_TRIGGER_ONLY ) ) // Only break on trigger
if( FBitSet( pev->spawnflags, SF_BREAK_TRIGGER_ONLY ) ) // Only break on trigger
SetTouch( NULL );
// Flag unbreakable glass as "worldbrush" so it will block ALL tracelines
if ( !IsBreakable() && pev->rendermode != kRenderNormal )
if( !IsBreakable() && pev->rendermode != kRenderNormal )
pev->flags |= FL_WORLDBRUSH;
}
@ -216,35 +215,31 @@ const char **CBreakable::MaterialSoundList( Materials precacheMaterial, int &sou
{
const char **pSoundList = NULL;
switch ( precacheMaterial )
switch( precacheMaterial )
{
case matWood:
pSoundList = pSoundsWood;
soundCount = ARRAYSIZE(pSoundsWood);
soundCount = ARRAYSIZE( pSoundsWood );
break;
case matFlesh:
pSoundList = pSoundsFlesh;
soundCount = ARRAYSIZE(pSoundsFlesh);
soundCount = ARRAYSIZE( pSoundsFlesh );
break;
case matComputer:
case matUnbreakableGlass:
case matGlass:
pSoundList = pSoundsGlass;
soundCount = ARRAYSIZE(pSoundsGlass);
soundCount = ARRAYSIZE( pSoundsGlass );
break;
case matMetal:
pSoundList = pSoundsMetal;
soundCount = ARRAYSIZE(pSoundsMetal);
soundCount = ARRAYSIZE( pSoundsMetal );
break;
case matCinderBlock:
case matRocks:
pSoundList = pSoundsConcrete;
soundCount = ARRAYSIZE(pSoundsConcrete);
soundCount = ARRAYSIZE( pSoundsConcrete );
break;
case matCeilingTile:
case matNone:
default:
@ -262,7 +257,7 @@ void CBreakable::MaterialSoundPrecache( Materials precacheMaterial )
pSoundList = MaterialSoundList( precacheMaterial, soundCount );
for ( i = 0; i < soundCount; i++ )
for( i = 0; i < soundCount; i++ )
{
PRECACHE_SOUND( (char *)pSoundList[i] );
}
@ -275,66 +270,65 @@ void CBreakable::MaterialSoundRandom( edict_t *pEdict, Materials soundMaterial,
pSoundList = MaterialSoundList( soundMaterial, soundCount );
if ( soundCount )
EMIT_SOUND( pEdict, CHAN_BODY, pSoundList[ RANDOM_LONG(0,soundCount-1) ], volume, 1.0 );
if( soundCount )
EMIT_SOUND( pEdict, CHAN_BODY, pSoundList[RANDOM_LONG( 0, soundCount - 1 )], volume, 1.0 );
}
void CBreakable::Precache( void )
{
const char *pGibName = NULL;
switch (m_Material)
switch( m_Material )
{
case matWood:
pGibName = "models/woodgibs.mdl";
PRECACHE_SOUND("debris/bustcrate1.wav");
PRECACHE_SOUND("debris/bustcrate2.wav");
PRECACHE_SOUND( "debris/bustcrate1.wav" );
PRECACHE_SOUND( "debris/bustcrate2.wav" );
break;
case matFlesh:
pGibName = "models/fleshgibs.mdl";
PRECACHE_SOUND("debris/bustflesh1.wav");
PRECACHE_SOUND("debris/bustflesh2.wav");
PRECACHE_SOUND( "debris/bustflesh1.wav" );
PRECACHE_SOUND( "debris/bustflesh2.wav" );
break;
case matComputer:
PRECACHE_SOUND("buttons/spark5.wav");
PRECACHE_SOUND("buttons/spark6.wav");
PRECACHE_SOUND( "buttons/spark5.wav" );
PRECACHE_SOUND( "buttons/spark6.wav" );
pGibName = "models/computergibs.mdl";
PRECACHE_SOUND("debris/bustmetal1.wav");
PRECACHE_SOUND("debris/bustmetal2.wav");
PRECACHE_SOUND( "debris/bustmetal1.wav" );
PRECACHE_SOUND( "debris/bustmetal2.wav" );
break;
case matUnbreakableGlass:
case matGlass:
pGibName = "models/glassgibs.mdl";
PRECACHE_SOUND("debris/bustglass1.wav");
PRECACHE_SOUND("debris/bustglass2.wav");
PRECACHE_SOUND( "debris/bustglass1.wav" );
PRECACHE_SOUND( "debris/bustglass2.wav" );
break;
case matMetal:
pGibName = "models/metalplategibs.mdl";
PRECACHE_SOUND("debris/bustmetal1.wav");
PRECACHE_SOUND("debris/bustmetal2.wav");
PRECACHE_SOUND( "debris/bustmetal1.wav" );
PRECACHE_SOUND( "debris/bustmetal2.wav" );
break;
case matCinderBlock:
pGibName = "models/cindergibs.mdl";
PRECACHE_SOUND("debris/bustconcrete1.wav");
PRECACHE_SOUND("debris/bustconcrete2.wav");
PRECACHE_SOUND( "debris/bustconcrete1.wav" );
PRECACHE_SOUND( "debris/bustconcrete2.wav" );
break;
case matRocks:
pGibName = "models/rockgibs.mdl";
PRECACHE_SOUND("debris/bustconcrete1.wav");
PRECACHE_SOUND("debris/bustconcrete2.wav");
PRECACHE_SOUND( "debris/bustconcrete1.wav" );
PRECACHE_SOUND( "debris/bustconcrete2.wav" );
break;
case matCeilingTile:
pGibName = "models/ceilinggibs.mdl";
PRECACHE_SOUND ("debris/bustceiling.wav");
PRECACHE_SOUND( "debris/bustceiling.wav" );
break;
case matNone:
case matLastMaterial:
@ -343,20 +337,18 @@ void CBreakable::Precache( void )
break;
}
MaterialSoundPrecache( m_Material );
if ( m_iszGibModel )
pGibName = STRING(m_iszGibModel);
if( m_iszGibModel )
pGibName = STRING( m_iszGibModel );
m_idShard = PRECACHE_MODEL( (char *)pGibName );
// Precache the spawn item's data
if ( m_iszSpawnObject )
if( m_iszSpawnObject )
UTIL_PrecacheOther( (char *)STRING( m_iszSpawnObject ) );
}
// play shard sound when func_breakable takes damage.
// the more damage, the louder the shard sound.
void CBreakable::DamageSound( void )
{
int pitch;
@ -365,20 +357,20 @@ void CBreakable::DamageSound( void )
int i = 0;
int material = m_Material;
// if (RANDOM_LONG(0,1))
// return;
//if( RANDOM_LONG( 0, 1 ) )
// return;
if (RANDOM_LONG(0,2))
if( RANDOM_LONG( 0, 2 ) )
pitch = PITCH_NORM;
else
pitch = 95 + RANDOM_LONG(0,34);
pitch = 95 + RANDOM_LONG( 0, 34 );
fvol = RANDOM_FLOAT(0.75, 1.0);
fvol = RANDOM_FLOAT( 0.75, 1.0 );
if (material == matComputer && RANDOM_LONG(0,1))
if( material == matComputer && RANDOM_LONG( 0, 1 ) )
material = matMetal;
switch (material)
switch( material )
{
case matComputer:
case matGlass:
@ -422,8 +414,8 @@ void CBreakable::DamageSound( void )
break;
}
if (i)
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, rgpsz[RANDOM_LONG(0,i-1)], fvol, ATTN_NORM, 0, pitch);
if( i )
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, rgpsz[ RANDOM_LONG( 0, i - 1 )], fvol, ATTN_NORM, 0, pitch );
}
void CBreakable::BreakTouch( CBaseEntity *pOther )
@ -432,27 +424,27 @@ void CBreakable::BreakTouch( CBaseEntity *pOther )
entvars_t* pevToucher = pOther->pev;
// only players can break these right now
if ( !pOther->IsPlayer() || !IsBreakable() )
if( !pOther->IsPlayer() || !IsBreakable() )
{
return;
}
if ( FBitSet ( pev->spawnflags, SF_BREAK_TOUCH ) )
if( FBitSet( pev->spawnflags, SF_BREAK_TOUCH ) )
{
// can be broken when run into
flDamage = pevToucher->velocity.Length() * 0.01;
if (flDamage >= pev->health)
if( flDamage >= pev->health )
{
SetTouch( NULL );
TakeDamage(pevToucher, pevToucher, flDamage, DMG_CRUSH);
TakeDamage( pevToucher, pevToucher, flDamage, DMG_CRUSH );
// do a little damage to player if we broke glass or computer
pOther->TakeDamage( pev, pev, flDamage/4, DMG_SLASH );
}
}
if ( FBitSet ( pev->spawnflags, SF_BREAK_PRESSURE ) && pevToucher->absmin.z >= pev->maxs.z - 2 )
if( FBitSet( pev->spawnflags, SF_BREAK_PRESSURE ) && pevToucher->absmin.z >= pev->maxs.z - 2 )
{
// can be broken when stood upon
// play creaking sound here.
@ -461,7 +453,7 @@ void CBreakable::BreakTouch( CBaseEntity *pOther )
SetThink( &CBreakable::Die );
SetTouch( NULL );
if ( m_flDelay == 0 )
if( m_flDelay == 0 )
{
// !!!BUGBUG - why doesn't zero delay work?
m_flDelay = 0.1;
@ -478,21 +470,20 @@ void CBreakable::BreakTouch( CBaseEntity *pOther )
// Break when triggered
void CBreakable::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( IsBreakable() )
if( IsBreakable() )
{
pev->angles.y = m_angle;
UTIL_MakeVectors(pev->angles);
UTIL_MakeVectors( pev->angles );
g_vecAttackDir = gpGlobals->v_forward;
Die();
}
}
void CBreakable::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
{
// random spark if this is a 'computer' object
if (RANDOM_LONG(0,1) )
if( RANDOM_LONG( 0, 1 ) )
{
switch( m_Material )
{
@ -500,16 +491,20 @@ void CBreakable::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vec
{
UTIL_Sparks( ptr->vecEndPos );
float flVolume = RANDOM_FLOAT ( 0.7 , 1.0 );//random volume range
switch ( RANDOM_LONG(0,1) )
float flVolume = RANDOM_FLOAT( 0.7 , 1.0 );//random volume range
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/spark5.wav", flVolume, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/spark6.wav", flVolume, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "buttons/spark5.wav", flVolume, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "buttons/spark6.wav", flVolume, ATTN_NORM );
break;
}
}
break;
case matUnbreakableGlass:
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT(0.5,1.5) );
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT( 0.5, 1.5 ) );
break;
default:
break;
@ -524,19 +519,19 @@ void CBreakable::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vec
// exceptions that are breakable-specific
// bitsDamageType indicates the type of damage sustained ie: DMG_CRUSH
//=========================================================
int CBreakable :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
int CBreakable::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
Vector vecTemp;
// if Attacker == Inflictor, the attack was a melee or other instant-hit attack.
// (that is, no actual entity projectile was involved in the attack so use the shooter's origin).
if ( pevAttacker == pevInflictor )
if( pevAttacker == pevInflictor )
{
vecTemp = pevInflictor->origin - ( pev->absmin + ( pev->size * 0.5 ) );
// if a client hit the breakable with a crowbar, and breakable is crowbar-sensitive, break it now.
if ( FBitSet ( pevAttacker->flags, FL_CLIENT ) &&
FBitSet ( pev->spawnflags, SF_BREAK_CROWBAR ) && (bitsDamageType & DMG_CLUB))
if( FBitSet ( pevAttacker->flags, FL_CLIENT ) &&
FBitSet ( pev->spawnflags, SF_BREAK_CROWBAR ) && ( bitsDamageType & DMG_CLUB ) )
flDamage = pev->health;
}
else
@ -545,15 +540,15 @@ int CBreakable :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, f
vecTemp = pevInflictor->origin - ( pev->absmin + ( pev->size * 0.5 ) );
}
if (!IsBreakable())
if( !IsBreakable() )
return 0;
// Breakables take double damage from the crowbar
if ( bitsDamageType & DMG_CLUB )
if( bitsDamageType & DMG_CLUB )
flDamage *= 2;
// Boxes / glass / etc. don't take much poison damage, just the impact of the dart - consider that 10%
if ( bitsDamageType & DMG_POISON )
if( bitsDamageType & DMG_POISON )
flDamage *= 0.1;
// this global is still used for glass and other non-monster killables, along with decals.
@ -561,7 +556,7 @@ int CBreakable :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, f
// do the damage
pev->health -= flDamage;
if (pev->health <= 0)
if( pev->health <= 0 )
{
Killed( pevAttacker, GIB_NORMAL );
Die();
@ -575,7 +570,6 @@ int CBreakable :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, f
return 1;
}
void CBreakable::Die( void )
{
Vector vecSpot;// shard origin
@ -585,75 +579,85 @@ void CBreakable::Die( void )
int pitch;
float fvol;
pitch = 95 + RANDOM_LONG(0,29);
pitch = 95 + RANDOM_LONG( 0, 29 );
if (pitch > 97 && pitch < 103)
if( pitch > 97 && pitch < 103 )
pitch = 100;
// The more negative pev->health, the louder
// the sound should be.
fvol = RANDOM_FLOAT(0.85, 1.0) + (fabs(pev->health) / 100.0);
fvol = RANDOM_FLOAT( 0.85, 1.0 ) + ( fabs( pev->health ) / 100.0 );
if (fvol > 1.0)
if( fvol > 1.0 )
fvol = 1.0;
switch (m_Material)
switch( m_Material )
{
case matGlass:
switch ( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustglass1.wav", fvol, ATTN_NORM, 0, pitch);
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustglass1.wav", fvol, ATTN_NORM, 0, pitch );
break;
case 1: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustglass2.wav", fvol, ATTN_NORM, 0, pitch);
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustglass2.wav", fvol, ATTN_NORM, 0, pitch );
break;
}
cFlag = BREAK_GLASS;
break;
case matWood:
switch ( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustcrate1.wav", fvol, ATTN_NORM, 0, pitch);
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustcrate1.wav", fvol, ATTN_NORM, 0, pitch );
break;
case 1: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustcrate2.wav", fvol, ATTN_NORM, 0, pitch);
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustcrate2.wav", fvol, ATTN_NORM, 0, pitch );
break;
}
cFlag = BREAK_WOOD;
break;
case matComputer:
case matMetal:
switch ( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustmetal1.wav", fvol, ATTN_NORM, 0, pitch);
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustmetal1.wav", fvol, ATTN_NORM, 0, pitch );
break;
case 1: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustmetal2.wav", fvol, ATTN_NORM, 0, pitch);
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustmetal2.wav", fvol, ATTN_NORM, 0, pitch );
break;
}
cFlag = BREAK_METAL;
break;
case matFlesh:
switch ( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustflesh1.wav", fvol, ATTN_NORM, 0, pitch);
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustflesh1.wav", fvol, ATTN_NORM, 0, pitch );
break;
case 1: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustflesh2.wav", fvol, ATTN_NORM, 0, pitch);
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustflesh2.wav", fvol, ATTN_NORM, 0, pitch );
break;
}
cFlag = BREAK_FLESH;
break;
case matRocks:
case matCinderBlock:
switch ( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustconcrete1.wav", fvol, ATTN_NORM, 0, pitch);
case 0:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustconcrete1.wav", fvol, ATTN_NORM, 0, pitch );
break;
case 1: EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustconcrete2.wav", fvol, ATTN_NORM, 0, pitch);
case 1:
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustconcrete2.wav", fvol, ATTN_NORM, 0, pitch );
break;
}
cFlag = BREAK_CONCRETE;
break;
case matCeilingTile:
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "debris/bustceiling.wav", fvol, ATTN_NORM, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "debris/bustceiling.wav", fvol, ATTN_NORM, 0, pitch );
break;
case matNone:
case matLastMaterial:
@ -663,7 +667,7 @@ void CBreakable::Die( void )
break;
}
if (m_Explosion == expDirected)
if( m_Explosion == expDirected )
vecVelocity = g_vecAttackDir * 200;
else
{
@ -672,9 +676,9 @@ void CBreakable::Die( void )
vecVelocity.z = 0;
}
vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
vecSpot = pev->origin + ( pev->mins + pev->maxs ) * 0.5;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_BREAKMODEL);
WRITE_BYTE( TE_BREAKMODEL );
// position
WRITE_COORD( vecSpot.x );
@ -682,9 +686,9 @@ void CBreakable::Die( void )
WRITE_COORD( vecSpot.z );
// size
WRITE_COORD( pev->size.x);
WRITE_COORD( pev->size.y);
WRITE_COORD( pev->size.z);
WRITE_COORD( pev->size.x );
WRITE_COORD( pev->size.y );
WRITE_COORD( pev->size.z );
// velocity
WRITE_COORD( vecVelocity.x );
@ -708,9 +712,9 @@ void CBreakable::Die( void )
MESSAGE_END();
float size = pev->size.x;
if ( size < pev->size.y )
if( size < pev->size.y )
size = pev->size.y;
if ( size < pev->size.z )
if( size < pev->size.z )
size = pev->size.z;
// !!! HACK This should work!
@ -723,9 +727,9 @@ void CBreakable::Die( void )
// BUGBUG -- can only find 256 entities on a breakable -- should be enough
CBaseEntity *pList[256];
int count = UTIL_EntitiesInBox( pList, 256, mins, maxs, FL_ONGROUND );
if ( count )
if( count )
{
for ( int i = 0; i < count; i++ )
for( int i = 0; i < count; i++ )
{
ClearBits( pList[i]->pev->flags, FL_ONGROUND );
pList[i]->pev->groundentity = NULL;
@ -742,26 +746,26 @@ void CBreakable::Die( void )
SetThink( &CBaseEntity::SUB_Remove );
pev->nextthink = pev->ltime + 0.1;
if ( m_iszSpawnObject )
CBaseEntity::Create( (char *)STRING(m_iszSpawnObject), VecBModelOrigin(pev), pev->angles, edict() );
if( m_iszSpawnObject )
CBaseEntity::Create( (char *)STRING( m_iszSpawnObject ), VecBModelOrigin( pev ), pev->angles, edict() );
if ( Explodable() )
if( Explodable() )
{
ExplosionCreate( Center(), pev->angles, edict(), ExplosionMagnitude(), TRUE );
}
}
BOOL CBreakable :: IsBreakable( void )
BOOL CBreakable::IsBreakable( void )
{
return m_Material != matUnbreakableGlass;
}
int CBreakable :: DamageDecal( int bitsDamageType )
int CBreakable::DamageDecal( int bitsDamageType )
{
if ( m_Material == matGlass )
return DECAL_GLASSBREAK1 + RANDOM_LONG(0,2);
if( m_Material == matGlass )
return DECAL_GLASSBREAK1 + RANDOM_LONG( 0, 2 );
if ( m_Material == matUnbreakableGlass )
if( m_Material == matUnbreakableGlass )
return DECAL_BPROOF1;
return CBaseEntity::DamageDecal( bitsDamageType );
@ -779,14 +783,14 @@ public:
void EXPORT StopSound( void );
//virtual void SetActivator( CBaseEntity *pActivator ) { m_pPusher = pActivator; }
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_CONTINUOUS_USE; }
virtual int ObjectCaps( void ) { return ( CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION ) | FCAP_CONTINUOUS_USE; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
inline float MaxSpeed( void ) { return m_maxSpeed; }
// breakables use an overridden takedamage
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
static TYPEDESCRIPTION m_SaveData[];
@ -806,20 +810,25 @@ IMPLEMENT_SAVERESTORE( CPushable, CBreakable )
LINK_ENTITY_TO_CLASS( func_pushable, CPushable )
char *CPushable :: m_soundNames[3] = { "debris/pushbox1.wav", "debris/pushbox2.wav", "debris/pushbox3.wav" };
void CPushable :: Spawn( void )
char *CPushable::m_soundNames[3] =
{
if ( pev->spawnflags & SF_PUSH_BREAKABLE )
"debris/pushbox1.wav",
"debris/pushbox2.wav",
"debris/pushbox3.wav"
};
void CPushable::Spawn( void )
{
if( pev->spawnflags & SF_PUSH_BREAKABLE )
CBreakable::Spawn();
else
Precache( );
Precache();
pev->movetype = MOVETYPE_PUSHSTEP;
pev->solid = SOLID_BBOX;
SET_MODEL( ENT(pev), STRING(pev->model) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
if ( pev->friction > 399 )
if( pev->friction > 399 )
pev->friction = 399;
m_maxSpeed = 400 - pev->friction;
@ -830,46 +839,50 @@ void CPushable :: Spawn( void )
UTIL_SetOrigin( pev, pev->origin );
// Multiply by area of the box's cross-section (assume 1000 units^3 standard volume)
pev->skin = ( pev->skin * (pev->maxs.x - pev->mins.x) * (pev->maxs.y - pev->mins.y) ) * 0.0005;
pev->skin = ( pev->skin * ( pev->maxs.x - pev->mins.x ) * ( pev->maxs.y - pev->mins.y ) ) * 0.0005;
m_soundTime = 0;
}
void CPushable :: Precache( void )
void CPushable::Precache( void )
{
for ( int i = 0; i < 3; i++ )
for( int i = 0; i < 3; i++ )
PRECACHE_SOUND( m_soundNames[i] );
if ( pev->spawnflags & SF_PUSH_BREAKABLE )
CBreakable::Precache( );
if( pev->spawnflags & SF_PUSH_BREAKABLE )
CBreakable::Precache();
}
void CPushable :: KeyValue( KeyValueData *pkvd )
void CPushable::KeyValue( KeyValueData *pkvd )
{
if ( FStrEq(pkvd->szKeyName, "size") )
if( FStrEq( pkvd->szKeyName, "size" ) )
{
int bbox = atoi(pkvd->szValue);
int bbox = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
switch( bbox )
{
case 0: // Point
UTIL_SetSize(pev, Vector(-8, -8, -8), Vector(8, 8, 8));
case 0:
// Point
UTIL_SetSize( pev, Vector( -8, -8, -8 ), Vector( 8, 8, 8 ) );
break;
case 2: // Big Hull!?!? !!!BUGBUG Figure out what this hull really is
UTIL_SetSize(pev, VEC_DUCK_HULL_MIN*2, VEC_DUCK_HULL_MAX*2);
case 2:
// Big Hull!?!? !!!BUGBUG Figure out what this hull really is
UTIL_SetSize( pev, VEC_DUCK_HULL_MIN*2, VEC_DUCK_HULL_MAX * 2 );
break;
case 3: // Player duck
UTIL_SetSize(pev, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX);
case 3:
// Player duck
UTIL_SetSize( pev, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX );
break;
default:
case 1: // Player
UTIL_SetSize(pev, VEC_HULL_MIN, VEC_HULL_MAX);
case 1:
// Player
UTIL_SetSize( pev, VEC_HULL_MIN, VEC_HULL_MAX );
break;
}
}
else if ( FStrEq(pkvd->szKeyName, "buoyancy") )
else if( FStrEq( pkvd->szKeyName, "buoyancy" ) )
{
pev->skin = atof(pkvd->szValue);
pev->skin = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -877,58 +890,58 @@ void CPushable :: KeyValue( KeyValueData *pkvd )
}
// Pull the func_pushable
void CPushable :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CPushable::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( !pActivator || !pActivator->IsPlayer() )
if( !pActivator || !pActivator->IsPlayer() )
{
if ( pev->spawnflags & SF_PUSH_BREAKABLE )
if( pev->spawnflags & SF_PUSH_BREAKABLE )
this->CBreakable::Use( pActivator, pCaller, useType, value );
return;
}
if ( pActivator->pev->velocity != g_vecZero )
if( pActivator->pev->velocity != g_vecZero )
Move( pActivator, 0 );
}
void CPushable :: Touch( CBaseEntity *pOther )
void CPushable::Touch( CBaseEntity *pOther )
{
if ( FClassnameIs( pOther->pev, "worldspawn" ) )
if( FClassnameIs( pOther->pev, "worldspawn" ) )
return;
Move( pOther, 1 );
}
void CPushable :: Move( CBaseEntity *pOther, int push )
void CPushable::Move( CBaseEntity *pOther, int push )
{
entvars_t* pevToucher = pOther->pev;
int playerTouch = 0;
// Is entity standing on this pushable ?
if ( FBitSet(pevToucher->flags,FL_ONGROUND) && pevToucher->groundentity && VARS(pevToucher->groundentity) == pev )
if( FBitSet( pevToucher->flags,FL_ONGROUND ) && pevToucher->groundentity && VARS( pevToucher->groundentity ) == pev )
{
// Only push if floating
if ( pev->waterlevel > 0 )
if( pev->waterlevel > 0 )
pev->velocity.z += pevToucher->velocity.z * 0.1;
return;
}
// g-cont. fix pushable acceleration bug (reverted as it used in mods)
if ( pOther->IsPlayer() )
if( pOther->IsPlayer() )
{
// Don't push unless the player is pushing forward and NOT use (pull)
if ( push && !(pevToucher->button & (IN_FORWARD|IN_USE)) )
if( push && !( pevToucher->button & ( IN_FORWARD | IN_USE ) ) )
return;
playerTouch = 1;
}
float factor;
if ( playerTouch )
if( playerTouch )
{
if ( !(pevToucher->flags & FL_ONGROUND) ) // Don't push away from jumping/falling players unless in water
if( !( pevToucher->flags & FL_ONGROUND ) ) // Don't push away from jumping/falling players unless in water
{
if ( pev->waterlevel < 1 )
if( pev->waterlevel < 1 )
return;
else
factor = 0.1;
@ -943,27 +956,27 @@ void CPushable :: Move( CBaseEntity *pOther, int push )
pev->velocity.y += pevToucher->velocity.y * factor;
float length = sqrt( pev->velocity.x * pev->velocity.x + pev->velocity.y * pev->velocity.y );
if ( push && (length > MaxSpeed()) )
if( push && ( length > MaxSpeed() ) )
{
pev->velocity.x = (pev->velocity.x * MaxSpeed() / length );
pev->velocity.y = (pev->velocity.y * MaxSpeed() / length );
}
if ( playerTouch )
if( playerTouch )
{
pevToucher->velocity.x = pev->velocity.x;
pevToucher->velocity.y = pev->velocity.y;
if ( (gpGlobals->time - m_soundTime) > 0.7 )
if( ( gpGlobals->time - m_soundTime ) > 0.7 )
{
m_soundTime = gpGlobals->time;
if ( length > 0 && FBitSet(pev->flags,FL_ONGROUND) )
if( length > 0 && FBitSet( pev->flags,FL_ONGROUND ) )
{
m_lastSound = RANDOM_LONG(0,2);
EMIT_SOUND(ENT(pev), CHAN_WEAPON, m_soundNames[m_lastSound], 0.5, ATTN_NORM);
m_lastSound = RANDOM_LONG( 0, 2 );
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, m_soundNames[m_lastSound], 0.5, ATTN_NORM );
//SetThink( &StopSound );
//pev->nextthink = pev->ltime + 0.1;
}
else
STOP_SOUND( ENT(pev), CHAN_WEAPON, m_soundNames[m_lastSound] );
STOP_SOUND( ENT( pev ), CHAN_WEAPON, m_soundNames[m_lastSound] );
}
}
}
@ -972,14 +985,14 @@ void CPushable :: Move( CBaseEntity *pOther, int push )
void CPushable::StopSound( void )
{
Vector dist = pev->oldorigin - pev->origin;
if ( dist.Length() <= 0 )
STOP_SOUND( ENT(pev), CHAN_WEAPON, m_soundNames[m_lastSound] );
if( dist.Length() <= 0 )
STOP_SOUND( ENT( pev ), CHAN_WEAPON, m_soundNames[m_lastSound] );
}
#endif
int CPushable::TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
int CPushable::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if ( pev->spawnflags & SF_PUSH_BREAKABLE )
if( pev->spawnflags & SF_PUSH_BREAKABLE )
return CBreakable::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
return 1;

26
dlls/func_break.h
View File

@ -15,8 +15,25 @@
#ifndef FUNC_BREAK_H
#define FUNC_BREAK_H
typedef enum { expRandom, expDirected} Explosions;
typedef enum { matGlass = 0, matWood, matMetal, matFlesh, matCinderBlock, matCeilingTile, matComputer, matUnbreakableGlass, matRocks, matNone, matLastMaterial } Materials;
typedef enum
{
expRandom,
expDirected
} Explosions;
typedef enum
{
matGlass = 0,
matWood,
matMetal,
matFlesh,
matCinderBlock,
matCeilingTile,
matComputer,
matUnbreakableGlass,
matRocks,
matNone,
matLastMaterial
} Materials;
#define NUM_SHARDS 6 // this many shards spawned when breakable objects break;
@ -32,7 +49,7 @@ public:
void DamageSound( void );
// breakables use an overridden takedamage
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
// To spark when hit
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
@ -42,7 +59,7 @@ public:
int DamageDecal( int bitsDamageType );
void EXPORT Die( void );
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
virtual int ObjectCaps( void ) { return ( CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION ); }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
@ -70,5 +87,4 @@ public:
int m_iszGibModel;
int m_iszSpawnObject;
};
#endif // FUNC_BREAK_H

361
dlls/func_tank.cpp
View File

@ -170,148 +170,149 @@ static Vector gTankSpread[] =
Vector( 0.25, 0.25, 0.25 ), // extra-large cone
};
#define MAX_FIRING_SPREADS ARRAYSIZE(gTankSpread)
#define MAX_FIRING_SPREADS ARRAYSIZE( gTankSpread )
void CFuncTank :: Spawn( void )
void CFuncTank::Spawn( void )
{
Precache();
pev->movetype = MOVETYPE_PUSH; // so it doesn't get pushed by anything
pev->solid = SOLID_BSP;
SET_MODEL( ENT(pev), STRING(pev->model) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
m_yawCenter = pev->angles.y;
m_pitchCenter = pev->angles.x;
if ( IsActive() )
if( IsActive() )
pev->nextthink = pev->ltime + 1.0;
m_sightOrigin = BarrelPosition(); // Point at the end of the barrel
if ( m_fireRate <= 0 )
if( m_fireRate <= 0 )
m_fireRate = 1;
if ( m_spread > MAX_FIRING_SPREADS )
if( m_spread > MAX_FIRING_SPREADS )
m_spread = 0;
pev->oldorigin = pev->origin;
}
void CFuncTank :: Precache( void )
void CFuncTank::Precache( void )
{
if ( m_iszSpriteSmoke )
PRECACHE_MODEL( (char *)STRING(m_iszSpriteSmoke) );
if ( m_iszSpriteFlash )
PRECACHE_MODEL( (char *)STRING(m_iszSpriteFlash) );
if( m_iszSpriteSmoke )
PRECACHE_MODEL( (char *)STRING( m_iszSpriteSmoke ) );
if ( pev->noise )
PRECACHE_SOUND( (char *)STRING(pev->noise) );
if( m_iszSpriteFlash )
PRECACHE_MODEL( (char *)STRING( m_iszSpriteFlash ) );
if( pev->noise )
PRECACHE_SOUND( (char *)STRING( pev->noise ) );
}
void CFuncTank :: KeyValue( KeyValueData *pkvd )
void CFuncTank::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "yawrate"))
if( FStrEq( pkvd->szKeyName, "yawrate" ) )
{
m_yawRate = atof(pkvd->szValue);
m_yawRate = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "yawrange"))
else if( FStrEq( pkvd->szKeyName, "yawrange" ) )
{
m_yawRange = atof(pkvd->szValue);
m_yawRange = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "yawtolerance"))
else if( FStrEq( pkvd->szKeyName, "yawtolerance" ) )
{
m_yawTolerance = atof(pkvd->szValue);
m_yawTolerance = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pitchrange"))
else if( FStrEq( pkvd->szKeyName, "pitchrange" ) )
{
m_pitchRange = atof(pkvd->szValue);
m_pitchRange = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pitchrate"))
else if( FStrEq( pkvd->szKeyName, "pitchrate" ) )
{
m_pitchRate = atof(pkvd->szValue);
m_pitchRate = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pitchtolerance"))
else if( FStrEq( pkvd->szKeyName, "pitchtolerance" ) )
{
m_pitchTolerance = atof(pkvd->szValue);
m_pitchTolerance = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "firerate"))
else if( FStrEq( pkvd->szKeyName, "firerate" ) )
{
m_fireRate = atof(pkvd->szValue);
m_fireRate = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "barrel"))
else if( FStrEq( pkvd->szKeyName, "barrel" ) )
{
m_barrelPos.x = atof(pkvd->szValue);
m_barrelPos.x = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "barrely"))
else if( FStrEq( pkvd->szKeyName, "barrely" ) )
{
m_barrelPos.y = atof(pkvd->szValue);
m_barrelPos.y = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "barrelz"))
else if( FStrEq( pkvd->szKeyName, "barrelz" ) )
{
m_barrelPos.z = atof(pkvd->szValue);
m_barrelPos.z = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "spritescale"))
else if( FStrEq( pkvd->szKeyName, "spritescale" ) )
{
m_spriteScale = atof(pkvd->szValue);
m_spriteScale = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "spritesmoke"))
else if( FStrEq( pkvd->szKeyName, "spritesmoke" ) )
{
m_iszSpriteSmoke = ALLOC_STRING(pkvd->szValue);
m_iszSpriteSmoke = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "spriteflash"))
else if( FStrEq( pkvd->szKeyName, "spriteflash" ) )
{
m_iszSpriteFlash = ALLOC_STRING(pkvd->szValue);
m_iszSpriteFlash = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "rotatesound"))
else if( FStrEq( pkvd->szKeyName, "rotatesound" ) )
{
pev->noise = ALLOC_STRING(pkvd->szValue);
pev->noise = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "persistence"))
else if( FStrEq( pkvd->szKeyName, "persistence" ) )
{
m_persist = atof(pkvd->szValue);
m_persist = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "bullet"))
else if( FStrEq( pkvd->szKeyName, "bullet" ) )
{
m_bulletType = (TANKBULLET)atoi(pkvd->szValue);
m_bulletType = (TANKBULLET)atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if ( FStrEq(pkvd->szKeyName, "bullet_damage" ))
else if( FStrEq( pkvd->szKeyName, "bullet_damage" ) )
{
m_iBulletDamage = atoi(pkvd->szValue);
m_iBulletDamage = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "firespread"))
else if( FStrEq(pkvd->szKeyName, "firespread" ) )
{
m_spread = atoi(pkvd->szValue);
m_spread = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "minRange"))
else if( FStrEq( pkvd->szKeyName, "minRange" ) )
{
m_minRange = atof(pkvd->szValue);
m_minRange = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "maxRange"))
else if( FStrEq( pkvd->szKeyName, "maxRange" ) )
{
m_maxRange = atof(pkvd->szValue);
m_maxRange = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "master"))
else if( FStrEq( pkvd->szKeyName, "master" ) )
{
m_iszMaster = ALLOC_STRING(pkvd->szValue);
m_iszMaster = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -322,40 +323,39 @@ void CFuncTank :: KeyValue( KeyValueData *pkvd )
//==================================================================================
// TANK CONTROLLING
BOOL CFuncTank :: OnControls( entvars_t *pevTest )
BOOL CFuncTank::OnControls( entvars_t *pevTest )
{
if ( !(pev->spawnflags & SF_TANK_CANCONTROL) )
if( !( pev->spawnflags & SF_TANK_CANCONTROL ) )
return FALSE;
Vector offset = pevTest->origin - pev->origin;
if ( (m_vecControllerUsePos - pevTest->origin).Length() < 30 )
if( ( m_vecControllerUsePos - pevTest->origin ).Length() < 30 )
return TRUE;
return FALSE;
}
BOOL CFuncTank :: StartControl( CBasePlayer *pController )
BOOL CFuncTank::StartControl( CBasePlayer *pController )
{
if ( m_pController != NULL )
if( m_pController != NULL )
return FALSE;
// Team only or disabled?
if ( m_iszMaster )
if( m_iszMaster )
{
if ( !UTIL_IsMasterTriggered( m_iszMaster, pController ) )
if( !UTIL_IsMasterTriggered( m_iszMaster, pController ) )
return FALSE;
}
ALERT( at_console, "using TANK!\n");
m_pController = pController;
if ( m_pController->m_pActiveItem )
if( m_pController->m_pActiveItem )
{
m_pController->m_pActiveItem->Holster();
m_pController->pev->weaponmodel = 0;
m_pController->pev->viewmodel = 0;
}
m_pController->m_iHideHUD |= HIDEHUD_WEAPONS;
@ -366,13 +366,13 @@ BOOL CFuncTank :: StartControl( CBasePlayer *pController )
return TRUE;
}
void CFuncTank :: StopControl()
void CFuncTank::StopControl()
{
// TODO: bring back the controllers current weapon
if ( !m_pController )
if( !m_pController )
return;
if ( m_pController->m_pActiveItem )
if( m_pController->m_pActiveItem )
m_pController->m_pActiveItem->Deploy();
ALERT( at_console, "stopped using TANK\n");
@ -382,51 +382,51 @@ void CFuncTank :: StopControl()
pev->nextthink = 0;
m_pController = NULL;
if ( IsActive() )
if( IsActive() )
pev->nextthink = pev->ltime + 1.0;
}
// Called each frame by the player's ItemPostFrame
void CFuncTank :: ControllerPostFrame( void )
void CFuncTank::ControllerPostFrame( void )
{
ASSERT(m_pController != NULL);
ASSERT( m_pController != NULL );
if ( gpGlobals->time < m_flNextAttack )
if( gpGlobals->time < m_flNextAttack )
return;
if ( m_pController->pev->button & IN_ATTACK )
if( m_pController->pev->button & IN_ATTACK )
{
Vector vecForward;
UTIL_MakeVectorsPrivate( pev->angles, vecForward, NULL, NULL );
m_fireLast = gpGlobals->time - (1/m_fireRate) - 0.01; // to make sure the gun doesn't fire too many bullets
m_fireLast = gpGlobals->time - ( 1 / m_fireRate ) - 0.01; // to make sure the gun doesn't fire too many bullets
Fire( BarrelPosition(), vecForward, m_pController->pev );
// HACKHACK -- make some noise (that the AI can hear)
if ( m_pController && m_pController->IsPlayer() )
((CBasePlayer *)m_pController)->m_iWeaponVolume = LOUD_GUN_VOLUME;
if( m_pController && m_pController->IsPlayer() )
( (CBasePlayer *)m_pController )->m_iWeaponVolume = LOUD_GUN_VOLUME;
m_flNextAttack = gpGlobals->time + (1/m_fireRate);
m_flNextAttack = gpGlobals->time + ( 1 / m_fireRate );
}
}
////////////// END NEW STUFF //////////////
void CFuncTank :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CFuncTank::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( pev->spawnflags & SF_TANK_CANCONTROL )
{ // player controlled turret
if ( pActivator->Classify() != CLASS_PLAYER )
if( pev->spawnflags & SF_TANK_CANCONTROL )
{
// player controlled turret
if( pActivator->Classify() != CLASS_PLAYER )
return;
if ( value == 2 && useType == USE_SET )
if( value == 2 && useType == USE_SET )
{
ControllerPostFrame();
}
else if ( !m_pController && useType != USE_OFF )
else if( !m_pController && useType != USE_OFF )
{
((CBasePlayer*)pActivator)->m_pTank = this;
( (CBasePlayer*)pActivator )->m_pTank = this;
StartControl( (CBasePlayer*)pActivator );
}
else
@ -436,37 +436,37 @@ void CFuncTank :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE u
}
else
{
if ( !ShouldToggle( useType, IsActive() ) )
if( !ShouldToggle( useType, IsActive() ) )
return;
if ( IsActive() )
if( IsActive() )
TankDeactivate();
else
TankActivate();
}
}
edict_t *CFuncTank :: FindTarget( edict_t *pPlayer )
edict_t *CFuncTank::FindTarget( edict_t *pPlayer )
{
return pPlayer;
}
BOOL CFuncTank :: InRange( float range )
BOOL CFuncTank::InRange( float range )
{
if ( range < m_minRange )
if( range < m_minRange )
return FALSE;
if ( m_maxRange > 0 && range > m_maxRange )
if( m_maxRange > 0 && range > m_maxRange )
return FALSE;
return TRUE;
}
void CFuncTank :: Think( void )
void CFuncTank::Think( void )
{
pev->avelocity = g_vecZero;
TrackTarget();
if ( fabs(pev->avelocity.x) > 1 || fabs(pev->avelocity.y) > 1 )
if( fabs( pev->avelocity.x ) > 1 || fabs( pev->avelocity.y ) > 1 )
StartRotSound();
else
StopRotSound();
@ -481,7 +481,7 @@ void CFuncTank::TrackTarget( void )
edict_t *pTarget;
// Get a position to aim for
if (m_pController)
if( m_pController )
{
// Tanks attempt to mirror the player's angles
angles = m_pController->pev->v_angle;
@ -490,39 +490,39 @@ void CFuncTank::TrackTarget( void )
}
else
{
if ( IsActive() )
if( IsActive() )
pev->nextthink = pev->ltime + 0.1;
else
return;
if ( FNullEnt( pPlayer ) )
if( FNullEnt( pPlayer ) )
{
if ( IsActive() )
if( IsActive() )
pev->nextthink = pev->ltime + 2; // Wait 2 secs
return;
}
pTarget = FindTarget( pPlayer );
if ( !pTarget )
if( !pTarget )
return;
// Calculate angle needed to aim at target
barrelEnd = BarrelPosition();
targetPosition = pTarget->v.origin + pTarget->v.view_ofs;
float range = (targetPosition - barrelEnd).Length();
float range = ( targetPosition - barrelEnd ).Length();
if ( !InRange( range ) )
if( !InRange( range ) )
return;
UTIL_TraceLine( barrelEnd, targetPosition, dont_ignore_monsters, edict(), &tr );
lineOfSight = FALSE;
// No line of sight, don't track
if ( tr.flFraction == 1.0 || tr.pHit == pTarget )
if( tr.flFraction == 1.0 || tr.pHit == pTarget )
{
lineOfSight = TRUE;
CBaseEntity *pInstance = CBaseEntity::Instance(pTarget);
if ( InRange( range ) && pInstance && pInstance->IsAlive() )
if( InRange( range ) && pInstance && pInstance->IsAlive() )
{
updateTime = TRUE;
m_sightOrigin = UpdateTargetPosition( pInstance );
@ -546,63 +546,63 @@ void CFuncTank::TrackTarget( void )
angles.x = m_pitchCenter + UTIL_AngleDistance( angles.x, m_pitchCenter );
// Limit against range in y
if ( angles.y > m_yawCenter + m_yawRange )
if( angles.y > m_yawCenter + m_yawRange )
{
angles.y = m_yawCenter + m_yawRange;
updateTime = FALSE; // Don't update if you saw the player, but out of range
}
else if ( angles.y < (m_yawCenter - m_yawRange) )
else if( angles.y < ( m_yawCenter - m_yawRange ) )
{
angles.y = (m_yawCenter - m_yawRange);
angles.y = ( m_yawCenter - m_yawRange );
updateTime = FALSE; // Don't update if you saw the player, but out of range
}
if ( updateTime )
if( updateTime )
m_lastSightTime = gpGlobals->time;
// Move toward target at rate or less
float distY = UTIL_AngleDistance( angles.y, pev->angles.y );
pev->avelocity.y = distY * 10;
if ( pev->avelocity.y > m_yawRate )
if( pev->avelocity.y > m_yawRate )
pev->avelocity.y = m_yawRate;
else if ( pev->avelocity.y < -m_yawRate )
else if( pev->avelocity.y < -m_yawRate )
pev->avelocity.y = -m_yawRate;
// Limit against range in x
if ( angles.x > m_pitchCenter + m_pitchRange )
if( angles.x > m_pitchCenter + m_pitchRange )
angles.x = m_pitchCenter + m_pitchRange;
else if ( angles.x < m_pitchCenter - m_pitchRange )
else if( angles.x < m_pitchCenter - m_pitchRange )
angles.x = m_pitchCenter - m_pitchRange;
// Move toward target at rate or less
float distX = UTIL_AngleDistance( angles.x, pev->angles.x );
pev->avelocity.x = distX * 10;
if ( pev->avelocity.x > m_pitchRate )
if( pev->avelocity.x > m_pitchRate )
pev->avelocity.x = m_pitchRate;
else if ( pev->avelocity.x < -m_pitchRate )
else if( pev->avelocity.x < -m_pitchRate )
pev->avelocity.x = -m_pitchRate;
if ( m_pController )
if( m_pController )
return;
if ( CanFire() && ( (fabs(distX) < m_pitchTolerance && fabs(distY) < m_yawTolerance) || (pev->spawnflags & SF_TANK_LINEOFSIGHT) ) )
if( CanFire() && ( ( fabs( distX ) < m_pitchTolerance && fabs( distY ) < m_yawTolerance ) || ( pev->spawnflags & SF_TANK_LINEOFSIGHT ) ) )
{
BOOL fire = FALSE;
Vector forward;
UTIL_MakeVectorsPrivate( pev->angles, forward, NULL, NULL );
if ( pev->spawnflags & SF_TANK_LINEOFSIGHT )
if( pev->spawnflags & SF_TANK_LINEOFSIGHT )
{
float length = direction.Length();
UTIL_TraceLine( barrelEnd, barrelEnd + forward * length, dont_ignore_monsters, edict(), &tr );
if ( tr.pHit == pTarget )
if( tr.pHit == pTarget )
fire = TRUE;
}
else
fire = TRUE;
if ( fire )
if( fire )
{
Fire( BarrelPosition(), forward, pev );
}
@ -618,20 +618,19 @@ void CFuncTank::AdjustAnglesForBarrel( Vector &angles, float distance )
{
float r2, d2;
if ( m_barrelPos.y != 0 || m_barrelPos.z != 0 )
if( m_barrelPos.y != 0 || m_barrelPos.z != 0 )
{
distance -= m_barrelPos.z;
d2 = distance * distance;
if ( m_barrelPos.y )
if( m_barrelPos.y )
{
r2 = m_barrelPos.y * m_barrelPos.y;
angles.y += (180.0 / M_PI) * atan2( m_barrelPos.y, sqrt( d2 - r2 ) );
angles.y += ( 180.0 / M_PI ) * atan2( m_barrelPos.y, sqrt( d2 - r2 ) );
}
if ( m_barrelPos.z )
if( m_barrelPos.z )
{
r2 = m_barrelPos.z * m_barrelPos.z;
angles.x += (180.0 / M_PI) * atan2( -m_barrelPos.z, sqrt( d2 - r2 ) );
angles.x += ( 180.0 / M_PI ) * atan2( -m_barrelPos.z, sqrt( d2 - r2 ) );
}
}
}
@ -639,19 +638,19 @@ void CFuncTank::AdjustAnglesForBarrel( Vector &angles, float distance )
// Fire targets and spawn sprites
void CFuncTank::Fire( const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker )
{
if ( m_fireLast != 0 )
if( m_fireLast != 0 )
{
if ( m_iszSpriteSmoke )
if( m_iszSpriteSmoke )
{
CSprite *pSprite = CSprite::SpriteCreate( STRING(m_iszSpriteSmoke), barrelEnd, TRUE );
CSprite *pSprite = CSprite::SpriteCreate( STRING( m_iszSpriteSmoke ), barrelEnd, TRUE );
pSprite->AnimateAndDie( RANDOM_FLOAT( 15.0, 20.0 ) );
pSprite->SetTransparency( kRenderTransAlpha, pev->rendercolor.x, pev->rendercolor.y, pev->rendercolor.z, 255, kRenderFxNone );
pSprite->pev->velocity.z = RANDOM_FLOAT(40, 80);
pSprite->pev->velocity.z = RANDOM_FLOAT( 40, 80 );
pSprite->SetScale( m_spriteScale );
}
if ( m_iszSpriteFlash )
if( m_iszSpriteFlash )
{
CSprite *pSprite = CSprite::SpriteCreate( STRING(m_iszSpriteFlash), barrelEnd, TRUE );
CSprite *pSprite = CSprite::SpriteCreate( STRING( m_iszSpriteFlash ), barrelEnd, TRUE );
pSprite->AnimateAndDie( 60 );
pSprite->SetTransparency( kRenderTransAdd, 255, 255, 255, 255, kRenderFxNoDissipation );
pSprite->SetScale( m_spriteScale );
@ -668,11 +667,12 @@ void CFuncTank::TankTrace( const Vector &vecStart, const Vector &vecForward, con
{
// get circular gaussian spread
float x, y, z;
do {
x = RANDOM_FLOAT(-0.5,0.5) + RANDOM_FLOAT(-0.5,0.5);
y = RANDOM_FLOAT(-0.5,0.5) + RANDOM_FLOAT(-0.5,0.5);
z = x*x+y*y;
} while (z > 1);
do
{
x = RANDOM_FLOAT( -0.5, 0.5 ) + RANDOM_FLOAT( -0.5, 0.5 );
y = RANDOM_FLOAT( -0.5, 0.5 ) + RANDOM_FLOAT( -0.5, 0.5 );
z = x * x + y * y;
} while( z > 1 );
Vector vecDir = vecForward +
x * vecSpread.x * gpGlobals->v_right +
y * vecSpread.y * gpGlobals->v_up;
@ -684,16 +684,16 @@ void CFuncTank::TankTrace( const Vector &vecStart, const Vector &vecForward, con
void CFuncTank::StartRotSound( void )
{
if ( !pev->noise || (pev->spawnflags & SF_TANK_SOUNDON) )
if( !pev->noise || ( pev->spawnflags & SF_TANK_SOUNDON ) )
return;
pev->spawnflags |= SF_TANK_SOUNDON;
EMIT_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noise), 0.85, ATTN_NORM);
EMIT_SOUND( edict(), CHAN_STATIC, (char*)STRING( pev->noise ), 0.85, ATTN_NORM );
}
void CFuncTank::StopRotSound( void )
{
if ( pev->spawnflags & SF_TANK_SOUNDON )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noise) );
if( pev->spawnflags & SF_TANK_SOUNDON )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING( pev->noise ) );
pev->spawnflags &= ~SF_TANK_SOUNDON;
}
@ -709,30 +709,27 @@ void CFuncTankGun::Fire( const Vector &barrelEnd, const Vector &forward, entvars
{
int i;
if ( m_fireLast != 0 )
if( m_fireLast != 0 )
{
// FireBullets needs gpGlobals->v_up, etc.
UTIL_MakeAimVectors(pev->angles);
UTIL_MakeAimVectors( pev->angles );
int bulletCount = (gpGlobals->time - m_fireLast) * m_fireRate;
if ( bulletCount > 0 )
int bulletCount = ( gpGlobals->time - m_fireLast ) * m_fireRate;
if( bulletCount > 0 )
{
for ( i = 0; i < bulletCount; i++ )
for( i = 0; i < bulletCount; i++ )
{
switch( m_bulletType )
{
case TANK_BULLET_9MM:
FireBullets( 1, barrelEnd, forward, gTankSpread[m_spread], 4096, BULLET_MONSTER_9MM, 1, m_iBulletDamage, pevAttacker );
break;
case TANK_BULLET_MP5:
FireBullets( 1, barrelEnd, forward, gTankSpread[m_spread], 4096, BULLET_MONSTER_MP5, 1, m_iBulletDamage, pevAttacker );
break;
case TANK_BULLET_12MM:
FireBullets( 1, barrelEnd, forward, gTankSpread[m_spread], 4096, BULLET_MONSTER_12MM, 1, m_iBulletDamage, pevAttacker );
break;
default:
case TANK_BULLET_NONE:
break;
@ -775,9 +772,9 @@ IMPLEMENT_SAVERESTORE( CFuncTankLaser, CFuncTank )
void CFuncTankLaser::Activate( void )
{
if ( !GetLaser() )
if( !GetLaser() )
{
UTIL_Remove(this);
UTIL_Remove( this );
ALERT( at_error, "Laser tank with no env_laser!\n" );
}
else
@ -788,9 +785,9 @@ void CFuncTankLaser::Activate( void )
void CFuncTankLaser::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "laserentity"))
if( FStrEq( pkvd->szKeyName, "laserentity" ) )
{
pev->message = ALLOC_STRING(pkvd->szValue);
pev->message = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -799,22 +796,22 @@ void CFuncTankLaser::KeyValue( KeyValueData *pkvd )
CLaser *CFuncTankLaser::GetLaser( void )
{
if ( m_pLaser )
if( m_pLaser )
return m_pLaser;
edict_t *pentLaser;
pentLaser = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(pev->message) );
while ( !FNullEnt( pentLaser ) )
pentLaser = FIND_ENTITY_BY_TARGETNAME( NULL, STRING( pev->message ) );
while( !FNullEnt( pentLaser ) )
{
// Found the landmark
if ( FClassnameIs( pentLaser, "env_laser" ) )
if( FClassnameIs( pentLaser, "env_laser" ) )
{
m_pLaser = (CLaser *)CBaseEntity::Instance(pentLaser);
m_pLaser = (CLaser *)CBaseEntity::Instance( pentLaser );
break;
}
else
pentLaser = FIND_ENTITY_BY_TARGETNAME( pentLaser, STRING(pev->message) );
pentLaser = FIND_ENTITY_BY_TARGETNAME( pentLaser, STRING( pev->message ) );
}
return m_pLaser;
@ -822,7 +819,7 @@ CLaser *CFuncTankLaser::GetLaser( void )
void CFuncTankLaser::Think( void )
{
if ( m_pLaser && (gpGlobals->time > m_laserTime) )
if( m_pLaser && (gpGlobals->time > m_laserTime) )
m_pLaser->TurnOff();
CFuncTank::Think();
@ -833,15 +830,15 @@ void CFuncTankLaser::Fire( const Vector &barrelEnd, const Vector &forward, entva
int i;
TraceResult tr;
if ( m_fireLast != 0 && GetLaser() )
if( m_fireLast != 0 && GetLaser() )
{
// TankTrace needs gpGlobals->v_up, etc.
UTIL_MakeAimVectors(pev->angles);
UTIL_MakeAimVectors( pev->angles );
int bulletCount = (gpGlobals->time - m_fireLast) * m_fireRate;
if ( bulletCount )
int bulletCount = ( gpGlobals->time - m_fireLast ) * m_fireRate;
if( bulletCount )
{
for ( i = 0; i < bulletCount; i++ )
for( i = 0; i < bulletCount; i++ )
{
m_pLaser->pev->origin = barrelEnd;
TankTrace( barrelEnd, forward, gTankSpread[m_spread], tr );
@ -880,12 +877,12 @@ void CFuncTankRocket::Fire( const Vector &barrelEnd, const Vector &forward, entv
{
int i;
if ( m_fireLast != 0 )
if( m_fireLast != 0 )
{
int bulletCount = (gpGlobals->time - m_fireLast) * m_fireRate;
if ( bulletCount > 0 )
int bulletCount = ( gpGlobals->time - m_fireLast ) * m_fireRate;
if( bulletCount > 0 )
{
for ( i = 0; i < bulletCount; i++ )
for( i = 0; i < bulletCount; i++ )
{
CBaseEntity *pRocket = CBaseEntity::Create( "rpg_rocket", barrelEnd, pev->angles, edict() );
}
@ -907,7 +904,7 @@ LINK_ENTITY_TO_CLASS( func_tankmortar, CFuncTankMortar )
void CFuncTankMortar::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "iMagnitude"))
if( FStrEq( pkvd->szKeyName, "iMagnitude" ) )
{
pev->impulse = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
@ -918,16 +915,16 @@ void CFuncTankMortar::KeyValue( KeyValueData *pkvd )
void CFuncTankMortar::Fire( const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker )
{
if ( m_fireLast != 0 )
if( m_fireLast != 0 )
{
int bulletCount = (gpGlobals->time - m_fireLast) * m_fireRate;
int bulletCount = ( gpGlobals->time - m_fireLast ) * m_fireRate;
// Only create 1 explosion
if ( bulletCount > 0 )
if( bulletCount > 0 )
{
TraceResult tr;
// TankTrace needs gpGlobals->v_up, etc.
UTIL_MakeAimVectors(pev->angles);
UTIL_MakeAimVectors( pev->angles );
TankTrace( barrelEnd, forward, gTankSpread[m_spread], tr );
@ -967,36 +964,36 @@ TYPEDESCRIPTION CFuncTankControls::m_SaveData[] =
IMPLEMENT_SAVERESTORE( CFuncTankControls, CBaseEntity )
int CFuncTankControls :: ObjectCaps( void )
int CFuncTankControls::ObjectCaps( void )
{
return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_IMPULSE_USE;
return ( CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION ) | FCAP_IMPULSE_USE;
}
void CFuncTankControls :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CFuncTankControls::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// pass the Use command onto the controls
if ( m_pTank )
if( m_pTank )
m_pTank->Use( pActivator, pCaller, useType, value );
ASSERT( m_pTank != NULL ); // if this fails, most likely means save/restore hasn't worked properly
}
void CFuncTankControls :: Think( void )
void CFuncTankControls::Think( void )
{
edict_t *pTarget = NULL;
do
{
pTarget = FIND_ENTITY_BY_TARGETNAME( pTarget, STRING(pev->target) );
} while ( !FNullEnt(pTarget) && strncmp( STRING(pTarget->v.classname), "func_tank", 9 ) );
pTarget = FIND_ENTITY_BY_TARGETNAME( pTarget, STRING( pev->target ) );
} while( !FNullEnt( pTarget ) && strncmp( STRING( pTarget->v.classname ), "func_tank", 9 ) );
if ( FNullEnt( pTarget ) )
if( FNullEnt( pTarget ) )
{
ALERT( at_console, "No tank %s\n", STRING(pev->target) );
ALERT( at_console, "No tank %s\n", STRING( pev->target ) );
return;
}
m_pTank = (CFuncTank*)Instance(pTarget);
m_pTank = (CFuncTank*)Instance( pTarget );
}
void CFuncTankControls::Spawn( void )
@ -1004,7 +1001,7 @@ void CFuncTankControls::Spawn( void )
pev->solid = SOLID_TRIGGER;
pev->movetype = MOVETYPE_NONE;
pev->effects |= EF_NODRAW;
SET_MODEL( ENT(pev), STRING(pev->model) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
UTIL_SetSize( pev, pev->mins, pev->maxs );
UTIL_SetOrigin( pev, pev->origin );

603
dlls/game.cpp
View File

@ -20,26 +20,26 @@
cvar_t displaysoundlist = {"displaysoundlist","0"};
// multiplayer server rules
cvar_t fragsleft = {"mp_fragsleft","0", FCVAR_SERVER | FCVAR_UNLOGGED }; // Don't spam console/log files/users with this changing
cvar_t timeleft = {"mp_timeleft","0" , FCVAR_SERVER | FCVAR_UNLOGGED }; // " "
cvar_t fragsleft = { "mp_fragsleft","0", FCVAR_SERVER | FCVAR_UNLOGGED }; // Don't spam console/log files/users with this changing
cvar_t timeleft = { "mp_timeleft","0" , FCVAR_SERVER | FCVAR_UNLOGGED }; // " "
// multiplayer server rules
cvar_t teamplay = {"mp_teamplay","0", FCVAR_SERVER };
cvar_t teamplay = { "mp_teamplay","0", FCVAR_SERVER };
cvar_t fraglimit = {"mp_fraglimit","0", FCVAR_SERVER };
cvar_t timelimit = {"mp_timelimit","0", FCVAR_SERVER };
cvar_t friendlyfire= {"mp_friendlyfire","0", FCVAR_SERVER };
cvar_t falldamage = {"mp_falldamage","0", FCVAR_SERVER };
cvar_t weaponstay = {"mp_weaponstay","0", FCVAR_SERVER };
cvar_t forcerespawn= {"mp_forcerespawn","1", FCVAR_SERVER };
cvar_t flashlight = {"mp_flashlight","0", FCVAR_SERVER };
cvar_t aimcrosshair= {"mp_autocrosshair","1", FCVAR_SERVER };
cvar_t decalfrequency = {"decalfrequency","30", FCVAR_SERVER };
cvar_t teamlist = {"mp_teamlist","hgrunt;scientist", FCVAR_SERVER };
cvar_t teamoverride = {"mp_teamoverride","1" };
cvar_t defaultteam = {"mp_defaultteam","0" };
cvar_t allowmonsters={"mp_allowmonsters","0", FCVAR_SERVER };
cvar_t timelimit = { "mp_timelimit","0", FCVAR_SERVER };
cvar_t friendlyfire = { "mp_friendlyfire","0", FCVAR_SERVER };
cvar_t falldamage = { "mp_falldamage","0", FCVAR_SERVER };
cvar_t weaponstay = { "mp_weaponstay","0", FCVAR_SERVER };
cvar_t forcerespawn = { "mp_forcerespawn","1", FCVAR_SERVER };
cvar_t flashlight = { "mp_flashlight","0", FCVAR_SERVER };
cvar_t aimcrosshair = { "mp_autocrosshair","1", FCVAR_SERVER };
cvar_t decalfrequency = { "decalfrequency","30", FCVAR_SERVER };
cvar_t teamlist = { "mp_teamlist","hgrunt;scientist", FCVAR_SERVER };
cvar_t teamoverride = { "mp_teamoverride","1" };
cvar_t defaultteam = { "mp_defaultteam","0" };
cvar_t allowmonsters = { "mp_allowmonsters","0", FCVAR_SERVER };
cvar_t mp_chattime = {"mp_chattime","10", FCVAR_SERVER };
cvar_t mp_chattime = { "mp_chattime","10", FCVAR_SERVER };
// Engine Cvars
cvar_t *g_psv_gravity = NULL;
@ -230,7 +230,6 @@ cvar_t sk_scientist_health1 = {"sk_scientist_health1","0"};
cvar_t sk_scientist_health2 = {"sk_scientist_health2","0"};
cvar_t sk_scientist_health3 = {"sk_scientist_health3","0"};
// Snark
cvar_t sk_snark_health1 = {"sk_snark_health1","0"};
cvar_t sk_snark_health2 = {"sk_snark_health2","0"};
@ -244,8 +243,6 @@ cvar_t sk_snark_dmg_pop1 = {"sk_snark_dmg_pop1","0"};
cvar_t sk_snark_dmg_pop2 = {"sk_snark_dmg_pop2","0"};
cvar_t sk_snark_dmg_pop3 = {"sk_snark_dmg_pop3","0"};
// Zombie
cvar_t sk_zombie_health1 = {"sk_zombie_health1","0"};
cvar_t sk_zombie_health2 = {"sk_zombie_health2","0"};
@ -259,25 +256,21 @@ cvar_t sk_zombie_dmg_both_slash1 = {"sk_zombie_dmg_both_slash1","0"};
cvar_t sk_zombie_dmg_both_slash2 = {"sk_zombie_dmg_both_slash2","0"};
cvar_t sk_zombie_dmg_both_slash3 = {"sk_zombie_dmg_both_slash3","0"};
//Turret
cvar_t sk_turret_health1 = {"sk_turret_health1","0"};
cvar_t sk_turret_health2 = {"sk_turret_health2","0"};
cvar_t sk_turret_health3 = {"sk_turret_health3","0"};
// MiniTurret
cvar_t sk_miniturret_health1 = {"sk_miniturret_health1","0"};
cvar_t sk_miniturret_health2 = {"sk_miniturret_health2","0"};
cvar_t sk_miniturret_health3 = {"sk_miniturret_health3","0"};
// Sentry Turret
cvar_t sk_sentry_health1 = {"sk_sentry_health1","0"};
cvar_t sk_sentry_health2 = {"sk_sentry_health2","0"};
cvar_t sk_sentry_health3 = {"sk_sentry_health3","0"};
// PLAYER WEAPONS
// Crowbar whack
@ -458,428 +451,402 @@ void GameDLLInit( void )
g_psv_aim = CVAR_GET_POINTER( "sv_aim" );
g_footsteps = CVAR_GET_POINTER( "mp_footsteps" );
CVAR_REGISTER (&displaysoundlist);
CVAR_REGISTER( &displaysoundlist );
CVAR_REGISTER (&teamplay);
CVAR_REGISTER (&fraglimit);
CVAR_REGISTER (&timelimit);
CVAR_REGISTER( &teamplay );
CVAR_REGISTER( &fraglimit );
CVAR_REGISTER( &timelimit );
CVAR_REGISTER (&fragsleft);
CVAR_REGISTER (&timeleft);
CVAR_REGISTER( &fragsleft );
CVAR_REGISTER( &timeleft );
CVAR_REGISTER (&friendlyfire);
CVAR_REGISTER (&falldamage);
CVAR_REGISTER (&weaponstay);
CVAR_REGISTER (&forcerespawn);
CVAR_REGISTER (&flashlight);
CVAR_REGISTER (&aimcrosshair);
CVAR_REGISTER (&decalfrequency);
CVAR_REGISTER (&teamlist);
CVAR_REGISTER (&teamoverride);
CVAR_REGISTER (&defaultteam);
CVAR_REGISTER (&allowmonsters);
CVAR_REGISTER( &friendlyfire );
CVAR_REGISTER( &falldamage );
CVAR_REGISTER( &weaponstay );
CVAR_REGISTER( &forcerespawn );
CVAR_REGISTER( &flashlight );
CVAR_REGISTER( &aimcrosshair );
CVAR_REGISTER( &decalfrequency );
CVAR_REGISTER( &teamlist );
CVAR_REGISTER( &teamoverride );
CVAR_REGISTER( &defaultteam );
CVAR_REGISTER( &allowmonsters );
CVAR_REGISTER (&mp_chattime);
CVAR_REGISTER( &mp_chattime );
// REGISTER CVARS FOR SKILL LEVEL STUFF
// Agrunt
CVAR_REGISTER ( &sk_agrunt_health1 );// {"sk_agrunt_health1","0"};
CVAR_REGISTER ( &sk_agrunt_health2 );// {"sk_agrunt_health2","0"};
CVAR_REGISTER ( &sk_agrunt_health3 );// {"sk_agrunt_health3","0"};
CVAR_REGISTER( &sk_agrunt_health1 );// {"sk_agrunt_health1","0"};
CVAR_REGISTER( &sk_agrunt_health2 );// {"sk_agrunt_health2","0"};
CVAR_REGISTER( &sk_agrunt_health3 );// {"sk_agrunt_health3","0"};
CVAR_REGISTER ( &sk_agrunt_dmg_punch1 );// {"sk_agrunt_dmg_punch1","0"};
CVAR_REGISTER ( &sk_agrunt_dmg_punch2 );// {"sk_agrunt_dmg_punch2","0"};
CVAR_REGISTER ( &sk_agrunt_dmg_punch3 );// {"sk_agrunt_dmg_punch3","0"};
CVAR_REGISTER( &sk_agrunt_dmg_punch1 );// {"sk_agrunt_dmg_punch1","0"};
CVAR_REGISTER( &sk_agrunt_dmg_punch2 );// {"sk_agrunt_dmg_punch2","0"};
CVAR_REGISTER( &sk_agrunt_dmg_punch3 );// {"sk_agrunt_dmg_punch3","0"};
// Apache
CVAR_REGISTER ( &sk_apache_health1 );// {"sk_apache_health1","0"};
CVAR_REGISTER ( &sk_apache_health2 );// {"sk_apache_health2","0"};
CVAR_REGISTER ( &sk_apache_health3 );// {"sk_apache_health3","0"};
CVAR_REGISTER( &sk_apache_health1 );// {"sk_apache_health1","0"};
CVAR_REGISTER( &sk_apache_health2 );// {"sk_apache_health2","0"};
CVAR_REGISTER( &sk_apache_health3 );// {"sk_apache_health3","0"};
// Barney
CVAR_REGISTER ( &sk_barney_health1 );// {"sk_barney_health1","0"};
CVAR_REGISTER ( &sk_barney_health2 );// {"sk_barney_health2","0"};
CVAR_REGISTER ( &sk_barney_health3 );// {"sk_barney_health3","0"};
CVAR_REGISTER( &sk_barney_health1 );// {"sk_barney_health1","0"};
CVAR_REGISTER( &sk_barney_health2 );// {"sk_barney_health2","0"};
CVAR_REGISTER( &sk_barney_health3 );// {"sk_barney_health3","0"};
// Bullsquid
CVAR_REGISTER ( &sk_bullsquid_health1 );// {"sk_bullsquid_health1","0"};
CVAR_REGISTER ( &sk_bullsquid_health2 );// {"sk_bullsquid_health2","0"};
CVAR_REGISTER ( &sk_bullsquid_health3 );// {"sk_bullsquid_health3","0"};
CVAR_REGISTER( &sk_bullsquid_health1 );// {"sk_bullsquid_health1","0"};
CVAR_REGISTER( &sk_bullsquid_health2 );// {"sk_bullsquid_health2","0"};
CVAR_REGISTER( &sk_bullsquid_health3 );// {"sk_bullsquid_health3","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_bite1 );// {"sk_bullsquid_dmg_bite1","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_bite2 );// {"sk_bullsquid_dmg_bite2","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_bite3 );// {"sk_bullsquid_dmg_bite3","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_bite1 );// {"sk_bullsquid_dmg_bite1","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_bite2 );// {"sk_bullsquid_dmg_bite2","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_bite3 );// {"sk_bullsquid_dmg_bite3","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_whip1 );// {"sk_bullsquid_dmg_whip1","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_whip2 );// {"sk_bullsquid_dmg_whip2","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_whip3 );// {"sk_bullsquid_dmg_whip3","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_whip1 );// {"sk_bullsquid_dmg_whip1","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_whip2 );// {"sk_bullsquid_dmg_whip2","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_whip3 );// {"sk_bullsquid_dmg_whip3","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_spit1 );// {"sk_bullsquid_dmg_spit1","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_spit2 );// {"sk_bullsquid_dmg_spit2","0"};
CVAR_REGISTER ( &sk_bullsquid_dmg_spit3 );// {"sk_bullsquid_dmg_spit3","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_spit1 );// {"sk_bullsquid_dmg_spit1","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_spit2 );// {"sk_bullsquid_dmg_spit2","0"};
CVAR_REGISTER( &sk_bullsquid_dmg_spit3 );// {"sk_bullsquid_dmg_spit3","0"};
CVAR_REGISTER( &sk_bigmomma_health_factor1 );// {"sk_bigmomma_health_factor1","1.0"};
CVAR_REGISTER( &sk_bigmomma_health_factor2 );// {"sk_bigmomma_health_factor2","1.0"};
CVAR_REGISTER( &sk_bigmomma_health_factor3 );// {"sk_bigmomma_health_factor3","1.0"};
CVAR_REGISTER ( &sk_bigmomma_health_factor1 );// {"sk_bigmomma_health_factor1","1.0"};
CVAR_REGISTER ( &sk_bigmomma_health_factor2 );// {"sk_bigmomma_health_factor2","1.0"};
CVAR_REGISTER ( &sk_bigmomma_health_factor3 );// {"sk_bigmomma_health_factor3","1.0"};
CVAR_REGISTER( &sk_bigmomma_dmg_slash1 );// {"sk_bigmomma_dmg_slash1","50"};
CVAR_REGISTER( &sk_bigmomma_dmg_slash2 );// {"sk_bigmomma_dmg_slash2","50"};
CVAR_REGISTER( &sk_bigmomma_dmg_slash3 );// {"sk_bigmomma_dmg_slash3","50"};
CVAR_REGISTER ( &sk_bigmomma_dmg_slash1 );// {"sk_bigmomma_dmg_slash1","50"};
CVAR_REGISTER ( &sk_bigmomma_dmg_slash2 );// {"sk_bigmomma_dmg_slash2","50"};
CVAR_REGISTER ( &sk_bigmomma_dmg_slash3 );// {"sk_bigmomma_dmg_slash3","50"};
CVAR_REGISTER( &sk_bigmomma_dmg_blast1 );// {"sk_bigmomma_dmg_blast1","100"};
CVAR_REGISTER( &sk_bigmomma_dmg_blast2 );// {"sk_bigmomma_dmg_blast2","100"};
CVAR_REGISTER( &sk_bigmomma_dmg_blast3 );// {"sk_bigmomma_dmg_blast3","100"};
CVAR_REGISTER ( &sk_bigmomma_dmg_blast1 );// {"sk_bigmomma_dmg_blast1","100"};
CVAR_REGISTER ( &sk_bigmomma_dmg_blast2 );// {"sk_bigmomma_dmg_blast2","100"};
CVAR_REGISTER ( &sk_bigmomma_dmg_blast3 );// {"sk_bigmomma_dmg_blast3","100"};
CVAR_REGISTER ( &sk_bigmomma_radius_blast1 );// {"sk_bigmomma_radius_blast1","250"};
CVAR_REGISTER ( &sk_bigmomma_radius_blast2 );// {"sk_bigmomma_radius_blast2","250"};
CVAR_REGISTER ( &sk_bigmomma_radius_blast3 );// {"sk_bigmomma_radius_blast3","250"};
CVAR_REGISTER( &sk_bigmomma_radius_blast1 );// {"sk_bigmomma_radius_blast1","250"};
CVAR_REGISTER( &sk_bigmomma_radius_blast2 );// {"sk_bigmomma_radius_blast2","250"};
CVAR_REGISTER( &sk_bigmomma_radius_blast3 );// {"sk_bigmomma_radius_blast3","250"};
// Gargantua
CVAR_REGISTER ( &sk_gargantua_health1 );// {"sk_gargantua_health1","0"};
CVAR_REGISTER ( &sk_gargantua_health2 );// {"sk_gargantua_health2","0"};
CVAR_REGISTER ( &sk_gargantua_health3 );// {"sk_gargantua_health3","0"};
CVAR_REGISTER( &sk_gargantua_health1 );// {"sk_gargantua_health1","0"};
CVAR_REGISTER( &sk_gargantua_health2 );// {"sk_gargantua_health2","0"};
CVAR_REGISTER( &sk_gargantua_health3 );// {"sk_gargantua_health3","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_slash1 );// {"sk_gargantua_dmg_slash1","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_slash2 );// {"sk_gargantua_dmg_slash2","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_slash3 );// {"sk_gargantua_dmg_slash3","0"};
CVAR_REGISTER( &sk_gargantua_dmg_slash1 );// {"sk_gargantua_dmg_slash1","0"};
CVAR_REGISTER( &sk_gargantua_dmg_slash2 );// {"sk_gargantua_dmg_slash2","0"};
CVAR_REGISTER( &sk_gargantua_dmg_slash3 );// {"sk_gargantua_dmg_slash3","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_fire1 );// {"sk_gargantua_dmg_fire1","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_fire2 );// {"sk_gargantua_dmg_fire2","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_fire3 );// {"sk_gargantua_dmg_fire3","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_stomp1 );// {"sk_gargantua_dmg_stomp1","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_stomp2 );// {"sk_gargantua_dmg_stomp2","0"};
CVAR_REGISTER ( &sk_gargantua_dmg_stomp3 );// {"sk_gargantua_dmg_stomp3","0"};
CVAR_REGISTER( &sk_gargantua_dmg_fire1 );// {"sk_gargantua_dmg_fire1","0"};
CVAR_REGISTER( &sk_gargantua_dmg_fire2 );// {"sk_gargantua_dmg_fire2","0"};
CVAR_REGISTER( &sk_gargantua_dmg_fire3 );// {"sk_gargantua_dmg_fire3","0"};
CVAR_REGISTER( &sk_gargantua_dmg_stomp1 );// {"sk_gargantua_dmg_stomp1","0"};
CVAR_REGISTER( &sk_gargantua_dmg_stomp2 );// {"sk_gargantua_dmg_stomp2","0"};
CVAR_REGISTER( &sk_gargantua_dmg_stomp3 );// {"sk_gargantua_dmg_stomp3","0"};
// Hassassin
CVAR_REGISTER ( &sk_hassassin_health1 );// {"sk_hassassin_health1","0"};
CVAR_REGISTER ( &sk_hassassin_health2 );// {"sk_hassassin_health2","0"};
CVAR_REGISTER ( &sk_hassassin_health3 );// {"sk_hassassin_health3","0"};
CVAR_REGISTER( &sk_hassassin_health1 );// {"sk_hassassin_health1","0"};
CVAR_REGISTER( &sk_hassassin_health2 );// {"sk_hassassin_health2","0"};
CVAR_REGISTER( &sk_hassassin_health3 );// {"sk_hassassin_health3","0"};
// Headcrab
CVAR_REGISTER ( &sk_headcrab_health1 );// {"sk_headcrab_health1","0"};
CVAR_REGISTER ( &sk_headcrab_health2 );// {"sk_headcrab_health2","0"};
CVAR_REGISTER ( &sk_headcrab_health3 );// {"sk_headcrab_health3","0"};
CVAR_REGISTER ( &sk_headcrab_dmg_bite1 );// {"sk_headcrab_dmg_bite1","0"};
CVAR_REGISTER ( &sk_headcrab_dmg_bite2 );// {"sk_headcrab_dmg_bite2","0"};
CVAR_REGISTER ( &sk_headcrab_dmg_bite3 );// {"sk_headcrab_dmg_bite3","0"};
CVAR_REGISTER( &sk_headcrab_health1 );// {"sk_headcrab_health1","0"};
CVAR_REGISTER( &sk_headcrab_health2 );// {"sk_headcrab_health2","0"};
CVAR_REGISTER( &sk_headcrab_health3 );// {"sk_headcrab_health3","0"};
CVAR_REGISTER( &sk_headcrab_dmg_bite1 );// {"sk_headcrab_dmg_bite1","0"};
CVAR_REGISTER( &sk_headcrab_dmg_bite2 );// {"sk_headcrab_dmg_bite2","0"};
CVAR_REGISTER( &sk_headcrab_dmg_bite3 );// {"sk_headcrab_dmg_bite3","0"};
// Hgrunt
CVAR_REGISTER ( &sk_hgrunt_health1 );// {"sk_hgrunt_health1","0"};
CVAR_REGISTER ( &sk_hgrunt_health2 );// {"sk_hgrunt_health2","0"};
CVAR_REGISTER ( &sk_hgrunt_health3 );// {"sk_hgrunt_health3","0"};
CVAR_REGISTER( &sk_hgrunt_health1 );// {"sk_hgrunt_health1","0"};
CVAR_REGISTER( &sk_hgrunt_health2 );// {"sk_hgrunt_health2","0"};
CVAR_REGISTER( &sk_hgrunt_health3 );// {"sk_hgrunt_health3","0"};
CVAR_REGISTER ( &sk_hgrunt_kick1 );// {"sk_hgrunt_kick1","0"};
CVAR_REGISTER ( &sk_hgrunt_kick2 );// {"sk_hgrunt_kick2","0"};
CVAR_REGISTER ( &sk_hgrunt_kick3 );// {"sk_hgrunt_kick3","0"};
CVAR_REGISTER( &sk_hgrunt_kick1 );// {"sk_hgrunt_kick1","0"};
CVAR_REGISTER( &sk_hgrunt_kick2 );// {"sk_hgrunt_kick2","0"};
CVAR_REGISTER( &sk_hgrunt_kick3 );// {"sk_hgrunt_kick3","0"};
CVAR_REGISTER ( &sk_hgrunt_pellets1 );
CVAR_REGISTER ( &sk_hgrunt_pellets2 );
CVAR_REGISTER ( &sk_hgrunt_pellets3 );
CVAR_REGISTER( &sk_hgrunt_pellets1 );
CVAR_REGISTER( &sk_hgrunt_pellets2 );
CVAR_REGISTER( &sk_hgrunt_pellets3 );
CVAR_REGISTER ( &sk_hgrunt_gspeed1 );
CVAR_REGISTER ( &sk_hgrunt_gspeed2 );
CVAR_REGISTER ( &sk_hgrunt_gspeed3 );
CVAR_REGISTER( &sk_hgrunt_gspeed1 );
CVAR_REGISTER( &sk_hgrunt_gspeed2 );
CVAR_REGISTER( &sk_hgrunt_gspeed3 );
// Houndeye
CVAR_REGISTER ( &sk_houndeye_health1 );// {"sk_houndeye_health1","0"};
CVAR_REGISTER ( &sk_houndeye_health2 );// {"sk_houndeye_health2","0"};
CVAR_REGISTER ( &sk_houndeye_health3 );// {"sk_houndeye_health3","0"};
CVAR_REGISTER ( &sk_houndeye_dmg_blast1 );// {"sk_houndeye_dmg_blast1","0"};
CVAR_REGISTER ( &sk_houndeye_dmg_blast2 );// {"sk_houndeye_dmg_blast2","0"};
CVAR_REGISTER ( &sk_houndeye_dmg_blast3 );// {"sk_houndeye_dmg_blast3","0"};
CVAR_REGISTER( &sk_houndeye_health1 );// {"sk_houndeye_health1","0"};
CVAR_REGISTER( &sk_houndeye_health2 );// {"sk_houndeye_health2","0"};
CVAR_REGISTER( &sk_houndeye_health3 );// {"sk_houndeye_health3","0"};
CVAR_REGISTER( &sk_houndeye_dmg_blast1 );// {"sk_houndeye_dmg_blast1","0"};
CVAR_REGISTER( &sk_houndeye_dmg_blast2 );// {"sk_houndeye_dmg_blast2","0"};
CVAR_REGISTER( &sk_houndeye_dmg_blast3 );// {"sk_houndeye_dmg_blast3","0"};
// ISlave
CVAR_REGISTER ( &sk_islave_health1 );// {"sk_islave_health1","0"};
CVAR_REGISTER ( &sk_islave_health2 );// {"sk_islave_health2","0"};
CVAR_REGISTER ( &sk_islave_health3 );// {"sk_islave_health3","0"};
CVAR_REGISTER( &sk_islave_health1 );// {"sk_islave_health1","0"};
CVAR_REGISTER( &sk_islave_health2 );// {"sk_islave_health2","0"};
CVAR_REGISTER( &sk_islave_health3 );// {"sk_islave_health3","0"};
CVAR_REGISTER ( &sk_islave_dmg_claw1 );// {"sk_islave_dmg_claw1","0"};
CVAR_REGISTER ( &sk_islave_dmg_claw2 );// {"sk_islave_dmg_claw2","0"};
CVAR_REGISTER ( &sk_islave_dmg_claw3 );// {"sk_islave_dmg_claw3","0"};
CVAR_REGISTER( &sk_islave_dmg_claw1 );// {"sk_islave_dmg_claw1","0"};
CVAR_REGISTER( &sk_islave_dmg_claw2 );// {"sk_islave_dmg_claw2","0"};
CVAR_REGISTER( &sk_islave_dmg_claw3 );// {"sk_islave_dmg_claw3","0"};
CVAR_REGISTER ( &sk_islave_dmg_clawrake1 );// {"sk_islave_dmg_clawrake1","0"};
CVAR_REGISTER ( &sk_islave_dmg_clawrake2 );// {"sk_islave_dmg_clawrake2","0"};
CVAR_REGISTER ( &sk_islave_dmg_clawrake3 );// {"sk_islave_dmg_clawrake3","0"};
CVAR_REGISTER ( &sk_islave_dmg_zap1 );// {"sk_islave_dmg_zap1","0"};
CVAR_REGISTER ( &sk_islave_dmg_zap2 );// {"sk_islave_dmg_zap2","0"};
CVAR_REGISTER ( &sk_islave_dmg_zap3 );// {"sk_islave_dmg_zap3","0"};
CVAR_REGISTER( &sk_islave_dmg_clawrake1 );// {"sk_islave_dmg_clawrake1","0"};
CVAR_REGISTER( &sk_islave_dmg_clawrake2 );// {"sk_islave_dmg_clawrake2","0"};
CVAR_REGISTER( &sk_islave_dmg_clawrake3 );// {"sk_islave_dmg_clawrake3","0"};
CVAR_REGISTER( &sk_islave_dmg_zap1 );// {"sk_islave_dmg_zap1","0"};
CVAR_REGISTER( &sk_islave_dmg_zap2 );// {"sk_islave_dmg_zap2","0"};
CVAR_REGISTER( &sk_islave_dmg_zap3 );// {"sk_islave_dmg_zap3","0"};
// Icthyosaur
CVAR_REGISTER ( &sk_ichthyosaur_health1 );// {"sk_ichthyosaur_health1","0"};
CVAR_REGISTER ( &sk_ichthyosaur_health2 );// {"sk_ichthyosaur_health2","0"};
CVAR_REGISTER ( &sk_ichthyosaur_health3 );// {"sk_ichthyosaur_health3","0"};
CVAR_REGISTER ( &sk_ichthyosaur_shake1 );// {"sk_ichthyosaur_health3","0"};
CVAR_REGISTER ( &sk_ichthyosaur_shake2 );// {"sk_ichthyosaur_health3","0"};
CVAR_REGISTER ( &sk_ichthyosaur_shake3 );// {"sk_ichthyosaur_health3","0"};
CVAR_REGISTER( &sk_ichthyosaur_health1 );// {"sk_ichthyosaur_health1","0"};
CVAR_REGISTER( &sk_ichthyosaur_health2 );// {"sk_ichthyosaur_health2","0"};
CVAR_REGISTER( &sk_ichthyosaur_health3 );// {"sk_ichthyosaur_health3","0"};
CVAR_REGISTER( &sk_ichthyosaur_shake1 );// {"sk_ichthyosaur_health3","0"};
CVAR_REGISTER( &sk_ichthyosaur_shake2 );// {"sk_ichthyosaur_health3","0"};
CVAR_REGISTER( &sk_ichthyosaur_shake3 );// {"sk_ichthyosaur_health3","0"};
// Leech
CVAR_REGISTER ( &sk_leech_health1 );// {"sk_leech_health1","0"};
CVAR_REGISTER ( &sk_leech_health2 );// {"sk_leech_health2","0"};
CVAR_REGISTER ( &sk_leech_health3 );// {"sk_leech_health3","0"};
CVAR_REGISTER ( &sk_leech_dmg_bite1 );// {"sk_leech_dmg_bite1","0"};
CVAR_REGISTER ( &sk_leech_dmg_bite2 );// {"sk_leech_dmg_bite2","0"};
CVAR_REGISTER ( &sk_leech_dmg_bite3 );// {"sk_leech_dmg_bite3","0"};
CVAR_REGISTER( &sk_leech_health1 );// {"sk_leech_health1","0"};
CVAR_REGISTER( &sk_leech_health2 );// {"sk_leech_health2","0"};
CVAR_REGISTER( &sk_leech_health3 );// {"sk_leech_health3","0"};
CVAR_REGISTER( &sk_leech_dmg_bite1 );// {"sk_leech_dmg_bite1","0"};
CVAR_REGISTER( &sk_leech_dmg_bite2 );// {"sk_leech_dmg_bite2","0"};
CVAR_REGISTER( &sk_leech_dmg_bite3 );// {"sk_leech_dmg_bite3","0"};
// Controller
CVAR_REGISTER ( &sk_controller_health1 );
CVAR_REGISTER ( &sk_controller_health2 );
CVAR_REGISTER ( &sk_controller_health3 );
CVAR_REGISTER( &sk_controller_health1 );
CVAR_REGISTER( &sk_controller_health2 );
CVAR_REGISTER( &sk_controller_health3 );
CVAR_REGISTER ( &sk_controller_dmgzap1 );
CVAR_REGISTER ( &sk_controller_dmgzap2 );
CVAR_REGISTER ( &sk_controller_dmgzap3 );
CVAR_REGISTER( &sk_controller_dmgzap1 );
CVAR_REGISTER( &sk_controller_dmgzap2 );
CVAR_REGISTER( &sk_controller_dmgzap3 );
CVAR_REGISTER ( &sk_controller_speedball1 );
CVAR_REGISTER ( &sk_controller_speedball2 );
CVAR_REGISTER ( &sk_controller_speedball3 );
CVAR_REGISTER( &sk_controller_speedball1 );
CVAR_REGISTER( &sk_controller_speedball2 );
CVAR_REGISTER( &sk_controller_speedball3 );
CVAR_REGISTER ( &sk_controller_dmgball1 );
CVAR_REGISTER ( &sk_controller_dmgball2 );
CVAR_REGISTER ( &sk_controller_dmgball3 );
CVAR_REGISTER( &sk_controller_dmgball1 );
CVAR_REGISTER( &sk_controller_dmgball2 );
CVAR_REGISTER( &sk_controller_dmgball3 );
// Nihilanth
CVAR_REGISTER ( &sk_nihilanth_health1 );// {"sk_nihilanth_health1","0"};
CVAR_REGISTER ( &sk_nihilanth_health2 );// {"sk_nihilanth_health2","0"};
CVAR_REGISTER ( &sk_nihilanth_health3 );// {"sk_nihilanth_health3","0"};
CVAR_REGISTER( &sk_nihilanth_health1 );// {"sk_nihilanth_health1","0"};
CVAR_REGISTER( &sk_nihilanth_health2 );// {"sk_nihilanth_health2","0"};
CVAR_REGISTER( &sk_nihilanth_health3 );// {"sk_nihilanth_health3","0"};
CVAR_REGISTER ( &sk_nihilanth_zap1 );
CVAR_REGISTER ( &sk_nihilanth_zap2 );
CVAR_REGISTER ( &sk_nihilanth_zap3 );
CVAR_REGISTER( &sk_nihilanth_zap1 );
CVAR_REGISTER( &sk_nihilanth_zap2 );
CVAR_REGISTER( &sk_nihilanth_zap3 );
// Scientist
CVAR_REGISTER ( &sk_scientist_health1 );// {"sk_scientist_health1","0"};
CVAR_REGISTER ( &sk_scientist_health2 );// {"sk_scientist_health2","0"};
CVAR_REGISTER ( &sk_scientist_health3 );// {"sk_scientist_health3","0"};
CVAR_REGISTER( &sk_scientist_health1 );// {"sk_scientist_health1","0"};
CVAR_REGISTER( &sk_scientist_health2 );// {"sk_scientist_health2","0"};
CVAR_REGISTER( &sk_scientist_health3 );// {"sk_scientist_health3","0"};
// Snark
CVAR_REGISTER ( &sk_snark_health1 );// {"sk_snark_health1","0"};
CVAR_REGISTER ( &sk_snark_health2 );// {"sk_snark_health2","0"};
CVAR_REGISTER ( &sk_snark_health3 );// {"sk_snark_health3","0"};
CVAR_REGISTER ( &sk_snark_dmg_bite1 );// {"sk_snark_dmg_bite1","0"};
CVAR_REGISTER ( &sk_snark_dmg_bite2 );// {"sk_snark_dmg_bite2","0"};
CVAR_REGISTER ( &sk_snark_dmg_bite3 );// {"sk_snark_dmg_bite3","0"};
CVAR_REGISTER ( &sk_snark_dmg_pop1 );// {"sk_snark_dmg_pop1","0"};
CVAR_REGISTER ( &sk_snark_dmg_pop2 );// {"sk_snark_dmg_pop2","0"};
CVAR_REGISTER ( &sk_snark_dmg_pop3 );// {"sk_snark_dmg_pop3","0"};
CVAR_REGISTER( &sk_snark_health1 );// {"sk_snark_health1","0"};
CVAR_REGISTER( &sk_snark_health2 );// {"sk_snark_health2","0"};
CVAR_REGISTER( &sk_snark_health3 );// {"sk_snark_health3","0"};
CVAR_REGISTER( &sk_snark_dmg_bite1 );// {"sk_snark_dmg_bite1","0"};
CVAR_REGISTER( &sk_snark_dmg_bite2 );// {"sk_snark_dmg_bite2","0"};
CVAR_REGISTER( &sk_snark_dmg_bite3 );// {"sk_snark_dmg_bite3","0"};
CVAR_REGISTER( &sk_snark_dmg_pop1 );// {"sk_snark_dmg_pop1","0"};
CVAR_REGISTER( &sk_snark_dmg_pop2 );// {"sk_snark_dmg_pop2","0"};
CVAR_REGISTER( &sk_snark_dmg_pop3 );// {"sk_snark_dmg_pop3","0"};
// Zombie
CVAR_REGISTER ( &sk_zombie_health1 );// {"sk_zombie_health1","0"};
CVAR_REGISTER ( &sk_zombie_health2 );// {"sk_zombie_health3","0"};
CVAR_REGISTER ( &sk_zombie_health3 );// {"sk_zombie_health3","0"};
CVAR_REGISTER( &sk_zombie_health1 );// {"sk_zombie_health1","0"};
CVAR_REGISTER( &sk_zombie_health2 );// {"sk_zombie_health3","0"};
CVAR_REGISTER( &sk_zombie_health3 );// {"sk_zombie_health3","0"};
CVAR_REGISTER ( &sk_zombie_dmg_one_slash1 );// {"sk_zombie_dmg_one_slash1","0"};
CVAR_REGISTER ( &sk_zombie_dmg_one_slash2 );// {"sk_zombie_dmg_one_slash2","0"};
CVAR_REGISTER ( &sk_zombie_dmg_one_slash3 );// {"sk_zombie_dmg_one_slash3","0"};
CVAR_REGISTER ( &sk_zombie_dmg_both_slash1 );// {"sk_zombie_dmg_both_slash1","0"};
CVAR_REGISTER ( &sk_zombie_dmg_both_slash2 );// {"sk_zombie_dmg_both_slash2","0"};
CVAR_REGISTER ( &sk_zombie_dmg_both_slash3 );// {"sk_zombie_dmg_both_slash3","0"};
CVAR_REGISTER( &sk_zombie_dmg_one_slash1 );// {"sk_zombie_dmg_one_slash1","0"};
CVAR_REGISTER( &sk_zombie_dmg_one_slash2 );// {"sk_zombie_dmg_one_slash2","0"};
CVAR_REGISTER( &sk_zombie_dmg_one_slash3 );// {"sk_zombie_dmg_one_slash3","0"};
CVAR_REGISTER( &sk_zombie_dmg_both_slash1 );// {"sk_zombie_dmg_both_slash1","0"};
CVAR_REGISTER( &sk_zombie_dmg_both_slash2 );// {"sk_zombie_dmg_both_slash2","0"};
CVAR_REGISTER( &sk_zombie_dmg_both_slash3 );// {"sk_zombie_dmg_both_slash3","0"};
//Turret
CVAR_REGISTER ( &sk_turret_health1 );// {"sk_turret_health1","0"};
CVAR_REGISTER ( &sk_turret_health2 );// {"sk_turret_health2","0"};
CVAR_REGISTER ( &sk_turret_health3 );// {"sk_turret_health3","0"};
CVAR_REGISTER( &sk_turret_health1 );// {"sk_turret_health1","0"};
CVAR_REGISTER( &sk_turret_health2 );// {"sk_turret_health2","0"};
CVAR_REGISTER( &sk_turret_health3 );// {"sk_turret_health3","0"};
// MiniTurret
CVAR_REGISTER ( &sk_miniturret_health1 );// {"sk_miniturret_health1","0"};
CVAR_REGISTER ( &sk_miniturret_health2 );// {"sk_miniturret_health2","0"};
CVAR_REGISTER ( &sk_miniturret_health3 );// {"sk_miniturret_health3","0"};
CVAR_REGISTER( &sk_miniturret_health1 );// {"sk_miniturret_health1","0"};
CVAR_REGISTER( &sk_miniturret_health2 );// {"sk_miniturret_health2","0"};
CVAR_REGISTER( &sk_miniturret_health3 );// {"sk_miniturret_health3","0"};
// Sentry Turret
CVAR_REGISTER ( &sk_sentry_health1 );// {"sk_sentry_health1","0"};
CVAR_REGISTER ( &sk_sentry_health2 );// {"sk_sentry_health2","0"};
CVAR_REGISTER ( &sk_sentry_health3 );// {"sk_sentry_health3","0"};
CVAR_REGISTER( &sk_sentry_health1 );// {"sk_sentry_health1","0"};
CVAR_REGISTER( &sk_sentry_health2 );// {"sk_sentry_health2","0"};
CVAR_REGISTER( &sk_sentry_health3 );// {"sk_sentry_health3","0"};
// PLAYER WEAPONS
// Crowbar whack
CVAR_REGISTER ( &sk_plr_crowbar1 );// {"sk_plr_crowbar1","0"};
CVAR_REGISTER ( &sk_plr_crowbar2 );// {"sk_plr_crowbar2","0"};
CVAR_REGISTER ( &sk_plr_crowbar3 );// {"sk_plr_crowbar3","0"};
CVAR_REGISTER( &sk_plr_crowbar1 );// {"sk_plr_crowbar1","0"};
CVAR_REGISTER( &sk_plr_crowbar2 );// {"sk_plr_crowbar2","0"};
CVAR_REGISTER( &sk_plr_crowbar3 );// {"sk_plr_crowbar3","0"};
// Glock Round
CVAR_REGISTER ( &sk_plr_9mm_bullet1 );// {"sk_plr_9mm_bullet1","0"};
CVAR_REGISTER ( &sk_plr_9mm_bullet2 );// {"sk_plr_9mm_bullet2","0"};
CVAR_REGISTER ( &sk_plr_9mm_bullet3 );// {"sk_plr_9mm_bullet3","0"};
CVAR_REGISTER( &sk_plr_9mm_bullet1 );// {"sk_plr_9mm_bullet1","0"};
CVAR_REGISTER( &sk_plr_9mm_bullet2 );// {"sk_plr_9mm_bullet2","0"};
CVAR_REGISTER( &sk_plr_9mm_bullet3 );// {"sk_plr_9mm_bullet3","0"};
// 357 Round
CVAR_REGISTER ( &sk_plr_357_bullet1 );// {"sk_plr_357_bullet1","0"};
CVAR_REGISTER ( &sk_plr_357_bullet2 );// {"sk_plr_357_bullet2","0"};
CVAR_REGISTER ( &sk_plr_357_bullet3 );// {"sk_plr_357_bullet3","0"};
CVAR_REGISTER( &sk_plr_357_bullet1 );// {"sk_plr_357_bullet1","0"};
CVAR_REGISTER( &sk_plr_357_bullet2 );// {"sk_plr_357_bullet2","0"};
CVAR_REGISTER( &sk_plr_357_bullet3 );// {"sk_plr_357_bullet3","0"};
// MP5 Round
CVAR_REGISTER ( &sk_plr_9mmAR_bullet1 );// {"sk_plr_9mmAR_bullet1","0"};
CVAR_REGISTER ( &sk_plr_9mmAR_bullet2 );// {"sk_plr_9mmAR_bullet2","0"};
CVAR_REGISTER ( &sk_plr_9mmAR_bullet3 );// {"sk_plr_9mmAR_bullet3","0"};
CVAR_REGISTER( &sk_plr_9mmAR_bullet1 );// {"sk_plr_9mmAR_bullet1","0"};
CVAR_REGISTER( &sk_plr_9mmAR_bullet2 );// {"sk_plr_9mmAR_bullet2","0"};
CVAR_REGISTER( &sk_plr_9mmAR_bullet3 );// {"sk_plr_9mmAR_bullet3","0"};
// M203 grenade
CVAR_REGISTER ( &sk_plr_9mmAR_grenade1 );// {"sk_plr_9mmAR_grenade1","0"};
CVAR_REGISTER ( &sk_plr_9mmAR_grenade2 );// {"sk_plr_9mmAR_grenade2","0"};
CVAR_REGISTER ( &sk_plr_9mmAR_grenade3 );// {"sk_plr_9mmAR_grenade3","0"};
CVAR_REGISTER( &sk_plr_9mmAR_grenade1 );// {"sk_plr_9mmAR_grenade1","0"};
CVAR_REGISTER( &sk_plr_9mmAR_grenade2 );// {"sk_plr_9mmAR_grenade2","0"};
CVAR_REGISTER( &sk_plr_9mmAR_grenade3 );// {"sk_plr_9mmAR_grenade3","0"};
// Shotgun buckshot
CVAR_REGISTER ( &sk_plr_buckshot1 );// {"sk_plr_buckshot1","0"};
CVAR_REGISTER ( &sk_plr_buckshot2 );// {"sk_plr_buckshot2","0"};
CVAR_REGISTER ( &sk_plr_buckshot3 );// {"sk_plr_buckshot3","0"};
CVAR_REGISTER( &sk_plr_buckshot1 );// {"sk_plr_buckshot1","0"};
CVAR_REGISTER( &sk_plr_buckshot2 );// {"sk_plr_buckshot2","0"};
CVAR_REGISTER( &sk_plr_buckshot3 );// {"sk_plr_buckshot3","0"};
// Crossbow
CVAR_REGISTER ( &sk_plr_xbow_bolt_monster1 );// {"sk_plr_xbow_bolt1","0"};
CVAR_REGISTER ( &sk_plr_xbow_bolt_monster2 );// {"sk_plr_xbow_bolt2","0"};
CVAR_REGISTER ( &sk_plr_xbow_bolt_monster3 );// {"sk_plr_xbow_bolt3","0"};
CVAR_REGISTER ( &sk_plr_xbow_bolt_client1 );// {"sk_plr_xbow_bolt1","0"};
CVAR_REGISTER ( &sk_plr_xbow_bolt_client2 );// {"sk_plr_xbow_bolt2","0"};
CVAR_REGISTER ( &sk_plr_xbow_bolt_client3 );// {"sk_plr_xbow_bolt3","0"};
CVAR_REGISTER( &sk_plr_xbow_bolt_monster1 );// {"sk_plr_xbow_bolt1","0"};
CVAR_REGISTER( &sk_plr_xbow_bolt_monster2 );// {"sk_plr_xbow_bolt2","0"};
CVAR_REGISTER( &sk_plr_xbow_bolt_monster3 );// {"sk_plr_xbow_bolt3","0"};
CVAR_REGISTER( &sk_plr_xbow_bolt_client1 );// {"sk_plr_xbow_bolt1","0"};
CVAR_REGISTER( &sk_plr_xbow_bolt_client2 );// {"sk_plr_xbow_bolt2","0"};
CVAR_REGISTER( &sk_plr_xbow_bolt_client3 );// {"sk_plr_xbow_bolt3","0"};
// RPG
CVAR_REGISTER ( &sk_plr_rpg1 );// {"sk_plr_rpg1","0"};
CVAR_REGISTER ( &sk_plr_rpg2 );// {"sk_plr_rpg2","0"};
CVAR_REGISTER ( &sk_plr_rpg3 );// {"sk_plr_rpg3","0"};
CVAR_REGISTER( &sk_plr_rpg1 );// {"sk_plr_rpg1","0"};
CVAR_REGISTER( &sk_plr_rpg2 );// {"sk_plr_rpg2","0"};
CVAR_REGISTER( &sk_plr_rpg3 );// {"sk_plr_rpg3","0"};
// Gauss Gun
CVAR_REGISTER ( &sk_plr_gauss1 );// {"sk_plr_gauss1","0"};
CVAR_REGISTER ( &sk_plr_gauss2 );// {"sk_plr_gauss2","0"};
CVAR_REGISTER ( &sk_plr_gauss3 );// {"sk_plr_gauss3","0"};
CVAR_REGISTER( &sk_plr_gauss1 );// {"sk_plr_gauss1","0"};
CVAR_REGISTER( &sk_plr_gauss2 );// {"sk_plr_gauss2","0"};
CVAR_REGISTER( &sk_plr_gauss3 );// {"sk_plr_gauss3","0"};
// Egon Gun
CVAR_REGISTER ( &sk_plr_egon_narrow1 );// {"sk_plr_egon_narrow1","0"};
CVAR_REGISTER ( &sk_plr_egon_narrow2 );// {"sk_plr_egon_narrow2","0"};
CVAR_REGISTER ( &sk_plr_egon_narrow3 );// {"sk_plr_egon_narrow3","0"};
CVAR_REGISTER ( &sk_plr_egon_wide1 );// {"sk_plr_egon_wide1","0"};
CVAR_REGISTER ( &sk_plr_egon_wide2 );// {"sk_plr_egon_wide2","0"};
CVAR_REGISTER ( &sk_plr_egon_wide3 );// {"sk_plr_egon_wide3","0"};
CVAR_REGISTER( &sk_plr_egon_narrow1 );// {"sk_plr_egon_narrow1","0"};
CVAR_REGISTER( &sk_plr_egon_narrow2 );// {"sk_plr_egon_narrow2","0"};
CVAR_REGISTER( &sk_plr_egon_narrow3 );// {"sk_plr_egon_narrow3","0"};
CVAR_REGISTER( &sk_plr_egon_wide1 );// {"sk_plr_egon_wide1","0"};
CVAR_REGISTER( &sk_plr_egon_wide2 );// {"sk_plr_egon_wide2","0"};
CVAR_REGISTER( &sk_plr_egon_wide3 );// {"sk_plr_egon_wide3","0"};
// Hand Grendade
CVAR_REGISTER ( &sk_plr_hand_grenade1 );// {"sk_plr_hand_grenade1","0"};
CVAR_REGISTER ( &sk_plr_hand_grenade2 );// {"sk_plr_hand_grenade2","0"};
CVAR_REGISTER ( &sk_plr_hand_grenade3 );// {"sk_plr_hand_grenade3","0"};
CVAR_REGISTER( &sk_plr_hand_grenade1 );// {"sk_plr_hand_grenade1","0"};
CVAR_REGISTER( &sk_plr_hand_grenade2 );// {"sk_plr_hand_grenade2","0"};
CVAR_REGISTER( &sk_plr_hand_grenade3 );// {"sk_plr_hand_grenade3","0"};
// Satchel Charge
CVAR_REGISTER ( &sk_plr_satchel1 );// {"sk_plr_satchel1","0"};
CVAR_REGISTER ( &sk_plr_satchel2 );// {"sk_plr_satchel2","0"};
CVAR_REGISTER ( &sk_plr_satchel3 );// {"sk_plr_satchel3","0"};
CVAR_REGISTER( &sk_plr_satchel1 );// {"sk_plr_satchel1","0"};
CVAR_REGISTER( &sk_plr_satchel2 );// {"sk_plr_satchel2","0"};
CVAR_REGISTER( &sk_plr_satchel3 );// {"sk_plr_satchel3","0"};
// Tripmine
CVAR_REGISTER ( &sk_plr_tripmine1 );// {"sk_plr_tripmine1","0"};
CVAR_REGISTER ( &sk_plr_tripmine2 );// {"sk_plr_tripmine2","0"};
CVAR_REGISTER ( &sk_plr_tripmine3 );// {"sk_plr_tripmine3","0"};
CVAR_REGISTER( &sk_plr_tripmine1 );// {"sk_plr_tripmine1","0"};
CVAR_REGISTER( &sk_plr_tripmine2 );// {"sk_plr_tripmine2","0"};
CVAR_REGISTER( &sk_plr_tripmine3 );// {"sk_plr_tripmine3","0"};
// WORLD WEAPONS
CVAR_REGISTER ( &sk_12mm_bullet1 );// {"sk_12mm_bullet1","0"};
CVAR_REGISTER ( &sk_12mm_bullet2 );// {"sk_12mm_bullet2","0"};
CVAR_REGISTER ( &sk_12mm_bullet3 );// {"sk_12mm_bullet3","0"};
CVAR_REGISTER( &sk_12mm_bullet1 );// {"sk_12mm_bullet1","0"};
CVAR_REGISTER( &sk_12mm_bullet2 );// {"sk_12mm_bullet2","0"};
CVAR_REGISTER( &sk_12mm_bullet3 );// {"sk_12mm_bullet3","0"};
CVAR_REGISTER ( &sk_9mmAR_bullet1 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER ( &sk_9mmAR_bullet2 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER ( &sk_9mmAR_bullet3 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER ( &sk_9mm_bullet1 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER ( &sk_9mm_bullet2 );// {"sk_9mm_bullet2","0"};
CVAR_REGISTER ( &sk_9mm_bullet3 );// {"sk_9mm_bullet3","0"};
CVAR_REGISTER( &sk_9mmAR_bullet1 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER( &sk_9mmAR_bullet2 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER( &sk_9mmAR_bullet3 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER( &sk_9mm_bullet1 );// {"sk_9mm_bullet1","0"};
CVAR_REGISTER( &sk_9mm_bullet2 );// {"sk_9mm_bullet2","0"};
CVAR_REGISTER( &sk_9mm_bullet3 );// {"sk_9mm_bullet3","0"};
// HORNET
CVAR_REGISTER ( &sk_hornet_dmg1 );// {"sk_hornet_dmg1","0"};
CVAR_REGISTER ( &sk_hornet_dmg2 );// {"sk_hornet_dmg2","0"};
CVAR_REGISTER ( &sk_hornet_dmg3 );// {"sk_hornet_dmg3","0"};
CVAR_REGISTER( &sk_hornet_dmg1 );// {"sk_hornet_dmg1","0"};
CVAR_REGISTER( &sk_hornet_dmg2 );// {"sk_hornet_dmg2","0"};
CVAR_REGISTER( &sk_hornet_dmg3 );// {"sk_hornet_dmg3","0"};
// HEALTH/SUIT CHARGE DISTRIBUTION
CVAR_REGISTER ( &sk_suitcharger1 );
CVAR_REGISTER ( &sk_suitcharger2 );
CVAR_REGISTER ( &sk_suitcharger3 );
CVAR_REGISTER( &sk_suitcharger1 );
CVAR_REGISTER( &sk_suitcharger2 );
CVAR_REGISTER( &sk_suitcharger3 );
CVAR_REGISTER ( &sk_battery1 );
CVAR_REGISTER ( &sk_battery2 );
CVAR_REGISTER ( &sk_battery3 );
CVAR_REGISTER( &sk_battery1 );
CVAR_REGISTER( &sk_battery2 );
CVAR_REGISTER( &sk_battery3 );
CVAR_REGISTER ( &sk_healthcharger1 );
CVAR_REGISTER ( &sk_healthcharger2 );
CVAR_REGISTER ( &sk_healthcharger3 );
CVAR_REGISTER( &sk_healthcharger1 );
CVAR_REGISTER( &sk_healthcharger2 );
CVAR_REGISTER( &sk_healthcharger3 );
CVAR_REGISTER ( &sk_healthkit1 );
CVAR_REGISTER ( &sk_healthkit2 );
CVAR_REGISTER ( &sk_healthkit3 );
CVAR_REGISTER( &sk_healthkit1 );
CVAR_REGISTER( &sk_healthkit2 );
CVAR_REGISTER( &sk_healthkit3 );
CVAR_REGISTER ( &sk_scientist_heal1 );
CVAR_REGISTER ( &sk_scientist_heal2 );
CVAR_REGISTER ( &sk_scientist_heal3 );
CVAR_REGISTER( &sk_scientist_heal1 );
CVAR_REGISTER( &sk_scientist_heal2 );
CVAR_REGISTER( &sk_scientist_heal3 );
// monster damage adjusters
CVAR_REGISTER ( &sk_monster_head1 );
CVAR_REGISTER ( &sk_monster_head2 );
CVAR_REGISTER ( &sk_monster_head3 );
// monster damage adjusters
CVAR_REGISTER( &sk_monster_head1 );
CVAR_REGISTER( &sk_monster_head2 );
CVAR_REGISTER( &sk_monster_head3 );
CVAR_REGISTER ( &sk_monster_chest1 );
CVAR_REGISTER ( &sk_monster_chest2 );
CVAR_REGISTER ( &sk_monster_chest3 );
CVAR_REGISTER( &sk_monster_chest1 );
CVAR_REGISTER( &sk_monster_chest2 );
CVAR_REGISTER( &sk_monster_chest3 );
CVAR_REGISTER ( &sk_monster_stomach1 );
CVAR_REGISTER ( &sk_monster_stomach2 );
CVAR_REGISTER ( &sk_monster_stomach3 );
CVAR_REGISTER( &sk_monster_stomach1 );
CVAR_REGISTER( &sk_monster_stomach2 );
CVAR_REGISTER( &sk_monster_stomach3 );
CVAR_REGISTER ( &sk_monster_arm1 );
CVAR_REGISTER ( &sk_monster_arm2 );
CVAR_REGISTER ( &sk_monster_arm3 );
CVAR_REGISTER( &sk_monster_arm1 );
CVAR_REGISTER( &sk_monster_arm2 );
CVAR_REGISTER( &sk_monster_arm3 );
CVAR_REGISTER ( &sk_monster_leg1 );
CVAR_REGISTER ( &sk_monster_leg2 );
CVAR_REGISTER ( &sk_monster_leg3 );
CVAR_REGISTER( &sk_monster_leg1 );
CVAR_REGISTER( &sk_monster_leg2 );
CVAR_REGISTER( &sk_monster_leg3 );
// player damage adjusters
CVAR_REGISTER ( &sk_player_head1 );
CVAR_REGISTER ( &sk_player_head2 );
CVAR_REGISTER ( &sk_player_head3 );
// player damage adjusters
CVAR_REGISTER( &sk_player_head1 );
CVAR_REGISTER( &sk_player_head2 );
CVAR_REGISTER( &sk_player_head3 );
CVAR_REGISTER ( &sk_player_chest1 );
CVAR_REGISTER ( &sk_player_chest2 );
CVAR_REGISTER ( &sk_player_chest3 );
CVAR_REGISTER( &sk_player_chest1 );
CVAR_REGISTER( &sk_player_chest2 );
CVAR_REGISTER( &sk_player_chest3 );
CVAR_REGISTER ( &sk_player_stomach1 );
CVAR_REGISTER ( &sk_player_stomach2 );
CVAR_REGISTER ( &sk_player_stomach3 );
CVAR_REGISTER( &sk_player_stomach1 );
CVAR_REGISTER( &sk_player_stomach2 );
CVAR_REGISTER( &sk_player_stomach3 );
CVAR_REGISTER ( &sk_player_arm1 );
CVAR_REGISTER ( &sk_player_arm2 );
CVAR_REGISTER ( &sk_player_arm3 );
CVAR_REGISTER( &sk_player_arm1 );
CVAR_REGISTER( &sk_player_arm2 );
CVAR_REGISTER( &sk_player_arm3 );
CVAR_REGISTER ( &sk_player_leg1 );
CVAR_REGISTER ( &sk_player_leg2 );
CVAR_REGISTER ( &sk_player_leg3 );
CVAR_REGISTER( &sk_player_leg1 );
CVAR_REGISTER( &sk_player_leg2 );
CVAR_REGISTER( &sk_player_leg3 );
// END REGISTER CVARS FOR SKILL LEVEL STUFF
SERVER_COMMAND( "exec skill.cfg\n" );

2
dlls/game.h
View File

@ -18,7 +18,6 @@
extern void GameDLLInit( void );
extern cvar_t displaysoundlist;
// multiplayer server rules
@ -41,5 +40,4 @@ extern cvar_t allowmonsters;
extern cvar_t *g_psv_gravity;
extern cvar_t *g_psv_aim;
extern cvar_t *g_footsteps;
#endif // GAME_H

171
dlls/gamerules.cpp
View File

@ -28,7 +28,7 @@
extern edict_t *EntSelectSpawnPoint( CBaseEntity *pPlayer );
DLL_GLOBAL CGameRules* g_pGameRules = NULL;
DLL_GLOBAL CGameRules *g_pGameRules = NULL;
extern DLL_GLOBAL BOOL g_fGameOver;
extern int gmsgDeathMsg; // client dll messages
extern int gmsgMOTD;
@ -41,13 +41,13 @@ BOOL CGameRules::CanHaveAmmo( CBasePlayer *pPlayer, const char *pszAmmoName, int
{
int iAmmoIndex;
if ( pszAmmoName )
if( pszAmmoName )
{
iAmmoIndex = pPlayer->GetAmmoIndex( pszAmmoName );
if ( iAmmoIndex > -1 )
if( iAmmoIndex > -1 )
{
if ( pPlayer->AmmoInventory( iAmmoIndex ) < iMaxCarry )
if( pPlayer->AmmoInventory( iAmmoIndex ) < iMaxCarry )
{
// player has room for more of this type of ammo
return TRUE;
@ -60,14 +60,14 @@ BOOL CGameRules::CanHaveAmmo( CBasePlayer *pPlayer, const char *pszAmmoName, int
//=========================================================
//=========================================================
edict_t *CGameRules :: GetPlayerSpawnSpot( CBasePlayer *pPlayer )
edict_t *CGameRules::GetPlayerSpawnSpot( CBasePlayer *pPlayer )
{
edict_t *pentSpawnSpot = EntSelectSpawnPoint( pPlayer );
pPlayer->pev->origin = VARS(pentSpawnSpot)->origin + Vector(0,0,1);
pPlayer->pev->origin = VARS( pentSpawnSpot )->origin + Vector( 0, 0, 1 );
pPlayer->pev->v_angle = g_vecZero;
pPlayer->pev->velocity = g_vecZero;
pPlayer->pev->angles = VARS(pentSpawnSpot)->angles;
pPlayer->pev->angles = VARS( pentSpawnSpot )->angles;
pPlayer->pev->punchangle = g_vecZero;
pPlayer->pev->fixangle = TRUE;
@ -79,16 +79,16 @@ edict_t *CGameRules :: GetPlayerSpawnSpot( CBasePlayer *pPlayer )
BOOL CGameRules::CanHavePlayerItem( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon )
{
// only living players can have items
if ( pPlayer->pev->deadflag != DEAD_NO )
if( pPlayer->pev->deadflag != DEAD_NO )
return FALSE;
if ( pWeapon->pszAmmo1() )
if( pWeapon->pszAmmo1() )
{
if ( !CanHaveAmmo( pPlayer, pWeapon->pszAmmo1(), pWeapon->iMaxAmmo1() ) )
if( !CanHaveAmmo( pPlayer, pWeapon->pszAmmo1(), pWeapon->iMaxAmmo1() ) )
{
// we can't carry anymore ammo for this gun. We can only
// have the gun if we aren't already carrying one of this type
if ( pPlayer->HasPlayerItem( pWeapon ) )
if( pPlayer->HasPlayerItem( pWeapon ) )
{
return FALSE;
}
@ -97,7 +97,7 @@ BOOL CGameRules::CanHavePlayerItem( CBasePlayer *pPlayer, CBasePlayerItem *pWeap
else
{
// weapon doesn't use ammo, don't take another if you already have it.
if ( pPlayer->HasPlayerItem( pWeapon ) )
if( pPlayer->HasPlayerItem( pWeapon ) )
{
return FALSE;
}
@ -114,31 +114,31 @@ void CGameRules::RefreshSkillData ( void )
{
int iSkill;
iSkill = (int)CVAR_GET_FLOAT("skill");
iSkill = (int)CVAR_GET_FLOAT( "skill" );
g_iSkillLevel = iSkill;
if ( iSkill < 1 )
if( iSkill < 1 )
{
iSkill = 1;
}
else if ( iSkill > 3 )
else if( iSkill > 3 )
{
iSkill = 3;
}
gSkillData.iSkillLevel = iSkill;
ALERT ( at_console, "\nGAME SKILL LEVEL:%d\n",iSkill );
ALERT( at_console, "\nGAME SKILL LEVEL:%d\n",iSkill );
//Agrunt
gSkillData.agruntHealth = GetSkillCvar( "sk_agrunt_health" );
gSkillData.agruntDmgPunch = GetSkillCvar( "sk_agrunt_dmg_punch");
gSkillData.agruntDmgPunch = GetSkillCvar( "sk_agrunt_dmg_punch" );
// Apache
gSkillData.apacheHealth = GetSkillCvar( "sk_apache_health");
gSkillData.apacheHealth = GetSkillCvar( "sk_apache_health" );
// Barney
gSkillData.barneyHealth = GetSkillCvar( "sk_barney_health");
gSkillData.barneyHealth = GetSkillCvar( "sk_barney_health" );
// Big Momma
gSkillData.bigmommaHealthFactor = GetSkillCvar( "sk_bigmomma_health_factor" );
@ -147,131 +147,131 @@ void CGameRules::RefreshSkillData ( void )
gSkillData.bigmommaRadiusBlast = GetSkillCvar( "sk_bigmomma_radius_blast" );
// Bullsquid
gSkillData.bullsquidHealth = GetSkillCvar( "sk_bullsquid_health");
gSkillData.bullsquidDmgBite = GetSkillCvar( "sk_bullsquid_dmg_bite");
gSkillData.bullsquidDmgWhip = GetSkillCvar( "sk_bullsquid_dmg_whip");
gSkillData.bullsquidDmgSpit = GetSkillCvar( "sk_bullsquid_dmg_spit");
gSkillData.bullsquidHealth = GetSkillCvar( "sk_bullsquid_health" );
gSkillData.bullsquidDmgBite = GetSkillCvar( "sk_bullsquid_dmg_bite" );
gSkillData.bullsquidDmgWhip = GetSkillCvar( "sk_bullsquid_dmg_whip" );
gSkillData.bullsquidDmgSpit = GetSkillCvar( "sk_bullsquid_dmg_spit" );
// Gargantua
gSkillData.gargantuaHealth = GetSkillCvar( "sk_gargantua_health");
gSkillData.gargantuaDmgSlash = GetSkillCvar( "sk_gargantua_dmg_slash");
gSkillData.gargantuaDmgFire = GetSkillCvar( "sk_gargantua_dmg_fire");
gSkillData.gargantuaDmgStomp = GetSkillCvar( "sk_gargantua_dmg_stomp");
gSkillData.gargantuaHealth = GetSkillCvar( "sk_gargantua_health" );
gSkillData.gargantuaDmgSlash = GetSkillCvar( "sk_gargantua_dmg_slash" );
gSkillData.gargantuaDmgFire = GetSkillCvar( "sk_gargantua_dmg_fire" );
gSkillData.gargantuaDmgStomp = GetSkillCvar( "sk_gargantua_dmg_stomp ");
// Hassassin
gSkillData.hassassinHealth = GetSkillCvar( "sk_hassassin_health");
gSkillData.hassassinHealth = GetSkillCvar( "sk_hassassin_health" );
// Headcrab
gSkillData.headcrabHealth = GetSkillCvar( "sk_headcrab_health");
gSkillData.headcrabDmgBite = GetSkillCvar( "sk_headcrab_dmg_bite");
gSkillData.headcrabHealth = GetSkillCvar( "sk_headcrab_health" );
gSkillData.headcrabDmgBite = GetSkillCvar( "sk_headcrab_dmg_bite" );
// Hgrunt
gSkillData.hgruntHealth = GetSkillCvar( "sk_hgrunt_health");
gSkillData.hgruntDmgKick = GetSkillCvar( "sk_hgrunt_kick");
gSkillData.hgruntShotgunPellets = GetSkillCvar( "sk_hgrunt_pellets");
gSkillData.hgruntGrenadeSpeed = GetSkillCvar( "sk_hgrunt_gspeed");
gSkillData.hgruntHealth = GetSkillCvar( "sk_hgrunt_health" );
gSkillData.hgruntDmgKick = GetSkillCvar( "sk_hgrunt_kick" );
gSkillData.hgruntShotgunPellets = GetSkillCvar( "sk_hgrunt_pellets" );
gSkillData.hgruntGrenadeSpeed = GetSkillCvar( "sk_hgrunt_gspeed" );
// Houndeye
gSkillData.houndeyeHealth = GetSkillCvar( "sk_houndeye_health");
gSkillData.houndeyeDmgBlast = GetSkillCvar( "sk_houndeye_dmg_blast");
gSkillData.houndeyeHealth = GetSkillCvar( "sk_houndeye_health" );
gSkillData.houndeyeDmgBlast = GetSkillCvar( "sk_houndeye_dmg_blast" );
// ISlave
gSkillData.slaveHealth = GetSkillCvar( "sk_islave_health");
gSkillData.slaveDmgClaw = GetSkillCvar( "sk_islave_dmg_claw");
gSkillData.slaveDmgClawrake = GetSkillCvar( "sk_islave_dmg_clawrake");
gSkillData.slaveDmgZap = GetSkillCvar( "sk_islave_dmg_zap");
gSkillData.slaveHealth = GetSkillCvar( "sk_islave_health" );
gSkillData.slaveDmgClaw = GetSkillCvar( "sk_islave_dmg_claw" );
gSkillData.slaveDmgClawrake = GetSkillCvar( "sk_islave_dmg_clawrake" );
gSkillData.slaveDmgZap = GetSkillCvar( "sk_islave_dmg_zap" );
// Icthyosaur
gSkillData.ichthyosaurHealth = GetSkillCvar( "sk_ichthyosaur_health");
gSkillData.ichthyosaurDmgShake = GetSkillCvar( "sk_ichthyosaur_shake");
gSkillData.ichthyosaurHealth = GetSkillCvar( "sk_ichthyosaur_health" );
gSkillData.ichthyosaurDmgShake = GetSkillCvar( "sk_ichthyosaur_shake" );
// Leech
gSkillData.leechHealth = GetSkillCvar( "sk_leech_health");
gSkillData.leechHealth = GetSkillCvar( "sk_leech_health" );
gSkillData.leechDmgBite = GetSkillCvar( "sk_leech_dmg_bite");
gSkillData.leechDmgBite = GetSkillCvar( "sk_leech_dmg_bite" );
// Controller
gSkillData.controllerHealth = GetSkillCvar( "sk_controller_health");
gSkillData.controllerDmgZap = GetSkillCvar( "sk_controller_dmgzap");
gSkillData.controllerSpeedBall = GetSkillCvar( "sk_controller_speedball");
gSkillData.controllerDmgBall = GetSkillCvar( "sk_controller_dmgball");
gSkillData.controllerHealth = GetSkillCvar( "sk_controller_health" );
gSkillData.controllerDmgZap = GetSkillCvar( "sk_controller_dmgzap" );
gSkillData.controllerSpeedBall = GetSkillCvar( "sk_controller_speedball" );
gSkillData.controllerDmgBall = GetSkillCvar( "sk_controller_dmgball" );
// Nihilanth
gSkillData.nihilanthHealth = GetSkillCvar( "sk_nihilanth_health");
gSkillData.nihilanthZap = GetSkillCvar( "sk_nihilanth_zap");
gSkillData.nihilanthHealth = GetSkillCvar( "sk_nihilanth_health" );
gSkillData.nihilanthZap = GetSkillCvar( "sk_nihilanth_zap" );
// Scientist
gSkillData.scientistHealth = GetSkillCvar( "sk_scientist_health");
gSkillData.scientistHealth = GetSkillCvar( "sk_scientist_health" );
// Snark
gSkillData.snarkHealth = GetSkillCvar( "sk_snark_health");
gSkillData.snarkDmgBite = GetSkillCvar( "sk_snark_dmg_bite");
gSkillData.snarkDmgPop = GetSkillCvar( "sk_snark_dmg_pop");
gSkillData.snarkHealth = GetSkillCvar( "sk_snark_health" );
gSkillData.snarkDmgBite = GetSkillCvar( "sk_snark_dmg_bite" );
gSkillData.snarkDmgPop = GetSkillCvar( "sk_snark_dmg_pop" );
// Zombie
gSkillData.zombieHealth = GetSkillCvar( "sk_zombie_health");
gSkillData.zombieDmgOneSlash = GetSkillCvar( "sk_zombie_dmg_one_slash");
gSkillData.zombieDmgBothSlash = GetSkillCvar( "sk_zombie_dmg_both_slash");
gSkillData.zombieHealth = GetSkillCvar( "sk_zombie_health" );
gSkillData.zombieDmgOneSlash = GetSkillCvar( "sk_zombie_dmg_one_slash" );
gSkillData.zombieDmgBothSlash = GetSkillCvar( "sk_zombie_dmg_both_slash" );
//Turret
gSkillData.turretHealth = GetSkillCvar( "sk_turret_health");
gSkillData.turretHealth = GetSkillCvar( "sk_turret_health" );
// MiniTurret
gSkillData.miniturretHealth = GetSkillCvar( "sk_miniturret_health");
gSkillData.miniturretHealth = GetSkillCvar( "sk_miniturret_health" );
// Sentry Turret
gSkillData.sentryHealth = GetSkillCvar( "sk_sentry_health");
gSkillData.sentryHealth = GetSkillCvar( "sk_sentry_health" );
// PLAYER WEAPONS
// PLAYER WEAPONS
// Crowbar whack
gSkillData.plrDmgCrowbar = GetSkillCvar( "sk_plr_crowbar");
gSkillData.plrDmgCrowbar = GetSkillCvar( "sk_plr_crowbar" );
// Glock Round
gSkillData.plrDmg9MM = GetSkillCvar( "sk_plr_9mm_bullet");
gSkillData.plrDmg9MM = GetSkillCvar( "sk_plr_9mm_bullet" );
// 357 Round
gSkillData.plrDmg357 = GetSkillCvar( "sk_plr_357_bullet");
gSkillData.plrDmg357 = GetSkillCvar( "sk_plr_357_bullet" );
// MP5 Round
gSkillData.plrDmgMP5 = GetSkillCvar( "sk_plr_9mmAR_bullet");
gSkillData.plrDmgMP5 = GetSkillCvar( "sk_plr_9mmAR_bullet" );
// M203 grenade
gSkillData.plrDmgM203Grenade = GetSkillCvar( "sk_plr_9mmAR_grenade");
gSkillData.plrDmgM203Grenade = GetSkillCvar( "sk_plr_9mmAR_grenade" );
// Shotgun buckshot
gSkillData.plrDmgBuckshot = GetSkillCvar( "sk_plr_buckshot");
gSkillData.plrDmgBuckshot = GetSkillCvar( "sk_plr_buckshot" );
// Crossbow
gSkillData.plrDmgCrossbowClient = GetSkillCvar( "sk_plr_xbow_bolt_client");
gSkillData.plrDmgCrossbowMonster = GetSkillCvar( "sk_plr_xbow_bolt_monster");
gSkillData.plrDmgCrossbowClient = GetSkillCvar( "sk_plr_xbow_bolt_client" );
gSkillData.plrDmgCrossbowMonster = GetSkillCvar( "sk_plr_xbow_bolt_monster" );
// RPG
gSkillData.plrDmgRPG = GetSkillCvar( "sk_plr_rpg");
gSkillData.plrDmgRPG = GetSkillCvar( "sk_plr_rpg" );
// Gauss gun
gSkillData.plrDmgGauss = GetSkillCvar( "sk_plr_gauss");
gSkillData.plrDmgGauss = GetSkillCvar( "sk_plr_gauss" );
// Egon Gun
gSkillData.plrDmgEgonNarrow = GetSkillCvar( "sk_plr_egon_narrow");
gSkillData.plrDmgEgonWide = GetSkillCvar( "sk_plr_egon_wide");
gSkillData.plrDmgEgonNarrow = GetSkillCvar( "sk_plr_egon_narrow" );
gSkillData.plrDmgEgonWide = GetSkillCvar( "sk_plr_egon_wide" );
// Hand Grendade
gSkillData.plrDmgHandGrenade = GetSkillCvar( "sk_plr_hand_grenade");
gSkillData.plrDmgHandGrenade = GetSkillCvar( "sk_plr_hand_grenade" );
// Satchel Charge
gSkillData.plrDmgSatchel = GetSkillCvar( "sk_plr_satchel");
gSkillData.plrDmgSatchel = GetSkillCvar( "sk_plr_satchel" );
// Tripmine
gSkillData.plrDmgTripmine = GetSkillCvar( "sk_plr_tripmine");
gSkillData.plrDmgTripmine = GetSkillCvar( "sk_plr_tripmine" );
// MONSTER WEAPONS
gSkillData.monDmg12MM = GetSkillCvar( "sk_12mm_bullet");
gSkillData.monDmg12MM = GetSkillCvar( "sk_12mm_bullet" );
gSkillData.monDmgMP5 = GetSkillCvar ("sk_9mmAR_bullet" );
gSkillData.monDmg9MM = GetSkillCvar( "sk_9mm_bullet");
gSkillData.monDmg9MM = GetSkillCvar( "sk_9mm_bullet" );
// MONSTER HORNET
gSkillData.monDmgHornet = GetSkillCvar( "sk_hornet_dmg");
gSkillData.monDmgHornet = GetSkillCvar( "sk_hornet_dmg" );
// PLAYER HORNET
// Up to this point, player hornet damage and monster hornet damage were both using
@ -281,7 +281,6 @@ void CGameRules::RefreshSkillData ( void )
// via SKILLS.CFG. Any player hivehand tuning must take place in the code. (sjb)
gSkillData.plrDmgHornet = 7;
// HEALTH/CHARGE
gSkillData.suitchargerCapacity = GetSkillCvar( "sk_suitcharger" );
gSkillData.batteryCapacity = GetSkillCvar( "sk_battery" );
@ -311,9 +310,9 @@ void CGameRules::RefreshSkillData ( void )
CGameRules *InstallGameRules( void )
{
SERVER_COMMAND( "exec game.cfg\n" );
SERVER_EXECUTE( );
SERVER_EXECUTE();
if ( !gpGlobals->deathmatch )
if( !gpGlobals->deathmatch )
{
// generic half-life
g_teamplay = 0;
@ -321,14 +320,13 @@ CGameRules *InstallGameRules( void )
}
else
{
if ( teamplay.value > 0 )
if( teamplay.value > 0 )
{
// teamplay
g_teamplay = 1;
return new CHalfLifeTeamplay;
}
if ((int)gpGlobals->deathmatch == 1)
if( (int)gpGlobals->deathmatch == 1 )
{
// vanilla deathmatch
g_teamplay = 0;
@ -342,6 +340,3 @@ CGameRules *InstallGameRules( void )
}
}
}

6
dlls/gamerules.h
View File

@ -75,7 +75,7 @@ public:
virtual const char *GetGameDescription( void ) { return "Half-Life"; } // this is the game name that gets seen in the server browser
// Client connection/disconnection
virtual BOOL ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] ) = 0;// a client just connected to the server (player hasn't spawned yet)
virtual BOOL ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[128] ) = 0;// a client just connected to the server (player hasn't spawned yet)
virtual void InitHUD( CBasePlayer *pl ) = 0; // the client dll is ready for updating
virtual void ClientDisconnected( edict_t *pClient ) = 0;// a client just disconnected from the server
virtual void UpdateGameMode( CBasePlayer *pPlayer ) {} // the client needs to be informed of the current game mode
@ -276,7 +276,7 @@ public:
// If ClientConnected returns FALSE, the connection is rejected and the user is provided the reason specified in
// svRejectReason
// Only the client's name and remote address are provided to the dll for verification.
virtual BOOL ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] );
virtual BOOL ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[128] );
virtual void InitHUD( CBasePlayer *pl ); // the client dll is ready for updating
virtual void ClientDisconnected( edict_t *pClient );
virtual void UpdateGameMode( CBasePlayer *pPlayer ); // the client needs to be informed of the current game mode
@ -358,4 +358,4 @@ protected:
void SendMOTDToClient( edict_t *client );
};
extern DLL_GLOBAL CGameRules* g_pGameRules;
extern DLL_GLOBAL CGameRules *g_pGameRules;

358
dlls/gargantua.cpp
View File

@ -85,7 +85,7 @@ public:
private:
// UNDONE: re-use this sprite list instead of creating new ones all the time
// CSprite *m_pSprites[ STOMP_SPRITE_COUNT ];
// CSprite *m_pSprites[STOMP_SPRITE_COUNT];
};
LINK_ENTITY_TO_CLASS( garg_stomp, CStomp )
@ -95,7 +95,7 @@ CStomp *CStomp::StompCreate( const Vector &origin, const Vector &end, float spee
CStomp *pStomp = GetClassPtr( (CStomp *)NULL );
pStomp->pev->origin = origin;
Vector dir = (end - origin);
Vector dir = end - origin;
pStomp->pev->scale = dir.Length();
pStomp->pev->movedir = dir.Normalize();
pStomp->pev->speed = speed;
@ -107,14 +107,14 @@ CStomp *CStomp::StompCreate( const Vector &origin, const Vector &end, float spee
void CStomp::Spawn( void )
{
pev->nextthink = gpGlobals->time;
pev->classname = MAKE_STRING("garg_stomp");
pev->classname = MAKE_STRING( "garg_stomp" );
pev->dmgtime = gpGlobals->time;
pev->framerate = 30;
pev->model = MAKE_STRING(GARG_STOMP_SPRITE_NAME);
pev->model = MAKE_STRING( GARG_STOMP_SPRITE_NAME );
pev->rendermode = kRenderTransTexture;
pev->renderamt = 0;
EMIT_SOUND_DYN( edict(), CHAN_BODY, GARG_STOMP_BUZZ_SOUND, 1, ATTN_NORM, 0, PITCH_NORM * 0.55);
EMIT_SOUND_DYN( edict(), CHAN_BODY, GARG_STOMP_BUZZ_SOUND, 1, ATTN_NORM, 0, PITCH_NORM * 0.55 );
}
#define STOMP_INTERVAL 0.025
@ -128,37 +128,37 @@ void CStomp::Think( void )
// Do damage for this frame
Vector vecStart = pev->origin;
vecStart.z += 30;
Vector vecEnd = vecStart + (pev->movedir * pev->speed * STOMP_FRAMETIME);
Vector vecEnd = vecStart + ( pev->movedir * pev->speed * STOMP_FRAMETIME );
UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr );
if ( tr.pHit && tr.pHit != pev->owner )
if( tr.pHit && tr.pHit != pev->owner )
{
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
entvars_t *pevOwner = pev;
if ( pev->owner )
pevOwner = VARS(pev->owner);
if( pev->owner )
pevOwner = VARS( pev->owner );
if ( pEntity )
if( pEntity )
pEntity->TakeDamage( pev, pevOwner, gSkillData.gargantuaDmgStomp, DMG_SONIC );
}
// Accelerate the effect
pev->speed = pev->speed + (STOMP_FRAMETIME) * pev->framerate;
pev->framerate = pev->framerate + (STOMP_FRAMETIME) * 1500;
pev->speed = pev->speed + ( STOMP_FRAMETIME ) * pev->framerate;
pev->framerate = pev->framerate + ( STOMP_FRAMETIME ) * 1500;
// Move and spawn trails
while ( gpGlobals->time - pev->dmgtime > STOMP_INTERVAL )
while( gpGlobals->time - pev->dmgtime > STOMP_INTERVAL )
{
pev->origin = pev->origin + pev->movedir * pev->speed * STOMP_INTERVAL;
for ( int i = 0; i < 2; i++ )
for( int i = 0; i < 2; i++ )
{
CSprite *pSprite = CSprite::SpriteCreate( GARG_STOMP_SPRITE_NAME, pev->origin, TRUE );
if ( pSprite )
if( pSprite )
{
UTIL_TraceLine( pev->origin, pev->origin - Vector(0,0,500), ignore_monsters, edict(), &tr );
UTIL_TraceLine( pev->origin, pev->origin - Vector( 0, 0, 500 ), ignore_monsters, edict(), &tr );
pSprite->pev->origin = tr.vecEndPos;
pSprite->pev->velocity = Vector(RANDOM_FLOAT(-200,200),RANDOM_FLOAT(-200,200),175);
pSprite->pev->velocity = Vector( RANDOM_FLOAT( -200, 200 ), RANDOM_FLOAT( -200, 200 ), 175 );
// pSprite->AnimateAndDie( RANDOM_FLOAT( 8.0, 12.0 ) );
pSprite->pev->nextthink = gpGlobals->time + 0.3;
pSprite->SetThink( &CBaseEntity::SUB_Remove );
@ -169,16 +169,15 @@ void CStomp::Think( void )
// Scale has the "life" of this effect
pev->scale -= STOMP_INTERVAL * pev->speed;
if ( pev->scale <= 0 )
if( pev->scale <= 0 )
{
// Life has run out
UTIL_Remove(this);
UTIL_Remove( this );
STOP_SOUND( edict(), CHAN_BODY, GARG_STOMP_BUZZ_SOUND );
}
}
}
void StreakSplash( const Vector &origin, const Vector &direction, int color, int count, int speed, int velocityRange )
{
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, origin );
@ -202,7 +201,7 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int Classify ( void );
int Classify( 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 );
void HandleAnimEvent( MonsterEvent_t *pEvent );
@ -402,7 +401,7 @@ Schedule_t slGargFlame[] =
{
{
tlGargFlame,
ARRAYSIZE ( tlGargFlame ),
ARRAYSIZE( tlGargFlame ),
0,
0,
"GargFlame"
@ -421,7 +420,7 @@ Schedule_t slGargSwipe[] =
{
{
tlGargSwipe,
ARRAYSIZE ( tlGargSwipe ),
ARRAYSIZE( tlGargSwipe ),
bits_COND_CAN_MELEE_ATTACK2,
0,
"GargSwipe"
@ -448,10 +447,10 @@ void CGargantua::EyeOff( void )
void CGargantua::EyeUpdate( void )
{
if ( m_pEyeGlow )
if( m_pEyeGlow )
{
m_pEyeGlow->pev->renderamt = UTIL_Approach( m_eyeBrightness, m_pEyeGlow->pev->renderamt, 26 );
if ( m_pEyeGlow->pev->renderamt == 0 )
if( m_pEyeGlow->pev->renderamt == 0 )
m_pEyeGlow->pev->effects |= EF_NODRAW;
else
m_pEyeGlow->pev->effects &= ~EF_NODRAW;
@ -471,14 +470,14 @@ void CGargantua::StompAttack( void )
UTIL_TraceLine( vecStart, vecEnd, ignore_monsters, edict(), &trace );
CStomp::StompCreate( vecStart, trace.vecEndPos, 0 );
UTIL_ScreenShake( pev->origin, 12.0, 100.0, 2.0, 1000 );
EMIT_SOUND_DYN ( edict(), CHAN_WEAPON, pStompSounds[ RANDOM_LONG(0,ARRAYSIZE(pStompSounds)-1) ], 1.0, ATTN_GARG, 0, PITCH_NORM + RANDOM_LONG(-10,10) );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, pStompSounds[RANDOM_LONG( 0, ARRAYSIZE( pStompSounds ) - 1 )], 1.0, ATTN_GARG, 0, PITCH_NORM + RANDOM_LONG( -10, 10 ) );
UTIL_TraceLine( pev->origin, pev->origin - Vector(0,0,20), ignore_monsters, edict(), &trace );
if ( trace.flFraction < 1.0 )
if( trace.flFraction < 1.0 )
UTIL_DecalTrace( &trace, DECAL_GARGSTOMP1 );
}
void CGargantua :: FlameCreate( void )
void CGargantua::FlameCreate( void )
{
int i;
Vector posGun, angleGun;
@ -486,23 +485,23 @@ void CGargantua :: FlameCreate( void )
UTIL_MakeVectors( pev->angles );
for ( i = 0; i < 4; i++ )
for( i = 0; i < 4; i++ )
{
if ( i < 2 )
if( i < 2 )
m_pFlame[i] = CBeam::BeamCreate( GARG_BEAM_SPRITE_NAME, 240 );
else
m_pFlame[i] = CBeam::BeamCreate( GARG_BEAM_SPRITE2, 140 );
if ( m_pFlame[i] )
if( m_pFlame[i] )
{
int attach = i%2;
// attachment is 0 based in GetAttachment
GetAttachment( attach+1, posGun, angleGun );
GetAttachment( attach + 1, posGun, angleGun );
Vector vecEnd = (gpGlobals->v_forward * GARG_FLAME_LENGTH) + posGun;
Vector vecEnd = ( gpGlobals->v_forward * GARG_FLAME_LENGTH ) + posGun;
UTIL_TraceLine( posGun, vecEnd, dont_ignore_monsters, edict(), &trace );
m_pFlame[i]->PointEntInit( trace.vecEndPos, entindex() );
if ( i < 2 )
if( i < 2 )
m_pFlame[i]->SetColor( 255, 130, 90 );
else
m_pFlame[i]->SetColor( 0, 120, 255 );
@ -514,20 +513,20 @@ void CGargantua :: FlameCreate( void )
CSoundEnt::InsertSound( bits_SOUND_COMBAT, posGun, 384, 0.3 );
}
}
EMIT_SOUND_DYN ( edict(), CHAN_BODY, pBeamAttackSounds[ 1 ], 1.0, ATTN_NORM, 0, PITCH_NORM );
EMIT_SOUND_DYN ( edict(), CHAN_WEAPON, pBeamAttackSounds[ 2 ], 1.0, ATTN_NORM, 0, PITCH_NORM );
EMIT_SOUND_DYN( edict(), CHAN_BODY, pBeamAttackSounds[1], 1.0, ATTN_NORM, 0, PITCH_NORM );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, pBeamAttackSounds[2], 1.0, ATTN_NORM, 0, PITCH_NORM );
}
void CGargantua :: FlameControls( float angleX, float angleY )
void CGargantua::FlameControls( float angleX, float angleY )
{
if ( angleY < -180 )
if( angleY < -180 )
angleY += 360;
else if ( angleY > 180 )
else if( angleY > 180 )
angleY -= 360;
if ( angleY < -45 )
if( angleY < -45 )
angleY = -45;
else if ( angleY > 45 )
else if( angleY > 45 )
angleY = 45;
m_flameX = UTIL_ApproachAngle( angleX, m_flameX, 4 );
@ -536,7 +535,7 @@ void CGargantua :: FlameControls( float angleX, float angleY )
SetBoneController( 1, m_flameX );
}
void CGargantua :: FlameUpdate( void )
void CGargantua::FlameUpdate( void )
{
int i;
static float offset[2] = { 60, -60 };
@ -544,9 +543,9 @@ void CGargantua :: FlameUpdate( void )
Vector vecStart, angleGun;
BOOL streaks = FALSE;
for ( i = 0; i < 2; i++ )
for( i = 0; i < 2; i++ )
{
if ( m_pFlame[i] )
if( m_pFlame[i] )
{
Vector vecAim = pev->angles;
vecAim.x += m_flameX;
@ -554,19 +553,19 @@ void CGargantua :: FlameUpdate( void )
UTIL_MakeVectors( vecAim );
GetAttachment( i+1, vecStart, angleGun );
Vector vecEnd = vecStart + (gpGlobals->v_forward * GARG_FLAME_LENGTH); // - offset[i] * gpGlobals->v_right;
GetAttachment( i + 1, vecStart, angleGun );
Vector vecEnd = vecStart + ( gpGlobals->v_forward * GARG_FLAME_LENGTH ); // - offset[i] * gpGlobals->v_right;
UTIL_TraceLine( vecStart, vecEnd, dont_ignore_monsters, edict(), &trace );
m_pFlame[i]->SetStartPos( trace.vecEndPos );
m_pFlame[i+2]->SetStartPos( (vecStart * 0.6) + (trace.vecEndPos * 0.4) );
m_pFlame[i+2]->SetStartPos( ( vecStart * 0.6 ) + ( trace.vecEndPos * 0.4 ) );
if ( trace.flFraction != 1.0 && gpGlobals->time > m_streakTime )
if( trace.flFraction != 1.0 && gpGlobals->time > m_streakTime )
{
StreakSplash( trace.vecEndPos, trace.vecPlaneNormal, 6, 20, 50, 400 );
streaks = TRUE;
UTIL_DecalTrace( &trace, DECAL_SMALLSCORCH1 + RANDOM_LONG(0,2) );
UTIL_DecalTrace( &trace, DECAL_SMALLSCORCH1 + RANDOM_LONG( 0, 2 ) );
}
// RadiusDamage( trace.vecEndPos, pev, pev, gSkillData.gargantuaDmgFire, CLASS_ALIEN_MONSTER, DMG_BURN );
@ -574,7 +573,7 @@ void CGargantua :: FlameUpdate( void )
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE( TE_ELIGHT );
WRITE_SHORT( entindex( ) + 0x1000 * (i + 2) ); // entity, attachment
WRITE_SHORT( entindex() + 0x1000 * ( i + 2 ) ); // entity, attachment
WRITE_COORD( vecStart.x ); // origin
WRITE_COORD( vecStart.y );
WRITE_COORD( vecStart.z );
@ -587,56 +586,57 @@ void CGargantua :: FlameUpdate( void )
MESSAGE_END();
}
}
if ( streaks )
if( streaks )
m_streakTime = gpGlobals->time;
}
void CGargantua :: FlameDamage( Vector vecStart, Vector vecEnd, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType )
void CGargantua::FlameDamage( Vector vecStart, Vector vecEnd, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType )
{
CBaseEntity *pEntity = NULL;
TraceResult tr;
float flAdjustedDamage;
Vector vecSpot;
Vector vecMid = (vecStart + vecEnd) * 0.5;
Vector vecMid = ( vecStart + vecEnd ) * 0.5;
float searchRadius = (vecStart - vecMid).Length();
float searchRadius = ( vecStart - vecMid).Length();
Vector vecAim = (vecEnd - vecStart).Normalize( );
Vector vecAim = ( vecEnd - vecStart ).Normalize();
// iterate on all entities in the vicinity.
while ((pEntity = UTIL_FindEntityInSphere( pEntity, vecMid, searchRadius )) != NULL)
while( ( pEntity = UTIL_FindEntityInSphere( pEntity, vecMid, searchRadius ) ) != NULL )
{
if ( pEntity->pev->takedamage != DAMAGE_NO )
if( pEntity->pev->takedamage != DAMAGE_NO )
{
// UNDONE: this should check a damage mask, not an ignore
if ( iClassIgnore != CLASS_NONE && pEntity->Classify() == iClassIgnore )
{// houndeyes don't hurt other houndeyes with their attack
if( iClassIgnore != CLASS_NONE && pEntity->Classify() == iClassIgnore )
{
// houndeyes don't hurt other houndeyes with their attack
continue;
}
vecSpot = pEntity->BodyTarget( vecMid );
float dist = DotProduct( vecAim, vecSpot - vecMid );
if (dist > searchRadius)
if( dist > searchRadius )
dist = searchRadius;
else if (dist < -searchRadius)
else if( dist < -searchRadius )
dist = searchRadius;
Vector vecSrc = vecMid + dist * vecAim;
UTIL_TraceLine ( vecSrc, vecSpot, dont_ignore_monsters, ENT(pev), &tr );
UTIL_TraceLine( vecSrc, vecSpot, dont_ignore_monsters, ENT( pev ), &tr );
if ( tr.flFraction == 1.0 || tr.pHit == pEntity->edict() )
if( tr.flFraction == 1.0 || tr.pHit == pEntity->edict() )
{
// the explosion can 'see' this entity, so hurt them!
// decrease damage for an ent that's farther from the flame.
dist = ( vecSrc - tr.vecEndPos ).Length();
if (dist > 64)
if( dist > 64 )
{
flAdjustedDamage = flDamage - (dist - 64) * 0.4;
if (flAdjustedDamage <= 0)
flAdjustedDamage = flDamage - ( dist - 64 ) * 0.4;
if( flAdjustedDamage <= 0 )
continue;
}
else
@ -645,29 +645,29 @@ void CGargantua :: FlameDamage( Vector vecStart, Vector vecEnd, entvars_t *pevIn
}
// ALERT( at_console, "hit %s\n", STRING( pEntity->pev->classname ) );
if (tr.flFraction != 1.0)
if( tr.flFraction != 1.0 )
{
ClearMultiDamage( );
pEntity->TraceAttack( pevInflictor, flAdjustedDamage, (tr.vecEndPos - vecSrc).Normalize( ), &tr, bitsDamageType );
ClearMultiDamage();
pEntity->TraceAttack( pevInflictor, flAdjustedDamage, ( tr.vecEndPos - vecSrc ).Normalize(), &tr, bitsDamageType );
ApplyMultiDamage( pevInflictor, pevAttacker );
}
else
{
pEntity->TakeDamage ( pevInflictor, pevAttacker, flAdjustedDamage, bitsDamageType );
pEntity->TakeDamage( pevInflictor, pevAttacker, flAdjustedDamage, bitsDamageType );
}
}
}
}
}
void CGargantua :: FlameDestroy( void )
void CGargantua::FlameDestroy( void )
{
int i;
EMIT_SOUND_DYN ( edict(), CHAN_WEAPON, pBeamAttackSounds[ 0 ], 1.0, ATTN_NORM, 0, PITCH_NORM );
for ( i = 0; i < 4; i++ )
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, pBeamAttackSounds[0], 1.0, ATTN_NORM, 0, PITCH_NORM );
for( i = 0; i < 4; i++ )
{
if ( m_pFlame[i] )
if( m_pFlame[i] )
{
UTIL_Remove( m_pFlame[i] );
m_pFlame[i] = NULL;
@ -675,9 +675,9 @@ void CGargantua :: FlameDestroy( void )
}
}
void CGargantua :: PrescheduleThink( void )
void CGargantua::PrescheduleThink( void )
{
if ( !HasConditions( bits_COND_SEE_ENEMY ) )
if( !HasConditions( bits_COND_SEE_ENEMY ) )
{
m_seeTime = gpGlobals->time + 5;
EyeOff();
@ -692,7 +692,7 @@ void CGargantua :: PrescheduleThink( void )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CGargantua :: Classify ( void )
int CGargantua::Classify( void )
{
return CLASS_ALIEN_MONSTER;
}
@ -701,7 +701,7 @@ int CGargantua :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CGargantua :: SetYawSpeed ( void )
void CGargantua::SetYawSpeed( void )
{
int ys;
@ -729,11 +729,11 @@ void CGargantua :: SetYawSpeed ( void )
//=========================================================
// Spawn
//=========================================================
void CGargantua :: Spawn()
void CGargantua::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/garg.mdl");
SET_MODEL( ENT( pev ), "models/garg.mdl" );
UTIL_SetSize( pev, Vector( -32, -32, 0 ), Vector( 32, 32, 64 ) );
pev->solid = SOLID_SLIDEBOX;
@ -757,11 +757,11 @@ void CGargantua :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CGargantua :: Precache()
void CGargantua::Precache()
{
int i;
PRECACHE_MODEL("models/garg.mdl");
PRECACHE_MODEL( "models/garg.mdl" );
PRECACHE_MODEL( GARG_EYE_SPRITE_NAME );
PRECACHE_MODEL( GARG_BEAM_SPRITE_NAME );
PRECACHE_MODEL( GARG_BEAM_SPRITE2 );
@ -769,70 +769,70 @@ void CGargantua :: Precache()
gGargGibModel = PRECACHE_MODEL( GARG_GIB_MODEL );
PRECACHE_SOUND( GARG_STOMP_BUZZ_SOUND );
for ( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
PRECACHE_SOUND((char *)pAttackHitSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackHitSounds[i] );
for ( i = 0; i < ARRAYSIZE( pBeamAttackSounds ); i++ )
PRECACHE_SOUND((char *)pBeamAttackSounds[i]);
for( i = 0; i < ARRAYSIZE( pBeamAttackSounds ); i++ )
PRECACHE_SOUND( (char *)pBeamAttackSounds[i] );
for ( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
PRECACHE_SOUND((char *)pAttackMissSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackMissSounds[i] );
for ( i = 0; i < ARRAYSIZE( pRicSounds ); i++ )
PRECACHE_SOUND((char *)pRicSounds[i]);
for( i = 0; i < ARRAYSIZE( pRicSounds ); i++ )
PRECACHE_SOUND( (char *)pRicSounds[i] );
for ( i = 0; i < ARRAYSIZE( pFootSounds ); i++ )
PRECACHE_SOUND((char *)pFootSounds[i]);
for( i = 0; i < ARRAYSIZE( pFootSounds ); i++ )
PRECACHE_SOUND( (char *)pFootSounds[i] );
for ( i = 0; i < ARRAYSIZE( pIdleSounds ); i++ )
PRECACHE_SOUND((char *)pIdleSounds[i]);
for( i = 0; i < ARRAYSIZE( pIdleSounds ); i++ )
PRECACHE_SOUND( (char *)pIdleSounds[i] );
for ( i = 0; i < ARRAYSIZE( pAlertSounds ); i++ )
for( i = 0; i < ARRAYSIZE( pAlertSounds ); i++ )
PRECACHE_SOUND((char *)pAlertSounds[i]);
for ( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
PRECACHE_SOUND((char *)pPainSounds[i]);
for( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
PRECACHE_SOUND( (char *)pPainSounds[i] );
for ( i = 0; i < ARRAYSIZE( pAttackSounds ); i++ )
PRECACHE_SOUND((char *)pAttackSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackSounds[i] );
for ( i = 0; i < ARRAYSIZE( pStompSounds ); i++ )
PRECACHE_SOUND((char *)pStompSounds[i]);
for( i = 0; i < ARRAYSIZE( pStompSounds ); i++ )
PRECACHE_SOUND( (char *)pStompSounds[i] );
for ( i = 0; i < ARRAYSIZE( pBreatheSounds ); i++ )
PRECACHE_SOUND((char *)pBreatheSounds[i]);
for( i = 0; i < ARRAYSIZE( pBreatheSounds ); i++ )
PRECACHE_SOUND( (char *)pBreatheSounds[i] );
}
void CGargantua::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
{
ALERT( at_aiconsole, "CGargantua::TraceAttack\n");
ALERT( at_aiconsole, "CGargantua::TraceAttack\n" );
if ( !IsAlive() )
if( !IsAlive() )
{
CBaseMonster::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
return;
}
// UNDONE: Hit group specific damage?
if ( bitsDamageType & (GARG_DAMAGE|DMG_BLAST) )
if( bitsDamageType & ( GARG_DAMAGE | DMG_BLAST ) )
{
if ( m_painSoundTime < gpGlobals->time )
if( m_painSoundTime < gpGlobals->time )
{
EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, pPainSounds[ RANDOM_LONG(0,ARRAYSIZE(pPainSounds)-1) ], 1.0, ATTN_GARG, 0, PITCH_NORM );
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, pPainSounds[RANDOM_LONG( 0, ARRAYSIZE( pPainSounds ) - 1 )], 1.0, ATTN_GARG, 0, PITCH_NORM );
m_painSoundTime = gpGlobals->time + RANDOM_FLOAT( 2.5, 4 );
}
}
bitsDamageType &= GARG_DAMAGE;
if ( bitsDamageType == 0)
if( bitsDamageType == 0 )
{
if ( pev->dmgtime != gpGlobals->time || (RANDOM_LONG(0,100) < 20) )
if( pev->dmgtime != gpGlobals->time || (RANDOM_LONG( 0, 100 ) < 20 ) )
{
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT(0.5,1.5) );
UTIL_Ricochet( ptr->vecEndPos, RANDOM_FLOAT( 0.5 ,1.5 ) );
pev->dmgtime = gpGlobals->time;
// if ( RANDOM_LONG(0,100) < 25 )
// EMIT_SOUND_DYN( ENT(pev), CHAN_BODY, pRicSounds[ RANDOM_LONG(0,ARRAYSIZE(pRicSounds)-1) ], 1.0, ATTN_NORM, 0, PITCH_NORM );
//if ( RANDOM_LONG( 0, 100 ) < 25 )
// EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, pRicSounds[RANDOM_LONG( 0, ARRAYSIZE( pRicSounds ) - 1 )], 1.0, ATTN_NORM, 0, PITCH_NORM );
}
flDamage = 0;
}
@ -842,13 +842,13 @@ void CGargantua::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vec
int CGargantua::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
ALERT( at_aiconsole, "CGargantua::TakeDamage\n");
ALERT( at_aiconsole, "CGargantua::TakeDamage\n" );
if ( IsAlive() )
if( IsAlive() )
{
if ( !(bitsDamageType & GARG_DAMAGE) )
if( !( bitsDamageType & GARG_DAMAGE ) )
flDamage *= 0.01;
if ( bitsDamageType & DMG_BLAST )
if( bitsDamageType & DMG_BLAST )
SetConditions( bits_COND_LIGHT_DAMAGE );
}
@ -858,17 +858,17 @@ int CGargantua::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, flo
void CGargantua::DeathEffect( void )
{
int i;
UTIL_MakeVectors(pev->angles);
UTIL_MakeVectors( pev->angles );
Vector deathPos = pev->origin + gpGlobals->v_forward * 100;
// Create a spiral of streaks
CSpiral::Create( deathPos, (pev->absmax.z - pev->absmin.z) * 0.6, 125, 1.5 );
CSpiral::Create( deathPos, ( pev->absmax.z - pev->absmin.z ) * 0.6, 125, 1.5 );
Vector position = pev->origin;
position.z += 32;
for ( i = 0; i < 7; i+=2 )
for( i = 0; i < 7; i+=2 )
{
SpawnExplosion( position, 70, (i * 0.3), 60 + (i*20) );
SpawnExplosion( position, 70, ( i * 0.3 ), 60 + ( i * 20 ) );
position.z += 15;
}
@ -894,11 +894,11 @@ void CGargantua::Killed( entvars_t *pevAttacker, int iGib )
//=========================================================
BOOL CGargantua::CheckMeleeAttack1( float flDot, float flDist )
{
// ALERT(at_aiconsole, "CheckMelee(%f, %f)\n", flDot, flDist);
//ALERT( at_aiconsole, "CheckMelee(%f, %f)\n", flDot, flDist );
if (flDot >= 0.7)
if( flDot >= 0.7 )
{
if (flDist <= GARG_ATTACKDIST)
if( flDist <= GARG_ATTACKDIST )
return TRUE;
}
return FALSE;
@ -907,11 +907,11 @@ BOOL CGargantua::CheckMeleeAttack1( float flDot, float flDist )
// Flame thrower madness!
BOOL CGargantua::CheckMeleeAttack2( float flDot, float flDist )
{
// ALERT(at_aiconsole, "CheckMelee(%f, %f)\n", flDot, flDist);
//ALERT( at_aiconsole, "CheckMelee(%f, %f)\n", flDot, flDist );
if ( gpGlobals->time > m_flameTime )
if( gpGlobals->time > m_flameTime )
{
if (flDot >= 0.8 && flDist > GARG_ATTACKDIST)
if( flDot >= 0.8 && flDist > GARG_ATTACKDIST )
{
if ( flDist <= GARG_FLAME_LENGTH )
return TRUE;
@ -931,9 +931,9 @@ BOOL CGargantua::CheckMeleeAttack2( float flDot, float flDist )
//=========================================================
BOOL CGargantua::CheckRangeAttack1( float flDot, float flDist )
{
if ( gpGlobals->time > m_seeTime )
if( gpGlobals->time > m_seeTime )
{
if (flDot >= 0.7 && flDist > GARG_ATTACKDIST)
if( flDot >= 0.7 && flDist > GARG_ATTACKDIST )
{
return TRUE;
}
@ -945,7 +945,7 @@ BOOL CGargantua::CheckRangeAttack1( float flDot, float flDist )
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CGargantua::HandleAnimEvent(MonsterEvent_t *pEvent)
void CGargantua::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -953,43 +953,39 @@ void CGargantua::HandleAnimEvent(MonsterEvent_t *pEvent)
{
// HACKHACK!!!
CBaseEntity *pHurt = GargantuaCheckTraceHullAttack( GARG_ATTACKDIST + 10.0, gSkillData.gargantuaDmgSlash, DMG_SLASH );
if (pHurt)
if( pHurt )
{
if ( pHurt->pev->flags & (FL_MONSTER|FL_CLIENT) )
if( pHurt->pev->flags & ( FL_MONSTER | FL_CLIENT ) )
{
pHurt->pev->punchangle.x = -30; // pitch
pHurt->pev->punchangle.y = -30; // yaw
pHurt->pev->punchangle.z = 30; // roll
//UTIL_MakeVectors(pev->angles); // called by CheckTraceHullAttack
//UTIL_MakeVectors( pev->angles ); // called by CheckTraceHullAttack
pHurt->pev->velocity = pHurt->pev->velocity - gpGlobals->v_right * 100;
}
EMIT_SOUND_DYN ( edict(), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, 50 + RANDOM_LONG(0,15) );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, pAttackHitSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackHitSounds ) - 1 )], 1.0, ATTN_NORM, 0, 50 + RANDOM_LONG( 0, 15 ) );
}
else // Play a random attack miss sound
EMIT_SOUND_DYN ( edict(), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, 50 + RANDOM_LONG(0,15) );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, pAttackMissSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackMissSounds ) - 1 )], 1.0, ATTN_NORM, 0, 50 + RANDOM_LONG( 0, 15 ) );
Vector forward;
UTIL_MakeVectorsPrivate( pev->angles, forward, NULL, NULL );
}
break;
case GARG_AE_RIGHT_FOOT:
case GARG_AE_LEFT_FOOT:
UTIL_ScreenShake( pev->origin, 4.0, 3.0, 1.0, 750 );
EMIT_SOUND_DYN ( edict(), CHAN_BODY, pFootSounds[ RANDOM_LONG(0,ARRAYSIZE(pFootSounds)-1) ], 1.0, ATTN_GARG, 0, PITCH_NORM + RANDOM_LONG(-10,10) );
EMIT_SOUND_DYN( edict(), CHAN_BODY, pFootSounds[RANDOM_LONG( 0, ARRAYSIZE( pFootSounds ) - 1 )], 1.0, ATTN_GARG, 0, PITCH_NORM + RANDOM_LONG( -10, 10 ) );
break;
case GARG_AE_STOMP:
StompAttack();
m_seeTime = gpGlobals->time + 12;
break;
case GARG_AE_BREATHE:
EMIT_SOUND_DYN ( edict(), CHAN_VOICE, pBreatheSounds[ RANDOM_LONG(0,ARRAYSIZE(pBreatheSounds)-1) ], 1.0, ATTN_GARG, 0, PITCH_NORM + RANDOM_LONG(-10,10) );
EMIT_SOUND_DYN( edict(), CHAN_VOICE, pBreatheSounds[RANDOM_LONG( 0, ARRAYSIZE( pBreatheSounds ) - 1 )], 1.0, ATTN_GARG, 0, PITCH_NORM + RANDOM_LONG( -10, 10 ) );
break;
default:
CBaseMonster::HandleAnimEvent(pEvent);
CBaseMonster::HandleAnimEvent( pEvent );
break;
}
}
@ -1012,15 +1008,15 @@ CBaseEntity* CGargantua::GargantuaCheckTraceHullAttack(float flDist, int iDamage
UTIL_MakeVectors( pev->angles );
Vector vecStart = pev->origin;
vecStart.z += 64;
Vector vecEnd = vecStart + (gpGlobals->v_forward * flDist) - (gpGlobals->v_up * flDist * 0.3);
Vector vecEnd = vecStart + ( gpGlobals->v_forward * flDist ) - ( gpGlobals->v_up * flDist * 0.3 );
UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr );
UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT( pev ), &tr );
if ( tr.pHit )
if( tr.pHit )
{
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
if ( iDamage > 0 )
if( iDamage > 0 )
{
pEntity->TakeDamage( pev, pev, iDamage, iDmgType );
}
@ -1034,7 +1030,7 @@ CBaseEntity* CGargantua::GargantuaCheckTraceHullAttack(float flDist, int iDamage
Schedule_t *CGargantua::GetScheduleOfType( int Type )
{
// HACKHACK - turn off the flames if they are on and garg goes scripted / dead
if ( FlameIsOn() )
if( FlameIsOn() )
FlameDestroy();
switch( Type )
@ -1051,7 +1047,7 @@ Schedule_t *CGargantua::GetScheduleOfType( int Type )
void CGargantua::StartTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_FLAME_SWEEP:
FlameCreate();
@ -1060,13 +1056,11 @@ void CGargantua::StartTask( Task_t *pTask )
m_flameX = 0;
m_flameY = 0;
break;
case TASK_SOUND_ATTACK:
if ( RANDOM_LONG(0,100) < 30 )
EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, pAttackSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackSounds)-1) ], 1.0, ATTN_GARG, 0, PITCH_NORM );
if( RANDOM_LONG( 0, 100 ) < 30 )
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, pAttackSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackSounds ) - 1 )], 1.0, ATTN_GARG, 0, PITCH_NORM );
TaskComplete();
break;
case TASK_DIE:
m_flWaitFinished = gpGlobals->time + 1.6;
DeathEffect();
@ -1082,10 +1076,10 @@ void CGargantua::StartTask( Task_t *pTask )
//=========================================================
void CGargantua::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_DIE:
if ( gpGlobals->time > m_flWaitFinished )
if( gpGlobals->time > m_flWaitFinished )
{
pev->renderfx = kRenderFxExplode;
pev->rendercolor.x = 255;
@ -1096,15 +1090,15 @@ void CGargantua::RunTask( Task_t *pTask )
SetThink( &CBaseEntity::SUB_Remove );
int i;
int parts = MODEL_FRAMES( gGargGibModel );
for ( i = 0; i < 10; i++ )
for( i = 0; i < 10; i++ )
{
CGib *pGib = GetClassPtr( (CGib *)NULL );
pGib->Spawn( GARG_GIB_MODEL );
int bodyPart = 0;
if ( parts > 1 )
bodyPart = RANDOM_LONG( 0, pev->body-1 );
if( parts > 1 )
bodyPart = RANDOM_LONG( 0, pev->body - 1 );
pGib->pev->body = bodyPart;
pGib->m_bloodColor = BLOOD_COLOR_YELLOW;
@ -1115,7 +1109,7 @@ void CGargantua::RunTask( Task_t *pTask )
pGib->SetThink( &CBaseEntity::SUB_FadeOut );
}
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_BREAKMODEL);
WRITE_BYTE( TE_BREAKMODEL );
// position
WRITE_COORD( pev->origin.x );
@ -1152,10 +1146,10 @@ void CGargantua::RunTask( Task_t *pTask )
return;
}
else
CBaseMonster::RunTask(pTask);
CBaseMonster::RunTask( pTask );
break;
case TASK_FLAME_SWEEP:
if ( gpGlobals->time > m_flWaitFinished )
if( gpGlobals->time > m_flWaitFinished )
{
FlameDestroy();
TaskComplete();
@ -1171,26 +1165,26 @@ void CGargantua::RunTask( Task_t *pTask )
FlameUpdate();
CBaseEntity *pEnemy = m_hEnemy;
if ( pEnemy )
if( pEnemy )
{
Vector org = pev->origin;
org.z += 64;
Vector dir = pEnemy->BodyTarget(org) - org;
Vector dir = pEnemy->BodyTarget( org ) - org;
angles = UTIL_VecToAngles( dir );
angles.x = -angles.x;
angles.y -= pev->angles.y;
if ( dir.Length() > 400 )
if( dir.Length() > 400 )
cancel = TRUE;
}
if ( fabs(angles.y) > 60 )
if( fabs(angles.y) > 60 )
cancel = TRUE;
if ( cancel )
if( cancel )
{
m_flWaitFinished -= 0.5;
m_flameTime -= 0.5;
}
// FlameControls( angles.x + 2 * sin(gpGlobals->time*8), angles.y + 28 * sin(gpGlobals->time*8.5) );
// FlameControls( angles.x + 2 * sin( gpGlobals->time * 8 ), angles.y + 28 * sin( gpGlobals->time * 8.5 ) );
FlameControls( angles.x, angles.y );
}
break;
@ -1224,17 +1218,17 @@ void CSmoker::Think( void )
// lots of smoke
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_SMOKE );
WRITE_COORD( pev->origin.x + RANDOM_FLOAT( -pev->dmg, pev->dmg ));
WRITE_COORD( pev->origin.y + RANDOM_FLOAT( -pev->dmg, pev->dmg ));
WRITE_COORD( pev->origin.x + RANDOM_FLOAT( -pev->dmg, pev->dmg ) );
WRITE_COORD( pev->origin.y + RANDOM_FLOAT( -pev->dmg, pev->dmg ) );
WRITE_COORD( pev->origin.z);
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( RANDOM_LONG(pev->scale, pev->scale * 1.1) );
WRITE_BYTE( RANDOM_LONG(8,14) ); // framerate
WRITE_BYTE( RANDOM_LONG(pev->scale, pev->scale * 1.1 ) );
WRITE_BYTE( RANDOM_LONG( 8, 14 ) ); // framerate
MESSAGE_END();
pev->health--;
if ( pev->health > 0 )
pev->nextthink = gpGlobals->time + RANDOM_FLOAT(0.1, 0.2);
if( pev->health > 0 )
pev->nextthink = gpGlobals->time + RANDOM_FLOAT( 0.1, 0.2 );
else
UTIL_Remove( this );
}
@ -1244,14 +1238,14 @@ void CSpiral::Spawn( void )
pev->movetype = MOVETYPE_NONE;
pev->nextthink = gpGlobals->time;
pev->solid = SOLID_NOT;
UTIL_SetSize(pev, g_vecZero, g_vecZero );
UTIL_SetSize( pev, g_vecZero, g_vecZero );
pev->effects |= EF_NODRAW;
pev->angles = g_vecZero;
}
CSpiral *CSpiral::Create( const Vector &origin, float height, float radius, float duration )
{
if ( duration <= 0 )
if( duration <= 0 )
return NULL;
CSpiral *pSpiral = GetClassPtr( (CSpiral *)NULL );
@ -1273,22 +1267,22 @@ void CSpiral::Think( void )
{
float time = gpGlobals->time - pev->dmgtime;
while ( time > SPIRAL_INTERVAL )
while( time > SPIRAL_INTERVAL )
{
Vector position = pev->origin;
Vector direction = Vector(0,0,1);
float fraction = 1.0 / pev->speed;
float radius = (pev->scale * pev->health) * fraction;
float radius = ( pev->scale * pev->health ) * fraction;
position.z += (pev->health * pev->dmg) * fraction;
pev->angles.y = (pev->health * 360 * 8) * fraction;
position.z += ( pev->health * pev->dmg ) * fraction;
pev->angles.y = ( pev->health * 360 * 8 ) * fraction;
UTIL_MakeVectors( pev->angles );
position = position + gpGlobals->v_forward * radius;
direction = (direction + gpGlobals->v_forward).Normalize();
direction = ( direction + gpGlobals->v_forward ).Normalize();
StreakSplash( position, Vector(0,0,1), RANDOM_LONG(8,11), 20, RANDOM_LONG(50,150), 400 );
StreakSplash( position, Vector( 0, 0, 1 ), RANDOM_LONG( 8, 11 ), 20, RANDOM_LONG( 50, 150 ), 400 );
// Jeez, how many counters should this take ? :)
pev->dmgtime += SPIRAL_INTERVAL;
@ -1298,7 +1292,7 @@ void CSpiral::Think( void )
pev->nextthink = gpGlobals->time;
if ( pev->health >= pev->speed )
if( pev->health >= pev->speed )
UTIL_Remove( this );
}

201
dlls/gauss.cpp
View File

@ -28,7 +28,8 @@
#define GAUSS_PRIMARY_CHARGE_VOLUME 256// how loud gauss is while charging
#define GAUSS_PRIMARY_FIRE_VOLUME 450// how loud gauss is when discharged
enum gauss_e {
enum gauss_e
{
GAUSS_IDLE = 0,
GAUSS_IDLE2,
GAUSS_FIDGET,
@ -45,9 +46,9 @@ LINK_ENTITY_TO_CLASS( weapon_gauss, CGauss )
float CGauss::GetFullChargeTime( void )
{
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
return 1.5;
@ -60,11 +61,11 @@ float CGauss::GetFullChargeTime( void )
extern int g_irunninggausspred;
#endif
void CGauss::Spawn( )
void CGauss::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_GAUSS;
SET_MODEL(ENT(pev), "models/w_gauss.mdl");
SET_MODEL( ENT( pev ), "models/w_gauss.mdl" );
m_iDefaultAmmo = GAUSS_DEFAULT_GIVE;
@ -73,17 +74,17 @@ void CGauss::Spawn( )
void CGauss::Precache( void )
{
PRECACHE_MODEL("models/w_gauss.mdl");
PRECACHE_MODEL("models/v_gauss.mdl");
PRECACHE_MODEL("models/p_gauss.mdl");
PRECACHE_MODEL( "models/w_gauss.mdl" );
PRECACHE_MODEL( "models/v_gauss.mdl" );
PRECACHE_MODEL( "models/p_gauss.mdl" );
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_SOUND( "items/9mmclip1.wav" );
PRECACHE_SOUND("weapons/gauss2.wav");
PRECACHE_SOUND("weapons/electro4.wav");
PRECACHE_SOUND("weapons/electro5.wav");
PRECACHE_SOUND("weapons/electro6.wav");
PRECACHE_SOUND("ambience/pulsemachine.wav");
PRECACHE_SOUND( "weapons/gauss2.wav" );
PRECACHE_SOUND( "weapons/electro4.wav" );
PRECACHE_SOUND( "weapons/electro5.wav" );
PRECACHE_SOUND( "weapons/electro6.wav" );
PRECACHE_SOUND( "ambience/pulsemachine.wav" );
m_iGlow = PRECACHE_MODEL( "sprites/hotglow.spr" );
m_iBalls = PRECACHE_MODEL( "sprites/hotglow.spr" );
@ -95,7 +96,7 @@ void CGauss::Precache( void )
int CGauss::AddToPlayer( CBasePlayer *pPlayer )
{
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
WRITE_BYTE( m_iId );
@ -105,9 +106,9 @@ int CGauss::AddToPlayer( CBasePlayer *pPlayer )
return FALSE;
}
int CGauss::GetItemInfo(ItemInfo *p)
int CGauss::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "uranium";
p->iMaxAmmo1 = URANIUM_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -122,7 +123,7 @@ int CGauss::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CGauss::Deploy( )
BOOL CGauss::Deploy()
{
m_pPlayer->m_flPlayAftershock = 0.0;
return DefaultDeploy( "models/v_gauss.mdl", "models/p_gauss.mdl", GAUSS_DRAW, "gauss" );
@ -141,16 +142,16 @@ void CGauss::Holster( int skiplocal /* = 0 */ )
void CGauss::PrimaryAttack()
{
// don't fire underwater
if ( m_pPlayer->pev->waterlevel == 3 )
if( m_pPlayer->pev->waterlevel == 3 )
{
PlayEmptySound( );
PlayEmptySound();
m_flNextSecondaryAttack = m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.15;
return;
}
if ( m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] < 2 )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] < 2 )
{
PlayEmptySound( );
PlayEmptySound();
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
return;
}
@ -169,28 +170,28 @@ void CGauss::PrimaryAttack()
void CGauss::SecondaryAttack()
{
// don't fire underwater
if ( m_pPlayer->pev->waterlevel == 3 )
if( m_pPlayer->pev->waterlevel == 3 )
{
if ( m_fInAttack != 0 )
if( m_fInAttack != 0 )
{
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/electro4.wav", 1.0, ATTN_NORM, 0, 80 + RANDOM_LONG(0,0x3f));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/electro4.wav", 1.0, ATTN_NORM, 0, 80 + RANDOM_LONG( 0, 0x3f ) );
SendWeaponAnim( GAUSS_IDLE );
m_fInAttack = 0;
}
else
{
PlayEmptySound( );
PlayEmptySound();
}
m_flNextSecondaryAttack = m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.5;
return;
}
if ( m_fInAttack == 0 )
if( m_fInAttack == 0 )
{
if ( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
{
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/357_cock1.wav", 0.8, ATTN_NORM);
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/357_cock1.wav", 0.8, ATTN_NORM );
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
return;
}
@ -213,9 +214,9 @@ void CGauss::SecondaryAttack()
m_iSoundState = SND_CHANGE_PITCH;
}
else if (m_fInAttack == 1)
else if( m_fInAttack == 1 )
{
if (m_flTimeWeaponIdle < UTIL_WeaponTimeBase())
if( m_flTimeWeaponIdle < UTIL_WeaponTimeBase() )
{
SendWeaponAnim( GAUSS_SPIN );
m_fInAttack = 2;
@ -224,12 +225,12 @@ void CGauss::SecondaryAttack()
else
{
// during the charging process, eat one bit of ammo every once in a while
if ( UTIL_WeaponTimeBase() >= m_pPlayer->m_flNextAmmoBurn && m_pPlayer->m_flNextAmmoBurn != 1000 )
if( UTIL_WeaponTimeBase() >= m_pPlayer->m_flNextAmmoBurn && m_pPlayer->m_flNextAmmoBurn != 1000 )
{
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;
@ -242,7 +243,7 @@ void CGauss::SecondaryAttack()
}
}
if ( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
{
// out of ammo! force the gun to fire
StartFire();
@ -252,19 +253,19 @@ void CGauss::SecondaryAttack()
return;
}
if ( UTIL_WeaponTimeBase() >= m_pPlayer->m_flAmmoStartCharge )
if( UTIL_WeaponTimeBase() >= m_pPlayer->m_flAmmoStartCharge )
{
// don't eat any more ammo after gun is fully charged.
m_pPlayer->m_flNextAmmoBurn = 1000;
}
int pitch = ( gpGlobals->time - m_pPlayer->m_flStartCharge ) * ( 150 / GetFullChargeTime() ) + 100;
if ( pitch > 250 )
if( pitch > 250 )
pitch = 250;
// ALERT( at_console, "%d %d %d\n", m_fInAttack, m_iSoundState, pitch );
if ( m_iSoundState == 0 )
if( m_iSoundState == 0 )
ALERT( at_console, "sound state %d\n", m_iSoundState );
PLAYBACK_EVENT_FULL( FEV_NOTHOST, m_pPlayer->edict(), m_usGaussSpin, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, pitch, 0, ( m_iSoundState == SND_CHANGE_PITCH ) ? 1 : 0, 0 );
@ -274,19 +275,18 @@ void CGauss::SecondaryAttack()
m_pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_CHARGE_VOLUME;
// m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 0.1;
if ( m_pPlayer->m_flStartCharge < gpGlobals->time - 10 )
if( m_pPlayer->m_flStartCharge < gpGlobals->time - 10 )
{
// Player charged up too long. Zap him.
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/electro4.wav", 1.0, ATTN_NORM, 0, 80 + RANDOM_LONG(0,0x3f));
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/electro6.wav", 1.0, ATTN_NORM, 0, 75 + RANDOM_LONG(0,0x3f));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/electro4.wav", 1.0, ATTN_NORM, 0, 80 + RANDOM_LONG( 0, 0x3f ) );
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/electro6.wav", 1.0, ATTN_NORM, 0, 75 + RANDOM_LONG( 0, 0x3f ) );
m_fInAttack = 0;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 1.0;
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 1.0;
#ifndef CLIENT_DLL
m_pPlayer->TakeDamage( VARS(eoNullEntity), VARS(eoNullEntity), 50, DMG_SHOCK );
UTIL_ScreenFade( m_pPlayer, Vector(255,128,0), 2, 0.5, 128, FFADE_IN );
m_pPlayer->TakeDamage( VARS( eoNullEntity ), VARS( eoNullEntity ), 50, DMG_SHOCK );
UTIL_ScreenFade( m_pPlayer, Vector( 255, 128, 0 ), 2, 0.5, 128, FFADE_IN );
#endif
SendWeaponAnim( GAUSS_IDLE );
@ -308,18 +308,18 @@ void CGauss::StartFire( void )
UTIL_MakeVectors( m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle );
Vector vecAiming = gpGlobals->v_forward;
Vector vecSrc = m_pPlayer->GetGunPosition( ); // + gpGlobals->v_up * -8 + gpGlobals->v_right * 8;
Vector vecSrc = m_pPlayer->GetGunPosition(); // + gpGlobals->v_up * -8 + gpGlobals->v_right * 8;
if ( gpGlobals->time - m_pPlayer->m_flStartCharge > GetFullChargeTime() )
if( gpGlobals->time - m_pPlayer->m_flStartCharge > GetFullChargeTime() )
{
flDamage = 200;
}
else
{
flDamage = 200 * (( gpGlobals->time - m_pPlayer->m_flStartCharge) / GetFullChargeTime() );
flDamage = 200 * ( ( gpGlobals->time - m_pPlayer->m_flStartCharge ) / GetFullChargeTime() );
}
if ( m_fPrimaryFire )
if( m_fPrimaryFire )
{
// fixed damage on primary attack
#ifdef CLIENT_DLL
@ -329,18 +329,18 @@ void CGauss::StartFire( void )
#endif
}
if (m_fInAttack != 3)
if( m_fInAttack != 3 )
{
//ALERT ( at_console, "Time:%f Damage:%f\n", gpGlobals->time - m_pPlayer->m_flStartCharge, flDamage );
//ALERT( at_console, "Time:%f Damage:%f\n", gpGlobals->time - m_pPlayer->m_flStartCharge, flDamage );
#ifndef CLIENT_DLL
float flZVel = m_pPlayer->pev->velocity.z;
if ( !m_fPrimaryFire )
if( !m_fPrimaryFire )
{
m_pPlayer->pev->velocity = m_pPlayer->pev->velocity - gpGlobals->v_forward * flDamage * 5;
}
if ( !g_pGameRules->IsMultiplayer() )
if( !g_pGameRules->IsMultiplayer() )
{
// in deathmatch, gauss can pop you up into the air. Not in single play.
m_pPlayer->pev->velocity.z = flZVel;
@ -373,7 +373,7 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
pentIgnore = ENT( m_pPlayer->pev );
#ifdef CLIENT_DLL
if ( m_fPrimaryFire == false )
if( m_fPrimaryFire == false )
g_irunninggausspred = true;
#endif
// The main firing event is sent unreliably so it won't be delayed.
@ -385,7 +385,6 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
PLAYBACK_EVENT_FULL( FEV_NOTHOST | FEV_RELIABLE, m_pPlayer->edict(), m_usGaussFire, 0.01, (float *)&m_pPlayer->pev->origin, (float *)&m_pPlayer->pev->angles, 0.0, 0.0, 0, 0, 0, 1 );
/*ALERT( at_console, "%f %f %f\n%f %f %f\n",
vecSrc.x, vecSrc.y, vecSrc.z,
vecDest.x, vecDest.y, vecDest.z );*/
@ -393,22 +392,22 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
//ALERT( at_console, "%f %f\n", tr.flFraction, flMaxFrac );
#ifndef CLIENT_DLL
while (flDamage > 10 && nMaxHits > 0)
while( flDamage > 10 && nMaxHits > 0 )
{
nMaxHits--;
// ALERT( at_console, "." );
UTIL_TraceLine(vecSrc, vecDest, dont_ignore_monsters, pentIgnore, &tr);
UTIL_TraceLine( vecSrc, vecDest, dont_ignore_monsters, pentIgnore, &tr );
if (tr.fAllSolid)
if( tr.fAllSolid )
break;
CBaseEntity *pEntity = CBaseEntity::Instance(tr.pHit);
CBaseEntity *pEntity = CBaseEntity::Instance( tr.pHit );
if (pEntity == NULL)
if( pEntity == NULL )
break;
if ( fFirstBeam )
if( fFirstBeam )
{
m_pPlayer->pev->effects |= EF_MUZZLEFLASH;
fFirstBeam = 0;
@ -416,22 +415,22 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
nTotal += 26;
}
if (pEntity->pev->takedamage)
if( pEntity->pev->takedamage )
{
ClearMultiDamage();
pEntity->TraceAttack( m_pPlayer->pev, flDamage, vecDir, &tr, DMG_BULLET );
ApplyMultiDamage(m_pPlayer->pev, m_pPlayer->pev);
ApplyMultiDamage( m_pPlayer->pev, m_pPlayer->pev );
}
if ( pEntity->ReflectGauss() )
if( pEntity->ReflectGauss() )
{
float n;
pentIgnore = NULL;
n = -DotProduct(tr.vecPlaneNormal, vecDir);
n = -DotProduct( tr.vecPlaneNormal, vecDir );
if (n < 0.5) // 60 degrees
if( n < 0.5 ) // 60 degrees
{
// ALERT( at_console, "reflect %f\n", n );
// reflect
@ -449,32 +448,33 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
nTotal += 34;
// lose energy
if (n == 0) n = 0.1;
flDamage = flDamage * (1 - n);
if( n == 0 ) n = 0.1;
flDamage = flDamage * ( 1 - n );
}
else
{
nTotal += 13;
// limit it to one hole punch
if (fHasPunched)
if( fHasPunched )
break;
fHasPunched = 1;
// try punching through wall if secondary attack (primary is incapable of breaking through)
if ( !m_fPrimaryFire )
if( !m_fPrimaryFire )
{
UTIL_TraceLine( tr.vecEndPos + vecDir * 8, vecDest, dont_ignore_monsters, pentIgnore, &beam_tr);
if (!beam_tr.fAllSolid)
UTIL_TraceLine( tr.vecEndPos + vecDir * 8, vecDest, dont_ignore_monsters, pentIgnore, &beam_tr );
if( !beam_tr.fAllSolid )
{
// trace backwards to find exit point
UTIL_TraceLine( beam_tr.vecEndPos, tr.vecEndPos, dont_ignore_monsters, pentIgnore, &beam_tr);
UTIL_TraceLine( beam_tr.vecEndPos, tr.vecEndPos, dont_ignore_monsters, pentIgnore, &beam_tr );
float n = (beam_tr.vecEndPos - tr.vecEndPos).Length( );
if (n < flDamage)
if( n < flDamage )
{
if (n == 0) n = 1;
if( n == 0 )
n = 1;
flDamage -= n;
// ALERT( at_console, "punch %f\n", n );
@ -484,8 +484,7 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
//m_pPlayer->RadiusDamage( beam_tr.vecEndPos + vecDir * 8, pev, m_pPlayer->pev, flDamage, CLASS_NONE, DMG_BLAST );
float damage_radius;
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
damage_radius = flDamage * 1.75; // Old code == 2.5
}
@ -496,7 +495,7 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
::RadiusDamage( beam_tr.vecEndPos + vecDir * 8, pev, m_pPlayer->pev, flDamage, damage_radius, CLASS_NONE, DMG_BLAST );
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, NORMAL_EXPLOSION_VOLUME, 3.0 );
CSoundEnt::InsertSound( bits_SOUND_COMBAT, pev->origin, NORMAL_EXPLOSION_VOLUME, 3.0 );
nTotal += 53;
@ -530,25 +529,32 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
void CGauss::WeaponIdle( void )
{
ResetEmptySound( );
ResetEmptySound();
// play aftershock static discharge
if ( m_pPlayer->m_flPlayAftershock && m_pPlayer->m_flPlayAftershock < gpGlobals->time )
if( m_pPlayer->m_flPlayAftershock && m_pPlayer->m_flPlayAftershock < gpGlobals->time )
{
switch (RANDOM_LONG(0,3))
switch( RANDOM_LONG( 0, 3 ) )
{
case 0: EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/electro4.wav", RANDOM_FLOAT(0.7, 0.8), ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/electro5.wav", RANDOM_FLOAT(0.7, 0.8), ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/electro6.wav", RANDOM_FLOAT(0.7, 0.8), ATTN_NORM); break;
case 3: break; // no sound
case 0:
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/electro4.wav", RANDOM_FLOAT( 0.7, 0.8 ), ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/electro5.wav", RANDOM_FLOAT( 0.7, 0.8 ), ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/electro6.wav", RANDOM_FLOAT( 0.7, 0.8 ), ATTN_NORM );
break;
case 3:
break; // no sound
}
m_pPlayer->m_flPlayAftershock = 0.0;
}
if (m_flTimeWeaponIdle > UTIL_WeaponTimeBase())
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
if (m_fInAttack != 0)
if( m_fInAttack != 0 )
{
StartFire();
m_fInAttack = 0;
@ -557,13 +563,13 @@ void CGauss::WeaponIdle( void )
else
{
int iAnim;
float flRand = RANDOM_FLOAT(0, 1);
if (flRand <= 0.5)
float flRand = RANDOM_FLOAT( 0, 1 );
if( flRand <= 0.5 )
{
iAnim = GAUSS_IDLE;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
}
else if (flRand <= 0.75)
else if( flRand <= 0.75 )
{
iAnim = GAUSS_IDLE2;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
@ -574,7 +580,6 @@ void CGauss::WeaponIdle( void )
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 3;
}
SendWeaponAnim( iAnim );
}
}
@ -582,20 +587,20 @@ class CGaussAmmo : public CBasePlayerAmmo
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_gaussammo.mdl");
CBasePlayerAmmo::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_gaussammo.mdl" );
CBasePlayerAmmo::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_gaussammo.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_gaussammo.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
}
BOOL AddAmmo( CBaseEntity *pOther )
{
if (pOther->GiveAmmo( AMMO_URANIUMBOX_GIVE, "uranium", URANIUM_MAX_CARRY ) != -1)
if( pOther->GiveAmmo( AMMO_URANIUMBOX_GIVE, "uranium", URANIUM_MAX_CARRY ) != -1 )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
return TRUE;
}
return FALSE;

38
dlls/genericmonster.cpp
View File

@ -34,9 +34,9 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int Classify ( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
int ISoundMask ( void );
int ISoundMask( void );
};
LINK_ENTITY_TO_CLASS( monster_generic, CGenericMonster )
@ -45,7 +45,7 @@ LINK_ENTITY_TO_CLASS( monster_generic, CGenericMonster )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CGenericMonster :: Classify ( void )
int CGenericMonster::Classify( void )
{
return CLASS_PLAYER_ALLY;
}
@ -54,11 +54,11 @@ int CGenericMonster :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CGenericMonster :: SetYawSpeed ( void )
void CGenericMonster::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_IDLE:
default:
@ -72,7 +72,7 @@ void CGenericMonster :: SetYawSpeed ( void )
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CGenericMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CGenericMonster::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -86,7 +86,7 @@ void CGenericMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// ISoundMask - generic monster can't hear.
//=========================================================
int CGenericMonster :: ISoundMask ( void )
int CGenericMonster::ISoundMask( void )
{
return NULL;
}
@ -94,23 +94,21 @@ int CGenericMonster :: ISoundMask ( void )
//=========================================================
// Spawn
//=========================================================
void CGenericMonster :: Spawn()
void CGenericMonster::Spawn()
{
Precache();
SET_MODEL( ENT(pev), STRING(pev->model) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
/*
if ( FStrEq( STRING(pev->model), "models/player.mdl" ) )
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
if( FStrEq( STRING( pev->model ), "models/player.mdl" ) )
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
else
UTIL_SetSize(pev, VEC_HULL_MIN, VEC_HULL_MAX);
UTIL_SetSize( pev, VEC_HULL_MIN, VEC_HULL_MAX);
*/
if ( FStrEq( STRING(pev->model), "models/player.mdl" ) || FStrEq( STRING(pev->model), "models/holo.mdl" ) )
UTIL_SetSize(pev, VEC_HULL_MIN, VEC_HULL_MAX);
if( FStrEq( STRING( pev->model ), "models/player.mdl" ) || FStrEq( STRING( pev->model ), "models/holo.mdl" ) )
UTIL_SetSize( pev, VEC_HULL_MIN, VEC_HULL_MAX );
else
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
@ -121,7 +119,7 @@ void CGenericMonster :: Spawn()
MonsterInit();
if ( pev->spawnflags & SF_GENERICMONSTER_NOTSOLID )
if( pev->spawnflags & SF_GENERICMONSTER_NOTSOLID )
{
pev->solid = SOLID_NOT;
pev->takedamage = DAMAGE_NO;
@ -131,9 +129,9 @@ void CGenericMonster :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CGenericMonster :: Precache()
void CGenericMonster::Precache()
{
PRECACHE_MODEL( (char *)STRING(pev->model) );
PRECACHE_MODEL( (char *)STRING( pev->model ) );
}
//=========================================================

169
dlls/ggrenade.cpp
View File

@ -27,7 +27,6 @@
#include "soundent.h"
#include "decals.h"
//===================grenade
@ -42,7 +41,7 @@ LINK_ENTITY_TO_CLASS( grenade, CGrenade )
void CGrenade::Explode( Vector vecSrc, Vector vecAim )
{
TraceResult tr;
UTIL_TraceLine ( pev->origin, pev->origin + Vector ( 0, 0, -32 ), ignore_monsters, ENT(pev), & tr);
UTIL_TraceLine( pev->origin, pev->origin + Vector( 0, 0, -32 ), ignore_monsters, ENT( pev ), & tr );
Explode( &tr, DMG_BLAST );
}
@ -58,19 +57,19 @@ void CGrenade::Explode( TraceResult *pTrace, int bitsDamageType )
pev->takedamage = DAMAGE_NO;
// Pull out of the wall a bit
if ( pTrace->flFraction != 1.0 )
if( pTrace->flFraction != 1.0 )
{
pev->origin = pTrace->vecEndPos + (pTrace->vecPlaneNormal * (pev->dmg - 24) * 0.6);
pev->origin = pTrace->vecEndPos + ( pTrace->vecPlaneNormal * ( pev->dmg - 24 ) * 0.6 );
}
int iContents = UTIL_PointContents ( pev->origin );
int iContents = UTIL_PointContents( pev->origin );
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_EXPLOSION ); // This makes a dynamic light and the explosion sprites/sound
WRITE_COORD( pev->origin.x ); // Send to PAS because of the sound
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z );
if (iContents != CONTENTS_WATER)
if( iContents != CONTENTS_WATER )
{
WRITE_SHORT( g_sModelIndexFireball );
}
@ -78,23 +77,23 @@ void CGrenade::Explode( TraceResult *pTrace, int bitsDamageType )
{
WRITE_SHORT( g_sModelIndexWExplosion );
}
WRITE_BYTE( (pev->dmg - 50) * .60 ); // scale * 10
WRITE_BYTE( ( pev->dmg - 50 ) * .60 ); // scale * 10
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, NORMAL_EXPLOSION_VOLUME, 3.0 );
CSoundEnt::InsertSound( bits_SOUND_COMBAT, pev->origin, NORMAL_EXPLOSION_VOLUME, 3.0 );
entvars_t *pevOwner;
if ( pev->owner )
if( pev->owner )
pevOwner = VARS( pev->owner );
else
pevOwner = NULL;
pev->owner = NULL; // can't traceline attack owner if this is set
RadiusDamage ( pev, pevOwner, pev->dmg, CLASS_NONE, bitsDamageType );
RadiusDamage( pev, pevOwner, pev->dmg, CLASS_NONE, bitsDamageType );
if ( RANDOM_FLOAT( 0 , 1 ) < 0.5 )
if( RANDOM_FLOAT( 0, 1 ) < 0.5 )
{
UTIL_DecalTrace( pTrace, DECAL_SCORCH1 );
}
@ -103,13 +102,19 @@ void CGrenade::Explode( TraceResult *pTrace, int bitsDamageType )
UTIL_DecalTrace( pTrace, DECAL_SCORCH2 );
}
flRndSound = RANDOM_FLOAT( 0 , 1 );
flRndSound = RANDOM_FLOAT( 0, 1 );
switch ( RANDOM_LONG( 0, 2 ) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris1.wav", 0.55, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris2.wav", 0.55, ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/debris3.wav", 0.55, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/debris1.wav", 0.55, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/debris2.wav", 0.55, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/debris3.wav", 0.55, ATTN_NORM );
break;
}
pev->effects |= EF_NODRAW;
@ -117,17 +122,17 @@ void CGrenade::Explode( TraceResult *pTrace, int bitsDamageType )
pev->velocity = g_vecZero;
pev->nextthink = gpGlobals->time + 0.3;
if (iContents != CONTENTS_WATER)
if( iContents != CONTENTS_WATER )
{
int sparkCount = RANDOM_LONG(0,3);
for ( int i = 0; i < sparkCount; i++ )
int sparkCount = RANDOM_LONG( 0, 3 );
for( int i = 0; i < sparkCount; i++ )
Create( "spark_shower", pev->origin, pTrace->vecPlaneNormal, NULL );
}
}
void CGrenade::Smoke( void )
{
if (UTIL_PointContents ( pev->origin ) == CONTENTS_WATER)
if( UTIL_PointContents( pev->origin ) == CONTENTS_WATER )
{
UTIL_Bubbles( pev->origin - Vector( 64, 64, 64 ), pev->origin + Vector( 64, 64, 64 ), 100 );
}
@ -139,7 +144,7 @@ void CGrenade::Smoke( void )
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z );
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( (pev->dmg - 50) * 0.80 ); // scale * 10
WRITE_BYTE( ( pev->dmg - 50 ) * 0.80 ); // scale * 10
WRITE_BYTE( 12 ); // framerate
MESSAGE_END();
}
@ -148,7 +153,7 @@ void CGrenade::Smoke( void )
void CGrenade::Killed( entvars_t *pevAttacker, int iGib )
{
Detonate( );
Detonate();
}
// Timed grenade, this think is called when time runs out.
@ -171,8 +176,8 @@ void CGrenade::Detonate( void )
TraceResult tr;
Vector vecSpot;// trace starts here!
vecSpot = pev->origin + Vector ( 0 , 0 , 8 );
UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -40 ), ignore_monsters, ENT(pev), & tr);
vecSpot = pev->origin + Vector( 0, 0, 8 );
UTIL_TraceLine( vecSpot, vecSpot + Vector( 0, 0, -40 ), ignore_monsters, ENT(pev), &tr );
Explode( &tr, DMG_BLAST );
}
@ -189,23 +194,23 @@ void CGrenade::ExplodeTouch( CBaseEntity *pOther )
pev->enemy = pOther->edict();
vecSpot = pev->origin - pev->velocity.Normalize() * 32;
UTIL_TraceLine( vecSpot, vecSpot + pev->velocity.Normalize() * 64, ignore_monsters, ENT(pev), &tr );
UTIL_TraceLine( vecSpot, vecSpot + pev->velocity.Normalize() * 64, ignore_monsters, ENT( pev ), &tr );
Explode( &tr, DMG_BLAST );
}
void CGrenade::DangerSoundThink( void )
{
if (!IsInWorld())
if( !IsInWorld() )
{
UTIL_Remove( this );
return;
}
CSoundEnt::InsertSound ( bits_SOUND_DANGER, pev->origin + pev->velocity * 0.5, pev->velocity.Length( ), 0.2 );
CSoundEnt::InsertSound ( bits_SOUND_DANGER, pev->origin + pev->velocity * 0.5, pev->velocity.Length(), 0.2 );
pev->nextthink = gpGlobals->time + 0.2;
if (pev->waterlevel != 0)
if( pev->waterlevel != 0 )
{
pev->velocity = pev->velocity * 0.5;
}
@ -214,25 +219,25 @@ void CGrenade::DangerSoundThink( void )
void CGrenade::BounceTouch( CBaseEntity *pOther )
{
// don't hit the guy that launched this grenade
if ( pOther->edict() == pev->owner )
if( pOther->edict() == pev->owner )
return;
// only do damage if we're moving fairly fast
if (m_flNextAttack < gpGlobals->time && pev->velocity.Length() > 100)
if( m_flNextAttack < gpGlobals->time && pev->velocity.Length() > 100 )
{
entvars_t *pevOwner = VARS( pev->owner );
if (pevOwner)
if( pevOwner )
{
TraceResult tr = UTIL_GetGlobalTrace( );
ClearMultiDamage( );
pOther->TraceAttack(pevOwner, 1, gpGlobals->v_forward, &tr, DMG_CLUB );
ApplyMultiDamage( pev, pevOwner);
TraceResult tr = UTIL_GetGlobalTrace();
ClearMultiDamage();
pOther->TraceAttack( pevOwner, 1, gpGlobals->v_forward, &tr, DMG_CLUB );
ApplyMultiDamage( pev, pevOwner );
}
m_flNextAttack = gpGlobals->time + 1.0; // debounce
}
Vector vecTestVelocity;
// pev->avelocity = Vector (300, 300, 300);
// pev->avelocity = Vector( 300, 300, 300 );
// this is my heuristic for modulating the grenade velocity because grenades dropped purely vertical
// or thrown very far tend to slow down too quickly for me to always catch just by testing velocity.
@ -240,7 +245,7 @@ void CGrenade::BounceTouch( CBaseEntity *pOther )
vecTestVelocity = pev->velocity;
vecTestVelocity.z *= 0.45;
if ( !m_fRegisteredSound && vecTestVelocity.Length() <= 60 )
if( !m_fRegisteredSound && vecTestVelocity.Length() <= 60 )
{
//ALERT( at_console, "Grenade Registered!: %f\n", vecTestVelocity.Length() );
@ -248,11 +253,11 @@ void CGrenade::BounceTouch( CBaseEntity *pOther )
// go ahead and emit the danger sound.
// register a radius louder than the explosion, so we make sure everyone gets out of the way
CSoundEnt::InsertSound ( bits_SOUND_DANGER, pev->origin, pev->dmg / 0.4, 0.3 );
CSoundEnt::InsertSound( bits_SOUND_DANGER, pev->origin, pev->dmg / 0.4, 0.3 );
m_fRegisteredSound = TRUE;
}
if (pev->flags & FL_ONGROUND)
if( pev->flags & FL_ONGROUND )
{
// add a bit of static friction
pev->velocity = pev->velocity * 0.8;
@ -265,27 +270,25 @@ void CGrenade::BounceTouch( CBaseEntity *pOther )
BounceSound();
}
pev->framerate = pev->velocity.Length() / 200.0;
if (pev->framerate > 1.0)
if( pev->framerate > 1.0 )
pev->framerate = 1;
else if (pev->framerate < 0.5)
else if( pev->framerate < 0.5 )
pev->framerate = 0;
}
void CGrenade::SlideTouch( CBaseEntity *pOther )
{
// don't hit the guy that launched this grenade
if ( pOther->edict() == pev->owner )
if( pOther->edict() == pev->owner )
return;
// pev->avelocity = Vector (300, 300, 300);
if (pev->flags & FL_ONGROUND)
// pev->avelocity = Vector( 300, 300, 300 );
if( pev->flags & FL_ONGROUND )
{
// add a bit of static friction
pev->velocity = pev->velocity * 0.95;
if (pev->velocity.x != 0 || pev->velocity.y != 0)
if( pev->velocity.x != 0 || pev->velocity.y != 0 )
{
// maintain sliding sound
}
@ -296,52 +299,58 @@ void CGrenade::SlideTouch( CBaseEntity *pOther )
}
}
void CGrenade :: BounceSound( void )
void CGrenade::BounceSound( void )
{
switch ( RANDOM_LONG( 0, 2 ) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/grenade_hit1.wav", 0.25, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/grenade_hit2.wav", 0.25, ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/grenade_hit3.wav", 0.25, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/grenade_hit1.wav", 0.25, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/grenade_hit2.wav", 0.25, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/grenade_hit3.wav", 0.25, ATTN_NORM );
break;
}
}
void CGrenade :: TumbleThink( void )
void CGrenade::TumbleThink( void )
{
if (!IsInWorld())
if( !IsInWorld() )
{
UTIL_Remove( this );
return;
}
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1;
if (pev->dmgtime - 1 < gpGlobals->time)
if( pev->dmgtime - 1 < gpGlobals->time )
{
CSoundEnt::InsertSound ( bits_SOUND_DANGER, pev->origin + pev->velocity * (pev->dmgtime - gpGlobals->time), 400, 0.1 );
CSoundEnt::InsertSound( bits_SOUND_DANGER, pev->origin + pev->velocity * ( pev->dmgtime - gpGlobals->time ), 400, 0.1 );
}
if (pev->dmgtime <= gpGlobals->time)
if( pev->dmgtime <= gpGlobals->time )
{
SetThink( &CGrenade::Detonate );
}
if (pev->waterlevel != 0)
if( pev->waterlevel != 0 )
{
pev->velocity = pev->velocity * 0.5;
pev->framerate = 0.2;
}
}
void CGrenade:: Spawn( void )
void CGrenade::Spawn( void )
{
pev->movetype = MOVETYPE_BOUNCE;
pev->classname = MAKE_STRING( "grenade" );
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/grenade.mdl");
UTIL_SetSize(pev, Vector( 0, 0, 0), Vector(0, 0, 0));
SET_MODEL( ENT( pev ), "models/grenade.mdl" );
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
pev->dmg = 100;
m_fRegisteredSound = FALSE;
@ -355,15 +364,15 @@ CGrenade *CGrenade::ShootContact( entvars_t *pevOwner, Vector vecStart, Vector v
pGrenade->pev->gravity = 0.5;// lower gravity since grenade is aerodynamic and engine doesn't know it.
UTIL_SetOrigin( pGrenade->pev, vecStart );
pGrenade->pev->velocity = vecVelocity;
pGrenade->pev->angles = UTIL_VecToAngles (pGrenade->pev->velocity);
pGrenade->pev->owner = ENT(pevOwner);
pGrenade->pev->angles = UTIL_VecToAngles( pGrenade->pev->velocity );
pGrenade->pev->owner = ENT( pevOwner );
// make monsters afaid of it while in the air
pGrenade->SetThink( &CGrenade::DangerSoundThink );
pGrenade->pev->nextthink = gpGlobals->time;
// Tumble in air
pGrenade->pev->avelocity.x = RANDOM_FLOAT ( -100, -500 );
pGrenade->pev->avelocity.x = RANDOM_FLOAT( -100, -500 );
// Explode on contact
pGrenade->SetTouch( &CGrenade::ExplodeTouch );
@ -373,14 +382,14 @@ CGrenade *CGrenade::ShootContact( entvars_t *pevOwner, Vector vecStart, Vector v
return pGrenade;
}
CGrenade * CGrenade:: ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time )
CGrenade *CGrenade::ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time )
{
CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );
pGrenade->Spawn();
UTIL_SetOrigin( pGrenade->pev, vecStart );
pGrenade->pev->velocity = vecVelocity;
pGrenade->pev->angles = UTIL_VecToAngles(pGrenade->pev->velocity);
pGrenade->pev->owner = ENT(pevOwner);
pGrenade->pev->angles = UTIL_VecToAngles( pGrenade->pev->velocity );
pGrenade->pev->owner = ENT( pevOwner );
pGrenade->SetTouch( &CGrenade::BounceTouch ); // Bounce if touched
@ -391,7 +400,7 @@ CGrenade * CGrenade:: ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector v
pGrenade->pev->dmgtime = gpGlobals->time + time;
pGrenade->SetThink( &CGrenade::TumbleThink );
pGrenade->pev->nextthink = gpGlobals->time + 0.1;
if (time < 0.1)
if( time < 0.1 )
{
pGrenade->pev->nextthink = gpGlobals->time;
pGrenade->pev->velocity = Vector( 0, 0, 0 );
@ -406,13 +415,13 @@ CGrenade * CGrenade:: ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector v
pGrenade->pev->gravity = 0.5;
pGrenade->pev->friction = 0.8;
SET_MODEL(ENT(pGrenade->pev), "models/w_grenade.mdl");
SET_MODEL( ENT( pGrenade->pev ), "models/w_grenade.mdl" );
pGrenade->pev->dmg = 100;
return pGrenade;
}
CGrenade * CGrenade :: ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
CGrenade *CGrenade::ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity )
{
CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );
pGrenade->pev->movetype = MOVETYPE_BOUNCE;
@ -420,15 +429,15 @@ CGrenade * CGrenade :: ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart,
pGrenade->pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pGrenade->pev), "models/grenade.mdl"); // Change this to satchel charge model
SET_MODEL( ENT( pGrenade->pev ), "models/grenade.mdl" ); // Change this to satchel charge model
UTIL_SetSize(pGrenade->pev, Vector( 0, 0, 0), Vector(0, 0, 0));
UTIL_SetSize( pGrenade->pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
pGrenade->pev->dmg = 200;
UTIL_SetOrigin( pGrenade->pev, vecStart );
pGrenade->pev->velocity = vecVelocity;
pGrenade->pev->angles = g_vecZero;
pGrenade->pev->owner = ENT(pevOwner);
pGrenade->pev->owner = ENT( pevOwner );
// Detonate in "time" seconds
pGrenade->SetThink( &CBaseEntity::SUB_DoNothing );
@ -441,12 +450,12 @@ CGrenade * CGrenade :: ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart,
return pGrenade;
}
void CGrenade :: UseSatchelCharges( entvars_t *pevOwner, SATCHELCODE code )
void CGrenade::UseSatchelCharges( entvars_t *pevOwner, SATCHELCODE code )
{
edict_t *pentFind;
edict_t *pentOwner;
if ( !pevOwner )
if( !pevOwner )
return;
CBaseEntity *pOwner = CBaseEntity::Instance( pevOwner );
@ -454,14 +463,14 @@ void CGrenade :: UseSatchelCharges( entvars_t *pevOwner, SATCHELCODE code )
pentOwner = pOwner->edict();
pentFind = FIND_ENTITY_BY_CLASSNAME( NULL, "grenade" );
while ( !FNullEnt( pentFind ) )
while( !FNullEnt( pentFind ) )
{
CBaseEntity *pEnt = Instance( pentFind );
if ( pEnt )
if( pEnt )
{
if ( FBitSet( pEnt->pev->spawnflags, SF_DETONATE ) && pEnt->pev->owner == pentOwner )
if( FBitSet( pEnt->pev->spawnflags, SF_DETONATE ) && pEnt->pev->owner == pentOwner )
{
if ( code == SATCHEL_DETONATE )
if( code == SATCHEL_DETONATE )
pEnt->Use( pOwner, pOwner, USE_ON, 0 );
else // SATCHEL_RELEASE
pEnt->pev->owner = NULL;

2
dlls/globals.cpp
View File

@ -35,5 +35,5 @@ DLL_GLOBAL Vector g_vecAttackDir;
DLL_GLOBAL int g_iSkillLevel;
DLL_GLOBAL int gDisplayTitle;
DLL_GLOBAL BOOL g_fGameOver;
DLL_GLOBAL const Vector g_vecZero = Vector(0,0,0);
DLL_GLOBAL const Vector g_vecZero = Vector( 0, 0, 0 );
DLL_GLOBAL int g_Language;

87
dlls/glock.cpp
View File

@ -21,7 +21,8 @@
#include "nodes.h"
#include "player.h"
enum glock_e {
enum glock_e
{
GLOCK_IDLE1 = 0,
GLOCK_IDLE2,
GLOCK_IDLE3,
@ -37,12 +38,12 @@ enum glock_e {
LINK_ENTITY_TO_CLASS( weapon_glock, CGlock )
LINK_ENTITY_TO_CLASS( weapon_9mmhandgun, CGlock )
void CGlock::Spawn( )
void CGlock::Spawn()
{
pev->classname = MAKE_STRING("weapon_9mmhandgun"); // hack to allow for old names
Precache( );
pev->classname = MAKE_STRING( "weapon_9mmhandgun" ); // hack to allow for old names
Precache();
m_iId = WEAPON_GLOCK;
SET_MODEL(ENT(pev), "models/w_9mmhandgun.mdl");
SET_MODEL( ENT( pev ), "models/w_9mmhandgun.mdl" );
m_iDefaultAmmo = GLOCK_DEFAULT_GIVE;
@ -51,26 +52,26 @@ void CGlock::Spawn( )
void CGlock::Precache( void )
{
PRECACHE_MODEL("models/v_9mmhandgun.mdl");
PRECACHE_MODEL("models/w_9mmhandgun.mdl");
PRECACHE_MODEL("models/p_9mmhandgun.mdl");
PRECACHE_MODEL( "models/v_9mmhandgun.mdl" );
PRECACHE_MODEL( "models/w_9mmhandgun.mdl" );
PRECACHE_MODEL( "models/p_9mmhandgun.mdl" );
m_iShell = PRECACHE_MODEL ("models/shell.mdl");// brass shell
m_iShell = PRECACHE_MODEL( "models/shell.mdl" );// brass shell
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_SOUND("items/9mmclip2.wav");
PRECACHE_SOUND( "items/9mmclip1.wav" );
PRECACHE_SOUND( "items/9mmclip2.wav" );
PRECACHE_SOUND ("weapons/pl_gun1.wav");//silenced handgun
PRECACHE_SOUND ("weapons/pl_gun2.wav");//silenced handgun
PRECACHE_SOUND ("weapons/pl_gun3.wav");//handgun
PRECACHE_SOUND( "weapons/pl_gun1.wav" );//silenced handgun
PRECACHE_SOUND( "weapons/pl_gun2.wav" );//silenced handgun
PRECACHE_SOUND( "weapons/pl_gun3.wav" );//handgun
m_usFireGlock1 = PRECACHE_EVENT( 1, "events/glock1.sc" );
m_usFireGlock2 = PRECACHE_EVENT( 1, "events/glock2.sc" );
}
int CGlock::GetItemInfo(ItemInfo *p)
int CGlock::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "9mm";
p->iMaxAmmo1 = _9MM_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -85,7 +86,7 @@ int CGlock::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CGlock::Deploy( )
BOOL CGlock::Deploy()
{
// pev->body = 1;
return DefaultDeploy( "models/v_9mmhandgun.mdl", "models/p_9mmhandgun.mdl", GLOCK_DRAW, "onehanded", /*UseDecrement() ? 1 : 0*/ 0 );
@ -101,11 +102,11 @@ void CGlock::PrimaryAttack( void )
GlockFire( 0.01, 0.3, TRUE );
}
void CGlock::GlockFire( float flSpread , float flCycleTime, BOOL fUseAutoAim )
void CGlock::GlockFire( float flSpread, float flCycleTime, BOOL fUseAutoAim )
{
if (m_iClip <= 0)
if( m_iClip <= 0 )
{
if (m_fFireOnEmpty)
if( m_fFireOnEmpty )
{
PlayEmptySound();
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.2;
@ -116,7 +117,7 @@ void CGlock::GlockFire( float flSpread , float flCycleTime, BOOL fUseAutoAim )
m_iClip--;
m_pPlayer->pev->effects = (int)(m_pPlayer->pev->effects) | EF_MUZZLEFLASH;
m_pPlayer->pev->effects = (int)( m_pPlayer->pev->effects ) | EF_MUZZLEFLASH;
int flags;
#if defined( CLIENT_WEAPONS )
@ -128,7 +129,7 @@ void CGlock::GlockFire( float flSpread , float flCycleTime, BOOL fUseAutoAim )
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
// silenced
if (pev->body == 1)
if( pev->body == 1 )
{
m_pPlayer->m_iWeaponVolume = QUIET_GUN_VOLUME;
m_pPlayer->m_iWeaponFlash = DIM_GUN_FLASH;
@ -140,10 +141,10 @@ void CGlock::GlockFire( float flSpread , float flCycleTime, BOOL fUseAutoAim )
m_pPlayer->m_iWeaponFlash = NORMAL_GUN_FLASH;
}
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecSrc = m_pPlayer->GetGunPosition();
Vector vecAiming;
if ( fUseAutoAim )
if( fUseAutoAim )
{
vecAiming = m_pPlayer->GetAutoaimVector( AUTOAIM_10DEGREES );
}
@ -159,26 +160,26 @@ void CGlock::GlockFire( float flSpread , float flCycleTime, BOOL fUseAutoAim )
m_flNextPrimaryAttack = m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + flCycleTime;
if (!m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
if( !m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
// HEV suit - indicate out of ammo condition
m_pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
m_pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 );
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
}
void CGlock::Reload( void )
{
if ( m_pPlayer->ammo_9mm <= 0 )
if( m_pPlayer->ammo_9mm <= 0 )
return;
int iResult;
if (m_iClip == 0)
if( m_iClip == 0 )
iResult = DefaultReload( 17, GLOCK_RELOAD, 1.5 );
else
iResult = DefaultReload( 17, GLOCK_RELOAD_NOT_EMPTY, 1.5 );
if (iResult)
if( iResult )
{
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
}
@ -186,25 +187,25 @@ void CGlock::Reload( void )
void CGlock::WeaponIdle( void )
{
ResetEmptySound( );
ResetEmptySound();
m_pPlayer->GetAutoaimVector( AUTOAIM_10DEGREES );
if ( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
// only idle if the slid isn't back
if (m_iClip != 0)
if( m_iClip != 0 )
{
int iAnim;
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0.0, 1.0 );
if (flRand <= 0.3 + 0 * 0.75)
if( flRand <= 0.3 + 0 * 0.75 )
{
iAnim = GLOCK_IDLE3;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 49.0 / 16;
}
else if (flRand <= 0.6 + 0 * 0.875)
else if( flRand <= 0.6 + 0 * 0.875 )
{
iAnim = GLOCK_IDLE1;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 60.0 / 16.0;
@ -222,25 +223,27 @@ class CGlockAmmo : public CBasePlayerAmmo
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
CBasePlayerAmmo::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_9mmclip.mdl" );
CBasePlayerAmmo::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_9mmclip.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_9mmclip.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
}
BOOL AddAmmo( CBaseEntity *pOther )
{
if (pOther->GiveAmmo( AMMO_GLOCKCLIP_GIVE, "9mm", _9MM_MAX_CARRY ) != -1)
if( pOther->GiveAmmo( AMMO_GLOCKCLIP_GIVE, "9mm", _9MM_MAX_CARRY ) != -1 )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
return TRUE;
}
return FALSE;
}
};
LINK_ENTITY_TO_CLASS( ammo_glockclip, CGlockAmmo )
LINK_ENTITY_TO_CLASS( ammo_9mmclip, CGlockAmmo )

56
dlls/gman.cpp
View File

@ -42,7 +42,7 @@ public:
void StartTask( Task_t *pTask );
void RunTask( Task_t *pTask );
int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
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);
void PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, CBaseEntity *pListener );
@ -66,7 +66,7 @@ IMPLEMENT_SAVERESTORE( CGMan, CBaseMonster )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CGMan :: Classify ( void )
int CGMan::Classify( void )
{
return CLASS_NONE;
}
@ -75,11 +75,11 @@ int CGMan :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CGMan :: SetYawSpeed ( void )
void CGMan::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_IDLE:
default:
@ -93,7 +93,7 @@ void CGMan :: SetYawSpeed ( void )
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CGMan :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CGMan::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -107,7 +107,7 @@ void CGMan :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// ISoundMask - generic monster can't hear.
//=========================================================
int CGMan :: ISoundMask ( void )
int CGMan::ISoundMask( void )
{
return NULL;
}
@ -115,12 +115,12 @@ int CGMan :: ISoundMask ( void )
//=========================================================
// Spawn
//=========================================================
void CGMan :: Spawn()
void CGMan::Spawn()
{
Precache();
SET_MODEL( ENT(pev), "models/gman.mdl" );
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
SET_MODEL( ENT( pev ), "models/gman.mdl" );
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
@ -135,7 +135,7 @@ void CGMan :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CGMan :: Precache()
void CGMan::Precache()
{
PRECACHE_MODEL( "models/gman.mdl" );
}
@ -144,12 +144,12 @@ void CGMan :: Precache()
// AI Schedules Specific to this monster
//=========================================================
void CGMan :: StartTask( Task_t *pTask )
void CGMan::StartTask( Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_WAIT:
if (m_hPlayer == NULL)
if( m_hPlayer == NULL )
{
m_hPlayer = UTIL_FindEntityByClassname( NULL, "player" );
}
@ -158,29 +158,33 @@ void CGMan :: StartTask( Task_t *pTask )
CBaseMonster::StartTask( pTask );
}
void CGMan :: RunTask( Task_t *pTask )
void CGMan::RunTask( Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_WAIT:
// look at who I'm talking to
if (m_flTalkTime > gpGlobals->time && m_hTalkTarget != NULL)
if( m_flTalkTime > gpGlobals->time && m_hTalkTarget != NULL )
{
float yaw = VecToYaw(m_hTalkTarget->pev->origin - pev->origin) - pev->angles.y;
float yaw = VecToYaw( m_hTalkTarget->pev->origin - pev->origin ) - pev->angles.y;
if (yaw > 180) yaw -= 360;
if (yaw < -180) yaw += 360;
if( yaw > 180 )
yaw -= 360;
if( yaw < -180 )
yaw += 360;
// turn towards vector
SetBoneController( 0, yaw );
}
// look at player, but only if playing a "safe" idle animation
else if (m_hPlayer != NULL && pev->sequence == 0)
else if( m_hPlayer != NULL && pev->sequence == 0 )
{
float yaw = VecToYaw(m_hPlayer->pev->origin - pev->origin) - pev->angles.y;
float yaw = VecToYaw( m_hPlayer->pev->origin - pev->origin ) - pev->angles.y;
if (yaw > 180) yaw -= 360;
if (yaw < -180) yaw += 360;
if( yaw > 180 )
yaw -= 360;
if( yaw < -180 )
yaw += 360;
// turn towards vector
SetBoneController( 0, yaw );
@ -201,18 +205,18 @@ void CGMan :: RunTask( Task_t *pTask )
//=========================================================
// Override all damage
//=========================================================
int CGMan :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
int CGMan::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
pev->health = pev->max_health / 2; // always trigger the 50% damage aitrigger
if ( flDamage > 0 )
if( flDamage > 0 )
{
SetConditions(bits_COND_LIGHT_DAMAGE);
SetConditions( bits_COND_LIGHT_DAMAGE );
}
if ( flDamage >= 20 )
if( flDamage >= 20 )
{
SetConditions(bits_COND_HEAVY_DAMAGE);
SetConditions( bits_COND_HEAVY_DAMAGE );
}
return TRUE;
}

80
dlls/h_ai.cpp
View File

@ -18,7 +18,6 @@
*/
#include "extdll.h"
#include "util.h"
#include "cbase.h"
@ -28,7 +27,7 @@
#define NUM_LATERAL_CHECKS 13 // how many checks are made on each side of a monster looking for lateral cover
#define NUM_LATERAL_LOS_CHECKS 6 // how many checks are made on each side of a monster looking for lateral cover
//float flRandom = RANDOM_FLOAT(0,1);
//float flRandom = RANDOM_FLOAT( 0, 1 );
DLL_GLOBAL BOOL g_fDrawLines = FALSE;
@ -45,25 +44,25 @@ DLL_GLOBAL BOOL g_fDrawLines = FALSE;
//
// !!!UNDONE - make this CBaseMonster?
//=========================================================
BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize )
BOOL FBoxVisible( entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTargetOrigin, float flSize )
{
// don't look through water
if ((pevLooker->waterlevel != 3 && pevTarget->waterlevel == 3)
|| (pevLooker->waterlevel == 3 && pevTarget->waterlevel == 0))
if( ( pevLooker->waterlevel != 3 && pevTarget->waterlevel == 3 )
|| ( pevLooker->waterlevel == 3 && pevTarget->waterlevel == 0 ) )
return FALSE;
TraceResult tr;
Vector vecLookerOrigin = pevLooker->origin + pevLooker->view_ofs;//look through the monster's 'eyes'
for (int i = 0; i < 5; i++)
for( int i = 0; i < 5; i++ )
{
Vector vecTarget = pevTarget->origin;
vecTarget.x += RANDOM_FLOAT( pevTarget->mins.x + flSize, pevTarget->maxs.x - flSize);
vecTarget.y += RANDOM_FLOAT( pevTarget->mins.y + flSize, pevTarget->maxs.y - flSize);
vecTarget.z += RANDOM_FLOAT( pevTarget->mins.z + flSize, pevTarget->maxs.z - flSize);
vecTarget.x += RANDOM_FLOAT( pevTarget->mins.x + flSize, pevTarget->maxs.x - flSize );
vecTarget.y += RANDOM_FLOAT( pevTarget->mins.y + flSize, pevTarget->maxs.y - flSize );
vecTarget.z += RANDOM_FLOAT( pevTarget->mins.z + flSize, pevTarget->maxs.z - flSize );
UTIL_TraceLine(vecLookerOrigin, vecTarget, ignore_monsters, ignore_glass, ENT(pevLooker)/*pentIgnore*/, &tr);
UTIL_TraceLine( vecLookerOrigin, vecTarget, ignore_monsters, ignore_glass, ENT( pevLooker )/*pentIgnore*/, &tr );
if (tr.flFraction == 1.0)
if( tr.flFraction == 1.0 )
{
vecTargetOrigin = vecTarget;
return TRUE;// line of sight is valid.
@ -76,7 +75,7 @@ BOOL FBoxVisible ( entvars_t *pevLooker, entvars_t *pevTarget, Vector &vecTarget
// VecCheckToss - returns the velocity at which an object should be lobbed from vecspot1 to land near vecspot2.
// returns g_vecZero if toss is not feasible.
//
Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flGravityAdj )
Vector VecCheckToss( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flGravityAdj )
{
TraceResult tr;
Vector vecMidPoint;// halfway point between Spot1 and Spot2
@ -86,17 +85,17 @@ Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, f
Vector vecTemp;
float flGravity = g_psv_gravity->value * flGravityAdj;
if (vecSpot2.z - vecSpot1.z > 500)
if( vecSpot2.z - vecSpot1.z > 500 )
{
// to high, fail
return g_vecZero;
}
UTIL_MakeVectors (pev->angles);
UTIL_MakeVectors( pev->angles );
// toss a little bit to the left or right, not right down on the enemy's bean (head).
vecSpot2 = vecSpot2 + gpGlobals->v_right * ( RANDOM_FLOAT(-8,8) + RANDOM_FLOAT(-16,16) );
vecSpot2 = vecSpot2 + gpGlobals->v_forward * ( RANDOM_FLOAT(-8,8) + RANDOM_FLOAT(-16,16) );
vecSpot2 = vecSpot2 + gpGlobals->v_right * ( RANDOM_FLOAT( -8, 8 ) + RANDOM_FLOAT( -16, 16 ) );
vecSpot2 = vecSpot2 + gpGlobals->v_forward * ( RANDOM_FLOAT( -8, 8 ) + RANDOM_FLOAT( -16, 16 ) );
// calculate the midpoint and apex of the 'triangle'
// UNDONE: normalize any Z position differences between spot1 and spot2 so that triangle is always RIGHT
@ -104,34 +103,34 @@ Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, f
// How much time does it take to get there?
// get a rough idea of how high it can be thrown
vecMidPoint = vecSpot1 + (vecSpot2 - vecSpot1) * 0.5;
UTIL_TraceLine(vecMidPoint, vecMidPoint + Vector(0,0,500), ignore_monsters, ENT(pev), &tr);
vecMidPoint = vecSpot1 + ( vecSpot2 - vecSpot1 ) * 0.5;
UTIL_TraceLine(vecMidPoint, vecMidPoint + Vector( 0, 0, 500 ), ignore_monsters, ENT( pev ), &tr );
vecMidPoint = tr.vecEndPos;
// (subtract 15 so the grenade doesn't hit the ceiling)
vecMidPoint.z -= 15;
if (vecMidPoint.z < vecSpot1.z || vecMidPoint.z < vecSpot2.z)
if( vecMidPoint.z < vecSpot1.z || vecMidPoint.z < vecSpot2.z )
{
// to not enough space, fail
return g_vecZero;
}
// How high should the grenade travel to reach the apex
float distance1 = (vecMidPoint.z - vecSpot1.z);
float distance2 = (vecMidPoint.z - vecSpot2.z);
float distance1 = vecMidPoint.z - vecSpot1.z;
float distance2 = vecMidPoint.z - vecSpot2.z;
// How long will it take for the grenade to travel this distance
float time1 = sqrt( distance1 / (0.5 * flGravity) );
float time2 = sqrt( distance2 / (0.5 * flGravity) );
float time1 = sqrt( distance1 / ( 0.5 * flGravity ) );
float time2 = sqrt( distance2 / ( 0.5 * flGravity ) );
if (time1 < 0.1)
if( time1 < 0.1 )
{
// too close
return g_vecZero;
}
// how hard to throw sideways to get there in time.
vecGrenadeVel = (vecSpot2 - vecSpot1) / (time1 + time2);
vecGrenadeVel = ( vecSpot2 - vecSpot1 ) / ( time1 + time2 );
// how hard upwards to reach the apex at the right time.
vecGrenadeVel.z = flGravity * time1;
@ -139,16 +138,16 @@ Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, f
vecApex = vecSpot1 + vecGrenadeVel * time1;
vecApex.z = vecMidPoint.z;
UTIL_TraceLine(vecSpot1, vecApex, dont_ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( vecSpot1, vecApex, dont_ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
// fail!
return g_vecZero;
}
// UNDONE: either ignore monsters or change it to not care if we hit our enemy
UTIL_TraceLine(vecSpot2, vecApex, ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( vecSpot2, vecApex, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
// fail!
return g_vecZero;
@ -157,37 +156,36 @@ Vector VecCheckToss ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, f
return vecGrenadeVel;
}
//
// VecCheckThrow - returns the velocity vector at which an object should be thrown from vecspot1 to hit vecspot2.
// returns g_vecZero if throw is not feasible.
//
Vector VecCheckThrow ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flSpeed, float flGravityAdj )
Vector VecCheckThrow( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2, float flSpeed, float flGravityAdj )
{
float flGravity = g_psv_gravity->value * flGravityAdj;
Vector vecGrenadeVel = (vecSpot2 - vecSpot1);
Vector vecGrenadeVel = vecSpot2 - vecSpot1;
// throw at a constant time
float time = vecGrenadeVel.Length( ) / flSpeed;
vecGrenadeVel = vecGrenadeVel * (1.0 / time);
float time = vecGrenadeVel.Length() / flSpeed;
vecGrenadeVel = vecGrenadeVel * ( 1.0 / time );
// adjust upward toss to compensate for gravity loss
vecGrenadeVel.z += flGravity * time * 0.5;
Vector vecApex = vecSpot1 + (vecSpot2 - vecSpot1) * 0.5;
vecApex.z += 0.5 * flGravity * (time * 0.5) * (time * 0.5);
Vector vecApex = vecSpot1 + ( vecSpot2 - vecSpot1 ) * 0.5;
vecApex.z += 0.5 * flGravity * ( time * 0.5 ) * ( time * 0.5 );
TraceResult tr;
UTIL_TraceLine(vecSpot1, vecApex, dont_ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( vecSpot1, vecApex, dont_ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
// fail!
return g_vecZero;
}
UTIL_TraceLine(vecSpot2, vecApex, ignore_monsters, ENT(pev), &tr);
if (tr.flFraction != 1.0)
UTIL_TraceLine( vecSpot2, vecApex, ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction != 1.0 )
{
// fail!
return g_vecZero;
@ -195,5 +193,3 @@ Vector VecCheckThrow ( entvars_t *pev, const Vector &vecSpot1, Vector vecSpot2,
return vecGrenadeVel;
}

84
dlls/h_battery.cpp
View File

@ -30,20 +30,20 @@
class CRecharge : public CBaseToggle
{
public:
void Spawn( );
void Spawn();
void Precache( void );
void EXPORT Off(void);
void EXPORT Recharge(void);
void KeyValue( KeyValueData *pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual int ObjectCaps( void ) { return (CBaseToggle :: ObjectCaps() | FCAP_CONTINUOUS_USE) & ~FCAP_ACROSS_TRANSITION; }
virtual int ObjectCaps( void ) { return ( CBaseToggle::ObjectCaps() | FCAP_CONTINUOUS_USE ) & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
float m_flNextCharge;
int m_iReactivate ; // DeathMatch Delay until reactvated
int m_iReactivate; // DeathMatch Delay until reactvated
int m_iJuice;
int m_iOn; // 0 = off, 1 = startup, 2 = going
float m_flSoundTime;
@ -52,9 +52,9 @@ public:
TYPEDESCRIPTION CRecharge::m_SaveData[] =
{
DEFINE_FIELD( CRecharge, m_flNextCharge, FIELD_TIME ),
DEFINE_FIELD( CRecharge, m_iReactivate, FIELD_INTEGER),
DEFINE_FIELD( CRecharge, m_iJuice, FIELD_INTEGER),
DEFINE_FIELD( CRecharge, m_iOn, FIELD_INTEGER),
DEFINE_FIELD( CRecharge, m_iReactivate, FIELD_INTEGER ),
DEFINE_FIELD( CRecharge, m_iJuice, FIELD_INTEGER ),
DEFINE_FIELD( CRecharge, m_iOn, FIELD_INTEGER ),
DEFINE_FIELD( CRecharge, m_flSoundTime, FIELD_TIME ),
};
@ -64,17 +64,17 @@ LINK_ENTITY_TO_CLASS( func_recharge, CRecharge )
void CRecharge::KeyValue( KeyValueData *pkvd )
{
if ( FStrEq(pkvd->szKeyName, "style") ||
FStrEq(pkvd->szKeyName, "height") ||
FStrEq(pkvd->szKeyName, "value1") ||
FStrEq(pkvd->szKeyName, "value2") ||
FStrEq(pkvd->szKeyName, "value3"))
if( FStrEq( pkvd->szKeyName, "style" ) ||
FStrEq( pkvd->szKeyName, "height" ) ||
FStrEq( pkvd->szKeyName, "value1" ) ||
FStrEq( pkvd->szKeyName, "value2" ) ||
FStrEq( pkvd->szKeyName, "value3" ) )
{
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "dmdelay"))
else if( FStrEq( pkvd->szKeyName, "dmdelay" ) )
{
m_iReactivate = atoi(pkvd->szValue);
m_iReactivate = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -83,88 +83,86 @@ void CRecharge::KeyValue( KeyValueData *pkvd )
void CRecharge::Spawn()
{
Precache( );
Precache();
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(pev, pev->origin); // set size and link into world
UTIL_SetSize(pev, pev->mins, pev->maxs);
SET_MODEL(ENT(pev), STRING(pev->model) );
UTIL_SetOrigin( pev, pev->origin ); // set size and link into world
UTIL_SetSize( pev, pev->mins, pev->maxs );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
m_iJuice = gSkillData.suitchargerCapacity;
pev->frame = 0;
}
void CRecharge::Precache()
{
PRECACHE_SOUND("items/suitcharge1.wav");
PRECACHE_SOUND("items/suitchargeno1.wav");
PRECACHE_SOUND("items/suitchargeok1.wav");
PRECACHE_SOUND( "items/suitcharge1.wav" );
PRECACHE_SOUND( "items/suitchargeno1.wav" );
PRECACHE_SOUND( "items/suitchargeok1.wav" );
}
void CRecharge::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// if it's not a player, ignore
if (!FClassnameIs(pActivator->pev, "player"))
if( !FClassnameIs( pActivator->pev, "player" ) )
return;
// if there is no juice left, turn it off
if (m_iJuice <= 0)
if( m_iJuice <= 0 )
{
pev->frame = 1;
Off();
}
// if the player doesn't have the suit, or there is no juice left, make the deny noise
if ((m_iJuice <= 0) || (!(pActivator->pev->weapons & (1<<WEAPON_SUIT))))
if( ( m_iJuice <= 0 ) || ( !( pActivator->pev->weapons & ( 1 << WEAPON_SUIT ) ) ) )
{
if (m_flSoundTime <= gpGlobals->time)
if( m_flSoundTime <= gpGlobals->time )
{
m_flSoundTime = gpGlobals->time + 0.62;
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/suitchargeno1.wav", 0.85, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/suitchargeno1.wav", 0.85, ATTN_NORM );
}
return;
}
pev->nextthink = pev->ltime + 0.25;
SetThink( &CRecharge::Off);
SetThink( &CRecharge::Off );
// Time to recharge yet?
if (m_flNextCharge >= gpGlobals->time)
if( m_flNextCharge >= gpGlobals->time )
return;
// Make sure that we have a caller
if (!pActivator)
if( !pActivator )
return;
m_hActivator = pActivator;
//only recharge the player
if (!m_hActivator->IsPlayer() )
if( !m_hActivator->IsPlayer() )
return;
// Play the on sound or the looping charging sound
if (!m_iOn)
if( !m_iOn )
{
m_iOn++;
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/suitchargeok1.wav", 0.85, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/suitchargeok1.wav", 0.85, ATTN_NORM );
m_flSoundTime = 0.56 + gpGlobals->time;
}
if ((m_iOn == 1) && (m_flSoundTime <= gpGlobals->time))
if( ( m_iOn == 1 ) && ( m_flSoundTime <= gpGlobals->time ) )
{
m_iOn++;
EMIT_SOUND(ENT(pev), CHAN_STATIC, "items/suitcharge1.wav", 0.85, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_STATIC, "items/suitcharge1.wav", 0.85, ATTN_NORM );
}
// charge the player
if (m_hActivator->pev->armorvalue < 100)
if( m_hActivator->pev->armorvalue < 100 )
{
m_iJuice--;
m_hActivator->pev->armorvalue += 1;
if (m_hActivator->pev->armorvalue > 100)
if( m_hActivator->pev->armorvalue > 100 )
m_hActivator->pev->armorvalue = 100;
}
@ -172,25 +170,25 @@ void CRecharge::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE use
m_flNextCharge = gpGlobals->time + 0.1;
}
void CRecharge::Recharge(void)
void CRecharge::Recharge( void )
{
m_iJuice = gSkillData.suitchargerCapacity;
pev->frame = 0;
SetThink( &CBaseEntity::SUB_DoNothing );
}
void CRecharge::Off(void)
void CRecharge::Off( void )
{
// Stop looping sound.
if (m_iOn > 1)
STOP_SOUND( ENT(pev), CHAN_STATIC, "items/suitcharge1.wav" );
if( m_iOn > 1 )
STOP_SOUND( ENT( pev ), CHAN_STATIC, "items/suitcharge1.wav" );
m_iOn = 0;
if ((!m_iJuice) && ( ( m_iReactivate = g_pGameRules->FlHEVChargerRechargeTime() ) > 0) )
if( ( !m_iJuice ) && ( ( m_iReactivate = g_pGameRules->FlHEVChargerRechargeTime() ) > 0 ) )
{
pev->nextthink = pev->ltime + m_iReactivate;
SetThink( &CRecharge::Recharge);
SetThink( &CRecharge::Recharge );
}
else
SetThink( &CBaseEntity::SUB_DoNothing );

133
dlls/h_cycler.cpp
View File

@ -35,7 +35,7 @@ class CCycler : public CBaseMonster
{
public:
void GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax);
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() | FCAP_IMPULSE_USE); }
virtual int ObjectCaps( void ) { return ( CBaseEntity::ObjectCaps() | FCAP_IMPULSE_USE ); }
int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
void Spawn( void );
void Think( void );
@ -65,7 +65,10 @@ IMPLEMENT_SAVERESTORE( CCycler, CBaseMonster )
class CGenericCycler : public CCycler
{
public:
void Spawn( void ) { GenericCyclerSpawn( (char *)STRING(pev->model), Vector(-16, -16, 0), Vector(16, 16, 72) ); }
void Spawn( void )
{
GenericCyclerSpawn( (char *)STRING( pev->model ), Vector( -16, -16, 0 ), Vector( 16, 16, 72 ) );
}
};
LINK_ENTITY_TO_CLASS( cycler, CGenericCycler )
@ -82,33 +85,32 @@ public:
LINK_ENTITY_TO_CLASS( cycler_prdroid, CCyclerProbe )
void CCyclerProbe :: Spawn( void )
void CCyclerProbe::Spawn( void )
{
pev->origin = pev->origin + Vector ( 0, 0, 16 );
GenericCyclerSpawn( "models/prdroid.mdl", Vector(-16,-16,-16), Vector(16,16,16));
pev->origin = pev->origin + Vector( 0, 0, 16 );
GenericCyclerSpawn( "models/prdroid.mdl", Vector( -16, -16, -16 ), Vector( 16, 16, 16 ) );
}
// Cycler member functions
void CCycler :: GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax)
void CCycler::GenericCyclerSpawn( char *szModel, Vector vecMin, Vector vecMax )
{
if (!szModel || !*szModel)
if( !szModel || !*szModel )
{
ALERT(at_error, "cycler at %.0f %.0f %0.f missing modelname", pev->origin.x, pev->origin.y, pev->origin.z );
REMOVE_ENTITY(ENT(pev));
ALERT( at_error, "cycler at %.0f %.0f %0.f missing modelname", pev->origin.x, pev->origin.y, pev->origin.z );
REMOVE_ENTITY( ENT( pev ) );
return;
}
pev->classname = MAKE_STRING("cycler");
pev->classname = MAKE_STRING( "cycler" );
PRECACHE_MODEL( szModel );
SET_MODEL(ENT(pev), szModel);
SET_MODEL( ENT( pev ), szModel );
CCycler::Spawn( );
CCycler::Spawn();
UTIL_SetSize(pev, vecMin, vecMax);
UTIL_SetSize( pev, vecMin, vecMax );
}
void CCycler :: Spawn( )
void CCycler::Spawn()
{
InitBoneControllers();
pev->solid = SOLID_SLIDEBOX;
@ -125,9 +127,9 @@ void CCycler :: Spawn( )
pev->nextthink += 1.0;
ResetSequenceInfo( );
ResetSequenceInfo();
if (pev->sequence != 0 || pev->frame != 0)
if( pev->sequence != 0 || pev->frame != 0 )
{
m_animate = 0;
pev->framerate = 0;
@ -141,15 +143,15 @@ void CCycler :: Spawn( )
//
// cycler think
//
void CCycler :: Think( void )
void CCycler::Think( void )
{
pev->nextthink = gpGlobals->time + 0.1;
if (m_animate)
if( m_animate )
{
StudioFrameAdvance ( );
StudioFrameAdvance();
}
if (m_fSequenceFinished && !m_fSequenceLoops)
if( m_fSequenceFinished && !m_fSequenceLoops )
{
// ResetSequenceInfo();
// hack to avoid reloading model every frame
@ -158,7 +160,7 @@ void CCycler :: Think( void )
m_fSequenceFinished = FALSE;
m_flLastEventCheck = gpGlobals->time;
pev->frame = 0;
if (!m_animate)
if( !m_animate )
pev->framerate = 0.0; // FIX: don't reset framerate
}
}
@ -166,10 +168,10 @@ void CCycler :: Think( void )
//
// CyclerUse - starts a rotation trend
//
void CCycler :: Use ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CCycler::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
m_animate = !m_animate;
if (m_animate)
if( m_animate )
pev->framerate = 1.0;
else
pev->framerate = 0.0;
@ -178,26 +180,26 @@ void CCycler :: Use ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE us
//
// CyclerPain , changes sequences when shot
//
//void CCycler :: Pain( float flDamage )
int CCycler :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
//void CCycler::Pain( float flDamage )
int CCycler::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if (m_animate)
if( m_animate )
{
pev->sequence++;
ResetSequenceInfo( );
ResetSequenceInfo();
if (m_flFrameRate == 0.0)
if( m_flFrameRate == 0.0 )
{
pev->sequence = 0;
ResetSequenceInfo( );
ResetSequenceInfo();
}
pev->frame = 0;
}
else
{
pev->framerate = 1.0;
StudioFrameAdvance ( 0.1 );
StudioFrameAdvance( 0.1 );
pev->framerate = 0;
ALERT( at_console, "sequence: %d, frame %.0f\n", pev->sequence, pev->frame );
}
@ -212,15 +214,19 @@ public:
void Spawn( void );
void Think( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() | FCAP_DONT_SAVE | FCAP_IMPULSE_USE); }
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
virtual int ObjectCaps( void ) { return ( CBaseEntity :: ObjectCaps() | FCAP_DONT_SAVE | FCAP_IMPULSE_USE ); }
virtual int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
void Animate( float frames );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
inline int ShouldAnimate( void ) { return m_animate && m_maxFrame > 1.0; }
inline int ShouldAnimate( void )
{
return m_animate && m_maxFrame > 1.0;
}
int m_animate;
float m_lastTime;
float m_maxFrame;
@ -249,16 +255,16 @@ void CCyclerSprite::Spawn( void )
m_animate = 1;
m_lastTime = gpGlobals->time;
PRECACHE_MODEL( (char *)STRING(pev->model) );
SET_MODEL( ENT(pev), STRING(pev->model) );
PRECACHE_MODEL( (char *)STRING( pev->model ) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
m_maxFrame = (float) MODEL_FRAMES( pev->modelindex ) - 1;
m_maxFrame = (float)MODEL_FRAMES( pev->modelindex ) - 1;
}
void CCyclerSprite::Think( void )
{
if ( ShouldAnimate() )
Animate( pev->framerate * (gpGlobals->time - m_lastTime) );
if( ShouldAnimate() )
Animate( pev->framerate * ( gpGlobals->time - m_lastTime ) );
pev->nextthink = gpGlobals->time + 0.1;
m_lastTime = gpGlobals->time;
@ -267,12 +273,12 @@ void CCyclerSprite::Think( void )
void CCyclerSprite::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
m_animate = !m_animate;
ALERT( at_console, "Sprite: %s\n", STRING(pev->model) );
ALERT( at_console, "Sprite: %s\n", STRING( pev->model ) );
}
int CCyclerSprite::TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType )
int CCyclerSprite::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if ( m_maxFrame > 1.0 )
if( m_maxFrame > 1.0 )
{
Animate( 1.0 );
}
@ -282,7 +288,7 @@ int CCyclerSprite::TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker,
void CCyclerSprite::Animate( float frames )
{
pev->frame += frames;
if ( m_maxFrame > 0 )
if( m_maxFrame > 0 )
pev->frame = fmod( pev->frame, m_maxFrame );
}
@ -303,22 +309,22 @@ public:
LINK_ENTITY_TO_CLASS( cycler_weapon, CWeaponCycler )
void CWeaponCycler::Spawn( )
void CWeaponCycler::Spawn()
{
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE;
PRECACHE_MODEL( (char *)STRING(pev->model) );
SET_MODEL( ENT(pev), STRING(pev->model) );
PRECACHE_MODEL( (char *)STRING( pev->model ) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
m_iszModel = pev->model;
m_iModel = pev->modelindex;
UTIL_SetOrigin( pev, pev->origin );
UTIL_SetSize(pev, Vector(-16, -16, 0), Vector(16, 16, 16));
UTIL_SetSize( pev, Vector( -16, -16, 0 ), Vector( 16, 16, 16 ) );
SetTouch( &CBasePlayerItem::DefaultTouch );
}
BOOL CWeaponCycler::Deploy( )
BOOL CWeaponCycler::Deploy()
{
m_pPlayer->pev->viewmodel = m_iszModel;
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 1.0;
@ -334,7 +340,6 @@ void CWeaponCycler::Holster( int skiplocal /* = 0 */ )
void CWeaponCycler::PrimaryAttack()
{
SendWeaponAnim( pev->sequence );
m_flNextPrimaryAttack = gpGlobals->time + 0.3;
@ -344,14 +349,14 @@ void CWeaponCycler::SecondaryAttack( void )
{
float flFrameRate, flGroundSpeed;
pev->sequence = (pev->sequence + 1) % 8;
pev->sequence = ( pev->sequence + 1 ) % 8;
pev->modelindex = m_iModel;
void *pmodel = GET_MODEL_PTR( ENT(pev) );
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
GetSequenceInfo( pmodel, pev, &flFrameRate, &flGroundSpeed );
pev->modelindex = 0;
if (flFrameRate == 0.0)
if( flFrameRate == 0.0 )
{
pev->sequence = 0;
}
@ -394,35 +399,35 @@ void CWreckage::Spawn( void )
pev->frame = 0;
pev->nextthink = gpGlobals->time + 0.1;
if (pev->model)
if( pev->model )
{
PRECACHE_MODEL( (char *)STRING(pev->model) );
SET_MODEL( ENT(pev), STRING(pev->model) );
PRECACHE_MODEL( (char *)STRING( pev->model ) );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
}
// pev->scale = 5.0;
m_flStartTime = gpGlobals->time;
}
void CWreckage::Precache( )
void CWreckage::Precache()
{
if ( pev->model )
PRECACHE_MODEL( (char *)STRING(pev->model) );
if( pev->model )
PRECACHE_MODEL( (char *)STRING( pev->model ) );
}
void CWreckage::Think( void )
{
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.2;
if (pev->dmgtime)
if( pev->dmgtime )
{
if (pev->dmgtime < gpGlobals->time)
if( pev->dmgtime < gpGlobals->time )
{
UTIL_Remove( this );
return;
}
else if (RANDOM_FLOAT( 0, pev->dmgtime - m_flStartTime ) > pev->dmgtime - gpGlobals->time)
else if( RANDOM_FLOAT( 0, pev->dmgtime - m_flStartTime ) > pev->dmgtime - gpGlobals->time )
{
return;
}
@ -440,7 +445,7 @@ void CWreckage::Think( void )
WRITE_COORD( VecSrc.y );
WRITE_COORD( VecSrc.z );
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( RANDOM_LONG(0,49) + 50 ); // scale * 10
WRITE_BYTE( RANDOM_LONG(0, 3) + 8 ); // framerate
WRITE_BYTE( RANDOM_LONG( 0,49 ) + 50 ); // scale * 10
WRITE_BYTE( RANDOM_LONG( 0, 3 ) + 8 ); // framerate
MESSAGE_END();
}

13
dlls/h_export.cpp
View File

@ -33,15 +33,12 @@ server_physics_api_t g_physfuncs;
#ifdef _WIN32
// Required DLL entry point
BOOL WINAPI DllMain(
HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved)
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
if (fdwReason == DLL_PROCESS_ATTACH)
if( fdwReason == DLL_PROCESS_ATTACH )
{
}
else if (fdwReason == DLL_PROCESS_DETACH)
else if( fdwReason == DLL_PROCESS_DETACH )
{
}
return TRUE;
@ -53,8 +50,8 @@ BOOL WINAPI DllMain(
#define EXPORT2
#endif
extern "C" void DLLEXPORT EXPORT2 GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
extern "C" void DLLEXPORT EXPORT2 GiveFnptrsToDll( enginefuncs_t *pengfuncsFromEngine, globalvars_t *pGlobals )
{
memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t));
memcpy( &g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t) );
gpGlobals = pGlobals;
}

57
dlls/handgrenade.cpp
View File

@ -23,7 +23,8 @@
#define HANDGRENADE_PRIMARY_VOLUME 450
enum handgrenade_e {
enum handgrenade_e
{
HANDGRENADE_IDLE = 0,
HANDGRENADE_FIDGET,
HANDGRENADE_PINPULL,
@ -36,11 +37,11 @@ enum handgrenade_e {
LINK_ENTITY_TO_CLASS( weapon_handgrenade, CHandGrenade )
void CHandGrenade::Spawn( )
void CHandGrenade::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_HANDGRENADE;
SET_MODEL(ENT(pev), "models/w_grenade.mdl");
SET_MODEL( ENT( pev ), "models/w_grenade.mdl" );
#ifndef CLIENT_DLL
pev->dmg = gSkillData.plrDmgHandGrenade;
@ -52,14 +53,14 @@ void CHandGrenade::Spawn( )
void CHandGrenade::Precache( void )
{
PRECACHE_MODEL("models/w_grenade.mdl");
PRECACHE_MODEL("models/v_grenade.mdl");
PRECACHE_MODEL("models/p_grenade.mdl");
PRECACHE_MODEL( "models/w_grenade.mdl" );
PRECACHE_MODEL( "models/v_grenade.mdl" );
PRECACHE_MODEL( "models/p_grenade.mdl" );
}
int CHandGrenade::GetItemInfo(ItemInfo *p)
int CHandGrenade::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "Hand Grenade";
p->iMaxAmmo1 = HANDGRENADE_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -74,7 +75,7 @@ int CHandGrenade::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CHandGrenade::Deploy( )
BOOL CHandGrenade::Deploy()
{
m_flReleaseThrow = -1;
return DefaultDeploy( "models/v_grenade.mdl", "models/p_grenade.mdl", HANDGRENADE_DRAW, "crowbar" );
@ -90,24 +91,24 @@ void CHandGrenade::Holster( int skiplocal /* = 0 */ )
{
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
if ( m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
SendWeaponAnim( HANDGRENADE_HOLSTER );
}
else
{
// no more grenades!
m_pPlayer->pev->weapons &= ~(1<<WEAPON_HANDGRENADE);
m_pPlayer->pev->weapons &= ~( 1 << WEAPON_HANDGRENADE );
SetThink( &CBasePlayerItem::DestroyItem );
pev->nextthink = gpGlobals->time + 0.1;
}
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM);
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM );
}
void CHandGrenade::PrimaryAttack()
{
if ( !m_flStartThrow && m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] > 0 )
if( !m_flStartThrow && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] > 0 )
{
m_flStartThrow = gpGlobals->time;
m_flReleaseThrow = 0;
@ -119,23 +120,23 @@ void CHandGrenade::PrimaryAttack()
void CHandGrenade::WeaponIdle( void )
{
if ( m_flReleaseThrow == 0 && m_flStartThrow )
if( m_flReleaseThrow == 0 && m_flStartThrow )
m_flReleaseThrow = gpGlobals->time;
if ( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
if ( m_flStartThrow )
if( m_flStartThrow )
{
Vector angThrow = m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle;
if ( angThrow.x < 0 )
if( angThrow.x < 0 )
angThrow.x = -10 + angThrow.x * ( ( 90 - 10 ) / 90.0 );
else
angThrow.x = -10 + angThrow.x * ( ( 90 + 10 ) / 90.0 );
float flVel = ( 90 - angThrow.x ) * 4;
if ( flVel > 500 )
if( flVel > 500 )
flVel = 500;
UTIL_MakeVectors( angThrow );
@ -146,16 +147,16 @@ void CHandGrenade::WeaponIdle( void )
// alway explode 3 seconds after the pin was pulled
float time = m_flStartThrow - gpGlobals->time + 3.0;
if (time < 0)
if( time < 0 )
time = 0;
CGrenade::ShootTimed( m_pPlayer->pev, vecSrc, vecThrow, time );
if ( flVel < 500 )
if( flVel < 500 )
{
SendWeaponAnim( HANDGRENADE_THROW1 );
}
else if ( flVel < 1000 )
else if( flVel < 1000 )
{
SendWeaponAnim( HANDGRENADE_THROW2 );
}
@ -172,9 +173,9 @@ void CHandGrenade::WeaponIdle( void )
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.5;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 0.5;
m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ]--;
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;
if ( !m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] )
if( !m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
// just threw last grenade
// set attack times in the future, and weapon idle in the future so we can see the whole throw
@ -183,12 +184,12 @@ void CHandGrenade::WeaponIdle( void )
}
return;
}
else if ( m_flReleaseThrow > 0 )
else if( m_flReleaseThrow > 0 )
{
// we've finished the throw, restart.
m_flStartThrow = 0;
if ( m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
SendWeaponAnim( HANDGRENADE_DRAW );
}
@ -203,11 +204,11 @@ void CHandGrenade::WeaponIdle( void )
return;
}
if ( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
int iAnim;
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0, 1 );
if (flRand <= 0.75)
if( flRand <= 0.75 )
{
iAnim = HANDGRENADE_IDLE;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );// how long till we do this again.

306
dlls/hassassin.cpp
View File

@ -57,7 +57,7 @@ enum
#define ASSASSIN_AE_TOSS1 2
#define ASSASSIN_AE_JUMP 3
#define bits_MEMORY_BADJUMP (bits_MEMORY_CUSTOM1)
#define bits_MEMORY_BADJUMP ( bits_MEMORY_CUSTOM1 )
class CHAssassin : public CBaseMonster
{
@ -65,21 +65,21 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed ( void );
int Classify ( void );
int ISoundMask ( void);
int Classify( void );
int ISoundMask( void);
void Shoot( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
Schedule_t* GetSchedule ( void );
Schedule_t* GetScheduleOfType ( int Type );
BOOL CheckMeleeAttack1 ( float flDot, float flDist ); // jump
// BOOL CheckMeleeAttack2 ( float flDot, float flDist );
BOOL CheckRangeAttack1 ( float flDot, float flDist ); // shoot
BOOL CheckRangeAttack2 ( float flDot, float flDist ); // throw grenade
void StartTask ( Task_t *pTask );
Schedule_t *GetSchedule( void );
Schedule_t *GetScheduleOfType( int Type );
BOOL CheckMeleeAttack1( float flDot, float flDist ); // jump
// BOOL CheckMeleeAttack2( float flDot, float flDist );
BOOL CheckRangeAttack1( float flDot, float flDist ); // shoot
BOOL CheckRangeAttack2( float flDot, float flDist ); // throw grenade
void StartTask( Task_t *pTask );
void RunAI( void );
void RunTask ( Task_t *pTask );
void DeathSound ( void );
void IdleSound ( void );
void RunTask( Task_t *pTask );
void DeathSound( void );
void IdleSound( void );
CUSTOM_SCHEDULES
int Save( CSave &save );
@ -126,14 +126,14 @@ IMPLEMENT_SAVERESTORE( CHAssassin, CBaseMonster )
//=========================================================
// DieSound
//=========================================================
void CHAssassin :: DeathSound ( void )
void CHAssassin::DeathSound( void )
{
}
//=========================================================
// IdleSound
//=========================================================
void CHAssassin :: IdleSound ( void )
void CHAssassin::IdleSound( void )
{
}
@ -141,7 +141,7 @@ void CHAssassin :: IdleSound ( void )
// ISoundMask - returns a bit mask indicating which types
// of sounds this monster regards.
//=========================================================
int CHAssassin :: ISoundMask ( void)
int CHAssassin::ISoundMask( void )
{
return bits_SOUND_WORLD |
bits_SOUND_COMBAT |
@ -153,7 +153,7 @@ int CHAssassin :: ISoundMask ( void)
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CHAssassin :: Classify ( void )
int CHAssassin::Classify( void )
{
return CLASS_HUMAN_MILITARY;
}
@ -162,11 +162,11 @@ int CHAssassin :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CHAssassin :: SetYawSpeed ( void )
void CHAssassin::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_TURN_LEFT:
case ACT_TURN_RIGHT:
@ -183,9 +183,9 @@ void CHAssassin :: SetYawSpeed ( void )
//=========================================================
// Shoot
//=========================================================
void CHAssassin :: Shoot ( void )
void CHAssassin::Shoot( void )
{
if (m_hEnemy == NULL)
if( m_hEnemy == NULL )
{
return;
}
@ -193,31 +193,31 @@ void CHAssassin :: Shoot ( void )
Vector vecShootOrigin = GetGunPosition();
Vector vecShootDir = ShootAtEnemy( vecShootOrigin );
if (m_flLastShot + 2 < gpGlobals->time)
if( m_flLastShot + 2 < gpGlobals->time )
{
m_flDiviation = 0.10;
}
else
{
m_flDiviation -= 0.01;
if (m_flDiviation < 0.02)
if( m_flDiviation < 0.02 )
m_flDiviation = 0.02;
}
m_flLastShot = gpGlobals->time;
UTIL_MakeVectors ( pev->angles );
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
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))
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);
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);
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "weapons/pl_gun2.wav", RANDOM_FLOAT( 0.6, 0.8 ), ATTN_NORM );
break;
}
@ -235,17 +235,17 @@ void CHAssassin :: Shoot ( void )
//
// Returns number of events handled, 0 if none.
//=========================================================
void CHAssassin :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CHAssassin::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
case ASSASSIN_AE_SHOOT1:
Shoot( );
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 );
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;
@ -271,12 +271,12 @@ void CHAssassin :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CHAssassin :: Spawn()
void CHAssassin::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/hassassin.mdl");
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
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;
@ -300,16 +300,16 @@ void CHAssassin :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CHAssassin :: Precache()
void CHAssassin::Precache()
{
PRECACHE_MODEL("models/hassassin.mdl");
PRECACHE_MODEL( "models/hassassin.mdl" );
PRECACHE_SOUND("weapons/pl_gun1.wav");
PRECACHE_SOUND("weapons/pl_gun2.wav");
PRECACHE_SOUND( "weapons/pl_gun1.wav" );
PRECACHE_SOUND( "weapons/pl_gun2.wav" );
PRECACHE_SOUND("debris/beamstart1.wav");
PRECACHE_SOUND( "debris/beamstart1.wav" );
m_iShell = PRECACHE_MODEL ("models/shell.mdl");// brass shell
m_iShell = PRECACHE_MODEL( "models/shell.mdl" );// brass shell
}
//=========================================================
@ -332,7 +332,7 @@ Schedule_t slAssassinFail[] =
{
{
tlAssassinFail,
ARRAYSIZE ( tlAssassinFail ),
ARRAYSIZE( tlAssassinFail ),
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_PROVOKED |
@ -340,7 +340,6 @@ Schedule_t slAssassinFail[] =
bits_COND_CAN_RANGE_ATTACK2 |
bits_COND_CAN_MELEE_ATTACK1 |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER |
bits_SOUND_PLAYER,
"AssassinFail"
@ -362,7 +361,7 @@ Schedule_t slAssassinExposed[] =
{
{
tlAssassinExposed,
ARRAYSIZE ( tlAssassinExposed ),
ARRAYSIZE( tlAssassinExposed ),
bits_COND_CAN_MELEE_ATTACK1,
0,
"AssassinExposed",
@ -389,11 +388,10 @@ Schedule_t slAssassinTakeCoverFromEnemy[] =
{
{
tlAssassinTakeCoverFromEnemy,
ARRAYSIZE ( tlAssassinTakeCoverFromEnemy ),
ARRAYSIZE( tlAssassinTakeCoverFromEnemy ),
bits_COND_NEW_ENEMY |
bits_COND_CAN_MELEE_ATTACK1 |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"AssassinTakeCoverFromEnemy"
},
@ -421,11 +419,10 @@ Schedule_t slAssassinTakeCoverFromEnemy2[] =
{
{
tlAssassinTakeCoverFromEnemy2,
ARRAYSIZE ( tlAssassinTakeCoverFromEnemy2 ),
ARRAYSIZE( tlAssassinTakeCoverFromEnemy2 ),
bits_COND_NEW_ENEMY |
bits_COND_CAN_MELEE_ATTACK2 |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"AssassinTakeCoverFromEnemy2"
},
@ -449,7 +446,7 @@ Schedule_t slAssassinTakeCoverFromBestSound[] =
{
{
tlAssassinTakeCoverFromBestSound,
ARRAYSIZE ( tlAssassinTakeCoverFromBestSound ),
ARRAYSIZE( tlAssassinTakeCoverFromBestSound ),
bits_COND_NEW_ENEMY,
0,
"AssassinTakeCoverFromBestSound"
@ -471,7 +468,7 @@ Schedule_t slAssassinHide[] =
{
{
tlAssassinHide,
ARRAYSIZE ( tlAssassinHide ),
ARRAYSIZE( tlAssassinHide ),
bits_COND_NEW_ENEMY |
bits_COND_SEE_ENEMY |
bits_COND_SEE_FEAR |
@ -479,7 +476,6 @@ Schedule_t slAssassinHide[] =
bits_COND_HEAVY_DAMAGE |
bits_COND_PROVOKED |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"AssassinHide"
},
@ -499,12 +495,11 @@ Schedule_t slAssassinHunt[] =
{
{
tlAssassinHunt,
ARRAYSIZE ( tlAssassinHunt ),
ARRAYSIZE( tlAssassinHunt ),
bits_COND_NEW_ENEMY |
// bits_COND_SEE_ENEMY |
bits_COND_CAN_RANGE_ATTACK1 |
bits_COND_HEAR_SOUND,
bits_SOUND_DANGER,
"AssassinHunt"
},
@ -524,7 +519,7 @@ Schedule_t slAssassinJump[] =
{
{
tlAssassinJump,
ARRAYSIZE ( tlAssassinJump ),
ARRAYSIZE( tlAssassinJump ),
0,
0,
"AssassinJump"
@ -545,7 +540,7 @@ Schedule_t slAssassinJumpAttack[] =
{
{
tlAssassinJumpAttack,
ARRAYSIZE ( tlAssassinJumpAttack ),
ARRAYSIZE( tlAssassinJumpAttack ),
0,
0,
"AssassinJumpAttack"
@ -574,7 +569,7 @@ Schedule_t slAssassinJumpLand[] =
{
{
tlAssassinJumpLand,
ARRAYSIZE ( tlAssassinJumpLand ),
ARRAYSIZE( tlAssassinJumpLand ),
0,
0,
"AssassinJumpLand"
@ -600,26 +595,26 @@ IMPLEMENT_CUSTOM_SCHEDULES( CHAssassin, CBaseMonster )
//=========================================================
// CheckMeleeAttack1 - jump like crazy if the enemy gets too close.
//=========================================================
BOOL CHAssassin :: CheckMeleeAttack1 ( float flDot, float flDist )
BOOL CHAssassin::CheckMeleeAttack1( float flDot, float flDist )
{
if ( m_flNextJump < gpGlobals->time && (flDist <= 128 || HasMemory( bits_MEMORY_BADJUMP )) && m_hEnemy != NULL )
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);
UTIL_TraceHull( pev->origin + Vector( 0, 0, 36 ), vecDest + Vector( 0, 0, 36 ), dont_ignore_monsters, human_hull, ENT( pev ), &tr );
if ( tr.fStartSolid || tr.flFraction < 1.0)
if( tr.fStartSolid || tr.flFraction < 1.0 )
{
return FALSE;
}
float flGravity = g_psv_gravity->value;
float time = sqrt( 160 / (0.5 * flGravity));
float time = sqrt( 160 / ( 0.5 * flGravity ) );
float speed = flGravity * time / 160;
m_vecJumpVelocity = (vecDest - pev->origin) * speed;
m_vecJumpVelocity = ( vecDest - pev->origin ) * speed;
return TRUE;
}
@ -630,18 +625,18 @@ BOOL CHAssassin :: CheckMeleeAttack1 ( float flDot, float flDist )
// CheckRangeAttack1 - drop a cap in their ass
//
//=========================================================
BOOL CHAssassin :: CheckRangeAttack1 ( float flDot, float flDist )
BOOL CHAssassin::CheckRangeAttack1( float flDot, float flDist )
{
if ( !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDist > 64 && flDist <= 2048 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */ )
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);
UTIL_TraceLine( vecSrc, m_hEnemy->BodyTarget( vecSrc ), dont_ignore_monsters, ENT( pev ), &tr );
if ( tr.flFraction == 1 || tr.pHit == m_hEnemy->edict() )
if( tr.flFraction == 1 || tr.pHit == m_hEnemy->edict() )
{
return TRUE;
}
@ -652,24 +647,24 @@ BOOL CHAssassin :: CheckRangeAttack1 ( float flDot, float flDist )
//=========================================================
// CheckRangeAttack2 - toss grenade is enemy gets in the way and is too close.
//=========================================================
BOOL CHAssassin :: CheckRangeAttack2 ( float flDot, float flDist )
BOOL CHAssassin::CheckRangeAttack2( float flDot, float flDist )
{
m_fThrowGrenade = FALSE;
if ( !FBitSet ( m_hEnemy->pev->flags, FL_ONGROUND ) )
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)
if( m_iFrustration <= 2 )
return FALSE;
if ( m_flNextGrenadeCheck < gpGlobals->time && !HasConditions( bits_COND_ENEMY_OCCLUDED ) && flDist <= 512 /* && flDot >= 0.5 */ /* && NoFriendlyFire() */ )
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
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 )
if( vecToss != g_vecZero )
{
m_vecTossVelocity = vecToss;
@ -686,46 +681,54 @@ BOOL CHAssassin :: CheckRangeAttack2 ( float flDot, float flDist )
//=========================================================
// RunAI
//=========================================================
void CHAssassin :: RunAI( void )
void CHAssassin::RunAI( void )
{
CBaseMonster :: 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))
if( g_iSkillLevel != SKILL_HARD || m_hEnemy == NULL || pev->deadflag != DEAD_NO || m_Activity == ACT_RUN || m_Activity == ACT_WALK || !( pev->flags & FL_ONGROUND ) )
m_iTargetRanderamt = 255;
else
m_iTargetRanderamt = 20;
if (pev->renderamt > m_iTargetRanderamt)
if( pev->renderamt > m_iTargetRanderamt )
{
if (pev->renderamt == 255)
if( pev->renderamt == 255 )
{
EMIT_SOUND (ENT(pev), CHAN_BODY, "debris/beamstart1.wav", 0.2, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_BODY, "debris/beamstart1.wav", 0.2, ATTN_NORM );
}
pev->renderamt = max( pev->renderamt - 50, m_iTargetRanderamt );
pev->rendermode = kRenderTransTexture;
}
else if (pev->renderamt < m_iTargetRanderamt)
else if( pev->renderamt < m_iTargetRanderamt )
{
pev->renderamt = min( pev->renderamt + 50, m_iTargetRanderamt );
if (pev->renderamt == 255)
if( pev->renderamt == 255 )
pev->rendermode = kRenderNormal;
}
if (m_Activity == ACT_RUN || m_Activity == ACT_WALK)
if( m_Activity == ACT_RUN || m_Activity == ACT_WALK )
{
static int iStep = 0;
iStep = ! iStep;
if (iStep)
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;
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;
}
}
}
@ -734,24 +737,24 @@ void CHAssassin :: RunAI( void )
//=========================================================
// StartTask
//=========================================================
void CHAssassin :: StartTask ( Task_t *pTask )
void CHAssassin::StartTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_RANGE_ATTACK2:
if (!m_fThrowGrenade)
if( !m_fThrowGrenade )
{
TaskComplete( );
TaskComplete();
}
else
{
CBaseMonster :: StartTask ( pTask );
CBaseMonster::StartTask( pTask );
}
break;
case TASK_ASSASSIN_FALL_TO_GROUND:
break;
default:
CBaseMonster :: StartTask ( pTask );
CBaseMonster::StartTask( pTask );
break;
}
}
@ -759,21 +762,21 @@ void CHAssassin :: StartTask ( Task_t *pTask )
//=========================================================
// RunTask
//=========================================================
void CHAssassin :: RunTask ( Task_t *pTask )
void CHAssassin::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_ASSASSIN_FALL_TO_GROUND:
MakeIdealYaw( m_vecEnemyLKP );
ChangeYaw( pev->yaw_speed );
if (m_fSequenceFinished)
if( m_fSequenceFinished )
{
if (pev->velocity.z > 0)
if( pev->velocity.z > 0 )
{
pev->sequence = LookupSequence( "fly_up" );
}
else if (HasConditions ( bits_COND_SEE_ENEMY ))
else if( HasConditions( bits_COND_SEE_ENEMY ) )
{
pev->sequence = LookupSequence( "fly_attack" );
pev->frame = 0;
@ -784,17 +787,17 @@ void CHAssassin :: RunTask ( Task_t *pTask )
pev->frame = 0;
}
ResetSequenceInfo( );
ResetSequenceInfo();
SetYawSpeed();
}
if (pev->flags & FL_ONGROUND)
if( pev->flags & FL_ONGROUND )
{
// ALERT( at_console, "on ground\n");
TaskComplete( );
// ALERT( at_console, "on ground\n" );
TaskComplete();
}
break;
default:
CBaseMonster :: RunTask ( pTask );
CBaseMonster::RunTask( pTask );
break;
}
}
@ -805,145 +808,144 @@ void CHAssassin :: RunTask ( Task_t *pTask )
// monster's member function to get a pointer to a schedule
// of the proper type.
//=========================================================
Schedule_t *CHAssassin :: GetSchedule ( void )
Schedule_t *CHAssassin::GetSchedule( void )
{
switch ( m_MonsterState )
switch( m_MonsterState )
{
case MONSTERSTATE_IDLE:
case MONSTERSTATE_ALERT:
{
if ( HasConditions ( bits_COND_HEAR_SOUND ))
if( HasConditions( bits_COND_HEAR_SOUND ) )
{
CSound *pSound;
pSound = PBestSound();
ASSERT( pSound != NULL );
if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
if( pSound &&( pSound->m_iType & bits_SOUND_DANGER ) )
{
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
}
if ( pSound && (pSound->m_iType & bits_SOUND_COMBAT) )
if( pSound &&( pSound->m_iType & bits_SOUND_COMBAT ) )
{
return GetScheduleOfType( SCHED_INVESTIGATE_SOUND );
}
}
}
break;
case MONSTERSTATE_COMBAT:
{
// dead enemy
if ( HasConditions( bits_COND_ENEMY_DEAD ) )
if( HasConditions( bits_COND_ENEMY_DEAD ) )
{
// call base class, all code to handle dead enemies is centralized there.
return CBaseMonster :: GetSchedule();
return CBaseMonster::GetSchedule();
}
// flying?
if ( pev->movetype == MOVETYPE_TOSS)
if( pev->movetype == MOVETYPE_TOSS )
{
if (pev->flags & FL_ONGROUND)
if( pev->flags & FL_ONGROUND )
{
// ALERT( at_console, "landed\n");
// ALERT( at_console, "landed\n" );
// just landed
pev->movetype = MOVETYPE_STEP;
return GetScheduleOfType ( SCHED_ASSASSIN_JUMP_LAND );
}
else
{
// ALERT( at_console, "jump\n");
// ALERT( at_console, "jump\n" );
// jump or jump/shoot
if ( m_MonsterState == MONSTERSTATE_COMBAT )
return GetScheduleOfType ( SCHED_ASSASSIN_JUMP );
if( m_MonsterState == MONSTERSTATE_COMBAT )
return GetScheduleOfType( SCHED_ASSASSIN_JUMP );
else
return GetScheduleOfType ( SCHED_ASSASSIN_JUMP_ATTACK );
return GetScheduleOfType( SCHED_ASSASSIN_JUMP_ATTACK );
}
}
if ( HasConditions ( bits_COND_HEAR_SOUND ))
if( HasConditions( bits_COND_HEAR_SOUND ) )
{
CSound *pSound;
pSound = PBestSound();
ASSERT( pSound != NULL );
if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
if( pSound && ( pSound->m_iType & bits_SOUND_DANGER ) )
{
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
}
}
if ( HasConditions ( bits_COND_LIGHT_DAMAGE ) )
if( HasConditions( bits_COND_LIGHT_DAMAGE ) )
{
m_iFrustration++;
}
if ( HasConditions ( bits_COND_HEAVY_DAMAGE ) )
if( HasConditions( bits_COND_HEAVY_DAMAGE ) )
{
m_iFrustration++;
}
// jump player!
if ( HasConditions ( bits_COND_CAN_MELEE_ATTACK1 ) )
if( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
{
// ALERT( at_console, "melee attack 1\n");
return GetScheduleOfType ( SCHED_MELEE_ATTACK1 );
// ALERT( at_console, "melee attack 1\n" );
return GetScheduleOfType( SCHED_MELEE_ATTACK1 );
}
// throw grenade
if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK2 ) )
if( HasConditions( bits_COND_CAN_RANGE_ATTACK2 ) )
{
// ALERT( at_console, "range attack 2\n");
return GetScheduleOfType ( SCHED_RANGE_ATTACK2 );
return GetScheduleOfType( SCHED_RANGE_ATTACK2 );
}
// spotted
if ( HasConditions ( bits_COND_SEE_ENEMY ) && HasConditions ( bits_COND_ENEMY_FACING_ME ) )
if( HasConditions( bits_COND_SEE_ENEMY ) && HasConditions( bits_COND_ENEMY_FACING_ME ) )
{
// ALERT( at_console, "exposed\n");
// ALERT( at_console, "exposed\n" );
m_iFrustration++;
return GetScheduleOfType ( SCHED_ASSASSIN_EXPOSED );
return GetScheduleOfType( SCHED_ASSASSIN_EXPOSED );
}
// can attack
if ( HasConditions ( bits_COND_CAN_RANGE_ATTACK1 ) )
if( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )
{
// ALERT( at_console, "range attack 1\n");
// ALERT( at_console, "range attack 1\n" );
m_iFrustration = 0;
return GetScheduleOfType ( SCHED_RANGE_ATTACK1 );
return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
}
if ( HasConditions ( bits_COND_SEE_ENEMY ) )
if( HasConditions( bits_COND_SEE_ENEMY ) )
{
// ALERT( at_console, "face\n");
return GetScheduleOfType ( SCHED_COMBAT_FACE );
// ALERT( at_console, "face\n" );
return GetScheduleOfType( SCHED_COMBAT_FACE );
}
// new enemy
if ( HasConditions ( bits_COND_NEW_ENEMY ) )
if( HasConditions( bits_COND_NEW_ENEMY ) )
{
// ALERT( at_console, "take cover\n");
return GetScheduleOfType ( SCHED_TAKE_COVER_FROM_ENEMY );
// ALERT( at_console, "take cover\n" );
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
}
// ALERT( at_console, "stand\n");
return GetScheduleOfType ( SCHED_ALERT_STAND );
// ALERT( at_console, "stand\n" );
return GetScheduleOfType( SCHED_ALERT_STAND );
}
break;
default:
break;
}
return CBaseMonster :: GetSchedule();
return CBaseMonster::GetSchedule();
}
//=========================================================
//=========================================================
Schedule_t* CHAssassin :: GetScheduleOfType ( int Type )
Schedule_t *CHAssassin::GetScheduleOfType( int Type )
{
// ALERT( at_console, "%d\n", m_iFrustration );
switch ( Type )
switch( Type )
{
case SCHED_TAKE_COVER_FROM_ENEMY:
if (pev->health > 30)
if( pev->health > 30 )
return slAssassinTakeCoverFromEnemy;
else
return slAssassinTakeCoverFromEnemy2;
@ -952,19 +954,19 @@ Schedule_t* CHAssassin :: GetScheduleOfType ( int Type )
case SCHED_ASSASSIN_EXPOSED:
return slAssassinExposed;
case SCHED_FAIL:
if (m_MonsterState == MONSTERSTATE_COMBAT)
if( m_MonsterState == MONSTERSTATE_COMBAT )
return slAssassinFail;
break;
case SCHED_ALERT_STAND:
if (m_MonsterState == MONSTERSTATE_COMBAT)
if( m_MonsterState == MONSTERSTATE_COMBAT )
return slAssassinHide;
break;
case SCHED_CHASE_ENEMY:
return slAssassinHunt;
case SCHED_MELEE_ATTACK1:
if (pev->flags & FL_ONGROUND)
if( pev->flags & FL_ONGROUND )
{
if (m_flNextJump > gpGlobals->time)
if( m_flNextJump > gpGlobals->time )
{
// can't jump yet, go ahead and fail
return slAssassinFail;
@ -985,6 +987,6 @@ Schedule_t* CHAssassin :: GetScheduleOfType ( int Type )
return slAssassinJumpLand;
}
return CBaseMonster :: GetScheduleOfType( Type );
return CBaseMonster::GetScheduleOfType( Type );
}
#endif

159
dlls/headcrab.cpp
View File

@ -42,7 +42,7 @@ Schedule_t slHCRangeAttack1[] =
{
{
tlHCRangeAttack1,
ARRAYSIZE ( tlHCRangeAttack1 ),
ARRAYSIZE( tlHCRangeAttack1 ),
bits_COND_ENEMY_OCCLUDED |
bits_COND_NO_AMMO_LOADED,
0,
@ -62,7 +62,7 @@ Schedule_t slHCRangeAttack1Fast[] =
{
{
tlHCRangeAttack1Fast,
ARRAYSIZE ( tlHCRangeAttack1Fast ),
ARRAYSIZE( tlHCRangeAttack1Fast ),
bits_COND_ENEMY_OCCLUDED |
bits_COND_NO_AMMO_LOADED,
0,
@ -158,7 +158,7 @@ const char *CHeadCrab::pBiteSounds[] =
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CHeadCrab :: Classify ( void )
int CHeadCrab::Classify( void )
{
return CLASS_ALIEN_PREY;
}
@ -168,25 +168,25 @@ int CHeadCrab :: Classify ( void )
// bounding box is much larger than the actual creature so
// this is needed for targeting
//=========================================================
Vector CHeadCrab :: Center ( void )
Vector CHeadCrab::Center( void )
{
return Vector( pev->origin.x, pev->origin.y, pev->origin.z + 6 );
}
Vector CHeadCrab :: BodyTarget( const Vector &posSrc )
Vector CHeadCrab::BodyTarget( const Vector &posSrc )
{
return Center( );
return Center();
}
//=========================================================
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CHeadCrab :: SetYawSpeed ( void )
void CHeadCrab::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_IDLE:
ys = 30;
@ -214,7 +214,7 @@ void CHeadCrab :: SetYawSpeed ( void )
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CHeadCrab :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CHeadCrab::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch( pEvent->event )
{
@ -222,25 +222,25 @@ void CHeadCrab :: HandleAnimEvent( MonsterEvent_t *pEvent )
{
ClearBits( pev->flags, FL_ONGROUND );
UTIL_SetOrigin (pev, pev->origin + Vector ( 0 , 0 , 1) );// take him off ground so engine doesn't instantly reset onground
UTIL_MakeVectors ( pev->angles );
UTIL_SetOrigin( pev, pev->origin + Vector( 0, 0, 1 ) );// take him off ground so engine doesn't instantly reset onground
UTIL_MakeVectors( pev->angles );
Vector vecJumpDir;
if (m_hEnemy != NULL)
if( m_hEnemy != NULL )
{
float gravity = g_psv_gravity->value;
if (gravity <= 1)
if( gravity <= 1 )
gravity = 1;
// How fast does the headcrab need to travel to reach that height given gravity?
float height = (m_hEnemy->pev->origin.z + m_hEnemy->pev->view_ofs.z - pev->origin.z);
if (height < 16)
float height = m_hEnemy->pev->origin.z + m_hEnemy->pev->view_ofs.z - pev->origin.z;
if( height < 16 )
height = 16;
float speed = sqrt( 2 * gravity * height );
float time = speed / gravity;
// Scale the sideways velocity to get there at the right time
vecJumpDir = (m_hEnemy->pev->origin + m_hEnemy->pev->view_ofs - pev->origin);
vecJumpDir = m_hEnemy->pev->origin + m_hEnemy->pev->view_ofs - pev->origin;
vecJumpDir = vecJumpDir * ( 1.0 / time );
// Speed to offset gravity at the desired height
@ -249,7 +249,7 @@ void CHeadCrab :: HandleAnimEvent( MonsterEvent_t *pEvent )
// Don't jump too far/fast
float distance = vecJumpDir.Length();
if (distance > 650)
if( distance > 650 )
{
vecJumpDir = vecJumpDir * ( 650.0 / distance );
}
@ -261,14 +261,13 @@ void CHeadCrab :: HandleAnimEvent( MonsterEvent_t *pEvent )
}
int iSound = RANDOM_LONG(0,2);
if ( iSound != 0 )
if( iSound != 0 )
EMIT_SOUND_DYN( edict(), CHAN_VOICE, pAttackSounds[iSound], GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
pev->velocity = vecJumpDir;
m_flNextAttack = gpGlobals->time + 2;
}
break;
default:
CBaseMonster::HandleAnimEvent( pEvent );
break;
@ -278,19 +277,19 @@ void CHeadCrab :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CHeadCrab :: Spawn()
void CHeadCrab::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/headcrab.mdl");
UTIL_SetSize(pev, Vector(-12, -12, 0), Vector(12, 12, 24));
SET_MODEL( ENT( pev ), "models/headcrab.mdl" );
UTIL_SetSize( pev, Vector( -12, -12, 0 ), Vector( 12, 12, 24 ) );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->effects = 0;
pev->health = gSkillData.headcrabHealth;
pev->view_ofs = Vector ( 0, 0, 20 );// position of the eyes relative to monster's origin.
pev->view_ofs = Vector( 0, 0, 20 );// position of the eyes relative to monster's origin.
pev->yaw_speed = 5;//!!! should we put this in the monster's changeanim function since turn rates may vary with state/anim?
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
@ -301,29 +300,29 @@ void CHeadCrab :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CHeadCrab :: Precache()
void CHeadCrab::Precache()
{
PRECACHE_SOUND_ARRAY(pIdleSounds);
PRECACHE_SOUND_ARRAY(pAlertSounds);
PRECACHE_SOUND_ARRAY(pPainSounds);
PRECACHE_SOUND_ARRAY(pAttackSounds);
PRECACHE_SOUND_ARRAY(pDeathSounds);
PRECACHE_SOUND_ARRAY(pBiteSounds);
PRECACHE_SOUND_ARRAY( pIdleSounds );
PRECACHE_SOUND_ARRAY( pAlertSounds );
PRECACHE_SOUND_ARRAY( pPainSounds );
PRECACHE_SOUND_ARRAY( pAttackSounds );
PRECACHE_SOUND_ARRAY( pDeathSounds );
PRECACHE_SOUND_ARRAY( pBiteSounds );
PRECACHE_MODEL("models/headcrab.mdl");
PRECACHE_MODEL( "models/headcrab.mdl" );
}
//=========================================================
// RunTask
//=========================================================
void CHeadCrab :: RunTask ( Task_t *pTask )
void CHeadCrab::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_RANGE_ATTACK1:
case TASK_RANGE_ATTACK2:
{
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
TaskComplete();
SetTouch( NULL );
@ -333,7 +332,7 @@ void CHeadCrab :: RunTask ( Task_t *pTask )
}
default:
{
CBaseMonster :: RunTask(pTask);
CBaseMonster::RunTask( pTask );
}
}
}
@ -342,22 +341,22 @@ void CHeadCrab :: RunTask ( Task_t *pTask )
// LeapTouch - this is the headcrab's touch function when it
// is in the air
//=========================================================
void CHeadCrab :: LeapTouch ( CBaseEntity *pOther )
void CHeadCrab::LeapTouch( CBaseEntity *pOther )
{
if ( !pOther->pev->takedamage )
if( !pOther->pev->takedamage )
{
return;
}
if ( pOther->Classify() == Classify() )
if( pOther->Classify() == Classify() )
{
return;
}
// Don't hit if back on ground
if ( !FBitSet( pev->flags, FL_ONGROUND ) )
if( !FBitSet( pev->flags, FL_ONGROUND ) )
{
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY(pBiteSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
EMIT_SOUND_DYN( edict(), CHAN_WEAPON, RANDOM_SOUND_ARRAY( pBiteSounds ), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
pOther->TakeDamage( pev, pev, GetDamageAmount(), DMG_SLASH );
}
@ -368,20 +367,20 @@ void CHeadCrab :: LeapTouch ( CBaseEntity *pOther )
//=========================================================
// PrescheduleThink
//=========================================================
void CHeadCrab :: PrescheduleThink ( void )
void CHeadCrab::PrescheduleThink( void )
{
// make the crab coo a little bit in combat state
if ( m_MonsterState == MONSTERSTATE_COMBAT && RANDOM_FLOAT( 0, 5 ) < 0.1 )
if( m_MonsterState == MONSTERSTATE_COMBAT && RANDOM_FLOAT( 0, 5 ) < 0.1 )
{
IdleSound();
}
}
void CHeadCrab :: StartTask ( Task_t *pTask )
void CHeadCrab::StartTask( Task_t *pTask )
{
m_iTaskStatus = TASKSTATUS_RUNNING;
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_RANGE_ATTACK1:
{
@ -392,7 +391,7 @@ void CHeadCrab :: StartTask ( Task_t *pTask )
}
default:
{
CBaseMonster :: StartTask( pTask );
CBaseMonster::StartTask( pTask );
}
}
}
@ -400,9 +399,9 @@ void CHeadCrab :: StartTask ( Task_t *pTask )
//=========================================================
// CheckRangeAttack1
//=========================================================
BOOL CHeadCrab :: CheckRangeAttack1 ( float flDot, float flDist )
BOOL CHeadCrab::CheckRangeAttack1( float flDot, float flDist )
{
if ( FBitSet( pev->flags, FL_ONGROUND ) && flDist <= 256 && flDot >= 0.65 )
if( FBitSet( pev->flags, FL_ONGROUND ) && flDist <= 256 && flDot >= 0.65 )
{
return TRUE;
}
@ -412,12 +411,12 @@ BOOL CHeadCrab :: CheckRangeAttack1 ( float flDot, float flDist )
//=========================================================
// CheckRangeAttack2
//=========================================================
BOOL CHeadCrab :: CheckRangeAttack2 ( float flDot, float flDist )
BOOL CHeadCrab::CheckRangeAttack2( float flDot, float flDist )
{
return FALSE;
// BUGBUG: Why is this code here? There is no ACT_RANGE_ATTACK2 animation. I've disabled it for now.
#if 0
if ( FBitSet( pev->flags, FL_ONGROUND ) && flDist > 64 && flDist <= 256 && flDot >= 0.5 )
if( FBitSet( pev->flags, FL_ONGROUND ) && flDist > 64 && flDist <= 256 && flDot >= 0.5 )
{
return TRUE;
}
@ -425,55 +424,56 @@ BOOL CHeadCrab :: CheckRangeAttack2 ( float flDot, float flDist )
#endif
}
int CHeadCrab :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
int CHeadCrab::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
// Don't take any acid damage -- BigMomma's mortar is acid
if ( bitsDamageType & DMG_ACID )
if( bitsDamageType & DMG_ACID )
flDamage = 0;
return CBaseMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}
#define CRAB_ATTN_IDLE (float)1.5
//=========================================================
// IdleSound
//=========================================================
#define CRAB_ATTN_IDLE (float)1.5
void CHeadCrab :: IdleSound ( void )
void CHeadCrab::IdleSound( void )
{
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pIdleSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY( pIdleSounds ), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
}
//=========================================================
// AlertSound
//=========================================================
void CHeadCrab :: AlertSound ( void )
void CHeadCrab::AlertSound( void )
{
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pAlertSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY( pAlertSounds ), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
}
//=========================================================
// AlertSound
//=========================================================
void CHeadCrab :: PainSound ( void )
void CHeadCrab::PainSound( void )
{
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pPainSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY( pPainSounds ), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
}
//=========================================================
// DeathSound
//=========================================================
void CHeadCrab :: DeathSound ( void )
void CHeadCrab::DeathSound( void )
{
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY(pDeathSounds), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
EMIT_SOUND_DYN( edict(), CHAN_VOICE, RANDOM_SOUND_ARRAY( pDeathSounds ), GetSoundVolue(), ATTN_IDLE, 0, GetVoicePitch() );
}
Schedule_t* CHeadCrab :: GetScheduleOfType ( int Type )
Schedule_t *CHeadCrab::GetScheduleOfType( int Type )
{
switch ( Type )
switch( Type )
{
case SCHED_RANGE_ATTACK1:
{
return &slHCRangeAttack1[ 0 ];
return &slHCRangeAttack1[0];
}
break;
}
@ -486,62 +486,61 @@ class CBabyCrab : public CHeadCrab
public:
void Spawn( void );
void Precache( void );
void SetYawSpeed ( void );
void SetYawSpeed( void );
float GetDamageAmount( void ) { return gSkillData.headcrabDmgBite * 0.3; }
BOOL CheckRangeAttack1 ( float flDot, float flDist );
Schedule_t* GetScheduleOfType ( int Type );
virtual int GetVoicePitch( void ) { return PITCH_NORM + RANDOM_LONG(40,50); }
BOOL CheckRangeAttack1( float flDot, float flDist );
Schedule_t *GetScheduleOfType ( int Type );
virtual int GetVoicePitch( void ) { return PITCH_NORM + RANDOM_LONG( 40, 50 ); }
virtual float GetSoundVolue( void ) { return 0.8; }
};
LINK_ENTITY_TO_CLASS( monster_babycrab, CBabyCrab )
void CBabyCrab :: Spawn( void )
void CBabyCrab::Spawn( void )
{
CHeadCrab::Spawn();
SET_MODEL(ENT(pev), "models/baby_headcrab.mdl");
SET_MODEL( ENT( pev ), "models/baby_headcrab.mdl" );
pev->rendermode = kRenderTransTexture;
pev->renderamt = 192;
UTIL_SetSize(pev, Vector(-12, -12, 0), Vector(12, 12, 24));
UTIL_SetSize( pev, Vector( -12, -12, 0 ), Vector( 12, 12, 24 ) );
pev->health = gSkillData.headcrabHealth * 0.25; // less health than full grown
}
void CBabyCrab :: Precache( void )
void CBabyCrab::Precache( void )
{
PRECACHE_MODEL( "models/baby_headcrab.mdl" );
CHeadCrab::Precache();
}
void CBabyCrab :: SetYawSpeed ( void )
void CBabyCrab::SetYawSpeed( void )
{
pev->yaw_speed = 120;
}
BOOL CBabyCrab :: CheckRangeAttack1( float flDot, float flDist )
BOOL CBabyCrab::CheckRangeAttack1( float flDot, float flDist )
{
if ( pev->flags & FL_ONGROUND )
if( pev->flags & FL_ONGROUND )
{
if ( pev->groundentity && (pev->groundentity->v.flags & (FL_CLIENT|FL_MONSTER)) )
if( pev->groundentity && ( pev->groundentity->v.flags & ( FL_CLIENT | FL_MONSTER ) ) )
return TRUE;
// A little less accurate, but jump from closer
if ( flDist <= 180 && flDot >= 0.55 )
if( flDist <= 180 && flDot >= 0.55 )
return TRUE;
}
return FALSE;
}
Schedule_t* CBabyCrab :: GetScheduleOfType ( int Type )
Schedule_t *CBabyCrab::GetScheduleOfType( int Type )
{
switch( Type )
{
case SCHED_FAIL: // If you fail, try to jump!
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
return slHCRangeAttack1Fast;
break;
case SCHED_RANGE_ATTACK1:
{
return slHCRangeAttack1Fast;

110
dlls/healthkit.cpp
View File

@ -33,7 +33,6 @@ class CHealthKit : public CItem
/*
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
*/
};
@ -46,46 +45,45 @@ TYPEDESCRIPTION CHealthKit::m_SaveData[] =
};
IMPLEMENT_SAVERESTORE( CHealthKit, CItem)
IMPLEMENT_SAVERESTORE( CHealthKit, CItem )
*/
void CHealthKit :: Spawn( void )
void CHealthKit::Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_medkit.mdl");
Precache();
SET_MODEL( ENT( pev ), "models/w_medkit.mdl" );
CItem::Spawn();
}
void CHealthKit::Precache( void )
{
PRECACHE_MODEL("models/w_medkit.mdl");
PRECACHE_SOUND("items/smallmedkit1.wav");
PRECACHE_MODEL( "models/w_medkit.mdl" );
PRECACHE_SOUND( "items/smallmedkit1.wav" );
}
BOOL CHealthKit::MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer->pev->deadflag != DEAD_NO )
if( pPlayer->pev->deadflag != DEAD_NO )
{
return FALSE;
}
if ( pPlayer->TakeHealth( gSkillData.healthkitCapacity, DMG_GENERIC ) )
if( pPlayer->TakeHealth( gSkillData.healthkitCapacity, DMG_GENERIC ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgItemPickup, NULL, pPlayer->pev );
WRITE_STRING( STRING(pev->classname) );
WRITE_STRING( STRING( pev->classname ) );
MESSAGE_END();
EMIT_SOUND(ENT(pPlayer->pev), CHAN_ITEM, "items/smallmedkit1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pPlayer->pev ), CHAN_ITEM, "items/smallmedkit1.wav", 1, ATTN_NORM );
if ( g_pGameRules->ItemShouldRespawn( this ) )
if( g_pGameRules->ItemShouldRespawn( this ) )
{
Respawn();
}
else
{
UTIL_Remove(this);
UTIL_Remove( this );
}
return TRUE;
@ -100,13 +98,13 @@ BOOL CHealthKit::MyTouch( CBasePlayer *pPlayer )
class CWallHealth : public CBaseToggle
{
public:
void Spawn( );
void Spawn();
void Precache( void );
void EXPORT Off(void);
void EXPORT Recharge(void);
void EXPORT Off( void );
void EXPORT Recharge( void );
void KeyValue( KeyValueData *pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual int ObjectCaps( void ) { return (CBaseToggle :: ObjectCaps() | FCAP_CONTINUOUS_USE) & ~FCAP_ACROSS_TRANSITION; }
virtual int ObjectCaps( void ) { return ( CBaseToggle::ObjectCaps() | FCAP_CONTINUOUS_USE ) & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
@ -121,30 +119,30 @@ public:
TYPEDESCRIPTION CWallHealth::m_SaveData[] =
{
DEFINE_FIELD( CWallHealth, m_flNextCharge, FIELD_TIME),
DEFINE_FIELD( CWallHealth, m_iReactivate, FIELD_INTEGER),
DEFINE_FIELD( CWallHealth, m_iJuice, FIELD_INTEGER),
DEFINE_FIELD( CWallHealth, m_iOn, FIELD_INTEGER),
DEFINE_FIELD( CWallHealth, m_flSoundTime, FIELD_TIME),
DEFINE_FIELD( CWallHealth, m_flNextCharge, FIELD_TIME ),
DEFINE_FIELD( CWallHealth, m_iReactivate, FIELD_INTEGER ),
DEFINE_FIELD( CWallHealth, m_iJuice, FIELD_INTEGER ),
DEFINE_FIELD( CWallHealth, m_iOn, FIELD_INTEGER ),
DEFINE_FIELD( CWallHealth, m_flSoundTime, FIELD_TIME ),
};
IMPLEMENT_SAVERESTORE( CWallHealth, CBaseEntity )
LINK_ENTITY_TO_CLASS(func_healthcharger, CWallHealth)
LINK_ENTITY_TO_CLASS( func_healthcharger, CWallHealth )
void CWallHealth::KeyValue( KeyValueData *pkvd )
{
if ( FStrEq(pkvd->szKeyName, "style") ||
FStrEq(pkvd->szKeyName, "height") ||
FStrEq(pkvd->szKeyName, "value1") ||
FStrEq(pkvd->szKeyName, "value2") ||
FStrEq(pkvd->szKeyName, "value3"))
if( FStrEq(pkvd->szKeyName, "style" ) ||
FStrEq( pkvd->szKeyName, "height" ) ||
FStrEq( pkvd->szKeyName, "value1" ) ||
FStrEq( pkvd->szKeyName, "value2" ) ||
FStrEq( pkvd->szKeyName, "value3" ) )
{
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "dmdelay"))
else if( FStrEq( pkvd->szKeyName, "dmdelay" ) )
{
m_iReactivate = atoi(pkvd->szValue);
m_iReactivate = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -153,48 +151,48 @@ void CWallHealth::KeyValue( KeyValueData *pkvd )
void CWallHealth::Spawn()
{
Precache( );
Precache();
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(pev, pev->origin); // set size and link into world
UTIL_SetSize(pev, pev->mins, pev->maxs);
SET_MODEL(ENT(pev), STRING(pev->model) );
UTIL_SetOrigin( pev, pev->origin ); // set size and link into world
UTIL_SetSize( pev, pev->mins, pev->maxs );
SET_MODEL( ENT( pev ), STRING( pev->model ) );
m_iJuice = gSkillData.healthchargerCapacity;
pev->frame = 0;
}
void CWallHealth::Precache()
{
PRECACHE_SOUND("items/medshot4.wav");
PRECACHE_SOUND("items/medshotno1.wav");
PRECACHE_SOUND("items/medcharge4.wav");
PRECACHE_SOUND( "items/medshot4.wav" );
PRECACHE_SOUND( "items/medshotno1.wav" );
PRECACHE_SOUND( "items/medcharge4.wav" );
}
void CWallHealth::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// Make sure that we have a caller
if (!pActivator)
if( !pActivator )
return;
// if it's not a player, ignore
if ( !pActivator->IsPlayer() )
if( !pActivator->IsPlayer() )
return;
// if there is no juice left, turn it off
if (m_iJuice <= 0)
if( m_iJuice <= 0 )
{
pev->frame = 1;
Off();
}
// if the player doesn't have the suit, or there is no juice left, make the deny noise
if ((m_iJuice <= 0) || (!(pActivator->pev->weapons & (1<<WEAPON_SUIT))))
if( ( m_iJuice <= 0 ) || ( !( pActivator->pev->weapons & ( 1 << WEAPON_SUIT ) ) ) )
{
if (m_flSoundTime <= gpGlobals->time)
if( m_flSoundTime <= gpGlobals->time )
{
m_flSoundTime = gpGlobals->time + 0.62;
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/medshotno1.wav", 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/medshotno1.wav", 1.0, ATTN_NORM );
}
return;
}
@ -203,24 +201,24 @@ void CWallHealth::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE u
SetThink( &CWallHealth::Off );
// Time to recharge yet?
if (m_flNextCharge >= gpGlobals->time)
if( m_flNextCharge >= gpGlobals->time )
return;
// Play the on sound or the looping charging sound
if (!m_iOn)
if( !m_iOn )
{
m_iOn++;
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/medshot4.wav", 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/medshot4.wav", 1.0, ATTN_NORM );
m_flSoundTime = 0.56 + gpGlobals->time;
}
if ((m_iOn == 1) && (m_flSoundTime <= gpGlobals->time))
if( ( m_iOn == 1 ) && ( m_flSoundTime <= gpGlobals->time ) )
{
m_iOn++;
EMIT_SOUND(ENT(pev), CHAN_STATIC, "items/medcharge4.wav", 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_STATIC, "items/medcharge4.wav", 1.0, ATTN_NORM );
}
// charge the player
if ( pActivator->TakeHealth( 1, DMG_GENERIC ) )
if( pActivator->TakeHealth( 1, DMG_GENERIC ) )
{
m_iJuice--;
}
@ -229,23 +227,23 @@ void CWallHealth::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE u
m_flNextCharge = gpGlobals->time + 0.1;
}
void CWallHealth::Recharge(void)
void CWallHealth::Recharge( void )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/medshot4.wav", 1.0, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/medshot4.wav", 1.0, ATTN_NORM );
m_iJuice = gSkillData.healthchargerCapacity;
pev->frame = 0;
SetThink( &CBaseEntity::SUB_DoNothing );
}
void CWallHealth::Off(void)
void CWallHealth::Off( void )
{
// Stop looping sound.
if (m_iOn > 1)
STOP_SOUND( ENT(pev), CHAN_STATIC, "items/medcharge4.wav" );
if( m_iOn > 1 )
STOP_SOUND( ENT( pev ), CHAN_STATIC, "items/medcharge4.wav" );
m_iOn = 0;
if ((!m_iJuice) && ( ( m_iReactivate = g_pGameRules->FlHealthChargerRechargeTime() ) > 0) )
if( ( !m_iJuice ) && ( ( m_iReactivate = g_pGameRules->FlHealthChargerRechargeTime() ) > 0 ) )
{
pev->nextthink = pev->ltime + m_iReactivate;
SetThink( &CWallHealth::Recharge );

725
dlls/hgrunt.cpp
View File

File diff suppressed because it is too large Load Diff

140
dlls/hornet.cpp
View File

@ -45,18 +45,18 @@ IMPLEMENT_SAVERESTORE( CHornet, CBaseMonster )
//=========================================================
// don't let hornets gib, ever.
//=========================================================
int CHornet :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
int CHornet::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
// filter these bits a little.
bitsDamageType &= ~ ( DMG_ALWAYSGIB );
bitsDamageType &= ~( DMG_ALWAYSGIB );
bitsDamageType |= DMG_NEVERGIB;
return CBaseMonster :: TakeDamage ( pevInflictor, pevAttacker, flDamage, bitsDamageType );
return CBaseMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}
//=========================================================
//=========================================================
void CHornet :: Spawn( void )
void CHornet::Spawn( void )
{
Precache();
@ -66,7 +66,7 @@ void CHornet :: Spawn( void )
pev->flags |= FL_MONSTER;
pev->health = 1;// weak!
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
// hornets don't live as long in multiplayer
m_flStopAttack = gpGlobals->time + 3.5;
@ -78,7 +78,7 @@ void CHornet :: Spawn( void )
m_flFieldOfView = 0.9; // +- 25 degrees
if ( RANDOM_LONG ( 1, 5 ) <= 2 )
if( RANDOM_LONG( 1, 5 ) <= 2 )
{
m_iHornetType = HORNET_TYPE_RED;
m_flFlySpeed = HORNET_RED_SPEED;
@ -89,17 +89,17 @@ void CHornet :: Spawn( void )
m_flFlySpeed = HORNET_ORANGE_SPEED;
}
SET_MODEL(ENT( pev ), "models/hornet.mdl");
SET_MODEL( ENT( pev ), "models/hornet.mdl" );
UTIL_SetSize( pev, Vector( -4, -4, -4 ), Vector( 4, 4, 4 ) );
SetTouch( &CHornet::DieTouch );
SetThink( &CHornet::StartTrack );
edict_t *pSoundEnt = pev->owner;
if ( !pSoundEnt )
if( !pSoundEnt )
pSoundEnt = edict();
if ( !FNullEnt(pev->owner) && (pev->owner->v.flags & FL_CLIENT) )
if( !FNullEnt( pev->owner ) && ( pev->owner->v.flags & FL_CLIENT ) )
{
pev->dmg = gSkillData.plrDmgHornet;
}
@ -110,12 +110,12 @@ void CHornet :: Spawn( void )
}
pev->nextthink = gpGlobals->time + 0.1;
ResetSequenceInfo( );
ResetSequenceInfo();
}
void CHornet :: Precache()
void CHornet::Precache()
{
PRECACHE_MODEL("models/hornet.mdl");
PRECACHE_MODEL( "models/hornet.mdl" );
PRECACHE_SOUND( "agrunt/ag_fire1.wav" );
PRECACHE_SOUND( "agrunt/ag_fire2.wav" );
@ -130,29 +130,28 @@ void CHornet :: Precache()
PRECACHE_SOUND( "hornet/ag_hornethit3.wav" );
iHornetPuff = PRECACHE_MODEL( "sprites/muz1.spr" );
iHornetTrail = PRECACHE_MODEL("sprites/laserbeam.spr");
iHornetTrail = PRECACHE_MODEL( "sprites/laserbeam.spr" );
}
//=========================================================
// hornets will never get mad at each other, no matter who the owner is.
//=========================================================
int CHornet::IRelationship ( CBaseEntity *pTarget )
int CHornet::IRelationship( CBaseEntity *pTarget )
{
if ( pTarget->pev->modelindex == pev->modelindex )
if( pTarget->pev->modelindex == pev->modelindex )
{
return R_NO;
}
return CBaseMonster :: IRelationship( pTarget );
return CBaseMonster::IRelationship( pTarget );
}
//=========================================================
// ID's Hornet as their owner
//=========================================================
int CHornet::Classify ( void )
int CHornet::Classify( void )
{
if ( pev->owner && pev->owner->v.flags & FL_CLIENT)
if( pev->owner && pev->owner->v.flags & FL_CLIENT )
{
return CLASS_PLAYER_BIOWEAPON;
}
@ -163,7 +162,7 @@ int CHornet::Classify ( void )
//=========================================================
// StartTrack - starts a hornet out tracking its target
//=========================================================
void CHornet :: StartTrack ( void )
void CHornet::StartTrack( void )
{
IgniteTrail();
@ -176,7 +175,7 @@ void CHornet :: StartTrack ( void )
//=========================================================
// StartDart - starts a hornet out just flying straight.
//=========================================================
void CHornet :: StartDart ( void )
void CHornet::StartDart( void )
{
IgniteTrail();
@ -221,7 +220,7 @@ old colors
WRITE_BYTE( 10 ); // life
WRITE_BYTE( 2 ); // width
switch ( m_iHornetType )
switch( m_iHornetType )
{
case HORNET_TYPE_RED:
WRITE_BYTE( 179 ); // r, g, b
@ -236,22 +235,21 @@ old colors
}
WRITE_BYTE( 128 ); // brightness
MESSAGE_END();
}
//=========================================================
// Hornet is flying, gently tracking target
//=========================================================
void CHornet :: TrackTarget ( void )
void CHornet::TrackTarget( void )
{
Vector vecFlightDir;
Vector vecDirToEnemy;
float flDelta;
StudioFrameAdvance( );
StudioFrameAdvance();
if (gpGlobals->time > m_flStopAttack)
if( gpGlobals->time > m_flStopAttack )
{
SetTouch( NULL );
SetThink( &CBaseEntity::SUB_Remove );
@ -260,14 +258,14 @@ void CHornet :: TrackTarget ( void )
}
// UNDONE: The player pointer should come back after returning from another level
if ( m_hEnemy == NULL )
if( m_hEnemy == NULL )
{
// enemy is dead.
Look( 512 );
m_hEnemy = BestVisibleEnemy( );
m_hEnemy = BestVisibleEnemy();
}
if ( m_hEnemy != NULL && FVisible( m_hEnemy ))
if( m_hEnemy != NULL && FVisible( m_hEnemy ) )
{
m_vecEnemyLKP = m_hEnemy->BodyTarget( pev->origin );
}
@ -278,42 +276,48 @@ void CHornet :: TrackTarget ( void )
vecDirToEnemy = ( m_vecEnemyLKP - pev->origin ).Normalize();
if (pev->velocity.Length() < 0.1)
if( pev->velocity.Length() < 0.1 )
vecFlightDir = vecDirToEnemy;
else
vecFlightDir = pev->velocity.Normalize();
// measure how far the turn is, the wider the turn, the slow we'll go this time.
flDelta = DotProduct ( vecFlightDir, vecDirToEnemy );
flDelta = DotProduct( vecFlightDir, vecDirToEnemy );
if ( flDelta < 0.5 )
if( flDelta < 0.5 )
{
// hafta turn wide again. play sound
switch (RANDOM_LONG(0,2))
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz1.wav", HORNET_BUZZ_VOLUME, ATTN_NORM); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz2.wav", HORNET_BUZZ_VOLUME, ATTN_NORM); break;
case 2: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz3.wav", HORNET_BUZZ_VOLUME, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_buzz1.wav", HORNET_BUZZ_VOLUME, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_buzz2.wav", HORNET_BUZZ_VOLUME, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_buzz3.wav", HORNET_BUZZ_VOLUME, ATTN_NORM );
break;
}
}
if ( flDelta <= 0 && m_iHornetType == HORNET_TYPE_RED )
if( flDelta <= 0 && m_iHornetType == HORNET_TYPE_RED )
{
// no flying backwards, but we don't want to invert this, cause we'd go fast when we have to turn REAL far.
flDelta = 0.25;
}
pev->velocity = ( vecFlightDir + vecDirToEnemy).Normalize();
pev->velocity = ( vecFlightDir + vecDirToEnemy ).Normalize();
if ( pev->owner && (pev->owner->v.flags & FL_MONSTER) )
if( pev->owner && ( pev->owner->v.flags & FL_MONSTER ) )
{
// random pattern only applies to hornets fired by monsters, not players.
pev->velocity.x += RANDOM_FLOAT ( -0.10, 0.10 );// scramble the flight dir a bit.
pev->velocity.y += RANDOM_FLOAT ( -0.10, 0.10 );
pev->velocity.z += RANDOM_FLOAT ( -0.10, 0.10 );
pev->velocity.x += RANDOM_FLOAT( -0.10, 0.10 );// scramble the flight dir a bit.
pev->velocity.y += RANDOM_FLOAT( -0.10, 0.10 );
pev->velocity.z += RANDOM_FLOAT( -0.10, 0.10 );
}
switch ( m_iHornetType )
switch( m_iHornetType )
{
case HORNET_TYPE_RED:
pev->velocity = pev->velocity * ( m_flFlySpeed * flDelta );// scale the dir by the ( speed * width of turn )
@ -325,32 +329,38 @@ void CHornet :: TrackTarget ( void )
break;
}
pev->angles = UTIL_VecToAngles (pev->velocity);
pev->angles = UTIL_VecToAngles( pev->velocity );
pev->solid = SOLID_BBOX;
// if hornet is close to the enemy, jet in a straight line for a half second.
// (only in the single player game)
if ( m_hEnemy != NULL && !g_pGameRules->IsMultiplayer() )
if( m_hEnemy != NULL && !g_pGameRules->IsMultiplayer() )
{
if ( flDelta >= 0.4 && ( pev->origin - m_vecEnemyLKP ).Length() <= 300 )
if( flDelta >= 0.4 && ( pev->origin - m_vecEnemyLKP ).Length() <= 300 )
{
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_SPRITE );
WRITE_COORD( pev->origin.x); // pos
WRITE_COORD( pev->origin.y);
WRITE_COORD( pev->origin.z);
WRITE_COORD( pev->origin.x ); // pos
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z );
WRITE_SHORT( iHornetPuff ); // model
// WRITE_BYTE( 0 ); // life * 10
WRITE_BYTE( 2 ); // size * 10
WRITE_BYTE( 128 ); // brightness
MESSAGE_END();
switch (RANDOM_LONG(0,2))
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz1.wav", HORNET_BUZZ_VOLUME, ATTN_NORM); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz2.wav", HORNET_BUZZ_VOLUME, ATTN_NORM); break;
case 2: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_buzz3.wav", HORNET_BUZZ_VOLUME, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_buzz1.wav", HORNET_BUZZ_VOLUME, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_buzz2.wav", HORNET_BUZZ_VOLUME, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_buzz3.wav", HORNET_BUZZ_VOLUME, ATTN_NORM );
break;
}
pev->velocity = pev->velocity * 2;
pev->nextthink = gpGlobals->time + 1.0;
@ -363,16 +373,16 @@ void CHornet :: TrackTarget ( void )
//=========================================================
// Tracking Hornet hit something
//=========================================================
void CHornet :: TrackTouch ( CBaseEntity *pOther )
void CHornet::TrackTouch( CBaseEntity *pOther )
{
if ( pOther->edict() == pev->owner || pOther->pev->modelindex == pev->modelindex )
if( pOther->edict() == pev->owner || pOther->pev->modelindex == pev->modelindex )
{
// bumped into the guy that shot it.
pev->solid = SOLID_NOT;
return;
}
if ( IRelationship( pOther ) <= R_NO )
if( IRelationship( pOther ) <= R_NO )
{
// hit something we don't want to hurt, so turn around.
@ -395,17 +405,23 @@ void CHornet::DartTouch( CBaseEntity *pOther )
DieTouch( pOther );
}
void CHornet::DieTouch ( CBaseEntity *pOther )
void CHornet::DieTouch( CBaseEntity *pOther )
{
if ( pOther && pOther->pev->takedamage )
if( pOther && pOther->pev->takedamage )
{
// do the damage
switch (RANDOM_LONG(0,2))
switch( RANDOM_LONG( 0, 2 ) )
{
// buzz when you plug someone
case 0: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit1.wav", 1, ATTN_NORM); break;
case 1: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit2.wav", 1, ATTN_NORM); break;
case 2: EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit3.wav", 1, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_hornethit1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_hornethit2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "hornet/ag_hornethit3.wav", 1, ATTN_NORM );
break;
}
pOther->TakeDamage( pev, VARS( pev->owner ), pev->dmg, DMG_BULLET );

15
dlls/hornet.h
View File

@ -35,19 +35,19 @@ class CHornet : public CBaseMonster
public:
void Spawn( void );
void Precache( void );
int Classify ( void );
int IRelationship ( CBaseEntity *pTarget );
int Classify( void );
int IRelationship( CBaseEntity *pTarget );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
void IgniteTrail( void );
void EXPORT StartTrack ( void );
void EXPORT StartDart ( void );
void EXPORT TrackTarget ( void );
void EXPORT TrackTouch ( CBaseEntity *pOther );
void EXPORT StartTrack( void );
void EXPORT StartDart( void );
void EXPORT TrackTarget( void );
void EXPORT TrackTouch( CBaseEntity *pOther );
void EXPORT DartTouch( CBaseEntity *pOther );
void EXPORT DieTouch ( CBaseEntity *pOther );
void EXPORT DieTouch( CBaseEntity *pOther );
int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
@ -55,4 +55,3 @@ public:
int m_iHornetType;
float m_flFlySpeed;
};

62
dlls/hornetgun.cpp
View File

@ -24,7 +24,8 @@
#include "hornet.h"
#include "gamerules.h"
enum hgun_e {
enum hgun_e
{
HGUN_IDLE1 = 0,
HGUN_FIDGETSWAY,
HGUN_FIDGETSHAKE,
@ -46,11 +47,11 @@ BOOL CHgun::IsUseable( void )
return TRUE;
}
void CHgun::Spawn( )
void CHgun::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_HORNETGUN;
SET_MODEL(ENT(pev), "models/w_hgun.mdl");
SET_MODEL( ENT( pev ), "models/w_hgun.mdl" );
m_iDefaultAmmo = HIVEHAND_DEFAULT_GIVE;
m_iFirePhase = 0;
@ -60,24 +61,24 @@ void CHgun::Spawn( )
void CHgun::Precache( void )
{
PRECACHE_MODEL("models/v_hgun.mdl");
PRECACHE_MODEL("models/w_hgun.mdl");
PRECACHE_MODEL("models/p_hgun.mdl");
PRECACHE_MODEL( "models/v_hgun.mdl" );
PRECACHE_MODEL( "models/w_hgun.mdl" );
PRECACHE_MODEL( "models/p_hgun.mdl" );
m_usHornetFire = PRECACHE_EVENT ( 1, "events/firehornet.sc" );
m_usHornetFire = PRECACHE_EVENT( 1, "events/firehornet.sc" );
UTIL_PrecacheOther("hornet");
UTIL_PrecacheOther( "hornet" );
}
int CHgun::AddToPlayer( CBasePlayer *pPlayer )
{
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
{
#ifndef CLIENT_DLL
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
// in multiplayer, all hivehands come full.
pPlayer->m_rgAmmo[ PrimaryAmmoIndex() ] = HORNET_MAX_CARRY;
pPlayer->m_rgAmmo[PrimaryAmmoIndex()] = HORNET_MAX_CARRY;
}
#endif
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
@ -88,9 +89,9 @@ int CHgun::AddToPlayer( CBasePlayer *pPlayer )
return FALSE;
}
int CHgun::GetItemInfo(ItemInfo *p)
int CHgun::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "Hornets";
p->iMaxAmmo1 = HORNET_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -105,7 +106,7 @@ int CHgun::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CHgun::Deploy( )
BOOL CHgun::Deploy()
{
return DefaultDeploy( "models/v_hgun.mdl", "models/p_hgun.mdl", HGUN_UP, "hive" );
}
@ -116,17 +117,17 @@ void CHgun::Holster( int skiplocal /* = 0 */ )
SendWeaponAnim( HGUN_DOWN );
//!!!HACKHACK - can't select hornetgun if it's empty! no way to get ammo for it, either.
if ( !m_pPlayer->m_rgAmmo[ PrimaryAmmoIndex() ] )
if( !m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] )
{
m_pPlayer->m_rgAmmo[ PrimaryAmmoIndex() ] = 1;
m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] = 1;
}
}
void CHgun::PrimaryAttack()
{
Reload( );
Reload();
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
if(m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
{
return;
}
@ -149,7 +150,6 @@ void CHgun::PrimaryAttack()
#else
flags = 0;
#endif
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usHornetFire, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, FIREMODE_TRACK, 0, 0, 0 );
// player "shoot" animation
@ -157,7 +157,7 @@ void CHgun::PrimaryAttack()
m_flNextPrimaryAttack = m_flNextPrimaryAttack + 0.25;
if (m_flNextPrimaryAttack < UTIL_WeaponTimeBase() )
if( m_flNextPrimaryAttack < UTIL_WeaponTimeBase() )
{
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.25;
}
@ -169,7 +169,7 @@ void CHgun::SecondaryAttack( void )
{
Reload();
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
{
return;
}
@ -181,10 +181,10 @@ void CHgun::SecondaryAttack( void )
UTIL_MakeVectors( m_pPlayer->pev->v_angle );
vecSrc = m_pPlayer->GetGunPosition( ) + gpGlobals->v_forward * 16 + gpGlobals->v_right * 8 + gpGlobals->v_up * -12;
vecSrc = m_pPlayer->GetGunPosition() + gpGlobals->v_forward * 16 + gpGlobals->v_right * 8 + gpGlobals->v_up * -12;
m_iFirePhase++;
switch ( m_iFirePhase )
switch( m_iFirePhase )
{
case 1:
vecSrc = vecSrc + gpGlobals->v_up * 8;
@ -246,10 +246,10 @@ void CHgun::SecondaryAttack( void )
void CHgun::Reload( void )
{
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] >= HORNET_MAX_CARRY)
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] >= HORNET_MAX_CARRY )
return;
while (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] < HORNET_MAX_CARRY && m_flRechargeTime < gpGlobals->time)
while( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] < HORNET_MAX_CARRY && m_flRechargeTime < gpGlobals->time )
{
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]++;
m_flRechargeTime += 0.5;
@ -258,19 +258,19 @@ void CHgun::Reload( void )
void CHgun::WeaponIdle( void )
{
Reload( );
Reload();
if (m_flTimeWeaponIdle > UTIL_WeaponTimeBase())
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
int iAnim;
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0, 1 );
if (flRand <= 0.75)
if( flRand <= 0.75 )
{
iAnim = HGUN_IDLE1;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 30.0 / 16 * (2);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 30.0 / 16 * ( 2 );
}
else if (flRand <= 0.875)
else if( flRand <= 0.875 )
{
iAnim = HGUN_FIDGETSWAY;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 40.0 / 16.0;

419
dlls/houndeye.cpp
View File

@ -78,25 +78,25 @@ class CHoundeye : public CSquadMonster
public:
void Spawn( void );
void Precache( void );
int Classify ( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
void SetYawSpeed ( void );
void WarmUpSound ( void );
void SetYawSpeed( void );
void WarmUpSound( void );
void AlertSound( void );
void DeathSound( void );
void WarnSound( void );
void PainSound( void );
void IdleSound( void );
void StartTask( Task_t *pTask );
void RunTask ( Task_t *pTask );
void RunTask( Task_t *pTask );
void SonicAttack( void );
void PrescheduleThink( void );
void SetActivity ( Activity NewActivity );
void WriteBeamColor ( void );
BOOL CheckRangeAttack1 ( float flDot, float flDist );
BOOL FValidateHintType ( short sHint );
BOOL FCanActiveIdle ( void );
Schedule_t *GetScheduleOfType ( int Type );
void SetActivity( Activity NewActivity );
void WriteBeamColor( void );
BOOL CheckRangeAttack1( float flDot, float flDist );
BOOL FValidateHintType( short sHint );
BOOL FCanActiveIdle( void );
Schedule_t *GetScheduleOfType( int Type );
Schedule_t *GetSchedule( void );
int Save( CSave &save );
@ -127,7 +127,7 @@ IMPLEMENT_SAVERESTORE( CHoundeye, CSquadMonster )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CHoundeye :: Classify ( void )
int CHoundeye::Classify( void )
{
return CLASS_ALIEN_MONSTER;
}
@ -135,7 +135,7 @@ int CHoundeye :: Classify ( void )
//=========================================================
// FValidateHintType
//=========================================================
BOOL CHoundeye :: FValidateHintType ( short sHint )
BOOL CHoundeye::FValidateHintType( short sHint )
{
int i;
@ -147,33 +147,32 @@ BOOL CHoundeye :: FValidateHintType ( short sHint )
HINT_WORLD_ALIEN_BLOOD,
};
for ( i = 0 ; i < ARRAYSIZE ( sHoundHints ) ; i++ )
for( i = 0; i < ARRAYSIZE( sHoundHints ); i++ )
{
if ( sHoundHints[ i ] == sHint )
if( sHoundHints[i] == sHint )
{
return TRUE;
}
}
ALERT ( at_aiconsole, "Couldn't validate hint type" );
ALERT( at_aiconsole, "Couldn't validate hint type" );
return FALSE;
}
//=========================================================
// FCanActiveIdle
//=========================================================
BOOL CHoundeye :: FCanActiveIdle ( void )
BOOL CHoundeye::FCanActiveIdle( void )
{
if ( InSquad() )
if( InSquad() )
{
CSquadMonster *pSquadLeader = MySquadLeader();
for (int i = 0; i < MAX_SQUAD_MEMBERS;i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS; i++ )
{
CSquadMonster *pMember = pSquadLeader->MySquadMember(i);
CSquadMonster *pMember = pSquadLeader->MySquadMember( i );
if ( pMember != NULL && pMember != this && pMember->m_iHintNode != NO_NODE )
if( pMember != NULL && pMember != this && pMember->m_iHintNode != NO_NODE )
{
// someone else in the group is active idling right now!
return FALSE;
@ -186,15 +185,14 @@ BOOL CHoundeye :: FCanActiveIdle ( void )
return TRUE;
}
//=========================================================
// CheckRangeAttack1 - overridden for houndeyes so that they
// try to get within half of their max attack radius before
// attacking, so as to increase their chances of doing damage.
//=========================================================
BOOL CHoundeye :: CheckRangeAttack1 ( float flDot, float flDist )
BOOL CHoundeye::CheckRangeAttack1( float flDot, float flDist )
{
if ( flDist <= ( HOUNDEYE_MAX_ATTACK_RADIUS * 0.5 ) && flDot >= 0.3 )
if( flDist <= ( HOUNDEYE_MAX_ATTACK_RADIUS * 0.5 ) && flDot >= 0.3 )
{
return TRUE;
}
@ -205,13 +203,13 @@ BOOL CHoundeye :: CheckRangeAttack1 ( float flDot, float flDist )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CHoundeye :: SetYawSpeed ( void )
void CHoundeye::SetYawSpeed( void )
{
int ys;
ys = 90;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_CROUCHIDLE://sleeping!
ys = 0;
@ -234,14 +232,14 @@ void CHoundeye :: SetYawSpeed ( void )
//=========================================================
// SetActivity
//=========================================================
void CHoundeye :: SetActivity ( Activity NewActivity )
void CHoundeye::SetActivity( Activity NewActivity )
{
int iSequence;
if ( NewActivity == m_Activity )
if( NewActivity == m_Activity )
return;
if ( m_MonsterState == MONSTERSTATE_COMBAT && NewActivity == ACT_IDLE && RANDOM_LONG(0,1) )
if( m_MonsterState == MONSTERSTATE_COMBAT && NewActivity == ACT_IDLE && RANDOM_LONG( 0, 1 ) )
{
// play pissed idle.
iSequence = LookupSequence( "madidle" );
@ -252,7 +250,7 @@ void CHoundeye :: SetActivity ( Activity NewActivity )
m_IdealActivity = m_Activity;
// Set to the desired anim, or default anim if the desired is not present
if ( iSequence > ACTIVITY_NOT_AVAILABLE )
if( iSequence > ACTIVITY_NOT_AVAILABLE )
{
pev->sequence = iSequence; // Set to the reset anim (if it's there)
pev->frame = 0; // FIX: frame counter shouldn't be reset when its the same activity as before
@ -262,7 +260,7 @@ void CHoundeye :: SetActivity ( Activity NewActivity )
}
else
{
CSquadMonster :: SetActivity ( NewActivity );
CSquadMonster::SetActivity( NewActivity );
}
}
@ -270,19 +268,17 @@ void CHoundeye :: SetActivity ( Activity NewActivity )
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CHoundeye :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CHoundeye::HandleAnimEvent( MonsterEvent_t *pEvent )
{
switch ( pEvent->event )
switch( pEvent->event )
{
case HOUND_AE_WARN:
// do stuff for this event.
WarnSound();
break;
case HOUND_AE_STARTATTACK:
WarmUpSound();
break;
case HOUND_AE_HOPBACK:
{
float flGravity = g_psv_gravity->value;
@ -290,31 +286,25 @@ void CHoundeye :: HandleAnimEvent( MonsterEvent_t *pEvent )
pev->flags &= ~FL_ONGROUND;
pev->velocity = gpGlobals->v_forward * -200;
pev->velocity.z += (0.6 * flGravity) * 0.5;
pev->velocity.z += ( 0.6 * flGravity ) * 0.5;
break;
}
case HOUND_AE_THUMP:
// emit the shockwaves
SonicAttack();
break;
case HOUND_AE_ANGERSOUND1:
EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_pain3.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_pain3.wav", 1, ATTN_NORM );
break;
case HOUND_AE_ANGERSOUND2:
EMIT_SOUND(ENT(pev), CHAN_VOICE, "houndeye/he_pain1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_pain1.wav", 1, ATTN_NORM );
break;
case HOUND_AE_CLOSE_EYE:
if ( !m_fDontBlink )
if( !m_fDontBlink )
{
pev->skin = HOUNDEYE_EYE_FRAMES - 1;
}
break;
default:
CSquadMonster::HandleAnimEvent( pEvent );
break;
@ -324,12 +314,12 @@ void CHoundeye :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CHoundeye :: Spawn()
void CHoundeye::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/houndeye.mdl");
UTIL_SetSize(pev, Vector ( -16, -16, 0 ), Vector ( 16, 16, 36 ) );
SET_MODEL( ENT( pev ), "models/houndeye.mdl" );
UTIL_SetSize( pev, Vector( -16, -16, 0 ), Vector( 16, 16, 36 ) );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
@ -349,37 +339,37 @@ void CHoundeye :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CHoundeye :: Precache()
void CHoundeye::Precache()
{
PRECACHE_MODEL("models/houndeye.mdl");
PRECACHE_MODEL( "models/houndeye.mdl" );
PRECACHE_SOUND("houndeye/he_alert1.wav");
PRECACHE_SOUND("houndeye/he_alert2.wav");
PRECACHE_SOUND("houndeye/he_alert3.wav");
PRECACHE_SOUND( "houndeye/he_alert1.wav" );
PRECACHE_SOUND( "houndeye/he_alert2.wav" );
PRECACHE_SOUND( "houndeye/he_alert3.wav" );
PRECACHE_SOUND("houndeye/he_die1.wav");
PRECACHE_SOUND("houndeye/he_die2.wav");
PRECACHE_SOUND("houndeye/he_die3.wav");
PRECACHE_SOUND( "houndeye/he_die1.wav" );
PRECACHE_SOUND( "houndeye/he_die2.wav" );
PRECACHE_SOUND( "houndeye/he_die3.wav" );
PRECACHE_SOUND("houndeye/he_idle1.wav");
PRECACHE_SOUND("houndeye/he_idle2.wav");
PRECACHE_SOUND("houndeye/he_idle3.wav");
PRECACHE_SOUND( "houndeye/he_idle1.wav" );
PRECACHE_SOUND( "houndeye/he_idle2.wav" );
PRECACHE_SOUND( "houndeye/he_idle3.wav" );
PRECACHE_SOUND("houndeye/he_hunt1.wav");
PRECACHE_SOUND("houndeye/he_hunt2.wav");
PRECACHE_SOUND("houndeye/he_hunt3.wav");
PRECACHE_SOUND( "houndeye/he_hunt1.wav" );
PRECACHE_SOUND( "houndeye/he_hunt2.wav" );
PRECACHE_SOUND( "houndeye/he_hunt3.wav" );
PRECACHE_SOUND("houndeye/he_pain1.wav");
PRECACHE_SOUND("houndeye/he_pain3.wav");
PRECACHE_SOUND("houndeye/he_pain4.wav");
PRECACHE_SOUND("houndeye/he_pain5.wav");
PRECACHE_SOUND( "houndeye/he_pain1.wav" );
PRECACHE_SOUND( "houndeye/he_pain3.wav" );
PRECACHE_SOUND( "houndeye/he_pain4.wav" );
PRECACHE_SOUND( "houndeye/he_pain5.wav" );
PRECACHE_SOUND("houndeye/he_attack1.wav");
PRECACHE_SOUND("houndeye/he_attack3.wav");
PRECACHE_SOUND( "houndeye/he_attack1.wav" );
PRECACHE_SOUND( "houndeye/he_attack3.wav" );
PRECACHE_SOUND("houndeye/he_blast1.wav");
PRECACHE_SOUND("houndeye/he_blast2.wav");
PRECACHE_SOUND("houndeye/he_blast3.wav");
PRECACHE_SOUND( "houndeye/he_blast1.wav" );
PRECACHE_SOUND( "houndeye/he_blast2.wav" );
PRECACHE_SOUND( "houndeye/he_blast3.wav" );
m_iSpriteTexture = PRECACHE_MODEL( "sprites/shockwave.spr" );
}
@ -387,18 +377,18 @@ void CHoundeye :: Precache()
//=========================================================
// IdleSound
//=========================================================
void CHoundeye :: IdleSound ( void )
void CHoundeye::IdleSound( void )
{
switch ( RANDOM_LONG(0,2) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_idle1.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_idle1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_idle2.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_idle2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_idle3.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_idle3.wav", 1, ATTN_NORM );
break;
}
}
@ -406,15 +396,15 @@ void CHoundeye :: IdleSound ( void )
//=========================================================
// IdleSound
//=========================================================
void CHoundeye :: WarmUpSound ( void )
void CHoundeye::WarmUpSound( void )
{
switch ( RANDOM_LONG(0,1) )
switch( RANDOM_LONG( 0, 1 ) )
{
case 0:
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "houndeye/he_attack1.wav", 0.7, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "houndeye/he_attack1.wav", 0.7, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT(pev), CHAN_WEAPON, "houndeye/he_attack3.wav", 0.7, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "houndeye/he_attack3.wav", 0.7, ATTN_NORM );
break;
}
}
@ -422,18 +412,18 @@ void CHoundeye :: WarmUpSound ( void )
//=========================================================
// WarnSound
//=========================================================
void CHoundeye :: WarnSound ( void )
void CHoundeye::WarnSound( void )
{
switch ( RANDOM_LONG(0,2) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_hunt1.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_hunt1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_hunt2.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_hunt2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_hunt3.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_hunt3.wav", 1, ATTN_NORM );
break;
}
}
@ -441,24 +431,23 @@ void CHoundeye :: WarnSound ( void )
//=========================================================
// AlertSound
//=========================================================
void CHoundeye :: AlertSound ( void )
void CHoundeye::AlertSound( void )
{
if ( InSquad() && !IsLeader() )
if( InSquad() && !IsLeader() )
{
return; // only leader makes ALERT sound.
}
switch ( RANDOM_LONG(0,2) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_alert1.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_alert1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_alert2.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_alert2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_alert3.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_alert3.wav", 1, ATTN_NORM );
break;
}
}
@ -466,18 +455,18 @@ void CHoundeye :: AlertSound ( void )
//=========================================================
// DeathSound
//=========================================================
void CHoundeye :: DeathSound ( void )
void CHoundeye::DeathSound( void )
{
switch ( RANDOM_LONG(0,2) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_die1.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_die1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_die2.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_die2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_die3.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_die3.wav", 1, ATTN_NORM );
break;
}
}
@ -485,18 +474,18 @@ void CHoundeye :: DeathSound ( void )
//=========================================================
// PainSound
//=========================================================
void CHoundeye :: PainSound ( void )
void CHoundeye::PainSound( void )
{
switch ( RANDOM_LONG(0,2) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_pain3.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_pain3.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_pain4.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_pain4.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT(pev), CHAN_VOICE, "houndeye/he_pain5.wav", 1, ATTN_NORM );
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "houndeye/he_pain5.wav", 1, ATTN_NORM );
break;
}
}
@ -505,13 +494,13 @@ void CHoundeye :: PainSound ( void )
// WriteBeamColor - writes a color vector to the network
// based on the size of the group.
//=========================================================
void CHoundeye :: WriteBeamColor ( void )
void CHoundeye::WriteBeamColor( void )
{
BYTE bRed, bGreen, bBlue;
if ( InSquad() )
if( InSquad() )
{
switch ( SquadCount() )
switch( SquadCount() )
{
case 2:
// no case for 0 or 1, cause those are impossible for monsters in Squads.
@ -530,7 +519,7 @@ void CHoundeye :: WriteBeamColor ( void )
bBlue = 211;
break;
default:
ALERT ( at_aiconsole, "Unsupported Houndeye SquadSize!\n" );
ALERT( at_aiconsole, "Unsupported Houndeye SquadSize!\n" );
bRed = 188;
bGreen = 220;
bBlue = 255;
@ -553,27 +542,33 @@ void CHoundeye :: WriteBeamColor ( void )
//=========================================================
// SonicAttack
//=========================================================
void CHoundeye :: SonicAttack ( void )
void CHoundeye::SonicAttack( void )
{
float flAdjustedDamage;
float flDist;
switch ( RANDOM_LONG( 0, 2 ) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_blast1.wav", 1, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_blast2.wav", 1, ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(pev), CHAN_WEAPON, "houndeye/he_blast3.wav", 1, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "houndeye/he_blast1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "houndeye/he_blast2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_WEAPON, "houndeye/he_blast3.wav", 1, ATTN_NORM );
break;
}
// blast circles
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_BEAMCYLINDER );
WRITE_COORD( pev->origin.x);
WRITE_COORD( pev->origin.y);
WRITE_COORD( pev->origin.z + 16);
WRITE_COORD( pev->origin.x);
WRITE_COORD( pev->origin.y);
WRITE_COORD( pev->origin.z + 16 + HOUNDEYE_MAX_ATTACK_RADIUS / .2); // reach damage radius over .3 seconds
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z + 16 );
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z + 16 + HOUNDEYE_MAX_ATTACK_RADIUS / .2 ); // reach damage radius over .3 seconds
WRITE_SHORT( m_iSpriteTexture );
WRITE_BYTE( 0 ); // startframe
WRITE_BYTE( 0 ); // framerate
@ -589,12 +584,12 @@ void CHoundeye :: SonicAttack ( void )
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_BEAMCYLINDER );
WRITE_COORD( pev->origin.x);
WRITE_COORD( pev->origin.y);
WRITE_COORD( pev->origin.z + 16);
WRITE_COORD( pev->origin.x);
WRITE_COORD( pev->origin.y);
WRITE_COORD( pev->origin.z + 16 + ( HOUNDEYE_MAX_ATTACK_RADIUS / 2 ) / .2); // reach damage radius over .3 seconds
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z + 16 );
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z + 16 + ( HOUNDEYE_MAX_ATTACK_RADIUS / 2 ) / .2 ); // reach damage radius over .3 seconds
WRITE_SHORT( m_iSpriteTexture );
WRITE_BYTE( 0 ); // startframe
WRITE_BYTE( 0 ); // framerate
@ -610,18 +605,18 @@ void CHoundeye :: SonicAttack ( void )
CBaseEntity *pEntity = NULL;
// iterate on all entities in the vicinity.
while ((pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, HOUNDEYE_MAX_ATTACK_RADIUS )) != NULL)
while( ( pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, HOUNDEYE_MAX_ATTACK_RADIUS ) ) != NULL )
{
if ( pEntity->pev->takedamage != DAMAGE_NO )
if( pEntity->pev->takedamage != DAMAGE_NO )
{
if ( !FClassnameIs(pEntity->pev, "monster_houndeye") )
if( !FClassnameIs( pEntity->pev, "monster_houndeye" ) )
{
// houndeyes don't hurt other houndeyes with their attack
// houndeyes do FULL damage if the ent in question is visible. Half damage otherwise.
// This means that you must get out of the houndeye's attack range entirely to avoid damage.
// Calculate full damage first
if ( SquadCount() > 1 )
if( SquadCount() > 1 )
{
// squad gets attack bonus.
flAdjustedDamage = gSkillData.houndeyeDmgBlast + gSkillData.houndeyeDmgBlast * ( HOUNDEYE_SQUAD_BONUS * ( SquadCount() - 1 ) );
@ -632,20 +627,20 @@ void CHoundeye :: SonicAttack ( void )
flAdjustedDamage = gSkillData.houndeyeDmgBlast;
}
flDist = (pEntity->Center() - pev->origin).Length();
flDist = ( pEntity->Center() - pev->origin ).Length();
flAdjustedDamage -= ( flDist / HOUNDEYE_MAX_ATTACK_RADIUS ) * flAdjustedDamage;
if ( !FVisible( pEntity ) )
if( !FVisible( pEntity ) )
{
if ( pEntity->IsPlayer() )
if( pEntity->IsPlayer() )
{
// if this entity is a client, and is not in full view, inflict half damage. We do this so that players still
// take the residual damage if they don't totally leave the houndeye's effective radius. We restrict it to clients
// so that monsters in other parts of the level don't take the damage and get pissed.
flAdjustedDamage *= 0.5;
}
else if ( !FClassnameIs( pEntity->pev, "func_breakable" ) && !FClassnameIs( pEntity->pev, "func_pushable" ) )
else if( !FClassnameIs( pEntity->pev, "func_breakable" ) && !FClassnameIs( pEntity->pev, "func_pushable" ) )
{
// do not hurt nonclients through walls, but allow damage to be done to breakables
flAdjustedDamage = 0;
@ -654,9 +649,9 @@ void CHoundeye :: SonicAttack ( void )
//ALERT ( at_aiconsole, "Damage: %f\n", flAdjustedDamage );
if (flAdjustedDamage > 0 )
if( flAdjustedDamage > 0 )
{
pEntity->TakeDamage ( pev, pev, flAdjustedDamage, DMG_SONIC | DMG_ALWAYSGIB );
pEntity->TakeDamage( pev, pev, flAdjustedDamage, DMG_SONIC | DMG_ALWAYSGIB );
}
}
}
@ -666,11 +661,11 @@ void CHoundeye :: SonicAttack ( void )
//=========================================================
// start task
//=========================================================
void CHoundeye :: StartTask ( Task_t *pTask )
void CHoundeye::StartTask( Task_t *pTask )
{
m_iTaskStatus = TASKSTATUS_RUNNING;
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_HOUND_FALL_ASLEEP:
{
@ -711,14 +706,14 @@ void CHoundeye :: StartTask ( Task_t *pTask )
m_IdealActivity = ACT_RANGE_ATTACK1;
/*
if ( InSquad() )
if( InSquad() )
{
// see if there is a battery to connect to.
CSquadMonster *pSquad = m_pSquadLeader;
while ( pSquad )
while( pSquad )
{
if ( pSquad->m_iMySlot == bits_SLOT_HOUND_BATTERY )
if( pSquad->m_iMySlot == bits_SLOT_HOUND_BATTERY )
{
// draw a beam.
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
@ -758,7 +753,7 @@ void CHoundeye :: StartTask ( Task_t *pTask )
}
default:
{
CSquadMonster :: StartTask(pTask);
CSquadMonster::StartTask( pTask );
break;
}
}
@ -767,16 +762,16 @@ void CHoundeye :: StartTask ( Task_t *pTask )
//=========================================================
// RunTask
//=========================================================
void CHoundeye :: RunTask ( Task_t *pTask )
void CHoundeye::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_HOUND_THREAT_DISPLAY:
{
MakeIdealYaw ( m_vecEnemyLKP );
ChangeYaw ( pev->yaw_speed );
MakeIdealYaw( m_vecEnemyLKP );
ChangeYaw( pev->yaw_speed );
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
TaskComplete();
}
@ -784,7 +779,7 @@ void CHoundeye :: RunTask ( Task_t *pTask )
}
case TASK_HOUND_CLOSE_EYE:
{
if ( pev->skin < HOUNDEYE_EYE_FRAMES - 1 )
if( pev->skin < HOUNDEYE_EYE_FRAMES - 1 )
{
pev->skin++;
}
@ -792,7 +787,7 @@ void CHoundeye :: RunTask ( Task_t *pTask )
}
case TASK_HOUND_HOP_BACK:
{
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
TaskComplete();
}
@ -800,26 +795,27 @@ void CHoundeye :: RunTask ( Task_t *pTask )
}
case TASK_SPECIAL_ATTACK1:
{
pev->skin = RANDOM_LONG(0, HOUNDEYE_EYE_FRAMES - 1);
pev->skin = RANDOM_LONG( 0, HOUNDEYE_EYE_FRAMES - 1 );
MakeIdealYaw ( m_vecEnemyLKP );
ChangeYaw ( pev->yaw_speed );
MakeIdealYaw( m_vecEnemyLKP );
ChangeYaw( pev->yaw_speed );
float life;
life = ((255 - pev->frame) / (pev->framerate * m_flFrameRate));
if (life < 0.1) life = 0.1;
life = ( ( 255 - pev->frame ) / ( pev->framerate * m_flFrameRate ) );
if( life < 0.1 )
life = 0.1;
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, pev->origin );
WRITE_BYTE( TE_IMPLOSION);
WRITE_COORD( pev->origin.x);
WRITE_COORD( pev->origin.y);
WRITE_COORD( pev->origin.z + 16);
WRITE_BYTE( 50 * life + 100); // radius
WRITE_BYTE( TE_IMPLOSION );
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z + 16 );
WRITE_BYTE( 50 * life + 100 ); // radius
WRITE_BYTE( pev->frame / 25.0 ); // count
WRITE_BYTE( life * 10 ); // life
MESSAGE_END();
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
SonicAttack();
TaskComplete();
@ -828,7 +824,7 @@ void CHoundeye :: RunTask ( Task_t *pTask )
}
default:
{
CSquadMonster :: RunTask(pTask);
CSquadMonster::RunTask( pTask );
break;
}
}
@ -837,23 +833,23 @@ void CHoundeye :: RunTask ( Task_t *pTask )
//=========================================================
// PrescheduleThink
//=========================================================
void CHoundeye::PrescheduleThink ( void )
void CHoundeye::PrescheduleThink( void )
{
// if the hound is mad and is running, make hunt noises.
if ( m_MonsterState == MONSTERSTATE_COMBAT && m_Activity == ACT_RUN && RANDOM_FLOAT( 0, 1 ) < 0.2 )
if( m_MonsterState == MONSTERSTATE_COMBAT && m_Activity == ACT_RUN && RANDOM_FLOAT( 0, 1 ) < 0.2 )
{
WarnSound();
}
// at random, initiate a blink if not already blinking or sleeping
if ( !m_fDontBlink )
if( !m_fDontBlink )
{
if ( ( pev->skin == 0 ) && RANDOM_LONG(0,0x7F) == 0 )
if( ( pev->skin == 0 ) && RANDOM_LONG( 0, 0x7F ) == 0 )
{
// start blinking!
pev->skin = HOUNDEYE_EYE_FRAMES - 1;
}
else if ( pev->skin != 0 )
else if( pev->skin != 0 )
{
// already blinking
pev->skin--;
@ -861,16 +857,16 @@ void CHoundeye::PrescheduleThink ( void )
}
// if you are the leader, average the origins of each pack member to get an approximate center.
if ( IsLeader() )
if( IsLeader() )
{
CSquadMonster *pSquadMember;
int iSquadCount = 0;
for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS; i++ )
{
pSquadMember = MySquadMember(i);
pSquadMember = MySquadMember( i );
if (pSquadMember)
if( pSquadMember )
{
iSquadCount++;
m_vecPackCenter = m_vecPackCenter + pSquadMember->pev->origin;
@ -1142,107 +1138,106 @@ IMPLEMENT_CUSTOM_SCHEDULES( CHoundeye, CSquadMonster )
//=========================================================
// GetScheduleOfType
//=========================================================
Schedule_t* CHoundeye :: GetScheduleOfType ( int Type )
Schedule_t *CHoundeye::GetScheduleOfType( int Type )
{
if ( m_fAsleep )
if( m_fAsleep )
{
// if the hound is sleeping, must wake and stand!
if ( HasConditions( bits_COND_HEAR_SOUND ) )
if( HasConditions( bits_COND_HEAR_SOUND ) )
{
CSound *pWakeSound;
pWakeSound = PBestSound();
ASSERT( pWakeSound != NULL );
if ( pWakeSound )
if( pWakeSound )
{
MakeIdealYaw ( pWakeSound->m_vecOrigin );
MakeIdealYaw( pWakeSound->m_vecOrigin );
if ( FLSoundVolume ( pWakeSound ) >= HOUNDEYE_SOUND_STARTLE_VOLUME )
if( FLSoundVolume( pWakeSound ) >= HOUNDEYE_SOUND_STARTLE_VOLUME )
{
// awakened by a loud sound
return &slHoundWakeUrgent[ 0 ];
return &slHoundWakeUrgent[0];
}
}
// sound was not loud enough to scare the bejesus out of houndeye
return &slHoundWakeLazy[ 0 ];
return &slHoundWakeLazy[0];
}
else if ( HasConditions( bits_COND_NEW_ENEMY ) )
else if( HasConditions( bits_COND_NEW_ENEMY ) )
{
// get up fast, to fight.
return &slHoundWakeUrgent[ 0 ];
return &slHoundWakeUrgent[0];
}
else
{
// hound is waking up on its own
return &slHoundWakeLazy[ 0 ];
return &slHoundWakeLazy[0];
}
}
switch ( Type )
switch( Type )
{
case SCHED_IDLE_STAND:
{
// we may want to sleep instead of stand!
if ( InSquad() && !IsLeader() && !m_fAsleep && RANDOM_LONG(0,29) < 1 )
if( InSquad() && !IsLeader() && !m_fAsleep && RANDOM_LONG( 0, 29 ) < 1 )
{
return &slHoundSleep[ 0 ];
return &slHoundSleep[0];
}
else
{
return CSquadMonster :: GetScheduleOfType( Type );
return CSquadMonster::GetScheduleOfType( Type );
}
}
case SCHED_RANGE_ATTACK1:
{
return &slHoundRangeAttack[ 0 ];
return &slHoundRangeAttack[0];
/*
if ( InSquad() )
if( InSquad() )
{
return &slHoundRangeAttack[ RANDOM_LONG( 0, 1 ) ];
return &slHoundRangeAttack[RANDOM_LONG( 0, 1 )];
}
return &slHoundRangeAttack[ 1 ];
return &slHoundRangeAttack[1];
*/
}
case SCHED_SPECIAL_ATTACK1:
{
return &slHoundSpecialAttack1[ 0 ];
return &slHoundSpecialAttack1[0];
}
case SCHED_GUARD:
{
return &slHoundGuardPack[ 0 ];
return &slHoundGuardPack[0];
}
case SCHED_HOUND_AGITATED:
{
return &slHoundAgitated[ 0 ];
return &slHoundAgitated[0];
}
case SCHED_HOUND_HOP_RETREAT:
{
return &slHoundHopRetreat[ 0 ];
return &slHoundHopRetreat[0];
}
case SCHED_FAIL:
{
if ( m_MonsterState == MONSTERSTATE_COMBAT )
if( m_MonsterState == MONSTERSTATE_COMBAT )
{
if ( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
if( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
{
// client in PVS
return &slHoundCombatFailPVS[ 0 ];
return &slHoundCombatFailPVS[0];
}
else
{
// client has taken off!
return &slHoundCombatFailNoPVS[ 0 ];
return &slHoundCombatFailNoPVS[0];
}
}
else
{
return CSquadMonster :: GetScheduleOfType ( Type );
return CSquadMonster::GetScheduleOfType( Type );
}
}
default:
{
return CSquadMonster :: GetScheduleOfType ( Type );
return CSquadMonster::GetScheduleOfType( Type );
}
}
}
@ -1250,45 +1245,45 @@ Schedule_t* CHoundeye :: GetScheduleOfType ( int Type )
//=========================================================
// GetSchedule
//=========================================================
Schedule_t *CHoundeye :: GetSchedule( void )
Schedule_t *CHoundeye::GetSchedule( void )
{
switch ( m_MonsterState )
switch( m_MonsterState )
{
case MONSTERSTATE_COMBAT:
{
// dead enemy
if ( HasConditions( bits_COND_ENEMY_DEAD ) )
if( HasConditions( bits_COND_ENEMY_DEAD ) )
{
// call base class, all code to handle dead enemies is centralized there.
return CBaseMonster :: GetSchedule();
return CBaseMonster::GetSchedule();
}
if ( HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )
if( HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )
{
if ( RANDOM_FLOAT( 0 , 1 ) <= 0.4 )
if( RANDOM_FLOAT( 0, 1 ) <= 0.4 )
{
TraceResult tr;
UTIL_MakeVectors( pev->angles );
UTIL_TraceHull( pev->origin, pev->origin + gpGlobals->v_forward * -128, dont_ignore_monsters, head_hull, ENT( pev ), &tr );
if ( tr.flFraction == 1.0 )
if( tr.flFraction == 1.0 )
{
// it's clear behind, so the hound will jump
return GetScheduleOfType ( SCHED_HOUND_HOP_RETREAT );
return GetScheduleOfType( SCHED_HOUND_HOP_RETREAT );
}
}
return GetScheduleOfType ( SCHED_TAKE_COVER_FROM_ENEMY );
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
}
if ( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )
if( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )
{
if ( OccupySlot ( bits_SLOTS_HOUND_ATTACK ) )
if( OccupySlot( bits_SLOTS_HOUND_ATTACK ) )
{
return GetScheduleOfType ( SCHED_RANGE_ATTACK1 );
return GetScheduleOfType( SCHED_RANGE_ATTACK1 );
}
return GetScheduleOfType ( SCHED_HOUND_AGITATED );
return GetScheduleOfType( SCHED_HOUND_AGITATED );
}
break;
}
@ -1296,5 +1291,5 @@ Schedule_t *CHoundeye :: GetSchedule( void )
break;
}
return CSquadMonster :: GetSchedule();
return CSquadMonster::GetSchedule();
}

339
dlls/ichthyosaur.cpp
View File

@ -73,8 +73,8 @@ public:
void StartTask( Task_t *pTask );
void RunTask( Task_t *pTask );
BOOL CheckMeleeAttack1 ( float flDot, float flDist );
BOOL CheckRangeAttack1 ( float flDot, float flDist );
BOOL CheckMeleeAttack1( float flDot, float flDist );
BOOL CheckRangeAttack1( float flDot, float flDist );
float ChangeYaw( int speed );
Activity GetStoppedActivity( void );
@ -84,9 +84,9 @@ public:
void MonsterThink( void );
void Stop( void );
void Swim( void );
Vector DoProbe(const Vector &Probe);
Vector DoProbe(const Vector &Probe );
float VectorToPitch( const Vector &vec);
float VectorToPitch( const Vector &vec );
float FlPitchDiff( void );
float ChangePitch( int speed );
@ -178,34 +178,34 @@ const char *CIchthyosaur::pDieSounds[] =
};
#define EMIT_ICKY_SOUND( chan, array ) \
EMIT_SOUND_DYN ( ENT(pev), chan , array [ RANDOM_LONG(0,ARRAYSIZE( array )-1) ], 1.0, 0.6, 0, RANDOM_LONG(95,105) );
EMIT_SOUND_DYN( ENT( pev ), chan , array[RANDOM_LONG( 0, ARRAYSIZE( array ) - 1 )], 1.0, 0.6, 0, RANDOM_LONG( 95, 105 ) );
void CIchthyosaur :: IdleSound( void )
void CIchthyosaur::IdleSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pIdleSounds );
}
void CIchthyosaur :: AlertSound( void )
void CIchthyosaur::AlertSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pAlertSounds );
}
void CIchthyosaur :: AttackSound( void )
void CIchthyosaur::AttackSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pAttackSounds );
}
void CIchthyosaur :: BiteSound( void )
void CIchthyosaur::BiteSound( void )
{
EMIT_ICKY_SOUND( CHAN_WEAPON, pBiteSounds );
}
void CIchthyosaur :: DeathSound( void )
void CIchthyosaur::DeathSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pDieSounds );
}
void CIchthyosaur :: PainSound( void )
void CIchthyosaur::PainSound( void )
{
EMIT_ICKY_SOUND( CHAN_VOICE, pPainSounds );
}
@ -318,7 +318,7 @@ IMPLEMENT_CUSTOM_SCHEDULES( CIchthyosaur, CFlyingMonster )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CIchthyosaur :: Classify ( void )
int CIchthyosaur::Classify( void )
{
return CLASS_ALIEN_MONSTER;
}
@ -326,9 +326,9 @@ int CIchthyosaur :: Classify ( void )
//=========================================================
// CheckMeleeAttack1
//=========================================================
BOOL CIchthyosaur :: CheckMeleeAttack1 ( float flDot, float flDist )
BOOL CIchthyosaur::CheckMeleeAttack1( float flDot, float flDist )
{
if ( flDot >= 0.7 && m_flEnemyTouched > gpGlobals->time - 0.2 )
if( flDot >= 0.7 && m_flEnemyTouched > gpGlobals->time - 0.2 )
{
return TRUE;
}
@ -338,7 +338,7 @@ BOOL CIchthyosaur :: CheckMeleeAttack1 ( float flDot, float flDist )
void CIchthyosaur::BiteTouch( CBaseEntity *pOther )
{
// bite if we hit who we want to eat
if ( pOther == m_hEnemy )
if( pOther == m_hEnemy )
{
m_flEnemyTouched = gpGlobals->time;
m_bOnAttack = TRUE;
@ -347,10 +347,10 @@ void CIchthyosaur::BiteTouch( CBaseEntity *pOther )
void CIchthyosaur::CombatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( !ShouldToggle( useType, m_bOnAttack ) )
if( !ShouldToggle( useType, m_bOnAttack ) )
return;
if (m_bOnAttack)
if( m_bOnAttack )
{
m_bOnAttack = 0;
}
@ -364,9 +364,9 @@ void CIchthyosaur::CombatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE
// CheckRangeAttack1 - swim in for a chomp
//
//=========================================================
BOOL CIchthyosaur :: CheckRangeAttack1 ( float flDot, float flDist )
BOOL CIchthyosaur::CheckRangeAttack1( float flDot, float flDist )
{
if ( flDot > -0.7 && (m_bOnAttack || ( flDist <= 192 && m_idealDist <= 192)))
if( flDot > -0.7 && (m_bOnAttack || ( flDist <= 192 && m_idealDist <= 192 ) ) )
{
return TRUE;
}
@ -378,7 +378,7 @@ BOOL CIchthyosaur :: CheckRangeAttack1 ( float flDot, float flDist )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CIchthyosaur :: SetYawSpeed ( void )
void CIchthyosaur::SetYawSpeed( void )
{
pev->yaw_speed = 100;
}
@ -386,7 +386,7 @@ void CIchthyosaur :: SetYawSpeed ( void )
//=========================================================
// Killed - overrides CFlyingMonster.
//
void CIchthyosaur :: Killed( entvars_t *pevAttacker, int iGib )
void CIchthyosaur::Killed( entvars_t *pevAttacker, int iGib )
{
CBaseMonster::Killed( pevAttacker, iGib );
pev->velocity = Vector( 0, 0, 0 );
@ -408,7 +408,7 @@ void CIchthyosaur::BecomeDead( void )
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CIchthyosaur :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CIchthyosaur::HandleAnimEvent( MonsterEvent_t *pEvent )
{
int bDidAttack = FALSE;
switch( pEvent->event )
@ -416,23 +416,23 @@ void CIchthyosaur :: HandleAnimEvent( MonsterEvent_t *pEvent )
case ICHTHYOSAUR_AE_SHAKE_RIGHT:
case ICHTHYOSAUR_AE_SHAKE_LEFT:
{
if (m_hEnemy != NULL && FVisible( m_hEnemy ))
if( m_hEnemy != NULL && FVisible( m_hEnemy ) )
{
CBaseEntity *pHurt = m_hEnemy;
if (m_flEnemyTouched < gpGlobals->time - 0.2 && (m_hEnemy->BodyTarget( pev->origin ) - pev->origin).Length() > (32+16+32))
if( m_flEnemyTouched < gpGlobals->time - 0.2 && ( m_hEnemy->BodyTarget( pev->origin ) - pev->origin).Length() > ( 32 + 16 + 32 ) )
break;
Vector vecShootDir = ShootAtEnemy( pev->origin );
UTIL_MakeAimVectors ( pev->angles );
UTIL_MakeAimVectors( pev->angles );
if (DotProduct( vecShootDir, gpGlobals->v_forward ) > 0.707)
if( DotProduct( vecShootDir, gpGlobals->v_forward ) > 0.707 )
{
m_bOnAttack = TRUE;
pHurt->pev->punchangle.z = -18;
pHurt->pev->punchangle.x = 5;
pHurt->pev->velocity = pHurt->pev->velocity - gpGlobals->v_right * 300;
if (pHurt->IsPlayer())
if( pHurt->IsPlayer() )
{
pHurt->pev->angles.x += RANDOM_FLOAT( -35, 35 );
pHurt->pev->angles.y += RANDOM_FLOAT( -90, 90 );
@ -452,7 +452,7 @@ void CIchthyosaur :: HandleAnimEvent( MonsterEvent_t *pEvent )
break;
}
if (bDidAttack)
if( bDidAttack )
{
Vector vecSrc = pev->origin + gpGlobals->v_forward * 32;
UTIL_Bubbles( vecSrc - Vector( 8, 8, 8 ), vecSrc + Vector( 8, 8, 8 ), 16 );
@ -462,18 +462,18 @@ void CIchthyosaur :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// Spawn
//=========================================================
void CIchthyosaur :: Spawn()
void CIchthyosaur::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/icky.mdl");
SET_MODEL( ENT( pev ), "models/icky.mdl" );
UTIL_SetSize( pev, Vector( -32, -32, -32 ), Vector( 32, 32, 32 ) );
pev->solid = SOLID_BBOX;
pev->movetype = MOVETYPE_FLY;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->health = gSkillData.ichthyosaurHealth;
pev->view_ofs = Vector ( 0, 0, 16 );
pev->view_ofs = Vector( 0, 0, 16 );
m_flFieldOfView = VIEW_FIELD_WIDE;
m_MonsterState = MONSTERSTATE_NONE;
SetBits(pev->flags, FL_SWIM);
@ -493,7 +493,7 @@ void CIchthyosaur :: Spawn()
m_flMaxDist = 384;
Vector Forward;
UTIL_MakeVectorsPrivate(pev->angles, Forward, 0, 0);
UTIL_MakeVectorsPrivate( pev->angles, Forward, 0, 0 );
pev->velocity = m_flightSpeed * Forward.Normalize();
m_SaveVelocity = pev->velocity;
}
@ -501,9 +501,9 @@ void CIchthyosaur :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CIchthyosaur :: Precache()
void CIchthyosaur::Precache()
{
PRECACHE_MODEL("models/icky.mdl");
PRECACHE_MODEL( "models/icky.mdl" );
PRECACHE_SOUND_ARRAY( pIdleSounds );
PRECACHE_SOUND_ARRAY( pAlertSounds );
@ -519,7 +519,7 @@ void CIchthyosaur :: Precache()
Schedule_t* CIchthyosaur::GetSchedule()
{
// ALERT( at_console, "GetSchedule( )\n" );
switch(m_MonsterState)
switch( m_MonsterState )
{
case MONSTERSTATE_IDLE:
m_flightSpeed = 80;
@ -532,20 +532,21 @@ Schedule_t* CIchthyosaur::GetSchedule()
case MONSTERSTATE_COMBAT:
m_flMaxSpeed = 400;
// eat them
if ( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
if( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
{
return GetScheduleOfType( SCHED_MELEE_ATTACK1 );
}
// chase them down and eat them
if ( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )
if( HasConditions( bits_COND_CAN_RANGE_ATTACK1 ) )
{
return GetScheduleOfType( SCHED_CHASE_ENEMY );
}
if ( HasConditions( bits_COND_HEAVY_DAMAGE ) )
if( HasConditions( bits_COND_HEAVY_DAMAGE ) )
{
m_bOnAttack = TRUE;
}
if ( pev->health < pev->max_health - 20 )
if( pev->health < pev->max_health - 20 )
{
m_bOnAttack = TRUE;
}
@ -556,15 +557,15 @@ Schedule_t* CIchthyosaur::GetSchedule()
break;
}
return CFlyingMonster :: GetSchedule();
return CFlyingMonster::GetSchedule();
}
//=========================================================
//=========================================================
Schedule_t* CIchthyosaur :: GetScheduleOfType ( int Type )
Schedule_t *CIchthyosaur::GetScheduleOfType( int Type )
{
// ALERT( at_console, "GetScheduleOfType( %d ) %d\n", Type, m_bOnAttack );
switch ( Type )
switch( Type )
{
case SCHED_IDLE_WALK:
return slSwimAround;
@ -575,10 +576,10 @@ Schedule_t* CIchthyosaur :: GetScheduleOfType ( int Type )
case SCHED_DIE:
return slTwitchDie;
case SCHED_CHASE_ENEMY:
AttackSound( );
AttackSound();
}
return CBaseMonster :: GetScheduleOfType( Type );
return CBaseMonster::GetScheduleOfType( Type );
}
//=========================================================
@ -586,16 +587,16 @@ Schedule_t* CIchthyosaur :: GetScheduleOfType ( int Type )
// any necessary calculations to start the next task on the
// schedule.
//=========================================================
void CIchthyosaur::StartTask(Task_t *pTask)
void CIchthyosaur::StartTask( Task_t *pTask )
{
switch (pTask->iTask)
switch( pTask->iTask )
{
case TASK_ICHTHYOSAUR_CIRCLE_ENEMY:
break;
case TASK_ICHTHYOSAUR_SWIM:
break;
case TASK_SMALL_FLINCH:
if (m_idealDist > 128)
if( m_idealDist > 128 )
{
m_flMaxDist = 512;
m_idealDist = 512;
@ -604,35 +605,35 @@ void CIchthyosaur::StartTask(Task_t *pTask)
{
m_bOnAttack = TRUE;
}
CFlyingMonster::StartTask(pTask);
CFlyingMonster::StartTask( pTask );
break;
case TASK_ICHTHYOSAUR_FLOAT:
pev->skin = EYE_BASE;
SetSequenceByName( "bellyup" );
break;
default:
CFlyingMonster::StartTask(pTask);
CFlyingMonster::StartTask( pTask );
break;
}
}
void CIchthyosaur :: RunTask ( Task_t *pTask )
void CIchthyosaur::RunTask( Task_t *pTask )
{
switch ( pTask->iTask )
switch( pTask->iTask )
{
case TASK_ICHTHYOSAUR_CIRCLE_ENEMY:
if (m_hEnemy == NULL)
if( m_hEnemy == NULL )
{
TaskComplete( );
TaskComplete();
}
else if (FVisible( m_hEnemy ))
else if( FVisible( m_hEnemy ) )
{
Vector vecFrom = m_hEnemy->EyePosition( );
Vector vecFrom = m_hEnemy->EyePosition();
Vector vecDelta = (pev->origin - vecFrom).Normalize( );
Vector vecSwim = CrossProduct( vecDelta, Vector( 0, 0, 1 ) ).Normalize( );
Vector vecDelta = ( pev->origin - vecFrom ).Normalize();
Vector vecSwim = CrossProduct( vecDelta, Vector( 0, 0, 1 ) ).Normalize();
if (DotProduct( vecSwim, m_SaveVelocity ) < 0)
if( DotProduct( vecSwim, m_SaveVelocity ) < 0 )
vecSwim = vecSwim * -1.0;
Vector vecPos = vecFrom + vecDelta * m_idealDist + vecSwim * 32;
@ -643,30 +644,31 @@ void CIchthyosaur :: RunTask ( Task_t *pTask )
UTIL_TraceHull( vecFrom, vecPos, ignore_monsters, large_hull, m_hEnemy->edict(), &tr );
if (tr.flFraction > 0.5)
if( tr.flFraction > 0.5 )
vecPos = tr.vecEndPos;
m_SaveVelocity = m_SaveVelocity * 0.8 + 0.2 * (vecPos - pev->origin).Normalize() * m_flightSpeed;
m_SaveVelocity = m_SaveVelocity * 0.8 + 0.2 * ( vecPos - pev->origin ).Normalize() * m_flightSpeed;
// ALERT( at_console, "m_SaveVelocity %.2f %.2f %.2f\n", m_SaveVelocity.x, m_SaveVelocity.y, m_SaveVelocity.z );
if (HasConditions( bits_COND_ENEMY_FACING_ME ) && m_hEnemy->FVisible( this ))
if( HasConditions( bits_COND_ENEMY_FACING_ME ) && m_hEnemy->FVisible( this ) )
{
m_flNextAlert -= 0.1;
if (m_idealDist < m_flMaxDist)
if( m_idealDist < m_flMaxDist )
{
m_idealDist += 4;
}
if (m_flightSpeed > m_flMinSpeed)
if( m_flightSpeed > m_flMinSpeed )
{
m_flightSpeed -= 2;
}
else if (m_flightSpeed < m_flMinSpeed)
else if( m_flightSpeed < m_flMinSpeed )
{
m_flightSpeed += 2;
}
if (m_flMinSpeed < m_flMaxSpeed)
if( m_flMinSpeed < m_flMaxSpeed )
{
m_flMinSpeed += 0.5;
}
@ -675,11 +677,11 @@ void CIchthyosaur :: RunTask ( Task_t *pTask )
{
m_flNextAlert += 0.1;
if (m_idealDist > 128)
if( m_idealDist > 128 )
{
m_idealDist -= 4;
}
if (m_flightSpeed < m_flMaxSpeed)
if( m_flightSpeed < m_flMaxSpeed )
{
m_flightSpeed += 4;
}
@ -691,32 +693,31 @@ void CIchthyosaur :: RunTask ( Task_t *pTask )
m_flNextAlert = gpGlobals->time + 0.2;
}
if (m_flNextAlert < gpGlobals->time)
if( m_flNextAlert < gpGlobals->time )
{
// ALERT( at_console, "AlertSound()\n");
AlertSound( );
// ALERT( at_console, "AlertSound()\n" );
AlertSound();
m_flNextAlert = gpGlobals->time + RANDOM_FLOAT( 3, 5 );
}
break;
case TASK_ICHTHYOSAUR_SWIM:
if (m_fSequenceFinished)
if( m_fSequenceFinished )
{
TaskComplete( );
TaskComplete();
}
break;
case TASK_DIE:
if ( m_fSequenceFinished )
if( m_fSequenceFinished )
{
pev->deadflag = DEAD_DEAD;
TaskComplete( );
TaskComplete();
}
break;
case TASK_ICHTHYOSAUR_FLOAT:
pev->angles.x = UTIL_ApproachAngle( 0, pev->angles.x, 20 );
pev->velocity = pev->velocity * 0.8;
if (pev->waterlevel > 1 && pev->velocity.z < 64)
if( pev->waterlevel > 1 && pev->velocity.z < 64 )
{
pev->velocity.z += 8;
}
@ -727,7 +728,7 @@ void CIchthyosaur :: RunTask ( Task_t *pTask )
// ALERT( at_console, "%f\n", pev->velocity.z );
break;
default:
CFlyingMonster :: RunTask ( pTask );
CFlyingMonster::RunTask( pTask );
break;
}
}
@ -735,19 +736,19 @@ void CIchthyosaur :: RunTask ( Task_t *pTask )
float CIchthyosaur::VectorToPitch( const Vector &vec )
{
float pitch;
if (vec.z == 0 && vec.x == 0)
if( vec.z == 0 && vec.x == 0 )
pitch = 0;
else
{
pitch = (int) (atan2(vec.z, sqrt(vec.x*vec.x+vec.y*vec.y)) * 180 / M_PI);
if (pitch < 0)
pitch = (int) ( atan2( vec.z, sqrt( vec.x * vec.x + vec.y * vec.y ) ) * 180 / M_PI );
if( pitch < 0 )
pitch += 360;
}
return pitch;
}
//=========================================================
void CIchthyosaur::Move(float flInterval)
void CIchthyosaur::Move( float flInterval )
{
CFlyingMonster::Move( flInterval );
}
@ -759,37 +760,37 @@ float CIchthyosaur::FlPitchDiff( void )
flCurrentPitch = UTIL_AngleMod( pev->angles.z );
if ( flCurrentPitch == pev->idealpitch )
if( flCurrentPitch == pev->idealpitch )
{
return 0;
}
flPitchDiff = pev->idealpitch - flCurrentPitch;
if ( pev->idealpitch > flCurrentPitch )
if( pev->idealpitch > flCurrentPitch )
{
if (flPitchDiff >= 180)
if( flPitchDiff >= 180 )
flPitchDiff = flPitchDiff - 360;
}
else
{
if (flPitchDiff <= -180)
if( flPitchDiff <= -180 )
flPitchDiff = flPitchDiff + 360;
}
return flPitchDiff;
}
float CIchthyosaur :: ChangePitch( int speed )
float CIchthyosaur::ChangePitch( int speed )
{
if ( pev->movetype == MOVETYPE_FLY )
if( pev->movetype == MOVETYPE_FLY )
{
float diff = FlPitchDiff();
float target = 0;
if ( m_IdealActivity != GetStoppedActivity() )
if( m_IdealActivity != GetStoppedActivity() )
{
if (diff < -20)
if( diff < -20 )
target = 45;
else if (diff > 20)
else if( diff > 20 )
target = -45;
}
pev->angles.x = UTIL_Approach(target, pev->angles.x, 220.0 * 0.1 );
@ -799,16 +800,16 @@ float CIchthyosaur :: ChangePitch( int speed )
float CIchthyosaur::ChangeYaw( int speed )
{
if ( pev->movetype == MOVETYPE_FLY )
if( pev->movetype == MOVETYPE_FLY )
{
float diff = FlYawDiff();
float target = 0;
if ( m_IdealActivity != GetStoppedActivity() )
if( m_IdealActivity != GetStoppedActivity() )
{
if ( diff < -20 )
if( diff < -20 )
target = 20;
else if ( diff > 20 )
else if( diff > 20 )
target = -20;
}
pev->angles.z = UTIL_Approach( target, pev->angles.z, 220.0 * 0.1 );
@ -816,9 +817,9 @@ float CIchthyosaur::ChangeYaw( int speed )
return CFlyingMonster::ChangeYaw( speed );
}
Activity CIchthyosaur:: GetStoppedActivity( void )
Activity CIchthyosaur::GetStoppedActivity( void )
{
if ( pev->movetype != MOVETYPE_FLY ) // UNDONE: Ground idle here, IDLE may be something else
if( pev->movetype != MOVETYPE_FLY ) // UNDONE: Ground idle here, IDLE may be something else
return ACT_IDLE;
return ACT_WALK;
}
@ -828,24 +829,24 @@ void CIchthyosaur::MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, f
m_SaveVelocity = vecDir * m_flightSpeed;
}
void CIchthyosaur::MonsterThink ( void )
void CIchthyosaur::MonsterThink( void )
{
CFlyingMonster::MonsterThink( );
CFlyingMonster::MonsterThink();
if (pev->deadflag == DEAD_NO)
if( pev->deadflag == DEAD_NO )
{
if (m_MonsterState != MONSTERSTATE_SCRIPT)
if( m_MonsterState != MONSTERSTATE_SCRIPT )
{
Swim( );
Swim();
// blink the eye
if (m_flBlink < gpGlobals->time)
if( m_flBlink < gpGlobals->time )
{
pev->skin = EYE_CLOSED;
if (m_flBlink + 0.2 < gpGlobals->time)
if( m_flBlink + 0.2 < gpGlobals->time )
{
m_flBlink = gpGlobals->time + RANDOM_FLOAT( 3, 4 );
if (m_bOnAttack)
if( m_bOnAttack )
pev->skin = EYE_MAD;
else
pev->skin = EYE_BASE;
@ -855,13 +856,13 @@ void CIchthyosaur::MonsterThink ( void )
}
}
void CIchthyosaur :: Stop( void )
void CIchthyosaur::Stop( void )
{
if (!m_bOnAttack)
if( !m_bOnAttack )
m_flightSpeed = 80.0;
}
void CIchthyosaur::Swim( )
void CIchthyosaur::Swim()
{
int retValue = 0;
@ -870,45 +871,45 @@ void CIchthyosaur::Swim( )
Vector Angles;
Vector Forward, Right, Up;
if (FBitSet( pev->flags, FL_ONGROUND))
if( FBitSet( pev->flags, FL_ONGROUND ) )
{
pev->angles.x = 0;
pev->angles.y += RANDOM_FLOAT( -45, 45 );
ClearBits( pev->flags, FL_ONGROUND );
Angles = Vector( -pev->angles.x, pev->angles.y, pev->angles.z );
UTIL_MakeVectorsPrivate(Angles, Forward, Right, Up);
UTIL_MakeVectorsPrivate( Angles, Forward, Right, Up );
pev->velocity = Forward * 200 + Up * 200;
return;
}
if (m_bOnAttack && m_flightSpeed < m_flMaxSpeed)
if( m_bOnAttack && m_flightSpeed < m_flMaxSpeed )
{
m_flightSpeed += 40;
}
if (m_flightSpeed < 180)
if( m_flightSpeed < 180 )
{
if (m_IdealActivity == ACT_RUN)
if( m_IdealActivity == ACT_RUN )
SetActivity( ACT_WALK );
if (m_IdealActivity == ACT_WALK)
if( m_IdealActivity == ACT_WALK )
pev->framerate = m_flightSpeed / 150.0;
// ALERT( at_console, "walk %.2f\n", pev->framerate );
}
else
{
if (m_IdealActivity == ACT_WALK)
if( m_IdealActivity == ACT_WALK )
SetActivity( ACT_RUN );
if (m_IdealActivity == ACT_RUN)
if( m_IdealActivity == ACT_RUN)
pev->framerate = m_flightSpeed / 150.0;
// ALERT( at_console, "run %.2f\n", pev->framerate );
}
/*
if (!m_pBeam)
if( !m_pBeam )
{
m_pBeam = CBeam::BeamCreate( "sprites/laserbeam.spr", 80 );
m_pBeam->PointEntInit( pev->origin + m_SaveVelocity, entindex( ) );
m_pBeam->PointEntInit( pev->origin + m_SaveVelocity, entindex() );
m_pBeam->SetEndAttachment( 1 );
m_pBeam->SetColor( 255, 180, 96 );
m_pBeam->SetBrightness( 192 );
@ -917,27 +918,27 @@ void CIchthyosaur::Swim( )
#define PROBE_LENGTH 150
Angles = UTIL_VecToAngles( m_SaveVelocity );
Angles.x = -Angles.x;
UTIL_MakeVectorsPrivate(Angles, Forward, Right, Up);
UTIL_MakeVectorsPrivate( Angles, Forward, Right, Up );
Vector f, u, l, r, d;
f = DoProbe(start + PROBE_LENGTH * Forward);
r = DoProbe(start + PROBE_LENGTH/3 * Forward+Right);
l = DoProbe(start + PROBE_LENGTH/3 * Forward-Right);
u = DoProbe(start + PROBE_LENGTH/3 * Forward+Up);
d = DoProbe(start + PROBE_LENGTH/3 * Forward-Up);
f = DoProbe( start + PROBE_LENGTH * Forward );
r = DoProbe( start + PROBE_LENGTH / 3 * Forward + Right );
l = DoProbe( start + PROBE_LENGTH / 3 * Forward - Right );
u = DoProbe( start + PROBE_LENGTH / 3 * Forward + Up );
d = DoProbe( start + PROBE_LENGTH / 3 * Forward - Up );
Vector SteeringVector = f+r+l+u+d;
m_SaveVelocity = (m_SaveVelocity + SteeringVector/2).Normalize();
Vector SteeringVector = f + r + l + u + d;
m_SaveVelocity = ( m_SaveVelocity + SteeringVector / 2 ).Normalize();
Angles = Vector( -pev->angles.x, pev->angles.y, pev->angles.z );
UTIL_MakeVectorsPrivate(Angles, Forward, Right, Up);
UTIL_MakeVectorsPrivate( Angles, Forward, Right, Up );
// ALERT( at_console, "%f : %f\n", Angles.x, Forward.z );
float flDot = DotProduct( Forward, m_SaveVelocity );
if (flDot > 0.5)
if( flDot > 0.5 )
pev->velocity = m_SaveVelocity = m_SaveVelocity * m_flightSpeed;
else if (flDot > 0)
pev->velocity = m_SaveVelocity = m_SaveVelocity * m_flightSpeed * (flDot + 0.5);
else if( flDot > 0 )
pev->velocity = m_SaveVelocity = m_SaveVelocity * m_flightSpeed * ( flDot + 0.5 );
else
pev->velocity = m_SaveVelocity = m_SaveVelocity * 80;
@ -946,7 +947,7 @@ void CIchthyosaur::Swim( )
// ALERT( at_console, "Steer %f %f %f\n", SteeringVector.x, SteeringVector.y, SteeringVector.z );
/*
m_pBeam->SetStartPos( pev->origin + pev->velocity );
m_pBeam->RelinkBeam( );
m_pBeam->RelinkBeam();
*/
// ALERT( at_console, "speed %f\n", m_flightSpeed );
@ -954,26 +955,28 @@ void CIchthyosaur::Swim( )
// Smooth Pitch
//
if (Angles.x > 180)
if( Angles.x > 180 )
Angles.x = Angles.x - 360;
pev->angles.x = UTIL_Approach(Angles.x, pev->angles.x, 50 * 0.1 );
if (pev->angles.x < -80) pev->angles.x = -80;
if (pev->angles.x > 80) pev->angles.x = 80;
pev->angles.x = UTIL_Approach( Angles.x, pev->angles.x, 50 * 0.1 );
if( pev->angles.x < -80 )
pev->angles.x = -80;
if( pev->angles.x > 80 )
pev->angles.x = 80;
// Smooth Yaw and generate Roll
//
float turn = 360;
// ALERT( at_console, "Y %.0f %.0f\n", Angles.y, pev->angles.y );
if (fabs(Angles.y - pev->angles.y) < fabs(turn))
if( fabs( Angles.y - pev->angles.y ) < fabs( turn ) )
{
turn = Angles.y - pev->angles.y;
}
if (fabs(Angles.y - pev->angles.y + 360) < fabs(turn))
if( fabs( Angles.y - pev->angles.y + 360 ) < fabs( turn ) )
{
turn = Angles.y - pev->angles.y + 360;
}
if (fabs(Angles.y - pev->angles.y - 360) < fabs(turn))
if( fabs( Angles.y - pev->angles.y - 360 ) < fabs( turn ) )
{
turn = Angles.y - pev->angles.y - 360;
}
@ -981,9 +984,9 @@ void CIchthyosaur::Swim( )
float speed = m_flightSpeed * 0.1;
// ALERT( at_console, "speed %.0f %f\n", turn, speed );
if (fabs(turn) > speed)
if( fabs( turn ) > speed )
{
if (turn < 0.0)
if( turn < 0.0 )
{
turn = -speed;
}
@ -994,7 +997,7 @@ void CIchthyosaur::Swim( )
}
pev->angles.y += turn;
pev->angles.z -= turn;
pev->angles.y = fmod((pev->angles.y + 360.0), 360.0);
pev->angles.y = fmod( ( pev->angles.y + 360.0 ), 360.0 );
static float yaw_adj;
@ -1007,26 +1010,27 @@ void CIchthyosaur::Swim( )
// Roll Smoothing
//
turn = 360;
if (fabs(Angles.z - pev->angles.z) < fabs(turn))
if( fabs( Angles.z - pev->angles.z ) < fabs( turn ) )
{
turn = Angles.z - pev->angles.z;
}
if (fabs(Angles.z - pev->angles.z + 360) < fabs(turn))
if( fabs( Angles.z - pev->angles.z + 360 ) < fabs( turn ) )
{
turn = Angles.z - pev->angles.z + 360;
}
if (fabs(Angles.z - pev->angles.z - 360) < fabs(turn))
if( fabs( Angles.z - pev->angles.z - 360 ) < fabs( turn ) )
{
turn = Angles.z - pev->angles.z - 360;
}
speed = m_flightSpeed/2 * 0.1;
if (fabs(turn) < speed)
speed = m_flightSpeed / 2 * 0.1;
if( fabs( turn ) < speed )
{
pev->angles.z += turn;
}
else
{
if (turn < 0.0)
if( turn < 0.0 )
{
pev->angles.z -= speed;
}
@ -1035,27 +1039,32 @@ void CIchthyosaur::Swim( )
pev->angles.z += speed;
}
}
if (pev->angles.z < -20) pev->angles.z = -20;
if (pev->angles.z > 20) pev->angles.z = 20;
UTIL_MakeVectorsPrivate( Vector( -Angles.x, Angles.y, Angles.z ), Forward, Right, Up);
if( pev->angles.z < -20 )
pev->angles.z = -20;
if( pev->angles.z > 20 )
pev->angles.z = 20;
// UTIL_MoveToOrigin ( ENT(pev), pev->origin + Forward * speed, speed, MOVE_STRAFE );
UTIL_MakeVectorsPrivate( Vector( -Angles.x, Angles.y, Angles.z ), Forward, Right, Up );
// UTIL_MoveToOrigin ( ENT( pev ), pev->origin + Forward * speed, speed, MOVE_STRAFE );
}
Vector CIchthyosaur::DoProbe(const Vector &Probe)
Vector CIchthyosaur::DoProbe( const Vector &Probe )
{
Vector WallNormal = Vector(0,0,-1); // WATER normal is Straight Down for fish.
Vector WallNormal = Vector( 0, 0, -1 ); // WATER normal is Straight Down for fish.
float frac;
BOOL bBumpedSomething = ProbeZ(pev->origin, Probe, &frac);
BOOL bBumpedSomething = ProbeZ( pev->origin, Probe, &frac );
TraceResult tr;
TRACE_MONSTER_HULL(edict(), pev->origin, Probe, dont_ignore_monsters, edict(), &tr);
if ( tr.fAllSolid || tr.flFraction < 0.99 )
TRACE_MONSTER_HULL( edict(), pev->origin, Probe, dont_ignore_monsters, edict(), &tr );
if( tr.fAllSolid || tr.flFraction < 0.99 )
{
if (tr.flFraction < 0.0) tr.flFraction = 0.0;
if (tr.flFraction > 1.0) tr.flFraction = 1.0;
if (tr.flFraction < frac)
if( tr.flFraction < 0.0 )
tr.flFraction = 0.0;
if( tr.flFraction > 1.0 )
tr.flFraction = 1.0;
if( tr.flFraction < frac )
{
frac = tr.flFraction;
bBumpedSomething = TRUE;
@ -1063,15 +1072,15 @@ Vector CIchthyosaur::DoProbe(const Vector &Probe)
}
}
if (bBumpedSomething && (m_hEnemy == NULL || tr.pHit != m_hEnemy->edict()))
if( bBumpedSomething && ( m_hEnemy == NULL || tr.pHit != m_hEnemy->edict() ) )
{
Vector ProbeDir = Probe - pev->origin;
Vector NormalToProbeAndWallNormal = CrossProduct(ProbeDir, WallNormal);
Vector SteeringVector = CrossProduct( NormalToProbeAndWallNormal, ProbeDir);
Vector NormalToProbeAndWallNormal = CrossProduct( ProbeDir, WallNormal );
Vector SteeringVector = CrossProduct( NormalToProbeAndWallNormal, ProbeDir );
float SteeringForce = m_flightSpeed * (1-frac) * (DotProduct(WallNormal.Normalize(), m_SaveVelocity.Normalize()));
if (SteeringForce < 0.0)
float SteeringForce = m_flightSpeed * ( 1 -frac ) * ( DotProduct( WallNormal.Normalize(), m_SaveVelocity.Normalize() ) );
if( SteeringForce < 0.0 )
{
SteeringForce = -SteeringForce;
}
@ -1079,6 +1088,6 @@ Vector CIchthyosaur::DoProbe(const Vector &Probe)
return SteeringVector;
}
return Vector(0, 0, 0);
return Vector( 0, 0, 0 );
}
#endif

313
dlls/islave.cpp
View File

@ -46,14 +46,14 @@ public:
void Precache( void );
void SetYawSpeed( void );
int ISoundMask( void );
int Classify ( void );
int Classify( void );
int IRelationship( CBaseEntity *pTarget );
void HandleAnimEvent( MonsterEvent_t *pEvent );
BOOL CheckRangeAttack1 ( float flDot, float flDist );
BOOL CheckRangeAttack2 ( float flDot, float flDist );
BOOL CheckRangeAttack1( float flDot, float flDist );
BOOL CheckRangeAttack2( float flDot, float flDist );
void CallForHelp( char *szClassname, float flDist, EHANDLE hEnemy, Vector &vecLocation );
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
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 TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
void DeathSound( void );
void PainSound( void );
@ -62,16 +62,16 @@ public:
void Killed( entvars_t *pevAttacker, int iGib );
void StartTask ( Task_t *pTask );
void StartTask( Task_t *pTask );
Schedule_t *GetSchedule( void );
Schedule_t *GetScheduleOfType ( int Type );
Schedule_t *GetScheduleOfType( int Type );
CUSTOM_SCHEDULES
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
void ClearBeams( );
void ClearBeams();
void ArmBeam( int side );
void WackBeam( int side, CBaseEntity *pEntity );
void ZapBeam( int side );
@ -142,36 +142,36 @@ const char *CISlave::pDeathSounds[] =
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CISlave :: Classify ( void )
int CISlave::Classify( void )
{
return CLASS_ALIEN_MILITARY;
}
int CISlave::IRelationship( CBaseEntity *pTarget )
{
if ( (pTarget->IsPlayer()) )
if ( (pev->spawnflags & SF_MONSTER_WAIT_UNTIL_PROVOKED ) && ! (m_afMemory & bits_MEMORY_PROVOKED ))
if( ( pTarget->IsPlayer() ) )
if( ( pev->spawnflags & SF_MONSTER_WAIT_UNTIL_PROVOKED ) && ! ( m_afMemory & bits_MEMORY_PROVOKED ) )
return R_NO;
return CBaseMonster::IRelationship( pTarget );
}
void CISlave :: CallForHelp( char *szClassname, float flDist, EHANDLE hEnemy, Vector &vecLocation )
void CISlave::CallForHelp( char *szClassname, float flDist, EHANDLE hEnemy, Vector &vecLocation )
{
// ALERT( at_aiconsole, "help " );
// skip ones not on my netname
if ( FStringNull( pev->netname ))
if( FStringNull( pev->netname ) )
return;
CBaseEntity *pEntity = NULL;
while ((pEntity = UTIL_FindEntityByString( pEntity, "netname", STRING( pev->netname ))) != NULL)
while( ( pEntity = UTIL_FindEntityByString( pEntity, "netname", STRING( pev->netname ) ) ) != NULL)
{
float d = (pev->origin - pEntity->pev->origin).Length();
if (d < flDist)
float d = ( pev->origin - pEntity->pev->origin ).Length();
if( d < flDist )
{
CBaseMonster *pMonster = pEntity->MyMonsterPointer( );
if (pMonster)
CBaseMonster *pMonster = pEntity->MyMonsterPointer();
if( pMonster )
{
pMonster->m_afMemory |= bits_MEMORY_PROVOKED;
pMonster->PushEnemy( hEnemy, vecLocation );
@ -183,11 +183,11 @@ void CISlave :: CallForHelp( char *szClassname, float flDist, EHANDLE hEnemy, Ve
//=========================================================
// ALertSound - scream
//=========================================================
void CISlave :: AlertSound( void )
void CISlave::AlertSound( void )
{
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
SENTENCEG_PlayRndSz(ENT(pev), "SLV_ALERT", 0.85, ATTN_NORM, 0, m_voicePitch);
SENTENCEG_PlayRndSz( ENT( pev ), "SLV_ALERT", 0.85, ATTN_NORM, 0, m_voicePitch );
CallForHelp( "monster_alien_slave", 512, m_hEnemy, m_vecEnemyLKP );
}
@ -196,62 +196,61 @@ void CISlave :: AlertSound( void )
//=========================================================
// IdleSound
//=========================================================
void CISlave :: IdleSound( void )
void CISlave::IdleSound( void )
{
if (RANDOM_LONG( 0, 2 ) == 0)
if( RANDOM_LONG( 0, 2 ) == 0 )
{
SENTENCEG_PlayRndSz(ENT(pev), "SLV_IDLE", 0.85, ATTN_NORM, 0, m_voicePitch);
SENTENCEG_PlayRndSz( ENT( pev ), "SLV_IDLE", 0.85, ATTN_NORM, 0, m_voicePitch );
}
#if 0
int side = RANDOM_LONG( 0, 1 ) * 2 - 1;
ClearBeams( );
ClearBeams();
ArmBeam( side );
UTIL_MakeAimVectors( pev->angles );
Vector vecSrc = pev->origin + gpGlobals->v_right * 2 * side;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc );
WRITE_BYTE(TE_DLIGHT);
WRITE_COORD(vecSrc.x); // X
WRITE_COORD(vecSrc.y); // Y
WRITE_COORD(vecSrc.z); // Z
WRITE_BYTE( TE_DLIGHT );
WRITE_COORD( vecSrc.x ); // X
WRITE_COORD( vecSrc.y ); // Y
WRITE_COORD( vecSrc.z ); // Z
WRITE_BYTE( 8 ); // radius * 0.1
WRITE_BYTE( 255 ); // r
WRITE_BYTE( 180 ); // g
WRITE_BYTE( 96 ); // b
WRITE_BYTE( 10 ); // time * 10
WRITE_BYTE( 0 ); // decay * 0.1
MESSAGE_END( );
MESSAGE_END();
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "debris/zap1.wav", 1, ATTN_NORM, 0, 100 );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "debris/zap1.wav", 1, ATTN_NORM, 0, 100 );
#endif
}
//=========================================================
// PainSound
//=========================================================
void CISlave :: PainSound( void )
void CISlave::PainSound( void )
{
if (RANDOM_LONG( 0, 2 ) == 0)
if( RANDOM_LONG( 0, 2 ) == 0 )
{
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pPainSounds[ RANDOM_LONG(0,ARRAYSIZE(pPainSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pPainSounds[RANDOM_LONG( 0, ARRAYSIZE( pPainSounds ) - 1 )], 1.0, ATTN_NORM, 0, m_voicePitch );
}
}
//=========================================================
// DieSound
//=========================================================
void CISlave :: DeathSound( void )
void CISlave::DeathSound( void )
{
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pDeathSounds[ RANDOM_LONG(0,ARRAYSIZE(pDeathSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pDeathSounds[RANDOM_LONG( 0, ARRAYSIZE( pDeathSounds ) - 1 )], 1.0, ATTN_NORM, 0, m_voicePitch );
}
//=========================================================
// ISoundMask - returns a bit mask indicating which types
// of sounds this monster regards.
//=========================================================
int CISlave :: ISoundMask ( void)
int CISlave::ISoundMask( void )
{
return bits_SOUND_WORLD |
bits_SOUND_COMBAT |
@ -261,7 +260,7 @@ int CISlave :: ISoundMask ( void)
void CISlave::Killed( entvars_t *pevAttacker, int iGib )
{
ClearBeams( );
ClearBeams();
CSquadMonster::Killed( pevAttacker, iGib );
}
@ -269,11 +268,11 @@ void CISlave::Killed( entvars_t *pevAttacker, int iGib )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CISlave :: SetYawSpeed ( void )
void CISlave::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_WALK:
ys = 50;
@ -298,7 +297,7 @@ void CISlave :: SetYawSpeed ( void )
//
// Returns number of events handled, 0 if none.
//=========================================================
void CISlave :: HandleAnimEvent( MonsterEvent_t *pEvent )
void CISlave::HandleAnimEvent( MonsterEvent_t *pEvent )
{
// ALERT( at_console, "event %d : %f\n", pEvent->event, pev->frame );
switch( pEvent->event )
@ -307,67 +306,66 @@ void CISlave :: HandleAnimEvent( MonsterEvent_t *pEvent )
{
// SOUND HERE!
CBaseEntity *pHurt = CheckTraceHullAttack( 70, gSkillData.slaveDmgClaw, DMG_SLASH );
if ( pHurt )
if( pHurt )
{
if ( pHurt->pev->flags & (FL_MONSTER|FL_CLIENT) )
if( pHurt->pev->flags & ( FL_MONSTER | FL_CLIENT ) )
{
pHurt->pev->punchangle.z = -18;
pHurt->pev->punchangle.x = 5;
}
// Play a random attack hit sound
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pAttackHitSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackHitSounds ) - 1 )], 1.0, ATTN_NORM, 0, m_voicePitch );
}
else
{
// Play a random attack miss sound
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pAttackMissSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackMissSounds ) - 1 )], 1.0, ATTN_NORM, 0, m_voicePitch );
}
}
break;
case ISLAVE_AE_CLAWRAKE:
{
CBaseEntity *pHurt = CheckTraceHullAttack( 70, gSkillData.slaveDmgClawrake, DMG_SLASH );
if ( pHurt )
if( pHurt )
{
if ( pHurt->pev->flags & (FL_MONSTER|FL_CLIENT) )
if( pHurt->pev->flags & ( FL_MONSTER | FL_CLIENT ) )
{
pHurt->pev->punchangle.z = -18;
pHurt->pev->punchangle.x = 5;
}
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackHitSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackHitSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, pAttackHitSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackHitSounds ) - 1 )], 1.0, ATTN_NORM, 0, m_voicePitch );
}
else
{
EMIT_SOUND_DYN ( ENT(pev), CHAN_WEAPON, pAttackMissSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackMissSounds)-1) ], 1.0, ATTN_NORM, 0, m_voicePitch );
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, pAttackMissSounds[RANDOM_LONG( 0, ARRAYSIZE( pAttackMissSounds ) - 1 )], 1.0, ATTN_NORM, 0, m_voicePitch );
}
}
break;
case ISLAVE_AE_ZAP_POWERUP:
{
// speed up attack when on hard
if (g_iSkillLevel == SKILL_HARD)
if( g_iSkillLevel == SKILL_HARD )
pev->framerate = 1.5;
UTIL_MakeAimVectors( pev->angles );
if (m_iBeams == 0)
if( m_iBeams == 0 )
{
Vector vecSrc = pev->origin + gpGlobals->v_forward * 2;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc );
WRITE_BYTE(TE_DLIGHT);
WRITE_COORD(vecSrc.x); // X
WRITE_COORD(vecSrc.y); // Y
WRITE_COORD(vecSrc.z); // Z
WRITE_BYTE( TE_DLIGHT );
WRITE_COORD( vecSrc.x ); // X
WRITE_COORD( vecSrc.y ); // Y
WRITE_COORD( vecSrc.z ); // Z
WRITE_BYTE( 12 ); // radius * 0.1
WRITE_BYTE( 255 ); // r
WRITE_BYTE( 180 ); // g
WRITE_BYTE( 96 ); // b
WRITE_BYTE( 20 / pev->framerate ); // time * 10
WRITE_BYTE( 0 ); // decay * 0.1
MESSAGE_END( );
MESSAGE_END();
}
if (m_hDead != NULL)
if( m_hDead != NULL )
{
WackBeam( -1, m_hDead );
WackBeam( 1, m_hDead );
@ -376,24 +374,24 @@ void CISlave :: HandleAnimEvent( MonsterEvent_t *pEvent )
{
ArmBeam( -1 );
ArmBeam( 1 );
BeamGlow( );
BeamGlow();
}
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "debris/zap4.wav", 1, ATTN_NORM, 0, 100 + m_iBeams * 10 );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "debris/zap4.wav", 1, ATTN_NORM, 0, 100 + m_iBeams * 10 );
pev->skin = m_iBeams / 2;
}
break;
case ISLAVE_AE_ZAP_SHOOT:
{
ClearBeams( );
ClearBeams();
if (m_hDead != NULL)
if( m_hDead != NULL )
{
Vector vecDest = m_hDead->pev->origin + Vector( 0, 0, 38 );
TraceResult trace;
UTIL_TraceHull( vecDest, vecDest, dont_ignore_monsters, human_hull, m_hDead->edict(), &trace );
if ( !trace.fStartSolid )
if( !trace.fStartSolid )
{
CBaseEntity *pNew = Create( "monster_alien_slave", m_hDead->pev->origin, m_hDead->pev->angles );
CBaseMonster *pNewMonster = pNew->MyMonsterPointer( );
@ -401,7 +399,7 @@ void CISlave :: HandleAnimEvent( MonsterEvent_t *pEvent )
WackBeam( -1, pNew );
WackBeam( 1, pNew );
UTIL_Remove( m_hDead );
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, RANDOM_LONG( 130, 160 ) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, RANDOM_LONG( 130, 160 ) );
/*
CBaseEntity *pEffect = Create( "test_effect", pNew->Center(), pev->angles );
pEffect->Use( this, this, USE_ON, 1 );
@ -416,16 +414,16 @@ void CISlave :: HandleAnimEvent( MonsterEvent_t *pEvent )
ZapBeam( -1 );
ZapBeam( 1 );
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, RANDOM_LONG( 130, 160 ) );
// STOP_SOUND( ENT(pev), CHAN_WEAPON, "debris/zap4.wav" );
ApplyMultiDamage(pev, pev);
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "hassault/hw_shoot1.wav", 1, ATTN_NORM, 0, RANDOM_LONG( 130, 160 ) );
// STOP_SOUND( ENT( pev ), CHAN_WEAPON, "debris/zap4.wav" );
ApplyMultiDamage( pev, pev );
m_flNextAttack = gpGlobals->time + RANDOM_FLOAT( 0.5, 4.0 );
}
break;
case ISLAVE_AE_ZAP_DONE:
{
ClearBeams( );
ClearBeams();
}
break;
default:
@ -437,9 +435,9 @@ void CISlave :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// CheckRangeAttack1 - normal beam attack
//=========================================================
BOOL CISlave :: CheckRangeAttack1 ( float flDot, float flDist )
BOOL CISlave::CheckRangeAttack1( float flDot, float flDist )
{
if (m_flNextAttack > gpGlobals->time)
if( m_flNextAttack > gpGlobals->time )
{
return FALSE;
}
@ -450,11 +448,11 @@ BOOL CISlave :: CheckRangeAttack1 ( float flDot, float flDist )
//=========================================================
// CheckRangeAttack2 - check bravery and try to resurect dead comrades
//=========================================================
BOOL CISlave :: CheckRangeAttack2 ( float flDot, float flDist )
BOOL CISlave::CheckRangeAttack2( float flDot, float flDist )
{
return FALSE;
if (m_flNextAttack > gpGlobals->time)
if( m_flNextAttack > gpGlobals->time )
{
return FALSE;
}
@ -463,17 +461,17 @@ BOOL CISlave :: CheckRangeAttack2 ( float flDot, float flDist )
m_iBravery = 0;
CBaseEntity *pEntity = NULL;
while ((pEntity = UTIL_FindEntityByClassname( pEntity, "monster_alien_slave" )) != NULL)
while( ( pEntity = UTIL_FindEntityByClassname( pEntity, "monster_alien_slave" ) ) != NULL )
{
TraceResult tr;
UTIL_TraceLine( EyePosition( ), pEntity->EyePosition( ), ignore_monsters, ENT(pev), &tr );
if (tr.flFraction == 1.0 || tr.pHit == pEntity->edict())
UTIL_TraceLine( EyePosition(), pEntity->EyePosition(), ignore_monsters, ENT( pev ), &tr );
if( tr.flFraction == 1.0 || tr.pHit == pEntity->edict() )
{
if (pEntity->pev->deadflag == DEAD_DEAD)
if( pEntity->pev->deadflag == DEAD_DEAD )
{
float d = (pev->origin - pEntity->pev->origin).Length();
if (d < flDist)
float d = ( pev->origin - pEntity->pev->origin ).Length();
if( d < flDist )
{
m_hDead = pEntity;
flDist = d;
@ -486,7 +484,7 @@ BOOL CISlave :: CheckRangeAttack2 ( float flDot, float flDist )
}
}
}
if (m_hDead != NULL)
if( m_hDead != NULL )
return TRUE;
else
return FALSE;
@ -495,29 +493,29 @@ BOOL CISlave :: CheckRangeAttack2 ( float flDot, float flDist )
//=========================================================
// StartTask
//=========================================================
void CISlave :: StartTask ( Task_t *pTask )
void CISlave::StartTask( Task_t *pTask )
{
ClearBeams( );
ClearBeams();
CSquadMonster :: StartTask ( pTask );
CSquadMonster::StartTask( pTask );
}
//=========================================================
// Spawn
//=========================================================
void CISlave :: Spawn()
void CISlave::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/islave.mdl");
UTIL_SetSize(pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX);
SET_MODEL( ENT( pev ), "models/islave.mdl" );
UTIL_SetSize( pev, VEC_HUMAN_HULL_MIN, VEC_HUMAN_HULL_MAX );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->effects = 0;
pev->health = gSkillData.slaveHealth;
pev->view_ofs = Vector ( 0, 0, 64 );// position of the eyes relative to monster's origin.
pev->view_ofs = Vector( 0, 0, 64 );// position of the eyes relative to monster's origin.
m_flFieldOfView = VIEW_FIELD_WIDE; // NOTE: we need a wide field of view so npc will notice player and say hello
m_MonsterState = MONSTERSTATE_NONE;
m_afCapability = bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_RANGE_ATTACK2 | bits_CAP_DOORS_GROUP;
@ -530,31 +528,31 @@ void CISlave :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CISlave :: Precache()
void CISlave::Precache()
{
int i;
PRECACHE_MODEL("models/islave.mdl");
PRECACHE_MODEL("sprites/lgtning.spr");
PRECACHE_SOUND("debris/zap1.wav");
PRECACHE_SOUND("debris/zap4.wav");
PRECACHE_SOUND("weapons/electro4.wav");
PRECACHE_SOUND("hassault/hw_shoot1.wav");
PRECACHE_SOUND("zombie/zo_pain2.wav");
PRECACHE_SOUND("headcrab/hc_headbite.wav");
PRECACHE_SOUND("weapons/cbar_miss1.wav");
PRECACHE_MODEL( "models/islave.mdl" );
PRECACHE_MODEL( "sprites/lgtning.spr" );
PRECACHE_SOUND( "debris/zap1.wav" );
PRECACHE_SOUND( "debris/zap4.wav" );
PRECACHE_SOUND( "weapons/electro4.wav" );
PRECACHE_SOUND( "hassault/hw_shoot1.wav" );
PRECACHE_SOUND( "zombie/zo_pain2.wav" );
PRECACHE_SOUND( "headcrab/hc_headbite.wav" );
PRECACHE_SOUND( "weapons/cbar_miss1.wav" );
for ( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
PRECACHE_SOUND((char *)pAttackHitSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackHitSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackHitSounds[i] );
for ( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
PRECACHE_SOUND((char *)pAttackMissSounds[i]);
for( i = 0; i < ARRAYSIZE( pAttackMissSounds ); i++ )
PRECACHE_SOUND( (char *)pAttackMissSounds[i] );
for ( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
PRECACHE_SOUND((char *)pPainSounds[i]);
for( i = 0; i < ARRAYSIZE( pPainSounds ); i++ )
PRECACHE_SOUND((char *)pPainSounds[i] );
for ( i = 0; i < ARRAYSIZE( pDeathSounds ); i++ )
PRECACHE_SOUND((char *)pDeathSounds[i]);
for( i = 0; i < ARRAYSIZE( pDeathSounds ); i++ )
PRECACHE_SOUND( (char *)pDeathSounds[i] );
UTIL_PrecacheOther( "test_effect" );
}
@ -563,19 +561,19 @@ void CISlave :: Precache()
// TakeDamage - get provoked when injured
//=========================================================
int CISlave :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType)
int CISlave::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
// don't slash one of your own
if ((bitsDamageType & DMG_SLASH) && pevAttacker && IRelationship( Instance(pevAttacker) ) < R_DL)
if( ( bitsDamageType & DMG_SLASH ) && pevAttacker && IRelationship( Instance( pevAttacker ) ) < R_DL )
return 0;
m_afMemory |= bits_MEMORY_PROVOKED;
return CSquadMonster::TakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
return CSquadMonster::TakeDamage( pevInflictor, pevAttacker, flDamage, bitsDamageType );
}
void CISlave::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
{
if (bitsDamageType & DMG_SHOCK)
if( bitsDamageType & DMG_SHOCK )
return;
CSquadMonster::TraceAttack( pevAttacker, flDamage, vecDir, ptr, bitsDamageType );
@ -616,49 +614,49 @@ IMPLEMENT_CUSTOM_SCHEDULES( CISlave, CSquadMonster )
//=========================================================
//=========================================================
Schedule_t *CISlave :: GetSchedule( void )
Schedule_t *CISlave::GetSchedule( void )
{
ClearBeams( );
ClearBeams();
/*
if (pev->spawnflags)
if( pev->spawnflags )
{
pev->spawnflags = 0;
return GetScheduleOfType( SCHED_RELOAD );
}
*/
if ( HasConditions( bits_COND_HEAR_SOUND ) )
if( HasConditions( bits_COND_HEAR_SOUND ) )
{
CSound *pSound;
pSound = PBestSound();
ASSERT( pSound != NULL );
if ( pSound && (pSound->m_iType & bits_SOUND_DANGER) )
if( pSound && ( pSound->m_iType & bits_SOUND_DANGER ) )
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_BEST_SOUND );
if ( pSound->m_iType & bits_SOUND_COMBAT )
if( pSound->m_iType & bits_SOUND_COMBAT )
m_afMemory |= bits_MEMORY_PROVOKED;
}
switch (m_MonsterState)
switch( m_MonsterState )
{
case MONSTERSTATE_COMBAT:
// dead enemy
if ( HasConditions( bits_COND_ENEMY_DEAD ) )
if( HasConditions( bits_COND_ENEMY_DEAD ) )
{
// call base class, all code to handle dead enemies is centralized there.
return CBaseMonster :: GetSchedule();
return CBaseMonster::GetSchedule();
}
if (pev->health < 20 || m_iBravery < 0)
if( pev->health < 20 || m_iBravery < 0 )
{
if (!HasConditions( bits_COND_CAN_MELEE_ATTACK1 ))
if( !HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
{
m_failSchedule = SCHED_CHASE_ENEMY;
if (HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE))
if( HasConditions( bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )
{
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
}
if ( HasConditions ( bits_COND_SEE_ENEMY ) && HasConditions ( bits_COND_ENEMY_FACING_ME ) )
if( HasConditions( bits_COND_SEE_ENEMY ) && HasConditions( bits_COND_ENEMY_FACING_ME ) )
{
// ALERT( at_console, "exposed\n");
return GetScheduleOfType( SCHED_TAKE_COVER_FROM_ENEMY );
@ -669,17 +667,17 @@ Schedule_t *CISlave :: GetSchedule( void )
default:
break;
}
return CSquadMonster::GetSchedule( );
return CSquadMonster::GetSchedule();
}
Schedule_t *CISlave :: GetScheduleOfType ( int Type )
Schedule_t *CISlave::GetScheduleOfType( int Type )
{
switch( Type )
{
case SCHED_FAIL:
if (HasConditions( bits_COND_CAN_MELEE_ATTACK1 ))
if( HasConditions( bits_COND_CAN_MELEE_ATTACK1 ) )
{
return CSquadMonster :: GetScheduleOfType( SCHED_MELEE_ATTACK1 ); ;
return CSquadMonster::GetScheduleOfType( SCHED_MELEE_ATTACK1 );
}
break;
case SCHED_RANGE_ATTACK1:
@ -687,30 +685,29 @@ Schedule_t *CISlave :: GetScheduleOfType ( int Type )
case SCHED_RANGE_ATTACK2:
return slSlaveAttack1;
}
return CSquadMonster :: GetScheduleOfType( Type );
return CSquadMonster::GetScheduleOfType( Type );
}
//=========================================================
// ArmBeam - small beam from arm to nearby geometry
//=========================================================
void CISlave :: ArmBeam( int side )
void CISlave::ArmBeam( int side )
{
TraceResult tr;
float flDist = 1.0;
if (m_iBeams >= ISLAVE_MAX_BEAMS)
if( m_iBeams >= ISLAVE_MAX_BEAMS )
return;
UTIL_MakeAimVectors( pev->angles );
Vector vecSrc = pev->origin + gpGlobals->v_up * 36 + gpGlobals->v_right * side * 16 + gpGlobals->v_forward * 32;
for (int i = 0; i < 3; i++)
for( int i = 0; i < 3; i++ )
{
Vector vecAim = gpGlobals->v_right * side * RANDOM_FLOAT( 0, 1 ) + gpGlobals->v_up * RANDOM_FLOAT( -1, 1 );
TraceResult tr1;
UTIL_TraceLine ( vecSrc, vecSrc + vecAim * 512, dont_ignore_monsters, ENT( pev ), &tr1);
if (flDist > tr1.flFraction)
UTIL_TraceLine( vecSrc, vecSrc + vecAim * 512, dont_ignore_monsters, ENT( pev ), &tr1 );
if( flDist > tr1.flFraction )
{
tr = tr1;
flDist = tr.flFraction;
@ -718,16 +715,16 @@ void CISlave :: ArmBeam( int side )
}
// Couldn't find anything close enough
if ( flDist == 1.0 )
if( flDist == 1.0 )
return;
DecalGunshot( &tr, BULLET_PLAYER_CROWBAR );
m_pBeam[m_iBeams] = CBeam::BeamCreate( "sprites/lgtning.spr", 30 );
if (!m_pBeam[m_iBeams])
if( !m_pBeam[m_iBeams] )
return;
m_pBeam[m_iBeams]->PointEntInit( tr.vecEndPos, entindex( ) );
m_pBeam[m_iBeams]->PointEntInit( tr.vecEndPos, entindex() );
m_pBeam[m_iBeams]->SetEndAttachment( side < 0 ? 2 : 1 );
// m_pBeam[m_iBeams]->SetColor( 180, 255, 96 );
m_pBeam[m_iBeams]->SetColor( 96, 128, 16 );
@ -739,15 +736,15 @@ void CISlave :: ArmBeam( int side )
//=========================================================
// BeamGlow - brighten all beams
//=========================================================
void CISlave :: BeamGlow( )
void CISlave::BeamGlow()
{
int b = m_iBeams * 32;
if (b > 255)
if( b > 255 )
b = 255;
for (int i = 0; i < m_iBeams; i++)
for( int i = 0; i < m_iBeams; i++ )
{
if (m_pBeam[i]->GetBrightness() != 255)
if( m_pBeam[i]->GetBrightness() != 255 )
{
m_pBeam[i]->SetBrightness( b );
}
@ -757,22 +754,22 @@ void CISlave :: BeamGlow( )
//=========================================================
// WackBeam - regenerate dead colleagues
//=========================================================
void CISlave :: WackBeam( int side, CBaseEntity *pEntity )
void CISlave::WackBeam( int side, CBaseEntity *pEntity )
{
Vector vecDest;
float flDist = 1.0;
if (m_iBeams >= ISLAVE_MAX_BEAMS)
if( m_iBeams >= ISLAVE_MAX_BEAMS )
return;
if (pEntity == NULL)
if( pEntity == NULL )
return;
m_pBeam[m_iBeams] = CBeam::BeamCreate( "sprites/lgtning.spr", 30 );
if (!m_pBeam[m_iBeams])
if( !m_pBeam[m_iBeams] )
return;
m_pBeam[m_iBeams]->PointEntInit( pEntity->Center(), entindex( ) );
m_pBeam[m_iBeams]->PointEntInit( pEntity->Center(), entindex() );
m_pBeam[m_iBeams]->SetEndAttachment( side < 0 ? 2 : 1 );
m_pBeam[m_iBeams]->SetColor( 180, 255, 96 );
m_pBeam[m_iBeams]->SetBrightness( 255 );
@ -783,48 +780,48 @@ void CISlave :: WackBeam( int side, CBaseEntity *pEntity )
//=========================================================
// ZapBeam - heavy damage directly forward
//=========================================================
void CISlave :: ZapBeam( int side )
void CISlave::ZapBeam( int side )
{
Vector vecSrc, vecAim;
TraceResult tr;
CBaseEntity *pEntity;
if (m_iBeams >= ISLAVE_MAX_BEAMS)
if( m_iBeams >= ISLAVE_MAX_BEAMS )
return;
vecSrc = pev->origin + gpGlobals->v_up * 36;
vecAim = ShootAtEnemy( vecSrc );
float deflection = 0.01;
vecAim = vecAim + side * gpGlobals->v_right * RANDOM_FLOAT( 0, deflection ) + gpGlobals->v_up * RANDOM_FLOAT( -deflection, deflection );
UTIL_TraceLine ( vecSrc, vecSrc + vecAim * 1024, dont_ignore_monsters, ENT( pev ), &tr);
UTIL_TraceLine( vecSrc, vecSrc + vecAim * 1024, dont_ignore_monsters, ENT( pev ), &tr );
m_pBeam[m_iBeams] = CBeam::BeamCreate( "sprites/lgtning.spr", 50 );
if (!m_pBeam[m_iBeams])
if( !m_pBeam[m_iBeams] )
return;
m_pBeam[m_iBeams]->PointEntInit( tr.vecEndPos, entindex( ) );
m_pBeam[m_iBeams]->PointEntInit( tr.vecEndPos, entindex() );
m_pBeam[m_iBeams]->SetEndAttachment( side < 0 ? 2 : 1 );
m_pBeam[m_iBeams]->SetColor( 180, 255, 96 );
m_pBeam[m_iBeams]->SetBrightness( 255 );
m_pBeam[m_iBeams]->SetNoise( 20 );
m_iBeams++;
pEntity = CBaseEntity::Instance(tr.pHit);
if (pEntity != NULL && pEntity->pev->takedamage)
pEntity = CBaseEntity::Instance( tr.pHit );
if( pEntity != NULL && pEntity->pev->takedamage )
{
pEntity->TraceAttack( pev, gSkillData.slaveDmgZap, vecAim, &tr, DMG_SHOCK );
}
UTIL_EmitAmbientSound( ENT(pev), tr.vecEndPos, "weapons/electro4.wav", 0.5, ATTN_NORM, 0, RANDOM_LONG( 140, 160 ) );
UTIL_EmitAmbientSound( ENT( pev ), tr.vecEndPos, "weapons/electro4.wav", 0.5, ATTN_NORM, 0, RANDOM_LONG( 140, 160 ) );
}
//=========================================================
// ClearBeams - remove all beams
//=========================================================
void CISlave :: ClearBeams( )
void CISlave::ClearBeams()
{
for (int i = 0; i < ISLAVE_MAX_BEAMS; i++)
for( int i = 0; i < ISLAVE_MAX_BEAMS; i++ )
{
if (m_pBeam[i])
if( m_pBeam[i] )
{
UTIL_Remove( m_pBeam[i] );
m_pBeam[i] = NULL;
@ -833,5 +830,5 @@ void CISlave :: ClearBeams( )
m_iBeams = 0;
pev->skin = 0;
STOP_SOUND( ENT(pev), CHAN_WEAPON, "debris/zap4.wav" );
STOP_SOUND( ENT( pev ), CHAN_WEAPON, "debris/zap4.wav" );
}

114
dlls/items.cpp
View File

@ -34,18 +34,18 @@ extern int gmsgItemPickup;
class CWorldItem : public CBaseEntity
{
public:
void KeyValue(KeyValueData *pkvd );
void KeyValue( KeyValueData *pkvd );
void Spawn( void );
int m_iType;
};
LINK_ENTITY_TO_CLASS(world_items, CWorldItem)
LINK_ENTITY_TO_CLASS( world_items, CWorldItem )
void CWorldItem::KeyValue(KeyValueData *pkvd)
void CWorldItem::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "type"))
if( FStrEq( pkvd->szKeyName, "type" ) )
{
m_iType = atoi(pkvd->szValue);
m_iType = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
@ -56,7 +56,7 @@ void CWorldItem::Spawn( void )
{
CBaseEntity *pEntity = NULL;
switch (m_iType)
switch( m_iType )
{
case 44: // ITEM_BATTERY:
pEntity = CBaseEntity::Create( "item_battery", pev->origin, pev->angles );
@ -72,7 +72,7 @@ void CWorldItem::Spawn( void )
break;
}
if (!pEntity)
if( !pEntity )
{
ALERT( at_console, "unable to create world_item %d\n", m_iType );
}
@ -83,7 +83,7 @@ void CWorldItem::Spawn( void )
pEntity->pev->spawnflags = pev->spawnflags;
}
REMOVE_ENTITY(edict());
REMOVE_ENTITY( edict() );
}
void CItem::Spawn( void )
@ -91,10 +91,10 @@ void CItem::Spawn( void )
pev->movetype = MOVETYPE_TOSS;
pev->solid = SOLID_TRIGGER;
UTIL_SetOrigin( pev, pev->origin );
UTIL_SetSize(pev, Vector(-16, -16, 0), Vector(16, 16, 16));
UTIL_SetSize( pev, Vector( -16, -16, 0 ), Vector( 16, 16, 16 ) );
SetTouch( &CItem::ItemTouch );
if (DROP_TO_FLOOR(ENT(pev)) == 0)
if( DROP_TO_FLOOR(ENT( pev ) ) == 0 )
{
ALERT(at_error, "Item %s fell out of level at %f,%f,%f\n", STRING( pev->classname ), pev->origin.x, pev->origin.y, pev->origin.z);
UTIL_Remove( this );
@ -107,7 +107,7 @@ extern int gEvilImpulse101;
void CItem::ItemTouch( CBaseEntity *pOther )
{
// if it's not a player, ignore
if ( !pOther->IsPlayer() )
if( !pOther->IsPlayer() )
{
return;
}
@ -115,20 +115,20 @@ void CItem::ItemTouch( CBaseEntity *pOther )
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
// ok, a player is touching this item, but can he have it?
if ( !g_pGameRules->CanHaveItem( pPlayer, this ) )
if( !g_pGameRules->CanHaveItem( pPlayer, this ) )
{
// no? Ignore the touch.
return;
}
if (MyTouch( pPlayer ))
if( MyTouch( pPlayer ) )
{
SUB_UseTargets( pOther, USE_TOGGLE, 0 );
SetTouch( NULL );
// player grabbed the item.
g_pGameRules->PlayerGotItem( pPlayer, this );
if ( g_pGameRules->ItemShouldRespawn( this ) == GR_ITEM_RESPAWN_YES )
if( g_pGameRules->ItemShouldRespawn( this ) == GR_ITEM_RESPAWN_YES )
{
Respawn();
}
@ -137,7 +137,7 @@ void CItem::ItemTouch( CBaseEntity *pOther )
UTIL_Remove( this );
}
}
else if (gEvilImpulse101)
else if( gEvilImpulse101 )
{
UTIL_Remove( this );
}
@ -157,10 +157,10 @@ CBaseEntity* CItem::Respawn( void )
void CItem::Materialize( void )
{
if ( pev->effects & EF_NODRAW )
if( pev->effects & EF_NODRAW )
{
// changing from invisible state to visible.
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "items/suitchargeok1.wav", 1, ATTN_NORM, 0, 150 );
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "items/suitchargeok1.wav", 1, ATTN_NORM, 0, 150 );
pev->effects &= ~EF_NODRAW;
pev->effects |= EF_MUZZLEFLASH;
}
@ -174,77 +174,77 @@ class CItemSuit : public CItem
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_suit.mdl");
CItem::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_suit.mdl" );
CItem::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_suit.mdl");
PRECACHE_MODEL( "models/w_suit.mdl" );
}
BOOL MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer->pev->weapons & (1<<WEAPON_SUIT) )
if( pPlayer->pev->weapons & ( 1<<WEAPON_SUIT ) )
return FALSE;
if ( pev->spawnflags & SF_SUIT_SHORTLOGON )
EMIT_SOUND_SUIT(pPlayer->edict(), "!HEV_A0"); // short version of suit logon,
if( pev->spawnflags & SF_SUIT_SHORTLOGON )
EMIT_SOUND_SUIT( pPlayer->edict(), "!HEV_A0" ); // short version of suit logon,
else
EMIT_SOUND_SUIT(pPlayer->edict(), "!HEV_AAx"); // long version of suit logon
EMIT_SOUND_SUIT( pPlayer->edict(), "!HEV_AAx" ); // long version of suit logon
pPlayer->pev->weapons |= (1<<WEAPON_SUIT);
pPlayer->pev->weapons |= ( 1 << WEAPON_SUIT );
return TRUE;
}
};
LINK_ENTITY_TO_CLASS(item_suit, CItemSuit)
LINK_ENTITY_TO_CLASS( item_suit, CItemSuit )
class CItemBattery : public CItem
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_battery.mdl");
CItem::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_battery.mdl" );
CItem::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_battery.mdl");
PRECACHE_MODEL( "models/w_battery.mdl" );
PRECACHE_SOUND( "items/gunpickup2.wav" );
}
BOOL MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer->pev->deadflag != DEAD_NO )
if( pPlayer->pev->deadflag != DEAD_NO )
{
return FALSE;
}
if ((pPlayer->pev->armorvalue < MAX_NORMAL_BATTERY) &&
(pPlayer->pev->weapons & (1<<WEAPON_SUIT)))
if( ( pPlayer->pev->armorvalue < MAX_NORMAL_BATTERY ) &&
( pPlayer->pev->weapons & ( 1 << WEAPON_SUIT ) ) )
{
int pct;
char szcharge[64];
pPlayer->pev->armorvalue += gSkillData.batteryCapacity;
pPlayer->pev->armorvalue = min(pPlayer->pev->armorvalue, MAX_NORMAL_BATTERY);
pPlayer->pev->armorvalue = min( pPlayer->pev->armorvalue, MAX_NORMAL_BATTERY );
EMIT_SOUND( pPlayer->edict(), CHAN_ITEM, "items/gunpickup2.wav", 1, ATTN_NORM );
MESSAGE_BEGIN( MSG_ONE, gmsgItemPickup, NULL, pPlayer->pev );
WRITE_STRING( STRING(pev->classname) );
WRITE_STRING( STRING( pev->classname ) );
MESSAGE_END();
// Suit reports new power level
// For some reason this wasn't working in release build -- round it.
pct = (int)( (float)(pPlayer->pev->armorvalue * 100.0) * (1.0/MAX_NORMAL_BATTERY) + 0.5);
pct = (pct / 5);
if (pct > 0)
pct = (int)( (float)( pPlayer->pev->armorvalue * 100.0 ) * ( 1.0 / MAX_NORMAL_BATTERY ) + 0.5 );
pct = ( pct / 5 );
if( pct > 0 )
pct--;
sprintf( szcharge,"!HEV_%1dP", pct );
//EMIT_SOUND_SUIT(ENT(pev), szcharge);
pPlayer->SetSuitUpdate(szcharge, FALSE, SUIT_NEXT_IN_30SEC);
//EMIT_SOUND_SUIT( ENT( pev ), szcharge );
pPlayer->SetSuitUpdate( szcharge, FALSE, SUIT_NEXT_IN_30SEC);
return TRUE;
}
return FALSE;
@ -257,17 +257,17 @@ class CItemAntidote : public CItem
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_antidote.mdl");
CItem::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_antidote.mdl" );
CItem::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_antidote.mdl");
PRECACHE_MODEL( "models/w_antidote.mdl" );
}
BOOL MyTouch( CBasePlayer *pPlayer )
{
pPlayer->SetSuitUpdate("!HEV_DET4", FALSE, SUIT_NEXT_IN_1MIN);
pPlayer->SetSuitUpdate( "!HEV_DET4", FALSE, SUIT_NEXT_IN_1MIN );
pPlayer->m_rgItems[ITEM_ANTIDOTE] += 1;
return TRUE;
@ -280,13 +280,13 @@ class CItemSecurity : public CItem
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_security.mdl");
CItem::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_security.mdl" );
CItem::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_security.mdl");
PRECACHE_MODEL( "models/w_security.mdl" );
}
BOOL MyTouch( CBasePlayer *pPlayer )
{
@ -301,29 +301,29 @@ class CItemLongJump : public CItem
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_longjump.mdl");
CItem::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_longjump.mdl" );
CItem::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_longjump.mdl");
PRECACHE_MODEL( "models/w_longjump.mdl" );
}
BOOL MyTouch( CBasePlayer *pPlayer )
{
if ( pPlayer->m_fLongJump )
if( pPlayer->m_fLongJump )
{
return FALSE;
}
if ( ( pPlayer->pev->weapons & (1<<WEAPON_SUIT) ) )
if( ( pPlayer->pev->weapons & ( 1 << WEAPON_SUIT ) ) )
{
pPlayer->m_fLongJump = TRUE;// player now has longjump module
g_engfuncs.pfnSetPhysicsKeyValue( pPlayer->edict(), "slj", "1" );
MESSAGE_BEGIN( MSG_ONE, gmsgItemPickup, NULL, pPlayer->pev );
WRITE_STRING( STRING(pev->classname) );
WRITE_STRING( STRING( pev->classname ) );
MESSAGE_END();
EMIT_SOUND_SUIT( pPlayer->edict(), "!HEV_A1" ); // Play the longjump sound UNDONE: Kelly? correct sound?

8
dlls/items.h
View File

@ -19,10 +19,12 @@ class CItem : public CBaseEntity
{
public:
void Spawn( void );
CBaseEntity* Respawn( void );
CBaseEntity *Respawn( void );
void EXPORT ItemTouch( CBaseEntity *pOther );
void EXPORT Materialize( void );
virtual BOOL MyTouch( CBasePlayer *pPlayer ) { return FALSE; };
virtual BOOL MyTouch( CBasePlayer *pPlayer )
{
return FALSE;
};
};
#endif // ITEMS_H

69
dlls/lights.cpp
View File

@ -54,19 +54,19 @@ IMPLEMENT_SAVERESTORE( CLight, CPointEntity )
//
// Cache user-entity-field values until spawn is called.
//
void CLight :: KeyValue( KeyValueData* pkvd)
void CLight::KeyValue( KeyValueData* pkvd )
{
if (FStrEq(pkvd->szKeyName, "style"))
if( FStrEq(pkvd->szKeyName, "style" ) )
{
m_iStyle = atoi(pkvd->szValue);
m_iStyle = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pitch"))
else if( FStrEq(pkvd->szKeyName, "pitch" ) )
{
pev->angles.x = atof(pkvd->szValue);
pev->angles.x = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "pattern"))
else if( FStrEq(pkvd->szKeyName, "pattern" ) )
{
m_iszPattern = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
@ -84,45 +84,46 @@ Default style is 0
If targeted, it will toggle between on or off.
*/
void CLight :: Spawn( void )
void CLight::Spawn( void )
{
if (FStringNull(pev->targetname))
{ // inert light
REMOVE_ENTITY(ENT(pev));
if( FStringNull( pev->targetname ) )
{
// inert light
REMOVE_ENTITY(ENT( pev ) );
return;
}
if (m_iStyle >= 32)
if( m_iStyle >= 32 )
{
//CHANGE_METHOD(ENT(pev), em_use, light_use);
if (FBitSet(pev->spawnflags, SF_LIGHT_START_OFF))
LIGHT_STYLE(m_iStyle, "a");
else if (m_iszPattern)
LIGHT_STYLE(m_iStyle, (char *)STRING( m_iszPattern ));
if( FBitSet( pev->spawnflags, SF_LIGHT_START_OFF ) )
LIGHT_STYLE( m_iStyle, "a" );
else if( m_iszPattern )
LIGHT_STYLE( m_iStyle, (char *)STRING( m_iszPattern ) );
else
LIGHT_STYLE(m_iStyle, "m");
LIGHT_STYLE( m_iStyle, "m" );
}
}
void CLight :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CLight::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if (m_iStyle >= 32)
if( m_iStyle >= 32 )
{
if ( !ShouldToggle( useType, !FBitSet(pev->spawnflags, SF_LIGHT_START_OFF) ) )
if( !ShouldToggle( useType, !FBitSet( pev->spawnflags, SF_LIGHT_START_OFF ) ) )
return;
if (FBitSet(pev->spawnflags, SF_LIGHT_START_OFF))
if( FBitSet( pev->spawnflags, SF_LIGHT_START_OFF ) )
{
if (m_iszPattern)
LIGHT_STYLE(m_iStyle, (char *)STRING( m_iszPattern ));
if( m_iszPattern )
LIGHT_STYLE( m_iStyle, (char *)STRING( m_iszPattern ) );
else
LIGHT_STYLE(m_iStyle, "m");
ClearBits(pev->spawnflags, SF_LIGHT_START_OFF);
LIGHT_STYLE( m_iStyle, "m" );
ClearBits( pev->spawnflags, SF_LIGHT_START_OFF );
}
else
{
LIGHT_STYLE(m_iStyle, "a");
SetBits(pev->spawnflags, SF_LIGHT_START_OFF);
LIGHT_STYLE( m_iStyle, "a" );
SetBits( pev->spawnflags, SF_LIGHT_START_OFF );
}
}
}
@ -143,20 +144,20 @@ LINK_ENTITY_TO_CLASS( light_environment, CEnvLight )
void CEnvLight::KeyValue( KeyValueData* pkvd )
{
if (FStrEq(pkvd->szKeyName, "_light"))
if( FStrEq(pkvd->szKeyName, "_light" ) )
{
int r, g, b, v, j;
char szColor[64];
j = sscanf( pkvd->szValue, "%d %d %d %d\n", &r, &g, &b, &v );
if (j == 1)
if( j == 1 )
{
g = b = r;
}
else if (j == 4)
else if( j == 4 )
{
r = r * (v / 255.0);
g = g * (v / 255.0);
b = b * (v / 255.0);
r = r * ( v / 255.0 );
g = g * ( v / 255.0 );
b = b * ( v / 255.0 );
}
// simulate qrad direct, ambient,and gamma adjustments, as well as engine scaling
@ -178,7 +179,7 @@ void CEnvLight::KeyValue( KeyValueData* pkvd )
}
}
void CEnvLight :: Spawn( void )
void CEnvLight::Spawn( void )
{
char szVector[64];
UTIL_MakeAimVectors( pev->angles );
@ -190,5 +191,5 @@ void CEnvLight :: Spawn( void )
sprintf( szVector, "%f", gpGlobals->v_forward.z );
CVAR_SET_STRING( "sv_skyvec_z", szVector );
CLight::Spawn( );
CLight::Spawn();
}

68
dlls/monstermaker.cpp
View File

@ -37,10 +37,10 @@ public:
void Spawn( void );
void Precache( void );
void KeyValue( KeyValueData* pkvd);
void EXPORT ToggleUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT CyclicUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT MakerThink ( void );
void DeathNotice ( entvars_t *pevChild );// monster maker children use this to tell the monster maker that they have died.
void EXPORT ToggleUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT CyclicUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT MakerThink( void );
void DeathNotice( entvars_t *pevChild );// monster maker children use this to tell the monster maker that they have died.
void MakeMonster( void );
virtual int Save( CSave &save );
@ -76,19 +76,19 @@ TYPEDESCRIPTION CMonsterMaker::m_SaveData[] =
IMPLEMENT_SAVERESTORE( CMonsterMaker, CBaseMonster )
void CMonsterMaker :: KeyValue( KeyValueData *pkvd )
void CMonsterMaker::KeyValue( KeyValueData *pkvd )
{
if ( FStrEq(pkvd->szKeyName, "monstercount") )
if( FStrEq( pkvd->szKeyName, "monstercount" ) )
{
m_cNumMonsters = atoi(pkvd->szValue);
m_cNumMonsters = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if ( FStrEq(pkvd->szKeyName, "m_imaxlivechildren") )
else if( FStrEq( pkvd->szKeyName, "m_imaxlivechildren" ) )
{
m_iMaxLiveChildren = atoi(pkvd->szValue);
m_iMaxLiveChildren = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if ( FStrEq(pkvd->szKeyName, "monstertype") )
else if( FStrEq( pkvd->szKeyName, "monstertype" ) )
{
m_iszMonsterClassname = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
@ -97,15 +97,15 @@ void CMonsterMaker :: KeyValue( KeyValueData *pkvd )
CBaseMonster::KeyValue( pkvd );
}
void CMonsterMaker :: Spawn( )
void CMonsterMaker::Spawn()
{
pev->solid = SOLID_NOT;
m_cLiveChildren = 0;
Precache();
if ( !FStringNull ( pev->targetname ) )
if( !FStringNull( pev->targetname ) )
{
if ( pev->spawnflags & SF_MONSTERMAKER_CYCLIC )
if( pev->spawnflags & SF_MONSTERMAKER_CYCLIC )
{
SetUse( &CMonsterMaker::CyclicUse );// drop one monster each time we fire
}
@ -114,7 +114,7 @@ void CMonsterMaker :: Spawn( )
SetUse( &CMonsterMaker::ToggleUse );// so can be turned on/off
}
if ( FBitSet ( pev->spawnflags, SF_MONSTERMAKER_START_ON ) )
if( FBitSet( pev->spawnflags, SF_MONSTERMAKER_START_ON ) )
{
// start making monsters as soon as monstermaker spawns
m_fActive = TRUE;
@ -135,7 +135,7 @@ void CMonsterMaker :: Spawn( )
SetThink( &CMonsterMaker::MakerThink );
}
if ( m_cNumMonsters == 1 )
if( m_cNumMonsters == 1 )
{
m_fFadeChildren = FALSE;
}
@ -147,7 +147,7 @@ void CMonsterMaker :: Spawn( )
m_flGround = 0;
}
void CMonsterMaker :: Precache( void )
void CMonsterMaker::Precache( void )
{
CBaseMonster::Precache();
@ -162,18 +162,18 @@ void CMonsterMaker::MakeMonster( void )
edict_t *pent;
entvars_t *pevCreate;
if ( m_iMaxLiveChildren > 0 && m_cLiveChildren >= m_iMaxLiveChildren )
if( m_iMaxLiveChildren > 0 && m_cLiveChildren >= m_iMaxLiveChildren )
{
// not allowed to make a new one yet. Too many live ones out right now.
return;
}
if ( !m_flGround )
if( !m_flGround )
{
// set altitude. Now that I'm activated, any breakables, etc should be out from under me.
TraceResult tr;
UTIL_TraceLine ( pev->origin, pev->origin - Vector ( 0, 0, 2048 ), ignore_monsters, ENT(pev), &tr );
UTIL_TraceLine( pev->origin, pev->origin - Vector( 0, 0, 2048 ), ignore_monsters, ENT( pev ), &tr );
m_flGround = tr.vecEndPos.z;
}
@ -183,8 +183,8 @@ void CMonsterMaker::MakeMonster( void )
mins.z = m_flGround;
CBaseEntity *pList[2];
int count = UTIL_EntitiesInBox( pList, 2, mins, maxs, FL_CLIENT|FL_MONSTER );
if ( count )
int count = UTIL_EntitiesInBox( pList, 2, mins, maxs, FL_CLIENT | FL_MONSTER );
if( count )
{
// don't build a stack of monsters!
return;
@ -192,17 +192,17 @@ void CMonsterMaker::MakeMonster( void )
pent = CREATE_NAMED_ENTITY( m_iszMonsterClassname );
if ( FNullEnt( pent ) )
if( FNullEnt( pent ) )
{
ALERT ( at_console, "NULL Ent in MonsterMaker!\n" );
return;
}
// If I have a target, fire!
if ( !FStringNull ( pev->target ) )
if( !FStringNull( pev->target ) )
{
// delay already overloaded for this entity, so can't call SUB_UseTargets()
FireTargets( STRING(pev->target), this, this, USE_TOGGLE, 0 );
FireTargets( STRING( pev->target ), this, this, USE_TOGGLE, 0 );
}
pevCreate = VARS( pent );
@ -211,13 +211,13 @@ void CMonsterMaker::MakeMonster( void )
SetBits( pevCreate->spawnflags, SF_MONSTER_FALL_TO_GROUND );
// Children hit monsterclip brushes
if ( pev->spawnflags & SF_MONSTERMAKER_MONSTERCLIP )
if( pev->spawnflags & SF_MONSTERMAKER_MONSTERCLIP )
SetBits( pevCreate->spawnflags, SF_MONSTER_HITMONSTERCLIP );
DispatchSpawn( ENT( pevCreate ) );
pevCreate->owner = edict();
if ( !FStringNull( pev->netname ) )
if( !FStringNull( pev->netname ) )
{
// if I have a netname (overloaded), give the child monster that name as a targetname
pevCreate->targetname = pev->netname;
@ -226,7 +226,7 @@ void CMonsterMaker::MakeMonster( void )
m_cLiveChildren++;// count this monster
m_cNumMonsters--;
if ( m_cNumMonsters == 0 )
if( m_cNumMonsters == 0 )
{
// Disable this forever. Don't kill it because it still gets death notices
SetThink( NULL );
@ -238,7 +238,7 @@ void CMonsterMaker::MakeMonster( void )
// CyclicUse - drops one monster from the monstermaker
// each time we call this.
//=========================================================
void CMonsterMaker::CyclicUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CMonsterMaker::CyclicUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
MakeMonster();
}
@ -246,12 +246,12 @@ void CMonsterMaker::CyclicUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, U
//=========================================================
// ToggleUse - activates/deactivates the monster maker
//=========================================================
void CMonsterMaker :: ToggleUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CMonsterMaker::ToggleUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( !ShouldToggle( useType, m_fActive ) )
if( !ShouldToggle( useType, m_fActive ) )
return;
if ( m_fActive )
if( m_fActive )
{
m_fActive = FALSE;
SetThink( NULL );
@ -268,7 +268,7 @@ void CMonsterMaker :: ToggleUse ( CBaseEntity *pActivator, CBaseEntity *pCaller,
//=========================================================
// MakerThink - creates a new monster every so often
//=========================================================
void CMonsterMaker :: MakerThink ( void )
void CMonsterMaker::MakerThink( void )
{
pev->nextthink = gpGlobals->time + m_flDelay;
@ -277,12 +277,12 @@ void CMonsterMaker :: MakerThink ( void )
//=========================================================
//=========================================================
void CMonsterMaker :: DeathNotice ( entvars_t *pevChild )
void CMonsterMaker::DeathNotice( entvars_t *pevChild )
{
// ok, we've gotten the deathnotice from our child, now clear out its owner if we don't want it to fade.
m_cLiveChildren--;
if ( !m_fFadeChildren )
if( !m_fFadeChildren )
{
pevChild->owner = NULL;
}

1185
dlls/monsters.cpp
View File

File diff suppressed because it is too large Load Diff

58
dlls/monsterstate.cpp
View File

@ -29,12 +29,12 @@
//=========================================================
// SetState
//=========================================================
void CBaseMonster :: SetState ( MONSTERSTATE State )
void CBaseMonster::SetState( MONSTERSTATE State )
{
/*
if ( State != m_MonsterState )
if( State != m_MonsterState )
{
ALERT ( at_aiconsole, "State Changed to %d\n", State );
ALERT( at_aiconsole, "State Changed to %d\n", State );
}
*/
switch( State )
@ -42,10 +42,10 @@ void CBaseMonster :: SetState ( MONSTERSTATE State )
// Drop enemy pointers when going to idle
case MONSTERSTATE_IDLE:
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
m_hEnemy = NULL;// not allowed to have an enemy anymore.
ALERT ( at_aiconsole, "Stripped\n" );
ALERT( at_aiconsole, "Stripped\n" );
}
break;
default:
@ -59,19 +59,19 @@ void CBaseMonster :: SetState ( MONSTERSTATE State )
//=========================================================
// RunAI
//=========================================================
void CBaseMonster :: RunAI ( void )
void CBaseMonster::RunAI( void )
{
// to test model's eye height
//UTIL_ParticleEffect ( pev->origin + pev->view_ofs, g_vecZero, 255, 10 );
// IDLE sound permitted in ALERT state is because monsters were silent in ALERT state. Only play IDLE sound in IDLE state
// once we have sounds for that state.
if ( ( m_MonsterState == MONSTERSTATE_IDLE || m_MonsterState == MONSTERSTATE_ALERT ) && RANDOM_LONG(0,99) == 0 && !(pev->flags & SF_MONSTER_GAG) )
if( ( m_MonsterState == MONSTERSTATE_IDLE || m_MonsterState == MONSTERSTATE_ALERT ) && RANDOM_LONG( 0, 99 ) == 0 && !( pev->flags & SF_MONSTER_GAG ) )
{
IdleSound();
}
if ( m_MonsterState != MONSTERSTATE_NONE &&
if( m_MonsterState != MONSTERSTATE_NONE &&
m_MonsterState != MONSTERSTATE_PRONE &&
m_MonsterState != MONSTERSTATE_DEAD )// don't bother with this crap if monster is prone.
{
@ -80,7 +80,7 @@ void CBaseMonster :: RunAI ( void )
// things will happen before the player gets there!
// UPDATE: We now let COMBAT state monsters think and act fully outside of player PVS. This allows the player to leave
// an area where monsters are fighting, and the fight will continue.
if ( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) || ( m_MonsterState == MONSTERSTATE_COMBAT ) )
if( !FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) || ( m_MonsterState == MONSTERSTATE_COMBAT ) )
{
Look( m_flDistLook );
Listen();// check for audible sounds.
@ -92,7 +92,7 @@ void CBaseMonster :: RunAI ( void )
}
// do these calculations if monster has an enemy.
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
CheckEnemy( m_hEnemy );
}
@ -116,14 +116,14 @@ void CBaseMonster :: RunAI ( void )
// GetIdealState - surveys the Conditions information available
// and finds the best new state for a monster.
//=========================================================
MONSTERSTATE CBaseMonster :: GetIdealState ( void )
MONSTERSTATE CBaseMonster::GetIdealState( void )
{
int iConditions;
iConditions = IScheduleFlags();
// If no schedule conditions, the new ideal state is probably the reason we're in here.
switch ( m_MonsterState )
switch( m_MonsterState )
{
case MONSTERSTATE_IDLE:
/*
@ -134,36 +134,36 @@ MONSTERSTATE CBaseMonster :: GetIdealState ( void )
IDLE goes to HUNT upon smelling food
*/
{
if ( iConditions & bits_COND_NEW_ENEMY )
if( iConditions & bits_COND_NEW_ENEMY )
{
// new enemy! This means an idle monster has seen someone it dislikes, or
// that a monster in combat has found a more suitable target to attack
m_IdealMonsterState = MONSTERSTATE_COMBAT;
}
else if ( iConditions & bits_COND_LIGHT_DAMAGE )
else if( iConditions & bits_COND_LIGHT_DAMAGE )
{
MakeIdealYaw ( m_vecEnemyLKP );
MakeIdealYaw( m_vecEnemyLKP );
m_IdealMonsterState = MONSTERSTATE_ALERT;
}
else if ( iConditions & bits_COND_HEAVY_DAMAGE )
else if( iConditions & bits_COND_HEAVY_DAMAGE )
{
MakeIdealYaw ( m_vecEnemyLKP );
MakeIdealYaw( m_vecEnemyLKP );
m_IdealMonsterState = MONSTERSTATE_ALERT;
}
else if ( iConditions & bits_COND_HEAR_SOUND )
else if( iConditions & bits_COND_HEAR_SOUND )
{
CSound *pSound;
pSound = PBestSound();
ASSERT( pSound != NULL );
if ( pSound )
if( pSound )
{
MakeIdealYaw ( pSound->m_vecOrigin );
if ( pSound->m_iType & (bits_SOUND_COMBAT|bits_SOUND_DANGER) )
MakeIdealYaw( pSound->m_vecOrigin );
if( pSound->m_iType & ( bits_SOUND_COMBAT|bits_SOUND_DANGER ) )
m_IdealMonsterState = MONSTERSTATE_ALERT;
}
}
else if ( iConditions & (bits_COND_SMELL | bits_COND_SMELL_FOOD) )
else if( iConditions & ( bits_COND_SMELL | bits_COND_SMELL_FOOD ) )
{
m_IdealMonsterState = MONSTERSTATE_ALERT;
}
@ -177,18 +177,18 @@ MONSTERSTATE CBaseMonster :: GetIdealState ( void )
ALERT goes to HUNT upon hearing a noise
*/
{
if ( iConditions & (bits_COND_NEW_ENEMY|bits_COND_SEE_ENEMY) )
if( iConditions & ( bits_COND_NEW_ENEMY | bits_COND_SEE_ENEMY ) )
{
// see an enemy we MUST attack
m_IdealMonsterState = MONSTERSTATE_COMBAT;
}
else if ( iConditions & bits_COND_HEAR_SOUND )
else if( iConditions & bits_COND_HEAR_SOUND )
{
m_IdealMonsterState = MONSTERSTATE_ALERT;
CSound *pSound = PBestSound();
ASSERT( pSound != NULL );
if ( pSound )
MakeIdealYaw ( pSound->m_vecOrigin );
if( pSound )
MakeIdealYaw( pSound->m_vecOrigin );
}
break;
}
@ -198,11 +198,11 @@ MONSTERSTATE CBaseMonster :: GetIdealState ( void )
COMBAT goes to ALERT upon death of enemy
*/
{
if ( m_hEnemy == NULL )
if( m_hEnemy == NULL )
{
m_IdealMonsterState = MONSTERSTATE_ALERT;
// pev->effects = EF_BRIGHTFIELD;
ALERT ( at_aiconsole, "***Combat state with no enemy!\n" );
ALERT( at_aiconsole, "***Combat state with no enemy!\n" );
}
break;
}
@ -217,7 +217,7 @@ MONSTERSTATE CBaseMonster :: GetIdealState ( void )
break;
}
case MONSTERSTATE_SCRIPT:
if ( iConditions & (bits_COND_TASK_FAILED|bits_COND_LIGHT_DAMAGE|bits_COND_HEAVY_DAMAGE) )
if( iConditions & ( bits_COND_TASK_FAILED | bits_COND_LIGHT_DAMAGE | bits_COND_HEAVY_DAMAGE ) )
{
ExitScriptedSequence(); // This will set the ideal state
}

128
dlls/mortar.cpp
View File

@ -36,7 +36,7 @@ public:
void KeyValue( KeyValueData *pkvd );
// Bmodels don't go across transitions
virtual int ObjectCaps( void ) { return CBaseToggle :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int ObjectCaps( void ) { return CBaseToggle::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
@ -67,55 +67,55 @@ TYPEDESCRIPTION CFuncMortarField::m_SaveData[] =
IMPLEMENT_SAVERESTORE( CFuncMortarField, CBaseToggle )
void CFuncMortarField :: KeyValue( KeyValueData *pkvd )
void CFuncMortarField::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "m_iszXController"))
if( FStrEq( pkvd->szKeyName, "m_iszXController" ) )
{
m_iszXController = ALLOC_STRING(pkvd->szValue);
m_iszXController = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iszYController"))
else if( FStrEq( pkvd->szKeyName, "m_iszYController" ) )
{
m_iszYController = ALLOC_STRING(pkvd->szValue);
m_iszYController = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_flSpread"))
else if( FStrEq( pkvd->szKeyName, "m_flSpread" ) )
{
m_flSpread = atof(pkvd->szValue);
m_flSpread = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_fControl"))
else if( FStrEq( pkvd->szKeyName, "m_fControl" ) )
{
m_fControl = atoi(pkvd->szValue);
m_fControl = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "m_iCount"))
else if( FStrEq( pkvd->szKeyName, "m_iCount" ) )
{
m_iCount = atoi(pkvd->szValue);
m_iCount = atoi( pkvd->szValue );
pkvd->fHandled = TRUE;
}
}
// Drop bombs from above
void CFuncMortarField :: Spawn( void )
void CFuncMortarField::Spawn( void )
{
pev->solid = SOLID_NOT;
SET_MODEL(ENT(pev), STRING(pev->model)); // set size and link into world
SET_MODEL( ENT( pev ), STRING( pev->model ) ); // set size and link into world
pev->movetype = MOVETYPE_NONE;
SetBits( pev->effects, EF_NODRAW );
SetUse( &CFuncMortarField::FieldUse );
Precache();
}
void CFuncMortarField :: Precache( void )
void CFuncMortarField::Precache( void )
{
PRECACHE_SOUND ("weapons/mortar.wav");
PRECACHE_SOUND ("weapons/mortarhit.wav");
PRECACHE_SOUND( "weapons/mortar.wav" );
PRECACHE_SOUND( "weapons/mortarhit.wav" );
PRECACHE_MODEL( "sprites/lgtning.spr" );
}
// If connected to a table, then use the table controllers, else hit where the trigger is.
void CFuncMortarField :: FieldUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CFuncMortarField::FieldUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
Vector vecStart;
@ -125,62 +125,66 @@ void CFuncMortarField :: FieldUse( CBaseEntity *pActivator, CBaseEntity *pCaller
switch( m_fControl )
{
case 0: // random
case 0:
// random
break;
case 1: // Trigger Activator
if (pActivator != NULL)
case 1:
// Trigger Activator
if( pActivator != NULL )
{
vecStart.x = pActivator->pev->origin.x;
vecStart.y = pActivator->pev->origin.y;
}
break;
case 2: // table
case 2:
// table
{
CBaseEntity *pController;
if (!FStringNull(m_iszXController))
if( !FStringNull( m_iszXController ) )
{
pController = UTIL_FindEntityByTargetname( NULL, STRING(m_iszXController));
if (pController != NULL)
pController = UTIL_FindEntityByTargetname( NULL, STRING( m_iszXController ) );
if( pController != NULL )
{
vecStart.x = pev->mins.x + pController->pev->ideal_yaw * (pev->size.x);
vecStart.x = pev->mins.x + pController->pev->ideal_yaw * ( pev->size.x );
}
}
if (!FStringNull(m_iszYController))
if( !FStringNull( m_iszYController ) )
{
pController = UTIL_FindEntityByTargetname( NULL, STRING(m_iszYController));
if (pController != NULL)
pController = UTIL_FindEntityByTargetname( NULL, STRING( m_iszYController ) );
if( pController != NULL )
{
vecStart.y = pev->mins.y + pController->pev->ideal_yaw * (pev->size.y);
vecStart.y = pev->mins.y + pController->pev->ideal_yaw * ( pev->size.y );
}
}
}
break;
}
int pitch = RANDOM_LONG(95,124);
int pitch = RANDOM_LONG( 95,124 );
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "weapons/mortar.wav", 1.0, ATTN_NONE, 0, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "weapons/mortar.wav", 1.0, ATTN_NONE, 0, pitch );
float t = 2.5;
for (int i = 0; i < m_iCount; i++)
for( int i = 0; i < m_iCount; i++ )
{
Vector vecSpot = vecStart;
vecSpot.x += RANDOM_FLOAT( -m_flSpread, m_flSpread );
vecSpot.y += RANDOM_FLOAT( -m_flSpread, m_flSpread );
TraceResult tr;
UTIL_TraceLine( vecSpot, vecSpot + Vector( 0, 0, -1 ) * 4096, ignore_monsters, ENT(pev), &tr );
UTIL_TraceLine( vecSpot, vecSpot + Vector( 0, 0, -1 ) * 4096, ignore_monsters, ENT( pev ), &tr );
edict_t *pentOwner = NULL;
if (pActivator) pentOwner = pActivator->edict();
if( pActivator )
pentOwner = pActivator->edict();
CBaseEntity *pMortar = Create("monster_mortar", tr.vecEndPos, Vector( 0, 0, 0 ), pentOwner );
CBaseEntity *pMortar = Create( "monster_mortar", tr.vecEndPos, Vector( 0, 0, 0 ), pentOwner );
pMortar->pev->nextthink = gpGlobals->time + t;
t += RANDOM_FLOAT( 0.2, 0.5 );
if (i == 0)
CSoundEnt::InsertSound ( bits_SOUND_DANGER, tr.vecEndPos, 400, 0.3 );
if( i == 0 )
CSoundEnt::InsertSound( bits_SOUND_DANGER, tr.vecEndPos, 400, 0.3 );
}
}
@ -197,7 +201,7 @@ public:
LINK_ENTITY_TO_CLASS( monster_mortar, CMortar )
void CMortar::Spawn( )
void CMortar::Spawn()
{
pev->movetype = MOVETYPE_NONE;
pev->solid = SOLID_NOT;
@ -207,10 +211,10 @@ void CMortar::Spawn( )
SetThink( &CMortar::MortarExplode );
pev->nextthink = 0;
Precache( );
Precache();
}
void CMortar::Precache( )
void CMortar::Precache()
{
m_spriteTexture = PRECACHE_MODEL( "sprites/lgtning.spr" );
}
@ -221,13 +225,13 @@ void CMortar::MortarExplode( void )
// mortar beam
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE( TE_BEAMPOINTS );
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 + 1024);
WRITE_SHORT(m_spriteTexture );
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 + 1024 );
WRITE_SHORT( m_spriteTexture );
WRITE_BYTE( 0 ); // framerate
WRITE_BYTE( 0 ); // framerate
WRITE_BYTE( 1 ); // life
@ -244,14 +248,14 @@ void CMortar::MortarExplode( void )
#if 0
// blast circle
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE( TE_BEAMTORUS);
WRITE_COORD(pev->origin.x);
WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z + 32);
WRITE_COORD(pev->origin.x);
WRITE_COORD(pev->origin.y);
WRITE_COORD(pev->origin.z + 32 + pev->dmg * 2 / .2); // reach damage radius over .3 seconds
WRITE_SHORT(m_spriteTexture );
WRITE_BYTE( TE_BEAMTORUS );
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z + 32 );
WRITE_COORD( pev->origin.x );
WRITE_COORD( pev->origin.y );
WRITE_COORD( pev->origin.z + 32 + pev->dmg * 2 / .2 ); // reach damage radius over .3 seconds
WRITE_SHORT( m_spriteTexture );
WRITE_BYTE( 0 ); // startframe
WRITE_BYTE( 0 ); // framerate
WRITE_BYTE( 2 ); // life
@ -266,22 +270,22 @@ void CMortar::MortarExplode( void )
#endif
TraceResult tr;
UTIL_TraceLine( pev->origin + Vector( 0, 0, 1024 ), pev->origin - Vector( 0, 0, 1024 ), dont_ignore_monsters, ENT(pev), &tr );
UTIL_TraceLine( pev->origin + Vector( 0, 0, 1024 ), pev->origin - Vector( 0, 0, 1024 ), dont_ignore_monsters, ENT( pev ), &tr );
Explode( &tr, DMG_BLAST | DMG_MORTAR );
UTIL_ScreenShake( tr.vecEndPos, 25.0, 150.0, 1.0, 750 );
#if 0
int pitch = RANDOM_LONG(95,124);
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "weapons/mortarhit.wav", 1.0, 0.55, 0, pitch);
int pitch = RANDOM_LONG( 95, 124 );
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "weapons/mortarhit.wav", 1.0, 0.55, 0, pitch );
// ForceSound( SNDRADIUS_MP5, bits_SOUND_COMBAT );
// ExplodeModel( pev->origin, 400, g_sModelIndexShrapnel, 30 );
RadiusDamage ( pev, VARS(pev->owner), pev->dmg, CLASS_NONE, DMG_BLAST );
RadiusDamage( pev, VARS( pev->owner ), pev->dmg, CLASS_NONE, DMG_BLAST );
/*
if ( RANDOM_FLOAT ( 0 , 1 ) < 0.5 )
if( RANDOM_FLOAT( 0, 1 ) < 0.5 )
{
UTIL_DecalTrace( pTrace, DECAL_SCORCH1 );
}
@ -303,7 +307,7 @@ void CMortar::ShootTimed( EVARS *pevOwner, Vector vecStart, float time )
pMortar->Spawn();
TraceResult tr;
UTIL_TraceLine( vecStart, vecStart + Vector( 0, 0, -1 ) * 4096, ignore_monsters, ENT(pMortar->pev), &tr );
UTIL_TraceLine( vecStart, vecStart + Vector( 0, 0, -1 ) * 4096, ignore_monsters, ENT( pMortar->pev ), &tr );
pMortar->pev->nextthink = gpGlobals->time + time;

76
dlls/mpstubb.cpp
View File

@ -26,27 +26,27 @@ float CTalkMonster::g_talkWaitTime = 0; // time delay until it's ok to speak: u
/*********************************************************/
CGraph WorldGraph;
void CGraph :: InitGraph( void ) { }
int CGraph :: FLoadGraph ( char *szMapName ) { return FALSE; }
int CGraph :: AllocNodes ( void ) { return FALSE; }
int CGraph :: CheckNODFile ( char *szMapName ) { return FALSE; }
int CGraph :: FSetGraphPointers ( void ) { return 0; }
void CGraph :: ShowNodeConnections ( int iNode ) { }
int CGraph :: FindNearestNode ( const Vector &vecOrigin, int afNodeTypes ) { return 0; }
void CGraph::InitGraph( void ) { }
int CGraph::FLoadGraph( char *szMapName ) { return FALSE; }
int CGraph::AllocNodes( void ) { return FALSE; }
int CGraph::CheckNODFile( char *szMapName ) { return FALSE; }
int CGraph::FSetGraphPointers( void ) { return 0; }
void CGraph::ShowNodeConnections( int iNode ) { }
int CGraph::FindNearestNode( const Vector &vecOrigin, int afNodeTypes ) { return 0; }
/*********************************************************/
void CBaseMonster :: ReportAIState( void ) { }
float CBaseMonster :: ChangeYaw ( int speed ) { return 0; }
void CBaseMonster :: MakeIdealYaw( Vector vecTarget ) { }
void CBaseMonster::ReportAIState( void ) { }
float CBaseMonster::ChangeYaw( int speed ) { return 0; }
void CBaseMonster::MakeIdealYaw( Vector vecTarget ) { }
void CBaseMonster::CorpseFallThink( void )
{
if ( pev->flags & FL_ONGROUND )
if( pev->flags & FL_ONGROUND )
{
SetThink( NULL );
SetSequenceBox( );
SetSequenceBox();
UTIL_SetOrigin( pev, pev->origin );// link into world.
}
else
@ -54,7 +54,7 @@ void CBaseMonster::CorpseFallThink( void )
}
// Call after animation/pose is set up
void CBaseMonster :: MonsterInitDead( void )
void CBaseMonster::MonsterInitDead( void )
{
InitBoneControllers();
@ -62,14 +62,14 @@ void CBaseMonster :: MonsterInitDead( void )
pev->movetype = MOVETYPE_TOSS;// so he'll fall to ground
pev->frame = 0;
ResetSequenceInfo( );
ResetSequenceInfo();
pev->framerate = 0;
// Copy health
pev->max_health = pev->health;
pev->deadflag = DEAD_DEAD;
UTIL_SetSize(pev, g_vecZero, g_vecZero );
UTIL_SetSize( pev, g_vecZero, g_vecZero );
UTIL_SetOrigin( pev, pev->origin );
// Setup health counters, etc.
@ -78,22 +78,22 @@ void CBaseMonster :: MonsterInitDead( void )
pev->nextthink = gpGlobals->time + 0.5;
}
BOOL CBaseMonster :: ShouldFadeOnDeath( void )
BOOL CBaseMonster::ShouldFadeOnDeath( void )
{
return FALSE;
}
BOOL CBaseMonster :: FCheckAITrigger ( void )
BOOL CBaseMonster::FCheckAITrigger( void )
{
return FALSE;
}
void CBaseMonster :: KeyValue( KeyValueData *pkvd )
void CBaseMonster::KeyValue( KeyValueData *pkvd )
{
CBaseToggle::KeyValue( pkvd );
}
int CBaseMonster::IRelationship ( CBaseEntity *pTarget )
int CBaseMonster::IRelationship( CBaseEntity *pTarget )
{
static int iEnemy[14][14] =
{ // NONE MACH PLYR HPASS HMIL AMIL APASS AMONST APREY APRED INSECT PLRALY PBWPN ABWPN
@ -113,7 +113,7 @@ int CBaseMonster::IRelationship ( CBaseEntity *pTarget )
/*ABIOWEAPON*/ { R_NO ,R_NO ,R_DL ,R_DL ,R_DL ,R_AL ,R_NO ,R_DL ,R_DL ,R_NO ,R_NO ,R_DL, R_DL, R_NO }
};
return iEnemy[ Classify() ][ pTarget->Classify() ];
return iEnemy[Classify()][pTarget->Classify()];
}
//=========================================================
@ -128,12 +128,12 @@ int CBaseMonster::IRelationship ( CBaseEntity *pTarget )
// (linked via each ent's m_pLink field)
//
//=========================================================
void CBaseMonster :: Look ( int iDistance )
void CBaseMonster::Look( int iDistance )
{
int iSighted = 0;
// DON'T let visibility information from last frame sit around!
ClearConditions(bits_COND_SEE_HATE | bits_COND_SEE_DISLIKE | bits_COND_SEE_ENEMY | bits_COND_SEE_FEAR | bits_COND_SEE_NEMESIS | bits_COND_SEE_CLIENT);
ClearConditions( bits_COND_SEE_HATE | bits_COND_SEE_DISLIKE | bits_COND_SEE_ENEMY | bits_COND_SEE_FEAR | bits_COND_SEE_NEMESIS | bits_COND_SEE_CLIENT );
m_pLink = NULL;
@ -144,17 +144,17 @@ void CBaseMonster :: Look ( int iDistance )
Vector delta = Vector( iDistance, iDistance, iDistance );
// Find only monsters/clients in box, NOT limited to PVS
int count = UTIL_EntitiesInBox( pList, 100, pev->origin - delta, pev->origin + delta, FL_CLIENT|FL_MONSTER );
for ( int i = 0; i < count; i++ )
int count = UTIL_EntitiesInBox( pList, 100, pev->origin - delta, pev->origin + delta, FL_CLIENT | FL_MONSTER );
for( int i = 0; i < count; i++ )
{
pSightEnt = pList[i];
if ( pSightEnt != this && pSightEnt->pev->health > 0 )
if( pSightEnt != this && pSightEnt->pev->health > 0 )
{
// the looker will want to consider this entity
// don't check anything else about an entity that can't be seen, or an entity that you don't care about.
if ( IRelationship( pSightEnt ) != R_NO && FInViewCone( pSightEnt ) && !FBitSet( pSightEnt->pev->flags, FL_NOTARGET ) && FVisible( pSightEnt ) )
if( IRelationship( pSightEnt ) != R_NO && FInViewCone( pSightEnt ) && !FBitSet( pSightEnt->pev->flags, FL_NOTARGET ) && FVisible( pSightEnt ) )
{
if ( pSightEnt->IsPlayer() )
if( pSightEnt->IsPlayer() )
{
// if we see a client, remember that (mostly for scripted AI)
iSighted |= bits_COND_SEE_CLIENT;
@ -163,7 +163,7 @@ void CBaseMonster :: Look ( int iDistance )
pSightEnt->m_pLink = m_pLink;
m_pLink = pSightEnt;
if ( pSightEnt == m_hEnemy )
if( pSightEnt == m_hEnemy )
{
// we know this ent is visible, so if it also happens to be our enemy, store that now.
iSighted |= bits_COND_SEE_ENEMY;
@ -171,7 +171,7 @@ void CBaseMonster :: Look ( int iDistance )
// don't add the Enemy's relationship to the conditions. We only want to worry about conditions when
// we see monsters other than the Enemy.
switch ( IRelationship ( pSightEnt ) )
switch( IRelationship( pSightEnt ) )
{
case R_NM:
iSighted |= bits_COND_SEE_NEMESIS;
@ -188,7 +188,7 @@ void CBaseMonster :: Look ( int iDistance )
case R_AL:
break;
default:
ALERT ( at_aiconsole, "%s can't assess %s\n", STRING(pev->classname), STRING(pSightEnt->pev->classname ) );
ALERT( at_aiconsole, "%s can't assess %s\n", STRING( pev->classname ), STRING(pSightEnt->pev->classname ) );
break;
}
}
@ -207,7 +207,7 @@ void CBaseMonster :: Look ( int iDistance )
// !!!UNDONE - currently, this only returns the closest enemy.
// we'll want to consider distance, relationship, attack types, back turned, etc.
//=========================================================
CBaseEntity *CBaseMonster :: BestVisibleEnemy ( void )
CBaseEntity *CBaseMonster::BestVisibleEnemy( void )
{
CBaseEntity *pReturn;
CBaseEntity *pNextEnt;
@ -220,30 +220,30 @@ CBaseEntity *CBaseMonster :: BestVisibleEnemy ( void )
pReturn = NULL;
iBestRelationship = R_NO;
while ( pNextEnt != NULL )
while( pNextEnt != NULL )
{
if ( pNextEnt->IsAlive() )
if( pNextEnt->IsAlive() )
{
if ( IRelationship( pNextEnt) > iBestRelationship )
if( IRelationship( pNextEnt ) > iBestRelationship )
{
// this entity is disliked MORE than the entity that we
// currently think is the best visible enemy. No need to do
// a distance check, just get mad at this one for now.
iBestRelationship = IRelationship ( pNextEnt );
iBestRelationship = IRelationship( pNextEnt );
iNearest = ( pNextEnt->pev->origin - pev->origin ).Length();
pReturn = pNextEnt;
}
else if ( IRelationship( pNextEnt) == iBestRelationship )
else if( IRelationship( pNextEnt ) == iBestRelationship )
{
// this entity is disliked just as much as the entity that
// we currently think is the best visible enemy, so we only
// get mad at it if it is closer.
iDist = ( pNextEnt->pev->origin - pev->origin ).Length();
if ( iDist <= iNearest )
if( iDist <= iNearest )
{
iNearest = iDist;
iBestRelationship = IRelationship ( pNextEnt );
iBestRelationship = IRelationship( pNextEnt );
pReturn = pNextEnt;
}
}

445
dlls/multiplay_gamerules.cpp
View File

File diff suppressed because it is too large Load Diff

612
dlls/nihilanth.cpp
View File

File diff suppressed because it is too large Load Diff

1892
dlls/nodes.cpp
View File

File diff suppressed because it is too large Load Diff

238
dlls/osprey.cpp
View File

@ -41,7 +41,7 @@ public:
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int ObjectCaps( void ) { return CBaseMonster :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
int ObjectCaps( void ) { return CBaseMonster::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
void Spawn( void );
void Precache( void );
@ -62,8 +62,8 @@ public:
void EXPORT DyingThink( void );
void EXPORT CommandUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
// 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 TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
void ShowDamage( void );
CBaseEntity *m_pGoalEnt;
@ -140,15 +140,15 @@ TYPEDESCRIPTION COsprey::m_SaveData[] =
IMPLEMENT_SAVERESTORE( COsprey, CBaseMonster )
void COsprey :: Spawn( void )
void COsprey::Spawn( void )
{
Precache( );
Precache();
// motor
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/osprey.mdl");
UTIL_SetSize(pev, Vector( -400, -400, -100), Vector(400, 400, 32));
SET_MODEL( ENT( pev ), "models/osprey.mdl" );
UTIL_SetSize( pev, Vector( -400, -400, -100 ), Vector( 400, 400, 32 ) );
UTIL_SetOrigin( pev, pev->origin );
pev->flags |= FL_MONSTER;
@ -160,15 +160,15 @@ void COsprey :: Spawn( void )
m_flFieldOfView = 0; // 180 degrees
pev->sequence = 0;
ResetSequenceInfo( );
pev->frame = RANDOM_LONG(0,0xFF);
ResetSequenceInfo();
pev->frame = RANDOM_LONG( 0, 0xFF );
InitBoneControllers();
SetThink( &COsprey::FindAllThink );
SetUse( &COsprey::CommandUse );
if (!(pev->spawnflags & SF_WAITFORTRIGGER))
if( !( pev->spawnflags & SF_WAITFORTRIGGER ) )
{
pev->nextthink = gpGlobals->time + 1.0;
}
@ -182,11 +182,11 @@ void COsprey::Precache( void )
{
UTIL_PrecacheOther( "monster_human_grunt" );
PRECACHE_MODEL("models/osprey.mdl");
PRECACHE_MODEL("models/HVR.mdl");
PRECACHE_MODEL( "models/osprey.mdl" );
PRECACHE_MODEL( "models/HVR.mdl" );
PRECACHE_SOUND("apache/ap_rotor4.wav");
PRECACHE_SOUND("weapons/mortarhit.wav");
PRECACHE_SOUND( "apache/ap_rotor4.wav" );
PRECACHE_SOUND( "weapons/mortarhit.wav" );
m_iSpriteTexture = PRECACHE_MODEL( "sprites/rope.spr" );
@ -201,14 +201,14 @@ void COsprey::CommandUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYP
pev->nextthink = gpGlobals->time + 0.1;
}
void COsprey :: FindAllThink( void )
void COsprey::FindAllThink( void )
{
CBaseEntity *pEntity = NULL;
m_iUnits = 0;
while (m_iUnits < MAX_CARRY && (pEntity = UTIL_FindEntityByClassname( pEntity, "monster_human_grunt" )) != NULL)
while( m_iUnits < MAX_CARRY && ( pEntity = UTIL_FindEntityByClassname( pEntity, "monster_human_grunt" ) ) != NULL )
{
if (pEntity->IsAlive())
if( pEntity->IsAlive() )
{
m_hGrunt[m_iUnits] = pEntity;
m_vecOrigin[m_iUnits] = pEntity->pev->origin;
@ -216,9 +216,9 @@ void COsprey :: FindAllThink( void )
}
}
if (m_iUnits == 0)
if( m_iUnits == 0 )
{
ALERT( at_console, "osprey error: no grunts to resupply\n");
ALERT( at_console, "osprey error: no grunts to resupply\n" );
UTIL_Remove( this );
return;
}
@ -227,7 +227,7 @@ void COsprey :: FindAllThink( void )
m_startTime = gpGlobals->time;
}
void COsprey :: DeployThink( void )
void COsprey::DeployThink( void )
{
UTIL_MakeAimVectors( pev->angles );
@ -238,8 +238,8 @@ void COsprey :: DeployThink( void )
Vector vecSrc;
TraceResult tr;
UTIL_TraceLine( pev->origin, pev->origin + Vector( 0, 0, -4096.0), ignore_monsters, ENT(pev), &tr);
CSoundEnt::InsertSound ( bits_SOUND_DANGER, tr.vecEndPos, 400, 0.3 );
UTIL_TraceLine( pev->origin, pev->origin + Vector( 0, 0, -4096.0 ), ignore_monsters, ENT( pev ), &tr );
CSoundEnt::InsertSound( bits_SOUND_DANGER, tr.vecEndPos, 400, 0.3 );
vecSrc = pev->origin + vecForward * 32 + vecRight * 100 + vecUp * -96;
m_hRepel[0] = MakeGrunt( vecSrc );
@ -257,11 +257,11 @@ void COsprey :: DeployThink( void )
pev->nextthink = gpGlobals->time + 0.1;
}
BOOL COsprey :: HasDead( )
BOOL COsprey::HasDead()
{
for (int i = 0; i < m_iUnits; i++)
for( int i = 0; i < m_iUnits; i++ )
{
if (m_hGrunt[i] == NULL || !m_hGrunt[i]->IsAlive())
if( m_hGrunt[i] == NULL || !m_hGrunt[i]->IsAlive() )
{
return TRUE;
}
@ -273,26 +273,26 @@ BOOL COsprey :: HasDead( )
return FALSE;
}
CBaseMonster *COsprey :: MakeGrunt( Vector vecSrc )
CBaseMonster *COsprey::MakeGrunt( Vector vecSrc )
{
CBaseEntity *pEntity;
CBaseMonster *pGrunt;
TraceResult tr;
UTIL_TraceLine( vecSrc, vecSrc + Vector( 0, 0, -4096.0), dont_ignore_monsters, ENT(pev), &tr);
if ( tr.pHit && Instance( tr.pHit )->pev->solid != SOLID_BSP)
UTIL_TraceLine( vecSrc, vecSrc + Vector( 0, 0, -4096.0 ), dont_ignore_monsters, ENT( pev ), &tr );
if( tr.pHit && Instance( tr.pHit )->pev->solid != SOLID_BSP )
return NULL;
for (int i = 0; i < m_iUnits; i++)
for( int i = 0; i < m_iUnits; i++ )
{
if (m_hGrunt[i] == NULL || !m_hGrunt[i]->IsAlive())
if( m_hGrunt[i] == NULL || !m_hGrunt[i]->IsAlive() )
{
if (m_hGrunt[i] != NULL && m_hGrunt[i]->pev->rendermode == kRenderNormal)
if( m_hGrunt[i] != NULL && m_hGrunt[i]->pev->rendermode == kRenderNormal )
{
m_hGrunt[i]->SUB_StartFadeOut( );
m_hGrunt[i]->SUB_StartFadeOut();
}
pEntity = Create( "monster_human_grunt", vecSrc, pev->angles );
pGrunt = pEntity->MyMonsterPointer( );
pGrunt = pEntity->MyMonsterPointer();
pGrunt->pev->movetype = MOVETYPE_FLY;
pGrunt->pev->velocity = Vector( 0, 0, RANDOM_FLOAT( -196, -128 ) );
pGrunt->SetActivity( ACT_GLIDE );
@ -314,18 +314,18 @@ CBaseMonster *COsprey :: MakeGrunt( Vector vecSrc )
return NULL;
}
void COsprey :: HoverThink( void )
void COsprey::HoverThink( void )
{
int i;
for (i = 0; i < 4; i++)
for( i = 0; i < 4; i++ )
{
if (m_hRepel[i] != NULL && m_hRepel[i]->pev->health > 0 && !(m_hRepel[i]->pev->flags & FL_ONGROUND))
if( m_hRepel[i] != NULL && m_hRepel[i]->pev->health > 0 && !( m_hRepel[i]->pev->flags & FL_ONGROUND ) )
{
break;
}
}
if (i == 4)
if( i == 4 )
{
m_startTime = gpGlobals->time;
SetThink( &COsprey::FlyThink );
@ -333,12 +333,12 @@ void COsprey :: HoverThink( void )
pev->nextthink = gpGlobals->time + 0.1;
UTIL_MakeAimVectors( pev->angles );
ShowDamage( );
ShowDamage();
}
void COsprey::UpdateGoal( )
void COsprey::UpdateGoal()
{
if (m_pGoalEnt)
if( m_pGoalEnt )
{
m_pos1 = m_pos2;
m_ang1 = m_ang2;
@ -349,65 +349,65 @@ void COsprey::UpdateGoal( )
m_vel2 = gpGlobals->v_forward * m_pGoalEnt->pev->speed;
m_startTime = m_startTime + m_dTime;
m_dTime = 2.0 * (m_pos1 - m_pos2).Length() / (m_vel1.Length() + m_pGoalEnt->pev->speed);
m_dTime = 2.0 * ( m_pos1 - m_pos2 ).Length() / ( m_vel1.Length() + m_pGoalEnt->pev->speed );
if (m_ang1.y - m_ang2.y < -180)
if( m_ang1.y - m_ang2.y < -180 )
{
m_ang1.y += 360;
}
else if (m_ang1.y - m_ang2.y > 180)
else if( m_ang1.y - m_ang2.y > 180 )
{
m_ang1.y -= 360;
}
if (m_pGoalEnt->pev->speed < 400)
if( m_pGoalEnt->pev->speed < 400 )
m_flIdealtilt = 0;
else
m_flIdealtilt = -90;
}
else
{
ALERT( at_console, "osprey missing target");
ALERT( at_console, "osprey missing target" );
}
}
void COsprey::FlyThink( void )
{
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1;
if ( m_pGoalEnt == NULL && !FStringNull(pev->target) )// this monster has a target
if( m_pGoalEnt == NULL && !FStringNull( pev->target) )// this monster has a target
{
m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME ( NULL, STRING( pev->target ) ) );
UpdateGoal( );
m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME( NULL, STRING( pev->target ) ) );
UpdateGoal();
}
if (gpGlobals->time > m_startTime + m_dTime)
if( gpGlobals->time > m_startTime + m_dTime )
{
if (m_pGoalEnt->pev->speed == 0)
if( m_pGoalEnt->pev->speed == 0 )
{
SetThink( &COsprey::DeployThink );
}
do {
m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME ( NULL, STRING( m_pGoalEnt->pev->target ) ) );
} while (m_pGoalEnt->pev->speed < 400 && !HasDead());
UpdateGoal( );
do{
m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME( NULL, STRING( m_pGoalEnt->pev->target ) ) );
} while( m_pGoalEnt->pev->speed < 400 && !HasDead() );
UpdateGoal();
}
Flight( );
ShowDamage( );
Flight();
ShowDamage();
}
void COsprey::Flight( )
void COsprey::Flight()
{
float t = (gpGlobals->time - m_startTime);
float t = ( gpGlobals->time - m_startTime );
float scale = 1.0 / m_dTime;
float f = UTIL_SplineFraction( t * scale, 1.0 );
Vector pos = (m_pos1 + m_vel1 * t) * (1.0 - f) + (m_pos2 - m_vel2 * (m_dTime - t)) * f;
Vector ang = (m_ang1) * (1.0 - f) + (m_ang2) * f;
m_velocity = m_vel1 * (1.0 - f) + m_vel2 * f;
Vector pos = ( m_pos1 + m_vel1 * t ) * ( 1.0 - f ) + ( m_pos2 - m_vel2 * ( m_dTime - t ) ) * f;
Vector ang = ( m_ang1 ) * ( 1.0 - f ) + ( m_ang2 ) * f;
m_velocity = m_vel1 * ( 1.0 - f ) + m_vel2 * f;
UTIL_SetOrigin( pev, pos );
pev->angles = ang;
@ -416,28 +416,27 @@ void COsprey::Flight( )
// float flSpeed = DotProduct( gpGlobals->v_forward, pev->velocity );
float m_flIdealtilt = (160 - flSpeed) / 10.0;
float m_flIdealtilt = ( 160 - flSpeed ) / 10.0;
// ALERT( at_console, "%f %f\n", flSpeed, flIdealtilt );
if (m_flRotortilt < m_flIdealtilt)
if( m_flRotortilt < m_flIdealtilt )
{
m_flRotortilt += 0.5;
if (m_flRotortilt > 0)
if ( m_flRotortilt > 0 )
m_flRotortilt = 0;
}
if (m_flRotortilt > m_flIdealtilt)
if( m_flRotortilt > m_flIdealtilt )
{
m_flRotortilt -= 0.5;
if (m_flRotortilt < -90)
if( m_flRotortilt < -90 )
m_flRotortilt = -90;
}
SetBoneController( 0, m_flRotortilt );
if (m_iSoundState == 0)
if( m_iSoundState == 0 )
{
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_rotor4.wav", 1.0, 0.15, 0, 110 );
// EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_whine1.wav", 0.5, 0.2, 0, 110 );
EMIT_SOUND_DYN( ENT( pev ), CHAN_STATIC, "apache/ap_rotor4.wav", 1.0, 0.15, 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
}
@ -447,28 +446,28 @@ void COsprey::Flight( )
pPlayer = UTIL_FindEntityByClassname( NULL, "player" );
// UNDONE: this needs to send different sounds to every player for multiplayer.
if (pPlayer)
if( pPlayer )
{
float pitch = DotProduct( m_velocity - pPlayer->pev->velocity, (pPlayer->pev->origin - pev->origin).Normalize() );
float pitch = DotProduct( m_velocity - pPlayer->pev->velocity, ( pPlayer->pev->origin - pev->origin ).Normalize() );
pitch = (int)(100 + pitch / 75.0);
pitch = (int)( 100 + pitch / 75.0 );
if (pitch > 250)
if( pitch > 250 )
pitch = 250;
if (pitch < 50)
if( pitch < 50 )
pitch = 50;
if (pitch == 100)
if( pitch == 100 )
pitch = 101;
if (pitch != m_iPitch)
if( pitch != m_iPitch )
{
m_iPitch = pitch;
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_rotor4.wav", 1.0, 0.15, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_STATIC, "apache/ap_rotor4.wav", 1.0, 0.15, SND_CHANGE_PITCH | SND_CHANGE_VOL, pitch );
// ALERT( at_console, "%.0f\n", pitch );
}
}
// EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, "apache/ap_whine1.wav", flVol, 0.2, 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 );
}
}
@ -481,7 +480,7 @@ void COsprey::HitTouch( CBaseEntity *pOther )
/*
int COsprey::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if (m_flRotortilt <= -90)
if( m_flRotortilt <= -90 )
{
m_flRotortilt = 0;
}
@ -494,15 +493,15 @@ int COsprey::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float
}
*/
void COsprey :: Killed( entvars_t *pevAttacker, int iGib )
void COsprey::Killed( entvars_t *pevAttacker, int iGib )
{
pev->movetype = MOVETYPE_TOSS;
pev->gravity = 0.3;
pev->velocity = m_velocity;
pev->avelocity = Vector( RANDOM_FLOAT( -20, 20 ), 0, RANDOM_FLOAT( -50, 50 ) );
STOP_SOUND( ENT(pev), CHAN_STATIC, "apache/ap_rotor4.wav" );
STOP_SOUND( ENT( pev ), CHAN_STATIC, "apache/ap_rotor4.wav" );
UTIL_SetSize( pev, Vector( -32, -32, -64), Vector( 32, 32, 0) );
UTIL_SetSize( pev, Vector( -32, -32, -64 ), Vector( 32, 32, 0 ) );
SetThink( &COsprey::DyingThink );
SetTouch( &COsprey::CrashTouch );
pev->nextthink = gpGlobals->time + 0.1;
@ -515,7 +514,7 @@ void COsprey :: Killed( entvars_t *pevAttacker, int iGib )
void COsprey::CrashTouch( CBaseEntity *pOther )
{
// only crash if we hit something solid
if ( pOther->pev->solid == SOLID_BSP)
if( pOther->pev->solid == SOLID_BSP )
{
SetTouch( NULL );
m_startTime = gpGlobals->time;
@ -524,29 +523,29 @@ void COsprey::CrashTouch( CBaseEntity *pOther )
}
}
void COsprey :: DyingThink( void )
void COsprey::DyingThink( void )
{
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1;
pev->avelocity = pev->avelocity * 1.02;
// still falling?
if (m_startTime > gpGlobals->time )
if( m_startTime > gpGlobals->time )
{
UTIL_MakeAimVectors( pev->angles );
ShowDamage( );
ShowDamage();
Vector vecSpot = pev->origin + pev->velocity * 0.2;
// random explosions
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_EXPLOSION); // This just makes a dynamic light now
WRITE_COORD( vecSpot.x + RANDOM_FLOAT( -150, 150 ));
WRITE_COORD( vecSpot.y + RANDOM_FLOAT( -150, 150 ));
WRITE_COORD( vecSpot.z + RANDOM_FLOAT( -150, -50 ));
WRITE_BYTE( TE_EXPLOSION ); // This just makes a dynamic light now
WRITE_COORD( vecSpot.x + RANDOM_FLOAT( -150, 150 ) );
WRITE_COORD( vecSpot.y + RANDOM_FLOAT( -150, 150 ) );
WRITE_COORD( vecSpot.z + RANDOM_FLOAT( -150, -50 ) );
WRITE_SHORT( g_sModelIndexFireball );
WRITE_BYTE( RANDOM_LONG(0,29) + 30 ); // scale * 10
WRITE_BYTE( RANDOM_LONG( 0, 29 ) + 30 ); // scale * 10
WRITE_BYTE( 12 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
@ -554,16 +553,15 @@ void COsprey :: DyingThink( void )
// lots of smoke
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_SMOKE );
WRITE_COORD( vecSpot.x + RANDOM_FLOAT( -150, 150 ));
WRITE_COORD( vecSpot.y + RANDOM_FLOAT( -150, 150 ));
WRITE_COORD( vecSpot.z + RANDOM_FLOAT( -150, -50 ));
WRITE_COORD( vecSpot.x + RANDOM_FLOAT( -150, 150 ) );
WRITE_COORD( vecSpot.y + RANDOM_FLOAT( -150, 150 ) );
WRITE_COORD( vecSpot.z + RANDOM_FLOAT( -150, -50 ) );
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( 100 ); // scale * 10
WRITE_BYTE( 10 ); // framerate
MESSAGE_END();
vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
vecSpot = pev->origin + ( pev->mins + pev->maxs ) * 0.5;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_BREAKMODEL);
@ -595,12 +593,9 @@ void COsprey :: DyingThink( void )
WRITE_BYTE( 200 );// 10.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;
@ -608,7 +603,7 @@ void COsprey :: DyingThink( void )
}
else
{
Vector vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
Vector vecSpot = pev->origin + ( pev->mins + pev->maxs ) * 0.5;
/*
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
@ -667,19 +662,19 @@ void COsprey :: DyingThink( void )
WRITE_BYTE( 0 ); // speed
MESSAGE_END();
EMIT_SOUND(ENT(pev), CHAN_STATIC, "weapons/mortarhit.wav", 1.0, 0.3);
EMIT_SOUND( ENT( pev ), CHAN_STATIC, "weapons/mortarhit.wav", 1.0, 0.3 );
RadiusDamage( pev->origin, pev, pev, 300, CLASS_NONE, DMG_BLAST );
// gibs
vecSpot = pev->origin + (pev->mins + pev->maxs) * 0.5;
vecSpot = pev->origin + ( pev->mins + pev->maxs ) * 0.5;
MESSAGE_BEGIN( MSG_PAS, SVC_TEMPENTITY, vecSpot );
WRITE_BYTE( TE_BREAKMODEL);
// position
WRITE_COORD( vecSpot.x );
WRITE_COORD( vecSpot.y );
WRITE_COORD( vecSpot.z + 64);
WRITE_COORD( vecSpot.z + 64 );
// size
WRITE_COORD( 800 );
@ -704,7 +699,6 @@ void COsprey :: DyingThink( void )
WRITE_BYTE( 200 );// 10.0 seconds
// flags
WRITE_BYTE( BREAK_METAL );
MESSAGE_END();
@ -712,9 +706,9 @@ void COsprey :: DyingThink( void )
}
}
void COsprey :: ShowDamage( void )
void COsprey::ShowDamage( void )
{
if (m_iDoLeftSmokePuff > 0 || RANDOM_LONG(0,99) > m_flLeftHealth)
if( m_iDoLeftSmokePuff > 0 || RANDOM_LONG( 0, 99 ) > m_flLeftHealth )
{
Vector vecSrc = pev->origin + gpGlobals->v_right * -340;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc );
@ -723,13 +717,13 @@ void COsprey :: ShowDamage( void )
WRITE_COORD( vecSrc.y );
WRITE_COORD( vecSrc.z );
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( RANDOM_LONG(0,9) + 20 ); // scale * 10
WRITE_BYTE( RANDOM_LONG( 0, 9 ) + 20 ); // scale * 10
WRITE_BYTE( 12 ); // framerate
MESSAGE_END();
if (m_iDoLeftSmokePuff > 0)
if( m_iDoLeftSmokePuff > 0 )
m_iDoLeftSmokePuff--;
}
if (m_iDoRightSmokePuff > 0 || RANDOM_LONG(0,99) > m_flRightHealth)
if( m_iDoRightSmokePuff > 0 || RANDOM_LONG( 0, 99 ) > m_flRightHealth )
{
Vector vecSrc = pev->origin + gpGlobals->v_right * 340;
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecSrc );
@ -738,39 +732,39 @@ void COsprey :: ShowDamage( void )
WRITE_COORD( vecSrc.y );
WRITE_COORD( vecSrc.z );
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( RANDOM_LONG(0,9) + 20 ); // scale * 10
WRITE_BYTE( RANDOM_LONG( 0, 9 ) + 20 ); // scale * 10
WRITE_BYTE( 12 ); // framerate
MESSAGE_END();
if (m_iDoRightSmokePuff > 0)
if( m_iDoRightSmokePuff > 0 )
m_iDoRightSmokePuff--;
}
}
void COsprey::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
void COsprey::TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType )
{
// ALERT( at_console, "%d %.0f\n", ptr->iHitgroup, flDamage );
// only so much per engine
if (ptr->iHitgroup == 3)
if( ptr->iHitgroup == 3 )
{
if (m_flRightHealth < 0)
if( m_flRightHealth < 0 )
return;
else
m_flRightHealth -= flDamage;
m_iDoLeftSmokePuff = 3 + (flDamage / 5.0);
m_iDoLeftSmokePuff = 3 + ( flDamage / 5.0 );
}
if (ptr->iHitgroup == 2)
if( ptr->iHitgroup == 2 )
{
if (m_flLeftHealth < 0)
if( m_flLeftHealth < 0 )
return;
else
m_flLeftHealth -= flDamage;
m_iDoRightSmokePuff = 3 + (flDamage / 5.0);
m_iDoRightSmokePuff = 3 + ( flDamage / 5.0 );
}
// hit hard, hits cockpit, hits engines
if (flDamage > 50 || ptr->iHitgroup == 1 || ptr->iHitgroup == 2 || ptr->iHitgroup == 3)
if( flDamage > 50 || ptr->iHitgroup == 1 || ptr->iHitgroup == 2 || ptr->iHitgroup == 3 )
{
// ALERT( at_console, "%.0f\n", flDamage );
AddMultiDamage( pevAttacker, this, flDamage, bitsDamageType );

159
dlls/pathcorner.cpp
View File

@ -25,10 +25,10 @@
class CPathCorner : public CPointEntity
{
public:
void Spawn( );
void Spawn();
void KeyValue( KeyValueData* pkvd );
float GetDelay( void ) { return m_flWait; }
// void Touch( CBaseEntity *pOther );
//void Touch( CBaseEntity *pOther );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
@ -51,67 +51,68 @@ IMPLEMENT_SAVERESTORE( CPathCorner, CPointEntity )
//
// Cache user-entity-field values until spawn is called.
//
void CPathCorner :: KeyValue( KeyValueData *pkvd )
void CPathCorner::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "wait"))
if( FStrEq( pkvd->szKeyName, "wait" ) )
{
m_flWait = atof(pkvd->szValue);
m_flWait = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
CPointEntity::KeyValue( pkvd );
}
void CPathCorner :: Spawn( )
void CPathCorner::Spawn()
{
ASSERTSZ(!FStringNull(pev->targetname), "path_corner without a targetname");
ASSERTSZ( !FStringNull( pev->targetname ), "path_corner without a targetname" );
}
#if 0
void CPathCorner :: Touch( CBaseEntity *pOther )
void CPathCorner::Touch( CBaseEntity *pOther )
{
entvars_t* pevToucher = pOther->pev;
entvars_t *pevToucher = pOther->pev;
if ( FBitSet ( pevToucher->flags, FL_MONSTER ) )
{// monsters don't navigate path corners based on touch anymore
if( FBitSet( pevToucher->flags, FL_MONSTER ) )
{
// monsters don't navigate path corners based on touch anymore
return;
}
// If OTHER isn't explicitly looking for this path_corner, bail out
if ( pOther->m_pGoalEnt != this )
if( pOther->m_pGoalEnt != this )
{
return;
}
// If OTHER has an enemy, this touch is incidental, ignore
if ( !FNullEnt(pevToucher->enemy) )
if( !FNullEnt( pevToucher->enemy ) )
{
return; // fighting, not following a path
}
// UNDONE: support non-zero flWait
/*
if (m_flWait != 0)
ALERT(at_warning, "Non-zero path-cornder waits NYI");
if( m_flWait != 0 )
ALERT( at_warning, "Non-zero path-cornder waits NYI" );
*/
// Find the next "stop" on the path, make it the goal of the "toucher".
if (FStringNull(pev->target))
if( FStringNull( pev->target ) )
{
ALERT(at_warning, "PathCornerTouch: no next stop specified");
ALERT( at_warning, "PathCornerTouch: no next stop specified" );
}
pOther->m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME ( NULL, STRING(pev->target) ) );
pOther->m_pGoalEnt = CBaseEntity::Instance( FIND_ENTITY_BY_TARGETNAME( NULL, STRING( pev->target ) ) );
// If "next spot" was not found (does not exist - level design error)
if ( !pOther->m_pGoalEnt )
if( !pOther->m_pGoalEnt )
{
ALERT(at_console, "PathCornerTouch--%s couldn't find next stop in path: %s", STRING(pev->classname), STRING(pev->target));
ALERT( at_console, "PathCornerTouch--%s couldn't find next stop in path: %s", STRING( pev->classname ), STRING( pev->target ) );
return;
}
// Turn towards the next stop in the path.
pevToucher->ideal_yaw = UTIL_VecToYaw ( pOther->m_pGoalEnt->pev->origin - pevToucher->origin );
pevToucher->ideal_yaw = UTIL_VecToYaw( pOther->m_pGoalEnt->pev->origin - pevToucher->origin );
}
#endif
@ -130,28 +131,28 @@ LINK_ENTITY_TO_CLASS( path_track, CPathTrack )
//
// Cache user-entity-field values until spawn is called.
//
void CPathTrack :: KeyValue( KeyValueData *pkvd )
void CPathTrack::KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "altpath"))
if( FStrEq( pkvd->szKeyName, "altpath" ) )
{
m_altName = ALLOC_STRING(pkvd->szValue);
m_altName = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
CPointEntity::KeyValue( pkvd );
}
void CPathTrack :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
void CPathTrack::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
int on;
// Use toggles between two paths
if ( m_paltpath )
if( m_paltpath )
{
on = !FBitSet( pev->spawnflags, SF_PATH_ALTERNATE );
if ( ShouldToggle( useType, on ) )
if( ShouldToggle( useType, on ) )
{
if ( on )
if( on )
SetBits( pev->spawnflags, SF_PATH_ALTERNATE );
else
ClearBits( pev->spawnflags, SF_PATH_ALTERNATE );
@ -161,9 +162,9 @@ void CPathTrack :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
{
on = !FBitSet( pev->spawnflags, SF_PATH_DISABLED );
if ( ShouldToggle( useType, on ) )
if( ShouldToggle( useType, on ) )
{
if ( on )
if( on )
SetBits( pev->spawnflags, SF_PATH_DISABLED );
else
ClearBits( pev->spawnflags, SF_PATH_DISABLED );
@ -171,35 +172,35 @@ void CPathTrack :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
}
}
void CPathTrack :: Link( void )
void CPathTrack::Link( void )
{
edict_t *pentTarget;
if ( !FStringNull(pev->target) )
if( !FStringNull( pev->target ) )
{
pentTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(pev->target) );
if ( !FNullEnt(pentTarget) )
pentTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING( pev->target ) );
if( !FNullEnt(pentTarget) )
{
m_pnext = CPathTrack::Instance( pentTarget );
if ( m_pnext ) // If no next pointer, this is the end of a path
if( m_pnext ) // If no next pointer, this is the end of a path
{
m_pnext->SetPrevious( this );
}
}
else
ALERT( at_console, "Dead end link %s\n", STRING(pev->target) );
ALERT( at_console, "Dead end link %s\n", STRING( pev->target ) );
}
// Find "alternate" path
if ( m_altName )
if( m_altName )
{
pentTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_altName) );
if ( !FNullEnt(pentTarget) )
pentTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING( m_altName ) );
if( !FNullEnt( pentTarget ) )
{
m_paltpath = CPathTrack::Instance( pentTarget );
if ( m_paltpath ) // If no next pointer, this is the end of a path
if( m_paltpath ) // If no next pointer, this is the end of a path
{
m_paltpath->SetPrevious( this );
}
@ -207,10 +208,10 @@ void CPathTrack :: Link( void )
}
}
void CPathTrack :: Spawn( void )
void CPathTrack::Spawn( void )
{
pev->solid = SOLID_TRIGGER;
UTIL_SetSize(pev, Vector(-8, -8, -8), Vector(8, 8, 8));
UTIL_SetSize( pev, Vector( -8, -8, -8 ), Vector( 8, 8, 8 ) );
m_pnext = NULL;
m_pprevious = NULL;
@ -223,26 +224,26 @@ void CPathTrack :: Spawn( void )
void CPathTrack::Activate( void )
{
if ( !FStringNull( pev->targetname ) ) // Link to next, and back-link
if( !FStringNull( pev->targetname ) ) // Link to next, and back-link
Link();
}
CPathTrack *CPathTrack :: ValidPath( CPathTrack *ppath, int testFlag )
CPathTrack *CPathTrack::ValidPath( CPathTrack *ppath, int testFlag )
{
if ( !ppath )
if( !ppath )
return NULL;
if ( testFlag && FBitSet( ppath->pev->spawnflags, SF_PATH_DISABLED ) )
if( testFlag && FBitSet( ppath->pev->spawnflags, SF_PATH_DISABLED ) )
return NULL;
return ppath;
}
void CPathTrack :: Project( CPathTrack *pstart, CPathTrack *pend, Vector *origin, float dist )
void CPathTrack::Project( CPathTrack *pstart, CPathTrack *pend, Vector *origin, float dist )
{
if ( pstart && pend )
if( pstart && pend )
{
Vector dir = (pend->pev->origin - pstart->pev->origin);
Vector dir = pend->pev->origin - pstart->pev->origin;
dir = dir.Normalize();
*origin = pend->pev->origin + dir * dist;
}
@ -250,17 +251,15 @@ void CPathTrack :: Project( CPathTrack *pstart, CPathTrack *pend, Vector *origin
CPathTrack *CPathTrack::GetNext( void )
{
if ( m_paltpath && FBitSet( pev->spawnflags, SF_PATH_ALTERNATE ) && !FBitSet( pev->spawnflags, SF_PATH_ALTREVERSE ) )
if( m_paltpath && FBitSet( pev->spawnflags, SF_PATH_ALTERNATE ) && !FBitSet( pev->spawnflags, SF_PATH_ALTREVERSE ) )
return m_paltpath;
return m_pnext;
}
CPathTrack *CPathTrack::GetPrevious( void )
{
if ( m_paltpath && FBitSet( pev->spawnflags, SF_PATH_ALTERNATE ) && FBitSet( pev->spawnflags, SF_PATH_ALTREVERSE ) )
if( m_paltpath && FBitSet( pev->spawnflags, SF_PATH_ALTERNATE ) && FBitSet( pev->spawnflags, SF_PATH_ALTREVERSE ) )
return m_paltpath;
return m_pprevious;
@ -269,12 +268,12 @@ CPathTrack *CPathTrack::GetPrevious( void )
void CPathTrack::SetPrevious( CPathTrack *pprev )
{
// Only set previous if this isn't my alternate path
if ( pprev && !FStrEq( STRING(pprev->pev->targetname), STRING(m_altName) ) )
if( pprev && !FStrEq( STRING( pprev->pev->targetname ), STRING( m_altName ) ) )
m_pprevious = pprev;
}
// Assumes this is ALWAYS enabled
CPathTrack *CPathTrack :: LookAhead( Vector *origin, float dist, int move )
CPathTrack *CPathTrack::LookAhead( Vector *origin, float dist, int move )
{
CPathTrack *pcurrent;
float originalDist = dist;
@ -282,26 +281,26 @@ CPathTrack *CPathTrack :: LookAhead( Vector *origin, float dist, int move )
pcurrent = this;
Vector currentPos = *origin;
if ( dist < 0 ) // Travelling backwards through path
if( dist < 0 ) // Travelling backwards through path
{
dist = -dist;
while ( dist > 0 )
while( dist > 0 )
{
Vector dir = pcurrent->pev->origin - currentPos;
float length = dir.Length();
if ( !length )
if( !length )
{
if ( !ValidPath(pcurrent->GetPrevious(), move) ) // If there is no previous node, or it's disabled, return now.
if( !ValidPath( pcurrent->GetPrevious(), move ) ) // If there is no previous node, or it's disabled, return now.
{
if ( !move )
if( !move )
Project( pcurrent->GetNext(), pcurrent, origin, dist );
return NULL;
}
pcurrent = pcurrent->GetPrevious();
}
else if ( length > dist ) // enough left in this path to move
else if( length > dist ) // enough left in this path to move
{
*origin = currentPos + (dir * (dist / length));
*origin = currentPos + ( dir * ( dist / length ) );
return pcurrent;
}
else
@ -309,7 +308,7 @@ CPathTrack *CPathTrack :: LookAhead( Vector *origin, float dist, int move )
dist -= length;
currentPos = pcurrent->pev->origin;
*origin = currentPos;
if ( !ValidPath(pcurrent->GetPrevious(), move) ) // If there is no previous node, or it's disabled, return now.
if( !ValidPath( pcurrent->GetPrevious(), move ) ) // If there is no previous node, or it's disabled, return now.
return NULL;
pcurrent = pcurrent->GetPrevious();
@ -320,23 +319,23 @@ CPathTrack *CPathTrack :: LookAhead( Vector *origin, float dist, int move )
}
else
{
while ( dist > 0 )
while( dist > 0 )
{
if ( !ValidPath(pcurrent->GetNext(), move) ) // If there is no next node, or it's disabled, return now.
if( !ValidPath( pcurrent->GetNext(), move ) ) // If there is no next node, or it's disabled, return now.
{
if ( !move )
if( !move )
Project( pcurrent->GetPrevious(), pcurrent, origin, dist );
return NULL;
}
Vector dir = pcurrent->GetNext()->pev->origin - currentPos;
float length = dir.Length();
if ( !length && !ValidPath( pcurrent->GetNext()->GetNext(), move ) )
if( !length && !ValidPath( pcurrent->GetNext()->GetNext(), move ) )
{
if ( dist == originalDist ) // HACK -- up against a dead end
return NULL;
return pcurrent;
}
if ( length > dist ) // enough left in this path to move
if( length > dist ) // enough left in this path to move
{
*origin = currentPos + (dir * (dist / length));
return pcurrent;
@ -356,14 +355,13 @@ CPathTrack *CPathTrack :: LookAhead( Vector *origin, float dist, int move )
}
// Assumes this is ALWAYS enabled
CPathTrack *CPathTrack :: Nearest( Vector origin )
CPathTrack *CPathTrack::Nearest( Vector origin )
{
int deadCount;
float minDist, dist;
Vector delta;
CPathTrack *ppath, *pnearest;
delta = origin - pev->origin;
delta.z = 0;
minDist = delta.Length();
@ -372,18 +370,18 @@ CPathTrack *CPathTrack :: Nearest( Vector origin )
// Hey, I could use the old 2 racing pointers solution to this, but I'm lazy :)
deadCount = 0;
while ( ppath && ppath != this )
while( ppath && ppath != this )
{
deadCount++;
if ( deadCount > 9999 )
if( deadCount > 9999 )
{
ALERT( at_error, "Bad sequence of path_tracks from %s", STRING(pev->targetname) );
ALERT( at_error, "Bad sequence of path_tracks from %s", STRING( pev->targetname ) );
return NULL;
}
delta = origin - ppath->pev->origin;
delta.z = 0;
dist = delta.Length();
if ( dist < minDist )
if( dist < minDist )
{
minDist = dist;
pnearest = ppath;
@ -395,20 +393,19 @@ CPathTrack *CPathTrack :: Nearest( Vector origin )
CPathTrack *CPathTrack::Instance( edict_t *pent )
{
if ( FClassnameIs( pent, "path_track" ) )
return (CPathTrack *)GET_PRIVATE(pent);
if( FClassnameIs( pent, "path_track" ) )
return (CPathTrack *)GET_PRIVATE( pent );
return NULL;
}
// DEBUGGING CODE
#if PATH_SPARKLE_DEBUG
void CPathTrack :: Sparkle( void )
void CPathTrack::Sparkle( void )
{
pev->nextthink = gpGlobals->time + 0.2;
if ( FBitSet( pev->spawnflags, SF_PATH_DISABLED ) )
UTIL_ParticleEffect(pev->origin, Vector(0,0,100), 210, 10);
if( FBitSet( pev->spawnflags, SF_PATH_DISABLED ) )
UTIL_ParticleEffect( pev->origin, Vector( 0, 0,100 ), 210, 10 );
else
UTIL_ParticleEffect(pev->origin, Vector(0,0,100), 84, 10);
UTIL_ParticleEffect( pev->origin, Vector( 0, 0, 100 ), 84, 10 );
}
#endif

14
dlls/plane.cpp
View File

@ -19,7 +19,7 @@
//=========================================================
// Plane
//=========================================================
CPlane :: CPlane ( void )
CPlane::CPlane( void )
{
m_fInitialized = FALSE;
}
@ -28,10 +28,10 @@ CPlane :: CPlane ( void )
// InitializePlane - Takes a normal for the plane and a
// point on the plane and
//=========================================================
void CPlane :: InitializePlane ( const Vector &vecNormal, const Vector &vecPoint )
void CPlane::InitializePlane( const Vector &vecNormal, const Vector &vecPoint )
{
m_vecNormal = vecNormal;
m_flDist = DotProduct ( m_vecNormal, vecPoint );
m_flDist = DotProduct( m_vecNormal, vecPoint );
m_fInitialized = TRUE;
}
@ -39,18 +39,18 @@ void CPlane :: InitializePlane ( const Vector &vecNormal, const Vector &vecPoint
// PointInFront - determines whether the given vector is
// in front of the plane.
//=========================================================
BOOL CPlane :: PointInFront ( const Vector &vecPoint )
BOOL CPlane::PointInFront( const Vector &vecPoint )
{
float flFace;
if ( !m_fInitialized )
if( !m_fInitialized )
{
return FALSE;
}
flFace = DotProduct ( m_vecNormal, vecPoint ) - m_flDist;
flFace = DotProduct( m_vecNormal, vecPoint ) - m_flDist;
if ( flFace >= 0 )
if( flFace >= 0 )
{
return TRUE;
}

5
dlls/plane.h
View File

@ -21,7 +21,7 @@
class CPlane
{
public:
CPlane ( void );
CPlane( void );
//=========================================================
// InitializePlane - Takes a normal for the plane and a
@ -33,11 +33,10 @@ public:
// PointInFront - determines whether the given vector is
// in front of the plane.
//=========================================================
BOOL PointInFront ( const Vector &vecPoint );
BOOL PointInFront( const Vector &vecPoint );
Vector m_vecNormal;
float m_flDist;
BOOL m_fInitialized;
};
#endif // PLANE_H

1785
dlls/player.cpp
View File

File diff suppressed because it is too large Load Diff

26
dlls/playermonster.cpp
View File

@ -28,9 +28,9 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int Classify ( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
int ISoundMask ( void );
int ISoundMask( void );
};
LINK_ENTITY_TO_CLASS( monster_player, CPlayerMonster )
@ -39,7 +39,7 @@ LINK_ENTITY_TO_CLASS( monster_player, CPlayerMonster )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CPlayerMonster :: Classify ( void )
int CPlayerMonster::Classify( void )
{
return CLASS_PLAYER_ALLY;
}
@ -48,11 +48,11 @@ int CPlayerMonster :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CPlayerMonster :: SetYawSpeed ( void )
void CPlayerMonster::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_IDLE:
default:
@ -80,7 +80,7 @@ void CPlayerMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// ISoundMask - player monster can't hear.
//=========================================================
int CPlayerMonster :: ISoundMask ( void )
int CPlayerMonster::ISoundMask( void )
{
return NULL;
}
@ -88,12 +88,12 @@ int CPlayerMonster :: ISoundMask ( void )
//=========================================================
// Spawn
//=========================================================
void CPlayerMonster :: Spawn()
void CPlayerMonster::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/player.mdl");
UTIL_SetSize(pev, VEC_HULL_MIN, VEC_HULL_MAX);
SET_MODEL( ENT( pev ), "models/player.mdl" );
UTIL_SetSize( pev, VEC_HULL_MIN, VEC_HULL_MAX );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
@ -103,7 +103,7 @@ void CPlayerMonster :: Spawn()
m_MonsterState = MONSTERSTATE_NONE;
MonsterInit();
if ( pev->spawnflags & SF_MONSTERPLAYER_NOTSOLID )
if( pev->spawnflags & SF_MONSTERPLAYER_NOTSOLID )
{
pev->solid = SOLID_NOT;
pev->takedamage = DAMAGE_NO;
@ -113,9 +113,9 @@ void CPlayerMonster :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CPlayerMonster :: Precache()
void CPlayerMonster::Precache()
{
PRECACHE_MODEL("models/player.mdl");
PRECACHE_MODEL( "models/player.mdl" );
}
//=========================================================

116
dlls/python.cpp
View File

@ -22,8 +22,8 @@
#include "player.h"
#include "gamerules.h"
enum python_e {
enum python_e
{
PYTHON_IDLE1 = 0,
PYTHON_FIDGET,
PYTHON_FIRE1,
@ -37,9 +37,9 @@ enum python_e {
LINK_ENTITY_TO_CLASS( weapon_python, CPython )
LINK_ENTITY_TO_CLASS( weapon_357, CPython )
int CPython::GetItemInfo(ItemInfo *p)
int CPython::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "357";
p->iMaxAmmo1 = _357_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -56,7 +56,7 @@ int CPython::GetItemInfo(ItemInfo *p)
int CPython::AddToPlayer( CBasePlayer *pPlayer )
{
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
WRITE_BYTE( m_iId );
@ -66,12 +66,12 @@ int CPython::AddToPlayer( CBasePlayer *pPlayer )
return FALSE;
}
void CPython::Spawn( )
void CPython::Spawn()
{
pev->classname = MAKE_STRING("weapon_357"); // hack to allow for old names
Precache( );
pev->classname = MAKE_STRING( "weapon_357" ); // hack to allow for old names
Precache();
m_iId = WEAPON_PYTHON;
SET_MODEL(ENT(pev), "models/w_357.mdl");
SET_MODEL( ENT( pev ), "models/w_357.mdl" );
m_iDefaultAmmo = PYTHON_DEFAULT_GIVE;
@ -80,27 +80,27 @@ void CPython::Spawn( )
void CPython::Precache( void )
{
PRECACHE_MODEL("models/v_357.mdl");
PRECACHE_MODEL("models/w_357.mdl");
PRECACHE_MODEL("models/p_357.mdl");
PRECACHE_MODEL( "models/v_357.mdl" );
PRECACHE_MODEL( "models/w_357.mdl" );
PRECACHE_MODEL( "models/p_357.mdl" );
PRECACHE_MODEL("models/w_357ammobox.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_357ammobox.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
PRECACHE_SOUND ("weapons/357_reload1.wav");
PRECACHE_SOUND ("weapons/357_cock1.wav");
PRECACHE_SOUND ("weapons/357_shot1.wav");
PRECACHE_SOUND ("weapons/357_shot2.wav");
PRECACHE_SOUND( "weapons/357_reload1.wav" );
PRECACHE_SOUND( "weapons/357_cock1.wav" );
PRECACHE_SOUND( "weapons/357_shot1.wav" );
PRECACHE_SOUND( "weapons/357_shot2.wav" );
m_usFirePython = PRECACHE_EVENT( 1, "events/python.sc" );
}
BOOL CPython::Deploy( )
BOOL CPython::Deploy()
{
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
// enable laser sight geometry.
@ -118,7 +118,7 @@ void CPython::Holster( int skiplocal /* = 0 */ )
{
m_fInReload = FALSE;// cancel any reload in progress.
if ( m_fInZoom )
if( m_fInZoom )
{
SecondaryAttack();
}
@ -131,20 +131,20 @@ void CPython::Holster( int skiplocal /* = 0 */ )
void CPython::SecondaryAttack( void )
{
#ifdef CLIENT_DLL
if ( !bIsMultiplayer() )
if( !bIsMultiplayer() )
#else
if ( !g_pGameRules->IsMultiplayer() )
if( !g_pGameRules->IsMultiplayer() )
#endif
{
return;
}
if ( m_pPlayer->pev->fov != 0 )
if( m_pPlayer->pev->fov != 0 )
{
m_fInZoom = FALSE;
m_pPlayer->pev->fov = m_pPlayer->m_iFOV = 0; // 0 means reset to default fov
}
else if ( m_pPlayer->pev->fov != 40 )
else if( m_pPlayer->pev->fov != 40 )
{
m_fInZoom = TRUE;
m_pPlayer->pev->fov = m_pPlayer->m_iFOV = 40;
@ -156,20 +156,20 @@ void CPython::SecondaryAttack( void )
void CPython::PrimaryAttack()
{
// don't fire underwater
if (m_pPlayer->pev->waterlevel == 3)
if( m_pPlayer->pev->waterlevel == 3 )
{
PlayEmptySound( );
PlayEmptySound();
m_flNextPrimaryAttack = 0.15;
return;
}
if (m_iClip <= 0)
if( m_iClip <= 0 )
{
if (!m_fFireOnEmpty)
Reload( );
if( !m_fFireOnEmpty )
Reload();
else
{
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/357_cock1.wav", 0.8, ATTN_NORM);
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/357_cock1.wav", 0.8, ATTN_NORM );
m_flNextPrimaryAttack = 0.15;
}
@ -181,14 +181,14 @@ void CPython::PrimaryAttack()
m_iClip--;
m_pPlayer->pev->effects = (int)(m_pPlayer->pev->effects) | EF_MUZZLEFLASH;
m_pPlayer->pev->effects = (int)( m_pPlayer->pev->effects ) | EF_MUZZLEFLASH;
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
UTIL_MakeVectors( m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle );
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecSrc = m_pPlayer->GetGunPosition();
Vector vecAiming = m_pPlayer->GetAutoaimVector( AUTOAIM_10DEGREES );
Vector vecDir;
@ -202,9 +202,9 @@ void CPython::PrimaryAttack()
#endif
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usFirePython, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, vecDir.x, vecDir.y, 0, 0, 0, 0 );
if (!m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
if( !m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
// HEV suit - indicate out of ammo condition
m_pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
m_pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 );
m_flNextPrimaryAttack = 0.75;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
@ -212,10 +212,10 @@ void CPython::PrimaryAttack()
void CPython::Reload( void )
{
if ( m_pPlayer->ammo_357 <= 0 )
if( m_pPlayer->ammo_357 <= 0 )
return;
if ( m_pPlayer->pev->fov != 0 )
if( m_pPlayer->pev->fov != 0 )
{
m_fInZoom = FALSE;
m_pPlayer->pev->fov = m_pPlayer->m_iFOV = 0; // 0 means reset to default fov
@ -227,8 +227,7 @@ void CPython::Reload( void )
#else
bUseScope = g_pGameRules->IsMultiplayer();
#endif
if (DefaultReload( 6, PYTHON_RELOAD, 2.0, bUseScope ))
if( DefaultReload( 6, PYTHON_RELOAD, 2.0, bUseScope ) )
{
m_flSoundDelay = 1.5;
}
@ -236,41 +235,41 @@ void CPython::Reload( void )
void CPython::WeaponIdle( void )
{
ResetEmptySound( );
ResetEmptySound();
m_pPlayer->GetAutoaimVector( AUTOAIM_10DEGREES );
// ALERT( at_console, "%.2f\n", gpGlobals->time - m_flSoundDelay );
if (m_flSoundDelay != 0 && m_flSoundDelay <= UTIL_WeaponTimeBase() )
if( m_flSoundDelay != 0 && m_flSoundDelay <= UTIL_WeaponTimeBase() )
{
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/357_reload1.wav", RANDOM_FLOAT(0.8, 0.9), ATTN_NORM);
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "weapons/357_reload1.wav", RANDOM_FLOAT( 0.8, 0.9 ), ATTN_NORM );
m_flSoundDelay = 0;
}
if (m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
int iAnim;
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0.0f, 1.0f );
if (flRand <= 0.5)
if( flRand <= 0.5 )
{
iAnim = PYTHON_IDLE1;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + (70.0/30.0);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + ( 70.0 / 30.0 );
}
else if (flRand <= 0.7)
else if( flRand <= 0.7 )
{
iAnim = PYTHON_IDLE2;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + (60.0/30.0);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + ( 60.0 / 30.0 );
}
else if (flRand <= 0.9)
else if( flRand <= 0.9 )
{
iAnim = PYTHON_IDLE3;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + (88.0/30.0);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + ( 88.0 / 30.0 );
}
else
{
iAnim = PYTHON_FIDGET;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + (170.0/30.0);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + ( 170.0 / 30.0 );
}
int bUseScope = FALSE;
@ -279,7 +278,6 @@ void CPython::WeaponIdle( void )
#else
bUseScope = g_pGameRules->IsMultiplayer();
#endif
SendWeaponAnim( iAnim, UseDecrement() ? 1 : 0, bUseScope );
}
@ -287,20 +285,20 @@ class CPythonAmmo : public CBasePlayerAmmo
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_357ammobox.mdl");
CBasePlayerAmmo::Spawn( );
Precache();
SET_MODEL( ENT(pev), "models/w_357ammobox.mdl" );
CBasePlayerAmmo::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_357ammobox.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_357ammobox.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
}
BOOL AddAmmo( CBaseEntity *pOther )
{
if (pOther->GiveAmmo( AMMO_357BOX_GIVE, "357", _357_MAX_CARRY ) != -1)
if( pOther->GiveAmmo( AMMO_357BOX_GIVE, "357", _357_MAX_CARRY ) != -1 )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
return TRUE;
}
return FALSE;

20
dlls/rat.cpp
View File

@ -32,7 +32,7 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int Classify ( void );
int Classify( void );
};
LINK_ENTITY_TO_CLASS( monster_rat, CRat )
@ -41,7 +41,7 @@ LINK_ENTITY_TO_CLASS( monster_rat, CRat )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CRat :: Classify ( void )
int CRat::Classify( void )
{
return CLASS_INSECT;
}
@ -50,11 +50,11 @@ int CRat :: Classify ( void )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CRat :: SetYawSpeed ( void )
void CRat::SetYawSpeed( void )
{
int ys;
switch ( m_Activity )
switch( m_Activity )
{
case ACT_IDLE:
default:
@ -68,18 +68,18 @@ void CRat :: SetYawSpeed ( void )
//=========================================================
// Spawn
//=========================================================
void CRat :: Spawn()
void CRat::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/bigrat.mdl");
SET_MODEL( ENT( pev ), "models/bigrat.mdl" );
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_RED;
pev->health = 8;
pev->view_ofs = Vector ( 0, 0, 6 );// position of the eyes relative to monster's origin.
pev->view_ofs = Vector( 0, 0, 6 );// position of the eyes relative to monster's origin.
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
@ -89,9 +89,9 @@ void CRat :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CRat :: Precache()
void CRat::Precache()
{
PRECACHE_MODEL("models/bigrat.mdl");
PRECACHE_MODEL( "models/bigrat.mdl" );
}
//=========================================================

197
dlls/roach.cpp
View File

@ -41,22 +41,23 @@ public:
void Precache( void );
void SetYawSpeed( void );
void EXPORT MonsterThink ( void );
void Move ( float flInterval );
void PickNewDest ( int iCondition );
void EXPORT Touch ( CBaseEntity *pOther );
void Move( float flInterval );
void PickNewDest( int iCondition );
void EXPORT Touch( CBaseEntity *pOther );
void Killed( entvars_t *pevAttacker, int iGib );
float m_flLastLightLevel;
float m_flNextSmellTime;
int Classify ( void );
void Look ( int iDistance );
int ISoundMask ( void );
int Classify( void );
void Look( int iDistance );
int ISoundMask( void );
// UNDONE: These don't necessarily need to be save/restored, but if we add more data, it may
BOOL m_fLightHacked;
int m_iMode;
// -----------------------------
};
LINK_ENTITY_TO_CLASS( monster_cockroach, CRoach )
//=========================================================
@ -64,7 +65,7 @@ LINK_ENTITY_TO_CLASS( monster_cockroach, CRoach )
// of sounds this monster regards. In the base class implementation,
// monsters care about all sounds, but no scents.
//=========================================================
int CRoach :: ISoundMask ( void )
int CRoach::ISoundMask( void )
{
return bits_SOUND_CARCASS | bits_SOUND_MEAT;
}
@ -73,7 +74,7 @@ int CRoach :: ISoundMask ( void )
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CRoach :: Classify ( void )
int CRoach::Classify( void )
{
return CLASS_INSECT;
}
@ -81,21 +82,21 @@ int CRoach :: Classify ( void )
//=========================================================
// Touch
//=========================================================
void CRoach :: Touch ( CBaseEntity *pOther )
void CRoach::Touch( CBaseEntity *pOther )
{
Vector vecSpot;
TraceResult tr;
if ( pOther->pev->velocity == g_vecZero || !pOther->IsPlayer() )
if( pOther->pev->velocity == g_vecZero || !pOther->IsPlayer() )
{
return;
}
vecSpot = pev->origin + Vector ( 0 , 0 , 8 );//move up a bit, and trace down.
UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -24 ), ignore_monsters, ENT(pev), & tr);
vecSpot = pev->origin + Vector( 0, 0, 8 );//move up a bit, and trace down.
UTIL_TraceLine( vecSpot, vecSpot + Vector( 0, 0, -24 ), ignore_monsters, ENT( pev ), &tr );
// This isn't really blood. So you don't have to screen it out based on violence levels (UTIL_ShouldShowBlood())
UTIL_DecalTrace( &tr, DECAL_YBLOOD1 +RANDOM_LONG(0,5) );
UTIL_DecalTrace( &tr, DECAL_YBLOOD1 + RANDOM_LONG( 0, 5 ) );
TakeDamage( pOther->pev, pOther->pev, pev->health, DMG_CRUSH );
}
@ -104,7 +105,7 @@ void CRoach :: Touch ( CBaseEntity *pOther )
// SetYawSpeed - allows each sequence to have a different
// turn rate associated with it.
//=========================================================
void CRoach :: SetYawSpeed ( void )
void CRoach::SetYawSpeed( void )
{
int ys;
@ -116,11 +117,11 @@ void CRoach :: SetYawSpeed ( void )
//=========================================================
// Spawn
//=========================================================
void CRoach :: Spawn()
void CRoach::Spawn()
{
Precache( );
Precache();
SET_MODEL(ENT(pev), "models/roach.mdl");
SET_MODEL( ENT( pev ), "models/roach.mdl" );
UTIL_SetSize( pev, Vector( -1, -1, 0 ), Vector( 1, 1, 2 ) );
pev->solid = SOLID_SLIDEBOX;
@ -132,9 +133,9 @@ void CRoach :: Spawn()
m_MonsterState = MONSTERSTATE_NONE;
MonsterInit();
SetActivity ( ACT_IDLE );
SetActivity( ACT_IDLE );
pev->view_ofs = Vector ( 0, 0, 1 );// position of the eyes relative to monster's origin.
pev->view_ofs = Vector( 0, 0, 1 );// position of the eyes relative to monster's origin.
pev->takedamage = DAMAGE_YES;
m_fLightHacked = FALSE;
m_flLastLightLevel = -1;
@ -145,37 +146,36 @@ void CRoach :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CRoach :: Precache()
void CRoach::Precache()
{
PRECACHE_MODEL("models/roach.mdl");
PRECACHE_MODEL( "models/roach.mdl" );
PRECACHE_SOUND("roach/rch_die.wav");
PRECACHE_SOUND("roach/rch_walk.wav");
PRECACHE_SOUND("roach/rch_smash.wav");
PRECACHE_SOUND( "roach/rch_die.wav" );
PRECACHE_SOUND( "roach/rch_walk.wav" );
PRECACHE_SOUND( "roach/rch_smash.wav" );
}
//=========================================================
// Killed.
//=========================================================
void CRoach :: Killed( entvars_t *pevAttacker, int iGib )
void CRoach::Killed( entvars_t *pevAttacker, int iGib )
{
pev->solid = SOLID_NOT;
//random sound
if ( RANDOM_LONG(0,4) == 1 )
if( RANDOM_LONG( 0, 4 ) == 1 )
{
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "roach/rch_die.wav", 0.8, ATTN_NORM, 0, 80 + RANDOM_LONG(0,39) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "roach/rch_die.wav", 0.8, ATTN_NORM, 0, 80 + RANDOM_LONG( 0, 39 ) );
}
else
{
EMIT_SOUND_DYN(ENT(pev), CHAN_BODY, "roach/rch_smash.wav", 0.7, ATTN_NORM, 0, 80 + RANDOM_LONG(0,39) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "roach/rch_smash.wav", 0.7, ATTN_NORM, 0, 80 + RANDOM_LONG( 0, 39 ) );
}
CSoundEnt::InsertSound ( bits_SOUND_WORLD, pev->origin, 128, 1 );
CSoundEnt::InsertSound( bits_SOUND_WORLD, pev->origin, 128, 1 );
CBaseEntity *pOwner = CBaseEntity::Instance(pev->owner);
if ( pOwner )
CBaseEntity *pOwner = CBaseEntity::Instance( pev->owner );
if( pOwner )
{
pOwner->DeathNotice( pev );
}
@ -185,16 +185,16 @@ void CRoach :: Killed( entvars_t *pevAttacker, int iGib )
//=========================================================
// MonsterThink, overridden for roaches.
//=========================================================
void CRoach :: MonsterThink( void )
void CRoach::MonsterThink( void )
{
if ( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
pev->nextthink = gpGlobals->time + RANDOM_FLOAT(1,1.5);
if( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
pev->nextthink = gpGlobals->time + RANDOM_FLOAT( 1, 1.5 );
else
pev->nextthink = gpGlobals->time + 0.1;// keep monster thinking
float flInterval = StudioFrameAdvance( ); // animate
float flInterval = StudioFrameAdvance(); // animate
if ( !m_fLightHacked )
if( !m_fLightHacked )
{
// if light value hasn't been collection for the first time yet,
// suspend the creature for a second so the world finishes spawning, then we'll collect the light level.
@ -202,70 +202,70 @@ void CRoach :: MonsterThink( void )
m_fLightHacked = TRUE;
return;
}
else if ( m_flLastLightLevel < 0 )
else if( m_flLastLightLevel < 0 )
{
// collect light level for the first time, now that all of the lightmaps in the roach's area have been calculated.
m_flLastLightLevel = GETENTITYILLUM( ENT( pev ) );
}
switch ( m_iMode )
switch( m_iMode )
{
case ROACH_IDLE:
case ROACH_EAT:
{
// if not moving, sample environment to see if anything scary is around. Do a radius search 'look' at random.
if ( RANDOM_LONG(0,3) == 1 )
if( RANDOM_LONG( 0, 3 ) == 1 )
{
Look( 150 );
if (HasConditions(bits_COND_SEE_FEAR))
if( HasConditions( bits_COND_SEE_FEAR ) )
{
// if see something scary
//ALERT ( at_aiconsole, "Scared\n" );
Eat( 30 + ( RANDOM_LONG(0,14) ) );// roach will ignore food for 30 to 45 seconds
//ALERT( at_aiconsole, "Scared\n" );
Eat( 30 + ( RANDOM_LONG( 0, 14 ) ) );// roach will ignore food for 30 to 45 seconds
PickNewDest( ROACH_SCARED_BY_ENT );
SetActivity ( ACT_WALK );
SetActivity( ACT_WALK );
}
else if ( RANDOM_LONG(0,149) == 1 )
else if( RANDOM_LONG( 0, 149 ) == 1 )
{
// if roach doesn't see anything, there's still a chance that it will move. (boredom)
//ALERT ( at_aiconsole, "Bored\n" );
//ALERT( at_aiconsole, "Bored\n" );
PickNewDest( ROACH_BORED );
SetActivity ( ACT_WALK );
SetActivity( ACT_WALK );
if ( m_iMode == ROACH_EAT )
if( m_iMode == ROACH_EAT )
{
// roach will ignore food for 30 to 45 seconds if it got bored while eating.
Eat( 30 + ( RANDOM_LONG(0,14) ) );
Eat( 30 + ( RANDOM_LONG( 0, 14 ) ) );
}
}
}
// don't do this stuff if eating!
if ( m_iMode == ROACH_IDLE )
if( m_iMode == ROACH_IDLE )
{
if ( FShouldEat() )
if( FShouldEat() )
{
Listen();
}
if ( GETENTITYILLUM( ENT(pev) ) > m_flLastLightLevel )
if( GETENTITYILLUM( ENT( pev ) ) > m_flLastLightLevel )
{
// someone turned on lights!
//ALERT ( at_console, "Lights!\n" );
//ALERT( at_console, "Lights!\n" );
PickNewDest( ROACH_SCARED_BY_LIGHT );
SetActivity ( ACT_WALK );
SetActivity( ACT_WALK );
}
else if ( HasConditions(bits_COND_SMELL_FOOD) )
else if( HasConditions( bits_COND_SMELL_FOOD ) )
{
CSound *pSound;
pSound = CSoundEnt::SoundPointerForIndex( m_iAudibleList );
// roach smells food and is just standing around. Go to food unless food isn't on same z-plane.
if ( pSound && fabs( pSound->m_vecOrigin.z - pev->origin.z ) <= 3.0 )
if( pSound && fabs( pSound->m_vecOrigin.z - pev->origin.z ) <= 3.0 )
{
PickNewDest( ROACH_SMELL_FOOD );
SetActivity ( ACT_WALK );
SetActivity( ACT_WALK );
}
}
}
@ -275,16 +275,16 @@ void CRoach :: MonsterThink( void )
case ROACH_SCARED_BY_LIGHT:
{
// if roach was scared by light, then stop if we're over a spot at least as dark as where we started!
if ( GETENTITYILLUM( ENT( pev ) ) <= m_flLastLightLevel )
if( GETENTITYILLUM( ENT( pev ) ) <= m_flLastLightLevel )
{
SetActivity ( ACT_IDLE );
m_flLastLightLevel = GETENTITYILLUM( ENT ( pev ) );// make this our new light level.
SetActivity( ACT_IDLE );
m_flLastLightLevel = GETENTITYILLUM( ENT( pev ) );// make this our new light level.
}
break;
}
}
if ( m_flGroundSpeed != 0 )
if( m_flGroundSpeed != 0 )
{
Move( flInterval );
}
@ -293,7 +293,7 @@ void CRoach :: MonsterThink( void )
//=========================================================
// Picks a new spot for roach to run to.(
//=========================================================
void CRoach :: PickNewDest ( int iCondition )
void CRoach::PickNewDest( int iCondition )
{
Vector vecNewDir;
Vector vecDest;
@ -301,20 +301,20 @@ void CRoach :: PickNewDest ( int iCondition )
m_iMode = iCondition;
if ( m_iMode == ROACH_SMELL_FOOD )
if( m_iMode == ROACH_SMELL_FOOD )
{
// find the food and go there.
CSound *pSound;
pSound = CSoundEnt::SoundPointerForIndex( m_iAudibleList );
if ( pSound )
if( pSound )
{
m_Route[ 0 ].vecLocation.x = pSound->m_vecOrigin.x + ( 3 - RANDOM_LONG(0,5) );
m_Route[ 0 ].vecLocation.y = pSound->m_vecOrigin.y + ( 3 - RANDOM_LONG(0,5) );
m_Route[ 0 ].vecLocation.z = pSound->m_vecOrigin.z;
m_Route[ 0 ].iType = bits_MF_TO_LOCATION;
m_movementGoal = RouteClassify( m_Route[ 0 ].iType );
m_Route[0].vecLocation.x = pSound->m_vecOrigin.x + ( 3 - RANDOM_LONG( 0, 5 ) );
m_Route[0].vecLocation.y = pSound->m_vecOrigin.y + ( 3 - RANDOM_LONG( 0, 5 ) );
m_Route[0].vecLocation.z = pSound->m_vecOrigin.z;
m_Route[0].iType = bits_MF_TO_LOCATION;
m_movementGoal = RouteClassify( m_Route[0].iType );
return;
}
}
@ -326,60 +326,60 @@ void CRoach :: PickNewDest ( int iCondition )
// circles. this is a hack but buys me time to work on the real monsters.
vecNewDir.x = RANDOM_FLOAT( -1, 1 );
vecNewDir.y = RANDOM_FLOAT( -1, 1 );
flDist = 256 + ( RANDOM_LONG(0,255) );
flDist = 256 + ( RANDOM_LONG( 0, 255 ) );
vecDest = pev->origin + vecNewDir * flDist;
} while ( ( vecDest - pev->origin ).Length2D() < 128 );
} while( ( vecDest - pev->origin ).Length2D() < 128 );
m_Route[ 0 ].vecLocation.x = vecDest.x;
m_Route[ 0 ].vecLocation.y = vecDest.y;
m_Route[ 0 ].vecLocation.z = pev->origin.z;
m_Route[ 0 ].iType = bits_MF_TO_LOCATION;
m_movementGoal = RouteClassify( m_Route[ 0 ].iType );
m_Route[0].vecLocation.x = vecDest.x;
m_Route[0].vecLocation.y = vecDest.y;
m_Route[0].vecLocation.z = pev->origin.z;
m_Route[0].iType = bits_MF_TO_LOCATION;
m_movementGoal = RouteClassify( m_Route[0].iType );
if ( RANDOM_LONG(0,9) == 1 )
if( RANDOM_LONG( 0, 9 ) == 1 )
{
// every once in a while, a roach will play a skitter sound when they decide to run
EMIT_SOUND_DYN(ENT(pev), CHAN_BODY, "roach/rch_walk.wav", 1, ATTN_NORM, 0, 80 + RANDOM_LONG(0,39) );
EMIT_SOUND_DYN( ENT( pev ), CHAN_BODY, "roach/rch_walk.wav", 1, ATTN_NORM, 0, 80 + RANDOM_LONG( 0, 39 ) );
}
}
//=========================================================
// roach's move function
//=========================================================
void CRoach :: Move ( float flInterval )
void CRoach::Move( float flInterval )
{
float flWaypointDist;
Vector vecApex;
// local move to waypoint.
flWaypointDist = ( m_Route[ m_iRouteIndex ].vecLocation - pev->origin ).Length2D();
MakeIdealYaw ( m_Route[ m_iRouteIndex ].vecLocation );
flWaypointDist = ( m_Route[m_iRouteIndex].vecLocation - pev->origin ).Length2D();
MakeIdealYaw( m_Route[m_iRouteIndex].vecLocation );
ChangeYaw ( pev->yaw_speed );
ChangeYaw( pev->yaw_speed );
UTIL_MakeVectors( pev->angles );
if ( RANDOM_LONG(0,7) == 1 )
if( RANDOM_LONG( 0, 7 ) == 1 )
{
// randomly check for blocked path.(more random load balancing)
if ( !WALK_MOVE( ENT(pev), pev->ideal_yaw, 4, WALKMOVE_NORMAL ) )
if( !WALK_MOVE( ENT( pev ), pev->ideal_yaw, 4, WALKMOVE_NORMAL ) )
{
// stuck, so just pick a new spot to run off to
PickNewDest( m_iMode );
}
}
WALK_MOVE( ENT(pev), pev->ideal_yaw, m_flGroundSpeed * flInterval, WALKMOVE_NORMAL );
WALK_MOVE( ENT( pev ), pev->ideal_yaw, m_flGroundSpeed * flInterval, WALKMOVE_NORMAL );
// if the waypoint is closer than step size, then stop after next step (ok for roach to overshoot)
if ( flWaypointDist <= m_flGroundSpeed * flInterval )
if( flWaypointDist <= m_flGroundSpeed * flInterval )
{
// take truncated step and stop
SetActivity ( ACT_IDLE );
m_flLastLightLevel = GETENTITYILLUM( ENT ( pev ) );// this is roach's new comfortable light level
SetActivity( ACT_IDLE );
m_flLastLightLevel = GETENTITYILLUM( ENT( pev ) );// this is roach's new comfortable light level
if ( m_iMode == ROACH_SMELL_FOOD )
if( m_iMode == ROACH_SMELL_FOOD )
{
m_iMode = ROACH_EAT;
}
@ -389,7 +389,7 @@ void CRoach :: Move ( float flInterval )
}
}
if ( RANDOM_LONG(0,149) == 1 && m_iMode != ROACH_SCARED_BY_LIGHT && m_iMode != ROACH_SMELL_FOOD )
if( RANDOM_LONG( 0, 149 ) == 1 && m_iMode != ROACH_SCARED_BY_LIGHT && m_iMode != ROACH_SMELL_FOOD )
{
// random skitter while moving as long as not on a b-line to get out of light or going to food
PickNewDest( FALSE );
@ -400,18 +400,18 @@ void CRoach :: Move ( float flInterval )
// Look - overriden for the roach, which can virtually see
// 360 degrees.
//=========================================================
void CRoach :: Look ( int iDistance )
void CRoach::Look( int iDistance )
{
CBaseEntity *pSightEnt = NULL;// the current visible entity that we're dealing with
CBaseEntity *pPreviousEnt;// the last entity added to the link list
int iSighted = 0;
// DON'T let visibility information from last frame sit around!
ClearConditions( bits_COND_SEE_HATE |bits_COND_SEE_DISLIKE | bits_COND_SEE_ENEMY | bits_COND_SEE_FEAR );
ClearConditions( bits_COND_SEE_HATE | bits_COND_SEE_DISLIKE | bits_COND_SEE_ENEMY | bits_COND_SEE_FEAR );
// don't let monsters outside of the player's PVS act up, or most of the interesting
// things will happen before the player gets there!
if ( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
if( FNullEnt( FIND_CLIENT_IN_PVS( edict() ) ) )
{
return;
}
@ -422,12 +422,12 @@ void CRoach :: Look ( int iDistance )
// Does sphere also limit itself to PVS?
// Examine all entities within a reasonable radius
// !!!PERFORMANCE - let's trivially reject the ent list before radius searching!
while ((pSightEnt = UTIL_FindEntityInSphere( pSightEnt, pev->origin, iDistance )) != NULL)
while( ( pSightEnt = UTIL_FindEntityInSphere( pSightEnt, pev->origin, iDistance ) ) != NULL )
{
// only consider ents that can be damaged. !!!temporarily only considering other monsters and clients
if ( pSightEnt->IsPlayer() || FBitSet ( pSightEnt->pev->flags, FL_MONSTER ) )
if( pSightEnt->IsPlayer() || FBitSet( pSightEnt->pev->flags, FL_MONSTER ) )
{
if ( /*FVisible( pSightEnt ) &&*/ !FBitSet( pSightEnt->pev->flags, FL_NOTARGET ) && pSightEnt->pev->health > 0 )
if( /*FVisible( pSightEnt ) &&*/ !FBitSet( pSightEnt->pev->flags, FL_NOTARGET ) && pSightEnt->pev->health > 0 )
{
// NULL the Link pointer for each ent added to the link list. If other ents follow, the will overwrite
// this value. If this ent happens to be the last, the list will be properly terminated.
@ -437,7 +437,7 @@ void CRoach :: Look ( int iDistance )
// don't add the Enemy's relationship to the conditions. We only want to worry about conditions when
// we see monsters other than the Enemy.
switch ( IRelationship ( pSightEnt ) )
switch( IRelationship( pSightEnt ) )
{
case R_FR:
iSighted |= bits_COND_SEE_FEAR;
@ -445,7 +445,7 @@ void CRoach :: Look ( int iDistance )
case R_NO:
break;
default:
ALERT ( at_console, "%s can't asses %s\n", STRING(pev->classname), STRING(pSightEnt->pev->classname ) );
ALERT( at_console, "%s can't asses %s\n", STRING( pev->classname ), STRING( pSightEnt->pev->classname ) );
break;
}
}
@ -457,4 +457,3 @@ void CRoach :: Look ( int iDistance )
//=========================================================
// AI Schedules Specific to this monster
//=========================================================

189
dlls/rpg.cpp
View File

@ -23,10 +23,8 @@
#include "player.h"
#include "gamerules.h"
enum rpg_e {
enum rpg_e
{
RPG_IDLE = 0,
RPG_FIDGET,
RPG_RELOAD, // to reload
@ -52,7 +50,7 @@ CLaserSpot *CLaserSpot::CreateSpot( void )
CLaserSpot *pSpot = GetClassPtr( (CLaserSpot *)NULL );
pSpot->Spawn();
pSpot->pev->classname = MAKE_STRING("laser_spot");
pSpot->pev->classname = MAKE_STRING( "laser_spot" );
return pSpot;
}
@ -61,7 +59,7 @@ CLaserSpot *CLaserSpot::CreateSpot( void )
//=========================================================
void CLaserSpot::Spawn( void )
{
Precache( );
Precache();
pev->movetype = MOVETYPE_NONE;
pev->solid = SOLID_NOT;
@ -69,7 +67,7 @@ void CLaserSpot::Spawn( void )
pev->renderfx = kRenderFxNoDissipation;
pev->renderamt = 255;
SET_MODEL(ENT(pev), "sprites/laserdot.spr");
SET_MODEL( ENT( pev ), "sprites/laserdot.spr" );
UTIL_SetOrigin( pev, pev->origin );
}
@ -96,7 +94,7 @@ void CLaserSpot::Revive( void )
void CLaserSpot::Precache( void )
{
PRECACHE_MODEL("sprites/laserdot.spr");
PRECACHE_MODEL( "sprites/laserdot.spr" );
}
LINK_ENTITY_TO_CLASS( rpg_rocket, CRpgRocket )
@ -120,25 +118,25 @@ CRpgRocket *CRpgRocket::CreateRpgRocket( Vector vecOrigin, Vector vecAngles, CBa
//=========================================================
//=========================================================
void CRpgRocket :: Spawn( void )
void CRpgRocket::Spawn( void )
{
Precache( );
Precache();
// motor
pev->movetype = MOVETYPE_BOUNCE;
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/rpgrocket.mdl");
UTIL_SetSize(pev, Vector( 0, 0, 0), Vector(0, 0, 0));
SET_MODEL( ENT( pev ), "models/rpgrocket.mdl" );
UTIL_SetSize( pev, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
UTIL_SetOrigin( pev, pev->origin );
pev->classname = MAKE_STRING("rpg_rocket");
pev->classname = MAKE_STRING( "rpg_rocket" );
SetThink( &CRpgRocket::IgniteThink );
SetTouch( &CGrenade::ExplodeTouch );
pev->angles.x -= 30;
UTIL_MakeVectors( pev->angles );
pev->angles.x = -(pev->angles.x + 30);
pev->angles.x = -( pev->angles.x + 30 );
pev->velocity = gpGlobals->v_forward * 250;
pev->gravity = 0.5;
@ -150,9 +148,9 @@ void CRpgRocket :: Spawn( void )
//=========================================================
//=========================================================
void CRpgRocket :: RocketTouch ( CBaseEntity *pOther )
void CRpgRocket::RocketTouch( CBaseEntity *pOther )
{
if ( m_pLauncher )
if( m_pLauncher )
{
// my launcher is still around, tell it I'm dead.
m_pLauncher->m_cActiveRockets--;
@ -164,15 +162,14 @@ void CRpgRocket :: RocketTouch ( CBaseEntity *pOther )
//=========================================================
//=========================================================
void CRpgRocket :: Precache( void )
void CRpgRocket::Precache( void )
{
PRECACHE_MODEL("models/rpgrocket.mdl");
m_iTrail = PRECACHE_MODEL("sprites/smoke.spr");
PRECACHE_SOUND ("weapons/rocket1.wav");
PRECACHE_MODEL( "models/rpgrocket.mdl" );
m_iTrail = PRECACHE_MODEL( "sprites/smoke.spr" );
PRECACHE_SOUND( "weapons/rocket1.wav" );
}
void CRpgRocket :: IgniteThink( void )
void CRpgRocket::IgniteThink( void )
{
// pev->movetype = MOVETYPE_TOSS;
@ -180,21 +177,19 @@ void CRpgRocket :: IgniteThink( void )
pev->effects |= EF_LIGHT;
// make rocket sound
EMIT_SOUND( ENT(pev), CHAN_VOICE, "weapons/rocket1.wav", 1, 0.5 );
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_SHORT( entindex() ); // entity
WRITE_SHORT( m_iTrail ); // model
WRITE_BYTE( 40 ); // 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)
m_flIgniteTime = gpGlobals->time;
@ -204,7 +199,7 @@ void CRpgRocket :: IgniteThink( void )
pev->nextthink = gpGlobals->time + 0.1;
}
void CRpgRocket :: FollowThink( void )
void CRpgRocket::FollowThink( void )
{
CBaseEntity *pOther = NULL;
Vector vecTarget;
@ -218,19 +213,19 @@ void CRpgRocket :: FollowThink( void )
flMax = 4096;
// Examine all entities within a reasonable radius
while ((pOther = UTIL_FindEntityByClassname( pOther, "laser_spot" )) != NULL)
while( ( pOther = UTIL_FindEntityByClassname( pOther, "laser_spot" ) ) != NULL )
{
UTIL_TraceLine ( pev->origin, pOther->pev->origin, dont_ignore_monsters, ENT(pev), &tr );
UTIL_TraceLine( pev->origin, pOther->pev->origin, dont_ignore_monsters, ENT( pev ), &tr );
// ALERT( at_console, "%f\n", tr.flFraction );
if (tr.flFraction >= 0.90)
if( tr.flFraction >= 0.90 )
{
vecDir = pOther->pev->origin - pev->origin;
flDist = vecDir.Length( );
vecDir = vecDir.Normalize( );
flDist = vecDir.Length();
vecDir = vecDir.Normalize();
flDot = DotProduct( gpGlobals->v_forward, vecDir );
if ((flDot > 0) && (flDist * (1 - flDot) < flMax))
if( ( flDot > 0 ) && ( flDist * ( 1 - flDot ) < flMax ) )
{
flMax = flDist * (1 - flDot);
flMax = flDist * ( 1 - flDot );
vecTarget = vecDir;
}
}
@ -240,13 +235,13 @@ void CRpgRocket :: FollowThink( void )
// this acceleration and turning math is totally wrong, but it seems to respond well so don't change it.
float flSpeed = pev->velocity.Length();
if (gpGlobals->time - m_flIgniteTime < 1.0)
if( gpGlobals->time - m_flIgniteTime < 1.0 )
{
pev->velocity = pev->velocity * 0.2 + vecTarget * (flSpeed * 0.8 + 400);
if (pev->waterlevel == 3)
pev->velocity = pev->velocity * 0.2 + vecTarget * ( flSpeed * 0.8 + 400 );
if( pev->waterlevel == 3 )
{
// go slow underwater
if (pev->velocity.Length() > 300)
if( pev->velocity.Length() > 300 )
{
pev->velocity = pev->velocity.Normalize() * 300;
}
@ -254,7 +249,7 @@ void CRpgRocket :: FollowThink( void )
}
else
{
if (pev->velocity.Length() > 2000)
if( pev->velocity.Length() > 2000 )
{
pev->velocity = pev->velocity.Normalize() * 2000;
}
@ -262,15 +257,15 @@ void CRpgRocket :: FollowThink( void )
}
else
{
if (pev->effects & EF_LIGHT)
if( pev->effects & EF_LIGHT )
{
pev->effects = 0;
STOP_SOUND( ENT(pev), CHAN_VOICE, "weapons/rocket1.wav" );
STOP_SOUND( ENT( pev ), CHAN_VOICE, "weapons/rocket1.wav" );
}
pev->velocity = pev->velocity * 0.2 + vecTarget * flSpeed * 0.798;
if (pev->waterlevel == 0 && pev->velocity.Length() < 1500)
if( pev->waterlevel == 0 && pev->velocity.Length() < 1500 )
{
Detonate( );
Detonate();
}
}
// ALERT( at_console, "%.0f\n", flSpeed );
@ -283,13 +278,13 @@ void CRpg::Reload( void )
{
int iResult = 0;
if ( m_iClip == 1 )
if( m_iClip == 1 )
{
// don't bother with any of this if don't need to reload.
return;
}
if ( m_pPlayer->ammo_rockets <= 0 )
if( m_pPlayer->ammo_rockets <= 0 )
return;
// because the RPG waits to autoreload when no missiles are active while the LTD is on, the
@ -304,7 +299,7 @@ void CRpg::Reload( void )
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.5;
if ( m_cActiveRockets && m_fSpotActive )
if( m_cActiveRockets && m_fSpotActive )
{
// no reloading when there are active missiles tracking the designator.
// ward off future autoreload attempts by setting next attack time into the future for a bit.
@ -312,33 +307,32 @@ void CRpg::Reload( void )
}
#ifndef CLIENT_DLL
if ( m_pSpot && m_fSpotActive )
if( m_pSpot && m_fSpotActive )
{
m_pSpot->Suspend( 2.1 );
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 2.1;
}
#endif
if ( m_iClip == 0 )
if( m_iClip == 0 )
iResult = DefaultReload( RPG_MAX_CLIP, RPG_RELOAD, 2 );
if ( iResult )
if( iResult )
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
}
void CRpg::Spawn( )
void CRpg::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_RPG;
SET_MODEL(ENT(pev), "models/w_rpg.mdl");
SET_MODEL( ENT( pev ), "models/w_rpg.mdl" );
m_fSpotActive = 1;
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
// more default ammo in multiplay.
@ -354,25 +348,24 @@ void CRpg::Spawn( )
void CRpg::Precache( void )
{
PRECACHE_MODEL("models/w_rpg.mdl");
PRECACHE_MODEL("models/v_rpg.mdl");
PRECACHE_MODEL("models/p_rpg.mdl");
PRECACHE_MODEL( "models/w_rpg.mdl" );
PRECACHE_MODEL( "models/v_rpg.mdl" );
PRECACHE_MODEL( "models/p_rpg.mdl" );
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_SOUND( "items/9mmclip1.wav" );
UTIL_PrecacheOther( "laser_spot" );
UTIL_PrecacheOther( "rpg_rocket" );
PRECACHE_SOUND("weapons/rocketfire1.wav");
PRECACHE_SOUND("weapons/glauncher.wav"); // alternative fire sound
PRECACHE_SOUND( "weapons/rocketfire1.wav" );
PRECACHE_SOUND( "weapons/glauncher.wav" ); // alternative fire sound
m_usRpg = PRECACHE_EVENT ( 1, "events/rpg.sc" );
m_usRpg = PRECACHE_EVENT( 1, "events/rpg.sc" );
}
int CRpg::GetItemInfo(ItemInfo *p)
int CRpg::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "rockets";
p->iMaxAmmo1 = ROCKET_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -389,7 +382,7 @@ int CRpg::GetItemInfo(ItemInfo *p)
int CRpg::AddToPlayer( CBasePlayer *pPlayer )
{
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
WRITE_BYTE( m_iId );
@ -399,9 +392,9 @@ int CRpg::AddToPlayer( CBasePlayer *pPlayer )
return FALSE;
}
BOOL CRpg::Deploy( )
BOOL CRpg::Deploy()
{
if ( m_iClip == 0 )
if( m_iClip == 0 )
{
return DefaultDeploy( "models/v_rpg.mdl", "models/p_rpg.mdl", RPG_DRAW_UL, "rpg" );
}
@ -411,7 +404,7 @@ BOOL CRpg::Deploy( )
BOOL CRpg::CanHolster( void )
{
if ( m_fSpotActive && m_cActiveRockets )
if( m_fSpotActive && m_cActiveRockets )
{
// can't put away while guiding a missile.
return FALSE;
@ -429,7 +422,7 @@ void CRpg::Holster( int skiplocal /* = 0 */ )
SendWeaponAnim( RPG_HOLSTER1 );
#ifndef CLIENT_DLL
if (m_pSpot)
if( m_pSpot )
{
m_pSpot->Killed( NULL, GIB_NEVER );
m_pSpot = NULL;
@ -439,7 +432,7 @@ void CRpg::Holster( int skiplocal /* = 0 */ )
void CRpg::PrimaryAttack()
{
if ( m_iClip )
if( m_iClip )
{
m_pPlayer->m_iWeaponVolume = LOUD_GUN_VOLUME;
m_pPlayer->m_iWeaponFlash = BRIGHT_GUN_FLASH;
@ -449,7 +442,7 @@ void CRpg::PrimaryAttack()
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
UTIL_MakeVectors( m_pPlayer->pev->v_angle );
Vector vecSrc = m_pPlayer->GetGunPosition( ) + gpGlobals->v_forward * 16 + gpGlobals->v_right * 8 + gpGlobals->v_up * -8;
Vector vecSrc = m_pPlayer->GetGunPosition() + gpGlobals->v_forward * 16 + gpGlobals->v_right * 8 + gpGlobals->v_up * -8;
CRpgRocket *pRocket = CRpgRocket::CreateRpgRocket( vecSrc, m_pPlayer->pev->v_angle, m_pPlayer, this );
@ -466,7 +459,6 @@ void CRpg::PrimaryAttack()
#else
flags = 0;
#endif
PLAYBACK_EVENT( flags, m_pPlayer->edict(), m_usRpg );
m_iClip--;
@ -476,18 +468,18 @@ void CRpg::PrimaryAttack()
}
else
{
PlayEmptySound( );
PlayEmptySound();
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.2;
}
UpdateSpot( );
UpdateSpot();
}
void CRpg::SecondaryAttack()
{
m_fSpotActive = ! m_fSpotActive;
m_fSpotActive = !m_fSpotActive;
#ifndef CLIENT_DLL
if (!m_fSpotActive && m_pSpot)
if( !m_fSpotActive && m_pSpot )
{
m_pSpot->Killed( NULL, GIB_NORMAL );
m_pSpot = NULL;
@ -498,20 +490,20 @@ void CRpg::SecondaryAttack()
void CRpg::WeaponIdle( void )
{
UpdateSpot( );
UpdateSpot();
ResetEmptySound( );
ResetEmptySound();
if ( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
if ( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
int iAnim;
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0, 1 );
if (flRand <= 0.75 || m_fSpotActive)
if( flRand <= 0.75 || m_fSpotActive )
{
if ( m_iClip == 0 )
if( m_iClip == 0 )
iAnim = RPG_IDLE_UL;
else
iAnim = RPG_IDLE;
@ -520,7 +512,7 @@ void CRpg::WeaponIdle( void )
}
else
{
if ( m_iClip == 0 )
if( m_iClip == 0 )
iAnim = RPG_FIDGET_UL;
else
iAnim = RPG_FIDGET;
@ -539,19 +531,19 @@ void CRpg::WeaponIdle( void )
void CRpg::UpdateSpot( void )
{
#ifndef CLIENT_DLL
if (m_fSpotActive)
if( m_fSpotActive )
{
if (!m_pSpot)
if( !m_pSpot )
{
m_pSpot = CLaserSpot::CreateSpot();
}
UTIL_MakeVectors( m_pPlayer->pev->v_angle );
Vector vecSrc = m_pPlayer->GetGunPosition( );;
Vector vecSrc = m_pPlayer->GetGunPosition();
Vector vecAiming = gpGlobals->v_forward;
TraceResult tr;
UTIL_TraceLine ( vecSrc, vecSrc + vecAiming * 8192, dont_ignore_monsters, ENT(m_pPlayer->pev), &tr );
UTIL_TraceLine( vecSrc, vecSrc + vecAiming * 8192, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );
UTIL_SetOrigin( m_pSpot->pev, tr.vecEndPos );
}
@ -562,23 +554,22 @@ class CRpgAmmo : public CBasePlayerAmmo
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_rpgammo.mdl");
CBasePlayerAmmo::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_rpgammo.mdl" );
CBasePlayerAmmo::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_rpgammo.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_rpgammo.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
}
BOOL AddAmmo( CBaseEntity *pOther )
{
int iGive;
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
// hand out more ammo per rocket in multiplayer.
@ -589,9 +580,9 @@ class CRpgAmmo : public CBasePlayerAmmo
iGive = AMMO_RPGCLIP_GIVE;
}
if (pOther->GiveAmmo( iGive, "rockets", ROCKET_MAX_CARRY ) != -1)
if( pOther->GiveAmmo( iGive, "rockets", ROCKET_MAX_CARRY ) != -1 )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
return TRUE;
}
return FALSE;

166
dlls/satchel.cpp
View File

@ -23,14 +23,16 @@
#include "player.h"
#include "gamerules.h"
enum satchel_e {
enum satchel_e
{
SATCHEL_IDLE1 = 0,
SATCHEL_FIDGET1,
SATCHEL_DRAW,
SATCHEL_DROP
};
enum satchel_radio_e {
enum satchel_radio_e
{
SATCHEL_RADIO_IDLE1 = 0,
SATCHEL_RADIO_FIDGET1,
SATCHEL_RADIO_DRAW,
@ -63,16 +65,16 @@ void CSatchelCharge::Deactivate( void )
UTIL_Remove( this );
}
void CSatchelCharge :: Spawn( void )
void CSatchelCharge::Spawn( void )
{
Precache( );
Precache();
// motor
pev->movetype = MOVETYPE_BOUNCE;
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/w_satchel.mdl");
//UTIL_SetSize(pev, Vector( -16, -16, -4), Vector(16, 16, 32)); // Old box -- size of headcrab monsters/players get blocked by this
UTIL_SetSize(pev, Vector( -4, -4, -4), Vector(4, 4, 4)); // Uses point-sized, and can be stepped over
SET_MODEL( ENT( pev ), "models/w_satchel.mdl" );
//UTIL_SetSize( pev, Vector( -16, -16, -4 ), Vector( 16, 16, 32 ) ); // Old box -- size of headcrab monsters/players get blocked by this
UTIL_SetSize( pev, Vector( -4, -4, -4 ), Vector( 4, 4, 4 ) ); // Uses point-sized, and can be stepped over
UTIL_SetOrigin( pev, pev->origin );
SetTouch( &CSatchelCharge::SatchelSlide );
@ -84,7 +86,7 @@ void CSatchelCharge :: Spawn( void )
pev->friction = 0.8;
pev->dmg = gSkillData.plrDmgSatchel;
// ResetSequenceInfo( );
// ResetSequenceInfo();
pev->sequence = 1;
}
@ -93,49 +95,49 @@ void CSatchelCharge::SatchelSlide( CBaseEntity *pOther )
entvars_t *pevOther = pOther->pev;
// don't hit the guy that launched this grenade
if ( pOther->edict() == pev->owner )
if( pOther->edict() == pev->owner )
return;
// pev->avelocity = Vector (300, 300, 300);
// pev->avelocity = Vector( 300, 300, 300 );
pev->gravity = 1;// normal gravity now
// HACKHACK - On ground isn't always set, so look for ground underneath
TraceResult tr;
UTIL_TraceLine( pev->origin, pev->origin - Vector(0,0,10), ignore_monsters, edict(), &tr );
UTIL_TraceLine( pev->origin, pev->origin - Vector( 0, 0, 10 ), ignore_monsters, edict(), &tr );
if ( tr.flFraction < 1.0 )
if( tr.flFraction < 1.0 )
{
// add a bit of static friction
pev->velocity = pev->velocity * 0.95;
pev->avelocity = pev->avelocity * 0.9;
// play sliding sound, volume based on velocity
}
if ( !(pev->flags & FL_ONGROUND) && pev->velocity.Length2D() > 10 )
if( !( pev->flags & FL_ONGROUND ) && pev->velocity.Length2D() > 10 )
{
BounceSound();
}
StudioFrameAdvance( );
StudioFrameAdvance();
}
void CSatchelCharge :: SatchelThink( void )
void CSatchelCharge::SatchelThink( void )
{
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1;
if (!IsInWorld())
if( !IsInWorld() )
{
UTIL_Remove( this );
return;
}
if (pev->waterlevel == 3)
if( pev->waterlevel == 3 )
{
pev->movetype = MOVETYPE_FLY;
pev->velocity = pev->velocity * 0.8;
pev->avelocity = pev->avelocity * 0.9;
pev->velocity.z += 8;
}
else if (pev->waterlevel == 0)
else if( pev->waterlevel == 0 )
{
pev->movetype = MOVETYPE_BOUNCE;
}
@ -145,21 +147,27 @@ void CSatchelCharge :: SatchelThink( void )
}
}
void CSatchelCharge :: Precache( void )
void CSatchelCharge::Precache( void )
{
PRECACHE_MODEL("models/grenade.mdl");
PRECACHE_SOUND("weapons/g_bounce1.wav");
PRECACHE_SOUND("weapons/g_bounce2.wav");
PRECACHE_SOUND("weapons/g_bounce3.wav");
PRECACHE_MODEL( "models/grenade.mdl" );
PRECACHE_SOUND( "weapons/g_bounce1.wav" );
PRECACHE_SOUND( "weapons/g_bounce2.wav" );
PRECACHE_SOUND( "weapons/g_bounce3.wav" );
}
void CSatchelCharge :: BounceSound( void )
void CSatchelCharge::BounceSound( void )
{
switch ( RANDOM_LONG( 0, 2 ) )
switch( RANDOM_LONG( 0, 2 ) )
{
case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/g_bounce1.wav", 1, ATTN_NORM); break;
case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/g_bounce2.wav", 1, ATTN_NORM); break;
case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "weapons/g_bounce3.wav", 1, ATTN_NORM); break;
case 0:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/g_bounce1.wav", 1, ATTN_NORM );
break;
case 1:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/g_bounce2.wav", 1, ATTN_NORM );
break;
case 2:
EMIT_SOUND( ENT( pev ), CHAN_VOICE, "weapons/g_bounce3.wav", 1, ATTN_NORM );
break;
}
}
@ -173,21 +181,21 @@ int CSatchel::AddDuplicate( CBasePlayerItem *pOriginal )
CSatchel *pSatchel;
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
pSatchel = (CSatchel *)pOriginal;
if ( pSatchel->m_chargeReady != 0 )
if( pSatchel->m_chargeReady != 0 )
{
// player has some satchels deployed. Refuse to add more.
return FALSE;
}
}
return CBasePlayerWeapon::AddDuplicate ( pOriginal );
return CBasePlayerWeapon::AddDuplicate( pOriginal );
}
//=========================================================
@ -196,21 +204,21 @@ int CSatchel::AddToPlayer( CBasePlayer *pPlayer )
{
int bResult = CBasePlayerItem::AddToPlayer( pPlayer );
pPlayer->pev->weapons |= (1<<m_iId);
pPlayer->pev->weapons |= ( 1 << m_iId );
m_chargeReady = 0;// this satchel charge weapon now forgets that any satchels are deployed by it.
if ( bResult )
if( bResult )
{
return AddWeapon( );
return AddWeapon();
}
return FALSE;
}
void CSatchel::Spawn( )
void CSatchel::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_SATCHEL;
SET_MODEL(ENT(pev), "models/w_satchel.mdl");
SET_MODEL( ENT( pev ), "models/w_satchel.mdl" );
m_iDefaultAmmo = SATCHEL_DEFAULT_GIVE;
@ -219,18 +227,18 @@ void CSatchel::Spawn( )
void CSatchel::Precache( void )
{
PRECACHE_MODEL("models/v_satchel.mdl");
PRECACHE_MODEL("models/v_satchel_radio.mdl");
PRECACHE_MODEL("models/w_satchel.mdl");
PRECACHE_MODEL("models/p_satchel.mdl");
PRECACHE_MODEL("models/p_satchel_radio.mdl");
PRECACHE_MODEL( "models/v_satchel.mdl" );
PRECACHE_MODEL( "models/v_satchel_radio.mdl" );
PRECACHE_MODEL( "models/w_satchel.mdl" );
PRECACHE_MODEL( "models/p_satchel.mdl" );
PRECACHE_MODEL( "models/p_satchel_radio.mdl" );
UTIL_PrecacheOther( "monster_satchel" );
}
int CSatchel::GetItemInfo(ItemInfo *p)
int CSatchel::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "Satchel Charge";
p->iMaxAmmo1 = SATCHEL_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -249,13 +257,13 @@ int CSatchel::GetItemInfo(ItemInfo *p)
//=========================================================
BOOL CSatchel::IsUseable( void )
{
if ( m_pPlayer->m_rgAmmo[ PrimaryAmmoIndex() ] > 0 )
if( m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] > 0 )
{
// player is carrying some satchels
return TRUE;
}
if ( m_chargeReady != 0 )
if( m_chargeReady != 0 )
{
// player isn't carrying any satchels, but has some out
return TRUE;
@ -266,13 +274,13 @@ BOOL CSatchel::IsUseable( void )
BOOL CSatchel::CanDeploy( void )
{
if ( m_pPlayer->m_rgAmmo[ PrimaryAmmoIndex() ] > 0 )
if( m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] > 0 )
{
// player is carrying some satchels
return TRUE;
}
if ( m_chargeReady != 0 )
if( m_chargeReady != 0 )
{
// player isn't carrying any satchels, but has some out
return TRUE;
@ -281,18 +289,16 @@ BOOL CSatchel::CanDeploy( void )
return FALSE;
}
BOOL CSatchel::Deploy( )
BOOL CSatchel::Deploy()
{
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 1.0;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + UTIL_SharedRandomFloat( m_pPlayer->random_seed, 10, 15 );
if ( m_chargeReady )
if( m_chargeReady )
return DefaultDeploy( "models/v_satchel_radio.mdl", "models/p_satchel_radio.mdl", SATCHEL_RADIO_DRAW, "hive" );
else
return DefaultDeploy( "models/v_satchel.mdl", "models/p_satchel.mdl", SATCHEL_DRAW, "trip" );
return TRUE;
}
@ -300,7 +306,7 @@ void CSatchel::Holster( int skiplocal /* = 0 */ )
{
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
if ( m_chargeReady )
if( m_chargeReady )
{
SendWeaponAnim( SATCHEL_RADIO_HOLSTER );
}
@ -308,11 +314,11 @@ void CSatchel::Holster( int skiplocal /* = 0 */ )
{
SendWeaponAnim( SATCHEL_DROP );
}
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM);
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM );
if ( !m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] && !m_chargeReady )
if( !m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] && !m_chargeReady )
{
m_pPlayer->pev->weapons &= ~(1<<WEAPON_SATCHEL);
m_pPlayer->pev->weapons &= ~( 1 << WEAPON_SATCHEL );
SetThink( &CBasePlayerItem::DestroyItem );
pev->nextthink = gpGlobals->time + 0.1;
}
@ -320,26 +326,26 @@ void CSatchel::Holster( int skiplocal /* = 0 */ )
void CSatchel::PrimaryAttack()
{
switch (m_chargeReady)
switch( m_chargeReady )
{
case 0:
{
Throw( );
Throw();
}
break;
case 1:
{
SendWeaponAnim( SATCHEL_RADIO_FIRE );
edict_t *pPlayer = m_pPlayer->edict( );
edict_t *pPlayer = m_pPlayer->edict();
CBaseEntity *pSatchel = NULL;
while ((pSatchel = UTIL_FindEntityInSphere( pSatchel, m_pPlayer->pev->origin, 4096 )) != NULL)
while( ( pSatchel = UTIL_FindEntityInSphere( pSatchel, m_pPlayer->pev->origin, 4096 ) ) != NULL )
{
if (FClassnameIs( pSatchel->pev, "monster_satchel"))
if( FClassnameIs( pSatchel->pev, "monster_satchel" ) )
{
if (pSatchel->pev->owner == pPlayer)
if( pSatchel->pev->owner == pPlayer )
{
pSatchel->Use( m_pPlayer, m_pPlayer, USE_ON, 0 );
m_chargeReady = 2;
@ -355,37 +361,35 @@ void CSatchel::PrimaryAttack()
}
case 2:
// we're reloading, don't allow fire
{
}
break;
}
}
void CSatchel::SecondaryAttack( void )
{
if ( m_chargeReady != 2 )
if( m_chargeReady != 2 )
{
Throw( );
Throw();
}
}
void CSatchel::Throw( void )
{
if ( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
Vector vecSrc = m_pPlayer->pev->origin;
Vector vecThrow = gpGlobals->v_forward * 274 + m_pPlayer->pev->velocity;
#ifndef CLIENT_DLL
CBaseEntity *pSatchel = Create( "monster_satchel", vecSrc, Vector( 0, 0, 0), m_pPlayer->edict() );
CBaseEntity *pSatchel = Create( "monster_satchel", vecSrc, Vector( 0, 0, 0 ), m_pPlayer->edict() );
pSatchel->pev->velocity = vecThrow;
pSatchel->pev->avelocity.y = 400;
m_pPlayer->pev->viewmodel = MAKE_STRING("models/v_satchel_radio.mdl");
m_pPlayer->pev->weaponmodel = MAKE_STRING("models/p_satchel_radio.mdl");
m_pPlayer->pev->viewmodel = MAKE_STRING( "models/v_satchel_radio.mdl" );
m_pPlayer->pev->weaponmodel = MAKE_STRING( "models/p_satchel_radio.mdl" );
#else
LoadVModel ( "models/v_satchel_radio.mdl", m_pPlayer );
LoadVModel( "models/v_satchel_radio.mdl", m_pPlayer );
#endif
SendWeaponAnim( SATCHEL_RADIO_DRAW );
@ -404,7 +408,7 @@ void CSatchel::Throw( void )
void CSatchel::WeaponIdle( void )
{
if ( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
switch( m_chargeReady )
@ -420,7 +424,7 @@ void CSatchel::WeaponIdle( void )
strcpy( m_pPlayer->m_szAnimExtention, "hive" );
break;
case 2:
if ( !m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
if( !m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
m_chargeReady = 0;
RetireWeapon();
@ -428,10 +432,10 @@ void CSatchel::WeaponIdle( void )
}
#ifndef CLIENT_DLL
m_pPlayer->pev->viewmodel = MAKE_STRING("models/v_satchel.mdl");
m_pPlayer->pev->weaponmodel = MAKE_STRING("models/p_satchel.mdl");
m_pPlayer->pev->viewmodel = MAKE_STRING( "models/v_satchel.mdl" );
m_pPlayer->pev->weaponmodel = MAKE_STRING( "models/p_satchel.mdl" );
#else
LoadVModel ( "models/v_satchel.mdl", m_pPlayer );
LoadVModel( "models/v_satchel.mdl", m_pPlayer );
#endif
SendWeaponAnim( SATCHEL_DRAW );
@ -458,14 +462,14 @@ void DeactivateSatchels( CBasePlayer *pOwner )
pFind = FIND_ENTITY_BY_CLASSNAME( NULL, "monster_satchel" );
while ( !FNullEnt( pFind ) )
while( !FNullEnt( pFind ) )
{
CBaseEntity *pEnt = CBaseEntity::Instance( pFind );
CSatchelCharge *pSatchel = (CSatchelCharge *)pEnt;
if ( pSatchel )
if( pSatchel )
{
if ( pSatchel->pev->owner == pOwner->edict() )
if( pSatchel->pev->owner == pOwner->edict() )
{
pSatchel->Deactivate();
}

361
dlls/schedule.cpp
View File

File diff suppressed because it is too large Load Diff

471
dlls/scientist.cpp
View File

File diff suppressed because it is too large Load Diff

394
dlls/scripted.cpp
View File

File diff suppressed because it is too large Load Diff

158
dlls/shotgun.cpp
View File

@ -26,7 +26,8 @@
#define VECTOR_CONE_DM_SHOTGUN Vector( 0.08716, 0.04362, 0.00 )// 10 degrees by 5 degrees
#define VECTOR_CONE_DM_DOUBLESHOTGUN Vector( 0.17365, 0.04362, 0.00 ) // 20 degrees by 5 degrees
enum shotgun_e {
enum shotgun_e
{
SHOTGUN_IDLE = 0,
SHOTGUN_FIRE,
SHOTGUN_FIRE2,
@ -41,11 +42,11 @@ enum shotgun_e {
LINK_ENTITY_TO_CLASS( weapon_shotgun, CShotgun )
void CShotgun::Spawn( )
void CShotgun::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_SHOTGUN;
SET_MODEL(ENT(pev), "models/w_shotgun.mdl");
SET_MODEL( ENT( pev ), "models/w_shotgun.mdl" );
m_iDefaultAmmo = SHOTGUN_DEFAULT_GIVE;
@ -54,25 +55,25 @@ void CShotgun::Spawn( )
void CShotgun::Precache( void )
{
PRECACHE_MODEL("models/v_shotgun.mdl");
PRECACHE_MODEL("models/w_shotgun.mdl");
PRECACHE_MODEL("models/p_shotgun.mdl");
PRECACHE_MODEL( "models/v_shotgun.mdl" );
PRECACHE_MODEL( "models/w_shotgun.mdl" );
PRECACHE_MODEL( "models/p_shotgun.mdl" );
m_iShell = PRECACHE_MODEL ("models/shotgunshell.mdl");// shotgun shell
m_iShell = PRECACHE_MODEL( "models/shotgunshell.mdl" );// shotgun shell
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_SOUND( "items/9mmclip1.wav" );
PRECACHE_SOUND ("weapons/dbarrel1.wav");//shotgun
PRECACHE_SOUND ("weapons/sbarrel1.wav");//shotgun
PRECACHE_SOUND( "weapons/dbarrel1.wav" );//shotgun
PRECACHE_SOUND( "weapons/sbarrel1.wav" );//shotgun
PRECACHE_SOUND ("weapons/reload1.wav"); // shotgun reload
PRECACHE_SOUND ("weapons/reload3.wav"); // shotgun reload
PRECACHE_SOUND( "weapons/reload1.wav" ); // shotgun reload
PRECACHE_SOUND( "weapons/reload3.wav" ); // shotgun reload
// PRECACHE_SOUND ("weapons/sshell1.wav"); // shotgun reload - played on client
// PRECACHE_SOUND ("weapons/sshell3.wav"); // shotgun reload - played on client
//PRECACHE_SOUND( "weapons/sshell1.wav" ); // shotgun reload - played on client
//PRECACHE_SOUND( "weapons/sshell3.wav" ); // shotgun reload - played on client
PRECACHE_SOUND ("weapons/357_cock1.wav"); // gun empty sound
PRECACHE_SOUND ("weapons/scock1.wav"); // cock gun
PRECACHE_SOUND( "weapons/357_cock1.wav" ); // gun empty sound
PRECACHE_SOUND( "weapons/scock1.wav" ); // cock gun
m_usSingleFire = PRECACHE_EVENT( 1, "events/shotgun1.sc" );
m_usDoubleFire = PRECACHE_EVENT( 1, "events/shotgun2.sc" );
@ -80,7 +81,7 @@ void CShotgun::Precache( void )
int CShotgun::AddToPlayer( CBasePlayer *pPlayer )
{
if ( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
if( CBasePlayerWeapon::AddToPlayer( pPlayer ) )
{
MESSAGE_BEGIN( MSG_ONE, gmsgWeapPickup, NULL, pPlayer->pev );
WRITE_BYTE( m_iId );
@ -90,9 +91,9 @@ int CShotgun::AddToPlayer( CBasePlayer *pPlayer )
return FALSE;
}
int CShotgun::GetItemInfo(ItemInfo *p)
int CShotgun::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "buckshot";
p->iMaxAmmo1 = BUCKSHOT_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -107,7 +108,7 @@ int CShotgun::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CShotgun::Deploy( )
BOOL CShotgun::Deploy()
{
return DefaultDeploy( "models/v_shotgun.mdl", "models/p_shotgun.mdl", SHOTGUN_DRAW, "shotgun" );
}
@ -115,18 +116,18 @@ BOOL CShotgun::Deploy( )
void CShotgun::PrimaryAttack()
{
// don't fire underwater
if (m_pPlayer->pev->waterlevel == 3)
if( m_pPlayer->pev->waterlevel == 3 )
{
PlayEmptySound( );
PlayEmptySound();
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.15;
return;
}
if (m_iClip <= 0)
if( m_iClip <= 0 )
{
Reload( );
if (m_iClip == 0)
PlayEmptySound( );
Reload();
if( m_iClip == 0 )
PlayEmptySound();
return;
}
@ -141,18 +142,17 @@ void CShotgun::PrimaryAttack()
#else
flags = 0;
#endif
m_pPlayer->pev->effects = (int)( m_pPlayer->pev->effects ) | EF_MUZZLEFLASH;
m_pPlayer->pev->effects = (int)(m_pPlayer->pev->effects) | EF_MUZZLEFLASH;
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecSrc = m_pPlayer->GetGunPosition();
Vector vecAiming = m_pPlayer->GetAutoaimVector( AUTOAIM_5DEGREES );
Vector vecDir;
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
vecDir = m_pPlayer->FireBulletsPlayer( 4, vecSrc, vecAiming, VECTOR_CONE_DM_SHOTGUN, 2048, BULLET_PLAYER_BUCKSHOT, 0, 0, m_pPlayer->pev, m_pPlayer->random_seed );
@ -165,16 +165,16 @@ void CShotgun::PrimaryAttack()
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usSingleFire, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, vecDir.x, vecDir.y, 0, 0, 0, 0 );
if (!m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
if( !m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
// HEV suit - indicate out of ammo condition
m_pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
m_pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 );
if (m_iClip != 0)
if( m_iClip != 0 )
m_flPumpTime = gpGlobals->time + 0.5;
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.75;
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 0.75;
if (m_iClip != 0)
if( m_iClip != 0 )
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 5.0;
else
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 0.75;
@ -184,17 +184,17 @@ void CShotgun::PrimaryAttack()
void CShotgun::SecondaryAttack( void )
{
// don't fire underwater
if (m_pPlayer->pev->waterlevel == 3)
if( m_pPlayer->pev->waterlevel == 3 )
{
PlayEmptySound( );
PlayEmptySound();
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.15;
return;
}
if (m_iClip <= 1)
if( m_iClip <= 1 )
{
Reload( );
PlayEmptySound( );
Reload();
PlayEmptySound();
return;
}
@ -209,20 +209,20 @@ void CShotgun::SecondaryAttack( void )
#else
flags = 0;
#endif
m_pPlayer->pev->effects = (int)(m_pPlayer->pev->effects) | EF_MUZZLEFLASH;
m_pPlayer->pev->effects = (int)( m_pPlayer->pev->effects ) | EF_MUZZLEFLASH;
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
Vector vecSrc = m_pPlayer->GetGunPosition( );
Vector vecSrc = m_pPlayer->GetGunPosition();
Vector vecAiming = m_pPlayer->GetAutoaimVector( AUTOAIM_5DEGREES );
Vector vecDir;
#ifdef CLIENT_DLL
if ( bIsMultiplayer() )
if( bIsMultiplayer() )
#else
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
#endif
{
// tuned for deathmatch
@ -236,16 +236,16 @@ void CShotgun::SecondaryAttack( void )
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usDoubleFire, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, vecDir.x, vecDir.y, 0, 0, 0, 0 );
if (!m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
if( !m_iClip && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 )
// HEV suit - indicate out of ammo condition
m_pPlayer->SetSuitUpdate("!HEV_AMO0", FALSE, 0);
m_pPlayer->SetSuitUpdate( "!HEV_AMO0", FALSE, 0 );
if (m_iClip != 0)
if( m_iClip != 0 )
m_flPumpTime = gpGlobals->time + 0.95;
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 1.5;
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 1.5;
if (m_iClip != 0)
if( m_iClip != 0 )
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 6.0;
else
m_flTimeWeaponIdle = 1.5;
@ -255,15 +255,15 @@ void CShotgun::SecondaryAttack( void )
void CShotgun::Reload( void )
{
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 || m_iClip == SHOTGUN_MAX_CLIP)
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0 || m_iClip == SHOTGUN_MAX_CLIP )
return;
// don't reload until recoil is done
if (m_flNextPrimaryAttack > UTIL_WeaponTimeBase())
if( m_flNextPrimaryAttack > UTIL_WeaponTimeBase() )
return;
// check to see if we're ready to reload
if (m_fInSpecialReload == 0)
if( m_fInSpecialReload == 0 )
{
SendWeaponAnim( SHOTGUN_START_RELOAD );
m_fInSpecialReload = 1;
@ -273,17 +273,17 @@ void CShotgun::Reload( void )
m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 1.0;
return;
}
else if (m_fInSpecialReload == 1)
else if( m_fInSpecialReload == 1 )
{
if (m_flTimeWeaponIdle > UTIL_WeaponTimeBase())
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
// was waiting for gun to move to side
m_fInSpecialReload = 2;
if (RANDOM_LONG(0,1))
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/reload1.wav", 1, ATTN_NORM, 0, 85 + RANDOM_LONG(0,0x1f));
if( RANDOM_LONG( 0, 1 ) )
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/reload1.wav", 1, ATTN_NORM, 0, 85 + RANDOM_LONG( 0, 0x1f ) );
else
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/reload3.wav", 1, ATTN_NORM, 0, 85 + RANDOM_LONG(0,0x1f));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/reload3.wav", 1, ATTN_NORM, 0, 85 + RANDOM_LONG( 0, 0x1f ) );
SendWeaponAnim( SHOTGUN_RELOAD );
@ -301,28 +301,28 @@ void CShotgun::Reload( void )
void CShotgun::WeaponIdle( void )
{
ResetEmptySound( );
ResetEmptySound();
m_pPlayer->GetAutoaimVector( AUTOAIM_5DEGREES );
if ( m_flPumpTime && m_flPumpTime < gpGlobals->time )
if( m_flPumpTime && m_flPumpTime < gpGlobals->time )
{
// play pumping sound
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/scock1.wav", 1, ATTN_NORM, 0, 95 + RANDOM_LONG(0,0x1f));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/scock1.wav", 1, ATTN_NORM, 0, 95 + RANDOM_LONG( 0, 0x1f ) );
m_flPumpTime = 0;
}
if (m_flTimeWeaponIdle < UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle < UTIL_WeaponTimeBase() )
{
if (m_iClip == 0 && m_fInSpecialReload == 0 && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
if( m_iClip == 0 && m_fInSpecialReload == 0 && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
Reload( );
Reload();
}
else if (m_fInSpecialReload != 0)
else if( m_fInSpecialReload != 0 )
{
if (m_iClip != 8 && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType])
if( m_iClip != 8 && m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
Reload( );
Reload();
}
else
{
@ -330,7 +330,7 @@ void CShotgun::WeaponIdle( void )
SendWeaponAnim( SHOTGUN_PUMP );
// play cocking sound
EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/scock1.wav", 1, ATTN_NORM, 0, 95 + RANDOM_LONG(0,0x1f));
EMIT_SOUND_DYN( ENT( m_pPlayer->pev ), CHAN_ITEM, "weapons/scock1.wav", 1, ATTN_NORM, 0, 95 + RANDOM_LONG( 0, 0x1f ) );
m_fInSpecialReload = 0;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 1.5;
}
@ -339,20 +339,20 @@ void CShotgun::WeaponIdle( void )
{
int iAnim;
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0, 1 );
if (flRand <= 0.8)
if( flRand <= 0.8 )
{
iAnim = SHOTGUN_IDLE_DEEP;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + (60.0/12.0);// * RANDOM_LONG(2, 5);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + ( 60.0 / 12.0 );// * RANDOM_LONG( 2, 5 );
}
else if (flRand <= 0.95)
else if( flRand <= 0.95 )
{
iAnim = SHOTGUN_IDLE;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + (20.0/9.0);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + ( 20.0 / 9.0 );
}
else
{
iAnim = SHOTGUN_IDLE4;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + (20.0/9.0);
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + ( 20.0 / 9.0 );
}
SendWeaponAnim( iAnim );
}
@ -363,20 +363,20 @@ class CShotgunAmmo : public CBasePlayerAmmo
{
void Spawn( void )
{
Precache( );
SET_MODEL(ENT(pev), "models/w_shotbox.mdl");
CBasePlayerAmmo::Spawn( );
Precache();
SET_MODEL( ENT( pev ), "models/w_shotbox.mdl" );
CBasePlayerAmmo::Spawn();
}
void Precache( void )
{
PRECACHE_MODEL ("models/w_shotbox.mdl");
PRECACHE_SOUND("items/9mmclip1.wav");
PRECACHE_MODEL( "models/w_shotbox.mdl" );
PRECACHE_SOUND( "items/9mmclip1.wav" );
}
BOOL AddAmmo( CBaseEntity *pOther )
{
if (pOther->GiveAmmo( AMMO_BUCKSHOTBOX_GIVE, "buckshot", BUCKSHOT_MAX_CARRY ) != -1)
if( pOther->GiveAmmo( AMMO_BUCKSHOTBOX_GIVE, "buckshot", BUCKSHOT_MAX_CARRY ) != -1 )
{
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
EMIT_SOUND( ENT( pev ), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM );
return TRUE;
}
return FALSE;

43
dlls/singleplay_gamerules.cpp
View File

@ -40,7 +40,7 @@ CHalfLifeRules::CHalfLifeRules( void )
//=========================================================
//=========================================================
void CHalfLifeRules::Think ( void )
void CHalfLifeRules::Think( void )
{
}
@ -53,7 +53,7 @@ BOOL CHalfLifeRules::IsMultiplayer( void )
//=========================================================
//=========================================================
BOOL CHalfLifeRules::IsDeathmatch ( void )
BOOL CHalfLifeRules::IsDeathmatch( void )
{
return FALSE;
}
@ -65,18 +65,17 @@ BOOL CHalfLifeRules::IsCoOp( void )
return FALSE;
}
//=========================================================
//=========================================================
BOOL CHalfLifeRules::FShouldSwitchWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon )
{
if ( !pPlayer->m_pActiveItem )
if( !pPlayer->m_pActiveItem )
{
// player doesn't have an active item!
return TRUE;
}
if ( !pPlayer->m_pActiveItem->CanHolster() )
if( !pPlayer->m_pActiveItem->CanHolster() )
{
return FALSE;
}
@ -86,25 +85,25 @@ BOOL CHalfLifeRules::FShouldSwitchWeapon( CBasePlayer *pPlayer, CBasePlayerItem
//=========================================================
//=========================================================
BOOL CHalfLifeRules :: GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon )
BOOL CHalfLifeRules::GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon )
{
return FALSE;
}
//=========================================================
//=========================================================
BOOL CHalfLifeRules :: ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] )
BOOL CHalfLifeRules::ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[128] )
{
return TRUE;
}
void CHalfLifeRules :: InitHUD( CBasePlayer *pl )
void CHalfLifeRules::InitHUD( CBasePlayer *pl )
{
}
//=========================================================
//=========================================================
void CHalfLifeRules :: ClientDisconnected( edict_t *pClient )
void CHalfLifeRules::ClientDisconnected( edict_t *pClient )
{
}
@ -120,33 +119,33 @@ float CHalfLifeRules::FlPlayerFallDamage( CBasePlayer *pPlayer )
//=========================================================
//=========================================================
void CHalfLifeRules :: PlayerSpawn( CBasePlayer *pPlayer )
void CHalfLifeRules::PlayerSpawn( CBasePlayer *pPlayer )
{
}
//=========================================================
//=========================================================
BOOL CHalfLifeRules :: AllowAutoTargetCrosshair( void )
BOOL CHalfLifeRules::AllowAutoTargetCrosshair( void )
{
return ( g_iSkillLevel == SKILL_EASY );
}
//=========================================================
//=========================================================
void CHalfLifeRules :: PlayerThink( CBasePlayer *pPlayer )
void CHalfLifeRules::PlayerThink( CBasePlayer *pPlayer )
{
}
//=========================================================
//=========================================================
BOOL CHalfLifeRules :: FPlayerCanRespawn( CBasePlayer *pPlayer )
BOOL CHalfLifeRules::FPlayerCanRespawn( CBasePlayer *pPlayer )
{
return TRUE;
}
//=========================================================
//=========================================================
float CHalfLifeRules :: FlPlayerSpawnTime( CBasePlayer *pPlayer )
float CHalfLifeRules::FlPlayerSpawnTime( CBasePlayer *pPlayer )
{
return gpGlobals->time;//now!
}
@ -155,7 +154,7 @@ float CHalfLifeRules :: FlPlayerSpawnTime( CBasePlayer *pPlayer )
// IPointsForKill - how many points awarded to anyone
// that kills this player?
//=========================================================
int CHalfLifeRules :: IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKilled )
int CHalfLifeRules::IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKilled )
{
return 1;
}
@ -163,7 +162,7 @@ int CHalfLifeRules :: IPointsForKill( CBasePlayer *pAttacker, CBasePlayer *pKill
//=========================================================
// PlayerKilled - someone/something killed this player
//=========================================================
void CHalfLifeRules :: PlayerKilled( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor )
void CHalfLifeRules::PlayerKilled( CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor )
{
}
@ -178,7 +177,7 @@ void CHalfLifeRules::DeathNotice( CBasePlayer *pVictim, entvars_t *pKiller, entv
// PlayerGotWeapon - player has grabbed a weapon that was
// sitting in the world
//=========================================================
void CHalfLifeRules :: PlayerGotWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon )
void CHalfLifeRules::PlayerGotWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon )
{
}
@ -186,7 +185,7 @@ void CHalfLifeRules :: PlayerGotWeapon( CBasePlayer *pPlayer, CBasePlayerItem *p
// FlWeaponRespawnTime - what is the time in the future
// at which this weapon may spawn?
//=========================================================
float CHalfLifeRules :: FlWeaponRespawnTime( CBasePlayerItem *pWeapon )
float CHalfLifeRules::FlWeaponRespawnTime( CBasePlayerItem *pWeapon )
{
return -1;
}
@ -196,7 +195,7 @@ float CHalfLifeRules :: FlWeaponRespawnTime( CBasePlayerItem *pWeapon )
// now, otherwise it returns the time at which it can try
// to spawn again.
//=========================================================
float CHalfLifeRules :: FlWeaponTryRespawn( CBasePlayerItem *pWeapon )
float CHalfLifeRules::FlWeaponTryRespawn( CBasePlayerItem *pWeapon )
{
return 0;
}
@ -205,7 +204,7 @@ float CHalfLifeRules :: FlWeaponTryRespawn( CBasePlayerItem *pWeapon )
// VecWeaponRespawnSpot - where should this weapon spawn?
// Some game variations may choose to randomize spawn locations
//=========================================================
Vector CHalfLifeRules :: VecWeaponRespawnSpot( CBasePlayerItem *pWeapon )
Vector CHalfLifeRules::VecWeaponRespawnSpot( CBasePlayerItem *pWeapon )
{
return pWeapon->pev->origin;
}
@ -214,7 +213,7 @@ Vector CHalfLifeRules :: VecWeaponRespawnSpot( CBasePlayerItem *pWeapon )
// WeaponShouldRespawn - any conditions inhibiting the
// respawning of this weapon?
//=========================================================
int CHalfLifeRules :: WeaponShouldRespawn( CBasePlayerItem *pWeapon )
int CHalfLifeRules::WeaponShouldRespawn( CBasePlayerItem *pWeapon )
{
return GR_WEAPON_RESPAWN_NO;
}
@ -321,7 +320,7 @@ int CHalfLifeRules::PlayerRelationship( CBaseEntity *pPlayer, CBaseEntity *pTarg
//=========================================================
//=========================================================
BOOL CHalfLifeRules :: FAllowMonsters( void )
BOOL CHalfLifeRules::FAllowMonsters( void )
{
return TRUE;
}

8
dlls/skill.cpp
View File

@ -29,15 +29,15 @@ float GetSkillCvar( char *pName )
{
int iCount;
float flValue;
char szBuffer[ 64 ];
char szBuffer[64];
iCount = sprintf( szBuffer, "%s%d",pName, gSkillData.iSkillLevel );
flValue = CVAR_GET_FLOAT ( szBuffer );
flValue = CVAR_GET_FLOAT( szBuffer );
if ( flValue <= 0 )
if( flValue <= 0 )
{
ALERT ( at_console, "\n\n** GetSkillCVar Got a zero for %s **\n\n", szBuffer );
ALERT( at_console, "\n\n** GetSkillCVar Got a zero for %s **\n\n", szBuffer );
}
return flValue;

943
dlls/sound.cpp
View File

File diff suppressed because it is too large Load Diff

28
dlls/spectator.cpp
View File

@ -32,7 +32,7 @@ SpectatorConnect
called when a spectator connects to a server
============
*/
void CBaseSpectator::SpectatorConnect(void)
void CBaseSpectator::SpectatorConnect( void )
{
pev->flags = FL_SPECTATOR;
pev->solid = SOLID_NOT;
@ -48,7 +48,7 @@ SpectatorDisconnect
called when a spectator disconnects from a server
============
*/
void CBaseSpectator::SpectatorDisconnect(void)
void CBaseSpectator::SpectatorDisconnect( void )
{
}
@ -59,14 +59,14 @@ SpectatorImpulseCommand
Called by SpectatorThink if the spectator entered an impulse
================
*/
void CBaseSpectator::SpectatorImpulseCommand(void)
void CBaseSpectator::SpectatorImpulseCommand( void )
{
static edict_t *pGoal = NULL;
edict_t *pPreviousGoal;
edict_t *pCurrentGoal;
BOOL bFound;
switch (pev->impulse)
switch( pev->impulse )
{
case 1:
// teleport the spectator to the next spawn point
@ -78,24 +78,24 @@ void CBaseSpectator::SpectatorImpulseCommand(void)
// back around
bFound = FALSE;
while (1)
while( 1 )
{
pCurrentGoal = FIND_ENTITY_BY_CLASSNAME(pCurrentGoal, "info_player_deathmatch");
pCurrentGoal = FIND_ENTITY_BY_CLASSNAME( pCurrentGoal, "info_player_deathmatch" );
// Looped around, failure
if (pCurrentGoal == pPreviousGoal)
if( pCurrentGoal == pPreviousGoal )
{
ALERT(at_console, "Could not find a spawn spot.\n");
ALERT( at_console, "Could not find a spawn spot.\n" );
break;
}
// Found a non-world entity, set success, otherwise, look for the next one.
if (!FNullEnt(pCurrentGoal))
if( !FNullEnt( pCurrentGoal ) )
{
bFound = TRUE;
break;
}
}
if (!bFound) // Didn't find a good spot.
if( !bFound ) // Didn't find a good spot.
break;
pGoal = pCurrentGoal;
@ -104,7 +104,7 @@ void CBaseSpectator::SpectatorImpulseCommand(void)
pev->fixangle = FALSE;
break;
default:
ALERT(at_console, "Unknown spectator impulse\n");
ALERT( at_console, "Unknown spectator impulse\n" );
break;
}
@ -118,9 +118,9 @@ SpectatorThink
Called every frame after physics are run
================
*/
void CBaseSpectator::SpectatorThink(void)
void CBaseSpectator::SpectatorThink( void )
{
if (!(pev->flags & FL_SPECTATOR))
if( !( pev->flags & FL_SPECTATOR ) )
{
pev->flags = FL_SPECTATOR;
}
@ -128,7 +128,7 @@ void CBaseSpectator::SpectatorThink(void)
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NOCLIP;
if (pev->impulse)
if( pev->impulse )
SpectatorImpulseCommand();
}

8
dlls/spectator.h
View File

@ -18,10 +18,10 @@ class CBaseSpectator : public CBaseEntity
{
public:
void Spawn();
void SpectatorConnect(void);
void SpectatorDisconnect(void);
void SpectatorThink(void);
void SpectatorConnect( void );
void SpectatorDisconnect( void );
void SpectatorThink( void );
private:
void SpectatorImpulseCommand(void);
void SpectatorImpulseCommand( void );
};

230
dlls/squadmonster.cpp
View File

@ -47,18 +47,18 @@ IMPLEMENT_SAVERESTORE( CSquadMonster, CBaseMonster )
// OccupySlot - if any slots of the passed slots are
// available, the monster will be assigned to one.
//=========================================================
BOOL CSquadMonster :: OccupySlot( int iDesiredSlots )
BOOL CSquadMonster::OccupySlot( int iDesiredSlots )
{
int i;
int iMask;
int iSquadSlots;
if ( !InSquad() )
if( !InSquad() )
{
return TRUE;
}
if ( SquadEnemySplit() )
if( SquadEnemySplit() )
{
// if the squad members aren't all fighting the same enemy, slots are disabled
// so that a squad member doesn't get stranded unable to engage his enemy because
@ -69,7 +69,7 @@ BOOL CSquadMonster :: OccupySlot( int iDesiredSlots )
CSquadMonster *pSquadLeader = MySquadLeader();
if ( !( iDesiredSlots ^ pSquadLeader->m_afSquadSlots ) )
if( !( iDesiredSlots ^ pSquadLeader->m_afSquadSlots ) )
{
// none of the desired slots are available.
return FALSE;
@ -77,17 +77,17 @@ BOOL CSquadMonster :: OccupySlot( int iDesiredSlots )
iSquadSlots = pSquadLeader->m_afSquadSlots;
for ( i = 0; i < NUM_SLOTS; i++ )
for( i = 0; i < NUM_SLOTS; i++ )
{
iMask = 1<<i;
if ( iDesiredSlots & iMask ) // am I looking for this bit?
iMask = 1 << i;
if( iDesiredSlots & iMask ) // am I looking for this bit?
{
if ( !(iSquadSlots & iMask) ) // Is it already taken?
if( !( iSquadSlots & iMask ) ) // Is it already taken?
{
// No, use this bit
pSquadLeader->m_afSquadSlots |= iMask;
m_iMySlot = iMask;
//ALERT ( at_aiconsole, "Took slot %d - %d\n", i, m_hSquadLeader->m_afSquadSlots );
//ALERT( at_aiconsole, "Took slot %d - %d\n", i, m_hSquadLeader->m_afSquadSlots );
return TRUE;
}
}
@ -99,11 +99,11 @@ BOOL CSquadMonster :: OccupySlot( int iDesiredSlots )
//=========================================================
// VacateSlot
//=========================================================
void CSquadMonster :: VacateSlot()
void CSquadMonster::VacateSlot()
{
if ( m_iMySlot != bits_NO_SLOT && InSquad() )
if( m_iMySlot != bits_NO_SLOT && InSquad() )
{
//ALERT ( at_aiconsole, "Vacated Slot %d - %d\n", m_iMySlot, m_hSquadLeader->m_afSquadSlots );
//ALERT( at_aiconsole, "Vacated Slot %d - %d\n", m_iMySlot, m_hSquadLeader->m_afSquadSlots );
MySquadLeader()->m_afSquadSlots &= ~m_iMySlot;
m_iMySlot = bits_NO_SLOT;
}
@ -112,7 +112,7 @@ void CSquadMonster :: VacateSlot()
//=========================================================
// ScheduleChange
//=========================================================
void CSquadMonster :: ScheduleChange ( void )
void CSquadMonster::ScheduleChange ( void )
{
VacateSlot();
}
@ -120,16 +120,16 @@ void CSquadMonster :: ScheduleChange ( void )
//=========================================================
// Killed
//=========================================================
void CSquadMonster :: Killed( entvars_t *pevAttacker, int iGib )
void CSquadMonster::Killed( entvars_t *pevAttacker, int iGib )
{
VacateSlot();
if ( InSquad() )
if( InSquad() )
{
MySquadLeader()->SquadRemove( this );
}
CBaseMonster :: Killed ( pevAttacker, iGib );
CBaseMonster::Killed( pevAttacker, iGib );
}
// These functions are still awaiting conversion to CSquadMonster
@ -141,19 +141,19 @@ void CSquadMonster :: Killed( entvars_t *pevAttacker, int iGib )
// If I am pRemove, promote m_pSquadNext to leader
//
//=========================================================
void CSquadMonster :: SquadRemove( CSquadMonster *pRemove )
void CSquadMonster::SquadRemove( CSquadMonster *pRemove )
{
ASSERT( pRemove!=NULL );
ASSERT( this->IsLeader() );
ASSERT( pRemove->m_hSquadLeader == this );
// If I'm the leader, get rid of my squad
if (pRemove == MySquadLeader())
if( pRemove == MySquadLeader() )
{
for (int i = 0; i < MAX_SQUAD_MEMBERS-1;i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS - 1; i++ )
{
CSquadMonster *pMember = MySquadMember(i);
if (pMember)
CSquadMonster *pMember = MySquadMember( i );
if( pMember )
{
pMember->m_hSquadLeader = NULL;
m_hSquadMember[i] = NULL;
@ -163,11 +163,11 @@ void CSquadMonster :: SquadRemove( CSquadMonster *pRemove )
else
{
CSquadMonster *pSquadLeader = MySquadLeader();
if (pSquadLeader)
if( pSquadLeader )
{
for (int i = 0; i < MAX_SQUAD_MEMBERS-1;i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS - 1; i++ )
{
if (pSquadLeader->m_hSquadMember[i] == this)
if( pSquadLeader->m_hSquadMember[i] == this )
{
pSquadLeader->m_hSquadMember[i] = NULL;
break;
@ -184,15 +184,15 @@ void CSquadMonster :: SquadRemove( CSquadMonster *pRemove )
// SquadAdd(), add pAdd to my squad
//
//=========================================================
BOOL CSquadMonster :: SquadAdd( CSquadMonster *pAdd )
BOOL CSquadMonster::SquadAdd( CSquadMonster *pAdd )
{
ASSERT( pAdd!=NULL );
ASSERT( pAdd != NULL );
ASSERT( !pAdd->InSquad() );
ASSERT( this->IsLeader() );
for (int i = 0; i < MAX_SQUAD_MEMBERS-1; i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS - 1; i++ )
{
if (m_hSquadMember[i] == NULL)
if( m_hSquadMember[i] == NULL )
{
m_hSquadMember[i] = pAdd;
pAdd->m_hSquadLeader = this;
@ -210,10 +210,10 @@ BOOL CSquadMonster :: SquadAdd( CSquadMonster *pAdd )
// members who don't have current info.
//
//=========================================================
void CSquadMonster :: SquadPasteEnemyInfo ( void )
void CSquadMonster::SquadPasteEnemyInfo( void )
{
CSquadMonster *pSquadLeader = MySquadLeader( );
if (pSquadLeader)
CSquadMonster *pSquadLeader = MySquadLeader();
if( pSquadLeader )
pSquadLeader->m_vecEnemyLKP = m_vecEnemyLKP;
}
@ -225,10 +225,10 @@ void CSquadMonster :: SquadPasteEnemyInfo ( void )
// so the most recent data is always available here.
//
//=========================================================
void CSquadMonster :: SquadCopyEnemyInfo ( void )
void CSquadMonster::SquadCopyEnemyInfo( void )
{
CSquadMonster *pSquadLeader = MySquadLeader( );
if (pSquadLeader)
CSquadMonster *pSquadLeader = MySquadLeader();
if( pSquadLeader )
m_vecEnemyLKP = pSquadLeader->m_vecEnemyLKP;
}
@ -238,27 +238,27 @@ void CSquadMonster :: SquadCopyEnemyInfo ( void )
// the same entity.
//
//=========================================================
void CSquadMonster :: SquadMakeEnemy ( CBaseEntity *pEnemy )
void CSquadMonster::SquadMakeEnemy( CBaseEntity *pEnemy )
{
if (!InSquad())
if( !InSquad() )
return;
if ( !pEnemy )
if( !pEnemy )
{
ALERT ( at_console, "ERROR: SquadMakeEnemy() - pEnemy is NULL!\n" );
ALERT( at_console, "ERROR: SquadMakeEnemy() - pEnemy is NULL!\n" );
return;
}
CSquadMonster *pSquadLeader = MySquadLeader( );
for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
CSquadMonster *pSquadLeader = MySquadLeader();
for( int i = 0; i < MAX_SQUAD_MEMBERS; i++ )
{
CSquadMonster *pMember = pSquadLeader->MySquadMember(i);
if (pMember)
CSquadMonster *pMember = pSquadLeader->MySquadMember( i );
if( pMember )
{
// reset members who aren't activly engaged in fighting
if (pMember->m_hEnemy != pEnemy && !pMember->HasConditions( bits_COND_SEE_ENEMY))
if( pMember->m_hEnemy != pEnemy && !pMember->HasConditions( bits_COND_SEE_ENEMY ) )
{
if ( pMember->m_hEnemy != NULL)
if( pMember->m_hEnemy != NULL )
{
// remember their current enemy
pMember->PushEnemy( pMember->m_hEnemy, pMember->m_vecEnemyLKP );
@ -266,7 +266,7 @@ void CSquadMonster :: SquadMakeEnemy ( CBaseEntity *pEnemy )
// give them a new enemy
pMember->m_hEnemy = pEnemy;
pMember->m_vecEnemyLKP = pEnemy->pev->origin;
pMember->SetConditions ( bits_COND_NEW_ENEMY );
pMember->SetConditions( bits_COND_NEW_ENEMY );
}
}
}
@ -278,16 +278,16 @@ void CSquadMonster :: SquadMakeEnemy ( CBaseEntity *pEnemy )
// callable from leaders & followers
//
//=========================================================
int CSquadMonster :: SquadCount( void )
int CSquadMonster::SquadCount( void )
{
if (!InSquad())
if( !InSquad() )
return 0;
CSquadMonster *pSquadLeader = MySquadLeader();
int squadCount = 0;
for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS; i++ )
{
if (pSquadLeader->MySquadMember(i) != NULL)
if( pSquadLeader->MySquadMember( i ) != NULL )
squadCount++;
}
@ -300,16 +300,16 @@ int CSquadMonster :: SquadCount( void )
// link them as a group. returns the group size
//
//=========================================================
int CSquadMonster :: SquadRecruit( int searchRadius, int maxMembers )
int CSquadMonster::SquadRecruit( int searchRadius, int maxMembers )
{
int squadCount;
int iMyClass = Classify();// cache this monster's class
// Don't recruit if I'm already in a group
if ( InSquad() )
if( InSquad() )
return 0;
if ( maxMembers < 2 )
if( maxMembers < 2 )
return 0;
// I am my own leader
@ -318,20 +318,20 @@ int CSquadMonster :: SquadRecruit( int searchRadius, int maxMembers )
CBaseEntity *pEntity = NULL;
if ( !FStringNull( pev->netname ) )
if( !FStringNull( pev->netname ) )
{
// I have a netname, so unconditionally recruit everyone else with that name.
pEntity = UTIL_FindEntityByString( pEntity, "netname", STRING( pev->netname ) );
while ( pEntity )
while( pEntity )
{
CSquadMonster *pRecruit = pEntity->MySquadMonsterPointer();
if ( pRecruit )
if( pRecruit )
{
if ( !pRecruit->InSquad() && pRecruit->Classify() == iMyClass && pRecruit != this )
if( !pRecruit->InSquad() && pRecruit->Classify() == iMyClass && pRecruit != this )
{
// minimum protection here against user error.in worldcraft.
if (!SquadAdd( pRecruit ))
if( !SquadAdd( pRecruit ) )
break;
squadCount++;
}
@ -342,22 +342,22 @@ int CSquadMonster :: SquadRecruit( int searchRadius, int maxMembers )
}
else
{
while ((pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, searchRadius )) != NULL)
while( ( pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, searchRadius ) ) != NULL )
{
CSquadMonster *pRecruit = pEntity->MySquadMonsterPointer( );
CSquadMonster *pRecruit = pEntity->MySquadMonsterPointer();
if ( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_pCine )
if( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_pCine )
{
// Can we recruit this guy?
if ( !pRecruit->InSquad() && pRecruit->Classify() == iMyClass &&
( (iMyClass != CLASS_ALIEN_MONSTER) || FStrEq(STRING(pev->classname), STRING(pRecruit->pev->classname))) &&
if( !pRecruit->InSquad() && pRecruit->Classify() == iMyClass &&
( ( iMyClass != CLASS_ALIEN_MONSTER ) || FStrEq( STRING( pev->classname ), STRING( pRecruit->pev->classname ) ) ) &&
FStringNull( pRecruit->pev->netname ) )
{
TraceResult tr;
UTIL_TraceLine( pev->origin + pev->view_ofs, pRecruit->pev->origin + pev->view_ofs, ignore_monsters, pRecruit->edict(), &tr );// try to hit recruit with a traceline.
if ( tr.flFraction == 1.0 )
if( tr.flFraction == 1.0 )
{
if (!SquadAdd( pRecruit ))
if( !SquadAdd( pRecruit ) )
break;
squadCount++;
@ -368,7 +368,7 @@ int CSquadMonster :: SquadRecruit( int searchRadius, int maxMembers )
}
// no single member squads
if (squadCount == 1)
if( squadCount == 1 )
{
m_hSquadLeader = NULL;
}
@ -379,16 +379,16 @@ int CSquadMonster :: SquadRecruit( int searchRadius, int maxMembers )
//=========================================================
// CheckEnemy
//=========================================================
int CSquadMonster :: CheckEnemy ( CBaseEntity *pEnemy )
int CSquadMonster::CheckEnemy( CBaseEntity *pEnemy )
{
int iUpdatedLKP;
iUpdatedLKP = CBaseMonster :: CheckEnemy ( m_hEnemy );
iUpdatedLKP = CBaseMonster::CheckEnemy( m_hEnemy );
// communicate with squad members about the enemy IF this individual has the same enemy as the squad leader.
if ( InSquad() && (CBaseEntity *)m_hEnemy == MySquadLeader()->m_hEnemy )
if( InSquad() && (CBaseEntity *)m_hEnemy == MySquadLeader()->m_hEnemy )
{
if ( iUpdatedLKP )
if( iUpdatedLKP )
{
// have new enemy information, so paste to the squad.
SquadPasteEnemyInfo();
@ -406,16 +406,16 @@ int CSquadMonster :: CheckEnemy ( CBaseEntity *pEnemy )
//=========================================================
// StartMonster
//=========================================================
void CSquadMonster :: StartMonster( void )
void CSquadMonster::StartMonster( void )
{
CBaseMonster :: StartMonster();
CBaseMonster::StartMonster();
if ( ( m_afCapability & bits_CAP_SQUAD ) && !InSquad() )
if( ( m_afCapability & bits_CAP_SQUAD ) && !InSquad() )
{
if ( !FStringNull( pev->netname ) )
if( !FStringNull( pev->netname ) )
{
// if I have a groupname, I can only recruit if I'm flagged as leader
if ( !( pev->spawnflags & SF_SQUADMONSTER_LEADER ) )
if( !( pev->spawnflags & SF_SQUADMONSTER_LEADER ) )
{
return;
}
@ -424,12 +424,12 @@ void CSquadMonster :: StartMonster( void )
// try to form squads now.
int iSquadSize = SquadRecruit( 1024, 4 );
if ( iSquadSize )
if( iSquadSize )
{
ALERT ( at_aiconsole, "Squad of %d %s formed\n", iSquadSize, STRING( pev->classname ) );
ALERT( at_aiconsole, "Squad of %d %s formed\n", iSquadSize, STRING( pev->classname ) );
}
if ( IsLeader() && FClassnameIs ( pev, "monster_human_grunt" ) )
if( IsLeader() && FClassnameIs( pev, "monster_human_grunt" ) )
{
SetBodygroup( 1, 1 ); // UNDONE: truly ugly hack
pev->skin = 0;
@ -443,9 +443,9 @@ void CSquadMonster :: StartMonster( void )
// Builds a large box in front of the grunt and checks to see
// if any squad members are in that box.
//=========================================================
BOOL CSquadMonster :: NoFriendlyFire( void )
BOOL CSquadMonster::NoFriendlyFire( void )
{
if ( !InSquad() )
if( !InSquad() )
{
return TRUE;
}
@ -459,10 +459,9 @@ BOOL CSquadMonster :: NoFriendlyFire( void )
Vector v_left;
//!!!BUGBUG - to fix this, the planes must be aligned to where the monster will be firing its gun, not the direction it is facing!!!
if ( m_hEnemy != NULL )
if( m_hEnemy != NULL )
{
UTIL_MakeVectors ( UTIL_VecToAngles( m_hEnemy->Center() - pev->origin ) );
UTIL_MakeVectors( UTIL_VecToAngles( m_hEnemy->Center() - pev->origin ) );
}
else
{
@ -470,30 +469,29 @@ BOOL CSquadMonster :: NoFriendlyFire( void )
return FALSE;
}
//UTIL_MakeVectors ( pev->angles );
//UTIL_MakeVectors( pev->angles );
vecLeftSide = pev->origin - ( gpGlobals->v_right * ( pev->size.x * 1.5 ) );
vecRightSide = pev->origin + ( gpGlobals->v_right * ( pev->size.x * 1.5 ) );
v_left = gpGlobals->v_right * -1;
leftPlane.InitializePlane ( gpGlobals->v_right, vecLeftSide );
rightPlane.InitializePlane ( v_left, vecRightSide );
backPlane.InitializePlane ( gpGlobals->v_forward, pev->origin );
leftPlane.InitializePlane( gpGlobals->v_right, vecLeftSide );
rightPlane.InitializePlane( v_left, vecRightSide );
backPlane.InitializePlane( gpGlobals->v_forward, pev->origin );
/*
ALERT ( at_console, "LeftPlane: %f %f %f : %f\n", leftPlane.m_vecNormal.x, leftPlane.m_vecNormal.y, leftPlane.m_vecNormal.z, leftPlane.m_flDist );
ALERT ( at_console, "RightPlane: %f %f %f : %f\n", rightPlane.m_vecNormal.x, rightPlane.m_vecNormal.y, rightPlane.m_vecNormal.z, rightPlane.m_flDist );
ALERT ( at_console, "BackPlane: %f %f %f : %f\n", backPlane.m_vecNormal.x, backPlane.m_vecNormal.y, backPlane.m_vecNormal.z, backPlane.m_flDist );
ALERT( at_console, "LeftPlane: %f %f %f : %f\n", leftPlane.m_vecNormal.x, leftPlane.m_vecNormal.y, leftPlane.m_vecNormal.z, leftPlane.m_flDist );
ALERT( at_console, "RightPlane: %f %f %f : %f\n", rightPlane.m_vecNormal.x, rightPlane.m_vecNormal.y, rightPlane.m_vecNormal.z, rightPlane.m_flDist );
ALERT( at_console, "BackPlane: %f %f %f : %f\n", backPlane.m_vecNormal.x, backPlane.m_vecNormal.y, backPlane.m_vecNormal.z, backPlane.m_flDist );
*/
CSquadMonster *pSquadLeader = MySquadLeader();
for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS; i++ )
{
CSquadMonster *pMember = pSquadLeader->MySquadMember(i);
if (pMember && pMember != this)
CSquadMonster *pMember = pSquadLeader->MySquadMember( i );
if( pMember && pMember != this )
{
if ( backPlane.PointInFront ( pMember->pev->origin ) &&
leftPlane.PointInFront ( pMember->pev->origin ) &&
rightPlane.PointInFront ( pMember->pev->origin) )
if( backPlane.PointInFront( pMember->pev->origin ) &&
leftPlane.PointInFront( pMember->pev->origin ) &&
rightPlane.PointInFront( pMember->pev->origin ) )
{
// this guy is in the check volume! Don't shoot!
return FALSE;
@ -508,27 +506,27 @@ BOOL CSquadMonster :: NoFriendlyFire( void )
// GetIdealState - surveys the Conditions information available
// and finds the best new state for a monster.
//=========================================================
MONSTERSTATE CSquadMonster :: GetIdealState ( void )
MONSTERSTATE CSquadMonster::GetIdealState ( void )
{
int iConditions;
iConditions = IScheduleFlags();
// If no schedule conditions, the new ideal state is probably the reason we're in here.
switch ( m_MonsterState )
switch( m_MonsterState )
{
case MONSTERSTATE_IDLE:
case MONSTERSTATE_ALERT:
if ( HasConditions ( bits_COND_NEW_ENEMY ) && InSquad() )
if( HasConditions( bits_COND_NEW_ENEMY ) && InSquad() )
{
SquadMakeEnemy ( m_hEnemy );
SquadMakeEnemy( m_hEnemy );
}
break;
default:
break;
}
return CBaseMonster :: GetIdealState();
return CBaseMonster::GetIdealState();
}
//=========================================================
@ -536,14 +534,14 @@ MONSTERSTATE CSquadMonster :: GetIdealState ( void )
// cover location is a good one to move to. (currently based
// on proximity to others in the squad)
//=========================================================
BOOL CSquadMonster :: FValidateCover ( const Vector &vecCoverLocation )
BOOL CSquadMonster::FValidateCover( const Vector &vecCoverLocation )
{
if ( !InSquad() )
if( !InSquad() )
{
return TRUE;
}
if (SquadMemberInRange( vecCoverLocation, 128 ))
if( SquadMemberInRange( vecCoverLocation, 128 ) )
{
// another squad member is too close to this piece of cover.
return FALSE;
@ -556,18 +554,18 @@ BOOL CSquadMonster :: FValidateCover ( const Vector &vecCoverLocation )
// SquadEnemySplit- returns TRUE if not all squad members
// are fighting the same enemy.
//=========================================================
BOOL CSquadMonster :: SquadEnemySplit ( void )
BOOL CSquadMonster::SquadEnemySplit( void )
{
if (!InSquad())
if( !InSquad() )
return FALSE;
CSquadMonster *pSquadLeader = MySquadLeader();
CBaseEntity *pEnemy = pSquadLeader->m_hEnemy;
for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS; i++ )
{
CSquadMonster *pMember = pSquadLeader->MySquadMember(i);
if (pMember != NULL && pMember->m_hEnemy != NULL && pMember->m_hEnemy != pEnemy)
CSquadMonster *pMember = pSquadLeader->MySquadMember( i );
if( pMember != NULL && pMember->m_hEnemy != NULL && pMember->m_hEnemy != pEnemy )
{
return TRUE;
}
@ -580,17 +578,17 @@ BOOL CSquadMonster :: SquadEnemySplit ( void )
// cover location is a good one to move to. (currently based
// on proximity to others in the squad)
//=========================================================
BOOL CSquadMonster :: SquadMemberInRange ( const Vector &vecLocation, float flDist )
BOOL CSquadMonster::SquadMemberInRange( const Vector &vecLocation, float flDist )
{
if (!InSquad())
if( !InSquad() )
return FALSE;
CSquadMonster *pSquadLeader = MySquadLeader();
for (int i = 0; i < MAX_SQUAD_MEMBERS; i++)
for( int i = 0; i < MAX_SQUAD_MEMBERS; i++ )
{
CSquadMonster *pSquadMember = pSquadLeader->MySquadMember(i);
if (pSquadMember && (vecLocation - pSquadMember->pev->origin ).Length2D() <= flDist)
CSquadMonster *pSquadMember = pSquadLeader->MySquadMember( i );
if( pSquadMember && ( vecLocation - pSquadMember->pev->origin ).Length2D() <= flDist )
return TRUE;
}
return FALSE;
@ -600,11 +598,11 @@ extern Schedule_t slChaseEnemyFailed[];
Schedule_t *CSquadMonster::GetScheduleOfType( int iType )
{
switch ( iType )
switch( iType )
{
case SCHED_CHASE_ENEMY_FAILED:
{
return &slChaseEnemyFailed[ 0 ];
return &slChaseEnemyFailed[0];
}
default:
return CBaseMonster::GetScheduleOfType( iType );

40
dlls/squadmonster.h
View File

@ -57,7 +57,7 @@ class CSquadMonster : public CBaseMonster
public:
// squad leader info
EHANDLE m_hSquadLeader; // who is my leader
EHANDLE m_hSquadMember[MAX_SQUAD_MEMBERS-1]; // valid only for leader
EHANDLE m_hSquadMember[MAX_SQUAD_MEMBERS - 1]; // valid only for leader
int m_afSquadSlots;
float m_flLastEnemySightTime; // last time anyone in the squad saw the enemy
BOOL m_fEnemyEluded;
@ -65,8 +65,8 @@ public:
// squad member info
int m_iMySlot;// this is the behaviour slot that the monster currently holds in the squad.
int CheckEnemy ( CBaseEntity *pEnemy );
void StartMonster ( void );
int CheckEnemy( CBaseEntity *pEnemy );
void StartMonster( void );
void VacateSlot( void );
void ScheduleChange( void );
void Killed( entvars_t *pevAttacker, int iGib );
@ -74,34 +74,34 @@ public:
BOOL NoFriendlyFire( void );
// squad functions still left in base class
CSquadMonster *MySquadLeader( )
CSquadMonster *MySquadLeader()
{
CSquadMonster *pSquadLeader = (CSquadMonster *)((CBaseEntity *)m_hSquadLeader);
if (pSquadLeader != NULL)
CSquadMonster *pSquadLeader = (CSquadMonster *)( (CBaseEntity *)m_hSquadLeader );
if( pSquadLeader != NULL )
return pSquadLeader;
return this;
}
CSquadMonster *MySquadMember( int i )
{
if (i >= MAX_SQUAD_MEMBERS-1)
if( i >= MAX_SQUAD_MEMBERS - 1 )
return this;
else
return (CSquadMonster *)((CBaseEntity *)m_hSquadMember[i]);
return (CSquadMonster *)( (CBaseEntity *)m_hSquadMember[i] );
}
int InSquad ( void ) { return m_hSquadLeader != NULL; }
int IsLeader ( void ) { return m_hSquadLeader == this; }
int SquadJoin ( int searchRadius );
int SquadRecruit ( int searchRadius, int maxMembers );
int InSquad( void ) { return m_hSquadLeader != NULL; }
int IsLeader( void ) { return m_hSquadLeader == this; }
int SquadJoin( int searchRadius );
int SquadRecruit( int searchRadius, int maxMembers );
int SquadCount( void );
void SquadRemove( CSquadMonster *pRemove );
void SquadUnlink( void );
BOOL SquadAdd( CSquadMonster *pAdd );
void SquadDisband( void );
void SquadAddConditions ( int iConditions );
void SquadMakeEnemy ( CBaseEntity *pEnemy );
void SquadPasteEnemyInfo ( void );
void SquadCopyEnemyInfo ( void );
BOOL SquadEnemySplit ( void );
void SquadAddConditions( int iConditions );
void SquadMakeEnemy( CBaseEntity *pEnemy );
void SquadPasteEnemyInfo( void );
void SquadCopyEnemyInfo( void );
BOOL SquadEnemySplit( void );
BOOL SquadMemberInRange( const Vector &vecLocation, float flDist );
virtual CSquadMonster *MySquadMonsterPointer( void ) { return this; }
@ -111,8 +111,8 @@ public:
int Save( CSave &save );
int Restore( CRestore &restore );
BOOL FValidateCover ( const Vector &vecCoverLocation );
BOOL FValidateCover( const Vector &vecCoverLocation );
MONSTERSTATE GetIdealState ( void );
Schedule_t *GetScheduleOfType ( int iType );
MONSTERSTATE GetIdealState( void );
Schedule_t *GetScheduleOfType( int iType );
};

221
dlls/squeakgrenade.cpp
View File

@ -24,14 +24,16 @@
#include "soundent.h"
#include "gamerules.h"
enum w_squeak_e {
enum w_squeak_e
{
WSQUEAK_IDLE1 = 0,
WSQUEAK_FIDGET,
WSQUEAK_JUMP,
WSQUEAK_RUN
};
enum squeak_e {
enum squeak_e
{
SQUEAK_IDLE1 = 0,
SQUEAK_FIDGETFIT,
SQUEAK_FIDGETNIP,
@ -41,7 +43,6 @@ enum squeak_e {
};
#ifndef CLIENT_DLL
class CSqueakGrenade : public CGrenade
{
void Spawn( void );
@ -88,15 +89,15 @@ IMPLEMENT_SAVERESTORE( CSqueakGrenade, CGrenade )
#define SQUEEK_DETONATE_DELAY 15.0
int CSqueakGrenade :: Classify ( void )
int CSqueakGrenade::Classify( void )
{
if (m_iMyClass != 0)
if( m_iMyClass != 0 )
return m_iMyClass; // protect against recursion
if (m_hEnemy != NULL)
if( m_hEnemy != NULL )
{
m_iMyClass = CLASS_INSECT; // no one cares about it
switch( m_hEnemy->Classify( ) )
switch( m_hEnemy->Classify() )
{
case CLASS_PLAYER:
case CLASS_HUMAN_PASSIVE:
@ -110,16 +111,16 @@ int CSqueakGrenade :: Classify ( void )
return CLASS_ALIEN_BIOWEAPON;
}
void CSqueakGrenade :: Spawn( void )
void CSqueakGrenade::Spawn( void )
{
Precache( );
Precache();
// motor
pev->movetype = MOVETYPE_BOUNCE;
pev->solid = SOLID_BBOX;
SET_MODEL(ENT(pev), "models/w_squeak.mdl");
UTIL_SetSize(pev, Vector( -4, -4, 0), Vector(4, 4, 8));
SET_MODEL( ENT( pev ), "models/w_squeak.mdl" );
UTIL_SetSize( pev, Vector( -4, -4, 0 ), Vector( 4, 4, 8 ) );
UTIL_SetOrigin( pev, pev->origin );
SetTouch( &CSqueakGrenade::SuperBounceTouch );
@ -139,28 +140,28 @@ void CSqueakGrenade :: Spawn( void )
m_flFieldOfView = 0; // 180 degrees
if ( pev->owner )
if( pev->owner )
m_hOwner = Instance( pev->owner );
m_flNextBounceSoundTime = gpGlobals->time;// reset each time a snark is spawned.
pev->sequence = WSQUEAK_RUN;
ResetSequenceInfo( );
ResetSequenceInfo();
}
void CSqueakGrenade::Precache( void )
{
PRECACHE_MODEL("models/w_squeak.mdl");
PRECACHE_SOUND("squeek/sqk_blast1.wav");
PRECACHE_SOUND("common/bodysplat.wav");
PRECACHE_SOUND("squeek/sqk_die1.wav");
PRECACHE_SOUND("squeek/sqk_hunt1.wav");
PRECACHE_SOUND("squeek/sqk_hunt2.wav");
PRECACHE_SOUND("squeek/sqk_hunt3.wav");
PRECACHE_SOUND("squeek/sqk_deploy1.wav");
PRECACHE_MODEL( "models/w_squeak.mdl" );
PRECACHE_SOUND( "squeek/sqk_blast1.wav" );
PRECACHE_SOUND( "common/bodysplat.wav" );
PRECACHE_SOUND( "squeek/sqk_die1.wav" );
PRECACHE_SOUND( "squeek/sqk_hunt1.wav" );
PRECACHE_SOUND( "squeek/sqk_hunt2.wav" );
PRECACHE_SOUND( "squeek/sqk_hunt3.wav" );
PRECACHE_SOUND( "squeek/sqk_deploy1.wav" );
}
void CSqueakGrenade :: Killed( entvars_t *pevAttacker, int iGib )
void CSqueakGrenade::Killed( entvars_t *pevAttacker, int iGib )
{
pev->model = iStringNull;// make invisible
SetThink( &CBaseEntity::SUB_Remove );
@ -173,69 +174,69 @@ void CSqueakGrenade :: Killed( entvars_t *pevAttacker, int iGib )
pev->takedamage = DAMAGE_NO;
// play squeek blast
EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, "squeek/sqk_blast1.wav", 1, 0.5, 0, PITCH_NORM);
EMIT_SOUND_DYN( ENT( pev ), CHAN_ITEM, "squeek/sqk_blast1.wav", 1, 0.5, 0, PITCH_NORM );
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, SMALL_EXPLOSION_VOLUME, 3.0 );
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 );
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 );
RadiusDamage( pev, pev, pev->dmg, CLASS_NONE, DMG_BLAST );
// reset owner so death message happens
if (m_hOwner != NULL)
if( m_hOwner != NULL )
pev->owner = m_hOwner->edict();
CBaseMonster :: Killed( pevAttacker, GIB_ALWAYS );
CBaseMonster::Killed( pevAttacker, GIB_ALWAYS );
}
void CSqueakGrenade :: GibMonster( void )
void CSqueakGrenade::GibMonster( void )
{
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "common/bodysplat.wav", 0.75, ATTN_NORM, 0, 200 );
}
void CSqueakGrenade::HuntThink( void )
{
// ALERT( at_console, "think\n" );
if (!IsInWorld())
if( !IsInWorld() )
{
SetTouch( NULL );
UTIL_Remove( this );
return;
}
StudioFrameAdvance( );
StudioFrameAdvance();
pev->nextthink = gpGlobals->time + 0.1;
// explode when ready
if (gpGlobals->time >= m_flDie)
if( gpGlobals->time >= m_flDie )
{
g_vecAttackDir = pev->velocity.Normalize( );
g_vecAttackDir = pev->velocity.Normalize();
pev->health = -1;
Killed( pev, 0 );
return;
}
// float
if (pev->waterlevel != 0)
if( pev->waterlevel != 0 )
{
if (pev->movetype == MOVETYPE_BOUNCE)
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 ) )
else if( ( pev->movetype = MOVETYPE_FLY ) )
{
pev->movetype = MOVETYPE_BOUNCE;
}
// return if not time to hunt
if (m_flNextHunt > gpGlobals->time)
if( m_flNextHunt > gpGlobals->time )
return;
m_flNextHunt = gpGlobals->time + 2.0;
@ -246,41 +247,41 @@ void CSqueakGrenade::HuntThink( void )
Vector vecFlat = pev->velocity;
vecFlat.z = 0;
vecFlat = vecFlat.Normalize( );
vecFlat = vecFlat.Normalize();
UTIL_MakeVectors( pev->angles );
if (m_hEnemy == NULL || !m_hEnemy->IsAlive())
if( m_hEnemy == NULL || !m_hEnemy->IsAlive() )
{
// find target, bounce a bit towards it.
Look( 512 );
m_hEnemy = BestVisibleEnemy( );
m_hEnemy = BestVisibleEnemy();
}
// squeek if it's about time blow up
if ((m_flDie - gpGlobals->time <= 0.5) && (m_flDie - gpGlobals->time >= 0.3))
if( ( m_flDie - gpGlobals->time <= 0.5 ) && ( m_flDie - gpGlobals->time >= 0.3 ) )
{
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_die1.wav", 1, ATTN_NORM, 0, 100 + RANDOM_LONG(0,0x3F));
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 256, 0.25 );
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_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) / SQUEEK_DETONATE_DELAY);
if (flpitch < 80)
float flpitch = 155.0 - 60.0 * ( ( m_flDie - gpGlobals->time ) / SQUEEK_DETONATE_DELAY );
if( flpitch < 80 )
flpitch = 80;
if (m_hEnemy != NULL)
if( m_hEnemy != NULL )
{
if (FVisible( m_hEnemy ))
if( FVisible( m_hEnemy ) )
{
vecDir = m_hEnemy->EyePosition() - pev->origin;
m_vecTarget = vecDir.Normalize( );
m_vecTarget = vecDir.Normalize();
}
float flVel = pev->velocity.Length();
float flAdj = 50.0 / (flVel + 10.0);
float flAdj = 50.0 / ( flVel + 10.0 );
if (flAdj > 1.2)
if( flAdj > 1.2 )
flAdj = 1.2;
// ALERT( at_console, "think : enemy\n");
@ -290,20 +291,20 @@ void CSqueakGrenade::HuntThink( void )
pev->velocity = pev->velocity * flAdj + m_vecTarget * 300;
}
if (pev->flags & FL_ONGROUND)
if( pev->flags & FL_ONGROUND )
{
pev->avelocity = Vector( 0, 0, 0 );
}
else
{
if (pev->avelocity == Vector( 0, 0, 0))
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)
if( ( pev->origin - m_posPrev ).Length() < 1.0 )
{
pev->velocity.x = RANDOM_FLOAT( -100, 100 );
pev->velocity.y = RANDOM_FLOAT( -100, 100 );
@ -319,10 +320,10 @@ void CSqueakGrenade::SuperBounceTouch( CBaseEntity *pOther )
{
float flpitch;
TraceResult tr = UTIL_GetGlobalTrace( );
TraceResult tr = UTIL_GetGlobalTrace();
// don't hit the guy that launched this grenade
if ( pev->owner && pOther->edict() == pev->owner )
if( pev->owner && pOther->edict() == pev->owner )
return;
// at least until we've bounced once
@ -332,26 +333,26 @@ void CSqueakGrenade::SuperBounceTouch( CBaseEntity *pOther )
pev->angles.z = 0;
// avoid bouncing too much
if (m_flNextHit > gpGlobals->time)
if( m_flNextHit > gpGlobals->time )
return;
// higher pitch as squeeker gets closer to detonation time
flpitch = 155.0 - 60.0 * ((m_flDie - gpGlobals->time) / SQUEEK_DETONATE_DELAY);
flpitch = 155.0 - 60.0 * ( ( m_flDie - gpGlobals->time ) / SQUEEK_DETONATE_DELAY );
if ( pOther->pev->takedamage && m_flNextAttack < gpGlobals->time )
if( pOther->pev->takedamage && m_flNextAttack < gpGlobals->time )
{
// attack!
// make sure it's me who has touched them
if (tr.pHit == pOther->edict())
if( tr.pHit == pOther->edict() )
{
// and it's not another squeakgrenade
if (tr.pHit->v.modelindex != pev->modelindex)
if( tr.pHit->v.modelindex != pev->modelindex )
{
// ALERT( at_console, "hit enemy\n");
// ALERT( at_console, "hit enemy\n" );
ClearMultiDamage( );
pOther->TraceAttack(pev, gSkillData.snarkDmgBite, gpGlobals->v_forward, &tr, DMG_SLASH );
if (m_hOwner != NULL)
pOther->TraceAttack( pev, gSkillData.snarkDmgBite, gpGlobals->v_forward, &tr, DMG_SLASH );
if( m_hOwner != NULL )
ApplyMultiDamage( pev, m_hOwner->pev );
else
ApplyMultiDamage( pev, pev );
@ -360,46 +361,46 @@ void CSqueakGrenade::SuperBounceTouch( CBaseEntity *pOther )
// m_flDie += 2.0; // add more life
// make bite sound
EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, "squeek/sqk_deploy1.wav", 1.0, ATTN_NORM, 0, (int)flpitch);
EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "squeek/sqk_deploy1.wav", 1.0, ATTN_NORM, 0, (int)flpitch );
m_flNextAttack = gpGlobals->time + 0.5;
}
}
else
{
// ALERT( at_console, "been hit\n");
// ALERT( at_console, "been hit\n" );
}
}
m_flNextHit = gpGlobals->time + 0.1;
m_flNextHunt = gpGlobals->time;
if ( g_pGameRules->IsMultiplayer() )
if( g_pGameRules->IsMultiplayer() )
{
// in multiplayer, we limit how often snarks can make their bounce sounds to prevent overflows.
if ( gpGlobals->time < m_flNextBounceSoundTime )
if( gpGlobals->time < m_flNextBounceSoundTime )
{
// too soon!
return;
}
}
if (!(pev->flags & FL_ONGROUND))
if( !( pev->flags & FL_ONGROUND ) )
{
// play bounce sound
float flRndSound = RANDOM_FLOAT ( 0 , 1 );
float flRndSound = RANDOM_FLOAT( 0, 1 );
if ( flRndSound <= 0.33 )
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt1.wav", 1, ATTN_NORM, 0, (int)flpitch);
else if (flRndSound <= 0.66)
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt2.wav", 1, ATTN_NORM, 0, (int)flpitch);
if( flRndSound <= 0.33 )
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_hunt1.wav", 1, ATTN_NORM, 0, (int)flpitch );
else if( flRndSound <= 0.66 )
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_hunt2.wav", 1, ATTN_NORM, 0, (int)flpitch );
else
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt3.wav", 1, ATTN_NORM, 0, (int)flpitch);
CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, 256, 0.25 );
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_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 );
CSoundEnt::InsertSound( bits_SOUND_COMBAT, pev->origin, 100, 0.1 );
}
m_flNextBounceSoundTime = gpGlobals->time + 0.5;// half second.
@ -408,11 +409,11 @@ void CSqueakGrenade::SuperBounceTouch( CBaseEntity *pOther )
LINK_ENTITY_TO_CLASS( weapon_snark, CSqueak )
void CSqueak::Spawn( )
void CSqueak::Spawn()
{
Precache( );
Precache();
m_iId = WEAPON_SNARK;
SET_MODEL(ENT(pev), "models/w_sqknest.mdl");
SET_MODEL( ENT( pev ), "models/w_sqknest.mdl" );
FallInit();//get ready to fall down.
@ -425,19 +426,19 @@ void CSqueak::Spawn( )
void CSqueak::Precache( void )
{
PRECACHE_MODEL("models/w_sqknest.mdl");
PRECACHE_MODEL("models/v_squeak.mdl");
PRECACHE_MODEL("models/p_squeak.mdl");
PRECACHE_SOUND("squeek/sqk_hunt2.wav");
PRECACHE_SOUND("squeek/sqk_hunt3.wav");
UTIL_PrecacheOther("monster_snark");
PRECACHE_MODEL( "models/w_sqknest.mdl" );
PRECACHE_MODEL( "models/v_squeak.mdl" );
PRECACHE_MODEL( "models/p_squeak.mdl" );
PRECACHE_SOUND( "squeek/sqk_hunt2.wav" );
PRECACHE_SOUND( "squeek/sqk_hunt3.wav" );
UTIL_PrecacheOther( "monster_snark" );
m_usSnarkFire = PRECACHE_EVENT ( 1, "events/snarkfire.sc" );
m_usSnarkFire = PRECACHE_EVENT( 1, "events/snarkfire.sc" );
}
int CSqueak::GetItemInfo(ItemInfo *p)
int CSqueak::GetItemInfo( ItemInfo *p )
{
p->pszName = STRING(pev->classname);
p->pszName = STRING( pev->classname );
p->pszAmmo1 = "Snarks";
p->iMaxAmmo1 = SNARK_MAX_CARRY;
p->pszAmmo2 = NULL;
@ -452,15 +453,15 @@ int CSqueak::GetItemInfo(ItemInfo *p)
return 1;
}
BOOL CSqueak::Deploy( )
BOOL CSqueak::Deploy()
{
// play hunt sound
float flRndSound = RANDOM_FLOAT ( 0 , 1 );
float flRndSound = RANDOM_FLOAT( 0, 1 );
if ( flRndSound <= 0.5 )
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt2.wav", 1, ATTN_NORM, 0, 100);
if( flRndSound <= 0.5 )
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_hunt2.wav", 1, ATTN_NORM, 0, 100 );
else
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt3.wav", 1, ATTN_NORM, 0, 100);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_hunt3.wav", 1, ATTN_NORM, 0, 100 );
m_pPlayer->m_iWeaponVolume = QUIET_GUN_VOLUME;
@ -471,21 +472,21 @@ void CSqueak::Holster( int skiplocal /* = 0 */ )
{
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
if ( !m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] )
if( !m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
m_pPlayer->pev->weapons &= ~(1<<WEAPON_SNARK);
m_pPlayer->pev->weapons &= ~( 1 << WEAPON_SNARK );
SetThink( &CBasePlayerItem::DestroyItem );
pev->nextthink = gpGlobals->time + 0.1;
return;
}
SendWeaponAnim( SQUEAK_DOWN );
EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM);
EMIT_SOUND( ENT( m_pPlayer->pev ), CHAN_WEAPON, "common/null.wav", 1.0, ATTN_NORM );
}
void CSqueak::PrimaryAttack()
{
if ( m_pPlayer->m_rgAmmo[ m_iPrimaryAmmoType ] )
if( m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] )
{
UTIL_MakeVectors( m_pPlayer->pev->v_angle );
TraceResult tr;
@ -494,7 +495,7 @@ void CSqueak::PrimaryAttack()
// 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 )
if( m_pPlayer->pev->flags & FL_DUCKING )
{
trace_origin = trace_origin - ( VEC_HULL_MIN - VEC_DUCK_HULL_MIN );
}
@ -510,7 +511,7 @@ void CSqueak::PrimaryAttack()
#endif
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usSnarkFire, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, 0, 0, 0, 0 );
if ( tr.fAllSolid == 0 && tr.fStartSolid == 0 && tr.flFraction > 0.25 )
if( tr.fAllSolid == 0 && tr.fStartSolid == 0 && tr.flFraction > 0.25 )
{
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
@ -519,12 +520,12 @@ void CSqueak::PrimaryAttack()
pSqueak->pev->velocity = gpGlobals->v_forward * 200 + m_pPlayer->pev->velocity;
#endif
// play hunt sound
float flRndSound = RANDOM_FLOAT ( 0 , 1 );
float flRndSound = RANDOM_FLOAT( 0, 1 );
if ( flRndSound <= 0.5 )
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt2.wav", 1, ATTN_NORM, 0, 105);
if( flRndSound <= 0.5 )
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_hunt2.wav", 1, ATTN_NORM, 0, 105 );
else
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt3.wav", 1, ATTN_NORM, 0, 105);
EMIT_SOUND_DYN( ENT( pev ), CHAN_VOICE, "squeek/sqk_hunt3.wav", 1, ATTN_NORM, 0, 105 );
m_pPlayer->m_iWeaponVolume = QUIET_GUN_VOLUME;
@ -545,14 +546,14 @@ void CSqueak::SecondaryAttack( void )
void CSqueak::WeaponIdle( void )
{
if ( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
if( m_flTimeWeaponIdle > UTIL_WeaponTimeBase() )
return;
if (m_fJustThrown)
if( m_fJustThrown )
{
m_fJustThrown = 0;
if ( !m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] )
if( !m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] )
{
RetireWeapon();
return;
@ -565,12 +566,12 @@ void CSqueak::WeaponIdle( void )
int iAnim;
float flRand = UTIL_SharedRandomFloat( m_pPlayer->random_seed, 0, 1 );
if (flRand <= 0.75)
if( flRand <= 0.75 )
{
iAnim = SQUEAK_IDLE1;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 30.0 / 16 * (2);
}
else if (flRand <= 0.875)
else if( flRand <= 0.875 )
{
iAnim = SQUEAK_FIDGETFIT;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 70.0 / 16.0;

56
dlls/stats.cpp
View File

@ -21,28 +21,28 @@
float AmmoDamage( const char *pName )
{
if ( !pName )
if( !pName )
return 0;
if ( !strcmp( pName, "9mm" ) )
if( !strcmp( pName, "9mm" ) )
return gSkillData.plrDmg9MM;
if ( !strcmp( pName, "357" ) )
if( !strcmp( pName, "357" ) )
return gSkillData.plrDmg357;
if ( !strcmp( pName, "ARgrenades" ) )
if( !strcmp( pName, "ARgrenades" ) )
return gSkillData.plrDmgM203Grenade;
if ( !strcmp( pName, "buckshot" ) )
if( !strcmp( pName, "buckshot" ) )
return gSkillData.plrDmgBuckshot;
if ( !strcmp( pName, "bolts") )
if( !strcmp( pName, "bolts") )
return gSkillData.plrDmgCrossbowMonster;
if ( !strcmp( pName, "rockets") )
if( !strcmp( pName, "rockets") )
return gSkillData.plrDmgRPG;
if ( !strcmp( pName, "uranium") )
if( !strcmp( pName, "uranium") )
return gSkillData.plrDmgGauss;
if ( !strcmp( pName, "Hand Grenade") )
if( !strcmp( pName, "Hand Grenade") )
return gSkillData.plrDmgHandGrenade;
if ( !strcmp( pName, "Satchel Charge") )
if( !strcmp( pName, "Satchel Charge") )
return gSkillData.plrDmgSatchel;
if ( !strcmp( pName, "Trip Mine") )
if( !strcmp( pName, "Trip Mine") )
return gSkillData.plrDmgTripmine;
return 0;
@ -53,7 +53,7 @@ void UpdateStatsFile( float dataTime, char *pMapname, float health, float ammo,
FILE *fp;
fp = fopen( "stats.txt", "a" );
if ( !fp )
if( !fp )
return;
fprintf( fp, "%6.2f, %6.2f, %6.2f, %s, %2d\n", dataTime, health, ammo, pMapname, skillLevel );
fclose( fp );
@ -74,18 +74,18 @@ typedef struct
float lastGameTime;
} TESTSTATS;
TESTSTATS gStats = {0,0,0,0,0,0,0};
TESTSTATS gStats = { 0, 0, 0, 0, 0, 0, 0 };
void UpdateStats( CBasePlayer *pPlayer )
{
int i;
int ammoCount[ MAX_AMMO_SLOTS ];
int ammoCount[MAX_AMMO_SLOTS];
memcpy( ammoCount, pPlayer->m_rgAmmo, MAX_AMMO_SLOTS * sizeof(int) );
// Keep a running time, so the graph doesn't overlap
if ( gpGlobals->time < gStats.lastGameTime ) // Changed level or died, don't b0rk
if( gpGlobals->time < gStats.lastGameTime ) // Changed level or died, don't b0rk
{
gStats.lastGameTime = gpGlobals->time;
gStats.dataTime = gStats.gameTime;
@ -94,26 +94,26 @@ void UpdateStats( CBasePlayer *pPlayer )
gStats.gameTime += gpGlobals->time - gStats.lastGameTime;
gStats.lastGameTime = gpGlobals->time;
for (i = 0; i < MAX_ITEM_TYPES; i++)
for( i = 0; i < MAX_ITEM_TYPES; i++ )
{
CBasePlayerItem *p = pPlayer->m_rgpPlayerItems[i];
while (p)
while( p )
{
ItemInfo II;
memset(&II, 0, sizeof(II));
p->GetItemInfo(&II);
memset( &II, 0, sizeof(II) );
p->GetItemInfo( &II );
int index = pPlayer->GetAmmoIndex(II.pszAmmo1);
if ( index >= 0 )
ammoCount[ index ] += ((CBasePlayerWeapon *)p)->m_iClip;
int index = pPlayer->GetAmmoIndex( II.pszAmmo1 );
if( index >= 0 )
ammoCount[index] += ( (CBasePlayerWeapon *)p )->m_iClip;
p = p->m_pNext;
}
}
float ammo = 0;
for (i = 1; i < MAX_AMMO_SLOTS; i++)
for( i = 1; i < MAX_AMMO_SLOTS; i++ )
{
ammo += ammoCount[i] * AmmoDamage( CBasePlayerItem::AmmoInfoArray[i].pszName );
}
@ -122,12 +122,12 @@ void UpdateStats( CBasePlayer *pPlayer )
float ammoDelta = fabs( ammo - gStats.lastAmmo );
float healthDelta = fabs( health - gStats.lastHealth );
int forceWrite = 0;
if ( health <= 0 && gStats.lastHealth > 0 )
if( health <= 0 && gStats.lastHealth > 0 )
forceWrite = 1;
if ( (ammoDelta > AMMO_THRESHOLD || healthDelta > HEALTH_THRESHOLD) && !forceWrite )
if( ( ammoDelta > AMMO_THRESHOLD || healthDelta > HEALTH_THRESHOLD ) && !forceWrite )
{
if ( gStats.nextOutputTime == 0 )
if( gStats.nextOutputTime == 0 )
gStats.dataTime = gStats.gameTime;
gStats.lastAmmo = ammo;
@ -135,9 +135,9 @@ void UpdateStats( CBasePlayer *pPlayer )
gStats.nextOutputTime = gStats.gameTime + OUTPUT_LATENCY;
}
else if ( (gStats.nextOutputTime != 0 && gStats.nextOutputTime < gStats.gameTime) || forceWrite )
else if( ( gStats.nextOutputTime != 0 && gStats.nextOutputTime < gStats.gameTime ) || forceWrite )
{
UpdateStatsFile( gStats.dataTime, (char *)STRING(gpGlobals->mapname), health, ammo, (int)CVAR_GET_FLOAT("skill") );
UpdateStatsFile( gStats.dataTime, (char *)STRING( gpGlobals->mapname ), health, ammo, (int)CVAR_GET_FLOAT( "skill" ) );
gStats.lastAmmo = ammo;
gStats.lastHealth = health;

Some files were not shown because too many files have changed in this diff Show More