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 - 2018 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_entity_property(ScriptVariant ** varlist,int paramCount)14 int mapstrings_entity_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 "ai_disable",
25 "ai_target_entity",
26 "alternate_idle",
27 "alternate_walk",
28 "animation",
29 "animation_frame",
30 "animation_id",
31 "animation_id_previous",
32 "animation_state",
33 "animation_time",
34 "arrow_state",
35 "attack_id_incoming",
36 "attack_id_outgoing",
37 "attack_state",
38 "autokill",
39 "back_hit_direction",
40 "bind",
41 "blast_state",
42 "blink",
43 "block_state",
44 "boss",
45 "charge_state",
46 "child",
47 "colorset_default",
48 "colorset_dying_health_1",
49 "colorset_dying_health_2",
50 "colorset_dying_index_1",
51 "colorset_dying_index_2",
52 "colorset_table",
53 "colorset_time",
54 "combo_step",
55 "combo_time",
56 "command_time",
57 "damage_on_landing",
58 "dead",
59 "deduct_ammo",
60 "defense_collection",
61 "destination_x",
62 "destination_z",
63 "die_on_landing",
64 "drawmethod",
65 "drop",
66 "duck_state",
67 "entvar_collection",
68 "escape_count",
69 "exists",
70 "explode",
71 "fall_state",
72 "freeze_state",
73 "freeze_time",
74 "function_take_action",
75 "function_take_damage",
76 "function_think",
77 "function_try_move",
78 "get_state",
79 "grab_target",
80 "grab_walk_state",
81 "guard_time",
82 "hp",
83 "hp_old",
84 "idle_state",
85 "in_pain",
86 "in_pain_back",
87 "invincible_state",
88 "invincible_time",
89 "item_data",
90 "jump_animation_id",
91 "jump_state",
92 "jump_velocity_x",
93 "jump_velocity_y",
94 "jump_velocity_z",
95 "knockdown_count",
96 "knockdown_time",
97 "last_damage_type",
98 "last_hit",
99 "lifespan",
100 "link",
101 "model",
102 "model_data",
103 "model_default",
104 "move_time",
105 "move_x",
106 "move_z",
107 "mp",
108 "mp_charge_time",
109 "mp_old",
110 "mp_time",
111 "name",
112 "next_attack_time",
113 "next_hit_time",
114 "nograb",
115 "nograb_default",
116 "obstructed",
117 "obstruction_overhead",
118 "offense_collection",
119 "opponent",
120 "owner",
121 "parent",
122 "path_obstructed_wait",
123 "pause_time",
124 "platform_land",
125 "player_index",
126 "position_base",
127 "position_base_alternate",
128 "position_direction",
129 "position_x",
130 "position_y",
131 "position_z",
132 "projectile_prime",
133 "recursive_damage",
134 "release_time",
135 "rise_attack_delay",
136 "rise_attack_time",
137 "rise_delay",
138 "rise_state",
139 "run_state",
140 "rush",
141 "script_collection",
142 "seal_energy",
143 "seal_time",
144 "sleep_time",
145 "sort_id",
146 "space_other",
147 "spawn_type",
148 "speed_multiplier",
149 "stall_time",
150 "think_time",
151 "timestamp",
152 "to_cost",
153 "toss_time",
154 "turn_state",
155 "turn_time",
156 "update_mark",
157 "velocity_x",
158 "velocity_y",
159 "velocity_z",
160 "walk_state",
161 "waypoint_collection",
162 "waypoint_count",
163 "weapon_item"
164 };
165
166 // If the minimum argument count
167 // was not passed, then there is
168 // nothing to map. Return true - we'll
169 // catch the mistake in property access
170 // functions.
171 if(paramCount < ARG_MINIMUM)
172 {
173 return 1;
174 }
175
176 // See macro - will return 0 on fail.
177 MAPSTRINGS(varlist[ARG_PROPERTY], proplist, _ENTITY_END,
178 "\n\n Error: '%s' is not a known entity property.\n");
179
180
181 // If we made it this far everything should be OK.
182 return 1;
183
184 #undef ARG_MINIMUM
185 #undef ARG_PROPERTY
186 }
187
188
189 // Caskey, Damon V.
190 // 2018-04-02
191 //
192 // Return an entity property. Requires
193 // an entity handle and property name to
194 // access.
openbor_get_entity_property(ScriptVariant ** varlist,ScriptVariant ** pretvar,int paramCount)195 HRESULT openbor_get_entity_property(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)
196 {
197 #define SELF_NAME "openbor_get_entity_property(void handle, char property)"
198 #define ARG_MINIMUM 2 // Minimum required arguments.
199 #define ARG_HANDLE 0 // Handle (pointer to property structure).
200 #define ARG_PROPERTY 1 // Property to access.
201
202 entity *handle = NULL; // Property handle.
203 e_entity_properties property = 0; // Property argument.
204
205 // Clear pass by reference argument used to send
206 // property data back to calling script.
207 ScriptVariant_Clear(*pretvar);
208
209 // Verify arguments. There should at least
210 // be a pointer for the property handle and an integer
211 // to determine which property constant is accessed.
212 if(paramCount < ARG_MINIMUM
213 || varlist[ARG_HANDLE]->vt != VT_PTR
214 || varlist[ARG_PROPERTY]->vt != VT_INTEGER)
215 {
216 *pretvar = NULL;
217 goto error_local;
218 }
219 else
220 {
221 // Populate local vars for readability.
222 handle = (entity *)varlist[ARG_HANDLE]->ptrVal;
223 property = (LONG)varlist[ARG_PROPERTY]->lVal;
224 }
225
226 switch(property)
227 {
228 case _ENTITY_AI_DISABLE:
229
230 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
231 (*pretvar)->lVal = (LONG)handle->noaicontrol;
232
233 break;
234
235 case _ENTITY_AI_TARGET_ENTITY:
236
237 if(handle->custom_target)
238 {
239 ScriptVariant_ChangeType(*pretvar, VT_PTR);
240 (*pretvar)->ptrVal = (entity *)handle->custom_target;
241 }
242
243 break;
244
245 case _ENTITY_ALTERNATE_IDLE:
246
247 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
248 (*pretvar)->lVal = (LONG)handle->idlemode;
249
250 break;
251
252 case _ENTITY_ALTERNATE_WALK:
253
254 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
255 (*pretvar)->lVal = (LONG)handle->walkmode;
256
257 break;
258
259 case _ENTITY_ANIMATION:
260
261 ScriptVariant_ChangeType(*pretvar, VT_PTR);
262 (*pretvar)->ptrVal = (s_anim *)handle->animation;
263
264 break;
265
266 case _ENTITY_ANIMATION_FRAME:
267
268 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
269 (*pretvar)->lVal = (LONG)handle->animpos;
270
271 break;
272
273 case _ENTITY_ANIMATION_ID:
274
275 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
276 (*pretvar)->lVal = (LONG)handle->animnum;
277
278 break;
279
280 case _ENTITY_ANIMATION_ID_PREVIOUS:
281
282 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
283 (*pretvar)->lVal = (LONG)handle->animnum_previous;
284
285 break;
286
287 case _ENTITY_ANIMATION_STATE:
288
289 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
290 (*pretvar)->lVal = (LONG)handle->animating;
291
292 break;
293
294 case _ENTITY_ANIMATION_TIME:
295
296 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
297 (*pretvar)->lVal = (LONG)handle->nextanim;
298
299 break;
300
301 case _ENTITY_ARROW_STATE:
302
303 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
304 (*pretvar)->lVal = (LONG)handle->arrowon;
305
306 break;
307
308 case _ENTITY_ATTACK_ID_INCOMING:
309
310 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
311 (*pretvar)->lVal = (LONG)handle->attack_id_incoming;
312
313 break;
314
315 case _ENTITY_ATTACK_ID_OUTGOING:
316
317 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
318 (*pretvar)->lVal = (LONG)handle->attack_id_outgoing;
319
320 break;
321
322 case _ENTITY_ATTACK_STATE:
323
324 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
325 (*pretvar)->lVal = (LONG)handle->attacking;
326
327 break;
328
329 case _ENTITY_AUTOKILL:
330
331 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
332 (*pretvar)->lVal = (LONG)handle->autokill;
333
334 break;
335
336 case _ENTITY_BACK_HIT_DIRECTION:
337
338 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
339 (*pretvar)->lVal = (LONG)handle->normaldamageflipdir;
340
341 break;
342
343 case _ENTITY_BIND:
344
345 ScriptVariant_ChangeType(*pretvar, VT_PTR);
346 (*pretvar)->ptrVal = (s_bind *)&handle->binding;
347
348 break;
349
350 case _ENTITY_BLAST_STATE:
351
352 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
353 (*pretvar)->lVal = (LONG)handle->projectile;
354
355 break;
356
357 case _ENTITY_BLINK:
358
359 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
360 (*pretvar)->lVal = (LONG)handle->blink;
361
362 break;
363
364 case _ENTITY_BLOCK_STATE:
365
366 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
367 (*pretvar)->lVal = (LONG)handle->blocking;
368
369 break;
370
371 case _ENTITY_BOSS:
372
373 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
374 (*pretvar)->lVal = (LONG)handle->boss;
375
376 break;
377
378 case _ENTITY_CHARGE_STATE:
379
380 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
381 (*pretvar)->lVal = (LONG)handle->charging;
382
383 break;
384
385 case _ENTITY_CHILD:
386
387 ScriptVariant_ChangeType(*pretvar, VT_PTR);
388 (*pretvar)->ptrVal = (entity *)handle->subentity;
389
390 break;
391
392 case _ENTITY_COLORSET_DEFAULT:
393
394 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
395 (*pretvar)->lVal = (LONG)handle->map;
396
397 break;
398
399 case _ENTITY_COLORSET_DYING_HEALTH_1:
400
401 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
402 (*pretvar)->lVal = (LONG)handle->per1;
403
404 break;
405
406 case _ENTITY_COLORSET_DYING_HEALTH_2:
407
408 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
409 (*pretvar)->lVal = (LONG)handle->per2;
410
411 break;
412
413 case _ENTITY_COLORSET_DYING_INDEX_1:
414
415 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
416 (*pretvar)->lVal = (LONG)handle->dying;
417
418 break;
419
420 case _ENTITY_COLORSET_DYING_INDEX_2:
421
422 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
423 (*pretvar)->lVal = (LONG)handle->dying2;
424
425 break;
426
427 case _ENTITY_COLORSET_TABLE:
428
429 ScriptVariant_ChangeType(*pretvar, VT_PTR);
430 (*pretvar)->ptrVal = (VOID *)(handle->colourmap);
431
432 break;
433
434 case _ENTITY_COLORSET_TIME:
435
436 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
437 (*pretvar)->lVal = (LONG)handle->maptime;
438
439 break;
440
441 case _ENTITY_COMBO_STEP:
442
443 ScriptVariant_ChangeType(*pretvar, VT_PTR);
444 (*pretvar)->ptrVal = (VOID *)&handle->combostep;
445
446 break;
447
448 case _ENTITY_COMBO_TIME:
449
450 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
451 (*pretvar)->lVal = (LONG)handle->combotime;
452
453 break;
454
455 case _ENTITY_COMMAND_TIME:
456
457 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
458 (*pretvar)->lVal = (LONG)handle->movetime;
459
460 break;
461
462 case _ENTITY_DAMAGE_ON_LANDING:
463
464 ScriptVariant_ChangeType(*pretvar, VT_PTR);
465 (*pretvar)->ptrVal = (s_damage_on_landing *)&handle->damage_on_landing;
466
467 break;
468
469 case _ENTITY_DEAD:
470
471 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
472 (*pretvar)->lVal = (LONG)handle->dead;
473
474 break;
475
476 case _ENTITY_DEDUCT_AMMO:
477
478 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
479 (*pretvar)->lVal = (LONG)handle->deduct_ammo;
480
481 break;
482
483 case _ENTITY_DEFENSE_COLLECTION:
484
485 ScriptVariant_ChangeType(*pretvar, VT_PTR);
486 (*pretvar)->ptrVal = (s_defense *)handle->defense;
487
488 break;
489
490 case _ENTITY_DESTINATION_X:
491
492 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
493 (*pretvar)->dblVal = (DOUBLE)handle->destx;
494
495 break;
496
497 case _ENTITY_DESTINATION_Z:
498
499 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
500 (*pretvar)->dblVal = (DOUBLE)handle->destz;
501
502 break;
503
504 case _ENTITY_DIE_ON_LANDING:
505
506 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
507 (*pretvar)->lVal = (LONG)handle->die_on_landing;
508
509 break;
510
511 case _ENTITY_DRAWMETHOD:
512
513 ScriptVariant_ChangeType(*pretvar, VT_PTR);
514 (*pretvar)->ptrVal = (s_drawmethod *)handle->drawmethod;
515
516 break;
517
518 case _ENTITY_DROP:
519
520 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
521 (*pretvar)->lVal = (LONG)handle->drop;
522
523 break;
524
525 case _ENTITY_DUCK_STATE:
526
527 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
528 (*pretvar)->lVal = (LONG)handle->ducking;
529
530 break;
531
532 case _ENTITY_ENTVAR_COLLECTION:
533
534 if (handle->varlist)
535 {
536 ScriptVariant_ChangeType(*pretvar, VT_PTR);
537 (*pretvar)->ptrVal = (Varlist *)handle->varlist;
538 }
539
540 break;
541
542 case _ENTITY_ESCAPE_COUNT:
543
544 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
545 (*pretvar)->lVal = (LONG)handle->escapecount;
546
547 break;
548
549 case _ENTITY_EXISTS:
550
551 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
552 (*pretvar)->lVal = (LONG)handle->exists;
553
554 break;
555
556 case _ENTITY_EXPLODE:
557
558 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
559 (*pretvar)->lVal = (LONG)handle->toexplode;
560
561 break;
562
563 case _ENTITY_FALL_STATE:
564
565 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
566 (*pretvar)->lVal = (LONG)handle->falling;
567
568 break;
569
570 case _ENTITY_FREEZE_STATE:
571
572 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
573 (*pretvar)->lVal = (LONG)handle->frozen;
574
575 break;
576
577 case _ENTITY_FREEZE_TIME:
578
579 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
580 (*pretvar)->lVal = (LONG)handle->freezetime;
581
582 break;
583
584 case _ENTITY_FUNCTION_TAKE_ACTION:
585
586 ScriptVariant_ChangeType(*pretvar, VT_PTR);
587 (*pretvar)->ptrVal = (VOID *)handle->takeaction;
588
589 break;
590
591 case _ENTITY_FUNCTION_TAKE_DAMAGE:
592
593 ScriptVariant_ChangeType(*pretvar, VT_PTR);
594 (*pretvar)->ptrVal = (VOID *)handle->takedamage;
595
596 break;
597
598 case _ENTITY_FUNCTION_THINK:
599
600 ScriptVariant_ChangeType(*pretvar, VT_PTR);
601 (*pretvar)->ptrVal = (VOID *)handle->think;
602
603 break;
604
605 case _ENTITY_FUNCTION_TRY_MOVE:
606
607 ScriptVariant_ChangeType(*pretvar, VT_PTR);
608 (*pretvar)->ptrVal = (VOID *)handle->trymove;
609
610 break;
611
612 case _ENTITY_GET_STATE:
613
614 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
615 (*pretvar)->lVal = (LONG)handle->getting;
616
617 break;
618
619 case _ENTITY_GRAB_TARGET:
620
621 if (handle->custom_target)
622 {
623 ScriptVariant_ChangeType(*pretvar, VT_PTR);
624 (*pretvar)->ptrVal = (entity *)handle->grabbing;
625 }
626
627 break;
628
629 case _ENTITY_GRAB_WALK_STATE:
630
631 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
632 (*pretvar)->lVal = (LONG)handle->grabwalking;
633
634 break;
635
636 case _ENTITY_GUARD_TIME:
637
638 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
639 (*pretvar)->lVal = (LONG)handle->guardtime;
640
641 break;
642
643 case _ENTITY_HP:
644
645 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
646 (*pretvar)->lVal = (LONG)handle->energy_state.health_current;
647
648 break;
649
650 case _ENTITY_HP_OLD:
651
652 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
653 (*pretvar)->lVal = (LONG)handle->energy_state.health_old;
654
655 break;
656
657 case _ENTITY_IDLE_STATE:
658
659 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
660 (*pretvar)->lVal = (LONG)handle->idling;
661
662 break;
663
664 case _ENTITY_IN_PAIN:
665
666 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
667 (*pretvar)->lVal = (LONG)handle->inpain;
668
669 break;
670
671 case _ENTITY_IN_PAIN_BACK:
672
673 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
674 (*pretvar)->lVal = (LONG)handle->inbackpain;
675
676 break;
677
678 case _ENTITY_INVINCIBLE_STATE:
679
680 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
681 (*pretvar)->lVal = (LONG)handle->invincible;
682
683 break;
684
685 case _ENTITY_INVINCIBLE_TIME:
686
687 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
688 (*pretvar)->lVal = (LONG)handle->invinctime;
689
690 break;
691
692 case _ENTITY_ITEM_DATA:
693
694 ScriptVariant_ChangeType(*pretvar, VT_PTR);
695 (*pretvar)->ptrVal = (s_item_properties *)&handle->item_properties;
696
697 break;
698
699 case _ENTITY_JUMP_ANIMATION_ID:
700
701 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
702 (*pretvar)->lVal = (LONG)handle->jump.animation_id;
703
704 break;
705
706 case _ENTITY_JUMP_STATE:
707
708 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
709 (*pretvar)->lVal = (LONG)handle->jumping;
710
711 break;
712
713 case _ENTITY_JUMP_VELOCITY_X:
714
715 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
716 (*pretvar)->dblVal = (DOUBLE)handle->jump.velocity.x;
717
718 break;
719
720 case _ENTITY_JUMP_VELOCITY_Y:
721
722 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
723 (*pretvar)->dblVal = (DOUBLE)handle->jump.velocity.y;
724
725 break;
726
727 case _ENTITY_JUMP_VELOCITY_Z:
728
729 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
730 (*pretvar)->dblVal = (DOUBLE)handle->jump.velocity.z;
731
732 break;
733
734 case _ENTITY_KNOCKDOWN_COUNT:
735
736 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
737 (*pretvar)->lVal = (LONG)handle->knockdowncount;
738
739 break;
740
741 case _ENTITY_KNOCKDOWN_TIME:
742
743 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
744 (*pretvar)->lVal = (LONG)handle->knockdowntime;
745
746 break;
747
748 case _ENTITY_LAST_DAMAGE_TYPE:
749
750 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
751 (*pretvar)->lVal = (LONG)handle->last_damage_type;
752
753 break;
754
755 case _ENTITY_LAST_HIT:
756
757 ScriptVariant_ChangeType(*pretvar, VT_PTR);
758 (*pretvar)->ptrVal = (entity *)handle->lasthit;
759
760 break;
761
762 case _ENTITY_LIFESPAN:
763
764 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
765 (*pretvar)->lVal = (LONG)handle->lifespancountdown;
766
767 break;
768
769 case _ENTITY_LINK:
770
771 ScriptVariant_ChangeType(*pretvar, VT_PTR);
772 (*pretvar)->ptrVal = (entity *)handle->link;
773
774 break;
775
776 case _ENTITY_MODEL:
777
778 ScriptVariant_ChangeType(*pretvar, VT_PTR);
779 (*pretvar)->ptrVal = (s_model *)(handle->model);
780
781 break;
782
783 case _ENTITY_MODEL_DATA:
784
785 ScriptVariant_ChangeType(*pretvar, VT_PTR);
786 (*pretvar)->ptrVal = (s_model *)&handle->modeldata;
787
788 break;
789
790 case _ENTITY_MODEL_DEFAULT:
791
792 ScriptVariant_ChangeType(*pretvar, VT_PTR);
793 (*pretvar)->ptrVal = (s_model *)(handle->defaultmodel);
794
795 break;
796
797 case _ENTITY_MOVE_TIME:
798
799 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
800 (*pretvar)->lVal = (LONG)handle->nextmove;
801
802 break;
803
804 case _ENTITY_MOVE_X:
805
806 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
807 (*pretvar)->dblVal = (DOUBLE)handle->movex;
808
809 break;
810
811 case _ENTITY_MOVE_Z:
812
813 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
814 (*pretvar)->dblVal = (DOUBLE)handle->movez;
815
816 break;
817
818 case _ENTITY_MP:
819
820 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
821 (*pretvar)->lVal = (LONG)handle->energy_state.mp_current;
822
823 break;
824
825 case _ENTITY_MP_CHARGE_TIME:
826
827 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
828 (*pretvar)->lVal = (LONG)handle->mpchargetime;
829
830 break;
831
832 case _ENTITY_MP_OLD:
833
834 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
835 (*pretvar)->lVal = (LONG)handle->energy_state.mp_old;
836
837 break;
838
839 case _ENTITY_MP_TIME:
840
841 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
842 (*pretvar)->lVal = (LONG)handle->magictime;
843
844 break;
845
846 case _ENTITY_NAME:
847
848 ScriptVariant_ChangeType(*pretvar, VT_STR);
849 (*pretvar)->strVal = StrCache_CreateNewFrom(handle->name);
850 break;
851
852 case _ENTITY_NEXT_ATTACK_TIME:
853
854 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
855 (*pretvar)->lVal = (LONG)handle->nextattack;
856
857 break;
858
859 case _ENTITY_NEXT_HIT_TIME:
860
861 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
862 (*pretvar)->lVal = (LONG)handle->next_hit_time;
863
864 break;
865
866 case _ENTITY_NOGRAB:
867
868 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
869 (*pretvar)->lVal = (LONG)handle->nograb;
870
871 break;
872
873 case _ENTITY_NOGRAB_DEFAULT:
874
875 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
876 (*pretvar)->lVal = (LONG)handle->nograb_default;
877
878 break;
879
880 case _ENTITY_OBSTRUCTED:
881
882 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
883 (*pretvar)->lVal = (LONG)handle->hitwall;
884
885 break;
886
887 case _ENTITY_OBSTRUCTION_OVERHEAD:
888
889 ScriptVariant_ChangeType(*pretvar, VT_PTR);
890 (*pretvar)->ptrVal = (entity *)handle->hithead;
891
892 break;
893
894 case _ENTITY_OFFENSE_COLLECTION:
895
896 ScriptVariant_ChangeType(*pretvar, VT_PTR);
897 (*pretvar)->ptrVal = (float *)handle->offense_factors;
898
899 break;
900
901 case _ENTITY_OPPONENT:
902
903 ScriptVariant_ChangeType(*pretvar, VT_PTR);
904 (*pretvar)->ptrVal = (entity *)handle->opponent;
905
906 break;
907
908 case _ENTITY_OWNER:
909
910 ScriptVariant_ChangeType(*pretvar, VT_PTR);
911 (*pretvar)->ptrVal = (entity *)handle->owner;
912
913 break;
914
915 case _ENTITY_PARENT:
916
917 ScriptVariant_ChangeType(*pretvar, VT_PTR);
918 (*pretvar)->ptrVal = (entity *)handle->parent;
919
920 break;
921
922 case _ENTITY_PATH_OBSTRUCTED_WAIT:
923
924 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
925 (*pretvar)->lVal = (LONG)handle->pathblocked;
926
927 break;
928
929 case _ENTITY_PAUSE_TIME:
930
931 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
932 (*pretvar)->lVal = (LONG)handle->pausetime;
933
934 break;
935
936 case _ENTITY_PLATFORM_LAND:
937
938 ScriptVariant_ChangeType(*pretvar, VT_PTR);
939 (*pretvar)->ptrVal = (entity *)handle->landed_on_platform;
940
941 break;
942
943 case _ENTITY_PLAYER_INDEX:
944
945 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
946 (*pretvar)->lVal = (LONG)handle->playerindex;
947
948 break;
949
950 case _ENTITY_POSITION_BASE:
951
952 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
953 (*pretvar)->dblVal = (DOUBLE)handle->base;
954
955 break;
956
957 case _ENTITY_POSITION_BASE_ALTERNATE:
958
959 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
960 (*pretvar)->dblVal = (DOUBLE)handle->altbase;
961
962 break;
963
964 case _ENTITY_POSITION_DIRECTION:
965
966 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
967 (*pretvar)->lVal = (LONG)handle->direction;
968
969 break;
970
971 case _ENTITY_POSITION_X:
972
973 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
974 (*pretvar)->dblVal = (DOUBLE)handle->position.x;
975
976 break;
977
978 case _ENTITY_POSITION_Y:
979
980 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
981 (*pretvar)->dblVal = (DOUBLE)handle->position.y;
982
983 break;
984
985 case _ENTITY_POSITION_Z:
986
987 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
988 (*pretvar)->dblVal = (DOUBLE)handle->position.z;
989
990 break;
991
992 case _ENTITY_PROJECTILE_PRIME:
993
994 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
995 (*pretvar)->lVal = (LONG)handle->projectile_prime;
996
997 break;
998
999 case _ENTITY_RECURSIVE_DAMAGE:
1000
1001 ScriptVariant_ChangeType(*pretvar, VT_PTR);
1002 (*pretvar)->ptrVal = (s_damage_recursive *)handle->recursive_damage;
1003
1004 break;
1005
1006 case _ENTITY_RELEASE_TIME:
1007
1008 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1009 (*pretvar)->lVal = (LONG)handle->releasetime;
1010
1011 break;
1012
1013 case _ENTITY_RISE_ATTACK_DELAY:
1014
1015 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1016 (*pretvar)->lVal = (LONG)handle->staydown.riseattack;
1017
1018 break;
1019
1020 case _ENTITY_RISE_ATTACK_TIME:
1021
1022 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1023 (*pretvar)->lVal = (LONG)handle->staydown.riseattack_stall;
1024
1025 break;
1026
1027 case _ENTITY_RISE_DELAY:
1028
1029 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1030 (*pretvar)->lVal = (LONG)handle->staydown.rise;
1031
1032 break;
1033
1034 case _ENTITY_RISE_STATE:
1035
1036 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1037 (*pretvar)->lVal = (LONG)handle->rising;
1038
1039 break;
1040
1041 case _ENTITY_RUN_STATE:
1042
1043 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1044 (*pretvar)->lVal = (LONG)handle->running;
1045
1046 break;
1047
1048 case _ENTITY_RUSH:
1049
1050 ScriptVariant_ChangeType(*pretvar, VT_PTR);
1051 (*pretvar)->ptrVal = (s_rush *)&handle->rush;
1052
1053 break;
1054
1055 case _ENTITY_SCRIPT_COLLECTION:
1056
1057 ScriptVariant_ChangeType(*pretvar, VT_PTR);
1058 (*pretvar)->ptrVal = (s_scripts *)handle->scripts;
1059
1060 break;
1061
1062 case _ENTITY_SEAL_ENERGY:
1063
1064 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1065 (*pretvar)->lVal = (LONG)handle->seal;
1066
1067 break;
1068
1069 case _ENTITY_SEAL_TIME:
1070
1071 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1072 (*pretvar)->lVal = (LONG)handle->sealtime;
1073
1074 break;
1075
1076 case _ENTITY_SLEEP_TIME:
1077
1078 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1079 (*pretvar)->lVal = (LONG)handle->sleeptime;
1080
1081 break;
1082
1083 case _ENTITY_SORT_ID:
1084
1085 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1086 (*pretvar)->lVal = (LONG)handle->sortid;
1087
1088 break;
1089
1090 case _ENTITY_SPACE_OTHER:
1091
1092 ScriptVariant_ChangeType(*pretvar, VT_PTR);
1093 (*pretvar)->ptrVal = (entity *)handle->collided_entity;
1094
1095 break;
1096
1097 case _ENTITY_SPAWN_TYPE:
1098
1099 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1100 (*pretvar)->lVal = (LONG)handle->spawntype;
1101
1102 break;
1103
1104 case _ENTITY_SPEED_MULTIPLIER:
1105
1106 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
1107 (*pretvar)->dblVal = (DOUBLE)handle->speedmul;
1108
1109 break;
1110
1111 case _ENTITY_STALL_TIME:
1112
1113 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1114 (*pretvar)->lVal = (LONG)handle->stalltime;
1115
1116 break;
1117
1118 case _ENTITY_THINK_TIME:
1119
1120 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1121 (*pretvar)->lVal = (LONG)handle->nextthink;
1122
1123 break;
1124
1125 case _ENTITY_TIMESTAMP:
1126
1127 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1128 (*pretvar)->lVal = (LONG)handle->timestamp;
1129
1130 break;
1131
1132 case _ENTITY_TO_COST:
1133
1134 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1135 (*pretvar)->lVal = (LONG)handle->tocost;
1136
1137 break;
1138
1139 case _ENTITY_TOSS_TIME:
1140
1141 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1142 (*pretvar)->lVal = (LONG)handle->toss_time;
1143
1144 break;
1145
1146 case _ENTITY_TURN_STATE:
1147
1148 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1149 (*pretvar)->lVal = (LONG)handle->turning;
1150
1151 break;
1152
1153 case _ENTITY_TURN_TIME:
1154
1155 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1156 (*pretvar)->lVal = (LONG)handle->turntime;
1157
1158 break;
1159
1160 case _ENTITY_UPDATE_MARK:
1161
1162 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1163 (*pretvar)->lVal = (LONG)handle->update_mark;
1164
1165 break;
1166
1167 case _ENTITY_VELOCITY_X:
1168
1169 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
1170 (*pretvar)->dblVal = (DOUBLE)handle->velocity.x;
1171
1172 break;
1173
1174 case _ENTITY_VELOCITY_Y:
1175
1176 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
1177 (*pretvar)->dblVal = (DOUBLE)handle->velocity.y;
1178
1179 break;
1180
1181 case _ENTITY_VELOCITY_Z:
1182
1183 ScriptVariant_ChangeType(*pretvar, VT_DECIMAL);
1184 (*pretvar)->dblVal = (DOUBLE)handle->velocity.z;
1185
1186 break;
1187
1188 case _ENTITY_WALK_STATE:
1189
1190 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1191 (*pretvar)->lVal = (LONG)handle->walking;
1192
1193 break;
1194
1195 case _ENTITY_WAYPOINT_COLLECTION:
1196
1197 ScriptVariant_ChangeType(*pretvar, VT_PTR);
1198 (*pretvar)->ptrVal = (s_axis_plane_lateral_float *)handle->waypoints;
1199
1200 break;
1201
1202 case _ENTITY_WAYPOINT_COUNT:
1203
1204 ScriptVariant_ChangeType(*pretvar, VT_INTEGER);
1205 (*pretvar)->lVal = (LONG)handle->numwaypoints;
1206
1207 break;
1208
1209 case _ENTITY_WEAPON_ITEM:
1210
1211 ScriptVariant_ChangeType(*pretvar, VT_PTR);
1212 (*pretvar)->ptrVal = (entity *)handle->weapent;
1213
1214 break;
1215
1216 default:
1217
1218 printf("Unsupported property.\n");
1219 goto error_local;
1220
1221 break;
1222 }
1223
1224 return S_OK;
1225
1226 error_local:
1227
1228 printf("You must provide a valid handle and property name: " SELF_NAME "\n");
1229 *pretvar = NULL;
1230
1231 return E_FAIL;
1232
1233 #undef SELF_NAME
1234 #undef ARG_MINIMUM
1235 #undef ARG_HANDLE
1236 #undef ARG_INDEX
1237 }
1238
1239 // Caskey, Damon V.
1240 // 2018-04-03
1241 //
1242 // Mutate an entity property. Requires
1243 // the entity handle, a string property
1244 // name, and new value.
openbor_set_entity_property(ScriptVariant ** varlist,ScriptVariant ** pretvar,int paramCount)1245 HRESULT openbor_set_entity_property(ScriptVariant **varlist, ScriptVariant **pretvar, int paramCount)
1246 {
1247 #define SELF_NAME "openbor_set_entity_property(void handle, char property, value)"
1248 #define ARG_MINIMUM 3 // Minimum required arguments.
1249 #define ARG_HANDLE 0 // Handle (pointer to property structure).
1250 #define ARG_PROPERTY 1 // Property to access.
1251 #define ARG_VALUE 2 // New value to apply.
1252
1253 int result = S_OK; // Success or error?
1254 entity *handle = NULL; // Property handle.
1255 e_entity_properties property = 0; // Property to access.
1256
1257 // Value carriers to apply on properties after
1258 // taken from argument.
1259 LONG temp_int;
1260 DOUBLE temp_float;
1261
1262 // Verify incoming arguments. There should at least
1263 // be a pointer for the property handle and an integer
1264 // to determine which property is accessed.
1265 if(paramCount < ARG_MINIMUM
1266 || varlist[ARG_HANDLE]->vt != VT_PTR
1267 || varlist[ARG_PROPERTY]->vt != VT_INTEGER)
1268 {
1269 *pretvar = NULL;
1270 goto error_local;
1271 }
1272
1273 // Populate local handle and property vars.
1274 handle = (entity *)varlist[ARG_HANDLE]->ptrVal;
1275 property = (LONG)varlist[ARG_PROPERTY]->lVal;
1276
1277 // Which property to modify?
1278 switch(property)
1279 {
1280
1281 case _ENTITY_AI_DISABLE:
1282
1283 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1284 {
1285 handle->noaicontrol = temp_int;
1286 }
1287
1288 break;
1289
1290 case _ENTITY_AI_TARGET_ENTITY:
1291
1292 handle->custom_target = (entity *)varlist[ARG_VALUE]->ptrVal;
1293
1294 break;
1295
1296 case _ENTITY_ALTERNATE_IDLE:
1297
1298 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1299 {
1300 handle->idlemode = temp_int;
1301 }
1302
1303 break;
1304
1305 case _ENTITY_ALTERNATE_WALK:
1306
1307 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1308 {
1309 handle->walkmode = temp_int;
1310 }
1311
1312 break;
1313
1314 case _ENTITY_ANIMATION:
1315
1316 handle->animation = (s_anim *)varlist[ARG_VALUE]->ptrVal;
1317
1318 break;
1319
1320 case _ENTITY_ANIMATION_FRAME:
1321
1322 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1323 {
1324 handle->animpos = temp_int;
1325 }
1326
1327 break;
1328
1329 case _ENTITY_ANIMATION_ID:
1330
1331 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1332 {
1333 handle->animnum = temp_int;
1334 }
1335
1336 break;
1337
1338 case _ENTITY_ANIMATION_ID_PREVIOUS:
1339
1340 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1341 {
1342 handle->animnum_previous = temp_int;
1343 }
1344
1345 break;
1346
1347 case _ENTITY_ANIMATION_STATE:
1348
1349 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1350 {
1351 handle->animating = temp_int;
1352 }
1353
1354 break;
1355
1356 case _ENTITY_ANIMATION_TIME:
1357
1358 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1359 {
1360 handle->nextanim = temp_int;
1361 }
1362
1363 break;
1364
1365 case _ENTITY_ARROW_STATE:
1366
1367 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1368 {
1369 handle->arrowon = temp_int;
1370 }
1371
1372 break;
1373
1374 case _ENTITY_ATTACK_ID_INCOMING:
1375
1376 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1377 {
1378 handle->attack_id_incoming = temp_int;
1379 }
1380
1381 break;
1382
1383 case _ENTITY_ATTACK_ID_OUTGOING:
1384
1385 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1386 {
1387 handle->attack_id_outgoing = temp_int;
1388 }
1389
1390 break;
1391
1392 case _ENTITY_ATTACK_STATE:
1393
1394 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1395 {
1396 handle->attacking = temp_int;
1397 }
1398
1399 break;
1400
1401 case _ENTITY_AUTOKILL:
1402
1403 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1404 {
1405 handle->autokill = temp_int;
1406 }
1407
1408 break;
1409
1410 case _ENTITY_BACK_HIT_DIRECTION:
1411
1412 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1413 {
1414 handle->normaldamageflipdir = temp_int;
1415 }
1416
1417 break;
1418
1419 case _ENTITY_BIND:
1420
1421 // Read only.
1422
1423 break;
1424
1425 case _ENTITY_BLAST_STATE:
1426
1427 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1428 {
1429 handle->projectile = temp_int;
1430 }
1431
1432 break;
1433
1434 case _ENTITY_BLINK:
1435
1436 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1437 {
1438 handle->blink = temp_int;
1439 }
1440
1441 break;
1442
1443 case _ENTITY_BLOCK_STATE:
1444
1445 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1446 {
1447 handle->blocking = temp_int;
1448 }
1449
1450 break;
1451
1452 case _ENTITY_BOSS:
1453
1454 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1455 {
1456 handle->boss = temp_int;
1457 }
1458
1459 break;
1460
1461 case _ENTITY_CHARGE_STATE:
1462
1463 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1464 {
1465 handle->charging = temp_int;
1466 }
1467
1468 break;
1469
1470 case _ENTITY_CHILD:
1471
1472 handle->subentity = (entity *)varlist[ARG_VALUE]->ptrVal;
1473
1474 break;
1475
1476 case _ENTITY_COLORSET_DEFAULT:
1477
1478 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1479 {
1480 handle->map = temp_int;
1481 }
1482
1483 break;
1484
1485 case _ENTITY_COLORSET_DYING_HEALTH_1:
1486
1487 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1488 {
1489 handle->per1 = temp_int;
1490 }
1491
1492 break;
1493
1494 case _ENTITY_COLORSET_DYING_HEALTH_2:
1495
1496 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1497 {
1498 handle->per2 = temp_int;
1499 }
1500
1501 break;
1502
1503 case _ENTITY_COLORSET_DYING_INDEX_1:
1504
1505 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1506 {
1507 handle->dying = temp_int;
1508 }
1509
1510 break;
1511
1512 case _ENTITY_COLORSET_DYING_INDEX_2:
1513
1514 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1515 {
1516 handle->dying2 = temp_int;
1517 }
1518
1519 break;
1520
1521 case _ENTITY_COLORSET_TABLE:
1522
1523 handle->colourmap = (VOID *)varlist[ARG_VALUE]->ptrVal;
1524
1525 break;
1526
1527 case _ENTITY_COLORSET_TIME:
1528
1529 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1530 {
1531 handle->maptime = temp_int;
1532 }
1533
1534 break;
1535
1536 case _ENTITY_COMBO_STEP:
1537
1538 // Read only.
1539
1540 break;
1541
1542 case _ENTITY_COMBO_TIME:
1543
1544 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1545 {
1546 handle->combotime = temp_int;
1547 }
1548
1549 break;
1550
1551 case _ENTITY_COMMAND_TIME:
1552
1553 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1554 {
1555 handle->movetime = temp_int;
1556 }
1557
1558 break;
1559
1560 case _ENTITY_DAMAGE_ON_LANDING:
1561
1562 // Read only.
1563
1564 break;
1565
1566 case _ENTITY_DEAD:
1567
1568 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1569 {
1570 handle->dead = temp_int;
1571 }
1572
1573 break;
1574
1575 case _ENTITY_DEDUCT_AMMO:
1576
1577 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1578 {
1579 handle->deduct_ammo = temp_int;
1580 }
1581
1582 break;
1583
1584 case _ENTITY_DEFENSE_COLLECTION:
1585
1586 handle->defense = (s_defense *)varlist[ARG_VALUE]->ptrVal;
1587
1588 break;
1589
1590 case _ENTITY_DESTINATION_X:
1591
1592 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
1593 {
1594 handle->destx = temp_float;
1595 }
1596
1597 break;
1598
1599 case _ENTITY_DESTINATION_Z:
1600
1601 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
1602 {
1603 handle->destz = temp_float;
1604 }
1605
1606 break;
1607
1608 case _ENTITY_DIE_ON_LANDING:
1609
1610 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1611 {
1612 handle->die_on_landing = temp_int;
1613 }
1614
1615 break;
1616
1617 case _ENTITY_DRAWMETHOD:
1618
1619 handle->drawmethod = (s_drawmethod *)varlist[ARG_VALUE]->ptrVal;
1620
1621 break;
1622
1623 case _ENTITY_DROP:
1624
1625 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1626 {
1627 handle->drop = temp_int;
1628 }
1629
1630 break;
1631
1632 case _ENTITY_DUCK_STATE:
1633
1634 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1635 {
1636 handle->ducking = temp_int;
1637 }
1638
1639 break;
1640
1641 case _ENTITY_ENTVAR_COLLECTION:
1642
1643 handle->varlist = (Varlist *)varlist[ARG_VALUE]->ptrVal;
1644
1645 break;
1646
1647 case _ENTITY_ESCAPE_COUNT:
1648
1649 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1650 {
1651 handle->escapecount = temp_int;
1652 }
1653
1654 break;
1655
1656 case _ENTITY_EXISTS:
1657
1658 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1659 {
1660 handle->exists = temp_int;
1661 }
1662
1663 break;
1664
1665 case _ENTITY_EXPLODE:
1666
1667 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1668 {
1669 handle->toexplode = temp_int;
1670 }
1671
1672 break;
1673
1674 case _ENTITY_FALL_STATE:
1675
1676 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1677 {
1678 handle->falling = temp_int;
1679 }
1680
1681 break;
1682
1683 case _ENTITY_FREEZE_STATE:
1684
1685 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1686 {
1687 handle->frozen = temp_int;
1688 }
1689
1690 break;
1691
1692 case _ENTITY_FREEZE_TIME:
1693
1694 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1695 {
1696 handle->freezetime = temp_int;
1697 }
1698
1699 break;
1700
1701 case _ENTITY_FUNCTION_TAKE_ACTION:
1702
1703 handle->takeaction = (VOID *)varlist[ARG_VALUE]->ptrVal;
1704
1705 break;
1706
1707 case _ENTITY_FUNCTION_TAKE_DAMAGE:
1708
1709 handle->takedamage = (VOID *)varlist[ARG_VALUE]->ptrVal;
1710
1711 break;
1712
1713 case _ENTITY_FUNCTION_THINK:
1714
1715 handle->think = (VOID *)varlist[ARG_VALUE]->ptrVal;
1716
1717 break;
1718
1719 case _ENTITY_FUNCTION_TRY_MOVE:
1720
1721 handle->trymove = (VOID *)varlist[ARG_VALUE]->ptrVal;
1722
1723 break;
1724
1725 case _ENTITY_GET_STATE:
1726
1727 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1728 {
1729 handle->getting = temp_int;
1730 }
1731
1732 break;
1733
1734 case _ENTITY_GRAB_TARGET:
1735
1736 handle->grabbing = (entity *)varlist[ARG_VALUE]->ptrVal;
1737
1738 break;
1739
1740 case _ENTITY_GRAB_WALK_STATE:
1741
1742 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1743 {
1744 handle->grabwalking = temp_int;
1745 }
1746
1747 break;
1748
1749 case _ENTITY_GUARD_TIME:
1750
1751 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1752 {
1753 handle->guardtime = temp_int;
1754 }
1755
1756 break;
1757
1758 case _ENTITY_HP:
1759
1760 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1761 {
1762 handle->energy_state.health_current = temp_int;
1763 }
1764
1765 break;
1766
1767 case _ENTITY_HP_OLD:
1768
1769 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1770 {
1771 handle->energy_state.health_old = temp_int;
1772 }
1773
1774 break;
1775
1776 case _ENTITY_IDLE_STATE:
1777
1778 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1779 {
1780 handle->idling = temp_int;
1781 }
1782
1783 break;
1784
1785 case _ENTITY_IN_PAIN:
1786
1787 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1788 {
1789 handle->inpain = temp_int;
1790 }
1791
1792 break;
1793
1794 case _ENTITY_IN_PAIN_BACK:
1795
1796 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1797 {
1798 handle->inbackpain = temp_int;
1799 }
1800
1801 break;
1802
1803 case _ENTITY_INVINCIBLE_STATE:
1804
1805 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1806 {
1807 handle->invincible = temp_int;
1808 }
1809
1810 break;
1811
1812 case _ENTITY_INVINCIBLE_TIME:
1813
1814 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1815 {
1816 handle->invinctime = temp_int;
1817 }
1818
1819 break;
1820
1821 case _ENTITY_ITEM_DATA:
1822
1823 // Read only.
1824
1825 break;
1826
1827 case _ENTITY_JUMP_ANIMATION_ID:
1828
1829 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1830 {
1831 handle->jump.animation_id = temp_int;
1832 }
1833
1834 break;
1835
1836 case _ENTITY_JUMP_STATE:
1837
1838 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1839 {
1840 handle->jumping = temp_int;
1841 }
1842
1843 break;
1844
1845 case _ENTITY_JUMP_VELOCITY_X:
1846
1847 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
1848 {
1849 handle->jump.velocity.x = temp_float;
1850 }
1851
1852 break;
1853
1854 case _ENTITY_JUMP_VELOCITY_Y:
1855
1856 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
1857 {
1858 handle->jump.velocity.y = temp_float;
1859 }
1860
1861 break;
1862
1863 case _ENTITY_JUMP_VELOCITY_Z:
1864
1865 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
1866 {
1867 handle->jump.velocity.z = temp_float;
1868 }
1869
1870 break;
1871
1872 case _ENTITY_KNOCKDOWN_COUNT:
1873
1874 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1875 {
1876 handle->knockdowncount = temp_int;
1877 }
1878
1879 break;
1880
1881 case _ENTITY_KNOCKDOWN_TIME:
1882
1883 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1884 {
1885 handle->knockdowntime = temp_int;
1886 }
1887
1888 break;
1889
1890 case _ENTITY_LAST_DAMAGE_TYPE:
1891
1892 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1893 {
1894 handle->last_damage_type = temp_int;
1895 }
1896
1897 break;
1898
1899 case _ENTITY_LAST_HIT:
1900
1901 handle->lasthit = (entity *)varlist[ARG_VALUE]->ptrVal;
1902
1903 break;
1904
1905 case _ENTITY_LIFESPAN:
1906
1907 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1908 {
1909 handle->lifespancountdown = temp_int;
1910 }
1911
1912 break;
1913
1914 case _ENTITY_LINK:
1915
1916 handle->link = (entity *)varlist[ARG_VALUE]->ptrVal;
1917
1918 break;
1919
1920 case _ENTITY_MODEL:
1921
1922 handle->model = (s_model *)varlist[ARG_VALUE]->ptrVal;
1923
1924 break;
1925
1926 case _ENTITY_MODEL_DATA:
1927
1928 // Read only.
1929
1930 break;
1931
1932 case _ENTITY_MODEL_DEFAULT:
1933
1934 handle->defaultmodel = (s_model *)varlist[ARG_VALUE]->ptrVal;
1935
1936 break;
1937
1938 case _ENTITY_MOVE_TIME:
1939
1940 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1941 {
1942 handle->nextmove = temp_int;
1943 }
1944
1945 break;
1946
1947 case _ENTITY_MOVE_X:
1948
1949 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
1950 {
1951 handle->movex = temp_float;
1952 }
1953
1954 break;
1955
1956 case _ENTITY_MOVE_Z:
1957
1958 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
1959 {
1960 handle->movez = temp_float;
1961 }
1962
1963 break;
1964
1965 case _ENTITY_MP:
1966
1967 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1968 {
1969 handle->energy_state.mp_current = temp_int;
1970 }
1971
1972 break;
1973
1974 case _ENTITY_MP_OLD:
1975
1976 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1977 {
1978 handle->energy_state.mp_old = temp_int;
1979 }
1980
1981 break;
1982
1983 case _ENTITY_MP_CHARGE_TIME:
1984
1985 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1986 {
1987 handle->mpchargetime = temp_int;
1988 }
1989
1990 break;
1991
1992 case _ENTITY_MP_TIME:
1993
1994 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
1995 {
1996 handle->magictime = temp_int;
1997 }
1998
1999 break;
2000
2001 case _ENTITY_NAME:
2002
2003 if (varlist[ARG_VALUE]->vt == VT_STR)
2004 {
2005 strcpy(handle->name, (char *)StrCache_Get(varlist[ARG_VALUE]->strVal));
2006 }
2007
2008 break;
2009
2010 case _ENTITY_NEXT_ATTACK_TIME:
2011
2012 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2013 {
2014 handle->nextattack = temp_int;
2015 }
2016
2017 break;
2018
2019 case _ENTITY_NEXT_HIT_TIME:
2020
2021 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2022 {
2023 handle->next_hit_time = temp_int;
2024 }
2025
2026 break;
2027
2028 case _ENTITY_NOGRAB:
2029
2030 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2031 {
2032 handle->nograb = temp_int;
2033 }
2034
2035 break;
2036
2037 case _ENTITY_NOGRAB_DEFAULT:
2038
2039 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2040 {
2041 handle->nograb_default = temp_int;
2042 }
2043
2044 break;
2045
2046 case _ENTITY_OBSTRUCTED:
2047
2048 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2049 {
2050 handle->hitwall = temp_int;
2051 }
2052
2053 break;
2054
2055 case _ENTITY_OBSTRUCTION_OVERHEAD:
2056
2057 handle->hithead = (entity *)varlist[ARG_VALUE]->ptrVal;
2058
2059 break;
2060
2061 case _ENTITY_OFFENSE_COLLECTION:
2062
2063 handle->offense_factors = (float *)varlist[ARG_VALUE]->ptrVal;
2064
2065 break;
2066
2067 case _ENTITY_OPPONENT:
2068
2069 handle->opponent = (entity *)varlist[ARG_VALUE]->ptrVal;
2070
2071 break;
2072
2073 case _ENTITY_OWNER:
2074
2075 handle->owner = (entity *)varlist[ARG_VALUE]->ptrVal;
2076
2077 break;
2078
2079 case _ENTITY_PARENT:
2080
2081 handle->parent = (entity *)varlist[ARG_VALUE]->ptrVal;
2082
2083 break;
2084
2085 case _ENTITY_PATH_OBSTRUCTED_WAIT:
2086
2087 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2088 {
2089 handle->pathblocked = temp_int;
2090 }
2091
2092 break;
2093
2094 case _ENTITY_PAUSE_TIME:
2095
2096 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2097 {
2098 handle->pausetime = temp_int;
2099 }
2100
2101 break;
2102
2103 case _ENTITY_PLATFORM_LAND:
2104
2105 handle->parent = (entity *)varlist[ARG_VALUE]->ptrVal;
2106
2107 break;
2108
2109 case _ENTITY_PLAYER_INDEX:
2110
2111 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2112 {
2113 handle->playerindex = temp_int;
2114 }
2115
2116 break;
2117
2118 case _ENTITY_POSITION_BASE:
2119
2120 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2121 {
2122 handle->base = temp_float;
2123 }
2124
2125 break;
2126
2127 case _ENTITY_POSITION_BASE_ALTERNATE:
2128
2129 if(SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2130 {
2131 handle->altbase = temp_float;
2132 }
2133
2134 break;
2135
2136 case _ENTITY_POSITION_DIRECTION:
2137
2138 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2139 {
2140 handle->direction = temp_int;
2141 }
2142
2143 break;
2144
2145 case _ENTITY_POSITION_X:
2146
2147 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2148 {
2149 handle->position.x = temp_float;
2150 }
2151
2152 break;
2153
2154 case _ENTITY_POSITION_Y:
2155
2156 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2157 {
2158 handle->position.y = temp_float;
2159 }
2160
2161 break;
2162
2163 case _ENTITY_POSITION_Z:
2164
2165 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2166 {
2167 handle->position.z = temp_float;
2168 }
2169
2170 break;
2171
2172 case _ENTITY_PROJECTILE_PRIME:
2173
2174 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2175 {
2176 handle->projectile_prime = temp_int;
2177 }
2178
2179 break;
2180
2181 case _ENTITY_RECURSIVE_DAMAGE:
2182
2183 handle->recursive_damage = (s_damage_recursive *)varlist[ARG_VALUE]->ptrVal;
2184
2185 break;
2186
2187 case _ENTITY_RELEASE_TIME:
2188
2189 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2190 {
2191 handle->releasetime = temp_int;
2192 }
2193
2194 break;
2195
2196 case _ENTITY_RISE_ATTACK_DELAY:
2197
2198 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2199 {
2200 handle->staydown.riseattack = temp_int;
2201 }
2202
2203 break;
2204
2205 case _ENTITY_RISE_ATTACK_TIME:
2206
2207 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2208 {
2209 handle->staydown.riseattack_stall = temp_int;
2210 }
2211
2212 break;
2213
2214 case _ENTITY_RISE_DELAY:
2215
2216 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2217 {
2218 handle->staydown.rise = temp_int;
2219 }
2220
2221 break;
2222
2223 case _ENTITY_RISE_STATE:
2224
2225 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2226 {
2227 handle->rising = temp_int;
2228 }
2229
2230 break;
2231
2232 case _ENTITY_RUN_STATE:
2233
2234 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2235 {
2236 handle->running = temp_int;
2237 }
2238
2239 break;
2240
2241 case _ENTITY_RUSH:
2242
2243 // Read only.
2244
2245 break;
2246
2247 case _ENTITY_SCRIPT_COLLECTION:
2248
2249 handle->scripts = (s_scripts *)varlist[ARG_VALUE]->ptrVal;
2250
2251 break;
2252
2253 case _ENTITY_SEAL_ENERGY:
2254
2255 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2256 {
2257 handle->seal = temp_int;
2258 }
2259
2260 break;
2261
2262 case _ENTITY_SEAL_TIME:
2263
2264 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2265 {
2266 handle->sealtime = temp_int;
2267 }
2268
2269 break;
2270
2271 case _ENTITY_SLEEP_TIME:
2272
2273 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2274 {
2275 handle->sleeptime = temp_int;
2276 }
2277
2278 break;
2279
2280 case _ENTITY_SORT_ID:
2281
2282 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2283 {
2284 handle->sortid = temp_int;
2285 }
2286
2287 break;
2288
2289 case _ENTITY_SPACE_OTHER:
2290
2291 handle->collided_entity = (entity *)varlist[ARG_VALUE]->ptrVal;
2292
2293 break;
2294
2295 case _ENTITY_SPAWN_TYPE:
2296
2297 if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2298 {
2299 handle->spawntype = temp_int;
2300 }
2301
2302 break;
2303
2304 case _ENTITY_SPEED_MULTIPLIER:
2305
2306 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2307 {
2308 handle->speedmul = temp_float;
2309 }
2310
2311 break;
2312
2313 case _ENTITY_STALL_TIME:
2314
2315 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2316 {
2317 handle->stalltime = temp_int;
2318 }
2319
2320 break;
2321
2322 case _ENTITY_THINK_TIME:
2323
2324 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2325 {
2326 handle->nextthink = temp_int;
2327 }
2328
2329 break;
2330
2331 case _ENTITY_TIMESTAMP:
2332
2333 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2334 {
2335 handle->timestamp = temp_int;
2336 }
2337
2338 break;
2339
2340 case _ENTITY_TO_COST:
2341
2342 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2343 {
2344 handle->tocost = temp_int;
2345 }
2346
2347 break;
2348
2349 case _ENTITY_TOSS_TIME:
2350
2351 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2352 {
2353 handle->toss_time = temp_int;
2354 }
2355
2356 break;
2357
2358 case _ENTITY_TURN_STATE:
2359
2360 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2361 {
2362 handle->turning = temp_int;
2363 }
2364
2365 break;
2366
2367 case _ENTITY_TURN_TIME:
2368
2369 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2370 {
2371 handle->turntime = temp_int;
2372 }
2373
2374 break;
2375
2376 case _ENTITY_UPDATE_MARK:
2377
2378 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2379 {
2380 handle->update_mark = temp_int;
2381 }
2382
2383 break;
2384
2385 case _ENTITY_VELOCITY_X:
2386
2387 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2388 {
2389 handle->velocity.x = temp_float;
2390 }
2391
2392 break;
2393
2394 case _ENTITY_VELOCITY_Y:
2395
2396 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2397 {
2398 handle->velocity.y = temp_float;
2399 }
2400
2401 break;
2402
2403 case _ENTITY_VELOCITY_Z:
2404
2405 if (SUCCEEDED(ScriptVariant_DecimalValue(varlist[ARG_VALUE], &temp_float)))
2406 {
2407 handle->velocity.z = temp_float;
2408 }
2409
2410 break;
2411
2412 case _ENTITY_WALK_STATE:
2413
2414 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2415 {
2416 handle->walking = temp_int;
2417 }
2418
2419 break;
2420
2421 case _ENTITY_WAYPOINT_COLLECTION:
2422
2423 // Read only.
2424
2425 break;
2426
2427 case _ENTITY_WAYPOINT_COUNT:
2428
2429 if (SUCCEEDED(ScriptVariant_IntegerValue(varlist[ARG_VALUE], &temp_int)))
2430 {
2431 handle->numwaypoints = temp_int;
2432 }
2433
2434 break;
2435
2436 case _ENTITY_WEAPON_ITEM:
2437
2438 handle->weapent = (entity *)varlist[ARG_VALUE]->ptrVal;
2439
2440 break;
2441
2442 default:
2443
2444 printf("Unsupported property.\n");
2445 goto error_local;
2446
2447 break;
2448 }
2449
2450 return result;
2451
2452 // Error trapping.
2453 error_local:
2454
2455 printf("You must provide a valid handle, property, and new value: " SELF_NAME "\n");
2456
2457 result = E_FAIL;
2458 return result;
2459
2460 #undef SELF_NAME
2461 #undef ARG_MINIMUM
2462 #undef ARG_HANDLE
2463 #undef ARG_PROPERTY
2464 #undef ARG_VALUE
2465 }
2466