CoCalc -- Script.cpp

GitHub Repository: rubberduckycooly/Sonic-1-2-2013-Decompilation
Path: blob/main/RSDKv4/Script.cpp
⁸¹⁷ views
1
#include "RetroEngine.hpp"
2
#include <cmath>
3

4
#if RETRO_USE_COMPILER
5
#if !RETRO_REV00
6
#define COMMON_SCRIPT_VAR_COUNT (34)
7
#else
8
#define COMMON_SCRIPT_VAR_COUNT (33)
9
#endif
10
#endif
11

12
#define SCRIPT_VAR_COUNT (COMMON_SCRIPT_VAR_COUNT + 0x1DF)
13
int lineID = 0;
14

15
enum ScriptVarType { VAR_ALIAS, VAR_STATICVALUE, VAR_TABLE };
16
enum ScriptVarAccessModifier { ACCESS_NONE, ACCESS_PUBLIC, ACCESS_PRIVATE };
17

18
struct ScriptVariableInfo {
19
    ScriptVariableInfo()
20
    {
21
        type   = VAR_ALIAS;
22
        access = ACCESS_NONE;
23
        StrCopy(name, "");
24
        StrCopy(value, "");
25
    }
26

27
    ScriptVariableInfo(byte type, byte access, const char *name, const char *value)
28
    {
29
        this->type   = type;
30
        this->access = access;
31
        StrCopy(this->name, name);
32
        StrCopy(this->value, value);
33
    }
34

35
    byte type;
36
    byte access;
37
    char name[0x20];
38
    char value[0x20];
39
};
40

41
struct FunctionInfo {
42
    FunctionInfo()
43
    {
44
        StrCopy(name, "");
45
        opcodeSize = 0;
46
    }
47
    FunctionInfo(const char *functionName, int opSize)
48
    {
49
        StrCopy(name, functionName);
50
        opcodeSize = opSize;
51
    }
52
    
53
#if RETRO_REV03
54
    char name[0x30];
55
#else
56
    char name[0x20];
57
#endif
58
    int opcodeSize;
59
};
60

61
#if RETRO_USE_COMPILER
62
const char variableNames[][0x20] = {
63
    // Internal Script Values
64
    "temp0",
65
    "temp1",
66
    "temp2",
67
    "temp3",
68
    "temp4",
69
    "temp5",
70
    "temp6",
71
    "temp7",
72
    "checkResult",
73
    "arrayPos0",
74
    "arrayPos1",
75
    "arrayPos2",
76
    "arrayPos3",
77
    "arrayPos4",
78
    "arrayPos5",
79
    "arrayPos6",
80
    "arrayPos7",
81
    "global",
82
    "local",
83

84
    // Object Properties
85
    "object.entityPos",
86
    "object.groupID",
87
    "object.type",
88
    "object.propertyValue",
89
    "object.xpos",
90
    "object.ypos",
91
    "object.ixpos",
92
    "object.iypos",
93
    "object.xvel",
94
    "object.yvel",
95
    "object.speed",
96
    "object.state",
97
    "object.rotation",
98
    "object.scale",
99
    "object.priority",
100
    "object.drawOrder",
101
    "object.direction",
102
    "object.inkEffect",
103
    "object.alpha",
104
    "object.frame",
105
    "object.animation",
106
    "object.prevAnimation",
107
    "object.animationSpeed",
108
    "object.animationTimer",
109
    "object.angle",
110
    "object.lookPosX",
111
    "object.lookPosY",
112
    "object.collisionMode",
113
    "object.collisionPlane",
114
    "object.controlMode",
115
    "object.controlLock",
116
    "object.pushing",
117
    "object.visible",
118
    "object.tileCollisions",
119
    "object.interaction",
120
    "object.gravity",
121
    "object.up",
122
    "object.down",
123
    "object.left",
124
    "object.right",
125
    "object.jumpPress",
126
    "object.jumpHold",
127
    "object.scrollTracking",
128
    "object.floorSensorL",
129
    "object.floorSensorC",
130
    "object.floorSensorR",
131
#if !RETRO_REV00
132
    "object.floorSensorLC",
133
    "object.floorSensorRC",
134
#endif
135
    "object.collisionLeft",
136
    "object.collisionTop",
137
    "object.collisionRight",
138
    "object.collisionBottom",
139
    "object.outOfBounds",
140
    "object.spriteSheet",
141

142
    // Object Values
143
    "object.value0",
144
    "object.value1",
145
    "object.value2",
146
    "object.value3",
147
    "object.value4",
148
    "object.value5",
149
    "object.value6",
150
    "object.value7",
151
    "object.value8",
152
    "object.value9",
153
    "object.value10",
154
    "object.value11",
155
    "object.value12",
156
    "object.value13",
157
    "object.value14",
158
    "object.value15",
159
    "object.value16",
160
    "object.value17",
161
    "object.value18",
162
    "object.value19",
163
    "object.value20",
164
    "object.value21",
165
    "object.value22",
166
    "object.value23",
167
    "object.value24",
168
    "object.value25",
169
    "object.value26",
170
    "object.value27",
171
    "object.value28",
172
    "object.value29",
173
    "object.value30",
174
    "object.value31",
175
    "object.value32",
176
    "object.value33",
177
    "object.value34",
178
    "object.value35",
179
    "object.value36",
180
    "object.value37",
181
    "object.value38",
182
    "object.value39",
183
    "object.value40",
184
    "object.value41",
185
    "object.value42",
186
    "object.value43",
187
    "object.value44",
188
    "object.value45",
189
    "object.value46",
190
    "object.value47",
191

192
    // Stage Properties
193
    "stage.state",
194
    "stage.activeList",
195
    "stage.listPos",
196
    "stage.timeEnabled",
197
    "stage.milliSeconds",
198
    "stage.seconds",
199
    "stage.minutes",
200
    "stage.actNum",
201
    "stage.pauseEnabled",
202
    "stage.listSize",
203
    "stage.newXBoundary1",
204
    "stage.newXBoundary2",
205
    "stage.newYBoundary1",
206
    "stage.newYBoundary2",
207
    "stage.curXBoundary1",
208
    "stage.curXBoundary2",
209
    "stage.curYBoundary1",
210
    "stage.curYBoundary2",
211
    "stage.deformationData0",
212
    "stage.deformationData1",
213
    "stage.deformationData2",
214
    "stage.deformationData3",
215
    "stage.waterLevel",
216
    "stage.activeLayer",
217
    "stage.midPoint",
218
    "stage.playerListPos",
219
    "stage.debugMode",
220
    "stage.entityPos",
221

222
    // Screen Properties
223
    "screen.cameraEnabled",
224
    "screen.cameraTarget",
225
    "screen.cameraStyle",
226
    "screen.cameraX",
227
    "screen.cameraY",
228
    "screen.drawListSize",
229
    "screen.xcenter",
230
    "screen.ycenter",
231
    "screen.xsize",
232
    "screen.ysize",
233
    "screen.xoffset",
234
    "screen.yoffset",
235
    "screen.shakeX",
236
    "screen.shakeY",
237
    "screen.adjustCameraY",
238

239
    "touchscreen.down",
240
    "touchscreen.xpos",
241
    "touchscreen.ypos",
242

243
    // Sound Properties
244
    "music.volume",
245
    "music.currentTrack",
246
    "music.position",
247

248
    // Input Properties
249
    "keyDown.up",
250
    "keyDown.down",
251
    "keyDown.left",
252
    "keyDown.right",
253
    "keyDown.buttonA",
254
    "keyDown.buttonB",
255
    "keyDown.buttonC",
256
    "keyDown.buttonX",
257
    "keyDown.buttonY",
258
    "keyDown.buttonZ",
259
    "keyDown.buttonL",
260
    "keyDown.buttonR",
261
    "keyDown.start",
262
    "keyDown.select",
263
    "keyPress.up",
264
    "keyPress.down",
265
    "keyPress.left",
266
    "keyPress.right",
267
    "keyPress.buttonA",
268
    "keyPress.buttonB",
269
    "keyPress.buttonC",
270
    "keyPress.buttonX",
271
    "keyPress.buttonY",
272
    "keyPress.buttonZ",
273
    "keyPress.buttonL",
274
    "keyPress.buttonR",
275
    "keyPress.start",
276
    "keyPress.select",
277

278
    // Menu Properties
279
    "menu1.selection",
280
    "menu2.selection",
281

282
    // Tile Layer Properties
283
    "tileLayer.xsize",
284
    "tileLayer.ysize",
285
    "tileLayer.type",
286
    "tileLayer.angle",
287
    "tileLayer.xpos",
288
    "tileLayer.ypos",
289
    "tileLayer.zpos",
290
    "tileLayer.parallaxFactor",
291
    "tileLayer.scrollSpeed",
292
    "tileLayer.scrollPos",
293
    "tileLayer.deformationOffset",
294
    "tileLayer.deformationOffsetW",
295
    "hParallax.parallaxFactor",
296
    "hParallax.scrollSpeed",
297
    "hParallax.scrollPos",
298
    "vParallax.parallaxFactor",
299
    "vParallax.scrollSpeed",
300
    "vParallax.scrollPos",
301

302
    // 3D Scene Properties
303
    "scene3D.vertexCount",
304
    "scene3D.faceCount",
305
    "scene3D.projectionX",
306
    "scene3D.projectionY",
307
#if !RETRO_REV00
308
    "scene3D.fogColor",
309
    "scene3D.fogStrength",
310
#endif
311

312
    "vertexBuffer.x",
313
    "vertexBuffer.y",
314
    "vertexBuffer.z",
315
    "vertexBuffer.u",
316
    "vertexBuffer.v",
317

318
    "faceBuffer.a",
319
    "faceBuffer.b",
320
    "faceBuffer.c",
321
    "faceBuffer.d",
322
    "faceBuffer.flag",
323
    "faceBuffer.color",
324

325
    "saveRAM",
326
    "engine.state",
327
#if RETRO_REV00
328
    "engine.message",
329
#endif
330
    "engine.language",
331
    "engine.onlineActive",
332
    "engine.sfxVolume",
333
    "engine.bgmVolume",
334
#if RETRO_REV00
335
    "engine.platformID",
336
#endif
337
    "engine.trialMode",
338
#if !RETRO_REV00
339
    "engine.deviceType",
340
#endif
341

342
// Extras
343
#if RETRO_REV03
344
    "screen.currentID",
345
    "camera.enabled",
346
    "camera.target",
347
    "camera.style",
348
    "camera.xpos",
349
    "camera.ypos",
350
    "camera.adjustY",
351
#endif
352

353
// Haptics
354
#if RETRO_USE_HAPTICS
355
    "engine.hapticsEnabled",
356
#endif
357
};
358
#endif
359

360
const FunctionInfo functions[] = {
361
    FunctionInfo("End", 0),      // End of Script
362
    FunctionInfo("Equal", 2),    // Equal
363
    FunctionInfo("Add", 2),      // Add
364
    FunctionInfo("Sub", 2),      // Subtract
365
    FunctionInfo("Inc", 1),      // Increment
366
    FunctionInfo("Dec", 1),      // Decrement
367
    FunctionInfo("Mul", 2),      // Multiply
368
    FunctionInfo("Div", 2),      // Divide
369
    FunctionInfo("ShR", 2),      // Bit Shift Right
370
    FunctionInfo("ShL", 2),      // Bit Shift Left
371
    FunctionInfo("And", 2),      // Bitwise And
372
    FunctionInfo("Or", 2),       // Bitwise Or
373
    FunctionInfo("Xor", 2),      // Bitwise Xor
374
    FunctionInfo("Mod", 2),      // Mod
375
    FunctionInfo("FlipSign", 1), // Flips the Sign of the value
376

377
    FunctionInfo("CheckEqual", 2),    // compare a=b, return result in CheckResult Variable
378
    FunctionInfo("CheckGreater", 2),  // compare a>b, return result in CheckResult Variable
379
    FunctionInfo("CheckLower", 2),    // compare a<b, return result in CheckResult Variable
380
    FunctionInfo("CheckNotEqual", 2), // compare a!=b, return result in CheckResult Variable
381

382
    FunctionInfo("IfEqual", 3),          // compare a=b, jump if condition met
383
    FunctionInfo("IfGreater", 3),        // compare a>b, jump if condition met
384
    FunctionInfo("IfGreaterOrEqual", 3), // compare a>=b, jump if condition met
385
    FunctionInfo("IfLower", 3),          // compare a<b, jump if condition met
386
    FunctionInfo("IfLowerOrEqual", 3),   // compare a<=b, jump if condition met
387
    FunctionInfo("IfNotEqual", 3),       // compare a!=b, jump if condition met
388
    FunctionInfo("else", 0),             // The else for an if statement
389
    FunctionInfo("endif", 0),            // The end if
390

391
    FunctionInfo("WEqual", 3),          // compare a=b, loop if condition met
392
    FunctionInfo("WGreater", 3),        // compare a>b, loop if condition met
393
    FunctionInfo("WGreaterOrEqual", 3), // compare a>=b, loop if condition met
394
    FunctionInfo("WLower", 3),          // compare a<b, loop if condition met
395
    FunctionInfo("WLowerOrEqual", 3),   // compare a<=b, loop if condition met
396
    FunctionInfo("WNotEqual", 3),       // compare a!=b, loop if condition met
397
    FunctionInfo("loop", 0),            // While Loop marker
398

399
    FunctionInfo("ForEachActive", 3), // foreach loop, iterates through object group lists only if they are active and interaction is true
400
    FunctionInfo("ForEachAll", 3),    // foreach loop, iterates through objects matching type
401
    FunctionInfo("next", 0),          // foreach loop, next marker
402

403
    FunctionInfo("switch", 2),    // Switch Statement
404
    FunctionInfo("break", 0),     // break
405
    FunctionInfo("endswitch", 0), // endswitch
406

407
    // Math Functions
408
    FunctionInfo("Rand", 2),
409
    FunctionInfo("Sin", 2),
410
    FunctionInfo("Cos", 2),
411
    FunctionInfo("Sin256", 2),
412
    FunctionInfo("Cos256", 2),
413
    FunctionInfo("ATan2", 3),
414
    FunctionInfo("Interpolate", 4),
415
    FunctionInfo("InterpolateXY", 7),
416

417
    // Graphics Functions
418
    FunctionInfo("LoadSpriteSheet", 1),
419
    FunctionInfo("RemoveSpriteSheet", 1),
420
    FunctionInfo("DrawSprite", 1),
421
    FunctionInfo("DrawSpriteXY", 3),
422
    FunctionInfo("DrawSpriteScreenXY", 3),
423
    FunctionInfo("DrawTintRect", 4),
424
    FunctionInfo("DrawNumbers", 7),
425
    FunctionInfo("DrawActName", 7),
426
    FunctionInfo("DrawMenu", 3),
427
    FunctionInfo("SpriteFrame", 6),
428
    FunctionInfo("EditFrame", 7),
429
    FunctionInfo("LoadPalette", 5),
430
    FunctionInfo("RotatePalette", 4),
431
    FunctionInfo("SetScreenFade", 4),
432
    FunctionInfo("SetActivePalette", 3),
433
#if RETRO_REV00
434
    FunctionInfo("SetPaletteFade", 7),
435
#else
436
    FunctionInfo("SetPaletteFade", 6),
437
#endif
438
    FunctionInfo("SetPaletteEntry", 3),
439
    FunctionInfo("GetPaletteEntry", 3),
440
    FunctionInfo("CopyPalette", 5),
441
    FunctionInfo("ClearScreen", 1),
442
    FunctionInfo("DrawSpriteFX", 4),
443
    FunctionInfo("DrawSpriteScreenFX", 4),
444

445
    // More Useful Stuff
446
    FunctionInfo("LoadAnimation", 1),
447
    FunctionInfo("SetupMenu", 4),
448
    FunctionInfo("AddMenuEntry", 3),
449
    FunctionInfo("EditMenuEntry", 4),
450
    FunctionInfo("LoadStage", 0),
451
    FunctionInfo("DrawRect", 8),
452
    FunctionInfo("ResetObjectEntity", 5),
453
    FunctionInfo("BoxCollisionTest", 11),
454
    FunctionInfo("CreateTempObject", 4),
455

456
    // Player and Animation Functions
457
    FunctionInfo("ProcessObjectMovement", 0),
458
    FunctionInfo("ProcessObjectControl", 0),
459
    FunctionInfo("ProcessAnimation", 0),
460
    FunctionInfo("DrawObjectAnimation", 0),
461

462
    // Music
463
    FunctionInfo("SetMusicTrack", 3),
464
    FunctionInfo("PlayMusic", 1),
465
    FunctionInfo("StopMusic", 0),
466
    FunctionInfo("PauseMusic", 0),
467
    FunctionInfo("ResumeMusic", 0),
468
    FunctionInfo("SwapMusicTrack", 4),
469

470
    // Sound FX
471
    FunctionInfo("PlaySfx", 2),
472
    FunctionInfo("StopSfx", 1),
473
    FunctionInfo("SetSfxAttributes", 3),
474

475
    // More Collision Stuff
476
    FunctionInfo("ObjectTileCollision", 4),
477
    FunctionInfo("ObjectTileGrip", 4),
478

479
    // Bitwise Not
480
    FunctionInfo("Not", 1),
481

482
    // 3D Stuff
483
    FunctionInfo("Draw3DScene", 0),
484
    FunctionInfo("SetIdentityMatrix", 1),
485
    FunctionInfo("MatrixMultiply", 2),
486
    FunctionInfo("MatrixTranslateXYZ", 4),
487
    FunctionInfo("MatrixScaleXYZ", 4),
488
    FunctionInfo("MatrixRotateX", 2),
489
    FunctionInfo("MatrixRotateY", 2),
490
    FunctionInfo("MatrixRotateZ", 2),
491
    FunctionInfo("MatrixRotateXYZ", 4),
492
#if !RETRO_REV00
493
    FunctionInfo("MatrixInverse", 1),
494
#endif
495
    FunctionInfo("TransformVertices", 3),
496

497
    FunctionInfo("CallFunction", 1),
498
    FunctionInfo("return", 0),
499

500
    FunctionInfo("SetLayerDeformation", 6),
501
    FunctionInfo("CheckTouchRect", 4),
502
    FunctionInfo("GetTileLayerEntry", 4),
503
    FunctionInfo("SetTileLayerEntry", 4),
504

505
    FunctionInfo("GetBit", 3),
506
    FunctionInfo("SetBit", 3),
507

508
    FunctionInfo("ClearDrawList", 1),
509
    FunctionInfo("AddDrawListEntityRef", 2),
510
    FunctionInfo("GetDrawListEntityRef", 3),
511
    FunctionInfo("SetDrawListEntityRef", 3),
512

513
    FunctionInfo("Get16x16TileInfo", 4),
514
    FunctionInfo("Set16x16TileInfo", 4),
515
    FunctionInfo("Copy16x16Tile", 2),
516
    FunctionInfo("GetAnimationByName", 2),
517
    FunctionInfo("ReadSaveRAM", 0),
518
    FunctionInfo("WriteSaveRAM", 0),
519

520
#if !RETRO_REV02
521
    FunctionInfo("LoadFontFile", 1),
522
    FunctionInfo("LoadTextFile", 3),
523
#else
524
    FunctionInfo("LoadTextFile", 2),
525
#endif
526
    FunctionInfo("GetTextInfo", 5),
527
#if !RETRO_REV02
528
    FunctionInfo("DrawText", 7),
529
#endif
530
    FunctionInfo("GetVersionNumber", 2),
531

532
    FunctionInfo("GetTableValue", 3),
533
    FunctionInfo("SetTableValue", 3),
534

535
    FunctionInfo("CheckCurrentStageFolder", 1),
536
    FunctionInfo("Abs", 1),
537

538
    FunctionInfo("CallNativeFunction", 1),
539
    FunctionInfo("CallNativeFunction2", 3),
540
    FunctionInfo("CallNativeFunction4", 5),
541

542
    FunctionInfo("SetObjectRange", 1),
543
#if RETRO_REV02
544
    FunctionInfo("GetObjectValue", 3),
545
    FunctionInfo("SetObjectValue", 3),
546
    FunctionInfo("CopyObject", 3),
547
#endif
548
    FunctionInfo("Print", 3),
549

550
#if RETRO_REV03
551
    // Extras
552
    FunctionInfo("CheckCameraProximity", 4),
553
    FunctionInfo("SetScreenCount", 1),
554
    FunctionInfo("SetScreenVertices", 5),
555
    FunctionInfo("GetInputDeviceID", 2),
556
    FunctionInfo("GetFilteredInputDeviceID", 4),
557
    FunctionInfo("GetInputDeviceType", 2),
558
    FunctionInfo("IsInputDeviceAssigned", 1),
559
    FunctionInfo("AssignInputSlotToDevice", 2),
560
    FunctionInfo("IsInputSlotAssigned", 1),
561
    FunctionInfo("ResetInputSlotAssignments", 0),
562
#endif
563
};
564

565
#if RETRO_USE_COMPILER
566

567
int scriptValueListCount = 0;
568
// clang-format off
569
ScriptVariableInfo scriptValueList[SCRIPT_VAR_COUNT] = {
570
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "true", "1"),
571
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "false", "0"),
572
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "FX_SCALE", "0"),
573
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "FX_ROTATE", "1"),
574
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "FX_ROTOZOOM", "2"),
575
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "FX_INK", "3"),
576
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "PRESENTATION_STAGE", "0"),
577
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "REGULAR_STAGE", "1"),
578
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "BONUS_STAGE", "2"),
579
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "SPECIAL_STAGE", "3"),
580
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "MENU_1", "0"),
581
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "MENU_2", "1"),
582
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "C_TOUCH", "0"),
583
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "C_SOLID", "1"),
584
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "C_SOLID2", "2"),
585
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "C_PLATFORM", "3"),
586
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "C_BOX", "65536"),
587
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "MAT_WORLD", "0"),
588
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "MAT_VIEW", "1"),
589
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "MAT_TEMP", "2"),
590
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "FX_FLIP", "5"),
591
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "FACING_LEFT", "1"),
592
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "FACING_RIGHT", "0"),
593
#if !RETRO_REV00
594
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "STAGE_2P_MODE", "4"),
595
#endif
596
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "STAGE_FROZEN", "3"),
597
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "STAGE_PAUSED", "2"),
598
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "STAGE_RUNNING", "1"),
599
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "RESET_GAME", "2"),
600
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "STANDARD", "0"),
601
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "MOBILE", "1"),
602
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "DEVICE_XBOX", "2"),
603
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "DEVICE_PSN", "3"),
604
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "DEVICE_IOS", "4"),
605
    ScriptVariableInfo(VAR_ALIAS, ACCESS_PUBLIC, "DEVICE_ANDROID", "5"),
606
};
607
// clang-format on
608

609
const char scriptEvaluationTokens[][0x4] = { "=",  "+=", "-=", "++", "--", "*=", "/=", ">>=", "<<=", "&=",
610
                                             "|=", "^=", "%=", "==", ">",  ">=", "<",  "<=",  "!=" };
611

612
enum ScriptReadModes { READMODE_NORMAL = 0, READMODE_STRING = 1, READMODE_COMMENTLINE = 2, READMODE_ENDLINE = 3, READMODE_EOF = 4 };
613
enum ScriptParseModes {
614
    PARSEMODE_SCOPELESS    = 0,
615
    PARSEMODE_PLATFORMSKIP = 1,
616
    PARSEMODE_FUNCTION     = 2,
617
    PARSEMODE_SWITCHREAD   = 3,
618
    PARSEMODE_TABLEREAD    = 4,
619
    PARSEMODE_ERROR        = 0xFF
620
};
621
#endif
622

623
enum ScriptVarTypes { SCRIPTVAR_VAR = 1, SCRIPTVAR_INTCONST = 2, SCRIPTVAR_STRCONST = 3 };
624
enum ScriptVarArrTypes { VARARR_NONE = 0, VARARR_ARRAY = 1, VARARR_ENTNOPLUS1 = 2, VARARR_ENTNOMINUS1 = 3 };
625

626
enum ScrVar {
627
    VAR_TEMP0,
628
    VAR_TEMP1,
629
    VAR_TEMP2,
630
    VAR_TEMP3,
631
    VAR_TEMP4,
632
    VAR_TEMP5,
633
    VAR_TEMP6,
634
    VAR_TEMP7,
635
    VAR_CHECKRESULT,
636
    VAR_ARRAYPOS0,
637
    VAR_ARRAYPOS1,
638
    VAR_ARRAYPOS2,
639
    VAR_ARRAYPOS3,
640
    VAR_ARRAYPOS4,
641
    VAR_ARRAYPOS5,
642
    VAR_ARRAYPOS6,
643
    VAR_ARRAYPOS7,
644
    VAR_GLOBAL,
645
    VAR_LOCAL,
646
    VAR_OBJECTENTITYPOS,
647
    VAR_OBJECTGROUPID,
648
    VAR_OBJECTTYPE,
649
    VAR_OBJECTPROPERTYVALUE,
650
    VAR_OBJECTXPOS,
651
    VAR_OBJECTYPOS,
652
    VAR_OBJECTIXPOS,
653
    VAR_OBJECTIYPOS,
654
    VAR_OBJECTXVEL,
655
    VAR_OBJECTYVEL,
656
    VAR_OBJECTSPEED,
657
    VAR_OBJECTSTATE,
658
    VAR_OBJECTROTATION,
659
    VAR_OBJECTSCALE,
660
    VAR_OBJECTPRIORITY,
661
    VAR_OBJECTDRAWORDER,
662
    VAR_OBJECTDIRECTION,
663
    VAR_OBJECTINKEFFECT,
664
    VAR_OBJECTALPHA,
665
    VAR_OBJECTFRAME,
666
    VAR_OBJECTANIMATION,
667
    VAR_OBJECTPREVANIMATION,
668
    VAR_OBJECTANIMATIONSPEED,
669
    VAR_OBJECTANIMATIONTIMER,
670
    VAR_OBJECTANGLE,
671
    VAR_OBJECTLOOKPOSX,
672
    VAR_OBJECTLOOKPOSY,
673
    VAR_OBJECTCOLLISIONMODE,
674
    VAR_OBJECTCOLLISIONPLANE,
675
    VAR_OBJECTCONTROLMODE,
676
    VAR_OBJECTCONTROLLOCK,
677
    VAR_OBJECTPUSHING,
678
    VAR_OBJECTVISIBLE,
679
    VAR_OBJECTTILECOLLISIONS,
680
    VAR_OBJECTINTERACTION,
681
    VAR_OBJECTGRAVITY,
682
    VAR_OBJECTUP,
683
    VAR_OBJECTDOWN,
684
    VAR_OBJECTLEFT,
685
    VAR_OBJECTRIGHT,
686
    VAR_OBJECTJUMPPRESS,
687
    VAR_OBJECTJUMPHOLD,
688
    VAR_OBJECTSCROLLTRACKING,
689
    VAR_OBJECTFLOORSENSORL,
690
    VAR_OBJECTFLOORSENSORC,
691
    VAR_OBJECTFLOORSENSORR,
692
#if !RETRO_REV00
693
    VAR_OBJECTFLOORSENSORLC,
694
    VAR_OBJECTFLOORSENSORRC,
695
#endif
696
    VAR_OBJECTCOLLISIONLEFT,
697
    VAR_OBJECTCOLLISIONTOP,
698
    VAR_OBJECTCOLLISIONRIGHT,
699
    VAR_OBJECTCOLLISIONBOTTOM,
700
    VAR_OBJECTOUTOFBOUNDS,
701
    VAR_OBJECTSPRITESHEET,
702
    VAR_OBJECTVALUE0,
703
    VAR_OBJECTVALUE1,
704
    VAR_OBJECTVALUE2,
705
    VAR_OBJECTVALUE3,
706
    VAR_OBJECTVALUE4,
707
    VAR_OBJECTVALUE5,
708
    VAR_OBJECTVALUE6,
709
    VAR_OBJECTVALUE7,
710
    VAR_OBJECTVALUE8,
711
    VAR_OBJECTVALUE9,
712
    VAR_OBJECTVALUE10,
713
    VAR_OBJECTVALUE11,
714
    VAR_OBJECTVALUE12,
715
    VAR_OBJECTVALUE13,
716
    VAR_OBJECTVALUE14,
717
    VAR_OBJECTVALUE15,
718
    VAR_OBJECTVALUE16,
719
    VAR_OBJECTVALUE17,
720
    VAR_OBJECTVALUE18,
721
    VAR_OBJECTVALUE19,
722
    VAR_OBJECTVALUE20,
723
    VAR_OBJECTVALUE21,
724
    VAR_OBJECTVALUE22,
725
    VAR_OBJECTVALUE23,
726
    VAR_OBJECTVALUE24,
727
    VAR_OBJECTVALUE25,
728
    VAR_OBJECTVALUE26,
729
    VAR_OBJECTVALUE27,
730
    VAR_OBJECTVALUE28,
731
    VAR_OBJECTVALUE29,
732
    VAR_OBJECTVALUE30,
733
    VAR_OBJECTVALUE31,
734
    VAR_OBJECTVALUE32,
735
    VAR_OBJECTVALUE33,
736
    VAR_OBJECTVALUE34,
737
    VAR_OBJECTVALUE35,
738
    VAR_OBJECTVALUE36,
739
    VAR_OBJECTVALUE37,
740
    VAR_OBJECTVALUE38,
741
    VAR_OBJECTVALUE39,
742
    VAR_OBJECTVALUE40,
743
    VAR_OBJECTVALUE41,
744
    VAR_OBJECTVALUE42,
745
    VAR_OBJECTVALUE43,
746
    VAR_OBJECTVALUE44,
747
    VAR_OBJECTVALUE45,
748
    VAR_OBJECTVALUE46,
749
    VAR_OBJECTVALUE47,
750
    VAR_STAGESTATE,
751
    VAR_STAGEACTIVELIST,
752
    VAR_STAGELISTPOS,
753
    VAR_STAGETIMEENABLED,
754
    VAR_STAGEMILLISECONDS,
755
    VAR_STAGESECONDS,
756
    VAR_STAGEMINUTES,
757
    VAR_STAGEACTNUM,
758
    VAR_STAGEPAUSEENABLED,
759
    VAR_STAGELISTSIZE,
760
    VAR_STAGENEWXBOUNDARY1,
761
    VAR_STAGENEWXBOUNDARY2,
762
    VAR_STAGENEWYBOUNDARY1,
763
    VAR_STAGENEWYBOUNDARY2,
764
    VAR_STAGECURXBOUNDARY1,
765
    VAR_STAGECURXBOUNDARY2,
766
    VAR_STAGECURYBOUNDARY1,
767
    VAR_STAGECURYBOUNDARY2,
768
    VAR_STAGEDEFORMATIONDATA0,
769
    VAR_STAGEDEFORMATIONDATA1,
770
    VAR_STAGEDEFORMATIONDATA2,
771
    VAR_STAGEDEFORMATIONDATA3,
772
    VAR_STAGEWATERLEVEL,
773
    VAR_STAGEACTIVELAYER,
774
    VAR_STAGEMIDPOINT,
775
    VAR_STAGEPLAYERLISTPOS,
776
    VAR_STAGEDEBUGMODE,
777
    VAR_STAGEENTITYPOS,
778
    VAR_SCREENCAMERAENABLED,
779
    VAR_SCREENCAMERATARGET,
780
    VAR_SCREENCAMERASTYLE,
781
    VAR_SCREENCAMERAX,
782
    VAR_SCREENCAMERAY,
783
    VAR_SCREENDRAWLISTSIZE,
784
    VAR_SCREENXCENTER,
785
    VAR_SCREENYCENTER,
786
    VAR_SCREENXSIZE,
787
    VAR_SCREENYSIZE,
788
    VAR_SCREENXOFFSET,
789
    VAR_SCREENYOFFSET,
790
    VAR_SCREENSHAKEX,
791
    VAR_SCREENSHAKEY,
792
    VAR_SCREENADJUSTCAMERAY,
793
    VAR_TOUCHSCREENDOWN,
794
    VAR_TOUCHSCREENXPOS,
795
    VAR_TOUCHSCREENYPOS,
796
    VAR_MUSICVOLUME,
797
    VAR_MUSICCURRENTTRACK,
798
    VAR_MUSICPOSITION,
799
    VAR_KEYDOWNUP,
800
    VAR_KEYDOWNDOWN,
801
    VAR_KEYDOWNLEFT,
802
    VAR_KEYDOWNRIGHT,
803
    VAR_KEYDOWNBUTTONA,
804
    VAR_KEYDOWNBUTTONB,
805
    VAR_KEYDOWNBUTTONC,
806
    VAR_KEYDOWNBUTTONX,
807
    VAR_KEYDOWNBUTTONY,
808
    VAR_KEYDOWNBUTTONZ,
809
    VAR_KEYDOWNBUTTONL,
810
    VAR_KEYDOWNBUTTONR,
811
    VAR_KEYDOWNSTART,
812
    VAR_KEYDOWNSELECT,
813
    VAR_KEYPRESSUP,
814
    VAR_KEYPRESSDOWN,
815
    VAR_KEYPRESSLEFT,
816
    VAR_KEYPRESSRIGHT,
817
    VAR_KEYPRESSBUTTONA,
818
    VAR_KEYPRESSBUTTONB,
819
    VAR_KEYPRESSBUTTONC,
820
    VAR_KEYPRESSBUTTONX,
821
    VAR_KEYPRESSBUTTONY,
822
    VAR_KEYPRESSBUTTONZ,
823
    VAR_KEYPRESSBUTTONL,
824
    VAR_KEYPRESSBUTTONR,
825
    VAR_KEYPRESSSTART,
826
    VAR_KEYPRESSSELECT,
827
    VAR_MENU1SELECTION,
828
    VAR_MENU2SELECTION,
829
    VAR_TILELAYERXSIZE,
830
    VAR_TILELAYERYSIZE,
831
    VAR_TILELAYERTYPE,
832
    VAR_TILELAYERANGLE,
833
    VAR_TILELAYERXPOS,
834
    VAR_TILELAYERYPOS,
835
    VAR_TILELAYERZPOS,
836
    VAR_TILELAYERPARALLAXFACTOR,
837
    VAR_TILELAYERSCROLLSPEED,
838
    VAR_TILELAYERSCROLLPOS,
839
    VAR_TILELAYERDEFORMATIONOFFSET,
840
    VAR_TILELAYERDEFORMATIONOFFSETW,
841
    VAR_HPARALLAXPARALLAXFACTOR,
842
    VAR_HPARALLAXSCROLLSPEED,
843
    VAR_HPARALLAXSCROLLPOS,
844
    VAR_VPARALLAXPARALLAXFACTOR,
845
    VAR_VPARALLAXSCROLLSPEED,
846
    VAR_VPARALLAXSCROLLPOS,
847
    VAR_SCENE3DVERTEXCOUNT,
848
    VAR_SCENE3DFACECOUNT,
849
    VAR_SCENE3DPROJECTIONX,
850
    VAR_SCENE3DPROJECTIONY,
851
#if !RETRO_REV00
852
    VAR_SCENE3DFOGCOLOR,
853
    VAR_SCENE3DFOGSTRENGTH,
854
#endif
855
    VAR_VERTEXBUFFERX,
856
    VAR_VERTEXBUFFERY,
857
    VAR_VERTEXBUFFERZ,
858
    VAR_VERTEXBUFFERU,
859
    VAR_VERTEXBUFFERV,
860
    VAR_FACEBUFFERA,
861
    VAR_FACEBUFFERB,
862
    VAR_FACEBUFFERC,
863
    VAR_FACEBUFFERD,
864
    VAR_FACEBUFFERFLAG,
865
    VAR_FACEBUFFERCOLOR,
866
    VAR_SAVERAM,
867
    VAR_ENGINESTATE,
868
#if RETRO_REV00
869
    VAR_ENGINEMESSAGE,
870
#endif
871
    VAR_ENGINELANGUAGE,
872
    VAR_ENGINEONLINEACTIVE,
873
    VAR_ENGINESFXVOLUME,
874
    VAR_ENGINEBGMVOLUME,
875
#if RETRO_REV00
876
    VAR_ENGINEPLATFORMID, // v3-style device type aka Windows/Mac/Android/etc
877
#endif
878
    VAR_ENGINETRIALMODE,
879
#if !RETRO_REV00
880
    VAR_ENGINEDEVICETYPE, // v4-style device type aka Standard/Mobile/Etc
881
#endif
882

883
#if RETRO_REV03
884
    // Extras
885
    VAR_SCREENCURRENTID,
886
    VAR_CAMERAENABLED,
887
    VAR_CAMERATARGET,
888
    VAR_CAMERASTYLE,
889
    VAR_CAMERAXPOS,
890
    VAR_CAMERAYPOS,
891
    VAR_CAMERAADJUSTY,
892
#endif
893

894
#if RETRO_USE_HAPTICS
895
    VAR_HAPTICSENABLED,
896
#endif
897
    VAR_MAX_CNT
898
};
899

