dp88_customAI.h

/*  Renegade Scripts.dll
    Copyright 2013 Tiberian Technologies
 
    This file is part of the Renegade scripts.dll
    The Renegade scripts.dll is free software; you can redistribute it and/or modify it under
    the terms of the GNU General Public License as published by the Free
    Software Foundation; either version 2, or (at your option) any later
    version. See the file COPYING for more details.
    In addition, an exemption is given to allow Run Time Dynamic Linking of this code with any closed source module that does not contain code covered by this licence.
    Only the source code to the module(s) containing the licenced code has to be released.
*/
#pragma once
 
#include "LoopedAnimationController.h"
#include "ObserverImpClass.h"
#include "ReferencerClass.h"
 
class ActionParamsStruct;
 
class Pathfind_Help_Implementer
{
public:
    virtual ~Pathfind_Help_Implementer() {};
    virtual bool Should_Ignore_Blocked_Checking(GameObject *obj) = 0;
    virtual void Prepare_Getting_Around(GameObject *obj) = 0;
    virtual void Stop_Getting_Around(GameObject *obj) = 0;
    virtual void On_Unable_To_Get_Unstuck(GameObject *obj) = 0;
    // Modify action params during getting unstuck to include target shooting, if any exist
    virtual ActionParamsStruct Get_Param_Attack_Modifications(ActionParamsStruct params) = 0;
};
 
// Forward declaration
class VehicleGameObj;
class dp88_AI_Objective;
class dp88_AI_ChargedTurret_AnimationObserver;
 
/*------------------------
Base class for custom AI's
--------------------------*/
 
 
class dp88_customAI : public ScriptImpClass
{
public:
 
  /* -----
  Constructor / Destructor (cleanup debug file if applicable
  ----- */
 
  dp88_customAI() { debugFile = NULL; };
  ~dp88_customAI() { if ( debugFile != NULL ) { fclose(debugFile); } };
 
 
 
 
  /* -----
  Variables
  ----- */
 
  // Priority and weapon choice for each target type
  float priority_infantry;        bool primary_infantry;
  float priority_lightVehicle;    bool primary_lightVehicle;
  float priority_heavyVehicle;    bool primary_heavyVehicle;
  float priority_VTOL;            bool primary_VTOL;
  float priority_building;        bool primary_building;
 
  // Priority modifiers
  float modifier_distance, modifier_target_damage, modifier_target_value;
 
  // Attack ranges
  int primary_minRange, primary_maxRange;
  int secondary_minRange, secondary_maxRange;
 
  // Current target state
  //int targetID;
  ReferencerClass m_target;
  bool hasTarget;
  int targetLastSeen;
  float targetPriority;
  bool m_bTargetPrimaryFire;
 
  // Brain speed
  float thinkTime;
 
  // Other settings
  bool m_bAiEnabled;
  bool m_bCanDetectStealth;
 
  // Debug state
  bool debug;
  FILE* debugFile;
 
  // Target types
  enum TargetType {
      SOLDIER = 0,
      LIGHT_VEHICLE,
      HEAVY_VEHICLE,
      FLYING,
      BUILDING,
      REPAIRABLE,
      UNKNOWN
  };
 
 
 
  /* -----
  Events
  ----- */
 
  virtual void Created( GameObject *obj );
  virtual void Timer_Expired(GameObject *obj, int number);
  virtual void Custom ( GameObject* pObj, int message, int param, GameObject* pSender );
  virtual void Action_Complete( GameObject *obj, int action_id, ActionCompleteReason complete_reason  );
  //virtual void Enemy_Seen ( GameObject *obj, GameObject *enemy );
  //virtual void Timer_Expired( GameObject *obj, int number );
 
 
 
 
  /* ----
  Functions
  ----- */
 
  virtual void Init( GameObject *obj );
  virtual void loadSettings( GameObject *obj, bool loadSecondaryFireSettings, bool loadBuildingTargetSettings );
  
  virtual void AIStateChanged( GameObject* pObj, bool bEnabled );
 
  virtual void ResetAllActions(GameObject* obj);
 
  static float getDistance ( GameObject *obj1, GameObject *obj2 );
  virtual float getBasePriority(GameObject *target );
  virtual float getPriority( GameObject *obj, GameObject *target );
  virtual float getPriority( GameObject *obj, int target_id );
  bool getPrimary ( GameObject *target );
 
  /* Utility functions for both priority calculations and AI scripts to utilise */
  virtual bool IsVehicleEmpty( VehicleGameObj* vobj );
  virtual bool IsVehicleAIEnabled( VehicleGameObj* vobj );
 
