//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponBuilder::Deploy( )
{
#if !defined( CLIENT_DLL )
if ( m_hObjectBeingBuilt.Get() && m_hObjectBeingBuilt->IsAnUpgrade() )
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_SLAM_STICKWALL_ND_DRAW, (char*)GetAnimPrefix() );
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() );
#else
return true;
#endif
}
void CHL2MPScriptedWeapon::Precache( void )
{
BaseClass::Precache();
InitScriptedWeapon();
// Get the ammo indexes for the ammo's specified in the data file
if ( GetWpnData().szAmmo1[0] )
{
m_iPrimaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo1 );
if (m_iPrimaryAmmoType == -1)
{
Msg("ERROR: Weapon (%s) using undefined primary ammo type (%s)\n",GetClassname(), GetWpnData().szAmmo1);
}
}
if ( GetWpnData().szAmmo2[0] )
{
m_iSecondaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo2 );
if (m_iSecondaryAmmoType == -1)
{
Msg("ERROR: Weapon (%s) using undefined secondary ammo type (%s)\n",GetClassname(),GetWpnData().szAmmo2);
}
}
// Precache models (preload to avoid hitch)
m_iViewModelIndex = 0;
m_iWorldModelIndex = 0;
if ( GetViewModel() && GetViewModel()[0] )
{
m_iViewModelIndex = CBaseEntity::PrecacheModel( GetViewModel() );
}
if ( GetWorldModel() && GetWorldModel()[0] )
{
m_iWorldModelIndex = CBaseEntity::PrecacheModel( GetWorldModel() );
}
// Precache sounds, too
for ( int i = 0; i < NUM_SHOOT_SOUND_TYPES; ++i )
{
const char *shootsound = GetShootSound( i );
if ( shootsound && shootsound[0] )
{
CBaseEntity::PrecacheScriptSound( shootsound );
}
}
#if defined ( LUA_SDK ) && !defined( CLIENT_DLL )
BEGIN_LUA_CALL_WEAPON_METHOD( "Precache" );
END_LUA_CALL_WEAPON_METHOD( 0, 0 );
#endif
}
/*
================
rvWeaponGauntlet::StartBlade
================
*/
void rvWeaponGauntlet::StartBlade ( void ) {
if ( viewModel ) {
viewModel->GetAnimator()->SetJointAngularVelocity ( bladeJoint, bladeSpinFast, gameLocal.time, bladeAccel );
}
if ( GetWorldModel() ) {
GetWorldModel()->GetAnimator()->SetJointAngularVelocity ( bladeJoint_world, bladeSpinFast, gameLocal.time, bladeAccel );
}
StopSound ( SND_CHANNEL_ITEM, false );
// StartSound ( "snd_blade_fast", SND_CHANNEL_ITEM, 0, false, NULL );
StartSound( "snd_spin_up", SND_CHANNEL_ITEM, 0, false, 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseHL1CombatWeapon::FallInit( void )
{
SetModel( GetWorldModel() );
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
AddSolidFlags( FSOLID_NOT_SOLID );
SetPickupTouch();
SetThink( &CBaseHL1CombatWeapon::FallThink );
SetNextThink( gpGlobals->curtime + 0.1f );
// HACKHACK - On ground isn't always set, so look for ground underneath
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector(0,0,2), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0 )
{
SetGroundEntity( tr.m_pEnt );
}
SetViewOffset( Vector(0,0,8) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBaseHL2MPCombatWeapon::Deploy( void )
{
// If we should be lowered, deploy in the lowered position
// We have to ask the player if the last time it checked, the weapon was lowered
if ( GetOwner() && GetOwner()->IsPlayer() )
{
CHL2MP_Player *pPlayer = assert_cast<CHL2MP_Player*>( GetOwner() );
if ( pPlayer->IsWeaponLowered() )
{
if ( SelectWeightedSequence( ACT_VM_IDLE_LOWERED ) != ACTIVITY_NOT_AVAILABLE )
{
if ( DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_IDLE_LOWERED, (char*)GetAnimPrefix() ) )
{
m_bLowered = true;
// Stomp the next attack time to fix the fact that the lower idles are long
pPlayer->SetNextAttack( gpGlobals->curtime + 1.0 );
m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
m_flNextSecondaryAttack = gpGlobals->curtime + 1.0;
return true;
}
}
}
}
m_bLowered = false;
return BaseClass::Deploy();
}
//-----------------------------------------------------------------------------
// Purpose: Drop/throw the weapon with the given velocity.
//-----------------------------------------------------------------------------
void CASW_Weapon::Drop( const Vector &vecVelocity )
{
StopAnimation();
StopFollowingEntity( );
SetMoveType( MOVETYPE_FLYGRAVITY );
// clear follow stuff, setup for collision
SetGravity(1.0);
m_iState = WEAPON_NOT_CARRIED;
RemoveEffects( EF_NODRAW );
FallInit();
SetGroundEntity( NULL );
SetTouch(NULL);
IPhysicsObject *pObj = VPhysicsGetObject();
if ( pObj != NULL )
{
AngularImpulse angImp( 200, 200, 200 );
pObj->AddVelocity( &vecVelocity, &angImp );
}
else
{
SetAbsVelocity( vecVelocity );
}
SetNextThink( gpGlobals->curtime + 1.0f );
SetOwnerEntity( NULL );
SetOwner( NULL );
SetModel( GetWorldModel() );
}
bool CWeaponFlowerLauncher::Deploy( void )
{
if ( m_iClip1 <= 0 )
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_CROSSBOW_DRAW_UNLOADED, (char*)GetAnimPrefix() );
return BaseClass::Deploy();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::Deploy( void )
{
bool bDeploy = BaseClass::Deploy();
if ( bDeploy )
{
SetCurrentState( BS_PLACING );
StartPlacement();
m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f;
m_flNextSecondaryAttack = gpGlobals->curtime; // asap
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if (!pPlayer)
return false;
pPlayer->SetNextAttack( gpGlobals->curtime );
m_iWorldModelIndex = modelinfo->GetModelIndex( GetWorldModel() );
m_flNextDenySound = 0;
// Set off the hint here, because we don't know until now if our building
// is rotate-able or not.
if ( m_hObjectBeingBuilt && !m_hObjectBeingBuilt->MustBeBuiltOnAttachmentPoint() )
{
// set the alt-fire hint so it gets removed when we holster
m_iAltFireHint = HINT_ALTFIRE_ROTATE_BUILDING;
pPlayer->StartHintTimer( m_iAltFireHint );
}
}
return bDeploy;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
bool CWeaponBrickbat::Deploy( void )
{
SetModel( GetViewModel() );
m_bNeedDraw = false;
m_bNeedThrow = false;
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponGrapple::Deploy( void )
{
if ( m_bMustReload )
{
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_CROSSBOW_DRAW_UNLOADED, (char*)GetAnimPrefix() );
}
return BaseClass::Deploy();
}
/*
================
rvWeaponGauntlet::StopBlade
================
*/
void rvWeaponGauntlet::StopBlade ( void ) {
if ( viewModel ) {
viewModel->GetAnimator()->SetJointAngularVelocity ( bladeJoint, bladeSpinSlow, gameLocal.time, bladeAccel );
}
if ( GetWorldModel() ) {
GetWorldModel()->GetAnimator()->SetJointAngularVelocity ( bladeJoint_world, bladeSpinSlow, gameLocal.time, bladeAccel );
}
StopSound ( SND_CHANNEL_WEAPON, false );
// StartSound ( "snd_blade_slow", SND_CHANNEL_ITEM, 0, false, NULL );
if ( impactEffect ) {
impactEffect->Stop ( );
impactEffect = NULL;
}
impactMaterial = -1;
}
bool CWeapon_SLAM::Deploy( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return false;
}
m_bDetonatorArmed = AnyUndetonatedCharges();
SetModel( GetViewModel() );
m_tSlamState = (int)SLAM_SATCHEL_THROW;
// ------------------------------
// Pick the right draw animation
// ------------------------------
int iActivity;
// If detonator is already armed
m_bNeedReload = false;
if (m_bDetonatorArmed)
{
if (pOwner->GetAmmoCount(m_iSecondaryAmmoType) <= 0)
{
iActivity = ACT_SLAM_DETONATOR_DRAW;
m_bNeedReload = true;
}
else if (CanAttachSLAM())
{
iActivity = ACT_SLAM_DETONATOR_STICKWALL_DRAW;
SetSlamState(SLAM_TRIPMINE_READY);
}
else
{
iActivity = ACT_SLAM_DETONATOR_THROW_DRAW;
SetSlamState(SLAM_SATCHEL_THROW);
}
}
else
{
if (CanAttachSLAM())
{
iActivity = ACT_SLAM_TRIPMINE_DRAW;
SetSlamState(SLAM_TRIPMINE_READY);
}
else
{
iActivity = ACT_SLAM_THROW_ND_DRAW;
SetSlamState(SLAM_SATCHEL_THROW);
}
}
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), iActivity, (char*)GetAnimPrefix() );
}
void CASW_Weapon::Spawn()
{
//InitializeAttributes();
BaseClass::Spawn();
SetModel( GetWorldModel() );
m_nSkin = GetWeaponInfo()->m_iPlayerModelSkin;
}
void CWeaponMolotov::Spawn( void )
{
// Call base class first
BaseClass::Spawn();
m_bNeedDraw = true;
SetModel( GetWorldModel() );
UTIL_SetSize(this, Vector( -6, -6, -2), Vector(6, 6, 2));
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponCrossbow::Deploy( void )
{
if ( m_iClip1 <= 0 )
{
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_CROSSBOW_DRAW_UNLOADED, (char*)GetAnimPrefix() );
}
SetSkin( BOLT_SKIN_GLOW );
return BaseClass::Deploy();
}
bool CWeaponM4A1::Holster(CBaseCombatWeapon *pSwitchingTo)
{
if (m_flDoneSwitchingSilencer > 0.0f && m_flDoneSwitchingSilencer > gpGlobals->curtime)
{
// still switching the silencer. Cancel the switch.
m_bSilencerOn = !m_bSilencerOn;
SetWeaponModelIndex(GetWorldModel());
}
return BaseClass::Holster(pSwitchingTo);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponSnark::Precache( void )
{
BaseClass::Precache();
m_iNestIndex = PrecacheModel( SNARK_NEST_MODEL );
m_iPickedUpIndex = PrecacheModel( GetWorldModel() );
enginesound->PrecacheSound( "squeek/sqk_hunt2.wav" );
enginesound->PrecacheSound( "squeek/sqk_hunt3.wav" );
UTIL_PrecacheOther("monster_snark");
}
/*
================
rvWeaponGauntlet::Spawn
================
*/
void rvWeaponGauntlet::Spawn ( void ) {
SetState ( "Raise", 0 );
bladeJoint = viewModel->GetAnimator()->GetJointHandle ( spawnArgs.GetString ( "joint_blade", "center" ) );
bladeJoint_world= GetWorldModel()->GetAnimator()->GetJointHandle ( spawnArgs.GetString ( "joint_blade", "center" ) );
bladeSpinFast = spawnArgs.GetAngles ( "blade_spinfast" );
bladeSpinSlow = spawnArgs.GetAngles ( "blade_spinslow" );
bladeAccel = SEC2MS ( spawnArgs.GetFloat ( "blade_accel", ".25" ) );
range = spawnArgs.GetFloat ( "range", "100" );
impactMaterial = -1;
impactEffect = NULL;
loopSound = LOOP_NONE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponBugBait::FallInit( void )
{
// Bugbait shouldn't be physics, because it musn't roll/move away from it's spawnpoint.
// The game will break if the player can't pick it up, so it must stay still.
SetModel( GetWorldModel() );
VPhysicsDestroyObject();
SetMoveType( MOVETYPE_FLYGRAVITY );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
SetPickupTouch();
SetThink( &CBaseCombatWeapon::FallThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
//====================================================================================
// FALL TO GROUND
//====================================================================================
//-----------------------------------------------------------------------------
// Purpose: Setup for the fall
//-----------------------------------------------------------------------------
void CBaseCombatWeapon::FallInit( void )
{
SetModel( GetWorldModel() );
VPhysicsDestroyObject();
if ( !VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, false ) )
{
SetMoveType( MOVETYPE_FLYGRAVITY );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
}
else
{
#if !defined( CLIENT_DLL )
// Constrained start?
if ( HasSpawnFlags( SF_WEAPON_START_CONSTRAINED ) )
{
//Constrain the weapon in place
IPhysicsObject *pReferenceObject, *pAttachedObject;
pReferenceObject = g_PhysWorldObject;
pAttachedObject = VPhysicsGetObject();
if ( pReferenceObject && pAttachedObject )
{
constraint_fixedparams_t fixed;
fixed.Defaults();
fixed.InitWithCurrentObjectState( pReferenceObject, pAttachedObject );
fixed.constraint.forceLimit = lbs2kg( 10000 );
fixed.constraint.torqueLimit = lbs2kg( 10000 );
m_pConstraint = physenv->CreateFixedConstraint( pReferenceObject, pAttachedObject, NULL, fixed );
m_pConstraint->SetGameData( (void *) this );
}
}
#endif //CLIENT_DLL
}
SetPickupTouch();
SetThink( &CBaseCombatWeapon::FallThink );
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CWeaponUSP::SecondaryAttack()
{
if ( m_bSilencerOn )
{
SendWeaponAnim( ACT_VM_DETACH_SILENCER );
}
else
{
SendWeaponAnim( ACT_VM_ATTACH_SILENCER );
}
m_bSilencerOn = !m_bSilencerOn;
m_flDoneSwitchingSilencer = gpGlobals->curtime + 3;
m_flNextSecondaryAttack = gpGlobals->curtime + 3;
m_flNextPrimaryAttack = gpGlobals->curtime + 3;
SetWeaponIdleTime( gpGlobals->curtime + 3 );
SetWeaponModelIndex( GetWorldModel() );
}
bool CWeapon_Tripwire::Deploy( void )
{
CBaseCombatCharacter *pOwner = GetOwner();
if (!pOwner)
{
return false;
}
SetModel( GetViewModel() );
// ------------------------------
// Pick the right draw animation
// ------------------------------
int iActivity;
// If detonator is already armed
m_bNeedReload = false;
iActivity = ACT_SLAM_STICKWALL_ND_DRAW;
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), iActivity, (char*)GetAnimPrefix() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool C_TFWeaponBuilder::Deploy( void )
{
bool bDeploy = BaseClass::Deploy();
if ( bDeploy )
{
m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f;
m_flNextSecondaryAttack = gpGlobals->curtime; // asap
CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
if (!pPlayer)
return false;
pPlayer->SetNextAttack( gpGlobals->curtime );
m_iWorldModelIndex = modelinfo->GetModelIndex( GetWorldModel() );
m_iViewModelIndex = modelinfo->GetModelIndex( GetViewModel(0) );
}
return bDeploy;
}
bool CWeapon_Manhack::Deploy( void )
{
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if ( !pOwner )
{
return false;
}
// ------------------------------
// Pick the right draw animation
// ------------------------------
int iActivity;
m_bHasFreeSlot = HasFreeSlot();
bool bNoDrivable = true;
CPropVehicleManhack *pManhack = CPropVehicleManhack::GetManhackVehicle();
if (pManhack) //m_hManhack)
{
// = dynamic_cast<CPropVehicleManhack*>((CBaseEntity*)m_hManhack);
if (pManhack->HasDrivableManhack(pOwner))
{
bNoDrivable = false;
}
}
if ( m_bHasAmmo && m_bHasFreeSlot && (!m_bIsDoingController || bNoDrivable))
{
iActivity = ACT_VM_DRAW;
//EnableManhackSubModel(true);
CBasePlayer *pPlayer = ToBasePlayer( pOwner );
if ( pPlayer != NULL)
m_bIsDoingController = false;
m_bSpawnSomeMore = true; //TERO: not sure about this
}
else
{
m_bIsDoingController = true;
m_bSpawnSomeMore = false;
iActivity = ACT_SLAM_DETONATOR_DRAW;
}
m_bIsDrawing=true;
m_bShouldShowPanel = true;
//TERO: this next bit is to make sure the player gets the right hint message if the controllable state has changed
if (GlobalEntity_GetState("manhacks_not_controllable") == GLOBAL_ON )
{
if (m_bHadControllable)
{
m_iManhackHintTimeShown=0;
CBasePlayer *pPlayer = ToBasePlayer( pOwner );
if ( pPlayer != NULL && (CPropVehicleManhack::GetManhackVehicle() != NULL) )
{
UTIL_HudHintText( pPlayer, "#HLSS_Hint_ManhackSend" );
m_iManhackHintTimeShown++;
}
}
m_bHadControllable = false;
}
else
{
if (!m_bHadControllable)
{
m_iManhackHintTimeShown=0;
CBasePlayer *pPlayer = ToBasePlayer( pOwner );
if ( pPlayer != NULL && (CPropVehicleManhack::GetManhackVehicle() != NULL) )
{
UTIL_HudHintText( pPlayer, "#HLSS_Hint_ManhackControl" );
m_iManhackHintTimeShown++;
}
}
m_bHadControllable = true;
}
if (!m_hScreen)
{
/*CBaseViewModel *vm = pOwner->GetViewModel( m_nViewModelIndex );
if (vm)
{
//vm->SpawnControlPanels();
int nLLAttachmentIndex = vm->LookupAttachment("controlpanel0_ll");
int nURAttachmentIndex = vm->LookupAttachment("controlpanel0_ur");
matrix3x4_t panelToWorld;
vm->GetAttachment( nLLAttachmentIndex, panelToWorld );
matrix3x4_t worldToPanel;
MatrixInvert( panelToWorld, worldToPanel );
// Now get the lower right position + transform into panel space
Vector lr, lrlocal;
vm->GetAttachment( nURAttachmentIndex, panelToWorld );
MatrixGetColumn( panelToWorld, 3, lr );
VectorTransform( lr, worldToPanel, lrlocal );
float flWidth = lrlocal.x;
float flHeight = lrlocal.y;
CVGuiScreen *pScreen = CreateVGuiScreen( "vgui_screen", "manhack_screen", this, this, 0 );
pScreen->ChangeTeam( 69 );
pScreen->SetActualSize( 128, 64 );
pScreen->SetActive( true );
pScreen->MakeVisibleOnlyToTeammates( true );
pScreen->SetAttachedToViewModel(true);
m_hScreen.Set( pScreen );
}*/
CVGuiScreen *pScreen = CreateVGuiScreen( "vgui_screen", "manhack_screen", this, this, 0 );
//pScreen->SetActualSize( 128, 64 );
pScreen->SetActive( true );
pScreen->MakeVisibleOnlyToTeammates( true );
pScreen->SetAttachedToViewModel(true);
m_hScreen.Set( pScreen );
}
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), iActivity, (char*)GetAnimPrefix() );
}
bool CWeaponMine::Deploy( void )
{
m_bNeedReload = false;
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_SLAM_TRIPMINE_DRAW, (char*)GetAnimPrefix() );
}
bool CDODBaseRocketWeapon::Deploy( )
{
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), GetDrawActivity(), (char*)GetAnimPrefix() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CWeaponMortar::Deploy( )
{
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_SLAM_TRIPMINE_DRAW, (char*)GetAnimPrefix() );
}