900
enum ScrFunc {
901
    FUNC_END,
902
    FUNC_EQUAL,
903
    FUNC_ADD,
904
    FUNC_SUB,
905
    FUNC_INC,
906
    FUNC_DEC,
907
    FUNC_MUL,
908
    FUNC_DIV,
909
    FUNC_SHR,
910
    FUNC_SHL,
911
    FUNC_AND,
912
    FUNC_OR,
913
    FUNC_XOR,
914
    FUNC_MOD,
915
    FUNC_FLIPSIGN,
916
    FUNC_CHECKEQUAL,
917
    FUNC_CHECKGREATER,
918
    FUNC_CHECKLOWER,
919
    FUNC_CHECKNOTEQUAL,
920
    FUNC_IFEQUAL,
921
    FUNC_IFGREATER,
922
    FUNC_IFGREATEROREQUAL,
923
    FUNC_IFLOWER,
924
    FUNC_IFLOWEROREQUAL,
925
    FUNC_IFNOTEQUAL,
926
    FUNC_ELSE,
927
    FUNC_ENDIF,
928
    FUNC_WEQUAL,
929
    FUNC_WGREATER,
930
    FUNC_WGREATEROREQUAL,
931
    FUNC_WLOWER,
932
    FUNC_WLOWEROREQUAL,
933
    FUNC_WNOTEQUAL,
934
    FUNC_LOOP,
935
    FUNC_FOREACHACTIVE,
936
    FUNC_FOREACHALL,
937
    FUNC_NEXT,
938
    FUNC_SWITCH,
939
    FUNC_BREAK,
940
    FUNC_ENDSWITCH,
941
    FUNC_RAND,
942
    FUNC_SIN,
943
    FUNC_COS,
944
    FUNC_SIN256,
945
    FUNC_COS256,
946
    FUNC_ATAN2,
947
    FUNC_INTERPOLATE,
948
    FUNC_INTERPOLATEXY,
949
    FUNC_LOADSPRITESHEET,
950
    FUNC_REMOVESPRITESHEET,
951
    FUNC_DRAWSPRITE,
952
    FUNC_DRAWSPRITEXY,
953
    FUNC_DRAWSPRITESCREENXY,
954
    FUNC_DRAWTINTRECT,
955
    FUNC_DRAWNUMBERS,
956
    FUNC_DRAWACTNAME,
957
    FUNC_DRAWMENU,
958
    FUNC_SPRITEFRAME,
959
    FUNC_EDITFRAME,
960
    FUNC_LOADPALETTE,
961
    FUNC_ROTATEPALETTE,
962
    FUNC_SETSCREENFADE,
963
    FUNC_SETACTIVEPALETTE,
964
    FUNC_SETPALETTEFADE,
965
    FUNC_SETPALETTEENTRY,
966
    FUNC_GETPALETTEENTRY,
967
    FUNC_COPYPALETTE,
968
    FUNC_CLEARSCREEN,
969
    FUNC_DRAWSPRITEFX,
970
    FUNC_DRAWSPRITESCREENFX,
971
    FUNC_LOADANIMATION,
972
    FUNC_SETUPMENU,
973
    FUNC_ADDMENUENTRY,
974
    FUNC_EDITMENUENTRY,
975
    FUNC_LOADSTAGE,
976
    FUNC_DRAWRECT,
977
    FUNC_RESETOBJECTENTITY,
978
    FUNC_BOXCOLLISIONTEST,
979
    FUNC_CREATETEMPOBJECT,
980
    FUNC_PROCESSOBJECTMOVEMENT,
981
    FUNC_PROCESSOBJECTCONTROL,
982
    FUNC_PROCESSANIMATION,
983
    FUNC_DRAWOBJECTANIMATION,
984
    FUNC_SETMUSICTRACK,
985
    FUNC_PLAYMUSIC,
986
    FUNC_STOPMUSIC,
987
    FUNC_PAUSEMUSIC,
988
    FUNC_RESUMEMUSIC,
989
    FUNC_SWAPMUSICTRACK,
990
    FUNC_PLAYSFX,
991
    FUNC_STOPSFX,
992
    FUNC_SETSFXATTRIBUTES,
993
    FUNC_OBJECTTILECOLLISION,
994
    FUNC_OBJECTTILEGRIP,
995
    FUNC_NOT,
996
    FUNC_DRAW3DSCENE,
997
    FUNC_SETIDENTITYMATRIX,
998
    FUNC_MATRIXMULTIPLY,
999
    FUNC_MATRIXTRANSLATEXYZ,
1000
    FUNC_MATRIXSCALEXYZ,
1001
    FUNC_MATRIXROTATEX,
1002
    FUNC_MATRIXROTATEY,
1003
    FUNC_MATRIXROTATEZ,
1004
    FUNC_MATRIXROTATEXYZ,
1005
#if !RETRO_REV00
1006
    FUNC_MATRIXINVERSE,
1007
#endif
1008
    FUNC_TRANSFORMVERTICES,
1009
    FUNC_CALLFUNCTION,
1010
    FUNC_RETURN,
1011
    FUNC_SETLAYERDEFORMATION,
1012
    FUNC_CHECKTOUCHRECT,
1013
    FUNC_GETTILELAYERENTRY,
1014
    FUNC_SETTILELAYERENTRY,
1015
    FUNC_GETBIT,
1016
    FUNC_SETBIT,
1017
    FUNC_CLEARDRAWLIST,
1018
    FUNC_ADDDRAWLISTENTITYREF,
1019
    FUNC_GETDRAWLISTENTITYREF,
1020
    FUNC_SETDRAWLISTENTITYREF,
1021
    FUNC_GET16X16TILEINFO,
1022
    FUNC_SET16X16TILEINFO,
1023
    FUNC_COPY16X16TILE,
1024
    FUNC_GETANIMATIONBYNAME,
1025
    FUNC_READSAVERAM,
1026
    FUNC_WRITESAVERAM,
1027
#if !RETRO_REV02
1028
    FUNC_LOADTEXTFONT,
1029
#endif
1030
    FUNC_LOADTEXTFILE,
1031
    FUNC_GETTEXTINFO,
1032
#if !RETRO_REV02
1033
    FUNC_DRAWTEXT,
1034
#endif
1035
    FUNC_GETVERSIONNUMBER,
1036
    FUNC_GETTABLEVALUE,
1037
    FUNC_SETTABLEVALUE,
1038
    FUNC_CHECKCURRENTSTAGEFOLDER,
1039
    FUNC_ABS,
1040
    FUNC_CALLNATIVEFUNCTION,
1041
    FUNC_CALLNATIVEFUNCTION2,
1042
    FUNC_CALLNATIVEFUNCTION4,
1043
    FUNC_SETOBJECTRANGE,
1044
#if RETRO_REV02
1045
    FUNC_GETOBJECTVALUE,
1046
    FUNC_SETOBJECTVALUE,
1047
    FUNC_COPYOBJECT,
1048
#endif
1049
    FUNC_PRINT,
1050

1051
#if RETRO_REV03
1052
    // Extras
1053
    FUNC_CHECKCAMERAPROXIMITY,
1054
    FUNC_SETSCREENCOUNT,
1055
    FUNC_SETSCREENVERTICES,
1056
    FUNC_GETINPUTDEVICEID,
1057
    FUNC_GETFILTEREDINPUTDEVICEID,
1058
    FUNC_GETINPUTDEVICETYPE,
1059
    FUNC_ISINPUTDEVICEASSIGNED,
1060
    FUNC_ASSIGNINPUTSLOTTODEVICE,
1061
    FUNC_ISSLOTASSIGNED,
1062
    FUNC_RESETINPUTSLOTASSIGNMENTS,
1063
#endif
1064
    FUNC_MAX_CNT
1065
};
1066

1067
ObjectScript objectScriptList[OBJECT_COUNT];
1068
ScriptFunction scriptFunctionList[FUNCTION_COUNT];
1069
#if RETRO_USE_COMPILER
1070
int scriptFunctionCount = 0;
1071
#endif
1072

1073
int scriptCode[SCRIPTCODE_COUNT];
1074
int jumpTable[JUMPTABLE_COUNT];
1075
int jumpTableStack[JUMPSTACK_COUNT];
1076
int functionStack[FUNCSTACK_COUNT];
1077
int foreachStack[FORSTACK_COUNT];
1078

1079
int scriptCodePos     = 0;
1080
int scriptCodeOffset  = 0;
1081
int jumpTablePos      = 0;
1082
int jumpTableOffset   = 0;
1083
int jumpTableStackPos = 0;
1084
int functionStackPos  = 0;
1085
int foreachStackPos   = 0;
1086

1087
ScriptEngine scriptEng = ScriptEngine();
1088
char scriptText[0x4000];
1089

1090
#if RETRO_USE_COMPILER
1091
void CheckAliasText(char *text)
1092
{
1093
    if (FindStringToken(text, "publicalias", 1) == 0) {
1094
#if !RETRO_USE_ORIGINAL_CODE
1095
        if (scriptValueListCount >= SCRIPT_VAR_COUNT) {
1096
            SetupTextMenu(&gameMenu[0], 0);
1097
            AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
1098
            AddTextMenuEntry(&gameMenu[0], " ");
1099
            AddTextMenuEntry(&gameMenu[0], "TOO MANY ALIASES, STATIC");
1100
            AddTextMenuEntry(&gameMenu[0], "VALUES, AND TABLES");
1101
            Engine.gameMode = ENGINE_SCRIPTERROR;
1102
            return;
1103
        }
1104
#endif
1105

1106
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1107
        MEM_ZEROP(variable);
1108

1109
        int textStrPos = 11;
1110
        int varStrPos  = 0;
1111
        int parseMode  = 0;
1112

1113
        while (text[textStrPos]) {
1114
            switch (parseMode) {
1115
                default: break;
1116

1117
                case 0:
1118
                    if (text[textStrPos] == ':') {
1119
                        textStrPos++;
1120
                        variable->value[varStrPos] = 0;
1121
                        varStrPos                  = 0;
1122
                        parseMode                  = 1;
1123
                    }
1124
                    else {
1125
                        variable->value[varStrPos++] = text[textStrPos++];
1126
                    }
1127
                    break;
1128

1129
                case 1: variable->name[varStrPos++] = text[textStrPos++]; break;
1130
            }
1131
        }
1132

1133
        variable->access = ACCESS_PUBLIC;
1134

1135
#if !RETRO_USE_ORIGINAL_CODE
1136
        for (int v = 0; v < scriptValueListCount; ++v) {
1137
            if (StrComp(scriptValueList[v].name, variable->name))
1138
                PrintLog("WARNING: Variable Name '%s' has already been used!", variable->name);
1139
        }
1140
#endif
1141

1142
        ++scriptValueListCount;
1143
    }
1144
    else if (FindStringToken(text, "privatealias", 1) == 0) {
1145
#if !RETRO_USE_ORIGINAL_CODE
1146
        if (scriptValueListCount >= SCRIPT_VAR_COUNT) {
1147
            SetupTextMenu(&gameMenu[0], 0);
1148
            AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
1149
            AddTextMenuEntry(&gameMenu[0], " ");
1150
            AddTextMenuEntry(&gameMenu[0], "TOO MANY ALIASES, STATIC");
1151
            AddTextMenuEntry(&gameMenu[0], "VALUES, AND TABLES");
1152
            Engine.gameMode = ENGINE_SCRIPTERROR;
1153
            return;
1154
        }
1155
#endif
1156

1157
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1158
        MEM_ZEROP(variable);
1159

1160
        int textStrPos = 12;
1161
        int varStrPos  = 0;
1162
        int parseMode  = 0;
1163

1164
        while (text[textStrPos]) {
1165
            switch (parseMode) {
1166
                default: break;
1167

1168
                case 0:
1169
                    if (text[textStrPos] == ':') {
1170
                        textStrPos++;
1171
                        variable->value[varStrPos] = 0;
1172
                        varStrPos                  = 0;
1173
                        parseMode                  = 1;
1174
                    }
1175
                    else {
1176
                        variable->value[varStrPos++] = text[textStrPos++];
1177
                    }
1178
                    break;
1179

1180
                case 1: variable->name[varStrPos++] = text[textStrPos++]; break;
1181
            }
1182
        }
1183

1184
        variable->access = ACCESS_PRIVATE;
1185

1186
#if !RETRO_USE_ORIGINAL_CODE
1187
        for (int v = 0; v < scriptValueListCount; ++v) {
1188
            if (StrComp(scriptValueList[v].name, variable->name))
1189
                PrintLog("WARNING: Variable Name '%s' has already been used!", variable->name);
1190
        }
1191
#endif
1192

1193
        ++scriptValueListCount;
1194
    }
1195
}
1196
void CheckStaticText(char *text)
1197
{
1198
    if (FindStringToken(text, "publicvalue", 1) == 0) {
1199
#if !RETRO_USE_ORIGINAL_CODE
1200
        if (scriptValueListCount >= SCRIPT_VAR_COUNT) {
1201
            SetupTextMenu(&gameMenu[0], 0);
1202
            AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
1203
            AddTextMenuEntry(&gameMenu[0], " ");
1204
            AddTextMenuEntry(&gameMenu[0], "TOO MANY ALIASES, STATIC");
1205
            AddTextMenuEntry(&gameMenu[0], "VALUES, AND TABLES");
1206
            Engine.gameMode = ENGINE_SCRIPTERROR;
1207
            return;
1208
        }
1209
#endif
1210

1211
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1212
        MEM_ZEROP(variable);
1213

1214
        int textStrPos = 11;
1215
        int varStrPos  = 0;
1216
        int parseMode  = 0;
1217

1218
        StrCopy(variable->value, "0"); // default value is 0
1219
        while (text[textStrPos]) {
1220
            switch (parseMode) {
1221
                default: break;
1222

1223
                case 0:
1224
                    if (text[textStrPos] == '=') {
1225
                        textStrPos++;
1226
                        variable->name[varStrPos] = 0;
1227
                        varStrPos                 = 0;
1228
                        parseMode                 = 1;
1229
                    }
1230
                    else {
1231
                        variable->name[varStrPos++] = text[textStrPos++];
1232
                    }
1233
                    break;
1234

1235
                case 1: variable->value[varStrPos++] = text[textStrPos++]; break;
1236
            }
1237
        }
1238

1239
        variable->access = ACCESS_PUBLIC;
1240

1241
        if (!ConvertStringToInteger(variable->value, &scriptCode[scriptCodePos]))
1242
            scriptCode[scriptCodePos] = 0;
1243

1244
        StrCopy(variable->value, "local[");
1245
        AppendIntegerToString(variable->value, scriptCodePos++);
1246
        StrAdd(variable->value, "]");
1247

1248
#if !RETRO_USE_ORIGINAL_CODE
1249
        for (int v = 0; v < scriptValueListCount; ++v) {
1250
            if (StrComp(scriptValueList[v].name, variable->name))
1251
                PrintLog("WARNING: Variable Name '%s' has already been used!", variable->name);
1252
        }
1253
#endif
1254

1255
        ++scriptValueListCount;
1256
    }
1257
    else if (FindStringToken(text, "privatevalue", 1) == 0) {
1258
#if !RETRO_USE_ORIGINAL_CODE
1259
        if (scriptValueListCount >= SCRIPT_VAR_COUNT) {
1260
            SetupTextMenu(&gameMenu[0], 0);
1261
            AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
1262
            AddTextMenuEntry(&gameMenu[0], " ");
1263
            AddTextMenuEntry(&gameMenu[0], "TOO MANY ALIASES, STATIC");
1264
            AddTextMenuEntry(&gameMenu[0], "VALUES, AND TABLES");
1265
            Engine.gameMode = ENGINE_SCRIPTERROR;
1266
            return;
1267
        }
1268
#endif
1269

1270
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1271
        MEM_ZEROP(variable);
1272

1273
        int textStrPos = 12;
1274
        int varStrPos  = 0;
1275
        int parseMode  = 0;
1276

1277
        StrCopy(variable->value, "0"); // default value is 0
1278
        while (text[textStrPos]) {
1279
            switch (parseMode) {
1280
                default: break;
1281

1282
                case 0:
1283
                    if (text[textStrPos] == '=') {
1284
                        textStrPos++;
1285
                        variable->name[varStrPos] = 0;
1286
                        varStrPos                 = 0;
1287
                        parseMode                 = 1;
1288
                    }
1289
                    else {
1290
                        variable->name[varStrPos++] = text[textStrPos++];
1291
                    }
1292
                    break;
1293

1294
                case 1: variable->value[varStrPos++] = text[textStrPos++]; break;
1295
            }
1296
        }
1297

1298
        variable->access = ACCESS_PRIVATE;
1299

1300
        if (!ConvertStringToInteger(variable->value, &scriptCode[scriptCodePos]))
1301
            scriptCode[scriptCodePos] = 0;
1302

1303
        StrCopy(variable->value, "local[");
1304
        AppendIntegerToString(variable->value, scriptCodePos++);
1305
        StrAdd(variable->value, "]");
1306

1307
#if !RETRO_USE_ORIGINAL_CODE
1308
        for (int v = 0; v < scriptValueListCount; ++v) {
1309
            if (StrComp(scriptValueList[v].name, variable->name))
1310
                PrintLog("WARNING: Variable Name '%s' has already been used!", variable->name);
1311
        }
1312
#endif
1313

1314
        ++scriptValueListCount;
1315
    }
1316
}
1317
bool CheckTableText(char *text)
1318
{
1319
    bool hasValues = false;
1320

1321
    if (FindStringToken(text, "publictable", 1) == 0) {
1322
#if !RETRO_USE_ORIGINAL_CODE
1323
        if (scriptValueListCount >= SCRIPT_VAR_COUNT) {
1324
            SetupTextMenu(&gameMenu[0], 0);
1325
            AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
1326
            AddTextMenuEntry(&gameMenu[0], " ");
1327
            AddTextMenuEntry(&gameMenu[0], "TOO MANY ALIASES, STATIC");
1328
            AddTextMenuEntry(&gameMenu[0], "VALUES, AND TABLES");
1329
            Engine.gameMode = ENGINE_SCRIPTERROR;
1330
            return false;
1331
        }
1332
#endif
1333

1334
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1335
        MEM_ZEROP(variable);
1336

1337
        int textStrPos = 11;
1338
        int varStrPos  = 0;
1339

1340
        while (text[textStrPos]) {
1341
            if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1342
                variable->name[varStrPos] = 0;
1343
                textStrPos++;
1344
                break;
1345
            }
1346
            else {
1347
                variable->name[varStrPos++] = text[textStrPos++];
1348
            }
1349
        }
1350

1351
        if (FindStringToken(text, "]", 1) < 1) {
1352
            // has default values, we'll stop here and read stuff in a seperate mode
1353
            scriptCode[scriptCodePos] = 0;
1354
            StrCopy(variable->value, "");
1355
            AppendIntegerToString(variable->value, scriptCodePos);
1356
            scriptCodeOffset = scriptCodePos++;
1357
            hasValues        = true;
1358
        }
1359
        else {
1360
            // no default values, just an array size
1361

1362
            varStrPos = 0;
1363
            while (text[textStrPos]) {
1364
                if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1365
                    variable->value[varStrPos] = 0;
1366
                    textStrPos++;
1367
                    break;
1368
                }
1369
                else {
1370
                    variable->value[varStrPos++] = text[textStrPos++];
1371
                }
1372
            }
1373

1374
            // array size can be an variable (alias), how cool!
1375
            for (int v = 0; v < scriptValueListCount; ++v) {
1376
                if (StrComp(variable->value, scriptValueList[v].name))
1377
                    StrCopy(variable->value, scriptValueList[v].value);
1378
            }
1379

1380
            if (!ConvertStringToInteger(variable->value, &scriptCode[scriptCodePos])) {
1381
                scriptCode[scriptCodePos] = 1;
1382
#if !RETRO_USE_ORIGINAL_CODE
1383
                PrintLog("WARNING: Unable to parse table size!");
1384
#endif
1385
            }
1386

1387
            StrCopy(variable->value, "");
1388
            AppendIntegerToString(variable->value, scriptCodePos);
1389

1390
            int valueCount = scriptCode[scriptCodePos++];
1391
            for (int v = 0; v < valueCount; ++v) scriptCode[scriptCodePos++] = 0;
1392
        }
1393

1394
        variable->access = ACCESS_PUBLIC;
1395
        scriptValueListCount++;
1396
    }
1397
    else if (FindStringToken(text, "privatetable", 1) == 0) {
1398
#if !RETRO_USE_ORIGINAL_CODE
1399
        if (scriptValueListCount >= SCRIPT_VAR_COUNT) {
1400
            SetupTextMenu(&gameMenu[0], 0);
1401
            AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
1402
            AddTextMenuEntry(&gameMenu[0], " ");
1403
            AddTextMenuEntry(&gameMenu[0], "TOO MANY ALIASES, STATIC");
1404
            AddTextMenuEntry(&gameMenu[0], "VALUES, AND TABLES");
1405
            Engine.gameMode = ENGINE_SCRIPTERROR;
1406
            return false;
1407
        }
1408
#endif
1409

1410
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1411
        MEM_ZEROP(variable);
1412

1413
        int textStrPos = 12;
1414
        int varStrPos  = 0;
1415

1416
        while (text[textStrPos]) {
1417
            if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1418
                variable->name[varStrPos] = 0;
1419
                textStrPos++;
1420
                break;
1421
            }
1422
            else {
1423
                variable->name[varStrPos++] = text[textStrPos++];
1424
            }
1425
        }
1426

1427
        if (FindStringToken(text, "]", 1) < 1) {
1428
            // has default values, we'll stop here and read stuff in a seperate mode
1429
            scriptCode[scriptCodePos] = 0;
1430
            StrCopy(variable->value, "");
1431
            AppendIntegerToString(variable->value, scriptCodePos);
1432
            scriptCodeOffset = scriptCodePos++;
1433
            hasValues        = true;
1434
        }
1435
        else {
1436
            // no default values, just an array size
1437

1438
            varStrPos = 0;
1439
            while (text[textStrPos]) {
1440
                if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1441
                    variable->value[varStrPos] = 0;
1442
                    textStrPos++;
1443
                    break;
1444
                }
1445
                else {
1446
                    variable->value[varStrPos++] = text[textStrPos++];
1447
                }
1448
            }
1449

1450
            // array size can be an variable (alias), how cool!
1451
            for (int v = 0; v < scriptValueListCount; ++v) {
1452
                if (StrComp(variable->value, scriptValueList[v].name))
1453
                    StrCopy(variable->value, scriptValueList[v].value);
1454
            }
1455

1456
            if (!ConvertStringToInteger(variable->value, &scriptCode[scriptCodePos])) {
1457
                scriptCode[scriptCodePos] = 1;
1458
#if !RETRO_USE_ORIGINAL_CODE
1459
                PrintLog("WARNING: Unable to parse table size!");
1460
#endif
1461
            }
1462

1463
            StrCopy(variable->value, "");
1464
            AppendIntegerToString(variable->value, scriptCodePos);
1465

1466
            int valueCount = scriptCode[scriptCodePos++];
1467
            for (int v = 0; v < valueCount; ++v) scriptCode[scriptCodePos++] = 0;
1468
        }
1469

1470
        variable->access = ACCESS_PRIVATE;
1471
        scriptValueListCount++;
1472
    }
1473

1474
    return hasValues;
