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

9
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 {
int type;
typedef struct
{
int type;
char *name;
} activity_map_t;
extern activity_map_t activity_map[];
#endif //ACTIVITY_H

431
dlls/aflock.cpp
View File

@ -14,13 +14,14 @@
****/
//=========================================================
//=========================================================
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "squadmonster.h"
#define AFLOCK_MAX_RECRUIT_RADIUS 1024
#define AFLOCK_MAX_RECRUIT_RADIUS 1024
#define AFLOCK_FLY_SPEED 125
#define AFLOCK_TURN_RATE 75
#define AFLOCK_ACCELERATE 10
@ -38,18 +39,18 @@ public:
void KeyValue( KeyValueData *pkvd );
void SpawnFlock( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
// Sounds are shared by the flock
static void PrecacheFlockSounds( void );
static void PrecacheFlockSounds( void );
int m_cFlockSize;
float m_flFlockRadius;
int m_cFlockSize;
float m_flFlockRadius;
};
TYPEDESCRIPTION CFlockingFlyerFlock::m_SaveData[] =
TYPEDESCRIPTION CFlockingFlyerFlock::m_SaveData[] =
{
DEFINE_FIELD( CFlockingFlyerFlock, m_cFlockSize, FIELD_INTEGER ),
DEFINE_FIELD( CFlockingFlyerFlock, m_flFlockRadius, FIELD_FLOAT ),
@ -81,13 +82,13 @@ public:
BOOL FPathBlocked( void );
//void KeyValue( KeyValueData *pkvd );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int IsLeader( void ) { return m_pSquadLeader == this; }
int InSquad( void ) { return m_pSquadLeader != NULL; }
int SquadCount( void );
int InSquad( void ) { return m_pSquadLeader != NULL; }
int SquadCount( void );
void SquadRemove( CFlockingFlyer *pRemove );
void SquadUnlink( void );
void SquadAdd( CFlockingFlyer *pAdd );
@ -95,22 +96,22 @@ public:
CFlockingFlyer *m_pSquadLeader;
CFlockingFlyer *m_pSquadNext;
BOOL m_fTurning;// is this boid turning?
BOOL m_fCourseAdjust;// followers set this flag TRUE to override flocking while they avoid something
BOOL m_fPathBlocked;// TRUE if there is an obstacle ahead
Vector m_vecReferencePoint;// last place we saw leader
Vector m_vecAdjustedVelocity;// adjusted velocity (used when fCourseAdjust is TRUE)
float m_flGoalSpeed;
float m_flLastBlockedTime;
float m_flFakeBlockedTime;
float m_flAlertTime;
float m_flFlockNextSoundTime;
BOOL m_fTurning;// is this boid turning?
BOOL m_fCourseAdjust;// followers set this flag TRUE to override flocking while they avoid something
BOOL m_fPathBlocked;// TRUE if there is an obstacle ahead
Vector m_vecReferencePoint;// last place we saw leader
Vector m_vecAdjustedVelocity;// adjusted velocity (used when fCourseAdjust is TRUE)
float m_flGoalSpeed;
float m_flLastBlockedTime;
float m_flFakeBlockedTime;
float m_flAlertTime;
float m_flFlockNextSoundTime;
};
LINK_ENTITY_TO_CLASS( monster_flyer, CFlockingFlyer )
LINK_ENTITY_TO_CLASS( monster_flyer_flock, CFlockingFlyerFlock )
TYPEDESCRIPTION CFlockingFlyer::m_SaveData[] =
TYPEDESCRIPTION CFlockingFlyer::m_SaveData[] =
{
DEFINE_FIELD( CFlockingFlyer, m_pSquadLeader, FIELD_CLASSPTR ),
DEFINE_FIELD( CFlockingFlyer, m_pSquadNext, FIELD_CLASSPTR ),
@ -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,15 +185,15 @@ 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;
pLeader->m_pSquadLeader = pLeader;
pLeader->m_pSquadNext = NULL;
}
@ -202,18 +203,18 @@ 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;
pBoid->pev->velocity = g_vecZero;
pBoid->pev->angles = pev->angles;
pBoid->pev->angles = pev->angles;
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,11 +223,11 @@ void CFlockingFlyerFlock :: SpawnFlock( void )
//=========================================================
//=========================================================
void CFlockingFlyer :: Spawn( )
void CFlockingFlyer::Spawn()
{
Precache( );
Precache();
SpawnCommonCode();
pev->frame = 0;
pev->nextthink = gpGlobals->time + 0.1;
SetThink( &CFlockingFlyer::IdleThink );
@ -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,56 +324,59 @@ void CFlockingFlyer :: FallHack( void )
//=========================================================
//=========================================================
void CFlockingFlyer :: SpawnCommonCode( )
void CFlockingFlyer::SpawnCommonCode()
{
pev->deadflag = DEAD_NO;
pev->classname = MAKE_STRING("monster_flyer");
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_FLY;
pev->deadflag = DEAD_NO;
pev->classname = MAKE_STRING( "monster_flyer" );
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_FLY;
pev->takedamage = DAMAGE_NO;
pev->health = 1;
pev->health = 1;
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;
// pev->framerate = flapspeed;
StudioFrameAdvance( 0.1 );
}
//=========================================================
//=========================================================
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 );
Vector vecTakeOff;
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;
@ -421,15 +431,15 @@ void CFlockingFlyer :: FormFlock( void )
int squadCount = 1;
CBaseEntity *pEntity = NULL;
while ((pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, AFLOCK_MAX_RECRUIT_RADIUS )) != NULL)
{
CBaseMonster *pRecruit = pEntity->MyMonsterPointer( );
if ( pRecruit && pRecruit != this && pRecruit->IsAlive() && !pRecruit->m_pCine )
while( ( pEntity = UTIL_FindEntityInSphere( pEntity, pev->origin, AFLOCK_MAX_RECRUIT_RADIUS ) ) != NULL )
{
CBaseMonster *pRecruit = pEntity->MyMonsterPointer();
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
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;
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;
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,25 +562,24 @@ 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
Vector vecDir;// used for general measurements
int cProcessed = 0;// keep track of how many other boids we've processed
float flLeftSide;
float flRightSide;
TraceResult tr;
Vector vecDist;// used for general measurements
Vector vecDir;// used for general measurements
int cProcessed = 0;// keep track of how many other boids we've processed
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,47 +638,47 @@ 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 );
}
BoidAdvanceFrame( );
return;
}
//=========================================================
// follower boids execute this code when flocking
//=========================================================
void CFlockingFlyer :: FlockFollowerThink( void )
void CFlockingFlyer::FlockFollowerThink( void )
{
TraceResult tr;
Vector vecDist;
Vector vecDir;
Vector vecDirToLeader;
float flDistToLeader;
TraceResult tr;
Vector vecDist;
Vector vecDir;
Vector vecDirToLeader;
float flDistToLeader;
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;
}
@ -737,13 +746,13 @@ void CFlockingFlyer :: FlockFollowerThink( void )
BoidAdvanceFrame( );
}
/*
/*
// 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;
@ -751,24 +760,24 @@ void CFlockingFlyer :: FlockFollowerThink( void )
else // set course adjust flag and calculate adjusted velocity
{
m_fCourseAdjust = TRUE;
// 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,10 +799,10 @@ void CFlockingFlyer :: FlockFollowerThink( void )
// SquadUnlink(), Unlink the squad pointers.
//
//=========================================================
void CFlockingFlyer :: SquadUnlink( void )
void CFlockingFlyer::SquadUnlink( void )
{
m_pSquadLeader = NULL;
m_pSquadNext = 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();

628
dlls/agrunt.cpp
View File

File diff suppressed because it is too large Load Diff

44
dlls/airtank.cpp
View File

@ -26,54 +26,54 @@ class CAirtank : public CGrenade
void Precache( void );
void EXPORT TankThink( void );
void EXPORT TankTouch( CBaseEntity *pOther );
int BloodColor( void ) { return DONT_BLEED; };
int BloodColor( void ) { return DONT_BLEED; };
void Killed( entvars_t *pevAttacker, int iGib );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int m_state;
int m_state;
};
LINK_ENTITY_TO_CLASS( item_airtank, CAirtank )
TYPEDESCRIPTION CAirtank::m_SaveData[] =
TYPEDESCRIPTION CAirtank::m_SaveData[] =
{
DEFINE_FIELD( CAirtank, m_state, FIELD_INTEGER ),
};
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 );
SetThink( &CAirtank::TankThink );
pev->flags |= FL_MONSTER;
pev->takedamage = DAMAGE_YES;
pev->health = 20;
pev->dmg = 50;
m_state = 1;
pev->takedamage = DAMAGE_YES;
pev->health = 20;
pev->dmg = 50;
m_state = 1;
}
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,21 +91,21 @@ 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;
}
// give player 12 more seconds of air
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;

147
dlls/animating.cpp
View File

@ -26,7 +26,7 @@
#include "animation.h"
#include "saverestore.h"
TYPEDESCRIPTION CBaseAnimating::m_SaveData[] =
TYPEDESCRIPTION CBaseAnimating::m_SaveData[] =
{
DEFINE_FIELD( CBaseMonster, m_flFrameRate, FIELD_FLOAT ),
DEFINE_FIELD( CBaseMonster, m_flGroundSpeed, FIELD_FLOAT ),
@ -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) );
if (piDir == NULL)
void *pmodel = GET_MODEL_PTR( ENT( pev ) );
if( piDir == NULL )
{
int iDir;
int sequence = ::FindTransition( pmodel, iEndingSequence, iGoalSequence, &iDir );
if (iDir != 1)
if( iDir != 1 )
return -1;
else
return sequence;
@ -226,80 +226,80 @@ 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;
bounds[1] = maxs;
Vector rmin( 9999, 9999, 9999 );
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;
// transform the point
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 );
}
}

280
dlls/animation.cpp
View File

@ -12,12 +12,13 @@
* without written permission from Valve LLC.
*
****/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int BOOL;
#define TRUE 1
#define TRUE 1
#define FALSE 0
// hack into header files that we can ship
@ -56,22 +57,22 @@ extern globalvars_t *gpGlobals;
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;
mstudioseqdesc_t *pseqdesc;
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];
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex );
maxs[0] = pseqdesc[ sequence ].bbmax[0];
maxs[1] = pseqdesc[ sequence ].bbmax[1];
maxs[2] = pseqdesc[ sequence ].bbmax[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];
return 1;
}
@ -79,23 +80,23 @@ int ExtractBbox( void *pmodel, int sequence, float *mins, float *maxs )
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;
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;
}
}
@ -106,22 +107,22 @@ int LookupActivity( void *pmodel, entvars_t *pev, int activity )
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;
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,36 +133,36 @@ 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 )
{
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return 0;
mstudioseqdesc_t *pseqdesc;
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;
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 ) ) );
}
}
}
@ -216,27 +217,27 @@ void SequencePrecache( void *pmodel, const char *pSequenceName )
void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed )
{
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return;
mstudioseqdesc_t *pseqdesc;
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
{
@ -248,13 +249,13 @@ void GetSequenceInfo( void *pmodel, entvars_t *pev, float *pflFrameRate, float *
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;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)( (byte *)pstudiohdr + pstudiohdr->seqindex ) + (int)pev->sequence;
return pseqdesc->flags;
}
@ -262,25 +263,25 @@ int GetSequenceFlags( void *pmodel, entvars_t *pev )
int GetAnimationEvent( void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index )
{
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;
mstudioseqdesc_t *pseqdesc;
mstudioevent_t *pevent;
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;
@ -310,119 +311,122 @@ float SetController( void *pmodel, entvars_t *pev, int iController, float flValu
{
studiohdr_t *pstudiohdr;
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 )
{
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return flValue;
mstudioseqdesc_t *pseqdesc;
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 )
{
studiohdr_t *pstudiohdr;
pstudiohdr = (studiohdr_t *)pmodel;
if (! pstudiohdr)
if( !pstudiohdr )
return iGoalAnim;
mstudioseqdesc_t *pseqdesc;
pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
mstudioseqdesc_t *pseqdesc;
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;
}
int iEndNode;
int iEndNode;
// 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;
@ -471,41 +475,41 @@ int FindTransition( void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir )
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 )
{
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

447
dlls/apache.cpp
View File

File diff suppressed because it is too large Load Diff

218
dlls/barnacle.cpp
View File

@ -36,23 +36,23 @@ 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 );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
float m_flAltitude;
float m_flCachedLength; // tongue cached length
float m_flKillVictimTime;
int m_cGibs; // barnacle loads up on gibs each time it kills something.
BOOL m_fTongueExtended;
BOOL m_fLiftingPrey;
int m_cGibs; // barnacle loads up on gibs each time it kills something.
BOOL m_fTongueExtended;
BOOL m_fLiftingPrey;
float m_flTongueAdj;
// FIXME: need a custom barnacle model with non-generic hitgroup
@ -68,7 +68,7 @@ public:
LINK_ENTITY_TO_CLASS( monster_barnacle, CBarnacle )
TYPEDESCRIPTION CBarnacle::m_SaveData[] =
TYPEDESCRIPTION CBarnacle::m_SaveData[] =
{
DEFINE_FIELD( CBarnacle, m_flAltitude, FIELD_FLOAT ),
DEFINE_FIELD( CBarnacle, m_flKillVictimTime, FIELD_TIME ),
@ -85,9 +85,9 @@ 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;
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,40 +112,40 @@ 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;
pev->takedamage = DAMAGE_AIM;
m_bloodColor = BLOOD_COLOR_RED;
pev->effects = EF_INVLIGHT; // take light from the ceiling
pev->health = 25;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
m_flKillVictimTime = 0;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE;
pev->takedamage = DAMAGE_AIM;
m_bloodColor = BLOOD_COLOR_RED;
pev->effects = EF_INVLIGHT; // take light from the ceiling
pev->health = 25;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
m_flKillVictimTime = 0;
m_flCachedLength = 32; // mins.z
m_cGibs = 0;
m_fLiftingPrey = FALSE;
m_flTongueAdj = -100;
m_cGibs = 0;
m_fLiftingPrey = FALSE;
m_flTongueAdj = -100;
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;
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];
}

446
dlls/barney.cpp
View File

@ -38,7 +38,7 @@
#define BARNEY_BODY_GUNHOLSTERED 0
#define BARNEY_BODY_GUNDRAWN 1
#define BARNEY_BODY_GUNGONE 2
#define BARNEY_BODY_GUNGONE 2
class CBarney : public CTalkMonster
{
@ -46,51 +46,51 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int ISoundMask( void );
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; }
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 );
void TalkInit( void );
void TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
void Killed( entvars_t *pevAttacker, int iGib );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
BOOL m_fGunDrawn;
float m_painTime;
float m_checkAttackTime;
BOOL m_lastAttackCheck;
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
BOOL m_fGunDrawn;
float m_painTime;
float m_checkAttackTime;
BOOL m_lastAttackCheck;
// UNDONE: What is this for? It isn't used?
float m_flPlayerDamage;// how much pain has the player inflicted on me?
float m_flPlayerDamage;// how much pain has the player inflicted on me?
CUSTOM_SCHEDULES
};
LINK_ENTITY_TO_CLASS( monster_barney, CBarney )
TYPEDESCRIPTION CBarney::m_SaveData[] =
TYPEDESCRIPTION CBarney::m_SaveData[] =
{
DEFINE_FIELD( CBarney, m_fGunDrawn, FIELD_BOOLEAN ),
DEFINE_FIELD( CBarney, m_painTime, FIELD_TIME ),
@ -104,20 +104,20 @@ IMPLEMENT_SAVERESTORE( CBarney, CTalkMonster )
//=========================================================
// AI Schedules Specific to this monster
//=========================================================
Task_t tlBaFollow[] =
Task_t tlBaFollow[] =
{
{ TASK_MOVE_TO_TARGET_RANGE,(float)128 }, // Move within 128 of target ent (client)
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
{ TASK_MOVE_TO_TARGET_RANGE, (float)128 }, // Move within 128 of target ent (client)
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
};
Schedule_t slBaFollow[] =
Schedule_t slBaFollow[] =
{
{
tlBaFollow,
ARRAYSIZE ( tlBaFollow ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
ARRAYSIZE( tlBaFollow ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_HEAR_SOUND |
bits_COND_PROVOKED,
bits_SOUND_DANGER,
@ -126,44 +126,44 @@ 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[] =
Task_t tlBarneyEnemyDraw[] =
{
{ TASK_STOP_MOVING, 0 },
{ TASK_FACE_ENEMY, 0 },
{ TASK_PLAY_SEQUENCE_FACE_ENEMY, (float) ACT_ARM },
{ TASK_STOP_MOVING, 0 },
{ TASK_FACE_ENEMY, 0 },
{ TASK_PLAY_SEQUENCE_FACE_ENEMY, (float) ACT_ARM },
};
Schedule_t slBarneyEnemyDraw[] =
Schedule_t slBarneyEnemyDraw[] =
{
{
tlBarneyEnemyDraw,
ARRAYSIZE ( tlBarneyEnemyDraw ),
ARRAYSIZE( tlBarneyEnemyDraw ),
0,
0,
"Barney Enemy Draw"
}
};
Task_t tlBaFaceTarget[] =
Task_t tlBaFaceTarget[] =
{
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_FACE_TARGET, (float)0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_CHASE },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_FACE_TARGET, (float)0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_CHASE },
};
Schedule_t slBaFaceTarget[] =
Schedule_t slBaFaceTarget[] =
{
{
tlBaFaceTarget,
ARRAYSIZE ( tlBaFaceTarget ),
bits_COND_CLIENT_PUSH |
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
ARRAYSIZE( tlBaFaceTarget ),
bits_COND_CLIENT_PUSH |
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_HEAR_SOUND |
bits_COND_PROVOKED,
bits_SOUND_DANGER,
@ -171,33 +171,31 @@ Schedule_t slBaFaceTarget[] =
},
};
Task_t tlIdleBaStand[] =
Task_t tlIdleBaStand[] =
{
{ TASK_STOP_MOVING, 0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_WAIT, (float)2 }, // repick IDLESTAND every two seconds.
{ TASK_TLK_HEADRESET, (float)0 }, // reset head position
{ TASK_STOP_MOVING, 0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_WAIT, (float)2 }, // repick IDLESTAND every two seconds.
{ TASK_TLK_HEADRESET, (float)0 }, // reset head position
};
Schedule_t slIdleBaStand[] =
Schedule_t slIdleBaStand[] =
{
{
{
tlIdleBaStand,
ARRAYSIZE ( tlIdleBaStand ),
bits_COND_NEW_ENEMY |
bits_COND_LIGHT_DAMAGE |
bits_COND_HEAVY_DAMAGE |
bits_COND_HEAR_SOUND |
bits_COND_SMELL |
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 |
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 |
bits_SOUND_GARBAGE,
"IdleStand"
},
@ -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,14 +237,14 @@ 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 |
bits_SOUND_CARCASS |
bits_SOUND_MEAT |
bits_SOUND_GARBAGE |
bits_SOUND_DANGER |
return bits_SOUND_WORLD |
bits_SOUND_COMBAT |
bits_SOUND_CARCASS |
bits_SOUND_MEAT |
bits_SOUND_GARBAGE |
bits_SOUND_DANGER |
bits_SOUND_PLAYER;
}
@ -254,21 +252,21 @@ 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;
return CLASS_PLAYER_ALLY;
}
//=========================================================
// 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,49 +343,46 @@ 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!
}
//=========================================================
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//
// 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,25 +391,25 @@ 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;
m_bloodColor = BLOOD_COLOR_RED;
pev->health = gSkillData.barneyHealth;
pev->view_ofs = Vector ( 0, 0, 50 );// 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;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_RED;
pev->health = gSkillData.barneyHealth;
pev->view_ofs = Vector ( 0, 0, 50 );// 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;
pev->body = 0; // gun in holster
m_fGunDrawn = FALSE;
pev->body = 0; // gun in holster
m_fGunDrawn = FALSE;
m_afCapability = bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_DOORS_GROUP;
m_afCapability = bits_CAP_HEAR | bits_CAP_TURN_HEAD | bits_CAP_DOORS_GROUP;
MonsterInit();
SetUse( &CTalkMonster::FollowerUse );
@ -423,21 +418,21 @@ 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)
TalkInit();
@ -445,35 +440,34 @@ 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_ANSWER] = "BA_ANSWER";
m_szGrp[TLK_QUESTION] = "BA_QUESTION";
m_szGrp[TLK_IDLE] = "BA_IDLE";
m_szGrp[TLK_STARE] = "BA_STARE";
m_szGrp[TLK_USE] = "BA_OK";
m_szGrp[TLK_UNUSE] = "BA_WAIT";
m_szGrp[TLK_STOP] = "BA_STOP";
m_szGrp[TLK_IDLE] = "BA_IDLE";
m_szGrp[TLK_STARE] = "BA_STARE";
m_szGrp[TLK_USE] = "BA_OK";
m_szGrp[TLK_UNUSE] = "BA_WAIT";
m_szGrp[TLK_STOP] = "BA_STOP";
m_szGrp[TLK_NOSHOOT] = "BA_SCARED";
m_szGrp[TLK_HELLO] = "BA_HELLO";
m_szGrp[TLK_NOSHOOT] = "BA_SCARED";
m_szGrp[TLK_HELLO] = "BA_HELLO";
m_szGrp[TLK_PLHURT1] = "!BA_CUREA";
m_szGrp[TLK_PLHURT2] = "!BA_CUREB";
m_szGrp[TLK_PLHURT3] = "!BA_CUREC";
m_szGrp[TLK_PLHURT1] = "!BA_CUREA";
m_szGrp[TLK_PLHURT2] = "!BA_CUREB";
m_szGrp[TLK_PLHURT3] = "!BA_CUREC";
m_szGrp[TLK_PHELLO] = NULL; //"BA_PHELLO"; // UNDONE
m_szGrp[TLK_PIDLE] = NULL; //"BA_PIDLE"; // UNDONE
m_szGrp[TLK_PHELLO] = NULL; //"BA_PHELLO"; // UNDONE
m_szGrp[TLK_PIDLE] = NULL; //"BA_PIDLE"; // UNDONE
m_szGrp[TLK_PQUESTION] = "BA_PQUEST"; // UNDONE
m_szGrp[TLK_SMELL] = "BA_SMELL";
m_szGrp[TLK_SMELL] = "BA_SMELL";
m_szGrp[TLK_WOUND] = "BA_WOUND";
m_szGrp[TLK_MORTAL] = "BA_MORTAL";
m_szGrp[TLK_WOUND] = "BA_WOUND";
m_szGrp[TLK_MORTAL] = "BA_MORTAL";
// get voice for head - just one barney voice for now
m_voicePitch = 100;
@ -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 );
}
@ -536,55 +530,66 @@ int CBarney :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, floa
return ret;
}
//=========================================================
// 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);
switch (RANDOM_LONG(0,2))
m_painTime = gpGlobals->time + RANDOM_FLOAT( 0.5, 0.75 );
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;
@ -610,7 +615,7 @@ void CBarney::Killed( entvars_t *pevAttacker, int iGib )
pev->body = BARNEY_BODY_GUNGONE;
GetAttachment( 0, vecGunPos, vecGunAngles );
CBaseEntity *pGun = DropItem( "weapon_9mmhandgun", vecGunPos, vecGunAngles );
}
@ -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 );
}
@ -750,11 +750,11 @@ Schedule_t *CBarney :: GetSchedule ( void )
default:
break;
}
return CTalkMonster::GetSchedule();
}
MONSTERSTATE CBarney :: GetIdealState ( void )
MONSTERSTATE CBarney::GetIdealState( void )
{
return CTalkMonster::GetIdealState();
}
@ -778,11 +778,11 @@ 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 );
int m_iPose;// which sequence to display -- temporary, don't need to save
int m_iPose;// which sequence to display -- temporary, don't need to save
static char *m_szPoses[3];
};
@ -790,12 +790,12 @@ 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
else
CBaseMonster::KeyValue( pkvd );
}
@ -804,23 +804,23 @@ 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;
pev->sequence = 0;
m_bloodColor = BLOOD_COLOR_RED;
pev->effects = 0;
pev->yaw_speed = 8;
pev->sequence = 0;
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;
pev->health = 8;//gSkillData.barneyHealth;
MonsterInitDead();
}

