You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2334 lines
64 KiB
2334 lines
64 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose: Player for Portal.
|
||
|
//
|
||
|
//=============================================================================//
|
||
|
|
||
|
#include "cbase.h"
|
||
|
#include "portal_player.h"
|
||
|
#include "globalstate.h"
|
||
|
#include "trains.h"
|
||
|
#include "game.h"
|
||
|
#include "portal_player_shared.h"
|
||
|
#include "predicted_viewmodel.h"
|
||
|
#include "in_buttons.h"
|
||
|
#include "portal_gamerules.h"
|
||
|
#include "weapon_portalgun.h"
|
||
|
#include "portal/weapon_physcannon.h"
|
||
|
#include "KeyValues.h"
|
||
|
#include "team.h"
|
||
|
#include "eventqueue.h"
|
||
|
#include "weapon_portalbase.h"
|
||
|
#include "engine/IEngineSound.h"
|
||
|
#include "ai_basenpc.h"
|
||
|
#include "SoundEmitterSystem/isoundemittersystembase.h"
|
||
|
#include "prop_portal_shared.h"
|
||
|
#include "player_pickup.h" // for player pickup code
|
||
|
#include "vphysics/player_controller.h"
|
||
|
#include "datacache/imdlcache.h"
|
||
|
#include "bone_setup.h"
|
||
|
#include "portal_gamestats.h"
|
||
|
#include "physicsshadowclone.h"
|
||
|
#include "physics_prop_ragdoll.h"
|
||
|
#include "soundenvelope.h"
|
||
|
#include "ai_speech.h" // For expressors, vcd playing
|
||
|
#include "sceneentity.h" // has the VCD precache function
|
||
|
|
||
|
// Max mass the player can lift with +use
|
||
|
#define PORTAL_PLAYER_MAX_LIFT_MASS 85
|
||
|
#define PORTAL_PLAYER_MAX_LIFT_SIZE 128
|
||
|
|
||
|
extern CBaseEntity *g_pLastSpawn;
|
||
|
|
||
|
extern void respawn(CBaseEntity *pEdict, bool fCopyCorpse);
|
||
|
|
||
|
|
||
|
// -------------------------------------------------------------------------------- //
|
||
|
// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
|
||
|
// -------------------------------------------------------------------------------- //
|
||
|
|
||
|
class CTEPlayerAnimEvent : public CBaseTempEntity
|
||
|
{
|
||
|
public:
|
||
|
DECLARE_CLASS( CTEPlayerAnimEvent, CBaseTempEntity );
|
||
|
DECLARE_SERVERCLASS();
|
||
|
|
||
|
CTEPlayerAnimEvent( const char *name ) : CBaseTempEntity( name )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
CNetworkHandle( CBasePlayer, m_hPlayer );
|
||
|
CNetworkVar( int, m_iEvent );
|
||
|
CNetworkVar( int, m_nData );
|
||
|
};
|
||
|
|
||
|
IMPLEMENT_SERVERCLASS_ST_NOBASE( CTEPlayerAnimEvent, DT_TEPlayerAnimEvent )
|
||
|
SendPropEHandle( SENDINFO( m_hPlayer ) ),
|
||
|
SendPropInt( SENDINFO( m_iEvent ), Q_log2( PLAYERANIMEVENT_COUNT ) + 1, SPROP_UNSIGNED ),
|
||
|
SendPropInt( SENDINFO( m_nData ), 32 ),
|
||
|
END_SEND_TABLE()
|
||
|
|
||
|
static CTEPlayerAnimEvent g_TEPlayerAnimEvent( "PlayerAnimEvent" );
|
||
|
|
||
|
void TE_PlayerAnimEvent( CBasePlayer *pPlayer, PlayerAnimEvent_t event, int nData )
|
||
|
{
|
||
|
CPVSFilter filter( (const Vector&)pPlayer->EyePosition() );
|
||
|
|
||
|
g_TEPlayerAnimEvent.m_hPlayer = pPlayer;
|
||
|
g_TEPlayerAnimEvent.m_iEvent = event;
|
||
|
g_TEPlayerAnimEvent.m_nData = nData;
|
||
|
g_TEPlayerAnimEvent.Create( filter, 0 );
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
//=================================================================================
|
||
|
//
|
||
|
// Ragdoll Entity
|
||
|
//
|
||
|
class CPortalRagdoll : public CBaseAnimatingOverlay, public CDefaultPlayerPickupVPhysics
|
||
|
{
|
||
|
public:
|
||
|
|
||
|
DECLARE_CLASS( CPortalRagdoll, CBaseAnimatingOverlay );
|
||
|
DECLARE_SERVERCLASS();
|
||
|
DECLARE_DATADESC();
|
||
|
|
||
|
CPortalRagdoll()
|
||
|
{
|
||
|
m_hPlayer.Set( NULL );
|
||
|
m_vecRagdollOrigin.Init();
|
||
|
m_vecRagdollVelocity.Init();
|
||
|
}
|
||
|
|
||
|
// Transmit ragdolls to everyone.
|
||
|
virtual int UpdateTransmitState()
|
||
|
{
|
||
|
return SetTransmitState( FL_EDICT_ALWAYS );
|
||
|
}
|
||
|
|
||
|
// In case the client has the player entity, we transmit the player index.
|
||
|
// In case the client doesn't have it, we transmit the player's model index, origin, and angles
|
||
|
// so they can create a ragdoll in the right place.
|
||
|
CNetworkHandle( CBaseEntity, m_hPlayer ); // networked entity handle
|
||
|
CNetworkVector( m_vecRagdollVelocity );
|
||
|
CNetworkVector( m_vecRagdollOrigin );
|
||
|
};
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( portal_ragdoll, CPortalRagdoll );
|
||
|
|
||
|
IMPLEMENT_SERVERCLASS_ST_NOBASE( CPortalRagdoll, DT_PortalRagdoll )
|
||
|
SendPropVector( SENDINFO(m_vecRagdollOrigin), -1, SPROP_COORD ),
|
||
|
SendPropEHandle( SENDINFO( m_hPlayer ) ),
|
||
|
SendPropModelIndex( SENDINFO( m_nModelIndex ) ),
|
||
|
SendPropInt ( SENDINFO(m_nForceBone), 8, 0 ),
|
||
|
SendPropVector ( SENDINFO(m_vecForce), -1, SPROP_NOSCALE ),
|
||
|
SendPropVector( SENDINFO( m_vecRagdollVelocity ) ),
|
||
|
END_SEND_TABLE()
|
||
|
|
||
|
|
||
|
BEGIN_DATADESC( CPortalRagdoll )
|
||
|
|
||
|
DEFINE_FIELD( m_vecRagdollOrigin, FIELD_POSITION_VECTOR ),
|
||
|
DEFINE_FIELD( m_hPlayer, FIELD_EHANDLE ),
|
||
|
DEFINE_FIELD( m_vecRagdollVelocity, FIELD_VECTOR ),
|
||
|
|
||
|
END_DATADESC()
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
LINK_ENTITY_TO_CLASS( player, CPortal_Player );
|
||
|
|
||
|
IMPLEMENT_SERVERCLASS_ST(CPortal_Player, DT_Portal_Player)
|
||
|
SendPropExclude( "DT_BaseAnimating", "m_flPlaybackRate" ),
|
||
|
SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
|
||
|
SendPropExclude( "DT_BaseAnimating", "m_nNewSequenceParity" ),
|
||
|
SendPropExclude( "DT_BaseAnimating", "m_nResetEventsParity" ),
|
||
|
SendPropExclude( "DT_BaseEntity", "m_angRotation" ),
|
||
|
SendPropExclude( "DT_BaseAnimatingOverlay", "overlay_vars" ),
|
||
|
SendPropExclude( "DT_BaseFlex", "m_viewtarget" ),
|
||
|
SendPropExclude( "DT_BaseFlex", "m_flexWeight" ),
|
||
|
SendPropExclude( "DT_BaseFlex", "m_blinktoggle" ),
|
||
|
|
||
|
// portal_playeranimstate and clientside animation takes care of these on the client
|
||
|
SendPropExclude( "DT_ServerAnimationData" , "m_flCycle" ),
|
||
|
SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ),
|
||
|
|
||
|
|
||
|
SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 0), 11, SPROP_CHANGES_OFTEN ),
|
||
|
SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 1), 11, SPROP_CHANGES_OFTEN ),
|
||
|
SendPropEHandle( SENDINFO( m_hRagdoll ) ),
|
||
|
SendPropInt( SENDINFO( m_iSpawnInterpCounter), 4 ),
|
||
|
SendPropInt( SENDINFO( m_iPlayerSoundType), 3 ),
|
||
|
SendPropBool( SENDINFO( m_bHeldObjectOnOppositeSideOfPortal) ),
|
||
|
SendPropEHandle( SENDINFO( m_pHeldObjectPortal ) ),
|
||
|
SendPropBool( SENDINFO( m_bPitchReorientation ) ),
|
||
|
SendPropEHandle( SENDINFO( m_hPortalEnvironment ) ),
|
||
|
SendPropEHandle( SENDINFO( m_hSurroundingLiquidPortal ) ),
|
||
|
SendPropBool( SENDINFO( m_bSuppressingCrosshair ) ),
|
||
|
SendPropExclude( "DT_BaseAnimating", "m_flPoseParameter" ),
|
||
|
|
||
|
END_SEND_TABLE()
|
||
|
|
||
|
BEGIN_DATADESC( CPortal_Player )
|
||
|
|
||
|
DEFINE_SOUNDPATCH( m_pWooshSound ),
|
||
|
|
||
|
DEFINE_FIELD( m_bHeldObjectOnOppositeSideOfPortal, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_pHeldObjectPortal, FIELD_EHANDLE ),
|
||
|
DEFINE_FIELD( m_bIntersectingPortalPlane, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_bStuckOnPortalCollisionObject, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_fTimeLastHurt, FIELD_TIME ),
|
||
|
DEFINE_FIELD( m_StatsThisLevel.iNumPortalsPlaced, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_StatsThisLevel.iNumStepsTaken, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_StatsThisLevel.fNumSecondsTaken, FIELD_FLOAT ),
|
||
|
DEFINE_FIELD( m_fTimeLastNumSecondsUpdate, FIELD_TIME ),
|
||
|
DEFINE_FIELD( m_iNumCamerasDetatched, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_bPitchReorientation, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_bIsRegenerating, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_fNeuroToxinDamageTime, FIELD_TIME ),
|
||
|
DEFINE_FIELD( m_hPortalEnvironment, FIELD_EHANDLE ),
|
||
|
DEFINE_FIELD( m_flExpressionLoopTime, FIELD_TIME ),
|
||
|
DEFINE_FIELD( m_iszExpressionScene, FIELD_STRING ),
|
||
|
DEFINE_FIELD( m_hExpressionSceneEnt, FIELD_EHANDLE ),
|
||
|
DEFINE_FIELD( m_vecTotalBulletForce, FIELD_VECTOR ),
|
||
|
DEFINE_FIELD( m_bSilentDropAndPickup, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_hRagdoll, FIELD_EHANDLE ),
|
||
|
DEFINE_FIELD( m_angEyeAngles, FIELD_VECTOR ),
|
||
|
DEFINE_FIELD( m_iPlayerSoundType, FIELD_INTEGER ),
|
||
|
DEFINE_FIELD( m_qPrePortalledViewAngles, FIELD_VECTOR ),
|
||
|
DEFINE_FIELD( m_bFixEyeAnglesFromPortalling, FIELD_BOOLEAN ),
|
||
|
DEFINE_FIELD( m_matLastPortalled, FIELD_VMATRIX_WORLDSPACE ),
|
||
|
DEFINE_FIELD( m_vWorldSpaceCenterHolder, FIELD_POSITION_VECTOR ),
|
||
|
DEFINE_FIELD( m_hSurroundingLiquidPortal, FIELD_EHANDLE ),
|
||
|
DEFINE_FIELD( m_bSuppressingCrosshair, FIELD_BOOLEAN ),
|
||
|
//DEFINE_FIELD ( m_PlayerAnimState, CPortalPlayerAnimState ),
|
||
|
//DEFINE_FIELD ( m_StatsThisLevel, PortalPlayerStatistics_t ),
|
||
|
|
||
|
DEFINE_EMBEDDEDBYREF( m_pExpresser ),
|
||
|
|
||
|
END_DATADESC()
|
||
|
|
||
|
ConVar sv_regeneration_wait_time ("sv_regeneration_wait_time", "1.0", FCVAR_REPLICATED );
|
||
|
|
||
|
const char *g_pszChellModel = "models/player/chell.mdl";
|
||
|
const char *g_pszPlayerModel = g_pszChellModel;
|
||
|
|
||
|
|
||
|
#define MAX_COMBINE_MODELS 4
|
||
|
#define MODEL_CHANGE_INTERVAL 5.0f
|
||
|
#define TEAM_CHANGE_INTERVAL 5.0f
|
||
|
|
||
|
#define PORTALPLAYER_PHYSDAMAGE_SCALE 4.0f
|
||
|
|
||
|
extern ConVar sv_turbophysics;
|
||
|
|
||
|
//----------------------------------------------------
|
||
|
// Player Physics Shadow
|
||
|
//----------------------------------------------------
|
||
|
#define VPHYS_MAX_DISTANCE 2.0
|
||
|
#define VPHYS_MAX_VEL 10
|
||
|
#define VPHYS_MAX_DISTSQR (VPHYS_MAX_DISTANCE*VPHYS_MAX_DISTANCE)
|
||
|
#define VPHYS_MAX_VELSQR (VPHYS_MAX_VEL*VPHYS_MAX_VEL)
|
||
|
|
||
|
|
||
|
extern float IntervalDistance( float x, float x0, float x1 );
|
||
|
|
||
|
//disable 'this' : used in base member initializer list
|
||
|
#pragma warning( disable : 4355 )
|
||
|
|
||
|
CPortal_Player::CPortal_Player()
|
||
|
{
|
||
|
|
||
|
m_PlayerAnimState = CreatePortalPlayerAnimState( this );
|
||
|
CreateExpresser();
|
||
|
|
||
|
UseClientSideAnimation();
|
||
|
|
||
|
m_angEyeAngles.Init();
|
||
|
|
||
|
m_iLastWeaponFireUsercmd = 0;
|
||
|
|
||
|
m_iSpawnInterpCounter = 0;
|
||
|
|
||
|
m_bHeldObjectOnOppositeSideOfPortal = false;
|
||
|
m_pHeldObjectPortal = 0;
|
||
|
|
||
|
m_bIntersectingPortalPlane = false;
|
||
|
|
||
|
m_bPitchReorientation = false;
|
||
|
|
||
|
m_bSilentDropAndPickup = false;
|
||
|
|
||
|
m_iszExpressionScene = NULL_STRING;
|
||
|
m_hExpressionSceneEnt = NULL;
|
||
|
m_flExpressionLoopTime = 0.0f;
|
||
|
m_bSuppressingCrosshair = false;
|
||
|
}
|
||
|
|
||
|
CPortal_Player::~CPortal_Player( void )
|
||
|
{
|
||
|
ClearSceneEvents( NULL, true );
|
||
|
|
||
|
if ( m_PlayerAnimState )
|
||
|
m_PlayerAnimState->Release();
|
||
|
|
||
|
CPortalRagdoll *pRagdoll = dynamic_cast<CPortalRagdoll*>( m_hRagdoll.Get() );
|
||
|
if( pRagdoll )
|
||
|
{
|
||
|
UTIL_Remove( pRagdoll );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::UpdateOnRemove( void )
|
||
|
{
|
||
|
BaseClass::UpdateOnRemove();
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::Precache( void )
|
||
|
{
|
||
|
BaseClass::Precache();
|
||
|
|
||
|
PrecacheScriptSound( "PortalPlayer.EnterPortal" );
|
||
|
PrecacheScriptSound( "PortalPlayer.ExitPortal" );
|
||
|
|
||
|
PrecacheScriptSound( "PortalPlayer.Woosh" );
|
||
|
PrecacheScriptSound( "PortalPlayer.FallRecover" );
|
||
|
|
||
|
PrecacheModel ( "sprites/glow01.vmt" );
|
||
|
|
||
|
//Precache Citizen models
|
||
|
PrecacheModel( g_pszPlayerModel );
|
||
|
PrecacheModel( g_pszChellModel );
|
||
|
|
||
|
PrecacheScriptSound( "NPC_Citizen.die" );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::CreateSounds()
|
||
|
{
|
||
|
if ( !m_pWooshSound )
|
||
|
{
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
CPASAttenuationFilter filter( this );
|
||
|
|
||
|
m_pWooshSound = controller.SoundCreate( filter, entindex(), "PortalPlayer.Woosh" );
|
||
|
controller.Play( m_pWooshSound, 0, 100 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::StopLoopingSounds()
|
||
|
{
|
||
|
if ( m_pWooshSound )
|
||
|
{
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
controller.SoundDestroy( m_pWooshSound );
|
||
|
m_pWooshSound = NULL;
|
||
|
}
|
||
|
|
||
|
BaseClass::StopLoopingSounds();
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::GiveAllItems( void )
|
||
|
{
|
||
|
EquipSuit();
|
||
|
|
||
|
CBasePlayer::GiveAmmo( 255, "Pistol");
|
||
|
CBasePlayer::GiveAmmo( 32, "357" );
|
||
|
|
||
|
CBasePlayer::GiveAmmo( 255, "AR2" );
|
||
|
CBasePlayer::GiveAmmo( 3, "AR2AltFire" );
|
||
|
CBasePlayer::GiveAmmo( 255, "SMG1");
|
||
|
CBasePlayer::GiveAmmo( 3, "smg1_grenade");
|
||
|
|
||
|
CBasePlayer::GiveAmmo( 255, "Buckshot");
|
||
|
CBasePlayer::GiveAmmo( 16, "XBowBolt" );
|
||
|
|
||
|
CBasePlayer::GiveAmmo( 3, "rpg_round");
|
||
|
CBasePlayer::GiveAmmo( 6, "grenade" );
|
||
|
|
||
|
GiveNamedItem( "weapon_crowbar" );
|
||
|
GiveNamedItem( "weapon_physcannon" );
|
||
|
|
||
|
GiveNamedItem( "weapon_pistol" );
|
||
|
GiveNamedItem( "weapon_357" );
|
||
|
|
||
|
GiveNamedItem( "weapon_smg1" );
|
||
|
GiveNamedItem( "weapon_ar2" );
|
||
|
|
||
|
GiveNamedItem( "weapon_shotgun" );
|
||
|
GiveNamedItem( "weapon_crossbow" );
|
||
|
|
||
|
GiveNamedItem( "weapon_rpg" );
|
||
|
GiveNamedItem( "weapon_frag" );
|
||
|
|
||
|
GiveNamedItem( "weapon_bugbait" );
|
||
|
|
||
|
//GiveNamedItem( "weapon_physcannon" );
|
||
|
CWeaponPortalgun *pPortalGun = static_cast<CWeaponPortalgun*>( GiveNamedItem( "weapon_portalgun" ) );
|
||
|
|
||
|
if ( !pPortalGun )
|
||
|
{
|
||
|
pPortalGun = static_cast<CWeaponPortalgun*>( Weapon_OwnsThisType( "weapon_portalgun" ) );
|
||
|
}
|
||
|
|
||
|
if ( pPortalGun )
|
||
|
{
|
||
|
pPortalGun->SetCanFirePortal1();
|
||
|
pPortalGun->SetCanFirePortal2();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::GiveDefaultItems( void )
|
||
|
{
|
||
|
castable_string_t st( "suit_no_sprint" );
|
||
|
GlobalEntity_SetState( st, GLOBAL_OFF );
|
||
|
inputdata_t in;
|
||
|
InputDisableFlashlight( in );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Sets specific defaults.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CPortal_Player::Spawn(void)
|
||
|
{
|
||
|
SetPlayerModel();
|
||
|
|
||
|
BaseClass::Spawn();
|
||
|
|
||
|
CreateSounds();
|
||
|
|
||
|
pl.deadflag = false;
|
||
|
RemoveSolidFlags( FSOLID_NOT_SOLID );
|
||
|
|
||
|
RemoveEffects( EF_NODRAW );
|
||
|
StopObserverMode();
|
||
|
|
||
|
GiveDefaultItems();
|
||
|
|
||
|
m_nRenderFX = kRenderNormal;
|
||
|
|
||
|
m_Local.m_iHideHUD = 0;
|
||
|
|
||
|
AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
|
||
|
|
||
|
m_impactEnergyScale = PORTALPLAYER_PHYSDAMAGE_SCALE;
|
||
|
|
||
|
RemoveFlag( FL_FROZEN );
|
||
|
|
||
|
m_iSpawnInterpCounter = (m_iSpawnInterpCounter + 1) % 8;
|
||
|
|
||
|
m_Local.m_bDucked = false;
|
||
|
|
||
|
SetPlayerUnderwater(false);
|
||
|
|
||
|
#ifdef PORTAL_MP
|
||
|
PickTeam();
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::Activate( void )
|
||
|
{
|
||
|
BaseClass::Activate();
|
||
|
m_fTimeLastNumSecondsUpdate = gpGlobals->curtime;
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::NotifySystemEvent(CBaseEntity *pNotify, notify_system_event_t eventType, const notify_system_event_params_t ¶ms )
|
||
|
{
|
||
|
// On teleport, we send event for tracking fling achievements
|
||
|
if ( eventType == NOTIFY_EVENT_TELEPORT )
|
||
|
{
|
||
|
CProp_Portal *pEnteredPortal = dynamic_cast<CProp_Portal*>( pNotify );
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "portal_player_portaled" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "userid", GetUserID() );
|
||
|
event->SetBool( "portal2", pEnteredPortal->m_bIsPortal2 );
|
||
|
gameeventmanager->FireEvent( event );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
BaseClass::NotifySystemEvent( pNotify, eventType, params );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::OnRestore( void )
|
||
|
{
|
||
|
BaseClass::OnRestore();
|
||
|
if ( m_pExpresser )
|
||
|
{
|
||
|
m_pExpresser->SetOuter ( this );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//bool CPortal_Player::StartObserverMode( int mode )
|
||
|
//{
|
||
|
// //Do nothing.
|
||
|
//
|
||
|
// return false;
|
||
|
//}
|
||
|
|
||
|
bool CPortal_Player::ValidatePlayerModel( const char *pModel )
|
||
|
{
|
||
|
if ( !Q_stricmp( g_pszPlayerModel, pModel ) )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
if ( !Q_stricmp( g_pszChellModel, pModel ) )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::SetPlayerModel( void )
|
||
|
{
|
||
|
const char *szModelName = NULL;
|
||
|
const char *pszCurrentModelName = modelinfo->GetModelName( GetModel());
|
||
|
|
||
|
szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" );
|
||
|
|
||
|
if ( ValidatePlayerModel( szModelName ) == false )
|
||
|
{
|
||
|
char szReturnString[512];
|
||
|
|
||
|
if ( ValidatePlayerModel( pszCurrentModelName ) == false )
|
||
|
{
|
||
|
pszCurrentModelName = g_pszPlayerModel;
|
||
|
}
|
||
|
|
||
|
Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", pszCurrentModelName );
|
||
|
engine->ClientCommand ( edict(), szReturnString );
|
||
|
|
||
|
szModelName = pszCurrentModelName;
|
||
|
}
|
||
|
|
||
|
int modelIndex = modelinfo->GetModelIndex( szModelName );
|
||
|
|
||
|
if ( modelIndex == -1 )
|
||
|
{
|
||
|
szModelName = g_pszPlayerModel;
|
||
|
|
||
|
char szReturnString[512];
|
||
|
|
||
|
Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", szModelName );
|
||
|
engine->ClientCommand ( edict(), szReturnString );
|
||
|
}
|
||
|
|
||
|
SetModel( szModelName );
|
||
|
m_iPlayerSoundType = (int)PLAYER_SOUNDS_CITIZEN;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool CPortal_Player::Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex )
|
||
|
{
|
||
|
bool bRet = BaseClass::Weapon_Switch( pWeapon, viewmodelindex );
|
||
|
|
||
|
return bRet;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CPortal_Player::UpdateExpression( void )
|
||
|
{
|
||
|
if ( !m_pExpresser )
|
||
|
return;
|
||
|
|
||
|
int iConcept = CONCEPT_CHELL_IDLE;
|
||
|
if ( GetHealth() <= 0 )
|
||
|
{
|
||
|
iConcept = CONCEPT_CHELL_DEAD;
|
||
|
}
|
||
|
|
||
|
GetExpresser()->SetOuter( this );
|
||
|
|
||
|
ClearExpression();
|
||
|
AI_Response response;
|
||
|
bool result = SpeakFindResponse( response, g_pszChellConcepts[iConcept] );
|
||
|
if ( !result )
|
||
|
{
|
||
|
m_flExpressionLoopTime = gpGlobals->curtime + RandomFloat(30,40);
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
char const *szScene = response.GetResponsePtr();
|
||
|
|
||
|
// Ignore updates that choose the same scene
|
||
|
if ( m_iszExpressionScene != NULL_STRING && stricmp( STRING(m_iszExpressionScene), szScene ) == 0 )
|
||
|
return;
|
||
|
|
||
|
if ( m_hExpressionSceneEnt )
|
||
|
{
|
||
|
ClearExpression();
|
||
|
}
|
||
|
|
||
|
m_iszExpressionScene = AllocPooledString( szScene );
|
||
|
float flDuration = InstancedScriptedScene( this, szScene, &m_hExpressionSceneEnt, 0.0, true, NULL );
|
||
|
m_flExpressionLoopTime = gpGlobals->curtime + flDuration;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CPortal_Player::ClearExpression( void )
|
||
|
{
|
||
|
if ( m_hExpressionSceneEnt != NULL )
|
||
|
{
|
||
|
StopScriptedScene( this, m_hExpressionSceneEnt );
|
||
|
}
|
||
|
m_flExpressionLoopTime = gpGlobals->curtime;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CPortal_Player::PreThink( void )
|
||
|
{
|
||
|
QAngle vOldAngles = GetLocalAngles();
|
||
|
QAngle vTempAngles = GetLocalAngles();
|
||
|
|
||
|
vTempAngles = EyeAngles();
|
||
|
|
||
|
if ( vTempAngles[PITCH] > 180.0f )
|
||
|
{
|
||
|
vTempAngles[PITCH] -= 360.0f;
|
||
|
}
|
||
|
|
||
|
SetLocalAngles( vTempAngles );
|
||
|
|
||
|
BaseClass::PreThink();
|
||
|
|
||
|
if( (m_afButtonPressed & IN_JUMP) )
|
||
|
{
|
||
|
Jump();
|
||
|
}
|
||
|
|
||
|
//Reset bullet force accumulator, only lasts one frame
|
||
|
m_vecTotalBulletForce = vec3_origin;
|
||
|
|
||
|
SetLocalAngles( vOldAngles );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::PostThink( void )
|
||
|
{
|
||
|
BaseClass::PostThink();
|
||
|
|
||
|
// Store the eye angles pitch so the client can compute its animation state correctly.
|
||
|
m_angEyeAngles = EyeAngles();
|
||
|
|
||
|
QAngle angles = GetLocalAngles();
|
||
|
angles[PITCH] = 0;
|
||
|
SetLocalAngles( angles );
|
||
|
|
||
|
// Regenerate heath after 3 seconds
|
||
|
if ( IsAlive() && GetHealth() < GetMaxHealth() )
|
||
|
{
|
||
|
// Color to overlay on the screen while the player is taking damage
|
||
|
color32 hurtScreenOverlay = {64,0,0,64};
|
||
|
|
||
|
if ( gpGlobals->curtime > m_fTimeLastHurt + sv_regeneration_wait_time.GetFloat() )
|
||
|
{
|
||
|
TakeHealth( 1, DMG_GENERIC );
|
||
|
m_bIsRegenerating = true;
|
||
|
|
||
|
if ( GetHealth() >= GetMaxHealth() )
|
||
|
{
|
||
|
m_bIsRegenerating = false;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_bIsRegenerating = false;
|
||
|
UTIL_ScreenFade( this, hurtScreenOverlay, 1.0f, 0.1f, FFADE_IN|FFADE_PURGE );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
UpdatePortalPlaneSounds();
|
||
|
UpdateWooshSounds();
|
||
|
|
||
|
m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
|
||
|
|
||
|
if ( IsAlive() && m_flExpressionLoopTime >= 0 && gpGlobals->curtime > m_flExpressionLoopTime )
|
||
|
{
|
||
|
// Random expressions need to be cleared, because they don't loop. So if we
|
||
|
// pick the same one again, we want to restart it.
|
||
|
ClearExpression();
|
||
|
m_iszExpressionScene = NULL_STRING;
|
||
|
UpdateExpression();
|
||
|
}
|
||
|
|
||
|
UpdateSecondsTaken();
|
||
|
|
||
|
// Try to fix the player if they're stuck
|
||
|
if ( m_bStuckOnPortalCollisionObject )
|
||
|
{
|
||
|
Vector vForward = ((CProp_Portal*)m_hPortalEnvironment.Get())->m_vPrevForward;
|
||
|
Vector vNewPos = GetAbsOrigin() + vForward * gpGlobals->frametime * -1000.0f;
|
||
|
Teleport( &vNewPos, NULL, &vForward );
|
||
|
m_bStuckOnPortalCollisionObject = false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::PlayerDeathThink(void)
|
||
|
{
|
||
|
float flForward;
|
||
|
|
||
|
SetNextThink( gpGlobals->curtime + 0.1f );
|
||
|
|
||
|
if (GetFlags() & FL_ONGROUND)
|
||
|
{
|
||
|
flForward = GetAbsVelocity().Length() - 20;
|
||
|
if (flForward <= 0)
|
||
|
{
|
||
|
SetAbsVelocity( vec3_origin );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Vector vecNewVelocity = GetAbsVelocity();
|
||
|
VectorNormalize( vecNewVelocity );
|
||
|
vecNewVelocity *= flForward;
|
||
|
SetAbsVelocity( vecNewVelocity );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
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 (GetModelIndex() && (!IsSequenceFinished()) && (m_lifeState == LIFE_DYING))
|
||
|
{
|
||
|
StudioFrameAdvance( );
|
||
|
|
||
|
m_iRespawnFrames++;
|
||
|
if ( m_iRespawnFrames < 60 ) // animations should be no longer than this
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (m_lifeState == LIFE_DYING)
|
||
|
m_lifeState = LIFE_DEAD;
|
||
|
|
||
|
StopAnimation();
|
||
|
|
||
|
IncrementInterpolationFrame();
|
||
|
m_flPlaybackRate = 0.0;
|
||
|
|
||
|
int fAnyButtonDown = (m_nButtons & ~IN_SCORE);
|
||
|
|
||
|
// Strip out the duck key from this check if it's toggled
|
||
|
if ( (fAnyButtonDown & IN_DUCK) && GetToggledDuckState())
|
||
|
{
|
||
|
fAnyButtonDown &= ~IN_DUCK;
|
||
|
}
|
||
|
|
||
|
// wait for all buttons released
|
||
|
if ( m_lifeState == LIFE_DEAD )
|
||
|
{
|
||
|
if ( fAnyButtonDown || gpGlobals->curtime < m_flDeathTime + DEATH_ANIMATION_TIME )
|
||
|
return;
|
||
|
|
||
|
if ( g_pGameRules->FPlayerCanRespawn( this ) )
|
||
|
{
|
||
|
m_lifeState = LIFE_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 ( g_pGameRules->IsMultiplayer() && ( gpGlobals->curtime > (m_flDeathTime + DEATH_ANIMATION_TIME) ) && !IsObserver() )
|
||
|
{
|
||
|
// go to dead camera.
|
||
|
StartObserverMode( m_iObserverLastMode );
|
||
|
}
|
||
|
|
||
|
// wait for any button down, or mp_forcerespawn is set and the respawn time is up
|
||
|
if (!fAnyButtonDown
|
||
|
&& !( g_pGameRules->IsMultiplayer() && forcerespawn.GetInt() > 0 && (gpGlobals->curtime > (m_flDeathTime + 5))) )
|
||
|
return;
|
||
|
|
||
|
m_nButtons = 0;
|
||
|
m_iRespawnFrames = 0;
|
||
|
|
||
|
//Msg( "Respawn\n");
|
||
|
|
||
|
respawn( this, !IsObserver() );// don't copy a corpse if we're in deathcam.
|
||
|
SetNextThink( TICK_NEVER_THINK );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::UpdatePortalPlaneSounds( void )
|
||
|
{
|
||
|
CProp_Portal *pPortal = m_hPortalEnvironment;
|
||
|
if ( pPortal && pPortal->m_bActivated )
|
||
|
{
|
||
|
Vector vVelocity;
|
||
|
GetVelocity( &vVelocity, NULL );
|
||
|
|
||
|
if ( !vVelocity.IsZero() )
|
||
|
{
|
||
|
Vector vMin, vMax;
|
||
|
CollisionProp()->WorldSpaceAABB( &vMin, &vMax );
|
||
|
|
||
|
Vector vEarCenter = ( vMax + vMin ) / 2.0f;
|
||
|
Vector vDiagonal = vMax - vMin;
|
||
|
|
||
|
if ( !m_bIntersectingPortalPlane )
|
||
|
{
|
||
|
vDiagonal *= 0.25f;
|
||
|
|
||
|
if ( UTIL_IsBoxIntersectingPortal( vEarCenter, vDiagonal, pPortal ) )
|
||
|
{
|
||
|
m_bIntersectingPortalPlane = true;
|
||
|
|
||
|
CPASAttenuationFilter filter( this );
|
||
|
CSoundParameters params;
|
||
|
if ( GetParametersForSound( "PortalPlayer.EnterPortal", params, NULL ) )
|
||
|
{
|
||
|
EmitSound_t ep( params );
|
||
|
ep.m_nPitch = 80.0f + vVelocity.Length() * 0.03f;
|
||
|
ep.m_flVolume = MIN( 0.3f + vVelocity.Length() * 0.00075f, 1.0f );
|
||
|
|
||
|
EmitSound( filter, entindex(), ep );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
vDiagonal *= 0.30f;
|
||
|
|
||
|
if ( !UTIL_IsBoxIntersectingPortal( vEarCenter, vDiagonal, pPortal ) )
|
||
|
{
|
||
|
m_bIntersectingPortalPlane = false;
|
||
|
|
||
|
CPASAttenuationFilter filter( this );
|
||
|
CSoundParameters params;
|
||
|
if ( GetParametersForSound( "PortalPlayer.ExitPortal", params, NULL ) )
|
||
|
{
|
||
|
EmitSound_t ep( params );
|
||
|
ep.m_nPitch = 80.0f + vVelocity.Length() * 0.03f;
|
||
|
ep.m_flVolume = MIN( 0.3f + vVelocity.Length() * 0.00075f, 1.0f );
|
||
|
|
||
|
EmitSound( filter, entindex(), ep );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else if ( m_bIntersectingPortalPlane )
|
||
|
{
|
||
|
m_bIntersectingPortalPlane = false;
|
||
|
|
||
|
CPASAttenuationFilter filter( this );
|
||
|
CSoundParameters params;
|
||
|
if ( GetParametersForSound( "PortalPlayer.ExitPortal", params, NULL ) )
|
||
|
{
|
||
|
EmitSound_t ep( params );
|
||
|
Vector vVelocity;
|
||
|
GetVelocity( &vVelocity, NULL );
|
||
|
ep.m_nPitch = 80.0f + vVelocity.Length() * 0.03f;
|
||
|
ep.m_flVolume = MIN( 0.3f + vVelocity.Length() * 0.00075f, 1.0f );
|
||
|
|
||
|
EmitSound( filter, entindex(), ep );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::UpdateWooshSounds( void )
|
||
|
{
|
||
|
if ( m_pWooshSound )
|
||
|
{
|
||
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
||
|
|
||
|
float fWooshVolume = GetAbsVelocity().Length() - MIN_FLING_SPEED;
|
||
|
|
||
|
if ( fWooshVolume < 0.0f )
|
||
|
{
|
||
|
controller.SoundChangeVolume( m_pWooshSound, 0.0f, 0.1f );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
fWooshVolume /= 2000.0f;
|
||
|
if ( fWooshVolume > 1.0f )
|
||
|
fWooshVolume = 1.0f;
|
||
|
|
||
|
controller.SoundChangeVolume( m_pWooshSound, fWooshVolume, 0.1f );
|
||
|
// controller.SoundChangePitch( m_pWooshSound, fWooshVolume + 0.5f, 0.1f );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::FireBullets ( const FireBulletsInfo_t &info )
|
||
|
{
|
||
|
NoteWeaponFired();
|
||
|
|
||
|
BaseClass::FireBullets( info );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::NoteWeaponFired( void )
|
||
|
{
|
||
|
Assert( m_pCurrentCommand );
|
||
|
if( m_pCurrentCommand )
|
||
|
{
|
||
|
m_iLastWeaponFireUsercmd = m_pCurrentCommand->command_number;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
extern ConVar sv_maxunlag;
|
||
|
|
||
|
bool CPortal_Player::WantsLagCompensationOnEntity( const CBasePlayer *pPlayer, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const
|
||
|
{
|
||
|
// No need to lag compensate at all if we're not attacking in this command and
|
||
|
// we haven't attacked recently.
|
||
|
if ( !( pCmd->buttons & IN_ATTACK ) && (pCmd->command_number - m_iLastWeaponFireUsercmd > 5) )
|
||
|
return false;
|
||
|
|
||
|
// If this entity hasn't been transmitted to us and acked, then don't bother lag compensating it.
|
||
|
if ( pEntityTransmitBits && !pEntityTransmitBits->Get( pPlayer->entindex() ) )
|
||
|
return false;
|
||
|
|
||
|
const Vector &vMyOrigin = GetAbsOrigin();
|
||
|
const Vector &vHisOrigin = pPlayer->GetAbsOrigin();
|
||
|
|
||
|
// get max distance player could have moved within max lag compensation time,
|
||
|
// multiply by 1.5 to to avoid "dead zones" (sqrt(2) would be the exact value)
|
||
|
float maxDistance = 1.5 * pPlayer->MaxSpeed() * sv_maxunlag.GetFloat();
|
||
|
|
||
|
// If the player is within this distance, lag compensate them in case they're running past us.
|
||
|
if ( vHisOrigin.DistTo( vMyOrigin ) < maxDistance )
|
||
|
return true;
|
||
|
|
||
|
// If their origin is not within a 45 degree cone in front of us, no need to lag compensate.
|
||
|
Vector vForward;
|
||
|
AngleVectors( pCmd->viewangles, &vForward );
|
||
|
|
||
|
Vector vDiff = vHisOrigin - vMyOrigin;
|
||
|
VectorNormalize( vDiff );
|
||
|
|
||
|
float flCosAngle = 0.707107f; // 45 degree angle
|
||
|
if ( vForward.Dot( vDiff ) < flCosAngle )
|
||
|
return false;
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CPortal_Player::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
|
||
|
{
|
||
|
m_PlayerAnimState->DoAnimationEvent( event, nData );
|
||
|
TE_PlayerAnimEvent( this, event, nData ); // Send to any clients who can see this guy.
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Override setup bones so that is uses the render angles from
|
||
|
// the Portal animation state to setup the hitboxes.
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CPortal_Player::SetupBones( matrix3x4_t *pBoneToWorld, int boneMask )
|
||
|
{
|
||
|
VPROF_BUDGET( "CBaseAnimating::SetupBones", VPROF_BUDGETGROUP_SERVER_ANIM );
|
||
|
|
||
|
// Set the mdl cache semaphore.
|
||
|
MDLCACHE_CRITICAL_SECTION();
|
||
|
|
||
|
// Get the studio header.
|
||
|
Assert( GetModelPtr() );
|
||
|
CStudioHdr *pStudioHdr = GetModelPtr( );
|
||
|
|
||
|
Vector pos[MAXSTUDIOBONES];
|
||
|
Quaternion q[MAXSTUDIOBONES];
|
||
|
|
||
|
// Adjust hit boxes based on IK driven offset.
|
||
|
Vector adjOrigin = GetAbsOrigin() + Vector( 0, 0, m_flEstIkOffset );
|
||
|
|
||
|
// FIXME: pass this into Studio_BuildMatrices to skip transforms
|
||
|
CBoneBitList boneComputed;
|
||
|
if ( m_pIk )
|
||
|
{
|
||
|
m_iIKCounter++;
|
||
|
m_pIk->Init( pStudioHdr, GetAbsAngles(), adjOrigin, gpGlobals->curtime, m_iIKCounter, boneMask );
|
||
|
GetSkeleton( pStudioHdr, pos, q, boneMask );
|
||
|
|
||
|
m_pIk->UpdateTargets( pos, q, pBoneToWorld, boneComputed );
|
||
|
CalculateIKLocks( gpGlobals->curtime );
|
||
|
m_pIk->SolveDependencies( pos, q, pBoneToWorld, boneComputed );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GetSkeleton( pStudioHdr, pos, q, boneMask );
|
||
|
}
|
||
|
|
||
|
CBaseAnimating *pParent = dynamic_cast< CBaseAnimating* >( GetMoveParent() );
|
||
|
if ( pParent )
|
||
|
{
|
||
|
// We're doing bone merging, so do special stuff here.
|
||
|
CBoneCache *pParentCache = pParent->GetBoneCache();
|
||
|
if ( pParentCache )
|
||
|
{
|
||
|
BuildMatricesWithBoneMerge(
|
||
|
pStudioHdr,
|
||
|
m_PlayerAnimState->GetRenderAngles(),
|
||
|
adjOrigin,
|
||
|
pos,
|
||
|
q,
|
||
|
pBoneToWorld,
|
||
|
pParent,
|
||
|
pParentCache );
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Studio_BuildMatrices(
|
||
|
pStudioHdr,
|
||
|
m_PlayerAnimState->GetRenderAngles(),
|
||
|
adjOrigin,
|
||
|
pos,
|
||
|
q,
|
||
|
-1,
|
||
|
GetModelScale(), // Scaling
|
||
|
pBoneToWorld,
|
||
|
boneMask );
|
||
|
}
|
||
|
|
||
|
|
||
|
// Set the activity based on an event or current state
|
||
|
void CPortal_Player::SetAnimation( PLAYER_ANIM playerAnim )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CAI_Expresser *CPortal_Player::CreateExpresser()
|
||
|
{
|
||
|
Assert( !m_pExpresser );
|
||
|
|
||
|
if ( m_pExpresser )
|
||
|
{
|
||
|
delete m_pExpresser;
|
||
|
}
|
||
|
|
||
|
m_pExpresser = new CAI_Expresser(this);
|
||
|
if ( !m_pExpresser)
|
||
|
{
|
||
|
return NULL;
|
||
|
}
|
||
|
m_pExpresser->Connect(this);
|
||
|
|
||
|
return m_pExpresser;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
|
||
|
CAI_Expresser *CPortal_Player::GetExpresser()
|
||
|
{
|
||
|
if ( m_pExpresser )
|
||
|
{
|
||
|
m_pExpresser->Connect(this);
|
||
|
}
|
||
|
return m_pExpresser;
|
||
|
}
|
||
|
|
||
|
|
||
|
extern int gEvilImpulse101;
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Player reacts to bumping a weapon.
|
||
|
// Input : pWeapon - the weapon that the player bumped into.
|
||
|
// Output : Returns true if player picked up the weapon
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CPortal_Player::BumpWeapon( CBaseCombatWeapon *pWeapon )
|
||
|
{
|
||
|
CBaseCombatCharacter *pOwner = pWeapon->GetOwner();
|
||
|
|
||
|
// Can I have this weapon type?
|
||
|
if ( !IsAllowedToPickupWeapons() )
|
||
|
return false;
|
||
|
|
||
|
if ( pOwner || !Weapon_CanUse( pWeapon ) || !g_pGameRules->CanHavePlayerItem( this, pWeapon ) )
|
||
|
{
|
||
|
if ( gEvilImpulse101 )
|
||
|
{
|
||
|
UTIL_Remove( pWeapon );
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Don't let the player fetch weapons through walls (use MASK_SOLID so that you can't pickup through windows)
|
||
|
if( !pWeapon->FVisible( this, MASK_SOLID ) && !(GetFlags() & FL_NOTARGET) )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
CWeaponPortalgun *pPickupPortalgun = dynamic_cast<CWeaponPortalgun*>( pWeapon );
|
||
|
|
||
|
bool bOwnsWeaponAlready = !!Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType());
|
||
|
|
||
|
if ( bOwnsWeaponAlready == true )
|
||
|
{
|
||
|
// If we picked up a second portal gun set the bool to alow secondary fire
|
||
|
if ( pPickupPortalgun )
|
||
|
{
|
||
|
CWeaponPortalgun *pPortalGun = static_cast<CWeaponPortalgun*>( Weapon_OwnsThisType( pWeapon->GetClassname() ) );
|
||
|
|
||
|
if ( pPickupPortalgun->CanFirePortal1() )
|
||
|
pPortalGun->SetCanFirePortal1();
|
||
|
|
||
|
if ( pPickupPortalgun->CanFirePortal2() )
|
||
|
pPortalGun->SetCanFirePortal2();
|
||
|
|
||
|
UTIL_Remove( pWeapon );
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
//If we have room for the ammo, then "take" the weapon too.
|
||
|
if ( Weapon_EquipAmmoOnly( pWeapon ) )
|
||
|
{
|
||
|
pWeapon->CheckRespawn();
|
||
|
|
||
|
UTIL_Remove( pWeapon );
|
||
|
return true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
pWeapon->CheckRespawn();
|
||
|
Weapon_Equip( pWeapon );
|
||
|
|
||
|
// If we're holding and object before picking up portalgun, drop it
|
||
|
if ( pPickupPortalgun )
|
||
|
{
|
||
|
ForceDropOfCarriedPhysObjects( GetPlayerHeldEntity( this ) );
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::ShutdownUseEntity( void )
|
||
|
{
|
||
|
ShutdownPickupController( m_hUseEntity );
|
||
|
}
|
||
|
|
||
|
const Vector& CPortal_Player::WorldSpaceCenter( ) const
|
||
|
{
|
||
|
m_vWorldSpaceCenterHolder = GetAbsOrigin();
|
||
|
m_vWorldSpaceCenterHolder.z += ( (IsDucked()) ? (VEC_DUCK_HULL_MAX_SCALED( this ).z) : (VEC_HULL_MAX_SCALED( this ).z) ) * 0.5f;
|
||
|
return m_vWorldSpaceCenterHolder;
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::Teleport( const Vector *newPosition, const QAngle *newAngles, const Vector *newVelocity )
|
||
|
{
|
||
|
Vector oldOrigin = GetLocalOrigin();
|
||
|
QAngle oldAngles = GetLocalAngles();
|
||
|
BaseClass::Teleport( newPosition, newAngles, newVelocity );
|
||
|
m_angEyeAngles = pl.v_angle;
|
||
|
|
||
|
m_PlayerAnimState->Teleport( newPosition, newAngles, this );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::VPhysicsShadowUpdate( IPhysicsObject *pPhysics )
|
||
|
{
|
||
|
if( m_hPortalEnvironment.Get() == NULL )
|
||
|
return BaseClass::VPhysicsShadowUpdate( pPhysics );
|
||
|
|
||
|
|
||
|
//below is mostly a cut/paste of existing CBasePlayer::VPhysicsShadowUpdate code with some minor tweaks to avoid getting stuck in stuff when in a portal environment
|
||
|
if ( sv_turbophysics.GetBool() )
|
||
|
return;
|
||
|
|
||
|
Vector newPosition;
|
||
|
|
||
|
bool physicsUpdated = m_pPhysicsController->GetShadowPosition( &newPosition, NULL ) > 0 ? true : false;
|
||
|
|
||
|
// UNDONE: If the player is penetrating, but the player's game collisions are not stuck, teleport the physics shadow to the game position
|
||
|
if ( pPhysics->GetGameFlags() & FVPHYSICS_PENETRATING )
|
||
|
{
|
||
|
CUtlVector<CBaseEntity *> list;
|
||
|
PhysGetListOfPenetratingEntities( this, list );
|
||
|
for ( int i = list.Count()-1; i >= 0; --i )
|
||
|
{
|
||
|
// filter out anything that isn't simulated by vphysics
|
||
|
// UNDONE: Filter out motion disabled objects?
|
||
|
if ( list[i]->GetMoveType() == MOVETYPE_VPHYSICS )
|
||
|
{
|
||
|
// I'm currently stuck inside a moving object, so allow vphysics to
|
||
|
// apply velocity to the player in order to separate these objects
|
||
|
m_touchedPhysObject = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_pPhysicsController->IsInContact() || (m_afPhysicsFlags & PFLAG_VPHYSICS_MOTIONCONTROLLER) )
|
||
|
{
|
||
|
m_touchedPhysObject = true;
|
||
|
}
|
||
|
|
||
|
if ( IsFollowingPhysics() )
|
||
|
{
|
||
|
m_touchedPhysObject = true;
|
||
|
}
|
||
|
|
||
|
if ( GetMoveType() == MOVETYPE_NOCLIP )
|
||
|
{
|
||
|
m_oldOrigin = GetAbsOrigin();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( phys_timescale.GetFloat() == 0.0f )
|
||
|
{
|
||
|
physicsUpdated = false;
|
||
|
}
|
||
|
|
||
|
if ( !physicsUpdated )
|
||
|
return;
|
||
|
|
||
|
IPhysicsObject *pPhysGround = GetGroundVPhysics();
|
||
|
|
||
|
Vector newVelocity;
|
||
|
pPhysics->GetPosition( &newPosition, 0 );
|
||
|
m_pPhysicsController->GetShadowVelocity( &newVelocity );
|
||
|
|
||
|
|
||
|
|
||
|
Vector tmp = GetAbsOrigin() - newPosition;
|
||
|
if ( !m_touchedPhysObject && !(GetFlags() & FL_ONGROUND) )
|
||
|
{
|
||
|
tmp.z *= 0.5f; // don't care about z delta as much
|
||
|
}
|
||
|
|
||
|
float dist = tmp.LengthSqr();
|
||
|
float deltaV = (newVelocity - GetAbsVelocity()).LengthSqr();
|
||
|
|
||
|
float maxDistErrorSqr = VPHYS_MAX_DISTSQR;
|
||
|
float maxVelErrorSqr = VPHYS_MAX_VELSQR;
|
||
|
if ( IsRideablePhysics(pPhysGround) )
|
||
|
{
|
||
|
maxDistErrorSqr *= 0.25;
|
||
|
maxVelErrorSqr *= 0.25;
|
||
|
}
|
||
|
|
||
|
if ( dist >= maxDistErrorSqr || deltaV >= maxVelErrorSqr || (pPhysGround && !m_touchedPhysObject) )
|
||
|
{
|
||
|
if ( m_touchedPhysObject || pPhysGround )
|
||
|
{
|
||
|
// BUGBUG: Rewrite this code using fixed timestep
|
||
|
if ( deltaV >= maxVelErrorSqr )
|
||
|
{
|
||
|
Vector dir = GetAbsVelocity();
|
||
|
float len = VectorNormalize(dir);
|
||
|
float dot = DotProduct( newVelocity, dir );
|
||
|
if ( dot > len )
|
||
|
{
|
||
|
dot = len;
|
||
|
}
|
||
|
else if ( dot < -len )
|
||
|
{
|
||
|
dot = -len;
|
||
|
}
|
||
|
|
||
|
VectorMA( newVelocity, -dot, dir, newVelocity );
|
||
|
|
||
|
if ( m_afPhysicsFlags & PFLAG_VPHYSICS_MOTIONCONTROLLER )
|
||
|
{
|
||
|
float val = Lerp( 0.1f, len, dot );
|
||
|
VectorMA( newVelocity, val - len, dir, newVelocity );
|
||
|
}
|
||
|
|
||
|
if ( !IsRideablePhysics(pPhysGround) )
|
||
|
{
|
||
|
if ( !(m_afPhysicsFlags & PFLAG_VPHYSICS_MOTIONCONTROLLER ) && IsSimulatingOnAlternateTicks() )
|
||
|
{
|
||
|
newVelocity *= 0.5f;
|
||
|
}
|
||
|
ApplyAbsVelocityImpulse( newVelocity );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
trace_t trace;
|
||
|
UTIL_TraceEntity( this, newPosition, newPosition, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
|
||
|
if ( !trace.allsolid && !trace.startsolid )
|
||
|
{
|
||
|
SetAbsOrigin( newPosition );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
trace_t trace;
|
||
|
|
||
|
Ray_t ray;
|
||
|
ray.Init( GetAbsOrigin(), GetAbsOrigin(), WorldAlignMins(), WorldAlignMaxs() );
|
||
|
|
||
|
CTraceFilterSimple OriginalTraceFilter( this, COLLISION_GROUP_PLAYER_MOVEMENT );
|
||
|
CTraceFilterTranslateClones traceFilter( &OriginalTraceFilter );
|
||
|
UTIL_Portal_TraceRay_With( m_hPortalEnvironment, ray, MASK_PLAYERSOLID, &traceFilter, &trace );
|
||
|
|
||
|
// current position is not ok, fixup
|
||
|
if ( trace.allsolid || trace.startsolid )
|
||
|
{
|
||
|
//try again with new position
|
||
|
ray.Init( newPosition, newPosition, WorldAlignMins(), WorldAlignMaxs() );
|
||
|
UTIL_Portal_TraceRay_With( m_hPortalEnvironment, ray, MASK_PLAYERSOLID, &traceFilter, &trace );
|
||
|
|
||
|
if( trace.startsolid == false )
|
||
|
{
|
||
|
SetAbsOrigin( newPosition );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if( !FindClosestPassableSpace( this, newPosition - GetAbsOrigin(), MASK_PLAYERSOLID ) )
|
||
|
{
|
||
|
// Try moving the player closer to the center of the portal
|
||
|
CProp_Portal *pPortal = m_hPortalEnvironment.Get();
|
||
|
newPosition += ( pPortal->GetAbsOrigin() - WorldSpaceCenter() ) * 0.1f;
|
||
|
SetAbsOrigin( newPosition );
|
||
|
|
||
|
DevMsg( "Hurting the player for FindClosestPassableSpaceFailure!" );
|
||
|
|
||
|
// Deal 1 damage per frame... this will kill a player very fast, but allow for the above correction to fix some cases
|
||
|
CTakeDamageInfo info( this, this, vec3_origin, vec3_origin, 1, DMG_CRUSH );
|
||
|
OnTakeDamage( info );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_touchedPhysObject )
|
||
|
{
|
||
|
// check my position (physics object could have simulated into my position
|
||
|
// physics is not very far away, check my position
|
||
|
trace_t trace;
|
||
|
UTIL_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(),
|
||
|
MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
|
||
|
|
||
|
// is current position ok?
|
||
|
if ( trace.allsolid || trace.startsolid )
|
||
|
{
|
||
|
// stuck????!?!?
|
||
|
//Msg("Stuck on %s\n", trace.m_pEnt->GetClassname());
|
||
|
SetAbsOrigin( newPosition );
|
||
|
UTIL_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(),
|
||
|
MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
|
||
|
if ( trace.allsolid || trace.startsolid )
|
||
|
{
|
||
|
//Msg("Double Stuck\n");
|
||
|
SetAbsOrigin( m_oldOrigin );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
m_oldOrigin = GetAbsOrigin();
|
||
|
}
|
||
|
|
||
|
bool CPortal_Player::UseFoundEntity( CBaseEntity *pUseEntity )
|
||
|
{
|
||
|
bool usedSomething = false;
|
||
|
|
||
|
//!!!UNDONE: traceline here to prevent +USEing buttons through walls
|
||
|
int caps = pUseEntity->ObjectCaps();
|
||
|
variant_t emptyVariant;
|
||
|
|
||
|
if ( m_afButtonPressed & IN_USE )
|
||
|
{
|
||
|
// Robin: Don't play sounds for NPCs, because NPCs will allow respond with speech.
|
||
|
if ( !pUseEntity->MyNPCPointer() )
|
||
|
{
|
||
|
EmitSound( "HL2Player.Use" );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( ( (m_nButtons & 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;
|
||
|
|
||
|
pUseEntity->AcceptInput( "Use", this, this, emptyVariant, USE_TOGGLE );
|
||
|
|
||
|
usedSomething = true;
|
||
|
}
|
||
|
// 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) && (pUseEntity->ObjectCaps() & FCAP_ONOFF_USE) ) // BUGBUG This is an "off" use
|
||
|
{
|
||
|
pUseEntity->AcceptInput( "Use", this, this, emptyVariant, USE_TOGGLE );
|
||
|
|
||
|
usedSomething = true;
|
||
|
}
|
||
|
|
||
|
#if HL2_SINGLE_PRIMARY_WEAPON_MODE
|
||
|
|
||
|
//Check for weapon pick-up
|
||
|
if ( m_afButtonPressed & IN_USE )
|
||
|
{
|
||
|
CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon *>(pUseEntity);
|
||
|
|
||
|
if ( ( pWeapon != NULL ) && ( Weapon_CanSwitchTo( pWeapon ) ) )
|
||
|
{
|
||
|
//Try to take ammo or swap the weapon
|
||
|
if ( Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType() ) )
|
||
|
{
|
||
|
Weapon_EquipAmmoOnly( pWeapon );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Weapon_DropSlot( pWeapon->GetSlot() );
|
||
|
Weapon_Equip( pWeapon );
|
||
|
}
|
||
|
|
||
|
usedSomething = true;
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
return usedSomething;
|
||
|
}
|
||
|
|
||
|
//bool CPortal_Player::StartReplayMode( float fDelay, float fDuration, int iEntity )
|
||
|
//{
|
||
|
// if ( !BaseClass::StartReplayMode( fDelay, fDuration, 1 ) )
|
||
|
// return false;
|
||
|
//
|
||
|
// CSingleUserRecipientFilter filter( this );
|
||
|
// filter.MakeReliable();
|
||
|
//
|
||
|
// UserMessageBegin( filter, "KillCam" );
|
||
|
//
|
||
|
// EHANDLE hPlayer = this;
|
||
|
//
|
||
|
// if ( m_hObserverTarget.Get() )
|
||
|
// {
|
||
|
// WRITE_EHANDLE( m_hObserverTarget ); // first target
|
||
|
// WRITE_EHANDLE( hPlayer ); //second target
|
||
|
// }
|
||
|
// else
|
||
|
// {
|
||
|
// WRITE_EHANDLE( hPlayer ); // first target
|
||
|
// WRITE_EHANDLE( 0 ); //second target
|
||
|
// }
|
||
|
// MessageEnd();
|
||
|
//
|
||
|
// return true;
|
||
|
//}
|
||
|
//
|
||
|
//void CPortal_Player::StopReplayMode()
|
||
|
//{
|
||
|
// BaseClass::StopReplayMode();
|
||
|
//
|
||
|
// CSingleUserRecipientFilter filter( this );
|
||
|
// filter.MakeReliable();
|
||
|
//
|
||
|
// UserMessageBegin( filter, "KillCam" );
|
||
|
// WRITE_EHANDLE( 0 );
|
||
|
// WRITE_EHANDLE( 0 );
|
||
|
// MessageEnd();
|
||
|
//}
|
||
|
|
||
|
void CPortal_Player::PlayerUse( void )
|
||
|
{
|
||
|
// Was use pressed or released?
|
||
|
if ( ! ((m_nButtons | m_afButtonPressed | m_afButtonReleased) & IN_USE) )
|
||
|
return;
|
||
|
|
||
|
if ( m_afButtonPressed & IN_USE )
|
||
|
{
|
||
|
// Currently using a latched entity?
|
||
|
if ( ClearUseEntity() )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_afPhysicsFlags & PFLAG_DIROVERRIDE )
|
||
|
{
|
||
|
m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE;
|
||
|
m_iTrain = TRAIN_NEW|TRAIN_OFF;
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{ // Start controlling the train!
|
||
|
CBaseEntity *pTrain = GetGroundEntity();
|
||
|
if ( pTrain && !(m_nButtons & IN_JUMP) && (GetFlags() & FL_ONGROUND) && (pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) && pTrain->OnControls(this) )
|
||
|
{
|
||
|
m_afPhysicsFlags |= PFLAG_DIROVERRIDE;
|
||
|
m_iTrain = TrainSpeed(pTrain->m_flSpeed, ((CFuncTrackTrain*)pTrain)->GetMaxSpeed());
|
||
|
m_iTrain |= TRAIN_NEW;
|
||
|
EmitSound( "HL2Player.TrainUse" );
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Tracker 3926: We can't +USE something if we're climbing a ladder
|
||
|
if ( GetMoveType() == MOVETYPE_LADDER )
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
CBaseEntity *pUseEntity = FindUseEntity();
|
||
|
|
||
|
bool usedSomething = false;
|
||
|
|
||
|
// Found an object
|
||
|
if ( pUseEntity )
|
||
|
{
|
||
|
SetHeldObjectOnOppositeSideOfPortal( false );
|
||
|
|
||
|
// TODO: Removed because we no longer have ghost animatings. May need to rework this code.
|
||
|
//// If we found a ghost animating then it needs to be held across a portal
|
||
|
//CGhostAnimating *pGhostAnimating = dynamic_cast<CGhostAnimating*>( pUseEntity );
|
||
|
//if ( pGhostAnimating )
|
||
|
//{
|
||
|
// CProp_Portal *pPortal = NULL;
|
||
|
|
||
|
// CPortalSimulator *pPortalSimulator = CPortalSimulator::GetSimulatorThatOwnsEntity( pGhostAnimating->GetSourceEntity() );
|
||
|
|
||
|
// //HACKHACK: This assumes all portal simulators are a member of a prop_portal
|
||
|
// pPortal = (CProp_Portal *)(((char *)pPortalSimulator) - ((int)&(((CProp_Portal *)0)->m_PortalSimulator)));
|
||
|
// Assert( (&(pPortal->m_PortalSimulator)) == pPortalSimulator ); //doublechecking the hack
|
||
|
|
||
|
// if ( pPortal )
|
||
|
// {
|
||
|
// SetHeldObjectPortal( pPortal->m_hLinkedPortal );
|
||
|
// SetHeldObjectOnOppositeSideOfPortal( true );
|
||
|
// }
|
||
|
//}
|
||
|
usedSomething = UseFoundEntity( pUseEntity );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Vector forward;
|
||
|
EyeVectors( &forward, NULL, NULL );
|
||
|
Vector start = EyePosition();
|
||
|
|
||
|
Ray_t rayPortalTest;
|
||
|
rayPortalTest.Init( start, start + forward * PLAYER_USE_RADIUS );
|
||
|
|
||
|
float fMustBeCloserThan = 2.0f;
|
||
|
|
||
|
CProp_Portal *pPortal = UTIL_Portal_FirstAlongRay( rayPortalTest, fMustBeCloserThan );
|
||
|
|
||
|
if ( pPortal )
|
||
|
{
|
||
|
SetHeldObjectPortal( pPortal );
|
||
|
pUseEntity = FindUseEntityThroughPortal();
|
||
|
}
|
||
|
|
||
|
if ( pUseEntity )
|
||
|
{
|
||
|
SetHeldObjectOnOppositeSideOfPortal( true );
|
||
|
usedSomething = UseFoundEntity( pUseEntity );
|
||
|
}
|
||
|
else if ( m_afButtonPressed & IN_USE )
|
||
|
{
|
||
|
// Signal that we want to play the deny sound, unless the user is +USEing on a ladder!
|
||
|
// The sound is emitted in ItemPostFrame, since that occurs after GameMovement::ProcessMove which
|
||
|
// lets the ladder code unset this flag.
|
||
|
m_bPlayUseDenySound = true;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Debounce the use key
|
||
|
if ( usedSomething && pUseEntity )
|
||
|
{
|
||
|
m_Local.m_nOldButtons |= IN_USE;
|
||
|
m_afButtonPressed &= ~IN_USE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::PlayerRunCommand(CUserCmd *ucmd, IMoveHelper *moveHelper)
|
||
|
{
|
||
|
if( m_bFixEyeAnglesFromPortalling )
|
||
|
{
|
||
|
//the idea here is to handle the notion that the player has portalled, but they sent us an angle update before receiving that message.
|
||
|
//If we don't handle this here, we end up sending back their old angles which makes them hiccup their angles for a frame
|
||
|
float fOldAngleDiff = fabs( AngleDistance( ucmd->viewangles.x, m_qPrePortalledViewAngles.x ) );
|
||
|
fOldAngleDiff += fabs( AngleDistance( ucmd->viewangles.y, m_qPrePortalledViewAngles.y ) );
|
||
|
fOldAngleDiff += fabs( AngleDistance( ucmd->viewangles.z, m_qPrePortalledViewAngles.z ) );
|
||
|
|
||
|
float fCurrentAngleDiff = fabs( AngleDistance( ucmd->viewangles.x, pl.v_angle.x ) );
|
||
|
fCurrentAngleDiff += fabs( AngleDistance( ucmd->viewangles.y, pl.v_angle.y ) );
|
||
|
fCurrentAngleDiff += fabs( AngleDistance( ucmd->viewangles.z, pl.v_angle.z ) );
|
||
|
|
||
|
if( fCurrentAngleDiff > fOldAngleDiff )
|
||
|
ucmd->viewangles = TransformAnglesToWorldSpace( ucmd->viewangles, m_matLastPortalled.As3x4() );
|
||
|
|
||
|
m_bFixEyeAnglesFromPortalling = false;
|
||
|
}
|
||
|
|
||
|
BaseClass::PlayerRunCommand( ucmd, moveHelper );
|
||
|
}
|
||
|
|
||
|
|
||
|
bool CPortal_Player::ClientCommand( const CCommand &args )
|
||
|
{
|
||
|
if ( FStrEq( args[0], "spectate" ) )
|
||
|
{
|
||
|
// do nothing.
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return BaseClass::ClientCommand( args );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::CheatImpulseCommands( int iImpulse )
|
||
|
{
|
||
|
switch ( iImpulse )
|
||
|
{
|
||
|
case 101:
|
||
|
{
|
||
|
if( sv_cheats->GetBool() )
|
||
|
{
|
||
|
GiveAllItems();
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
BaseClass::CheatImpulseCommands( iImpulse );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::CreateViewModel( int index /*=0*/ )
|
||
|
{
|
||
|
BaseClass::CreateViewModel( index );
|
||
|
return;
|
||
|
Assert( index >= 0 && index < MAX_VIEWMODELS );
|
||
|
|
||
|
if ( GetViewModel( index ) )
|
||
|
return;
|
||
|
|
||
|
CPredictedViewModel *vm = ( CPredictedViewModel * )CreateEntityByName( "predicted_viewmodel" );
|
||
|
if ( vm )
|
||
|
{
|
||
|
vm->SetAbsOrigin( GetAbsOrigin() );
|
||
|
vm->SetOwner( this );
|
||
|
vm->SetIndex( index );
|
||
|
DispatchSpawn( vm );
|
||
|
vm->FollowEntity( this, false );
|
||
|
m_hViewModel.Set( index, vm );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool CPortal_Player::BecomeRagdollOnClient( const Vector &force )
|
||
|
{
|
||
|
return true;//BaseClass::BecomeRagdollOnClient( force );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::CreateRagdollEntity( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
if ( m_hRagdoll )
|
||
|
{
|
||
|
UTIL_RemoveImmediate( m_hRagdoll );
|
||
|
m_hRagdoll = NULL;
|
||
|
}
|
||
|
|
||
|
#if PORTAL_HIDE_PLAYER_RAGDOLL
|
||
|
AddSolidFlags( FSOLID_NOT_SOLID );
|
||
|
AddEffects( EF_NODRAW | EF_NOSHADOW );
|
||
|
AddEFlags( EFL_NO_DISSOLVE );
|
||
|
#endif // PORTAL_HIDE_PLAYER_RAGDOLL
|
||
|
CBaseEntity *pRagdoll = CreateServerRagdoll( this, m_nForceBone, info, COLLISION_GROUP_INTERACTIVE_DEBRIS, true );
|
||
|
pRagdoll->m_takedamage = DAMAGE_NO;
|
||
|
m_hRagdoll = pRagdoll;
|
||
|
|
||
|
/*
|
||
|
// If we already have a ragdoll destroy it.
|
||
|
CPortalRagdoll *pRagdoll = dynamic_cast<CPortalRagdoll*>( m_hRagdoll.Get() );
|
||
|
if( pRagdoll )
|
||
|
{
|
||
|
UTIL_Remove( pRagdoll );
|
||
|
pRagdoll = NULL;
|
||
|
}
|
||
|
Assert( pRagdoll == NULL );
|
||
|
|
||
|
// Create a ragdoll.
|
||
|
pRagdoll = dynamic_cast<CPortalRagdoll*>( CreateEntityByName( "portal_ragdoll" ) );
|
||
|
if ( pRagdoll )
|
||
|
{
|
||
|
|
||
|
|
||
|
pRagdoll->m_hPlayer = this;
|
||
|
pRagdoll->m_vecRagdollOrigin = GetAbsOrigin();
|
||
|
pRagdoll->m_vecRagdollVelocity = GetAbsVelocity();
|
||
|
pRagdoll->m_nModelIndex = m_nModelIndex;
|
||
|
pRagdoll->m_nForceBone = m_nForceBone;
|
||
|
pRagdoll->CopyAnimationDataFrom( this );
|
||
|
pRagdoll->SetOwnerEntity( this );
|
||
|
pRagdoll->m_flAnimTime = gpGlobals->curtime;
|
||
|
pRagdoll->m_flPlaybackRate = 0.0;
|
||
|
pRagdoll->SetCycle( 0 );
|
||
|
pRagdoll->ResetSequence( 0 );
|
||
|
|
||
|
float fSequenceDuration = SequenceDuration( GetSequence() );
|
||
|
float fPreviousCycle = clamp(GetCycle()-( 0.1 * ( 1 / fSequenceDuration ) ),0.f,1.f);
|
||
|
float fCurCycle = GetCycle();
|
||
|
matrix3x4_t pBoneToWorld[MAXSTUDIOBONES], pBoneToWorldNext[MAXSTUDIOBONES];
|
||
|
SetupBones( pBoneToWorldNext, BONE_USED_BY_ANYTHING );
|
||
|
SetCycle( fPreviousCycle );
|
||
|
SetupBones( pBoneToWorld, BONE_USED_BY_ANYTHING );
|
||
|
SetCycle( fCurCycle );
|
||
|
|
||
|
pRagdoll->InitRagdoll( info.GetDamageForce(), m_nForceBone, info.GetDamagePosition(), pBoneToWorld, pBoneToWorldNext, 0.1f, COLLISION_GROUP_INTERACTIVE_DEBRIS, true );
|
||
|
pRagdoll->SetMoveType( MOVETYPE_VPHYSICS );
|
||
|
pRagdoll->SetSolid( SOLID_VPHYSICS );
|
||
|
if ( IsDissolving() )
|
||
|
{
|
||
|
pRagdoll->TransferDissolveFrom( this );
|
||
|
}
|
||
|
|
||
|
Vector mins, maxs;
|
||
|
mins = CollisionProp()->OBBMins();
|
||
|
maxs = CollisionProp()->OBBMaxs();
|
||
|
pRagdoll->CollisionProp()->SetCollisionBounds( mins, maxs );
|
||
|
pRagdoll->SetCollisionGroup( COLLISION_GROUP_INTERACTIVE_DEBRIS );
|
||
|
}
|
||
|
|
||
|
// Turn off the player.
|
||
|
AddSolidFlags( FSOLID_NOT_SOLID );
|
||
|
AddEffects( EF_NODRAW | EF_NOSHADOW );
|
||
|
SetMoveType( MOVETYPE_NONE );
|
||
|
|
||
|
// Save ragdoll handle.
|
||
|
m_hRagdoll = pRagdoll;
|
||
|
*/
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::Jump( void )
|
||
|
{
|
||
|
g_PortalGameStats.Event_PlayerJump( GetAbsOrigin(), GetAbsVelocity() );
|
||
|
BaseClass::Jump();
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::Event_Killed( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
//update damage info with our accumulated physics force
|
||
|
CTakeDamageInfo subinfo = info;
|
||
|
subinfo.SetDamageForce( m_vecTotalBulletForce );
|
||
|
|
||
|
// show killer in death cam mode
|
||
|
// chopped down version of SetObserverTarget without the team check
|
||
|
//if( info.GetAttacker() )
|
||
|
//{
|
||
|
// // set new target
|
||
|
// m_hObserverTarget.Set( info.GetAttacker() );
|
||
|
//}
|
||
|
//else
|
||
|
// m_hObserverTarget.Set( NULL );
|
||
|
|
||
|
UpdateExpression();
|
||
|
|
||
|
// Note: since we're dead, it won't draw us on the client, but we don't set EF_NODRAW
|
||
|
// because we still want to transmit to the clients in our PVS.
|
||
|
CreateRagdollEntity( info );
|
||
|
|
||
|
BaseClass::Event_Killed( subinfo );
|
||
|
|
||
|
#if PORTAL_HIDE_PLAYER_RAGDOLL
|
||
|
// Fizzle all portals so they don't see the player disappear
|
||
|
int iPortalCount = CProp_Portal_Shared::AllPortals.Count();
|
||
|
CProp_Portal **pPortals = CProp_Portal_Shared::AllPortals.Base();
|
||
|
for( int i = 0; i != iPortalCount; ++i )
|
||
|
{
|
||
|
CProp_Portal *pTempPortal = pPortals[i];
|
||
|
|
||
|
if( pTempPortal && pTempPortal->m_bActivated )
|
||
|
{
|
||
|
pTempPortal->Fizzle();
|
||
|
}
|
||
|
}
|
||
|
#endif // PORTAL_HIDE_PLAYER_RAGDOLL
|
||
|
|
||
|
if ( (info.GetDamageType() & DMG_DISSOLVE) && !(m_hRagdoll.Get()->GetEFlags() & EFL_NO_DISSOLVE) )
|
||
|
{
|
||
|
if ( m_hRagdoll )
|
||
|
{
|
||
|
m_hRagdoll->GetBaseAnimating()->Dissolve( NULL, gpGlobals->curtime, false, ENTITY_DISSOLVE_NORMAL );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_lifeState = LIFE_DYING;
|
||
|
StopZooming();
|
||
|
|
||
|
if ( GetObserverTarget() )
|
||
|
{
|
||
|
//StartReplayMode( 3, 3, GetObserverTarget()->entindex() );
|
||
|
//StartObserverMode( OBS_MODE_DEATHCAM );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int CPortal_Player::OnTakeDamage( const CTakeDamageInfo &inputInfo )
|
||
|
{
|
||
|
CTakeDamageInfo inputInfoCopy( inputInfo );
|
||
|
|
||
|
// If you shoot yourself, make it hurt but push you less
|
||
|
if ( inputInfoCopy.GetAttacker() == this && inputInfoCopy.GetDamageType() == DMG_BULLET )
|
||
|
{
|
||
|
inputInfoCopy.ScaleDamage( 5.0f );
|
||
|
inputInfoCopy.ScaleDamageForce( 0.05f );
|
||
|
}
|
||
|
|
||
|
CBaseEntity *pAttacker = inputInfoCopy.GetAttacker();
|
||
|
CBaseEntity *pInflictor = inputInfoCopy.GetInflictor();
|
||
|
|
||
|
bool bIsTurret = false;
|
||
|
|
||
|
if ( pAttacker && FClassnameIs( pAttacker, "npc_portal_turret_floor" ) )
|
||
|
bIsTurret = true;
|
||
|
|
||
|
// Refuse damage from prop_glados_core.
|
||
|
if ( (pAttacker && FClassnameIs( pAttacker, "prop_glados_core" )) ||
|
||
|
(pInflictor && FClassnameIs( pInflictor, "prop_glados_core" )) )
|
||
|
{
|
||
|
inputInfoCopy.SetDamage(0.0f);
|
||
|
}
|
||
|
|
||
|
if ( bIsTurret && ( inputInfoCopy.GetDamageType() & DMG_BULLET ) )
|
||
|
{
|
||
|
Vector vLateralForce = inputInfoCopy.GetDamageForce();
|
||
|
vLateralForce.z = 0.0f;
|
||
|
|
||
|
// Push if the player is moving against the force direction
|
||
|
if ( GetAbsVelocity().Dot( vLateralForce ) < 0.0f )
|
||
|
ApplyAbsVelocityImpulse( vLateralForce );
|
||
|
}
|
||
|
else if ( ( inputInfoCopy.GetDamageType() & DMG_CRUSH ) )
|
||
|
{
|
||
|
if ( bIsTurret )
|
||
|
{
|
||
|
inputInfoCopy.SetDamage( inputInfoCopy.GetDamage() * 0.5f );
|
||
|
}
|
||
|
|
||
|
if ( inputInfoCopy.GetDamage() >= 10.0f )
|
||
|
{
|
||
|
EmitSound( "PortalPlayer.BonkYelp" );
|
||
|
}
|
||
|
}
|
||
|
else if ( ( inputInfoCopy.GetDamageType() & DMG_SHOCK ) || ( inputInfoCopy.GetDamageType() & DMG_BURN ) )
|
||
|
{
|
||
|
EmitSound( "PortalPortal.PainYelp" );
|
||
|
}
|
||
|
|
||
|
int ret = BaseClass::OnTakeDamage( inputInfoCopy );
|
||
|
|
||
|
// Copy the multidamage damage origin over what the base class wrote, because
|
||
|
// that gets translated correctly though portals.
|
||
|
m_DmgOrigin = inputInfo.GetDamagePosition();
|
||
|
|
||
|
if ( GetHealth() < 100 )
|
||
|
{
|
||
|
m_fTimeLastHurt = gpGlobals->curtime;
|
||
|
}
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
int CPortal_Player::OnTakeDamage_Alive( const CTakeDamageInfo &info )
|
||
|
{
|
||
|
// set damage type sustained
|
||
|
m_bitsDamageType |= info.GetDamageType();
|
||
|
|
||
|
if ( !CBaseCombatCharacter::OnTakeDamage_Alive( info ) )
|
||
|
return 0;
|
||
|
|
||
|
CBaseEntity * attacker = info.GetAttacker();
|
||
|
|
||
|
if ( !attacker )
|
||
|
return 0;
|
||
|
|
||
|
Vector vecDir = vec3_origin;
|
||
|
if ( info.GetInflictor() )
|
||
|
{
|
||
|
vecDir = info.GetInflictor()->WorldSpaceCenter() - Vector ( 0, 0, 10 ) - WorldSpaceCenter();
|
||
|
VectorNormalize( vecDir );
|
||
|
}
|
||
|
|
||
|
if ( info.GetInflictor() && (GetMoveType() == MOVETYPE_WALK) &&
|
||
|
( !attacker->IsSolidFlagSet(FSOLID_TRIGGER)) )
|
||
|
{
|
||
|
Vector force = vecDir;// * -DamageForce( WorldAlignSize(), info.GetBaseDamage() );
|
||
|
if ( force.z > 250.0f )
|
||
|
{
|
||
|
force.z = 250.0f;
|
||
|
}
|
||
|
ApplyAbsVelocityImpulse( force );
|
||
|
}
|
||
|
|
||
|
// fire global game event
|
||
|
|
||
|
IGameEvent * event = gameeventmanager->CreateEvent( "player_hurt" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt("userid", GetUserID() );
|
||
|
event->SetInt("health", MAX(0, m_iHealth) );
|
||
|
event->SetInt("priority", 5 ); // HLTV event priority, not transmitted
|
||
|
|
||
|
if ( attacker->IsPlayer() )
|
||
|
{
|
||
|
CBasePlayer *player = ToBasePlayer( attacker );
|
||
|
event->SetInt("attacker", player->GetUserID() ); // hurt by other player
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
event->SetInt("attacker", 0 ); // hurt by "world"
|
||
|
}
|
||
|
|
||
|
gameeventmanager->FireEvent( event );
|
||
|
}
|
||
|
|
||
|
// Insert a combat sound so that nearby NPCs hear battle
|
||
|
if ( attacker->IsNPC() )
|
||
|
{
|
||
|
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 512, 0.5, this );//<<TODO>>//magic number
|
||
|
}
|
||
|
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CPortal_Player::ForceDuckThisFrame( void )
|
||
|
{
|
||
|
if( m_Local.m_bDucked != true )
|
||
|
{
|
||
|
//m_Local.m_bDucking = false;
|
||
|
m_Local.m_bDucked = true;
|
||
|
ForceButtons( IN_DUCK );
|
||
|
AddFlag( FL_DUCKING );
|
||
|
SetVCollisionState( GetAbsOrigin(), GetAbsVelocity(), VPHYS_CROUCH );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::UnDuck( void )
|
||
|
{
|
||
|
if( m_Local.m_bDucked != false )
|
||
|
{
|
||
|
m_Local.m_bDucked = false;
|
||
|
UnforceButtons( IN_DUCK );
|
||
|
RemoveFlag( FL_DUCKING );
|
||
|
SetVCollisionState( GetAbsOrigin(), GetAbsVelocity(), VPHYS_WALK );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Overload for portal-- Our player can lift his own mass.
|
||
|
// Input : *pObject - The object to lift
|
||
|
// bLimitMassAndSize - check for mass/size limits
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CPortal_Player::PickupObject(CBaseEntity *pObject, bool bLimitMassAndSize )
|
||
|
{
|
||
|
// can't pick up what you're standing on
|
||
|
if ( GetGroundEntity() == pObject )
|
||
|
return;
|
||
|
|
||
|
if ( bLimitMassAndSize == true )
|
||
|
{
|
||
|
if ( CBasePlayer::CanPickupObject( pObject, PORTAL_PLAYER_MAX_LIFT_MASS, PORTAL_PLAYER_MAX_LIFT_SIZE ) == false )
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// Can't be picked up if NPCs are on me
|
||
|
if ( pObject->HasNPCsOnIt() )
|
||
|
return;
|
||
|
|
||
|
PlayerPickupObject( this, pObject );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::ForceDropOfCarriedPhysObjects( CBaseEntity *pOnlyIfHoldingThis )
|
||
|
{
|
||
|
m_bHeldObjectOnOppositeSideOfPortal = false;
|
||
|
BaseClass::ForceDropOfCarriedPhysObjects( pOnlyIfHoldingThis );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::IncrementPortalsPlaced( void )
|
||
|
{
|
||
|
m_StatsThisLevel.iNumPortalsPlaced++;
|
||
|
|
||
|
if ( m_iBonusChallenge == PORTAL_CHALLENGE_PORTALS )
|
||
|
SetBonusProgress( static_cast<int>( m_StatsThisLevel.iNumPortalsPlaced ) );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::IncrementStepsTaken( void )
|
||
|
{
|
||
|
m_StatsThisLevel.iNumStepsTaken++;
|
||
|
|
||
|
if ( m_iBonusChallenge == PORTAL_CHALLENGE_STEPS )
|
||
|
SetBonusProgress( static_cast<int>( m_StatsThisLevel.iNumStepsTaken ) );
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::UpdateSecondsTaken( void )
|
||
|
{
|
||
|
float fSecondsSinceLastUpdate = ( gpGlobals->curtime - m_fTimeLastNumSecondsUpdate );
|
||
|
m_StatsThisLevel.fNumSecondsTaken += fSecondsSinceLastUpdate;
|
||
|
m_fTimeLastNumSecondsUpdate = gpGlobals->curtime;
|
||
|
|
||
|
if ( m_iBonusChallenge == PORTAL_CHALLENGE_TIME )
|
||
|
SetBonusProgress( static_cast<int>( m_StatsThisLevel.fNumSecondsTaken ) );
|
||
|
|
||
|
if ( m_fNeuroToxinDamageTime > 0.0f )
|
||
|
{
|
||
|
float fTimeRemaining = m_fNeuroToxinDamageTime - gpGlobals->curtime;
|
||
|
|
||
|
if ( fTimeRemaining < 0.0f )
|
||
|
{
|
||
|
CTakeDamageInfo info;
|
||
|
info.SetDamage( gpGlobals->frametime * 50.0f );
|
||
|
info.SetDamageType( DMG_NERVEGAS );
|
||
|
TakeDamage( info );
|
||
|
fTimeRemaining = 0.0f;
|
||
|
}
|
||
|
|
||
|
PauseBonusProgress( false );
|
||
|
SetBonusProgress( static_cast<int>( fTimeRemaining ) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::ResetThisLevelStats( void )
|
||
|
{
|
||
|
m_StatsThisLevel.iNumPortalsPlaced = 0;
|
||
|
m_StatsThisLevel.iNumStepsTaken = 0;
|
||
|
m_StatsThisLevel.fNumSecondsTaken = 0.0f;
|
||
|
|
||
|
if ( m_iBonusChallenge != PORTAL_CHALLENGE_NONE )
|
||
|
SetBonusProgress( 0 );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Update the area bits variable which is networked down to the client to determine
|
||
|
// which area portals should be closed based on visibility.
|
||
|
// Input : *pvs - pvs to be used to determine visibility of the portals
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CPortal_Player::UpdatePortalViewAreaBits( unsigned char *pvs, int pvssize )
|
||
|
{
|
||
|
Assert ( pvs );
|
||
|
|
||
|
int iPortalCount = CProp_Portal_Shared::AllPortals.Count();
|
||
|
if( iPortalCount == 0 )
|
||
|
return;
|
||
|
|
||
|
CProp_Portal **pPortals = CProp_Portal_Shared::AllPortals.Base();
|
||
|
int *portalArea = (int *)stackalloc( sizeof( int ) * iPortalCount );
|
||
|
bool *bUsePortalForVis = (bool *)stackalloc( sizeof( bool ) * iPortalCount );
|
||
|
|
||
|
unsigned char *portalTempBits = (unsigned char *)stackalloc( sizeof( unsigned char ) * 32 * iPortalCount );
|
||
|
COMPILE_TIME_ASSERT( (sizeof( unsigned char ) * 32) >= sizeof( ((CPlayerLocalData*)0)->m_chAreaBits ) );
|
||
|
|
||
|
// setup area bits for these portals
|
||
|
for ( int i = 0; i < iPortalCount; ++i )
|
||
|
{
|
||
|
CProp_Portal* pLocalPortal = pPortals[ i ];
|
||
|
// Make sure this portal is active before adding it's location to the pvs
|
||
|
if ( pLocalPortal && pLocalPortal->m_bActivated )
|
||
|
{
|
||
|
CProp_Portal* pRemotePortal = pLocalPortal->m_hLinkedPortal.Get();
|
||
|
|
||
|
// Make sure this portal's linked portal is in the PVS before we add what it can see
|
||
|
if ( pRemotePortal && pRemotePortal->m_bActivated && pRemotePortal->NetworkProp() &&
|
||
|
pRemotePortal->NetworkProp()->IsInPVS( edict(), pvs, pvssize ) )
|
||
|
{
|
||
|
portalArea[ i ] = engine->GetArea( pPortals[ i ]->GetAbsOrigin() );
|
||
|
|
||
|
if ( portalArea [ i ] >= 0 )
|
||
|
{
|
||
|
bUsePortalForVis[ i ] = true;
|
||
|
}
|
||
|
|
||
|
engine->GetAreaBits( portalArea[ i ], &portalTempBits[ i * 32 ], sizeof( unsigned char ) * 32 );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Use the union of player-view area bits and the portal-view area bits of each portal
|
||
|
for ( int i = 0; i < m_Local.m_chAreaBits.Count(); i++ )
|
||
|
{
|
||
|
for ( int j = 0; j < iPortalCount; ++j )
|
||
|
{
|
||
|
// If this portal is active, in PVS and it's location is valid
|
||
|
if ( bUsePortalForVis[ j ] )
|
||
|
{
|
||
|
m_Local.m_chAreaBits.Set( i, m_Local.m_chAreaBits[ i ] | portalTempBits[ (j * 32) + i ] );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//////////////////////////////////////////////////////////////////////////
|
||
|
// AddPortalCornersToEnginePVS
|
||
|
// Subroutine to wrap the adding of portal corners to the PVS which is called once for the setup of each portal.
|
||
|
// input - pPortal: the portal we are viewing 'out of' which needs it's corners added to the PVS
|
||
|
//////////////////////////////////////////////////////////////////////////
|
||
|
void AddPortalCornersToEnginePVS( CProp_Portal* pPortal )
|
||
|
{
|
||
|
Assert ( pPortal );
|
||
|
|
||
|
if ( !pPortal )
|
||
|
return;
|
||
|
|
||
|
Vector vForward, vRight, vUp;
|
||
|
pPortal->GetVectors( &vForward, &vRight, &vUp );
|
||
|
|
||
|
// Center of the remote portal
|
||
|
Vector ptOrigin = pPortal->GetAbsOrigin();
|
||
|
|
||
|
// Distance offsets to the different edges of the portal... Used in the placement checks
|
||
|
Vector vToTopEdge = vUp * ( PORTAL_HALF_HEIGHT - PORTAL_BUMP_FORGIVENESS );
|
||
|
Vector vToBottomEdge = -vToTopEdge;
|
||
|
Vector vToRightEdge = vRight * ( PORTAL_HALF_WIDTH - PORTAL_BUMP_FORGIVENESS );
|
||
|
Vector vToLeftEdge = -vToRightEdge;
|
||
|
|
||
|
// Distance to place PVS points away from portal, to avoid being in solid
|
||
|
Vector vForwardBump = vForward * 1.0f;
|
||
|
|
||
|
// Add center and edges to the engine PVS
|
||
|
engine->AddOriginToPVS( ptOrigin + vForwardBump);
|
||
|
engine->AddOriginToPVS( ptOrigin + vToTopEdge + vToLeftEdge + vForwardBump );
|
||
|
engine->AddOriginToPVS( ptOrigin + vToTopEdge + vToRightEdge + vForwardBump );
|
||
|
engine->AddOriginToPVS( ptOrigin + vToBottomEdge + vToLeftEdge + vForwardBump );
|
||
|
engine->AddOriginToPVS( ptOrigin + vToBottomEdge + vToRightEdge + vForwardBump );
|
||
|
}
|
||
|
|
||
|
void PortalSetupVisibility( CBaseEntity *pPlayer, int area, unsigned char *pvs, int pvssize )
|
||
|
{
|
||
|
int iPortalCount = CProp_Portal_Shared::AllPortals.Count();
|
||
|
if( iPortalCount == 0 )
|
||
|
return;
|
||
|
|
||
|
CProp_Portal **pPortals = CProp_Portal_Shared::AllPortals.Base();
|
||
|
for( int i = 0; i != iPortalCount; ++i )
|
||
|
{
|
||
|
CProp_Portal *pPortal = pPortals[i];
|
||
|
|
||
|
if ( pPortal && pPortal->m_bActivated )
|
||
|
{
|
||
|
if ( pPortal->NetworkProp()->IsInPVS( pPlayer->edict(), pvs, pvssize ) )
|
||
|
{
|
||
|
if ( engine->CheckAreasConnected( area, pPortal->NetworkProp()->AreaNum() ) )
|
||
|
{
|
||
|
CProp_Portal *pLinkedPortal = static_cast<CProp_Portal*>( pPortal->m_hLinkedPortal.Get() );
|
||
|
if ( pLinkedPortal )
|
||
|
{
|
||
|
AddPortalCornersToEnginePVS ( pLinkedPortal );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize )
|
||
|
{
|
||
|
BaseClass::SetupVisibility( pViewEntity, pvs, pvssize );
|
||
|
|
||
|
int area = pViewEntity ? pViewEntity->NetworkProp()->AreaNum() : NetworkProp()->AreaNum();
|
||
|
|
||
|
// At this point the EyePosition has been added as a view origin, but if we are currently stuck
|
||
|
// in a portal, our EyePosition may return a point in solid. Find the reflected eye position
|
||
|
// and use that as a vis origin instead.
|
||
|
if ( m_hPortalEnvironment )
|
||
|
{
|
||
|
CProp_Portal *pPortal = NULL, *pRemotePortal = NULL;
|
||
|
pPortal = m_hPortalEnvironment;
|
||
|
pRemotePortal = pPortal->m_hLinkedPortal;
|
||
|
|
||
|
if ( pPortal && pRemotePortal && pPortal->m_bActivated && pRemotePortal->m_bActivated )
|
||
|
{
|
||
|
Vector ptPortalCenter = pPortal->GetAbsOrigin();
|
||
|
Vector vPortalForward;
|
||
|
pPortal->GetVectors( &vPortalForward, NULL, NULL );
|
||
|
|
||
|
Vector eyeOrigin = EyePosition();
|
||
|
Vector vEyeToPortalCenter = ptPortalCenter - eyeOrigin;
|
||
|
|
||
|
float fPortalDist = vPortalForward.Dot( vEyeToPortalCenter );
|
||
|
if( fPortalDist > 0.0f ) //eye point is behind portal
|
||
|
{
|
||
|
// Move eye origin to it's transformed position on the other side of the portal
|
||
|
UTIL_Portal_PointTransform( pPortal->MatrixThisToLinked(), eyeOrigin, eyeOrigin );
|
||
|
|
||
|
// Use this as our view origin (as this is where the client will be displaying from)
|
||
|
engine->AddOriginToPVS( eyeOrigin );
|
||
|
if ( !pViewEntity || pViewEntity->IsPlayer() )
|
||
|
{
|
||
|
area = engine->GetArea( eyeOrigin );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
PortalSetupVisibility( this, area, pvs, pvssize );
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef PORTAL_MP
|
||
|
|
||
|
CBaseEntity* CPortal_Player::EntSelectSpawnPoint( void )
|
||
|
{
|
||
|
CBaseEntity *pSpot = NULL;
|
||
|
CBaseEntity *pLastSpawnPoint = g_pLastSpawn;
|
||
|
edict_t *player = edict();
|
||
|
const char *pSpawnpointName = "info_player_start";
|
||
|
|
||
|
/*if ( HL2MPRules()->IsTeamplay() == true )
|
||
|
{
|
||
|
if ( GetTeamNumber() == TEAM_COMBINE )
|
||
|
{
|
||
|
pSpawnpointName = "info_player_combine";
|
||
|
pLastSpawnPoint = g_pLastCombineSpawn;
|
||
|
}
|
||
|
else if ( GetTeamNumber() == TEAM_REBELS )
|
||
|
{
|
||
|
pSpawnpointName = "info_player_rebel";
|
||
|
pLastSpawnPoint = g_pLastRebelSpawn;
|
||
|
}
|
||
|
|
||
|
if ( gEntList.FindEntityByClassname( NULL, pSpawnpointName ) == NULL )
|
||
|
{
|
||
|
pSpawnpointName = "info_player_deathmatch";
|
||
|
pLastSpawnPoint = g_pLastSpawn;
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
pSpot = pLastSpawnPoint;
|
||
|
// Randomize the start spot
|
||
|
for ( int i = random->RandomInt(1,5); i > 0; i-- )
|
||
|
pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );
|
||
|
if ( !pSpot ) // skip over the null point
|
||
|
pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );
|
||
|
|
||
|
CBaseEntity *pFirstSpot = pSpot;
|
||
|
|
||
|
do
|
||
|
{
|
||
|
if ( pSpot )
|
||
|
{
|
||
|
// check if pSpot is valid
|
||
|
if ( g_pGameRules->IsSpawnPointValid( pSpot, this ) )
|
||
|
{
|
||
|
if ( pSpot->GetLocalOrigin() == vec3_origin )
|
||
|
{
|
||
|
pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
// if so, go to pSpot
|
||
|
goto ReturnSpot;
|
||
|
}
|
||
|
}
|
||
|
// increment pSpot
|
||
|
pSpot = gEntList.FindEntityByClassname( pSpot, pSpawnpointName );
|
||
|
} 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 ( pSpot )
|
||
|
{
|
||
|
CBaseEntity *ent = NULL;
|
||
|
for ( CEntitySphereQuery sphere( pSpot->GetAbsOrigin(), 128 ); (ent = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() )
|
||
|
{
|
||
|
// if ent is a client, kill em (unless they are ourselves)
|
||
|
if ( ent->IsPlayer() && !(ent->edict() == player) )
|
||
|
ent->TakeDamage( CTakeDamageInfo( GetContainingEntity(INDEXENT(0)), GetContainingEntity(INDEXENT(0)), 300, DMG_GENERIC ) );
|
||
|
}
|
||
|
goto ReturnSpot;
|
||
|
}
|
||
|
|
||
|
if ( !pSpot )
|
||
|
{
|
||
|
pSpot = gEntList.FindEntityByClassname( pSpot, "info_player_start" );
|
||
|
|
||
|
if ( pSpot )
|
||
|
goto ReturnSpot;
|
||
|
}
|
||
|
|
||
|
ReturnSpot:
|
||
|
|
||
|
/*if ( HL2MPRules()->IsTeamplay() == true )
|
||
|
{
|
||
|
if ( GetTeamNumber() == TEAM_COMBINE )
|
||
|
{
|
||
|
g_pLastCombineSpawn = pSpot;
|
||
|
}
|
||
|
else if ( GetTeamNumber() == TEAM_REBELS )
|
||
|
{
|
||
|
g_pLastRebelSpawn = pSpot;
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
g_pLastSpawn = pSpot;
|
||
|
|
||
|
//m_flSlamProtectTime = gpGlobals->curtime + 0.5;
|
||
|
|
||
|
return pSpot;
|
||
|
}
|
||
|
|
||
|
void CPortal_Player::PickTeam( void )
|
||
|
{
|
||
|
//picks lowest or random
|
||
|
CTeam *pCombine = g_Teams[TEAM_COMBINE];
|
||
|
CTeam *pRebels = g_Teams[TEAM_REBELS];
|
||
|
if ( pCombine->GetNumPlayers() > pRebels->GetNumPlayers() )
|
||
|
{
|
||
|
ChangeTeam( TEAM_REBELS );
|
||
|
}
|
||
|
else if ( pCombine->GetNumPlayers() < pRebels->GetNumPlayers() )
|
||
|
{
|
||
|
ChangeTeam( TEAM_COMBINE );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
ChangeTeam( random->RandomInt( TEAM_COMBINE, TEAM_REBELS ) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
CON_COMMAND( startadmiregloves, "Starts the admire gloves animation." )
|
||
|
{
|
||
|
CPortal_Player *pPlayer = (CPortal_Player *)UTIL_GetCommandClient();
|
||
|
if( pPlayer == NULL )
|
||
|
pPlayer = GetPortalPlayer( 1 ); //last ditch effort
|
||
|
|
||
|
if( pPlayer )
|
||
|
pPlayer->StartAdmireGlovesAnimation();
|
||
|
}
|
||
|
|
||
|
CON_COMMAND( displayportalplayerstats, "Displays current level stats for portals placed, steps taken, and seconds taken." )
|
||
|
{
|
||
|
CPortal_Player *pPlayer = (CPortal_Player *)UTIL_GetCommandClient();
|
||
|
if( pPlayer == NULL )
|
||
|
pPlayer = GetPortalPlayer( 1 ); //last ditch effort
|
||
|
|
||
|
if( pPlayer )
|
||
|
{
|
||
|
int iMinutes = static_cast<int>( pPlayer->NumSecondsTaken() / 60.0f );
|
||
|
int iSeconds = static_cast<int>( pPlayer->NumSecondsTaken() ) % 60;
|
||
|
|
||
|
CFmtStr msg;
|
||
|
NDebugOverlay::ScreenText( 0.5f, 0.5f, msg.sprintf( "Portals Placed: %d\nSteps Taken: %d\nTime: %d:%d", pPlayer->NumPortalsPlaced(), pPlayer->NumStepsTaken(), iMinutes, iSeconds ), 255, 255, 255, 150, 5.0f );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
CON_COMMAND( startneurotoxins, "Starts the nerve gas timer." )
|
||
|
{
|
||
|
CPortal_Player *pPlayer = (CPortal_Player *)UTIL_GetCommandClient();
|
||
|
if( pPlayer == NULL )
|
||
|
pPlayer = GetPortalPlayer( 1 ); //last ditch effort
|
||
|
|
||
|
float fCoundownTime = 180.0f;
|
||
|
|
||
|
if ( args.ArgC() > 1 )
|
||
|
fCoundownTime = atof( args[ 1 ] );
|
||
|
|
||
|
if( pPlayer )
|
||
|
pPlayer->SetNeuroToxinDamageTime( fCoundownTime );
|
||
|
}
|