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) {