summaryrefslogtreecommitdiffhomepage
path: root/StarsEx/Ship.h
blob: cdf38bd62e614981dfcfae1a7125b728e5ccf5ce (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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2024, Starshatter: The Open Source Project Contributors
    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
    Copyright (c) 1997-2006, Destroyer Studios LLC.

    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    Starship (or space/ground station) class
*/

#ifndef Ship_h
#define Ship_h

#include "Types.h"
#include "SimObject.h"
#include "DetailSet.h"
#include "Director.h"
#include "Geometry.h"
#include "List.h"

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

class Ship;
class Shot;
class Drone;

class Bitmap;
class CombatUnit;
class Computer;
class Contact;
class Drive;
class Element;
class Farcaster;
class FlightComp;
class FlightDeck;
class Hangar;
class InboundSlot;
class Instruction;
class LandingGear;
class MotionController;
class NavLight;
class NavSystem;
class PowerSource;
class QuantumDrive;
class RadioMessage;
class Shield;
class ShieldRep;
class ShipDesign;
class ShipKiller;
class Solid;
class Skin;
class Sound;
class Sensor;
class System;
class Thruster;
class Weapon;
class WeaponDesign;
class WeaponGroup;

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

class Ship : public SimObject,
public SimObserver
{
public:
    static const char* TYPENAME() { return "Ship"; }

    enum CLASSIFICATION {
        DRONE             = 0x0001,
        FIGHTER           = 0x0002,
        ATTACK            = 0x0004,
        LCA               = 0x0008,
        COURIER           = 0x0010,
        CARGO             = 0x0020,
        CORVETTE          = 0x0040,
        FREIGHTER         = 0x0080,
        FRIGATE           = 0x0100,
        DESTROYER         = 0x0200,
        CRUISER           = 0x0400,
        BATTLESHIP        = 0x0800,
        CARRIER           = 0x1000,
        DREADNAUGHT       = 0x2000,

        STATION           = 0x4000,
        FARCASTER         = 0x8000,

        MINE              = 0x00010000,
        COMSAT            = 0x00020000,
        DEFSAT            = 0x00040000,
        SWACS             = 0x00080000,

        BUILDING          = 0x00100000,
        FACTORY           = 0x00200000,
        SAM               = 0x00400000,
        EWR               = 0x00800000,
        C3I               = 0x01000000,
        STARBASE          = 0x02000000,

        DROPSHIPS         = 0x0000000f,
        STARSHIPS         = 0x0000fff0,
        SPACE_UNITS       = 0x000f0000,
        GROUND_UNITS      = 0xfff00000
    };

    enum OP_MODE   { DOCKED, ALERT, LOCKED, LAUNCH, TAKEOFF, ACTIVE, APPROACH, RECOVERY, DOCKING };
    enum FLCS_MODE { FLCS_MANUAL, FLCS_AUTO, FLCS_HELM };
    enum TRAN_TYPE { TRANSITION_NONE,
        TRANSITION_DROP_CAM,
        TRANSITION_DROP_ORBIT,
        TRANSITION_MAKE_ORBIT,
        TRANSITION_TIME_SKIP,
        TRANSITION_DEATH_SPIRAL,
        TRANSITION_DEAD };

    enum FLIGHT_MODEL    { FM_STANDARD, FM_RELAXED, FM_ARCADE };
    enum LANDING_MODEL   { LM_STANDARD, LM_EASIER };

    // CONSTRUCTORS:
    Ship(const char* ship_name, const char* reg_num, ShipDesign* design, int IFF=0, int cmd_ai=0, const int* loadout=0);
    virtual ~Ship();

    int operator == (const Ship& s) const { return id == s.id; }

    static void       Initialize();
    static void       Close();

    virtual void      ExecFrame(double seconds);
    virtual void      AeroFrame(double seconds);
    virtual void      StatFrame(double seconds);
    virtual void      DockFrame(double seconds);
    virtual void      LinearFrame(double seconds);
    virtual void      ExecSensors(double seconds);

    void              ExecNavFrame(double seconds);
    void              ExecPhysics(double seconds);
    void              ExecThrottle(double seconds);
    void              ExecSystems(double seconds);

    virtual void      Activate(Scene& scene);
    virtual void      Deactivate(Scene& scene);
    virtual void      SelectDetail(double seconds);
    virtual void      SetRegion(SimRegion* rgn);
    virtual int       GetTextureList(List<Bitmap>& textures);

    // DIRECTION:
    virtual void      SetControls(MotionController* m);
    virtual void      SetNetworkControl(Director* net_ctrl=0);
    void              SetDirectorInfo(const char* msg) { director_info = msg; }
    const char*       GetDirectorInfo()          const { return director_info; }
    void              SetAIMode(int n)                 { ai_mode = (BYTE) n; }
    int               GetAIMode()                const { return (int) ai_mode; }
    void              SetCommandAILevel(int n)         { command_ai_level = (BYTE) n; }
    int               GetCommandAILevel()        const { return command_ai_level; }
    virtual int       GetFlightPhase()           const { return flight_phase; }
    virtual void      SetFlightPhase(OP_MODE phase);
    bool              IsNetObserver()            const { return net_observer_mode; }
    void              SetNetObserver(bool n)           { net_observer_mode = n;    }

    bool              IsInvulnerable()           const { return invulnerable;      }
    void              SetInvulnerable(bool n)          { invulnerable = n;         }

    double            GetHelmHeading()     const { return helm_heading;  }
    double            GetHelmPitch()       const { return helm_pitch;    }
    void              SetHelmHeading(double h);
    void              SetHelmPitch(double p);
    virtual void      ApplyHelmYaw(double y);
    virtual void      ApplyHelmPitch(double p);
    virtual void      ApplyPitch(double pitch_acc); // override for G limiter

    void              ArcadeStop()               { arcade_velocity *= 0; }

    // CAMERA:
    Point             BridgeLocation()     const { return bridge_vec;       }
    Point             ChaseLocation()      const { return chase_vec;        }
    Point             TransitionLocation() const { return transition_loc;   }

    // FLIGHT DECK:
    Ship*             GetController()    const;
    int               NumInbound()       const;
    int               NumFlightDecks()   const;
    FlightDeck*       GetFlightDeck(int i=0) const;
    Ship*             GetCarrier()       const { return carrier;       }
    FlightDeck*       GetDock()          const { return dock;          }
    void              SetCarrier(Ship* c, FlightDeck* d);
    void              Stow();
    InboundSlot*      GetInbound()      const { return inbound;       }
    void              SetInbound(InboundSlot* s);

    // DRIVE SYSTEMS:
    int               GetFuelLevel()       const; // (0-100) percent of full tank
    void              SetThrottle(double percent);
    void              SetAugmenter(bool  enable);
    double            Thrust(double seconds) const;
    double            VelocityLimit()      const { return vlimit;        }
    Drive*            GetDrive()           const { return main_drive;    }
    double            Throttle()           const { return throttle;      }
    bool              Augmenter()          const { return augmenter;     }
    QuantumDrive*     GetQuantumDrive()    const { return quantum_drive; }
    Farcaster*        GetFarcaster()       const { return farcaster;     }

    bool              IsAirborne()         const;
    bool              IsDropCam()          const { return transition_type == TRANSITION_DROP_CAM;     }
    bool              IsDropping()         const { return transition_type == TRANSITION_DROP_ORBIT;   }
    bool              IsAttaining()        const { return transition_type == TRANSITION_MAKE_ORBIT;   }
    bool              IsSkipping()         const { return transition_type == TRANSITION_TIME_SKIP;    }
    bool              IsDying()            const { return transition_type == TRANSITION_DEATH_SPIRAL; }
    bool              IsDead()             const { return transition_type == TRANSITION_DEAD;         }
    bool              InTransition()       const { return transition_type != TRANSITION_NONE;         }
    void              DropOrbit();
    void              MakeOrbit();
    bool              CanTimeSkip();
    bool              IsInCombat();
    void              TimeSkip();
    void              DropCam(double time=10, double range=0);
    void              DeathSpiral();
    void              CompleteTransition();
    void              SetTransition(double trans_time, int trans_type, const Point& trans_loc);

    double            CompassHeading()     const;
    double            CompassPitch()       const;
    double            AltitudeMSL()        const;
    double            AltitudeAGL()        const;
    double            GForce()             const;

    virtual void      SetupAgility();

    // FLIGHT CONTROL SYSTEM (FLCS):
    void              ExecFLCSFrame();
    void              CycleFLCSMode();
    void              SetFLCSMode(int mode);
    int               GetFLCSMode() const;
    void              SetTransX(double t);
    void              SetTransY(double t);
    void              SetTransZ(double t);

    bool              IsGearDown();
    void              LowerGear();
    void              RaiseGear();
    void              ToggleGear();
    void              ToggleNavlights();

    // WEAPON SYSTEMS:
    virtual void      CheckFriendlyFire();
    virtual void      CheckFire(bool c)          { check_fire = c;               }
    virtual bool      CheckFire()       const    { return (check_fire||net_observer_mode)?true:false; }
    virtual void      SelectWeapon(int n, int w);
    virtual bool      FireWeapon(int n);
    virtual bool      FirePrimary()              { return FireWeapon(primary);   }
    virtual bool      FireSecondary()            { return FireWeapon(secondary); }
    virtual bool      FireDecoy();
    virtual void      CyclePrimary();
    virtual void      CycleSecondary();
    virtual Weapon*   GetPrimary()      const;
    virtual Weapon*   GetSecondary()    const;
    virtual Weapon*   GetWeaponByIndex(int n);
    virtual WeaponGroup* GetPrimaryGroup()      const;
    virtual WeaponGroup* GetSecondaryGroup()    const;
    virtual Weapon*   GetDecoy()        const;
    virtual List<Shot>& GetActiveDecoys();
    virtual void      AddActiveDecoy(Drone* d);
    virtual int*      GetLoadout()               { return loadout; }

    List<Shot>&       GetThreatList();
    void              AddThreat(Shot* s);
    void              DropThreat(Shot* s);

    virtual bool         Update(SimObject* obj);
    virtual const char*  GetObserverName() const { return name; }

    virtual int       GetMissileEta(int index) const;
    virtual void      SetMissileEta(int id, int eta);

    virtual WeaponDesign*   GetPrimaryDesign()      const;
    virtual WeaponDesign*   GetSecondaryDesign()    const;

    virtual void      SetTarget(SimObject* t, System* sub=0, bool from_net=false);
    virtual SimObject* GetTarget()      const    { return target;     }
    virtual System*   GetSubTarget()    const    { return subtarget;  }
    virtual void      CycleSubTarget(int dir=1);
    virtual void      DropTarget();
    virtual void      LockTarget(int  type=SimObject::SIM_SHIP,
    bool closest=false,
    bool hostile=false);
    virtual void      LockTarget(SimObject* candidate);
    virtual bool      IsTracking(SimObject* tgt);
    virtual bool      GetTrigger(int i) const;
    virtual void      SetTrigger(int i);

    Ship*             GetWard()         const    { return ward;          }
    void              SetWard(Ship* s);

    // SHIELD SYSTEMS:
    virtual double    InflictDamage(double damage,
    Shot*  shot        = 0,
    int    hit_type    = 3,
    Point  hull_impact = Point(0,0,0));

    virtual double    InflictSystemDamage(double damage, Shot* shot, Point impact);

    virtual void      InflictNetDamage(double damage, Shot* shot=0);
    virtual void      InflictNetSystemDamage(System* system, double damage, BYTE type);
    virtual void      SetNetSystemStatus(System* system, int status, int power, int reactor, double avail);
    virtual void      SetIntegrity(float n)      { integrity = n;        }

    virtual void      Destroy();
    virtual int       ShieldStrength()  const;
    virtual int       HullStrength()    const;
    virtual int       HitBy(Shot* shot, Point& impact);
    virtual int       CollidesWith(Physical& o);

    // SENSORS AND VISIBILITY:
    virtual int       GetContactID()    const    { return contact_id;    }
    virtual int       GetIFF()          const    { return IFF_code;      }
    virtual void      SetIFF(int iff);
    virtual Color     MarkerColor()     const;
    static  Color     IFFColor(int iff);
    virtual void      DoEMCON();
    virtual double    PCS()             const;
    virtual double    ACS()             const;
    int               NumContacts()     const;   // actual sensor contacts
    List<Contact>&    ContactList();
    virtual int       GetSensorMode()   const;
    virtual void      SetSensorMode(int mode);
    virtual void      LaunchProbe();
    virtual Weapon*   GetProbeLauncher() const   { return probe;         }
    virtual Drone*    GetProbe()        const    { return sensor_drone;  }
    virtual void      SetProbe(Drone* d);
    virtual int       GetEMCON()        const    { return emcon;         }
    virtual void      SetEMCON(int e, bool from_net=false);
    virtual Contact*  FindContact(SimObject* s) const;
    virtual bool      IsHostileTo(const SimObject* o) const;

    // GENERAL ACCESSORS:
    const char*       Registry()        const    { return regnum;        }
    void              SetName(const char* ident) { strcpy_s(name, ident);  }
    const ShipDesign* Design()          const    { return design;        }
    const char*       Abbreviation()    const;
    const char*       DesignName()      const;
    const char*       DesignFileName()  const;
    static const char* ClassName(int c);
    static int        ClassForName(const char* name);
    const char*       ClassName()       const;
    CLASSIFICATION    Class()           const;
    bool              IsGroundUnit()    const;
    bool              IsStarship()      const;
    bool              IsDropship()      const;
    bool              IsStatic()        const;
    bool              IsRogue()         const;
    void              SetRogue(bool r=true);
    int               GetFriendlyFire() const    { return ff_count;      }
    void              SetFriendlyFire(int f);
    void              IncFriendlyFire(int f=1);
    double            Agility()         const    { return agility;       }
    DWORD             MissionClock()    const;
    Graphic*          Cockpit()         const;
    void              ShowCockpit();
    void              HideCockpit();
    int               Value()           const;
    double            AIValue()         const;
    static int        Value(int type);

    const Skin*       GetSkin()         const    { return skin;          }
    void              UseSkin(const Skin* s)     { skin = s;             }
    void              ShowRep();
    void              HideRep();
    void              EnableShadows(bool enable);

    int               RespawnCount()    const    { return respawns;      }
    void              SetRespawnCount(int r)     { respawns = r;         }
    const Point&      RespawnLoc()      const    { return respawn_loc;   }
    void              SetRespawnLoc(const Point& rl)
    { respawn_loc = rl;     }

    double            WarpFactor()      const    { return warp_fov;      }
    void              SetWarp(double w)          { warp_fov = (float) w; }

    void              MatchOrientation(const Ship& s);

    // ORDERS AND NAVIGATION:
    void                    ExecEvalFrame(double seconds);
    void                    SetLaunchPoint(Instruction* pt);
    void                    AddNavPoint(Instruction* pt, Instruction* afterPoint=0);
    void                    DelNavPoint(Instruction* pt);
    void                    ClearFlightPlan();
    Instruction*            GetNextNavPoint();
    int                     GetNavIndex(const Instruction* n);
    double                  RangeToNavPoint(const Instruction* n);
    void                    SetNavptStatus(Instruction* n, int status);
    List<Instruction>&      GetFlightPlan();
    int                     FlightPlanLength();
    CombatUnit*             GetCombatUnit()   const { return combat_unit; }
    Element*                GetElement()      const { return element; }
    Ship*                   GetLeader()       const;
    int                     GetElementIndex() const;
    int                     GetOrigElementIndex() const;
    void                    SetElement(Element* e);

    Instruction*            GetRadioOrders()  const;
    void                    ClearRadioOrders();
    void                    HandleRadioMessage(RadioMessage* msg);
    bool                    IsAutoNavEngaged();
    void                    SetAutoNav(bool engage=true);
    void                    CommandMode();

    void                    ClearTrack();
    void                    UpdateTrack();
    int                     TrackLength()     const { return ntrack;   }
    Point                   TrackPoint(int i) const;

    // DAMAGE CONTROL AND ENGINEERING:
    List<System>&           RepairQueue()        { return repair_queue; }
    double                  RepairSpeed() const;
    int                     RepairTeams() const;
    void                    RepairSystem(System* sys);
    void                    IncreaseRepairPriority(int task_index);
    void                    DecreaseRepairPriority(int task_index);
    void                    ExecMaintFrame(double seconds);
    bool                    AutoRepair()    const { return auto_repair;    }
    void                    EnableRepair(bool e)  { auto_repair = e;       }
    bool                    MasterCaution() const { return master_caution; }
    void                    ClearCaution()       { master_caution = 0; }

    // SYSTEM ACCESSORS:
    List<System>&           Systems()            { return systems;       }
    List<WeaponGroup>&      Weapons()            { return weapons;       }
    List<Drive>&            Drives()             { return drives;        }
    List<Computer>&         Computers()          { return computers;     }
    List<FlightDeck>&       FlightDecks()        { return flight_decks;  }
    List<PowerSource>&      Reactors()           { return reactors;      }
    List<NavLight>&         NavLights()          { return navlights;     }
    Shield*                 GetShield()          { return shield;        }
    Solid*                  GetShieldRep()       { return (Solid*) shieldRep; }
    Sensor*                 GetSensor()          { return sensor;        }
    NavSystem*              GetNavSystem()       { return navsys;        }
    FlightComp*             GetFLCS()            { return flcs;          }
    Thruster*               GetThruster()        { return thruster;      }
    Hangar*                 GetHangar()          { return hangar;        }
    LandingGear*            GetGear()            { return gear;          }

    System*                 GetSystem(int sys_id);

    static int              GetControlModel()       { return control_model; }
    static void             SetControlModel(int n)  { control_model = n;    }
    static int              GetFlightModel()        { return flight_model;  }
    static void             SetFlightModel(int f)   { flight_model = f;     }
    static int              GetLandingModel()       { return landing_model; }
    static void             SetLandingModel(int f)  { landing_model = f;    }
    static double           GetFriendlyFireLevel()  { return friendly_fire_level; }
    static void             SetFriendlyFireLevel(double f)
    { friendly_fire_level = f;    }

protected:
    int               CheckShotIntersection(Shot* shot, Point& ipt, Point& hpt, Weapon** wep=0);
    WeaponGroup*      FindWeaponGroup(const char* name);

    char              regnum[16];
    ShipDesign*       design;
    ShipKiller*       killer;
    DetailSet         detail;
    int               detail_level;
    Sim*              sim;
    double            vlimit;
    double            agility;
    double            throttle;
    double            throttle_request;
    bool              augmenter;
    float             wep_mass;
    float             wep_resist;

    int               IFF_code;
    int               cmd_chain_index;
    int               ff_count;
    OP_MODE           flight_phase;

    SimObject*        target;
    System*           subtarget;
    Ship*             ward;
    int               check_fire;
    int               primary;
    int               secondary;

    const Skin*       skin;
    Solid*            cockpit;
    Drive*            main_drive;
    QuantumDrive*     quantum_drive;
    Farcaster*        farcaster;
    Shield*           shield;
    ShieldRep*        shieldRep;
    NavSystem*        navsys;
    FlightComp*       flcs;
    Sensor*           sensor;
    LandingGear*      gear;
    Thruster*         thruster;
    Weapon*           decoy;
    Weapon*           probe;
    Drone*            sensor_drone;
    Hangar*           hangar;
    List<Shot>        decoy_list;
    List<Shot>        threat_list;

    List<System>      systems;
    List<PowerSource> reactors;
    List<WeaponGroup> weapons;
    List<Drive>       drives;
    List<Computer>    computers;
    List<FlightDeck>  flight_decks;
    List<NavLight>    navlights;
    List<System>      repair_queue;

    CombatUnit*       combat_unit;
    Element*          element;
    int               orig_elem_index;
    Instruction*      radio_orders;
    Instruction*      launch_point;

    Vec3              chase_vec;
    Vec3              bridge_vec;

    const char*       director_info;
    BYTE              ai_mode;
    BYTE              command_ai_level;
    BYTE              flcs_mode;
    bool              net_observer_mode;

    float             pcs;  // passive sensor cross section
    float             acs;  // active  sensor cross section
    BYTE              emcon;
    BYTE              old_emcon;
    bool              invulnerable;

    DWORD             launch_time;
    DWORD             friendly_fire_time;

    Ship*             carrier;
    FlightDeck*       dock;
    InboundSlot*      inbound;

    Director*         net_control;

    Point*            track;
    int               ntrack;
    DWORD             track_time;

    float             helm_heading;
    float             helm_pitch;

    float             altitude_agl;
    float             g_force;

    float             warp_fov;

    float             transition_time;
    int               transition_type;
    Point             transition_loc;
    Point             respawn_loc;
    int               respawns;

    bool              master_caution;
    bool              auto_repair;
    DWORD             last_repair_time;
    DWORD             last_eval_time;
    DWORD             last_beam_time;
    DWORD             last_bolt_time;

    int               missile_id[4];
    BYTE              missile_eta[4];
    bool              trigger[4];
    int*              loadout;

    int               contact_id;

    static int        control_model;
    static int        flight_model;
    static int        landing_model;
    static double     friendly_fire_level;
};

#endif  // Ship_h