//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//

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

#include "triggers.h"

#define SF_TANK_ACTIVE 0x0001
#define SF_TANK_PLAYER 0x0002
#define SF_TANK_HUMANS 0x0004
#define SF_TANK_ALIENS 0x0008
#define SF_TANK_LINEOFSIGHT 0x0010
#define SF_TANK_CANCONTROL 0x0020
#define SF_TANK_DAMAGE_KICK 0x0040  // Kick when take damage
#define SF_TANK_AIM_AT_POS 0x0080   // Aim at a particular position
#define SF_TANK_AIM_ASSISTANCE 0x0100
#define SF_TANK_NPC 0x0200
#define SF_TANK_NPC_CONTROLLABLE 0x0400    // 1024
#define SF_TANK_NPC_SET_CONTROLLER 0x0800  // 2048
#define SF_TANK_ALLOW_PLAYER_HITS \
    0x1000  // 4096		Allow friendly NPCs to fire upon enemies near the
            // player
#define SF_TANK_IGNORE_RANGE_IN_VIEWCONE \
    0x2000  // 8192		Don't use range as a factor in determining if something is
            // in view cone
#define SF_TANK_NOTSOLID 0x8000  // 32768
#define SF_TANK_SOUNDON \
    0x10000  // FIXME: This is not really a spawnflag! It holds transient
             // state!!!
#define SF_TANK_HACKPLAYERHIT \
    0x20000  // 131072	Make this func_tank cheat and hit the player regularly

#define FUNCTANK_DISTANCE_MAX 1200  // 100 ft.
#define FUNCTANK_DISTANCE_MIN_TO_ENEMY 180
#define FUNCTANK_FIREVOLUME 1000
#define FUNCTANK_NPC_ROUTE_TIME 5.0f

// Effect handling
// If the func_tank has a chosen method of handling effects, use that
// instead of the individual effect settings. (muzzleflash, sound, tracer, etc)
enum FUNCTANK_EFFECT_HANDLING {
    EH_NONE,           // Use the effect settings
    EH_AR2,            // Use AR2 effects
    EH_COMBINE_CANNON  // Large Combine cannon
};

enum TANKBULLET {
    TANK_BULLET_NONE = 0,
    TANK_BULLET_SMALL = 1,
    TANK_BULLET_MEDIUM = 2,
    TANK_BULLET_LARGE = 3,
};

#define MORTAR_BLAST_RADIUS 350

//			Custom damage
//			env_laser (duration is 0.5 rate of fire)
//			rockets
//			explosion?

class CFuncTank : public CBaseEntity {
    DECLARE_CLASS(CFuncTank, CBaseEntity);

   public:
    CFuncTank();
    ~CFuncTank();
    void Spawn(void);
    void Activate(void);
    void Precache(void);
    bool CreateVPhysics(void);
    bool KeyValue(const char *szKeyName, const char *szValue);
    void UpdateOnRemove();

    void SetYawRate(float flYawRate) { m_yawRate = flYawRate; }
    void SetPitchRate(float flPitchRate) { m_pitchRate = flPitchRate; }

    int ObjectCaps(void) {
        return (BaseClass::ObjectCaps() | FCAP_IMPULSE_USE |
                FCAP_USE_IN_RADIUS);
    }

