Moved modified HL SDK to trunk
This commit is contained in:
Scott Ehlert
330
hlsdk/dmc/cl_dll/quake/quake_baseentity.cpp
Normal file
330
hlsdk/dmc/cl_dll/quake/quake_baseentity.cpp
Normal file
@ -0,0 +1,330 @@
|
||||
/***
|
||||
*
|
||||
* 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"
|
||||
|
||||
// Globals used by game logic
|
||||
const Vector g_vecZero = Vector( 0, 0, 0 );
|
||||
int gmsgWeapPickup = 0;
|
||||
enginefuncs_t g_engfuncs;
|
||||
globalvars_t *gpGlobals;
|
||||
|
||||
short g_sModelIndexLaser;
|
||||
|
||||
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( 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 ) { }
|
||||
|
||||
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 ( 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 ( 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::CheckAmmo(void) { }
|
||||
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::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 :: PlayStepSound(int step, float fvol) { }
|
||||
void CBasePlayer :: UpdateStepSound( void ) { }
|
||||
void CBasePlayer::PreThink(void) { }
|
||||
void CBasePlayer::CheckTimeBasedDamage() { }
|
||||
void CBasePlayer :: UpdateGeigerCounter( void ) { }
|
||||
void CBasePlayer::CheckSuitUpdate() { }
|
||||
void CBasePlayer::SetSuitUpdate(char *name, int fgroup, int iNoRepeatTime) { }
|
||||
void CBasePlayer::PostThink() { }
|
||||
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, 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; }
|
||||
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 ) { }
|
||||
83
hlsdk/dmc/cl_dll/quake/quake_events.cpp
Normal file
83
hlsdk/dmc/cl_dll/quake/quake_events.cpp
Normal file
@ -0,0 +1,83 @@
|
||||
/***
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
****/
|
||||
#include "../hud.h"
|
||||
#include "../cl_util.h"
|
||||
#include "event_api.h"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
// Deathmatch Classic
|
||||
void EV_FireShotGunSingle( struct event_args_s *args );
|
||||
void EV_FireShotGunDouble( struct event_args_s *args );
|
||||
void EV_FireAxe( struct event_args_s *args );
|
||||
void EV_FireAxeSwing( struct event_args_s *args );
|
||||
void EV_FireRocket( struct event_args_s *args );
|
||||
void EV_FireLightning( struct event_args_s *args );
|
||||
void EV_FireSpike( struct event_args_s *args );
|
||||
void EV_FireSuperSpike( struct event_args_s *args );
|
||||
void EV_FireGrenade( struct event_args_s *args );
|
||||
void EV_Gibbed (struct event_args_s *args );
|
||||
void EV_Teleport (struct event_args_s *args );
|
||||
void EV_Trail (struct event_args_s *args );
|
||||
void EV_Explosion (struct event_args_s *args );
|
||||
void EV_PlayerPowerup ( struct event_args_s *args );
|
||||
|
||||
void EV_DMC_DoorGoUp( struct event_args_s *args );
|
||||
void EV_DMC_DoorGoDown( struct event_args_s *args );
|
||||
void EV_DMC_DoorHitTop( struct event_args_s *args );
|
||||
void EV_DMC_DoorHitBottom( struct event_args_s *args );
|
||||
|
||||
// HLDM
|
||||
void EV_TrainPitchAdjust( struct event_args_s *args );
|
||||
}
|
||||
|
||||
/*
|
||||
======================
|
||||
Game_HookEvents
|
||||
|
||||
Associate script file name with callback functions. Callback's must be extern "C" so
|
||||
the engine doesn't get confused about name mangling stuff. Note that the format is
|
||||
always the same. Of course, a clever mod team could actually embed parameters, behavior
|
||||
into the actual .sc files and create a .sc file parser and hook their functionality through
|
||||
that.. i.e., a scripting system.
|
||||
|
||||
That was what we were going to do, but we ran out of time...oh well.
|
||||
======================
|
||||
*/
|
||||
void Game_HookEvents( void )
|
||||
{
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun1.sc", EV_FireShotGunSingle );
|
||||
gEngfuncs.pfnHookEvent( "events/shotgun2.sc", EV_FireShotGunDouble );
|
||||
gEngfuncs.pfnHookEvent( "events/axe.sc", EV_FireAxe );
|
||||
gEngfuncs.pfnHookEvent( "events/axeswing.sc", EV_FireAxeSwing );
|
||||
gEngfuncs.pfnHookEvent( "events/rocket.sc", EV_FireRocket );
|
||||
gEngfuncs.pfnHookEvent( "events/lightning.sc", EV_FireLightning );
|
||||
gEngfuncs.pfnHookEvent( "events/grenade.sc", EV_FireGrenade );
|
||||
gEngfuncs.pfnHookEvent( "events/spike.sc", EV_FireSpike );
|
||||
gEngfuncs.pfnHookEvent( "events/superspike.sc", EV_FireSuperSpike );
|
||||
gEngfuncs.pfnHookEvent( "events/gibs.sc", EV_Gibbed );
|
||||
gEngfuncs.pfnHookEvent( "events/teleport.sc", EV_Teleport );
|
||||
gEngfuncs.pfnHookEvent( "events/trail.sc", EV_Trail );
|
||||
gEngfuncs.pfnHookEvent( "events/explosion.sc", EV_Explosion );
|
||||
|
||||
gEngfuncs.pfnHookEvent( "events/powerup.sc", EV_PlayerPowerup );
|
||||
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorgoup.sc", EV_DMC_DoorGoUp );
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorgodown.sc", EV_DMC_DoorGoDown );
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorhittop.sc", EV_DMC_DoorHitTop );
|
||||
gEngfuncs.pfnHookEvent( "events/door/doorhitbottom.sc", EV_DMC_DoorHitBottom );
|
||||
|
||||
gEngfuncs.pfnHookEvent( "events/train.sc", EV_TrainPitchAdjust );
|
||||
}
|
||||
81
hlsdk/dmc/cl_dll/quake/quake_objects.cpp
Normal file
81
hlsdk/dmc/cl_dll/quake/quake_objects.cpp
Normal file
@ -0,0 +1,81 @@
|
||||
/***
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
****/
|
||||
#include "../hud.h"
|
||||
#include "../cl_util.h"
|
||||
#include "../demo.h"
|
||||
|
||||
#include "demo_api.h"
|
||||
#include "const.h"
|
||||
#include "entity_state.h"
|
||||
#include "cl_entity.h"
|
||||
|
||||
#include "pm_defs.h"
|
||||
#include "event_api.h"
|
||||
#include "entity_types.h"
|
||||
#include "r_efx.h"
|
||||
|
||||
|
||||
extern BEAM *pBeam;
|
||||
void HUD_GetLastOrg( float *org );
|
||||
|
||||
void UpdateBeams ( void )
|
||||
{
|
||||
vec3_t forward, vecSrc, vecEnd, origin, angles, right, up;
|
||||
vec3_t view_ofs;
|
||||
pmtrace_t tr;
|
||||
cl_entity_t *pthisplayer = gEngfuncs.GetLocalPlayer();
|
||||
int idx = pthisplayer->index;
|
||||
|
||||
// Get our exact viewangles from engine
|
||||
gEngfuncs.GetViewAngles( (float *)angles );
|
||||
|
||||
// Determine our last predicted origin
|
||||
HUD_GetLastOrg( (float *)&origin );
|
||||
|
||||
AngleVectors( angles, forward, right, up );
|
||||
|
||||
VectorCopy( origin, vecSrc );
|
||||
|
||||
VectorMA( vecSrc, 2048, forward, vecEnd );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
|
||||
|
||||
// Store off the old count
|
||||
gEngfuncs.pEventAPI->EV_PushPMStates();
|
||||
|
||||
// Now add in all of the players.
|
||||
gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
|
||||
gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecEnd, PM_STUDIO_BOX, -1, &tr );
|
||||
|
||||
gEngfuncs.pEventAPI->EV_PopPMStates();
|
||||
|
||||
pBeam->target = tr.endpos;
|
||||
pBeam->die = gEngfuncs.GetClientTime() + 0.1; // We keep it alive just a little bit forward in the future, just in case.
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
Game_AddObjects
|
||||
|
||||
Add game specific, client-side objects here
|
||||
=====================
|
||||
*/
|
||||
void Game_AddObjects( void )
|
||||
{
|
||||
if ( pBeam )
|
||||
UpdateBeams();
|
||||
}
|
||||
988
hlsdk/dmc/cl_dll/quake/quake_weapons.cpp
Normal file
988
hlsdk/dmc/cl_dll/quake/quake_weapons.cpp
Normal file
@ -0,0 +1,988 @@
|
||||
/***
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
****/
|
||||
#include "extdll.h"
|
||||
#include "util.h"
|
||||
#include "cbase.h"
|
||||
#include "monsters.h"
|
||||
#include "weapons.h"
|
||||
#include "nodes.h"
|
||||
#include "player.h"
|
||||
|
||||
#include "usercmd.h"
|
||||
#include "entity_state.h"
|
||||
#include "demo_api.h"
|
||||
#include "pm_defs.h"
|
||||
#include "event_api.h"
|
||||
#include "r_efx.h"
|
||||
|
||||
#include "../hud_iface.h"
|
||||
#include "../com_weapons.h"
|
||||
#include "../demo.h"
|
||||
|
||||
#include "quake_gun.h"
|
||||
#include "../DMC_Teleporters.h"
|
||||
|
||||
extern globalvars_t *gpGlobals;
|
||||
|
||||
// Pool of client side entities/entvars_t
|
||||
static entvars_t ev[ 32 ];
|
||||
static int num_ents = 0;
|
||||
|
||||
// The entity we'll use to represent the local client
|
||||
static CBasePlayer player;
|
||||
|
||||
// Local version of game .dll global variables ( time, etc. )
|
||||
static globalvars_t Globals;
|
||||
|
||||
static CBasePlayerWeapon *g_pWpns[ 32 ];
|
||||
extern int iCarriedWeapons;
|
||||
int g_iWaterLevel;
|
||||
// HLDM Weapon placeholder entities.
|
||||
CQuakeGun g_QuakeGun;
|
||||
|
||||
extern BEAM *pBeam;
|
||||
/*
|
||||
======================
|
||||
AlertMessage
|
||||
|
||||
Print debug messages to console
|
||||
======================
|
||||
*/
|
||||
void AlertMessage( ALERT_TYPE atype, char *szFmt, ... )
|
||||
{
|
||||
va_list argptr;
|
||||
static char string[1024];
|
||||
|
||||
va_start (argptr, szFmt);
|
||||
vsprintf (string, szFmt,argptr);
|
||||
va_end (argptr);
|
||||
|
||||
gEngfuncs.Con_Printf( "cl: " );
|
||||
gEngfuncs.Con_Printf( string );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_PrepEntity
|
||||
|
||||
Links the raw entity to an entvars_s holder. If a player is passed in as the owner, then
|
||||
we set up the m_pPlayer field.
|
||||
=====================
|
||||
*/
|
||||
void HUD_PrepEntity( CBaseEntity *pEntity, CBasePlayer *pWeaponOwner )
|
||||
{
|
||||
memset( &ev[ num_ents ], 0, sizeof( entvars_t ) );
|
||||
pEntity->pev = &ev[ num_ents++ ];
|
||||
|
||||
pEntity->Precache();
|
||||
pEntity->Spawn();
|
||||
|
||||
if ( pWeaponOwner )
|
||||
{
|
||||
ItemInfo info;
|
||||
|
||||
((CBasePlayerWeapon *)pEntity)->m_pPlayer = pWeaponOwner;
|
||||
|
||||
((CBasePlayerWeapon *)pEntity)->GetItemInfo( &info );
|
||||
|
||||
g_pWpns[ info.iId ] = (CBasePlayerWeapon *)pEntity;
|
||||
}
|
||||
}
|
||||
|
||||
CQuakeRocket *CQuakeRocket::CreateRocket( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CQuakeRocket *CQuakeRocket::CreateGrenade( Vector vecOrigin, Vector vecVelocity, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CQuakeNail *CQuakeNail::CreateSuperNail( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CQuakeNail *CQuakeNail::CreateNail( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void CBasePlayer :: Precache( void )
|
||||
{
|
||||
m_usShotgunSingle = PRECACHE_EVENT( 1, "events/shotgun1.sc" );
|
||||
m_usShotgunDouble = PRECACHE_EVENT( 1, "events/shotgun2.sc" );
|
||||
m_usAxe = PRECACHE_EVENT( 1, "events/axe.sc" );
|
||||
m_usAxeSwing = PRECACHE_EVENT( 1, "events/axeswing.sc" );
|
||||
m_usRocket = PRECACHE_EVENT( 1, "events/rocket.sc" );
|
||||
m_usGrenade = PRECACHE_EVENT( 1, "events/grenade.sc" );
|
||||
m_usLightning = PRECACHE_EVENT( 1, "events/lightning.sc" );
|
||||
m_usSpike = PRECACHE_EVENT( 1, "events/spike.sc" );
|
||||
m_usSuperSpike = PRECACHE_EVENT( 1, "events/superspike.sc" );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBaseEntity :: Killed
|
||||
|
||||
If weapons code "kills" an entity, just set its effects to EF_NODRAW
|
||||
=====================
|
||||
*/
|
||||
void CBaseEntity :: Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
pev->effects |= EF_NODRAW;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: DefaultReload
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: DefaultReload( int iClipSize, int iAnim, float fDelay )
|
||||
{
|
||||
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + fDelay;
|
||||
|
||||
//!!UNDONE -- reload sound goes here !!!
|
||||
SendWeaponAnim( iAnim );
|
||||
|
||||
m_fInReload = TRUE;
|
||||
|
||||
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + 3;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: CanDeploy
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: CanDeploy( void )
|
||||
{
|
||||
BOOL bHasAmmo = 0;
|
||||
|
||||
if ( !pszAmmo1() )
|
||||
{
|
||||
// this weapon doesn't use ammo, can always deploy.
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
if ( pszAmmo1() )
|
||||
{
|
||||
bHasAmmo |= (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] != 0);
|
||||
}
|
||||
if ( pszAmmo2() )
|
||||
{
|
||||
bHasAmmo |= (m_pPlayer->m_rgAmmo[m_iSecondaryAmmoType] != 0);
|
||||
}
|
||||
if (m_iClip > 0)
|
||||
{
|
||||
bHasAmmo |= 1;
|
||||
}
|
||||
if (!bHasAmmo)
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: DefaultDeploy
|
||||
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: DefaultDeploy( char *szViewModel, char *szWeaponModel, int iAnim, char *szAnimExt, int skiplocal )
|
||||
{
|
||||
if ( !CanDeploy() )
|
||||
return FALSE;
|
||||
|
||||
gEngfuncs.CL_LoadModel( szViewModel, &m_pPlayer->pev->viewmodel );
|
||||
|
||||
SendWeaponAnim( iAnim );
|
||||
|
||||
m_bPlayedIdleAnim = FALSE;
|
||||
|
||||
m_pPlayer->m_flNextAttack = 0.5;
|
||||
m_flTimeWeaponIdle = 1.0;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: PlayEmptySound
|
||||
|
||||
=====================
|
||||
*/
|
||||
BOOL CBasePlayerWeapon :: PlayEmptySound( void )
|
||||
{
|
||||
if (m_iPlayEmptySound)
|
||||
{
|
||||
HUD_PlaySound( "weapons/357_cock1.wav", 0.8 );
|
||||
m_iPlayEmptySound = 0;
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon :: ResetEmptySound
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon :: ResetEmptySound( void )
|
||||
{
|
||||
m_iPlayEmptySound = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::Holster
|
||||
|
||||
Put away weapon
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::Holster( int skiplocal /* = 0 */ )
|
||||
{
|
||||
m_fInReload = FALSE; // cancel any reload in progress.
|
||||
m_pPlayer->pev->viewmodel = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::SendWeaponAnim
|
||||
|
||||
Animate weapon model
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::SendWeaponAnim( int iAnim, int skiplocal )
|
||||
{
|
||||
m_pPlayer->pev->weaponanim = iAnim;
|
||||
|
||||
int body = 0;
|
||||
|
||||
HUD_SendWeaponAnim( iAnim, body, 0 );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::ItemPostFrame
|
||||
|
||||
Handles weapon firing, reloading, etc.
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::ItemPostFrame( void )
|
||||
{
|
||||
if ((m_fInReload) && (m_pPlayer->m_flNextAttack <= 0.0))
|
||||
{
|
||||
#if 0 // FIXME, need ammo on client to make this work right
|
||||
// complete the reload.
|
||||
int j = min( iMaxClip() - m_iClip, m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]);
|
||||
|
||||
// Add them to the clip
|
||||
m_iClip += j;
|
||||
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] -= j;
|
||||
#else
|
||||
m_iClip += 10;
|
||||
#endif
|
||||
m_fInReload = FALSE;
|
||||
}
|
||||
|
||||
if ((m_pPlayer->pev->button & IN_ATTACK2) && (m_flNextSecondaryAttack <= 0.0))
|
||||
{
|
||||
if ( pszAmmo2() && !m_pPlayer->m_rgAmmo[SecondaryAmmoIndex()] )
|
||||
{
|
||||
m_fFireOnEmpty = TRUE;
|
||||
}
|
||||
|
||||
SecondaryAttack();
|
||||
m_pPlayer->pev->button &= ~IN_ATTACK2;
|
||||
}
|
||||
else if ((m_pPlayer->pev->button & IN_ATTACK) && (m_flNextPrimaryAttack <= 0.0))
|
||||
{
|
||||
if ( (m_iClip == 0 && pszAmmo1()) || (iMaxClip() == -1 && !m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] ) )
|
||||
{
|
||||
m_fFireOnEmpty = TRUE;
|
||||
}
|
||||
|
||||
PrimaryAttack();
|
||||
}
|
||||
else if ( m_pPlayer->pev->button & IN_RELOAD && iMaxClip() != WEAPON_NOCLIP && !m_fInReload )
|
||||
{
|
||||
// reload when reload is pressed, or if no buttons are down and weapon is empty.
|
||||
Reload();
|
||||
}
|
||||
else if ( !(m_pPlayer->pev->button & (IN_ATTACK|IN_ATTACK2) ) )
|
||||
{
|
||||
// no fire buttons down
|
||||
|
||||
m_fFireOnEmpty = FALSE;
|
||||
|
||||
if ( !m_bPlayedIdleAnim )
|
||||
{
|
||||
m_bPlayedIdleAnim = TRUE;
|
||||
|
||||
if ( m_pPlayer->m_iQuakeWeapon == IT_LIGHTNING )
|
||||
PLAYBACK_EVENT_FULL( FEV_NOTHOST, m_pPlayer->edict(), m_pPlayer->m_usLightning, 0, (float *)&m_pPlayer->pev->origin, (float *)&m_pPlayer->pev->angles, 0.0, 0.0, 0, 1, 0, 0 );
|
||||
}
|
||||
|
||||
WeaponIdle( );
|
||||
return;
|
||||
}
|
||||
|
||||
// catch all
|
||||
if ( ShouldWeaponIdle() )
|
||||
{
|
||||
WeaponIdle();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::SelectItem
|
||||
|
||||
Switch weapons
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::SelectItem(const char *pstr)
|
||||
{
|
||||
if (!pstr)
|
||||
return;
|
||||
|
||||
CBasePlayerItem *pItem = NULL;
|
||||
|
||||
if (!pItem)
|
||||
return;
|
||||
|
||||
|
||||
if (pItem == m_pActiveItem)
|
||||
return;
|
||||
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Holster( );
|
||||
|
||||
m_pLastItem = m_pActiveItem;
|
||||
m_pActiveItem = pItem;
|
||||
|
||||
if (m_pActiveItem)
|
||||
{
|
||||
m_pActiveItem->Deploy( );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::SelectLastItem
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::SelectLastItem(void)
|
||||
{
|
||||
if (!m_pLastItem)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if ( m_pActiveItem && !m_pActiveItem->CanHolster() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Holster( );
|
||||
|
||||
CBasePlayerItem *pTemp = m_pActiveItem;
|
||||
m_pActiveItem = m_pLastItem;
|
||||
m_pLastItem = pTemp;
|
||||
m_pActiveItem->Deploy( );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::Killed
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::Killed( entvars_t *pevAttacker, int iGib )
|
||||
{
|
||||
if ( m_iQuakeWeapon == IT_LIGHTNING )
|
||||
{
|
||||
PLAYBACK_EVENT_FULL( FEV_NOTHOST, edict(), m_usLightning, 0, (float *)&pev->origin, (float *)&pev->angles, 0.0, 0.0, 0, 1, 0, 0 );
|
||||
}
|
||||
|
||||
// Holster weapon immediately, to allow it to cleanup
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Holster( );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayer::Spawn
|
||||
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayer::Spawn( void )
|
||||
{
|
||||
if (m_pActiveItem)
|
||||
m_pActiveItem->Deploy( );
|
||||
}
|
||||
|
||||
BOOL CQuakeGun::Deploy( )
|
||||
{
|
||||
gEngfuncs.CL_LoadModel( "models/v_axe.mdl", &m_pPlayer->pev->viewmodel );
|
||||
strcpy( m_pPlayer->m_szAnimExtention, "onehanded" );
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int HUD_GetModelIndex( char *modelname )
|
||||
{
|
||||
int retval = 0;
|
||||
gEngfuncs.CL_LoadModel( modelname, &retval );
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_TraceLine
|
||||
|
||||
Don't actually trace, but act like the trace didn't hit anything.
|
||||
=====================
|
||||
*/
|
||||
void UTIL_TraceLine( const Vector &vecStart, const Vector &vecEnd, IGNORE_MONSTERS igmon, edict_t *pentIgnore, TraceResult *ptr )
|
||||
{
|
||||
memset( ptr, 0, sizeof( *ptr ) );
|
||||
ptr->flFraction = 1.0;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_ParticleBox
|
||||
|
||||
For debugging, draw a box around a player made out of particles
|
||||
=====================
|
||||
*/
|
||||
void UTIL_ParticleBox( CBasePlayer *player, float *mins, float *maxs, float life, unsigned char r, unsigned char g, unsigned char b )
|
||||
{
|
||||
int i;
|
||||
vec3_t mmin, mmax;
|
||||
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
mmin[ i ] = player->pev->origin[ i ] + mins[ i ];
|
||||
mmax[ i ] = player->pev->origin[ i ] + maxs[ i ];
|
||||
}
|
||||
|
||||
gEngfuncs.pEfxAPI->R_ParticleBox( (float *)&mmin, (float *)&mmax, 5.0, 0, 255, 0 );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_ParticleBoxes
|
||||
|
||||
For debugging, draw boxes for other collidable players
|
||||
=====================
|
||||
*/
|
||||
void UTIL_ParticleBoxes( void )
|
||||
{
|
||||
int idx;
|
||||
physent_t *pe;
|
||||
cl_entity_t *player;
|
||||
vec3_t mins, maxs;
|
||||
|
||||
gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
|
||||
|
||||
// Store off the old count
|
||||
gEngfuncs.pEventAPI->EV_PushPMStates();
|
||||
|
||||
player = gEngfuncs.GetLocalPlayer();
|
||||
// Now add in all of the players.
|
||||
gEngfuncs.pEventAPI->EV_SetSolidPlayers ( player->index - 1 );
|
||||
|
||||
for ( idx = 1; idx < 100; idx++ )
|
||||
{
|
||||
pe = gEngfuncs.pEventAPI->EV_GetPhysent( idx );
|
||||
if ( !pe )
|
||||
break;
|
||||
|
||||
if ( pe->info >= 1 && pe->info <= gEngfuncs.GetMaxClients() )
|
||||
{
|
||||
mins = pe->origin + pe->mins;
|
||||
maxs = pe->origin + pe->maxs;
|
||||
|
||||
gEngfuncs.pEfxAPI->R_ParticleBox( (float *)&mins, (float *)&maxs, 0, 0, 255, 2.0 );
|
||||
}
|
||||
}
|
||||
|
||||
gEngfuncs.pEventAPI->EV_PopPMStates();
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
UTIL_ParticleLine
|
||||
|
||||
For debugging, draw a line made out of particles
|
||||
=====================
|
||||
*/
|
||||
void UTIL_ParticleLine( CBasePlayer *player, float *start, float *end, float life, unsigned char r, unsigned char g, unsigned char b )
|
||||
{
|
||||
gEngfuncs.pEfxAPI->R_ParticleLine( start, end, r, g, b, life );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
CBasePlayerWeapon::PrintState
|
||||
|
||||
For debugging, print out state variables to log file
|
||||
=====================
|
||||
*/
|
||||
void CBasePlayerWeapon::PrintState( void )
|
||||
{
|
||||
COM_Log( "c:\\hl.log", "%.4f ", gpGlobals->time );
|
||||
COM_Log( "c:\\hl.log", "%.4f ", m_pPlayer->m_flNextAttack );
|
||||
COM_Log( "c:\\hl.log", "%.4f ", m_flNextPrimaryAttack );
|
||||
COM_Log( "c:\\hl.log", "%.4f ", m_flTimeWeaponIdle - gpGlobals->time);
|
||||
COM_Log( "c:\\hl.log", "%i ", m_iClip );
|
||||
}
|
||||
|
||||
vec3_t previousorigin;
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_GetLastOrg
|
||||
|
||||
Retruns the last position that we stored for egon beam endpoint.
|
||||
=====================
|
||||
*/
|
||||
void HUD_GetLastOrg( float *org )
|
||||
{
|
||||
int i;
|
||||
|
||||
// Return last origin
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
org[i] = previousorigin[i];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_SetLastOrg
|
||||
|
||||
Remember our exact predicted origin so we can draw the egon to the right position.
|
||||
=====================
|
||||
*/
|
||||
void HUD_SetLastOrg( void )
|
||||
{
|
||||
int i;
|
||||
|
||||
// Offset final origin by view_offset
|
||||
for ( i = 0; i < 3; i++ )
|
||||
{
|
||||
previousorigin[i] = g_finalstate->playerstate.origin[i] + g_finalstate->client.view_ofs[ i ];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_InitClientWeapons
|
||||
|
||||
Set up weapons, player and functions needed to run weapons code client-side.
|
||||
=====================
|
||||
*/
|
||||
void HUD_InitClientWeapons( void )
|
||||
{
|
||||
static int initialized = 0;
|
||||
if ( initialized )
|
||||
return;
|
||||
|
||||
initialized = 1;
|
||||
|
||||
// Set up pointer ( dummy object )
|
||||
gpGlobals = &Globals;
|
||||
|
||||
// Fill in current time ( probably not needed )
|
||||
gpGlobals->time = gEngfuncs.GetClientTime();
|
||||
|
||||
// Fake functions
|
||||
g_engfuncs.pfnPrecacheModel = stub_PrecacheModel;
|
||||
g_engfuncs.pfnPrecacheSound = stub_PrecacheSound;
|
||||
g_engfuncs.pfnPrecacheEvent = stub_PrecacheEvent;
|
||||
g_engfuncs.pfnNameForFunction = stub_NameForFunction;
|
||||
g_engfuncs.pfnSetModel = stub_SetModel;
|
||||
g_engfuncs.pfnSetClientMaxspeed = HUD_SetMaxSpeed;
|
||||
|
||||
// Handled locally
|
||||
g_engfuncs.pfnPlaybackEvent = HUD_PlaybackEvent;
|
||||
g_engfuncs.pfnAlertMessage = AlertMessage;
|
||||
|
||||
// Pass through to engine
|
||||
g_engfuncs.pfnPrecacheEvent = gEngfuncs.pfnPrecacheEvent;
|
||||
g_engfuncs.pfnRandomFloat = gEngfuncs.pfnRandomFloat;
|
||||
g_engfuncs.pfnRandomLong = gEngfuncs.pfnRandomLong;
|
||||
|
||||
// Allocate a slot for the local player
|
||||
HUD_PrepEntity( &player , NULL );
|
||||
|
||||
// Allocate slot(s) for each weapon that we are going to be predicting
|
||||
HUD_PrepEntity( &g_QuakeGun , &player );
|
||||
}
|
||||
|
||||
int Quake_NumForWeaponItem( int quakeitem )
|
||||
{
|
||||
int retval = 1;
|
||||
switch ( quakeitem )
|
||||
{
|
||||
default:
|
||||
case IT_AXE:
|
||||
retval = 1;
|
||||
break;
|
||||
case IT_SHOTGUN:
|
||||
retval = 2;
|
||||
break;
|
||||
case IT_SUPER_SHOTGUN:
|
||||
retval = 3;
|
||||
break;
|
||||
case IT_NAILGUN:
|
||||
retval = 4;
|
||||
break;
|
||||
case IT_SUPER_NAILGUN:
|
||||
retval = 5;
|
||||
break;
|
||||
case IT_GRENADE_LAUNCHER:
|
||||
retval = 6;
|
||||
break;
|
||||
case IT_ROCKET_LAUNCHER:
|
||||
retval = 7;
|
||||
break;
|
||||
|
||||
case IT_LIGHTNING:
|
||||
retval = 8;
|
||||
break;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_WeaponsPostThink
|
||||
|
||||
Run Weapon firing code on client
|
||||
=====================
|
||||
*/
|
||||
void HUD_WeaponsPostThink( local_state_s *from, local_state_s *to, usercmd_t *cmd, double time, unsigned int random_seed )
|
||||
{
|
||||
int i;
|
||||
int buttonsChanged;
|
||||
CBasePlayerWeapon *pWeapon = NULL;
|
||||
CBasePlayerWeapon *pCurrent;
|
||||
weapon_data_t nulldata, *pfrom, *pto;
|
||||
static int lasthealth;
|
||||
|
||||
memset( &nulldata, 0, sizeof( nulldata ) );
|
||||
|
||||
HUD_InitClientWeapons();
|
||||
|
||||
// Get current clock
|
||||
gpGlobals->time = time;
|
||||
|
||||
// Fill in data based on selected weapon
|
||||
// FIXME, make this a method in each weapon? where you pass in an entity_state_t *?
|
||||
switch ( from->client.m_iId )
|
||||
{
|
||||
case WEAPON_GLOCK:
|
||||
pWeapon = &g_QuakeGun;
|
||||
break;
|
||||
}
|
||||
|
||||
// Store pointer to our destination entity_state_t so we can get our origin, etc. from it
|
||||
// for setting up events on the client
|
||||
g_finalstate = to;
|
||||
|
||||
// If we are running events/etc. go ahead and see if we
|
||||
// managed to die between last frame and this one
|
||||
// If so, run the appropriate player killed or spawn function
|
||||
if ( g_runfuncs )
|
||||
{
|
||||
if ( to->client.health <= 0 && lasthealth > 0 )
|
||||
{
|
||||
player.Killed( NULL, 0 );
|
||||
}
|
||||
else if ( to->client.health > 0 && lasthealth <= 0 )
|
||||
{
|
||||
player.Spawn();
|
||||
}
|
||||
|
||||
lasthealth = to->client.health;
|
||||
}
|
||||
|
||||
// We are not predicting the current weapon, just bow out here.
|
||||
if ( !pWeapon )
|
||||
return;
|
||||
|
||||
gpGlobals->deathmatch = from->client.iuser4;
|
||||
|
||||
for ( i = 0; i < 32; i++ )
|
||||
{
|
||||
pCurrent = g_pWpns[ i ];
|
||||
if ( !pCurrent )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
pfrom = &from->weapondata[ i ];
|
||||
|
||||
pCurrent->m_fInReload = pfrom->m_fInReload;
|
||||
pCurrent->m_iClip = pfrom->m_iClip;
|
||||
pCurrent->m_flNextPrimaryAttack = pfrom->m_flNextPrimaryAttack;
|
||||
pCurrent->m_flNextSecondaryAttack = pfrom->m_flNextSecondaryAttack;
|
||||
pCurrent->m_flTimeWeaponIdle = pfrom->m_flTimeWeaponIdle;
|
||||
}
|
||||
|
||||
// For random weapon events, use this seed to seed random # generator
|
||||
player.random_seed = random_seed;
|
||||
|
||||
// Get old buttons from previous state.
|
||||
player.m_afButtonLast = from->playerstate.oldbuttons;
|
||||
|
||||
// Which buttsons chave changed
|
||||
buttonsChanged = (player.m_afButtonLast ^ cmd->buttons); // These buttons have changed this frame
|
||||
|
||||
// Debounced button codes for pressed/released
|
||||
// The changed ones still down are "pressed"
|
||||
player.m_afButtonPressed = buttonsChanged & cmd->buttons;
|
||||
// The ones not down are "released"
|
||||
player.m_afButtonReleased = buttonsChanged & (~cmd->buttons);
|
||||
|
||||
// Set player variables that weapons code might check/alter
|
||||
player.pev->button = cmd->buttons;
|
||||
|
||||
player.pev->velocity = from->client.velocity;
|
||||
player.pev->flags = from->client.flags;
|
||||
|
||||
player.pev->deadflag = from->client.deadflag;
|
||||
g_iWaterLevel = player.pev->waterlevel = from->client.waterlevel;
|
||||
player.pev->maxspeed = from->client.maxspeed;
|
||||
player.pev->fov = from->client.fov;
|
||||
player.pev->weaponanim = from->client.weaponanim;
|
||||
player.pev->viewmodel = from->client.viewmodel;
|
||||
player.m_flNextAttack = from->client.m_flNextAttack;
|
||||
player.m_iQuakeWeapon = (int)from->client.fuser1;
|
||||
iCarriedWeapons = player.m_iQuakeItems = from->client.iuser3;
|
||||
|
||||
player.m_iAmmoShells = from->client.ammo_shells;
|
||||
player.m_iAmmoCells = from->client.ammo_cells;
|
||||
player.m_iAmmoRockets = from->client.ammo_rockets;
|
||||
player.m_iAmmoNails = from->client.ammo_nails;
|
||||
|
||||
player.m_iNailOffset = (int)from->client.fuser2 != 0.0 ? 4.0 : -4.0;
|
||||
|
||||
|
||||
|
||||
// REally useful for debugging prediction
|
||||
/* if ( player.m_iQuakeWeapon > 0 )
|
||||
{
|
||||
gEngfuncs.Con_NPrintf( 9, "got qw %i", player.m_iQuakeWeapon );
|
||||
char items[33];
|
||||
for ( int i = 0; i < 32; i++ )
|
||||
{
|
||||
if ( player.m_iQuakeItems & (1<<i) )
|
||||
{
|
||||
items[i] = '1';
|
||||
}
|
||||
else
|
||||
{
|
||||
items[i] = '0';
|
||||
}
|
||||
}
|
||||
items[32] = 0;
|
||||
gEngfuncs.Con_NPrintf( 10, "got qi %s", items );
|
||||
gEngfuncs.Con_NPrintf( 11, "shells %i", player.m_iAmmoShells );
|
||||
gEngfuncs.Con_NPrintf( 12, "cells %i", player.m_iAmmoCells );
|
||||
gEngfuncs.Con_NPrintf( 13, "rockets %i", player.m_iAmmoRockets );
|
||||
gEngfuncs.Con_NPrintf( 14, "nails %i", player.m_iAmmoNails );
|
||||
gEngfuncs.Con_NPrintf( 15, "viewmodel %i", player.pev->viewmodel );
|
||||
gEngfuncs.Con_NPrintf( 16, "dm == %i", gpGlobals->deathmatch );
|
||||
}*/
|
||||
|
||||
|
||||
// Point to current weapon object
|
||||
if ( from->client.m_iId )
|
||||
{
|
||||
player.m_pActiveItem = g_pWpns[ from->client.m_iId ];
|
||||
}
|
||||
|
||||
// Set ammo, but don't change anim
|
||||
player.W_SetCurrentAmmo( 0 );
|
||||
|
||||
|
||||
|
||||
// Don't go firing anything if we have died.
|
||||
// Or if we don't have a weapon model deployed
|
||||
if ( ( player.pev->deadflag != ( DEAD_DISCARDBODY + 1 ) ) && !CL_IsDead() ) // && player.pev->viewmodel )
|
||||
{
|
||||
if ( player.m_flNextAttack <= 0 )
|
||||
{
|
||||
pWeapon->ItemPostFrame();
|
||||
}
|
||||
}
|
||||
|
||||
// Assume that we are not going to switch weapons
|
||||
to->client.m_iId = from->client.m_iId;
|
||||
|
||||
// Now see if we issued a changeweapon command ( and we're not dead )
|
||||
if ( cmd->weaponselect && ( player.pev->deadflag != ( DEAD_DISCARDBODY + 1 ) ) )
|
||||
{
|
||||
// Switched to a different weapon?
|
||||
if ( Quake_NumForWeaponItem( player.m_iQuakeWeapon ) != cmd->weaponselect )
|
||||
{
|
||||
player.W_ChangeWeapon( cmd->weaponselect );
|
||||
}
|
||||
}
|
||||
|
||||
if ( player.m_iQuakeWeapon != IT_LIGHTNING && pBeam != NULL )
|
||||
{
|
||||
pBeam->die = 0.0;
|
||||
pBeam = NULL;
|
||||
}
|
||||
// Copy in results of predcition code
|
||||
|
||||
to->client.viewmodel = player.pev->viewmodel;
|
||||
to->client.fov = player.pev->fov;
|
||||
to->client.weaponanim = player.pev->weaponanim;
|
||||
to->client.m_flNextAttack = player.m_flNextAttack;
|
||||
to->client.maxspeed = player.pev->maxspeed;
|
||||
to->client.iuser3 = player.m_iQuakeItems;
|
||||
to->client.fuser1 = (float)player.m_iQuakeWeapon;
|
||||
to->client.fuser2 = (float)player.m_iNailOffset > 0.0 ? 1.0 : 0.0;
|
||||
|
||||
to->client.ammo_shells = player.m_iAmmoShells;
|
||||
to->client.ammo_cells = player.m_iAmmoCells;
|
||||
to->client.ammo_rockets = player.m_iAmmoRockets;
|
||||
to->client.ammo_nails = player.m_iAmmoNails;
|
||||
|
||||
// Make sure that weapon animation matches what the game .dll is telling us
|
||||
// over the wire ( fixes some animation glitches )
|
||||
if ( g_runfuncs && ( HUD_GetWeaponAnim() != to->client.weaponanim ) )
|
||||
{
|
||||
int body = 2;
|
||||
// Force a fixed anim down to viewmodel
|
||||
HUD_SendWeaponAnim( to->client.weaponanim, body, 1 );
|
||||
}
|
||||
|
||||
for ( i = 0; i < 32; i++ )
|
||||
{
|
||||
pCurrent = g_pWpns[ i ];
|
||||
|
||||
pto = &to->weapondata[ i ];
|
||||
|
||||
if ( !pCurrent )
|
||||
{
|
||||
memset( pto, 0, sizeof( weapon_data_t ) );
|
||||
continue;
|
||||
}
|
||||
|
||||
pto->m_fInReload = pCurrent->m_fInReload;
|
||||
pto->m_iClip = pCurrent->m_iClip;
|
||||
pto->m_flNextPrimaryAttack = pCurrent->m_flNextPrimaryAttack;
|
||||
pto->m_flNextSecondaryAttack = pCurrent->m_flNextSecondaryAttack;
|
||||
pto->m_flTimeWeaponIdle = pCurrent->m_flTimeWeaponIdle;
|
||||
|
||||
// Decrement weapon counters, server does this at same time ( during post think, after doing everything else )
|
||||
pto->m_flNextReload -= cmd->msec / 1000.0;
|
||||
pto->m_fNextAimBonus -= cmd->msec / 1000.0;
|
||||
pto->m_flNextPrimaryAttack -= cmd->msec / 1000.0;
|
||||
pto->m_flNextSecondaryAttack -= cmd->msec / 1000.0;
|
||||
pto->m_flTimeWeaponIdle -= cmd->msec / 1000.0;
|
||||
|
||||
if ( pto->m_flPumpTime != -9999 )
|
||||
{
|
||||
pto->m_flPumpTime -= cmd->msec / 1000.0;
|
||||
if ( pto->m_flPumpTime < -0.001 )
|
||||
pto->m_flPumpTime = -0.001;
|
||||
}
|
||||
|
||||
if ( pto->m_fNextAimBonus < -1.0 )
|
||||
{
|
||||
pto->m_fNextAimBonus = -1.0;
|
||||
}
|
||||
|
||||
if ( pto->m_flNextPrimaryAttack < -1.0 )
|
||||
{
|
||||
pto->m_flNextPrimaryAttack = -1.0;
|
||||
}
|
||||
|
||||
if ( pto->m_flNextSecondaryAttack < -0.001 )
|
||||
{
|
||||
pto->m_flNextSecondaryAttack = -0.001;
|
||||
}
|
||||
|
||||
if ( pto->m_flTimeWeaponIdle < -0.001 )
|
||||
{
|
||||
pto->m_flTimeWeaponIdle = -0.001;
|
||||
}
|
||||
|
||||
if ( pto->m_flNextReload < -0.001 )
|
||||
{
|
||||
pto->m_flNextReload = -0.001;
|
||||
}
|
||||
}
|
||||
|
||||
// m_flNextAttack is now part of the weapons, but is part of the player instead
|
||||
to->client.m_flNextAttack -= cmd->msec / 1000.0;
|
||||
if ( to->client.m_flNextAttack < -0.001 )
|
||||
{
|
||||
to->client.m_flNextAttack = -0.001;
|
||||
}
|
||||
|
||||
// Store off the last position from the predicted state.
|
||||
HUD_SetLastOrg();
|
||||
// Wipe it so we can't use it after this frame
|
||||
g_finalstate = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
HUD_PostRunCmd
|
||||
|
||||
Client calls this during prediction, after it has moved the player and updated any info changed into to->
|
||||
time is the current client clock based on prediction
|
||||
cmd is the command that caused the movement, etc
|
||||
runfuncs is 1 if this is the first time we've predicted this command. If so, sounds and effects should play, otherwise, they should
|
||||
be ignored
|
||||
=====================
|
||||
*/
|
||||
void _DLLEXPORT HUD_PostRunCmd( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed )
|
||||
{
|
||||
g_runfuncs = runfuncs;
|
||||
|
||||
// Only run post think stuff for glock for the sample
|
||||
// implementation
|
||||
if ( cl_lw && cl_lw->value )
|
||||
{
|
||||
HUD_WeaponsPostThink( from, to, cmd, time, random_seed );
|
||||
}
|
||||
else
|
||||
{
|
||||
to->client.fov = g_lastFOV;
|
||||
}
|
||||
|
||||
Dmc_CheckTeleporters( from, to ); // See if we stepped on a jump pad
|
||||
|
||||
// All games can use FOV state
|
||||
g_lastFOV = to->client.fov;
|
||||
}
|
||||
Reference in New Issue
Block a user