//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Base Object built by a player
//
// $NoKeywords: $
//=============================================================================//

#ifndef TF_OBJ_H
#define TF_OBJ_H
#ifdef _WIN32
#pragma once
#endif

#include "baseentity.h"
#include "tf_func_resource.h"
#include "ihasbuildpoints.h"
#include "baseobject_shared.h"
#include "info_vehicle_bay.h"

class CBaseTFPlayer;
class CTFTeam;
class CRopeKeyframe;
class CBaseTechnology;
class CGrenadeObjectSapper;
class CObjectPowerPack;
class CVGuiScreen;
class CResourceZone;
class KeyValues;
class CObjectBuffStation;
struct animevent_t;

#define OBJECT_REPAIR_RATE		10			// Health healed per second while repairing

// Construction
#define OBJECT_CONSTRUCTION_INTERVAL			0.1
#define OBJECT_CONSTRUCTION_STARTINGHEALTH		0.1


extern ConVar object_verbose;
extern ConVar obj_child_range_factor;

#if defined( _DEBUG )
#define TRACE_OBJECT( str )										\
if ( object_verbose.GetInt() )									\
{																\
	Msg( "%s", str );					\
}																
#else
#define TRACE_OBJECT( string )
#endif


// ------------------------------------------------------------------------ //
// Resupply object that's built by the player
// ------------------------------------------------------------------------ //
class CBaseObject : public CBaseCombatCharacter, public IHasBuildPoints
{
	DECLARE_CLASS( CBaseObject, CBaseCombatCharacter );
public:
	CBaseObject();

	virtual void	UpdateOnRemove( void );

	DECLARE_SERVERCLASS();
	DECLARE_DATADESC();

	virtual bool	IsBaseObject( void ) const { return true; }

	virtual void	BaseObjectThink( void );
	virtual void	LostPowerThink( void );
	virtual CBaseTFPlayer *GetOwner( void );

	// Creation
	virtual void	Precache();
	virtual void	Spawn( void );
	virtual void	Activate( void );
	void			InitializeMapPlacedObject( void );

	virtual void	SetBuilder( CBaseTFPlayer *pBuilder, bool moveobjects = false );
	virtual void	SetupTeamModel( void ) { return; }
	virtual void	SetType( int iObjectType );
	int				ObjectType( ) const;

	virtual int		BloodColor( void ) { return BLOOD_COLOR_MECH; }

	// Building
	virtual float	GetTotalTime( void );
	virtual void	StartPlacement( CBaseTFPlayer *pPlayer );
	void			StopPlacement( void );
	bool			FindNearestBuildPoint( CBaseEntity *pEntity, Vector vecBuildOrigin, float &flNearestPoint, Vector &vecNearestBuildPoint );
	virtual bool	CalculatePlacement( CBaseTFPlayer *pPlayer );
	bool			CheckBuildPoint( Vector vecPoint, Vector &vecTrace, Vector *vecOutPoint=NULL );
	bool			VerifyCorner( const Vector &vBottomCenter, float xOffset, float yOffset );
	virtual bool	CheckBuildOrigin( CBaseTFPlayer *pPlayer, const Vector &vecBuildOrigin, bool bSnappedToPoint = false );
	void			AttemptToFindPower( void );
	void			AttemptToFindBuffStation( void );
	void			AttemptToActivateBuffStation( void );
	virtual float	GetNearbyObjectCheckRadius( void ) { return 30.0; }
	bool			UpdatePlacement( CBaseTFPlayer *pPlayer );
	virtual bool	ShouldAttachToParent( void ) { return true; }
	void			SetVehicleBay( CVGuiScreenVehicleBay *pBay ) { m_hVehicleBay = pBay; }

	// Sort of a hack for walkers - vehicles are pre-rotated by 90 degrees and walkers need to undo this.
	virtual void	AdjustInitialBuildAngles();
	