1475
}
1476
void ConvertArithmaticSyntax(char *text)
1477
{
1478
    int token  = 0;
1479
    int offset = 0;
1480
    int findID = 0;
1481
    char dest[260];
1482

1483
    for (int i = FUNC_EQUAL; i <= FUNC_MOD; ++i) {
1484
        findID = FindStringToken(text, scriptEvaluationTokens[i - 1], 1);
1485
        if (findID > -1) {
1486
            offset = findID;
1487
            token  = i;
1488
        }
1489
    }
1490

1491
    if (token > 0) {
1492
        StrCopy(dest, functions[token].name);
1493
        StrAdd(dest, "(");
1494
        findID = StrLength(dest);
1495
        for (int i = 0; i < offset; ++i) dest[findID++] = text[i];
1496
        if (functions[token].opcodeSize > 1) {
1497
            dest[findID] = ',';
1498
            int len      = StrLength(scriptEvaluationTokens[token - 1]);
1499
            offset += len;
1500
            ++findID;
1501
            while (text[offset]) dest[findID++] = text[offset++];
1502
        }
1503
        dest[findID] = 0;
1504
        StrAdd(dest, ")");
1505
        StrCopy(text, dest);
1506
    }
1507
}
1508
void ConvertConditionalStatement(char *text)
1509
{
1510
    char dest[260];
1511
    int compareOp  = -1;
1512
    int strPos     = 0;
1513
    int destStrPos = 0;
1514

1515
    if (FindStringToken(text, "if", 1) == 0) {
1516
        for (int i = 0; i < 6; ++i) {
1517
            destStrPos = FindStringToken(text, scriptEvaluationTokens[i + FUNC_MOD], 1);
1518
            if (destStrPos > -1) {
1519
                strPos    = destStrPos;
1520
                compareOp = i;
1521
            }
1522
        }
1523

1524
        if (compareOp > -1) {
1525
            text[strPos] = ',';
1526
            StrCopy(dest, functions[compareOp + FUNC_IFEQUAL].name);
1527
            StrAdd(dest, "(");
1528
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
1529
            StrAdd(dest, ",");
1530

1531
            destStrPos = StrLength(dest);
1532
            for (int i = 2; text[i]; ++i) {
1533
                if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1534
                    dest[destStrPos++] = text[i];
1535
            }
1536
            dest[destStrPos] = 0;
1537

1538
            StrAdd(dest, ")");
1539
            StrCopy(text, dest);
1540

1541
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1542
            jumpTable[jumpTablePos++]       = -1;
1543
            jumpTable[jumpTablePos++]       = 0;
1544
        }
1545
    }
1546
    else if (FindStringToken(text, "while", 1) == 0) {
1547
        for (int i = 0; i < 6; ++i) {
1548
            destStrPos = FindStringToken(text, scriptEvaluationTokens[i + FUNC_MOD], 1);
1549
            if (destStrPos > -1) {
1550
                strPos    = destStrPos;
1551
                compareOp = i;
1552
            }
1553
        }
1554

1555
        if (compareOp > -1) {
1556
            text[strPos] = ',';
1557
            StrCopy(dest, functions[compareOp + FUNC_WEQUAL].name);
1558
            StrAdd(dest, "(");
1559
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
1560
            StrAdd(dest, ",");
1561

1562
            destStrPos = StrLength(dest);
1563
            for (int i = 5; text[i]; ++i) {
1564
                if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1565
                    dest[destStrPos++] = text[i];
1566
            }
1567
            dest[destStrPos] = 0;
1568

1569
            StrAdd(dest, ")");
1570
            StrCopy(text, dest);
1571

1572
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1573
            jumpTable[jumpTablePos++]       = scriptCodePos - scriptCodeOffset;
1574
            jumpTable[jumpTablePos++]       = 0;
1575
        }
1576
    }
1577
    else if (FindStringToken(text, "foreach", 1) == 0) {
1578
        int argStrPos = FindStringToken(text, ",", 2);
1579

1580
        if (argStrPos > -1) {
1581
            StrCopy(dest, functions[text[argStrPos + 2] == 'C' ? (int)FUNC_FOREACHACTIVE : (int)FUNC_FOREACHALL].name);
1582
            StrAdd(dest, "(");
1583
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
1584
            StrAdd(dest, ",");
1585

1586
            destStrPos = StrLength(dest);
1587
            for (int i = 7; text[i] && i < argStrPos; ++i) {
1588
                if (text[i] != '(' && text[i] != ')')
1589
                    dest[destStrPos++] = text[i];
1590
            }
1591
            dest[destStrPos] = 0;
1592

1593
            StrAdd(dest, ")");
1594
            StrCopy(text, dest);
1595

1596
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1597
            jumpTable[jumpTablePos++]       = scriptCodePos - scriptCodeOffset;
1598
            jumpTable[jumpTablePos++]       = 0;
1599
        }
1600
    }
1601
}
1602
bool ConvertSwitchStatement(char *text)
1603
{
1604
    if (FindStringToken(text, "switch", 1) != 0)
1605
        return false;
1606

1607
    char switchText[260];
1608
    StrCopy(switchText, "switch");
1609
    StrAdd(switchText, "(");
1610
    AppendIntegerToString(switchText, jumpTablePos - jumpTableOffset);
1611
    StrAdd(switchText, ",");
1612
    int pos = StrLength(switchText);
1613
    for (int i = 6; text[i]; ++i) {
1614
        if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1615
            switchText[pos++] = text[i];
1616
    }
1617
    switchText[pos] = 0;
1618
    StrAdd(switchText, ")");
1619
    StrCopy(text, switchText);
1620
    jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1621
    jumpTable[jumpTablePos++]       = 0x10000;
1622
    jumpTable[jumpTablePos++]       = -0x10000;
1623
    jumpTable[jumpTablePos++]       = -1;
1624
    jumpTable[jumpTablePos++]       = 0;
1625

1626
    return true;
1627
}
1628
void ConvertFunctionText(char *text)
1629
{
1630
    char arrayStr[0x80];
1631
    char funcName[132];
1632

1633
    int opcode     = 0;
1634
    int opcodeSize = 0;
1635
    int textPos    = 0;
1636
    int namePos    = 0;
1637

1638
    for (namePos = 0; text[namePos] != '(' && text[namePos]; ++namePos) funcName[namePos] = text[namePos];
1639
    funcName[namePos] = 0;
1640

1641
    for (int i = 0; i < FUNC_MAX_CNT; ++i) {
1642
        if (StrComp(funcName, functions[i].name)) {
1643
            opcode     = i;
1644
            opcodeSize = functions[i].opcodeSize;
1645
            textPos    = StrLength(functions[i].name);
1646
            i          = FUNC_MAX_CNT;
1647
        }
1648
    }
1649

1650
    if (opcode <= 0) {
1651
        SetupTextMenu(&gameMenu[0], 0);
1652
        AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
1653
        AddTextMenuEntry(&gameMenu[0], " ");
1654
        AddTextMenuEntry(&gameMenu[0], "OPCODE NOT FOUND");
1655
        AddTextMenuEntry(&gameMenu[0], funcName);
1656
#if !RETRO_USE_ORIGINAL_CODE
1657
        AddTextMenuEntry(&gameMenu[0], " ");
1658
        AddTextMenuEntry(&gameMenu[0], "LINE NUMBER");
1659
        char buffer[0x10];
1660
        buffer[0] = 0;
1661
        AppendIntegerToString(buffer, lineID);
1662
        AddTextMenuEntry(&gameMenu[0], buffer);
1663
#endif
1664
        Engine.gameMode = ENGINE_SCRIPTERROR;
1665
    }
1666
    else {
1667
        scriptCode[scriptCodePos++] = opcode;
1668
        if (StrComp("else", functions[opcode].name))
1669
            jumpTable[jumpTableStack[jumpTableStackPos]] = scriptCodePos - scriptCodeOffset;
1670

1671
        if (StrComp("endif", functions[opcode].name) == 1) {
1672
            int jPos                = jumpTableStack[jumpTableStackPos];
1673
            jumpTable[jPos + 1] = scriptCodePos - scriptCodeOffset;
1674
            if (jumpTable[jPos] == -1)
1675
                jumpTable[jPos] = (scriptCodePos - scriptCodeOffset) - 1;
1676
            --jumpTableStackPos;
1677
        }
1678

1679
        if (StrComp("endswitch", functions[opcode].name)) {
1680
            int jPos                = jumpTableStack[jumpTableStackPos];
1681
            jumpTable[jPos + 3] = scriptCodePos - scriptCodeOffset;
1682
            if (jumpTable[jPos + 2] == -1) {
1683
                jumpTable[jPos + 2] = (scriptCodePos - scriptCodeOffset) - 1;
1684
                int caseCnt             = abs(jumpTable[jPos + 1] - jumpTable[jPos]) + 1;
1685

1686
                int jOffset = jPos + 4;
1687
                for (int c = 0; c < caseCnt; ++c) {
1688
                    if (jumpTable[jOffset + c] < 0)
1689
                        jumpTable[jOffset + c] = jumpTable[jPos + 2];
1690
                }
1691
            }
1692
            --jumpTableStackPos;
1693
        }
1694

1695
        if (StrComp("loop", functions[opcode].name) || StrComp("next", functions[opcode].name)) {
1696
            jumpTable[jumpTableStack[jumpTableStackPos--] + 1] = scriptCodePos - scriptCodeOffset;
1697
        }
1698

1699
        for (int i = 0; i < opcodeSize; ++i) {
1700
            ++textPos;
1701
            int funcNamePos = 0;
1702
            int mode        = 0;
1703
            int prevMode    = 0;
1704
            int arrayStrPos = 0;
1705
            while (((text[textPos] != ',' && text[textPos] != ')') || mode == 2) && text[textPos]) {
1706
                switch (mode) {
1707
                    case 0: // normal
1708
                        if (text[textPos] == '[')
1709
                            mode = 1;
1710
                        else if (text[textPos] == '"') {
1711
                            prevMode                = mode;
1712
                            mode                    = 2;
1713
                            funcName[funcNamePos++] = '"';
1714
                        }
1715
                        else
1716
                            funcName[funcNamePos++] = text[textPos];
1717
                        ++textPos;
1718
                        break;
1719

1720
                    case 1: // array val
1721
                        if (text[textPos] == ']')
1722
                            mode = 0;
1723
                        else if (text[textPos] == '"') {
1724
                            prevMode = mode;
1725
                            mode     = 2;
1726
                        }
1727
                        else
1728
                            arrayStr[arrayStrPos++] = text[textPos];
1729
                        ++textPos;
1730
                        break;
1731

1732
                    case 2: // string
1733
                        if (text[textPos] == '"') {
1734
                            mode                    = prevMode;
1735
                            funcName[funcNamePos++] = '"';
1736
                        }
1737
                        else
1738
                            funcName[funcNamePos++] = text[textPos];
1739
                        ++textPos;
1740
                        break;
1741
                }
1742
            }
1743
            funcName[funcNamePos] = 0;
1744
            arrayStr[arrayStrPos] = 0;
1745

1746
            for (int v = 0; v < scriptValueListCount; ++v) {
1747
                if (StrComp(funcName, scriptValueList[v].name)) {
1748
                    CopyAliasStr(funcName, scriptValueList[v].value, 0);
1749
                    if (FindStringToken(scriptValueList[v].value, "[", 1) > -1)
1750
                        CopyAliasStr(arrayStr, scriptValueList[v].value, 1);
1751
                }
1752
            }
1753

1754
            if (arrayStr[0]) {
1755
                char arrStrBuf[0x80];
1756
                int arrPos = 0;
1757
                int bufPos = 0;
1758
                if (arrayStr[0] == '+' || arrayStr[0] == '-')
1759
                    ++arrPos;
1760
                while (arrayStr[arrPos]) arrStrBuf[bufPos++] = arrayStr[arrPos++];
1761
                arrStrBuf[bufPos] = 0;
1762

1763
                for (int v = 0; v < scriptValueListCount; ++v) {
1764
                    if (StrComp(arrStrBuf, scriptValueList[v].name)) {
1765
                        char pref = arrayStr[0];
1766
                        CopyAliasStr(arrayStr, scriptValueList[v].value, 0);
1767

1768
                        if (pref == '+' || pref == '-') {
1769
                            int len = StrLength(arrayStr);
1770
                            for (int i = len; i >= 0; --i) arrayStr[i + 1] = arrayStr[i];
1771
                            arrayStr[0] = pref;
1772
                        }
1773
                    }
1774
                }
1775
            }
1776

1777
            // Eg: temp0 = game.variable
1778
            for (int v = 0; v < globalVariablesCount; ++v) {
1779
                if (StrComp(funcName, globalVariableNames[v])) {
1780
                    StrCopy(funcName, "global");
1781
                    arrayStr[0] = 0;
1782
                    AppendIntegerToString(arrayStr, v);
1783
                }
1784
            }
1785

1786
            // Eg: temp0 = Function1
1787
            for (int f = 0; f < scriptFunctionCount; ++f) {
1788
                if (StrComp(funcName, scriptFunctionList[f].name)) {
1789
                    funcName[0] = 0;
1790
                    AppendIntegerToString(funcName, f);
1791
                }
1792
            }
1793

1794
            // Eg: temp0 = TypeName[Player Object]
1795
            if (StrComp(funcName, "TypeName")) {
1796
                funcName[0] = '0';
1797
                funcName[1] = 0;
1798

1799
                int o = 0;
1800
                for (; o < OBJECT_COUNT; ++o) {
1801
                    if (StrComp(arrayStr, typeNames[o])) {
1802
                        funcName[0] = 0;
1803
                        AppendIntegerToString(funcName, o);
1804
                        break;
1805
                    }
1806
                }
1807

1808
                if (o == OBJECT_COUNT)
1809
                    PrintLog("WARNING: Unknown typename \"%s\", on line %d", arrayStr, lineID);
1810
            }
1811

1812
#if !RETRO_USE_ORIGINAL_CODE
1813
            // Eg: temp0 = SfxName[Jump]
1814
            if (StrComp(funcName, "SfxName")) {
1815
                funcName[0] = '0';
1816
                funcName[1] = 0;
1817

1818
                int s = 0;
1819
                for (; s < SFX_COUNT; ++s) {
1820
                    if (StrComp(arrayStr, sfxNames[s])) {
1821
                        funcName[0] = 0;
1822
                        AppendIntegerToString(funcName, s);
1823
                        break;
1824
                    }
1825
                }
1826

1827
                if (s == SFX_COUNT)
1828
                    PrintLog("WARNING: Unknown sfxName \"%s\", on line %d", arrayStr, lineID);
1829
            }
1830

1831
            // Eg: temp0 = VarName[player.lives]
1832
            if (StrComp(funcName, "VarName")) {
1833
                funcName[0] = '0';
1834
                funcName[1] = 0;
1835

1836
                int v = 0;
1837
                for (; v < globalVariablesCount; ++v) {
1838
                    if (StrComp(arrayStr, globalVariableNames[v])) {
1839
                        funcName[0] = 0;
1840
                        AppendIntegerToString(funcName, v);
1841
                        break;
1842
                    }
1843
                }
1844

1845
                if (v == globalVariablesCount)
1846
                    PrintLog("WARNING: Unknown varName \"%s\", on line %d", arrayStr, lineID);
1847
            }
1848

1849
            // Eg: temp0 = AchievementName[Ring King]
1850
            if (StrComp(funcName, "AchievementName")) {
1851
                funcName[0] = '0';
1852
                funcName[1] = 0;
1853

1854
                int a = 0;
1855
                for (; a < achievementCount; ++a) {
1856
                    char buf[0x40];
1857
                    char *str = achievements[a].name;
1858
                    int pos   = 0;
1859

1860
                    while (*str) {
1861
                        if (*str != ' ')
1862
                            buf[pos++] = *str;
1863
                        str++;
1864
                    }
1865
                    buf[pos] = 0;
1866

1867
                    if (StrComp(arrayStr, buf)) {
1868
                        funcName[0] = 0;
1869
                        AppendIntegerToString(funcName, a);
1870
                        break;
1871
                    }
1872
                }
1873

1874
                if (a == achievementCount)
1875
                    PrintLog("WARNING: Unknown AchievementName \"%s\", on line %d", arrayStr, lineID);
1876
            }
1877

1878
            // Eg: temp0 = PlayerName[SONIC]
1879
            if (StrComp(funcName, "PlayerName")) {
1880
                funcName[0] = '0';
1881
                funcName[1] = 0;
1882

1883
                int p = 0;
1884
                for (; p < PLAYER_COUNT; ++p) {
1885
                    char buf[0x40];
1886
                    char *str = playerNames[p];
1887
                    int pos   = 0;
1888

1889
                    while (*str) {
1890
                        if (*str != ' ')
1891
                            buf[pos++] = *str;
1892
                        str++;
1893
                    }
1894
                    buf[pos] = 0;
1895

1896
                    if (StrComp(arrayStr, buf)) {
1897
                        funcName[0] = 0;
1898
                        AppendIntegerToString(funcName, p);
1899
                        break;
1900
                    }
1901
                }
1902

1903
                if (p == PLAYER_COUNT)
1904
                    PrintLog("WARNING: Unknown PlayerName \"%s\", on line %d", arrayStr, lineID);
1905
            }
1906

1907
            // Eg: temp0 = StageName[R - GREEN HILL ZONE 1]
1908
            if (StrComp(funcName, "StageName")) {
1909
                funcName[0] = '0';
1910
                funcName[1] = 0;
1911

1912
                int s = -1;
1913
                if (StrLength(arrayStr) >= 2) {
1914
                    char list = arrayStr[0];
1915
                    switch (list) {
1916
                        case 'P': list = STAGELIST_PRESENTATION; break;
1917
                        case 'R': list = STAGELIST_REGULAR; break;
1918
                        case 'S': list = STAGELIST_SPECIAL; break;
1919
                        case 'B': list = STAGELIST_BONUS; break;
1920
                    }
1921
                    s = GetSceneID(list, &arrayStr[2]);
1922
                }
1923

1924
                if (s == -1) {
1925
                    char buf[0x40];
1926
                    sprintf(buf, "WARNING: Unknown StageName \"%s\", on line %d", arrayStr, lineID);
1927
                    PrintLog(buf);
1928
                    s = 0;
1929
                }
1930
                funcName[0] = 0;
1931
                AppendIntegerToString(funcName, s);
1932
            }
1933
#endif
1934

1935
            // Storing Values
1936
            int constant = 0;
1937
            if (ConvertStringToInteger(funcName, &constant)) {
1938
                scriptCode[scriptCodePos++] = SCRIPTVAR_INTCONST;
1939
                scriptCode[scriptCodePos++] = constant;
1940
            }
1941
            else if (funcName[0] == '"') {
1942
                scriptCode[scriptCodePos++] = SCRIPTVAR_STRCONST;
1943
                scriptCode[scriptCodePos++] = StrLength(funcName) - 2;
1944

1945
                int scriptTextPos = 1;
1946
                arrayStrPos       = 0;
1947
                while (scriptTextPos > -1) {
1948
                    switch (arrayStrPos) {
1949
                        case 0:
1950
                            scriptCode[scriptCodePos] = funcName[scriptTextPos] << 24;
1951
                            ++arrayStrPos;
1952
                            break;
1953

1954
                        case 1:
1955
                            scriptCode[scriptCodePos] += funcName[scriptTextPos] << 16;
1956
                            ++arrayStrPos;
1957
                            break;
1958

1959
                        case 2:
1960
                            scriptCode[scriptCodePos] += funcName[scriptTextPos] << 8;
1961
                            ++arrayStrPos;
1962
                            break;
1963

1964
                        case 3:
1965
                            scriptCode[scriptCodePos++] += funcName[scriptTextPos];
1966
                            arrayStrPos = 0;
1967
                            break;
1968

1969
                        default: break;
1970
                    }
1971

1972
                    if (funcName[scriptTextPos] == '"') {
1973
                        if (arrayStrPos > 0)
1974
                            ++scriptCodePos;
1975
                        scriptTextPos = -1;
1976
                    }
1977
                    else {
1978
                        scriptTextPos++;
1979
                    }
1980
                }
1981
            }
1982
            else {
1983
                scriptCode[scriptCodePos++] = SCRIPTVAR_VAR;
1984

1985
                if (arrayStr[0]) {
1986
                    scriptCode[scriptCodePos] = VARARR_ARRAY;
1987

1988
                    if (arrayStr[0] == '+')
1989
                        scriptCode[scriptCodePos] = VARARR_ENTNOPLUS1;
1990

1991
                    if (arrayStr[0] == '-')
1992
                        scriptCode[scriptCodePos] = VARARR_ENTNOMINUS1;
1993

1994
                    ++scriptCodePos;
1995

1996
                    if (arrayStr[0] == '-' || arrayStr[0] == '+') {
1997
                        for (int i = 0; i < StrLength(arrayStr); ++i) arrayStr[i] = arrayStr[i + 1];
1998
                    }
1999

2000
                    if (ConvertStringToInteger(arrayStr, &constant) == 1) {
2001
                        scriptCode[scriptCodePos++] = 0;
2002
                        scriptCode[scriptCodePos++] = constant;
2003
                    }
2004
                    else {
2005
                        if (StrComp(arrayStr, "arrayPos0"))
2006
                            constant = 0;
2007
                        if (StrComp(arrayStr, "arrayPos1"))
2008
                            constant = 1;
2009
                        if (StrComp(arrayStr, "arrayPos2"))
2010
                            constant = 2;
2011
                        if (StrComp(arrayStr, "arrayPos3"))
2012
                            constant = 3;
2013
                        if (StrComp(arrayStr, "arrayPos4"))
2014
                            constant = 4;
2015
                        if (StrComp(arrayStr, "arrayPos5"))
2016
                            constant = 5;
2017
                        if (StrComp(arrayStr, "arrayPos6"))
2018
                            constant = 6;
2019
                        if (StrComp(arrayStr, "arrayPos7"))
2020
                            constant = 7;
2021
                        if (StrComp(arrayStr, "tempObjectPos"))
2022
                            constant = 8;
2023

2024
                        scriptCode[scriptCodePos++] = 1;
2025
                        scriptCode[scriptCodePos++] = constant;
2026
                    }
2027
                }
2028
                else {
2029
                    scriptCode[scriptCodePos++] = VARARR_NONE;
2030
                }
2031

2032
                constant = -1;
2033
                for (int i = 0; i < VAR_MAX_CNT; ++i) {
2034
                    if (StrComp(funcName, variableNames[i]))
2035
                        constant = i;
2036
                }
2037

2038
                if (constant == -1 && Engine.gameMode != ENGINE_SCRIPTERROR) {
2039
                    SetupTextMenu(&gameMenu[0], 0);
2040
                    AddTextMenuEntry(&gameMenu[0], "SCRIPT PARSING FAILED");
2041
                    AddTextMenuEntry(&gameMenu[0], " ");
2042
                    AddTextMenuEntry(&gameMenu[0], "OPERAND NOT FOUND");
2043
                    AddTextMenuEntry(&gameMenu[0], funcName);
2044
                    AddTextMenuEntry(&gameMenu[0], " ");
2045
                    AddTextMenuEntry(&gameMenu[0], "LINE NUMBER");
2046
                    funcName[0] = 0;
2047
                    AppendIntegerToString(funcName, lineID);
2048
                    AddTextMenuEntry(&gameMenu[0], funcName);
2049
                    Engine.gameMode = ENGINE_SCRIPTERROR;
2050
                    constant        = 0;
2051
                }
2052

2053
                scriptCode[scriptCodePos++] = constant;
2054
            }
2055
        }
2056
    }
2057
}
2058
void CheckCaseNumber(char *text)
2059
{
2060
    if (FindStringToken(text, "case", 1) != 0)
2061
        return;
2062

2063
    char caseString[128];
2064
    char caseChar = text[4];
2065

2066
    int textPos    = 5;
2067
    int caseStrPos = 0;
2068
    while (caseChar) {
2069
        if (caseChar != ':')
2070
            caseString[caseStrPos++] = caseChar;
2071
        caseChar = text[textPos++];
2072
    }
2073
    caseString[caseStrPos] = 0;
2074

2075
    bool foundValue = false;
2076

2077
    if (FindStringToken(caseString, "[", 1) >= 0) {
2078
        char caseValue[0x80];
2079
        char arrayStr[0x80];
2080

2081
        int textPos     = 0;
2082
        int funcNamePos = 0;
2083
        int mode        = 0;
2084
        int arrayStrPos = 0;
2085
        while (caseString[textPos] != ':' && caseString[textPos]) {
2086
            if (mode) {
2087
                if (caseString[textPos] == ']')
2088
                    mode = 0;
2089
                else
2090
                    arrayStr[arrayStrPos++] = caseString[textPos];
2091
                ++textPos;
2092
            }
2093
            else {
2094
                if (caseString[textPos] == '[')
2095
                    mode = 1;
2096
                else
2097
                    caseValue[funcNamePos++] = caseString[textPos];
2098
                ++textPos;
2099
            }
2100
        }
2101
        caseValue[funcNamePos] = 0;
2102
        arrayStr[arrayStrPos]  = 0;
2103

2104
        // Eg: temp0 = TypeName[Player Object]
2105
        if (StrComp(caseValue, "TypeName")) {
2106
            caseValue[0] = '0';
2107
            caseValue[1] = 0;
2108

2109
            int o = 0;
2110
            for (; o < OBJECT_COUNT; ++o) {
2111
                if (StrComp(arrayStr, typeNames[o])) {
2112
                    caseValue[0] = 0;
2113
                    AppendIntegerToString(caseValue, o);
2114
                    break;
2115
                }
2116
            }
2117

2118
            if (o == OBJECT_COUNT)
2119
                PrintLog("WARNING: Unknown typename \"%s\", on line %d", arrayStr, lineID);
2120
        }
2121

2122
        // Eg: temp0 = SfxName[Jump]
2123
        if (StrComp(caseValue, "SfxName")) {
2124
            caseValue[0] = '0';
2125
            caseValue[1] = 0;
2126

2127
            int s = 0;
2128
            for (; s < SFX_COUNT; ++s) {
2129
                if (StrComp(arrayStr, sfxNames[s])) {
2130
                    caseValue[0] = 0;
2131
                    AppendIntegerToString(caseValue, s);
2132
                    break;
2133
                }
2134
            }
2135

2136
            if (s == SFX_COUNT)
2137
                PrintLog("WARNING: Unknown sfxName \"%s\", on line %d", arrayStr, lineID);
2138
        }
2139

2140
#if !RETRO_USE_ORIGINAL_CODE
2141
        // Eg: temp0 = VarName[player.lives]
2142
        if (StrComp(caseValue, "VarName")) {
2143
            caseValue[0] = '0';
2144
            caseValue[1] = 0;
2145

2146
            int v = 0;
2147
            for (; v < globalVariablesCount; ++v) {
2148
                if (StrComp(arrayStr, globalVariableNames[v])) {
2149
                    caseValue[0] = 0;
2150
                    AppendIntegerToString(caseValue, v);
2151
                    break;
2152
                }
2153
            }
2154

2155
            if (v == globalVariablesCount) {
2156
                PrintLog("WARNING: Unknown varName \"%s\", on line %d", arrayStr, lineID);
2157
            }
2158
        }
2159

2160
        // Eg: temp0 = AchievementName[Ring King]
2161
        if (StrComp(caseValue, "AchievementName")) {
2162
            caseValue[0] = '0';
2163
            caseValue[1] = 0;
2164

2165
            int a = 0;
2166
            for (; a < achievementCount; ++a) {
2167
                char buf[0x40];
2168
                char *str = achievements[a].name;
2169
                int pos   = 0;
2170

2171
                while (*str) {
2172
                    if (*str != ' ')
2173
                        buf[pos++] = *str;
2174
                    str++;
2175
                }
2176
                buf[pos] = 0;
2177

2178
                if (StrComp(arrayStr, buf)) {
2179
                    caseValue[0] = 0;
2180
                    AppendIntegerToString(caseValue, a);
2181
                    break;
2182
                }
2183
            }
2184

2185
            if (a == achievementCount) {
2186
                PrintLog("WARNING: Unknown AchievementName \"%s\", on line %d", arrayStr, lineID);
2187
            }
2188
        }
2189

2190
        // Eg: temp0 = PlayerName[SONIC]
2191
        if (StrComp(caseValue, "PlayerName")) {
2192
            caseValue[0] = '0';
2193
            caseValue[1] = 0;
2194

2195
            int p = 0;
2196
            for (; p < PLAYER_COUNT; ++p) {
2197
                char buf[0x40];
2198
                char *str = playerNames[p];
2199
                int pos   = 0;
2200

2201
                while (*str) {
2202
                    if (*str != ' ')
2203
                        buf[pos++] = *str;
2204
                    str++;
2205
                }
2206
                buf[pos] = 0;
2207

2208
                if (StrComp(arrayStr, buf)) {
2209
                    caseValue[0] = 0;
2210
                    AppendIntegerToString(caseValue, p);
2211
                    break;
2212
                }
2213
            }
2214

2215
            if (p == PLAYER_COUNT) {
2216
                PrintLog("WARNING: Unknown PlayerName \"%s\", on line %d", arrayStr, lineID);
2217
            }
2218
        }
2219

2220
        // Eg: temp0 = StageName[R - GREEN HILL ZONE 1]
2221
        if (StrComp(caseValue, "StageName")) {
2222
            caseValue[0] = '0';
2223
            caseValue[1] = 0;
2224

2225
            int s = -1;
2226
            if (StrLength(arrayStr) >= 2) {
2227
                char list = arrayStr[0];
2228
                switch (list) {
2229
                    case 'P': list = STAGELIST_PRESENTATION; break;
2230
                    case 'R': list = STAGELIST_REGULAR; break;
2231
                    case 'S': list = STAGELIST_SPECIAL; break;
2232
                    case 'B': list = STAGELIST_BONUS; break;
2233
                }
2234
                s = GetSceneID(list, &arrayStr[2]);
2235
            }
2236

2237
            if (s == -1) {
2238
                PrintLog("WARNING: Unknown StageName \"%s\", on line %d", arrayStr, lineID);
2239
                s = 0;
2240
            }
2241
            caseValue[0] = 0;
2242
            AppendIntegerToString(caseValue, s);
2243
        }
2244
#endif
2245
        StrCopy(caseString, caseValue);
2246
        foundValue = true;
2247
    }
2248

2249
    for (int a = 0; a < scriptValueListCount && !foundValue; ++a) {
2250
        if (StrComp(scriptValueList[a].name, caseString)) {
2251
            StrCopy(caseString, scriptValueList[a].value);
2252
            break;
2253
        }
2254
    }
2255

2256
    int caseID = 0;
2257
    if (ConvertStringToInteger(caseString, &caseID)) {
2258
        int stackValue = jumpTableStack[jumpTableStackPos];
2259
        if (caseID < jumpTable[stackValue])
2260
            jumpTable[stackValue] = caseID;
2261
        stackValue++;
2262
        if (caseID > jumpTable[stackValue])
2263
            jumpTable[stackValue] = caseID;
2264
    }
2265
    else {
2266
        PrintLog("WARNING: unable to convert case string \"%s\" to int, on line %d", caseString, lineID);
2267
    }
2268
}
2269
bool ReadSwitchCase(char *text)
2270
{
2271
    char caseText[0x80];
2272
    if (FindStringToken(text, "case", 1) == 0) {
2273
        int textPos       = 4;
2274
        int caseStringPos = 0;
2275
        while (text[textPos]) {
2276
            if (text[textPos] != ':')
2277
                caseText[caseStringPos++] = text[textPos];
2278
            ++textPos;
2279
        }
2280
        caseText[caseStringPos] = 0;
2281

2282
        bool foundValue = false;
2283
        if (FindStringToken(caseText, "[", 1) >= 0) {
2284
            char caseValue[0x80];
2285
            char arrayStr[0x80];
2286

2287
            int textPos     = 0;
2288
            int funcNamePos = 0;
2289
            int mode        = 0;
2290
            int arrayStrPos = 0;
2291
            while (caseText[textPos] != ':' && caseText[textPos]) {
2292
                if (mode) {
2293
                    if (caseText[textPos] == ']')
2294
                        mode = 0;
2295
                    else
2296
                        arrayStr[arrayStrPos++] = caseText[textPos];
2297
                    ++textPos;
2298
                }
2299
                else {
2300
                    if (caseText[textPos] == '[')
2301
                        mode = 1;
2302
                    else
2303
                        caseValue[funcNamePos++] = caseText[textPos];
2304
                    ++textPos;
2305
                }
2306
            }
2307
            caseValue[funcNamePos] = 0;
2308
            arrayStr[arrayStrPos]  = 0;
2309

2310
            // Eg: temp0 = TypeName[Player Object]
2311
            if (StrComp(caseValue, "TypeName")) {
2312
                caseValue[0] = '0';
2313
                caseValue[1] = 0;
2314

2315
                int o = 0;
2316
                for (; o < OBJECT_COUNT; ++o) {
2317
                    if (StrComp(arrayStr, typeNames[o])) {
2318
                        caseValue[0] = 0;
2319
                        AppendIntegerToString(caseValue, o);
2320
                        break;
2321
                    }
2322
                }
2323

2324
                if (o == OBJECT_COUNT)
2325
                    PrintLog("WARNING: Unknown typename \"%s\", on line %d", arrayStr, lineID);
2326
            }
2327

2328
            // Eg: temp0 = SfxName[Jump]
2329
            if (StrComp(caseValue, "SfxName")) {
2330
                caseValue[0] = '0';
2331
                caseValue[1] = 0;
2332

2333
                int s = 0;
2334
                for (; s < SFX_COUNT; ++s) {
2335
                    if (StrComp(arrayStr, sfxNames[s])) {
2336
                        caseValue[0] = 0;
2337
                        AppendIntegerToString(caseValue, s);
2338
                        break;
2339
                    }
2340
                }
2341

2342
                if (s == SFX_COUNT)
2343
                    PrintLog("WARNING: Unknown sfxName \"%s\", on line %d", arrayStr, lineID);
2344
            }
2345

2346
#if !RETRO_USE_ORIGINAL_CODE
2347
            // Eg: temp0 = VarName[player.lives]
2348
            if (StrComp(caseValue, "VarName")) {
2349
                caseValue[0] = '0';
2350
                caseValue[1] = 0;
2351

2352
                int v = 0;
2353
                for (; v < globalVariablesCount; ++v) {
2354
                    if (StrComp(arrayStr, globalVariableNames[v])) {
2355
                        caseValue[0] = 0;
2356
                        AppendIntegerToString(caseValue, v);
2357
                        break;
2358
                    }
2359
                }
2360

2361
                if (v == globalVariablesCount)
2362
                    PrintLog("WARNING: Unknown varName \"%s\", on line %d", arrayStr, lineID);
2363
            }
2364

2365
            // Eg: temp0 = AchievementName[Ring King]
2366
            if (StrComp(caseValue, "AchievementName")) {
2367
                caseValue[0] = '0';
2368
                caseValue[1] = 0;
2369

2370
                int a = 0;
2371
                for (; a < achievementCount; ++a) {
2372
                    char buf[0x40];
2373
                    char *str = achievements[a].name;
2374
                    int pos   = 0;
2375

2376
                    while (*str) {
2377
                        if (*str != ' ')
2378
                            buf[pos++] = *str;
2379
                        str++;
2380
                    }
2381
                    buf[pos] = 0;
2382

2383
                    if (StrComp(arrayStr, buf)) {
2384
                        caseValue[0] = 0;
2385
                        AppendIntegerToString(caseValue, a);
2386
                        break;
2387
                    }
2388
                }
2389

2390
                if (a == achievementCount)
2391
                    PrintLog("WARNING: Unknown AchievementName \"%s\", on line %d", arrayStr, lineID);
2392
            }
2393

2394
            // Eg: temp0 = PlayerName[SONIC]
2395
            if (StrComp(caseValue, "PlayerName")) {
2396
                caseValue[0] = '0';
2397
                caseValue[1] = 0;
2398

2399
                int p = 0;
2400
                for (; p < PLAYER_COUNT; ++p) {
2401
                    char buf[0x40];
2402
                    char *str = playerNames[p];
2403
                    int pos   = 0;
2404

2405
                    while (*str) {
2406
                        if (*str != ' ')
2407
                            buf[pos++] = *str;
2408
                        str++;
2409
                    }
2410
                    buf[pos] = 0;
2411

2412
                    if (StrComp(arrayStr, buf)) {
2413
                        caseValue[0] = 0;
2414
                        AppendIntegerToString(caseValue, p);
2415
                        break;
2416
                    }
2417
                }
2418

2419
                if (p == PLAYER_COUNT)
2420
                    PrintLog("WARNING: Unknown PlayerName \"%s\", on line %d", arrayStr, lineID);
2421
            }
2422

2423
            // Eg: temp0 = StageName[R - GREEN HILL ZONE 1]
2424
            if (StrComp(caseValue, "StageName")) {
2425
                caseValue[0] = '0';
2426
                caseValue[1] = 0;
2427

2428
                int s = -1;
2429
                if (StrLength(arrayStr) >= 2) {
2430
                    char list = arrayStr[0];
2431
                    switch (list) {
2432
                        case 'P': list = STAGELIST_PRESENTATION; break;
2433
                        case 'R': list = STAGELIST_REGULAR; break;
2434
                        case 'S': list = STAGELIST_SPECIAL; break;
2435
                        case 'B': list = STAGELIST_BONUS; break;
2436
                    }
2437
                    s = GetSceneID(list, &arrayStr[2]);
2438
                }
2439

2440
                if (s == -1) {
2441
                    PrintLog("WARNING: Unknown StageName \"%s\", on line %d", arrayStr, lineID);
2442
                    s = 0;
2443
                }
2444
                caseValue[0] = 0;
2445
                AppendIntegerToString(caseValue, s);
2446
            }
2447
#endif
2448
            StrCopy(caseText, caseValue);
2449
            foundValue = true;
2450
        }
2451

2452
        for (int v = 0; v < scriptValueListCount && !foundValue; ++v) {
2453
            if (StrComp(caseText, scriptValueList[v].name)) {
2454
                StrCopy(caseText, scriptValueList[v].value);
2455
                break;
2456
            }
2457
        }
2458

2459
        int val = 0;
2460

2461
        int jPos    = jumpTableStack[jumpTableStackPos];
2462
        int jOffset = jPos + 4;
2463
        if (ConvertStringToInteger(caseText, &val))
2464
            jumpTable[val - jumpTable[jPos] + jOffset] = scriptCodePos - scriptCodeOffset;
2465
        else
2466
            PrintLog("WARNING: unable to read case string \"%s\" as an int, on line %d", caseText, lineID);
2467

2468
        return true;
2469
    }
2470
    else if (FindStringToken(text, "default", 1) == 0) {
2471
        int jumpTablepos                = jumpTableStack[jumpTableStackPos];
2472
        jumpTable[jumpTablepos + 2] = scriptCodePos - scriptCodeOffset;
2473
        int cnt                         = abs(jumpTable[jumpTablepos + 1] - jumpTable[jumpTablepos]) + 1;
2474

2475
        int jOffset = jumpTablepos + 4;
2476
        for (int i = 0; i < cnt; ++i) {
2477
            if (jumpTable[jOffset + i] < 0)
2478
                jumpTable[jOffset + i] = scriptCodePos - scriptCodeOffset;
2479
        }
2480

2481
        return true;
2482
    }
2483

2484
    return false;
2485
}
2486
void ReadTableValues(char *text)
2487
{
2488
    int textStrPos = 0;
2489

2490
    char valueBuffer[256];
2491
    int valueBufferPos = 0;
2492

2493
    while (text[textStrPos]) {
2494
        valueBuffer[valueBufferPos++] = text[textStrPos++];
2495

2496
        while (text[textStrPos] == ',') {
2497
            valueBuffer[valueBufferPos] = 0;
2498
            ++scriptCode[scriptCodeOffset];
2499
            if (!ConvertStringToInteger(valueBuffer, &scriptCode[scriptCodePos])) {
2500
                scriptCode[scriptCodePos] = 0;
2501
#if !RETRO_USE_ORIGINAL_CODE
2502
                PrintLog("WARNING: unable to parse table value \"%s\" as an int, on line %d", valueBuffer, lineID);
2503
#endif
2504
            }
2505
            scriptCodePos++;
2506
            valueBufferPos = 0;
2507
            textStrPos++;
2508
        }
2509
    }
2510

2511
    if (StrLength(valueBuffer)) {
2512
        valueBuffer[valueBufferPos] = 0;
2513
        ++scriptCode[scriptCodeOffset];
2514
        if (!ConvertStringToInteger(valueBuffer, &scriptCode[scriptCodePos])) {
2515
            scriptCode[scriptCodePos] = 0;
2516
#if !RETRO_USE_ORIGINAL_CODE
2517
            PrintLog("WARNING: unable to parse table value \"%s\" as an int, on line %d", valueBuffer, lineID);
2518
#endif
2519
        }
2520
        scriptCodePos++;
2521
    }
2522
}
2523
void AppendIntegerToString(char *text, int value)
2524
{
2525
    int textPos = 0;
2526
    while (true) {
2527
        if (!text[textPos])
2528
            break;
2529
        ++textPos;
2530
    }
2531

2532
    int cnt = 0;
2533
    int v   = value;
2534
    while (v != 0) {
2535
        v /= 10;
2536
        cnt++;
2537
    }
2538

2539
    v = 0;
2540
    for (int i = cnt - 1; i >= 0; --i) {
2541
        v = value / pow(10, i);
2542
        v %= 10;
2543

2544
        int strValue = v + '0';
2545
        if (strValue < '0' || strValue > '9') {
2546
            // what
2547
        }
2548
        text[textPos++] = strValue;
2549
    }
2550
    if (value == 0)
2551
        text[textPos++] = '0';
2552
    text[textPos] = 0;
2553
}
2554
void AppendIntegerToStringW(ushort *text, int value)
2555
{
2556
    int textPos = 0;
2557
    while (true) {
2558
        if (!text[textPos])
2559
            break;
2560
        ++textPos;
2561
    }
2562

2563
    int cnt = 0;
2564
    int v   = value;
2565
    while (v != 0) {
2566
        v /= 10;
2567
        cnt++;
2568
    }
2569

2570
    v = 0;
2571
    for (int i = cnt - 1; i >= 0; --i) {
2572
        v = value / pow(10, i);
2573
        v %= 10;
2574

2575
        int strValue = v + '0';
2576
        if (strValue < '0' || strValue > '9') {
2577
            // what
2578
        }
2579
        text[textPos++] = strValue;
2580
    }
2581
    if (value == 0)
2582
        text[textPos++] = '0';
2583
    text[textPos] = 0;
2584
}
2585
#endif
2586

2587
bool ConvertStringToInteger(const char *text, int *value)
2588
{
2589
    int charID    = 0;
2590
    bool negative = false;
2591
    int base      = 10;
2592
    *value        = 0;
2593
    if (*text != '+' && !(*text >= '0' && *text <= '9') && *text != '-')
2594
        return false;
2595
    int strLength = StrLength(text) - 1;
2596
    uint charVal  = 0;
2597
    if (*text == '-') {
2598
        negative = true;
2599
        charID   = 1;
2600
        --strLength;
2601
    }
2602
    else if (*text == '+') {
2603
        charID = 1;
2604
        --strLength;
2605
    }
2606

2607
    if (text[charID] == '0') {
2608
        if (text[charID + 1] == 'x' || text[charID + 1] == 'X')
2609
            base = 0x10;
2610
#if !RETRO_USE_ORIGINAL_CODE
2611
        else if (text[charID + 1] == 'b' || text[charID + 1] == 'B')
2612
            base = 0b10;
2613
        else if (text[charID + 1] == 'o' || text[charID + 1] == 'O')
2614
            base = 0010; // base 8
2615
#endif
2616

2617
        if (base != 10) {
2618
            charID += 2;
2619
            strLength -= 2;
2620
        }
2621
    }
2622

2623
    while (strLength > -1) {
2624
        bool flag = text[charID] < '0';
2625
        if (!flag) {
2626
            if (base == 0x10 && text[charID] > 'f')
2627
                flag = true;
2628
#if !RETRO_USE_ORIGINAL_CODE
2629
            if (base == 0010 && text[charID] > '7')
2630
                flag = true;
2631
            if (base == 0b10 && text[charID] > '1')
2632
                flag = true;
2633
#endif
2634
        }
2635

2636
        if (flag) {
2637
            return 0;
2638
        }
2639
        if (strLength <= 0) {
2640
            if (text[charID] >= '0' && text[charID] <= '9') {
2641
                *value = text[charID] + *value - '0';
2642
            }
2643
            else if (text[charID] >= 'a' && text[charID] <= 'f') {
2644
                charVal = text[charID] - 'a';
2645
                charVal += 10;
2646
                *value += charVal;
2647
            }
2648
            else if (text[charID] >= 'A' && text[charID] <= 'F') {
2649
                charVal = text[charID] - 'A';
2650
                charVal += 10;
2651
                *value += charVal;
2652
            }
2653
        }
2654
        else {
2655
            int strlen = strLength + 1;
2656
            charVal    = 0;
2657
            if (text[charID] >= '0' && text[charID] <= '9') {
2658
                charVal = text[charID] - '0';
2659
            }
2660
            else if (text[charID] >= 'a' && text[charID] <= 'f') {
2661
                charVal = text[charID] - 'a';
2662
                charVal += 10;
2663
            }
2664
            else if (text[charID] >= 'A' && text[charID] <= 'F') {
2665
                charVal = text[charID] - 'A';
2666
                charVal += 10;
2667
            }
2668
            for (; --strlen; charVal *= base)
2669
                ;
2670
            *value += charVal;
2671
        }
2672
        --strLength;
2673
        ++charID;
2674
    }
2675

2676
    if (negative)
2677
        *value = -*value;
2678

2679
    return true;
2680
}
2681

2682
#if RETRO_USE_COMPILER
2683
void CopyAliasStr(char *dest, char *text, bool arrayIndex)
2684
{
2685
    int textPos     = 0;
2686
    int destPos     = 0;
2687
    bool arrayValue = false;
2688
    if (arrayIndex) {
2689
        while (text[textPos]) {
2690
            if (arrayValue) {
2691
                if (text[textPos] == ']')
2692
                    arrayValue = false;
2693
                else
2694
                    dest[destPos++] = text[textPos];
2695
                ++textPos;
2696
            }
2697
            else {
2698
                if (text[textPos] == '[')
2699
                    arrayValue = true;
2700
                ++textPos;
2701
            }
2702
        }
2703
    }
2704
    else {
2705
        while (text[textPos]) {
2706
            if (arrayValue) {
2707
                if (text[textPos] == ']')
2708
                    arrayValue = false;
2709
                ++textPos;
2710
            }
2711
            else {
2712
                if (text[textPos] == '[')
2713
                    arrayValue = true;
2714
                else
2715
                    dest[destPos++] = text[textPos];
2716
                ++textPos;
2717
            }
2718
        }
2719
    }
2720
    dest[destPos] = 0;
2721
}
2722
bool CheckOpcodeType(char *text)
2723
{
2724
    while (true) {
2725
        int c = *text;
2726
        if (!*text)
2727
            break;
2728
        ++text;
2729
        if (c == '(')
2730
            return false;
2731
    }
2732
    return true;
2733
}
2734