438
dlls/basemonster.h
View File

@ -22,314 +22,310 @@
class CBaseMonster : public CBaseToggle
{
private:
int m_afConditions;
int m_afConditions;
public:
typedef enum
{
SCRIPT_PLAYING = 0, // Playing the sequence
SCRIPT_WAIT, // Waiting on everyone in the script to be ready
SCRIPT_CLEANUP, // Cancelling the script / cleaning up
SCRIPT_WALK_TO_MARK,
SCRIPT_RUN_TO_MARK
} SCRIPTSTATE;
typedef enum
{
SCRIPT_PLAYING = 0, // Playing the sequence
SCRIPT_WAIT, // Waiting on everyone in the script to be ready
SCRIPT_CLEANUP, // Cancelling the script / cleaning up
SCRIPT_WALK_TO_MARK,
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];
// 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 ];
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.
float m_flMoveWaitFinished;
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.
float m_flMoveWaitFinished;
Activity m_Activity;// what the monster is doing (animation)
Activity m_IdealActivity;// monster should switch to this activity
Activity m_Activity;// what the monster is doing (animation)
Activity m_IdealActivity;// monster should switch to this activity
int m_LastHitGroup; // the last body region that took damage
MONSTERSTATE m_MonsterState;// monster's current state
MONSTERSTATE m_IdealMonsterState;// monster should change to this state
int m_iTaskStatus;
Schedule_t *m_pSchedule;
int m_iScheduleIndex;
int m_LastHitGroup; // the last body region that took damage
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
MONSTERSTATE m_MonsterState;// monster's current state
MONSTERSTATE m_IdealMonsterState;// monster should change to this state
Vector m_vecMoveGoal; // kept around for node graph moves, so we know our ultimate goal
Activity m_movementActivity; // When moving, set this activity
int m_iTaskStatus;
Schedule_t *m_pSchedule;
int m_iScheduleIndex;
int m_iAudibleList; // first index of a linked list of sounds that the monster can hear.
int m_afSoundTypes;
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
Vector m_vecLastPosition;// monster sometimes wants to return to where it started after an operation.
Vector m_vecMoveGoal; // kept around for node graph moves, so we know our ultimate goal
Activity m_movementActivity; // When moving, set this activity
int m_iHintNode; // this is the hint node that the monster is moving towards or performing active idle on.
int m_iAudibleList; // first index of a linked list of sounds that the monster can hear.
int m_afSoundTypes;
int m_afMemory;
Vector m_vecLastPosition;// monster sometimes wants to return to where it started after an operation.
int m_iMaxHealth;// keeps track of monster's maximum health value (for re-healing, etc)
int m_iHintNode; // this is the hint node that the monster is moving towards or performing active idle on.
Vector m_vecEnemyLKP;// last known position of enemy. (enemy's origin)
int m_afMemory;
int m_cAmmoLoaded; // how much ammo is in the weapon (used to trigger reload anim sequences)
int m_iMaxHealth;// keeps track of monster's maximum health value (for re-healing, etc)
int m_afCapability;// tells us what a monster can/can't do.
Vector m_vecEnemyLKP;// last known position of enemy. (enemy's origin)
float m_flNextAttack; // cannot attack again until this time
int m_cAmmoLoaded; // how much ammo is in the weapon (used to trigger reload anim sequences)
int m_bitsDamageType; // what types of damage has monster (player) taken
BYTE m_rgbTimeBasedDamage[CDMG_TIMEBASED];
int m_afCapability;// tells us what a monster can/can't do.
int m_lastDamageAmount;// how much damage did monster (player) last take
// time based damage counters, decr. 1 per 2 seconds
int m_bloodColor; // color of blood particless
float m_flNextAttack; // cannot attack again until this time
int m_failSchedule; // Schedule type to choose if current schedule fails
int m_bitsDamageType; // what types of damage has monster (player) taken
BYTE m_rgbTimeBasedDamage[CDMG_TIMEBASED];
float m_flHungryTime;// set this is a future time to stop the monster from eating for a while.
int m_lastDamageAmount;// how much damage did monster (player) last take
// time based damage counters, decr. 1 per 2 seconds
int m_bloodColor; // color of blood particless
float m_flDistTooFar; // if enemy farther away than this, bits_COND_ENEMY_TOOFAR set in CheckEnemy
float m_flDistLook; // distance monster sees (Default 2048)
int m_failSchedule; // Schedule type to choose if current schedule fails
int m_iTriggerCondition;// for scripted AI, this is the condition that will cause the activation of the monster's TriggerTarget
string_t m_iszTriggerTarget;// name of target that should be fired.
float m_flHungryTime;// set this is a future time to stop the monster from eating for a while.
Vector m_HackedGunPos; // HACK until we can query end of gun
float m_flDistTooFar; // if enemy farther away than this, bits_COND_ENEMY_TOOFAR set in CheckEnemy
float m_flDistLook; // distance monster sees (Default 2048)
int m_iTriggerCondition;// for scripted AI, this is the condition that will cause the activation of the monster's TriggerTarget
string_t m_iszTriggerTarget;// name of target that should be fired.
Vector m_HackedGunPos; // HACK until we can query end of gun
// Scripted sequence Info
SCRIPTSTATE m_scriptState; // internal cinematic state
CCineMonster *m_pCine;
SCRIPTSTATE m_scriptState; // internal cinematic state
CCineMonster *m_pCine;
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
void KeyValue( KeyValueData *pkvd );
// monster use function
void EXPORT MonsterUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT CorpseUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT MonsterUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT CorpseUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
// overrideable Monster member functions
virtual int BloodColor( void ) { return m_bloodColor; }
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 ShouldFadeOnDeath( void );
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 void MonsterInitDead( void ); // Call after animation/pose is set up
virtual void BecomeDead( void );
void EXPORT CorpseFallThink( void );
virtual void MonsterThink( void );
void EXPORT CallMonsterThink( void ) { this->MonsterThink(); }
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
virtual void HandleAnimEvent( MonsterEvent_t *pEvent );
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
virtual void Move( float flInterval = 0.1 );
virtual void MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval );
virtual BOOL ShouldAdvanceRoute( float flWaypointDist );
virtual int CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist );// check validity of a straight move through space
virtual void Move( float flInterval = 0.1 );
virtual void MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval );
virtual BOOL ShouldAdvanceRoute( float flWaypointDist );
virtual Activity GetStoppedActivity( void ) { return ACT_IDLE; }
virtual void Stop( void ) { m_IdealActivity = GetStoppedActivity(); }
virtual Activity GetStoppedActivity( void ) { return ACT_IDLE; }
virtual void Stop( void ) { m_IdealActivity = GetStoppedActivity(); }
// This will stop animation until you call ResetSequenceInfo() at some point in the future
inline void StopAnimation( void ) { pev->framerate = 0; }
// This will stop animation until you call ResetSequenceInfo() at some point in the future
inline void StopAnimation( void ) { pev->framerate = 0; }
// these functions will survey conditions and set appropriate conditions bits for attack types.
virtual BOOL CheckRangeAttack1( float flDot, float flDist );
virtual BOOL CheckRangeAttack2( float flDot, float flDist );
virtual BOOL CheckMeleeAttack1( float flDot, float flDist );
virtual BOOL CheckMeleeAttack2( float flDot, float flDist );
// these functions will survey conditions and set appropriate conditions bits for attack types.
virtual BOOL CheckRangeAttack1( float flDot, float flDist );
virtual BOOL CheckRangeAttack2( float flDot, float flDist );
virtual BOOL CheckMeleeAttack1( float flDot, float flDist );
virtual BOOL CheckMeleeAttack2( float flDot, float flDist );
BOOL FHaveSchedule( void );
BOOL FScheduleValid ( void );
void ClearSchedule( void );
BOOL FScheduleDone ( void );
void ChangeSchedule ( Schedule_t *pNewSchedule );
void NextScheduledTask ( void );
Schedule_t *ScheduleInList( const char *pName, Schedule_t **pList, int listCount );
BOOL FHaveSchedule( void );
BOOL FScheduleValid( void );
void ClearSchedule( 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 );
virtual Schedule_t *GetScheduleOfType( int Type );
virtual Schedule_t *GetSchedule( void );
virtual void ScheduleChange( void ) {}
// virtual int CanPlaySequence( void ) { return ((m_pCine == NULL) && (m_MonsterState == MONSTERSTATE_NONE || m_MonsterState == MONSTERSTATE_IDLE || m_IdealMonsterState == MONSTERSTATE_IDLE)); }
virtual int CanPlaySequence( BOOL fDisregardState, int interruptLevel );
virtual int CanPlaySentence( BOOL fDisregardState ) { return IsAlive(); }
virtual void PlaySentence( const char *pszSentence, float duration, float volume, float attenuation );
virtual void PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, CBaseEntity *pListener );
virtual Schedule_t *ScheduleFromName( const char *pName );
static Schedule_t *m_scheduleList[];
virtual void SentenceStop( void );
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 ) {}
// virtual int CanPlaySequence( void ) { return ((m_pCine == NULL) && (m_MonsterState == MONSTERSTATE_NONE || m_MonsterState == MONSTERSTATE_IDLE || m_IdealMonsterState == MONSTERSTATE_IDLE)); }
virtual int CanPlaySequence( BOOL fDisregardState, int interruptLevel );
virtual int CanPlaySentence( BOOL fDisregardState ) { return IsAlive(); }
virtual void PlaySentence( const char *pszSentence, float duration, float volume, float attenuation );
virtual void PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, CBaseEntity *pListener );
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 );
virtual void SentenceStop( void );
void CheckAttacks ( CBaseEntity *pTarget, float flDist );
virtual int CheckEnemy ( CBaseEntity *pEnemy );
void PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos );
BOOL PopEnemy( void );
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 );
BOOL FGetNodeRoute ( Vector vecDest );
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 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); }
void CheckAttacks( CBaseEntity *pTarget, float flDist );
virtual int CheckEnemy( CBaseEntity *pEnemy );
void PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos );
BOOL PopEnemy( void );
int IScheduleFlags ( void );
BOOL FRefreshRoute( 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 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 );
int RouteClassify( int iMoveFlag );
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; };
virtual float CoverRadius( void ) { return 784; } // Default cover radius
BOOL FGetNodeRoute( Vector vecDest );
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 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 ); }
virtual BOOL FCanCheckAttacks ( void );
virtual void CheckAmmo( void ) { return; };
virtual int IgnoreConditions ( void );
inline void SetConditions( int iConditions ) { m_afConditions |= iConditions; }
inline void ClearConditions( int iConditions ) { m_afConditions &= ~iConditions; }
inline BOOL HasConditions( int iConditions ) { if ( m_afConditions & iConditions ) return TRUE; return FALSE; }
inline BOOL HasAllConditions( int iConditions ) { if ( (m_afConditions & iConditions) == iConditions ) return TRUE; return FALSE; }
int IScheduleFlags( void );
BOOL FRefreshRoute( 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 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 );
int RouteClassify( int iMoveFlag );
void InsertWaypoint( Vector vecLocation, int afMoveFlags );
virtual BOOL FValidateHintType( short sHint );
int FindHintNode ( void );
virtual BOOL FCanActiveIdle ( void );
void SetTurnActivity ( void );
float FLSoundVolume ( CSound *pSound );
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
BOOL MoveToNode( Activity movementAct, float waitTime, const Vector &goal );
BOOL MoveToTarget( Activity movementAct, float waitTime );
BOOL MoveToLocation( Activity movementAct, float waitTime, const Vector &goal );
BOOL MoveToEnemy( Activity movementAct, float waitTime );
virtual BOOL FCanCheckAttacks( void );
virtual void CheckAmmo( void ) { return; };
virtual int IgnoreConditions( void );
// Returns the time when the door will be open
float OpenDoorAndWait( entvars_t *pevDoor );
inline void SetConditions( int iConditions ) { m_afConditions |= iConditions; }
inline void ClearConditions( int iConditions ) { m_afConditions &= ~iConditions; }
inline BOOL HasConditions( int iConditions ) { if ( m_afConditions & iConditions ) return TRUE; return FALSE; }
inline BOOL HasAllConditions( int iConditions ) { if ( (m_afConditions & iConditions) == iConditions ) return TRUE; return FALSE; }
virtual int ISoundMask( void );
virtual CSound* PBestSound ( void );
virtual CSound* PBestScent ( void );
virtual float HearingSensitivity( void ) { return 1.0; };
virtual BOOL FValidateHintType( short sHint );
int FindHintNode( void );
virtual BOOL FCanActiveIdle( void );
void SetTurnActivity( void );
float FLSoundVolume( CSound *pSound );
BOOL FBecomeProne ( void );
virtual void BarnacleVictimBitten( entvars_t *pevBarnacle );
virtual void BarnacleVictimReleased( void );
BOOL MoveToNode( Activity movementAct, float waitTime, const Vector &goal );
BOOL MoveToTarget( Activity movementAct, float waitTime );
BOOL MoveToLocation( Activity movementAct, float waitTime, const Vector &goal );
BOOL MoveToEnemy( Activity movementAct, float waitTime );
void SetEyePosition ( void );
// Returns the time when the door will be open
float OpenDoorAndWait( entvars_t *pevDoor );
BOOL FShouldEat( void );// see if a monster is 'hungry'
void Eat ( float flFullDuration );// make the monster 'full' for a while.
virtual int ISoundMask( void );
virtual CSound* PBestSound( void );
virtual CSound* PBestScent( void );
virtual float HearingSensitivity( void ) { return 1.0; };
CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
BOOL FacingIdeal( void );
BOOL FBecomeProne( void );
virtual void BarnacleVictimBitten( entvars_t *pevBarnacle );
virtual void BarnacleVictimReleased( void );
BOOL FCheckAITrigger( void );// checks and, if necessary, fires the monster's trigger target.
BOOL NoFriendlyFire( void );
void SetEyePosition( void );
BOOL BBoxFlat( void );
BOOL FShouldEat( void );// see if a monster is 'hungry'
void Eat( float flFullDuration );// make the monster 'full' for a while.
// PrescheduleThink
virtual void PrescheduleThink( void ) { return; };
CBaseEntity *CheckTraceHullAttack( float flDist, int iDamage, int iDmgType );
BOOL FacingIdeal( void );
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);
BOOL FCheckAITrigger( void );// checks and, if necessary, fires the monster's trigger target.
BOOL NoFriendlyFire( void );
BOOL BBoxFlat( void );
// PrescheduleThink
virtual void PrescheduleThink( void ) { return; };
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 );
BOOL ShouldGibMonster( int iGib );
void CallGibMonster( void );
virtual BOOL HasHumanGibs( void );
virtual BOOL HasAlienGibs( void );
virtual void FadeMonster( void ); // Called instead of GibMonster() when gibs are disabled
BOOL ShouldGibMonster( int iGib );
void CallGibMonster( void );
virtual BOOL HasHumanGibs( void );
virtual BOOL HasAlienGibs( void );
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 Vector GetGunPosition( void );
virtual int TakeHealth( float flHealth, 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 );
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 );
virtual int IsMoving( void ) { return m_movementGoal != MOVEGOAL_NONE; }
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 ) {}
inline void Remember( int iMemory ) { m_afMemory |= iMemory; }
inline void Forget( int iMemory ) { m_afMemory &= ~iMemory; }
inline void Remember( int iMemory ) { m_afMemory |= iMemory; }
inline void Forget( int iMemory ) { m_afMemory &= ~iMemory; }
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.
};