	// Exit points for mounted vehicles....
	virtual void	GetExitPoint( CBaseEntity *pPlayer, int nBuildPoint, Vector *pExitPoint, QAngle *pAngles );

	// I've finished building the specified object on the specified build point
	virtual int		FindObjectOnBuildPoint( CBaseObject *pObject );

	// This gives an object a chance to prevent itself from being built when the user clicks the 
	// attack button during placement. Barbed wire uses this to change which object the barbed wire 
	// is attached to.
	virtual bool PreStartBuilding();
	
	virtual bool	StartBuilding( CBaseEntity *pPlayer );
	void			BuildingThink( void );
	void			SetControlPanelsActive( bool bState );
	virtual void	FinishedBuilding( void );
	bool			IsBuilding( void ) { return m_bBuilding; };
	bool			IsPlacing( void ) { return m_bPlacing; };
	bool			MustBeBuiltInResourceZone( void ) const;
	bool			MustBeBuiltInConstructionYard( void ) const;
	virtual bool	MustNotBeBuiltInConstructionYard( void ) const;
	bool			MustBeBuiltOnAttachmentPoint( void ) const;

	void			AlignToGround( Vector vecOrigin );

	// Returns information about the various control panels
	virtual void 	GetControlPanelInfo( int nPanelIndex, const char *&pPanelName );
	virtual void	GetControlPanelClassName( int nPanelIndex, const char *&pPanelName );

	// Client commands sent by clicking on various panels....
	// NOTE: pArg->Argv(0) == pCmd, pArg->Argv(1) == the first argument
	virtual bool	ClientCommand( CBaseTFPlayer *pSender, const CCommand &args );

