text: /***
  *
  *	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
  *	
  *	This product contains software technology licensed from Id 
  *	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
  *	All Rights Reserved.
  *
  *   Use, distribution, and modification of this source code and/or resulting
  *   object code is restricted to non-commercial enhancements to products from
  *   Valve LLC.  All other use, distribution, or modification is prohibited
  *   without written permission from Valve LLC.
  *
  ****/
  
  /*
  ==========================
  This file contains "stubs" of class member implementations so that we can predict certain
   weapons client side.  From time to time you might find that you need to implement part of the
   these functions.  If so, cut it from here, paste it in hl_weapons.cpp or somewhere else and
   add in the functionality you need.
  ==========================
  */
  #include	"extdll.h"
  #include	"util.h"
  #include	"cbase.h"
  #include	"player.h"
  #include	"weapons.h"
  #include	"nodes.h"
  #include	"soundent.h"
  #include	"skill.h"
  
  // Globals used by game logic
  const Vector g_vecZero = Vector( 0, 0, 0 );
  int gmsgWeapPickup = 0;
  enginefuncs_t g_engfuncs;
  globalvars_t  *gpGlobals;
  
  ItemInfo CBasePlayerItem::ItemInfoArray[MAX_WEAPONS];
  
  void EMIT_SOUND_DYN(edict_t *entity, int channel, const char *sample, float volume, float attenuation, int flags, int pitch) { }
  
  // CBaseEntity Stubs
  int CBaseEntity :: TakeHealth( float flHealth, int bitsDamageType ) { return 1; }
  int CBaseEntity :: TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType ) { return 1; }
  CBaseEntity *CBaseEntity::GetNextTarget( void ) { return NULL; }
  int CBaseEntity::Save( CSave &save ) { return 1; }
  int CBaseEntity::Restore( CRestore &restore ) { return 1; }
  void CBaseEntity::SetObjectCollisionBox( void ) { }
  int	CBaseEntity :: Intersects( CBaseEntity *pOther ) { return 0; }
  void CBaseEntity :: MakeDormant( void ) { }
  int CBaseEntity :: IsDormant( void ) { return 0; }
  BOOL CBaseEntity :: IsInWorld( void ) { return TRUE; }
  int CBaseEntity::ShouldToggle( USE_TYPE useType, BOOL currentState ) { return 0; }
  int	CBaseEntity :: DamageDecal( int bitsDamageType ) { return -1; }
  CBaseEntity * CBaseEntity::Create( const char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner ) { return NULL; }
  void CBaseEntity::SUB_Remove( void ) { }
  
  // CBaseDelay Stubs
  void CBaseDelay :: KeyValue( struct KeyValueData_s * ) { }
  int CBaseDelay::Restore( class CRestore & ) { return 1; }
  int CBaseDelay::Save( class CSave & ) { return 1; }
  
  // CBaseAnimating Stubs
  int CBaseAnimating::Restore( class CRestore & ) { return 1; }
  int CBaseAnimating::Save( class CSave & ) { return 1; }
  
  // DEBUG Stubs
  edict_t *DBG_EntOfVars( const entvars_t *pev ) { return NULL; }
  void DBG_AssertFunction(BOOL fExpr,	const char*	szExpr,	const char*	szFile,	int szLine,	const char*	szMessage) { }
  
  // UTIL_* Stubs
  void UTIL_PrecacheOther( const char *szClassname ) { }
  void UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount ) { }
  void UTIL_DecalTrace( TraceResult *pTrace, int decalNumber ) { }
  void UTIL_GunshotDecalTrace( TraceResult *pTrace, int decalNumber ) { }
  void UTIL_MakeVectors( const Vector &vecAngles ) { }
  BOOL UTIL_IsValidEntity( edict_t *pent ) { return TRUE; }
  void UTIL_SetOrigin( entvars_t *, const Vector &org ) { }
  BOOL UTIL_GetNextBestWeapon( CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon ) { return TRUE; }
  void UTIL_LogPrintf(char *,...) { }
  void UTIL_ClientPrintAll( int,char const *,char const *,char const *,char const *,char const *) { }
  void ClientPrint( entvars_t *client, int msg_dest, const char *msg_name, const char *param1, const char *param2, const char *param3, const char *param4 ) { }
  
  // CBaseToggle Stubs
  int CBaseToggle::Restore( class CRestore & ) { return 1; }
  int CBaseToggle::Save( class CSave & ) { return 1; }
  void CBaseToggle :: KeyValue( struct KeyValueData_s * ) { }
  
  // CGrenade Stubs
  void CGrenade::BounceSound( void ) { }
  void CGrenade::Explode( Vector, Vector ) { }
  void CGrenade::Explode( TraceResult *, int ) { }
  void CGrenade::Killed( entvars_t *, int ) { }
  void CGrenade::Spawn( void ) { }
  CGrenade * CGrenade:: ShootTimed( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time ){ return 0; }
  CGrenade *CGrenade::ShootContact( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity ){ return 0; }
  void CGrenade::DetonateUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ){ }
  
  void UTIL_Remove( CBaseEntity *pEntity ){ }
  struct skilldata_t  gSkillData;
  void UTIL_SetSize( entvars_t *pev, const Vector &vecMin, const Vector &vecMax ){ }
  CBaseEntity *UTIL_FindEntityInSphere( CBaseEntity *pStartEntity, const Vector &vecCenter, float flRadius ){ return 0;}
  
  Vector UTIL_VecToAngles( const Vector &vec ){ return 0; }
  CSprite *CSprite::SpriteCreate( const char *pSpriteName, const Vector &origin, BOOL animate ) { return 0; }
  void CBeam::PointEntInit( const Vector &start, int endIndex ) { }
  CBeam *CBeam::BeamCreate( const char *pSpriteName, int width ) { return NULL; }
  void CSprite::Expand( float scaleSpeed, float fadeSpeed ) { }
  
  
  CBaseEntity* CBaseMonster :: CheckTraceHullAttack( float flDist, int iDamage, int iDmgType ) { return NULL; }
  void CBaseMonster :: Eat ( float flFullDuration ) { }
  BOOL CBaseMonster :: FShouldEat ( void ) { return TRUE; }
  void CBaseMonster :: BarnacleVictimBitten ( entvars_t *pevBarnacle ) { }
  void CBaseMonster :: BarnacleVictimReleased ( void ) { }
  void CBaseMonster :: Listen ( void ) { }
  float CBaseMonster :: FLSoundVolume ( CSound *pSound ) { return 0.0; }
  BOOL CBaseMonster :: FValidateHintType ( short sHint ) { return FALSE; }
  void CBaseMonster :: Look ( int iDistance ) { }
  int CBaseMonster :: ISoundMask ( void ) { return 0; }
  CSound* CBaseMonster :: PBestSound ( void ) { return NULL; }
  CSound* CBaseMonster :: PBestScent ( void ) { return NULL; } 
  float CBaseAnimating :: StudioFrameAdvance ( float flInterval ) { return 0.0; }
  void CBaseMonster :: MonsterThink ( void ) { }
  void CBaseMonster :: MonsterUse ( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { }
  int CBaseMonster :: IgnoreConditions ( void ) { return 0; }
  void CBaseMonster :: RouteClear ( void ) { }
  void CBaseMonster :: RouteNew ( void ) { }
  BOOL CBaseMonster :: FRouteClear ( void ) { return FALSE; }
  BOOL CBaseMonster :: FRefreshRoute ( void ) { return 0; }
  BOOL CBaseMonster::MoveToEnemy( Activity movementAct, float waitTime ) { return FALSE; }
  BOOL CBaseMonster::MoveToLocation( Activity movementAct, float waitTime, const Vector &goal ) { return FALSE; }
  BOOL CBaseMonster::MoveToTarget( Activity movementAct, float waitTime ) { return FALSE; }
  BOOL CBaseMonster::MoveToNode( Activity movementAct, float waitTime, const Vector &goal ) { return FALSE; }
  int ShouldSimplify( int routeType ) { return TRUE; }
  void CBaseMonster :: RouteSimplify( CBaseEntity *pTargetEnt ) { }
  BOOL CBaseMonster :: FBecomeProne ( void ) { return TRUE; }
  BOOL CBaseMonster :: CheckRangeAttack1 ( float flDot, float flDist ) { return FALSE; }
  BOOL CBaseMonster :: CheckRangeAttack2 ( float flDot, float flDist ) { return FALSE; }
  BOOL CBaseMonster :: CheckMeleeAttack1 ( float flDot, float flDist ) { return FALSE; }
  BOOL CBaseMonster :: CheckMeleeAttack2 ( float flDot, float flDist ) { return FALSE; }
  void CBaseMonster :: CheckAttacks ( CBaseEntity *pTarget, float flDist ) { }
  BOOL CBaseMonster :: FCanCheckAttacks ( void ) { return FALSE; }
  int CBaseMonster :: CheckEnemy ( CBaseEntity *pEnemy ) { return 0; }
  void CBaseMonster :: PushEnemy( CBaseEntity *pEnemy, Vector &vecLastKnownPos ) { }
  BOOL CBaseMonster :: PopEnemy( ) { return FALSE; }
  void CBaseMonster :: SetActivity ( Activity NewActivity ) { }
  void CBaseMonster :: SetSequenceByName ( const char *szSequence ) { }
  int CBaseMonster :: CheckLocalMove ( const Vector &vecStart, const Vector &vecEnd, CBaseEntity *pTarget, float *pflDist ) { return 0; }
  float CBaseMonster :: OpenDoorAndWait( entvars_t *pevDoor ) { return 0.0; }
  void CBaseMonster :: AdvanceRoute ( float distance ) { }
  int CBaseMonster :: RouteClassify( int iMoveFlag ) { return 0; }
  BOOL CBaseMonster :: BuildRoute ( const Vector &vecGoal, int iMoveFlag, CBaseEntity *pTarget ) { return FALSE; }
  void CBaseMonster :: InsertWaypoint ( Vector vecLocation, int afMoveFlags ) { }
  BOOL CBaseMonster :: FTriangulate ( const Vector &vecStart , const Vector &vecEnd, float flDist, CBaseEntity *pTargetEnt, Vector *pApex ) { return FALSE; }
  void CBaseMonster :: Move ( float flInterval ) { }
  BOOL CBaseMonster:: ShouldAdvanceRoute( float flWaypointDist ) { return FALSE; }
  void CBaseMonster::MoveExecute( CBaseEntity *pTargetEnt, const Vector &vecDir, float flInterval ) { }
  void CBaseMonster :: MonsterInit ( void ) { }
  void CBaseMonster :: MonsterInitThink ( void ) { }
  void CBaseMonster :: StartMonster ( void ) { }
  void CBaseMonster :: MovementComplete( void ) { }
  int CBaseMonster::TaskIsRunning( void ) { return 0; }
  int CBaseMonster::IRelationship ( CBaseEntity *pTarget ) { return 0; }
  BOOL CBaseMonster :: FindCover ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist ) { return FALSE; }
  BOOL CBaseMonster :: BuildNearestRoute ( Vector vecThreat, Vector vecViewOffset, float flMinDist, float flMaxDist ) { return FALSE; }
  CBaseEntity *CBaseMonster :: BestVisibleEnemy ( void ) { return NULL; }
  BOOL CBaseMonster :: FInViewCone ( CBaseEntity *pEntity ) { return FALSE; }
  BOOL CBaseMonster :: FInViewCone ( Vector *pOrigin ) { return FALSE; }
  BOOL CBaseEntity :: FVisible ( CBaseEntity *pEntity ) { return FALSE; }
  BOOL CBaseEntity :: FVisible ( const Vector &vecOrigin ) { return FALSE; }
  void CBaseMonster :: MakeIdealYaw( Vector vecTarget ) { }
  float	CBaseMonster::FlYawDiff ( void ) { return 0.0; }
  float CBaseMonster::ChangeYaw ( int yawSpeed ) { return 0; }
  float	CBaseMonster::VecToYaw ( Vector vecDir ) { return 0.0; }
  int CBaseAnimating :: LookupActivity ( int activity ) { return 0; }
  int CBaseAnimating :: LookupActivityHeaviest ( int activity ) { return 0; }
  void CBaseMonster :: SetEyePosition ( void ) { }
  int CBaseAnimating :: LookupSequence ( const char *label ) { return 0; }
  void CBaseAnimating :: ResetSequenceInfo ( ) { }
  BOOL CBaseAnimating :: GetSequenceFlags( ) { return FALSE; }
  void CBaseAnimating :: DispatchAnimEvents ( float flInterval ) { }
  void CBaseMonster :: HandleAnimEvent( MonsterEvent_t *pEvent ) { }
  float CBaseAnimating :: SetBoneController ( int iController, float flValue ) { return 0.0; }
  void CBaseAnimating :: InitBoneControllers ( void ) { }
  float CBaseAnimating :: SetBlending ( int iBlender, float flValue ) { return 0; }
  void CBaseAnimating :: GetBonePosition ( int iBone, Vector &origin, Vector &angles ) { }
  void CBaseAnimating :: GetAttachment ( int iAttachment, Vector &origin, Vector &angles ) { }
  int CBaseAnimating :: FindTransition( int iEndingSequence, int iGoalSequence, int *piDir ) { return -1; }
  void CBaseAnimating :: GetAutomovement( Vector &origin, Vector &angles, float flInterval ) { }
  void CBaseAnimating :: SetBodygroup( int iGroup, int iValue ) { }
  int CBaseAnimating :: GetBodygroup( int iGroup ) { return 0; }
  Vector CBaseMonster :: GetGunPosition( void ) { return g_vecZero; }
  void CBaseEntity::TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
  void CBaseEntity::FireBullets(ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq, int iDamage, entvars_t *pevAttacker ) { }
  void CBaseEntity :: TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType ) { }
  void CBaseMonster :: MakeDamageBloodDecal ( int cCount, float flNoise, TraceResult *ptr, const Vector &vecDir ) { }
  BOOL CBaseMonster :: FGetNodeRoute ( Vector vecDest ) { return TRUE; }
  int CBaseMonster :: FindHintNode ( void ) { return NO_NODE; }
  void CBaseMonster::ReportAIState( void ) { }
  void CBaseMonster :: KeyValue( KeyValueData *pkvd ) { }
  BOOL CBaseMonster :: FCheckAITrigger ( void ) { return FALSE; }
  int CBaseMonster :: CanPlaySequence( BOOL fDisregardMonsterState, int interruptLevel ) { return FALSE; }
  BOOL CBaseMonster :: FindLateralCover ( const Vector &vecThreat, const Vector &vecViewOffset ) { return FALSE; }
  Vector CBaseMonster :: ShootAtEnemy( const Vector &shootOrigin ) { return g_vecZero; }
  BOOL CBaseMonster :: FacingIdeal( void ) { return FALSE; }
  BOOL CBaseMonster :: FCanActiveIdle ( void ) { return FALSE; }
  void CBaseMonster::PlaySentence( const char *pszSentence, float duration, float volume, float attenuation ) { }
  void CBaseMonster::PlayScriptedSentence( const char *pszSentence, float duration, float volume, float attenuation, BOOL bConcurrent, CBaseEntity *pListener ) { }
  void CBaseMonster::SentenceStop( void ) { }
  void CBaseMonster::CorpseFallThink( void ) { }
  void CBaseMonster :: MonsterInitDead( void ) { }
  BOOL CBaseMonster :: BBoxFlat ( void ) { return TRUE; }
  BOOL CBaseMonster :: GetEnemy ( void ) { return FALSE; }
  void CBaseMonster :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
  CBaseEntity* CBaseMonster :: DropItem ( const char *pszItemName, const Vector &vecPos, const Vector &vecAng ) { return NULL; }
  BOOL CBaseMonster :: ShouldFadeOnDeath( void ) { return FALSE; }
  void CBaseMonster :: RadiusDamage(entvars_t* pevInflictor, entvars_t*	pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
  void CBaseMonster :: RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int iClassIgnore, int bitsDamageType ) { }
  void CBaseMonster::FadeMonster( void ) { }
  void CBaseMonster :: GibMonster( void ) { }
  BOOL CBaseMonster :: HasHumanGibs( void ) { return FALSE; }
  BOOL CBaseMonster :: HasAlienGibs( void ) { return FALSE; }
  Activity CBaseMonster :: GetDeathActivity ( void ) { return ACT_DIE_HEADSHOT; }
  MONSTERSTATE CBaseMonster :: GetIdealState ( void ) { return MONSTERSTATE_ALERT; }
  Schedule_t* CBaseMonster :: GetScheduleOfType ( int Type ) { return NULL; }
  Schedule_t *CBaseMonster :: GetSchedule ( void ) { return NULL; }
  void CBaseMonster :: RunTask ( Task_t *pTask ) { }
  void CBaseMonster :: StartTask ( Task_t *pTask ) { }
  Schedule_t *CBaseMonster::ScheduleFromName( const char *pName ) { return NULL;}
  void CBaseMonster::BecomeDead( void ) {}
  void CBaseMonster :: RunAI ( void ) {}
  void CBaseMonster :: Killed( entvars_t *pevAttacker, int iGib ) {}
  int CBaseMonster :: TakeHealth (float flHealth, int bitsDamageType) { return 0; }
  int CBaseMonster :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
  int CBaseMonster::Restore( class CRestore & ) { return 1; }
  int CBaseMonster::Save( class CSave & ) { return 1; }
  
  int TrainSpeed(int iSpeed, int iMax) { 	return 0; }
  void CBasePlayer :: DeathSound( void ) { }
  int CBasePlayer :: TakeHealth( float flHealth, int bitsDamageType ) { return 0; }
  void CBasePlayer :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType) { }
  int CBasePlayer :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { return 0; }
  void CBasePlayer::PackDeadPlayerItems( void ) { }
  void CBasePlayer::RemoveAllItems( BOOL removeSuit ) { }
  void CBasePlayer::SetAnimation( PLAYER_ANIM playerAnim ) { }
  void CBasePlayer::WaterMove() { }
  BOOL CBasePlayer::IsOnLadder( void ) { return FALSE; }
  void CBasePlayer::PlayerDeathThink(void) { }
  void CBasePlayer::StartDeathCam( void ) { }
  void CBasePlayer::StartObserver( Vector vecPosition, Vector vecViewAngle ) { }
  void CBasePlayer::PlayerUse ( void ) { }
  void CBasePlayer::Jump() { }
  void CBasePlayer::Duck( ) { }
  int  CBasePlayer::Classify ( void ) { return 0; }
  void CBasePlayer::PreThink(void) { }
  void CBasePlayer::CheckTimeBasedDamage()  { }
  void CBasePlayer :: UpdateGeigerCounter( void ) { }
  void CBasePlayer::CheckSuitUpdate() { }
  void CBasePlayer::SetSuitUpdate(const char *name, int fgroup, int iNoRepeatTime) { }
  void CBasePlayer :: UpdatePlayerSound ( void ) { }
  void CBasePlayer::PostThink() { }
  void CBasePlayer :: Precache( void ) { }
  int CBasePlayer::Save( CSave &save ) { return 0; }
  void CBasePlayer::RenewItems(void) { }
  int CBasePlayer::Restore( CRestore &restore ) { return 0; }
  void CBasePlayer::SelectNextItem( int iItem ) { }
  BOOL CBasePlayer::HasWeapons( void ) { return FALSE; }
  void CBasePlayer::SelectPrevItem( int iItem ) { }
  CBaseEntity *FindEntityForward( CBaseEntity *pMe ) { return NULL; }
  BOOL CBasePlayer :: FlashlightIsOn( void ) { return FALSE; }
  void CBasePlayer :: FlashlightTurnOn( void ) { }
  void CBasePlayer :: FlashlightTurnOff( void ) { }
  void CBasePlayer :: ForceClientDllUpdate( void ) { }
  void CBasePlayer::ImpulseCommands( ) { }
  void CBasePlayer::CheatImpulseCommands( int iImpulse ) { }
  int CBasePlayer::AddPlayerItem( CBasePlayerItem *pItem ) { return FALSE; }
  int CBasePlayer::RemovePlayerItem( CBasePlayerItem *pItem ) { return FALSE; }
  void CBasePlayer::ItemPreFrame() { }
  void CBasePlayer::ItemPostFrame() { }
  int CBasePlayer::AmmoInventory( int iAmmoIndex ) { return -1; }
  int CBasePlayer::GetAmmoIndex(const char *psz) { return -1; }
  void CBasePlayer::SendAmmoUpdate(void) { }
  void CBasePlayer :: UpdateClientData( void ) { }
  BOOL CBasePlayer :: FBecomeProne ( void ) { return TRUE; }
  void CBasePlayer :: BarnacleVictimBitten ( entvars_t *pevBarnacle ) { }
  void CBasePlayer :: BarnacleVictimReleased ( void ) { }
  int CBasePlayer :: Illumination( void ) { return 0; }
  void CBasePlayer :: EnableControl(BOOL fControl) { }
  Vector CBasePlayer :: GetAutoaimVector( float flDelta ) { return g_vecZero; }
  Vector CBasePlayer :: AutoaimDeflection( Vector &vecSrc, float flDist, float flDelta  ) { return g_vecZero; }
  void CBasePlayer :: ResetAutoaim( ) { }
  void CBasePlayer :: SetCustomDecalFrames( int nFrames ) { }
  int CBasePlayer :: GetCustomDecalFrames( void ) { return -1; }
  void CBasePlayer::DropPlayerItem ( char *pszItemName ) { }
  BOOL CBasePlayer::HasPlayerItem( CBasePlayerItem *pCheckItem ) { return FALSE; }
  BOOL CBasePlayer :: SwitchWeapon( CBasePlayerItem *pWeapon )  { return FALSE; }
  Vector CBasePlayer :: GetGunPosition( void ) { return g_vecZero; }
  const char *CBasePlayer::TeamID( void ) { return ""; }
  int CBasePlayer :: GiveAmmo( int iCount, const char *szName, int iMax ) { return 0; }
  void CBasePlayer::AddPoints( int score, BOOL bAllowNegativeScore ) { } 
  void CBasePlayer::AddPointsToTeam( int score, BOOL bAllowNegativeScore ) { } 
  
  void ClearMultiDamage(void) { }
  void ApplyMultiDamage(entvars_t *pevInflictor, entvars_t *pevAttacker ) { }
  void AddMultiDamage( entvars_t *pevInflictor, CBaseEntity *pEntity, float flDamage, int bitsDamageType) { }
  void SpawnBlood(Vector vecSpot, int bloodColor, float flDamage) { }
  int DamageDecal( CBaseEntity *pEntity, int bitsDamageType ) { return 0; }
  void DecalGunshot( TraceResult *pTrace, int iBulletType ) { }
  void EjectBrass ( const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype ) { }
  void AddAmmoNameToAmmoRegistry( const char *szAmmoname ) { }
  int CBasePlayerItem::Restore( class CRestore & ) { return 1; }
  int CBasePlayerItem::Save( class CSave & ) { return 1; }
  int CBasePlayerWeapon::Restore( class CRestore & ) { return 1; }
  int CBasePlayerWeapon::Save( class CSave & ) { return 1; }
  float CBasePlayerWeapon::GetNextAttackDelay( float flTime ) { return flTime; }
  void CBasePlayerItem :: SetObjectCollisionBox( void ) { }
  void CBasePlayerItem :: FallInit( void ) { }
  void CBasePlayerItem::FallThink ( void ) { }
  void CBasePlayerItem::Materialize( void ) { }
  void CBasePlayerItem::AttemptToMaterialize( void ) { }
  void CBasePlayerItem :: CheckRespawn ( void ) { }
  CBaseEntity* CBasePlayerItem::Respawn( void ) { return NULL; }
  void CBasePlayerItem::DefaultTouch( CBaseEntity *pOther ) { }
  void CBasePlayerItem::DestroyItem( void ) { }
  int CBasePlayerItem::AddToPlayer( CBasePlayer *pPlayer ) { return TRUE; }
  void CBasePlayerItem::Drop( void ) { }
  void CBasePlayerItem::Kill( void ) { }
  void CBasePlayerItem::Holster( int skiplocal ) { }
  void CBasePlayerItem::AttachToPlayer ( CBasePlayer *pPlayer ) { }
  int CBasePlayerWeapon::AddDuplicate( CBasePlayerItem *pOriginal ) { return 0; }
  int CBasePlayerWeapon::AddToPlayer( CBasePlayer *pPlayer ) { return FALSE; }
  int CBasePlayerWeapon::UpdateClientData( CBasePlayer *pPlayer ) { return 0; }
  BOOL CBasePlayerWeapon :: AddPrimaryAmmo( int iCount, char *szName, int iMaxClip, int iMaxCarry ) { return TRUE; }
  BOOL CBasePlayerWeapon :: AddSecondaryAmmo( int iCount, char *szName, int iMax ) { return TRUE; }
  BOOL CBasePlayerWeapon :: IsUseable( void ) { return TRUE; }
  int CBasePlayerWeapon::PrimaryAmmoIndex( void ) { return -1; }
  int CBasePlayerWeapon::SecondaryAmmoIndex( void ) {	return -1; }
  void CBasePlayerAmmo::Spawn( void ) { }
  CBaseEntity* CBasePlayerAmmo::Respawn( void ) { return this; }
  void CBasePlayerAmmo::Materialize( void ) { }
  void CBasePlayerAmmo :: DefaultTouch( CBaseEntity *pOther ) { }
  int CBasePlayerWeapon::ExtractAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }
  int CBasePlayerWeapon::ExtractClipAmmo( CBasePlayerWeapon *pWeapon ) { return 0; }	
  void CBasePlayerWeapon::RetireWeapon( void ) { }
  void CSoundEnt::InsertSound ( int iType, const Vector &vecOrigin, int iVolume, float flDuration ) {}
  void RadiusDamage( Vector vecSrc, entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, float flRadius, int iClassIgnore, int bitsDamageType ){}
  