488
dlls/bigmomma.cpp
View File

File diff suppressed because it is too large Load Diff

92
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,46 +53,46 @@ 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;
return CLASS_ALIEN_MONSTER;
}
//=========================================================
// 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);
break;
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,21 +180,21 @@ 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;
pev->movetype = MOVETYPE_FLY;
pev->spawnflags |= FL_FLY;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->health = 40;
pev->view_ofs = VEC_VIEW;// 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;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_FLY;
pev->spawnflags |= FL_FLY;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->health = 40;
pev->view_ofs = VEC_VIEW;// 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;
MonsterInit();
}
@ -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
//=========================================================

504
dlls/bmodels.cpp
View File

File diff suppressed because it is too large Load Diff

839
dlls/bullsquid.cpp
View File

File diff suppressed because it is too large Load Diff

790
dlls/buttons.cpp
View File

File diff suppressed because it is too large Load Diff

340
dlls/cbase.cpp
View File

@ -29,10 +29,10 @@ extern "C" void PM_Init ( struct playermove_s *ppmove );
extern "C" char PM_FindTextureType( char *name );
extern Vector VecBModelOrigin( entvars_t* pevBModel );
extern DLL_GLOBAL Vector g_vecAttackDir;
extern DLL_GLOBAL int g_iSkillLevel;
extern DLL_GLOBAL Vector g_vecAttackDir;
extern DLL_GLOBAL int g_iSkillLevel;
static DLL_FUNCTIONS gFunctionTable =
static DLL_FUNCTIONS gFunctionTable =
{
GameDLLInit, //pfnGameInit
DispatchSpawn, //pfnSpawn
@ -80,7 +80,7 @@ static DLL_FUNCTIONS gFunctionTable =
PM_Move, //pfnPM_Move
PM_Init, //pfnPM_Init Server version of player movement initialization
PM_FindTextureType, //pfnPM_FindTextureType
SetupVisibility, //pfnSetupVisibility Set up PVS and PAS for networking for this client
UpdateClientData, //pfnUpdateClientData Set up data sent only to specific client
AddToFullPack, //pfnAddToFullPack
@ -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,33 +207,33 @@ 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);
if ( pEntity && pSaveData )
{
ENTITYTABLE *pTable = &pSaveData->pTable[ pSaveData->currentIndex ];
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE( pent );
if ( pTable->pent != pent )
if( pEntity && pSaveData )
{
ENTITYTABLE *pTable = &pSaveData->pTable[pSaveData->currentIndex];
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 );
@ -320,23 +319,23 @@ int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity
// -------------------
const globalentity_t *pGlobal = gGlobalState.EntityFromTable( tmpVars.globalname );
// Don't overlay any instance of the global that isn't the latest
// 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,47 +498,47 @@ 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;
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.
g_vecAttackDir = vecTemp.Normalize();
// 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;
if (flForce > 1000.0)
float flForce = flDamage * ( ( 32 * 32 * 72.0 ) / ( pev->size.x * pev->size.y * pev->size.z ) ) * 5;
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,17 +556,17 @@ 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 );
}
// Global Savedata for Delay
TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
TYPEDESCRIPTION CBaseEntity::m_SaveData[] =
{
DEFINE_FIELD( CBaseEntity, m_pGoalEnt, FIELD_CLASSPTR ),
@ -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
float max, v;
int i;
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,19 +651,19 @@ void CBaseEntity::SetObjectCollisionBox( void )
::SetObjectCollisionBox( pev );
}
int CBaseEntity :: Intersects( CBaseEntity *pOther )
int CBaseEntity::Intersects( CBaseEntity *pOther )
{
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 ||
pOther->pev->absmax.y < pev->absmin.y ||
pOther->pev->absmax.z < pev->absmin.z )
return 0;
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 ||
pOther->pev->absmax.y < pev->absmin.y ||
pOther->pev->absmax.z < pev->absmin.z )
return 0;
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;

377
dlls/cbase.h
View File

