summaryrefslogtreecommitdiffhomepage
path: root/StarsEx/System.h
blob: d56c502890203ad6281873a2494fb924ebaebc5c (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
/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2022, 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
    ========
    Generic ship System class
*/

#ifndef System_h
#define System_h

#include "Types.h"
#include "Physical.h"
#include "Geometry.h"

#include "List.h"
#include "Text.h"

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

class Component;
class Ship;
class SystemDesign;

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

class System
{
    friend Component;

public:
    static const char* TYPENAME() { return "System"; }

    enum CATEGORY    { MISC_SYSTEM=0, DRIVE=1, WEAPON, SHIELD, SENSOR,
        COMPUTER, POWER_SOURCE, FLIGHT_DECK, FARCASTER };
    enum STATUS      { DESTROYED, CRITICAL, DEGRADED, NOMINAL, MAINT };
    enum POWER_FLAGS { POWER_WATTS=1, POWER_CRITICAL=2 };

    System(CATEGORY t, int s, const char* n, int maxv,
    double energy=0, double capacity=100, double sink_rate=1);
    System(const System& s);
    virtual ~System();

    int operator==(const System& s)  const { return this == &s; }

    CATEGORY          Type()         const { return type;    }
    int               Subtype()      const { return subtype; }
    const char*       Name()         const { return name;    }
    const char*       Abbreviation() const { return abrv;    }

    void              SetName(const char* n)           { name = n; }
    void              SetAbbreviation(const char* a)   { abrv = a; }
    void              SetDesign(SystemDesign* d);

    virtual int       Value()        const { return (int) (max_value*availability*100); }
    int               MaxValue()     const { return (int) (max_value*100); }
    STATUS            Status()       const { return       status;        }
    double            Availability() const { return       availability*100;  }
    double            Safety()       const { return       safety*100;        }
    double            Stability()    const { return       stability*100;     }
    virtual void      CalcStatus();
    virtual void      Repair();

    double            NetAvail()     const { return net_avail;        }
    void              SetNetAvail(double d){ net_avail = (float) d;   }

    List<Component>&  GetComponents()      { return components; }

    virtual void      ApplyDamage(double damage);
    virtual void      ExecFrame(double seconds);
    virtual void      ExecMaintFrame(double seconds);
    virtual void      DoEMCON(int emcon);

    // PHYSICAL LOCATION (for inflicting system damage):
    virtual void      Orient(const Physical* rep);
    virtual void      Mount(Point loc, float radius, float hull_factor=0.5f);
    virtual void      Mount(const System& system);

    Point             MountLocation()  const { return mount_loc;   }
    double            Radius()         const { return radius;      }
    double            HullProtection() const { return hull_factor; }

    // POWER UTILIZATION:
    bool              IsPowerCritical() const { return (power_flags & POWER_CRITICAL)?true:false; }
    bool              UsesWatts()       const { return (power_flags & POWER_WATTS)?true:false;    }

    virtual double    GetRequest(double seconds) const;
    virtual void      Distribute(double delivered_energy, double seconds);

    int               GetSourceIndex() const { return source_index; }
    void              SetSourceIndex(int i)  { source_index = i;    }

    virtual int       Charge()    const { return (int) (100 * energy/capacity); }

    bool              IsPowerOn() const { return power_on;  }
    virtual void      PowerOn()         { power_on = true;  }
    virtual void      PowerOff()        { power_on = false; }

    // percentage, but stored as 0-1
    virtual double    GetPowerLevel()  const { return power_level * 100; }
    virtual void      SetPowerLevel(double level);
    virtual void      SetOverride(bool over);

    // for power drain damage:
    virtual void      DrainPower(double to_level);

    void              SetCapacity(double c) { capacity = (float) c; }
    double            GetCapacity()  const { return capacity;  }
    double            GetEnergy()    const { return energy;    }
    double            GetSinkRate()  const { return sink_rate; }
    void              SetEMCONPower(int emcon, int power_level);
    int               GetEMCONPower(int emcon);

    int               GetExplosionType() const { return explosion_type; }
    void              SetExplosionType(int t)  { explosion_type = t;    }

    Ship*             GetShip()      const { return ship;    }
    void              SetShip(Ship* s)     { ship = s;       }
    int               GetID()        const { return id;      }
    void              SetID(int n)         { id = n;         }

protected:
    // AI information:
    CATEGORY          type;
    Ship*             ship;
    int               id;
    int               subtype;
    int               max_value;

    // Displayable name:
    Text              name;
    Text              abrv;

    // System health status:
    STATUS            status;
    float             crit_level;
    float             availability;
    float             safety;
    float             stability;
    float             safety_overload;
    float             net_avail;

    // Mounting:
    Point             mount_loc;  // world space
    Point             mount_rel;  // object space
    float             radius;
    float             hull_factor;

    // Power Sink:
    float             energy;
    float             capacity;
    float             sink_rate;
    float             power_level;
    int               source_index;
    DWORD             power_flags;
    bool              power_on;
    BYTE              emcon_power[3];
    BYTE              emcon;

    int               explosion_type;

    // Subcomponents:
    SystemDesign*     design;
    List<Component>   components;
};

#endif  // System_h