2735
void ParseScriptFile(char *scriptName, int scriptID)
2736
{
2737
    jumpTableStackPos = 0;
2738
    lineID            = 0;
2739

2740
    for (int f = 0; f < scriptFunctionCount; ++f) {
2741
        if (scriptFunctionList[f].access != ACCESS_PUBLIC)
2742
            StrCopy(scriptFunctionList[f].name, "");
2743
    }
2744

2745
    int newScriptValueCount = COMMON_SCRIPT_VAR_COUNT;
2746
    for (int v = COMMON_SCRIPT_VAR_COUNT; v < scriptValueListCount; ++v) {
2747
        if (scriptValueList[v].access != ACCESS_PUBLIC) {
2748
            StrCopy(scriptValueList[v].name, "");
2749
        }
2750
        else {
2751
            if (newScriptValueCount != v)
2752
                memcpy(&scriptValueList[newScriptValueCount], &scriptValueList[v], sizeof(ScriptVariableInfo));
2753

2754
            newScriptValueCount++;
2755
        }
2756
    }
2757
    scriptValueListCount = newScriptValueCount;
2758

2759
    for (int v = scriptValueListCount; v < SCRIPT_VAR_COUNT; ++v) {
2760
        MEM_ZERO(scriptValueList[v]);
2761
    }
2762

2763
    FileInfo info;
2764
    char scriptPath[0x40];
2765

2766
    // Try the original script folder
2767
    StrCopy(scriptPath, "Data/Scripts/");
2768
    StrAdd(scriptPath, scriptName);
2769
    if (LoadFile(scriptPath, &info)) {
2770
        int readMode   = READMODE_NORMAL;
2771
        int parseMode  = PARSEMODE_SCOPELESS;
2772
        char prevChar  = 0;
2773
        char curChar   = 0;
2774
        int switchDeep = 0;
2775

2776
        while (readMode < READMODE_EOF) {
2777
            int textPos               = 0;
2778
            readMode                  = READMODE_NORMAL;
2779
            bool disableLineIncrement = false;
2780

2781
            while (readMode < READMODE_ENDLINE) {
2782
                prevChar = curChar;
2783
                FileRead(&curChar, 1);
2784
                if (readMode == READMODE_STRING) {
2785
                    if (curChar == '\t' || curChar == '\r' || curChar == '\n' || curChar == ';' || readMode >= READMODE_COMMENTLINE) {
2786
                        if ((curChar == '\n' && prevChar != '\r') || (curChar == '\n' && prevChar == '\r')) {
2787
                            readMode            = READMODE_ENDLINE;
2788
                            scriptText[textPos] = 0;
2789
                            if (curChar == ';')
2790
                                disableLineIncrement = true;
2791
                        }
2792
                    }
2793
                    else if (curChar != '/' || textPos <= 0) {
2794
                        scriptText[textPos++] = curChar;
2795
                        if (curChar == '"')
2796
                            readMode = READMODE_NORMAL;
2797
                    }
2798
                    else if (curChar == '/' && prevChar == '/') {
2799
                        readMode              = READMODE_COMMENTLINE;
2800
                        scriptText[--textPos] = 0;
2801
                    }
2802
                    else {
2803
                        scriptText[textPos++] = curChar;
2804
                    }
2805
                }
2806
                else if (curChar == ' ' || curChar == '\t' || curChar == '\r' || curChar == '\n' || curChar == ';'
2807
                         || readMode >= READMODE_COMMENTLINE) {
2808
                    if ((curChar == '\n' && prevChar != '\r') || (curChar == '\n' && prevChar == '\r') || curChar == ';') {
2809
                        readMode            = READMODE_ENDLINE;
2810
                        scriptText[textPos] = 0;
2811
                        if (curChar == ';')
2812
                            disableLineIncrement = true;
2813
                    }
2814
                }
2815
                else if (curChar != '/' || textPos <= 0) {
2816
                    scriptText[textPos++] = curChar;
2817
                    if (curChar == '"' && !readMode)
2818
                        readMode = READMODE_STRING;
2819
                }
2820
                else if (curChar == '/' && prevChar == '/') {
2821
                    readMode              = READMODE_COMMENTLINE;
2822
                    scriptText[--textPos] = 0;
2823
                }
2824
                else {
2825
                    scriptText[textPos++] = curChar;
2826
                }
2827
                if (ReachedEndOfFile()) {
2828
                    scriptText[textPos] = 0;
2829
                    readMode            = READMODE_EOF;
2830
                }
2831
            }
2832

2833
            switch (parseMode) {
2834
                case PARSEMODE_SCOPELESS:
2835
                    if (!disableLineIncrement)
2836
                        ++lineID;
2837

2838
                    CheckAliasText(scriptText);
2839
                    CheckStaticText(scriptText);
2840

2841
                    if (CheckTableText(scriptText)) {
2842
                        parseMode = PARSEMODE_TABLEREAD;
2843
                        StrCopy(scriptText, "");
2844
                    }
2845

2846
                    if (StrComp(scriptText, "eventObjectUpdate")) {
2847
                        parseMode                                          = PARSEMODE_FUNCTION;
2848
                        objectScriptList[scriptID].eventUpdate.scriptCodePtr = scriptCodePos;
2849
                        objectScriptList[scriptID].eventUpdate.jumpTablePtr  = jumpTablePos;
2850
                        scriptCodeOffset                                   = scriptCodePos;
2851
                        jumpTableOffset                                    = jumpTablePos;
2852
                    }
2853

2854
                    if (StrComp(scriptText, "eventObjectDraw")) {
2855
                        parseMode                                          = PARSEMODE_FUNCTION;
2856
                        objectScriptList[scriptID].eventDraw.scriptCodePtr = scriptCodePos;
2857
                        objectScriptList[scriptID].eventDraw.jumpTablePtr  = jumpTablePos;
2858
                        scriptCodeOffset                                   = scriptCodePos;
2859
                        jumpTableOffset                                    = jumpTablePos;
2860
                    }
2861

2862
                    if (StrComp(scriptText, "eventObjectStartup")) {
2863
                        parseMode                                             = PARSEMODE_FUNCTION;
2864
                        objectScriptList[scriptID].eventStartup.scriptCodePtr = scriptCodePos;
2865
                        objectScriptList[scriptID].eventStartup.jumpTablePtr  = jumpTablePos;
2866
                        scriptCodeOffset                                      = scriptCodePos;
2867
                        jumpTableOffset                                       = jumpTablePos;
2868
                    }
2869

2870
                    if (FindStringToken(scriptText, "reservefunction", 1) == 0) { // forward decl
2871
                        char funcName[0x40];
2872
                        for (textPos = 15; scriptText[textPos]; ++textPos) funcName[textPos - 15] = scriptText[textPos];
2873
                        funcName[textPos - 15] = 0;
2874
                        int funcID             = -1;
2875
                        for (int f = 0; f < scriptFunctionCount; ++f) {
2876
                            if (StrComp(funcName, scriptFunctionList[f].name))
2877
                                funcID = f;
2878
                        }
2879

2880
                        if (scriptFunctionCount < FUNCTION_COUNT && funcID == -1) {
2881
                            StrCopy(scriptFunctionList[scriptFunctionCount++].name, funcName);
2882
                        }
2883
                        else {
2884
                            PrintLog("WARNING: Function %s has already been reserved!", funcName);
2885
                        }
2886

2887
                        parseMode = PARSEMODE_SCOPELESS;
2888
                    }
2889
                    else if (FindStringToken(scriptText, "publicfunction", 1) == 0) { // regular public decl
2890
                        char funcName[0x40];
2891
                        for (textPos = 14; scriptText[textPos]; ++textPos) funcName[textPos - 14] = scriptText[textPos];
2892

2893
                        funcName[textPos - 14] = 0;
2894
                        int funcID             = -1;
2895
                        for (int f = 0; f < scriptFunctionCount; ++f) {
2896
                            if (StrComp(funcName, scriptFunctionList[f].name))
2897
                                funcID = f;
2898
                        }
2899

2900
                        if (funcID <= -1) {
2901
                            if (scriptFunctionCount >= FUNCTION_COUNT) {
2902
                                parseMode = PARSEMODE_SCOPELESS;
2903
                            }
2904
                            else {
2905
                                StrCopy(scriptFunctionList[scriptFunctionCount].name, funcName);
2906
                                scriptFunctionList[scriptFunctionCount].access            = ACCESS_PUBLIC;
2907
                                scriptFunctionList[scriptFunctionCount].ptr.scriptCodePtr = scriptCodePos;
2908
                                scriptFunctionList[scriptFunctionCount].ptr.jumpTablePtr  = jumpTablePos;
2909

2910
                                scriptCodeOffset = scriptCodePos;
2911
                                jumpTableOffset  = jumpTablePos;
2912
                                parseMode        = PARSEMODE_FUNCTION;
2913
                                ++scriptFunctionCount;
2914
                            }
2915
                        }
2916
                        else {
2917
                            StrCopy(scriptFunctionList[funcID].name, funcName);
2918
                            scriptFunctionList[funcID].access            = ACCESS_PUBLIC;
2919
                            scriptFunctionList[funcID].ptr.scriptCodePtr = scriptCodePos;
2920
                            scriptFunctionList[funcID].ptr.jumpTablePtr  = jumpTablePos;
2921

2922
                            scriptCodeOffset = scriptCodePos;
2923
                            jumpTableOffset  = jumpTablePos;
2924
                            parseMode        = PARSEMODE_FUNCTION;
2925
                        }
2926
                    }
2927
                    else if (FindStringToken(scriptText, "privatefunction", 1) == 0) { // regular private decl
2928
                        char funcName[0x40];
2929
                        for (textPos = 15; scriptText[textPos]; ++textPos) funcName[textPos - 15] = scriptText[textPos];
2930

2931
                        funcName[textPos - 15] = 0;
2932
                        int funcID             = -1;
2933
                        for (int f = 0; f < scriptFunctionCount; ++f) {
2934
                            if (StrComp(funcName, scriptFunctionList[f].name))
2935
                                funcID = f;
2936
                        }
2937

2938
                        if (funcID <= -1) {
2939
                            if (scriptFunctionCount >= FUNCTION_COUNT) {
2940
                                parseMode = PARSEMODE_SCOPELESS;
2941
                            }
2942
                            else {
2943
                                StrCopy(scriptFunctionList[scriptFunctionCount].name, funcName);
2944
                                scriptFunctionList[scriptFunctionCount].access            = ACCESS_PRIVATE;
2945
                                scriptFunctionList[scriptFunctionCount].ptr.scriptCodePtr = scriptCodePos;
2946
                                scriptFunctionList[scriptFunctionCount].ptr.jumpTablePtr  = jumpTablePos;
2947

2948
                                scriptCodeOffset = scriptCodePos;
2949
                                jumpTableOffset  = jumpTablePos;
2950
                                parseMode        = PARSEMODE_FUNCTION;
2951
                                ++scriptFunctionCount;
2952
                            }
2953
                        }
2954
                        else {
2955
                            StrCopy(scriptFunctionList[funcID].name, funcName);
2956
                            scriptFunctionList[funcID].access            = ACCESS_PRIVATE;
2957
                            scriptFunctionList[funcID].ptr.scriptCodePtr = scriptCodePos;
2958
                            scriptFunctionList[funcID].ptr.jumpTablePtr  = jumpTablePos;
2959

2960
                            scriptCodeOffset = scriptCodePos;
2961
                            jumpTableOffset  = jumpTablePos;
2962
                            parseMode        = PARSEMODE_FUNCTION;
2963
                        }
2964
                    }
2965
                    break;
2966

2967
                case PARSEMODE_PLATFORMSKIP:
2968
                    if (!disableLineIncrement)
2969
                        ++lineID;
2970

2971
                    if (FindStringToken(scriptText, "#endplatform", 1) == 0)
2972
                        parseMode = PARSEMODE_FUNCTION;
2973
                    break;
2974

2975
                case PARSEMODE_FUNCTION:
2976
                    if (!disableLineIncrement)
2977
                        ++lineID;
2978

2979
                    if (scriptText[0]) {
2980
                        if (StrComp(scriptText, "endevent")) {
2981
                            scriptCode[scriptCodePos++] = FUNC_END;
2982
                            parseMode                   = PARSEMODE_SCOPELESS;
2983
                        }
2984
                        else if (StrComp(scriptText, "endfunction")) {
2985
                            scriptCode[scriptCodePos++] = FUNC_RETURN;
2986
                            parseMode                   = PARSEMODE_SCOPELESS;
2987
                        }
2988
                        else if (FindStringToken(scriptText, "#platform:", 1) == 0) {
2989
                            if (FindStringToken(scriptText, Engine.gamePlatform, 1) == -1
2990
                                && FindStringToken(scriptText, Engine.gameRenderType, 1) == -1
2991
#if RETRO_USE_HAPTICS
2992
                                && FindStringToken(scriptText, Engine.gameHapticSetting, 1) == -1
2993
#endif
2994
#if !RETRO_USE_ORIGINAL_CODE && RETRO_REV03
2995
                                && FindStringToken(scriptText, Engine.releaseType, 1) == -1 // general flag for standalone/origins content switching
2996
#endif
2997
#if !RETRO_USE_ORIGINAL_CODE
2998
                                && FindStringToken(scriptText, "USE_DECOMP", 1) == -1 // general flag for decomp-only stuff
2999
#endif
3000
#if RETRO_USE_NETWORKING
3001
                                && FindStringToken(scriptText, "USE_NETWORKING", 1) == -1
3002
#endif
3003
#if RETRO_USE_MOD_LOADER
3004
                                && FindStringToken(scriptText, "USE_MOD_LOADER", 1) == -1
3005
#endif
3006
                            ) {
3007
                                parseMode = PARSEMODE_PLATFORMSKIP;
3008
                            }
3009
                        }
3010
                        else if (FindStringToken(scriptText, "#endplatform", 1) == -1) {
3011
                            ConvertConditionalStatement(scriptText);
3012
                            if (ConvertSwitchStatement(scriptText)) {
3013
                                parseMode    = PARSEMODE_SWITCHREAD;
3014
                                info.readPos = (int)GetFilePosition();
3015
                                switchDeep   = 0;
3016
                            }
3017
                            ConvertArithmaticSyntax(scriptText);
3018
                            if (!ReadSwitchCase(scriptText)) {
3019
                                ConvertFunctionText(scriptText);
3020
                                if (Engine.gameMode == ENGINE_SCRIPTERROR) {
3021
                                    AddTextMenuEntry(&gameMenu[0], " ");
3022
                                    AddTextMenuEntry(&gameMenu[0], "ERROR IN");
3023
                                    AddTextMenuEntry(&gameMenu[0], scriptName);
3024
                                    parseMode = PARSEMODE_ERROR;
3025
                                }
3026
                            }
3027
                        }
3028
                    }
3029
                    break;
3030

3031
                case PARSEMODE_SWITCHREAD:
3032
                    if (FindStringToken(scriptText, "switch", 1) == 0)
3033
                        ++switchDeep;
3034

3035
                    if (switchDeep) {
3036
                        if (FindStringToken(scriptText, "endswitch", 1) == 0)
3037
                            --switchDeep;
3038
                    }
3039
                    else if (FindStringToken(scriptText, "endswitch", 1) == 0) {
3040
                        SetFilePosition(info.readPos);
3041
                        parseMode  = PARSEMODE_FUNCTION;
3042
                        int jPos   = jumpTableStack[jumpTableStackPos];
3043
                        switchDeep = abs(jumpTable[jPos + 1] - jumpTable[jPos]) + 1;
3044
                        for (textPos = 0; textPos < switchDeep; ++textPos) jumpTable[jumpTablePos++] = -1;
3045
                    }
3046
                    else {
3047
                        CheckCaseNumber(scriptText);
3048
                    }
3049
                    break;
3050

3051
                case PARSEMODE_TABLEREAD:
3052
                    if (!disableLineIncrement)
3053
                        ++lineID;
3054

3055
                    if (FindStringToken(scriptText, "endtable", 1) == 0) {
3056
                        parseMode = PARSEMODE_SCOPELESS;
3057
                    }
3058
                    else {
3059
                        if (StrLength(scriptText) >= 1)
3060
                            ReadTableValues(scriptText);
3061

3062
                        parseMode = PARSEMODE_TABLEREAD;
3063
                    }
3064
                    break;
3065

3066
                default: break;
3067
            }
3068
        }
3069

3070
        CloseFile();
3071
    }
3072
}
3073
#endif
3074

3075
void LoadBytecode(int stageListID, int scriptID)
3076
{
3077
    char scriptPath[0x40];
3078
    switch (stageListID) {
3079
        case STAGELIST_PRESENTATION:
3080
        case STAGELIST_REGULAR:
3081
        case STAGELIST_BONUS:
3082
        case STAGELIST_SPECIAL:
3083
            StrCopy(scriptPath, "Bytecode/");
3084
            StrAdd(scriptPath, stageList[stageListID][stageListPosition].folder);
3085
            StrAdd(scriptPath, ".bin");
3086
            break;
3087
        case 4: StrCopy(scriptPath, "Bytecode/GlobalCode.bin"); break;
3088
        default: break;
3089
    }
3090

3091
    FileInfo info;
3092
    if (LoadFile(scriptPath, &info)) {
3093
        byte fileBuffer    = 0;
3094
        int *scriptCodePtr = &scriptCode[scriptCodePos];
3095
        int *jumpTablePtr  = &jumpTable[jumpTablePos];
3096

3097
        FileRead(&fileBuffer, 1);
3098
        int scriptCodeSize = fileBuffer;
3099
        FileRead(&fileBuffer, 1);
3100
        scriptCodeSize |= fileBuffer << 8;
3101
        FileRead(&fileBuffer, 1);
3102
        scriptCodeSize |= fileBuffer << 16;
3103
        FileRead(&fileBuffer, 1);
3104
        scriptCodeSize |= fileBuffer << 24;
3105

3106
        while (scriptCodeSize > 0) {
3107
            FileRead(&fileBuffer, 1);
3108
            int blockSize = fileBuffer & 0x7F;
3109
            if (fileBuffer >= 0x80) {
3110
                while (blockSize > 0) {
3111
                    FileRead(&fileBuffer, 1);
3112
                    *scriptCodePtr = fileBuffer;
3113
                    FileRead(&fileBuffer, 1);
3114
                    *scriptCodePtr |= fileBuffer << 8;
3115
                    FileRead(&fileBuffer, 1);
3116
                    *scriptCodePtr |= fileBuffer << 16;
3117
                    FileRead(&fileBuffer, 1);
3118
                    *scriptCodePtr |= fileBuffer << 24;
3119

3120
                    ++scriptCodePtr;
3121
                    ++scriptCodePos;
3122
                    --scriptCodeSize;
3123
                    --blockSize;
3124
                }
3125
            }
3126
            else {
3127
                while (blockSize > 0) {
3128
                    FileRead(&fileBuffer, 1);
3129
                    *scriptCodePtr = fileBuffer;
3130

3131
                    ++scriptCodePtr;
3132
                    ++scriptCodePos;
3133
                    --scriptCodeSize;
3134
                    --blockSize;
3135
                }
3136
            }
3137
        }
3138

3139
        FileRead(&fileBuffer, 1);
3140
        int jumpTableSize = fileBuffer;
3141
        FileRead(&fileBuffer, 1);
3142
        jumpTableSize |= fileBuffer << 8;
3143
        FileRead(&fileBuffer, 1);
3144
        jumpTableSize |= fileBuffer << 16;
3145
        FileRead(&fileBuffer, 1);
3146
        jumpTableSize |= fileBuffer << 24;
3147

3148
        while (jumpTableSize > 0) {
3149
            FileRead(&fileBuffer, 1);
3150
            int blockSize = fileBuffer & 0x7F;
3151

3152
            if (fileBuffer >= 0x80) {
3153
                while (blockSize > 0) {
3154
                    FileRead(&fileBuffer, 1);
3155
                    *jumpTablePtr = fileBuffer;
3156
                    FileRead(&fileBuffer, 1);
3157
                    *jumpTablePtr |= fileBuffer << 8;
3158
                    FileRead(&fileBuffer, 1);
3159
                    *jumpTablePtr |= fileBuffer << 16;
3160
                    FileRead(&fileBuffer, 1);
3161
                    *jumpTablePtr |= fileBuffer << 24;
3162

3163
                    ++jumpTablePtr;
3164
                    ++jumpTablePos;
3165
                    --jumpTableSize;
3166
                    --blockSize;
3167
                }
3168
            }
3169
            else {
3170
                while (blockSize > 0) {
3171
                    FileRead(&fileBuffer, 1);
3172
                    *jumpTablePtr = fileBuffer;
3173

3174
                    ++jumpTablePtr;
3175
                    ++jumpTablePos;
3176
                    --jumpTableSize;
3177
                    --blockSize;
3178
                }
3179
            }
3180
        }
3181

3182
        FileRead(&fileBuffer, 1);
3183
        int scriptCount = fileBuffer;
3184
        FileRead(&fileBuffer, 1);
3185
        scriptCount |= fileBuffer << 8;
3186

3187
        for (int s = 0; s < scriptCount; ++s) {
3188
            ObjectScript *script = &objectScriptList[scriptID + s];
3189

3190
            FileRead(&fileBuffer, 1);
3191
            script->eventUpdate.scriptCodePtr = fileBuffer;
3192
            FileRead(&fileBuffer, 1);
3193
            script->eventUpdate.scriptCodePtr |= fileBuffer << 8;
3194
            FileRead(&fileBuffer, 1);
3195
            script->eventUpdate.scriptCodePtr |= fileBuffer << 16;
3196
            FileRead(&fileBuffer, 1);
3197
            script->eventUpdate.scriptCodePtr |= fileBuffer << 24;
3198

3199
            FileRead(&fileBuffer, 1);
3200
            script->eventDraw.scriptCodePtr = fileBuffer;
3201
            FileRead(&fileBuffer, 1);
3202
            script->eventDraw.scriptCodePtr |= fileBuffer << 8;
3203
            FileRead(&fileBuffer, 1);
3204
            script->eventDraw.scriptCodePtr |= fileBuffer << 16;
3205
            FileRead(&fileBuffer, 1);
3206
            script->eventDraw.scriptCodePtr |= fileBuffer << 24;
3207

3208
            FileRead(&fileBuffer, 1);
3209
            script->eventStartup.scriptCodePtr = fileBuffer;
3210
            FileRead(&fileBuffer, 1);
3211
            script->eventStartup.scriptCodePtr |= (fileBuffer << 8);
3212
            FileRead(&fileBuffer, 1);
3213
            script->eventStartup.scriptCodePtr |= (fileBuffer << 16);
3214
            FileRead(&fileBuffer, 1);
3215
            script->eventStartup.scriptCodePtr |= fileBuffer << 24;
3216
        }
3217

3218
        for (int s = 0; s < scriptCount; ++s) {
3219
            ObjectScript *script = &objectScriptList[scriptID + s];
3220

3221
            FileRead(&fileBuffer, 1);
3222
            script->eventUpdate.jumpTablePtr = fileBuffer;
3223
            FileRead(&fileBuffer, 1);
3224
            script->eventUpdate.jumpTablePtr |= fileBuffer << 8;
3225
            FileRead(&fileBuffer, 1);
3226
            script->eventUpdate.jumpTablePtr |= fileBuffer << 16;
3227
            FileRead(&fileBuffer, 1);
3228
            script->eventUpdate.jumpTablePtr |= fileBuffer << 24;
3229

3230
            FileRead(&fileBuffer, 1);
3231
            script->eventDraw.jumpTablePtr = fileBuffer;
3232
            FileRead(&fileBuffer, 1);
3233
            script->eventDraw.jumpTablePtr |= fileBuffer << 8;
3234
            FileRead(&fileBuffer, 1);
3235
            script->eventDraw.jumpTablePtr |= fileBuffer << 16;
3236
            FileRead(&fileBuffer, 1);
3237
            script->eventDraw.jumpTablePtr |= fileBuffer << 24;
3238

3239
            FileRead(&fileBuffer, 1);
3240
            script->eventStartup.jumpTablePtr = fileBuffer;
3241
            FileRead(&fileBuffer, 1);
3242
            script->eventStartup.jumpTablePtr |= fileBuffer << 8;
3243
            FileRead(&fileBuffer, 1);
3244
            script->eventStartup.jumpTablePtr |= fileBuffer << 16;
3245
            FileRead(&fileBuffer, 1);
3246
            script->eventStartup.jumpTablePtr |= fileBuffer << 24;
3247
        }
3248

3249
        FileRead(&fileBuffer, 1);
3250
        int functionCount = fileBuffer;
3251
        FileRead(&fileBuffer, 1);
3252
        functionCount |= fileBuffer << 8;
3253

3254
        for (int f = 0; f < functionCount; ++f) {
3255
            ScriptFunction *function = &scriptFunctionList[f];
3256

3257
            FileRead(&fileBuffer, 1);
3258
            function->ptr.scriptCodePtr = fileBuffer;
3259
            FileRead(&fileBuffer, 1);
3260
            function->ptr.scriptCodePtr |= fileBuffer << 8;
3261
            FileRead(&fileBuffer, 1);
3262
            function->ptr.scriptCodePtr |= fileBuffer << 16;
3263
            FileRead(&fileBuffer, 1);
3264
            function->ptr.scriptCodePtr |= fileBuffer << 24;
3265
        }
3266

3267
        for (int f = 0; f < functionCount; ++f) {
3268
            ScriptFunction *function = &scriptFunctionList[f];
3269

3270
            FileRead(&fileBuffer, 1);
3271
            function->ptr.jumpTablePtr = fileBuffer;
3272
            FileRead(&fileBuffer, 1);
3273
            function->ptr.jumpTablePtr |= fileBuffer << 8;
3274
            FileRead(&fileBuffer, 1);
3275
            function->ptr.jumpTablePtr |= fileBuffer << 16;
3276
            FileRead(&fileBuffer, 1);
3277
            function->ptr.jumpTablePtr |= fileBuffer << 24;
3278
        }
3279

3280
        CloseFile();
3281
    }
3282
}
3283

3284
void ClearScriptData()
3285
{
3286
    memset(scriptCode, 0, sizeof(scriptCode));
3287
    memset(jumpTable, 0, sizeof(jumpTable));
3288

3289
    memset(foreachStack, -1, sizeof(foreachStack));
3290
    memset(jumpTableStack, 0, sizeof(jumpTableStack));
3291
    memset(functionStack, 0, sizeof(functionStack));
3292

3293
    scriptFrameCount = 0;
3294

3295
    scriptCodePos     = 0;
3296
    jumpTablePos      = 0;
3297
    jumpTableStackPos = 0;
3298
    functionStackPos  = 0;
3299

3300
    scriptCodePos    = 0;
3301
    scriptCodeOffset = 0;
3302
    jumpTablePos     = 0;
3303
    jumpTableOffset  = 0;
3304

3305
#if RETRO_USE_COMPILER
3306
    scriptFunctionCount = 0;
3307

3308
    lineID = 0;
3309

3310
    scriptValueListCount = COMMON_SCRIPT_VAR_COUNT;
3311
    for (int v = COMMON_SCRIPT_VAR_COUNT; v < SCRIPT_VAR_COUNT; ++v) {
3312
        MEM_ZERO(scriptValueList[v]);
3313
    }
3314
#endif
3315

3316
    ClearAnimationData();
3317

3318
    for (int o = 0; o < OBJECT_COUNT; ++o) {
3319
        ObjectScript *scriptInfo               = &objectScriptList[o];
3320
        scriptInfo->eventUpdate.scriptCodePtr  = SCRIPTCODE_COUNT - 1;
3321
        scriptInfo->eventUpdate.jumpTablePtr   = JUMPTABLE_COUNT - 1;
3322
        scriptInfo->eventDraw.scriptCodePtr    = SCRIPTCODE_COUNT - 1;
3323
        scriptInfo->eventDraw.jumpTablePtr     = JUMPTABLE_COUNT - 1;
3324
        scriptInfo->eventStartup.scriptCodePtr = SCRIPTCODE_COUNT - 1;
3325
        scriptInfo->eventStartup.jumpTablePtr  = JUMPTABLE_COUNT - 1;
3326
        scriptInfo->frameListOffset            = 0;
3327
        scriptInfo->spriteSheetID              = 0;
3328
        scriptInfo->animFile                   = GetDefaultAnimationRef();
3329
        typeNames[o][0]                        = 0;
3330
    }
3331

3332
    for (int s = globalSFXCount; s < globalSFXCount + stageSFXCount; ++s) {
3333
        sfxNames[s][0] = 0;
3334
    }
3335

3336
    for (int f = 0; f < FUNCTION_COUNT; ++f) {
3337
        scriptFunctionList[f].ptr.scriptCodePtr = SCRIPTCODE_COUNT - 1;
3338
        scriptFunctionList[f].ptr.jumpTablePtr  = JUMPTABLE_COUNT - 1;
3339
    }
3340

3341
    SetObjectTypeName("Blank Object", OBJ_TYPE_BLANKOBJECT);
3342
}
3343

3344
void ProcessScript(int scriptCodeStart, int jumpTableStart, byte scriptEvent)
3345
{
3346
    bool running      = true;
3347
    int scriptCodePtr = scriptCodeStart;
3348
    jumpTableStackPos = 0;
3349
    functionStackPos  = 0;
3350
    foreachStackPos   = 0;
3351

3352
    while (running) {
3353
        int opcode           = scriptCode[scriptCodePtr++];
3354
        int opcodeSize       = functions[opcode].opcodeSize;
3355
        int scriptCodeOffset = scriptCodePtr;
3356

3357
        scriptText[0] = '\0';
3358

3359
        // Get Values
3360
        for (int i = 0; i < opcodeSize; ++i) {
3361
            int opcodeType = scriptCode[scriptCodePtr++];
3362

3363
            if (opcodeType == SCRIPTVAR_VAR) {
3364
                int arrayVal = 0;
3365
                switch (scriptCode[scriptCodePtr++]) {
3366
                    case VARARR_NONE: arrayVal = objectEntityPos; break;
3367

3368
                    case VARARR_ARRAY:
3369
                        if (scriptCode[scriptCodePtr++] == 1)
3370
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
3371
                        else
3372
                            arrayVal = scriptCode[scriptCodePtr++];
3373
                        break;
3374

3375
                    case VARARR_ENTNOPLUS1:
3376
                        if (scriptCode[scriptCodePtr++] == 1)
3377
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]] + objectEntityPos;
3378
                        else
3379
                            arrayVal = scriptCode[scriptCodePtr++] + objectEntityPos;
3380
                        break;
3381

3382
                    case VARARR_ENTNOMINUS1:
3383
                        if (scriptCode[scriptCodePtr++] == 1)
3384
                            arrayVal = objectEntityPos - scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
3385
                        else
3386
                            arrayVal = objectEntityPos - scriptCode[scriptCodePtr++];
3387
                        break;
3388

3389
                    default: break;
3390
                }
3391

3392
#if RETRO_REV03 && !RETRO_USE_ORIGINAL_CODE
3393
                bool inputCheck = true; // Default to true for mobile bytecode
3394
                // If we're using the scripts or an Origins datafile, check the array value
3395
                if (forceUseScripts || Engine.usingOrigins)
3396
                    inputCheck = arrayVal <= 1;
3397
#endif
3398

3399
                // Variables
3400
                switch (scriptCode[scriptCodePtr++]) {
3401
                    default: break;
3402
                    case VAR_TEMP0: scriptEng.operands[i] = scriptEng.temp[0]; break;
3403
                    case VAR_TEMP1: scriptEng.operands[i] = scriptEng.temp[1]; break;
3404
                    case VAR_TEMP2: scriptEng.operands[i] = scriptEng.temp[2]; break;
3405
                    case VAR_TEMP3: scriptEng.operands[i] = scriptEng.temp[3]; break;
3406
                    case VAR_TEMP4: scriptEng.operands[i] = scriptEng.temp[4]; break;
3407
                    case VAR_TEMP5: scriptEng.operands[i] = scriptEng.temp[5]; break;
3408
                    case VAR_TEMP6: scriptEng.operands[i] = scriptEng.temp[6]; break;
3409
                    case VAR_TEMP7: scriptEng.operands[i] = scriptEng.temp[7]; break;
3410
                    case VAR_CHECKRESULT: scriptEng.operands[i] = scriptEng.checkResult; break;
3411
                    case VAR_ARRAYPOS0: scriptEng.operands[i] = scriptEng.arrayPosition[0]; break;
3412
                    case VAR_ARRAYPOS1: scriptEng.operands[i] = scriptEng.arrayPosition[1]; break;
3413
                    case VAR_ARRAYPOS2: scriptEng.operands[i] = scriptEng.arrayPosition[2]; break;
3414
                    case VAR_ARRAYPOS3: scriptEng.operands[i] = scriptEng.arrayPosition[3]; break;
3415
                    case VAR_ARRAYPOS4: scriptEng.operands[i] = scriptEng.arrayPosition[4]; break;
3416
                    case VAR_ARRAYPOS5: scriptEng.operands[i] = scriptEng.arrayPosition[5]; break;
3417
                    case VAR_ARRAYPOS6: scriptEng.operands[i] = scriptEng.arrayPosition[6]; break;
3418
                    case VAR_ARRAYPOS7: scriptEng.operands[i] = scriptEng.arrayPosition[7]; break;
3419
                    case VAR_GLOBAL: scriptEng.operands[i] = globalVariables[arrayVal]; break;
3420
                    case VAR_LOCAL: scriptEng.operands[i] = scriptCode[arrayVal]; break;
3421
                    case VAR_OBJECTENTITYPOS: scriptEng.operands[i] = arrayVal; break;
3422
                    case VAR_OBJECTGROUPID: {
3423
                        scriptEng.operands[i] = objectEntityList[arrayVal].groupID;
3424
                        break;
3425
                    }
3426
                    case VAR_OBJECTTYPE: {
3427
                        scriptEng.operands[i] = objectEntityList[arrayVal].type;
3428
                        break;
3429
                    }
3430
                    case VAR_OBJECTPROPERTYVALUE: {
3431
                        scriptEng.operands[i] = objectEntityList[arrayVal].propertyValue;
3432
                        break;
3433
                    }
3434
                    case VAR_OBJECTXPOS: {
3435
                        scriptEng.operands[i] = objectEntityList[arrayVal].xpos;
3436
                        break;
3437
                    }
3438
                    case VAR_OBJECTYPOS: {
3439
                        scriptEng.operands[i] = objectEntityList[arrayVal].ypos;
3440
                        break;
3441
                    }
3442
                    case VAR_OBJECTIXPOS: {
3443
                        scriptEng.operands[i] = objectEntityList[arrayVal].xpos >> 16;
3444
                        break;
3445
                    }
3446
                    case VAR_OBJECTIYPOS: {
3447
                        scriptEng.operands[i] = objectEntityList[arrayVal].ypos >> 16;
3448
                        break;
3449
                    }
3450
                    case VAR_OBJECTXVEL: {
3451
                        scriptEng.operands[i] = objectEntityList[arrayVal].xvel;
3452
                        break;
3453
                    }
3454
                    case VAR_OBJECTYVEL: {
3455
                        scriptEng.operands[i] = objectEntityList[arrayVal].yvel;
3456
                        break;
3457
                    }
3458
                    case VAR_OBJECTSPEED: {
3459
                        scriptEng.operands[i] = objectEntityList[arrayVal].speed;
3460
                        break;
3461
                    }
3462
                    case VAR_OBJECTSTATE: {
3463
                        scriptEng.operands[i] = objectEntityList[arrayVal].state;
3464
                        break;
3465
                    }
3466
                    case VAR_OBJECTROTATION: {
3467
                        scriptEng.operands[i] = objectEntityList[arrayVal].rotation;
3468
                        break;
3469
                    }
3470
                    case VAR_OBJECTSCALE: {
3471
                        scriptEng.operands[i] = objectEntityList[arrayVal].scale;
3472
                        break;
3473
                    }
3474
                    case VAR_OBJECTPRIORITY: {
3475
                        scriptEng.operands[i] = objectEntityList[arrayVal].priority;
3476
                        break;
3477
                    }
3478
                    case VAR_OBJECTDRAWORDER: {
3479
                        scriptEng.operands[i] = objectEntityList[arrayVal].drawOrder;
3480
                        break;
3481
                    }
3482
                    case VAR_OBJECTDIRECTION: {
3483
                        scriptEng.operands[i] = objectEntityList[arrayVal].direction;
3484
                        break;
3485
                    }
3486
                    case VAR_OBJECTINKEFFECT: {
3487
                        scriptEng.operands[i] = objectEntityList[arrayVal].inkEffect;
3488
                        break;
3489
                    }
3490
                    case VAR_OBJECTALPHA: {
3491
                        scriptEng.operands[i] = objectEntityList[arrayVal].alpha;
3492
                        break;
3493
                    }
3494
                    case VAR_OBJECTFRAME: {
3495
                        scriptEng.operands[i] = objectEntityList[arrayVal].frame;
3496
                        break;
3497
                    }
3498
                    case VAR_OBJECTANIMATION: {
3499
                        scriptEng.operands[i] = objectEntityList[arrayVal].animation;
3500
                        break;
3501
                    }
3502
                    case VAR_OBJECTPREVANIMATION: {
3503
                        scriptEng.operands[i] = objectEntityList[arrayVal].prevAnimation;
3504
                        break;
3505
                    }
3506
                    case VAR_OBJECTANIMATIONSPEED: {
3507
                        scriptEng.operands[i] = objectEntityList[arrayVal].animationSpeed;
3508
                        break;
3509
                    }
3510
                    case VAR_OBJECTANIMATIONTIMER: {
3511
                        scriptEng.operands[i] = objectEntityList[arrayVal].animationTimer;
3512
                        break;
3513
                    }
3514
                    case VAR_OBJECTANGLE: {
3515
                        scriptEng.operands[i] = objectEntityList[arrayVal].angle;
3516
                        break;
3517
                    }
3518
                    case VAR_OBJECTLOOKPOSX: {
3519
                        scriptEng.operands[i] = objectEntityList[arrayVal].lookPosX;
3520
                        break;
3521
                    }
3522
                    case VAR_OBJECTLOOKPOSY: {
3523
                        scriptEng.operands[i] = objectEntityList[arrayVal].lookPosY;
3524
                        break;
3525
                    }
3526
                    case VAR_OBJECTCOLLISIONMODE: {
3527
                        scriptEng.operands[i] = objectEntityList[arrayVal].collisionMode;
3528
                        break;
3529
                    }
3530
                    case VAR_OBJECTCOLLISIONPLANE: {
3531
                        scriptEng.operands[i] = objectEntityList[arrayVal].collisionPlane;
3532
                        break;
3533
                    }
3534
                    case VAR_OBJECTCONTROLMODE: {
3535
                        scriptEng.operands[i] = objectEntityList[arrayVal].controlMode;
3536
                        break;
3537
                    }
3538
                    case VAR_OBJECTCONTROLLOCK: {
3539
                        scriptEng.operands[i] = objectEntityList[arrayVal].controlLock;
3540
                        break;
3541
                    }
3542
                    case VAR_OBJECTPUSHING: {
3543
                        scriptEng.operands[i] = objectEntityList[arrayVal].pushing;
3544
                        break;
3545
                    }
3546
                    case VAR_OBJECTVISIBLE: {
3547
                        scriptEng.operands[i] = objectEntityList[arrayVal].visible;
3548
                        break;
3549
                    }
3550
                    case VAR_OBJECTTILECOLLISIONS: {
3551
                        scriptEng.operands[i] = objectEntityList[arrayVal].tileCollisions;
3552
                        break;
3553
                    }
3554
                    case VAR_OBJECTINTERACTION: {
3555
                        scriptEng.operands[i] = objectEntityList[arrayVal].objectInteractions;
3556
                        break;
3557
                    }
3558
                    case VAR_OBJECTGRAVITY: {
3559
                        scriptEng.operands[i] = objectEntityList[arrayVal].gravity;
3560
                        break;
3561
                    }
3562
                    case VAR_OBJECTUP: {
3563
                        scriptEng.operands[i] = objectEntityList[arrayVal].up;
3564
                        break;
3565
                    }
3566
                    case VAR_OBJECTDOWN: {
3567
                        scriptEng.operands[i] = objectEntityList[arrayVal].down;
3568
                        break;
3569
                    }
3570
                    case VAR_OBJECTLEFT: {
3571
                        scriptEng.operands[i] = objectEntityList[arrayVal].left;
3572
                        break;
3573
                    }
3574
                    case VAR_OBJECTRIGHT: {
3575
                        scriptEng.operands[i] = objectEntityList[arrayVal].right;
3576
                        break;
3577
                    }
3578
                    case VAR_OBJECTJUMPPRESS: {
3579
                        scriptEng.operands[i] = objectEntityList[arrayVal].jumpPress;
3580
                        break;
3581
                    }
3582
                    case VAR_OBJECTJUMPHOLD: {
3583
                        scriptEng.operands[i] = objectEntityList[arrayVal].jumpHold;
3584
                        break;
3585
                    }
3586
                    case VAR_OBJECTSCROLLTRACKING: {
3587
                        scriptEng.operands[i] = objectEntityList[arrayVal].scrollTracking;
3588
                        break;
3589
                    }
3590
                    case VAR_OBJECTFLOORSENSORL: {
3591
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[0];
3592
                        break;
3593
                    }
3594
                    case VAR_OBJECTFLOORSENSORC: {
3595
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[1];
3596
                        break;
3597
                    }
3598
                    case VAR_OBJECTFLOORSENSORR: {
3599
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[2];
3600
                        break;
3601
                    }
3602
#if !RETRO_REV00
3603
                    case VAR_OBJECTFLOORSENSORLC: {
3604
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[3];
3605
                        break;
3606
                    }
3607
                    case VAR_OBJECTFLOORSENSORRC: {
3608
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[4];
3609
                        break;
3610
                    }
3611
#endif
3612
                    case VAR_OBJECTCOLLISIONLEFT: {
3613
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3614
                        Entity *ent             = &objectEntityList[arrayVal];
3615
                        if (animFile) {
3616
                            int h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3617

3618
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].left[0];
3619
                        }
3620
                        else {
3621
                            scriptEng.operands[i] = 0;
3622
                        }
3623
                        break;
3624
                    }
3625
                    case VAR_OBJECTCOLLISIONTOP: {
3626
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3627
                        Entity *ent             = &objectEntityList[arrayVal];
3628
                        if (animFile) {
3629
                            int h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3630

3631
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].top[0];
3632
                        }
3633
                        else {
3634
                            scriptEng.operands[i] = 0;
3635
                        }
3636
                        break;
3637
                    }
3638
                    case VAR_OBJECTCOLLISIONRIGHT: {
3639
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3640
                        Entity *ent             = &objectEntityList[arrayVal];
3641
                        if (animFile) {
3642
                            int h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3643

3644
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].right[0];
3645
                        }
3646
                        else {
3647
                            scriptEng.operands[i] = 0;
3648
                        }
3649
                        break;
3650
                    }