@ -30,14 +30,14 @@ CBaseEntity
// These are caps bits to indicate what an object's capabilities (currently used for save/restore and level transitions)
#define FCAP_CUSTOMSAVE 0x00000001
#define FCAP_ACROSS_TRANSITION 0x00000002 // should transfer between transitions
#define FCAP_ACROSS_TRANSITION 0x00000002 // should transfer between transitions
#define FCAP_MUST_SPAWN 0x00000004 // Spawn after restore
#define FCAP_DONT_SAVE 0x80000000 // Don't save this
#define FCAP_IMPULSE_USE 0x00000008 // can be used by the player
#define FCAP_CONTINUOUS_USE 0x00000010 // can be used by the player
#define FCAP_ONOFF_USE 0x00000020 // can be used by the player
#define FCAP_DIRECTIONAL_USE 0x00000040 // Player sends +/- 1 when using (currently only tracktrains)
#define FCAP_MASTER 0x00000080 // Can be used to "master" other entities (like multisource)
#define FCAP_DIRECTIONAL_USE 0x00000040 // Player sends +/- 1 when using (currently only tracktrains)
#define FCAP_MASTER 0x00000080 // Can be used to "master" other entities (like multisource)
// UNDONE: This will ignore transition volumes (trigger_transition), but not the PVS!!!
#define FCAP_FORCE_TRANSITION 0x00000080 // ALWAYS goes across transitions
@ -64,37 +64,43 @@ extern void DispatchUse( edict_t *pentUsed, edict_t *pentOther );
extern void DispatchThink( edict_t *pent );
extern void DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther );
extern void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData );
extern int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
extern void DispatchObjectCollsionBox( edict_t *pent );
extern int DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity );
extern void DispatchObjectCollsionBox( edict_t *pent );
extern void SaveWriteFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
extern void SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount );
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
#define CLASS_NONE 0
#define CLASS_MACHINE 1
#define CLASS_PLAYER 2
#define CLASS_HUMAN_PASSIVE 3
#define CLASS_HUMAN_MILITARY 4
#define CLASS_ALIEN_MILITARY 5
#define CLASS_HUMAN_MILITARY 4
#define CLASS_ALIEN_MILITARY 5
#define CLASS_ALIEN_PASSIVE 6
#define CLASS_ALIEN_MONSTER 7
#define CLASS_ALIEN_PREY 8
#define CLASS_ALIEN_PREDATOR 9
#define CLASS_ALIEN_PREDATOR 9
#define CLASS_INSECT 10
#define CLASS_PLAYER_ALLY 11
#define CLASS_PLAYER_BIOWEAPON 12 // hornets and snarks.launched by players
#define CLASS_ALIEN_BIOWEAPON 13 // hornets and snarks.launched by the alien menace
#define CLASS_PLAYER_BIOWEAPON 12 // hornets and snarks.launched by players
#define CLASS_ALIEN_BIOWEAPON 13 // hornets and snarks.launched by the alien menace
#define CLASS_BARNACLE 99 // special because no one pays attention to it, and it eats a wide cross-section of creatures.
class CBaseEntity;
@ -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.
//
@ -112,7 +117,7 @@ class EHANDLE
{
private:
edict_t *m_pent;
int m_serialnumber;
int m_serialnumber;
public:
edict_t *Get( void );
edict_t *Set( edict_t *pent );
@ -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
//
@ -137,91 +141,89 @@ public:
entvars_t *pev; // Don't need to save/restore this pointer, the engine resets it
// path corners
CBaseEntity *m_pGoalEnt;// path corner we are heading towards
CBaseEntity *m_pLink;// used for temporary link-list operations.
CBaseEntity *m_pGoalEnt;// path corner we are heading towards
CBaseEntity *m_pLink;// used for temporary link-list operations.
// initialization functions
virtual void Spawn( void ) { return; }
virtual void Precache( void ) { return; }
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; }
virtual void Activate( void ) {}
virtual void Spawn( void ) { return; }
virtual void Precache( void ) { return; }
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; }
virtual void Activate( void ) {}
// Setup the object->object collision box (pev->mins / pev->maxs is the object->world collision box)
virtual void SetObjectCollisionBox( void );
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[];
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 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 int GetToggleState( void ) { return TS_AT_TOP; }
virtual void AddPoints( int score, BOOL bAllowNegativeScore ) {}
virtual void AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
virtual BOOL AddPlayerItem( CBasePlayerItem *pItem ) { return 0; }
virtual BOOL RemovePlayerItem( CBasePlayerItem *pItem ) { return 0; }
virtual int GiveAmmo( int iAmount, char *szName, int iMax ) { return -1; };
virtual float GetDelay( void ) { return 0; }
virtual int IsMoving( void ) { return pev->velocity != g_vecZero; }
virtual void OverrideReset( void ) {}
virtual int DamageDecal( int bitsDamageType );
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 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 int GetToggleState( void ) { return TS_AT_TOP; }
virtual void AddPoints( int score, BOOL bAllowNegativeScore ) {}
virtual void AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
virtual BOOL AddPlayerItem( CBasePlayerItem *pItem ) { return 0; }
virtual BOOL RemovePlayerItem( CBasePlayerItem *pItem ) { return 0; }
virtual int GiveAmmo( int iAmount, char *szName, int iMax ) { return -1; };
virtual float GetDelay( void ) { return 0; }
virtual int IsMoving( void ) { return pev->velocity != g_vecZero; }
virtual void OverrideReset( void ) {}
virtual int DamageDecal( int bitsDamageType );
// This is ONLY used by the node graph to test movement through a door
virtual void SetToggleState( int state ) {}
virtual void StartSneaking( void ) {}
virtual void StopSneaking( void ) {}
virtual BOOL OnControls( entvars_t *pev ) { return FALSE; }
virtual BOOL IsSneaking( void ) { return FALSE; }
virtual BOOL IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
virtual BOOL IsBSPModel( void ) { return pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP; }
virtual BOOL ReflectGauss( void ) { return ( IsBSPModel() && !pev->takedamage ); }
virtual BOOL HasTarget( string_t targetname ) { return FStrEq(STRING(targetname), STRING(pev->targetname) ); }
virtual BOOL IsInWorld( void );
virtual BOOL IsPlayer( void ) { return FALSE; }
virtual BOOL IsNetClient( void ) { return FALSE; }
virtual void SetToggleState( int state ) {}
virtual void StartSneaking( void ) {}
virtual void StopSneaking( void ) {}
virtual BOOL OnControls( entvars_t *pev ) { return FALSE; }
virtual BOOL IsSneaking( void ) { return FALSE; }
virtual BOOL IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
virtual BOOL IsBSPModel( void ) { return pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP; }
virtual BOOL ReflectGauss( void ) { return ( IsBSPModel() && !pev->takedamage ); }
virtual BOOL HasTarget( string_t targetname ) { return FStrEq(STRING(targetname), STRING(pev->targetname) ); }
virtual BOOL IsInWorld( void );
virtual BOOL IsPlayer( void ) { return FALSE; }
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 Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
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 )
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,26 +235,26 @@ 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 );
Vector FireBulletsPlayer( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL, int shared_rand = 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 );
Vector FireBulletsPlayer( ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL, int shared_rand = 0 );
virtual CBaseEntity *Respawn( void ) { return NULL; }
void SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value );
// Do the bounding boxes of these two intersect?
int Intersects( CBaseEntity *pOther );
void MakeDormant( void );
int IsDormant( void );
BOOL IsLockedByMaster( void ) { return FALSE; }
int Intersects( CBaseEntity *pOther );
void MakeDormant( void );
int IsDormant( void );
BOOL IsLockedByMaster( void ) { return FALSE; }
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 )
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 )
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; }
void Spawn( void );
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,34 +398,34 @@ 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
//
#define MAX_MULTI_TARGETS 16 // maximum number of targets a single multi_manager entity may be assigned.
#define MS_MAX_TARGETS 32
#define MS_MAX_TARGETS 32
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[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
EHANDLE m_rgEntities[MS_MAX_TARGETS];
int m_rgTriggered[MS_MAX_TARGETS];
EHANDLE m_rgEntities[MS_MAX_TARGETS];
int m_rgTriggered[MS_MAX_TARGETS];
int m_iTotal;
string_t m_globalstate;
int m_iTotal;
string_t m_globalstate;
};
@ -444,58 +435,54 @@ public:
class CBaseDelay : public CBaseEntity
{
public:
float m_flDelay;
int m_iszKillTarget;
float m_flDelay;
int m_iszKillTarget;
virtual void KeyValue( KeyValueData* pkvd);
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
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[];
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 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
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 );
int FindTransition( int iEndingSequence, int iGoalSequence, int *piDir );
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 );
void SetSequenceBox( void );
// animation needs
float m_flFrameRate; // computed FPS for current sequence
float m_flGroundSpeed; // computed linear movement rate for current sequence
float m_flLastEventCheck; // last time the event list was checked
BOOL m_fSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry
BOOL m_fSequenceLoops; // true if the sequence loops
float m_flFrameRate; // computed FPS for current sequence
float m_flGroundSpeed; // computed linear movement rate for current sequence
float m_flLastEventCheck; // last time the event list was checked
BOOL m_fSequenceFinished;// flag set when StudioAdvanceFrame moves across a frame boundry
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,29 +669,29 @@ 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 );
virtual int TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
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 );
enum BUTTON_CODE { BUTTON_NOTHING, BUTTON_ACTIVATE, BUTTON_RETURN };
BUTTON_CODE ButtonResponseToTouch( void );
BUTTON_CODE ButtonResponseToTouch( void );
static TYPEDESCRIPTION m_SaveData[];
// Buttons that don't take damage can be IMPULSE used
virtual int ObjectCaps( void ) { return (CBaseToggle:: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | (pev->takedamage?0:FCAP_IMPULSE_USE); }
virtual int ObjectCaps( void ) { return (CBaseToggle:: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | (pev->takedamage?0:FCAP_IMPULSE_USE); }
BOOL m_fStayPushed; // button stays pushed in until touched again?
BOOL m_fRotating; // a rotating button? default is a sliding button.
BOOL m_fStayPushed; // button stays pushed in until touched again?
BOOL m_fRotating; // a rotating button? default is a sliding button.
string_t m_strChangeTarget; // if this field is not null, this is an index into the engine string array.
// when this button is touched, it's target entity's TARGET field will be set
@ -713,17 +699,16 @@ public:
locksound_t m_ls; // door lock sounds
BYTE m_bLockedSound; // ordinals from entity selection
BYTE m_bLockedSentence;
BYTE m_bUnlockedSound;
BYTE m_bUnlockedSentence;
int m_sounds;
BYTE m_bLockedSound; // ordinals from entity selection
BYTE m_bLockedSentence;
BYTE m_bUnlockedSound;
BYTE m_bUnlockedSentence;
int m_sounds;
};
//
// 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
@ -778,13 +762,12 @@ push_trigger_data
typedef struct _SelAmmo
{
BYTE Ammo1Type;
BYTE Ammo1;
BYTE Ammo2Type;
BYTE Ammo2;
BYTE Ammo1Type;
BYTE Ammo1;
BYTE Ammo2Type;
BYTE Ammo2;
} SelAmmo;
// this moved here from world.cpp, to allow classes to be derived from it
//=======================
// CWorld

13
dlls/cdll_dll.h
View File

@ -29,11 +29,11 @@
#define HIDEHUD_WEAPONS ( 1<<0 )
#define HIDEHUD_FLASHLIGHT ( 1<<1 )
#define HIDEHUD_ALL ( 1<<2 )
#define HIDEHUD_HEALTH ( 1<<3 )
#define HIDEHUD_ALL ( 1<<2 )
#define HIDEHUD_HEALTH ( 1<<3 )
#define MAX_AMMO_TYPES 32 // ???
#define MAX_AMMO_SLOTS 32 // not really slots
#define MAX_AMMO_TYPES 32 // ???
#define MAX_AMMO_SLOTS 32 // not really slots
#define HUD_PRINTNOTIFY 1
#define HUD_PRINTCONSOLE 2
@ -41,6 +41,5 @@
#define HUD_PRINTCENTER 4
#define WEAPON_SUIT 31
#endif
#define WEAPON_SUIT 31
#endif

989
dlls/client.cpp
View File

File diff suppressed because it is too large Load Diff

23
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,31 +35,30 @@ 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 );
extern int GetWeaponData( struct edict_s *player, struct weapon_data_s *info );
extern void CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
extern void CmdEnd ( const edict_t *player );
extern void CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed );
extern void CmdEnd ( const edict_t *player );
extern int ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
extern int ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
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 InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message );
extern int AllowLagCompensation( void );
#endif // CLIENT_H
#endif // CLIENT_H

778
dlls/combat.cpp
View File

File diff suppressed because it is too large Load Diff

527
dlls/controller.cpp
View File

File diff suppressed because it is too large Load Diff

220
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,46 +53,44 @@ 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;
return CLASS_NONE;
}
void CCrossbowBolt::BoltTouch( CBaseEntity *pOther )
@ -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( );
entvars_t *pevOwner;
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 );
}
@ -216,14 +216,14 @@ void CCrossbowBolt::ExplodeThink( void )
{
WRITE_SHORT( g_sModelIndexWExplosion );
}
WRITE_BYTE( iScale ); // scale * 10
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( iScale ); // scale * 10
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
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;
}
@ -375,19 +373,19 @@ void CCrossbow::FireSniperBolt()
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
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;
}
@ -421,10 +419,10 @@ void CCrossbow::FireBolt()
Vector anglesAim = m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle;
UTIL_MakeVectors( anglesAim );
anglesAim.x = -anglesAim.x;
Vector vecSrc = m_pPlayer->GetGunPosition( ) - gpGlobals->v_up * 2;
Vector vecDir = gpGlobals->v_forward;
anglesAim.x = -anglesAim.x;
Vector vecSrc = m_pPlayer->GetGunPosition() - gpGlobals->v_up * 2;
Vector vecDir = gpGlobals->v_forward;
#ifndef CLIENT_DLL
CCrossbowBolt *pBolt = CCrossbowBolt::BoltCreate();
@ -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,68 +443,65 @@ 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;
}
pev->nextthink = UTIL_WeaponTimeBase() + 0.1;
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 )
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

152
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,41 +92,40 @@ 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;
int i, j, k;
float distance;
float *minmaxs[2] = {mins, maxs};
TraceResult tmpTrace;
TraceResult tmpTrace;
Vector vecHullEnd = tr.vecEndPos;
Vector vecEnd;
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,131 +136,130 @@ 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( );
Vector vecEnd = vecSrc + gpGlobals->v_forward * 32;
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;
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
}
}
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
#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 );
// play thwack, smack, or dong sound
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() )
return TRUE;
if( !pEntity->IsAlive() )
return TRUE;
else
flVol = 0.1;
flVol = 0.1;
fHitWorld = FALSE;
}
@ -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;
}
@ -303,14 +298,9 @@ int CCrowbar::Swing( int fFirst )
m_pPlayer->m_iWeaponVolume = flVol * CROWBAR_WALLHIT_VOLUME;
#endif
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.25;
SetThink( &CCrowbar::Smack );
pev->nextthink = UTIL_WeaponTimeBase() + 0.2;
}
return fDidHit;
}

896
dlls/defaultai.cpp
View File

File diff suppressed because it is too large Load Diff

853
dlls/doors.cpp
View File

File diff suppressed because it is too large Load Diff

7
dlls/doors.h
View File

@ -18,16 +18,13 @@
// doors
#define SF_DOOR_ROTATE_Y 0
#define SF_DOOR_START_OPEN 1
#define SF_DOOR_ROTATE_BACKWARDS 2
#define SF_DOOR_ROTATE_BACKWARDS 2
#define SF_DOOR_PASSABLE 8
#define SF_DOOR_ONEWAY 16
#define SF_DOOR_NO_AUTO_RETURN 32
#define SF_DOOR_NO_AUTO_RETURN 32
#define SF_DOOR_ROTATE_Z 64
#define SF_DOOR_ROTATE_X 128
#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

1040
dlls/effects.cpp
View File

File diff suppressed because it is too large Load Diff

234
dlls/effects.h
View File

@ -36,12 +36,12 @@ public:
void Spawn( void );
void Precache( void );
int ObjectCaps( void )
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,89 +76,201 @@ 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;
}
void EXPORT AnimateUntilDead( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
static CSprite *SpriteCreate( const char *pSpriteName, const Vector &origin, BOOL animate );
private:
float m_lastTime;
float m_maxFrame;
float m_lastTime;
float m_maxFrame;
};
class CBeam : public CBaseEntity
{
public:
void Spawn( void );
void Precache( void );
int ObjectCaps( void )
void Spawn( void );
void Precache( void );
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 BeamDamageInstant( TraceResult *ptr, float damage )
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:
@ -191,7 +310,7 @@ public:
void TurnOn( void );
void TurnOff( void );
int IsOn( void );
int IsOn( void );
void FireAtPoint( TraceResult &point );
@ -202,8 +321,7 @@ public:
static TYPEDESCRIPTION m_SaveData[];
CSprite *m_pSprite;
int m_iszSpriteName;
Vector m_firePosition;
int m_iszSpriteName;
Vector m_firePosition;
};
#endif //EFFECTS_H

192
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,19 +103,17 @@ int CEgon::AddToPlayer( CBasePlayer *pPlayer )
return FALSE;
}
void CEgon::Holster( int skiplocal /* = 0 */ )
{
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
SendWeaponAnim( EGON_HOLSTER );
EndAttack();
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;
@ -131,7 +128,7 @@ int CEgon::GetItemInfo(ItemInfo *p)
return 1;
}
#define EGON_PULSE_INTERVAL 0.1
#define EGON_PULSE_INTERVAL 0.1
#define EGON_DISCHARGE_INTERVAL 0.1
float CEgon::GetPulseInterval( void )
@ -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( );
@ -202,37 +198,35 @@ void CEgon::Attack( void )
m_flAmmoUseTime = gpGlobals->time;// start using ammo ASAP.
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), m_usEgonFire, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, m_fireState, m_fireMode, 1, 0 );
m_shakeTime = 0;
m_pPlayer->m_iWeaponVolume = EGON_PRIMARY_VOLUME;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 0.1;
pev->fuser1 = UTIL_WeaponTimeBase() + 2;
pev->fuser1 = UTIL_WeaponTimeBase() + 2;
pev->dmgtime = gpGlobals->time + GetPulseInterval();
m_fireState = FIRE_CHARGE;
break;
}
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;
}
break;
}
}
@ -240,13 +234,12 @@ void CEgon::PrimaryAttack( void )
{
m_fireMode = FIRE_WIDE;
Attack();
}
void CEgon::Fire( const Vector &vecOrigSrc, const Vector &vecDir )
{
Vector vecDest = vecOrigSrc + vecDir * 2048;
edict_t *pentIgnore;
edict_t *pentIgnore;
TraceResult tr;
pentIgnore = m_pPlayer->edict();
@ -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)
BOOL AddAmmo( CBaseEntity *pOther )
{
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

8
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;
}
@ -155,4 +157,4 @@ inline void *GET_PRIVATE( edict_t *pent )
#define PLAYER_CNX_STATS ( *g_engfuncs.pfnGetPlayerStats )
#endif //ENGINECALLBACK_H
#endif //ENGINECALLBACK_H

