summaryrefslogtreecommitdiffhomepage
path: root/Stars45/ShipAI.h
blob: 05f05557441d0ec740134cd354699b806e006018 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/*  Project STARSHATTER
    John DiCamillo
    Copyright © 1997-2002. All Rights Reserved.

    SUBSYSTEM:    Stars.exe
    FILE:         ShipAI.h
    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    Common base class and interface for low-level ship AI
*/

#ifndef ShipAI_h
#define ShipAI_h

#include "Types.h"
#include "SteerAI.h"

// +--------------------------------------------------------------------+

class Ship;
class Shot;
class Instruction;
class TacticalAI;
class Farcaster;

// +--------------------------------------------------------------------+

class ShipAI : public SteerAI
{
public:
   ShipAI(SimObject* s);
   virtual ~ShipAI();

   virtual void      ExecFrame(double seconds);
   virtual int       Subframe()                 const { return true; }

   virtual Ship*     GetShip()                  const { return ship;    }

   virtual Ship*     GetWard()                  const;
   virtual void      SetWard(Ship* s);
   virtual Ship*     GetThreat()                const { return threat;  }
   virtual void      SetThreat(Ship* s);
   virtual Ship*     GetSupport()               const { return support; }
   virtual void      SetSupport(Ship* s);
   virtual Ship*     GetRumor()                 const { return rumor;   }
   virtual void      SetRumor(Ship* s);
   virtual Shot*     GetThreatMissile()         const { return threat_missile; }
   virtual void      SetThreatMissile(Shot* s);
   virtual Instruction* GetNavPoint()           const { return navpt; }
   virtual void      SetNavPoint(Instruction* n)      { navpt = n; }
   virtual Point     GetPatrol()                const;
   virtual void      SetPatrol(const Point& p);
   virtual void      ClearPatrol();
   virtual void      ClearRumor();
   virtual void      ClearTactical();

   virtual Farcaster* GetFarcaster() { return farcaster; }

   // convert the goal point from world to local coords:
   virtual void      FindObjective();

   virtual void      Splash(const Ship* targ);
   virtual void      SetTarget(SimObject* targ, System* sub=0);
   virtual void      DropTarget(double drop_time=1.5);
   virtual double    DropTime()                 const { return drop_time; }
   virtual void      SetBracket(bool bracket);
   virtual void      SetIdentify(bool identify);

   virtual void      SetFormationDelta(const Point& point);

   virtual bool         Update(SimObject* obj);
   virtual const char*  GetObserverName() const;

   virtual int       GetAILevel() const   { return ai_level; }

protected:
   // accumulate behaviors:
   virtual void      Navigator();

   // behaviors:
   virtual bool      AvoidTestSingleObject(SimObject*    obj,
                                           const Point&  bearing,
                                           double        avoid_dist,
                                           double&       avoid_time,
                                           Steer&        steer);

   virtual Steer     AvoidCloseObject(SimObject* obj);
   virtual Steer     AvoidCollision();
   virtual Steer     AvoidTerrain();
   virtual Steer     SeekTarget();
   virtual Steer     EvadeThreat();

   virtual Point     ClosingVelocity();

   // compute the goal point in world coords based on current ai state:
   virtual void      FindObjectiveTarget(SimObject* tgt);
   virtual void      FindObjectiveNavPoint();
   virtual void      FindObjectiveFormation();
   virtual void      FindObjectivePatrol();
   virtual void      FindObjectiveQuantum();
   virtual void      FindObjectiveFarcaster(SimRegion* src, SimRegion* dst);

   // fire on target if appropriate:
   virtual void      AdjustDefenses();
   virtual void      FireControl();
   virtual void      HelmControl();
   virtual void      ThrottleControl();
   virtual void      NavlightControl();

   virtual void      CheckTarget();

   Ship*             ship;
   Ship*             support;
   Ship*             rumor;
   Ship*             threat;
   Shot*             threat_missile;
   Instruction*      navpt;
   Point             obstacle;
   TacticalAI*       tactical;
   Farcaster*        farcaster;
   int               engaged_ship_id;
   int               splash_count;

   Point             formation_delta;
   double            slot_dist;

   double            throttle;
   double            old_throttle;
   double            seconds;
   double            drop_time;
   double            brake;
   DWORD             last_avoid_time;
   DWORD             last_call_time;

   int               element_index;
   int               too_close;
   bool              bracket;
   bool              identify;
   bool              hold;
   bool              takeoff;

   int               patrol;
   Point             patrol_loc;
   int               ai_level;
};

// +--------------------------------------------------------------------+

#endif ShipAI_h