  // "Global" decider about what a unit type is
  static TargetType GetTargetType(GameObject* obj);
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_heavyVehicleMarker : public ScriptImpClass
{
    void Created(GameObject* obj);
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_Marker_Building : public ScriptImpClass {};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_Marker_HeavyVehicle : public ScriptImpClass {};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_Marker_Repairable : public ScriptImpClass
{
public:
    void Created(GameObject* obj);
    float Get_Distance_From_Pathfind();
protected:
    float pathfindDistance;
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_Unit : public dp88_customAI
{
public:
  // Game Events
  void Created(GameObject *obj);
  void Detach(GameObject *obj);
  void Timer_Expired(GameObject *obj, int number);
  void Action_Complete(GameObject *obj, int action_id, ActionCompleteReason reason);
 
  // Custom AI initialisation script overloads
  virtual void Init(GameObject *obj);
  virtual void loadSettings(GameObject *obj, bool loadSecondaryFireSettings, bool loadBuildingTargetSettings);
 
  virtual void Force_Clear_Current_Objective();
  dp88_AI_Objective* Get_Current_Objective() { return m_pCurrentObjective; }
 
  // used in combination with Force_Clear_Current_Objective() to invalidate references to objectives when they are deleted (prevents use-after-free bugs)
  static DynamicVectorClass<dp88_AI_Unit*> ListOfAIUnits;
 
protected:
  static const int ACTION_ID_MOVE_TO_OBJECTIVE  = 7850001;
  static const int ACTION_ID_ATTACK_TARGET      = 7850002;
 
  // Action reset handler
  void ResetAllActions(GameObject* obj);
 
  // Go to the location of the current objective
  virtual void GoToObjective(GameObject *obj, float speed = 1.0f);
 
  // Attack the specified target
  virtual void AttackTarget(GameObject *obj, GameObject *target);
 
  virtual bool ShouldPursueTarget(GameObject *obj, GameObject *target);
 
  virtual int GetPreferredAttackRange(GameObject* obj, GameObject *target) = 0;
 
  virtual bool IsValidTarget(GameObject* obj, GameObject *target) = 0;
 
  virtual dp88_AI_Objective* ChooseNewObjective(GameObject* obj) = 0;
 
  // -----------------------------------------------------------------------------------------------
  // Member variables
 
  bool m_bMovingToObjective;
 
  bool m_bMovingToTarget;
 
  // Current objective
  dp88_AI_Objective* m_pCurrentObjective;
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_Tank_Offensive : public dp88_AI_Unit
{
public:
  // Game Events
  void Created(GameObject *obj);
  void Enemy_Seen(GameObject *obj, GameObject *enemy);
 
  // Custom AI initialisation script overloads
  virtual void Init(GameObject *obj);
  virtual void loadSettings(GameObject *obj, bool loadSecondaryFireSettings, bool loadBuildingTargetSettings);
 
protected:
 
  virtual int GetPreferredAttackRange(GameObject* obj, GameObject *target);
 
  virtual bool IsValidTarget(GameObject* obj, GameObject *target);
 
  virtual dp88_AI_Objective* ChooseNewObjective(GameObject* obj);
 
  int m_primary_prefRange, m_secondary_prefRange;
  int retreatDamageAmount;
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_Turret : public dp88_customAI
{
public:
  // Events
  virtual void Enemy_Seen ( GameObject *obj, GameObject *enemy );
  virtual void Timer_Expired( GameObject *obj, int number );
  virtual void Damaged(GameObject *obj, GameObject *damager, float amount);
 
  // Custom AI initialisation script overrides
  virtual void Init( GameObject *obj );
  virtual void loadSettings( GameObject *obj, bool loadSecondaryFireSettings, bool loadBuildingTargetSettings );
 
  // Custom AI event overrides
  virtual void AIStateChanged( GameObject* pObj, bool bEnabled );
 
protected:
  bool requiresPower, splashInfantry;
 
  // These can be overloaded from their default functionality as required, allowing the default
  // enemy seen procedure to be reused even when the behaviour of these checks has been altered
  virtual bool checkTeam ( GameObject* obj, GameObject* target );
  virtual bool checkRange ( GameObject* obj, GameObject* target, bool primary );
  virtual bool checkPowerState( GameObject* obj );
 
 
 
 
  /* These functions are used to initiate and control the AI actions and can be overloaded from
  their defaults if required to provide custom functionality, such as delaying an attack whilst
  waiting for a chargeup / popup animation to occur. */
 
  // These is called when a valid target has been identified and selected as the highest priority
  // target, the turret should begin attacking in this function. Note that this may be called
  // while another attack is already in progress, either normal or splash.
  virtual void attackTarget ( GameObject* obj, GameObject* target, bool primary );
 
  // This is called instead of attackTarget when we are set to splash infantry instead of shooting
  // at them directly. Whilst we are attacking an infantry unit with splash this will be called
  // regularly on a timer to update the location of the target. Note that this may be called
  // while another attack is already in progress, either normal or splash.
  virtual void attackLocation ( GameObject* obj, Vector3 location, bool primary );
 
  // This is called when the target is no longer valid and the turret should stop attacking, this
  // is called to stop both attackTarget and splashLocation attacks.
  virtual void stopAttacking ( GameObject* obj );
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_PopupTurret : public dp88_AI_Turret
{
public:
  // Game events
  virtual void Created ( GameObject* pSelf );
  virtual void Timer_Expired ( GameObject* pSelf, int number );
  virtual void Custom ( GameObject* pSelf, int type, int param, GameObject* pSender );
  virtual void Animation_Complete ( GameObject* pSelf, const char* animation_name );
  virtual void Destroyed( GameObject* pSelf );
 
 
protected:
  static const unsigned char    STATE_UNDEPLOYED  = 0x00;
  static const unsigned char    STATE_DEPLOYING   = 0x01;
  static const unsigned char    STATE_DEPLOYED    = 0x02;
  static const unsigned char    STATE_UNDEPLOYING = 0x03;
 
  unsigned char m_deploymentState;
 
  time_t m_undeployTime;
 
  int m_spotterId;
 
 
  virtual void attackTarget ( GameObject* pSelf, GameObject* pTarget, bool primary );
 
  virtual void attackLocation ( GameObject* pSelf, Vector3 location, bool primary );
 
 
  virtual void Deploy ( GameObject* pSelf );
 
  virtual void Undeploy ( GameObject* pSelf );
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_PopupTurret_Spotter : public ScriptImpClass
{
  void Enemy_Seen ( GameObject* pSelf, GameObject* pEnemy );
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_ChargedTurret : public dp88_AI_Turret
{
public:
  // Game events
  virtual void Timer_Expired ( GameObject* pSelf, int number );
  virtual void Animation_Complete ( GameObject* pSelf, const char* animation_name );
  virtual void Destroyed( GameObject* pSelf );
 
  // Custom AI initialisation script overloads
  virtual void Init( GameObject* pSelf );
  virtual void loadSettings( GameObject* pSelf, bool loadSecondaryFireSettings, bool loadBuildingTargetSettings );
 
 
protected:
  unsigned int m_myObjId; 
 
  bool m_bIsCharging;
 
  bool m_bIsDischarging;
 
  bool m_bIsPreReloading;
 
  int m_chargeAnimObjId;
 
  bool m_bPowerState;
 
  LoopedAnimationController* m_pLoopedAnimCtrl;
  
  dp88_AI_ChargedTurret_AnimationObserver* m_pAnimationObserver;
 
 
  virtual void attackTarget ( GameObject* pSelf, GameObject* pTarget, bool primary );
 
  virtual void attackLocation ( GameObject* pSelf, Vector3 location, bool primary );
 
 
  virtual void StartCharging ( GameObject* pSelf );
 
  virtual void StartDischarging ( GameObject* pSelf );
 
 
  virtual GameObject* GetAnimationObject ( GameObject* pSelf );
 
  virtual void ApplyIdleAnimation ( GameObject* pSelf );
};
 
class dp88_AI_ChargedTurret_AnimationObserver : public ObserverImpClass
{
public:
  dp88_AI_ChargedTurret_AnimationObserver(dp88_AI_ChargedTurret* pParent);
 
  // Game events
  virtual void Animation_Complete(GameObject* pSelf, const char* animation_name);
  
private:
  dp88_AI_ChargedTurret* m_pParent;
};
 
// -------------------------------------------------------------------------------------------------
 
class dp88_AI_Objective : public ScriptImpClass
{
public:
  void Created ( GameObject* obj );
  void Detach ( GameObject* obj );
 
  GameObject* GetGameObject();
 
  unsigned int GetType()    { return m_type; }
  int GetTeam()             { return m_team; }
  int GetRange()            { return m_range; }
  const char* GetDebugTag() { return m_debugTag; }
 
  float GetPriority(GameObject* obj, float distance_modifier);
 
  static dp88_AI_Objective* GetBestObjective ( GameObject* obj, unsigned int objective_type, float distance_modifier, DynamicVectorClass<int> ignoredObjectives );
 
  static int CountObjectives( int team, unsigned int objective_type );
 
  static int CountUnitObjectives( int team, unsigned int objective_type, GameObject* obj, float distance_modifier );
 
  static bool IsValidObjective ( dp88_AI_Objective* pObjective );
 
  const static unsigned int TYPE_OFFENSIVE = 1;
  const static unsigned int TYPE_DEFENSIVE = 2;
  const static unsigned int TYPE_ENGINEERING = 3;
protected:
  const static unsigned char UNITTYPE_SOLDIER = 0;
  const static unsigned char UNITTYPE_LVEHICLE = 1;
  const static unsigned char UNITTYPE_HVEHICLE = 2;
  const static unsigned char UNITTYPE_AIRCRAFT = 3;
  const static unsigned char UNITTYPE_MAX = UNITTYPE_AIRCRAFT;
  const static unsigned char UNITTYPE_UNKNOWN = UCHAR_MAX;
  unsigned char GetUnitType(GameObject* obj);
 
  //int m_objID;;
 
  unsigned int m_type;
  int m_priority[UNITTYPE_MAX + 1];
  int m_range;
  int m_team;
  const char* m_debugTag;
  static DynamicVectorClass<dp88_AI_Objective *> Objectives;
};