3651
                    case VAR_OBJECTCOLLISIONBOTTOM: {
3652
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3653
                        Entity *ent             = &objectEntityList[arrayVal];
3654
                        if (animFile) {
3655
                            int h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3656

3657
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].bottom[0];
3658
                        }
3659
                        else {
3660
                            scriptEng.operands[i] = 0;
3661
                        }
3662
                        break;
3663
                    }
3664
                    case VAR_OBJECTOUTOFBOUNDS: {
3665
#if !RETRO_REV00
3666
                        int boundX1_2P = -(0x200 << 16);
3667
                        int boundX2_2P = (0x200 << 16);
3668
                        int boundX3_2P = -(0x180 << 16);
3669
                        int boundX4_2P = (0x180 << 16);
3670

3671
                        int boundY1_2P = -(0x180 << 16);
3672
                        int boundY2_2P = (0x180 << 16);
3673
                        int boundY3_2P = -(0x100 << 16);
3674
                        int boundY4_2P = (0x100 << 16);
3675

3676
                        Entity *entPtr = &objectEntityList[arrayVal];
3677
                        int x          = entPtr->xpos >> 16;
3678
                        int y          = entPtr->ypos >> 16;
3679

3680
                        if (entPtr->priority == PRIORITY_BOUNDS_SMALL || entPtr->priority == PRIORITY_ACTIVE_SMALL) {
3681
                            if (stageMode == STAGEMODE_2P) {
3682
                                x = entPtr->xpos;
3683
                                y = entPtr->ypos;
3684

3685
                                int boundL_P1 = objectEntityList[0].xpos + boundX3_2P;
3686
                                int boundR_P1 = objectEntityList[0].xpos + boundX4_2P;
3687
                                int boundT_P1 = objectEntityList[0].ypos + boundY3_2P;
3688
                                int boundB_P1 = objectEntityList[0].ypos + boundY4_2P;
3689

3690
                                int boundL_P2 = objectEntityList[1].xpos + boundX3_2P;
3691
                                int boundR_P2 = objectEntityList[1].xpos + boundX4_2P;
3692
                                int boundT_P2 = objectEntityList[1].ypos + boundY3_2P;
3693
                                int boundB_P2 = objectEntityList[1].ypos + boundY4_2P;
3694

3695
                                bool oobP1 = scriptEng.operands[i] = x <= boundL_P1 || x >= boundR_P1 || y <= boundT_P1 || y >= boundB_P1;
3696
                                bool oobP2 = scriptEng.operands[i] = x <= boundL_P2 || x >= boundR_P2 || y <= boundT_P2 || y >= boundB_P2;
3697

3698
                                scriptEng.operands[i] = oobP1 && oobP2;
3699
                            }
3700
                            else {
3701
                                int boundL = xScrollOffset - OBJECT_BORDER_X3;
3702
                                int boundR = xScrollOffset + OBJECT_BORDER_X4;
3703
                                int boundT = yScrollOffset - OBJECT_BORDER_Y3;
3704
                                int boundB = yScrollOffset + OBJECT_BORDER_Y4;
3705

3706
                                scriptEng.operands[i] = x <= boundL || x >= boundR || y <= boundT || y >= boundB;
3707
                            }
3708
                        }
3709
                        else {
3710
                            if (stageMode == STAGEMODE_2P) {
3711
                                x = entPtr->xpos;
3712
                                y = entPtr->ypos;
3713

3714
                                int boundL_P1 = objectEntityList[0].xpos + boundX1_2P;
3715
                                int boundR_P1 = objectEntityList[0].xpos + boundX2_2P;
3716
                                int boundT_P1 = objectEntityList[0].ypos + boundY1_2P;
3717
                                int boundB_P1 = objectEntityList[0].ypos + boundY2_2P;
3718

3719
                                int boundL_P2 = objectEntityList[1].xpos + boundX1_2P;
3720
                                int boundR_P2 = objectEntityList[1].xpos + boundX2_2P;
3721
                                int boundT_P2 = objectEntityList[1].ypos + boundY1_2P;
3722
                                int boundB_P2 = objectEntityList[1].ypos + boundY2_2P;
3723

3724
                                bool oobP1 = scriptEng.operands[i] = x <= boundL_P1 || x >= boundR_P1 || y <= boundT_P1 || y >= boundB_P1;
3725
                                bool oobP2 = scriptEng.operands[i] = x <= boundL_P2 || x >= boundR_P2 || y <= boundT_P2 || y >= boundB_P2;
3726

3727
                                scriptEng.operands[i] = oobP1 && oobP2;
3728
                            }
3729
                            else {
3730
                                int boundL = xScrollOffset - OBJECT_BORDER_X1;
3731
                                int boundR = xScrollOffset + OBJECT_BORDER_X2;
3732
                                int boundT = yScrollOffset - OBJECT_BORDER_Y1;
3733
                                int boundB = yScrollOffset + OBJECT_BORDER_Y2;
3734

3735
                                scriptEng.operands[i] = x <= boundL || x >= boundR || y <= boundT || y >= boundB;
3736
                            }
3737
                        }
3738
#else
3739
                        int x = objectEntityList[arrayVal].xpos >> 16;
3740
                        int y = objectEntityList[arrayVal].ypos >> 16;
3741

3742
                        int boundL = xScrollOffset - OBJECT_BORDER_X1;
3743
                        int boundR = xScrollOffset + OBJECT_BORDER_X2;
3744
                        int boundT = yScrollOffset - OBJECT_BORDER_Y1;
3745
                        int boundB = yScrollOffset + OBJECT_BORDER_Y2;
3746

3747
                        scriptEng.operands[i] = x <= boundL || x >= boundR || y <= boundT || y >= boundB;
3748
#endif
3749
                        break;
3750
                    }
3751
                    case VAR_OBJECTSPRITESHEET: {
3752
                        scriptEng.operands[i] = objectScriptList[objectEntityList[arrayVal].type].spriteSheetID;
3753
                        break;
3754
                    }
3755
                    case VAR_OBJECTVALUE0: {
3756
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[0];
3757
                        break;
3758
                    }
3759
                    case VAR_OBJECTVALUE1: {
3760
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[1];
3761
                        break;
3762
                    }
3763
                    case VAR_OBJECTVALUE2: {
3764
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[2];
3765
                        break;
3766
                    }
3767
                    case VAR_OBJECTVALUE3: {
3768
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[3];
3769
                        break;
3770
                    }
3771
                    case VAR_OBJECTVALUE4: {
3772
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[4];
3773
                        break;
3774
                    }
3775
                    case VAR_OBJECTVALUE5: {
3776
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[5];
3777
                        break;
3778
                    }
3779
                    case VAR_OBJECTVALUE6: {
3780
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[6];
3781
                        break;
3782
                    }
3783
                    case VAR_OBJECTVALUE7: {
3784
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[7];
3785
                        break;
3786
                    }
3787
                    case VAR_OBJECTVALUE8: {
3788
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[8];
3789
                        break;
3790
                    }
3791
                    case VAR_OBJECTVALUE9: {
3792
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[9];
3793
                        break;
3794
                    }
3795
                    case VAR_OBJECTVALUE10: {
3796
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[10];
3797
                        break;
3798
                    }
3799
                    case VAR_OBJECTVALUE11: {
3800
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[11];
3801
                        break;
3802
                    }
3803
                    case VAR_OBJECTVALUE12: {
3804
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[12];
3805
                        break;
3806
                    }
3807
                    case VAR_OBJECTVALUE13: {
3808
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[13];
3809
                        break;
3810
                    }
3811
                    case VAR_OBJECTVALUE14: {
3812
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[14];
3813
                        break;
3814
                    }
3815
                    case VAR_OBJECTVALUE15: {
3816
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[15];
3817
                        break;
3818
                    }
3819
                    case VAR_OBJECTVALUE16: {
3820
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[16];
3821
                        break;
3822
                    }
3823
                    case VAR_OBJECTVALUE17: {
3824
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[17];
3825
                        break;
3826
                    }
3827
                    case VAR_OBJECTVALUE18: {
3828
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[18];
3829
                        break;
3830
                    }
3831
                    case VAR_OBJECTVALUE19: {
3832
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[19];
3833
                        break;
3834
                    }
3835
                    case VAR_OBJECTVALUE20: {
3836
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[20];
3837
                        break;
3838
                    }
3839
                    case VAR_OBJECTVALUE21: {
3840
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[21];
3841
                        break;
3842
                    }
3843
                    case VAR_OBJECTVALUE22: {
3844
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[22];
3845
                        break;
3846
                    }
3847
                    case VAR_OBJECTVALUE23: {
3848
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[23];
3849
                        break;
3850
                    }
3851
                    case VAR_OBJECTVALUE24: {
3852
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[24];
3853
                        break;
3854
                    }
3855
                    case VAR_OBJECTVALUE25: {
3856
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[25];
3857
                        break;
3858
                    }
3859
                    case VAR_OBJECTVALUE26: {
3860
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[26];
3861
                        break;
3862
                    }
3863
                    case VAR_OBJECTVALUE27: {
3864
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[27];
3865
                        break;
3866
                    }
3867
                    case VAR_OBJECTVALUE28: {
3868
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[28];
3869
                        break;
3870
                    }
3871
                    case VAR_OBJECTVALUE29: {
3872
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[29];
3873
                        break;
3874
                    }
3875
                    case VAR_OBJECTVALUE30: {
3876
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[30];
3877
                        break;
3878
                    }
3879
                    case VAR_OBJECTVALUE31: {
3880
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[31];
3881
                        break;
3882
                    }
3883
                    case VAR_OBJECTVALUE32: {
3884
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[32];
3885
                        break;
3886
                    }
3887
                    case VAR_OBJECTVALUE33: {
3888
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[33];
3889
                        break;
3890
                    }
3891
                    case VAR_OBJECTVALUE34: {
3892
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[34];
3893
                        break;
3894
                    }
3895
                    case VAR_OBJECTVALUE35: {
3896
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[35];
3897
                        break;
3898
                    }
3899
                    case VAR_OBJECTVALUE36: {
3900
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[36];
3901
                        break;
3902
                    }
3903
                    case VAR_OBJECTVALUE37: {
3904
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[37];
3905
                        break;
3906
                    }
3907
                    case VAR_OBJECTVALUE38: {
3908
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[38];
3909
                        break;
3910
                    }
3911
                    case VAR_OBJECTVALUE39: {
3912
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[39];
3913
                        break;
3914
                    }
3915
                    case VAR_OBJECTVALUE40: {
3916
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[40];
3917
                        break;
3918
                    }
3919
                    case VAR_OBJECTVALUE41: {
3920
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[41];
3921
                        break;
3922
                    }
3923
                    case VAR_OBJECTVALUE42: {
3924
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[42];
3925
                        break;
3926
                    }
3927
                    case VAR_OBJECTVALUE43: {
3928
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[43];
3929
                        break;
3930
                    }
3931
                    case VAR_OBJECTVALUE44: {
3932
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[44];
3933
                        break;
3934
                    }
3935
                    case VAR_OBJECTVALUE45: {
3936
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[45];
3937
                        break;
3938
                    }
3939
                    case VAR_OBJECTVALUE46: {
3940
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[46];
3941
                        break;
3942
                    }
3943
                    case VAR_OBJECTVALUE47: {
3944
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[47];
3945
                        break;
3946
                    }
3947
                    case VAR_STAGESTATE: scriptEng.operands[i] = stageMode; break;
3948
                    case VAR_STAGEACTIVELIST: scriptEng.operands[i] = activeStageList; break;
3949
                    case VAR_STAGELISTPOS: scriptEng.operands[i] = stageListPosition; break;
3950
                    case VAR_STAGETIMEENABLED: scriptEng.operands[i] = timeEnabled; break;
3951
                    case VAR_STAGEMILLISECONDS: scriptEng.operands[i] = stageMilliseconds; break;
3952
                    case VAR_STAGESECONDS: scriptEng.operands[i] = stageSeconds; break;
3953
                    case VAR_STAGEMINUTES: scriptEng.operands[i] = stageMinutes; break;
3954
                    case VAR_STAGEACTNUM: scriptEng.operands[i] = actID; break;
3955
                    case VAR_STAGEPAUSEENABLED: scriptEng.operands[i] = pauseEnabled; break;
3956
                    case VAR_STAGELISTSIZE: scriptEng.operands[i] = stageListCount[activeStageList]; break;
3957
                    case VAR_STAGENEWXBOUNDARY1: scriptEng.operands[i] = newXBoundary1; break;
3958
                    case VAR_STAGENEWXBOUNDARY2: scriptEng.operands[i] = newXBoundary2; break;
3959
                    case VAR_STAGENEWYBOUNDARY1: scriptEng.operands[i] = newYBoundary1; break;
3960
                    case VAR_STAGENEWYBOUNDARY2: scriptEng.operands[i] = newYBoundary2; break;
3961
                    case VAR_STAGECURXBOUNDARY1: scriptEng.operands[i] = curXBoundary1; break;
3962
                    case VAR_STAGECURXBOUNDARY2: scriptEng.operands[i] = curXBoundary2; break;
3963
                    case VAR_STAGECURYBOUNDARY1: scriptEng.operands[i] = curYBoundary1; break;
3964
                    case VAR_STAGECURYBOUNDARY2: scriptEng.operands[i] = curYBoundary2; break;
3965
                    case VAR_STAGEDEFORMATIONDATA0: scriptEng.operands[i] = bgDeformationData0[arrayVal]; break;
3966
                    case VAR_STAGEDEFORMATIONDATA1: scriptEng.operands[i] = bgDeformationData1[arrayVal]; break;
3967
                    case VAR_STAGEDEFORMATIONDATA2: scriptEng.operands[i] = bgDeformationData2[arrayVal]; break;
3968
                    case VAR_STAGEDEFORMATIONDATA3: scriptEng.operands[i] = bgDeformationData3[arrayVal]; break;
3969
                    case VAR_STAGEWATERLEVEL: scriptEng.operands[i] = waterLevel; break;
3970
                    case VAR_STAGEACTIVELAYER: scriptEng.operands[i] = activeTileLayers[arrayVal]; break;
3971
                    case VAR_STAGEMIDPOINT: scriptEng.operands[i] = tLayerMidPoint; break;
3972
                    case VAR_STAGEPLAYERLISTPOS: scriptEng.operands[i] = playerListPos; break;
3973
                    case VAR_STAGEDEBUGMODE: scriptEng.operands[i] = debugMode; break;
3974
                    case VAR_STAGEENTITYPOS: scriptEng.operands[i] = objectEntityPos; break;
3975
                    case VAR_SCREENCAMERAENABLED: scriptEng.operands[i] = cameraEnabled; break;
3976
                    case VAR_SCREENCAMERATARGET: scriptEng.operands[i] = cameraTarget; break;
3977
                    case VAR_SCREENCAMERASTYLE: scriptEng.operands[i] = cameraStyle; break;
3978
                    case VAR_SCREENCAMERAX: scriptEng.operands[i] = cameraXPos; break;
3979
                    case VAR_SCREENCAMERAY: scriptEng.operands[i] = cameraYPos; break;
3980
                    case VAR_SCREENDRAWLISTSIZE: scriptEng.operands[i] = drawListEntries[arrayVal].listSize; break;
3981
                    case VAR_SCREENXCENTER: scriptEng.operands[i] = SCREEN_CENTERX; break;
3982
                    case VAR_SCREENYCENTER: scriptEng.operands[i] = SCREEN_CENTERY; break;
3983
                    case VAR_SCREENXSIZE: scriptEng.operands[i] = SCREEN_XSIZE; break;
3984
                    case VAR_SCREENYSIZE: scriptEng.operands[i] = SCREEN_YSIZE; break;
3985
                    case VAR_SCREENXOFFSET: scriptEng.operands[i] = xScrollOffset; break;
3986
                    case VAR_SCREENYOFFSET: scriptEng.operands[i] = yScrollOffset; break;
3987
                    case VAR_SCREENSHAKEX: scriptEng.operands[i] = cameraShakeX; break;
3988
                    case VAR_SCREENSHAKEY: scriptEng.operands[i] = cameraShakeY; break;
3989
                    case VAR_SCREENADJUSTCAMERAY: scriptEng.operands[i] = cameraAdjustY; break;
3990
                    case VAR_TOUCHSCREENDOWN: scriptEng.operands[i] = touchDown[arrayVal]; break;
3991
                    case VAR_TOUCHSCREENXPOS: scriptEng.operands[i] = touchX[arrayVal]; break;
3992
                    case VAR_TOUCHSCREENYPOS: scriptEng.operands[i] = touchY[arrayVal]; break;
3993
                    case VAR_MUSICVOLUME: scriptEng.operands[i] = masterVolume; break;
3994
                    case VAR_MUSICCURRENTTRACK: scriptEng.operands[i] = trackID; break;
3995
                    case VAR_MUSICPOSITION: scriptEng.operands[i] = musicPosition; break;
3996
#if RETRO_REV03 && !RETRO_USE_ORIGINAL_CODE
3997
                    case VAR_KEYDOWNUP: scriptEng.operands[i] = keyDown.up && inputCheck; break;
3998
                    case VAR_KEYDOWNDOWN: scriptEng.operands[i] = keyDown.down && inputCheck; break;
3999
                    case VAR_KEYDOWNLEFT: scriptEng.operands[i] = keyDown.left && inputCheck; break;
4000
                    case VAR_KEYDOWNRIGHT: scriptEng.operands[i] = keyDown.right && inputCheck; break;
4001
                    case VAR_KEYDOWNBUTTONA: scriptEng.operands[i] = keyDown.A && inputCheck; break;
4002
                    case VAR_KEYDOWNBUTTONB: scriptEng.operands[i] = keyDown.B && inputCheck; break;
4003
                    case VAR_KEYDOWNBUTTONC: scriptEng.operands[i] = keyDown.C && inputCheck; break;
4004
                    case VAR_KEYDOWNBUTTONX: scriptEng.operands[i] = keyDown.X && inputCheck; break;
4005
                    case VAR_KEYDOWNBUTTONY: scriptEng.operands[i] = keyDown.Y && inputCheck; break;
4006
                    case VAR_KEYDOWNBUTTONZ: scriptEng.operands[i] = keyDown.Z && inputCheck; break;
4007
                    case VAR_KEYDOWNBUTTONL: scriptEng.operands[i] = keyDown.L && inputCheck; break;
4008
                    case VAR_KEYDOWNBUTTONR: scriptEng.operands[i] = keyDown.R && inputCheck; break;
4009
                    case VAR_KEYDOWNSTART: scriptEng.operands[i] = keyDown.start && inputCheck; break;
4010
                    case VAR_KEYDOWNSELECT: scriptEng.operands[i] = keyDown.select && inputCheck; break;
4011
                    case VAR_KEYPRESSUP: scriptEng.operands[i] = keyPress.up && inputCheck; break;
4012
                    case VAR_KEYPRESSDOWN: scriptEng.operands[i] = keyPress.down && inputCheck; break;
4013
                    case VAR_KEYPRESSLEFT: scriptEng.operands[i] = keyPress.left && inputCheck; break;
4014
                    case VAR_KEYPRESSRIGHT: scriptEng.operands[i] = keyPress.right && inputCheck; break;
4015
                    case VAR_KEYPRESSBUTTONA: scriptEng.operands[i] = keyPress.A && inputCheck; break;
4016
                    case VAR_KEYPRESSBUTTONB: scriptEng.operands[i] = keyPress.B && inputCheck; break;
4017
                    case VAR_KEYPRESSBUTTONC: scriptEng.operands[i] = keyPress.C && inputCheck; break;
4018
                    case VAR_KEYPRESSBUTTONX: scriptEng.operands[i] = keyPress.X && inputCheck; break;
4019
                    case VAR_KEYPRESSBUTTONY: scriptEng.operands[i] = keyPress.Y && inputCheck; break;
4020
                    case VAR_KEYPRESSBUTTONZ: scriptEng.operands[i] = keyPress.Z && inputCheck; break;
4021
                    case VAR_KEYPRESSBUTTONL: scriptEng.operands[i] = keyPress.L && inputCheck; break;
4022
                    case VAR_KEYPRESSBUTTONR: scriptEng.operands[i] = keyPress.R && inputCheck; break;
4023
                    case VAR_KEYPRESSSTART: scriptEng.operands[i] = keyPress.start && inputCheck; break;
4024
                    case VAR_KEYPRESSSELECT: scriptEng.operands[i] = keyPress.select && inputCheck; break;
4025
#else
4026
                    case VAR_KEYDOWNUP: scriptEng.operands[i] = keyDown.up; break;
4027
                    case VAR_KEYDOWNDOWN: scriptEng.operands[i] = keyDown.down; break;
4028
                    case VAR_KEYDOWNLEFT: scriptEng.operands[i] = keyDown.left; break;
4029
                    case VAR_KEYDOWNRIGHT: scriptEng.operands[i] = keyDown.right; break;
4030
                    case VAR_KEYDOWNBUTTONA: scriptEng.operands[i] = keyDown.A; break;
4031
                    case VAR_KEYDOWNBUTTONB: scriptEng.operands[i] = keyDown.B; break;
4032
                    case VAR_KEYDOWNBUTTONC: scriptEng.operands[i] = keyDown.C; break;
4033
                    case VAR_KEYDOWNBUTTONX: scriptEng.operands[i] = keyDown.X; break;
4034
                    case VAR_KEYDOWNBUTTONY: scriptEng.operands[i] = keyDown.Y; break;
4035
                    case VAR_KEYDOWNBUTTONZ: scriptEng.operands[i] = keyDown.Z; break;
4036
                    case VAR_KEYDOWNBUTTONL: scriptEng.operands[i] = keyDown.L; break;
4037
                    case VAR_KEYDOWNBUTTONR: scriptEng.operands[i] = keyDown.R; break;
4038
                    case VAR_KEYDOWNSTART: scriptEng.operands[i] = keyDown.start; break;
4039
                    case VAR_KEYDOWNSELECT: scriptEng.operands[i] = keyDown.select; break;
4040
                    case VAR_KEYPRESSUP: scriptEng.operands[i] = keyPress.up; break;
4041
                    case VAR_KEYPRESSDOWN: scriptEng.operands[i] = keyPress.down; break;
4042
                    case VAR_KEYPRESSLEFT: scriptEng.operands[i] = keyPress.left; break;
4043
                    case VAR_KEYPRESSRIGHT: scriptEng.operands[i] = keyPress.right; break;
4044
                    case VAR_KEYPRESSBUTTONA: scriptEng.operands[i] = keyPress.A; break;
4045
                    case VAR_KEYPRESSBUTTONB: scriptEng.operands[i] = keyPress.B; break;
4046
                    case VAR_KEYPRESSBUTTONC: scriptEng.operands[i] = keyPress.C; break;
4047
                    case VAR_KEYPRESSBUTTONX: scriptEng.operands[i] = keyPress.X; break;
4048
                    case VAR_KEYPRESSBUTTONY: scriptEng.operands[i] = keyPress.Y; break;
4049
                    case VAR_KEYPRESSBUTTONZ: scriptEng.operands[i] = keyPress.Z; break;
4050
                    case VAR_KEYPRESSBUTTONL: scriptEng.operands[i] = keyPress.L; break;
4051
                    case VAR_KEYPRESSBUTTONR: scriptEng.operands[i] = keyPress.R; break;
4052
                    case VAR_KEYPRESSSTART: scriptEng.operands[i] = keyPress.start; break;
4053
                    case VAR_KEYPRESSSELECT: scriptEng.operands[i] = keyPress.select; break;
4054
#endif
4055
                    case VAR_MENU1SELECTION: scriptEng.operands[i] = gameMenu[0].selection1; break;
4056
                    case VAR_MENU2SELECTION: scriptEng.operands[i] = gameMenu[1].selection1; break;
4057
                    case VAR_TILELAYERXSIZE: scriptEng.operands[i] = stageLayouts[arrayVal].xsize; break;
4058
                    case VAR_TILELAYERYSIZE: scriptEng.operands[i] = stageLayouts[arrayVal].ysize; break;
4059
                    case VAR_TILELAYERTYPE: scriptEng.operands[i] = stageLayouts[arrayVal].type; break;
4060
                    case VAR_TILELAYERANGLE: scriptEng.operands[i] = stageLayouts[arrayVal].angle; break;
4061
                    case VAR_TILELAYERXPOS: scriptEng.operands[i] = stageLayouts[arrayVal].xpos; break;
4062
                    case VAR_TILELAYERYPOS: scriptEng.operands[i] = stageLayouts[arrayVal].ypos; break;
4063
                    case VAR_TILELAYERZPOS: scriptEng.operands[i] = stageLayouts[arrayVal].zpos; break;
4064
                    case VAR_TILELAYERPARALLAXFACTOR: scriptEng.operands[i] = stageLayouts[arrayVal].parallaxFactor; break;
4065
                    case VAR_TILELAYERSCROLLSPEED: scriptEng.operands[i] = stageLayouts[arrayVal].scrollSpeed; break;
4066
                    case VAR_TILELAYERSCROLLPOS: scriptEng.operands[i] = stageLayouts[arrayVal].scrollPos; break;
4067
                    case VAR_TILELAYERDEFORMATIONOFFSET: scriptEng.operands[i] = stageLayouts[arrayVal].deformationOffset; break;
4068
                    case VAR_TILELAYERDEFORMATIONOFFSETW: scriptEng.operands[i] = stageLayouts[arrayVal].deformationOffsetW; break;
4069
                    case VAR_HPARALLAXPARALLAXFACTOR: scriptEng.operands[i] = hParallax.parallaxFactor[arrayVal]; break;
4070
                    case VAR_HPARALLAXSCROLLSPEED: scriptEng.operands[i] = hParallax.scrollSpeed[arrayVal]; break;
4071
                    case VAR_HPARALLAXSCROLLPOS: scriptEng.operands[i] = hParallax.scrollPos[arrayVal]; break;
4072
                    case VAR_VPARALLAXPARALLAXFACTOR: scriptEng.operands[i] = vParallax.parallaxFactor[arrayVal]; break;
4073
                    case VAR_VPARALLAXSCROLLSPEED: scriptEng.operands[i] = vParallax.scrollSpeed[arrayVal]; break;
4074
                    case VAR_VPARALLAXSCROLLPOS: scriptEng.operands[i] = vParallax.scrollPos[arrayVal]; break;
4075
                    case VAR_SCENE3DVERTEXCOUNT: scriptEng.operands[i] = vertexCount; break;
4076
                    case VAR_SCENE3DFACECOUNT: scriptEng.operands[i] = faceCount; break;
4077
                    case VAR_SCENE3DPROJECTIONX: scriptEng.operands[i] = projectionX; break;
4078
                    case VAR_SCENE3DPROJECTIONY: scriptEng.operands[i] = projectionY; break;
4079
#if !RETRO_REV00
4080
                    case VAR_SCENE3DFOGCOLOR: scriptEng.operands[i] = fogColor; break;
4081
                    case VAR_SCENE3DFOGSTRENGTH: scriptEng.operands[i] = fogStrength; break;
4082
#endif
4083
                    case VAR_VERTEXBUFFERX: scriptEng.operands[i] = vertexBuffer[arrayVal].x; break;
4084
                    case VAR_VERTEXBUFFERY: scriptEng.operands[i] = vertexBuffer[arrayVal].y; break;
4085
                    case VAR_VERTEXBUFFERZ: scriptEng.operands[i] = vertexBuffer[arrayVal].z; break;
4086
                    case VAR_VERTEXBUFFERU: scriptEng.operands[i] = vertexBuffer[arrayVal].u; break;
4087
                    case VAR_VERTEXBUFFERV: scriptEng.operands[i] = vertexBuffer[arrayVal].v; break;
4088
                    case VAR_FACEBUFFERA: scriptEng.operands[i] = faceBuffer[arrayVal].a; break;
4089
                    case VAR_FACEBUFFERB: scriptEng.operands[i] = faceBuffer[arrayVal].b; break;
4090
                    case VAR_FACEBUFFERC: scriptEng.operands[i] = faceBuffer[arrayVal].c; break;
4091
                    case VAR_FACEBUFFERD: scriptEng.operands[i] = faceBuffer[arrayVal].d; break;
4092
                    case VAR_FACEBUFFERFLAG: scriptEng.operands[i] = faceBuffer[arrayVal].flag; break;
4093
                    case VAR_FACEBUFFERCOLOR: scriptEng.operands[i] = faceBuffer[arrayVal].color; break;
4094
                    case VAR_SAVERAM: scriptEng.operands[i] = saveRAM[arrayVal]; break;
4095
                    case VAR_ENGINESTATE: scriptEng.operands[i] = Engine.gameMode; break;
4096
#if RETRO_REV00
4097
                    case VAR_ENGINEMESSAGE: scriptEng.operands[i] = Engine.message; break;
4098
#endif
4099
                    case VAR_ENGINELANGUAGE: scriptEng.operands[i] = Engine.language; break;
4100
                    case VAR_ENGINEONLINEACTIVE: scriptEng.operands[i] = Engine.onlineActive; break;
4101
                    case VAR_ENGINESFXVOLUME: scriptEng.operands[i] = sfxVolume; break;
4102
                    case VAR_ENGINEBGMVOLUME: scriptEng.operands[i] = bgmVolume; break;
4103
#if RETRO_REV00
4104
                    case VAR_ENGINEPLATFORMID: scriptEng.operands[i] = RETRO_GAMEPLATFORMID; break;
4105
#endif
4106
                    case VAR_ENGINETRIALMODE: scriptEng.operands[i] = Engine.trialMode; break;
4107
#if !RETRO_REV00
4108
                    case VAR_ENGINEDEVICETYPE: scriptEng.operands[i] = RETRO_DEVICETYPE; break;
4109
#endif
4110

4111
#if RETRO_REV03
4112
                    // Origins Extras
4113
                    // Due to using regular v4, these don't support array values like origins expects, so its always screen[0]
4114
                    case VAR_SCREENCURRENTID: scriptEng.operands[i] = 0; break;
4115
                    case VAR_CAMERAENABLED:
4116
                        if (arrayVal == 0)
4117
                            scriptEng.operands[i] = cameraEnabled;
4118
                        else
4119
                            scriptEng.operands[i] = 0;
4120
                        break;
4121
                    case VAR_CAMERATARGET:
4122
                        if (arrayVal == 0)
4123
                            scriptEng.operands[i] = cameraTarget;
4124
                        else
4125
                            scriptEng.operands[i] = 0;
4126
                        break;
4127
                    case VAR_CAMERASTYLE:
4128
                        if (arrayVal == 0)
4129
                            scriptEng.operands[i] = cameraStyle;
4130
                        else
4131
                            scriptEng.operands[i] = 0;
4132
                        break;
4133
                    case VAR_CAMERAXPOS:
4134
                        if (arrayVal == 0)
4135
                            scriptEng.operands[i] = cameraXPos;
4136
                        else
4137
                            scriptEng.operands[i] = 0;
4138
                        break;
4139
                    case VAR_CAMERAYPOS:
4140
                        if (arrayVal == 0)
4141
                            scriptEng.operands[i] = cameraYPos;
4142
                        else
4143
                            scriptEng.operands[i] = 0;
4144
                        break;
4145
                    case VAR_CAMERAADJUSTY:
4146
                        if (arrayVal == 0)
4147
                            scriptEng.operands[i] = cameraAdjustY;
4148
                        else
4149
                            scriptEng.operands[i] = 0;
4150
                        break;
4151
#endif
4152

4153
#if RETRO_USE_HAPTICS
4154
                    case VAR_HAPTICSENABLED: scriptEng.operands[i] = Engine.hapticsEnabled; break;
4155
#endif
4156
                }
4157
            }
4158
            else if (opcodeType == SCRIPTVAR_INTCONST) { // int constant
4159
                scriptEng.operands[i] = scriptCode[scriptCodePtr++];
4160
            }
4161
            else if (opcodeType == SCRIPTVAR_STRCONST) { // string constant
4162
                int strLen         = scriptCode[scriptCodePtr++];
4163
                scriptText[strLen] = 0;
4164
                for (int c = 0; c < strLen; ++c) {
4165
                    switch (c % 4) {
4166
                        case 0: 
4167
                            scriptText[c] = scriptCode[scriptCodePtr] >> 24;
4168
                            break;
4169

4170
                        case 1: 
4171
                            scriptText[c] = (0xFFFFFF & scriptCode[scriptCodePtr]) >> 16;
4172
                            break;
4173

4174
                        case 2: 
4175
                            scriptText[c] = (0xFFFF & scriptCode[scriptCodePtr]) >> 8;
4176
                            break;
4177

4178
                        case 3: 
4179
                            scriptText[c] = scriptCode[scriptCodePtr++];
4180
                            break;
4181

4182
                        default: break;
4183
                    }
4184
                }
4185
                scriptCodePtr++;
4186
            }
4187
        }
4188

4189
        ObjectScript *scriptInfo = &objectScriptList[objectEntityList[objectEntityPos].type];
4190
        Entity *entity           = &objectEntityList[objectEntityPos];
4191
        SpriteFrame *spriteFrame = nullptr;
4192

4193
        // Functions
