1 #ifndef MUTATORS_BASE_H
2 #define MUTATORS_BASE_H
4 const int CBC_ORDER_FIRST = 1;
5 const int CBC_ORDER_LAST = 2;
6 const int CBC_ORDER_EXCLUSIVE = 3;
7 const int CBC_ORDER_ANY = 4;
9 bool CallbackChain_ReturnValue; // read-only field of the current return value
12 * Callbacks may be added to zero or more callback chains.
14 CLASS(Callback, Object)
16 * a callback function is like this:
23 ATTRIB(Callback, cbc_func, bool(), func_null)
24 CONSTRUCTOR(Callback, bool() func) {
31 * Callback chains contain zero or more callbacks.
33 CLASS(CallbackChain, Object)
34 CLASS(CallbackNode, Object)
35 ATTRIB(CallbackNode, cbc, Callback, NULL)
36 ATTRIB(CallbackNode, cbc_next, CallbackNode, NULL)
37 ATTRIB(CallbackNode, cbc_order, int, 0)
38 CONSTRUCTOR(CallbackNode, Callback it, int order) {
39 CONSTRUCT(CallbackNode);
41 this.cbc_order = order;
43 ENDCLASS(CallbackNode)
45 ATTRIB(CallbackChain, cbc_next, CallbackNode, NULL)
46 ATTRIB(CallbackChain, cbc_order, int, 0)
47 CONSTRUCTOR(CallbackChain, string _name) {
48 CONSTRUCT(CallbackChain);
52 bool CallbackChain_Add(CallbackChain this, Callback cb, int order)
54 if (order & CBC_ORDER_FIRST) {
55 if (order & CBC_ORDER_LAST)
56 if (this.cbc_order & CBC_ORDER_ANY)
58 if (this.cbc_order & CBC_ORDER_FIRST)
60 } else if (order & CBC_ORDER_LAST) {
61 if (this.cbc_order & CBC_ORDER_LAST)
64 entity node = NEW(CallbackNode, cb, order);
65 if (order & CBC_ORDER_FIRST) {
66 node.cbc_next = this.cbc_next;
68 } else if (order & CBC_ORDER_LAST) {
69 CallbackNode prev = NULL, it = this.cbc_next;
70 while (it) { prev = it, it = it.cbc_next; }
71 if (prev) prev.cbc_next = node;
72 else this.cbc_next = node;
74 // by default we execute last, but before a possible CBC_ORDER_LAST callback
75 CallbackNode prev = NULL, it = this.cbc_next;
76 while (it && !(it.cbc_order & CBC_ORDER_LAST)) { prev = it, it = it.cbc_next; }
78 if (prev) prev.cbc_next = node;
79 else this.cbc_next = node;
81 this.cbc_order |= (order | CBC_ORDER_ANY);
84 int CallbackChain_Remove(CallbackChain this, Callback cb)
87 for (Callback prev = NULL, it = this.cbc_next; it; prev = it, it = it.cbc_next) {
89 // remove it from the chain
90 Callback next = it.cbc_next;
91 if (prev) prev.cbc_next = next;
92 else this.cbc_next = next;
95 // it is now something we want to keep
96 order |= (it.cbc_order & CBC_ORDER_ANY);
98 this.cbc_order = order;
101 bool CallbackChain_Call(CallbackChain this)
104 for (Callback it = this.cbc_next; it; it = it.cbc_next) {
105 CallbackChain_ReturnValue = r;
106 r |= it.cbc.cbc_func();
108 return r; // callbacks return an error status, so 0 is default return value
110 ENDCLASS(CallbackChain)
112 #define _MUTATOR_HANDLE_NOP(type, id)
113 #define _MUTATOR_HANDLE_PARAMS(type, id) , type in_##id
114 #define _MUTATOR_HANDLE_PREPARE(type, id) id = in_##id;
115 #define _MUTATOR_HANDLE_PUSHTMP(type, id) type tmp_##id = id;
116 #define _MUTATOR_HANDLE_PUSHOUT(type, id) type out_##id = id;
117 #define _MUTATOR_HANDLE_POPTMP(type, id) id = tmp_##id;
118 #define _MUTATOR_HANDLE_POPOUT(type, id) id = out_##id;
120 void RegisterHooks() {};
121 void RegisterCallbacks() {};
123 #define _MUTATOR_HOOKABLE(id, ...) CallbackChain HOOK_##id; bool __Mutator_Send_##id(__VA_ARGS__)
124 #define MUTATOR_HOOKABLE(id, params) \
125 _MUTATOR_HOOKABLE(id, int params(_MUTATOR_HANDLE_PARAMS, _MUTATOR_HANDLE_NOP)) { \
126 params(_MUTATOR_HANDLE_PUSHTMP, _MUTATOR_HANDLE_NOP) \
127 params(_MUTATOR_HANDLE_PREPARE, _MUTATOR_HANDLE_NOP) \
128 bool ret = CallbackChain_Call(HOOK_##id); \
129 params(_MUTATOR_HANDLE_NOP, _MUTATOR_HANDLE_PUSHOUT) \
130 params(_MUTATOR_HANDLE_POPTMP, _MUTATOR_HANDLE_NOP) \
131 params(_MUTATOR_HANDLE_NOP, _MUTATOR_HANDLE_POPOUT) \
134 [[accumulate]] void RegisterHooks() { HOOK_##id = NEW(CallbackChain, #id); }
135 #define MUTATOR_CALLHOOK(id, ...) APPLY(__Mutator_Send_##id, 0, ##__VA_ARGS__)
143 typedef bool(int) mutatorfunc_t;
145 CLASS(Mutator, Object)
146 ATTRIB(Mutator, m_id, int, 0)
147 ATTRIB(Mutator, m_name, string, string_null)
148 ATTRIB(Mutator, mutatorfunc, mutatorfunc_t, func_null)
149 ATTRIB(Mutator, mutatorcheck, bool(), func_null)
150 CONSTRUCTOR(Mutator, string _name, mutatorfunc_t func) {
153 this.mutatorfunc = func;
157 REGISTRY(Mutators, BITS(7))
158 #define Mutators_from(i) _Mutators_from(i, NULL)
159 Mutator loaded_mutators[Mutators_MAX];
160 bool Mutator_Add(Mutator mut);
161 void Mutator_Remove(Mutator mut);
162 bool mutator_log = false;
165 REGISTER_NET_LINKED(Mutator)
168 bool Mutator_SendEntity(entity this, entity to, int sf)
170 int chan = MSG_ENTITY;
171 WriteHeader(chan, Mutator);
172 WriteString(chan, this.registered_id);
178 void NET_Mutator_Remove()
181 string s = this.netname;
182 WITH(bool, mutator_log, true, LAMBDA(
183 FOREACH(Mutators, it.registered_id == s, LAMBDA(Mutator_Remove(it)));
186 NET_HANDLE(Mutator, bool isNew)
188 string s = this.netname = ReadString();
193 this.entremove = NET_Mutator_Remove;
195 WITH(bool, mutator_log, true, LAMBDA(
196 FOREACH(Mutators, it.registered_id == s, LAMBDA(Mutator_Add(it); ++added));
198 if (added > 1) LOG_WARNINGF("Added more than one mutator for %s\n", s);
205 bool Mutator_Add(Mutator mut)
208 for (int i = 0; i < Mutators_MAX; ++i) {
209 if (loaded_mutators[i] == mut)
210 return true; // already added
211 if (!(loaded_mutators[i]))
215 backtrace("WARNING: too many mutators, cannot add any more\n");
218 loaded_mutators[j] = mut;
219 mutatorfunc_t func = mut.mutatorfunc;
220 if (!func(MUTATOR_ADDING)) {
222 if (mutator_log) LOG_TRACEF("Mutator: added %s\n", mut.m_name);
224 Net_LinkEntity(mut, false, 0, Mutator_SendEntity);
228 backtrace("WARNING: when adding mutator: adding failed, rolling back\n");
229 if (func(MUTATOR_ROLLING_BACK)) {
231 error("WARNING: when adding mutator: rolling back failed");
236 void Mutator_Remove(Mutator mut)
239 for (i = 0; i < Mutators_MAX; ++i)
240 if (loaded_mutators[i] == mut)
242 if (i >= Mutators_MAX) {
243 backtrace("WARNING: removing not-added mutator\n");
246 loaded_mutators[i] = NULL;
247 mutatorfunc_t func = mut.mutatorfunc;
248 if (func(MUTATOR_REMOVING)) {
250 error("Mutator_Remove: removing mutator failed");
252 if (mutator_log) LOG_TRACEF("Mutator: removed %s\n", mut.m_name);
254 Net_UnlinkEntity(mut);
258 #define REGISTER_MUTATOR(id, dependence) \
259 bool MUTATORFUNCTION_##id##_hooks(int mode) { return = false; } \
260 bool MUTATORFUNCTION_##id(int mode) { \
262 bool ret = MUTATORFUNCTION_##id##_hooks(mode); if (ret) return ret; \
264 bool MUTATOR_##id##_check() { return dependence; } \
265 REGISTER(Mutators, MUTATOR, id, m_id, NEW(Mutator, #id, MUTATORFUNCTION_##id)) \
266 { this.mutatorcheck = MUTATOR_##id##_check; } \
267 [[accumulate]] bool MUTATORFUNCTION_##id(int mode)
269 STATIC_INIT(Mutators) {
275 STATIC_INIT_LATE(Mutators) {
276 FOREACH(Mutators, it.mutatorcheck(), LAMBDA(Mutator_Add(it)));
279 #define MUTATOR_ONADD if (mode == MUTATOR_ADDING)
280 #define MUTATOR_ONREMOVE if (mode == MUTATOR_REMOVING)
281 #define MUTATOR_ONROLLBACK_OR_REMOVE if (mode == MUTATOR_REMOVING || mode == MUTATOR_ROLLING_BACK)
282 #define MUTATOR_ADD(name) Mutator_Add(MUTATOR_##name)
283 #define MUTATOR_REMOVE(name) Mutator_Remove(MUTATOR_##name)
284 #define MUTATOR_RETURNVALUE CallbackChain_ReturnValue
286 #define _MUTATOR_CALLBACK(name, func) \
287 Callback CALLBACK_##name; \
289 [[accumulate]] void RegisterCallbacks() { CALLBACK_##name = NEW(Callback, func); }
291 #define MUTATOR_HOOKFUNCTION(...) \
292 EVAL(OVERLOAD(MUTATOR_HOOKFUNCTION, __VA_ARGS__))
294 #define MUTATOR_HOOKFUNCTION_2(mut, cb) \
295 MUTATOR_HOOKFUNCTION_3(mut, cb, CBC_ORDER_ANY)
297 #define MUTATOR_HOOKFUNCTION_3(mut, cb, order) \
298 _MUTATOR_CALLBACK(mut##_##cb, mut##_##cb) \
299 [[accumulate]] bool MUTATORFUNCTION_##mut##_hooks(int mode) { MUTATOR_HOOK(cb, mut##_##cb, order); } \
300 bool mut##_##cb() { return = false; } \
301 [[accumulate]] bool mut##_##cb()
303 #define MUTATOR_HOOK(cb, func, order) MACRO_BEGIN { \
305 if (!CallbackChain_Add(HOOK_##cb, CALLBACK_##func, order)) { \
306 LOG_INFO("HOOK FAILED: ", #cb, ":", #func, "\n"); \
310 MUTATOR_ONROLLBACK_OR_REMOVE { \
311 CallbackChain_Remove(HOOK_##cb, CALLBACK_##func); \