tf2/tf2_src/game/server/tf/tf_weapon_builder.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:			The "weapon" used to build objects
//					
//
// $Workfile:     $
// $Date:         $
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_player.h"
#include "entitylist.h"
#include "in_buttons.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "engine/IEngineSound.h"
#include "tf_obj.h"
#include "sendproxy.h"
#include "tf_weapon_builder.h"
#include "vguiscreen.h"
#include "tf_gamerules.h"
#include "tf_obj_teleporter.h"
#include "tf_obj_sapper.h"

extern ISoundEmitterSystemBase *soundemitterbase;

extern ConVar tf2_object_hard_limits;
extern ConVar tf_fastbuild;


EXTERN_SEND_TABLE(DT_BaseCombatWeapon)

BEGIN_NETWORK_TABLE_NOBASE( CTFWeaponBuilder, DT_BuilderLocalData )
	SendPropInt( SENDINFO( m_iObjectType ), BUILDER_OBJECT_BITS, SPROP_UNSIGNED ),
	SendPropEHandle( SENDINFO( m_hObjectBeingBuilt ) ),
	SendPropArray3( SENDINFO_ARRAY3( m_aBuildableObjectTypes ), SendPropBool( SENDINFO_ARRAY( m_aBuildableObjectTypes ) ) ),
END_NETWORK_TABLE()

IMPLEMENT_SERVERCLASS_ST(CTFWeaponBuilder, DT_TFWeaponBuilder)
	SendPropInt( SENDINFO( m_iBuildState ), 4, SPROP_UNSIGNED ),
	SendPropDataTable( "BuilderLocalData", 0, &REFERENCE_SEND_TABLE( DT_BuilderLocalData ), SendProxy_SendLocalWeaponDataTable ),
	SendPropInt( SENDINFO( m_iObjectMode ) , 4, SPROP_UNSIGNED ),
	SendPropFloat( SENDINFO( m_flWheatleyTalkingUntil) ),
END_SEND_TABLE()

LINK_ENTITY_TO_CLASS( tf_weapon_builder, CTFWeaponBuilder );
PRECACHE_WEAPON_REGISTER( tf_weapon_builder );

//

IMPLEMENT_SERVERCLASS_ST( CTFWeaponSapper, DT_TFWeaponSapper )
	SendPropFloat( SENDINFO( m_flChargeBeginTime ) ),
END_SEND_TABLE()

