/*** * * Copyright (c) 1996-2001, 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. * ****/ /* ===== player.cpp ======================================================== functions dealing with the player */ #include "extdll.h" #include "util.h" #include "cbase.h" #include "player.h" #include "trains.h" #include "nodes.h" #include "weapons.h" #include "soundent.h" #include "monsters.h" #include "shake.h" #include "decals.h" #include "gamerules.h" #include "game.h" #include "thewastes.h" #include "tw_common.h" #include "pm_shared.h" // #define DUCKFIX //BLONDE - Different default movement speeds #define NORMAL_SPEED 320 #define AIMED_SPEED 190 #define DYING_SPEED 240 //&BLONDE extern DLL_GLOBAL ULONG g_ulModelIndexPlayer; extern DLL_GLOBAL BOOL g_fGameOver; extern DLL_GLOBAL BOOL g_fDrawLines; int gEvilImpulse101; extern DLL_GLOBAL int g_iSkillLevel, gDisplayTitle; BOOL gInitHUD = TRUE; extern void CopyToBodyQue(entvars_t* pev); extern void respawn(entvars_t *pev, BOOL fCopyCorpse); extern Vector VecBModelOrigin(entvars_t *pevBModel ); extern edict_t *EntSelectSpawnPoint( CBaseEntity *pPlayer ); // the world node graph extern CGraph WorldGraph; #define TRAIN_ACTIVE 0x80 #define TRAIN_NEW 0xc0 #define TRAIN_OFF 0x00 #define TRAIN_NEUTRAL 0x01 #define TRAIN_SLOW 0x02 #define TRAIN_MEDIUM 0x03 #define TRAIN_FAST 0x04 #define TRAIN_BACK 0x05 #define FLASH_DRAIN_TIME 1.2 //100 units/3 minutes #define FLASH_CHARGE_TIME 0.2 // 100 units/20 seconds (seconds per unit) // Global Savedata for player TYPEDESCRIPTION CBasePlayer::m_playerSaveData[] = { DEFINE_FIELD( CBasePlayer, m_flFlashLightTime, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_iFlashBattery, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_afButtonLast, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_afButtonPressed, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_afButtonReleased, FIELD_INTEGER ), DEFINE_ARRAY( CBasePlayer, m_rgItems, FIELD_INTEGER, MAX_ITEMS ), DEFINE_FIELD( CBasePlayer, m_afPhysicsFlags, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_flTimeStepSound, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_flTimeWeaponIdle, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_flSwimTime, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_flDuckTime, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_flWallJumpTime, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_lastDamageAmount, FIELD_INTEGER ), DEFINE_ARRAY( CBasePlayer, m_rgpPlayerItems, FIELD_CLASSPTR, MAX_ITEM_TYPES ), DEFINE_FIELD( CBasePlayer, m_pActiveItem, FIELD_CLASSPTR ), DEFINE_FIELD( CBasePlayer, m_pLastItem, FIELD_CLASSPTR ), DEFINE_ARRAY( CBasePlayer, m_rgAmmo, FIELD_INTEGER, MAX_AMMO_SLOTS ), DEFINE_FIELD( CBasePlayer, m_idrowndmg, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_idrownrestored, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_tSneaking, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_iTrain, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_bitsHUDDamage, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_flFallVelocity, FIELD_FLOAT ), DEFINE_FIELD( CBasePlayer, m_iTargetVolume, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_iWeaponVolume, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_iExtraSoundTypes, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_iWeaponFlash, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_fLongJump, FIELD_BOOLEAN ), DEFINE_FIELD( CBasePlayer, m_fInitHUD, FIELD_BOOLEAN ), DEFINE_FIELD( CBasePlayer, m_tbdPrev, FIELD_TIME ), DEFINE_FIELD( CBasePlayer, m_pTank, FIELD_EHANDLE ), DEFINE_FIELD( CBasePlayer, m_iHideHUD, FIELD_INTEGER ), DEFINE_FIELD( CBasePlayer, m_iFOV, FIELD_INTEGER ), //DEFINE_FIELD( CBasePlayer, m_fDeadTime, FIELD_FLOAT ), // only used in multiplayer games //DEFINE_FIELD( CBasePlayer, m_fGameHUDInitialized, FIELD_INTEGER ), // only used in multiplayer games //DEFINE_FIELD( CBasePlayer, m_flStopExtraSoundTime, FIELD_TIME ), //DEFINE_FIELD( CBasePlayer, m_fKnownItem, FIELD_INTEGER ), // reset to zero on load //DEFINE_FIELD( CBasePlayer, m_iPlayerSound, FIELD_INTEGER ), // Don't restore, set in Precache() //DEFINE_FIELD( CBasePlayer, m_pentSndLast, FIELD_EDICT ), // Don't restore, client needs reset //DEFINE_FIELD( CBasePlayer, m_flSndRoomtype, FIELD_FLOAT ), // Don't restore, client needs reset //DEFINE_FIELD( CBasePlayer, m_flSndRange, FIELD_FLOAT ), // Don't restore, client needs reset //DEFINE_FIELD( CBasePlayer, m_fNewAmmo, FIELD_INTEGER ), // Don't restore, client needs reset //DEFINE_FIELD( CBasePlayer, m_flgeigerRange, FIELD_FLOAT ), // Don't restore, reset in Precache() //DEFINE_FIELD( CBasePlayer, m_flgeigerDelay, FIELD_FLOAT ), // Don't restore, reset in Precache() //DEFINE_FIELD( CBasePlayer, m_igeigerRangePrev, FIELD_FLOAT ), // Don't restore, reset in Precache() //DEFINE_FIELD( CBasePlayer, m_iStepLeft, FIELD_INTEGER ), // Don't need to restore //DEFINE_ARRAY( CBasePlayer, m_szTextureName, FIELD_CHARACTER, CBTEXTURENAMEMAX ), // Don't need to restore //DEFINE_FIELD( CBasePlayer, m_chTextureType, FIELD_CHARACTER ), // Don't need to restore //DEFINE_FIELD( CBasePlayer, m_fNoPlayerSound, FIELD_BOOLEAN ), // Don't need to restore, debug //DEFINE_FIELD( CBasePlayer, m_iUpdateTime, FIELD_INTEGER ), // Don't need to restore //DEFINE_FIELD( CBasePlayer, m_iClientHealth, FIELD_INTEGER ), // Don't restore, client needs reset //DEFINE_FIELD( CBasePlayer, m_iClientHideHUD, FIELD_INTEGER ), // Don't restore, client needs reset //DEFINE_FIELD( CBasePlayer, m_fWeapon, FIELD_BOOLEAN ), // Don't restore, client needs reset //DEFINE_FIELD( CBasePlayer, m_nCustomSprayFrames, FIELD_INTEGER ), // Don't restore, depends on server message after spawning and only matters in multiplayer //DEFINE_FIELD( CBasePlayer, m_vecAutoAim, FIELD_VECTOR ), // Don't save/restore - this is recomputed //DEFINE_ARRAY( CBasePlayer, m_rgAmmoLast, FIELD_INTEGER, MAX_AMMO_SLOTS ), // Don't need to restore //DEFINE_FIELD( CBasePlayer, m_fOnTarget, FIELD_BOOLEAN ), // Don't need to restore //DEFINE_FIELD( CBasePlayer, m_nCustomSprayFrames, FIELD_INTEGER ), // Don't need to restore }; int giPrecacheGrunt = 0; int gmsgShake = 0; int gmsgFade = 0; int gmsgSelAmmo = 0; int gmsgFlashlight = 0; int gmsgFlashBattery = 0; int gmsgResetHUD = 0; int gmsgInitHUD = 0; int gmsgShowGameTitle = 0; int gmsgCurWeapon = 0; int gmsgHealth = 0; int gmsgDamage = 0; int gmsgTrain = 0; int gmsgWeaponList = 0; int gmsgAmmoX = 0; int gmsgHudText = 0; int gmsgDeathMsg = 0; int gmsgScoreInfo = 0; int gmsgTeamInfo = 0; int gmsgTeamScore = 0; int gmsgGameMode = 0; int gmsgMOTD = 0; int gmsgBriefing = 0; int gmsgServerName = 0; int gmsgAmmoPickup = 0; int gmsgWeapPickup = 0; int gmsgItemPickup = 0; int gmsgHideWeapon = 0; int gmsgSetCurWeap = 0; int gmsgSayText = 0; int gmsgTextMsg = 0; int gmsgSetFOV = 0; int gmsgShowMenu = 0; int gmsgGeigerRange = 0; int gmsgTeamNames = 0; int gmsgSpectator = 0; int gmsgLaserInfo = 0; int gmsgPlayerState = 0; int gmsgLmsStart = 0; void LinkUserMessages( void ) { // Already taken care of? if ( gmsgSelAmmo ) { return; } // Message identifiers must be less than 12 characters! - Stuart Crouch gmsgSelAmmo = REG_USER_MSG("SelAmmo", sizeof(SelAmmo)); gmsgCurWeapon = REG_USER_MSG("CurWeapon", 3); gmsgGeigerRange = REG_USER_MSG("Geiger", 1); gmsgFlashlight = REG_USER_MSG("Flashlight", 2); gmsgFlashBattery = REG_USER_MSG("FlashBat", 1); gmsgHealth = REG_USER_MSG( "Health", 1 ); gmsgDamage = REG_USER_MSG( "Damage", 12 ); gmsgTrain = REG_USER_MSG( "Train", 1); gmsgHudText = REG_USER_MSG( "HudText", -1 ); gmsgSayText = REG_USER_MSG( "SayText", -1 ); gmsgTextMsg = REG_USER_MSG( "TextMsg", -1 ); gmsgWeaponList = REG_USER_MSG("WeaponList", -1); gmsgResetHUD = REG_USER_MSG("ResetHUD", 1); // called every respawn gmsgInitHUD = REG_USER_MSG("InitHUD", 0 ); // called every time a new player joins the server gmsgShowGameTitle = REG_USER_MSG("GameTitle", 1); gmsgDeathMsg = REG_USER_MSG( "DeathMsg", -1 ); gmsgScoreInfo = REG_USER_MSG( "ScoreInfo", 9 ); gmsgTeamInfo = REG_USER_MSG( "TeamInfo", -1 ); // sets the name of a player's team gmsgTeamScore = REG_USER_MSG( "TeamScore", -1 ); // sets the score of a team on the scoreboard gmsgGameMode = REG_USER_MSG( "GameMode", 1 ); gmsgMOTD = REG_USER_MSG( "MOTD", -1 ); gmsgBriefing = REG_USER_MSG( "Briefing", 1 ); gmsgServerName = REG_USER_MSG( "ServerName", -1 ); gmsgAmmoPickup = REG_USER_MSG( "AmmoPickup", 2 ); gmsgWeapPickup = REG_USER_MSG( "WeapPickup", 1 ); gmsgItemPickup = REG_USER_MSG( "ItemPickup", -1 ); gmsgHideWeapon = REG_USER_MSG( "HideWeapon", 1 ); gmsgSetFOV = REG_USER_MSG( "SetFOV", 1 ); gmsgShowMenu = REG_USER_MSG( "ShowMenu", -1 ); gmsgShake = REG_USER_MSG("ScreenShake", sizeof(ScreenShake)); gmsgFade = REG_USER_MSG("ScreenFade", sizeof(ScreenFade)); gmsgAmmoX = REG_USER_MSG("AmmoX", 2); gmsgTeamNames = REG_USER_MSG( "TeamNames", -1 ); gmsgSpectator = REG_USER_MSG( "Spectator", 2 ); gmsgLaserInfo = REG_USER_MSG( "LaserInfo", 2 ); gmsgPlayerState = REG_USER_MSG( "PlayerState", 1 ); gmsgLmsStart = REG_USER_MSG( "LmsStart", 2 ); } /* * * CPlayerInventory * */ CPlayerInventory::CPlayerInventory() { memset( m_iItemIndices, -1, sizeof( m_iItemIndices ) ); m_bRandom = FALSE; } BOOL CPlayerInventory::SetInventory( int Slot, int Index ) { if( m_bRandom ) return FALSE; BOOL bOutOfBounds = FALSE; playeritemlist_t *pList = GetListForSlot( Slot ); if( pList == NULL ) return FALSE; if( Index < pList->size && Index >= 0 ) { if( g_pGameRules->AcceptInventory( &pList->array[Index] ) ) { m_iItemIndices[Slot] = Index; return TRUE; } } m_iItemIndices[Slot] = -1; return TRUE; } void CPlayerInventory::SpawnInventory( CBasePlayer *pPlayer ) { for( int i = 0;i < 5;i++ ) { playeritemlist_t *pList = GetListForSlot( i ); int index; if( m_bRandom ) { // Randomize weapon index = RANDOM_FLOAT( -1, pList->size-1 ); if( !g_pGameRules->AcceptInventory( &pList->array[index] ) ) index = -1; } else index = m_iItemIndices[i]; if( index < 0 ) continue; char *weapon_classname = pList->array[index].weapon_classname; char *ammo_classname = pList->array[index].ammo_classname; int ammo_count = pList->array[index].num_ammospawns; // Spawn ammo for weapon if( ammo_classname != NULL ) { for( int j = 0;j < ammo_count;j++ ) pPlayer->GiveNamedItem( ammo_classname ); } // Spawn weapon pPlayer->GiveNamedItem( weapon_classname ); } // Spawn with best weapon selected CBasePlayerItem *pBest; int iBestWeight = -1 ; for( i = 0;i < MAX_ITEM_TYPES;i++ ) { CBasePlayerItem *pWeap = pPlayer->m_rgpPlayerItems[ i ]; while( pWeap != NULL ) { if( pWeap->iWeight() > iBestWeight && pWeap != pPlayer->m_pActiveItem ) { if( pWeap->CanDeploy() ) { pBest = pWeap; iBestWeight = pWeap->iWeight(); } } pWeap = pWeap->m_pNext; } } if( pBest != NULL ) pPlayer->SwitchWeapon( pBest ); } void CPlayerInventory::SetRandom( BOOL b ) { m_bRandom = b; if( m_bRandom == TRUE ) memset( m_iItemIndices, -1, sizeof( m_iItemIndices ) ); } playeritemlist_t *CPlayerInventory::GetListForSlot( int Slot ) { playeritemlist_t *pList; switch( Slot ) { case 0: pList = &g_MeleeItems; break; case 1: pList = &g_SidearmItems; break; case 2: pList = &g_PrimaryItems; break; case 3: pList = &g_UniqueItems; break; case 4: pList = &g_OtherItems; break; default: pList = NULL; break; } return pList; } #if 0 /* CPlayerInventory */ BOOL CPlayerInventory::bSetInventory(char *pszClassname,int iSlot) { // Get category int iCat = iGetCategory(pszClassname); int iSecondaryIndex = -1; // Make sure this item isnt already in the inventory more than it should be for(int i = 0;i < 3;i++) { // This comes into play later on if(iGetCategory(m_pszItemClasses[i]) == CAT_SECONDARY) iSecondaryIndex = i; } // If this is a secondary weapon, make sure we dont have one already in inventory if(iSecondaryIndex != -1) iSlot = iSecondaryIndex; // Now we just go ahead and fill in based on the slot the user wants to use strcpy(m_pszItemClasses[iSlot],pszClassname); return TRUE; } void CPlayerInventory::SpawnInventory(CBasePlayer *pPlayer) { if(m_bRandomItems) { int unique = 0; int secondary = 0; BOOL bUseSecondary = FALSE; int count = 0; // First lets find out where the 0 number (unique) weapons start for(playeritem_t *pCurItem = &g_PlayerItems[0];pCurItem->weapon_classname != NULL;pCurItem++) { if(pCurItem->category == CAT_UNIQUE) break; unique++; } // Then we find where the secondary weapons start for(pCurItem = &g_PlayerItems[0];pCurItem->weapon_classname != NULL;pCurItem++) { if(pCurItem->category == CAT_SECONDARY) break; secondary++; } // Now that we have our constraints, we can start spawning items. for(int i = 0;i < 3;i++) { int index = bUseSecondary ? RANDOM_LONG(0,secondary-1) : RANDOM_LONG(0,unique-1); pCurItem = &g_PlayerItems[index]; if(pCurItem->category == CAT_SECONDARY) bUseSecondary = TRUE; count = 0; // See if we already tried to spawn this item. for(int j = 0;j < 3;j++) if(!strcmp(pCurItem->weapon_classname,m_pszItemClasses[i])) count++; if(count) continue; // Add it up :) strcpy(m_pszItemClasses[i],pCurItem->weapon_classname); } } for(int i = 0;i < 3;i++) { // Spawn weapons if(strcmp(m_pszItemClasses[i],"")) { pPlayer->GiveNamedItem(m_pszItemClasses[i]); // Spawn ammo for(playeritem_t *pCurItem = &g_PlayerItems[0];pCurItem->weapon_classname != NULL;pCurItem++) { if( !strcmp( m_pszItemClasses[i], pCurItem->weapon_classname ) ) { // Now items! for( int j = 0;j < pCurItem->num_ammospawns;j++ ) pPlayer->GiveNamedItem(pCurItem->ammo_classname); break; } } } } } int CPlayerInventory::iGetCategory(char *pszClassname) { for(playeritem_t *pCurItem = &g_PlayerItems[0];pCurItem->weapon_classname != NULL;pCurItem++) { if(!strcmp(pCurItem->weapon_classname,pszClassname)) return pCurItem->category; } return CAT_NONE; } #endif LINK_ENTITY_TO_CLASS( player, CBasePlayer ); void CBasePlayer :: Pain( void ) { float flRndSound;//sound randomizer flRndSound = RANDOM_FLOAT ( 0 , 1 ); if ( flRndSound <= 0.33 ) EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_pain5.wav", 1, ATTN_NORM); else if ( flRndSound <= 0.66 ) EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_pain6.wav", 1, ATTN_NORM); else EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_pain7.wav", 1, ATTN_NORM); } /* * */ Vector VecVelocityForDamage(float flDamage) { Vector vec(RANDOM_FLOAT(-100,100), RANDOM_FLOAT(-100,100), RANDOM_FLOAT(200,300)); if (flDamage > -50) vec = vec * 0.7; else if (flDamage > -200) vec = vec * 2; else vec = vec * 10; return vec; } #if 0 /* static void ThrowGib(entvars_t *pev, char *szGibModel, float flDamage) { edict_t *pentNew = CREATE_ENTITY(); entvars_t *pevNew = VARS(pentNew); pevNew->origin = pev->origin; SET_MODEL(ENT(pevNew), szGibModel); UTIL_SetSize(pevNew, g_vecZero, g_vecZero); pevNew->velocity = VecVelocityForDamage(flDamage); pevNew->movetype = MOVETYPE_BOUNCE; pevNew->solid = SOLID_NOT; pevNew->avelocity.x = RANDOM_FLOAT(0,600); pevNew->avelocity.y = RANDOM_FLOAT(0,600); pevNew->avelocity.z = RANDOM_FLOAT(0,600); CHANGE_METHOD(ENT(pevNew), em_think, SUB_Remove); pevNew->ltime = gpGlobals->time; pevNew->nextthink = gpGlobals->time + RANDOM_FLOAT(10,20); pevNew->frame = 0; pevNew->flags = 0; } static void ThrowHead(entvars_t *pev, char *szGibModel, floatflDamage) { SET_MODEL(ENT(pev), szGibModel); pev->frame = 0; pev->nextthink = -1; pev->movetype = MOVETYPE_BOUNCE; pev->takedamage = DAMAGE_NO; pev->solid = SOLID_NOT; pev->view_ofs = Vector(0,0,8); UTIL_SetSize(pev, Vector(-16,-16,0), Vector(16,16,56)); pev->velocity = VecVelocityForDamage(flDamage); pev->avelocity = RANDOM_FLOAT(-1,1) * Vector(0,600,0); pev->origin.z -= 24; ClearBits(pev->flags, FL_ONGROUND); } */ #endif int TrainSpeed(int iSpeed, int iMax) { float fSpeed, fMax; int iRet = 0; fMax = (float)iMax; fSpeed = iSpeed; fSpeed = fSpeed/fMax; if (iSpeed < 0) iRet = TRAIN_BACK; else if (iSpeed == 0) iRet = TRAIN_NEUTRAL; else if (fSpeed < 0.33) iRet = TRAIN_SLOW; else if (fSpeed < 0.66) iRet = TRAIN_MEDIUM; else iRet = TRAIN_FAST; return iRet; } void CBasePlayer :: DeathSound( void ) { // water death sounds /* if (pev->waterlevel == 3) { EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/h2odeath.wav", 1, ATTN_NONE); return; } */ // temporarily using pain sounds for death sounds switch (RANDOM_LONG(1,5)) { case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_pain5.wav", 1, ATTN_NORM); break; case 2: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_pain6.wav", 1, ATTN_NORM); break; case 3: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_pain7.wav", 1, ATTN_NORM); break; } } // override takehealth // bitsDamageType indicates type of damage healed. int CBasePlayer :: TakeHealth( float flHealth, int bitsDamageType ) { return CBaseMonster :: TakeHealth (flHealth, bitsDamageType); } Vector CBasePlayer :: GetGunPosition( ) { // UTIL_MakeVectors(pev->v_angle); // m_HackedGunPos = pev->view_ofs; Vector origin; origin = pev->origin + pev->view_ofs; return origin; } //========================================================= // TraceAttack //========================================================= void CBasePlayer :: TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType,int PenetrationValue) { if ( pev->takedamage ) { // If this bullet has gone through // a wall, reduce bullet damage if(PenetrationValue) { flDamage *= PenetrationValue; if(flDamage < 0) return; } m_LastHitGroup = ptr->iHitgroup; switch ( ptr->iHitgroup ) { case HITGROUP_GENERIC: break; case HITGROUP_HEAD: switch(RANDOM_LONG(0,2)) { case 0: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/headshot1.wav", 1, ATTN_NORM); break; case 1: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/headshot2.wav", 1, ATTN_NORM); break; case 2: default: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/headshot3.wav", 1, ATTN_NORM); break; } if(!(bitsDamageType & DMG_BUCKSHOT)) { pev->vuser2.y = 1; // Store off headshot value. flDamage *= HEAD_DAMAGE; } break; case HITGROUP_CHEST: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/chest_hit1.wav", 1, ATTN_NORM); if(!(bitsDamageType & DMG_BUCKSHOT)) flDamage *= CHEST_DAMAGE; break; case HITGROUP_STOMACH: if(!(bitsDamageType & DMG_BUCKSHOT)) flDamage *= GUT_DAMAGE; break; case HITGROUP_LEFTARM: case HITGROUP_RIGHTARM: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/arm_hit1.wav", 1, ATTN_NORM); if(!(bitsDamageType & DMG_BUCKSHOT)) flDamage *= ARM_DAMAGE; break; case HITGROUP_LEFTLEG: case HITGROUP_RIGHTLEG: EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/leg_hit1.wav", 1, ATTN_NORM); if(!(bitsDamageType & DMG_BUCKSHOT)) flDamage *= LEG_DAMAGE; break; default: break; } // FIX: Molotovs/Explosives shouldnt have blood streams if(!(bitsDamageType & DMG_BURN) && !(bitsDamageType & DMG_BLAST)) UTIL_BloodStream(pev->origin,vecDir*(flDamage/2),70,flDamage*5); if(flDamage && flDamage < pev->health) { // Flash blends for damage if(bitsDamageType == DMG_BULLET_CONC) { UTIL_ScreenShake( pev->origin,(int)(flDamage/3),12,1.5,0.1); UTIL_ScreenFade(this,RGB_CONC,TIME_CONC,HOLD_CONC,ALPHA_CONC,FLAGS_CONC); } else if( !(bitsDamageType & DMG_SHOCK) ) UTIL_ScreenFade(this,RGB_SHOT,TIME_SHOT,HOLD_SHOT,ALPHA_SHOT,FLAGS_SHOT); else { UTIL_ScreenFade(this,RGB_SHOCK,TIME_SHOCK,HOLD_SHOCK,ALPHA_SHOCK,FLAGS_SHOCK); } } SpawnBlood(ptr->vecEndPos, BloodColor(), flDamage);// a little surface blood. TraceBleed( flDamage, vecDir, ptr, bitsDamageType ); AddMultiDamage( pevAttacker, this, flDamage,bitsDamageType); } } /* Take some damage. NOTE: each call to TakeDamage with bitsDamageType set to a time-based damage type will cause the damage time countdown to be reset. Thus the ongoing effects of poison, radiation etc are implemented with subsequent calls to TakeDamage using DMG_GENERIC. */ #define ARMOR_RATIO 0.2 // Armor Takes 80% of the damage #define ARMOR_BONUS 0.5 // Each Point of Armor is work 1/x points of health int CBasePlayer :: TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType ) { int bitsDamage = bitsDamageType; int ffound = TRUE; int fmajor; int fcritical; int fTookDamage; int ftrivial; float flRatio; float flBonus; float flHealthPrev = pev->health; flBonus = ARMOR_BONUS; flRatio = ARMOR_RATIO; if ( ( bitsDamageType & DMG_BLAST ) && g_pGameRules->IsMultiplayer() ) { // blasts damage armor more. flBonus *= 2; } // Already dead if ( !IsAlive() ) return 0; // go take the damage first CBaseEntity *pAttacker = CBaseEntity::Instance(pevAttacker); if ( !g_pGameRules->FPlayerCanTakeDamage( this, pAttacker ) ) { // Refuse the damage return 0; } // keep track of amount of damage last sustained m_lastDamageAmount = flDamage; // Armor. if (pev->armorvalue && !(bitsDamageType & (DMG_FALL | DMG_DROWN)) )// armor doesn't protect against fall or drown damage! { float flNew = flDamage * flRatio; float flArmor; flArmor = (flDamage - flNew) * flBonus; // Does this use more armor than we have? if (flArmor > pev->armorvalue) { flArmor = pev->armorvalue; flArmor *= (1/flBonus); flNew = flDamage - flArmor; pev->armorvalue = 0; } else pev->armorvalue -= flArmor; flDamage = flNew; } // this cast to INT is critical!!! If a player ends up with 0.5 health, the engine will get that // as an int (zero) and think the player is dead! (this will incite a clientside screentilt, etc) fTookDamage = CBaseMonster::TakeDamage(pevInflictor, pevAttacker, (int)flDamage, bitsDamageType); // reset damage time countdown for each type of time based damage player just sustained { for (int i = 0; i < CDMG_TIMEBASED; i++) if (bitsDamageType & (DMG_PARALYZE << i)) m_rgbTimeBasedDamage[i] = 0; } // tell director about it MESSAGE_BEGIN ( MSG_SPEC, SVC_DIRECTOR ); WRITE_BYTE ( 9 ); //command length in bytes WRITE_BYTE ( DRC_EVENT ); WRITE_SHORT( ENTINDEX(this->edict()) ); WRITE_SHORT( ENTINDEX(ENT(pevInflictor)) ); WRITE_LONG ( 5 ); MESSAGE_END(); // how bad is it, doc? ftrivial = (pev->health > 75 || m_lastDamageAmount < 5); fmajor = (m_lastDamageAmount > 25); fcritical = (pev->health < 30); // handle all bits set in this damage message, // UNDONE: add sounds for types of damage sustained (ie: burn, shock, slash ) // UNDONE: still need to record damage and heal messages for the following types // DMG_BURN // DMG_FREEZE // DMG_BLAST // DMG_SHOCK m_bitsDamageType |= bitsDamage; // Save this so we can report it to the client m_bitsHUDDamage = -1; // make sure the damage bits get resent while (fTookDamage && (!ftrivial || (bitsDamage & DMG_TIMEBASED)) && ffound && bitsDamage) { ffound = FALSE; if (bitsDamage & DMG_CLUB) { bitsDamage &= ~DMG_CLUB; ffound = TRUE; } if (bitsDamage & (DMG_FALL | DMG_CRUSH)) { bitsDamage &= ~(DMG_FALL | DMG_CRUSH); ffound = TRUE; } if (bitsDamage & DMG_BULLET) { bitsDamage &= ~DMG_BULLET; ffound = TRUE; } if (bitsDamage & DMG_SLASH) { bitsDamage &= ~DMG_SLASH; ffound = TRUE; } if (bitsDamage & DMG_SONIC) { bitsDamage &= ~DMG_SONIC; ffound = TRUE; } if (bitsDamage & (DMG_POISON | DMG_PARALYZE)) { bitsDamage &= ~(DMG_POISON | DMG_PARALYZE); ffound = TRUE; } if (bitsDamage & DMG_ACID) { bitsDamage &= ~DMG_ACID; ffound = TRUE; } if (bitsDamage & DMG_NERVEGAS) { bitsDamage &= ~DMG_NERVEGAS; ffound = TRUE; } if (bitsDamage & DMG_RADIATION) { bitsDamage &= ~DMG_RADIATION; ffound = TRUE; } if (bitsDamage & DMG_SHOCK) { bitsDamage &= ~DMG_SHOCK; ffound = TRUE; } } pev->punchangle.x = -2; // Store who it is (bleeding death credit) m_pLastAttacker = pevAttacker; return fTookDamage; } //========================================================= // PackDeadPlayerItems - call this when a player dies to // pack up the appropriate weapons and ammo items, and to // destroy anything that shouldn't be packed. // // This is pretty brute force :( //========================================================= void CBasePlayer::PackDeadPlayerItems( void ) { int iWeaponRules; int iAmmoRules; int i; CBasePlayerWeapon *rgpPackWeapons[ 20 ];// 20 hardcoded for now. How to determine exactly how many weapons we have? int iPackAmmo[ MAX_AMMO_SLOTS + 1]; int iPW = 0;// index into packweapons array int iPA = 0;// index into packammo array memset(rgpPackWeapons, NULL, sizeof(rgpPackWeapons) ); memset(iPackAmmo, -1, sizeof(iPackAmmo) ); // get the game rules iWeaponRules = g_pGameRules->DeadPlayerWeapons( this ); iAmmoRules = g_pGameRules->DeadPlayerAmmo( this ); if ( iWeaponRules == GR_PLR_DROP_GUN_NO && iAmmoRules == GR_PLR_DROP_AMMO_NO ) { // nothing to pack. Remove the weapons and return. Don't call create on the box! RemoveAllItems(); return; } // go through all of the weapons and make a list of the ones to pack for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ ) { if ( m_rgpPlayerItems[ i ] ) { // there's a weapon here. Should I pack it? CBasePlayerItem *pPlayerItem = m_rgpPlayerItems[ i ]; while ( pPlayerItem ) { CBasePlayerWeapon *pWeapon = (CBasePlayerWeapon*)pPlayerItem; if( pWeapon != NULL && pWeapon->iWeight() == WEIGHT_UNIQUE) { rgpPackWeapons[ iPW++ ] = (CBasePlayerWeapon *)pPlayerItem; } else { switch( iWeaponRules ) { case GR_PLR_DROP_GUN_ACTIVE: if ( m_pActiveItem && pPlayerItem == m_pActiveItem ) { // this is the active item. Pack it. rgpPackWeapons[ iPW++ ] = (CBasePlayerWeapon *)pPlayerItem; } break; case GR_PLR_DROP_GUN_ALL: rgpPackWeapons[ iPW++ ] = (CBasePlayerWeapon *)pPlayerItem; break; default: break; } } pPlayerItem = pPlayerItem->m_pNext; } } } // now go through ammo and make a list of which types to pack. if ( iAmmoRules != GR_PLR_DROP_AMMO_NO ) { for ( i = 0 ; i < MAX_AMMO_SLOTS ; i++ ) { if ( m_rgAmmo[ i ] > 0 ) { // player has some ammo of this type. switch ( iAmmoRules ) { case GR_PLR_DROP_AMMO_ALL: iPackAmmo[ iPA++ ] = i; break; case GR_PLR_DROP_AMMO_ACTIVE: if ( m_pActiveItem && i == m_pActiveItem->PrimaryAmmoIndex() ) { // this is the primary ammo type for the active weapon iPackAmmo[ iPA++ ] = i; } else if ( m_pActiveItem && i == m_pActiveItem->SecondaryAmmoIndex() ) { // this is the secondary ammo type for the active weapon iPackAmmo[ iPA++ ] = i; } break; default: break; } } } } #if 0 // create a box to pack the stuff into. CWeaponBox *pWeaponBox = (CWeaponBox *)CBaseEntity::Create( "weaponbox", pev->origin, pev->angles, edict() ); pWeaponBox->pev->angles.x = 0;// don't let weaponbox tilt. pWeaponBox->pev->angles.z = 0; pWeaponBox->SetThink( CWeaponBox::Kill ); pWeaponBox->pev->nextthink = gpGlobals->time + 60.0f; // back these two lists up to their first elements iPA = 0; iPW = 0; // pack the ammo while ( iPackAmmo[ iPA ] != -1 ) { pWeaponBox->PackAmmo( MAKE_STRING( CBasePlayerItem::AmmoInfoArray[ iPackAmmo[ iPA ] ].pszName ), m_rgAmmo[ iPackAmmo[ iPA ] ] ); iPA++; } // now pack all of the items in the lists while ( rgpPackWeapons[ iPW ] ) { // weapon unhooked from the player. Pack it into der box. pWeaponBox->PackWeapon( rgpPackWeapons[ iPW ] ); iPW++; } pWeaponBox->pev->velocity = pev->velocity * 1.2;// weaponbox has player's velocity, then some. #endif // back these two lists up to their first elements iPA = 0; iPW = 0; // Create a box for each weapon :) while( rgpPackWeapons[ iPW ] ) { CWeaponBox *pWeaponBox = (CWeaponBox*)CBaseEntity::Create( "weaponbox", pev->origin, pev->angles, edict() ); pWeaponBox->pev->angles.x = 0 ;// don't let weaponbox tilt. pWeaponBox->pev->angles.z = 0; pWeaponBox->SetThink( CWeaponBox::Kill ); pWeaponBox->pev->nextthink = gpGlobals->time + 120; // pWeaponBox->pev->velocity = pev->velocity * 1.2;// weaponbox has player's velocity, then some. pWeaponBox->pev->velocity = gpGlobals->v_forward * RANDOM_FLOAT(200,300) + gpGlobals->v_right * RANDOM_FLOAT(-400,400); pWeaponBox->PackWeapon( rgpPackWeapons[ iPW ] ); iPW++; } RemoveAllItems();// now strip off everything that wasn't handled by the code above. } void CBasePlayer::RemoveAllItems( void ) { // This player isnt using a laser beam anymore :) g_pGameRules->SetLaserBeam( ENTINDEX( edict() ), FALSE ); if (m_pActiveItem) { ResetAutoaim( ); m_pActiveItem->Holster( ); m_pActiveItem = NULL; } m_pLastItem = NULL; int i; CBasePlayerItem *pPendingItem; for (i = 0; i < MAX_ITEM_TYPES; i++) { m_pActiveItem = m_rgpPlayerItems[i]; while (m_pActiveItem) { pPendingItem = m_pActiveItem->m_pNext; m_pActiveItem->Drop( ); m_pActiveItem = pPendingItem; } m_rgpPlayerItems[i] = NULL; } m_pActiveItem = NULL; pev->viewmodel = 0; pev->weaponmodel = 0; pev->weapons = 0; for ( i = 0; i < MAX_AMMO_SLOTS;i++) m_rgAmmo[i] = 0; UpdateClientData(); // send Selected Weapon Message to our client MESSAGE_BEGIN( MSG_ONE, gmsgCurWeapon, NULL, pev ); WRITE_BYTE(0); WRITE_BYTE(0); WRITE_BYTE(0); MESSAGE_END(); } /* * GLOBALS ASSUMED SET: g_ulModelIndexPlayer * * ENTITY_METHOD(PlayerDie) */ entvars_t *g_pevLastInflictor; // Set in combat.cpp. Used to pass the damage inflictor for death messages. // Better solution: Add as parameter to all Killed() functions. void CBasePlayer::Killed( entvars_t *pevAttacker, int iGib ) { CSound *pSound; // Holster weapon immediately, to allow it to cleanup if ( m_pActiveItem ) m_pActiveItem->Holster(); g_pGameRules->PlayerKilled( this, pevAttacker, g_pevLastInflictor); if ( m_pTank != NULL ) { m_pTank->Use( this, this, USE_OFF, 0 ); m_pTank = NULL; } // this client isn't going to be thinking for a while, so reset the sound until they respawn pSound = CSoundEnt::SoundPointerForIndex( CSoundEnt::ClientSoundIndex( edict() ) ); { if ( pSound ) { pSound->Reset(); } } SetAnimation( PLAYER_DIE ); m_iRespawnFrames = 0; pev->modelindex = g_ulModelIndexPlayer; // don't use eyes pev->deadflag = DEAD_DYING; pev->movetype = MOVETYPE_TOSS; ClearBits( pev->flags, FL_ONGROUND ); if (pev->velocity.z < 10) pev->velocity.z += RANDOM_FLOAT(0,300); // send "health" update message to zero m_iClientHealth = 0; MESSAGE_BEGIN( MSG_ONE, gmsgHealth, NULL, pev ); WRITE_BYTE( m_iClientHealth ); MESSAGE_END(); // Tell Ammo Hud that the player is dead MESSAGE_BEGIN( MSG_ONE, gmsgCurWeapon, NULL, pev ); WRITE_BYTE(0); WRITE_BYTE(0XFF); WRITE_BYTE(0xFF); MESSAGE_END(); // reset FOV pev->fov = m_iFOV = m_iClientFOV = 0; MESSAGE_BEGIN( MSG_ONE, gmsgSetFOV, NULL, pev ); WRITE_BYTE(0); MESSAGE_END(); if ( ( pev->health < -40 && iGib != GIB_NEVER ) || iGib == GIB_ALWAYS ) { pev->solid = SOLID_NOT; GibMonster(); // This clears pev->model pev->effects |= EF_NODRAW; return; } DeathSound(); pev->angles.x = 0; pev->angles.z = 0; SetThink(PlayerDeathThink); pev->nextthink = gpGlobals->time + 0.1; } // Set the activity based on an event or current state void CBasePlayer::SetAnimation( PLAYER_ANIM playerAnim ) { int animDesired; float speed; char szAnim[64]; speed = pev->velocity.Length2D(); if (pev->flags & FL_FROZEN) { speed = 0; playerAnim = PLAYER_IDLE; } switch (playerAnim) { case PLAYER_RELOAD: m_IdealActivity = ACT_RELOAD; break; case PLAYER_JUMP: m_IdealActivity = ACT_HOP; break; case PLAYER_SUPERJUMP: m_IdealActivity = ACT_LEAP; break; case PLAYER_DIE: m_IdealActivity = ACT_DIESIMPLE; m_IdealActivity = GetDeathActivity( ); break; case PLAYER_ATTACK1: switch( m_Activity ) { case ACT_HOVER: case ACT_SWIM: case ACT_HOP: case ACT_LEAP: case ACT_DIESIMPLE: m_IdealActivity = m_Activity; break; default: m_IdealActivity = ACT_RANGE_ATTACK1; break; } break; case PLAYER_IDLE: case PLAYER_WALK: if ( !FBitSet( pev->flags, FL_ONGROUND ) && (m_Activity == ACT_HOP || m_Activity == ACT_LEAP) ) // Still jumping { m_IdealActivity = m_Activity; } else if ( pev->waterlevel > 1 ) { if ( speed == 0 ) m_IdealActivity = ACT_HOVER; else m_IdealActivity = ACT_SWIM; } else { m_IdealActivity = ACT_WALK; } break; } switch (m_IdealActivity) { case ACT_WALK: if (m_Activity != ACT_RANGE_ATTACK1 || m_fSequenceFinished) { if(FBitSet(pev->flags,FL_DUCKING)) { strcpy( szAnim, "crouch_aim_" ); strcat( szAnim, m_szAnimExtention ); } else { strcpy( szAnim, "ref_aim_" ); strcpy( szAnim, m_szAnimExtention ); } animDesired = LookupSequence( szAnim ); if (animDesired == -1) animDesired = 0; m_Activity = ACT_WALK; } else { animDesired = pev->sequence; } break; case ACT_HOVER: case ACT_LEAP: case ACT_SWIM: case ACT_HOP: case ACT_DIESIMPLE: default: if ( m_Activity == m_IdealActivity) return; m_Activity = m_IdealActivity; animDesired = LookupActivity( m_Activity ); // Already using the desired animation? if (pev->sequence == animDesired) return; pev->gaitsequence = 0; pev->sequence = animDesired; pev->frame = 0; ResetSequenceInfo( ); return; case ACT_RELOAD: if(FBitSet(pev->flags,FL_DUCKING)) strcpy( szAnim, "crouch_shoot_reload_"); else strcpy( szAnim, "ref_shoot_reload_"); strcat( szAnim, m_szAnimExtention ); animDesired = LookupSequence( szAnim ); if(animDesired == -1) animDesired = 0; if(pev->sequence != animDesired || !m_fSequenceLoops) pev->frame = 0; if(!m_fSequenceLoops) pev->effects |= EF_NOINTERP; m_Activity = m_IdealActivity; pev->sequence = animDesired; ResetSequenceInfo(); break; case ACT_RANGE_ATTACK1: if(FBitSet(pev->flags,FL_DUCKING)) { strcpy( szAnim, "crouch_shoot_" ); strcat( szAnim, m_szAnimExtention ); } else { strcpy( szAnim, "ref_shoot_" ); strcpy( szAnim, m_szAnimExtention ); } animDesired = LookupSequence( szAnim ); if (animDesired == -1) animDesired = 0; if ( pev->sequence != animDesired || !m_fSequenceLoops ) { pev->frame = 0; } if (!m_fSequenceLoops) { pev->effects |= EF_NOINTERP; } m_Activity = m_IdealActivity; pev->sequence = animDesired; ResetSequenceInfo( ); break; } if ( FBitSet( pev->flags, FL_DUCKING ) ) { if ( speed == 0) { pev->gaitsequence = LookupActivity( ACT_CROUCHIDLE ); // pev->gaitsequence = LookupActivity( ACT_CROUCH ); } else { pev->gaitsequence = LookupActivity( ACT_CROUCH ); } } else if ( speed > 220 ) { pev->gaitsequence = LookupActivity( ACT_RUN ); } else if (speed > 0) { pev->gaitsequence = LookupActivity( ACT_WALK ); } else { // pev->gaitsequence = LookupActivity( ACT_WALK ); pev->gaitsequence = LookupSequence( "deep_idle" ); } // Already using the desired animation? if (pev->sequence == animDesired) return; //ALERT( at_console, "Set animation to %d\n", animDesired ); // Reset to first frame of desired animation pev->sequence = animDesired; pev->frame = 0; ResetSequenceInfo( ); } /* =========== TabulateAmmo This function is used to find and store all the ammo we have into the ammo vars. ============ */ void CBasePlayer::TabulateAmmo() { ammo_9mm = AmmoInventory( GetAmmoIndex("9mm Parabellum")); ammo_357 = AmmoInventory( GetAmmoIndex(".40 S&W")); ammo_bolts = AmmoInventory( GetAmmoIndex(".50 AE")); ammo_argrens = AmmoInventory( GetAmmoIndex(".454 Casull")); ammo_rockets = AmmoInventory( GetAmmoIndex(".223 Handcannon")); ammo_uranium = AmmoInventory( GetAmmoIndex("9mm SMG9 Ammo")); ammo_buckshot = AmmoInventory( GetAmmoIndex("Buckshot")); /* ammo_hornets = AmmoInventory( GetAmmoIndex( "Hornets" ) );*/ } /* =========== WaterMove ============ */ #define AIRTIME 12 // lung full of air lasts this many seconds void CBasePlayer::WaterMove() { int air; if (pev->movetype == MOVETYPE_NOCLIP) return; if (pev->health < 0) return; // waterlevel 0 - not in water // waterlevel 1 - feet in water // waterlevel 2 - waist in water // waterlevel 3 - head in water if (pev->waterlevel != 3) { // not underwater // play 'up for air' sound if (pev->air_finished < gpGlobals->time) EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_wade1.wav", 1, ATTN_NORM); else if (pev->air_finished < gpGlobals->time + 9) EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/pl_wade2.wav", 1, ATTN_NORM); pev->air_finished = gpGlobals->time + AIRTIME; pev->dmg = 2; // if we took drowning damage, give it back slowly if (m_idrowndmg > m_idrownrestored) { // set drowning damage bit. hack - dmg_drownrecover actually // makes the time based damage code 'give back' health over time. // make sure counter is cleared so we start count correctly. // NOTE: this actually causes the count to continue restarting // until all drowning damage is healed. m_bitsDamageType |= DMG_DROWNRECOVER; m_bitsDamageType &= ~DMG_DROWN; m_rgbTimeBasedDamage[itbd_DrownRecover] = 0; } } else { // fully under water // stop restoring damage while underwater m_bitsDamageType &= ~DMG_DROWNRECOVER; m_rgbTimeBasedDamage[itbd_DrownRecover] = 0; if (pev->air_finished < gpGlobals->time) // drown! { if (pev->pain_finished < gpGlobals->time) { // take drowning damage pev->dmg += 1; if (pev->dmg > 5) pev->dmg = 5; TakeDamage(VARS(eoNullEntity), VARS(eoNullEntity), pev->dmg, DMG_DROWN); pev->pain_finished = gpGlobals->time + 1; // track drowning damage, give it back when // player finally takes a breath m_idrowndmg += pev->dmg; } } else { m_bitsDamageType &= ~DMG_DROWN; } } if (!pev->waterlevel) { if (FBitSet(pev->flags, FL_INWATER)) { ClearBits(pev->flags, FL_INWATER); } return; } // make bubbles air = (int)(pev->air_finished - gpGlobals->time); if (!RANDOM_LONG(0,0x1f) && RANDOM_LONG(0,AIRTIME-1) >= air) { switch (RANDOM_LONG(0,3)) { case 0: EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_swim1.wav", 0.8, ATTN_NORM); break; case 1: EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_swim2.wav", 0.8, ATTN_NORM); break; case 2: EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_swim3.wav", 0.8, ATTN_NORM); break; case 3: EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_swim4.wav", 0.8, ATTN_NORM); break; } } if (pev->watertype == CONTENT_LAVA) // do damage { if (pev->dmgtime < gpGlobals->time) TakeDamage(VARS(eoNullEntity), VARS(eoNullEntity), 10 * pev->waterlevel, DMG_BURN); } else if (pev->watertype == CONTENT_SLIME) // do damage { pev->dmgtime = gpGlobals->time + 1; TakeDamage(VARS(eoNullEntity), VARS(eoNullEntity), 4 * pev->waterlevel, DMG_ACID); } if (!FBitSet(pev->flags, FL_INWATER)) { SetBits(pev->flags, FL_INWATER); pev->dmgtime = 0; } } // TRUE if the player is attached to a ladder BOOL CBasePlayer::IsOnLadder( void ) { return ( pev->movetype == MOVETYPE_FLY ); } void CBasePlayer::PlayerDeathThink(void) { float flForward; if (FBitSet(pev->flags, FL_ONGROUND)) { flForward = pev->velocity.Length() - 20; if (flForward <= 0) pev->velocity = g_vecZero; else pev->velocity = flForward * pev->velocity.Normalize(); } if ( HasWeapons() ) { // we drop the guns here because weapons that have an area effect and can kill their user // will sometimes crash coming back from CBasePlayer::Killed() if they kill their owner because the // player class sometimes is freed. It's safer to manipulate the weapons once we know // we aren't calling into any of their code anymore through the player pointer. PackDeadPlayerItems(); } if (pev->modelindex && (!m_fSequenceFinished) && (pev->deadflag == DEAD_DYING)) { StudioFrameAdvance( ); m_iRespawnFrames++; // Note, these aren't necessarily real "frames", so behavior is dependent on # of client movement commands if ( m_iRespawnFrames < 120 ) // Animations should be no longer than this return; } // once we're done animating our death and we're on the ground, we want to set movetype to None so our dead body won't do collisions and stuff anymore // this prevents a bug where the dead body would go to a player's head if he walked over it while the dead player was clicking their button to respawn if ( pev->movetype != MOVETYPE_NONE && FBitSet(pev->flags, FL_ONGROUND) ) pev->movetype = MOVETYPE_NONE; if (pev->deadflag == DEAD_DYING) pev->deadflag = DEAD_DEAD; StopAnimation(); pev->effects |= EF_NOINTERP; pev->framerate = 0.0; BOOL fAnyButtonDown = (pev->button & ~IN_SCORE ); // wait for all buttons released if (pev->deadflag == DEAD_DEAD) { if (fAnyButtonDown) return; if ( g_pGameRules->FPlayerCanRespawn( this ) ) { m_fDeadTime = gpGlobals->time; pev->deadflag = DEAD_RESPAWNABLE; } return; } // if the player has been dead for one second longer than allowed by forcerespawn, // forcerespawn isn't on. Send the player off to an intermission camera until they // choose to respawn. #if 0 if ( g_pGameRules->IsMultiplayer() && ( gpGlobals->time > (m_fDeadTime + 6) ) && !(m_afPhysicsFlags & PFLAG_OBSERVER) ) { // go to dead camera. StartDeathCam(); } #endif // If player has been dead for over 1 second, respond to key presses if( gpGlobals->time > (m_fDeadTime + 1.0f) ) { if( !fAnyButtonDown ) return; } else return; // wait for any button down, or mp_forcerespawn is set and the respawn time is up // if (!fAnyButtonDown // && !( g_pGameRules->IsMultiplayer() && forcerespawn.value > 0 && (gpGlobals->time > (m_fDeadTime + 5))) ) // return; // First, wait at least 5 seconds before respawning. if forcerespawn is set, respawn // Otherwise, just go ahead and wait for a button press. /* if(gpGlobals->time > (m_fDeadTime + 1)) { if(!fAnyButtonDown && !g_pGameRules->IsMultiplayer() ) return; } else return;*/ pev->button = 0; m_iRespawnFrames = 0; //ALERT(at_console, "Respawn\n"); respawn(pev, !(m_afPhysicsFlags & PFLAG_OBSERVER) );// don't copy a corpse if we're in deathcam. pev->nextthink = -1; } //========================================================= // StartDeathCam - find an intermission spot and send the // player off into observer mode //========================================================= void CBasePlayer::StartDeathCam( void ) { edict_t *pSpot, *pNewSpot; int iRand; if ( pev->view_ofs == g_vecZero ) { // don't accept subsequent attempts to StartDeathCam() return; } pSpot = FIND_ENTITY_BY_CLASSNAME( NULL, "info_intermission"); if ( !FNullEnt( pSpot ) ) { // at least one intermission spot in the world. iRand = RANDOM_LONG( 0, 3 ); while ( iRand > 0 ) { pNewSpot = FIND_ENTITY_BY_CLASSNAME( pSpot, "info_intermission"); if ( pNewSpot ) { pSpot = pNewSpot; } iRand--; } CopyToBodyQue( pev ); UTIL_ScreenFade(this,Vector(0,0,0),0,0,0,FFADE_OUT); StartObserver( pSpot->v.origin, pSpot->v.v_angle ); } else { // no intermission spot. Push them up in the air, looking down at their corpse TraceResult tr; CopyToBodyQue( pev ); UTIL_TraceLine( pev->origin, pev->origin + Vector( 0, 0, 128 ), ignore_monsters, edict(), &tr ); UTIL_ScreenFade(this,Vector(0,0,0),0,0,0,FFADE_OUT); StartObserver( tr.vecEndPos, UTIL_VecToAngles( tr.vecEndPos - pev->origin ) ); return; } } // // PlayerUse - handles USE keypress // #define PLAYER_SEARCH_RADIUS (float)64 void CBasePlayer::PlayerUse ( void ) { // Was use pressed or released? if ( ! ((pev->button | m_afButtonPressed | m_afButtonReleased) & IN_USE) ) return; // Hit Use on a train? if ( m_afButtonPressed & IN_USE ) { if ( m_pTank != NULL ) { // Stop controlling the tank // TODO: Send HUD Update m_pTank->Use( this, this, USE_OFF, 0 ); m_pTank = NULL; return; } else { if ( m_afPhysicsFlags & PFLAG_ONTRAIN ) { m_afPhysicsFlags &= ~PFLAG_ONTRAIN; m_iTrain = TRAIN_NEW|TRAIN_OFF; return; } else { // Start controlling the train! CBaseEntity *pTrain = CBaseEntity::Instance( pev->groundentity ); if ( pTrain && !(pev->button & IN_JUMP) && FBitSet(pev->flags, FL_ONGROUND) && (pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) && pTrain->OnControls(pev) ) { m_afPhysicsFlags |= PFLAG_ONTRAIN; m_iTrain = TrainSpeed(pTrain->pev->speed, pTrain->pev->impulse); m_iTrain |= TRAIN_NEW; EMIT_SOUND( ENT(pev), CHAN_ITEM, "plats/train_use1.wav", 0.8, ATTN_NORM); return; } } } } CBaseEntity *pObject = NULL; CBaseEntity *pClosest = NULL; Vector vecLOS; float flMaxDot = VIEW_FIELD_NARROW; float flDot; UTIL_MakeVectors ( pev->v_angle );// so we know which way we are facing while ((pObject = UTIL_FindEntityInSphere( pObject, pev->origin, PLAYER_SEARCH_RADIUS )) != NULL) { if (pObject->ObjectCaps() & (FCAP_IMPULSE_USE | FCAP_CONTINUOUS_USE | FCAP_ONOFF_USE)) { // !!!PERFORMANCE- should this check be done on a per case basis AFTER we've determined that // this object is actually usable? This dot is being done for every object within PLAYER_SEARCH_RADIUS // when player hits the use key. How many objects can be in that area, anyway? (sjb) vecLOS = (VecBModelOrigin( pObject->pev ) - (pev->origin + pev->view_ofs)); // This essentially moves the origin of the target to the corner nearest the player to test to see // if it's "hull" is in the view cone vecLOS = UTIL_ClampVectorToBox( vecLOS, pObject->pev->size * 0.5 ); flDot = DotProduct (vecLOS , gpGlobals->v_forward); if (flDot > flMaxDot ) {// only if the item is in front of the user pClosest = pObject; flMaxDot = flDot; // ALERT( at_console, "%s : %f\n", STRING( pObject->pev->classname ), flDot ); } // ALERT( at_console, "%s : %f\n", STRING( pObject->pev->classname ), flDot ); } } pObject = pClosest; // Found an object if (pObject ) { //!!!UNDONE: traceline here to prevent USEing buttons through walls int caps = pObject->ObjectCaps(); if ( m_afButtonPressed & IN_USE ) EMIT_SOUND( ENT(pev), CHAN_ITEM, "common/wpn_select.wav", 0.4, ATTN_NORM); if ( ( (pev->button & IN_USE) && (caps & FCAP_CONTINUOUS_USE) ) || ( (m_afButtonPressed & IN_USE) && (caps & (FCAP_IMPULSE_USE|FCAP_ONOFF_USE)) ) ) { if ( caps & FCAP_CONTINUOUS_USE ) m_afPhysicsFlags |= PFLAG_USING; pObject->Use( this, this, USE_SET, 1 ); } // UNDONE: Send different USE codes for ON/OFF. Cache last ONOFF_USE object to send 'off' if you turn away else if ( (m_afButtonReleased & IN_USE) && (pObject->ObjectCaps() & FCAP_ONOFF_USE) ) // BUGBUG This is an "off" use { pObject->Use( this, this, USE_SET, 0 ); } } else { if ( m_afButtonPressed & IN_USE ) EMIT_SOUND( ENT(pev), CHAN_ITEM, "common/wpn_denyselect.wav", 0.4, ATTN_NORM); } } void CBasePlayer::Jump() { Vector vecWallCheckDir;// direction we're tracing a line to find a wall when walljumping Vector vecAdjustedVelocity; Vector vecSpot; TraceResult tr; if (FBitSet(pev->flags, FL_WATERJUMP)) return; if (pev->waterlevel >= 2) { return; } // jump velocity is sqrt( height * gravity * 2) // If this isn't the first frame pressing the jump button, break out. if ( !FBitSet( m_afButtonPressed, IN_JUMP ) ) return; // don't pogo stick if ( !(pev->flags & FL_ONGROUND) || !pev->groundentity ) { return; } // many features in this function use v_forward, so makevectors now. UTIL_MakeVectors (pev->angles); // ClearBits(pev->flags, FL_ONGROUND); // don't stairwalk SetAnimation( PLAYER_JUMP ); if ( m_fLongJump && (pev->button & IN_DUCK) && ( pev->flDuckTime > 0 ) && pev->velocity.Length() > 50 ) { SetAnimation( PLAYER_SUPERJUMP ); } // If you're standing on a conveyor, add it's velocity to yours (for momentum) entvars_t *pevGround = VARS(pev->groundentity); if ( pevGround && (pevGround->flags & FL_CONVEYOR) ) { pev->velocity = pev->velocity + pev->basevelocity; } } // This is a glorious hack to find free space when you've crouched into some solid space // Our crouching collisions do not work correctly for some reason and this is easier // than fixing the problem :( void FixPlayerCrouchStuck( edict_t *pPlayer ) { TraceResult trace; // Move up as many as 18 pixels if the player is stuck. for ( int i = 0; i < 18; i++ ) { UTIL_TraceHull( pPlayer->v.origin, pPlayer->v.origin, dont_ignore_monsters, head_hull, pPlayer, &trace ); if ( trace.fStartSolid ) pPlayer->v.origin.z ++; else break; } } void CBasePlayer::Duck( ) { if (pev->button & IN_DUCK) { if ( m_IdealActivity != ACT_LEAP ) { SetAnimation( PLAYER_WALK ); } } } // // ID's player as such. // int CBasePlayer::Classify ( void ) { return CLASS_PLAYER; } void CBasePlayer::AddPoints( int score, BOOL bAllowNegativeScore ) { // Positive score always adds if ( score < 0 ) { if ( !bAllowNegativeScore ) { if ( pev->frags < 0 ) // Can't go more negative return; if ( -score > pev->frags ) // Will this go negative? { score = -pev->frags; // Sum will be 0 } } } pev->frags += score; MESSAGE_BEGIN( MSG_ALL, gmsgScoreInfo ); WRITE_BYTE( ENTINDEX(edict()) ); WRITE_SHORT( pev->frags ); WRITE_SHORT( m_iDeaths ); WRITE_SHORT( 0 ); WRITE_SHORT( g_pGameRules->GetTeamIndex( m_szTeamName ) + 1 ); MESSAGE_END(); } void CBasePlayer::AddPointsToTeam( int score, BOOL bAllowNegativeScore ) { int index = entindex(); for ( int i = 1; i <= gpGlobals->maxClients; i++ ) { CBaseEntity *pPlayer = UTIL_PlayerByIndex( i ); if ( pPlayer && i != index ) { if ( g_pGameRules->PlayerRelationship( this, pPlayer ) == GR_TEAMMATE ) { pPlayer->AddPoints( score, bAllowNegativeScore ); } } } } #define CLIMB_SHAKE_FREQUENCY 22 // how many frames in between screen shakes when climbing #define MAX_CLIMB_SPEED 200 // fastest vertical climbing speed possible #define CLIMB_SPEED_DEC 15 // climbing deceleration rate #define CLIMB_PUNCH_X -7 // how far to 'punch' client X axis when climbing #define CLIMB_PUNCH_Z 7 // how far to 'punch' client Z axis when climbing void CBasePlayer::PreThink(void) { int buttonsChanged = (m_afButtonLast ^ pev->button); // These buttons have changed this frame // Debounced button codes for pressed/released // UNDONE: Do we need auto-repeat? m_afButtonPressed = buttonsChanged & pev->button; // The changed ones still down are "pressed" m_afButtonReleased = buttonsChanged & (~pev->button); // The ones not down are "released" g_pGameRules->PlayerThink( this ); if ( g_fGameOver ) return; // intermission or finale UTIL_MakeVectors(pev->v_angle); // is this still used? ItemPreFrame( ); WaterMove(); if ( g_pGameRules && g_pGameRules->FAllowFlashlight() ) m_iHideHUD &= ~HIDEHUD_FLASHLIGHT; else m_iHideHUD |= HIDEHUD_FLASHLIGHT; // JOHN: checks if new client data (for HUD and view control) needs to be sent to the client UpdateClientData(); CheckTimeBasedDamage(); // Observer Button Handling if ( IsObserver() ) { Observer_HandleButtons(); pev->impulse = 0; return; } if (pev->deadflag >= DEAD_DYING) { PlayerDeathThink(); return; } // So the correct flags get sent to client asap. // if ( m_afPhysicsFlags & PFLAG_ONTRAIN ) pev->flags |= FL_ONTRAIN; else pev->flags &= ~FL_ONTRAIN; // Train speed control if ( m_afPhysicsFlags & PFLAG_ONTRAIN ) { CBaseEntity *pTrain = CBaseEntity::Instance( pev->groundentity ); float vel; if ( !pTrain ) { TraceResult trainTrace; // Maybe this is on the other side of a level transition UTIL_TraceLine( pev->origin, pev->origin + Vector(0,0,-38), ignore_monsters, ENT(pev), &trainTrace ); // HACKHACK - Just look for the func_tracktrain classname if ( trainTrace.flFraction != 1.0 && trainTrace.pHit ) pTrain = CBaseEntity::Instance( trainTrace.pHit ); if ( !pTrain || !(pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) || !pTrain->OnControls(pev) ) { //ALERT( at_error, "In train mode with no train!\n" ); m_afPhysicsFlags &= ~PFLAG_ONTRAIN; m_iTrain = TRAIN_NEW|TRAIN_OFF; return; } } else if ( !FBitSet( pev->flags, FL_ONGROUND ) || FBitSet( pTrain->pev->spawnflags, SF_TRACKTRAIN_NOCONTROL ) || (pev->button & (IN_MOVELEFT|IN_MOVERIGHT) ) ) { // Turn off the train if you jump, strafe, or the train controls go dead m_afPhysicsFlags &= ~PFLAG_ONTRAIN; m_iTrain = TRAIN_NEW|TRAIN_OFF; return; } pev->velocity = g_vecZero; vel = 0; if ( m_afButtonPressed & IN_FORWARD ) { vel = 1; pTrain->Use( this, this, USE_SET, (float)vel ); } else if ( m_afButtonPressed & IN_BACK ) { vel = -1; pTrain->Use( this, this, USE_SET, (float)vel ); } if (vel) { m_iTrain = TrainSpeed(pTrain->pev->speed, pTrain->pev->impulse); m_iTrain |= TRAIN_ACTIVE|TRAIN_NEW; } } else if (m_iTrain & TRAIN_ACTIVE) m_iTrain = TRAIN_NEW; // turn off train if (pev->button & IN_JUMP) { // If on a ladder, jump off the ladder // else Jump Jump(); } // If trying to duck, already ducked, or in the process of ducking if ((pev->button & IN_DUCK) || FBitSet(pev->flags,FL_DUCKING) || (m_afPhysicsFlags & PFLAG_DUCKING) ) Duck(); if ( !FBitSet ( pev->flags, FL_ONGROUND ) ) { m_flFallVelocity = -pev->velocity.z; } // StudioFrameAdvance( );//!!!HACKHACK!!! Can't be hit by traceline when not animating? // Clear out ladder pointer m_hEnemy = NULL; } /* Time based Damage works as follows: 1) There are several types of timebased damage: #define DMG_PARALYZE (1 << 14) // slows affected creature down #define DMG_NERVEGAS (1 << 15) // nerve toxins, very bad #define DMG_POISON (1 << 16) // blood poisioning #define DMG_RADIATION (1 << 17) // radiation exposure #define DMG_DROWNRECOVER (1 << 18) // drown recovery #define DMG_ACID (1 << 19) // toxic chemicals or acid burns #define DMG_SLOWBURN (1 << 20) // in an oven #define DMG_SLOWFREEZE (1 << 21) // in a subzero freezer 2) A new hit inflicting tbd restarts the tbd counter - each monster has an 8bit counter, per damage type. The counter is decremented every second, so the maximum time an effect will last is 255/60 = 4.25 minutes. Of course, staying within the radius of a damaging effect like fire, nervegas, radiation will continually reset the counter to max. 3) Every second that a tbd counter is running, the player takes damage. The damage is determined by the type of tdb. Paralyze - 1/2 movement rate, 30 second duration. Nervegas - 5 points per second, 16 second duration = 80 points max dose. Poison - 2 points per second, 25 second duration = 50 points max dose. Radiation - 1 point per second, 50 second duration = 50 points max dose. Drown - 5 points per second, 2 second duration. Acid/Chemical - 5 points per second, 10 second duration = 50 points max. Burn - 10 points per second, 2 second duration. Freeze - 3 points per second, 10 second duration = 30 points max. 4) Certain actions or countermeasures counteract the damaging effects of tbds: Armor/Heater/Cooler - Chemical(acid),burn, freeze all do damage to armor power, then to body Air In Lungs - drowning damage is done to air in lungs first, then to body - recharged by poking head out of water - 10 seconds if swiming fast Air In SCUBA - drowning damage is done to air in tanks first, then to body - 2 minutes in tanks. Need new tank once empty. Radiation Syringe - Each syringe full provides protection vs one radiation dosage Antitoxin Syringe - Each syringe full provides protection vs one poisoning (nervegas or poison). Health kit - Immediate stop to acid/chemical, fire or freeze damage. Radiation Shower - Immediate stop to radiation damage, acid/chemical or fire damage. */ // If player is taking time based damage, continue doing damage to player - // this simulates the effect of being poisoned, gassed, dosed with radiation etc - // anything that continues to do damage even after the initial contact stops. // Update all time based damage counters, and shut off any that are done. // The m_bitsDamageType bit MUST be set if any damage is to be taken. // This routine will detect the initial on value of the m_bitsDamageType // and init the appropriate counter. Only processes damage every second. //#define PARALYZE_DURATION 30 // number of 2 second intervals to take damage //#define PARALYZE_DAMAGE 0.0 // damage to take each 2 second interval //#define NERVEGAS_DURATION 16 //#define NERVEGAS_DAMAGE 5.0 //#define POISON_DURATION 25 //#define POISON_DAMAGE 2.0 //#define RADIATION_DURATION 50 //#define RADIATION_DAMAGE 1.0 //#define ACID_DURATION 10 //#define ACID_DAMAGE 5.0 //#define SLOWBURN_DURATION 2 //#define SLOWBURN_DAMAGE 1.0 //#define SLOWFREEZE_DURATION 1.0 //#define SLOWFREEZE_DAMAGE 3.0 /* */ void CBasePlayer::CheckTimeBasedDamage() { int i; BYTE bDuration = 0; static float gtbdPrev = 0.0; if (!(m_bitsDamageType & DMG_TIMEBASED)) return; // only check for time based damage approx. every 2 seconds if (abs(gpGlobals->time - m_tbdPrev) < 2.0) return; m_tbdPrev = gpGlobals->time; for (i = 0; i < CDMG_TIMEBASED; i++) { // make sure bit is set for damage type if (m_bitsDamageType & (DMG_PARALYZE << i)) { switch (i) { case itbd_Paralyze: // UNDONE - flag movement as half-speed bDuration = PARALYZE_DURATION; break; case itbd_NerveGas: // TakeDamage(pev, pev, NERVEGAS_DAMAGE, DMG_GENERIC); bDuration = NERVEGAS_DURATION; break; case itbd_Poison: TakeDamage(pev, pev, POISON_DAMAGE, DMG_GENERIC); bDuration = POISON_DURATION; break; case itbd_Radiation: // TakeDamage(pev, pev, RADIATION_DAMAGE, DMG_GENERIC); bDuration = RADIATION_DURATION; break; case itbd_DrownRecover: // NOTE: this hack is actually used to RESTORE health // after the player has been drowning and finally takes a breath if (m_idrowndmg > m_idrownrestored) { int idif = min(m_idrowndmg - m_idrownrestored, 10); TakeHealth(idif, DMG_GENERIC); m_idrownrestored += idif; } bDuration = 4; // get up to 5*10 = 50 points back break; case itbd_Acid: // TakeDamage(pev, pev, ACID_DAMAGE, DMG_GENERIC); bDuration = ACID_DURATION; break; case itbd_SlowBurn: // TakeDamage(pev, pev, SLOWBURN_DAMAGE, DMG_GENERIC); bDuration = SLOWBURN_DURATION; break; case itbd_SlowFreeze: // TakeDamage(pev, pev, SLOWFREEZE_DAMAGE, DMG_GENERIC); bDuration = SLOWFREEZE_DURATION; break; default: bDuration = 0; } if (m_rgbTimeBasedDamage[i]) { // decrement damage duration, detect when done. if (!m_rgbTimeBasedDamage[i] || --m_rgbTimeBasedDamage[i] == 0) { m_rgbTimeBasedDamage[i] = 0; // if we're done, clear damage bits m_bitsDamageType &= ~(DMG_PARALYZE << i); } } else // first time taking this damage type - init damage duration m_rgbTimeBasedDamage[i] = bDuration; } } } /* ================ CheckPowerups Check for turning off powerups GLOBALS ASSUMED SET: g_ulModelIndexPlayer ================ */ static void CheckPowerups(entvars_t *pev) { if (pev->health <= 0) return; pev->modelindex = g_ulModelIndexPlayer; // don't use eyes } //========================================================= // UpdatePlayerSound - updates the position of the player's // reserved sound slot in the sound list. //========================================================= void CBasePlayer :: UpdatePlayerSound ( void ) { int iBodyVolume; int iVolume; CSound *pSound; pSound = CSoundEnt::SoundPointerForIndex( CSoundEnt :: ClientSoundIndex( edict() ) ); if ( !pSound ) { ALERT ( at_console, "Client lost reserved sound!\n" ); return; } pSound->m_iType = bits_SOUND_NONE; // now calculate the best target volume for the sound. If the player's weapon // is louder than his body/movement, use the weapon volume, else, use the body volume. if ( FBitSet ( pev->flags, FL_ONGROUND ) ) { iBodyVolume = pev->velocity.Length(); // clamp the noise that can be made by the body, in case a push trigger, // weapon recoil, or anything shoves the player abnormally fast. if ( iBodyVolume > 512 ) { iBodyVolume = 512; } } else { iBodyVolume = 0; } if ( pev->button & IN_JUMP ) { iBodyVolume += 100; } // convert player move speed and actions into sound audible by monsters. if ( m_iWeaponVolume > iBodyVolume ) { m_iTargetVolume = m_iWeaponVolume; // OR in the bits for COMBAT sound if the weapon is being louder than the player. pSound->m_iType |= bits_SOUND_COMBAT; } else { m_iTargetVolume = iBodyVolume; } // decay weapon volume over time so bits_SOUND_COMBAT stays set for a while m_iWeaponVolume -= 250 * gpGlobals->frametime; if ( m_iWeaponVolume < 0 ) { iVolume = 0; } // if target volume is greater than the player sound's current volume, we paste the new volume in // immediately. If target is less than the current volume, current volume is not set immediately to the // lower volume, rather works itself towards target volume over time. This gives monsters a much better chance // to hear a sound, especially if they don't listen every frame. iVolume = pSound->m_iVolume; if ( m_iTargetVolume > iVolume ) { iVolume = m_iTargetVolume; } else if ( iVolume > m_iTargetVolume ) { iVolume -= 250 * gpGlobals->frametime; if ( iVolume < m_iTargetVolume ) { iVolume = 0; } } if ( m_fNoPlayerSound ) { // debugging flag, lets players move around and shoot without monsters hearing. iVolume = 0; } if ( gpGlobals->time > m_flStopExtraSoundTime ) { // since the extra sound that a weapon emits only lasts for one client frame, we keep that sound around for a server frame or two // after actual emission to make sure it gets heard. m_iExtraSoundTypes = 0; } if ( pSound ) { pSound->m_vecOrigin = pev->origin; pSound->m_iType |= ( bits_SOUND_PLAYER | m_iExtraSoundTypes ); pSound->m_iVolume = iVolume; } // keep track of virtual muzzle flash m_iWeaponFlash -= 256 * gpGlobals->frametime; if (m_iWeaponFlash < 0) m_iWeaponFlash = 0; //UTIL_MakeVectors ( pev->angles ); //gpGlobals->v_forward.z = 0; // Below are a couple of useful little bits that make it easier to determine just how much noise the // player is making. // UTIL_ParticleEffect ( pev->origin + gpGlobals->v_forward * iVolume, g_vecZero, 255, 25 ); //ALERT ( at_console, "%d/%d\n", iVolume, m_iTargetVolume ); } void CBasePlayer::PostThink() { if ( g_fGameOver ) goto pt_end; // intermission or finale if (!IsAlive()) goto pt_end; // Handle Tank controlling if ( m_pTank != NULL ) { // if they've moved too far from the gun, or selected a weapon, unuse the gun if ( m_pTank->OnControls( pev ) && !pev->weaponmodel ) { m_pTank->Use( this, this, USE_SET, 2 ); // try fire the gun } else { // they've moved off the platform m_pTank->Use( this, this, USE_OFF, 0 ); m_pTank = NULL; } } // do weapon stuff ItemPostFrame( ); // calculate weapon weight pev->fuser4 = flCalculateInventoryWeight(); // can this person use willpower ? pev->vuser3[0] = (m_bWillpower == TRUE) ? 1 : 0; // check to see if player landed hard enough to make a sound // falling farther than half of the maximum safe distance, but not as far a max safe distance will // play a bootscrape sound, and no damage will be inflicted. Fallling a distance shorter than half // of maximum safe distance will make no sound. Falling farther than max safe distance will play a // fallpain sound, and damage will be inflicted based on how far the player fell if ( (FBitSet(pev->flags, FL_ONGROUND)) && (pev->health > 0) && m_flFallVelocity >= PLAYER_FALL_PUNCH_THRESHHOLD ) { // ALERT ( at_console, "%f\n", m_flFallVelocity ); if (pev->watertype == CONTENT_WATER) { // Did he hit the world or a non-moving entity? // BUG - this happens all the time in water, especially when // BUG - water has current force // if ( !pev->groundentity || VARS(pev->groundentity)->velocity.z == 0 ) // EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_wade1.wav", 1, ATTN_NORM); } else if ( m_flFallVelocity > PLAYER_MAX_SAFE_FALL_SPEED ) {// after this point, we start doing damage float flFallDamage = g_pGameRules->FlPlayerFallDamage( this ); if ( flFallDamage > pev->health ) {//splat // note: play on item channel because we play footstep landing on body channel EMIT_SOUND(ENT(pev), CHAN_ITEM, "common/bodysplat.wav", 1, ATTN_NORM); } if ( flFallDamage > 0 ) { TakeDamage(VARS(eoNullEntity), VARS(eoNullEntity), flFallDamage, DMG_FALL ); pev->punchangle.x = 0; } } if ( IsAlive() ) { SetAnimation( PLAYER_WALK ); } } if (FBitSet(pev->flags, FL_ONGROUND)) { if (m_flFallVelocity > 64 && !g_pGameRules->IsMultiplayer()) { CSoundEnt::InsertSound ( bits_SOUND_PLAYER, pev->origin, m_flFallVelocity, 0.2 ); // ALERT( at_console, "fall %f\n", m_flFallVelocity ); } m_flFallVelocity = 0; } // select the proper animation for the player character if ( IsAlive() ) { if (!pev->velocity.x && !pev->velocity.y) SetAnimation( PLAYER_IDLE ); else if ((pev->velocity.x || pev->velocity.y) && (FBitSet(pev->flags, FL_ONGROUND))) SetAnimation( PLAYER_WALK ); else if (pev->waterlevel > 1) SetAnimation( PLAYER_WALK ); } StudioFrameAdvance( ); CheckPowerups(pev); UpdatePlayerSound(); // Track button info so we can detect 'pressed' and 'released' buttons next frame m_afButtonLast = pev->button; if(pev->health < 100 && IsAlive() && m_flNextHealthUpdate <= gpGlobals->time) { m_flNextHealthUpdate = gpGlobals->time + 2; if(pev->health >= PLAYER_COMPOSURE_LIMIT) { // Composure pev->health++; if(pev->health > pev->max_health) pev->health = pev->max_health; // Tell client about player state MESSAGE_BEGIN(MSG_ONE,gmsgPlayerState,NULL,pev); WRITE_BYTE(1); MESSAGE_END(); } else if(pev->health <= PLAYER_BLEED_LIMIT) { // Bleeding pev->vuser2.y = 2; TakeDamage(m_pLastAttacker,m_pLastAttacker,1.0f,DMG_BLEEDING); // Last person to hurt us gets credit. m_flLastAttack = gpGlobals->time; UTIL_ScreenFade(this,RGB_BLEED,TIME_BLEED,HOLD_BLEED,ALPHA_BLEED,FLAGS_BLEED); // blood drip if(pev->health <= 9) EMIT_SOUND(ENT(pev), CHAN_ITEM, "player/breathe2.wav", 0.5f, ATTN_NORM); else if(pev->health >= 10) EMIT_SOUND(ENT(pev), CHAN_ITEM, "player/breathe1.wav", 0.5f, ATTN_NORM); switch(RANDOM_LONG(0,2)) { case 0: break; EMIT_SOUND(ENT(pev), CHAN_BODY, "player/blood_drip1.wav", 1, ATTN_NORM); case 1: break; EMIT_SOUND(ENT(pev), CHAN_BODY, "player/blood_drip2.wav", 1, ATTN_NORM); case 2: default: EMIT_SOUND(ENT(pev), CHAN_BODY, "player/blood_drip3.wav", 1, ATTN_NORM); break; } // Tell client about player state MESSAGE_BEGIN(MSG_ONE,gmsgPlayerState,NULL,pev); WRITE_BYTE(2); MESSAGE_END(); } else if(pev->health >= PLAYER_WILLPOWER_LIMIT_LO && pev->health <= PLAYER_WILLPOWER_LIMIT_HI && m_bWillpower) { // Willpower pev->health++; if(pev->health > PLAYER_WILLPOWER_LIMIT_HI) m_bWillpower = FALSE; // Tell client about player state MESSAGE_BEGIN(MSG_ONE,gmsgPlayerState,NULL,pev); WRITE_BYTE(3); MESSAGE_END(); } else { // Tell client about player state MESSAGE_BEGIN(MSG_ONE,gmsgPlayerState,NULL,pev); WRITE_BYTE(0); MESSAGE_END(); } } // Blood trails if(pev->health <= PLAYER_BLEED_LIMIT && m_flNextBleedDrip <= gpGlobals->time) { m_flNextBleedDrip = gpGlobals->time + 0.3f; TraceResult tr; UTIL_TraceLine(pev->origin,pev->origin + Vector(0,0,-64),ignore_monsters,ENT(pev),&tr); UTIL_BloodDecalTrace(&tr,BLOOD_COLOR_RED); } pt_end: #if defined( CLIENT_WEAPONS ) // Decay timers on weapons // go through all of the weapons and make a list of the ones to pack for ( int i = 0 ; i < MAX_ITEM_TYPES ; i++ ) { if ( m_rgpPlayerItems[ i ] ) { CBasePlayerItem *pPlayerItem = m_rgpPlayerItems[ i ]; while ( pPlayerItem ) { CBasePlayerWeapon *gun; gun = (CBasePlayerWeapon *)pPlayerItem->GetWeaponPtr(); if ( gun && gun->UseDecrement() ) { gun->m_flNextPrimaryAttack = max( gun->m_flNextPrimaryAttack - gpGlobals->frametime, -1.0 ); gun->m_flNextSecondaryAttack = max( gun->m_flNextSecondaryAttack - gpGlobals->frametime, -0.001 ); if ( gun->m_flTimeWeaponIdle != 1000 ) { gun->m_flTimeWeaponIdle = max( gun->m_flTimeWeaponIdle - gpGlobals->frametime, -0.001 ); } if ( gun->pev->fuser1 != 1000 ) { gun->pev->fuser1 = max( gun->pev->fuser1 - gpGlobals->frametime, -0.001 ); } // Only decrement if not flagged as NO_DECREMENT // if ( gun->m_flPumpTime != 1000 ) // { // gun->m_flPumpTime = max( gun->m_flPumpTime - gpGlobals->frametime, -0.001 ); // } } pPlayerItem = pPlayerItem->m_pNext; } } } m_flNextAttack -= gpGlobals->frametime; if ( m_flNextAttack < -0.001 ) m_flNextAttack = -0.001; #else return; #endif } // as players gain more inventory items // they will have a tendency to slow // down. tell the game how much this player is carrying. float CBasePlayer::flCalculateInventoryWeight() { float flRet = 0; for(int i = 0;i < MAX_ITEM_TYPES;i++) if(m_rgpPlayerItems[ i ] != NULL) { CWasteWeapon *pThisWeapon = (CWasteWeapon*)m_rgpPlayerItems[i]; if(pThisWeapon != NULL) { flRet += (m_pActiveItem == pThisWeapon) ? pThisWeapon->iGetWeight() : pThisWeapon->iGetWeight() * 0.85f; } } // slightly less than the full value return flRet; } // checks if the spot is clear of players BOOL IsSpawnPointValid( CBaseEntity *pPlayer, CBaseEntity *pSpot ) { CBaseEntity *ent = NULL; if ( !pSpot->IsTriggered( pPlayer ) ) { return FALSE; } while ( (ent = UTIL_FindEntityInSphere( ent, pSpot->pev->origin, 128 )) != NULL ) { // if ent is a client, don't spawn on 'em if ( ent->IsPlayer() && ent != pPlayer ) return FALSE; } return TRUE; } DLL_GLOBAL CBaseEntity *g_pLastSpawn; inline int FNullEnt( CBaseEntity *ent ) { return (ent == NULL) || FNullEnt( ent->edict() ); } /* ============ EntSelectSpawnPoint Returns the entity to spawn at USES AND SETS GLOBAL g_pLastSpawn ============ */ edict_t *EntSelectSpawnPoint( CBaseEntity *pPlayer ) { CBaseEntity *pSpot; edict_t *player; player = pPlayer->edict(); // choose a info_player_deathmatch point if (g_pGameRules->IsCoOp()) { pSpot = UTIL_FindEntityByClassname( g_pLastSpawn, "info_player_coop"); if ( !FNullEnt(pSpot) ) goto ReturnSpot; pSpot = UTIL_FindEntityByClassname( g_pLastSpawn, "info_player_start"); if ( !FNullEnt(pSpot) ) goto ReturnSpot; } else if ( g_pGameRules->IsDeathmatch() ) { pSpot = g_pLastSpawn; // Randomize the start spot for ( int i = RANDOM_LONG(1,5); i > 0; i-- ) pSpot = UTIL_FindEntityByClassname( pSpot, "info_player_deathmatch" ); if ( FNullEnt( pSpot ) ) // skip over the null point pSpot = UTIL_FindEntityByClassname( pSpot, "info_player_deathmatch" ); CBaseEntity *pFirstSpot = pSpot; do { if ( pSpot ) { // check if pSpot is valid if ( IsSpawnPointValid( pPlayer, pSpot ) ) { if ( pSpot->pev->origin == Vector( 0, 0, 0 ) ) { pSpot = UTIL_FindEntityByClassname( pSpot, "info_player_deathmatch" ); continue; } // if so, go to pSpot goto ReturnSpot; } } // increment pSpot pSpot = UTIL_FindEntityByClassname( pSpot, "info_player_deathmatch" ); } while ( pSpot != pFirstSpot ); // loop if we're not back to the start // we haven't found a place to spawn yet, so kill any guy at the first spawn point and spawn there if ( !FNullEnt( pSpot ) ) { CBaseEntity *ent = NULL; while ( (ent = UTIL_FindEntityInSphere( ent, pSpot->pev->origin, 128 )) != NULL ) { // if ent is a client, kill em (unless they are ourselves) if ( ent->IsPlayer() && !(ent->edict() == player) ) ent->TakeDamage( VARS(INDEXENT(0)), VARS(INDEXENT(0)), 300, DMG_GENERIC ); } goto ReturnSpot; } } // If startspot is set, (re)spawn there. if ( FStringNull( gpGlobals->startspot ) || !strlen(STRING(gpGlobals->startspot))) { pSpot = UTIL_FindEntityByClassname(NULL, "info_player_start"); if ( !FNullEnt(pSpot) ) goto ReturnSpot; } else { pSpot = UTIL_FindEntityByTargetname( NULL, STRING(gpGlobals->startspot) ); if ( !FNullEnt(pSpot) ) goto ReturnSpot; } ReturnSpot: if ( FNullEnt( pSpot ) ) { ALERT(at_error, "PutClientInServer: no info_player_start on level"); return INDEXENT(0); } g_pLastSpawn = pSpot; return pSpot->edict(); } void CBasePlayer::Spawn( void ) { pev->classname = MAKE_STRING("player"); pev->health = 100; pev->armorvalue = 0; pev->takedamage = DAMAGE_AIM; pev->solid = SOLID_SLIDEBOX; pev->movetype = MOVETYPE_WALK; pev->max_health = pev->health; pev->flags &= FL_PROXY; // keep proxy flag sey by engine pev->flags |= FL_CLIENT; pev->air_finished = gpGlobals->time + 12; pev->dmg = 2; // initial water damage pev->effects = 0; pev->deadflag = DEAD_NO; pev->dmg_take = 0; pev->dmg_save = 0; pev->friction = 1.0; pev->gravity = 1.0; m_bitsHUDDamage = -1; m_bitsDamageType = 0; m_afPhysicsFlags = 0; m_fLongJump = FALSE;// no longjump module. g_engfuncs.pfnSetPhysicsKeyValue( edict(), "slj", "0" ); g_engfuncs.pfnSetPhysicsKeyValue( edict(), "hl", "1" ); pev->fov = m_iFOV = 0;// init field of view. m_iClientFOV = -1; // make sure fov reset is sent m_flNextDecalTime = 0;// let this player decal as soon as he spawns. m_flTimeStepSound = 0; m_iStepLeft = 0; m_flFieldOfView = 0.5;// some monsters use this to determine whether or not the player is looking at them. m_bloodColor = BLOOD_COLOR_RED; m_flNextAttack = UTIL_WeaponTimeBase(); StartSneaking(); m_iFlashBattery = 99; m_flFlashLightTime = 1; // force first message // dont let uninitialized value here hurt the player m_flFallVelocity = 0; g_pGameRules->SetDefaultPlayerTeam( this ); g_pGameRules->GetPlayerSpawnSpot( this ); SET_MODEL(ENT(pev), "models/player.mdl"); g_ulModelIndexPlayer = pev->modelindex; pev->sequence = LookupActivity( ACT_IDLE ); if ( FBitSet(pev->flags, FL_DUCKING) ) UTIL_SetSize(pev, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX); else UTIL_SetSize(pev, VEC_HULL_MIN, VEC_HULL_MAX); pev->view_ofs = VEC_VIEW; Precache(); m_HackedGunPos = Vector( 0, 32, 0 ); if ( m_iPlayerSound == SOUNDLIST_EMPTY ) { ALERT ( at_console, "Couldn't alloc player sound slot!\n" ); } m_fNoPlayerSound = FALSE;// normal sound behavior. m_pLastItem = NULL; m_fInitHUD = TRUE; m_iClientHideHUD = -1; // force this to be recalculated m_fWeapon = FALSE; m_pClientActiveItem = NULL; // Bleeding m_pLastAttacker = NULL; m_flNextBleedDrip = 0.0; m_flLastAttack = 0.0; m_bWillpower = TRUE; m_flNextHealthUpdate = 0.0; // reset all ammo values to 0 for ( int i = 0; i < MAX_AMMO_SLOTS; i++ ) { m_rgAmmo[i] = 0; m_rgAmmoLast[i] = 0; // client ammo values also have to be reset (the death hud clear messages does on the client side) } m_lastx = m_lasty = 0; pev->vuser2[2] = 1; // Player can scream from falling if(m_bCanSpawn) { m_iHideHUD &= ~( HIDEHUD_WEAPONS|HIDEHUD_FLASHLIGHT|HIDEHUD_HEALTH ); pev->effects &= ~EF_NODRAW; pev->iuser3 = 0; pev->vuser3[1] = 0; // Run all physics // Remove spectator standing MESSAGE_BEGIN(MSG_ALL,gmsgSpectator); WRITE_BYTE(ENTINDEX(edict())); WRITE_BYTE(0); MESSAGE_END(); g_pGameRules->PlayerSpawn(this); // Get his weapons, etc } else { if(m_bObserver) { pev->vuser3[1] = 0; // Run all physics StartObserver(pev->origin,pev->angles); } else { // Our player can just stick around pev->effects |= EF_NODRAW; pev->solid = SOLID_NOT; pev->takedamage = DAMAGE_NO; pev->movetype = MOVETYPE_NONE; pev->iuser3 = 1; pev->vuser3[1] = 1; // Dont run any player physics } m_iHideHUD |= HIDEHUD_WEAPONS|HIDEHUD_FLASHLIGHT|HIDEHUD_HEALTH; } } void CBasePlayer :: Precache( void ) { // in the event that the player JUST spawned, and the level node graph // was loaded, fix all of the node graph pointers before the game starts. // !!!BUGBUG - now that we have multiplayer, this needs to be moved! if ( WorldGraph.m_fGraphPresent && !WorldGraph.m_fGraphPointersSet ) { if ( !WorldGraph.FSetGraphPointers() ) { ALERT ( at_console, "**Graph pointers were not set!\n"); } else { ALERT ( at_console, "**Graph Pointers Set!\n" ); } } // SOUNDS / MODELS ARE PRECACHED in ClientPrecache() (game specific) // because they need to precache before any clients have connected m_bitsDamageType = 0; m_bitsHUDDamage = -1; m_iTrain = TRAIN_NEW; // Make sure any necessary user messages have been registered LinkUserMessages(); m_iUpdateTime = 5; // won't update for 1/2 a second if ( gInitHUD ) m_fInitHUD = TRUE; } int CBasePlayer::Save( CSave &save ) { if ( !CBaseMonster::Save(save) ) return 0; return save.WriteFields( "PLAYER", this, m_playerSaveData, ARRAYSIZE(m_playerSaveData) ); } // // Marks everything as new so the player will resend this to the hud. // void CBasePlayer::RenewItems(void) { } int CBasePlayer::Restore( CRestore &restore ) { if ( !CBaseMonster::Restore(restore) ) return 0; int status = restore.ReadFields( "PLAYER", this, m_playerSaveData, ARRAYSIZE(m_playerSaveData) ); SAVERESTOREDATA *pSaveData = (SAVERESTOREDATA *)gpGlobals->pSaveData; // landmark isn't present. if ( !pSaveData->fUseLandmark ) { ALERT( at_console, "No Landmark:%s\n", pSaveData->szLandmarkName ); // default to normal spawn edict_t* pentSpawnSpot = EntSelectSpawnPoint( this ); pev->origin = VARS(pentSpawnSpot)->origin + Vector(0,0,1); pev->angles = VARS(pentSpawnSpot)->angles; } pev->v_angle.z = 0; // Clear out roll pev->angles = pev->v_angle; pev->fixangle = TRUE; // turn this way immediately // Copied from spawn() for now m_bloodColor = BLOOD_COLOR_RED; g_ulModelIndexPlayer = pev->modelindex; if ( FBitSet(pev->flags, FL_DUCKING) ) { // Use the crouch HACK //FixPlayerCrouchStuck( edict() ); // Don't need to do this with new player prediction code. UTIL_SetSize(pev, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX); } else { UTIL_SetSize(pev, VEC_HULL_MIN, VEC_HULL_MAX); } g_engfuncs.pfnSetPhysicsKeyValue( edict(), "hl", "1" ); if ( m_fLongJump ) { g_engfuncs.pfnSetPhysicsKeyValue( edict(), "slj", "1" ); } else { g_engfuncs.pfnSetPhysicsKeyValue( edict(), "slj", "0" ); } RenewItems(); #if defined( CLIENT_WEAPONS ) // HACK: This variable is saved/restored in CBaseMonster as a time variable, but we're using it // as just a counter. Ideally, this needs its own variable that's saved as a plain float. // Barring that, we clear it out here instead of using the incorrect restored time value. m_flNextAttack = UTIL_WeaponTimeBase(); #endif return status; } void CBasePlayer::SelectNextItem( int iItem ) { CBasePlayerItem *pItem; pItem = m_rgpPlayerItems[ iItem ]; if( !g_pGameRules->FShouldSwitchWeapon( this, pItem ) ) return; if (!pItem) return; if (pItem == m_pActiveItem) { // select the next one in the chain pItem = m_pActiveItem->m_pNext; if (! pItem) { return; } CBasePlayerItem *pLast; pLast = pItem; while (pLast->m_pNext) pLast = pLast->m_pNext; // relink chain pLast->m_pNext = m_pActiveItem; m_pActiveItem->m_pNext = NULL; m_rgpPlayerItems[ iItem ] = pItem; } ResetAutoaim( ); // FIX, this needs to queue them up and delay if (m_pActiveItem) { m_pActiveItem->Holster( ); } m_pActiveItem = pItem; if (m_pActiveItem) { m_pActiveItem->Deploy( ); m_pActiveItem->UpdateItemInfo( ); } } void CBasePlayer::SelectItem(const char *pstr) { if (!pstr) return; CBasePlayerItem *pItem = NULL; for (int i = 0; i < MAX_ITEM_TYPES; i++) { if (m_rgpPlayerItems[i]) { pItem = m_rgpPlayerItems[i]; while (pItem) { if (FClassnameIs(pItem->pev, pstr)) break; pItem = pItem->m_pNext; } } if (pItem) break; } if (!pItem) return; if (pItem == m_pActiveItem) return; ResetAutoaim( ); // FIX, this needs to queue them up and delay if (m_pActiveItem) m_pActiveItem->Holster( ); m_pLastItem = m_pActiveItem; m_pActiveItem = pItem; if (m_pActiveItem) { m_pActiveItem->Deploy( ); m_pActiveItem->UpdateItemInfo( ); } } void CBasePlayer::SelectLastItem(void) { if (!m_pLastItem) { return; } if ( m_pActiveItem && !m_pActiveItem->CanHolster() ) { return; } ResetAutoaim( ); // FIX, this needs to queue them up and delay if (m_pActiveItem) m_pActiveItem->Holster( ); CBasePlayerItem *pTemp = m_pActiveItem; m_pActiveItem = m_pLastItem; m_pLastItem = pTemp; m_pActiveItem->Deploy( ); m_pActiveItem->UpdateItemInfo( ); } //============================================== // HasWeapons - do I have any weapons at all? //============================================== BOOL CBasePlayer::HasWeapons( void ) { int i; for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ ) { if ( m_rgpPlayerItems[ i ] ) { return TRUE; } } return FALSE; } void CBasePlayer::SelectPrevItem( int iItem ) { } const char *CBasePlayer::TeamID( void ) { if ( pev == NULL ) // Not fully connected yet return ""; // return their team name return m_szTeamName; } //============================================== // !!!UNDONE:ultra temporary SprayCan entity to apply // decal frame at a time. For PreAlpha CD //============================================== class CSprayCan : public CBaseEntity { public: void Spawn ( entvars_t *pevOwner ); void Think( void ); virtual int ObjectCaps( void ) { return FCAP_DONT_SAVE; } }; void CSprayCan::Spawn ( entvars_t *pevOwner ) { pev->origin = pevOwner->origin + Vector ( 0 , 0 , 32 ); pev->angles = pevOwner->v_angle; pev->owner = ENT(pevOwner); pev->frame = 0; pev->nextthink = gpGlobals->time + 0.1; EMIT_SOUND(ENT(pev), CHAN_VOICE, "player/sprayer.wav", 1, ATTN_NORM); } void CSprayCan::Think( void ) { TraceResult tr; int playernum; int nFrames; CBasePlayer *pPlayer; pPlayer = (CBasePlayer *)GET_PRIVATE(pev->owner); if (pPlayer) nFrames = pPlayer->GetCustomDecalFrames(); else nFrames = -1; playernum = ENTINDEX(pev->owner); // ALERT(at_console, "Spray by player %i, %i of %i\n", playernum, (int)(pev->frame + 1), nFrames); UTIL_MakeVectors(pev->angles); UTIL_TraceLine ( pev->origin, pev->origin + gpGlobals->v_forward * 128, ignore_monsters, pev->owner, & tr); // No customization present. if (nFrames == -1) { UTIL_DecalTrace( &tr, DECAL_LAMBDA6 ); UTIL_Remove( this ); } else { UTIL_PlayerDecalTrace( &tr, playernum, pev->frame, TRUE ); // Just painted last custom frame. if ( pev->frame++ >= (nFrames - 1)) UTIL_Remove( this ); } pev->nextthink = gpGlobals->time + 0.1; } class CBloodSplat : public CBaseEntity { public: void Spawn ( entvars_t *pevOwner ); void Spray ( void ); }; void CBloodSplat::Spawn ( entvars_t *pevOwner ) { pev->origin = pevOwner->origin + Vector ( 0 , 0 , 32 ); pev->angles = pevOwner->v_angle; pev->owner = ENT(pevOwner); SetThink ( Spray ); pev->nextthink = gpGlobals->time + 0.1; } void CBloodSplat::Spray ( void ) { TraceResult tr; // if ( g_Language != LANGUAGE_GERMAN ) // { UTIL_MakeVectors(pev->angles); UTIL_TraceLine ( pev->origin, pev->origin + gpGlobals->v_forward * 128, ignore_monsters, pev->owner, & tr); UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_RED ); // } SetThink ( SUB_Remove ); pev->nextthink = gpGlobals->time + 0.1; } //============================================== void CBasePlayer::GiveNamedItem( const char *pszName ) { edict_t *pent; int istr = MAKE_STRING(pszName); pent = CREATE_NAMED_ENTITY(istr); if ( FNullEnt( pent ) ) { ALERT ( at_console, "NULL Ent in GiveNamedItem!\n" ); return; } VARS( pent )->origin = pev->origin; pent->v.spawnflags |= SF_NORESPAWN; DispatchSpawn( pent ); DispatchTouch( pent, ENT( pev ) ); } CBaseEntity *FindEntityForward( CBaseEntity *pMe ) { TraceResult tr; UTIL_MakeVectors(pMe->pev->v_angle); UTIL_TraceLine(pMe->pev->origin + pMe->pev->view_ofs,pMe->pev->origin + pMe->pev->view_ofs + gpGlobals->v_forward * 8192,dont_ignore_monsters, pMe->edict(), &tr ); if ( tr.flFraction != 1.0 && !FNullEnt( tr.pHit) ) { CBaseEntity *pHit = CBaseEntity::Instance( tr.pHit ); return pHit; } return NULL; } BOOL CBasePlayer :: FlashlightIsOn( void ) { return FBitSet(pev->effects, EF_DIMLIGHT); } void CBasePlayer :: FlashlightTurnOn( void ) { if ( !g_pGameRules->FAllowFlashlight() ) { return; } EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, SOUND_FLASHLIGHT_ON, 1.0, ATTN_NORM, 0, PITCH_NORM ); SetBits(pev->effects, EF_DIMLIGHT); MESSAGE_BEGIN( MSG_ONE, gmsgFlashlight, NULL, pev ); WRITE_BYTE(1); WRITE_BYTE(m_iFlashBattery); MESSAGE_END(); m_flFlashLightTime = FLASH_DRAIN_TIME + gpGlobals->time; } void CBasePlayer :: FlashlightTurnOff( void ) { EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, SOUND_FLASHLIGHT_OFF, 1.0, ATTN_NORM, 0, PITCH_NORM ); ClearBits(pev->effects, EF_DIMLIGHT); MESSAGE_BEGIN( MSG_ONE, gmsgFlashlight, NULL, pev ); WRITE_BYTE(0); WRITE_BYTE(m_iFlashBattery); MESSAGE_END(); m_flFlashLightTime = FLASH_CHARGE_TIME + gpGlobals->time; } /* =============== ForceClientDllUpdate When recording a demo, we need to have the server tell us the entire client state so that the client side .dll can behave correctly. Reset stuff so that the state is transmitted. =============== */ void CBasePlayer :: ForceClientDllUpdate( void ) { m_iClientHealth = -1; m_iTrain |= TRAIN_NEW; // Force new train message. m_fWeapon = FALSE; // Force weapon send m_fKnownItem = FALSE; // Force weaponinit messages. // Now force all the necessary messages // to be sent. UpdateClientData(); } /* ============ ImpulseCommands ============ */ extern float g_flWeaponCheat; void CBasePlayer::ImpulseCommands( ) { TraceResult tr;// UNDONE: kill me! This is temporary for PreAlpha CDs // Handle use events PlayerUse(); int iImpulse = (int)pev->impulse; switch (iImpulse) { case 100: // temporary flashlight for level designers if ( FlashlightIsOn() ) { FlashlightTurnOff(); } else { FlashlightTurnOn(); } break; case 201:// paint decal if ( gpGlobals->time < m_flNextDecalTime ) { // too early! break; } UTIL_MakeVectors(pev->v_angle); UTIL_TraceLine ( pev->origin + pev->view_ofs, pev->origin + pev->view_ofs + gpGlobals->v_forward * 128, ignore_monsters, ENT(pev), & tr); if ( tr.flFraction != 1.0 ) {// line hit something, so paint a decal m_flNextDecalTime = gpGlobals->time + decalfrequency.value; CSprayCan *pCan = GetClassPtr((CSprayCan *)NULL); pCan->Spawn( pev ); } break; case 204: // Demo recording, update client dll specific data again. ForceClientDllUpdate(); break; default: // check all of the cheat impulse commands now CheatImpulseCommands( iImpulse ); break; } pev->impulse = 0; } //========================================================= //========================================================= void CBasePlayer::CheatImpulseCommands( int iImpulse ) { if ( g_flWeaponCheat == 0.0 ) { return; } CBaseEntity *pEntity; TraceResult tr; switch ( iImpulse ) { case 76: { if (!giPrecacheGrunt) { giPrecacheGrunt = 1; ALERT(at_console, "You must now restart to use Grunt-o-matic.\n"); } else { UTIL_MakeVectors( Vector( 0, pev->v_angle.y, 0 ) ); Create("monster_human_grunt", pev->origin + gpGlobals->v_forward * 128, pev->angles); } break; } case 101: { gEvilImpulse101 = TRUE; int i; for( i = 0;i < g_MeleeItems.size;i++ ) GiveNamedItem(g_MeleeItems.array[i].weapon_classname); for( i = 0;i < g_SidearmItems.size;i++ ) GiveNamedItem(g_SidearmItems.array[i].weapon_classname); for( i = 0;i < g_PrimaryItems.size;i++ ) GiveNamedItem(g_PrimaryItems.array[i].weapon_classname); for( i = 0;i < g_UniqueItems.size;i++ ) GiveNamedItem(g_UniqueItems.array[i].weapon_classname); for( i = 0;i < g_OtherItems.size;i++ ) GiveNamedItem(g_OtherItems.array[i].weapon_classname); gEvilImpulse101 = FALSE; } break; case 102: // Gibbage!!! CGib::SpawnRandomGibs( pev, 1, 1 ); break; case 103: // What the hell are you doing? pEntity = FindEntityForward( this ); if ( pEntity ) { CBaseMonster *pMonster = pEntity->MyMonsterPointer(); if ( pMonster ) pMonster->ReportAIState(); } break; case 104: // Dump all of the global state varaibles (and global entity names) gGlobalState.DumpGlobals(); break; case 105:// player makes no sound for monsters to hear. { if ( m_fNoPlayerSound ) { ALERT ( at_console, "Player is audible\n" ); m_fNoPlayerSound = FALSE; } else { ALERT ( at_console, "Player is silent\n" ); m_fNoPlayerSound = TRUE; } break; } case 106: // Give me the classname and targetname of this entity. pEntity = FindEntityForward( this ); if ( pEntity ) { ALERT ( at_console, "Classname: %s", STRING( pEntity->pev->classname ) ); if ( !FStringNull ( pEntity->pev->targetname ) ) { ALERT ( at_console, " - Targetname: %s\n", STRING( pEntity->pev->targetname ) ); } else { ALERT ( at_console, " - TargetName: No Targetname\n" ); } ALERT ( at_console, "Model: %s\n", STRING( pEntity->pev->model ) ); if ( pEntity->pev->globalname ) ALERT ( at_console, "Globalname: %s\n", STRING( pEntity->pev->globalname ) ); } break; case 107: { TraceResult tr; edict_t *pWorld = g_engfuncs.pfnPEntityOfEntIndex( 0 ); Vector start = pev->origin + pev->view_ofs; Vector end = start + gpGlobals->v_forward * 1024; UTIL_TraceLine( start, end, ignore_monsters, edict(), &tr ); if ( tr.pHit ) pWorld = tr.pHit; const char *pTextureName = TRACE_TEXTURE( pWorld, start, end ); if ( pTextureName ) ALERT( at_console, "Texture: %s\n", pTextureName ); } break; case 195:// show shortest paths for entire level to nearest node { Create("node_viewer_fly", pev->origin, pev->angles); } break; case 196:// show shortest paths for entire level to nearest node { Create("node_viewer_large", pev->origin, pev->angles); } break; case 197:// show shortest paths for entire level to nearest node { Create("node_viewer_human", pev->origin, pev->angles); } break; case 199:// show nearest node and all connections { ALERT ( at_console, "%d\n", WorldGraph.FindNearestNode ( pev->origin, bits_NODE_GROUP_REALM ) ); WorldGraph.ShowNodeConnections ( WorldGraph.FindNearestNode ( pev->origin, bits_NODE_GROUP_REALM ) ); } break; case 202:// Random blood splatter UTIL_MakeVectors(pev->v_angle); UTIL_TraceLine ( pev->origin + pev->view_ofs, pev->origin + pev->view_ofs + gpGlobals->v_forward * 128, ignore_monsters, ENT(pev), & tr); if ( tr.flFraction != 1.0 ) {// line hit something, so paint a decal CBloodSplat *pBlood = GetClassPtr((CBloodSplat *)NULL); pBlood->Spawn( pev ); } break; case 203:// remove creature. pEntity = FindEntityForward( this ); if ( pEntity ) { if ( pEntity->pev->takedamage ) pEntity->SetThink(SUB_Remove); } break; } } // // Add a weapon to the player (Item == Weapon == Selectable Object) // int CBasePlayer::AddPlayerItem( CBasePlayerItem *pItem ) { CBasePlayerItem *pInsert; pInsert = m_rgpPlayerItems[pItem->iItemSlot()]; while (pInsert) { if (FClassnameIs( pInsert->pev, STRING( pItem->pev->classname) )) { if (pItem->AddDuplicate( pInsert )) { g_pGameRules->PlayerGotWeapon ( this, pItem ); pItem->CheckRespawn(); // ugly hack to update clip w/o an update clip message pInsert->UpdateItemInfo( ); if (m_pActiveItem) m_pActiveItem->UpdateItemInfo( ); pItem->Kill( ); } else if (gEvilImpulse101) { // FIXME: remove anyway for deathmatch testing pItem->Kill( ); } return FALSE; } pInsert = pInsert->m_pNext; } if (pItem->AddToPlayer( this )) { g_pGameRules->PlayerGotWeapon ( this, pItem ); pItem->CheckRespawn(); pItem->m_pNext = m_rgpPlayerItems[pItem->iItemSlot()]; m_rgpPlayerItems[pItem->iItemSlot()] = pItem; // should we switch to this item? if ( g_pGameRules->FShouldSwitchWeapon( this, pItem ) ) { SwitchWeapon( pItem ); } return TRUE; } else if (gEvilImpulse101) { // FIXME: remove anyway for deathmatch testing pItem->Kill( ); } return FALSE; } int CBasePlayer::RemovePlayerItem( CBasePlayerItem *pItem ) { if (m_pActiveItem == pItem) { ResetAutoaim( ); pItem->Holster( ); pItem->pev->nextthink = 0;// crowbar may be trying to swing again, etc. pItem->SetThink( NULL ); m_pActiveItem = NULL; pev->viewmodel = 0; pev->weaponmodel = 0; } else if ( m_pLastItem == pItem ) m_pLastItem = NULL; CBasePlayerItem *pPrev = m_rgpPlayerItems[pItem->iItemSlot()]; if (pPrev == pItem) { m_rgpPlayerItems[pItem->iItemSlot()] = pItem->m_pNext; return TRUE; } else { while (pPrev && pPrev->m_pNext != pItem) { pPrev = pPrev->m_pNext; } if (pPrev) { pPrev->m_pNext = pItem->m_pNext; return TRUE; } } return FALSE; } // // Returns the unique ID for the ammo, or -1 if error // int CBasePlayer :: GiveAmmo( int iCount, char *szName, int iMax ) { if ( !szName ) { // no ammo. return -1; } if ( !g_pGameRules->CanHaveAmmo( this, szName, iMax ) ) { // game rules say I can't have any more of this ammo type. return -1; } int i = 0; i = GetAmmoIndex( szName ); if ( i < 0 || i >= MAX_AMMO_SLOTS ) return -1; int iAdd = min( iCount, iMax - m_rgAmmo[i] ); if ( iAdd < 1 ) return i; m_rgAmmo[ i ] += iAdd; if ( gmsgAmmoPickup ) // make sure the ammo messages have been linked first { // Send the message that ammo has been picked up MESSAGE_BEGIN( MSG_ONE, gmsgAmmoPickup, NULL, pev ); WRITE_BYTE( GetAmmoIndex(szName) ); // ammo ID WRITE_BYTE( iAdd ); // amount MESSAGE_END(); } TabulateAmmo(); return i; } /* ============ ItemPreFrame Called every frame by the player PreThink ============ */ void CBasePlayer::ItemPreFrame() { #if defined( CLIENT_WEAPONS ) if ( m_flNextAttack > 0 ) #else if ( gpGlobals->time < m_flNextAttack ) #endif { return; } if (!m_pActiveItem) return; m_pActiveItem->ItemPreFrame( ); } /* ============ ItemPostFrame Called every frame by the player PostThink ============ */ void CBasePlayer::ItemPostFrame() { static int fInSelect = FALSE; CWasteWeapon *pWeap = (CWasteWeapon*)(m_pActiveItem); if( pWeap != NULL ) { if( pWeap->bLaserActive() ) { g_pGameRules->SetLaserBeam( ENTINDEX( edict() ), TRUE ); } else { g_pGameRules->SetLaserBeam( ENTINDEX( edict() ), FALSE ); } } else g_pGameRules->SetLaserBeam( ENTINDEX( edict() ), FALSE ); // check if the player is using a tank if ( m_pTank != NULL ) return; #if defined( CLIENT_WEAPONS ) if ( m_flNextAttack > 0 ) #else if ( gpGlobals->time < m_flNextAttack ) #endif { return; } ImpulseCommands(); if (!m_pActiveItem) return; m_pActiveItem->ItemPostFrame( ); } int CBasePlayer::AmmoInventory( int iAmmoIndex ) { if (iAmmoIndex == -1) { return -1; } return m_rgAmmo[ iAmmoIndex ]; } int CBasePlayer::GetAmmoIndex(const char *psz) { int i; if (!psz) return -1; for (i = 1; i < MAX_AMMO_SLOTS; i++) { if ( !CBasePlayerItem::AmmoInfoArray[i].pszName ) continue; if (stricmp( psz, CBasePlayerItem::AmmoInfoArray[i].pszName ) == 0) return i; } return -1; } // Called from UpdateClientData // makes sure the client has all the necessary ammo info, if values have changed void CBasePlayer::SendAmmoUpdate(void) { for (int i=0; i < MAX_AMMO_SLOTS;i++) { if (m_rgAmmo[i] != m_rgAmmoLast[i]) { m_rgAmmoLast[i] = m_rgAmmo[i]; ASSERT( m_rgAmmo[i] >= 0 ); ASSERT( m_rgAmmo[i] < 255 ); // send "Ammo" update message MESSAGE_BEGIN( MSG_ONE, gmsgAmmoX, NULL, pev ); WRITE_BYTE( i ); WRITE_BYTE( max( min( m_rgAmmo[i], 254 ), 0 ) ); // clamp the value to one byte MESSAGE_END(); } } } /* ========================================================= UpdateClientData resends any changed player HUD info to the client. Called every frame by PlayerPreThink Also called at start of demo recording and playback by ForceClientDllUpdate to ensure the demo gets messages reflecting all of the HUD state info. ========================================================= */ void CBasePlayer :: UpdateClientData( void ) { if (m_fInitHUD) { m_fInitHUD = FALSE; gInitHUD = FALSE; MESSAGE_BEGIN( MSG_ONE, gmsgResetHUD, NULL, pev ); WRITE_BYTE( 0 ); MESSAGE_END(); if ( !m_fGameHUDInitialized ) { MESSAGE_BEGIN( MSG_ONE, gmsgInitHUD, NULL, pev ); MESSAGE_END(); g_pGameRules->InitHUD( this ); m_fGameHUDInitialized = TRUE; if ( g_pGameRules->IsMultiplayer() ) { FireTargets( "game_playerjoin", this, this, USE_TOGGLE, 0 ); } } FireTargets( "game_playerspawn", this, this, USE_TOGGLE, 0 ); } if ( m_iHideHUD != m_iClientHideHUD ) { MESSAGE_BEGIN( MSG_ONE, gmsgHideWeapon, NULL, pev ); WRITE_BYTE( m_iHideHUD ); MESSAGE_END(); m_iClientHideHUD = m_iHideHUD; } if ( m_iFOV != m_iClientFOV ) { MESSAGE_BEGIN( MSG_ONE, gmsgSetFOV, NULL, pev ); WRITE_BYTE( m_iFOV ); MESSAGE_END(); // cache FOV change at end of function, so weapon updates can see that FOV has changed } // HACKHACK -- send the message to display the game title if (gDisplayTitle) { MESSAGE_BEGIN( MSG_ONE, gmsgShowGameTitle, NULL, pev ); WRITE_BYTE( 0 ); MESSAGE_END(); gDisplayTitle = 0; } if (pev->health != m_iClientHealth) { int iHealth = max( pev->health, 0 ); // make sure that no negative health values are sent // send "health" update message MESSAGE_BEGIN( MSG_ONE, gmsgHealth, NULL, pev ); WRITE_BYTE( iHealth ); MESSAGE_END(); m_iClientHealth = pev->health; } if (pev->dmg_take || pev->dmg_save || m_bitsHUDDamage != m_bitsDamageType) { // Comes from inside me if not set Vector damageOrigin = pev->origin; // send "damage" message // causes screen to flash, and pain compass to show direction of damage edict_t *other = pev->dmg_inflictor; if ( other ) { CBaseEntity *pEntity = CBaseEntity::Instance(other); if ( pEntity ) damageOrigin = pEntity->Center(); } // only send down damage type that have hud art int visibleDamageBits = m_bitsDamageType & DMG_SHOWNHUD; MESSAGE_BEGIN( MSG_ONE, gmsgDamage, NULL, pev ); WRITE_BYTE( pev->dmg_save ); WRITE_BYTE( pev->dmg_take ); WRITE_LONG( visibleDamageBits ); WRITE_COORD( damageOrigin.x ); WRITE_COORD( damageOrigin.y ); WRITE_COORD( damageOrigin.z ); MESSAGE_END(); pev->dmg_take = 0; pev->dmg_save = 0; m_bitsHUDDamage = m_bitsDamageType; // Clear off non-time-based damage indicators m_bitsDamageType &= DMG_TIMEBASED; } // Update Flashlight if ((m_flFlashLightTime) && (m_flFlashLightTime <= gpGlobals->time)) { if (FlashlightIsOn()) { if (m_iFlashBattery) { m_flFlashLightTime = FLASH_DRAIN_TIME + gpGlobals->time; m_iFlashBattery--; if (!m_iFlashBattery) FlashlightTurnOff(); } } else { if (m_iFlashBattery < 100) { m_flFlashLightTime = FLASH_CHARGE_TIME + gpGlobals->time; m_iFlashBattery++; } else m_flFlashLightTime = 0; } MESSAGE_BEGIN( MSG_ONE, gmsgFlashBattery, NULL, pev ); WRITE_BYTE(m_iFlashBattery); MESSAGE_END(); } if (m_iTrain & TRAIN_NEW) { ASSERT( gmsgTrain > 0 ); // send "health" update message MESSAGE_BEGIN( MSG_ONE, gmsgTrain, NULL, pev ); WRITE_BYTE(m_iTrain & 0xF); MESSAGE_END(); m_iTrain &= ~TRAIN_NEW; } // // New Weapon? // if (!m_fKnownItem) { m_fKnownItem = TRUE; // WeaponInit Message // byte = # of weapons // // for each weapon: // byte name str length (not including null) // bytes... name // byte Ammo Type // byte Ammo2 Type // byte bucket // byte bucket pos // byte flags // ???? Icons // Send ALL the weapon info now int i; for (i = 0; i < MAX_WEAPONS; i++) { ItemInfo& II = CBasePlayerItem::ItemInfoArray[i]; if ( !II.iId ) continue; const char *pszName; if (!II.pszName) pszName = "Empty"; else pszName = II.pszName; MESSAGE_BEGIN( MSG_ONE, gmsgWeaponList, NULL, pev ); WRITE_STRING(pszName); // string weapon name WRITE_BYTE(GetAmmoIndex(II.pszAmmo1)); // byte Ammo Type WRITE_BYTE(II.iMaxAmmo1); // byte Max Ammo 1 WRITE_BYTE(GetAmmoIndex(II.pszAmmo2)); // byte Ammo2 Type WRITE_BYTE(II.iMaxAmmo2); // byte Max Ammo 2 WRITE_BYTE(II.iSlot); // byte bucket WRITE_BYTE(II.iPosition); // byte bucket pos WRITE_BYTE(II.iId); // byte id (bit index into pev->weapons) WRITE_BYTE(II.iFlags); // byte Flags MESSAGE_END(); } } SendAmmoUpdate(); // Update all the items for ( int i = 0; i < MAX_ITEM_TYPES; i++ ) { if ( m_rgpPlayerItems[i] ) // each item updates it's successors m_rgpPlayerItems[i]->UpdateClientData( this ); } // Cache and client weapon change m_pClientActiveItem = m_pActiveItem; m_iClientFOV = m_iFOV; } //========================================================= // FBecomeProne - Overridden for the player to set the proper // physics flags when a barnacle grabs player. //========================================================= BOOL CBasePlayer :: FBecomeProne ( void ) { return TRUE; } //========================================================= // Illumination // return player light level plus virtual muzzle flash //========================================================= int CBasePlayer :: Illumination( void ) { int iIllum = CBaseEntity::Illumination( ); iIllum += m_iWeaponFlash; if (iIllum > 255) return 255; return iIllum; } void CBasePlayer :: EnableControl(BOOL fControl) { if (!fControl) pev->flags |= FL_FROZEN; else pev->flags &= ~FL_FROZEN; } #define DOT_1DEGREE 0.9998476951564 #define DOT_2DEGREE 0.9993908270191 #define DOT_3DEGREE 0.9986295347546 #define DOT_4DEGREE 0.9975640502598 #define DOT_5DEGREE 0.9961946980917 #define DOT_6DEGREE 0.9945218953683 #define DOT_7DEGREE 0.9925461516413 #define DOT_8DEGREE 0.9902680687416 #define DOT_9DEGREE 0.9876883405951 #define DOT_10DEGREE 0.9848077530122 #define DOT_15DEGREE 0.9659258262891 #define DOT_20DEGREE 0.9396926207859 #define DOT_25DEGREE 0.9063077870367 //========================================================= // Autoaim // set crosshair position to point to enemey //========================================================= Vector CBasePlayer :: GetAutoaimVector( float flDelta ) { UTIL_MakeVectors( pev->v_angle + pev->punchangle ); return gpGlobals->v_forward; } Vector CBasePlayer :: AutoaimDeflection( Vector &vecSrc, float flDist, float flDelta ) { edict_t *pEdict = g_engfuncs.pfnPEntityOfEntIndex( 1 ); CBaseEntity *pEntity; float bestdot; Vector bestdir; edict_t *bestent; TraceResult tr; if ( g_psv_aim->value == 0 ) { m_fOnTarget = FALSE; return g_vecZero; } UTIL_MakeVectors( pev->v_angle + pev->punchangle + m_vecAutoAim ); // try all possible entities bestdir = gpGlobals->v_forward; bestdot = flDelta; // +- 10 degrees bestent = NULL; m_fOnTarget = FALSE; UTIL_TraceLine( vecSrc, vecSrc + bestdir * flDist, dont_ignore_monsters, edict(), &tr ); if ( tr.pHit && tr.pHit->v.takedamage != DAMAGE_NO) { // don't look through water if (!((pev->waterlevel != 3 && tr.pHit->v.waterlevel == 3) || (pev->waterlevel == 3 && tr.pHit->v.waterlevel == 0))) { if (tr.pHit->v.takedamage == DAMAGE_AIM) m_fOnTarget = TRUE; return m_vecAutoAim; } } for ( int i = 1; i < gpGlobals->maxEntities; i++, pEdict++ ) { Vector center; Vector dir; float dot; if ( pEdict->free ) // Not in use continue; if (pEdict->v.takedamage != DAMAGE_AIM) continue; if (pEdict == edict()) continue; // if (pev->team > 0 && pEdict->v.team == pev->team) // continue; // don't aim at teammate if ( !g_pGameRules->ShouldAutoAim( this, pEdict ) ) continue; pEntity = Instance( pEdict ); if (pEntity == NULL) continue; if (!pEntity->IsAlive()) continue; // don't look through water if ((pev->waterlevel != 3 && pEntity->pev->waterlevel == 3) || (pev->waterlevel == 3 && pEntity->pev->waterlevel == 0)) continue; center = pEntity->BodyTarget( vecSrc ); dir = (center - vecSrc).Normalize( ); // make sure it's in front of the player if (DotProduct (dir, gpGlobals->v_forward ) < 0) continue; dot = fabs( DotProduct (dir, gpGlobals->v_right ) ) + fabs( DotProduct (dir, gpGlobals->v_up ) ) * 0.5; // tweek for distance dot *= 1.0 + 0.2 * ((center - vecSrc).Length() / flDist); if (dot > bestdot) continue; // to far to turn UTIL_TraceLine( vecSrc, center, dont_ignore_monsters, edict(), &tr ); if (tr.flFraction != 1.0 && tr.pHit != pEdict) { // ALERT( at_console, "hit %s, can't see %s\n", STRING( tr.pHit->v.classname ), STRING( pEdict->v.classname ) ); continue; } // don't shoot at friends if (IRelationship( pEntity ) < 0) { if ( !pEntity->IsPlayer() && !g_pGameRules->IsDeathmatch()) // ALERT( at_console, "friend\n"); continue; } // can shoot at this one bestdot = dot; bestent = pEdict; bestdir = dir; } if (bestent) { bestdir = UTIL_VecToAngles (bestdir); bestdir.x = -bestdir.x; bestdir = bestdir - pev->v_angle - pev->punchangle; if (bestent->v.takedamage == DAMAGE_AIM) m_fOnTarget = TRUE; return bestdir; } return Vector( 0, 0, 0 ); } void CBasePlayer :: ResetAutoaim( ) { if (m_vecAutoAim.x != 0 || m_vecAutoAim.y != 0) { m_vecAutoAim = Vector( 0, 0, 0 ); SET_CROSSHAIRANGLE( edict(), 0, 0 ); } m_fOnTarget = FALSE; } /* ============= SetCustomDecalFrames UNDONE: Determine real frame limit, 8 is a placeholder. Note: -1 means no custom frames present. ============= */ void CBasePlayer :: SetCustomDecalFrames( int nFrames ) { if (nFrames > 0 && nFrames < 8) m_nCustomSprayFrames = nFrames; else m_nCustomSprayFrames = -1; } /* ============= GetCustomDecalFrames Returns the # of custom frames this player's custom clan logo contains. ============= */ int CBasePlayer :: GetCustomDecalFrames( void ) { return m_nCustomSprayFrames; } //========================================================= // DropPlayerItem - drop the named item, or if no name, // the active item. //========================================================= void CBasePlayer::DropPlayerItem ( char *pszItemName ) { if ( !g_pGameRules->IsMultiplayer() || (weaponstay.value > 0) ) { // no dropping in single player. return; } if ( !strlen( pszItemName ) ) { // if this string has no length, the client didn't type a name! // assume player wants to drop the active item. // make the string null to make future operations in this function easier pszItemName = NULL; } CBasePlayerItem *pWeapon; int i; for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ ) { pWeapon = m_rgpPlayerItems[ i ]; while ( pWeapon ) { if ( pszItemName ) { // try to match by name. if ( !strcmp( pszItemName, STRING( pWeapon->pev->classname ) ) ) { // match! break; } } else { // trying to drop active item if ( pWeapon == m_pActiveItem ) { // active item! break; } } pWeapon = pWeapon->m_pNext; } // if we land here with a valid pWeapon pointer, that's because we found the // item we want to drop and hit a BREAK; pWeapon is the item. if ( pWeapon ) { UTIL_MakeVectors ( pev->angles ); CWeaponBox *pWeaponBox = (CWeaponBox *)CBaseEntity::Create("weaponbox",pev->origin + gpGlobals->v_forward * 10,pev->angles,edict()); pWeaponBox->pev->angles.x = 0; pWeaponBox->pev->angles.z = 0; pWeaponBox->pev->velocity = gpGlobals->v_forward * RANDOM_FLOAT(200,300) + gpGlobals->v_right * RANDOM_FLOAT(-400,400); if( pWeapon->iFlags() & (ITEM_FLAG_EXHAUSTIBLE|ITEM_FLAG_LIMITINWORLD) ) { CBasePlayerWeapon *pLimitWeap = (CBasePlayerWeapon*)pWeapon; if( pLimitWeap ) { if( --m_rgAmmo[ pLimitWeap->m_iPrimaryAmmoType ] == 0 ) { g_pGameRules->GetNextBestWeapon( this, pWeapon ); pev->weapons &= ~(1<m_iId);// take item off hud } } CBaseEntity *pEnt = CBaseEntity::Create( (char*)STRING( pWeapon->pev->classname ), pev->origin, pev->angles, NULL ); pWeaponBox->PackWeapon( (CBasePlayerItem*)pEnt ); } else { g_pGameRules->GetNextBestWeapon( this, pWeapon ); pev->weapons &= ~(1<m_iId);// take item off hud pWeaponBox->PackWeapon( pWeapon ); } return;// we're done, so stop searching with the FOR loop. } } } //========================================================= // HasPlayerItem Does the player already have this item? //========================================================= BOOL CBasePlayer::HasPlayerItem( CBasePlayerItem *pCheckItem ) { CBasePlayerItem *pItem = m_rgpPlayerItems[pCheckItem->iItemSlot()]; while (pItem) { if (FClassnameIs( pItem->pev, STRING( pCheckItem->pev->classname) )) { return TRUE; } pItem = pItem->m_pNext; } return FALSE; } //========================================================= // HasNamedPlayerItem Does the player already have this item? //========================================================= BOOL CBasePlayer::HasNamedPlayerItem( const char *pszItemName ) { CBasePlayerItem *pItem; int i; for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ ) { pItem = m_rgpPlayerItems[ i ]; while (pItem) { if ( !strcmp( pszItemName, STRING( pItem->pev->classname ) ) ) { return TRUE; } pItem = pItem->m_pNext; } } return FALSE; } //========================================================= // //========================================================= BOOL CBasePlayer :: SwitchWeapon( CBasePlayerItem *pWeapon ) { if ( !pWeapon->CanDeploy() ) { return FALSE; } ResetAutoaim( ); if (m_pActiveItem) { m_pActiveItem->Holster( ); } m_pActiveItem = pWeapon; pWeapon->Deploy( ); return TRUE; } class CStripWeapons : public CPointEntity { public: void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); private: }; LINK_ENTITY_TO_CLASS( player_weaponstrip, CStripWeapons ); void CStripWeapons :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { CBasePlayer *pPlayer = NULL; if ( pActivator && pActivator->IsPlayer() ) { pPlayer = (CBasePlayer *)pActivator; } else if ( !g_pGameRules->IsDeathmatch() ) { pPlayer = (CBasePlayer *)CBaseEntity::Instance( g_engfuncs.pfnPEntityOfEntIndex( 1 ) ); } if ( pPlayer ) pPlayer->RemoveAllItems(); } class CRevertSaved : public CPointEntity { public: void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ); void EXPORT MessageThink( void ); void EXPORT LoadThink( void ); void KeyValue( KeyValueData *pkvd ); virtual int Save( CSave &save ); virtual int Restore( CRestore &restore ); static TYPEDESCRIPTION m_SaveData[]; inline float Duration( void ) { return pev->dmg_take; } inline float HoldTime( void ) { return pev->dmg_save; } inline float MessageTime( void ) { return m_messageTime; } inline float LoadTime( void ) { return m_loadTime; } inline void SetDuration( float duration ) { pev->dmg_take = duration; } inline void SetHoldTime( float hold ) { pev->dmg_save = hold; } inline void SetMessageTime( float time ) { m_messageTime = time; } inline void SetLoadTime( float time ) { m_loadTime = time; } private: float m_messageTime; float m_loadTime; }; LINK_ENTITY_TO_CLASS( player_loadsaved, CRevertSaved ); TYPEDESCRIPTION CRevertSaved::m_SaveData[] = { DEFINE_FIELD( CRevertSaved, m_messageTime, FIELD_FLOAT ), // These are not actual times, but durations, so save as floats DEFINE_FIELD( CRevertSaved, m_loadTime, FIELD_FLOAT ), }; IMPLEMENT_SAVERESTORE( CRevertSaved, CPointEntity ); void CRevertSaved :: KeyValue( KeyValueData *pkvd ) { if (FStrEq(pkvd->szKeyName, "duration")) { SetDuration( atof(pkvd->szValue) ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "holdtime")) { SetHoldTime( atof(pkvd->szValue) ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "messagetime")) { SetMessageTime( atof(pkvd->szValue) ); pkvd->fHandled = TRUE; } else if (FStrEq(pkvd->szKeyName, "loadtime")) { SetLoadTime( atof(pkvd->szValue) ); pkvd->fHandled = TRUE; } else CPointEntity::KeyValue( pkvd ); } void CRevertSaved :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) { UTIL_ScreenFadeAll( pev->rendercolor, Duration(), HoldTime(), pev->renderamt, FFADE_OUT ); pev->nextthink = gpGlobals->time + MessageTime(); SetThink( MessageThink ); } void CRevertSaved :: MessageThink( void ) { UTIL_ShowMessageAll( STRING(pev->message) ); float nextThink = LoadTime() - MessageTime(); if ( nextThink > 0 ) { pev->nextthink = gpGlobals->time + nextThink; SetThink( LoadThink ); } else LoadThink(); } void CRevertSaved :: LoadThink( void ) { if ( !gpGlobals->deathmatch ) { SERVER_COMMAND("reload\n"); } } //========================================================= // Multiplayer intermission spots. //========================================================= class CInfoIntermission:public CPointEntity { void Spawn( void ); void Think( void ); }; void CInfoIntermission::Spawn( void ) { UTIL_SetOrigin( pev, pev->origin ); pev->solid = SOLID_NOT; pev->effects = EF_NODRAW; pev->v_angle = g_vecZero; pev->nextthink = gpGlobals->time + 2;// let targets spawn! } void CInfoIntermission::Think ( void ) { edict_t *pTarget; // find my target pTarget = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(pev->target) ); if ( !FNullEnt(pTarget) ) { pev->v_angle = UTIL_VecToAngles( (pTarget->v.origin - pev->origin).Normalize() ); pev->v_angle.x = -pev->v_angle.x; } } LINK_ENTITY_TO_CLASS( info_intermission, CInfoIntermission );