	// Damage
	void			SetHealth( float flHealth );
	virtual void	TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr );
	virtual int		OnTakeDamage( const CTakeDamageInfo &info );
	bool			PassDamageOntoChildren( const CTakeDamageInfo &info, float *flDamageLeftOver );
	virtual float	GetRepairTime( void );
	virtual bool	UpdateRepair( float flRepairTime );
	virtual bool	Repair( float flHealth );

	// Powerups
	virtual bool	CanPowerupEver( int iPowerup );
	virtual bool	CanPowerupNow( int iPowerup );
	virtual void	PowerupStart( int iPowerup, float flAmount, CBaseEntity *pAttacker, CDamageModifier *pDamageModifier );
	virtual	void	PowerupEnd( int iPowerup );

	// Destruction
	virtual bool	ShouldAutoRemove( void );
	virtual void	Killed( void );
	virtual void	DestroyObject( void );		// Silent cleanup
	virtual bool	IsDying( void ) { return m_bDying; }

	// Data
	virtual Class_T	Classify( void );
	virtual int		GetType( void );
	virtual CBaseTFPlayer *GetBuilder( void );
	virtual CBaseTFPlayer *GetOriginalBuilder( void );
	CTFTeam			*GetTFTeam( void ) { return (CTFTeam*)GetTeam(); };
	
	// ID functions
	virtual bool	IsAnUpgrade( void )			{ return false; }
	virtual bool	IsAVehicle( void )			{ return false; }
	virtual bool	IsSentrygun()				{ return false; }
	virtual bool	WantsCoverFromSentryGun()	{ return false; }
	virtual bool	WantsCover()				{ return false; }

	// Inputs
	void			InputSetHealth( inputdata_t &inputdata );
	void			InputAddHealth( inputdata_t &inputdata );
	void			InputRemoveHealth( inputdata_t &inputdata );
	void			InputSetMinDisabledHealth( inputdata_t &inputdata );
	void			InputSetSolidToPlayer( inputdata_t &inputdata );

	// Pickup
	virtual int		ObjectCaps( void );
	virtual void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
	virtual void	PickupObject( void );
	virtual bool	CanBeRemovedBy( CBaseTFPlayer *pPlayer );
	virtual bool	CanBeRotatedBy( CBaseTFPlayer *pPlayer );

	virtual void	ChangeTeam( int iTeamNum ) OVERRIDE;			// Assign this entity to a team.

	virtual void	ChangeBuilder( CBaseTFPlayer *pNewBuilder, bool moveobjects );
	virtual const char *GetWeaponClassnameForObject( void );
	virtual void	AddItemsNeededForObject( CBaseTFPlayer *pNewOwner );

	// Objects that are damaged/disabled can return false here when checked for being available
	virtual bool	ComputeEMPDamageState( void ) { return true; }

	// Handling object inactive
	virtual bool	ShouldBeActive( void );

	// Technology
	virtual void	GainedNewTechnology( CBaseTechnology *pTechnology );

	// Sappers
	bool			HasSapper( void );
	bool			HasSapperFromPlayer( CBaseTFPlayer *pPlayer );
	void			AddSapper( CGrenadeObjectSapper *pSapper );
	void			RemoveSapper( CGrenadeObjectSapper *pSapper );

	// Called when the builder rotates this object...
	virtual void	ObjectMoved( );

	// Minibase stuff
	virtual bool	WasMapPlaced( void );
	virtual CRopeKeyframe *ConnectCableTo( CBaseObject *pObject, int iLocalAttachment, int iTargetAttachment );
	virtual bool	HasCableTo( CBaseObject *pObject );
	virtual int		GetCableAttachment( void );

	// Returns the object flags
	int				GetObjectFlags() const { return m_fObjectFlags; }
	void			SetObjectFlags( int flags ) { m_fObjectFlags = flags; }

	CResourceZone	*GetResourceZone() { return m_hResourceZone.Get(); }
	int				RopeCount() const { return m_aRopes.Count(); }

	// Power handling (Human objects need power to operate)
	bool				IsPowered( void );
	void				SetPowerPack( CObjectPowerPack *pPack );
	CObjectPowerPack	*GetPowerPack( void ) { return m_hPowerPack; };

	void			AttemptToGoActive( void );
	virtual void	OnGoActive( void );
	virtual void	OnGoInactive( void );

	// Buffed objects (objects that connect to a medic's buff station)
	bool			IsHookedAndBuffed( void );
	virtual bool	CanBeHookedToBuffStation( void );
	void			SetBuffStation( CObjectBuffStation *pBuffStation, bool bPlacing );
	CObjectBuffStation *GetBuffStation( void );

	virtual void	BuffStationActivate( void );
	virtual void	BuffStationDeactivate( void );

	// Deterioration
	void			StartDeteriorating( void );
	void			StopDeteriorating( void );
	bool			IsDeteriorating( void ) { return m_bDeteriorating; };
	void			DeterioratingThink( void );

	// Disabling
	void			SetDisabled( bool bDisabled );
	bool			IsDisabled( void ) { return m_bDisabled; }

	// Animation
	virtual void	PlayStartupAnimation( void );

	Activity		GetActivity( ) const;
	void			SetActivity( Activity act );
	void			SetObjectSequence( int sequence );
	
	virtual void	OnActivityChanged( Activity act );

	// Object points
	void			SpawnObjectPoints( void );

	// Derive to customize an object's attached version
	virtual	void	SetupAttachedVersion( void ) { return; }
	virtual void	SetupUnattachedVersion( void ) { return; }

	QAngle			ConvertAbsAnglesToLocal( QAngle vecLocalAngles );

public:
	// VulnerablePoints
	void				CreateVulnerablePoints( void );
	void				AddVulnerablePoint( const char* szHitboxName, float Multiplier );
	float				FindVulnerablePointMultiplier( int nGroup, int nBox ); 		

	// Build points
	CUtlVector<VulnerablePoint_t>	m_VulnerablePoints;

	virtual bool TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr );

public:
	// Client/Server shared build point code
	void				CreateBuildPoints( void );
	void				AddAndParseBuildPoint( int iAttachmentNumber, KeyValues *pkvBuildPoint );
	virtual int			AddBuildPoint( int iAttachmentNum );
	virtual void		AddValidObjectToBuildPoint( int iPoint, int iObjectType );
	virtual CBaseObject *GetBuildPointObject( int iPoint );
	bool				IsBuiltOnAttachment( void ) { return (m_hBuiltOnEntity.Get() != NULL); }
	void				AttachObjectToObject( const CBaseEntity *pEntity, int iPoint, Vector &vecOrigin );
	void				DetachObjectFromObject( void );
	CBaseObject			*GetParentObject( void );
	void				SetBuildPointPassenger( int iPoint, int iPassenger );
	int					GetBuildPointPassenger( int iPoint ) const;

	virtual float		GetSapperAttachTime( void );

// IHasBuildPoints
public:
	virtual int			GetNumBuildPoints( void ) const;
	virtual bool		GetBuildPoint( int iPoint, Vector &vecOrigin, QAngle &vecAngles );
	virtual int			GetBuildPointAttachmentIndex( int iPoint ) const;
	virtual bool		CanBuildObjectOnBuildPoint( int iPoint, int iObjectType );
	virtual void		SetObjectOnBuildPoint( int iPoint, CBaseObject *pObject );
	virtual float		GetMaxSnapDistance( int iBuildPoint );
	virtual bool		ShouldCheckForMovement( void ) { return true; }
	virtual int			GetNumObjectsOnMe( void );
	virtual CBaseEntity	*GetFirstObjectOnMe( void );
	virtual CBaseObject *GetObjectOfTypeOnMe( int iObjectType );
	virtual void		RemoveAllObjects( void );


// IServerNetworkable.
public:

	virtual int		ShouldTransmit( const CCheckTransmitInfo *pInfo );
	virtual void	SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways );


protected:
	// Clean off the object of offensive material, returns true if it found anything
	bool RemoveEnemyAttachments( CBaseEntity *pActivator );
	void RemoveAnalyzer( CBaseEntity *pRemovingEntity );
	void RemoveAllSappers( CBaseEntity *pRemovingEntity );

	void GiveNamedTechnology( CBaseTFPlayer *pRecipient, const char *techname );

	// Show/hide vgui screens.
	bool ShowVGUIScreen( int panelIndex, bool bShow );

private:
	void DetermineAnimation( void );

	// Spawns the various control panels
	void SpawnControlPanels();

	// Purpose: Spawn any objects specified inside the mdl
	void SpawnEntityOnBuildPoint( const char *pEntityName, int iAttachmentNumber );

	// Various commands sent by control panels
	void DismantleCommand( CBaseTFPlayer *pSender );
	void YawCommand( CBaseTFPlayer *pSender, float flYaw );
	void TakeControlCommand( CBaseTFPlayer *pSender );

protected:
	enum OBJSOLIDTYPE
	{
		SOLID_TO_PLAYER_USE_DEFAULT = 0,
		SOLID_TO_PLAYER_YES,
		SOLID_TO_PLAYER_NO,
	};

	bool		IsSolidToPlayers( void ) const;

	// object flags....
	CNetworkVar( int, m_fObjectFlags );
	CNetworkHandle( CBaseTFPlayer,	m_hBuilder );

	// Zone we're in (valid only for objects that sit in zones)
	CNetworkHandle( CResourceZone, m_hResourceZone );

	// Combat Objects
	char	*m_szAmmoName;		// Ammo used by players to build me

	// Cables
	CUtlVector< CHandle<CRopeKeyframe> > m_aRopes;

	// Placement
	Vector			m_vecBuildOrigin;
	Vector			m_vecBuildMins;
	Vector			m_vecBuildMaxs;
	CNetworkHandle( CBaseEntity, m_hBuiltOnEntity );
	int				m_iBuiltOnPoint;

	bool	m_bInvulnerable;
	bool	m_bCantDie;
	float	m_flRepairMultiplier;
	bool	m_bDying;

	// Outputs
	COutputEvent m_OnDestroyed;
	COutputEvent m_OnDamaged;
	COutputEvent m_OnRepaired;

	COutputEvent m_OnBecomingDisabled;
	COutputEvent m_OnBecomingReenabled;

	COutputFloat m_OnObjectHealthChanged;

	// Control panel
	typedef CHandle<CVGuiScreen>	ScreenHandle_t;
	CUtlVector<ScreenHandle_t>	m_hScreens;

