summaryrefslogtreecommitdiffhomepage
path: root/Stars45/MissionEvent.h
blob: 5fe4f105c316042072739ff2685219fd836a8dc8 (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
/*  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
    ========
    Events for mission scripting
*/

#ifndef MissionEvent_h
#define MissionEvent_h

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

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

class Mission;
class MissionElement;
class MissionLoad;
class MissionEvent;

class Ship;
class System;
class Element;
class ShipDesign;
class WeaponDesign;
class StarSystem;
class Instruction;
class Sound;

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

class MissionEvent
{
    friend class Mission;
    friend class MissionTemplate;
    friend class MsnEditDlg;
    friend class MsnEventDlg;

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

    enum EVENT_TYPE {
        MESSAGE,
        OBJECTIVE,
        INSTRUCTION,
        IFF,
        DAMAGE,
        JUMP,
        HOLD,
        SKIP,
        END_MISSION,

        BEGIN_SCENE,
        CAMERA,
        VOLUME,
        DISPLAY,
        FIRE_WEAPON,
        END_SCENE,

        NUM_EVENTS
    };

    enum EVENT_STATUS {
        PENDING, ACTIVE, COMPLETE, SKIPPED
    };

    enum EVENT_TRIGGER {
        TRIGGER_TIME,        TRIGGER_DAMAGE,      TRIGGER_DESTROYED,
        TRIGGER_JUMP,        TRIGGER_LAUNCH,      TRIGGER_DOCK,
        TRIGGER_NAVPT,       TRIGGER_EVENT,       TRIGGER_SKIPPED,
        TRIGGER_TARGET,      TRIGGER_SHIPS_LEFT,  TRIGGER_DETECT,
        TRIGGER_RANGE,       TRIGGER_EVENT_ALL,   TRIGGER_EVENT_ANY,
        NUM_TRIGGERS
    };

    MissionEvent();
    ~MissionEvent();

    // operations:
    void                 ExecFrame(double seconds);
    void                 Activate();

    virtual bool         CheckTrigger();
    virtual void         Execute(bool silent=false);
    virtual void         Skip();

    // accessors:
    int                  EventID()         const { return id;      }
    int                  Status()          const { return status;  }
    bool                 IsPending()       const { return status == PENDING;  }
    bool                 IsActive()        const { return status == ACTIVE;   }
    bool                 IsComplete()      const { return status == COMPLETE; }
    bool                 IsSkipped()       const { return status == SKIPPED;  }

    double               Time()            const { return time;    }
    double               Delay()           const { return delay;   }

    int                  Event()           const { return event;         }
    const char*          EventName()       const;
    Text                 EventShip()       const { return event_ship;    }
    Text                 EventSource()     const { return event_source;  }
    Text                 EventTarget()     const { return event_target;  }
    Text                 EventMessage()    const { return event_message; }
    Text                 EventSound()      const { return event_sound;   }

    int                  EventParam(int index=0)    const;
    int                  NumEventParams()           const;

    int                  EventChance()     const { return event_chance;  }
    Point                EventPoint()      const { return event_point;   }
    Rect                 EventRect()       const { return event_rect;    }

    int                  Trigger()         const { return trigger;          }
    const char*          TriggerName()     const;
    Text                 TriggerShip()     const { return trigger_ship;     }
    Text                 TriggerTarget()   const { return trigger_target;   }

    Text                 TriggerParamStr()          const;
    int                  TriggerParam(int index=0)  const;
    int                  NumTriggerParams()         const;

    static const char*   EventName(int n);
    static int           EventForName(const char* n);
    static const char*   TriggerName(int n);
    static int           TriggerForName(const char* n);

protected:
    int                  id;
    int                  status;
    double               time;
    double               delay;

    int                  event;
    Text                 event_ship;
    Text                 event_source;
    Text                 event_target;
    Text                 event_message;
    Text                 event_sound;
    int                  event_param[10];
    int                  event_nparams;
    int                  event_chance;
    Vec3                 event_point;
    Rect                 event_rect;

    int                  trigger;
    Text                 trigger_ship;
    Text                 trigger_target;
    int                  trigger_param[10];
    int                  trigger_nparams;

    Bitmap               image;
    Sound*               sound;
};


#endif  // MissionEvent_h