92
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,32 +71,32 @@ 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 );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int m_iMagnitude;// how large is the fireball? how much damage?
int m_spriteScale; // what's the exact fireball sprite scale?
};
TYPEDESCRIPTION CEnvExplosion::m_SaveData[] =
TYPEDESCRIPTION CEnvExplosion::m_SaveData[] =
{
DEFINE_FIELD( CEnvExplosion, m_iMagnitude, FIELD_INTEGER ),
DEFINE_FIELD( CEnvExplosion, m_spriteScale, FIELD_INTEGER ),
@ -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;
}
@ -153,16 +153,16 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
pev->model = iStringNull;//invisible
pev->solid = SOLID_NOT;// intangible
Vector vecSpot;// trace starts here!
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);
// 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);
@ -192,39 +192,39 @@ void CEnvExplosion::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
WRITE_COORD( pev->origin.z );
WRITE_SHORT( g_sModelIndexFireball );
WRITE_BYTE( (BYTE)m_spriteScale ); // scale * 10
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
}
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 );
WRITE_SHORT( g_sModelIndexFireball );
WRITE_BYTE( 0 ); // no sprite
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( 15 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
}
// 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 );
@ -242,11 +242,11 @@ void CEnvExplosion::Smoke( void )
WRITE_COORD( pev->origin.z );
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( (BYTE)m_spriteScale ); // scale * 10
WRITE_BYTE( 12 ); // framerate
WRITE_BYTE( 12 ); // framerate
MESSAGE_END();
}
if ( !(pev->spawnflags & SF_ENVEXPLOSION_REPEATABLE) )
if( !( pev->spawnflags & SF_ENVEXPLOSION_REPEATABLE ) )
{
UTIL_Remove( this );
}
@ -255,15 +255,15 @@ void CEnvExplosion::Smoke( void )
// HACKHACK -- create one of these and fake a keyvalue to get the right explosion setup
void ExplosionCreate( const Vector &center, const Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage )
{
KeyValueData kvd;
char buf[128];
KeyValueData kvd;
char buf[128];
CBaseEntity *pExplosion = CBaseEntity::Create( "env_explosion", center, angles, pOwner );
sprintf( buf, "%3d", magnitude );
kvd.szKeyName = "iMagnitude";
kvd.szValue = buf;
pExplosion->KeyValue( &kvd );
if ( !doDamage )
if( !doDamage )
pExplosion->pev->spawnflags |= SF_ENVEXPLOSION_NODAMAGE;
pExplosion->Spawn();

7
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
@ -23,10 +22,8 @@
#define SF_ENVEXPLOSION_NODECAL ( 1 << 4 ) // don't make a scorch mark
#define SF_ENVEXPLOSION_NOSPARKS ( 1 << 5 ) // don't make a scorch mark
extern DLL_GLOBAL short g_sModelIndexFireball;
extern DLL_GLOBAL short g_sModelIndexSmoke;
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

10
dlls/exportdef.h
View File

@ -7,11 +7,11 @@
#define EXPORT __declspec(dllexport) // Note: actually gcc seems to also supports this syntax.
#endif
#else
#if __GNUC__ >= 4
#define EXPORT __attribute__ ((visibility ("default")))
#else
#define EXPORT
#endif
#if __GNUC__ >= 4
#define EXPORT __attribute__ ((visibility ("default")))
#else
#define EXPORT
#endif
#endif
#define DLLEXPORT EXPORT
#define _DLLEXPORT EXPORT

102
dlls/flyingmonster.cpp
View File

@ -23,14 +23,14 @@
#define FLYING_AE_FLAP (8)
#define FLYING_AE_FLAPSOUND (9)
extern DLL_GLOBAL edict_t *g_pBodyQueueHead;
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 );

475
dlls/func_break.cpp
View File

File diff suppressed because it is too large Load Diff

54
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,23 +49,23 @@ 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 );
BOOL IsBreakable( void );
BOOL SparkWhenHit( void );
int DamageDecal( int bitsDamageType );
int DamageDecal( int bitsDamageType );
void EXPORT Die( void );
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
void EXPORT Die( void );
virtual int ObjectCaps( void ) { return ( CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION ); }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
inline BOOL Explodable( void ) { return ExplosionMagnitude() > 0; }
inline int ExplosionMagnitude( void ) { return pev->impulse; }
inline void ExplosionSetMagnitude( int magnitude ) { pev->impulse = magnitude; }
inline BOOL Explodable( void ) { return ExplosionMagnitude() > 0; }
inline int ExplosionMagnitude( void ) { return pev->impulse; }
inline void ExplosionSetMagnitude( int magnitude ) { pev->impulse = magnitude; }
static void MaterialSoundPrecache( Materials precacheMaterial );
static void MaterialSoundRandom( edict_t *pEdict, Materials soundMaterial, float volume );
@ -61,14 +78,13 @@ public:
static const char *pSoundsConcrete[];
static const char *pSpawnObjects[];
static TYPEDESCRIPTION m_SaveData[];
static TYPEDESCRIPTION m_SaveData[];
Materials m_Material;
Explosions m_Explosion;
int m_idShard;
float m_angle;
int m_iszGibModel;
int m_iszSpawnObject;
Materials m_Material;
Explosions m_Explosion;
int m_idShard;
float m_angle;
int m_iszGibModel;
int m_iszSpawnObject;
};
#endif // FUNC_BREAK_H

433
dlls/func_tank.cpp
View File

@ -46,12 +46,12 @@ enum TANKBULLET
class CFuncTank : public CBaseEntity
{
public:
void Spawn( void );
void Precache( void );
void KeyValue( KeyValueData *pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void Think( void );
void TrackTarget( void );
void Spawn( void );
void Precache( void );
void KeyValue( KeyValueData *pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void Think( void );
void TrackTarget( void );
virtual void Fire( const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker );
virtual Vector UpdateTargetPosition( CBaseEntity *pTarget )
@ -59,17 +59,17 @@ public:
return pTarget->BodyTarget( pev->origin );
}
void StartRotSound( void );
void StopRotSound( void );
void StartRotSound( void );
void StopRotSound( void );
// Bmodels don't go across transitions
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
inline BOOL IsActive( void ) { return (pev->spawnflags & SF_TANK_ACTIVE)?TRUE:FALSE; }
inline void TankActivate( void ) { pev->spawnflags |= SF_TANK_ACTIVE; pev->nextthink = pev->ltime + 0.1; m_fireLast = 0; }
inline void TankDeactivate( void ) { pev->spawnflags &= ~SF_TANK_ACTIVE; m_fireLast = 0; StopRotSound(); }
inline BOOL CanFire( void ) { return (gpGlobals->time - m_lastSightTime) < m_persist; }
BOOL InRange( float range );
BOOL InRange( float range );
// Acquire a target. pPlayer is a player in the PVS
edict_t *FindTarget( edict_t *pPlayer );
@ -129,7 +129,7 @@ protected:
int m_iszMaster; // Master entity (game_team_master or multisource)
};
TYPEDESCRIPTION CFuncTank::m_SaveData[] =
TYPEDESCRIPTION CFuncTank::m_SaveData[] =
{
DEFINE_FIELD( CFuncTank, m_yawCenter, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_yawRate, FIELD_FLOAT ),
@ -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) );
pev->movetype = MOVETYPE_PUSH; // so it doesn't get pushed by anything
pev->solid = SOLID_BSP;
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,57 +323,56 @@ 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->pev->viewmodel = 0;
}
m_pController->m_iHideHUD |= HIDEHUD_WEAPONS;
m_vecControllerUsePos = m_pController->pev->origin;
pev->nextthink = pev->ltime + 0.1;
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();
if ( !InRange( range ) )
float range = ( targetPosition - barrelEnd ).Length();
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,32 +667,33 @@ 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;
Vector vecEnd;
vecEnd = vecStart + vecDir * 4096;
UTIL_TraceLine( vecStart, vecEnd, dont_ignore_monsters, edict(), &tr );
}
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;
@ -748,24 +745,24 @@ void CFuncTankGun::Fire( const Vector &barrelEnd, const Vector &forward, entvars
class CFuncTankLaser : public CFuncTank
{
public:
void Activate( void );
void KeyValue( KeyValueData *pkvd );
void Fire( const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker );
void Think( void );
void Activate( void );
void KeyValue( KeyValueData *pkvd );
void Fire( const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker );
void Think( void );
CLaser *GetLaser( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
private:
CLaser *m_pLaser;
float m_laserTime;
CLaser *m_pLaser;
float m_laserTime;
};
LINK_ENTITY_TO_CLASS( func_tanklaser, CFuncTankLaser )
TYPEDESCRIPTION CFuncTankLaser::m_SaveData[] =
TYPEDESCRIPTION CFuncTankLaser::m_SaveData[] =
{
DEFINE_FIELD( CFuncTankLaser, m_pLaser, FIELD_CLASSPTR ),
DEFINE_FIELD( CFuncTankLaser, m_laserTime, FIELD_TIME ),
@ -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,19 +830,19 @@ 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 );
m_laserTime = gpGlobals->time;
m_pLaser->TurnOn();
m_pLaser->pev->dmgtime = gpGlobals->time - 1.0;
@ -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 );
@ -946,13 +943,13 @@ void CFuncTankMortar::Fire( const Vector &barrelEnd, const Vector &forward, entv
class CFuncTankControls : public CBaseEntity
{
public:
virtual int ObjectCaps( void );
virtual int ObjectCaps( void );
void Spawn( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void Think( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
CFuncTank *m_pTank;
@ -960,43 +957,43 @@ public:
LINK_ENTITY_TO_CLASS( func_tankcontrols, CFuncTankControls )
TYPEDESCRIPTION CFuncTankControls::m_SaveData[] =
TYPEDESCRIPTION CFuncTankControls::m_SaveData[] =
{
DEFINE_FIELD( CFuncTankControls, m_pTank, FIELD_CLASSPTR ),
};
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
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,11 +1001,11 @@ 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 );
pev->nextthink = gpGlobals->time + 0.3; // After all the func_tank's have spawned
CBaseEntity::Spawn();

639
dlls/game.cpp
View File

@ -17,34 +17,34 @@
#include "util.h"
#include "game.h"
cvar_t displaysoundlist = {"displaysoundlist","0"};
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 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 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 mp_chattime = {"mp_chattime","10", FCVAR_SERVER };
cvar_t mp_chattime = { "mp_chattime","10", FCVAR_SERVER };
// Engine Cvars
cvar_t *g_psv_gravity = NULL;
cvar_t *g_psv_aim = NULL;
cvar_t *g_footsteps = NULL;
cvar_t *g_psv_gravity = NULL;
cvar_t *g_psv_aim = NULL;
cvar_t *g_footsteps = NULL;
//CVARS FOR SKILL LEVEL SETTINGS
// Agrunt
@ -57,14 +57,14 @@ cvar_t sk_agrunt_dmg_punch2 = {"sk_agrunt_dmg_punch2","0"};
cvar_t sk_agrunt_dmg_punch3 = {"sk_agrunt_dmg_punch3","0"};
// Apache
cvar_t sk_apache_health1 = {"sk_apache_health1","0"};
cvar_t sk_apache_health2 = {"sk_apache_health2","0"};
cvar_t sk_apache_health3 = {"sk_apache_health3","0"};
cvar_t sk_apache_health1 = {"sk_apache_health1","0"};
cvar_t sk_apache_health2 = {"sk_apache_health2","0"};
cvar_t sk_apache_health3 = {"sk_apache_health3","0"};
// Barney
cvar_t sk_barney_health1 = {"sk_barney_health1","0"};
cvar_t sk_barney_health2 = {"sk_barney_health2","0"};
cvar_t sk_barney_health3 = {"sk_barney_health3","0"};
cvar_t sk_barney_health1 = {"sk_barney_health1","0"};
cvar_t sk_barney_health2 = {"sk_barney_health2","0"};
cvar_t sk_barney_health3 = {"sk_barney_health3","0"};
// Bullsquid
cvar_t sk_bullsquid_health1 = {"sk_bullsquid_health1","0"};
@ -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
@ -430,13 +423,13 @@ cvar_t sk_player_head1 = { "sk_player_head1","2" };
cvar_t sk_player_head2 = { "sk_player_head2","2" };
cvar_t sk_player_head3 = { "sk_player_head3","2" };
cvar_t sk_player_chest1 = { "sk_player_chest1","1" };
cvar_t sk_player_chest2 = { "sk_player_chest2","1" };
cvar_t sk_player_chest3 = { "sk_player_chest3","1" };
cvar_t sk_player_chest1 = { "sk_player_chest1","1" };
cvar_t sk_player_chest2 = { "sk_player_chest2","1" };
cvar_t sk_player_chest3 = { "sk_player_chest3","1" };
cvar_t sk_player_stomach1 = { "sk_player_stomach1","1" };
cvar_t sk_player_stomach2 = { "sk_player_stomach2","1" };
cvar_t sk_player_stomach3 = { "sk_player_stomach3","1" };
cvar_t sk_player_stomach1 = { "sk_player_stomach1","1" };
cvar_t sk_player_stomach2 = { "sk_player_stomach2","1" };
cvar_t sk_player_stomach3 = { "sk_player_stomach3","1" };
cvar_t sk_player_arm1 = { "sk_player_arm1","1" };
cvar_t sk_player_arm2 = { "sk_player_arm2","1" };
@ -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_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_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"};
// 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_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" );

40
dlls/game.h
View File

@ -18,28 +18,26 @@
extern void GameDLLInit( void );
extern cvar_t displaysoundlist;
extern cvar_t displaysoundlist;
// multiplayer server rules
extern cvar_t teamplay;
extern cvar_t fraglimit;
extern cvar_t timelimit;
extern cvar_t friendlyfire;
extern cvar_t falldamage;
extern cvar_t weaponstay;
extern cvar_t forcerespawn;
extern cvar_t flashlight;
extern cvar_t aimcrosshair;
extern cvar_t decalfrequency;
extern cvar_t teamlist;
extern cvar_t teamoverride;
extern cvar_t defaultteam;
extern cvar_t allowmonsters;
extern cvar_t teamplay;
extern cvar_t fraglimit;
extern cvar_t timelimit;
extern cvar_t friendlyfire;
extern cvar_t falldamage;
extern cvar_t weaponstay;
extern cvar_t forcerespawn;
extern cvar_t flashlight;
extern cvar_t aimcrosshair;
extern cvar_t decalfrequency;
extern cvar_t teamlist;
extern cvar_t teamoverride;
extern cvar_t defaultteam;
extern cvar_t allowmonsters;
// Engine Cvars
extern cvar_t *g_psv_gravity;
extern cvar_t *g_psv_aim;
extern cvar_t *g_footsteps;
#endif // GAME_H
extern cvar_t *g_psv_gravity;
extern cvar_t *g_psv_aim;
extern cvar_t *g_footsteps;
#endif // GAME_H

181
dlls/gamerules.cpp
View File

@ -28,8 +28,8 @@
extern edict_t *EntSelectSpawnPoint( CBaseEntity *pPlayer );
DLL_GLOBAL CGameRules* g_pGameRules = NULL;
extern DLL_GLOBAL BOOL g_fGameOver;
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,17 +60,17 @@ 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;
return pentSpawnSpot;
}
@ -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;
}
@ -112,33 +112,33 @@ BOOL CGameRules::CanHavePlayerItem( CBasePlayer *pPlayer, CBasePlayerItem *pWeap
//=========================================================
void CGameRules::RefreshSkillData ( void )
{
int iSkill;
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");
// Sentry Turret
gSkillData.sentryHealth = GetSkillCvar( "sk_sentry_health");
gSkillData.miniturretHealth = GetSkillCvar( "sk_miniturret_health" );
// PLAYER WEAPONS
// Sentry Turret
gSkillData.sentryHealth = GetSkillCvar( "sk_sentry_health" );
// 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 )
}
}
}

18
dlls/gamerules.h
View File

@ -27,13 +27,13 @@ class CBasePlayerAmmo;
enum
{
GR_NONE = 0,
GR_WEAPON_RESPAWN_YES,
GR_WEAPON_RESPAWN_NO,
GR_AMMO_RESPAWN_YES,
GR_AMMO_RESPAWN_NO,
GR_ITEM_RESPAWN_YES,
GR_ITEM_RESPAWN_NO,
@ -75,14 +75,14 @@ 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
// Client damage rules
virtual float FlPlayerFallDamage( CBasePlayer *pPlayer ) = 0;// this client just hit the ground after a fall. How much damage?
virtual BOOL FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker ) {return TRUE;};// can this player take damage from this attacker?
virtual BOOL FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker ) {return TRUE;};// can this player take damage from this attacker?
virtual BOOL ShouldAutoAim( CBasePlayer *pPlayer, edict_t *target ) { return TRUE; }
// Client spawn/respawn control
@ -179,7 +179,7 @@ public:
virtual BOOL FShouldSwitchWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pWeapon );
virtual BOOL GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon );
// Functions to verify the single/multiplayer status of a game
virtual BOOL IsMultiplayer( void );
virtual BOOL IsDeathmatch( void );
@ -192,7 +192,7 @@ public:
// Client damage rules
virtual float FlPlayerFallDamage( CBasePlayer *pPlayer );
// Client spawn/respawn control
virtual void PlayerSpawn( CBasePlayer *pPlayer );
virtual void PlayerThink( CBasePlayer *pPlayer );
@ -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;