4194
        switch (opcode) {
4195
            default: break;
4196
            case FUNC_END: running = false; break;
4197
            case FUNC_EQUAL: scriptEng.operands[0] = scriptEng.operands[1]; break;
4198
            case FUNC_ADD: scriptEng.operands[0] += scriptEng.operands[1]; break;
4199
            case FUNC_SUB: scriptEng.operands[0] -= scriptEng.operands[1]; break;
4200
            case FUNC_INC: ++scriptEng.operands[0]; break;
4201
            case FUNC_DEC: --scriptEng.operands[0]; break;
4202
            case FUNC_MUL: scriptEng.operands[0] *= scriptEng.operands[1]; break;
4203
            case FUNC_DIV: scriptEng.operands[0] /= scriptEng.operands[1]; break;
4204
            case FUNC_SHR: scriptEng.operands[0] >>= scriptEng.operands[1]; break;
4205
            case FUNC_SHL: scriptEng.operands[0] <<= scriptEng.operands[1]; break;
4206
            case FUNC_AND: scriptEng.operands[0] &= scriptEng.operands[1]; break;
4207
            case FUNC_OR: scriptEng.operands[0] |= scriptEng.operands[1]; break;
4208
            case FUNC_XOR: scriptEng.operands[0] ^= scriptEng.operands[1]; break;
4209
            case FUNC_MOD: scriptEng.operands[0] %= scriptEng.operands[1]; break;
4210
            case FUNC_FLIPSIGN: scriptEng.operands[0] = -scriptEng.operands[0]; break;
4211
            case FUNC_CHECKEQUAL:
4212
                scriptEng.checkResult = scriptEng.operands[0] == scriptEng.operands[1];
4213
                opcodeSize            = 0;
4214
                break;
4215
            case FUNC_CHECKGREATER:
4216
                scriptEng.checkResult = scriptEng.operands[0] > scriptEng.operands[1];
4217
                opcodeSize            = 0;
4218
                break;
4219
            case FUNC_CHECKLOWER:
4220
                scriptEng.checkResult = scriptEng.operands[0] < scriptEng.operands[1];
4221
                opcodeSize            = 0;
4222
                break;
4223
            case FUNC_CHECKNOTEQUAL:
4224
                scriptEng.checkResult = scriptEng.operands[0] != scriptEng.operands[1];
4225
                opcodeSize            = 0;
4226
                break;
4227
            case FUNC_IFEQUAL:
4228
                if (scriptEng.operands[1] != scriptEng.operands[2])
4229
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
4230
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4231
                opcodeSize                          = 0;
4232
                break;
4233
            case FUNC_IFGREATER:
4234
                if (scriptEng.operands[1] <= scriptEng.operands[2])
4235
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
4236
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4237
                opcodeSize                          = 0;
4238
                break;
4239
            case FUNC_IFGREATEROREQUAL:
4240
                if (scriptEng.operands[1] < scriptEng.operands[2])
4241
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
4242
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4243
                opcodeSize                          = 0;
4244
                break;
4245
            case FUNC_IFLOWER:
4246
                if (scriptEng.operands[1] >= scriptEng.operands[2])
4247
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
4248
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4249
                opcodeSize                          = 0;
4250
                break;
4251
            case FUNC_IFLOWEROREQUAL:
4252
                if (scriptEng.operands[1] > scriptEng.operands[2])
4253
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
4254
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4255
                opcodeSize                          = 0;
4256
                break;
4257
            case FUNC_IFNOTEQUAL:
4258
                if (scriptEng.operands[1] == scriptEng.operands[2])
4259
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
4260
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4261
                opcodeSize                          = 0;
4262
                break;
4263
            case FUNC_ELSE:
4264
                opcodeSize    = 0;
4265
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--] + 1];
4266
                break;
4267
            case FUNC_ENDIF:
4268
                opcodeSize = 0;
4269
                --jumpTableStackPos;
4270
                break;
4271
            case FUNC_WEQUAL:
4272
                if (scriptEng.operands[1] != scriptEng.operands[2])
4273
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4274
                else
4275
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4276
                opcodeSize = 0;
4277
                break;
4278
            case FUNC_WGREATER:
4279
                if (scriptEng.operands[1] <= scriptEng.operands[2])
4280
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4281
                else
4282
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4283
                opcodeSize = 0;
4284
                break;
4285
            case FUNC_WGREATEROREQUAL:
4286
                if (scriptEng.operands[1] < scriptEng.operands[2])
4287
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4288
                else
4289
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4290
                opcodeSize = 0;
4291
                break;
4292
            case FUNC_WLOWER:
4293
                if (scriptEng.operands[1] >= scriptEng.operands[2])
4294
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4295
                else
4296
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4297
                opcodeSize = 0;
4298
                break;
4299
            case FUNC_WLOWEROREQUAL:
4300
                if (scriptEng.operands[1] > scriptEng.operands[2])
4301
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4302
                else
4303
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4304
                opcodeSize = 0;
4305
                break;
4306
            case FUNC_WNOTEQUAL:
4307
                if (scriptEng.operands[1] == scriptEng.operands[2])
4308
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4309
                else
4310
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4311
                opcodeSize = 0;
4312
                break;
4313
            case FUNC_LOOP:
4314
                opcodeSize    = 0;
4315
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--]];
4316
                break;
4317
            case FUNC_FOREACHACTIVE: {
4318
                int groupID = scriptEng.operands[1];
4319
                if (groupID < TYPEGROUP_COUNT) {
4320
                    int loop                      = foreachStack[++foreachStackPos] + 1;
4321
                    foreachStack[foreachStackPos] = loop;
4322
                    if (loop >= objectTypeGroupList[groupID].listSize) {
4323
                        opcodeSize                      = 0;
4324
                        foreachStack[foreachStackPos--] = -1;
4325
                        scriptCodePtr                   = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4326
                        break;
4327
                    }
4328
                    else {
4329
                        scriptEng.operands[2]               = objectTypeGroupList[groupID].entityRefs[loop];
4330
                        jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4331
                    }
4332
                }
4333
                else {
4334
                    opcodeSize    = 0;
4335
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4336
                }
4337
                break;
4338
            }
4339
            case FUNC_FOREACHALL: {
4340
                int objType = scriptEng.operands[1];
4341
                if (objType < OBJECT_COUNT) {
4342
                    int loop                      = foreachStack[++foreachStackPos] + 1;
4343
                    foreachStack[foreachStackPos] = loop;
4344

4345
                    if (scriptEvent == EVENT_SETUP) {
4346
                        while (true) {
4347
                            if (loop >= TEMPENTITY_START) {
4348
                                opcodeSize                      = 0;
4349
                                foreachStack[foreachStackPos--] = -1;
4350
                                scriptCodePtr                   = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4351
                                break;
4352
                            }
4353
                            else if (objType == objectEntityList[loop].type) {
4354
                                scriptEng.operands[2]               = loop;
4355
                                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4356
                                break;
4357
                            }
4358
                            else {
4359
                                foreachStack[foreachStackPos] = ++loop;
4360
                            }
4361
                        }
4362
                    }
4363
                    else {
4364
                        while (true) {
4365
                            if (loop >= ENTITY_COUNT) {
4366
                                opcodeSize                      = 0;
4367
                                foreachStack[foreachStackPos--] = -1;
4368
                                scriptCodePtr                   = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4369
                                break;
4370
                            }
4371
                            else if (objType == objectEntityList[loop].type) {
4372
                                scriptEng.operands[2]               = loop;
4373
                                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4374
                                break;
4375
                            }
4376
                            else {
4377
                                foreachStack[foreachStackPos] = ++loop;
4378
                            }
4379
                        }
4380
                    }
4381
                }
4382
                else {
4383
                    opcodeSize    = 0;
4384
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4385
                }
4386
                break;
4387
            }
4388
            case FUNC_NEXT:
4389
                opcodeSize    = 0;
4390
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--]];
4391
                --foreachStackPos;
4392
                break;
4393
            case FUNC_SWITCH:
4394
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4395
                if (scriptEng.operands[1] < jumpTable[jumpTableStart + scriptEng.operands[0]]
4396
                    || scriptEng.operands[1] > jumpTable[jumpTableStart + scriptEng.operands[0] + 1])
4397
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 2];
4398
                else
4399
                    scriptCodePtr = scriptCodeStart
4400
                                    + jumpTable[jumpTableStart + scriptEng.operands[0] + 4
4401
                                                    + (scriptEng.operands[1] - jumpTable[jumpTableStart + scriptEng.operands[0]])];
4402
                opcodeSize = 0;
4403
                break;
4404
            case FUNC_BREAK:
4405
                opcodeSize    = 0;
4406
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--] + 3];
4407
                break;
4408
            case FUNC_ENDSWITCH:
4409
                opcodeSize = 0;
4410
                --jumpTableStackPos;
4411
                break;
4412
            case FUNC_RAND: scriptEng.operands[0] = rand() % scriptEng.operands[1]; break;
4413
            case FUNC_SIN: {
4414
                scriptEng.operands[0] = Sin512(scriptEng.operands[1]);
4415
                break;
4416
            }
4417
            case FUNC_COS: {
4418
                scriptEng.operands[0] = Cos512(scriptEng.operands[1]);
4419
                break;
4420
            }
4421
            case FUNC_SIN256: {
4422
                scriptEng.operands[0] = Sin256(scriptEng.operands[1]);
4423
                break;
4424
            }
4425
            case FUNC_COS256: {
4426
                scriptEng.operands[0] = Cos256(scriptEng.operands[1]);
4427
                break;
4428
            }
4429
            case FUNC_ATAN2: {
4430
                scriptEng.operands[0] = ArcTanLookup(scriptEng.operands[1], scriptEng.operands[2]);
4431
                break;
4432
            }
4433
            case FUNC_INTERPOLATE:
4434
                scriptEng.operands[0] =
4435
                    (scriptEng.operands[2] * (0x100 - scriptEng.operands[3]) + scriptEng.operands[3] * scriptEng.operands[1]) >> 8;
4436
                break;
4437
            case FUNC_INTERPOLATEXY:
4438
                scriptEng.operands[0] =
4439
                    (scriptEng.operands[3] * (0x100 - scriptEng.operands[6]) >> 8) + ((scriptEng.operands[6] * scriptEng.operands[2]) >> 8);
4440
                scriptEng.operands[1] =
4441
                    (scriptEng.operands[5] * (0x100 - scriptEng.operands[6]) >> 8) + (scriptEng.operands[6] * scriptEng.operands[4] >> 8);
4442
                break;
4443
            case FUNC_LOADSPRITESHEET:
4444
                opcodeSize                = 0;
4445
                scriptInfo->spriteSheetID = AddGraphicsFile(scriptText);
4446
                break;
4447
            case FUNC_REMOVESPRITESHEET:
4448
                opcodeSize = 0;
4449
                RemoveGraphicsFile(scriptText, -1);
4450
                break;
4451
            case FUNC_DRAWSPRITE:
4452
                opcodeSize  = 0;
4453
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4454
                DrawSprite((entity->xpos >> 16) - xScrollOffset + spriteFrame->pivotX, (entity->ypos >> 16) - yScrollOffset + spriteFrame->pivotY,
4455
                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4456
                break;
4457
            case FUNC_DRAWSPRITEXY:
4458
                opcodeSize  = 0;
4459
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4460
                DrawSprite((scriptEng.operands[1] >> 16) - xScrollOffset + spriteFrame->pivotX,
4461
                           (scriptEng.operands[2] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width, spriteFrame->height,
4462
                           spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4463
                break;
4464
            case FUNC_DRAWSPRITESCREENXY:
4465
                opcodeSize  = 0;
4466
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4467
                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY, spriteFrame->width,
4468
                           spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4469
                break;
4470
            case FUNC_DRAWTINTRECT:
4471
                opcodeSize = 0;
4472
                DrawTintRectangle(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
4473
                break;
4474
            case FUNC_DRAWNUMBERS: {
4475
                opcodeSize = 0;
4476
                int i      = 10;
4477
                if (scriptEng.operands[6]) {
4478
                    while (scriptEng.operands[4] > 0) {
4479
                        int frameID = scriptEng.operands[3] % i / (i / 10) + scriptEng.operands[0];
4480
                        spriteFrame = &scriptFrames[scriptInfo->frameListOffset + frameID];
4481
                        DrawSprite(spriteFrame->pivotX + scriptEng.operands[1], spriteFrame->pivotY + scriptEng.operands[2], spriteFrame->width,
4482
                                   spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4483
                        scriptEng.operands[1] -= scriptEng.operands[5];
4484
                        i *= 10;
4485
                        --scriptEng.operands[4];
4486
                    }
4487
                }
4488
                else {
4489
                    int extra = 10;
4490
                    if (scriptEng.operands[3])
4491
                        extra = 10 * scriptEng.operands[3];
4492
                    while (scriptEng.operands[4] > 0) {
4493
                        if (extra >= i) {
4494
                            int frameID = scriptEng.operands[3] % i / (i / 10) + scriptEng.operands[0];
4495
                            spriteFrame = &scriptFrames[scriptInfo->frameListOffset + frameID];
4496
                            DrawSprite(spriteFrame->pivotX + scriptEng.operands[1], spriteFrame->pivotY + scriptEng.operands[2], spriteFrame->width,
4497
                                       spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4498
                        }
4499
                        scriptEng.operands[1] -= scriptEng.operands[5];
4500
                        i *= 10;
4501
                        --scriptEng.operands[4];
4502
                    }
4503
                }
4504
                break;
4505
            }
4506
            case FUNC_DRAWACTNAME: {
4507
                opcodeSize = 0;
4508
                int charID = 0;
4509
                switch (scriptEng.operands[3]) { // Draw Mode
4510
                    case 0:                      // Draw Word 1 (but aligned from the right instead of left)
4511
                        charID = 0;
4512

4513
                        for (charID = 0;; ++charID) {
4514
                            int nextChar = titleCardText[charID + 1];
4515
                            if (nextChar == '-' || !nextChar)
4516
                                break;
4517
                        }
4518

4519
                        while (charID >= 0) {
4520
                            int character = titleCardText[charID];
4521
                            if (character == ' ')
4522
                                character = -1; // special space char
4523
                            if (character == '-')
4524
                                character = 0;
4525
                            if (character >= '0' && character <= '9')
4526
                                character -= 22;
4527
                            if (character > '9' && character < 'f')
4528
                                character -= 'A';
4529

4530
                            if (character <= -1) {
4531
                                scriptEng.operands[1] -= scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4532
                            }
4533
                            else {
4534
                                character += scriptEng.operands[0];
4535
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4536

4537
                                scriptEng.operands[1] -= spriteFrame->width + scriptEng.operands[6];
4538

4539
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4540
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4541
                            }
4542
                            charID--;
4543
                        }
4544
                        break;
4545

4546
                    case 1: // Draw Word 1
4547
                        charID = 0;
4548

4549
                        // Draw the first letter as a capital letter, the rest are lowercase (if scriptEng.operands[4] is true, otherwise they're all
4550
                        // uppercase)
4551
                        if (scriptEng.operands[4] == 1 && titleCardText[charID] != 0) {
4552
                            int character = titleCardText[charID];
4553
                            if (character == ' ')
4554
                                character = -1;
4555
                            if (character == '-')
4556
                                character = 0;
4557
                            if (character >= '0' && character <= '9')
4558
                                character -= 22;
4559
                            if (character > '9' && character < 'f')
4560
                                character -= 'A';
4561

4562
                            if (character <= -1) {
4563
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4564
                            }
4565
                            else {
4566
                                character += scriptEng.operands[0];
4567
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4568
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4569
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4570
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4571
                            }
4572

4573
                            scriptEng.operands[0] += 26;
4574
                            charID++;
4575
                        }
4576

4577
                        while (titleCardText[charID] != 0 && titleCardText[charID] != '-') {
4578
                            int character = titleCardText[charID];
4579
                            if (character == ' ')
4580
                                character = -1;
4581
                            if (character == '-')
4582
                                character = 0;
4583
                            if (character > '/' && character < ':')
4584
                                character -= 22;
4585
                            if (character > '9' && character < 'f')
4586
                                character -= 'A';
4587

4588
                            if (character <= -1) {
4589
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4590
                            }
4591
                            else {
4592
                                character += scriptEng.operands[0];
4593
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4594
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4595
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4596
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4597
                            }
4598
                            charID++;
4599
                        }
4600
                        break;
4601

4602
                    case 2: // Draw Word 2
4603
                        charID = titleCardWord2;
4604

4605
                        // Draw the first letter as a capital letter, the rest are lowercase (if scriptEng.operands[4] is true, otherwise they're all
4606
                        // uppercase)
4607
                        if (scriptEng.operands[4] == 1 && titleCardText[charID] != 0) {
4608
                            int character = titleCardText[charID];
4609
                            if (character == ' ')
4610
                                character = 0;
4611
                            if (character == '-')
4612
                                character = 0;
4613
                            if (character >= '0' && character <= '9')
4614
                                character -= 22;
4615
                            if (character > '9' && character < 'f')
4616
                                character -= 'A';
4617

4618
                            if (character <= -1) {
4619
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4620
                            }
4621
                            else {
4622
                                character += scriptEng.operands[0];
4623
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4624
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4625
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4626
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4627
                            }
4628
                            scriptEng.operands[0] += 26;
4629
                            charID++;
4630
                        }
4631

4632
                        while (titleCardText[charID] != 0) {
4633
                            int character = titleCardText[charID];
4634
                            if (character == ' ')
4635
                                character = 0;
4636
                            if (character == '-')
4637
                                character = 0;
4638
                            if (character >= '0' && character <= '9')
4639
                                character -= 22;
4640
                            if (character > '9' && character < 'f')
4641
                                character -= 'A';
4642

4643
                            if (character <= -1) {
4644
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4645
                            }
4646
                            else {
4647
                                character += scriptEng.operands[0];
4648
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4649
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4650
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4651
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4652
                            }
4653
                            charID++;
4654
                        }
4655
                        break;
4656
                }
4657
                break;
4658
            }
4659
            case FUNC_DRAWMENU:
4660
                opcodeSize        = 0;
4661
                textMenuSurfaceNo = scriptInfo->spriteSheetID;
4662
                DrawTextMenu(&gameMenu[scriptEng.operands[0]], scriptEng.operands[1], scriptEng.operands[2]);
4663
                break;
4664
            case FUNC_SPRITEFRAME:
4665
                opcodeSize = 0;
4666
                if (scriptEvent == EVENT_SETUP && scriptFrameCount < SPRITEFRAME_COUNT) {
4667
                    scriptFrames[scriptFrameCount].pivotX = scriptEng.operands[0];
4668
                    scriptFrames[scriptFrameCount].pivotY = scriptEng.operands[1];
4669
                    scriptFrames[scriptFrameCount].width  = scriptEng.operands[2];
4670
                    scriptFrames[scriptFrameCount].height = scriptEng.operands[3];
4671
                    scriptFrames[scriptFrameCount].sprX   = scriptEng.operands[4];
4672
                    scriptFrames[scriptFrameCount].sprY   = scriptEng.operands[5];
4673
                    ++scriptFrameCount;
4674
                }
4675
                break;
4676
            case FUNC_EDITFRAME: {
4677
                opcodeSize  = 0;
4678
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4679

4680
                spriteFrame->pivotX = scriptEng.operands[1];
4681
                spriteFrame->pivotY = scriptEng.operands[2];
4682
                spriteFrame->width  = scriptEng.operands[3];
4683
                spriteFrame->height = scriptEng.operands[4];
4684
                spriteFrame->sprX   = scriptEng.operands[5];
4685
                spriteFrame->sprY   = scriptEng.operands[6];
4686
            } break;
4687
            case FUNC_LOADPALETTE:
4688
                opcodeSize = 0;
4689
                LoadPalette(scriptText, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4]);
4690
                break;
4691
            case FUNC_ROTATEPALETTE:
4692
                opcodeSize = 0;
4693
                RotatePalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
4694
                break;
4695
            case FUNC_SETSCREENFADE:
4696
                opcodeSize = 0;
4697
                SetFade(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
4698
                break;
4699
            case FUNC_SETACTIVEPALETTE:
4700
                opcodeSize = 0;
4701
                SetActivePalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]);
4702
                break;
4703
            case FUNC_SETPALETTEFADE:
4704
#if RETRO_REV00
4705
                SetLimitedFade(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4706
                               scriptEng.operands[5], scriptEng.operands[6]);
4707
#else
4708
                SetPaletteFade(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4709
                               scriptEng.operands[5]);
4710
#endif
4711
                break;
4712
            case FUNC_SETPALETTEENTRY: SetPaletteEntryPacked(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]); break;
4713
            case FUNC_GETPALETTEENTRY: scriptEng.operands[2] = GetPaletteEntryPacked(scriptEng.operands[0], scriptEng.operands[1]); break;
4714
            case FUNC_COPYPALETTE:
4715
                opcodeSize = 0;
4716
                CopyPalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4]);
4717
                break;
4718
            case FUNC_CLEARSCREEN:
4719
                opcodeSize = 0;
4720
                ClearScreen(scriptEng.operands[0]);
4721
                break;
4722
            case FUNC_DRAWSPRITEFX:
4723
                opcodeSize  = 0;
4724
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4725
                switch (scriptEng.operands[1]) {
4726
                    default: break;
4727
                    case FX_SCALE:
4728
                        DrawSpriteScaled(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4729
                                         (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY, entity->scale,
4730
                                         entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4731
                                         scriptInfo->spriteSheetID);
4732
                        break;
4733
                    case FX_ROTATE:
4734
                        DrawSpriteRotated(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4735
                                          (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
4736
                                          spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
4737
                                          scriptInfo->spriteSheetID);
4738
                        break;
4739
                    case FX_ROTOZOOM:
4740
                        DrawSpriteRotozoom(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4741
                                           (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
4742
                                           spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
4743
                                           entity->scale, scriptInfo->spriteSheetID);
4744
                        break;
4745
                    case FX_INK:
4746
                        switch (entity->inkEffect) {
4747
                            case INK_NONE:
4748
                                DrawSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4749
                                           (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4750
                                           spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4751
                                break;
4752
                            case INK_BLEND:
4753
                                DrawBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4754
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4755
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4756
                                break;
4757
                            case INK_ALPHA:
4758
                                DrawAlphaBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4759
                                                       (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4760
                                                       spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4761
                                                       scriptInfo->spriteSheetID);
4762
                                break;
4763
                            case INK_ADD:
4764
                                DrawAdditiveBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4765
                                                          (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4766
                                                          spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4767
                                                          scriptInfo->spriteSheetID);
4768
                                break;
4769
                            case INK_SUB:
4770
                                DrawSubtractiveBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4771
                                                             (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4772
                                                             spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4773
                                                             scriptInfo->spriteSheetID);
4774
                                break;
4775
                        }
4776
                        break;
4777
                    case FX_TINT:
4778
                        if (entity->inkEffect == INK_ALPHA) {
4779
                            DrawScaledTintMask(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4780
                                               (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
4781
                                               entity->scale, entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX,
4782
                                               spriteFrame->sprY, scriptInfo->spriteSheetID);
4783
                        }
4784
                        else {
4785
                            DrawSpriteScaled(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4786
                                             (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY, entity->scale,
4787
                                             entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4788
                                             scriptInfo->spriteSheetID);
4789
                        }
4790
                        break;
4791
                    case FX_FLIP:
4792
                        switch (entity->direction) {
4793
                            default:
4794
                            case FLIP_NONE:
4795
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4796
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4797
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_NONE, scriptInfo->spriteSheetID);
4798
                                break;
4799
                            case FLIP_X:
4800
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset - spriteFrame->width - spriteFrame->pivotX,
4801
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4802
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_X, scriptInfo->spriteSheetID);
4803
                                break;
4804
                            case FLIP_Y:
4805
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4806
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset - spriteFrame->height - spriteFrame->pivotY,
4807
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_Y,
4808
                                                  scriptInfo->spriteSheetID);
4809
                                break;
4810
                            case FLIP_XY:
4811
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset - spriteFrame->width - spriteFrame->pivotX,
4812
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset - spriteFrame->height - spriteFrame->pivotY,
4813
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_XY,
4814
                                                  scriptInfo->spriteSheetID);
4815
                                break;
4816
                        }
4817
                        break;
4818
                }
4819
                break;
4820
            case FUNC_DRAWSPRITESCREENFX:
4821
                opcodeSize  = 0;
4822
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4823
                switch (scriptEng.operands[1]) {
4824
                    default: break;
4825
                    case FX_SCALE:
4826
                        DrawSpriteScaled(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX, -spriteFrame->pivotY,
4827
                                         entity->scale, entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4828
                                         scriptInfo->spriteSheetID);
4829
                        break;
4830
                    case FX_ROTATE:
4831
                        DrawSpriteRotated(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX, -spriteFrame->pivotY,
4832
                                          spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
4833
                                          scriptInfo->spriteSheetID);
4834
                        break;
4835
                    case FX_ROTOZOOM:
4836
                        DrawSpriteRotozoom(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
4837
                                           -spriteFrame->pivotY, spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height,
4838
                                           entity->rotation, entity->scale, scriptInfo->spriteSheetID);
4839
                        break;
4840
                    case FX_INK:
4841
                        switch (entity->inkEffect) {
4842
                            case INK_NONE:
4843
                                DrawSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4844
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4845
                                break;
4846
                            case INK_BLEND:
4847
                                DrawBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4848
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4849
                                                  scriptInfo->spriteSheetID);
4850
                                break;
4851
                            case INK_ALPHA:
4852
                                DrawAlphaBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4853
                                                       spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4854
                                                       scriptInfo->spriteSheetID);
4855
                                break;
4856
                            case INK_ADD:
4857
                                DrawAdditiveBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4858
                                                          spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4859
                                                          entity->alpha, scriptInfo->spriteSheetID);
4860
                                break;
4861
                            case INK_SUB:
4862
                                DrawSubtractiveBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4863
                                                             spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4864
                                                             entity->alpha, scriptInfo->spriteSheetID);
4865
                                break;
4866
                        }
4867
                        break;
4868
                    case FX_TINT:
4869
                        if (entity->inkEffect == INK_ALPHA) {
4870
                            DrawScaledTintMask(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
4871
                                               -spriteFrame->pivotY, entity->scale, entity->scale, spriteFrame->width, spriteFrame->height,
4872
                                               spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4873
                        }
4874
                        else {
4875
                            DrawSpriteScaled(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
4876
                                             -spriteFrame->pivotY, entity->scale, entity->scale, spriteFrame->width, spriteFrame->height,
4877
                                             spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4878
                        }
4879
                        break;
4880
                    case FX_FLIP:
4881
                        switch (entity->direction) {
4882
                            default:
4883
                            case FLIP_NONE:
4884
                                DrawSpriteFlipped(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4885
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_NONE,
4886
                                                  scriptInfo->spriteSheetID);
4887
                                break;
4888
                            case FLIP_X:
4889
                                DrawSpriteFlipped(scriptEng.operands[2] - spriteFrame->width - spriteFrame->pivotX,
4890
                                                  scriptEng.operands[3] + spriteFrame->pivotY, spriteFrame->width, spriteFrame->height,
4891
                                                  spriteFrame->sprX, spriteFrame->sprY, FLIP_X, scriptInfo->spriteSheetID);
4892
                                break;
4893
                            case FLIP_Y:
4894
                                DrawSpriteFlipped(scriptEng.operands[2] + spriteFrame->pivotX,
4895
                                                  scriptEng.operands[3] - spriteFrame->height - spriteFrame->pivotY, spriteFrame->width,
4896
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_Y, scriptInfo->spriteSheetID);
4897
                                break;
4898
                            case FLIP_XY:
4899
                                DrawSpriteFlipped(scriptEng.operands[2] - spriteFrame->width - spriteFrame->pivotX,
4900
                                                  scriptEng.operands[3] - spriteFrame->height - spriteFrame->pivotY, spriteFrame->width,
4901
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_XY, scriptInfo->spriteSheetID);
4902
                                break;
4903
                        }
4904
                        break;
4905
                }
4906
                break;
4907
            case FUNC_LOADANIMATION:
4908
                opcodeSize           = 0;
4909
                scriptInfo->animFile = AddAnimationFile(scriptText);
4910
                break;
4911
            case FUNC_SETUPMENU: {
4912
                opcodeSize     = 0;
4913
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
4914
                SetupTextMenu(menu, scriptEng.operands[1]);
4915
                menu->selectionCount = scriptEng.operands[2];
4916
                menu->alignment      = scriptEng.operands[3];
4917
                break;
4918
            }
4919
            case FUNC_ADDMENUENTRY: {
4920
                opcodeSize                           = 0;
4921
                TextMenu *menu                       = &gameMenu[scriptEng.operands[0]];
4922
                menu->entryHighlight[menu->rowCount] = scriptEng.operands[2];
4923
                AddTextMenuEntry(menu, scriptText);
4924
                break;
4925
            }
4926
            case FUNC_EDITMENUENTRY: {
4927
                opcodeSize     = 0;
4928
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
4929
                EditTextMenuEntry(menu, scriptText, scriptEng.operands[2]);
4930
                menu->entryHighlight[scriptEng.operands[2]] = scriptEng.operands[3];
4931
                break;
4932
            }
4933
            case FUNC_LOADSTAGE:
4934
                opcodeSize = 0;
4935
                stageMode  = STAGEMODE_LOAD;
4936
                break;
4937
            case FUNC_DRAWRECT:
4938
                opcodeSize = 0;
4939
                DrawRectangle(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4940
                              scriptEng.operands[5], scriptEng.operands[6], scriptEng.operands[7]);
4941
                break;
4942
            case FUNC_RESETOBJECTENTITY: {
4943
                opcodeSize     = 0;
4944
                Entity *newEnt = &objectEntityList[scriptEng.operands[0]];
4945
                memset(newEnt, 0, sizeof(Entity));
4946
                newEnt->type               = scriptEng.operands[1];
4947
                newEnt->propertyValue      = scriptEng.operands[2];
4948
                newEnt->xpos               = scriptEng.operands[3];
4949
                newEnt->ypos               = scriptEng.operands[4];
4950
                newEnt->direction          = FLIP_NONE;
4951
                newEnt->priority           = PRIORITY_BOUNDS;
4952
                newEnt->drawOrder          = 3;
4953
                newEnt->scale              = 512;
4954
                newEnt->inkEffect          = INK_NONE;
4955
                newEnt->objectInteractions = true;
4956
                newEnt->visible            = true;
4957
                newEnt->tileCollisions     = true;
4958
                break;
4959
            }
4960
            case FUNC_BOXCOLLISIONTEST:
4961
                opcodeSize = 0;
4962
                switch (scriptEng.operands[0]) {
4963
                    default: break;
4964
                    case C_TOUCH:
4965
                        TouchCollision(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4966
                                       scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]], scriptEng.operands[7], scriptEng.operands[8],
4967
                                       scriptEng.operands[9], scriptEng.operands[10]);
4968
                        break;
4969
                    case C_SOLID:
4970
                        BoxCollision(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4971
                                     scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]], scriptEng.operands[7], scriptEng.operands[8],
4972
                                     scriptEng.operands[9], scriptEng.operands[10]);
4973
                        break;
4974
                    case C_SOLID2:
4975
                        BoxCollision2(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4976
                                      scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]], scriptEng.operands[7], scriptEng.operands[8],
4977
                                      scriptEng.operands[9], scriptEng.operands[10]);
4978
                        break;
4979
                    case C_PLATFORM:
4980
                        PlatformCollision(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3],
4981
                                          scriptEng.operands[4], scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]],
4982
                                          scriptEng.operands[7], scriptEng.operands[8], scriptEng.operands[9], scriptEng.operands[10]);
4983
                        break;
4984
                }
4985
                break;
4986
            case FUNC_CREATETEMPOBJECT: {
4987
                opcodeSize = 0;
4988
                if (objectEntityList[scriptEng.arrayPosition[8]].type > OBJ_TYPE_BLANKOBJECT && ++scriptEng.arrayPosition[8] == ENTITY_COUNT)
4989
                    scriptEng.arrayPosition[8] = TEMPENTITY_START;
4990
                Entity *temp = &objectEntityList[scriptEng.arrayPosition[8]];
4991
                memset(temp, 0, sizeof(Entity));
4992
                temp->type               = scriptEng.operands[0];
4993
                temp->propertyValue      = scriptEng.operands[1];
4994
                temp->xpos               = scriptEng.operands[2];
4995
                temp->ypos               = scriptEng.operands[3];
4996
                temp->direction          = FLIP_NONE;
4997
                temp->priority           = PRIORITY_ACTIVE;
4998
                temp->drawOrder          = 3;
4999
                temp->scale              = 512;
5000
                temp->inkEffect          = INK_NONE;
5001
                temp->objectInteractions = true;
5002
                temp->visible            = true;
5003
                temp->tileCollisions     = true;
5004
                break;
5005
            }
5006
            case FUNC_PROCESSOBJECTMOVEMENT:
5007
                opcodeSize = 0;
5008
                if (entity->tileCollisions) {
5009
                    ProcessTileCollisions(entity);
5010
                }
5011
                else {
5012
                    entity->xpos += entity->xvel;
5013
                    entity->ypos += entity->yvel;
5014
                }
5015
                break;
5016
            case FUNC_PROCESSOBJECTCONTROL:
5017
                opcodeSize = 0;
5018
                ProcessObjectControl(entity);
5019
                break;
5020
            case FUNC_PROCESSANIMATION:
5021
                opcodeSize = 0;
5022
                ProcessObjectAnimation(scriptInfo, entity);
5023
                break;
5024
            case FUNC_DRAWOBJECTANIMATION:
5025
                opcodeSize = 0;
5026
                if (entity->visible)
5027
                    DrawObjectAnimation(scriptInfo, entity, (entity->xpos >> 16) - xScrollOffset, (entity->ypos >> 16) - yScrollOffset);
5028
                break;
5029
            case FUNC_SETMUSICTRACK:
5030
                opcodeSize = 0;
5031
                if (scriptEng.operands[2] <= 1)
5032
                    SetMusicTrack(scriptText, scriptEng.operands[1], scriptEng.operands[2], 0);
5033
                else
5034
                    SetMusicTrack(scriptText, scriptEng.operands[1], true, scriptEng.operands[2]);
5035
                break;
5036
            case FUNC_PLAYMUSIC:
5037
                opcodeSize = 0;
5038
                PlayMusic(scriptEng.operands[0], 0);
5039
                break;
5040
            case FUNC_STOPMUSIC:
5041
                opcodeSize = 0;
5042
                StopMusic(true);
5043
                break;
5044
            case FUNC_PAUSEMUSIC:
5045
                opcodeSize = 0;
5046
                PauseSound();
5047
                break;
5048
            case FUNC_RESUMEMUSIC:
5049
                opcodeSize = 0;
5050
                ResumeSound();
5051
                break;
5052
            case FUNC_SWAPMUSICTRACK:
5053
                opcodeSize = 0;
5054
                if (scriptEng.operands[2] <= 1)
5055
                    SwapMusicTrack(scriptText, scriptEng.operands[1], 0, scriptEng.operands[3]);
5056
                else
5057
                    SwapMusicTrack(scriptText, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
5058
                break;
5059
            case FUNC_PLAYSFX:
5060
                opcodeSize = 0;
5061
                PlaySfx(scriptEng.operands[0], scriptEng.operands[1]);
5062
                break;
5063
            case FUNC_STOPSFX:
5064
                opcodeSize = 0;
5065
                StopSfx(scriptEng.operands[0]);
5066
                break;
5067
            case FUNC_SETSFXATTRIBUTES:
5068
                opcodeSize = 0;
5069
                SetSfxAttributes(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]);
5070
                break;
5071
            case FUNC_OBJECTTILECOLLISION:
5072
                opcodeSize = 0;
5073
                switch (scriptEng.operands[0]) {
5074
                    default: break;
5075
                    case CSIDE_FLOOR: ObjectFloorCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5076
                    case CSIDE_LWALL: ObjectLWallCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5077
                    case CSIDE_RWALL: ObjectRWallCollision(scriptEng.operands[1] - 1, scriptEng.operands[2], scriptEng.operands[3]); break;
5078
                    case CSIDE_ROOF: ObjectRoofCollision(scriptEng.operands[1], scriptEng.operands[2] - 1, scriptEng.operands[3]); break;
5079
#if RETRO_REV03
5080
                    // Yes, the right side also calls for LWall
5081
                    case CSIDE_LENTITY: ObjectLWallCollision(scriptEng.operands[2], 0, objectEntityList[scriptEng.operands[1]].collisionPlane); break;
5082
                    case CSIDE_RENTITY: ObjectLWallCollision(scriptEng.operands[2] - 1, 0, objectEntityList[scriptEng.operands[1]].collisionPlane); break;
5083
#endif
5084
                }
5085
                break;
5086
            case FUNC_OBJECTTILEGRIP:
5087
                opcodeSize = 0;
5088
                switch (scriptEng.operands[0]) {
5089
                    default: break;
5090
                    case CSIDE_FLOOR: ObjectFloorGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5091
                    case CSIDE_LWALL: ObjectLWallGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5092
                    case CSIDE_RWALL: ObjectRWallGrip(scriptEng.operands[1] - 1, scriptEng.operands[2], scriptEng.operands[3]); break;
5093
                    case CSIDE_ROOF: ObjectRoofGrip(scriptEng.operands[1], scriptEng.operands[2] - 1, scriptEng.operands[3]); break;
5094
#if RETRO_REV03
5095
                    case CSIDE_LENTITY: ObjectLEntityGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5096
                    case CSIDE_RENTITY: ObjectREntityGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5097
#endif
5098
                }