    void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType,
             float value);

    virtual void FuncTankPreThink() { return; }
    void Think(void);
    virtual void FuncTankPostThink() { return; }

    int GetAmmoCount(void) { return m_iAmmoCount; }

    // NPC
    bool NPC_FindManPoint(Vector &vecPos);
    bool NPC_HasEnemy(void);
    void NPC_Fire(void);
    void NPC_InterruptRoute(void);
    void NPC_JustSawPlayer(CBaseEntity *pTarget);
    void NPC_SetInRoute(bool bInRoute) { m_bNPCInRoute = bInRoute; }
    void NPC_SetIdleAngle(Vector vecIdle) { m_vecNPCIdleTarget = vecIdle; }

    // LOS
    bool IsEntityInViewCone(CBaseEntity *pEntity);
    bool HasLOSTo(CBaseEntity *pEntity);

    // Controller
    CBaseCombatCharacter *GetController(void);
    bool StartControl(CBaseCombatCharacter *pController);
    void StopControl(void);
    Vector GetTargetPosition() { return m_vTargetPosition; }
    void SetTargetPosition(const Vector &vecPos) { m_vTargetPosition = vecPos; }

    const float YawCenter() const { return m_yawCenter; }
    const float YawCenterWorld() const { return m_yawCenterWorld; }
    const float YawRange() const { return m_yawRange; }
    const float PitchCenter() const { return m_pitchCenter; }
    const float PitchCenterWorld() const { return m_pitchCenterWorld; }
    const float PitchRange() const { return m_pitchRange; }

    virtual void PhysicsSimulate(void);

    virtual void OnStartControlled() {}
    virtual void OnStopControlled() {}

    // SF Tests.
    inline bool IsControllable(void) {
        return (m_spawnflags & SF_TANK_CANCONTROL) ? true : false;
    }
    inline bool IsActive(void) {
        return (m_spawnflags & SF_TANK_ACTIVE) ? true : false;
    }
    inline bool IsNPCControllable(void) {
        return (m_spawnflags & SF_TANK_NPC_CONTROLLABLE) ? true : false;
    }
    inline bool IsNPCSetController(void) {
        return (m_spawnflags & SF_TANK_NPC_SET_CONTROLLER) ? true : false;
    }

    virtual void DoMuzzleFlash(void);
    virtual const char *GetTracerType(void);

   protected:
    virtual float GetShotSpeed() { return 0; }

    virtual Vector WorldBarrelPosition(void);
    void UpdateMatrix(void);

    float GetNextAttack() const { return m_flNextAttack; }
    virtual void SetNextAttack(float flWait) { m_flNextAttack = flWait; }

    virtual void Fire(int bulletCount, const Vector &barrelEnd,
                      const Vector &forward, CBaseEntity *pAttacker,
                      bool bIgnoreSpread);
    void TankTrace(const Vector &vecStart, const Vector &vecForward,
                   const Vector &vecSpread, trace_t &tr);
    int GetRandomBurst(void);
    float GetRandomFireTime(void);

    void CalcPlayerCrosshairTarget(Vector *pVecTarget);
    void CalcNPCEnemyTarget(Vector *pVecTarget);

    inline bool IsPlayerManned(void) {
        return m_hController && m_hController->IsPlayer() &&
               (m_spawnflags & SF_TANK_PLAYER);
    }
    inline bool IsNPCManned(void) {
        return m_hController && m_hController->MyNPCPointer() &&
               (m_spawnflags & SF_TANK_NPC);
    }

   private:
    void TrackTarget(void);
    int DrawDebugTextOverlays(void);
    void DrawDebugGeometryOverlays(void);

    virtual void FiringSequence(const Vector &barrelEnd, const Vector &forward,
                                CBaseEntity *pAttacker);

    void StartRotSound(void);
    void StopRotSound(void);

    // Input handlers.
    void InputActivate(inputdata_t &inputdata);
    void InputDeactivate(inputdata_t &inputdata);
    void InputSetFireRate(inputdata_t &inputdata);
    void InputSetDamage(inputdata_t &inputdata);
    void InputSetTargetDir(inputdata_t &inputdata);
    void InputSetTargetPosition(inputdata_t &inputdata);
    void InputSetTargetEntityName(inputdata_t &inputdata);

   protected:
    virtual void InputSetTargetEntity(inputdata_t &inputdata);
    virtual void InputClearTargetEntity(inputdata_t &inputdata);

   private:
    void InputFindNPCToManTank(inputdata_t &inputdata);
    void InputStopFindingNPCs(inputdata_t &inputdata);
    void InputStartFindingNPCs(inputdata_t &inputdata);
    void InputForceNPCOff(inputdata_t &inputdata);
    void InputSetMaxRange(inputdata_t &inputdata);

    inline bool CanFire(void);
    bool InRange(float range);
    bool InRange2(float flRange2);

    void TraceAttack(CBaseEntity *pAttacker, float flDamage,
                     const Vector &vecDir, trace_t *ptr, int bitsDamageType);

    QAngle AimBarrelAt(const Vector &parentTarget);

    DECLARE_DATADESC();

    bool OnControls(CBaseEntity *pTest);
    bool HasController(void);

    CBaseEntity *FindTarget(string_t targetName, CBaseEntity *pActivator);

    // NPC
    void NPC_FindController(void);
    bool NPC_InRoute(void) { return m_bNPCInRoute; }
    bool NPC_InterruptController(void);

    // Aim the tank at the player crosshair
    void AimBarrelAtPlayerCrosshair(QAngle *pAngles);

    // Aim the tank at the NPC's enemy
    void AimBarrelAtNPCEnemy(QAngle *pAngles);

    // Aim the tank at the func_tank's enemy
    void AimFuncTankAtTarget(void);

    // Returns true if the desired angles are out of range
    bool RotateTankToAngles(const QAngle &angles, float *pDistX = NULL,
                            float *pDistY = NULL);

    // We lost our target!
    void LostTarget(void);

    // Purpose:
    void ComputeLeadingPosition(const Vector &vecShootPosition,
                                CBaseEntity *pTarget, Vector *pLeadPosition);

   protected:
    virtual void ControllerPostFrame(void);

    virtual void TankActivate(void);
    virtual void TankDeactivate(void);

    float m_fireLast;  // Last time I fired
    float m_fireRate;  // How many rounds/second

    EHANDLE m_hTarget;

    TANKBULLET m_bulletType;      // Bullet type
    int m_iBulletDamage;          // 0 means use Bullet type's default damage
    int m_iBulletDamageVsPlayer;  // Damage vs player. 0 means use
                                  // m_iBulletDamage