490
dlls/gargantua.cpp
View File

File diff suppressed because it is too large Load Diff

237
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,18 +74,18 @@ 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" );
m_iBeam = PRECACHE_MODEL( "sprites/smoke.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" );
@ -131,9 +132,9 @@ BOOL CGauss::Deploy( )
void CGauss::Holster( int skiplocal /* = 0 */ )
{
PLAYBACK_EVENT_FULL( FEV_RELIABLE | FEV_GLOBAL, 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 );
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
SendWeaponAnim( GAUSS_HOLSTER );
m_fInAttack = 0;
}
@ -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;
}
@ -202,7 +203,7 @@ void CGauss::SecondaryAttack()
// spin up
m_pPlayer->m_iWeaponVolume = GAUSS_PRIMARY_CHARGE_VOLUME;
SendWeaponAnim( GAUSS_SPINUP );
m_fInAttack = 1;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 0.5;
@ -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();
@ -251,20 +252,20 @@ void CGauss::SecondaryAttack()
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 1;
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 );
@ -272,24 +273,23 @@ void CGauss::SecondaryAttack()
m_iSoundState = SND_CHANGE_PITCH; // hack for going through level transitions
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 );
// Player may have been killed and this weapon dropped, don't execute any more code after this!
return;
}
@ -305,21 +305,21 @@ void CGauss::SecondaryAttack()
void CGauss::StartFire( void )
{
float flDamage;
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;
if ( gpGlobals->time - m_pPlayer->m_flStartCharge > GetFullChargeTime() )
Vector vecSrc = m_pPlayer->GetGunPosition(); // + gpGlobals->v_up * -8 + gpGlobals->v_right * 8;
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;
@ -362,18 +362,18 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
Vector vecSrc = vecOrigSrc;
Vector vecDest = vecSrc + vecDir * 8192;
edict_t *pentIgnore;
edict_t *pentIgnore;
TraceResult tr, beam_tr;
float flMaxFrac = 1.0;
int nTotal = 0;
int nTotal = 0;
int fHasPunched = 0;
int fFirstBeam = 1;
int nMaxHits = 10;
int nMaxHits = 10;
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,50 +392,50 @@ 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;
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
Vector r;
r = 2.0 * tr.vecPlaneNormal * n + vecDir;
flMaxFrac = flMaxFrac - tr.flFraction;
vecDir = r;
@ -447,34 +446,35 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
m_pPlayer->RadiusDamage( tr.vecEndPos, pev, m_pPlayer->pev, flDamage * n, CLASS_NONE, DMG_BLAST );
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 );
@ -483,9 +483,8 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
// exit blast damage
//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;
@ -512,7 +511,7 @@ void CGauss::Fire( Vector vecOrigSrc, Vector vecDir, float flDamage )
else
{
//ALERT( at_console, "blocked solid\n" );
flDamage = 0;
}
@ -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;

56
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,20 +45,20 @@ 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;
return CLASS_PLAYER_ALLY;
}
//=========================================================
// 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,42 +86,40 @@ void CGenericMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// ISoundMask - generic monster can't hear.
//=========================================================
int CGenericMonster :: ISoundMask ( void )
int CGenericMonster::ISoundMask( void )
{
return NULL;
return NULL;
}
//=========================================================
// 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;
m_bloodColor = BLOOD_COLOR_RED;
pev->health = 8;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_RED;
pev->health = 8;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
MonsterInit();
if ( pev->spawnflags & SF_GENERICMONSTER_NOTSOLID )
if( pev->spawnflags & SF_GENERICMONSTER_NOTSOLID )
{
pev->solid = SOLID_NOT;
pev->takedamage = DAMAGE_NO;
@ -131,10 +129,10 @@ 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 ) );
}
//=========================================================
// AI Schedules Specific to this monster

203
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 );
}
@ -50,7 +49,7 @@ void CGrenade::Explode( Vector vecSrc, Vector vecAim )
// UNDONE: temporary scorching for PreAlpha - find a less sleazy permenant solution.
void CGrenade::Explode( TraceResult *pTrace, int bitsDamageType )
{
float flRndSound;// sound randomizer
float flRndSound;// sound randomizer
pev->model = iStringNull;//invisible
pev->solid = SOLID_NOT;// intangible
@ -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( 15 ); // framerate
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.
@ -169,10 +174,10 @@ void CGrenade::PreDetonate( void )
void CGrenade::Detonate( void )
{
TraceResult tr;
Vector vecSpot;// trace starts here!
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 );
}
@ -184,28 +189,28 @@ void CGrenade::Detonate( void )
void CGrenade::ExplodeTouch( CBaseEntity *pOther )
{
TraceResult tr;
Vector vecSpot;// trace starts here!
Vector vecSpot;// trace starts here!
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,19 +245,19 @@ 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() );
// grenade is moving really slow. It's probably very close to where it will ultimately stop moving.
// 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,16 +364,16 @@ 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,17 +382,17 @@ 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
// Take one second off of the desired detonation time and set the think to PreDetonate. PreDetonate
// will insert a DANGER sound into the world sound list and delay detonation for one second so that
// the grenade explodes after the exact amount of time specified in the call to ShootTimed().
@ -391,12 +400,12 @@ 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 );
}
pGrenade->pev->sequence = RANDOM_LONG( 3, 6 );
pGrenade->pev->framerate = 1.0;
@ -406,30 +415,30 @@ 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;
pGrenade->pev->classname = MAKE_STRING( "grenade" );
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 );
pGrenade->SetUse( &CGrenade::DetonateUse );
@ -441,29 +450,29 @@ 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 );
CBaseEntity *pOwner = CBaseEntity::Instance( pevOwner );
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
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;

93
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)
BOOL AddAmmo( CBaseEntity *pOther )
{
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 )

72
dlls/gman.cpp
View File

@ -32,17 +32,17 @@ 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 Save( CSave &save );
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
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 );
@ -54,7 +54,7 @@ public:
LINK_ENTITY_TO_CLASS( monster_gman, CGMan )
TYPEDESCRIPTION CGMan::m_SaveData[] =
TYPEDESCRIPTION CGMan::m_SaveData[] =
{
DEFINE_FIELD( CGMan, m_hTalkTarget, FIELD_EHANDLE ),
DEFINE_FIELD( CGMan, m_flTalkTime, FIELD_TIME ),
@ -66,20 +66,20 @@ 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;
return CLASS_NONE;
}
//=========================================================
// 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,25 +107,25 @@ void CGMan :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// ISoundMask - generic monster can't hear.
//=========================================================
int CGMan :: ISoundMask ( void )
int CGMan::ISoundMask( void )
{
return NULL;
return NULL;
}
//=========================================================
// 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->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = DONT_BLEED;
pev->health = 100;
pev->health = 100;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
@ -135,21 +135,21 @@ void CGMan :: Spawn()
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CGMan :: Precache()
void CGMan::Precache()
{
PRECACHE_MODEL( "models/gman.mdl" );
}
}
//=========================================================
// 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;
}

90
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);
if (tr.flFraction == 1.0)
UTIL_TraceLine( vecLookerOrigin, vecTarget, ignore_monsters, ignore_glass, ENT( pevLooker )/*pentIgnore*/, &tr );
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,52 +85,52 @@ 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
// 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,55 +138,54 @@ 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;
}
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;
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;
}

102
dlls/h_battery.cpp
View File

@ -30,31 +30,31 @@
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 Save( CSave &save );
virtual int Restore( CRestore &restore );
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[];
static TYPEDESCRIPTION m_SaveData[];
float m_flNextCharge;
int m_iReactivate ; // DeathMatch Delay until reactvated
int m_iJuice;
int m_iOn; // 0 = off, 1 = startup, 2 = going
float m_flSoundTime;
int m_iReactivate; // DeathMatch Delay until reactvated
int m_iJuice;
int m_iOn; // 0 = off, 1 = startup, 2 = going
float m_flSoundTime;
};
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;
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;
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 );

205
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 );
@ -45,14 +45,14 @@ public:
// Don't treat as a live target
virtual BOOL IsAlive( void ) { return FALSE; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int m_animate;
int m_animate;
};
TYPEDESCRIPTION CCycler::m_SaveData[] =
TYPEDESCRIPTION CCycler::m_SaveData[] =
{
DEFINE_FIELD( CCycler, m_animate, FIELD_INTEGER ),
};
@ -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,52 +85,51 @@ 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;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE;
pev->takedamage = DAMAGE_YES;
pev->effects = 0;
pev->health = 80000;// no cycler should die
pev->health = 80000;// no cycler should die
pev->yaw_speed = 5;
pev->ideal_yaw = pev->angles.y;
ChangeYaw( 360 );
m_flFrameRate = 75;
m_flGroundSpeed = 0;
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,23 +214,27 @@ 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 );
void Animate( float frames );
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[];
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; }
int m_animate;
float m_lastTime;
float m_maxFrame;
inline int ShouldAnimate( void )
{
return m_animate && m_maxFrame > 1.0;
}
int m_animate;
float m_lastTime;
float m_maxFrame;
};
LINK_ENTITY_TO_CLASS( cycler_sprite, CCyclerSprite )
TYPEDESCRIPTION CCyclerSprite::m_SaveData[] =
TYPEDESCRIPTION CCyclerSprite::m_SaveData[] =
{
DEFINE_FIELD( CCyclerSprite, m_animate, FIELD_INTEGER ),
DEFINE_FIELD( CCyclerSprite, m_lastTime, FIELD_TIME ),
@ -239,40 +245,40 @@ IMPLEMENT_SAVERESTORE( CCyclerSprite, CBaseEntity )
void CCyclerSprite::Spawn( void )
{
pev->solid = SOLID_SLIDEBOX;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_NONE;
pev->takedamage = DAMAGE_YES;
pev->effects = 0;
pev->frame = 0;
pev->frame = 0;
pev->nextthink = gpGlobals->time + 0.1;
m_animate = 1;
m_lastTime = gpGlobals->time;
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;
pev->nextthink = gpGlobals->time + 0.1;
m_lastTime = gpGlobals->time;
}
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;
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;
}
@ -364,9 +369,9 @@ void CWeaponCycler::SecondaryAttack( void )
// Flaming Wreakage
class CWreckage : public CBaseMonster
{
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
void Spawn( void );
void Precache( void );
@ -375,7 +380,7 @@ class CWreckage : public CBaseMonster
int m_flStartTime;
};
TYPEDESCRIPTION CWreckage::m_SaveData[] =
TYPEDESCRIPTION CWreckage::m_SaveData[] =
{
DEFINE_FIELD( CWreckage, m_flStartTime, FIELD_TIME ),
};
@ -386,50 +391,50 @@ LINK_ENTITY_TO_CLASS( cycler_wreckage, CWreckage )
void CWreckage::Spawn( void )
{
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
pev->takedamage = 0;
pev->effects = 0;
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
pev->takedamage = 0;
pev->effects = 0;
pev->frame = 0;
pev->nextthink = gpGlobals->time + 0.1;
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;
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;
}
}
Vector VecSrc;
VecSrc.x = RANDOM_FLOAT( pev->absmin.x, pev->absmax.x );
VecSrc.y = RANDOM_FLOAT( pev->absmin.y, pev->absmax.y );
VecSrc.z = RANDOM_FLOAT( pev->absmin.z, pev->absmax.z );
@ -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();
}

23
dlls/h_export.cpp
View File

@ -27,23 +27,20 @@
// Holds engine functionality callbacks
enginefuncs_t g_engfuncs;
globalvars_t *gpGlobals;
globalvars_t *gpGlobals;
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)
{
}
else if (fdwReason == DLL_PROCESS_DETACH)
{
}
if( fdwReason == DLL_PROCESS_ATTACH )
{
}
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;
}