5099
                break;
5100
            case FUNC_NOT: scriptEng.operands[0] = ~scriptEng.operands[0]; break;
5101
            case FUNC_DRAW3DSCENE:
5102
                opcodeSize = 0;
5103
                TransformVertexBuffer();
5104
                Sort3DDrawList();
5105
                Draw3DScene(scriptInfo->spriteSheetID);
5106
                break;
5107
            case FUNC_SETIDENTITYMATRIX:
5108
                opcodeSize = 0;
5109
                switch (scriptEng.operands[0]) {
5110
                    case MAT_WORLD: SetIdentityMatrix(&matWorld); break;
5111
                    case MAT_VIEW: SetIdentityMatrix(&matView); break;
5112
                    case MAT_TEMP: SetIdentityMatrix(&matTemp); break;
5113
                }
5114
                break;
5115
            case FUNC_MATRIXMULTIPLY:
5116
                opcodeSize = 0;
5117
                switch (scriptEng.operands[0]) {
5118
                    case MAT_WORLD:
5119
                        switch (scriptEng.operands[1]) {
5120
                            case MAT_WORLD: MatrixMultiply(&matWorld, &matWorld); break;
5121
                            case MAT_VIEW: MatrixMultiply(&matWorld, &matView); break;
5122
                            case MAT_TEMP: MatrixMultiply(&matWorld, &matTemp); break;
5123
                        }
5124
                        break;
5125
                    case MAT_VIEW:
5126
                        switch (scriptEng.operands[1]) {
5127
                            case MAT_WORLD: MatrixMultiply(&matView, &matWorld); break;
5128
                            case MAT_VIEW: MatrixMultiply(&matView, &matView); break;
5129
                            case MAT_TEMP: MatrixMultiply(&matView, &matTemp); break;
5130
                        }
5131
                        break;
5132
                    case MAT_TEMP:
5133
                        switch (scriptEng.operands[1]) {
5134
                            case MAT_WORLD: MatrixMultiply(&matTemp, &matWorld); break;
5135
                            case MAT_VIEW: MatrixMultiply(&matTemp, &matView); break;
5136
                            case MAT_TEMP: MatrixMultiply(&matTemp, &matTemp); break;
5137
                        }
5138
                        break;
5139
                }
5140
                break;
5141
            case FUNC_MATRIXTRANSLATEXYZ:
5142
                opcodeSize = 0;
5143
                switch (scriptEng.operands[0]) {
5144
                    case MAT_WORLD: MatrixTranslateXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5145
                    case MAT_VIEW: MatrixTranslateXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5146
                    case MAT_TEMP: MatrixTranslateXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5147
                }
5148
                break;
5149
            case FUNC_MATRIXSCALEXYZ:
5150
                opcodeSize = 0;
5151
                switch (scriptEng.operands[0]) {
5152
                    case MAT_WORLD: MatrixScaleXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5153
                    case MAT_VIEW: MatrixScaleXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5154
                    case MAT_TEMP: MatrixScaleXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5155
                }
5156
                break;
5157
            case FUNC_MATRIXROTATEX:
5158
                opcodeSize = 0;
5159
                switch (scriptEng.operands[0]) {
5160
                    case MAT_WORLD: MatrixRotateX(&matWorld, scriptEng.operands[1]); break;
5161
                    case MAT_VIEW: MatrixRotateX(&matView, scriptEng.operands[1]); break;
5162
                    case MAT_TEMP: MatrixRotateX(&matTemp, scriptEng.operands[1]); break;
5163
                }
5164
                break;
5165
            case FUNC_MATRIXROTATEY:
5166
                opcodeSize = 0;
5167
                switch (scriptEng.operands[0]) {
5168
                    case MAT_WORLD: MatrixRotateY(&matWorld, scriptEng.operands[1]); break;
5169
                    case MAT_VIEW: MatrixRotateY(&matView, scriptEng.operands[1]); break;
5170
                    case MAT_TEMP: MatrixRotateY(&matTemp, scriptEng.operands[1]); break;
5171
                }
5172
                break;
5173
            case FUNC_MATRIXROTATEZ:
5174
                opcodeSize = 0;
5175
                switch (scriptEng.operands[0]) {
5176
                    case MAT_WORLD: MatrixRotateZ(&matWorld, scriptEng.operands[1]); break;
5177
                    case MAT_VIEW: MatrixRotateZ(&matView, scriptEng.operands[1]); break;
5178
                    case MAT_TEMP: MatrixRotateZ(&matTemp, scriptEng.operands[1]); break;
5179
                }
5180
                break;
5181
            case FUNC_MATRIXROTATEXYZ:
5182
                opcodeSize = 0;
5183
                switch (scriptEng.operands[0]) {
5184
                    case MAT_WORLD: MatrixRotateXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5185
                    case MAT_VIEW: MatrixRotateXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5186
                    case MAT_TEMP: MatrixRotateXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
5187
                }
5188
                break;
5189
#if !RETRO_REV00
5190
            case FUNC_MATRIXINVERSE:
5191
                opcodeSize = 0;
5192
                switch (scriptEng.operands[0]) {
5193
                    case MAT_WORLD: MatrixInverse(&matWorld); break;
5194
                    case MAT_VIEW: MatrixInverse(&matView); break;
5195
                    case MAT_TEMP: MatrixInverse(&matTemp); break;
5196
                }
5197
                break;
5198
#endif
5199
            case FUNC_TRANSFORMVERTICES:
5200
                opcodeSize = 0;
5201
                switch (scriptEng.operands[0]) {
5202
                    case MAT_WORLD: TransformVertices(&matWorld, scriptEng.operands[1], scriptEng.operands[2]); break;
5203
                    case MAT_VIEW: TransformVertices(&matView, scriptEng.operands[1], scriptEng.operands[2]); break;
5204
                    case MAT_TEMP: TransformVertices(&matTemp, scriptEng.operands[1], scriptEng.operands[2]); break;
5205
                }
5206
                break;
5207
            case FUNC_CALLFUNCTION: {
5208
                opcodeSize                        = 0;
5209
                functionStack[functionStackPos++] = scriptCodePtr;
5210
                functionStack[functionStackPos++] = jumpTableStart;
5211
                functionStack[functionStackPos++] = scriptCodeStart;
5212
                scriptCodeStart                   = scriptFunctionList[scriptEng.operands[0]].ptr.scriptCodePtr;
5213
                jumpTableStart                    = scriptFunctionList[scriptEng.operands[0]].ptr.jumpTablePtr;
5214
                scriptCodePtr                     = scriptCodeStart;
5215
                break;
5216
            }
5217
            case FUNC_RETURN:
5218
                opcodeSize = 0;
5219
                if (!functionStackPos) { // event, stop running
5220
                    running = false;
5221
                }
5222
                else { // function, jump out
5223
                    scriptCodeStart = functionStack[--functionStackPos];
5224
                    jumpTableStart  = functionStack[--functionStackPos];
5225
                    scriptCodePtr   = functionStack[--functionStackPos];
5226
                }
5227
                break;
5228
            case FUNC_SETLAYERDEFORMATION:
5229
                opcodeSize = 0;
5230
                SetLayerDeformation(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
5231
                                    scriptEng.operands[5]);
5232
                break;
5233
            case FUNC_CHECKTOUCHRECT: opcodeSize = 0; scriptEng.checkResult = -1;
5234
#if !RETRO_USE_ORIGINAL_CODE
5235
                AddDebugHitbox(H_TYPE_FINGER, NULL, scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
5236
#endif
5237
                for (int f = 0; f < touches; ++f) {
5238
                    if (touchDown[f] && touchX[f] > scriptEng.operands[0] && touchX[f] < scriptEng.operands[2] && touchY[f] > scriptEng.operands[1]
5239
                        && touchY[f] < scriptEng.operands[3]) {
5240
                        scriptEng.checkResult = f;
5241
                    }
5242
                }
5243
                break;
5244
            case FUNC_GETTILELAYERENTRY:
5245
                scriptEng.operands[0] = stageLayouts[scriptEng.operands[1]].tiles[scriptEng.operands[2] + 0x100 * scriptEng.operands[3]];
5246
                break;
5247
            case FUNC_SETTILELAYERENTRY:
5248
                stageLayouts[scriptEng.operands[1]].tiles[scriptEng.operands[2] + 0x100 * scriptEng.operands[3]] = scriptEng.operands[0];
5249
                break;
5250
            case FUNC_GETBIT: scriptEng.operands[0] = (scriptEng.operands[1] & (1 << scriptEng.operands[2])) >> scriptEng.operands[2]; break;
5251
            case FUNC_SETBIT:
5252
                if (scriptEng.operands[2] <= 0)
5253
                    scriptEng.operands[0] &= ~(1 << scriptEng.operands[1]);
5254
                else
5255
                    scriptEng.operands[0] |= 1 << scriptEng.operands[1];
5256
                break;
5257
            case FUNC_CLEARDRAWLIST:
5258
                opcodeSize                                      = 0;
5259
                drawListEntries[scriptEng.operands[0]].listSize = 0;
5260
                break;
5261
            case FUNC_ADDDRAWLISTENTITYREF: {
5262
                opcodeSize                                                                                           = 0;
5263
                drawListEntries[scriptEng.operands[0]].entityRefs[drawListEntries[scriptEng.operands[0]].listSize++] = scriptEng.operands[1];
5264
                break;
5265
            }
5266
            case FUNC_GETDRAWLISTENTITYREF: scriptEng.operands[0] = drawListEntries[scriptEng.operands[1]].entityRefs[scriptEng.operands[2]]; break;
5267
            case FUNC_SETDRAWLISTENTITYREF:
5268
                opcodeSize                                                               = 0;
5269
                drawListEntries[scriptEng.operands[1]].entityRefs[scriptEng.operands[2]] = scriptEng.operands[0];
5270
                break;
5271
            case FUNC_GET16X16TILEINFO: {
5272
                scriptEng.operands[4] = scriptEng.operands[1] >> 7;
5273
                scriptEng.operands[5] = scriptEng.operands[2] >> 7;
5274
                scriptEng.operands[6] = stageLayouts[0].tiles[scriptEng.operands[4] + (scriptEng.operands[5] << 8)] << 6;
5275
                scriptEng.operands[6] += ((scriptEng.operands[1] & 0x7F) >> 4) + 8 * ((scriptEng.operands[2] & 0x7F) >> 4);
5276
                int index = tiles128x128.tileIndex[scriptEng.operands[6]];
5277
                switch (scriptEng.operands[3]) {
5278
                    case TILEINFO_INDEX: scriptEng.operands[0] = tiles128x128.tileIndex[scriptEng.operands[6]]; break;
5279
                    case TILEINFO_DIRECTION: scriptEng.operands[0] = tiles128x128.direction[scriptEng.operands[6]]; break;
5280
                    case TILEINFO_VISUALPLANE: scriptEng.operands[0] = tiles128x128.visualPlane[scriptEng.operands[6]]; break;
5281
                    case TILEINFO_SOLIDITYA: scriptEng.operands[0] = tiles128x128.collisionFlags[0][scriptEng.operands[6]]; break;
5282
                    case TILEINFO_SOLIDITYB: scriptEng.operands[0] = tiles128x128.collisionFlags[1][scriptEng.operands[6]]; break;
5283
                    case TILEINFO_FLAGSA: scriptEng.operands[0] = collisionMasks[0].flags[index]; break;
5284
                    case TILEINFO_ANGLEA: scriptEng.operands[0] = collisionMasks[0].angles[index]; break;
5285
                    case TILEINFO_FLAGSB: scriptEng.operands[0] = collisionMasks[1].flags[index]; break;
5286
                    case TILEINFO_ANGLEB: scriptEng.operands[0] = collisionMasks[1].angles[index]; break;
5287
                    default: break;
5288
                }
5289
                break;
5290
            }
5291
            case FUNC_SET16X16TILEINFO: {
5292
                scriptEng.operands[4] = scriptEng.operands[1] >> 7;
5293
                scriptEng.operands[5] = scriptEng.operands[2] >> 7;
5294
                scriptEng.operands[6] = stageLayouts[0].tiles[scriptEng.operands[4] + (scriptEng.operands[5] << 8)] << 6;
5295
                scriptEng.operands[6] += ((scriptEng.operands[1] & 0x7F) >> 4) + 8 * ((scriptEng.operands[2] & 0x7F) >> 4);
5296
                switch (scriptEng.operands[3]) {
5297
                    case TILEINFO_INDEX:
5298
                        tiles128x128.tileIndex[scriptEng.operands[6]]  = scriptEng.operands[0];
5299
                        tiles128x128.gfxDataPos[scriptEng.operands[6]] = scriptEng.operands[0] << 8;
5300
                        break;
5301
                    case TILEINFO_DIRECTION: tiles128x128.direction[scriptEng.operands[6]] = scriptEng.operands[0]; break;
5302
                    case TILEINFO_VISUALPLANE: tiles128x128.visualPlane[scriptEng.operands[6]] = scriptEng.operands[0]; break;
5303
                    case TILEINFO_SOLIDITYA: tiles128x128.collisionFlags[0][scriptEng.operands[6]] = scriptEng.operands[0]; break;
5304
                    case TILEINFO_SOLIDITYB: tiles128x128.collisionFlags[1][scriptEng.operands[6]] = scriptEng.operands[0]; break;
5305
                    case TILEINFO_FLAGSA: collisionMasks[1].flags[tiles128x128.tileIndex[scriptEng.operands[6]]] = scriptEng.operands[0]; break;
5306
                    case TILEINFO_ANGLEA: collisionMasks[1].angles[tiles128x128.tileIndex[scriptEng.operands[6]]] = scriptEng.operands[0]; break;
5307
                    default: break;
5308
                }
5309
                break;
5310
            }
5311
            case FUNC_COPY16X16TILE:
5312
                opcodeSize = 0;
5313
                Copy16x16Tile(scriptEng.operands[0], scriptEng.operands[1]);
5314
                break;
5315
            case FUNC_GETANIMATIONBYNAME: {
5316
                AnimationFile *animFile = scriptInfo->animFile;
5317
                scriptEng.operands[0]   = -1;
5318
                int id                  = 0;
5319
                while (scriptEng.operands[0] == -1) {
5320
                    SpriteAnimation *anim = &animationList[animFile->aniListOffset + id];
5321
                    if (StrComp(scriptText, anim->name))
5322
                        scriptEng.operands[0] = id;
5323
                    else if (++id == animFile->animCount)
5324
                        scriptEng.operands[0] = 0;
5325
                }
5326
                break;
5327
            }
5328
            case FUNC_READSAVERAM:
5329
                opcodeSize            = 0;
5330
                scriptEng.checkResult = ReadSaveRAMData();
5331
                break;
5332
            case FUNC_WRITESAVERAM:
5333
                opcodeSize            = 0;
5334
                scriptEng.checkResult = WriteSaveRAMData();
5335
                break;
5336
#if !RETRO_REV02
5337
            case FUNC_LOADTEXTFONT: {
5338
                opcodeSize = 0;
5339
                LoadFontFile(scriptText);
5340
                break;
5341
            }
5342
#endif
5343
            case FUNC_LOADTEXTFILE: {
5344
                opcodeSize     = 0;
5345
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
5346
#if !RETRO_REV02
5347
                LoadTextFile(menu, scriptText, scriptEng.operands[2] != 0);
5348
#else
5349
                LoadTextFile(menu, scriptText, false);
5350
#endif
5351
                break;
5352
            }
5353
            case FUNC_GETTEXTINFO: {
5354
                TextMenu *menu = &gameMenu[scriptEng.operands[1]];
5355
                switch (scriptEng.operands[2]) {
5356
                    case TEXTINFO_TEXTDATA:
5357
                        scriptEng.operands[0] = menu->textData[menu->entryStart[scriptEng.operands[3]] + scriptEng.operands[4]];
5358
                        break;
5359
                    case TEXTINFO_TEXTSIZE: scriptEng.operands[0] = menu->entrySize[scriptEng.operands[3]]; break;
5360
                    case TEXTINFO_ROWCOUNT: scriptEng.operands[0] = menu->rowCount; break;
5361
                }
5362
                break;
5363
            }
5364
#if !RETRO_REV02
5365
            case FUNC_DRAWTEXT: {
5366
                opcodeSize        = 0;
5367
                textMenuSurfaceNo = scriptInfo->spriteSheetID;
5368
                TextMenu *menu    = &gameMenu[scriptEng.operands[0]];
5369
                DrawBitmapText(menu, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
5370
                               scriptEng.operands[5], scriptEng.operands[6]);
5371
                break;
5372
            }
5373
#endif
5374
            case FUNC_GETVERSIONNUMBER: {
5375
                opcodeSize                           = 0;
5376
                TextMenu *menu                       = &gameMenu[scriptEng.operands[0]];
5377
                menu->entryHighlight[menu->rowCount] = scriptEng.operands[1];
5378
                AddTextMenuEntry(menu, Engine.gameVersion);
5379
                break;
5380
            }
5381
            case FUNC_GETTABLEVALUE: {
5382
                int arrPos = scriptEng.operands[1];
5383
                if (arrPos >= 0) {
5384
                    int pos     = scriptEng.operands[2];
5385
                    int arrSize = scriptCode[pos];
5386
                    if (arrPos < arrSize)
5387
                        scriptEng.operands[0] = scriptCode[pos + arrPos + 1];
5388
                }
5389
                break;
5390
            }
5391
            case FUNC_SETTABLEVALUE: {
5392
                opcodeSize = 0;
5393
                int arrPos = scriptEng.operands[1];
5394
                if (arrPos >= 0) {
5395
                    int pos     = scriptEng.operands[2];
5396
                    int arrSize = scriptCode[pos];
5397
                    if (arrPos < arrSize)
5398
                        scriptCode[pos + arrPos + 1] = scriptEng.operands[0];
5399
                }
5400
                break;
5401
            }
5402
            case FUNC_CHECKCURRENTSTAGEFOLDER:
5403
                opcodeSize            = 0;
5404
                scriptEng.checkResult = StrComp(stageList[activeStageList][stageListPosition].folder, scriptText);
5405
#if RETRO_REV03
5406
                // Mission Mode stuff
5407
                if (!scriptEng.checkResult) {
5408
                    int targetLength  = strlen(stageList[activeStageList][stageListPosition].folder);
5409
                    int currentLength = strlen(scriptText);
5410
                    if (targetLength > currentLength) {
5411
                        scriptEng.checkResult =
5412
                            StrComp(&stageList[activeStageList][stageListPosition].folder[targetLength - currentLength], scriptText);
5413
                    }
5414
                }
5415
#endif
5416
                break;
5417
            case FUNC_ABS: {
5418
                scriptEng.operands[0] = abs(scriptEng.operands[0]);
5419
                break;
5420
            }
5421
            case FUNC_CALLNATIVEFUNCTION:
5422
                opcodeSize = 0;
5423
                if (scriptEng.operands[0] >= 0 && scriptEng.operands[0] < NATIIVEFUNCTION_COUNT) {
5424
                    void (*func)(void) = (void (*)(void))nativeFunction[scriptEng.operands[0]];
5425
                    if (func)
5426
                        func();
5427
                }
5428
                break;
5429
            case FUNC_CALLNATIVEFUNCTION2:
5430
                if (scriptEng.operands[0] >= 0 && scriptEng.operands[0] < NATIIVEFUNCTION_COUNT) {
5431
                    if (StrLength(scriptText)) {
5432
                        void (*func)(int *, char *) = (void (*)(int *, char *))nativeFunction[scriptEng.operands[0]];
5433
                        if (func)
5434
                            func(&scriptEng.operands[2], scriptText);
5435
                    }
5436
                    else {
5437
                        void (*func)(int *, int *) = (void (*)(int *, int *))nativeFunction[scriptEng.operands[0]];
5438
                        if (func)
5439
                            func(&scriptEng.operands[1], &scriptEng.operands[2]);
5440
                    }
5441
                }
5442
                break;
5443
            case FUNC_CALLNATIVEFUNCTION4:
5444
                if (scriptEng.operands[0] >= 0 && scriptEng.operands[0] < NATIIVEFUNCTION_COUNT) {
5445
                    if (StrLength(scriptText)) {
5446
                        void (*func)(int *, char *, int *, int *) = (void (*)(int *, char *, int *, int *))nativeFunction[scriptEng.operands[0]];
5447
                        if (func)
5448
                            func(&scriptEng.operands[1], scriptText, &scriptEng.operands[3], &scriptEng.operands[4]);
5449
                    }
5450
                    else {
5451
                        void (*func)(int *, int *, int *, int *) = (void (*)(int *, int *, int *, int *))nativeFunction[scriptEng.operands[0]];
5452
                        if (func)
5453
                            func(&scriptEng.operands[1], &scriptEng.operands[2], &scriptEng.operands[3], &scriptEng.operands[4]);
5454
                    }
5455
                }
5456
                break;
5457
            case FUNC_SETOBJECTRANGE: {
5458
                // FUNCTION PARAMS:
5459
                // scriptEng.operands[0] = range
5460

5461
                opcodeSize       = 0;
5462
                int offset       = (scriptEng.operands[0] >> 1) - SCREEN_CENTERX;
5463
                OBJECT_BORDER_X1 = offset + 0x80;
5464
                OBJECT_BORDER_X2 = scriptEng.operands[0] + 0x80 - offset;
5465
                OBJECT_BORDER_X3 = offset + 0x20;
5466
                OBJECT_BORDER_X4 = scriptEng.operands[0] + 0x20 - offset;
5467
                break;
5468
            }
5469
#if RETRO_REV02
5470
            case FUNC_GETOBJECTVALUE: {
5471
                // FUNCTION PARAMS:
5472
                // scriptEng.operands[0] = result
5473
                // scriptEng.operands[1] = valueID
5474
                // scriptEng.operands[2] = entitySlot
5475

5476
                if (scriptEng.operands[1] < 48)
5477
                    scriptEng.operands[0] = objectEntityList[scriptEng.operands[2]].values[scriptEng.operands[1]];
5478
                break;
5479
            }
5480
            case FUNC_SETOBJECTVALUE: {
5481
                // FUNCTION PARAMS:
5482
                // scriptEng.operands[0] = value
5483
                // scriptEng.operands[1] = valueID
5484
                // scriptEng.operands[2] = entitySlot
5485

5486
                opcodeSize = 0;
5487
                if (scriptEng.operands[1] < 48)
5488
                    objectEntityList[scriptEng.operands[2]].values[scriptEng.operands[1]] = scriptEng.operands[0];
5489
                break;
5490
            }
5491
            case FUNC_COPYOBJECT: {
5492
                // FUNCTION PARAMS:
5493
                // scriptEng.operands[0] = destSlot
5494
                // scriptEng.operands[1] = srcSlot
5495
                // scriptEng.operands[2] = count
5496

5497
                Entity *dstList = &objectEntityList[scriptEng.operands[0]];
5498
                Entity *srcList = &objectEntityList[scriptEng.operands[1]];
5499
                for (int i = 0; i < scriptEng.operands[2]; ++i) memcpy(&dstList[i], &srcList[i], sizeof(Entity));
5500
                break;
5501
            }
5502
#endif
5503
            case FUNC_PRINT: {
5504
                // FUNCTION PARAMS:
5505
                // scriptEng.operands[0] = message (can be a regular value or a string depending on scriptEng.operands[1])
5506
                // scriptEng.operands[1] = isInt
5507
                // scriptEng.operands[2] = useEndLine
5508

5509
                endLine = false;
5510
                if (scriptEng.operands[1])
5511
                    PrintLog("%d", scriptEng.operands[0]);
5512
                else
5513
                    PrintLog("%s", scriptText);
5514

5515
                if (scriptEng.operands[2])
5516
                    PrintLog("\n");
5517
                endLine = true;
5518
                break;
5519
            }
5520

5521
#if RETRO_REV03
5522
                // Extras for origins 2PVS,
5523
                // most of these aren't (and won't be) implemented here because they rely on v5 tech that isn't part of the scope of this project
5524
            case FUNC_CHECKCAMERAPROXIMITY:
5525
                scriptEng.checkResult = false;
5526

5527
                // FUNCTION PARAMS:
5528
                // scriptEng.operands[0] = pos.x
5529
                // scriptEng.operands[1] = pos.y
5530
                // scriptEng.operands[2] = range.x
5531
                // scriptEng.operands[3] = range.y
5532
                //
5533
                // FUNCTION NOTES:
5534
                // - Sets scriptEng.checkResult
5535

5536
                if (scriptEng.operands[2] > 0 && scriptEng.operands[3] > 0) {
5537
                    int sx = abs(scriptEng.operands[0] - cameraXPos);
5538
                    int sy = abs(scriptEng.operands[1] - cameraYPos);
5539

5540
                    if (sx < scriptEng.operands[2] && sy < scriptEng.operands[3]) {
5541
                        scriptEng.checkResult = true;
5542
                        break;
5543
                    }
5544
                }
5545
                else {
5546
                    if (scriptEng.operands[2] > 0) {
5547
                        int sx = abs(scriptEng.operands[0] - cameraXPos);
5548

5549
                        if (sx < scriptEng.operands[2]) {
5550
                            scriptEng.checkResult = true;
5551
                            break;
5552
                        }
5553
                    }
5554
                    else if (scriptEng.operands[3] > 0) {
5555
                        int sy = abs(scriptEng.operands[1] - cameraYPos);
5556

5557
                        if (sy < scriptEng.operands[3]) {
5558
                            scriptEng.checkResult = true;
5559
                            break;
5560
                        }
5561
                    }
5562
                }
5563
                break;
5564

5565
            case FUNC_SETSCREENCOUNT:
5566
                // FUNCTION PARAMS:
5567
                // scriptEng.operands[0] = screenCount
5568

5569
                break;
5570

5571
            case FUNC_SETSCREENVERTICES:
5572
                // FUNCTION PARAMS:
5573
                // scriptEng.operands[0] = startVert2P_S1
5574
                // scriptEng.operands[1] = startVert2P_S2
5575
                // scriptEng.operands[2] = startVert3P_S1
5576
                // scriptEng.operands[3] = startVert3P_S2
5577
                // scriptEng.operands[4] = startVert3P_S3
5578

5579
                break;
5580

5581
            case FUNC_GETINPUTDEVICEID:
5582
                // FUNCTION PARAMS:
5583
                // scriptEng.operands[0] = deviceID
5584
                // scriptEng.operands[1] = inputSlot
5585
                //
5586
                // FUNCTION NOTES:
5587
                // - Assigns the device's id to scriptEng.operands[0]
5588

5589
                break;
5590

5591
            case FUNC_GETFILTEREDINPUTDEVICEID:
5592
                // FUNCTION PARAMS:
5593
                // scriptEng.operands[0] = deviceID
5594
                // scriptEng.operands[1] = confirmOnly
5595
                // scriptEng.operands[2] = unassignedOnly
5596
                // scriptEng.operands[3] = maxInactiveTimer
5597
                //
5598
                // FUNCTION NOTES:
5599
                // - Assigns the filtered device's id to scriptEng.operands[0]
5600

5601
                break;
5602

5603
            case FUNC_GETINPUTDEVICETYPE:
5604
                // FUNCTION PARAMS:
5605
                // scriptEng.operands[0] = deviceType
5606
                // scriptEng.operands[1] = deviceID
5607
                //
5608
                // FUNCTION NOTES:
5609
                // - Assigns the device's type to scriptEng.operands[0]
5610

5611
                break;
5612

5613
            case FUNC_ISINPUTDEVICEASSIGNED:
5614
                // FUNCTION PARAMS:
5615
                // scriptEng.operands[0] = deviceID
5616

5617
                break;
5618

5619
            case FUNC_ASSIGNINPUTSLOTTODEVICE:
5620
                // FUNCTION PARAMS:
5621
                // scriptEng.operands[0] = inputSlot
5622
                // scriptEng.operands[1] = deviceID
5623

5624
                break;
5625

5626
            case FUNC_ISSLOTASSIGNED:
5627
                // FUNCTION PARAMS:
5628
                // scriptEng.operands[0] = inputSlot
5629
                //
5630
                // FUNCTION NOTES:
5631
                // - Sets scriptEng.checkResult
5632

5633
                break;
5634

5635
            case FUNC_RESETINPUTSLOTASSIGNMENTS:
5636
                // FUNCTION PARAMS:
5637
                // None
5638

5639
                break;
5640
#endif
5641
        }
5642

5643
        // Set Values
5644
        if (opcodeSize > 0)
5645
            scriptCodePtr -= scriptCodePtr - scriptCodeOffset;
