d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
3 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: af9544dcaa
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'af9544dcaa'
${ noResults }
source-engine/game/shared/tf2/weapon_combatshield.cpp

1205 lines
37 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Combative shield weapon
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "basetfplayer_shared.h"
#include "weapon_twohandedcontainer.h"
#include "weapon_combatshield.h"
#include "engine/IEngineSound.h"
#include "in_buttons.h"
#include "weapon_combat_usedwithshieldbase.h"
#if !defined( CLIENT_DLL )
#include "tf_shield.h"
extern ConVar tf_knockdowntime;
#else
#include "iviewrender_beams.h"
#include "c_team.h"
#include "cdll_int.h"
#include "hudelement.h"
#include "bone_setup.h"
#include "beamdraw.h"
#include <vgui/ISurface.h>
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Damage CVars
ConVar weapon_combat_shield_rechargetime( "weapon_combat_shield_rechargetime","4", FCVAR_REPLICATED, "Time after taking damage before the shields starts recharging" );
ConVar weapon_combat_shield_rechargeamount( "weapon_combat_shield_rechargeamount","0.03", FCVAR_REPLICATED, "Amount shield recharges every 10th of a second (must be an int)" );
ConVar weapon_combat_shield_factor( "weapon_combat_shield_factor","0.4", FCVAR_REPLICATED, "Factor applied to damage the shield blocks" );
ConVar weapon_combat_shield_teslaspeed( "weapon_combat_shield_teslaspeed", "0.025f", FCVAR_REPLICATED, "Speed of the tesla effect on the view model." );
ConVar weapon_combat_shield_teslaskitter( "weapon_combat_shield_teslaskitter", "0.3f", FCVAR_REPLICATED, "Speed of the tesla skitter effect (percentage)." );
ConVar weapon_combat_shield_teslaeffect( "weapon_combat_shield_teslaeffect", "4", FCVAR_REPLICATED, "Experimenting with effects." );
ConVar weapon_combat_shield_health( "weapon_combat_shield_health", "100", FCVAR_REPLICATED, "Combat shield's maximum health." );
// HACK: If we don't set this then we get a pop when transitioning into / out of idle animation
// for commando_test model because the origin is wrong
// This can be removed once the model itself is fixed
#define SHIELD_FADOUT_TIME 0.2f
//-----------------------------------------------------------------------------
// Constructor, destructor:
//-----------------------------------------------------------------------------
CWeaponCombatShield::CWeaponCombatShield()
{
m_bAllowPostFrame = true;
m_bHasShieldParry = false;
m_flShieldHealth = 1.0;
#if defined( CLIENT_DLL )
m_flFlashTimeEnd = 0;
m_flTeslaSpeed = weapon_combat_shield_teslaspeed.GetFloat();
m_flTeslaSkitter = weapon_combat_shield_teslaskitter.GetFloat();
m_flTeslaLeftInc = 0.0f;
m_flTeslaRightInc = 0.0f;
m_pTeslaBeam = NULL;
m_pTeslaBeam2 = NULL;
m_flShieldInc = 1.0f;
m_pShieldBeam = NULL;
m_pShieldBeam2 = NULL;
m_pShieldBeam3 = NULL;
#endif
SetPredictionEligible( true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::Precache( void )
{
BaseClass::Precache();
PrecacheModel( "sprites/blueflare1.vmt" );
PrecacheModel( "sprites/physbeam.vmt" );
PrecacheScriptSound( "WeaponCombatShield.TakeBash" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponCombatShield::Deploy( void )
{
if ( BaseClass::Deploy() )
{
GainedNewTechnology(NULL);
SetShieldState( SS_DOWN );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Get the activity the other weapon in our twohanded container should play for this activity
//-----------------------------------------------------------------------------
int CWeaponCombatShield::GetOtherWeaponsActivity( int iActivity )
{
switch ( iActivity )
{
case ACT_VM_HAULBACK:
return ACT_VM_DRAW;
case ACT_VM_SECONDARYATTACK:
return ACT_VM_HOLSTER;
default:
break;
};
return -1;
}
//-----------------------------------------------------------------------------
// Purpose: Get the activity the other weapon in our twohanded container should
// play instead of the one it's attempting to play.
//-----------------------------------------------------------------------------
int CWeaponCombatShield::ReplaceOtherWeaponsActivity( int iActivity )
{
switch ( iActivity )
{
case ACT_VM_IDLE:
// If I'm active, don't let it idle
if ( GetShieldState() != SS_DOWN )
return -1;
default:
break;
};
return BaseClass::ReplaceOtherWeaponsActivity(iActivity);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponCombatShield::Holster( CBaseCombatWeapon *pSwitchingTo )
{
CBaseTFPlayer *player = ToBaseTFPlayer( GetOwner() );
if ( player )
{
player->SetBlocking( false );
player->SetParrying( false );
if ( m_iShieldState != SS_DOWN &&
m_iShieldState != SS_UNAVAILABLE )
{
SetShieldState( SS_LOWERING );
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: I've been bashed by another player's shield
//-----------------------------------------------------------------------------
bool CWeaponCombatShield::TakeShieldBash( CBaseTFPlayer *pBasher )
{
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
if ( !pOwner )
return false;
// If I'm blocking, drop my block and prevent me from doing anything
if ( GetShieldState() == SS_UP ||
GetShieldState() == SS_RAISING ||
GetShieldState() == SS_LOWERING )
{
// Make the shield unavailable
SetShieldState( SS_UNAVAILABLE );
SendWeaponAnim( ACT_VM_HITCENTER );
m_flShieldUnavailableEndTime = gpGlobals->curtime + 2.0;
// Play a sound
EmitSound( "WeaponCombatShield.TakeBash" );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::SetShieldState( int iShieldState )
{
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
if ( !pOwner )
return;
switch (iShieldState )
{
default:
case SS_DOWN:
pOwner->SetBlocking( false );
m_flShieldUpStartTime = 0;
m_flShieldParryEndTime = 0;
m_flShieldUnavailableEndTime = 0;
m_flShieldRaisedTime = 0.0f;
m_flShieldLoweredTime = 0.0f;
break;
case SS_UP:
SendWeaponAnim( ACT_VM_FIDGET );
pOwner->SetBlocking( true );
m_flShieldDownStartTime = 0.0f;
m_flShieldParryEndTime = 0;
m_flShieldUnavailableEndTime = 0;
m_flShieldRaisedTime = 0.0f;
m_flShieldLoweredTime = 0.0f;
break;
case SS_PARRYING:
pOwner->SetBlocking( false );
pOwner->SetParrying( true );
m_flShieldParryEndTime = gpGlobals->curtime + PARRY_OPPORTUNITY_LENGTH;
m_flShieldParrySwingEndTime = gpGlobals->curtime + 1.0f; // a hack to make it look ok
m_flShieldUnavailableEndTime = gpGlobals->curtime + SequenceDuration();
m_flNextPrimaryAttack = m_flShieldUnavailableEndTime;
m_flShieldRaisedTime = 0.0f;
m_flShieldLoweredTime = 0.0f;
break;
case SS_PARRYING_FINISH_SWING:
pOwner->SetBlocking( false );
pOwner->SetParrying( false );
break;
case SS_UNAVAILABLE:
SendWeaponAnim( ACT_VM_HAULBACK );
pOwner->SetBlocking( false );
pOwner->SetParrying( false );
break;
case SS_RAISING:
{
pOwner->SetBlocking( false );
pOwner->SetParrying( false );
m_flShieldRaisedTime = gpGlobals->curtime + SequenceDuration();
m_flShieldUpStartTime = gpGlobals->curtime;
}
break;
case SS_LOWERING:
{
SendWeaponAnim( ACT_VM_HAULBACK );
pOwner->SetBlocking( false );
pOwner->SetParrying( false );
m_flShieldLoweredTime = gpGlobals->curtime + SequenceDuration();
m_flShieldDownStartTime = gpGlobals->curtime;
}
break;
};
m_iShieldState = iShieldState;
}
//-----------------------------------------------------------------------------
// Purpose: Check to see if the shield state should change
//-----------------------------------------------------------------------------
void CWeaponCombatShield::UpdateShieldState( void )
{
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
if ( !pOwner )
return;
// Check to see if I should move out of the current state
switch ( m_iShieldState )
{
default:
case SS_DOWN:
case SS_UP:
break;
case SS_RAISING:
if ( gpGlobals->curtime > m_flShieldRaisedTime )
{
SetShieldState( SS_UP );
}
break;
case SS_LOWERING:
if ( gpGlobals->curtime > m_flShieldLoweredTime )
{
SetShieldState( SS_DOWN );
}
break;
case SS_PARRYING:
if ( gpGlobals->curtime > m_flShieldParryEndTime )
{
SetShieldState( SS_PARRYING_FINISH_SWING );
}
break;
case SS_PARRYING_FINISH_SWING:
if ( gpGlobals->curtime > m_flShieldParrySwingEndTime )
{
SetShieldState( SS_UNAVAILABLE );
}
break;
case SS_UNAVAILABLE:
if ( gpGlobals->curtime > m_flShieldUnavailableEndTime )
{
SetShieldState( SS_DOWN );
}
break;
};
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CWeaponCombatShield::GetShieldState( void )
{
return m_iShieldState;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::SetShieldUsable( bool bUsable )
{
// Shutting down!
if ( !bUsable )
{
if ( m_iShieldState == SS_UP || m_iShieldState == SS_RAISING )
{
// We've got our shield up, so drop it (play sound & animation).
SendWeaponAnim( ACT_VM_HAULBACK );
WeaponSound( SPECIAL2 );
SetShieldState( SS_LOWERING );
}
}
m_bUsable = bUsable;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponCombatShield::ShieldUsable( void )
{
return m_bUsable;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : allow -
//-----------------------------------------------------------------------------
void CWeaponCombatShield::SetAllowPostFrame( bool allow )
{
m_bAllowPostFrame = allow;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::ItemPostFrame( void )
{
if ( m_bAllowPostFrame )
{
ShieldPostFrame();
}
}
//-----------------------------------------------------------------------------
// Purpose: Allow the shield to interrupt reloads, etc.
//-----------------------------------------------------------------------------
void CWeaponCombatShield::ItemBusyFrame( void )
{
if ( m_bAllowPostFrame )
{
ShieldPostFrame();
}
}
//-----------------------------------------------------------------------------
// Purpose: The player holding this weapon has just gained new technology.
//-----------------------------------------------------------------------------
void CWeaponCombatShield::GainedNewTechnology( CBaseTechnology *pTechnology )
{
BaseClass::GainedNewTechnology( pTechnology );
CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
if ( pPlayer )
{
// Has a parry?
if ( pPlayer->HasNamedTechnology( "com_comboshield_parry" ) )
{
m_bHasShieldParry = true;
}
else
{
m_bHasShieldParry = false;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle the shield input
//-----------------------------------------------------------------------------
void CWeaponCombatShield::ShieldPostFrame( void )
{
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
if (!pOwner)
return;
UpdateShieldState();
CheckReload();
// Store off EMP state
bool isEMPed = IsOwnerEMPed();
// If the shield's unavailable, just abort
if ( GetShieldState() == SS_UNAVAILABLE )
return;
if ( m_flNextPrimaryAttack > gpGlobals->curtime )
return;
bool shieldRaised = ( GetShieldState() == SS_UP );
bool shieldRaising = ( GetShieldState() == SS_RAISING );
// GetShieldState() == SS_LOWERING );
// If my shield's out of power, I can't do anything with it
if ( !GetShieldHealth() )
return;
// Was the shield button just pressed?
if ( GetShieldState() == SS_DOWN && !isEMPed && pOwner->m_nButtons & IN_ATTACK2 )
{
// Play sound & anim
WeaponSound( SPECIAL1 );
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
SetShieldState( SS_RAISING );
// Abort any reloads in progess
pOwner->AbortReload();
}
else if ( ( shieldRaised || shieldRaising ) && !FBitSet( pOwner->m_nButtons, IN_ATTACK2 ) )
{
// Shield button was just released, check to see if we were parrying
bool shouldParry = (gpGlobals->curtime < (m_flShieldUpStartTime + PARRY_DETECTION_TIME ));
if ( m_bHasShieldParry && shouldParry )
{
// Parry!
// Play sound & anim
WeaponSound( SPECIAL2 );
SendWeaponAnim( ACT_VM_SWINGHIT );
SetShieldState( SS_PARRYING );
// Bash enemies in front of me
ShieldBash();
}
else
{
// Player's just lowered his shield
// Play sound & anim
WeaponSound( SPECIAL2 );
SendWeaponAnim( ACT_VM_HAULBACK );
SetShieldState( SS_LOWERING );
m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
}
}
else if ( GetShieldState() == SS_UP && ( pOwner->m_nButtons & IN_ATTACK2 ) && ( isEMPed ) )
{
// We've got our shield up, and we were just EMPed, so drop it
// Play sound & anim
SendWeaponAnim( ACT_VM_HAULBACK );
WeaponSound( SPECIAL2 );
SetShieldState( SS_LOWERING );
}
}
//-----------------------------------------------------------------------------
// Purpose: Bash enemies in front of me with my shield
//-----------------------------------------------------------------------------
void CWeaponCombatShield::ShieldBash( void )
{
#if 0
// ROBIN: Disabled shield bash
return;
// Get any players in front of me
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
if ( !pOwner )
return;
// Get the target point and location
Vector vecAiming;
Vector vecSrc = pOwner->Weapon_ShootPosition( pOwner->GetOrigin() );
pOwner->EyeVectors( &vecAiming );
// Find a player in range of this player, and make sure they're healable
trace_t tr;
Vector vecEnd = vecSrc + (vecAiming * SHIELD_BASH_RANGE);
UTIL_TraceLine( vecSrc, vecEnd, MASK_SHOT, pOwner->edict(), COLLISION_GROUP_NONE, &tr);
if (tr.fraction != 1.0)
{
CBaseEntity *pEntity = CBaseEntity::Instance(tr.u.ent);
if ( pEntity )
{
CBaseTFPlayer *pPlayer = ToBaseTFPlayer( pEntity );
if ( pPlayer && (pPlayer != pOwner) )
{
// Target needs to be on the eneny team
if ( pPlayer->IsAlive() && !pPlayer->InSameTeam( pOwner ) )
{
// Ok, we have an enemy player
pPlayer->TakeShieldBash( pOwner );
}
}
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Attempt to block the incoming attack, and return the damage it
// should do after the block, if any.
//-----------------------------------------------------------------------------
float CWeaponCombatShield::AttemptToBlock( float flDamage )
{
CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
if ( !pPlayer || !weapon_combat_shield_factor.GetFloat() )
return 0;
// Block as much of the damage as we can
float flPowerNeeded = flDamage * weapon_combat_shield_factor.GetFloat();
flPowerNeeded = RemapVal( flPowerNeeded, 0, weapon_combat_shield_health.GetFloat(), 0, 1 );
float flPowerUsed = MIN( flPowerNeeded, GetShieldHealth() );
#ifndef CLIENT_DLL
RemoveShieldHealth( flPowerUsed );
// Start recharging shortly after taking damage
SetThink( ShieldRechargeThink );
SetNextThink( gpGlobals->curtime + weapon_combat_shield_rechargetime.GetFloat() );
#endif
// Failed to block it all?
if ( flPowerUsed < flPowerNeeded )
{
#ifndef CLIENT_DLL
// Force the shield to drop if it's up
if ( GetShieldState() == SS_UP )
{
// Play sound & anim
SendWeaponAnim( ACT_VM_HAULBACK );
WeaponSound( SPECIAL2 );
SetShieldState( SS_LOWERING );
}
#endif
return ( flDamage - (flPowerUsed * (1.0 / weapon_combat_shield_factor.GetFloat())) );
}
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CWeaponCombatShield::GetShieldHealth( void )
{
return m_flShieldHealth;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::AddShieldHealth( float flHealth )
{
m_flShieldHealth = MIN( 1.0, m_flShieldHealth + flHealth );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::RemoveShieldHealth( float flHealth )
{
m_flShieldHealth = MAX( 0.0, m_flShieldHealth - flHealth );
}
//-----------------------------------------------------------------------------
// Purpose: Recharge the shield
//-----------------------------------------------------------------------------
void CWeaponCombatShield::ShieldRechargeThink( void )
{
// FIXME:
//xxx
#if !defined( CLIENT_DLL )
if ( GetShieldHealth() >= 1.0 )
{
SetThink( NULL );
return;
}
AddShieldHealth( weapon_combat_shield_rechargeamount.GetFloat() );
SetNextThink( gpGlobals->curtime + 0.1f );
#endif
}
//====================================================================================
// WEAPON CLIENT HANDLING
//====================================================================================
int CWeaponCombatShield::UpdateClientData( CBasePlayer *pPlayer )
{
if ( !pPlayer )
{
return BaseClass::UpdateClientData( pPlayer );
}
CWeaponTwoHandedContainer *pContainer = ( CWeaponTwoHandedContainer * )pPlayer->Weapon_OwnsThisType( "weapon_twohandedcontainer" );
if ( !pContainer || pContainer != pPlayer->GetActiveWeapon() )
return BaseClass::UpdateClientData( pPlayer );
// Make sure this weapon is one of the container's active weapons
if ( pContainer->GetLeftWeapon() != this && pContainer->GetRightWeapon() != this )
return BaseClass::UpdateClientData( pPlayer );
int retval = pContainer->UpdateClientData( pPlayer );
m_iState = pContainer->m_iState;
return retval;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponCombatShield::VisibleInWeaponSelection( void )
{
return false;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool CWeaponCombatShield::IsUp( void )
{
return ( GetShieldState() == SS_UP );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
float CWeaponCombatShield::GetRaisingTime( void )
{
if ((GetShieldState() != SS_UP ) && (GetShieldState() != SS_RAISING))
return 0.0f;
return gpGlobals->curtime - m_flShieldUpStartTime;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
float CWeaponCombatShield::GetLoweringTime( void )
{
if ((GetShieldState() != SS_DOWN ) && (GetShieldState() != SS_LOWERING))
return 0.0f;
return gpGlobals->curtime - m_flShieldDownStartTime;
}
#if defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose: Draw the ammo counts
//-----------------------------------------------------------------------------
void CWeaponCombatShield::DrawAmmo( void )
{
// ROBIN: Removed this now that the shield colors itself to show health level
return;
int r, g, b, a;
int x, y;
// Get the shield power level
float flPowerLevel = GetShieldHealth();
float flInverseFactor = 1.0 - flPowerLevel;
// Set our color
gHUD.m_clrNormal.GetColor( r, g, b, a );
int iWidth = XRES(12);
int iHeight = YRES(64);
x = XRES(548);
y = ( ScreenHeight() - YRES(2) - iHeight );
// Flashing the power level?
float flFlash = 0;
if ( gpGlobals->curtime < m_flFlashTimeEnd && !GetPrimaryAmmo() )
{
flFlash = fmod( gpGlobals->curtime, 0.25 );
flFlash *= 2 * M_PI;
flFlash = cos( flFlash );
}
// draw the exhausted portion of the bar.
vgui::surface()->DrawSetColor( Color( r, g * flPowerLevel, b * flPowerLevel, 100 + (flFlash * 100) ) );
vgui::surface()->DrawFilledRect( x, y, x + iWidth, y + iHeight * flInverseFactor );
// draw the powerered portion of the bar
vgui::surface()->DrawSetColor( Color( r, g * flPowerLevel, b * flPowerLevel, 190 ) );
vgui::surface()->DrawFilledRect( x, y + iHeight * flInverseFactor, x + iWidth, y + iHeight * flInverseFactor + iHeight * flPowerLevel);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::GetViewmodelBoneControllers( C_BaseViewModel *pViewModel, float controllers[MAXSTUDIOBONECTRLS])
{
// Dial shows the shield power level
float flPowerLevel = 1.0;
if ( GetShieldState() == SS_UP )
{
flPowerLevel = GetShieldHealth();
}
else if ( GetShieldState() == SS_RAISING )
{
// Bring the power up with the animation
float flTotal = m_flShieldRaisedTime - m_flShieldUpStartTime;
float flCurrent = (gpGlobals->curtime - m_flShieldUpStartTime);
flPowerLevel = flCurrent / flTotal;
}
else if ( GetShieldState() == SS_LOWERING )
{
// Bring the power down with the animation
float flTotal = (m_flShieldLoweredTime - m_flShieldDownStartTime);
float flCurrent = (gpGlobals->curtime - m_flShieldDownStartTime);
flPowerLevel = 1.0 - (flCurrent / flTotal);
}
// Make the middle point be full power (right of the middle being powered up)
// Adjust a little for the perspective.
flPowerLevel *= 0.55;
// Add some shake
flPowerLevel += RandomFloat( -0.02, 0.02 );
controllers[0] = flPowerLevel;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponCombatShield::ViewModelDrawn( C_BaseViewModel *pViewModel )
{
if ( m_iShieldState == SS_DOWN )
return;
DrawBeams( pViewModel );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::InitShieldBeam( void )
{
BeamInfo_t beamInfo;
beamInfo.m_vecStart.Init();
beamInfo.m_vecEnd.Init();
beamInfo.m_pszModelName = "sprites/physbeam.vmt";
beamInfo.m_flHaloScale = 0.0f;
beamInfo.m_flLife = 0.0f;
beamInfo.m_flWidth = 2.0f;
beamInfo.m_flEndWidth = 2.0f;
beamInfo.m_flFadeLength = 0.0f;
beamInfo.m_flAmplitude = 4.0f;
beamInfo.m_flBrightness = 50.0f;
beamInfo.m_flSpeed = 5.0f;
beamInfo.m_nStartFrame = 0;
beamInfo.m_flFrameRate = 0.0f;
beamInfo.m_flRed = 255.0f;
beamInfo.m_flGreen = 255.0f;
beamInfo.m_flBlue = 128.0f;
beamInfo.m_nSegments = 15;
beamInfo.m_bRenderable = false;
m_pShieldBeam = beams->CreateBeamPoints( beamInfo );
beamInfo.m_vecStart.Init();
beamInfo.m_vecEnd.Init();
beamInfo.m_pszModelName = "sprites/physbeam.vmt";
beamInfo.m_flHaloScale = 0.0f;
beamInfo.m_flLife = 0.0f;
beamInfo.m_flWidth = 1.5f;
beamInfo.m_flEndWidth = 1.5f;
beamInfo.m_flFadeLength = 0.0f;
beamInfo.m_flAmplitude = 8.0f;
beamInfo.m_flBrightness = 75.0f;
beamInfo.m_flSpeed = 10.0f;
beamInfo.m_nStartFrame = 0;
beamInfo.m_flFrameRate = 0.0f;
beamInfo.m_flRed = 255.0f;
beamInfo.m_flGreen = 255.0f;
beamInfo.m_flBlue = 128.0f;
beamInfo.m_nSegments = 20;
beamInfo.m_bRenderable = false;
m_pShieldBeam2 = beams->CreateBeamPoints( beamInfo );
beamInfo.m_vecStart.Init();
beamInfo.m_vecEnd.Init();
beamInfo.m_pszModelName = "sprites/physbeam.vmt";
beamInfo.m_flHaloScale = 0.0f;
beamInfo.m_flLife = 0.0f;
beamInfo.m_flWidth = 3.0f;
beamInfo.m_flEndWidth = 3.0f;
beamInfo.m_flFadeLength = 0.0f;
beamInfo.m_flAmplitude = 5.5f;
beamInfo.m_flBrightness = 50.0f;
beamInfo.m_flSpeed = 10.0f;
beamInfo.m_nStartFrame = 0;
beamInfo.m_flFrameRate = 0.0f;
beamInfo.m_flRed = 255.0f;
beamInfo.m_flGreen = 255.0f;
beamInfo.m_flBlue = 128.0f;
beamInfo.m_nSegments = 18;
beamInfo.m_bRenderable = false;
m_pShieldBeam3 = beams->CreateBeamPoints( beamInfo );
m_hShieldSpriteMaterial.Init( "sprites/blueflare1", TEXTURE_GROUP_CLIENT_EFFECTS );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponCombatShield::InitTeslaBeam( void )
{
BeamInfo_t beamInfo;
beamInfo.m_vecStart.Init();
beamInfo.m_vecEnd.Init();
beamInfo.m_pszModelName = "sprites/blueflare1.vmt";
beamInfo.m_flHaloScale = 0.0f;
beamInfo.m_flLife = 0.0f;
beamInfo.m_flWidth = 1.0f;
beamInfo.m_flEndWidth = 1.0f;
beamInfo.m_flFadeLength = 0.0f;
beamInfo.m_flAmplitude = 16.0f;
beamInfo.m_flBrightness = 255.0f;
beamInfo.m_flSpeed = 25.0f;
beamInfo.m_nStartFrame = 0;
beamInfo.m_flFrameRate = 0.0f;
beamInfo.m_flRed = 206.0f;
beamInfo.m_flGreen = 181.0f;
beamInfo.m_flBlue = 127.0f;
beamInfo.m_nSegments = 15;
beamInfo.m_bRenderable = false;
m_pTeslaBeam = beams->CreateBeamPoints( beamInfo );
beamInfo.m_vecStart.Init();
beamInfo.m_vecEnd.Init();
beamInfo.m_pszModelName = "sprites/blueflare1.vmt";
beamInfo.m_flHaloScale = 0.0f;
beamInfo.m_flLife = 0.0f;
beamInfo.m_flWidth = 1.0f;
beamInfo.m_flEndWidth = 1.0f;
beamInfo.m_flFadeLength = 0.0f;
beamInfo.m_flAmplitude = 27.0f;
beamInfo.m_flBrightness = 100.0f;
beamInfo.m_flSpeed = 15.0f;
beamInfo.m_nStartFrame = 0;
beamInfo.m_flFrameRate = 0.0f;
beamInfo.m_flRed = 206.0f;
beamInfo.m_flGreen = 181.0f;
beamInfo.m_flBlue = 127.0f;
beamInfo.m_nSegments = 8;
beamInfo.m_bRenderable = false;
m_pTeslaBeam2 = beams->CreateBeamPoints( beamInfo );
m_hTeslaSpriteMaterial.Init( "sprites/blueflare1", TEXTURE_GROUP_CLIENT_EFFECTS );
}
//-----------------------------------------------------------------------------
// Purpose: Render a tesla beam in the veiw model.
//
// NOTE: This is a big ugly mess that will get cleaned up when I nail down
// the effect.
//-----------------------------------------------------------------------------
void CWeaponCombatShield::DrawBeams( C_BaseViewModel *pViewModel )
{
// Verify data.
if ( !pViewModel )
return;
// Only humans have the tesla effects
if ( GetTeamNumber() == TEAM_ALIENS )
return;
// Init
if ( !m_pTeslaBeam )
{
InitTeslaBeam();
}
if ( !m_pShieldBeam )
{
InitShieldBeam();
}
if ( !m_pShieldBeam || !m_pTeslaBeam )
return;
// Variables
BeamInfo_t beamInfo;
QAngle vecAngle;
int iAttachment;
// Setup a color reflecting the health
float flShieldHealth = GetShieldHealth();
color32 color;
color.r = 206;
color.g = flShieldHealth * 182;
color.b = flShieldHealth * 127;
color.a = 255;
// Tesla Effect
Vector vecRightTop, vecRightBottom;
Vector vecLeftTop, vecLeftBottom;
iAttachment = pViewModel->LookupAttachment( "LeftBottom" );
pViewModel->GetAttachment( iAttachment, vecLeftBottom, vecAngle );
pViewModel->UncorrectViewModelAttachment( vecLeftBottom );
iAttachment = pViewModel->LookupAttachment( "LeftTip" );
pViewModel->GetAttachment( iAttachment, vecLeftTop, vecAngle );
pViewModel->UncorrectViewModelAttachment( vecLeftTop );
iAttachment = pViewModel->LookupAttachment( "RightBottom" );
pViewModel->GetAttachment( iAttachment, vecRightBottom, vecAngle );
pViewModel->UncorrectViewModelAttachment( vecRightBottom );
iAttachment = pViewModel->LookupAttachment( "RightTip" );
pViewModel->GetAttachment( iAttachment, vecRightTop, vecAngle );
pViewModel->UncorrectViewModelAttachment( vecRightTop );
m_flTeslaLeftInc += weapon_combat_shield_teslaspeed.GetFloat();
m_flTeslaRightInc += weapon_combat_shield_teslaspeed.GetFloat();
if ( m_flTeslaLeftInc > 1.0f ) { m_flTeslaLeftInc = 0.0f; }
if ( m_flTeslaRightInc > 1.0f ) { m_flTeslaRightInc = 0.0f; }
Vector vecLeft = vecLeftTop - vecLeftBottom;
Vector vecRight = vecRightTop - vecRightBottom;
Vector vecStart = vecLeftBottom + ( m_flTeslaLeftInc * vecLeft );
Vector vecEnd = vecRightBottom + ( m_flTeslaRightInc * vecRight );
beamInfo.m_vecStart = vecStart;
beamInfo.m_vecEnd = vecEnd;
beamInfo.m_flRed = color.r;
beamInfo.m_flGreen = color.g;
beamInfo.m_flBlue = color.b;
beams->UpdateBeamInfo( m_pTeslaBeam, beamInfo );
beams->UpdateBeamInfo( m_pTeslaBeam2, beamInfo );
beams->DrawBeam( m_pTeslaBeam );
beams->DrawBeam( m_pTeslaBeam2 );
// Draw a sprite at the tip of the tesla coil.
float flSize = 4.0f;
materials->Bind( m_hShieldSpriteMaterial, this );
DrawSprite( vecStart, flSize, flSize, color );
DrawSprite( vecEnd, flSize, flSize, color );
// Shield Effect
float flPercentage = random->RandomFloat( 0.0f, 1.0f );
if ( flPercentage < weapon_combat_shield_teslaskitter.GetFloat() )
{
char szShieldJoint[16];
int nJoint = random->RandomInt( 1, 8 );
Q_snprintf( szShieldJoint, sizeof( szShieldJoint ), "Shield%d", nJoint );
Vector vecJoint;
int iAttachment = pViewModel->LookupAttachment( &szShieldJoint[0] );
pViewModel->GetAttachment( iAttachment, vecJoint, vecAngle );
pViewModel->UncorrectViewModelAttachment( vecJoint );
if ( nJoint < 5 )
{
beamInfo.m_vecStart = vecLeftTop;
}
else
{
beamInfo.m_vecStart = vecRightTop;
}
beamInfo.m_vecEnd = vecJoint;
beams->UpdateBeamInfo( m_pTeslaBeam, beamInfo );
beams->UpdateBeamInfo( m_pTeslaBeam2, beamInfo );
beams->DrawBeam( m_pTeslaBeam );
beams->DrawBeam( m_pTeslaBeam2 );
float flSize = 7.0f;
color32 color = { 206, 181, 127, 255 };
materials->Bind( m_hShieldSpriteMaterial, this );
DrawSprite( beamInfo.m_vecStart, flSize, flSize, color );
}
#if 0
// Shield Effect
char szShieldJoint[16];
Vector vecShieldJoints[8];
for( int iJoint = 0; iJoint < 8; ++iJoint )
{
Q_snprintf( szShieldJoint, sizeof( szShieldJoint ), "Shield%d", iJoint+1 );
iAttachment = pViewModel->LookupAttachment( &szShieldJoint[0] );
pViewModel->GetAttachment( iAttachment, vecShieldJoints[iJoint], vecAngle );
pViewModel->UncorrectViewModelAttachment( vecShieldJoints[iJoint] );
}
// Shield Internal
if ( m_flShieldInc < 1.0f )
{
Vector vecEdge, vecEnd;
if ( m_bLeftToRight )
{
vecEdge = vecShieldJoints[((m_nShieldEdge+1)%8)] - vecShieldJoints[m_nShieldEdge];
vecEnd = vecShieldJoints[m_nShieldEdge] + ( m_flShieldInc * vecEdge );
}
else
{
vecEdge = vecShieldJoints[m_nShieldEdge] - vecShieldJoints[((m_nShieldEdge+1)%8)];
vecEnd = vecShieldJoints[((m_nShieldEdge+1)%8)] + ( m_flShieldInc * vecEdge );
}
if ( m_nShieldEdge < 5 )
{
beamInfo.m_vecStart = vecLeftTop;
}
else
{
beamInfo.m_vecStart = vecRightTop;
}
beamInfo.m_vecEnd = vecEnd;
beams->UpdateBeamPoints( m_pShieldBeam2, beamInfo );
beams->UpdateBeamPoints( m_pShieldBeam3, beamInfo );
beams->DrawBeam( m_pShieldBeam2 );
beams->DrawBeam( m_pShieldBeam3 );
m_flShieldInc += m_flShieldSpeed;
}
else
{
m_flShieldInc = 0.0f;
m_flShieldSpeed = random->RandomFloat( 0.015f, 0.15f );
m_nShieldEdge = random->RandomInt( 0, 7 );
float flSide = random->RandomFloat( 0.0f, 1.0f );
m_bLeftToRight = ( flSide < 0.5f );
}
// Shield Outline
for( iJoint = 0; iJoint < 8; ++iJoint )
{
beamInfo.m_vecStart = vecShieldJoints[iJoint];
beamInfo.m_vecEnd = vecShieldJoints[(iJoint+1)%8];
beams->UpdateBeamPoints( m_pShieldBeam, beamInfo );
beams->UpdateBeamPoints( m_pShieldBeam2, beamInfo );
beams->DrawBeam( m_pShieldBeam );
beams->DrawBeam( m_pShieldBeam2 );
// Draw a sprite at the tip of the tesla coil.
float flSize = 3.0f;
color32 color = { 255, 255, 0, 255 };
materials->Bind( m_hShieldSpriteMaterial, this );
DrawSprite( vecShieldJoints[iJoint], flSize, flSize, color );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: If the shield has no health, and they're trying to raise it, flash the power level
//-----------------------------------------------------------------------------
void CWeaponCombatShield::HandleInput( void )
{
// If the player's dead, ignore input
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pPlayer || pPlayer->GetHealth() < 0 )
return;
// Attempting to raise the shield?
if ( !GetShieldHealth() && ( gHUD.m_iKeyBits & IN_ATTACK2 ) )
{
m_flFlashTimeEnd = gpGlobals->curtime + 1.0;
}
}
#endif
LINK_ENTITY_TO_CLASS( weapon_combat_shield, CWeaponCombatShield );
LINK_ENTITY_TO_CLASS( weapon_combat_shield_alien, CWeaponCombatShieldAlien );
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatShield , DT_WeaponCombatShield )
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatShieldAlien, DT_WeaponCombatShieldAlien )
#if !defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose: Only send the LocalWeaponData to the player carrying the weapon
//-----------------------------------------------------------------------------
void* SendProxy_SendCombatShieldLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
{
// Get the weapon entity
CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData;
if ( pWeapon )
{
// Only send this chunk of data to the player carrying this weapon
CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() );
if ( pPlayer )
{
pRecipients->SetOnly( pPlayer->GetClientIndex() );
return (void*)pVarData;
}
}
return NULL;
}
REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendCombatShieldLocalWeaponDataTable );
#endif
//-----------------------------------------------------------------------------
// Purpose: Propagation data for weapons. Only sent when a player's holding it.
//-----------------------------------------------------------------------------
BEGIN_NETWORK_TABLE_NOBASE( CWeaponCombatShield, DT_WeaponCombatShieldLocal )
#if !defined( CLIENT_DLL )
SendPropTime( SENDINFO( m_flShieldParryEndTime ) ),
SendPropTime( SENDINFO( m_flShieldParrySwingEndTime ) ),
SendPropTime( SENDINFO( m_flShieldUnavailableEndTime ) ),
SendPropTime( SENDINFO( m_flShieldRaisedTime ) ),
SendPropTime( SENDINFO( m_flShieldLoweredTime ) ),
#else
RecvPropTime( RECVINFO( m_flShieldParryEndTime ) ),
RecvPropTime( RECVINFO( m_flShieldParrySwingEndTime ) ),
RecvPropTime( RECVINFO( m_flShieldUnavailableEndTime ) ),
RecvPropTime( RECVINFO( m_flShieldRaisedTime ) ),
RecvPropTime( RECVINFO( m_flShieldLoweredTime ) ),
#endif
END_NETWORK_TABLE()
BEGIN_NETWORK_TABLE( CWeaponCombatShield , DT_WeaponCombatShield )
#if !defined( CLIENT_DLL )
SendPropDataTable("this", 0, &REFERENCE_SEND_TABLE(DT_WeaponCombatShieldLocal), SendProxy_SendCombatShieldLocalWeaponDataTable ),
SendPropTime( SENDINFO( m_flShieldUpStartTime ) ),
SendPropTime( SENDINFO( m_flShieldDownStartTime ) ),
SendPropInt( SENDINFO( m_iShieldState ), 3, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bAllowPostFrame ), 1, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_bHasShieldParry ), 1, SPROP_UNSIGNED ),
SendPropFloat(SENDINFO( m_flShieldHealth ), 8, SPROP_ROUNDDOWN, 0.0f, 1.0f ),
#else
RecvPropDataTable("this", 0, 0, &REFERENCE_RECV_TABLE(DT_WeaponCombatShieldLocal)),
RecvPropTime( RECVINFO( m_flShieldUpStartTime ) ),
RecvPropTime( RECVINFO( m_flShieldDownStartTime ) ),
RecvPropInt( RECVINFO( m_iShieldState ) ),
RecvPropInt( RECVINFO( m_bAllowPostFrame ) ),
RecvPropInt( RECVINFO( m_bHasShieldParry ) ),
RecvPropFloat(RECVINFO( m_flShieldHealth ) ),
#endif
END_NETWORK_TABLE()
BEGIN_NETWORK_TABLE( CWeaponCombatShieldAlien, DT_WeaponCombatShieldAlien )
END_NETWORK_TABLE()
BEGIN_PREDICTION_DATA( CWeaponCombatShield )
DEFINE_PRED_FIELD( m_iShieldState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bAllowPostFrame, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bHasShieldParry, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flShieldHealth, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD_TOL( m_flShieldUpStartTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flShieldDownStartTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flShieldParryEndTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flShieldParrySwingEndTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flShieldUnavailableEndTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flShieldRaisedTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD_TOL( m_flShieldLoweredTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
END_PREDICTION_DATA()
BEGIN_PREDICTION_DATA( CWeaponCombatShieldAlien )
END_PREDICTION_DATA()
PRECACHE_WEAPON_REGISTER(weapon_combat_shield);
PRECACHE_WEAPON_REGISTER(weapon_combat_shield_alien);