59
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,16 +204,16 @@ 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.
}
else
else
{
iAnim = HANDGRENADE_FIDGET;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 75.0 / 30.0;

534
dlls/hassassin.cpp
View File

File diff suppressed because it is too large Load Diff

223
dlls/headcrab.cpp
View File

@ -28,42 +28,42 @@
//=========================================================
#define HC_AE_JUMPATTACK ( 2 )
Task_t tlHCRangeAttack1[] =
Task_t tlHCRangeAttack1[] =
{
{ TASK_STOP_MOVING, (float)0 },
{ TASK_FACE_IDEAL, (float)0 },
{ TASK_RANGE_ATTACK1, (float)0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_FACE_IDEAL, (float)0 },
{ TASK_WAIT_RANDOM, (float)0.5 },
{ TASK_STOP_MOVING, (float)0 },
{ TASK_FACE_IDEAL, (float)0 },
{ TASK_RANGE_ATTACK1, (float)0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_FACE_IDEAL, (float)0 },
{ TASK_WAIT_RANDOM, (float)0.5 },
};
Schedule_t slHCRangeAttack1[] =
Schedule_t slHCRangeAttack1[] =
{
{
{
tlHCRangeAttack1,
ARRAYSIZE ( tlHCRangeAttack1 ),
bits_COND_ENEMY_OCCLUDED |
ARRAYSIZE( tlHCRangeAttack1 ),
bits_COND_ENEMY_OCCLUDED |
bits_COND_NO_AMMO_LOADED,
0,
"HCRangeAttack1"
},
};
Task_t tlHCRangeAttack1Fast[] =
Task_t tlHCRangeAttack1Fast[] =
{
{ TASK_STOP_MOVING, (float)0 },
{ TASK_FACE_IDEAL, (float)0 },
{ TASK_RANGE_ATTACK1, (float)0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
{ TASK_STOP_MOVING, (float)0 },
{ TASK_FACE_IDEAL, (float)0 },
{ TASK_RANGE_ATTACK1, (float)0 },
{ TASK_SET_ACTIVITY, (float)ACT_IDLE },
};
Schedule_t slHCRangeAttack1Fast[] =
Schedule_t slHCRangeAttack1Fast[] =
{
{
{
tlHCRangeAttack1Fast,
ARRAYSIZE ( tlHCRangeAttack1Fast ),
bits_COND_ENEMY_OCCLUDED |
ARRAYSIZE( tlHCRangeAttack1Fast ),
bits_COND_ENEMY_OCCLUDED |
bits_COND_NO_AMMO_LOADED,
0,
"HCRAFast"
@ -136,20 +136,20 @@ const char *CHeadCrab::pPainSounds[] =
"headcrab/hc_pain3.wav",
};
const char *CHeadCrab::pAttackSounds[] =
const char *CHeadCrab::pAttackSounds[] =
{
"headcrab/hc_attack1.wav",
"headcrab/hc_attack2.wav",
"headcrab/hc_attack3.wav",
};
const char *CHeadCrab::pDeathSounds[] =
const char *CHeadCrab::pDeathSounds[] =
{
"headcrab/hc_die1.wav",
"headcrab/hc_die2.wav",
};
const char *CHeadCrab::pBiteSounds[] =
const char *CHeadCrab::pBiteSounds[] =
{
"headcrab/hc_headbite.wav",
};
@ -158,9 +158,9 @@ 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;
return CLASS_ALIEN_PREY;
}
//=========================================================
@ -168,38 +168,38 @@ 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:
case ACT_IDLE:
ys = 30;
break;
case ACT_RUN:
case ACT_WALK:
case ACT_RUN:
case ACT_WALK:
ys = 20;
break;
case ACT_TURN_LEFT:
case ACT_TURN_RIGHT:
ys = 60;
break;
case ACT_RANGE_ATTACK1:
case ACT_RANGE_ATTACK1:
ys = 30;
break;
default:
@ -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
@ -248,8 +248,8 @@ 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->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->health = gSkillData.headcrabHealth;
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,23 +341,23 @@ 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
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;

134
dlls/healthkit.cpp
View File

@ -31,10 +31,9 @@ class CHealthKit : public CItem
void Precache( void );
BOOL MyTouch( CBasePlayer *pPlayer );
/*
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
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,51 +98,51 @@ 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 Save( CSave &save );
virtual int Restore( CRestore &restore );
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[];
static TYPEDESCRIPTION m_SaveData[];
float m_flNextCharge;
int m_iReactivate ; // DeathMatch Delay until reactvated
int m_iJuice;
int m_iOn; // 0 = off, 1 = startup, 2 = going
float m_flSoundTime;
int m_iReactivate ; // DeathMatch Delay until reactvated
int m_iJuice;
int m_iOn; // 0 = off, 1 = startup, 2 = going
float m_flSoundTime;
};
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;
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 );

1345
dlls/hgrunt.cpp
View File

File diff suppressed because it is too large Load Diff

170
dlls/hornet.cpp
View File

@ -45,28 +45,28 @@ 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();
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
pev->movetype = MOVETYPE_FLY;
pev->solid = SOLID_BBOX;
pev->takedamage = DAMAGE_YES;
pev->flags |= FL_MONSTER;
pev->health = 1;// weak!
if ( g_pGameRules->IsMultiplayer() )
pev->flags |= FL_MONSTER;
pev->health = 1;// weak!
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;
}
@ -108,14 +108,14 @@ void CHornet :: Spawn( void )
// no real owner, or owner isn't a client.
pev->dmg = gSkillData.monDmgHornet;
}
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();
@ -207,21 +206,21 @@ old colors
WRITE_BYTE( 0 ); // r, g, b
break;
case HORNET_TYPE_ORANGE:
WRITE_BYTE( 0 ); // r, g, b
WRITE_BYTE( 0 ); // r, g, b
WRITE_BYTE( 100 ); // r, g, b
WRITE_BYTE( 255 ); // r, g, b
break;
*/
// trail
MESSAGE_BEGIN( MSG_BROADCAST, SVC_TEMPENTITY );
WRITE_BYTE( TE_BEAMFOLLOW );
WRITE_BYTE( TE_BEAMFOLLOW );
WRITE_SHORT( entindex() ); // entity
WRITE_SHORT( iHornetTrail ); // model
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 );
if ( flDelta < 0.5 )
flDelta = DotProduct( vecFlightDir, vecDirToEnemy );
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,19 +405,25 @@ 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 );
}

29
dlls/hornet.h
View File

@ -35,24 +35,23 @@ class CHornet : public CBaseMonster
public:
void Spawn( void );
void Precache( void );
int Classify ( void );
int IRelationship ( CBaseEntity *pTarget );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
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 );
float m_flStopAttack;
int m_iHornetType;
float m_flFlySpeed;
float m_flStopAttack;
int m_iHornetType;
float m_flFlySpeed;
};

64
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;
@ -237,7 +237,7 @@ void CHgun::SecondaryAttack( void )
m_pPlayer->m_iWeaponVolume = NORMAL_GUN_VOLUME;
m_pPlayer->m_iWeaponFlash = DIM_GUN_FLASH;
// player "shoot" animation
// player "shoot" animation
m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
m_flNextPrimaryAttack = m_flNextSecondaryAttack = UTIL_WeaponTimeBase() + 0.1;
@ -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;

501
dlls/houndeye.cpp
View File

File diff suppressed because it is too large Load Diff

381
dlls/ichthyosaur.cpp
View File

@ -50,14 +50,14 @@ extern CGraph WorldGraph;
class CIchthyosaur : public CFlyingMonster
{
public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int Classify( void );
void HandleAnimEvent( MonsterEvent_t *pEvent );
CUSTOM_SCHEDULES
int Save( CSave &save );
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
@ -70,23 +70,23 @@ public:
void EXPORT CombatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT BiteTouch( CBaseEntity *pOther );
void StartTask( Task_t *pTask );
void RunTask( Task_t *pTask );
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 );
void Move( float flInterval );
void MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval );
void MonsterThink( void );
void Stop( void );
void Swim( void );
Vector DoProbe(const Vector &Probe);
void Move( float flInterval );
void MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval );
void MonsterThink( void );
void Stop( void );
void Swim( void );
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 );
}
@ -213,7 +213,7 @@ void CIchthyosaur :: PainSound( void )
//=========================================================
// monster-specific tasks and states
//=========================================================
enum
enum
{
TASK_ICHTHYOSAUR_CIRCLE_ENEMY = LAST_COMMON_TASK + 1,
TASK_ICHTHYOSAUR_SWIM,
@ -306,7 +306,7 @@ Schedule_t slTwitchDie[] =
DEFINE_CUSTOM_SCHEDULES( CIchthyosaur )
{
slSwimAround,
slSwimAround,
slSwimAgitated,
slCircleEnemy,
slTwitchDie,
@ -318,17 +318,17 @@ 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;
return CLASS_ALIEN_MONSTER;
}
//=========================================================
// 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->solid = SOLID_BBOX;
pev->movetype = MOVETYPE_FLY;
m_bloodColor = BLOOD_COLOR_GREEN;
pev->health = gSkillData.ichthyosaurHealth;
pev->view_ofs = Vector ( 0, 0, 16 );
pev->health = gSkillData.ichthyosaurHealth;
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,61 +736,61 @@ 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 );
}
float CIchthyosaur::FlPitchDiff( void )
{
float flPitchDiff;
float flCurrentPitch;
float flPitchDiff;
float flCurrentPitch;
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

347
dlls/islave.cpp
View File

@ -31,13 +31,13 @@ extern DLL_GLOBAL int g_iSkillLevel;
//=========================================================
// Monster's Anim Events Go Here
//=========================================================
#define ISLAVE_AE_CLAW ( 1 )
#define ISLAVE_AE_CLAWRAKE ( 2 )
#define ISLAVE_AE_ZAP_POWERUP ( 3 )
#define ISLAVE_AE_CLAW ( 1 )
#define ISLAVE_AE_CLAWRAKE ( 2 )
#define ISLAVE_AE_ZAP_POWERUP ( 3 )
#define ISLAVE_AE_ZAP_SHOOT ( 4 )
#define ISLAVE_AE_ZAP_DONE ( 5 )
#define ISLAVE_MAX_BEAMS 8
#define ISLAVE_MAX_BEAMS 8
class CISlave : public CSquadMonster
{
@ -45,15 +45,15 @@ public:
void Spawn( void );
void Precache( void );
void SetYawSpeed( void );
int ISoundMask( void );
int Classify ( void );
int IRelationship( CBaseEntity *pTarget );
int ISoundMask( 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 );
@ -84,7 +84,7 @@ public:
int m_iBeams;
float m_flNextAttack;
int m_voicePitch;
int m_voicePitch;
EHANDLE m_hDead;
@ -97,7 +97,7 @@ public:
LINK_ENTITY_TO_CLASS( monster_alien_slave, CISlave )
LINK_ENTITY_TO_CLASS( monster_vortigaunt, CISlave )
TYPEDESCRIPTION CISlave::m_SaveData[] =
TYPEDESCRIPTION CISlave::m_SaveData[] =
{
DEFINE_FIELD( CISlave, m_iBravery, FIELD_INTEGER ),
@ -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;
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,72 +196,71 @@ 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 |
bits_SOUND_DANGER |
bits_SOUND_PLAYER;
return bits_SOUND_WORLD |
bits_SOUND_COMBAT |
bits_SOUND_DANGER |
bits_SOUND_PLAYER;
}
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->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->health = gSkillData.slaveHealth;
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,52 +528,52 @@ 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" );
}
}
//=========================================================
// 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" );
}

126
dlls/items.cpp
View File

@ -34,18 +34,18 @@ extern int gmsgItemPickup;
class CWorldItem : public CBaseEntity
{
public:
void KeyValue(KeyValueData *pkvd );
void Spawn( void );
int m_iType;
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,78 +174,78 @@ 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);
return TRUE;
//EMIT_SOUND_SUIT( ENT( pev ), szcharge );
pPlayer->SetSuitUpdate( szcharge, FALSE, SUIT_NEXT_IN_30SEC);
return TRUE;
}
return FALSE;
}
@ -257,18 +257,18 @@ 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?

14
dlls/items.h
View File

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

95
dlls/lights.cpp
View File

@ -27,23 +27,23 @@
class CLight : public CPointEntity
{
public:
virtual void KeyValue( KeyValueData* pkvd );
virtual void Spawn( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual void KeyValue( KeyValueData* pkvd );
virtual void Spawn( void );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
private:
int m_iStyle;
int m_iszPattern;
int m_iStyle;
int m_iszPattern;
};
LINK_ENTITY_TO_CLASS( light, CLight )
TYPEDESCRIPTION CLight::m_SaveData[] =
TYPEDESCRIPTION CLight::m_SaveData[] =
{
DEFINE_FIELD( CLight, m_iStyle, FIELD_INTEGER ),
DEFINE_FIELD( CLight, m_iszPattern, FIELD_STRING ),
@ -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 );
}
}
}
@ -135,28 +136,28 @@ LINK_ENTITY_TO_CLASS( light_spot, CLight )
class CEnvLight : public CLight
{
public:
void KeyValue( KeyValueData* pkvd );
void Spawn( void );
void KeyValue( KeyValueData* pkvd );
void Spawn( void );
};
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();
}

84
dlls/monstermaker.cpp
View File

@ -37,23 +37,23 @@ 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 );
virtual int Restore( CRestore &restore );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
static TYPEDESCRIPTION m_SaveData[];
string_t m_iszMonsterClassname;// classname of the monster(s) that will be created.
int m_cNumMonsters;// max number of monsters this ent can create
int m_cNumMonsters;// max number of monsters this ent can create
int m_cLiveChildren;// how many monsters made by this monster maker that are currently alive
int m_iMaxLiveChildren;// max number of monsters that this maker may have out at one time.
int m_cLiveChildren;// how many monsters made by this monster maker that are currently alive
int m_iMaxLiveChildren;// max number of monsters that this maker may have out at one time.
float m_flGround; // z coord of the ground under me, used to make sure no monsters are under the maker when it drops a new child
@ -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();
@ -160,20 +160,20 @@ void CMonsterMaker :: Precache( void )
void CMonsterMaker::MakeMonster( void )
{
edict_t *pent;
entvars_t *pevCreate;
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;
}

1315
dlls/monsters.cpp
View File

File diff suppressed because it is too large Load Diff

66
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,20 +59,20 @@ 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 &&
m_MonsterState != MONSTERSTATE_PRONE &&
if( m_MonsterState != MONSTERSTATE_NONE &&
m_MonsterState != MONSTERSTATE_PRONE &&
m_MonsterState != MONSTERSTATE_DEAD )// don't bother with this crap if monster is prone.
{
// collect some sensory Condition information.
@ -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;
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
}

142
dlls/mortar.cpp
View File

@ -16,7 +16,7 @@
===== mortar.cpp ========================================================
the "LaBuznik" mortar device
the "LaBuznik" mortar device
*/
@ -36,12 +36,12 @@ 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 );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
static TYPEDESCRIPTION m_SaveData[];
void EXPORT FieldUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
@ -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,20 +201,20 @@ public:
LINK_ENTITY_TO_CLASS( monster_mortar, CMortar )
void CMortar::Spawn( )
void CMortar::Spawn()
{
pev->movetype = MOVETYPE_NONE;
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
pev->solid = SOLID_NOT;
pev->dmg = 200;
pev->dmg = 200;
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;

122
dlls/mpstubb.cpp
View File

@ -25,28 +25,28 @@ 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; }
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 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,22 +54,22 @@ void CBaseMonster::CorpseFallThink( void )
}
// Call after animation/pose is set up
void CBaseMonster :: MonsterInitDead( void )
void CBaseMonster::MonsterInitDead( void )
{
InitBoneControllers();
pev->solid = SOLID_BBOX;
pev->movetype = MOVETYPE_TOSS;// so he'll fall to ground
pev->solid = SOLID_BBOX;
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 );
pev->max_health = pev->health;
pev->deadflag = DEAD_DEAD;
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 )
{
return FALSE;
BOOL CBaseMonster::ShouldFadeOnDeath( void )
{
return FALSE;
}
BOOL CBaseMonster :: FCheckAITrigger ( void )
{
return FALSE;
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,33 +128,33 @@ 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;
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;
CBaseEntity *pSightEnt = NULL;// the current visible entity that we're dealing with
CBaseEntity *pSightEnt = NULL;// the current visible entity that we're dealing with
CBaseEntity *pList[100];
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,30 +171,30 @@ 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:
case R_NM:
iSighted |= bits_COND_SEE_NEMESIS;
break;
case R_HT:
case R_HT:
iSighted |= bits_COND_SEE_HATE;
break;
case R_DL:
case R_DL:
iSighted |= bits_COND_SEE_DISLIKE;
break;
case R_FR:
case R_FR:
iSighted |= bits_COND_SEE_FEAR;
break;
case R_AL:
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;
}
}
}
}
SetConditions( iSighted );
}
@ -207,43 +207,43 @@ 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;
int iNearest;
int iDist;
int iBestRelationship;
int iNearest;
int iDist;
int iBestRelationship;
iNearest = 8192;// so first visible entity will become the closest.
pNextEnt = m_pLink;
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;
}
}

487
dlls/multiplay_gamerules.cpp
View File

File diff suppressed because it is too large Load Diff

664
dlls/nihilanth.cpp
View File

File diff suppressed because it is too large Load Diff

2378
dlls/nodes.cpp
View File

File diff suppressed because it is too large Load Diff

282
dlls/osprey.cpp
View File