5646
        for (int i = 0; i < opcodeSize; ++i) {
5647
            int opcodeType = scriptCode[scriptCodePtr++];
5648
            if (opcodeType == SCRIPTVAR_VAR) {
5649
                int arrayVal = 0;
5650
                switch (scriptCode[scriptCodePtr++]) { // variable
5651
                    case VARARR_NONE: arrayVal = objectEntityPos; break;
5652

5653
                    case VARARR_ARRAY:
5654
                        if (scriptCode[scriptCodePtr++] == 1)
5655
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
5656
                        else
5657
                            arrayVal = scriptCode[scriptCodePtr++];
5658
                        break;
5659

5660
                    case VARARR_ENTNOPLUS1:
5661
                        if (scriptCode[scriptCodePtr++] == 1)
5662
                            arrayVal = objectEntityPos + scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
5663
                        else
5664
                            arrayVal = objectEntityPos + scriptCode[scriptCodePtr++];
5665
                        break;
5666

5667
                    case VARARR_ENTNOMINUS1:
5668
                        if (scriptCode[scriptCodePtr++] == 1)
5669
                            arrayVal = objectEntityPos - scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
5670
                        else
5671
                            arrayVal = objectEntityPos - scriptCode[scriptCodePtr++];
5672
                        break;
5673

5674
                    default: break;
5675
                }
5676

5677
#if RETRO_REV03 && !RETRO_USE_ORIGINAL_CODE
5678
                bool inputCheck = true; // Default to true for mobile bytecode
5679
                // If we're using the scripts or an Origins datafile, check the array value
5680
                if (forceUseScripts || Engine.usingOrigins)
5681
                    inputCheck = arrayVal <= 1;
5682
#endif
5683

5684
                // Variables
5685
                switch (scriptCode[scriptCodePtr++]) {
5686
                    default: break;
5687
                    case VAR_TEMP0: scriptEng.temp[0] = scriptEng.operands[i]; break;
5688
                    case VAR_TEMP1: scriptEng.temp[1] = scriptEng.operands[i]; break;
5689
                    case VAR_TEMP2: scriptEng.temp[2] = scriptEng.operands[i]; break;
5690
                    case VAR_TEMP3: scriptEng.temp[3] = scriptEng.operands[i]; break;
5691
                    case VAR_TEMP4: scriptEng.temp[4] = scriptEng.operands[i]; break;
5692
                    case VAR_TEMP5: scriptEng.temp[5] = scriptEng.operands[i]; break;
5693
                    case VAR_TEMP6: scriptEng.temp[6] = scriptEng.operands[i]; break;
5694
                    case VAR_TEMP7: scriptEng.temp[7] = scriptEng.operands[i]; break;
5695
                    case VAR_CHECKRESULT: scriptEng.checkResult = scriptEng.operands[i]; break;
5696
                    case VAR_ARRAYPOS0: scriptEng.arrayPosition[0] = scriptEng.operands[i]; break;
5697
                    case VAR_ARRAYPOS1: scriptEng.arrayPosition[1] = scriptEng.operands[i]; break;
5698
                    case VAR_ARRAYPOS2: scriptEng.arrayPosition[2] = scriptEng.operands[i]; break;
5699
                    case VAR_ARRAYPOS3: scriptEng.arrayPosition[3] = scriptEng.operands[i]; break;
5700
                    case VAR_ARRAYPOS4: scriptEng.arrayPosition[4] = scriptEng.operands[i]; break;
5701
                    case VAR_ARRAYPOS5: scriptEng.arrayPosition[5] = scriptEng.operands[i]; break;
5702
                    case VAR_ARRAYPOS6: scriptEng.arrayPosition[6] = scriptEng.operands[i]; break;
5703
                    case VAR_ARRAYPOS7: scriptEng.arrayPosition[7] = scriptEng.operands[i]; break;
5704
                    case VAR_GLOBAL: globalVariables[arrayVal] = scriptEng.operands[i]; break;
5705
                    case VAR_LOCAL: scriptCode[arrayVal] = scriptEng.operands[i]; break;
5706
                    case VAR_OBJECTENTITYPOS: break;
5707
                    case VAR_OBJECTGROUPID: {
5708
                        objectEntityList[arrayVal].groupID = scriptEng.operands[i];
5709
                        break;
5710
                    }
5711
                    case VAR_OBJECTTYPE: {
5712
                        objectEntityList[arrayVal].type = scriptEng.operands[i];
5713
                        break;
5714
                    }
5715
                    case VAR_OBJECTPROPERTYVALUE: {
5716
                        objectEntityList[arrayVal].propertyValue = scriptEng.operands[i];
5717
                        break;
5718
                    }
5719
                    case VAR_OBJECTXPOS: {
5720
                        objectEntityList[arrayVal].xpos = scriptEng.operands[i];
5721
                        break;
5722
                    }
5723
                    case VAR_OBJECTYPOS: {
5724
                        objectEntityList[arrayVal].ypos = scriptEng.operands[i];
5725
                        break;
5726
                    }
5727
                    case VAR_OBJECTIXPOS: {
5728
                        objectEntityList[arrayVal].xpos = scriptEng.operands[i] << 16;
5729
                        break;
5730
                    }
5731
                    case VAR_OBJECTIYPOS: {
5732
                        objectEntityList[arrayVal].ypos = scriptEng.operands[i] << 16;
5733
                        break;
5734
                    }
5735
                    case VAR_OBJECTXVEL: {
5736
                        objectEntityList[arrayVal].xvel = scriptEng.operands[i];
5737
                        break;
5738
                    }
5739
                    case VAR_OBJECTYVEL: {
5740
                        objectEntityList[arrayVal].yvel = scriptEng.operands[i];
5741
                        break;
5742
                    }
5743
                    case VAR_OBJECTSPEED: {
5744
                        objectEntityList[arrayVal].speed = scriptEng.operands[i];
5745
                        break;
5746
                    }
5747
                    case VAR_OBJECTSTATE: {
5748
                        objectEntityList[arrayVal].state = scriptEng.operands[i];
5749
                        break;
5750
                    }
5751
                    case VAR_OBJECTROTATION: {
5752
                        objectEntityList[arrayVal].rotation = scriptEng.operands[i];
5753
                        break;
5754
                    }
5755
                    case VAR_OBJECTSCALE: {
5756
                        objectEntityList[arrayVal].scale = scriptEng.operands[i];
5757
                        break;
5758
                    }
5759
                    case VAR_OBJECTPRIORITY: {
5760
                        objectEntityList[arrayVal].priority = scriptEng.operands[i];
5761
                        break;
5762
                    }
5763
                    case VAR_OBJECTDRAWORDER: {
5764
                        objectEntityList[arrayVal].drawOrder = scriptEng.operands[i];
5765
                        break;
5766
                    }
5767
                    case VAR_OBJECTDIRECTION: {
5768
                        objectEntityList[arrayVal].direction = scriptEng.operands[i];
5769
                        break;
5770
                    }
5771
                    case VAR_OBJECTINKEFFECT: {
5772
                        objectEntityList[arrayVal].inkEffect = scriptEng.operands[i];
5773
                        break;
5774
                    }
5775
                    case VAR_OBJECTALPHA: {
5776
                        objectEntityList[arrayVal].alpha = scriptEng.operands[i];
5777
                        break;
5778
                    }
5779
                    case VAR_OBJECTFRAME: {
5780
                        objectEntityList[arrayVal].frame = scriptEng.operands[i];
5781
                        break;
5782
                    }
5783
                    case VAR_OBJECTANIMATION: {
5784
                        objectEntityList[arrayVal].animation = scriptEng.operands[i];
5785
                        break;
5786
                    }
5787
                    case VAR_OBJECTPREVANIMATION: {
5788
                        objectEntityList[arrayVal].prevAnimation = scriptEng.operands[i];
5789
                        break;
5790
                    }
5791
                    case VAR_OBJECTANIMATIONSPEED: {
5792
                        objectEntityList[arrayVal].animationSpeed = scriptEng.operands[i];
5793
                        break;
5794
                    }
5795
                    case VAR_OBJECTANIMATIONTIMER: {
5796
                        objectEntityList[arrayVal].animationTimer = scriptEng.operands[i];
5797
                        break;
5798
                    }
5799
                    case VAR_OBJECTANGLE: {
5800
                        objectEntityList[arrayVal].angle = scriptEng.operands[i];
5801
                        break;
5802
                    }
5803
                    case VAR_OBJECTLOOKPOSX: {
5804
                        objectEntityList[arrayVal].lookPosX = scriptEng.operands[i];
5805
                        break;
5806
                    }
5807
                    case VAR_OBJECTLOOKPOSY: {
5808
                        objectEntityList[arrayVal].lookPosY = scriptEng.operands[i];
5809
                        break;
5810
                    }
5811
                    case VAR_OBJECTCOLLISIONMODE: {
5812
                        objectEntityList[arrayVal].collisionMode = scriptEng.operands[i];
5813
                        break;
5814
                    }
5815
                    case VAR_OBJECTCOLLISIONPLANE: {
5816
                        objectEntityList[arrayVal].collisionPlane = scriptEng.operands[i];
5817
                        break;
5818
                    }
5819
                    case VAR_OBJECTCONTROLMODE: {
5820
                        objectEntityList[arrayVal].controlMode = scriptEng.operands[i];
5821
                        break;
5822
                    }
5823
                    case VAR_OBJECTCONTROLLOCK: {
5824
                        objectEntityList[arrayVal].controlLock = scriptEng.operands[i];
5825
                        break;
5826
                    }
5827
                    case VAR_OBJECTPUSHING: {
5828
                        objectEntityList[arrayVal].pushing = scriptEng.operands[i];
5829
                        break;
5830
                    }
5831
                    case VAR_OBJECTVISIBLE: {
5832
                        objectEntityList[arrayVal].visible = scriptEng.operands[i];
5833
                        break;
5834
                    }
5835
                    case VAR_OBJECTTILECOLLISIONS: {
5836
                        objectEntityList[arrayVal].tileCollisions = scriptEng.operands[i];
5837
                        break;
5838
                    }
5839
                    case VAR_OBJECTINTERACTION: {
5840
                        objectEntityList[arrayVal].objectInteractions = scriptEng.operands[i];
5841
                        break;
5842
                    }
5843
                    case VAR_OBJECTGRAVITY: {
5844
                        objectEntityList[arrayVal].gravity = scriptEng.operands[i];
5845
                        break;
5846
                    }
5847
                    case VAR_OBJECTUP: {
5848
                        objectEntityList[arrayVal].up = scriptEng.operands[i];
5849
                        break;
5850
                    }
5851
                    case VAR_OBJECTDOWN: {
5852
                        objectEntityList[arrayVal].down = scriptEng.operands[i];
5853
                        break;
5854
                    }
5855
                    case VAR_OBJECTLEFT: {
5856
                        objectEntityList[arrayVal].left = scriptEng.operands[i];
5857
                        break;
5858
                    }
5859
                    case VAR_OBJECTRIGHT: {
5860
                        objectEntityList[arrayVal].right = scriptEng.operands[i];
5861
                        break;
5862
                    }
5863
                    case VAR_OBJECTJUMPPRESS: {
5864
                        objectEntityList[arrayVal].jumpPress = scriptEng.operands[i];
5865
                        break;
5866
                    }
5867
                    case VAR_OBJECTJUMPHOLD: {
5868
                        objectEntityList[arrayVal].jumpHold = scriptEng.operands[i];
5869
                        break;
5870
                    }
5871
                    case VAR_OBJECTSCROLLTRACKING: {
5872
                        objectEntityList[arrayVal].scrollTracking = scriptEng.operands[i];
5873
                        break;
5874
                    }
5875
                    case VAR_OBJECTFLOORSENSORL: {
5876
                        objectEntityList[arrayVal].floorSensors[0] = scriptEng.operands[i];
5877
                        break;
5878
                    }
5879
                    case VAR_OBJECTFLOORSENSORC: {
5880
                        objectEntityList[arrayVal].floorSensors[1] = scriptEng.operands[i];
5881
                        break;
5882
                    }
5883
                    case VAR_OBJECTFLOORSENSORR: {
5884
                        objectEntityList[arrayVal].floorSensors[2] = scriptEng.operands[i];
5885
                        break;
5886
                    }
5887
#if !RETRO_REV00
5888
                    case VAR_OBJECTFLOORSENSORLC: {
5889
                        objectEntityList[arrayVal].floorSensors[3] = scriptEng.operands[i];
5890
                        break;
5891
                    }
5892
                    case VAR_OBJECTFLOORSENSORRC: {
5893
                        objectEntityList[arrayVal].floorSensors[4] = scriptEng.operands[i];
5894
                        break;
5895
                    }
5896
#endif
5897
                    case VAR_OBJECTCOLLISIONLEFT: {
5898
                        break;
5899
                    }
5900
                    case VAR_OBJECTCOLLISIONTOP: {
5901
                        break;
5902
                    }
5903
                    case VAR_OBJECTCOLLISIONRIGHT: {
5904
                        break;
5905
                    }
5906
                    case VAR_OBJECTCOLLISIONBOTTOM: {
5907
                        break;
5908
                    }
5909
                    case VAR_OBJECTOUTOFBOUNDS: {
5910
                        break;
5911
                    }
5912
                    case VAR_OBJECTSPRITESHEET: {
5913
                        objectScriptList[objectEntityList[arrayVal].type].spriteSheetID = scriptEng.operands[i];
5914
                        break;
5915
                    }
5916
                    case VAR_OBJECTVALUE0: {
5917
                        objectEntityList[arrayVal].values[0] = scriptEng.operands[i];
5918
                        break;
5919
                    }
5920
                    case VAR_OBJECTVALUE1: {
5921
                        objectEntityList[arrayVal].values[1] = scriptEng.operands[i];
5922
                        break;
5923
                    }
5924
                    case VAR_OBJECTVALUE2: {
5925
                        objectEntityList[arrayVal].values[2] = scriptEng.operands[i];
5926
                        break;
5927
                    }
5928
                    case VAR_OBJECTVALUE3: {
5929
                        objectEntityList[arrayVal].values[3] = scriptEng.operands[i];
5930
                        break;
5931
                    }
5932
                    case VAR_OBJECTVALUE4: {
5933
                        objectEntityList[arrayVal].values[4] = scriptEng.operands[i];
5934
                        break;
5935
                    }
5936
                    case VAR_OBJECTVALUE5: {
5937
                        objectEntityList[arrayVal].values[5] = scriptEng.operands[i];
5938
                        break;
5939
                    }
5940
                    case VAR_OBJECTVALUE6: {
5941
                        objectEntityList[arrayVal].values[6] = scriptEng.operands[i];
5942
                        break;
5943
                    }
5944
                    case VAR_OBJECTVALUE7: {
5945
                        objectEntityList[arrayVal].values[7] = scriptEng.operands[i];
5946
                        break;
5947
                    }
5948
                    case VAR_OBJECTVALUE8: {
5949
                        objectEntityList[arrayVal].values[8] = scriptEng.operands[i];
5950
                        break;
5951
                    }
5952
                    case VAR_OBJECTVALUE9: {
5953
                        objectEntityList[arrayVal].values[9] = scriptEng.operands[i];
5954
                        break;
5955
                    }
5956
                    case VAR_OBJECTVALUE10: {
5957
                        objectEntityList[arrayVal].values[10] = scriptEng.operands[i];
5958
                        break;
5959
                    }
5960
                    case VAR_OBJECTVALUE11: {
5961
                        objectEntityList[arrayVal].values[11] = scriptEng.operands[i];
5962
                        break;
5963
                    }
5964
                    case VAR_OBJECTVALUE12: {
5965
                        objectEntityList[arrayVal].values[12] = scriptEng.operands[i];
5966
                        break;
5967
                    }
5968
                    case VAR_OBJECTVALUE13: {
5969
                        objectEntityList[arrayVal].values[13] = scriptEng.operands[i];
5970
                        break;
5971
                    }
5972
                    case VAR_OBJECTVALUE14: {
5973
                        objectEntityList[arrayVal].values[14] = scriptEng.operands[i];
5974
                        break;
5975
                    }
5976
                    case VAR_OBJECTVALUE15: {
5977
                        objectEntityList[arrayVal].values[15] = scriptEng.operands[i];
5978
                        break;
5979
                    }
5980
                    case VAR_OBJECTVALUE16: {
5981
                        objectEntityList[arrayVal].values[16] = scriptEng.operands[i];
5982
                        break;
5983
                    }
5984
                    case VAR_OBJECTVALUE17: {
5985
                        objectEntityList[arrayVal].values[17] = scriptEng.operands[i];
5986
                        break;
5987
                    }
5988
                    case VAR_OBJECTVALUE18: {
5989
                        objectEntityList[arrayVal].values[18] = scriptEng.operands[i];
5990
                        break;
5991
                    }
5992
                    case VAR_OBJECTVALUE19: {
5993
                        objectEntityList[arrayVal].values[19] = scriptEng.operands[i];
5994
                        break;
5995
                    }
5996
                    case VAR_OBJECTVALUE20: {
5997
                        objectEntityList[arrayVal].values[20] = scriptEng.operands[i];
5998
                        break;
5999
                    }
6000
                    case VAR_OBJECTVALUE21: {
6001
                        objectEntityList[arrayVal].values[21] = scriptEng.operands[i];
6002
                        break;
6003
                    }
6004
                    case VAR_OBJECTVALUE22: {
6005
                        objectEntityList[arrayVal].values[22] = scriptEng.operands[i];
6006
                        break;
6007
                    }
6008
                    case VAR_OBJECTVALUE23: {
6009
                        objectEntityList[arrayVal].values[23] = scriptEng.operands[i];
6010
                        break;
6011
                    }
6012
                    case VAR_OBJECTVALUE24: {
6013
                        objectEntityList[arrayVal].values[24] = scriptEng.operands[i];
6014
                        break;
6015
                    }
6016
                    case VAR_OBJECTVALUE25: {
6017
                        objectEntityList[arrayVal].values[25] = scriptEng.operands[i];
6018
                        break;
6019
                    }
6020
                    case VAR_OBJECTVALUE26: {
6021
                        objectEntityList[arrayVal].values[26] = scriptEng.operands[i];
6022
                        break;
6023
                    }
6024
                    case VAR_OBJECTVALUE27: {
6025
                        objectEntityList[arrayVal].values[27] = scriptEng.operands[i];
6026
                        break;
6027
                    }
6028
                    case VAR_OBJECTVALUE28: {
6029
                        objectEntityList[arrayVal].values[28] = scriptEng.operands[i];
6030
                        break;
6031
                    }
6032
                    case VAR_OBJECTVALUE29: {
6033
                        objectEntityList[arrayVal].values[29] = scriptEng.operands[i];
6034
                        break;
6035
                    }
6036
                    case VAR_OBJECTVALUE30: {
6037
                        objectEntityList[arrayVal].values[30] = scriptEng.operands[i];
6038
                        break;
6039
                    }
6040
                    case VAR_OBJECTVALUE31: {
6041
                        objectEntityList[arrayVal].values[31] = scriptEng.operands[i];
6042
                        break;
6043
                    }
6044
                    case VAR_OBJECTVALUE32: {
6045
                        objectEntityList[arrayVal].values[32] = scriptEng.operands[i];
6046
                        break;
6047
                    }
6048
                    case VAR_OBJECTVALUE33: {
6049
                        objectEntityList[arrayVal].values[33] = scriptEng.operands[i];
6050
                        break;
6051
                    }
6052
                    case VAR_OBJECTVALUE34: {
6053
                        objectEntityList[arrayVal].values[34] = scriptEng.operands[i];
6054
                        break;
6055
                    }
6056
                    case VAR_OBJECTVALUE35: {
6057
                        objectEntityList[arrayVal].values[35] = scriptEng.operands[i];
6058
                        break;
6059
                    }
6060
                    case VAR_OBJECTVALUE36: {
6061
                        objectEntityList[arrayVal].values[36] = scriptEng.operands[i];
6062
                        break;
6063
                    }
6064
                    case VAR_OBJECTVALUE37: {
6065
                        objectEntityList[arrayVal].values[37] = scriptEng.operands[i];
6066
                        break;
6067
                    }
6068
                    case VAR_OBJECTVALUE38: {
6069
                        objectEntityList[arrayVal].values[38] = scriptEng.operands[i];
6070
                        break;
6071
                    }
6072
                    case VAR_OBJECTVALUE39: {
6073
                        objectEntityList[arrayVal].values[39] = scriptEng.operands[i];
6074
                        break;
6075
                    }
6076
                    case VAR_OBJECTVALUE40: {
6077
                        objectEntityList[arrayVal].values[40] = scriptEng.operands[i];
6078
                        break;
6079
                    }
6080
                    case VAR_OBJECTVALUE41: {
6081
                        objectEntityList[arrayVal].values[41] = scriptEng.operands[i];
6082
                        break;
6083
                    }
6084
                    case VAR_OBJECTVALUE42: {
6085
                        objectEntityList[arrayVal].values[42] = scriptEng.operands[i];
6086
                        break;
6087
                    }
6088
                    case VAR_OBJECTVALUE43: {
6089
                        objectEntityList[arrayVal].values[43] = scriptEng.operands[i];
6090
                        break;
6091
                    }
6092
                    case VAR_OBJECTVALUE44: {
6093
                        objectEntityList[arrayVal].values[44] = scriptEng.operands[i];
6094
                        break;
6095
                    }
6096
                    case VAR_OBJECTVALUE45: {
6097
                        objectEntityList[arrayVal].values[45] = scriptEng.operands[i];
6098
                        break;
6099
                    }
6100
                    case VAR_OBJECTVALUE46: {
6101
                        objectEntityList[arrayVal].values[46] = scriptEng.operands[i];
6102
                        break;
6103
                    }
6104
                    case VAR_OBJECTVALUE47: {
6105
                        objectEntityList[arrayVal].values[47] = scriptEng.operands[i];
6106
                        break;
6107
                    }
6108
                    case VAR_STAGESTATE: stageMode = scriptEng.operands[i]; break;
6109
                    case VAR_STAGEACTIVELIST:
6110
#if RETRO_REV03 && !RETRO_USE_ORIGINAL_CODE
6111
                        // BONUS_STAGE and SPECIAL_STAGE are swapped on Origins bytecode, so correct it here
6112
                        if (Engine.usingOrigins && !forceUseScripts) {
6113
                            int listSlots[] = { 0, 1, 3, 2 };
6114

6115
                            int listID = scriptEng.operands[i];
6116
                            if (listID <= 3)
6117
                                listID = listSlots[listID];
6118
                            else
6119
                                listID = 2; // BONUS_STAGE
6120

6121
                            activeStageList = listID;
6122
                        }
6123
                        else
6124
                            activeStageList = scriptEng.operands[i];
6125
#else
6126
                        activeStageList = scriptEng.operands[i];
6127
#endif
6128
                        break;
6129
                    case VAR_STAGELISTPOS: stageListPosition = scriptEng.operands[i]; break;
6130
                    case VAR_STAGETIMEENABLED: timeEnabled = scriptEng.operands[i]; break;
6131
                    case VAR_STAGEMILLISECONDS: stageMilliseconds = scriptEng.operands[i]; break;
6132
                    case VAR_STAGESECONDS: stageSeconds = scriptEng.operands[i]; break;
6133
                    case VAR_STAGEMINUTES: stageMinutes = scriptEng.operands[i]; break;
6134
                    case VAR_STAGEACTNUM: actID = scriptEng.operands[i]; break;
6135
                    case VAR_STAGEPAUSEENABLED: pauseEnabled = scriptEng.operands[i]; break;
6136
                    case VAR_STAGELISTSIZE: break;
6137
                    case VAR_STAGENEWXBOUNDARY1: newXBoundary1 = scriptEng.operands[i]; break;
6138
                    case VAR_STAGENEWXBOUNDARY2: newXBoundary2 = scriptEng.operands[i]; break;
6139
                    case VAR_STAGENEWYBOUNDARY1: newYBoundary1 = scriptEng.operands[i]; break;
6140
                    case VAR_STAGENEWYBOUNDARY2: newYBoundary2 = scriptEng.operands[i]; break;
6141
                    case VAR_STAGECURXBOUNDARY1:
6142
                        if (curXBoundary1 != scriptEng.operands[i]) {
6143
                            curXBoundary1 = scriptEng.operands[i];
6144
                            newXBoundary1 = scriptEng.operands[i];
6145
                        }
6146
                        break;
6147
                    case VAR_STAGECURXBOUNDARY2:
6148
                        if (curXBoundary2 != scriptEng.operands[i]) {
6149
                            curXBoundary2 = scriptEng.operands[i];
6150
                            newXBoundary2 = scriptEng.operands[i];
6151
                        }
6152
                        break;
6153
                    case VAR_STAGECURYBOUNDARY1:
6154
                        if (curYBoundary1 != scriptEng.operands[i]) {
6155
                            curYBoundary1 = scriptEng.operands[i];
6156
                            newYBoundary1 = scriptEng.operands[i];
6157
                        }
6158
                        break;
6159
                    case VAR_STAGECURYBOUNDARY2:
6160
                        if (curYBoundary2 != scriptEng.operands[i]) {
6161
                            curYBoundary2 = scriptEng.operands[i];
6162
                            newYBoundary2 = scriptEng.operands[i];
6163
                        }
6164
                        break;
6165
                    case VAR_STAGEDEFORMATIONDATA0: bgDeformationData0[arrayVal] = scriptEng.operands[i]; break;
6166
                    case VAR_STAGEDEFORMATIONDATA1: bgDeformationData1[arrayVal] = scriptEng.operands[i]; break;
6167
                    case VAR_STAGEDEFORMATIONDATA2: bgDeformationData2[arrayVal] = scriptEng.operands[i]; break;
6168
                    case VAR_STAGEDEFORMATIONDATA3: bgDeformationData3[arrayVal] = scriptEng.operands[i]; break;
6169
                    case VAR_STAGEWATERLEVEL: waterLevel = scriptEng.operands[i]; break;
6170
                    case VAR_STAGEACTIVELAYER: activeTileLayers[arrayVal] = scriptEng.operands[i]; break;
6171
                    case VAR_STAGEMIDPOINT: tLayerMidPoint = scriptEng.operands[i]; break;
6172
                    case VAR_STAGEPLAYERLISTPOS: playerListPos = scriptEng.operands[i]; break;
6173
                    case VAR_STAGEDEBUGMODE: debugMode = scriptEng.operands[i]; break;
6174
                    case VAR_STAGEENTITYPOS: objectEntityPos = scriptEng.operands[i]; break;
6175
                    case VAR_SCREENCAMERAENABLED: cameraEnabled = scriptEng.operands[i]; break;
6176
                    case VAR_SCREENCAMERATARGET: cameraTarget = scriptEng.operands[i]; break;
6177
                    case VAR_SCREENCAMERASTYLE: cameraStyle = scriptEng.operands[i]; break;
6178
                    case VAR_SCREENCAMERAX: cameraXPos = scriptEng.operands[i]; break;
6179
                    case VAR_SCREENCAMERAY: cameraYPos = scriptEng.operands[i]; break;
6180
                    case VAR_SCREENDRAWLISTSIZE: drawListEntries[arrayVal].listSize = scriptEng.operands[i]; break;
6181
                    case VAR_SCREENXCENTER: break;
6182
                    case VAR_SCREENYCENTER: break;
6183
                    case VAR_SCREENXSIZE: break;
6184
                    case VAR_SCREENYSIZE: break;
6185
                    case VAR_SCREENXOFFSET: xScrollOffset = scriptEng.operands[i]; break;
6186
                    case VAR_SCREENYOFFSET: yScrollOffset = scriptEng.operands[i]; break;
6187
                    case VAR_SCREENSHAKEX: cameraShakeX = scriptEng.operands[i]; break;
6188
                    case VAR_SCREENSHAKEY: cameraShakeY = scriptEng.operands[i]; break;
6189
                    case VAR_SCREENADJUSTCAMERAY: cameraAdjustY = scriptEng.operands[i]; break;
6190
                    case VAR_TOUCHSCREENDOWN: break;
6191
                    case VAR_TOUCHSCREENXPOS: break;
6192
                    case VAR_TOUCHSCREENYPOS: break;
6193
                    case VAR_MUSICVOLUME: SetMusicVolume(scriptEng.operands[i]); break;
6194
                    case VAR_MUSICCURRENTTRACK: break;
6195
                    case VAR_MUSICPOSITION: break;
6196
#if RETRO_REV03 && !RETRO_USE_ORIGINAL_CODE
6197
                    case VAR_KEYDOWNUP:
6198
                        if (inputCheck)
6199
                            keyDown.up = scriptEng.operands[i];
6200
                        break;
6201
                    case VAR_KEYDOWNDOWN:
6202
                        if (inputCheck)
6203
                            keyDown.down = scriptEng.operands[i];
6204
                        break;
6205
                    case VAR_KEYDOWNLEFT:
6206
                        if (inputCheck)
6207
                            keyDown.left = scriptEng.operands[i];
6208
                        break;
6209
                    case VAR_KEYDOWNRIGHT:
6210
                        if (inputCheck)
6211
                            keyDown.right = scriptEng.operands[i];
6212
                        break;
6213
                    case VAR_KEYDOWNBUTTONA:
6214
                        if (inputCheck)
6215
                            keyDown.A = scriptEng.operands[i];
6216
                        break;
6217
                    case VAR_KEYDOWNBUTTONB:
6218
                        if (inputCheck)
6219
                            keyDown.B = scriptEng.operands[i];
6220
                        break;
6221
                    case VAR_KEYDOWNBUTTONC:
6222
                        if (inputCheck)
6223
                            keyDown.C = scriptEng.operands[i];
6224
                        break;
6225
                    case VAR_KEYDOWNBUTTONX:
6226
                        if (inputCheck)
6227
                            keyDown.X = scriptEng.operands[i];
6228
                        break;
6229
                    case VAR_KEYDOWNBUTTONY:
6230
                        if (inputCheck)
6231
                            keyDown.Y = scriptEng.operands[i];
6232
                        break;
6233
                    case VAR_KEYDOWNBUTTONZ:
6234
                        if (inputCheck)
6235
                            keyDown.Z = scriptEng.operands[i];
6236
                        break;
6237
                    case VAR_KEYDOWNBUTTONL:
6238
                        if (inputCheck)
6239
                            keyDown.L = scriptEng.operands[i];
6240
                        break;
6241
                    case VAR_KEYDOWNBUTTONR:
6242
                        if (inputCheck)
6243
                            keyDown.R = scriptEng.operands[i];
6244
                        break;
6245
                    case VAR_KEYDOWNSTART:
6246
                        if (inputCheck)
6247
                            keyDown.start = scriptEng.operands[i];
6248
                        break;
6249
                    case VAR_KEYDOWNSELECT:
6250
                        if (inputCheck)
6251
                            keyDown.select = scriptEng.operands[i];
6252
                        break;
6253
                    case VAR_KEYPRESSUP:
6254
                        if (inputCheck)
6255
                            keyPress.up = scriptEng.operands[i];
6256
                        break;
6257
                    case VAR_KEYPRESSDOWN:
6258
                        if (inputCheck)
6259
                            keyPress.down = scriptEng.operands[i];
6260
                        break;
6261
                    case VAR_KEYPRESSLEFT:
6262
                        if (inputCheck)
6263
                            keyPress.left = scriptEng.operands[i];
6264
                        break;
6265
                    case VAR_KEYPRESSRIGHT:
6266
                        if (inputCheck)
6267
                            keyPress.right = scriptEng.operands[i];
6268
                        break;
6269
                    case VAR_KEYPRESSBUTTONA:
6270
                        if (inputCheck)
6271
                            keyPress.A = scriptEng.operands[i];
6272
                        break;
6273
                    case VAR_KEYPRESSBUTTONB:
6274
                        if (inputCheck)
6275
                            keyPress.B = scriptEng.operands[i];
6276
                        break;
6277
                    case VAR_KEYPRESSBUTTONC:
6278
                        if (inputCheck)
6279
                            keyPress.C = scriptEng.operands[i];
6280
                        break;
6281
                    case VAR_KEYPRESSBUTTONX:
6282
                        if (inputCheck)
6283
                            keyPress.X = scriptEng.operands[i];
6284
                        break;
6285
                    case VAR_KEYPRESSBUTTONY:
6286
                        if (inputCheck)
6287
                            keyPress.Y = scriptEng.operands[i];
6288
                        break;
6289
                    case VAR_KEYPRESSBUTTONZ:
6290
                        if (inputCheck)
6291
                            keyPress.Z = scriptEng.operands[i];
6292
                        break;
6293
                    case VAR_KEYPRESSBUTTONL:
6294
                        if (inputCheck)
6295
                            keyPress.L = scriptEng.operands[i];
6296
                        break;
6297
                    case VAR_KEYPRESSBUTTONR:
6298
                        if (inputCheck)
6299
                            keyPress.R = scriptEng.operands[i];
6300
                        break;
6301
                    case VAR_KEYPRESSSTART:
6302
                        if (inputCheck)
6303
                            keyPress.start = scriptEng.operands[i];
6304
                        break;
6305
                    case VAR_KEYPRESSSELECT:
6306
                        if (inputCheck)
6307
                            keyPress.select = scriptEng.operands[i];
6308
                        break;
6309
#else
6310
                    case VAR_KEYDOWNUP: keyDown.up = scriptEng.operands[i]; break;
6311
                    case VAR_KEYDOWNDOWN: keyDown.down = scriptEng.operands[i]; break;
6312
                    case VAR_KEYDOWNLEFT: keyDown.left = scriptEng.operands[i]; break;
6313
                    case VAR_KEYDOWNRIGHT: keyDown.right = scriptEng.operands[i]; break;
6314
                    case VAR_KEYDOWNBUTTONA: keyDown.A = scriptEng.operands[i]; break;
6315
                    case VAR_KEYDOWNBUTTONB: keyDown.B = scriptEng.operands[i]; break;
6316
                    case VAR_KEYDOWNBUTTONC: keyDown.C = scriptEng.operands[i]; break;
6317
                    case VAR_KEYDOWNBUTTONX: keyDown.X = scriptEng.operands[i]; break;
6318
                    case VAR_KEYDOWNBUTTONY: keyDown.Y = scriptEng.operands[i]; break;
6319
                    case VAR_KEYDOWNBUTTONZ: keyDown.Z = scriptEng.operands[i]; break;
6320
                    case VAR_KEYDOWNBUTTONL: keyDown.L = scriptEng.operands[i]; break;
6321
                    case VAR_KEYDOWNBUTTONR: keyDown.R = scriptEng.operands[i]; break;
6322
                    case VAR_KEYDOWNSTART: keyDown.start = scriptEng.operands[i]; break;
6323
                    case VAR_KEYDOWNSELECT: keyDown.select = scriptEng.operands[i]; break;
6324
                    case VAR_KEYPRESSUP: keyPress.up = scriptEng.operands[i]; break;
6325
                    case VAR_KEYPRESSDOWN: keyPress.down = scriptEng.operands[i]; break;
6326
                    case VAR_KEYPRESSLEFT: keyPress.left = scriptEng.operands[i]; break;
6327
                    case VAR_KEYPRESSRIGHT: keyPress.right = scriptEng.operands[i]; break;
6328
                    case VAR_KEYPRESSBUTTONA: keyPress.A = scriptEng.operands[i]; break;
6329
                    case VAR_KEYPRESSBUTTONB: keyPress.B = scriptEng.operands[i]; break;
6330
                    case VAR_KEYPRESSBUTTONC: keyPress.C = scriptEng.operands[i]; break;
6331
                    case VAR_KEYPRESSBUTTONX: keyPress.X = scriptEng.operands[i]; break;
6332
                    case VAR_KEYPRESSBUTTONY: keyPress.Y = scriptEng.operands[i]; break;
6333
                    case VAR_KEYPRESSBUTTONZ: keyPress.Z = scriptEng.operands[i]; break;
6334
                    case VAR_KEYPRESSBUTTONL: keyPress.L = scriptEng.operands[i]; break;
6335
                    case VAR_KEYPRESSBUTTONR: keyPress.R = scriptEng.operands[i]; break;
6336
                    case VAR_KEYPRESSSTART: keyPress.start = scriptEng.operands[i]; break;
6337
                    case VAR_KEYPRESSSELECT: keyPress.select = scriptEng.operands[i]; break;
6338
#endif
6339
                    case VAR_MENU1SELECTION: gameMenu[0].selection1 = scriptEng.operands[i]; break;
6340
                    case VAR_MENU2SELECTION: gameMenu[1].selection1 = scriptEng.operands[i]; break;
6341
                    case VAR_TILELAYERXSIZE: stageLayouts[arrayVal].xsize = scriptEng.operands[i]; break;
6342
                    case VAR_TILELAYERYSIZE: stageLayouts[arrayVal].ysize = scriptEng.operands[i]; break;
6343
                    case VAR_TILELAYERTYPE: stageLayouts[arrayVal].type = scriptEng.operands[i]; break;
6344
                    case VAR_TILELAYERANGLE: {
6345
                        int angle = scriptEng.operands[i] + 0x200;
6346
                        if (scriptEng.operands[i] >= 0)
6347
                            angle = scriptEng.operands[i];
6348
                        stageLayouts[arrayVal].angle = angle & 0x1FF;
6349
                        break;
6350
                    }
6351
                    case VAR_TILELAYERXPOS: stageLayouts[arrayVal].xpos = scriptEng.operands[i]; break;
6352
                    case VAR_TILELAYERYPOS: stageLayouts[arrayVal].ypos = scriptEng.operands[i]; break;
6353
                    case VAR_TILELAYERZPOS: stageLayouts[arrayVal].zpos = scriptEng.operands[i]; break;
6354
                    case VAR_TILELAYERPARALLAXFACTOR: stageLayouts[arrayVal].parallaxFactor = scriptEng.operands[i]; break;
6355
                    case VAR_TILELAYERSCROLLSPEED: stageLayouts[arrayVal].scrollSpeed = scriptEng.operands[i]; break;
6356
                    case VAR_TILELAYERSCROLLPOS: stageLayouts[arrayVal].scrollPos = scriptEng.operands[i]; break;
6357
                    case VAR_TILELAYERDEFORMATIONOFFSET: stageLayouts[arrayVal].deformationOffset = scriptEng.operands[i]; break;
6358
                    case VAR_TILELAYERDEFORMATIONOFFSETW: stageLayouts[arrayVal].deformationOffsetW = scriptEng.operands[i]; break;
6359
                    case VAR_HPARALLAXPARALLAXFACTOR: hParallax.parallaxFactor[arrayVal] = scriptEng.operands[i]; break;
6360
                    case VAR_HPARALLAXSCROLLSPEED: hParallax.scrollSpeed[arrayVal] = scriptEng.operands[i]; break;
6361
                    case VAR_HPARALLAXSCROLLPOS: hParallax.scrollPos[arrayVal] = scriptEng.operands[i]; break;
6362
                    case VAR_VPARALLAXPARALLAXFACTOR: vParallax.parallaxFactor[arrayVal] = scriptEng.operands[i]; break;
6363
                    case VAR_VPARALLAXSCROLLSPEED: vParallax.scrollSpeed[arrayVal] = scriptEng.operands[i]; break;
6364
                    case VAR_VPARALLAXSCROLLPOS: vParallax.scrollPos[arrayVal] = scriptEng.operands[i]; break;
6365
                    case VAR_SCENE3DVERTEXCOUNT: vertexCount = scriptEng.operands[i]; break;
6366
                    case VAR_SCENE3DFACECOUNT: faceCount = scriptEng.operands[i]; break;
6367
                    case VAR_SCENE3DPROJECTIONX: projectionX = scriptEng.operands[i]; break;
6368
                    case VAR_SCENE3DPROJECTIONY: projectionY = scriptEng.operands[i]; break;
6369
#if !RETRO_REV00
6370
                    case VAR_SCENE3DFOGCOLOR: fogColor = scriptEng.operands[i]; break;
6371
                    case VAR_SCENE3DFOGSTRENGTH: fogStrength = scriptEng.operands[i]; break;
6372
#endif
6373
                    case VAR_VERTEXBUFFERX: vertexBuffer[arrayVal].x = scriptEng.operands[i]; break;
6374
                    case VAR_VERTEXBUFFERY: vertexBuffer[arrayVal].y = scriptEng.operands[i]; break;
6375
                    case VAR_VERTEXBUFFERZ: vertexBuffer[arrayVal].z = scriptEng.operands[i]; break;
6376
                    case VAR_VERTEXBUFFERU: vertexBuffer[arrayVal].u = scriptEng.operands[i]; break;
6377
                    case VAR_VERTEXBUFFERV: vertexBuffer[arrayVal].v = scriptEng.operands[i]; break;
6378
                    case VAR_FACEBUFFERA: faceBuffer[arrayVal].a = scriptEng.operands[i]; break;
6379
                    case VAR_FACEBUFFERB: faceBuffer[arrayVal].b = scriptEng.operands[i]; break;
6380
                    case VAR_FACEBUFFERC: faceBuffer[arrayVal].c = scriptEng.operands[i]; break;
6381
                    case VAR_FACEBUFFERD: faceBuffer[arrayVal].d = scriptEng.operands[i]; break;
6382
                    case VAR_FACEBUFFERFLAG: faceBuffer[arrayVal].flag = scriptEng.operands[i]; break;
6383
                    case VAR_FACEBUFFERCOLOR: faceBuffer[arrayVal].color = scriptEng.operands[i]; break;
6384
                    case VAR_SAVERAM: saveRAM[arrayVal] = scriptEng.operands[i]; break;
6385
                    case VAR_ENGINESTATE: Engine.gameMode = scriptEng.operands[i]; break;
6386
#if RETRO_REV00
6387
                    case VAR_ENGINEMESSAGE: break;
6388
#endif
6389
                    case VAR_ENGINELANGUAGE: Engine.language = scriptEng.operands[i]; break;
6390
                    case VAR_ENGINEONLINEACTIVE: Engine.onlineActive = scriptEng.operands[i]; break;
6391
                    case VAR_ENGINESFXVOLUME:
6392
                        sfxVolume = scriptEng.operands[i];
6393
                        SetGameVolumes(bgmVolume, sfxVolume);
6394
                        break;
6395
                    case VAR_ENGINEBGMVOLUME:
6396
                        bgmVolume = scriptEng.operands[i];
6397
                        SetGameVolumes(bgmVolume, sfxVolume);
6398
                        break;
6399
#if RETRO_REV00
6400
                    case VAR_ENGINEPLATFORMID: break;
6401
#endif
6402
                    case VAR_ENGINETRIALMODE: Engine.trialMode = scriptEng.operands[i]; break;
6403
#if !RETRO_REV00
6404
                    case VAR_ENGINEDEVICETYPE: break;
6405
#endif
6406

6407
#if RETRO_REV03
6408
                    // Origins Extras
6409
                    // Due to using regular v4, these don't support array values like origins expects, so its always screen[0]
6410
                    case VAR_SCREENCURRENTID: break;
6411
                    case VAR_CAMERAENABLED:
6412
                        if (arrayVal == 0)
6413
                            cameraEnabled = scriptEng.operands[i];
6414
                        break;
6415
                    case VAR_CAMERATARGET:
6416
                        if (arrayVal == 0)
6417
                            cameraTarget = scriptEng.operands[i];
6418
                        break;
6419
                    case VAR_CAMERASTYLE:
6420
                        if (arrayVal == 0)
6421
                            cameraStyle = scriptEng.operands[i];
6422
                        break;
6423
                    case VAR_CAMERAXPOS:
6424
                        if (arrayVal == 0)
6425
                            cameraXPos = scriptEng.operands[i];
6426
                        break;
6427
                    case VAR_CAMERAYPOS:
6428
                        if (arrayVal == 0)
6429
                            cameraYPos = scriptEng.operands[i];
6430
                        break;
6431
                    case VAR_CAMERAADJUSTY:
6432
                        if (arrayVal == 0)
6433
                            cameraAdjustY = scriptEng.operands[i];
6434
                        break;
6435
#endif
6436

6437
#if RETRO_USE_HAPTICS
6438
                    case VAR_HAPTICSENABLED: Engine.hapticsEnabled = scriptEng.operands[i]; break;
6439
#endif
6440
                }
6441
            }
6442
            else if (opcodeType == SCRIPTVAR_INTCONST) { // int constant
6443
                scriptCodePtr++;
6444
            }
6445
            else if (opcodeType == SCRIPTVAR_STRCONST) { // string constant
6446
                int strLen = scriptCode[scriptCodePtr++];
6447
                for (int c = 0; c < strLen; ++c) {
6448
                    switch (c % 4) {
6449
                        case 0: break;
6450
                        case 1: break;
6451
                        case 2: break;
6452
                        case 3: ++scriptCodePtr; break;
6453
                        default: break;
6454
                    }
6455
                }
6456
                scriptCodePtr++;
6457
            }
6458
        }
6459
    }
6460
}
6461

6462
Product

Resources

Company