LINK_ENTITY_TO_CLASS( tf_weapon_sapper, CTFWeaponSapper );
PRECACHE_WEAPON_REGISTER( tf_weapon_sapper );


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFWeaponBuilder::CTFWeaponBuilder()
{
	m_iObjectType.Set( BUILDER_INVALID_OBJECT );
	m_iObjectMode = 0;
	m_bAttack3Down = false;

	//Sapper VO Pack stuff
	WheatleyReset( true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFWeaponBuilder::~CTFWeaponBuilder()
{
	StopPlacement();
	if (m_pkvWavList)
	{
		m_pkvWavList->deleteThis();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::SetSubType( int iSubType )
{
	m_iObjectType = iSubType;
	
	// m_iViewModelIndex is set by the base Precache(), which didn't know what
	// type of object we built, so it didn't get the right viewmodel index.
	// Now that our data is filled in, go and get the right index.
	const char *pszViewModel = GetViewModel(0);
	if ( pszViewModel && pszViewModel[0] )
	{
		m_iViewModelIndex = CBaseEntity::PrecacheModel( pszViewModel );
	}

	if ( m_iObjectType == OBJ_ATTACHMENT_SAPPER )
	{
		if ( IsWheatleySapper() )
		{
			if (m_pkvWavList)
			{
				m_pkvWavList->deleteThis();
			}
			m_pkvWavList = new KeyValues("sappervo");
		}
	}

	BaseClass::SetSubType( iSubType );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::Precache( void )
{
	BaseClass::Precache();

	// Precache all the viewmodels we could possibly be building
	for ( int iObj=0; iObj < OBJ_LAST; iObj++ )
	{
		const CObjectInfo *pInfo = GetObjectInfo( iObj );

		if ( pInfo )
		{
			if ( pInfo->m_pViewModel )
			{
				PrecacheModel( pInfo->m_pViewModel );
			}

			if ( pInfo->m_pPlayerModel )
			{
				PrecacheModel( pInfo->m_pPlayerModel );
			}
		}
	}

}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::CanDeploy( void )
{
	CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
	if (!pPlayer)
		return false;

	if ( pPlayer->m_Shared.IsCarryingObject() )
		return BaseClass::CanDeploy();

	if ( pPlayer->CanBuild( m_iObjectType, m_iObjectMode ) != CB_CAN_BUILD )
	{
		return false;
	}

	return BaseClass::CanDeploy();
}

//-----------------------------------------------------------------------------
// 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 );
		}

		pPlayer->PlayWearableAnimsForPlaybackEvent( WAP_START_BUILDING );
	}

	return bDeploy;
}

Activity CTFWeaponBuilder::GetDrawActivity( void )
{
	// sapper used to call different draw animations , one when invis and one when not.
	// now you can go invis *while* deploying, so let's always use the one-handed deploy.
	if ( GetType() == OBJ_ATTACHMENT_SAPPER )
	{
		return ACT_VM_DRAW_DEPLOYED;
	}

	return BaseClass::GetDrawActivity();
}

//-----------------------------------------------------------------------------
// Purpose: Stop placement when holstering
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::Holster( CBaseCombatWeapon *pSwitchingTo )
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
		return false; 

	if ( pOwner->m_Shared.IsCarryingObject() )
		return false;

	if ( m_iObjectType == OBJ_ATTACHMENT_SAPPER )
	{
		if( IsWheatleySapper() )
		{
			pOwner->ClearSappingTracking();
			if ( pOwner->m_Shared.GetState() == TF_STATE_DYING)
			{
				if ( RandomInt( 0, 4) == 0 )
				{
					WheatleyEmitSound( "PSap.DeathLong", true );
				}
				else
				{
					WheatleyEmitSound( "PSap.Death", true );
				}
			}
			else
			{
				float flSoundDuration;
				if ( gpGlobals->curtime - m_flWheatleyLastDeploy < 1.5 && gpGlobals->curtime - m_flWheatleyLastDeploy > -1.0 )
				{
					flSoundDuration = WheatleyEmitSound( "PSap.HolsterFast");
				}
				else
				{
					flSoundDuration = WheatleyEmitSound( "PSap.Holster");
				}
				m_flWheatleyLastHolster = gpGlobals->curtime + flSoundDuration;
			}
		}
	}

	m_flNextVoicePakIdleStartTime = -1.0f;

	if ( m_iBuildState == BS_PLACING || m_iBuildState == BS_PLACING_INVALID )
	{
		SetCurrentState( BS_IDLE );
	}
	StopPlacement();

	pOwner->PlayWearableAnimsForPlaybackEvent( WAP_STOP_BUILDING );

	return BaseClass::Holster(pSwitchingTo);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::ItemPostFrame( void )
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

	// If we're building, and our team has lost, stop placing the object
	if ( m_hObjectBeingBuilt.Get() && 
		TFGameRules()->State_Get() == GR_STATE_TEAM_WIN && 
		pOwner->GetTeamNumber() != TFGameRules()->GetWinningTeam() )
	{
		StopPlacement();
		return;
	}

	// Check that I still have enough resources to build this item
	if ( pOwner->CanBuild( m_iObjectType, m_iObjectMode ) != CB_CAN_BUILD )
	{
		SwitchOwnersWeaponToLast();
	}

	if ( ( pOwner->m_nButtons & IN_ATTACK ) && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) )
	{
		PrimaryAttack();
	}

	if ( pOwner->m_nButtons & IN_ATTACK2 )
	{
		if ( m_flNextSecondaryAttack <= gpGlobals->curtime )
		{
			SecondaryAttack();
		}
	}
	else
	{
		m_bInAttack2 = false;
	}

	// Attrib
	int iMarkForDeathOnPickup = 0;
	if ( pOwner->m_Shared.IsCarryingObject () )
	{
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pOwner, iMarkForDeathOnPickup, mark_for_death_on_building_pickup );
		if ( iMarkForDeathOnPickup )
		{
			pOwner->m_Shared.AddCond( TF_COND_MARKEDFORDEATH_SILENT, 3.f );
		}
	}

	WeaponIdle();
}

