int m_iPitch;
int m_iExplode;
int m_iTailGibs;
int m_iBodyGibs;
int m_iEngineGibs;
int m_iDoLeftSmokePuff;
int m_iDoRightSmokePuff;
};
LINK_ENTITY_TO_CLASS( monster_osprey, COsprey );
TYPEDESCRIPTION COsprey::m_SaveData[] =
{
DEFINE_FIELD( COsprey, m_pGoalEnt, FIELD_CLASSPTR ),
DEFINE_FIELD( COsprey, m_vel1, FIELD_VECTOR ),
DEFINE_FIELD( COsprey, m_vel2, FIELD_VECTOR ),
DEFINE_FIELD( COsprey, m_pos1, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( COsprey, m_pos2, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( COsprey, m_ang1, FIELD_VECTOR ),
DEFINE_FIELD( COsprey, m_ang2, FIELD_VECTOR ),
DEFINE_FIELD( COsprey, m_startTime, FIELD_TIME ),
DEFINE_FIELD( COsprey, m_dTime, FIELD_FLOAT ),
DEFINE_FIELD( COsprey, m_velocity, FIELD_VECTOR ),
DEFINE_FIELD( COsprey, m_flIdealtilt, FIELD_FLOAT ),
DEFINE_FIELD( COsprey, m_flRotortilt, FIELD_FLOAT ),
DEFINE_FIELD( COsprey, m_flRightHealth, FIELD_FLOAT ),
BYTE m_bMoveSnd; // sound a door makes while moving
BYTE m_bStopSnd; // sound a door makes when it stops
locksound_t m_ls; // door lock sounds
BYTE m_bLockedSound; // ordinals from entity selection
BYTE m_bLockedSentence;
BYTE m_bUnlockedSound;
BYTE m_bUnlockedSentence;
};
TYPEDESCRIPTION CBaseDoor::m_SaveData[] =
{
DEFINE_FIELD( CBaseDoor, m_bHealthValue, FIELD_CHARACTER ),
DEFINE_FIELD( CBaseDoor, m_bMoveSnd, FIELD_CHARACTER ),
DEFINE_FIELD( CBaseDoor, m_bStopSnd, FIELD_CHARACTER ),
DEFINE_FIELD( CBaseDoor, m_bLockedSound, FIELD_CHARACTER ),
DEFINE_FIELD( CBaseDoor, m_bLockedSentence, FIELD_CHARACTER ),
DEFINE_FIELD( CBaseDoor, m_bUnlockedSound, FIELD_CHARACTER ),
DEFINE_FIELD( CBaseDoor, m_bUnlockedSentence, FIELD_CHARACTER ),
};
IMPLEMENT_SAVERESTORE( CBaseDoor, CBaseToggle );
#define DOOR_SENTENCEWAIT 6
#define DOOR_SOUNDWAIT 3
void SpawnFlock( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
// Sounds are shared by the flock
static void PrecacheFlockSounds( void );
int m_cFlockSize;
float m_flFlockRadius;
};
TYPEDESCRIPTION CFlockingFlyerFlock::m_SaveData[] =
{
DEFINE_FIELD( CFlockingFlyerFlock, m_cFlockSize, FIELD_INTEGER ),
DEFINE_FIELD( CFlockingFlyerFlock, m_flFlockRadius, FIELD_FLOAT ),
};
IMPLEMENT_SAVERESTORE( CFlockingFlyerFlock, CBaseMonster );
//=========================================================
//=========================================================
class CFlockingFlyer : public CBaseMonster
{
public:
void Spawn( void );
void Precache( void );
void SpawnCommonCode( void );
void EXPORT IdleThink( void );
void BoidAdvanceFrame( void );
PRECACHE_SOUND ("weapons/bullet_hit1.wav"); // hit by bullet
PRECACHE_SOUND ("weapons/bullet_hit2.wav"); // hit by bullet
PRECACHE_SOUND ("items/weapondrop1.wav");// weapon falls to the ground
PRECACHE_SOUND ("items/9mmclip1.wav");
PRECACHE_SOUND( "weapons/357_cock1.wav" );
}
TYPEDESCRIPTION CBasePlayerItem::m_SaveData[] =
{
DEFINE_FIELD( CBasePlayerItem, m_pPlayer, FIELD_CLASSPTR ),
DEFINE_FIELD( CBasePlayerItem, m_pNext, FIELD_CLASSPTR ),
//DEFINE_FIELD( CBasePlayerItem, m_fKnown, FIELD_INTEGER ),Reset to zero on load
DEFINE_FIELD( CBasePlayerItem, m_iId, FIELD_INTEGER ),
// DEFINE_FIELD( CBasePlayerItem, m_iIdPrimary, FIELD_INTEGER ),
// DEFINE_FIELD( CBasePlayerItem, m_iIdSecondary, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CBasePlayerItem, CBaseAnimating );
TYPEDESCRIPTION CBasePlayerWeapon::m_SaveData[] =
{
#if defined( CLIENT_WEAPONS )
DEFINE_FIELD( CBasePlayerWeapon, m_flNextPrimaryAttack, FIELD_FLOAT ),
DEFINE_FIELD( CBasePlayerWeapon, m_flNextSecondaryAttack, FIELD_FLOAT ),
DEFINE_FIELD( CBasePlayerWeapon, m_flTimeWeaponIdle, FIELD_FLOAT ),
#include "precompiled.h"
/*
* Globals initialization
*/
#ifndef HOOK_GAMEDLL
TYPEDESCRIPTION CLight::m_SaveData[] =
{
DEFINE_FIELD(CLight, m_iStyle, FIELD_INTEGER),
DEFINE_FIELD(CLight, m_iszPattern, FIELD_STRING),
};
#else
TYPEDESCRIPTION IMPLEMENT_ARRAY_CLASS(CLight, m_SaveData)[2];
#endif // HOOK_GAMEDLL
/* <e7ded> ../cstrike/dlls/lights.cpp:48 */
LINK_ENTITY_TO_CLASS(light, CLight);
/* <e7b2c> ../cstrike/dlls/lights.cpp:56 */
IMPLEMENT_SAVERESTORE(CLight, CPointEntity);
// Cache user-entity-field values until spawn is called.
/* <e7bef> ../cstrike/dlls/lights.cpp:62 */
void CLight::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
{
if (FStrEq(pkvd->szKeyName, "style"))
float m_painTime;
float m_checkAttackTime;
BOOL m_lastAttackCheck;
int m_iHead;
// UNDONE: What is this for? It isn't used?
float m_flPlayerDamage;// how much pain has the player inflicted on me?
CUSTOM_SCHEDULES;
};
LINK_ENTITY_TO_CLASS( monster_otis, COtis );
TYPEDESCRIPTION COtis::m_SaveData[] =
{
DEFINE_FIELD( COtis, m_fGunDrawn, FIELD_BOOLEAN ),
DEFINE_FIELD( COtis, m_painTime, FIELD_TIME ),
DEFINE_FIELD( COtis, m_checkAttackTime, FIELD_TIME ),
DEFINE_FIELD( COtis, m_lastAttackCheck, FIELD_BOOLEAN ),
DEFINE_FIELD( COtis, m_flPlayerDamage, FIELD_FLOAT ),
DEFINE_FIELD( COtis, m_fHostile, FIELD_BOOLEAN ),
DEFINE_FIELD( COtis, m_iHead, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( COtis, CTalkMonster );
//=========================================================
// KeyValue
//=========================================================
void COtis :: KeyValue( KeyValueData *pkvd )
{
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?
CUSTOM_SCHEDULES;
};
LINK_ENTITY_TO_CLASS( monster_barney, CBarney );
TYPEDESCRIPTION CBarney::m_SaveData[] =
{
DEFINE_FIELD( CBarney, m_fGunDrawn, FIELD_BOOLEAN ),
DEFINE_FIELD( CBarney, m_painTime, FIELD_TIME ),
DEFINE_FIELD( CBarney, m_checkAttackTime, FIELD_TIME ),
DEFINE_FIELD( CBarney, m_lastAttackCheck, FIELD_BOOLEAN ),
DEFINE_FIELD( CBarney, m_flPlayerDamage, FIELD_FLOAT ),
};
IMPLEMENT_SAVERESTORE( CBarney, CTalkMonster );
//=========================================================
// AI Schedules Specific to this monster
//=========================================================
Task_t tlBaFollow[] =
{
{ TASK_MOVE_TO_TARGET_RANGE,(float)128 }, // Move within 128 of target ent (client)
{ TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
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[];
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[] =
{
DEFINE_FIELD(CEnvExplosion, m_iMagnitude, FIELD_INTEGER),
DEFINE_FIELD(CEnvExplosion, m_spriteScale, FIELD_INTEGER),
};
IMPLEMENT_SAVERESTORE(CEnvExplosion, CBaseMonster);
LINK_ENTITY_TO_CLASS(env_explosion, CEnvExplosion);
void CEnvExplosion::KeyValue(KeyValueData *pkvd)
{
if (FStrEq(pkvd->szKeyName, "iMagnitude"))
{
m_iMagnitude = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseEntity::KeyValue(pkvd);
static TYPEDESCRIPTION m_SaveData[];
};
LINK_ENTITY_TO_CLASS( trigger_submodel, CTriggerSubModel );
//=============================
//=============================
// - savestore
TYPEDESCRIPTION CTriggerSubModel::m_SaveData[] =
{
DEFINE_FIELD( CTriggerSubModel, m_iBodygroup, FIELD_INTEGER ),
DEFINE_FIELD( CTriggerSubModel, m_iSubmodel, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CTriggerSubModel, CBaseEntity );
//=============================
//=============================
// - fonctions
void CTriggerSubModel :: Spawn ( void )
{
pev->solid = SOLID_NOT;
}
REMOVE_ENTITY(ENT(pev));
}
// Convenient way to explicitly do nothing (passed to functions that require a method)
void CBaseEntity :: SUB_DoNothing( void )
{
}
// Global Savedata for Delay
TYPEDESCRIPTION CBaseDelay::m_SaveData[] =
{
DEFINE_FIELD( CBaseDelay, m_flDelay, FIELD_FLOAT ),
DEFINE_FIELD( CBaseDelay, m_iszKillTarget, FIELD_STRING ),
};
IMPLEMENT_SAVERESTORE( CBaseDelay, CBaseEntity );
void CBaseDelay :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "delay"))
{
m_flDelay = atof( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "killtarget"))
{
m_iszKillTarget = ALLOC_STRING(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "lip") )
pkvd->fHandled = TRUE;
else
CBaseDelay::KeyValue( pkvd );
}
//
// func_breakable - bmodel that breaks into pieces after taking damage
//
LINK_ENTITY_TO_CLASS( func_breakable, CBreakable );
TYPEDESCRIPTION CBreakable::m_SaveData[] =
{
DEFINE_FIELD( CBreakable, m_Material, FIELD_INTEGER ),
DEFINE_FIELD( CBreakable, m_Explosion, FIELD_INTEGER ),
// Don't need to save/restore these because we precache after restore
// DEFINE_FIELD( CBreakable, m_idShard, FIELD_INTEGER ),
DEFINE_FIELD( CBreakable, m_angle, FIELD_FLOAT ),
DEFINE_FIELD( CBreakable, m_iszGibModel, FIELD_STRING ),
DEFINE_FIELD( CBreakable, m_iszSpawnObject, FIELD_STRING ),
// Explosion magnitude is stored in pev->impulse
};
IMPLEMENT_SAVERESTORE( CBreakable, CBaseEntity );
void CBreakable::Spawn( void )
Vector m_barrelPos; // Length of the freakin barrel
float m_spriteScale; // Scale of any sprites we shoot
int m_iszSpriteSmoke;
int m_iszSpriteFlash;
TANKBULLET m_bulletType; // Bullet type
int m_iBulletDamage; // 0 means use Bullet type's default damage
Vector m_sightOrigin; // Last sight of target
int m_spread; // firing spread
int m_iszMaster; // Master entity (game_team_master or multisource)
};
TYPEDESCRIPTION CFuncTank::m_SaveData[] =
{
DEFINE_FIELD( CFuncTank, m_yawCenter, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_yawRate, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_yawRange, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_yawTolerance, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_pitchCenter, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_pitchRate, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_pitchRange, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_pitchTolerance, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_fireLast, FIELD_TIME ),
DEFINE_FIELD( CFuncTank, m_fireRate, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_lastSightTime, FIELD_TIME ),
DEFINE_FIELD( CFuncTank, m_persist, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_minRange, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_maxRange, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTank, m_barrelPos, FIELD_VECTOR ),
DEFINE_FIELD( CFuncTank, m_spriteScale, FIELD_FLOAT ),
CSprite *m_pSprite;
EGON_FIRESTATE m_fireState;
EGON_FIREMODE m_fireMode;
float m_shakeTime;
BOOL m_deployed;
};
LINK_ENTITY_TO_CLASS( weapon_egon, CEgon );
int CEgon::g_fireAnims1[] = { EGON_FIRE1, EGON_FIRE2, EGON_FIRE3, EGON_FIRE4 };
int CEgon::g_fireAnims2[] = { EGON_ALTFIRECYCLE };
TYPEDESCRIPTION CEgon::m_SaveData[] =
{
DEFINE_FIELD( CEgon, m_pBeam, FIELD_CLASSPTR ),
DEFINE_FIELD( CEgon, m_pNoise, FIELD_CLASSPTR ),
DEFINE_FIELD( CEgon, m_pSprite, FIELD_CLASSPTR ),
DEFINE_FIELD( CEgon, m_shootTime, FIELD_TIME ),
DEFINE_FIELD( CEgon, m_fireState, FIELD_INTEGER ),
DEFINE_FIELD( CEgon, m_fireMode, FIELD_INTEGER ),
DEFINE_FIELD( CEgon, m_shakeTime, FIELD_TIME ),
DEFINE_FIELD( CEgon, m_flAmmoUseTime, FIELD_TIME ),
};
IMPLEMENT_SAVERESTORE( CEgon, CBasePlayerWeapon );
void CEgon::Spawn( )
{
Precache( );
m_iId = WEAPON_EGON;
static const char *pDieSounds[];
static const char *pPainSounds[];
void IdleSound( void );
void AlertSound( void );
void AttackSound( void );
void BiteSound( void );
void DeathSound( void );
void PainSound( void );
};
LINK_ENTITY_TO_CLASS( monster_ichthyosaur, CIchthyosaur );
TYPEDESCRIPTION CIchthyosaur::m_SaveData[] =
{
DEFINE_FIELD( CIchthyosaur, m_SaveVelocity, FIELD_VECTOR ),
DEFINE_FIELD( CIchthyosaur, m_idealDist, FIELD_FLOAT ),
DEFINE_FIELD( CIchthyosaur, m_flBlink, FIELD_FLOAT ),
DEFINE_FIELD( CIchthyosaur, m_flEnemyTouched, FIELD_FLOAT ),
DEFINE_FIELD( CIchthyosaur, m_bOnAttack, FIELD_BOOLEAN ),
DEFINE_FIELD( CIchthyosaur, m_flMaxSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CIchthyosaur, m_flMinSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CIchthyosaur, m_flMaxDist, FIELD_FLOAT ),
DEFINE_FIELD( CIchthyosaur, m_flNextAlert, FIELD_TIME ),
};
IMPLEMENT_SAVERESTORE( CIchthyosaur, CFlyingMonster );
const char *CIchthyosaur::pIdleSounds[] =
{
// CBaseEntity *m_pTarget;
float m_flDie;
Vector m_vecTarget;
float m_flNextHunt;
float m_flNextHit;
Vector m_posPrev;
EHANDLE m_hOwner;
int m_iMyClass;
};
float CSqueakGrenade::m_flNextBounceSoundTime = 0;
LINK_ENTITY_TO_CLASS( monster_snark, CSqueakGrenade )
TYPEDESCRIPTION CSqueakGrenade::m_SaveData[] =
{
DEFINE_FIELD( CSqueakGrenade, m_flDie, FIELD_TIME ),
DEFINE_FIELD( CSqueakGrenade, m_vecTarget, FIELD_VECTOR ),
DEFINE_FIELD( CSqueakGrenade, m_flNextHunt, FIELD_TIME ),
DEFINE_FIELD( CSqueakGrenade, m_flNextHit, FIELD_TIME ),
DEFINE_FIELD( CSqueakGrenade, m_posPrev, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CSqueakGrenade, m_hOwner, FIELD_EHANDLE ),
};
IMPLEMENT_SAVERESTORE( CSqueakGrenade, CGrenade )
#define SQUEEK_DETONATE_DELAY 15.0
int CSqueakGrenade :: Classify ( void )
{
if (m_iMyClass != 0)
return m_iMyClass; // protect against recursion
PRECACHE_SOUND ("weapons/grenade_hit2.wav");//grenade
PRECACHE_SOUND ("weapons/grenade_hit3.wav");//grenade
PRECACHE_SOUND ("weapons/bullet_hit1.wav"); // hit by bullet
PRECACHE_SOUND ("weapons/bullet_hit2.wav"); // hit by bullet
PRECACHE_SOUND ("items/weapondrop1.wav");// weapon falls to the ground
}
TYPEDESCRIPTION CBasePlayerItem::m_SaveData[] =
{
DEFINE_FIELD( CBasePlayerItem, m_pPlayer, FIELD_CLASSPTR ),
DEFINE_FIELD( CBasePlayerItem, m_pNext, FIELD_CLASSPTR ),
//DEFINE_FIELD( CBasePlayerItem, m_fKnown, FIELD_INTEGER ),Reset to zero on load
DEFINE_FIELD( CBasePlayerItem, m_iId, FIELD_INTEGER ),
// DEFINE_FIELD( CBasePlayerItem, m_iIdPrimary, FIELD_INTEGER ),
// DEFINE_FIELD( CBasePlayerItem, m_iIdSecondary, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CBasePlayerItem, CBaseAnimating );
TYPEDESCRIPTION CBasePlayerWeapon::m_SaveData[] =
{
#if defined( CLIENT_WEAPONS )
DEFINE_FIELD( CBasePlayerWeapon, m_flNextPrimaryAttack, FIELD_FLOAT ),
DEFINE_FIELD( CBasePlayerWeapon, m_flNextSecondaryAttack, FIELD_FLOAT ),
DEFINE_FIELD( CBasePlayerWeapon, m_flTimeWeaponIdle, FIELD_FLOAT ),
int m_iExplode;
int m_iBodyGibs;
float m_flGoalSpeed;
int m_iDoSmokePuff;
CBeam *m_pBeam;
// modif de Julien
BOOL m_bFlashLightOn;
};
LINK_ENTITY_TO_CLASS( monster_apache, CApache );
TYPEDESCRIPTION CApache::m_SaveData[] =
{
DEFINE_FIELD( CApache, m_iRockets, FIELD_INTEGER ),
DEFINE_FIELD( CApache, m_flForce, FIELD_FLOAT ),
DEFINE_FIELD( CApache, m_flNextRocket, FIELD_TIME ),
DEFINE_FIELD( CApache, m_vecTarget, FIELD_VECTOR ),
DEFINE_FIELD( CApache, m_posTarget, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CApache, m_vecDesired, FIELD_VECTOR ),
DEFINE_FIELD( CApache, m_posDesired, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CApache, m_vecGoal, FIELD_VECTOR ),
DEFINE_FIELD( CApache, m_angGun, FIELD_VECTOR ),
DEFINE_FIELD( CApache, m_flLastSeen, FIELD_TIME ),
DEFINE_FIELD( CApache, m_flPrevSeen, FIELD_TIME ),
// DEFINE_FIELD( CApache, m_iSoundState, FIELD_INTEGER ), // Don't save, precached
// DEFINE_FIELD( CApache, m_iSpriteTexture, FIELD_INTEGER ),
// DEFINE_FIELD( CApache, m_iExplode, FIELD_INTEGER ),
// DEFINE_FIELD( CApache, m_iBodyGibs, FIELD_INTEGER ),
DEFINE_FIELD( CApache, m_pBeam, FIELD_CLASSPTR ),
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
virtual int ObjectCaps( void ) { return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
static TYPEDESCRIPTION m_SaveData[];
int m_density;
int m_frequency;
int m_bubbleModel;
int m_state;
};
LINK_ENTITY_TO_CLASS( env_bubbles, CBubbling );
TYPEDESCRIPTION CBubbling::m_SaveData[] =
{
DEFINE_FIELD( CBubbling, m_density, FIELD_INTEGER ),
DEFINE_FIELD( CBubbling, m_frequency, FIELD_INTEGER ),
DEFINE_FIELD( CBubbling, m_state, FIELD_INTEGER ),
// Let spawn restore this!
// DEFINE_FIELD( CBubbling, m_bubbleModel, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CBubbling, CBaseEntity );
#define SF_BUBBLES_STARTOFF 0x0001
void CBubbling::Spawn( void )
{
Precache( );
SET_MODEL( ENT(pev), STRING(pev->model) ); // Set size
void SetActivity( Activity act );
inline Activity GetActivity( void ) { return m_Activity; }
virtual int ObjectCaps( void ) { return CBaseAnimating :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
private:
Activity m_Activity;
};
TYPEDESCRIPTION CActAnimating::m_SaveData[] =
{
DEFINE_FIELD( CActAnimating, m_Activity, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CActAnimating, CBaseAnimating );
void CActAnimating :: SetActivity( Activity act )
{
int sequence = LookupActivity( act );
if ( sequence != ACTIVITY_NOT_AVAILABLE )
{
pev->sequence = sequence;
m_Activity = act;
pev->frame = 0;
ResetSequenceInfo( );
}
}
GLOBALESTATE CGlobalState :: EntityGetState( string_t globalname )
{
globalentity_t *pEnt = Find( globalname );
if ( pEnt )
return pEnt->state;
return GLOBAL_OFF;
}
// Global Savedata for Delay
TYPEDESCRIPTION CGlobalState::m_SaveData[] =
{
DEFINE_FIELD( CGlobalState, m_listCount, FIELD_INTEGER ),
};
// Global Savedata for Delay
TYPEDESCRIPTION gGlobalEntitySaveData[] =
{
DEFINE_ARRAY( globalentity_t, name, FIELD_CHARACTER, 64 ),
DEFINE_ARRAY( globalentity_t, levelName, FIELD_CHARACTER, 32 ),
DEFINE_FIELD( globalentity_t, state, FIELD_INTEGER ),
};
int CGlobalState::Save( CSave &save )
{
int i;
globalentity_t *pEntity;
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[];
string_t m_globalstate;
int m_triggermode;
int m_initialstate;
};
TYPEDESCRIPTION CEnvGlobal::m_SaveData[] =
{
DEFINE_FIELD( CEnvGlobal, m_globalstate, FIELD_STRING ),
DEFINE_FIELD( CEnvGlobal, m_triggermode, FIELD_INTEGER ),
DEFINE_FIELD( CEnvGlobal, m_initialstate, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CEnvGlobal, CBaseEntity );
LINK_ENTITY_TO_CLASS( env_global, CEnvGlobal );
void CEnvGlobal::KeyValue( KeyValueData *pkvd )
{
pkvd->fHandled = TRUE;
if ( FStrEq(pkvd->szKeyName, "globalstate") ) // State name
m_globalstate = ALLOC_STRING( pkvd->szValue );
else if ( FStrEq(pkvd->szKeyName, "triggermode") )
private:
int m_iOnStyle; // style to use while on
int m_iOffStyle; // style to use while off
int m_iTurnOnStyle; // style to use while turning on
int m_iTurnOffStyle; // style to use while turning off
int m_iTurnOnTime; // time taken to turn on
int m_iTurnOffTime; // time taken to turn off
int m_iszPattern; // custom style to use while on
int m_iszCurrentStyle; // current style string
};
LINK_ENTITY_TO_CLASS( light, CLight );
LINK_ENTITY_TO_CLASS( light_spot, CLight );
TYPEDESCRIPTION CLight::m_SaveData[] =
{
DEFINE_FIELD( CLight, m_iState, FIELD_INTEGER ),
DEFINE_FIELD( CLight, m_iszPattern, FIELD_STRING ),
DEFINE_FIELD( CLight, m_iszCurrentStyle, FIELD_STRING ),
DEFINE_FIELD( CLight, m_iOnStyle, FIELD_INTEGER ),
DEFINE_FIELD( CLight, m_iOffStyle, FIELD_INTEGER ),
DEFINE_FIELD( CLight, m_iTurnOnStyle, FIELD_INTEGER ),
DEFINE_FIELD( CLight, m_iTurnOffStyle, FIELD_INTEGER ),
DEFINE_FIELD( CLight, m_iTurnOnTime, FIELD_INTEGER ),
DEFINE_FIELD( CLight, m_iTurnOffTime, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CLight, CBaseLogic );
//
// Cache user-entity-field values until spawn is called.
//
void CLight :: KeyValue( KeyValueData* pkvd)
void RunTask( Task_t *pTask );
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 );
EHANDLE m_hPlayer;
EHANDLE m_hTalkTarget;
float m_flTalkTime;
};
LINK_ENTITY_TO_CLASS( monster_gman, CGMan );
TYPEDESCRIPTION CGMan::m_SaveData[] =
{
DEFINE_FIELD( CGMan, m_hTalkTarget, FIELD_EHANDLE ),
DEFINE_FIELD( CGMan, m_flTalkTime, FIELD_TIME ),
};
IMPLEMENT_SAVERESTORE( CGMan, CBaseMonster );
//=========================================================
// Classify - indicates this monster's place in the
// relationship table.
//=========================================================
int CGMan :: Classify ( void )
{
return m_iClass?m_iClass:CLASS_NONE;
}
//=========================================================
Vector m_vecDir;
Vector m_vecEnd;
float m_flBeamLength;
EHANDLE m_hOwner;
CBeam *m_pBeam;
Vector m_posOwner;
Vector m_angleOwner;
edict_t *m_pRealOwner;// tracelines don't hit PEV->OWNER, which means a player couldn't detonate his own trip mine, so we store the owner here.
};
LINK_ENTITY_TO_CLASS( monster_tripmine, CTripmineGrenade );
TYPEDESCRIPTION CTripmineGrenade::m_SaveData[] =
{
DEFINE_FIELD( CTripmineGrenade, m_flPowerUp, FIELD_TIME ),
DEFINE_FIELD( CTripmineGrenade, m_vecDir, FIELD_VECTOR ),
DEFINE_FIELD( CTripmineGrenade, m_vecEnd, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CTripmineGrenade, m_flBeamLength, FIELD_FLOAT ),
DEFINE_FIELD( CTripmineGrenade, m_hOwner, FIELD_EHANDLE ),
DEFINE_FIELD( CTripmineGrenade, m_pBeam, FIELD_CLASSPTR ),
DEFINE_FIELD( CTripmineGrenade, m_posOwner, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( CTripmineGrenade, m_angleOwner, FIELD_VECTOR ),
DEFINE_FIELD( CTripmineGrenade, m_pRealOwner, FIELD_EDICT ),
};
IMPLEMENT_SAVERESTORE(CTripmineGrenade,CGrenade);
void CTripmineGrenade :: Spawn( void )
{
Vector m_vecEstVelocity;
Vector m_velocity;
int m_fInCombat;
};
LINK_ENTITY_TO_CLASS(monster_alien_controller, CController);
TYPEDESCRIPTION CController::m_SaveData[] =
{
DEFINE_ARRAY(CController, m_pBall, FIELD_CLASSPTR, 2),
DEFINE_ARRAY(CController, m_iBall, FIELD_INTEGER, 2),
DEFINE_ARRAY(CController, m_iBallTime, FIELD_TIME, 2),
DEFINE_ARRAY(CController, m_iBallCurrent, FIELD_INTEGER, 2),
DEFINE_FIELD(CController, m_vecEstVelocity, FIELD_VECTOR),
};
IMPLEMENT_SAVERESTORE(CController, CSquadMonster);
const char *CController::pAttackSounds[] =
{
"controller/con_attack1.wav",
"controller/con_attack2.wav",
"controller/con_attack3.wav",
};
const char *CController::pIdleSounds[] =
{
"controller/con_idle1.wav",
"controller/con_idle2.wav",
"controller/con_idle3.wav",
virtual int Save(CSave &save);
virtual int Restore(CRestore &restore);
static TYPEDESCRIPTION m_SaveData[];
virtual int ObjectCaps(void) { return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
float m_flAttenuation; // attenuation value
dynpitchvol_t m_dpv;
BOOL m_fActive; // only TRUE when the entity is playing a looping sound
BOOL m_fLooping; // TRUE when the sound played will loop
};
LINK_ENTITY_TO_CLASS(ambient_generic, CAmbientGeneric);
TYPEDESCRIPTION CAmbientGeneric::m_SaveData[] =
{
DEFINE_FIELD(CAmbientGeneric, m_flAttenuation, FIELD_FLOAT),
DEFINE_FIELD(CAmbientGeneric, m_fActive, FIELD_BOOLEAN),
DEFINE_FIELD(CAmbientGeneric, m_fLooping, FIELD_BOOLEAN),
// HACKHACK - This is not really in the spirit of the save/restore design, but save this
// out as a binary data block. If the dynpitchvol_t is changed, old saved games will NOT
// load these correctly, so bump the save/restore version if you change the size of the struct
// The right way to do this is to split the input parms (read in keyvalue) into members and re-init this
// struct in Precache(), but it's unlikely that the struct will change, so it's not worth the time right now.
DEFINE_ARRAY(CAmbientGeneric, m_dpv, FIELD_CHARACTER, sizeof(dynpitchvol_t)),
};
IMPLEMENT_SAVERESTORE(CAmbientGeneric, CBaseEntity);
//
// ambient_generic - general-purpose user-defined static sound
#include "precompiled.h"
/*
* Globals initialization
*/
#ifndef HOOK_GAMEDLL
TYPEDESCRIPTION CAirtank::m_SaveData[] =
{
DEFINE_FIELD(CAirtank, m_state, FIELD_INTEGER)
};
#endif
LINK_ENTITY_TO_CLASS(item_airtank, CAirtank, CCSAirtank);
IMPLEMENT_SAVERESTORE(CAirtank, CGrenade);
void CAirtank::__MAKE_VHOOK(Spawn)()
{
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));
UTIL_SetOrigin(pev, pev->origin);
SetTouch(&CAirtank::TankTouch);
SetThink(&CAirtank::TankThink);
#include "precompiled.h"
/*
* Globals initialization
*/
#ifndef HOOK_GAMEDLL
TYPEDESCRIPTION CFuncRotating::m_SaveData[] =
{
DEFINE_FIELD(CFuncRotating, m_flFanFriction, FIELD_FLOAT),
DEFINE_FIELD(CFuncRotating, m_flAttenuation, FIELD_FLOAT),
DEFINE_FIELD(CFuncRotating, m_flVolume, FIELD_FLOAT),
DEFINE_FIELD(CFuncRotating, m_pitch, FIELD_FLOAT),
DEFINE_FIELD(CFuncRotating, m_sounds, FIELD_INTEGER)
};
TYPEDESCRIPTION CPendulum::m_SaveData[] =
{
DEFINE_FIELD(CPendulum, m_accel, FIELD_FLOAT),
DEFINE_FIELD(CPendulum, m_distance, FIELD_FLOAT),
DEFINE_FIELD(CPendulum, m_time, FIELD_TIME),
DEFINE_FIELD(CPendulum, m_damp, FIELD_FLOAT),
DEFINE_FIELD(CPendulum, m_maxSpeed, FIELD_FLOAT),
DEFINE_FIELD(CPendulum, m_dampSpeed, FIELD_FLOAT),
DEFINE_FIELD(CPendulum, m_center, FIELD_VECTOR),
DEFINE_FIELD(CPendulum, m_start, FIELD_VECTOR),
};
#else
TYPEDESCRIPTION IMPLEMENT_ARRAY_CLASS(CFuncRotating, m_SaveData)[5];
static TYPEDESCRIPTION m_SaveData[];
CUSTOM_SCHEDULES;
private:
float m_painTime;
float m_healTime;
float m_fearTime;
};
LINK_ENTITY_TO_CLASS( monster_scientist, CScientist );
LINK_ENTITY_TO_CLASS( monster_rosenberg, CScientist );
TYPEDESCRIPTION CScientist::m_SaveData[] =
{
DEFINE_FIELD( CScientist, m_painTime, FIELD_TIME ),
DEFINE_FIELD( CScientist, m_healTime, FIELD_TIME ),
DEFINE_FIELD( CScientist, m_fearTime, FIELD_TIME ),
};
IMPLEMENT_SAVERESTORE( CScientist, CTalkMonster );
//=========================================================
// AI Schedules Specific to this monster
//=========================================================
Task_t tlFollow[] =
{
{ TASK_SET_FAIL_SCHEDULE, (float)SCHED_CANT_FOLLOW }, // If you fail, bail out of follow
{ TASK_MOVE_TO_TARGET_RANGE,(float)128 }, // Move within 128 of target ent (client)
// { TASK_SET_SCHEDULE, (float)SCHED_TARGET_FACE },
};
#include "precompiled.h"
/*
* Globals initialization
*/
#ifndef HOOK_GAMEDLL
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_flSoundTime, FIELD_TIME),
};
#else
TYPEDESCRIPTION IMPL_CLASS(CRecharge, m_SaveData)[5];
#endif // HOOK_GAMEDLL
/* <c61e2> ../cstrike/dlls/h_battery.cpp:61 */
IMPLEMENT_SAVERESTORE(CRecharge, CBaseEntity);
/* <c65cc> ../cstrike/dlls/h_battery.cpp:63 */
LINK_ENTITY_TO_CLASS(func_recharge, CRecharge);
/* <c648b> ../cstrike/dlls/h_battery.cpp:66 */
void CRecharge::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
{