private:
	// Make sure we pick up changes to these.
	IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_iHealth );
	IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_takedamage );

	Activity	m_Activity;

	CNetworkVar( int, m_iObjectType );


	// True if players shouldn't do collision avoidance, but should just collide exactly with the object.
	OBJSOLIDTYPE	m_SolidToPlayers;
	void		SetSolidToPlayers( OBJSOLIDTYPE stp, bool force = false );

	// True if this was a map placed object, not a player built one
	bool	m_bWasMapPlaced;

	// Disabled
	CNetworkVar( bool, m_bDisabled );

	// Vehicle bays
	CHandle<CVGuiScreenVehicleBay>	m_hVehicleBay;

	// Building
	CNetworkVar( bool, m_bPlacing );					// True while the object's being placed
	CNetworkVar( bool, m_bBuilding );				// True while the object's still constructing itself
	float	m_flConstructionTimeLeft;	// Current time left in construction
	float	m_flTotalConstructionTime;	// Total construction time (the value of GetTotalTime() at the time construction 
										// started, ie, incase you teleport out of a construction yard)

	CNetworkVar( float, m_flPercentageConstructed );	// Used to send to client
	float	m_flHealth;					// Health during construction. Needed a float due to small increases in health.

	// Repair capping
	float	m_flLastRepairTime;
	float	m_flNextRepairMultiplier;
	float	m_flRepairedSinceLastTime;

	// Sappers on me
	CNetworkVar( bool, m_bHasSapper );
	typedef CHandle<CGrenadeObjectSapper>	SapperHandle;
	CUtlVector< SapperHandle >	m_hSappers;

	// Power handling (Human objects need power to operate)
	CHandle< CObjectPowerPack >	m_hPowerPack;

	// Buff Station
	CHandle< CObjectBuffStation >	m_hBuffStation;
	bool							m_bBuffActivated;

	// Deterioration
	CNetworkVar( bool, m_bDeteriorating );
	float	m_flStartedDeterioratingAt;
	CHandle<CBaseTFPlayer>	m_hOriginalBuilder;

	// Build points
	CUtlVector<BuildPoint_t>	m_BuildPoints;

	// Store the last time I took damage from an enemy. Use this to know whether to drop resources
	// when I die, because I only want to drop resources if I was "destroyed" by an enemy, not if I deteriorated.
	float	m_flLastRealDamage;

	// Amount of resources the player who built me paid for me
	int		m_iAmountPlayerPaidForMe;

	// Attack notification sounds
	string_t	m_iszUnderAttackSound;

	// If non-zero then if health gets below this amount, the object becomes disabled
	float		m_flMinDisableHealth;

	// If not NULL, then when going disabled, swith to this model
	string_t	m_iszDisabledModel;
	string_t	m_iszEnabledModel;
};

inline bool	CBaseObject::CanBeHookedToBuffStation( void )
{ 
	return false; 
}

inline CObjectBuffStation *CBaseObject::GetBuffStation( void )
{
	return m_hBuffStation.Get(); 
}

inline void	CBaseObject::BuffStationActivate( void )
{ 
	m_bBuffActivated = true; 
}

inline void	CBaseObject::BuffStationDeactivate( void )
{ 
	m_bBuffActivated = false; 
}

extern short g_sModelIndexFireball;		// holds the index for the fireball


#endif // TF_OBJ_H