@ -38,15 +38,15 @@ typedef struct
class COsprey : public CBaseMonster
{
public:
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int ObjectCaps( void ) { return CBaseMonster :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
int Save( CSave &save );
int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
int ObjectCaps( void ) { return CBaseMonster::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
void Spawn( void );
void Precache( void );
int Classify( void ) { return CLASS_MACHINE; };
int BloodColor( void ) { return DONT_BLEED; }
int Classify( void ) { return CLASS_MACHINE; };
int BloodColor( void ) { return DONT_BLEED; }
void Killed( entvars_t *pevAttacker, int iGib );
void UpdateGoal( 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;
@ -84,7 +84,7 @@ public:
float m_flRightHealth;
float m_flLeftHealth;
int m_iUnits;
int m_iUnits;
EHANDLE m_hGrunt[MAX_CARRY];
Vector m_vecOrigin[MAX_CARRY];
EHANDLE m_hRepel[4];
@ -95,9 +95,9 @@ public:
int m_iPitch;
int m_iExplode;
int m_iTailGibs;
int m_iBodyGibs;
int m_iEngineGibs;
int m_iTailGibs;
int m_iBodyGibs;
int m_iEngineGibs;
int m_iDoLeftSmokePuff;
int m_iDoRightSmokePuff;
@ -140,35 +140,35 @@ 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;
pev->takedamage = DAMAGE_YES;
m_flRightHealth = 200;
m_flLeftHealth = 200;
pev->health = 400;
pev->takedamage = DAMAGE_YES;
m_flRightHealth = 200;
m_flLeftHealth = 200;
pev->health = 400;
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,15 +182,15 @@ 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" );
m_iExplode = PRECACHE_MODEL( "sprites/fexplo.spr" );
m_iExplode = PRECACHE_MODEL( "sprites/fexplo.spr" );
m_iTailGibs = PRECACHE_MODEL( "models/osprey_tailgibs.mdl" );
m_iBodyGibs = PRECACHE_MODEL( "models/osprey_bodygibs.mdl" );
m_iEngineGibs = PRECACHE_MODEL( "models/osprey_enginegibs.mdl" );
@ -201,24 +201,24 @@ 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;
m_hGrunt[m_iUnits] = pEntity;
m_vecOrigin[m_iUnits] = pEntity->pev->origin;
m_iUnits++;
}
}
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,46 +523,45 @@ 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( 12 ); // framerate
WRITE_BYTE( RANDOM_LONG( 0, 29 ) + 30 ); // scale * 10
WRITE_BYTE( 12 ); // framerate
WRITE_BYTE( TE_EXPLFLAG_NONE );
MESSAGE_END();
// lots of smoke
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, 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
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 );
@ -618,7 +613,7 @@ void COsprey :: DyingThink( void )
WRITE_COORD( vecSpot.z + 512 );
WRITE_SHORT( m_iExplode );
WRITE_BYTE( 250 ); // scale * 10
WRITE_BYTE( 10 ); // framerate
WRITE_BYTE( 10 ); // framerate
MESSAGE_END();
*/
@ -641,7 +636,7 @@ void COsprey :: DyingThink( void )
WRITE_COORD( vecSpot.z + 300 );
WRITE_SHORT( g_sModelIndexSmoke );
WRITE_BYTE( 250 ); // scale * 10
WRITE_BYTE( 6 ); // framerate
WRITE_BYTE( 6 ); // framerate
MESSAGE_END();
*/
@ -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 );

189
dlls/pathcorner.cpp
View File

@ -25,17 +25,17 @@
class CPathCorner : public CPointEntity
{
public:
void Spawn( );
void Spawn();
void KeyValue( KeyValueData* pkvd );
float GetDelay( void ) { return m_flWait; }
// void Touch( CBaseEntity *pOther );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
//void Touch( CBaseEntity *pOther );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
private:
float m_flWait;
float m_flWait;
};
LINK_ENTITY_TO_CLASS( path_corner, CPathCorner )
@ -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,58 +251,56 @@ 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;
}
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;
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;
@ -354,15 +353,14 @@ CPathTrack *CPathTrack :: LookAhead( Vector *origin, float dist, int move )
return pcurrent;
}
// Assumes this is ALWAYS enabled
CPathTrack *CPathTrack :: Nearest( Vector origin )
{
int deadCount;
float minDist, dist;
Vector delta;
CPathTrack *ppath, *pnearest;
// Assumes this is ALWAYS enabled
CPathTrack *CPathTrack::Nearest( Vector origin )
{
int deadCount;
float minDist, dist;
Vector delta;
CPathTrack *ppath, *pnearest;
delta = origin - pev->origin;
delta.z = 0;
@ -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;
@ -394,21 +392,20 @@ 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;
}

15
dlls/plane.h
View File

@ -1,7 +1,7 @@
/***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
@ -18,10 +18,10 @@
//=========================================================
// Plane
//=========================================================
class CPlane
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;
Vector m_vecNormal;
float m_flDist;
BOOL m_fInitialized;
};
#endif // PLANE_H

2149
dlls/player.cpp
View File

File diff suppressed because it is too large Load Diff

44
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,20 +39,20 @@ 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;
return CLASS_PLAYER_ALLY;
}
//=========================================================
// 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,30 +80,30 @@ void CPlayerMonster :: HandleAnimEvent( MonsterEvent_t *pEvent )
//=========================================================
// ISoundMask - player monster can't hear.
//=========================================================
int CPlayerMonster :: ISoundMask ( void )
int CPlayerMonster::ISoundMask( void )
{
return NULL;
return NULL;
}
//=========================================================
// 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;
m_bloodColor = BLOOD_COLOR_RED;
pev->health = 8;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_RED;
pev->health = 8;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
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,10 +113,10 @@ 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" );
}
//=========================================================
// AI Schedules Specific to this monster

118
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 )
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;

36
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,20 +41,20 @@ 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;
return CLASS_INSECT;
}
//=========================================================
// 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,20 +68,20 @@ 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.
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
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.
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
MonsterInit();
}
@ -89,10 +89,10 @@ 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" );
}
//=========================================================
// AI Schedules Specific to this monster

297
dlls/roach.cpp
View File

@ -16,20 +16,20 @@
// cockroach
//=========================================================
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "schedule.h"
#include "soundent.h"
#include "decals.h"
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "schedule.h"
#include "soundent.h"
#include "decals.h"
#define ROACH_IDLE 0
#define ROACH_BORED 1
#define ROACH_SCARED_BY_ENT 2
#define ROACH_SCARED_BY_LIGHT 3
#define ROACH_SMELL_FOOD 4
#define ROACH_EAT 5
#define ROACH_IDLE 0
#define ROACH_BORED 1
#define ROACH_SCARED_BY_ENT 2
#define ROACH_SCARED_BY_LIGHT 3
#define ROACH_SMELL_FOOD 4
#define ROACH_EAT 5
//=========================================================
// Monster's Anim Events Go Here
@ -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 );
float m_flLastLightLevel;
float m_flNextSmellTime;
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;
BOOL m_fLightHacked;
int m_iMode;
// -----------------------------
};
LINK_ENTITY_TO_CLASS( monster_cockroach, CRoach )
//=========================================================
@ -64,16 +65,16 @@ 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;
return bits_SOUND_CARCASS | bits_SOUND_MEAT;
}
//=========================================================
// 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;
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,66 +117,65 @@ 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;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_YELLOW;
pev->effects = 0;
pev->health = 1;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
m_MonsterState = MONSTERSTATE_NONE;
pev->solid = SOLID_SLIDEBOX;
pev->movetype = MOVETYPE_STEP;
m_bloodColor = BLOOD_COLOR_YELLOW;
pev->effects = 0;
pev->health = 1;
m_flFieldOfView = 0.5;// indicates the width of this monster's forward view cone ( as a dotproduct result )
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->takedamage = DAMAGE_YES;
m_fLightHacked = FALSE;
m_flLastLightLevel = -1;
m_iMode = ROACH_IDLE;
m_flNextSmellTime = gpGlobals->time;
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;
m_iMode = ROACH_IDLE;
m_flNextSmellTime = gpGlobals->time;
}
//=========================================================
// Precache - precaches all resources this monster needs
//=========================================================
void CRoach :: Precache()
void CRoach::Precache()
{
PRECACHE_MODEL("models/roach.mdl");
PRECACHE_SOUND("roach/rch_die.wav");
PRECACHE_SOUND("roach/rch_walk.wav");
PRECACHE_SOUND("roach/rch_smash.wav");
}
PRECACHE_MODEL( "models/roach.mdl" );
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,89 +202,89 @@ 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:
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 );
}
}
}
break;
}
case ROACH_SCARED_BY_LIGHT:
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,93 +293,93 @@ 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;
float flDist;
Vector vecNewDir;
Vector vecDest;
float flDist;
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;
}
}
do
do
{
// picks a random spot, requiring that it be at least 128 units away
// else, the roach will pick a spot too close to itself and run in
// 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;
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;
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,15 +437,15 @@ 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:
case R_FR:
iSighted |= bits_COND_SEE_FEAR;
break;
case R_NO:
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
//=========================================================

203
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 );
}
@ -79,7 +77,7 @@ void CLaserSpot::Spawn( void )
void CLaserSpot::Suspend( float flSuspendTime )
{
pev->effects |= EF_NODRAW;
SetThink( &CLaserSpot::Revive );
pev->nextthink = gpGlobals->time + flSuspendTime;
}
@ -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;
@ -425,11 +418,11 @@ void CRpg::Holster( int skiplocal /* = 0 */ )
m_fInReload = FALSE;// cancel any reload in progress.
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
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,8 +442,8 @@ 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 );
UTIL_MakeVectors( m_pPlayer->pev->v_angle );// RpgRocket::Create stomps on globals, so remake.
@ -466,28 +459,27 @@ void CRpg::PrimaryAttack()
#else
flags = 0;
#endif
PLAYBACK_EVENT( flags, m_pPlayer->edict(), m_usRpg );
m_iClip--;
m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 1.5;
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 1.5;
}
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,20 +531,20 @@ 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 );
}
#endif
@ -561,24 +553,23 @@ void CRpg::UpdateSpot( void )
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;

170
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,58 +86,58 @@ void CSatchelCharge :: Spawn( void )
pev->friction = 0.8;
pev->dmg = gSkillData.plrDmgSatchel;
// ResetSequenceInfo( );
// ResetSequenceInfo();
pev->sequence = 1;
}
void CSatchelCharge::SatchelSlide( CBaseEntity *pOther )
{
entvars_t *pevOther = pOther->pev;
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,17 +289,15 @@ 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;
}
@ -299,8 +305,8 @@ BOOL CSatchel::Deploy( )
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();
}

383
dlls/schedule.cpp
View File

File diff suppressed because it is too large Load Diff

789
dlls/scientist.cpp
View File

File diff suppressed because it is too large Load Diff

470
dlls/scripted.cpp
View File

File diff suppressed because it is too large Load Diff

164
dlls/shotgun.cpp
View File

@ -23,10 +23,11 @@
#include "gamerules.h"
// special deathmatch shotgun spreads
#define VECTOR_CONE_DM_SHOTGUN Vector( 0.08716, 0.04362, 0.00 )// 10 degrees by 5 degrees
#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
@ -233,19 +233,19 @@ void CShotgun::SecondaryAttack( void )
// untouched default single player
vecDir = m_pPlayer->FireBulletsPlayer( 12, vecSrc, vecAiming, VECTOR_CONE_10DEGREES, 2048, BULLET_PLAYER_BUCKSHOT, 0, 0, m_pPlayer->pev, m_pPlayer->random_seed );
}
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;
}

14
dlls/skill.cpp
View File

@ -19,7 +19,7 @@
#include "util.h"
#include "skill.h"
skilldata_t gSkillData;
skilldata_t gSkillData;
//=========================================================
// take the name of a cvar, tack a digit for the skill level
@ -27,17 +27,17 @@ skilldata_t gSkillData;
//=========================================================
float GetSkillCvar( char *pName )
{
int iCount;
float flValue;
char szBuffer[ 64 ];
int iCount;
float flValue;
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;

1011
dlls/sound.cpp
View File

File diff suppressed because it is too large Load Diff

40
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;
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,17 +118,17 @@ 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;
}
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NOCLIP;
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NOCLIP;
if (pev->impulse)
if( pev->impulse )
SpectatorImpulseCommand();
}

10
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 );
};

256
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;
}
}
@ -97,13 +97,13 @@ BOOL CSquadMonster :: OccupySlot( int iDesiredSlots )
}
//=========================================================
// VacateSlot
// 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,26 +443,25 @@ 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;
}
CPlane backPlane;
CPlane leftPlane;
CPlane rightPlane;
CPlane backPlane;
CPlane leftPlane;
CPlane rightPlane;
Vector vecLeftSide;
Vector vecRightSide;
Vector v_left;
Vector vecLeftSide;
Vector vecRightSide;
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;
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;
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,31 +578,31 @@ 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;
}
extern Schedule_t slChaseEnemyFailed[];
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 );

58
dlls/squadmonster.h
View File

@ -57,16 +57,16 @@ 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
int m_afSquadSlots;
float m_flLastEnemySightTime; // last time anyone in the squad saw the enemy
BOOL m_fEnemyEluded;
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;
// squad member info
int m_iMySlot;// this is the behaviour slot that the monster currently holds in the squad.
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,45 +74,45 @@ public:
BOOL NoFriendlyFire( void );
// squad functions still left in base class
CSquadMonster *MySquadLeader( )
{
CSquadMonster *pSquadLeader = (CSquadMonster *)((CBaseEntity *)m_hSquadLeader);
if (pSquadLeader != NULL)
CSquadMonster *MySquadLeader()
{
CSquadMonster *pSquadLeader = (CSquadMonster *)( (CBaseEntity *)m_hSquadLeader );
if( pSquadLeader != NULL )
return pSquadLeader;
return this;
}
CSquadMonster *MySquadMember( int i )
{
if (i >= MAX_SQUAD_MEMBERS-1)
CSquadMonster *MySquadMember( int i )
{
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 SquadCount( void );
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; }
static TYPEDESCRIPTION m_SaveData[];
int Save( CSave &save );
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 );
};

261
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,22 +43,21 @@ enum squeak_e {
};
#ifndef CLIENT_DLL
class CSqueakGrenade : public CGrenade
{
void Spawn( void );
void Precache( void );
int Classify( void );
int Classify( void );
void EXPORT SuperBounceTouch( CBaseEntity *pOther );
void EXPORT HuntThink( void );
int BloodColor( void ) { return BLOOD_COLOR_YELLOW; }
int BloodColor( void ) { return BLOOD_COLOR_YELLOW; }
void Killed( entvars_t *pevAttacker, int iGib );
void GibMonster( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
static TYPEDESCRIPTION m_SaveData[];
static float m_flNextBounceSoundTime;
@ -67,7 +68,7 @@ class CSqueakGrenade : public CGrenade
float m_flNextHit;
Vector m_posPrev;
EHANDLE m_hOwner;
int m_iMyClass;
int m_iMyClass;
};
float CSqueakGrenade::m_flNextBounceSoundTime = 0;
@ -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 );
@ -128,10 +129,10 @@ void CSqueakGrenade :: Spawn( void )
m_flNextHunt = gpGlobals->time + 1E6;
pev->flags |= FL_MONSTER;
pev->takedamage = DAMAGE_AIM;
pev->health = gSkillData.snarkHealth;
pev->gravity = 0.5;
pev->friction = 0.5;
pev->takedamage = DAMAGE_AIM;
pev->health = gSkillData.snarkHealth;
pev->gravity = 0.5;
pev->friction = 0.5;
pev->dmg = gSkillData.snarkDmgPop;
@ -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 );
@ -317,12 +318,12 @@ void CSqueakGrenade::HuntThink( void )
void CSqueakGrenade::SuperBounceTouch( CBaseEntity *pOther )
{
float flpitch;
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);
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 );
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 );
}
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,16 +409,16 @@ 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.
m_iDefaultAmmo = SNARK_DEFAULT_GIVE;
pev->sequence = 1;
pev->animtime = gpGlobals->time;
pev->framerate = 1.0;
@ -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);
else
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "squeek/sqk_hunt3.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 );
m_pPlayer->m_iWeaponVolume = QUIET_GUN_VOLUME;
@ -470,22 +471,22 @@ BOOL CSqueak::Deploy( )
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 );
}
@ -502,15 +503,15 @@ void CSqueak::PrimaryAttack()
// find place to toss monster
UTIL_TraceLine( trace_origin + gpGlobals->v_forward * 20, trace_origin + gpGlobals->v_forward * 64, dont_ignore_monsters, NULL, &tr );
int flags;
int flags;
#ifdef CLIENT_WEAPONS
flags = FEV_NOTHOST;
flags = FEV_NOTHOST;
#else
flags = 0;
flags = 0;
#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 );
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;

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