//-----------------------------------------------------------------------------
// Purpose: Start placing or building the currently selected object
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::PrimaryAttack( void )
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

	if ( !CanAttack() )
		return;

	// Necessary so that we get the latest building position for the test, otherwise
	// we are one frame behind.
	UpdatePlacementState();

	// What state should we move to?
	switch( m_iBuildState )
	{
	case BS_IDLE:
		{
			// Idle state starts selection
			SetCurrentState( BS_SELECTING );
		}
		break;

	case BS_SELECTING:
		{
			// Do nothing, client handles selection
			return;
		}
		break;

	case BS_PLACING:
		{
			if ( m_hObjectBeingBuilt )
			{
				int iFlags = m_hObjectBeingBuilt->GetObjectFlags();

				// Tricky, because this can re-calc the object position and change whether its a valid 
				// pos or not. Best not to do this only in debug, but we can be pretty sure that this
				// will give the same result as was calculated in UpdatePlacementState() above.
				Assert( IsValidPlacement() );

				// If we're placing an attachment, like a sapper, play a placement animation on the owner
				if ( m_hObjectBeingBuilt->MustBeBuiltOnAttachmentPoint() )
				{
					pOwner->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_GRENADE );
				}

				CBaseEntity *pBuiltOnObject = m_hObjectBeingBuilt->GetBuiltOnObject();
				
				if ( pBuiltOnObject && m_iObjectType == OBJ_ATTACHMENT_SAPPER )
				{
					m_vLastKnownSapPos = pBuiltOnObject->GetAbsOrigin();
					m_hLastSappedBuilding = pBuiltOnObject;
				}
				StartBuilding();

				if ( m_iObjectType == OBJ_ATTACHMENT_SAPPER )
				{
					// tell players a sapper was just placed (so bots can react)
					CUtlVector< CTFPlayer * > playerVector;
					CollectPlayers( &playerVector, TEAM_ANY, COLLECT_ONLY_LIVING_PLAYERS );

					for( int i=0; i<playerVector.Count(); ++i )
						playerVector[i]->OnSapperPlaced( pBuiltOnObject );

					// if we just placed a sapper on a teleporter...try to sap the match, too?
					if ( pBuiltOnObject )
					{
						CObjectTeleporter *pTeleporter = dynamic_cast<CObjectTeleporter*>( pBuiltOnObject );
						if ( pTeleporter && pTeleporter->GetMatchingTeleporter() && !pTeleporter->GetMatchingTeleporter()->HasSapper() )
						{
							// Start placing another
							SetCurrentState( BS_PLACING );
							StartPlacement(); 
	
							if ( m_hObjectBeingBuilt.Get() )
							{
								m_hObjectBeingBuilt->UpdateAttachmentPlacement( pTeleporter->GetMatchingTeleporter() );
								StartBuilding();
							}
						}
					}
				}

				// Should we switch away?
				if ( iFlags & OF_ALLOW_REPEAT_PLACEMENT )
				{
					// Start placing another
					SetCurrentState( BS_PLACING );
					StartPlacement(); 
				}
				else
				{
					SwitchOwnersWeaponToLast();
				}
			}
		}
		break;

	case BS_PLACING_INVALID:
		{
			if ( m_flNextDenySound < gpGlobals->curtime )
			{
				CSingleUserRecipientFilter filter( pOwner );
				EmitSound( filter, entindex(), "Player.DenyWeaponSelection" );

				m_flNextDenySound = gpGlobals->curtime + 0.5;
			}
		}
		break;
	}

	m_flNextPrimaryAttack = gpGlobals->curtime + 0.2f;
}

void CTFWeaponBuilder::SecondaryAttack( void )
{
	if ( m_bInAttack2 )
		return;

	// require a re-press
	m_bInAttack2 = true;

	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

	UpdatePlacementState();

	if ( !pOwner->IsPlayerClass( TF_CLASS_ENGINEER ) && pOwner->DoClassSpecialSkill() )
	{
		// Spies do the special skill first.
	}
	else if ( m_iBuildState == BS_PLACING || m_iBuildState == BS_PLACING_INVALID )
	{
		if ( m_hObjectBeingBuilt )
		{
			pOwner->StopHintTimer( HINT_ALTFIRE_ROTATE_BUILDING );
			m_hObjectBeingBuilt->RotateBuildAngles();
		}
	}
	else if ( pOwner->DoClassSpecialSkill() )
	{
		// Engineers do the special skill last.
	}

	m_flNextSecondaryAttack = gpGlobals->curtime + 0.2f;
}

//-----------------------------------------------------------------------------
// Purpose: Set the builder to the specified state
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::SetCurrentState( int iState )
{
	m_iBuildState = iState;
}

