Merge branch 'master' into martin-t/globals
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / mutators / base.qh
1 #pragma once
2
3 #ifdef CSQC
4 #include <client/main.qh>
5 #endif
6
7 const int CBC_ORDER_FIRST = 1;
8 const int CBC_ORDER_LAST = 2;
9 const int CBC_ORDER_EXCLUSIVE = 3;
10 const int CBC_ORDER_ANY = 4;
11
12 bool CallbackChain_ReturnValue; // read-only field of the current return value
13
14 /**
15  * Callbacks may be added to zero or more callback chains.
16  */
17 CLASS(Callback, Object)
18     /**
19      * a callback function is like this:
20      * bool mycallback()
21      * {
22      *     do something
23      *     return false;
24      * }
25      */
26     ATTRIB(Callback, cbc_func, bool());
27     CONSTRUCTOR(Callback, bool() func) {
28         CONSTRUCT(Callback);
29         this.cbc_func = func;
30     }
31 ENDCLASS(Callback)
32
33 /**
34  * Callback chains contain zero or more callbacks.
35  */
36 CLASS(CallbackChain, Object)
37     CLASS(CallbackNode, Object)
38         ATTRIB(CallbackNode, cbc, Callback);
39         ATTRIB(CallbackNode, cbc_next, CallbackNode);
40         ATTRIB(CallbackNode, cbc_order, int, 0);
41         CONSTRUCTOR(CallbackNode, Callback it, int order) {
42             CONSTRUCT(CallbackNode);
43             this.cbc = it;
44             this.cbc_order = order;
45         }
46     ENDCLASS(CallbackNode)
47
48     ATTRIB(CallbackChain, cbc_next, CallbackNode);
49     ATTRIB(CallbackChain, cbc_order, int, 0);
50     CONSTRUCTOR(CallbackChain, string _name) {
51         CONSTRUCT(CallbackChain);
52         this.netname = _name;
53     }
54
55     bool CallbackChain_Add(CallbackChain this, Callback cb, int order)
56     {
57         if (order & CBC_ORDER_FIRST) {
58             if (order & CBC_ORDER_LAST)
59                 if (this.cbc_order & CBC_ORDER_ANY)
60                     return false;
61             if (this.cbc_order & CBC_ORDER_FIRST)
62                 return false;
63         } else if (order & CBC_ORDER_LAST) {
64             if (this.cbc_order & CBC_ORDER_LAST)
65                 return false;
66         }
67         entity node = NEW(CallbackNode, cb, order);
68         if (order & CBC_ORDER_FIRST) {
69             node.cbc_next = this.cbc_next;
70             this.cbc_next = node;
71         } else if (order & CBC_ORDER_LAST) {
72             CallbackNode prev = NULL, it = this.cbc_next;
73             while (it) { prev = it, it = it.cbc_next; }
74             if (prev) prev.cbc_next = node;
75             else this.cbc_next = node;
76         } else {
77             // by default we execute last, but before a possible CBC_ORDER_LAST callback
78             CallbackNode prev = NULL, it = this.cbc_next;
79             while (it && !(it.cbc_order & CBC_ORDER_LAST)) { prev = it, it = it.cbc_next; }
80             node.cbc_next = it;
81             if (prev) prev.cbc_next = node;
82             else this.cbc_next = node;
83         }
84         this.cbc_order |= (order | CBC_ORDER_ANY);
85         return true;
86     }
87     int CallbackChain_Remove(CallbackChain this, Callback cb)
88     {
89         int n = 0, order = 0;
90         for (Callback prev = NULL, it = this.cbc_next; it; prev = it, it = it.cbc_next) {
91             if (it.cbc == cb) {
92                 // remove it from the chain
93                 Callback next = it.cbc_next;
94                 if (prev) prev.cbc_next = next;
95                 else this.cbc_next = next;
96                 ++n;
97             }
98             // it is now something we want to keep
99             order |= (it.cbc_order & CBC_ORDER_ANY);
100         }
101         this.cbc_order = order;
102         return n;
103     }
104     bool CallbackChain_Call(CallbackChain this)
105     {
106         bool r = false;
107         for (Callback it = this.cbc_next; it; it = it.cbc_next) {
108             CallbackChain_ReturnValue = r;
109             r |= it.cbc.cbc_func();
110         }
111         return r; // callbacks return an error status, so 0 is default return value
112     }
113 ENDCLASS(CallbackChain)
114
115 #define _MUTATOR_HANDLE_NOP(type, id)
116 #define _MUTATOR_HANDLE_PARAMS(type, id) , type in_##id
117 #define _MUTATOR_HANDLE_PREPARE(type, id) id = in_##id;
118 #define _MUTATOR_HANDLE_PUSHTMP(type, id) TC(type, id); type tmp_##id = id;
119 #define _MUTATOR_HANDLE_PUSHOUT(type, id) type out_##id = id;
120 #define _MUTATOR_HANDLE_POPTMP(type, id) id = tmp_##id;
121 #define _MUTATOR_HANDLE_POPOUT(type, id) id = out_##id;
122
123 void RegisterHooks() {};
124 void RegisterCallbacks() {};
125
126 #define MUTATOR_HOOKABLE(id, params) _MUTATOR_HOOKABLE(id, params)
127 #define _MUTATOR_HOOKABLE(id, params) \
128     CallbackChain HOOK_##id;  \
129     bool __Mutator_Send_##id(int params(_MUTATOR_HANDLE_PARAMS, _MUTATOR_HANDLE_NOP)) { \
130         params(_MUTATOR_HANDLE_PUSHTMP, _MUTATOR_HANDLE_NOP) \
131         params(_MUTATOR_HANDLE_PREPARE, _MUTATOR_HANDLE_NOP) \
132         bool ret = CallbackChain_Call(HOOK_##id); \
133         params(_MUTATOR_HANDLE_NOP,     _MUTATOR_HANDLE_PUSHOUT) \
134         params(_MUTATOR_HANDLE_POPTMP,  _MUTATOR_HANDLE_NOP) \
135         params(_MUTATOR_HANDLE_NOP,     _MUTATOR_HANDLE_POPOUT) \
136         return ret; \
137     } \
138     ACCUMULATE void RegisterHooks() { HOOK_##id = NEW(CallbackChain, #id); }
139
140 #define MUTATOR_CALLHOOK(id, ...) _MUTATOR_CALLHOOK(id, __VA_ARGS__)
141 #ifdef __STDC__
142     #define _MUTATOR_CALLHOOK(id, ...) APPLY(__Mutator_Send_##id, 0 P99_IF_EMPTY(__VA_ARGS__)()(, __VA_ARGS__))
143 #else
144     #define _MUTATOR_CALLHOOK(id, ...) APPLY(__Mutator_Send_##id, 0, ##__VA_ARGS__)
145 #endif
146
147 enum {
148     MUTATOR_REMOVING,
149     MUTATOR_ADDING,
150     MUTATOR_ROLLING_BACK
151 };
152
153 USING(mutatorfunc_t, bool(int));
154
155 CLASS(Mutator, Object)
156     ATTRIB(Mutator, m_id, int, 0);
157     ATTRIB(Mutator, m_name, string);
158     ATTRIB(Mutator, mutatorfunc, mutatorfunc_t);
159     ATTRIB(Mutator, mutatorcheck, bool());
160     CONSTRUCTOR(Mutator, string _name, mutatorfunc_t func) {
161         CONSTRUCT(Mutator);
162         this.m_name = _name;
163         this.mutatorfunc = func;
164     }
165 ENDCLASS(Mutator)
166
167 REGISTRY(Mutators, BITS(7))
168 #define Mutators_from(i) _Mutators_from(i, NULL)
169 bool Mutator_Add(Mutator mut);
170 void Mutator_Remove(Mutator mut);
171 bool mutator_log = false;
172 .bool m_added;
173
174 #define MUTATOR_IS_ENABLED(this) MUTATOR_##this.mutatorcheck()
175
176 #ifdef GAMEQC
177 /** server mutators activate corresponding client mutators for all clients */
178 REGISTER_NET_LINKED(Mutator)
179
180 #ifdef SVQC
181 bool Mutator_SendEntity(entity this, entity to, int sf)
182 {
183     int chan = MSG_ENTITY;
184     WriteHeader(chan, Mutator);
185     WriteString(chan, this.registered_id);
186     return true;
187 }
188 #endif
189
190 #ifdef CSQC
191 void NET_Mutator_Remove(entity this)
192 {
193     string s = this.netname;
194     WITH(bool, mutator_log, true, {
195         FOREACH(Mutators, it.registered_id == s, Mutator_Remove(it));
196     });
197 }
198 NET_HANDLE(Mutator, bool isNew)
199 {
200     make_pure(this);
201     string s = this.netname = ReadString();
202     return = true;
203     if (isNew)
204     {
205         make_pure(this);
206         this.entremove = NET_Mutator_Remove;
207         int added = 0;
208         WITH(bool, mutator_log, true, {
209             FOREACH(Mutators, it.registered_id == s, { Mutator_Add(it); ++added; });
210         });
211         if (added > 1) LOG_WARNF("Added more than one mutator for %s", s);
212     }
213 }
214 #endif
215
216 #endif
217
218 bool Mutator_Add(Mutator mut)
219 {
220     if(mut.m_added)
221         return true; // already added
222
223     mut.m_added = true;
224     mutatorfunc_t func = mut.mutatorfunc;
225     if (!func(MUTATOR_ADDING)) {
226         // good
227         if (mutator_log) LOG_TRACEF("Mutator: added %s", mut.m_name);
228 #ifdef SVQC
229         Net_LinkEntity(mut, false, 0, Mutator_SendEntity);
230 #endif
231         return true;
232     }
233     backtrace("WARNING: when adding mutator: adding failed, rolling back\n");
234     if (func(MUTATOR_ROLLING_BACK)) {
235         // baaaaad
236         error("WARNING: when adding mutator: rolling back failed");
237     }
238     return false;
239 }
240
241 void Mutator_Remove(Mutator mut)
242 {
243     if(!mut.m_added)
244     {
245         backtrace("WARNING: removing not-added mutator\n");
246         return;
247     }
248
249     mut.m_added = false;
250     mutatorfunc_t func = mut.mutatorfunc;
251     if (func(MUTATOR_REMOVING)) {
252         // baaaaad
253         error("Mutator_Remove: removing mutator failed");
254     }
255     if (mutator_log) LOG_TRACEF("Mutator: removed %s", mut.m_name);
256 #ifdef SVQC
257     Net_UnlinkEntity(mut);
258 #endif
259 }
260
261 #define REGISTER_MUTATOR(id, dependence) \
262     bool MUTATORFUNC_##id##_hooks(int mode) { return = false; } \
263     bool MUTATORFUNC_##id(int mode) { \
264         return = false; \
265         bool ret = MUTATORFUNC_##id##_hooks(mode); if (ret) return ret; \
266     } \
267     bool MUTATOR_##id##_check() { return dependence; } \
268     REGISTER(Mutators, MUTATOR, id, m_id, NEW(Mutator, #id, MUTATORFUNC_##id)) \
269     { this.mutatorcheck = MUTATOR_##id##_check; } \
270     ACCUMULATE bool MUTATORFUNC_##id(int mode)
271
272 STATIC_INIT(Mutators) {
273     RegisterHooks();
274     RegisterCallbacks();
275     RegisterMutators();
276 }
277
278 STATIC_INIT_LATE(Mutators) {
279     FOREACH(Mutators, it.mutatorcheck(), Mutator_Add(it));
280 }
281
282 #define MUTATOR_ONADD                   if (mode == MUTATOR_ADDING)
283 #define MUTATOR_ONREMOVE                if (mode == MUTATOR_REMOVING)
284 #define MUTATOR_ONROLLBACK_OR_REMOVE    if (mode == MUTATOR_REMOVING || mode == MUTATOR_ROLLING_BACK)
285
286 #define MUTATOR_STATIC() MACRO_BEGIN \
287     MUTATOR_ONADD { \
288         /* game loads at time 1 */ \
289         if (time > 1) { \
290             error("This is a game type and it cannot be added at runtime."); \
291         } \
292     } \
293         MUTATOR_ONREMOVE { \
294                 LOG_INFO("This is a game type and it cannot be removed at runtime."); \
295                 return -1; \
296         } \
297 MACRO_END
298
299 #define MUTATOR_ADD(name)               Mutator_Add(MUTATOR_##name)
300 #define MUTATOR_REMOVE(name)            Mutator_Remove(MUTATOR_##name)
301 #define MUTATOR_RETURNVALUE             CallbackChain_ReturnValue
302
303 #define _MUTATOR_CALLBACK(name, func) \
304     Callback CB_##name; \
305     bool func(); \
306     ACCUMULATE void RegisterCallbacks() { CB_##name = NEW(Callback, func); }
307
308 #define MUTATOR_HOOKFUNCTION(...) \
309     EVAL_MUTATOR_HOOKFUNCTION(OVERLOAD(MUTATOR_HOOKFUNCTION, __VA_ARGS__))
310 #define EVAL_MUTATOR_HOOKFUNCTION(...) __VA_ARGS__
311
312 #define MUTATOR_HOOKFUNCTION_2(mut, cb) \
313     MUTATOR_HOOKFUNCTION_3(mut, cb, CBC_ORDER_ANY)
314
315 #define MUTATOR_HOOKFUNCTION_3(mut, cb, order) \
316     _MUTATOR_CALLBACK(mut##_##cb, mut##_##cb) \
317     ACCUMULATE bool MUTATORFUNC_##mut##_hooks(int mode) { MUTATOR_HOOK(cb, mut##_##cb, order); } \
318     bool mut##_##cb() { return = false; } \
319     ACCUMULATE bool mut##_##cb()
320
321 void _mutPrintFail(string cb, string func)
322 {
323         // this is inside a function to avoid expanding it on compilation everytime
324         LOG_INFO("HOOK FAILED: ", cb, ":", func);
325 }
326
327 #define MUTATOR_HOOK(cb, func, order) MACRO_BEGIN \
328     MUTATOR_ONADD { \
329         if (!CallbackChain_Add(HOOK_##cb, CB_##func, order)) { \
330             _mutPrintFail(#cb, #func); \
331             return true; \
332         } \
333     } \
334     MUTATOR_ONROLLBACK_OR_REMOVE { \
335         CallbackChain_Remove(HOOK_##cb, CB_##func); \
336     } \
337 MACRO_END
338
339 #include "events.qh"