1 /*
2 * OpenBOR - http://www.chronocrash.com
3 * -----------------------------------------------------------------------
4 * All rights reserved. See LICENSE in OpenBOR root for license details.
5 *
6 * Copyright (c) 2004 - 2019 OpenBOR Team
7 */
8
9 #include "scriptcommon.h"
10
11 // Use string property argument to find an
12 // integer property constant and populate
13 // varlist->lval.
mapstrings_recursive_damage_property(ScriptVariant ** varlist,int paramCount)14 int mapstrings_recursive_damage_property(ScriptVariant **varlist, int paramCount)
15 {
16 #define ARG_MINIMUM 2 // Minimum number of arguments allowed in varlist.
17 #define ARG_PROPERTY 1 // Varlist element carrying which property is requested.
18
19 char *propname = NULL; // Placeholder for string property name from varlist.
20 int prop; // Placeholder for integer constant located by string.
21
22 static const char *proplist[] =
23 {
24 "force",
25 "index",
26 "mode",
27 "next",
28 "owner",
29 "rate",
30 "tag",
31 "tick",
32 "time",
33 "type",
34 };
35
36 // If the minimum argument count
37 // was not passed, then there is
38 // nothing to map. Return true - we'll
39 // catch the mistake in property access
40 // functions.
41 if (paramCount < ARG_MINIMUM)
42 {
43 return 1;
44 }
45
46 // See macro - will return 0 on fail.
47 MAPSTRINGS(varlist[ARG_PROPERTY], proplist, _RECURSIVE_DAMAGE_END,
48 "\n\n Error: '%s' is not a known recursive damage property.\n");
49
50
51 // If we made it this far everything should be OK.
52 return 1;
53
54 #undef ARG_MINIMUM
55 #undef ARG_PROPERTY
56 }
57
58
59 // Caskey, Damon V.
60 // 2018-04-02
61 //
62 // Return a property. Requires
63 // a pointer and property name to
64 // access.
openbor_get_recursive_damage_property(ScriptVariant ** varlist,ScriptVariant ** pretvar,int paramCount)65 HRESULT openbor_get_recursive_damage_property(ScriptVariant **varlist, ScriptVariant **pretvar, int paramCount)
66 {
67 #define SELF_NAME "openbor_get_recursive_damage_property(void handle, char property)"
68 #define ARG_MINIMUM 2 // Minimum required arguments.
69 #define ARG_HANDLE 0 // Handle (pointer to property structure).
70 #define ARG_PROPERTY 1 // Property to access.
71
72 s_damage_recursive *handle = NULL; // Property handle.
73 e_recursive_damage_properties property = 0; // Property argument.
74
75 // Clear pass by reference argument used to send
76 // property data back to calling script. .
77 ScriptVariant_Clear(*pretvar);
78
79 // Verify arguments. There should at least
80 // be a pointer for the property handle and an integer
81 // to determine which property constant is accessed.
82 if (paramCount < ARG_MINIMUM
83 || varlist[ARG_HANDLE]->vt != VT_PTR
84 || varlist[ARG_PROPERTY]->vt != VT_INTEGER)
85 {
86 *pretvar = NULL;
87 goto error_local;
88 }
89 else
90 {
91 // Populate local vars for readability.
92 handle = (s_damage_recursive *)varlist[ARG_HANDLE]->ptrVal;
93 property = (LONG)varlist[ARG_PROPERTY]->lVal;
94 }
95
96 switch (property)
97 {
98 case _RECURSIVE_DAMAGE_FORCE:
99
100 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
101 (*pretvar)->lVal = (LONG)handle->force;
102
103 break;
104
105 case _RECURSIVE_DAMAGE_INDEX:
106
107 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
108 (*pretvar)->lVal = (LONG)handle->force;
109
110 break;
111
112 case _RECURSIVE_DAMAGE_MODE:
113
114 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
115 (*pretvar)->lVal = (LONG)handle->index;
116
117 break;
118
119 case _RECURSIVE_DAMAGE_NEXT:
120
121 if (handle->next)
122 {
123 ScriptVariant_ChangeType(*pretvar, VT_PTR);
124 (*pretvar)->ptrVal = (VOID *)handle->next;
125 }
126
127 break;
128
129 case _RECURSIVE_DAMAGE_OWNER:
130
131 if (handle->owner)
132 {
133 ScriptVariant_ChangeType(*pretvar, VT_PTR);
134 (*pretvar)->ptrVal = (VOID *)handle->owner;
135 }
136
137 break;
138
139 case _RECURSIVE_DAMAGE_RATE:
140
141 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
142 (*pretvar)->lVal = (LONG)handle->rate;
143
144 break;
145
146 case _RECURSIVE_DAMAGE_TAG:
147
148 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
149 (*pretvar)->lVal = (LONG)handle->tag;
150
151 break;
152
153 case _RECURSIVE_DAMAGE_TICK:
154
155 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
156 (*pretvar)->lVal = (LONG)handle->tick;
157
158 break;
159
160 case _RECURSIVE_DAMAGE_TIME:
161
162 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
163 (*pretvar)->lVal = (LONG)handle->time;
164
165 break;
166
167 case _RECURSIVE_DAMAGE_TYPE:
168
169 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
170 (*pretvar)->lVal = (LONG)handle->type;
171
172 break;
173
174 default:
175
176 printf("Unsupported property.\n");
177 goto error_local;
178
179 break;
180 }
181
182 return S_OK;
183
184 error_local:
185
186 printf("You must provide a valid handle and property name: " SELF_NAME "\n");
187 *pretvar = NULL;
188
189 return E_FAIL;
190
191 #undef SELF_NAME
192 #undef ARG_MINIMUM
193 #undef ARG_HANDLE
194 #undef ARG_INDEX
195 }
196
197 // Caskey, Damon V.
198 // 2018-04-03
199 //
200 // Mutate a entity property. Requires
201 // the pointer, a string property
202 // name, and new value.
openbor_set_recursive_damage_property(ScriptVariant ** varlist,ScriptVariant ** pretvar,int paramCount)203 HRESULT openbor_set_recursive_damage_property(ScriptVariant **varlist, ScriptVariant **pretvar, int paramCount)
204 {
205 #define SELF_NAME "openbor_set_recursive_damage_property(void handle, char property, value)"
206 #define ARG_MINIMUM 3 // Minimum required arguments.
207 #define ARG_HANDLE 0 // Handle (pointer to property structure).
208 #define ARG_PROPERTY 1 // Property to access.
209 #define ARG_VALUE 2 // New value to apply.
210
211 int result = S_OK; // Success or error?
212 s_damage_recursive *handle = NULL; // Property handle.
213 e_recursive_damage_properties property = 0; // Property to access.
214
215 // Value carriers to apply on properties after
216 // taken from argument.
217 LONG temp_int;
218
219 // Verify incoming arguments. There should at least
220 // be a pointer for the property handle and an integer
221 // to determine which property is accessed.
222 if (paramCount < ARG_MINIMUM
223 || varlist[ARG_HANDLE]->vt != VT_PTR
224 || varlist[ARG_PROPERTY]->vt != VT_INTEGER)
225 {
226 *pretvar = NULL;
227 goto error_local;
228 }
229
230 // Populate local handle and property vars.
231 handle = (s_damage_recursive *)varlist[ARG_HANDLE]->ptrVal;
232 property = (LONG)varlist[ARG_PROPERTY]->lVal;
233
234 // Which property to modify?
235 switch (property)
236 {
237
238 case _RECURSIVE_DAMAGE_FORCE:
239
240 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
241 {
242 handle->force = temp_int;
243 }
244
245 break;
246
247 case _RECURSIVE_DAMAGE_INDEX:
248
249 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
250 {
251 handle->index = temp_int;
252 }
253
254 break;
255
256 case _RECURSIVE_DAMAGE_MODE:
257
258 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
259 {
260 handle->mode = temp_int;
261 }
262
263 break;
264
265 case _RECURSIVE_DAMAGE_NEXT:
266
267 handle->next = (s_damage_recursive *)varlist[ARG_VALUE]->ptrVal;
268
269 break;
270
271 case _RECURSIVE_DAMAGE_OWNER:
272
273 handle->owner = (entity *)varlist[ARG_VALUE]->ptrVal;
274
275 break;
276
277 case _RECURSIVE_DAMAGE_RATE:
278
279 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
280 {
281 handle->rate = temp_int;
282 }
283
284 break;
285
286 case _RECURSIVE_DAMAGE_TAG:
287
288 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
289 {
290 handle->tag = temp_int;
291 }
292
293 break;
294
295 case _RECURSIVE_DAMAGE_TICK:
296
297 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
298 {
299 handle->tick = temp_int;
300 }
301
302 break;
303
304 case _RECURSIVE_DAMAGE_TIME:
305
306 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
307 {
308 handle->time = temp_int;
309 }
310
311 break;
312
313 case _RECURSIVE_DAMAGE_TYPE:
314
315 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
316 {
317 handle->type = temp_int;
318 }
319
320 break;
321
322 default:
323
324 printf("Unsupported property.\n");
325 goto error_local;
326
327 break;
328 }
329
330 return result;
331
332 // Error trapping.
333 error_local:
334
335 printf("You must provide a valid handle, property, and new value: " SELF_NAME "\n");
336
337 result = E_FAIL;
338 return result;
339
340 #undef SELF_NAME
341 #undef ARG_MINIMUM
342 #undef ARG_HANDLE
343 #undef ARG_PROPERTY
344 #undef ARG_VALUE
345 }
346