#ifdef HL2_EPISODIC
    string_t m_iszAmmoType;  // The name of the ammodef that we use when we
                             // fire. Bullet damage still comes from keyvalues.
    int m_iAmmoType;  // The cached index of the ammodef that we use when we
                      // fire.
#else
    int m_iSmallAmmoType;
    int m_iMediumAmmoType;
    int m_iLargeAmmoType;
#endif  // HL2_EPISODIC

    int m_spread;  // firing spread

    EntityMatrix m_parentMatrix;

    Vector m_sightOrigin;  // Last sight of target
    EHANDLE m_hFuncTankTarget;

    int m_nBulletCount;

   private:
    // This is either the player manning the func_tank, or an NPC. The NPC is
    // either manning the tank, or running to the man point. If he's en-route,
    // m_bNPCInRoute will be true.
    CHandle<CBaseCombatCharacter> m_hController;

    float m_flNextAttack;
    Vector m_vecControllerUsePos;

    float m_yawCenter;       // "Center" yaw
    float m_yawCenterWorld;  // "Center" yaw in world space
    float m_yawRate;         // Max turn rate to track targets
    float m_yawRange;        // Range of turning motion (one-sided: 30 is +/- 30
                       // degress from center) Zero is full rotation
    float m_yawTolerance;  // Tolerance angle

    float m_pitchCenter;       // "Center" pitch
    float m_pitchCenterWorld;  // "Center" pitch in world space
    float m_pitchRate;         // Max turn rate on pitch
    float m_pitchRange;        // Range of pitch motion as above
    float m_pitchTolerance;    // Tolerance angle

    float m_fireTime;  // How much time has been used to fire the weapon so far.
    float m_lastSightTime;  // Last time I saw target
    float m_persist;  // Persistence of firing (how long do I shoot when I can't
                      // see)
    float m_persist2;  // Secondary persistence of firing (randomly shooting
                       // when I can't see)
    float m_persist2burst;  // How long secondary persistence burst lasts
    float m_minRange;       // Minimum range to aim/track
    float m_maxRange;       // Max range to aim/track
    float m_flMinRange2;
    float m_flMaxRange2;
    int m_iAmmoCount;  // ammo

    Vector m_barrelPos;   // Length of the freakin barrel
    float m_spriteScale;  // Scale of any sprites we shoot
    string_t m_iszSpriteSmoke;
    string_t m_iszSpriteFlash;

    string_t m_iszMaster;  // Master entity (game_team_master or multisource)

    string_t m_soundStartRotate;
    string_t m_soundStopRotate;
    string_t m_soundLoopRotate;

    float m_flPlayerGracePeriod;
    float m_flIgnoreGraceUpto;
    float m_flPlayerLockTimeBeforeFire;
    float m_flLastSawNonPlayer;

    string_t m_targetEntityName;
    Vector m_vTargetPosition;
    Vector m_vecNPCIdleTarget;

    // Used for when the gun is attached to another entity
    string_t m_iszBarrelAttachment;
    int m_nBarrelAttachment;
    string_t m_iszBaseAttachment;

    // Used when the gun is actually a part of the parent entity, and pose
    // params aim it
    string_t m_iszYawPoseParam;
    string_t m_iszPitchPoseParam;
    float m_flYawPoseCenter;
    float m_flPitchPoseCenter;
    bool m_bUsePoseParameters;

    // Lead the target?
    bool m_bPerformLeading;
    float m_flStartLeadFactor;
    float m_flStartLeadFactorTime;
    float m_flNextLeadFactor;
    float m_flNextLeadFactorTime;

    COutputEvent m_OnFire;
    COutputEvent m_OnLoseTarget;
    COutputEvent m_OnAquireTarget;
    COutputEvent m_OnAmmoDepleted;
    COutputEvent m_OnGotController;
    COutputEvent m_OnLostController;
    COutputEvent m_OnGotPlayerController;
    COutputEvent m_OnLostPlayerController;
    COutputEvent m_OnReadyToFire;

    CHandle<CBaseTrigger> m_hControlVolume;
    string_t m_iszControlVolume;

    float m_flNextControllerSearch;
    bool m_bShouldFindNPCs;
    bool m_bNPCInRoute;
    string_t m_iszNPCManPoint;

    bool m_bReadyToFire;

    int m_iEffectHandling;
};

#endif  // FUNC_TANK_H