//-----------------------------------------------------------------------------
// Purpose: Set the owner's weapon and last weapon appropriately when we need to
//			switch away from the builder weapon.  
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::SwitchOwnersWeaponToLast()
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

	// for engineer, switch to wrench and set last weapon appropriately
	if ( pOwner->IsPlayerClass( TF_CLASS_ENGINEER ) )
	{
		// Switch to wrench if possible. if not, then best weapon
		CBaseCombatWeapon *pWpn = pOwner->Weapon_GetSlot( 2 );

		// Don't store last weapon when we autoswitch off builder
		CBaseCombatWeapon *pLastWpn = pOwner->GetLastWeapon();

		if ( pWpn )
		{
			pOwner->Weapon_Switch( pWpn );
		}
		else
		{
			pOwner->SwitchToNextBestWeapon( NULL );
		}

		if ( pWpn == pLastWpn )
		{
			// We had the wrench out before we started building. Go ahead and set out last
			// weapon to our primary weapon.
			pWpn = pOwner->Weapon_GetSlot( 0 );
			pOwner->Weapon_SetLast( pWpn );
		}
		else
		{
			pOwner->Weapon_SetLast( pLastWpn );
		}
	}
	else
	{
		// for all other classes, just switch to last weapon used
		pOwner->Weapon_Switch( pOwner->GetLastWeapon() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: updates the building postion and checks the new postion
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::UpdatePlacementState( void )
{
	// This updates the building position
	bool bValidPos = IsValidPlacement();

	// If we're in placement mode, update the placement model
	switch( m_iBuildState )
	{
	case BS_PLACING:
	case BS_PLACING_INVALID:
		{
			if ( bValidPos )
			{
				SetCurrentState( BS_PLACING );
			}
			else
			{
				SetCurrentState( BS_PLACING_INVALID );
			}
		}
		break;

	default:
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Idle updates the position of the build placement model
//-----------------------------------------------------------------------------
/*#define SAPPER_VOPAK_DEFAULT_WAIT 0.0f*/
void CTFWeaponBuilder::WeaponIdle( void )
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

	WheatleySapperIdle( pOwner );

	if ( HasWeaponIdleTimeElapsed() )
	{
		SendWeaponAnim( ACT_VM_IDLE );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Special Item Idle
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::IsWheatleySapper( void )
{
	float flVoicePak = 0.0;
	CALL_ATTRIB_HOOK_FLOAT( flVoicePak, sapper_voice_pak );
	return (flVoicePak == 1.0);
}

//-----------------------------------------------------------------------------
// Purpose: Special Item Reset
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::WheatleyReset( bool bResetIntro )
{
	if ( IsWheatleySapper() )
	{
		WheatleyEmitSound( "PSap.null" );
	}
	if ( bResetIntro )
	{
		m_bWheatleyIntroPlayed = false;
	}
	m_flNextVoicePakIdleStartTime = -1.0f;
	SetWheatleyState( TF_PSAPSTATE_IDLE );
	m_flWheatleyTalkingUntil = 0.00;
	m_flWheatleyLastDamage = 0.00;
	m_iWheatleyVOSequenceOffset = 0;
	m_flWheatleyLastDeploy = 0.00;
	m_flWheatleyLastHolster = 0.00;
}

bool CTFWeaponBuilder::IsWheatleyTalking( void )
{
	return gpGlobals->curtime <= m_flWheatleyTalkingUntil;
}

float CTFWeaponBuilder::WheatleyEmitSound( const char *snd, bool bEmitToAll /*= false*/, bool bNoRepeats /*= false */ )
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	CSoundParameters params;
	if ( !soundemitterbase->GetParametersForSound( snd, params, GENDER_NONE ) )
	{
		return 0.00;
	}
	//Should we check to see if it's already been played?
	if ( bNoRepeats && m_pkvWavList )
	{
		if ( m_pkvWavList->GetInt( params.soundname , 0 ) )
		{
			return 0;
		}
		else
		{
			m_pkvWavList->SetInt( params.soundname , 1);
		}
	}
	//Look for special cases that require us to pick the next lines from a sequential list
	if ( Q_strcmp( params.soundname, "vo/items/wheatley_sapper/wheatley_sapper_idle38.mp3") == NULL )
	{
		SetWheatleyState( TF_PSAPSTATE_SPECIALIDLE_HARMLESS );
		m_iWheatleyVOSequenceOffset = 0;
	}
	else if ( Q_strcmp( params.soundname, "vo/items/wheatley_sapper/wheatley_sapper_idle41.mp3") == NULL )
	{
		SetWheatleyState( TF_PSAPSTATE_SPECIALIDLE_HACK );
		m_iWheatleyVOSequenceOffset = 0;
	}
	else if ( Q_strcmp( params.soundname, "vo/items/wheatley_sapper/wheatley_sapper_idle35.mp3") == NULL )
	{
		SetWheatleyState( TF_PSAPSTATE_SPECIALIDLE_KNIFE );
		m_iWheatleyVOSequenceOffset = 0;
	}
	
	//Play the sound
	// When playing a sound to all players, do it at the last known sapper location
	// This is not played on the object itself (building or sapper) cause it may not exist in the case of death and follow up audio
	// Also having it played on this entity itself prevents multiple VO playing in the case of mass sapping
	if ( bEmitToAll )
	{
		//int entIndex = 0;
		CBroadcastNonOwnerRecipientFilter filter( pOwner );
		EmitSound( filter, entindex(), snd, &m_vLastKnownSapPos );
	}

	// GetSoundDuration is not supported on Linux or for MP3s.  So lets just put in a good number
	//float flSoundDuration = enginesound->GetSoundDuration( params.soundname );
	float flSoundDuration = 3.0f;
	CSingleUserRecipientFilter filter( pOwner );
	EmitSound( filter, entindex(), params );
	m_flWheatleyTalkingUntil = gpGlobals->curtime + flSoundDuration;
	return flSoundDuration;
}

//-----------------------------------------------------------------------------
// Purpose: Set Wheatley Sapper State
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::SetWheatleyState( int iNewState )
{
	m_iSapState = iNewState;
}

int CTFWeaponBuilder::GetWheatleyIdleWait()
{
	return RandomInt( WHEATLEY_IDLE_WAIT_SECS_MIN, WHEATLEY_IDLE_WAIT_SECS_MAX );
}


//-----------------------------------------------------------------------------
// Purpose: Set Wheatley Sapper State
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::WheatleyDamage( void )
{
	if ( (gpGlobals->curtime - m_flWheatleyLastDamage) > 10.0)
	{
		if ( RandomInt(0,2) == 0 )
		{
			CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
			if (pOwner)
			{
				pOwner->ClearSappingEvent();
			}
			SetWheatleyState( TF_PSAPSTATE_IDLE );
			m_flWheatleyLastDamage = gpGlobals->curtime;
			WheatleyEmitSound( "PSap.Damage" );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Special Item Idle
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::WheatleySapperIdle( CTFPlayer *pOwner )
{
	if ( pOwner && m_iObjectType == OBJ_ATTACHMENT_SAPPER && IsWheatleySapper())
	{
		//Is Wheatley coming out of the player's pocket?
		if( m_flNextVoicePakIdleStartTime < 0.0f )
		{			
			pOwner->ClearSappingTracking();
			float flSoundDuration;
			if ( gpGlobals->curtime - m_flWheatleyLastHolster < 2.0 && gpGlobals->curtime - m_flWheatleyLastHolster >= -1.00 )
			{
				flSoundDuration = WheatleyEmitSound( "Psap.DeployAgain" );
			}
			else
			{
				flSoundDuration = WheatleyEmitSound( (m_bWheatleyIntroPlayed) ? "Psap.Deploy" : "Psap.DeployIntro" );
			}
			m_flWheatleyLastDeploy = gpGlobals->curtime + flSoundDuration;
			if ( (!m_bWheatleyIntroPlayed) && (RandomInt(0,2) == 0) )
			{
				SetWheatleyState( TF_PSAPSTATE_INTRO );
				m_bWheatleyIntroPlayed = true;
				m_iWheatleyVOSequenceOffset = 0;
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + flSoundDuration + 3.0;
			}
			else
			{
				m_bWheatleyIntroPlayed = true;
				SetWheatleyState( TF_PSAPSTATE_IDLE );
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + flSoundDuration + GetWheatleyIdleWait();
			}
		}
		//Is there a sapper event? (sapper placed / sapper finished)
		else if( pOwner->GetSappingEvent() != TF_SAPEVENT_NONE)
		{
			char *pVoicePakString = NULL;
			switch ( pOwner->GetSappingEvent() )
			{
			case TF_SAPEVENT_PLACED:
				if (RandomInt(0,1) == 0)
				{
					if ( RandomInt(0,3) == 0 )
					{
						pVoicePakString = "PSap.AttachedPW";
						SetWheatleyState( TF_PSAPSTATE_WAITINGHACK );
					}
					else 
					{
						pVoicePakString = "PSap.Attached";
						SetWheatleyState( TF_PSAPSTATE_WAITINGHACKPW );
					}
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + 0.2;
				}
				else
				{
					pVoicePakString = "PSap.Hacking";
					SetWheatleyState( TF_PSAPSTATE_IDLE );
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
				}
				break;
			case TF_SAPEVENT_DONE:
				if ( IsWheatleyTalking() )
				{
					if ( m_hLastSappedBuilding && m_hLastSappedBuilding.Get() )
					{
						//Building Alive, Sapper died
						pVoicePakString = "PSap.Death";
					}
					else
					{
						pVoicePakString = "PSap.HackedLoud";
					}
					
					if ( RandomInt( 0, 3 ) == 0 )
					{
						SetWheatleyState( TF_PSAPSTATE_WAITINGFOLLOWUP);
						m_flNextVoicePakIdleStartTime = gpGlobals->curtime + 1.3;
					}
					else
					{
						m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
					}
				}
				else
				{
					SetWheatleyState( TF_PSAPSTATE_WAITINGHACKED );
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + 0.5;
				}
				break;
			default:
				break;
			}
			pOwner->ClearSappingEvent();
			if ( pVoicePakString )
			{
				float flSoundDuration = WheatleyEmitSound( pVoicePakString, true );
				m_flNextVoicePakIdleStartTime += flSoundDuration;
			}
		}
		//Are we in the intro sequence?
		else if ( m_iSapState == TF_PSAPSTATE_INTRO && gpGlobals->curtime > m_flNextVoicePakIdleStartTime )
		{
			if ( !IsWheatleyTalking() )
			{
				char szVoicePakString[128];
				szVoicePakString[0] = '\0';
				if ( m_iWheatleyVOSequenceOffset >= 0 && m_iWheatleyVOSequenceOffset <=3 )
				{
					V_sprintf_safe( szVoicePakString, "PSap.IdleIntro0%i", ++m_iWheatleyVOSequenceOffset);
					float flSoundDuration = WheatleyEmitSound( szVoicePakString );
					if ( m_iWheatleyVOSequenceOffset == 4 )
					{
						m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait() + flSoundDuration;
					}
					else
					{
						m_flNextVoicePakIdleStartTime = gpGlobals->curtime + 1.0 + flSoundDuration;
					}
				}
				else
				{
					SetWheatleyState( TF_PSAPSTATE_IDLE );
					m_iWheatleyVOSequenceOffset = 0;
				}
			}
		}
		//Does a generic timed event need to be serviced?
		else if( gpGlobals->curtime > m_flNextVoicePakIdleStartTime )
		{
			bool bNoRepeats = false;
			bool bEmitAll = false;
			char *pVoicePakString = NULL;
			//Sapped! vo
			if ( m_iSapState == TF_PSAPSTATE_WAITINGHACKED )
			{
				bEmitAll = true;
				SetWheatleyState( TF_PSAPSTATE_IDLE );
				if ( IsWheatleyTalking() )
				{
					pVoicePakString = "PSap.HackedLoud";
				}
				else
				{
					pVoicePakString = "PSap.Hacked";
				}
				if ( RandomInt( 0, 3 ) == 0 )
				{
					SetWheatleyState( TF_PSAPSTATE_WAITINGFOLLOWUP);
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + 1.3;
				}
				else
				{
					SetWheatleyState( TF_PSAPSTATE_IDLE );
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
				}
			}
			//Waiting to start the password guessing vo
			else if ( m_iSapState == TF_PSAPSTATE_WAITINGHACKPW )
			{
				bEmitAll = true;
				SetWheatleyState( TF_PSAPSTATE_IDLE );
				pVoicePakString = "PSap.HackingPW";
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
			}
			//Waiting to start regular hacking vo
			else if ( m_iSapState == TF_PSAPSTATE_WAITINGHACK )
			{
				bEmitAll = true;
				SetWheatleyState( TF_PSAPSTATE_IDLE );
				if ( RandomInt( 0, 2 ) == 0 )
				{
					pVoicePakString = "PSap.HackingShort";
				}
				else
				{
					pVoicePakString = "PSap.Hacking";
				}
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
			}
			//Waiting to start successful hack followup vo
			else if ( m_iSapState == TF_PSAPSTATE_WAITINGFOLLOWUP )
			{
				bEmitAll = true;
				SetWheatleyState( TF_PSAPSTATE_IDLE );
				pVoicePakString = "PSap.HackedFollowup";
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
			}
			//If Wheatley's talking, skip & check again later
			else if ( IsWheatleyTalking() )
			{
				pVoicePakString = NULL;
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + 5.0;
			}
			//Are we in the SPECIAL IDLE SEQUENCE "HACK"?
			else if ( m_iSapState == TF_PSAPSTATE_SPECIALIDLE_HACK )
			{
				switch ( m_iWheatleyVOSequenceOffset )
				{
				case 0:
					pVoicePakString = "PSap.IdleHack02";
					m_iWheatleyVOSequenceOffset++;
					break;
				default:
					SetWheatleyState( TF_PSAPSTATE_IDLE );
					m_iWheatleyVOSequenceOffset = 0;
					break;
				}
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
			}
			//Are we in the SPECIAL IDLE SEQUENCE "KNIFE"?
			else if ( m_iSapState == TF_PSAPSTATE_SPECIALIDLE_KNIFE )
			{
				switch ( m_iWheatleyVOSequenceOffset )
				{
				case 0:
					pVoicePakString = "PSap.IdleKnife02";
					m_iWheatleyVOSequenceOffset++;
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + 0.3;
					break;
				case 1:
					pVoicePakString = "PSap.IdleKnife03";
					m_iWheatleyVOSequenceOffset++;
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
					break;
				default:
					SetWheatleyState( TF_PSAPSTATE_IDLE );
					m_iWheatleyVOSequenceOffset = 0;
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
					break;
				}
			}
			//Are we in the SPECIAL IDLE SEQUENCE "HARMLESS"?
			else if ( m_iSapState == TF_PSAPSTATE_SPECIALIDLE_HARMLESS )
			{
				switch ( m_iWheatleyVOSequenceOffset )
				{
				case 0:
					pVoicePakString = "PSap.IdleHarmless02";
					m_iWheatleyVOSequenceOffset++;
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
					break;
				default:
					SetWheatleyState( TF_PSAPSTATE_IDLE );
					m_iWheatleyVOSequenceOffset = 0;
					m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
					break;
				}
			}
			//Is the player stealthed?
			else if ( pOwner->m_Shared.IsStealthed() )
			{
				if ( RandomInt(0,1) == 0 )
				{
					pVoicePakString = "PSap.Sneak";
				}
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
			}
			else if ( m_iSapState == TF_PSAPSTATE_IDLE )
			{
				pVoicePakString = "PSap.Idle";
				bNoRepeats = true;
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
			}
			else
			{
				pVoicePakString = NULL;
			}
			if (!pVoicePakString)
			{
				m_flNextVoicePakIdleStartTime = gpGlobals->curtime + GetWheatleyIdleWait();
				return;
			}
			float flSoundDuration = WheatleyEmitSound( pVoicePakString, bEmitAll, bNoRepeats );
			m_flNextVoicePakIdleStartTime += flSoundDuration;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Start placing the object
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::StartPlacement( void )
{
	StopPlacement();

	CTFPlayer *pTFPlayer = ToTFPlayer( GetOwner() );
	if ( !pTFPlayer )
		return;

	if ( pTFPlayer->m_Shared.IsCarryingObject() )
	{
		m_hObjectBeingBuilt = pTFPlayer->m_Shared.GetCarriedObject();
		m_hObjectBeingBuilt->StopFollowingEntity();
	}
	else
	{
		m_hObjectBeingBuilt = (CBaseObject*)CreateEntityByName( GetObjectInfo( m_iObjectType )->m_pClassName );
	}

	if ( m_hObjectBeingBuilt )
	{
		// Set the builder before Spawn() so attributes can hook correctly
		m_hObjectBeingBuilt->SetBuilder( pTFPlayer );

		bool bIsCarried = m_hObjectBeingBuilt->IsCarried();

		// split this off from the block at the bottom because we need to know what type of building
		// this is before we spawn so things like the teleporters have the correct placement models
		// but we need to set the starting construction health after we've called spawn
		if ( !bIsCarried )
		{
			m_hObjectBeingBuilt->SetObjectMode( m_iObjectMode );
		}

		m_hObjectBeingBuilt->Spawn();
		m_hObjectBeingBuilt->StartPlacement( pTFPlayer );

		if ( !bIsCarried )
		{
			m_hObjectBeingBuilt->m_iHealth = OBJECT_CONSTRUCTION_STARTINGHEALTH;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::StopPlacement( void )
{
	if ( m_hObjectBeingBuilt )
	{
		if ( m_hObjectBeingBuilt->IsCarried() )
		{
			m_hObjectBeingBuilt->MakeCarriedObject( ToTFPlayer( GetOwner() ) );
		}
		else
		{
			m_hObjectBeingBuilt->StopPlacement();
		}
		m_hObjectBeingBuilt = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::WeaponReset( void )
{
	//Check to see if the active weapon is the wheatley sapper, and, if so, reset him
	if ( m_iObjectType == OBJ_ATTACHMENT_SAPPER )
	{
		if ( IsWheatleySapper() )
		{
			CTFPlayer *pPlayer = ToTFPlayer( GetOwner() );
			if ( pPlayer )
			{
				pPlayer->ClearSappingTracking();
			}
			WheatleyReset();
		}
	}

	BaseClass::WeaponReset();

	StopPlacement();
}


//-----------------------------------------------------------------------------
// Purpose: Move the placement model to the current position. Return false if it's an invalid position
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::IsValidPlacement( void )
{
	if ( !m_hObjectBeingBuilt )
		return false;

	CBaseObject *pObj = m_hObjectBeingBuilt.Get();

	pObj->UpdatePlacement();

	return m_hObjectBeingBuilt->IsValidPlacement();
}

//-----------------------------------------------------------------------------
// Purpose: Player holding this weapon has started building something
// Assumes we are in a valid build position
//-----------------------------------------------------------------------------
void CTFWeaponBuilder::StartBuilding( void )
{
	CBaseObject *pObj = m_hObjectBeingBuilt.Get();

	Assert( pObj );

	pObj->StartBuilding( GetOwner() );

	m_hObjectBeingBuilt = NULL;

	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( pOwner )
	{
		pOwner->RemoveInvisibility();
		pOwner->m_Shared.SetCarriedObject( NULL );

		if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
		{
			if ( pObj->ObjectType() == OBJ_ATTACHMENT_SAPPER )
			{
				// Let human players place player-targeted sappers in modes that allow upgrades
				if ( !pOwner->IsBot() && pObj->GetBuiltOnObject() && pObj->GetBuiltOnObject()->IsPlayer() )
				{
					int iRoboSapper = 0;
					CALL_ATTRIB_HOOK_INT_ON_OTHER( pOwner, iRoboSapper, robo_sapper );

					int nMode = iRoboSapper ? MODE_SAPPER_ANTI_ROBOT_RADIUS : MODE_SAPPER_ANTI_ROBOT;
					pObj->SetObjectMode( nMode );

					pOwner->RemoveAmmo( 1, TF_AMMO_GRENADES2 );
					StartEffectBarRegen();
				}
			}
#ifdef STAGING_ONLY
			// Traps use TF_AMMO_GRENADES1
			else if ( pObj->GetType() == OBJ_SPY_TRAP )
			{
				pOwner->RemoveAmmo( 1, TF_AMMO_GRENADES1 );
			}
#endif // STAGING_ONLY
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Return true if this weapon has some ammo
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::HasAmmo( void )
{
	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
	if ( !pOwner )
		return false;

	int iCost = pOwner->m_Shared.CalculateObjectCost( pOwner, m_iObjectType );
	return ( pOwner->GetBuildResources() >= iCost );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFWeaponBuilder::GetSlot( void ) const
{
	return GetObjectInfo( m_iObjectType )->m_SelectionSlot;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFWeaponBuilder::GetPosition( void ) const
{
	return GetObjectInfo( m_iObjectType )->m_SelectionPosition;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : char const
//-----------------------------------------------------------------------------
const char *CTFWeaponBuilder::GetPrintName( void ) const
{
	return GetObjectInfo( m_iObjectType )->m_pStatusName;
}

// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
bool CTFWeaponBuilder::CanBuildObjectType( int iObjectType )
{
	if ( iObjectType < 0 || iObjectType >= OBJ_LAST )
		return false;

	return m_aBuildableObjectTypes.Get( iObjectType );
}

// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
void CTFWeaponBuilder::SetObjectTypeAsBuildable( int iObjectType )
{
	if ( iObjectType < 0 || iObjectType >= OBJ_LAST )
		return;

	m_aBuildableObjectTypes.Set( iObjectType, true );
	SetSubType( iObjectType );
}

// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
Activity CTFWeaponBuilder::TranslateViewmodelHandActivity( Activity actBase )
{
	if ( GetObjectInfo( m_iObjectType )->m_bUseItemInfo )
	{
		return BaseClass::TranslateViewmodelHandActivity( actBase );
	}
	else
	{
		return actBase;
	}
}

// -----------------------------------------------------------------------------
// Purpose:
// -----------------------------------------------------------------------------
const char *CTFWeaponBuilder::GetViewModel( int iViewModel ) const
{
	if ( m_iObjectType != BUILDER_INVALID_OBJECT )
	{
		if ( GetObjectInfo( m_iObjectType )->m_bUseItemInfo )
			return BaseClass::GetViewModel();

		return GetObjectInfo( m_iObjectType )->m_pViewModel;
	}

	return BaseClass::GetViewModel();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CTFWeaponBuilder::GetWorldModel( void ) const	
{
	if ( m_iObjectType != BUILDER_INVALID_OBJECT )
	{
		return GetObjectInfo( m_iObjectType )->m_pPlayerModel;
	}

	return BaseClass::GetWorldModel();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFWeaponBuilder::AllowsAutoSwitchTo( void ) const
{
	// ask the object we're building
	return GetObjectInfo( m_iObjectType )->m_bAutoSwitchTo;
}

// ****************************************************************************
// SAPPER
// ****************************************************************************
CTFWeaponSapper::CTFWeaponSapper()
{
	m_flChargeBeginTime = 0;
	m_bAttackDown = false;
}
//-----------------------------------------------------------------------------
void CTFWeaponSapper::ItemPostFrame( void )
{
#ifdef STAGING_ONLY
	CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
	if ( pPlayer )
	{
		float flSapperDeployTime = 0;
		CALL_ATTRIB_HOOK_FLOAT( flSapperDeployTime, sapper_deploy_time );
		if ( flSapperDeployTime )
		{
			//IsValidPlacement
			if ( !( pPlayer->m_nButtons & IN_ATTACK ) || !IsValidPlacement() )
			{
				m_bAttackDown = false;
				m_flChargeBeginTime = 0;
			}
			else if ( m_bAttackDown == false && ( pPlayer->m_nButtons & IN_ATTACK ) )
			{
				m_bAttackDown = true;
				m_flChargeBeginTime = gpGlobals->curtime;
			}

			if ( ( m_bAttackDown == true && m_flChargeBeginTime + flSapperDeployTime < gpGlobals->curtime ) || !( pPlayer->m_nButtons & IN_ATTACK ) )
			{
				BaseClass::ItemPostFrame();
			}
			return;
		}
	}
#endif // STAGING_ONLY
	BaseClass::ItemPostFrame();
}
//-----------------------------------------------------------------------------
const char *CTFWeaponSapper::GetViewModel( int iViewModel ) const
{
	// Skip over Builder's version
	return CTFWeaponBase::GetViewModel();
}
//-----------------------------------------------------------------------------
const char *CTFWeaponSapper::GetWorldModel( void ) const	
{
	// Skip over Builder's version
	return CTFWeaponBase::GetWorldModel();
}
//-----------------------------------------------------------------------------
Activity CTFWeaponSapper::TranslateViewmodelHandActivity( Activity actBase )
{
	return BaseClass::TranslateViewmodelHandActivity( actBase );

	// Skip over Builder's version
	//return CTFWeaponBase::TranslateViewmodelHandActivity( actBase );
}