summaryrefslogtreecommitdiffhomepage
path: root/Stars45/Component.h
blob: 55763c3bd6334d34c264fb59b3b58a4026babf71 (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
/*  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 sub-component class
*/

#ifndef Component_h
#define Component_h

#include "Types.h"
#include "Geometry.h"
#include "Text.h"

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

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

    ComponentDesign();
    ~ComponentDesign();
    int operator == (const ComponentDesign& rhs) const { return (name == rhs.name); }

    // identification:
    Text              name;
    Text              abrv;

    float             repair_time;
    float             replace_time;
    int               spares;
    DWORD             affects;
};

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

class System;

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

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

    enum STATUS    { DESTROYED, CRITICAL, DEGRADED, NOMINAL, REPLACE, REPAIR };
    enum DAMAGE    { DAMAGE_EFFICIENCY = 0x01,
        DAMAGE_SAFETY     = 0x02,
        DAMAGE_STABILITY  = 0x04 };

    Component(ComponentDesign* d, System* s);
    Component(const Component& c);
    virtual ~Component();

    const char*       Name()         const { return design->name;           }
    const char*       Abbreviation() const { return design->abrv;           }
    float             RepairTime()   const { return design->repair_time;    }
    float             ReplaceTime()  const { return design->replace_time;   }

    bool              DamageEfficiency() const { return (design->affects & DAMAGE_EFFICIENCY)?true:false; }
    bool              DamageSafety()     const { return (design->affects & DAMAGE_SAFETY)?true:false;     }
    bool              DamageStability()  const { return (design->affects & DAMAGE_STABILITY)?true:false;  }

    STATUS            Status()       const { return status;                 }
    float             Availability() const;
    float             TimeRemaining() const;
    int               SpareCount()   const;
    bool              IsJerried()    const;
    int               NumJerried()   const;

    void              SetSystem(System* s) { system = s;                    }
    System*           GetSystem()    const { return system;                 }

    virtual void      ApplyDamage(double damage);
    virtual void      ExecMaintFrame(double seconds);
    virtual void      Repair();
    virtual void      Replace();

protected:
    ComponentDesign*  design;

    // Component health status:
    STATUS            status;
    float             availability;
    float             time_remaining;
    int               spares;
    int               jerried;
    System*           system;
};

#endif  // Component_h