CoCalc -- ScriptLegacyv4.cpp

GitHub Repository: Rubberduckycooly/RSDKv5-Decompilation
Path: blob/master/RSDKv5/RSDK/Scene/Legacy/v4/ScriptLegacyv4.cpp
¹¹⁷⁴ views
1

2

3
RSDK::Legacy::v4::ObjectScript RSDK::Legacy::v4::objectScriptList[LEGACY_v4_OBJECT_COUNT];
4
RSDK::Legacy::v4::ScriptFunction RSDK::Legacy::v4::scriptFunctionList[LEGACY_v4_FUNCTION_COUNT];
5
#if LEGACY_RETRO_USE_COMPILER
6
int32 RSDK::Legacy::v4::scriptFunctionCount = 0;
7
#endif
8

9
int32 RSDK::Legacy::v4::scriptCode[LEGACY_v4_SCRIPTCODE_COUNT];
10
int32 RSDK::Legacy::v4::jumpTable[LEGACY_v4_JUMPTABLE_COUNT];
11
int32 RSDK::Legacy::v4::jumpTableStack[LEGACY_v4_JUMPSTACK_COUNT];
12
int32 RSDK::Legacy::v4::functionStack[LEGACY_v4_FUNCSTACK_COUNT];
13
int32 RSDK::Legacy::v4::foreachStack[LEGACY_v4_FORSTACK_COUNT];
14

15
int32 RSDK::Legacy::v4::scriptCodePos     = 0;
16
int32 RSDK::Legacy::v4::scriptCodeOffset  = 0;
17
int32 RSDK::Legacy::v4::jumpTablePos      = 0;
18
int32 RSDK::Legacy::v4::jumpTableOffset   = 0;
19
int32 RSDK::Legacy::v4::jumpTableStackPos = 0;
20
int32 RSDK::Legacy::v4::functionStackPos  = 0;
21
int32 RSDK::Legacy::v4::foreachStackPos   = 0;
22

23
RSDK::Legacy::v4::ScriptEngine RSDK::Legacy::v4::scriptEng = Legacy::v4::ScriptEngine();
24
char RSDK::Legacy::v4::scriptText[0x4000];
25

26
#if LEGACY_RETRO_USE_COMPILER
27
#define LEGACY_v4_COMMON_SCRIPT_VAR_COUNT (34)
28

29
#define LEGACY_v4_SCRIPT_VAR_COUNT (LEGACY_v4_COMMON_SCRIPT_VAR_COUNT + 0x1DF)
30
int32 RSDK::Legacy::v4::lineID = 0;
31

32
namespace RSDK
33
{
34
namespace Legacy
35
{
36
namespace v4
37
{
38
const char *scriptFile = "";
39

40
enum ScriptVarType { VAR_ALIAS, VAR_STATICVALUE, VAR_TABLE };
41
enum ScriptVarAccessModifier { ACCESS_NONE, ACCESS_PUBLIC, ACCESS_PRIVATE };
42

43
struct ScriptVariableInfo {
44
    ScriptVariableInfo()
45
    {
46
        type     = VAR_ALIAS;
47
        access   = ACCESS_NONE;
48
        name[0]  = 0;
49
        value[0] = 0;
50
    }
51

52
    ScriptVariableInfo(uint8 type, uint8 access, const char *name, const char *value)
53
    {
54
        this->type   = type;
55
        this->access = access;
56
        strcpy(this->name, name);
57
        strcpy(this->value, value);
58
    }
59

60
    uint8 type;
61
    uint8 access;
62
    char name[0x20];
63
    char value[0x20];
64
};
65

66
} // namespace v4
67
} // namespace Legacy
68
} // namespace RSDK
69

70
#endif
71

72
namespace RSDK
73
{
74
namespace Legacy
75
{
76
namespace v4
77
{
78

79
struct FunctionInfo {
80
    FunctionInfo()
81
    {
82
        name[0]    = 0;
83
        opcodeSize = 0;
84
    }
85
    FunctionInfo(const char *functionName, int32 opSize)
86
    {
87
        strcpy(name, functionName);
88
        opcodeSize = opSize;
89
    }
90

91
    char name[0x30];
92
    int32 opcodeSize;
93
};
94

95
#if LEGACY_RETRO_USE_COMPILER
96
const char variableNames[][0x20] = {
97
    // Internal Script Values
98
    "temp0",
99
    "temp1",
100
    "temp2",
101
    "temp3",
102
    "temp4",
103
    "temp5",
104
    "temp6",
105
    "temp7",
106
    "checkResult",
107
    "arrayPos0",
108
    "arrayPos1",
109
    "arrayPos2",
110
    "arrayPos3",
111
    "arrayPos4",
112
    "arrayPos5",
113
    "arrayPos6",
114
    "arrayPos7",
115
    "global",
116
    "local",
117

118
    // Object Properties
119
    "object.entityPos",
120
    "object.groupID",
121
    "object.type",
122
    "object.propertyValue",
123
    "object.xpos",
124
    "object.ypos",
125
    "object.ixpos",
126
    "object.iypos",
127
    "object.xvel",
128
    "object.yvel",
129
    "object.speed",
130
    "object.state",
131
    "object.rotation",
132
    "object.scale",
133
    "object.priority",
134
    "object.drawOrder",
135
    "object.direction",
136
    "object.inkEffect",
137
    "object.alpha",
138
    "object.frame",
139
    "object.animation",
140
    "object.prevAnimation",
141
    "object.animationSpeed",
142
    "object.animationTimer",
143
    "object.angle",
144
    "object.lookPosX",
145
    "object.lookPosY",
146
    "object.collisionMode",
147
    "object.collisionPlane",
148
    "object.controlMode",
149
    "object.controlLock",
150
    "object.pushing",
151
    "object.visible",
152
    "object.tileCollisions",
153
    "object.interaction",
154
    "object.gravity",
155
    "object.up",
156
    "object.down",
157
    "object.left",
158
    "object.right",
159
    "object.jumpPress",
160
    "object.jumpHold",
161
    "object.scrollTracking",
162
    "object.floorSensorL",
163
    "object.floorSensorC",
164
    "object.floorSensorR",
165
    "object.floorSensorLC",
166
    "object.floorSensorRC",
167
    "object.collisionLeft",
168
    "object.collisionTop",
169
    "object.collisionRight",
170
    "object.collisionBottom",
171
    "object.outOfBounds",
172
    "object.spriteSheet",
173

174
    // Object Values
175
    "object.value0",
176
    "object.value1",
177
    "object.value2",
178
    "object.value3",
179
    "object.value4",
180
    "object.value5",
181
    "object.value6",
182
    "object.value7",
183
    "object.value8",
184
    "object.value9",
185
    "object.value10",
186
    "object.value11",
187
    "object.value12",
188
    "object.value13",
189
    "object.value14",
190
    "object.value15",
191
    "object.value16",
192
    "object.value17",
193
    "object.value18",
194
    "object.value19",
195
    "object.value20",
196
    "object.value21",
197
    "object.value22",
198
    "object.value23",
199
    "object.value24",
200
    "object.value25",
201
    "object.value26",
202
    "object.value27",
203
    "object.value28",
204
    "object.value29",
205
    "object.value30",
206
    "object.value31",
207
    "object.value32",
208
    "object.value33",
209
    "object.value34",
210
    "object.value35",
211
    "object.value36",
212
    "object.value37",
213
    "object.value38",
214
    "object.value39",
215
    "object.value40",
216
    "object.value41",
217
    "object.value42",
218
    "object.value43",
219
    "object.value44",
220
    "object.value45",
221
    "object.value46",
222
    "object.value47",
223

224
    // Stage Properties
225
    "stage.state",
226
    "stage.activeList",
227
    "stage.listPos",
228
    "stage.timeEnabled",
229
    "stage.milliSeconds",
230
    "stage.seconds",
231
    "stage.minutes",
232
    "stage.actNum",
233
    "stage.pauseEnabled",
234
    "stage.listSize",
235
    "stage.newXBoundary1",
236
    "stage.newXBoundary2",
237
    "stage.newYBoundary1",
238
    "stage.newYBoundary2",
239
    "stage.curXBoundary1",
240
    "stage.curXBoundary2",
241
    "stage.curYBoundary1",
242
    "stage.curYBoundary2",
243
    "stage.deformationData0",
244
    "stage.deformationData1",
245
    "stage.deformationData2",
246
    "stage.deformationData3",
247
    "stage.waterLevel",
248
    "stage.activeLayer",
249
    "stage.midPoint",
250
    "stage.playerListPos",
251
    "stage.debugMode",
252
    "stage.entityPos",
253

254
    // Screen Properties
255
    "screen.cameraEnabled",
256
    "screen.cameraTarget",
257
    "screen.cameraStyle",
258
    "screen.cameraX",
259
    "screen.cameraY",
260
    "screen.drawListSize",
261
    "screen.xcenter",
262
    "screen.ycenter",
263
    "screen.xsize",
264
    "screen.ysize",
265
    "screen.xoffset",
266
    "screen.yoffset",
267
    "screen.shakeX",
268
    "screen.shakeY",
269
    "screen.adjustCameraY",
270

271
    "touchscreen.down",
272
    "touchscreen.xpos",
273
    "touchscreen.ypos",
274

275
    // Sound Properties
276
    "music.volume",
277
    "music.currentTrack",
278
    "music.position",
279

280
    // Input Properties
281
    "keyDown.up",
282
    "keyDown.down",
283
    "keyDown.left",
284
    "keyDown.right",
285
    "keyDown.buttonA",
286
    "keyDown.buttonB",
287
    "keyDown.buttonC",
288
    "keyDown.buttonX",
289
    "keyDown.buttonY",
290
    "keyDown.buttonZ",
291
    "keyDown.buttonL",
292
    "keyDown.buttonR",
293
    "keyDown.start",
294
    "keyDown.select",
295
    "keyPress.up",
296
    "keyPress.down",
297
    "keyPress.left",
298
    "keyPress.right",
299
    "keyPress.buttonA",
300
    "keyPress.buttonB",
301
    "keyPress.buttonC",
302
    "keyPress.buttonX",
303
    "keyPress.buttonY",
304
    "keyPress.buttonZ",
305
    "keyPress.buttonL",
306
    "keyPress.buttonR",
307
    "keyPress.start",
308
    "keyPress.select",
309

310
    // Menu Properties
311
    "menu1.selection",
312
    "menu2.selection",
313

314
    // Tile Layer Properties
315
    "tileLayer.xsize",
316
    "tileLayer.ysize",
317
    "tileLayer.type",
318
    "tileLayer.angle",
319
    "tileLayer.xpos",
320
    "tileLayer.ypos",
321
    "tileLayer.zpos",
322
    "tileLayer.parallaxFactor",
323
    "tileLayer.scrollSpeed",
324
    "tileLayer.scrollPos",
325
    "tileLayer.deformationOffset",
326
    "tileLayer.deformationOffsetW",
327
    "hParallax.parallaxFactor",
328
    "hParallax.scrollSpeed",
329
    "hParallax.scrollPos",
330
    "vParallax.parallaxFactor",
331
    "vParallax.scrollSpeed",
332
    "vParallax.scrollPos",
333

334
    // 3D Scene Properties
335
    "scene3D.vertexCount",
336
    "scene3D.faceCount",
337
    "scene3D.projectionX",
338
    "scene3D.projectionY",
339
    "scene3D.fogColor",
340
    "scene3D.fogStrength",
341

342
    "vertexBuffer.x",
343
    "vertexBuffer.y",
344
    "vertexBuffer.z",
345
    "vertexBuffer.u",
346
    "vertexBuffer.v",
347

348
    "faceBuffer.a",
349
    "faceBuffer.b",
350
    "faceBuffer.c",
351
    "faceBuffer.d",
352
    "faceBuffer.flag",
353
    "faceBuffer.color",
354

355
    "saveRAM",
356
    "engine.state",
357
    "engine.language",
358
    "engine.onlineActive",
359
    "engine.sfxVolume",
360
    "engine.bgmVolume",
361
    "engine.trialMode",
362
    "engine.deviceType",
363

364
    // Extras
365
    "screen.currentID",
366
    "camera.enabled",
367
    "camera.target",
368
    "camera.style",
369
    "camera.xpos",
370
    "camera.ypos",
371
    "camera.adjustY",
372

373
// Haptics
374
#if LEGACY_RETRO_USE_HAPTICS
375
    "engine.hapticsEnabled",
376
#endif
377
};
378
#endif
379

380
const FunctionInfo functions[] = {
381
    FunctionInfo("End", 0),      // End of Script
382
    FunctionInfo("Equal", 2),    // Equal
383
    FunctionInfo("Add", 2),      // Add
384
    FunctionInfo("Sub", 2),      // Subtract
385
    FunctionInfo("Inc", 1),      // Increment
386
    FunctionInfo("Dec", 1),      // Decrement
387
    FunctionInfo("Mul", 2),      // Multiply
388
    FunctionInfo("Div", 2),      // Divide
389
    FunctionInfo("ShR", 2),      // Bit Shift Right
390
    FunctionInfo("ShL", 2),      // Bit Shift Left
391
    FunctionInfo("And", 2),      // Bitwise And
392
    FunctionInfo("Or", 2),       // Bitwise Or
393
    FunctionInfo("Xor", 2),      // Bitwise Xor
394
    FunctionInfo("Mod", 2),      // Mod
395
    FunctionInfo("FlipSign", 1), // Flips the Sign of the value
396

397
    FunctionInfo("CheckEqual", 2),    // compare a=b, return result in CheckResult Variable
398
    FunctionInfo("CheckGreater", 2),  // compare a>b, return result in CheckResult Variable
399
    FunctionInfo("CheckLower", 2),    // compare a<b, return result in CheckResult Variable
400
    FunctionInfo("CheckNotEqual", 2), // compare a!=b, return result in CheckResult Variable
401

402
    FunctionInfo("IfEqual", 3),          // compare a=b, jump if condition met
403
    FunctionInfo("IfGreater", 3),        // compare a>b, jump if condition met
404
    FunctionInfo("IfGreaterOrEqual", 3), // compare a>=b, jump if condition met
405
    FunctionInfo("IfLower", 3),          // compare a<b, jump if condition met
406
    FunctionInfo("IfLowerOrEqual", 3),   // compare a<=b, jump if condition met
407
    FunctionInfo("IfNotEqual", 3),       // compare a!=b, jump if condition met
408
    FunctionInfo("else", 0),             // The else for an if statement
409
    FunctionInfo("endif", 0),            // The end if
410

411
    FunctionInfo("WEqual", 3),          // compare a=b, loop if condition met
412
    FunctionInfo("WGreater", 3),        // compare a>b, loop if condition met
413
    FunctionInfo("WGreaterOrEqual", 3), // compare a>=b, loop if condition met
414
    FunctionInfo("WLower", 3),          // compare a<b, loop if condition met
415
    FunctionInfo("WLowerOrEqual", 3),   // compare a<=b, loop if condition met
416
    FunctionInfo("WNotEqual", 3),       // compare a!=b, loop if condition met
417
    FunctionInfo("loop", 0),            // While Loop marker
418

419
    FunctionInfo("ForEachActive", 3), // foreach loop, iterates through object group lists only if they are active and interaction is true
420
    FunctionInfo("ForEachAll", 3),    // foreach loop, iterates through objects matching type
421
    FunctionInfo("next", 0),          // foreach loop, next marker
422

423
    FunctionInfo("switch", 2),    // Switch Statement
424
    FunctionInfo("break", 0),     // break
425
    FunctionInfo("endswitch", 0), // endswitch
426

427
    // Math Functions
428
    FunctionInfo("Rand", 2),
429
    FunctionInfo("Sin", 2),
430
    FunctionInfo("Cos", 2),
431
    FunctionInfo("Sin256", 2),
432
    FunctionInfo("Cos256", 2),
433
    FunctionInfo("ATan2", 3),
434
    FunctionInfo("Interpolate", 4),
435
    FunctionInfo("InterpolateXY", 7),
436

437
    // Graphics Functions
438
    FunctionInfo("LoadSpriteSheet", 1),
439
    FunctionInfo("RemoveSpriteSheet", 1),
440
    FunctionInfo("DrawSprite", 1),
441
    FunctionInfo("DrawSpriteXY", 3),
442
    FunctionInfo("DrawSpriteScreenXY", 3),
443
    FunctionInfo("DrawTintRect", 4),
444
    FunctionInfo("DrawNumbers", 7),
445
    FunctionInfo("DrawActName", 7),
446
    FunctionInfo("DrawMenu", 3),
447
    FunctionInfo("SpriteFrame", 6),
448
    FunctionInfo("EditFrame", 7),
449
    FunctionInfo("LoadPalette", 5),
450
    FunctionInfo("RotatePalette", 4),
451
    FunctionInfo("SetScreenFade", 4),
452
    FunctionInfo("SetActivePalette", 3),
453
    FunctionInfo("SetPaletteFade", 6),
454
    FunctionInfo("SetPaletteEntry", 3),
455
    FunctionInfo("GetPaletteEntry", 3),
456
    FunctionInfo("CopyPalette", 5),
457
    FunctionInfo("ClearScreen", 1),
458
    FunctionInfo("DrawSpriteFX", 4),
459
    FunctionInfo("DrawSpriteScreenFX", 4),
460

461
    // More Useful Stuff
462
    FunctionInfo("LoadAnimation", 1),
463
    FunctionInfo("SetupMenu", 4),
464
    FunctionInfo("AddMenuEntry", 3),
465
    FunctionInfo("EditMenuEntry", 4),
466
    FunctionInfo("LoadStage", 0),
467
    FunctionInfo("DrawRect", 8),
468
    FunctionInfo("ResetObjectEntity", 5),
469
    FunctionInfo("BoxCollisionTest", 11),
470
    FunctionInfo("CreateTempObject", 4),
471

472
    // Player and Animation Functions
473
    FunctionInfo("ProcessObjectMovement", 0),
474
    FunctionInfo("ProcessObjectControl", 0),
475
    FunctionInfo("ProcessAnimation", 0),
476
    FunctionInfo("DrawObjectAnimation", 0),
477

478
    // Music
479
    FunctionInfo("SetMusicTrack", 3),
480
    FunctionInfo("PlayMusic", 1),
481
    FunctionInfo("StopMusic", 0),
482
    FunctionInfo("PauseMusic", 0),
483
    FunctionInfo("ResumeMusic", 0),
484
    FunctionInfo("SwapMusicTrack", 4),
485

486
    // Sound FX
487
    FunctionInfo("PlaySfx", 2),
488
    FunctionInfo("StopSfx", 1),
489
    FunctionInfo("SetSfxAttributes", 3),
490

491
    // More Collision Stuff
492
    FunctionInfo("ObjectTileCollision", 4),
493
    FunctionInfo("ObjectTileGrip", 4),
494

495
    // Bitwise Not
496
    FunctionInfo("Not", 1),
497

498
    // 3D Stuff
499
    FunctionInfo("Draw3DScene", 0),
500
    FunctionInfo("SetIdentityMatrix", 1),
501
    FunctionInfo("MatrixMultiply", 2),
502
    FunctionInfo("MatrixTranslateXYZ", 4),
503
    FunctionInfo("MatrixScaleXYZ", 4),
504
    FunctionInfo("MatrixRotateX", 2),
505
    FunctionInfo("MatrixRotateY", 2),
506
    FunctionInfo("MatrixRotateZ", 2),
507
    FunctionInfo("MatrixRotateXYZ", 4),
508
    FunctionInfo("MatrixInverse", 1),
509
    FunctionInfo("TransformVertices", 3),
510

511
    FunctionInfo("CallFunction", 1),
512
    FunctionInfo("return", 0),
513

514
    FunctionInfo("SetLayerDeformation", 6),
515
    FunctionInfo("CheckTouchRect", 4),
516
    FunctionInfo("GetTileLayerEntry", 4),
517
    FunctionInfo("SetTileLayerEntry", 4),
518

519
    FunctionInfo("GetBit", 3),
520
    FunctionInfo("SetBit", 3),
521

522
    FunctionInfo("ClearDrawList", 1),
523
    FunctionInfo("AddDrawListEntityRef", 2),
524
    FunctionInfo("GetDrawListEntityRef", 3),
525
    FunctionInfo("SetDrawListEntityRef", 3),
526

527
    FunctionInfo("Get16x16TileInfo", 4),
528
    FunctionInfo("Set16x16TileInfo", 4),
529
    FunctionInfo("Copy16x16Tile", 2),
530
    FunctionInfo("GetAnimationByName", 2),
531
    FunctionInfo("ReadSaveRAM", 0),
532
    FunctionInfo("WriteSaveRAM", 0),
533

534
    FunctionInfo("LoadTextFile", 2),
535
    FunctionInfo("GetTextInfo", 5),
536
    FunctionInfo("GetVersionNumber", 2),
537

538
    FunctionInfo("GetTableValue", 3),
539
    FunctionInfo("SetTableValue", 3),
540

541
    FunctionInfo("CheckCurrentStageFolder", 1),
542
    FunctionInfo("Abs", 1),
543

544
    FunctionInfo("CallNativeFunction", 1),
545
    FunctionInfo("CallNativeFunction2", 3),
546
    FunctionInfo("CallNativeFunction4", 5),
547

548
    FunctionInfo("SetObjectRange", 1),
549
    FunctionInfo("GetObjectValue", 3),
550
    FunctionInfo("SetObjectValue", 3),
551
    FunctionInfo("CopyObject", 3),
552
    FunctionInfo("Print", 3),
553

554
    // Extras
555
    FunctionInfo("CheckCameraProximity", 4),
556
    FunctionInfo("SetScreenCount", 1),
557
    FunctionInfo("SetScreenVertices", 5),
558
    FunctionInfo("GetInputDeviceID", 2),
559
    FunctionInfo("GetFilteredInputDeviceID", 4),
560
    FunctionInfo("GetInputDeviceType", 2),
561
    FunctionInfo("IsInputDeviceAssigned", 1),
562
    FunctionInfo("AssignInputSlotToDevice", 2),
563
    FunctionInfo("IsInputSlotAssigned", 1),
564
    FunctionInfo("ResetInputSlotAssignments", 0),
565
};
566

567
#if LEGACY_RETRO_USE_COMPILER
568

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

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

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

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

628
enum ScrVar {
629
    VAR_TEMP0,
630
    VAR_TEMP1,
631
    VAR_TEMP2,
632
    VAR_TEMP3,
633
    VAR_TEMP4,
634
    VAR_TEMP5,
635
    VAR_TEMP6,
636
    VAR_TEMP7,
637
    VAR_CHECKRESULT,
638
    VAR_ARRAYPOS0,
639
    VAR_ARRAYPOS1,
640
    VAR_ARRAYPOS2,
641
    VAR_ARRAYPOS3,
642
    VAR_ARRAYPOS4,
643
    VAR_ARRAYPOS5,
644
    VAR_ARRAYPOS6,
645
    VAR_ARRAYPOS7,
646
    VAR_GLOBAL,
647
    VAR_LOCAL,
648
    VAR_OBJECTENTITYPOS,
649
    VAR_OBJECTGROUPID,
650
    VAR_OBJECTTYPE,
651
    VAR_OBJECTPROPERTYVALUE,
652
    VAR_OBJECTXPOS,
653
    VAR_OBJECTYPOS,
654
    VAR_OBJECTIXPOS,
655
    VAR_OBJECTIYPOS,
656
    VAR_OBJECTXVEL,
657
    VAR_OBJECTYVEL,
658
    VAR_OBJECTSPEED,
659
    VAR_OBJECTSTATE,
660
    VAR_OBJECTROTATION,
661
    VAR_OBJECTSCALE,
662
    VAR_OBJECTPRIORITY,
663
    VAR_OBJECTDRAWORDER,
664
    VAR_OBJECTDIRECTION,
665
    VAR_OBJECTINKEFFECT,
666
    VAR_OBJECTALPHA,
667
    VAR_OBJECTFRAME,
668
    VAR_OBJECTANIMATION,
669
    VAR_OBJECTPREVANIMATION,
670
    VAR_OBJECTANIMATIONSPEED,
671
    VAR_OBJECTANIMATIONTIMER,
672
    VAR_OBJECTANGLE,
673
    VAR_OBJECTLOOKPOSX,
674
    VAR_OBJECTLOOKPOSY,
675
    VAR_OBJECTCOLLISIONMODE,
676
    VAR_OBJECTCOLLISIONPLANE,
677
    VAR_OBJECTCONTROLMODE,
678
    VAR_OBJECTCONTROLLOCK,
679
    VAR_OBJECTPUSHING,
680
    VAR_OBJECTVISIBLE,
681
    VAR_OBJECTTILECOLLISIONS,
682
    VAR_OBJECTINTERACTION,
683
    VAR_OBJECTGRAVITY,
684
    VAR_OBJECTUP,
685
    VAR_OBJECTDOWN,
686
    VAR_OBJECTLEFT,
687
    VAR_OBJECTRIGHT,
688
    VAR_OBJECTJUMPPRESS,
689
    VAR_OBJECTJUMPHOLD,
690
    VAR_OBJECTSCROLLTRACKING,
691
    VAR_OBJECTFLOORSENSORL,
692
    VAR_OBJECTFLOORSENSORC,
693
    VAR_OBJECTFLOORSENSORR,
694
    VAR_OBJECTFLOORSENSORLC,
695
    VAR_OBJECTFLOORSENSORRC,
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
    VAR_SCENE3DFOGCOLOR,
852
    VAR_SCENE3DFOGSTRENGTH,
853
    VAR_VERTEXBUFFERX,
854
    VAR_VERTEXBUFFERY,
855
    VAR_VERTEXBUFFERZ,
856
    VAR_VERTEXBUFFERU,
857
    VAR_VERTEXBUFFERV,
858
    VAR_FACEBUFFERA,
859
    VAR_FACEBUFFERB,
860
    VAR_FACEBUFFERC,
861
    VAR_FACEBUFFERD,
862
    VAR_FACEBUFFERFLAG,
863
    VAR_FACEBUFFERCOLOR,
864
    VAR_SAVERAM,
865
    VAR_ENGINESTATE,
866
    VAR_ENGINELANGUAGE,
867
    VAR_ENGINEONLINEACTIVE,
868
    VAR_ENGINESFXVOLUME,
869
    VAR_ENGINEBGMVOLUME,
870
    VAR_ENGINETRIALMODE,
871
    VAR_ENGINEDEVICETYPE,
872

873
    // Extras
874
    VAR_SCREENCURRENTID,
875
    VAR_CAMERAENABLED,
876
    VAR_CAMERATARGET,
877
    VAR_CAMERASTYLE,
878
    VAR_CAMERAXPOS,
879
    VAR_CAMERAYPOS,
880
    VAR_CAMERAADJUSTY,
881

882
#if LEGACY_RETRO_USE_HAPTICS
883
    VAR_HAPTICSENABLED,
884
#endif
885
    VAR_MAX_CNT
886
};
887

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

1029
    // Extras
1030
    FUNC_CHECKCAMERAPROXIMITY,
1031
    FUNC_SETSCREENCOUNT,
1032
    FUNC_SETSCREENVERTICES,
1033
    FUNC_GETINPUTDEVICEID,
1034
    FUNC_GETFILTEREDINPUTDEVICEID,
1035
    FUNC_GETINPUTDEVICETYPE,
1036
    FUNC_ISINPUTDEVICEASSIGNED,
1037
    FUNC_ASSIGNINPUTSLOTTODEVICE,
1038
    FUNC_ISSLOTASSIGNED,
1039
    FUNC_RESETINPUTSLOTASSIGNMENTS,
1040
    FUNC_MAX_CNT
1041
};
1042

1043
} // namespace v4
1044

1045
} // namespace Legacy
1046
} // namespace RSDK
1047

1048
#if LEGACY_RETRO_USE_COMPILER
1049
void RSDK::Legacy::v4::CheckAliasText(char *text)
1050
{
1051
    if (FindStringToken(text, "publicalias", 1) == 0) {
1052
#if !RETRO_USE_ORIGINAL_CODE
1053
        if (scriptValueListCount >= LEGACY_v4_SCRIPT_VAR_COUNT) {
1054
            RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Too many aliases, static values, and tables\nFILE: %s", scriptFile);
1055
            gameMode = ENGINE_SCRIPTERROR;
1056
            return;
1057
        }
1058
#endif
1059

1060
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1061
        MEM_ZERO(*variable);
1062

1063
        int32 textStrPos = 11;
1064
        int32 varStrPos  = 0;
1065
        int32 parseMode  = 0;
1066

1067
        while (text[textStrPos]) {
1068
            switch (parseMode) {
1069
                default: break;
1070

1071
                case 0:
1072
                    if (text[textStrPos] == ':') {
1073
                        textStrPos++;
1074
                        variable->value[varStrPos] = 0;
1075
                        varStrPos                  = 0;
1076
                        parseMode                  = 1;
1077
                    }
1078
                    else {
1079
                        variable->value[varStrPos++] = text[textStrPos++];
1080
                    }
1081
                    break;
1082

1083
                case 1: variable->name[varStrPos++] = text[textStrPos++]; break;
1084
            }
1085
        }
1086

1087
        variable->access = ACCESS_PUBLIC;
1088

1089
#if !RETRO_USE_ORIGINAL_CODE
1090
        for (int32 v = 0; v < scriptValueListCount; ++v) {
1091
            if (StrComp(scriptValueList[v].name, variable->name))
1092
                PrintLog(PRINT_NORMAL, "WARNING: Variable Name '%s' has already been used!", variable->name);
1093
        }
1094
#endif
1095

1096
        ++scriptValueListCount;
1097
    }
1098
    else if (FindStringToken(text, "privatealias", 1) == 0) {
1099
#if !RETRO_USE_ORIGINAL_CODE
1100
        if (scriptValueListCount >= LEGACY_v4_SCRIPT_VAR_COUNT) {
1101
            RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Too many aliases, static values, and tables\nFILE: %s", scriptFile);
1102
            gameMode = ENGINE_SCRIPTERROR;
1103
            return;
1104
        }
1105
#endif
1106

1107
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1108
        MEM_ZERO(*variable);
1109

1110
        int32 textStrPos = 12;
1111
        int32 varStrPos  = 0;
1112
        int32 parseMode  = 0;
1113

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

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

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

1134
        variable->access = ACCESS_PRIVATE;
1135

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

1141
        ++scriptValueListCount;
1142
    }
1143
}
1144
void RSDK::Legacy::v4::CheckStaticText(char *text)
1145
{
1146
    if (FindStringToken(text, "publicvalue", 1) == 0) {
1147
#if !RETRO_USE_ORIGINAL_CODE
1148
        if (scriptValueListCount >= LEGACY_v4_SCRIPT_VAR_COUNT) {
1149
            RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Too many aliases, static values, and tables\nFILE: %s", scriptFile);
1150
            gameMode = ENGINE_SCRIPTERROR;
1151
            return;
1152
        }
1153
#endif
1154

1155
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1156
        MEM_ZERO(*variable);
1157

1158
        int32 textStrPos = 11;
1159
        int32 varStrPos  = 0;
1160
        int32 parseMode  = 0;
1161

1162
        StrCopy(variable->value, "0"); // default value is 0
1163
        while (text[textStrPos]) {
1164
            switch (parseMode) {
1165
                default: break;
1166

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

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

1183
        variable->access = ACCESS_PUBLIC;
1184

1185
        if (!ConvertStringToInteger(variable->value, &scriptCode[scriptCodePos]))
1186
            scriptCode[scriptCodePos] = 0;
1187

1188
        StrCopy(variable->value, "local[");
1189
        AppendIntegerToString(variable->value, scriptCodePos++);
1190
        StrAdd(variable->value, "]");
1191

1192
#if !RETRO_USE_ORIGINAL_CODE
1193
        for (int32 v = 0; v < scriptValueListCount; ++v) {
1194
            if (StrComp(scriptValueList[v].name, variable->name))
1195
                PrintLog(PRINT_NORMAL, "WARNING: Variable Name '%s' has already been used!", variable->name);
1196
        }
1197
#endif
1198

1199
        ++scriptValueListCount;
1200
    }
1201
    else if (FindStringToken(text, "privatevalue", 1) == 0) {
1202
#if !RETRO_USE_ORIGINAL_CODE
1203
        if (scriptValueListCount >= LEGACY_v4_SCRIPT_VAR_COUNT) {
1204
            RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Too many aliases, static values, and tables\nFILE: %s", scriptFile);
1205
            gameMode = ENGINE_SCRIPTERROR;
1206
            return;
1207
        }
1208
#endif
1209

1210
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1211
        MEM_ZERO(*variable);
1212

1213
        int32 textStrPos = 12;
1214
        int32 varStrPos  = 0;
1215
        int32 parseMode  = 0;
1216

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

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

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

1238
        variable->access = ACCESS_PRIVATE;
1239

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

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

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

1254
        ++scriptValueListCount;
1255
    }
1256
}
1257
bool32 RSDK::Legacy::v4::CheckTableText(char *text)
1258
{
1259
    bool32 hasValues = false;
1260

1261
    if (FindStringToken(text, "publictable", 1) == 0) {
1262
#if !RETRO_USE_ORIGINAL_CODE
1263
        if (scriptValueListCount >= LEGACY_v4_SCRIPT_VAR_COUNT) {
1264
            RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Too many aliases, static values, and tables\nFILE: %s", scriptFile);
1265
            gameMode = ENGINE_SCRIPTERROR;
1266
            return false;
1267
        }
1268
#endif
1269

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

1273
        int32 textStrPos = 11;
1274
        int32 varStrPos  = 0;
1275

1276
        while (text[textStrPos]) {
1277
            if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1278
                variable->name[varStrPos] = 0;
1279
                textStrPos++;
1280
                break;
1281
            }
1282
            else {
1283
                variable->name[varStrPos++] = text[textStrPos++];
1284
            }
1285
        }
1286

1287
        if (FindStringToken(text, "]", 1) < 1) {
1288
            // has default values, we'll stop here and read stuff in a seperate mode
1289
            scriptCode[scriptCodePos] = 0;
1290
            StrCopy(variable->value, "");
1291
            AppendIntegerToString(variable->value, scriptCodePos);
1292
            scriptCodeOffset = scriptCodePos++;
1293
            hasValues        = true;
1294
        }
1295
        else {
1296
            // no default values, just an array size
1297

1298
            varStrPos = 0;
1299
            while (text[textStrPos]) {
1300
                if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1301
                    variable->value[varStrPos] = 0;
1302
                    textStrPos++;
1303
                    break;
1304
                }
1305
                else {
1306
                    variable->value[varStrPos++] = text[textStrPos++];
1307
                }
1308
            }
1309

1310
            // array size can be an variable (alias), how cool!
1311
            for (int32 v = 0; v < scriptValueListCount; ++v) {
1312
                if (StrComp(variable->value, scriptValueList[v].name))
1313
                    StrCopy(variable->value, scriptValueList[v].value);
1314
            }
1315

1316
            if (!ConvertStringToInteger(variable->value, &scriptCode[scriptCodePos])) {
1317
                scriptCode[scriptCodePos] = 1;
1318
#if !RETRO_USE_ORIGINAL_CODE
1319
                PrintLog(PRINT_NORMAL, "WARNING: Unable to parse table size!");
1320
#endif
1321
            }
1322

1323
            StrCopy(variable->value, "");
1324
            AppendIntegerToString(variable->value, scriptCodePos);
1325

1326
            int32 valueCount = scriptCode[scriptCodePos++];
1327
            for (int32 v = 0; v < valueCount; ++v) scriptCode[scriptCodePos++] = 0;
1328
        }
1329

1330
        variable->access = ACCESS_PUBLIC;
1331
        scriptValueListCount++;
1332
    }
1333
    else if (FindStringToken(text, "privatetable", 1) == 0) {
1334
#if !RETRO_USE_ORIGINAL_CODE
1335
        if (scriptValueListCount >= LEGACY_v4_SCRIPT_VAR_COUNT) {
1336
            RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Too many aliases, static values, and tables\nFILE: %s", scriptFile);
1337
            gameMode = ENGINE_SCRIPTERROR;
1338
            return false;
1339
        }
1340
#endif
1341

1342
        ScriptVariableInfo *variable = &scriptValueList[scriptValueListCount];
1343
        MEM_ZERO(*variable);
1344

1345
        int32 textStrPos = 12;
1346
        int32 varStrPos  = 0;
1347

1348
        while (text[textStrPos]) {
1349
            if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1350
                variable->name[varStrPos] = 0;
1351
                textStrPos++;
1352
                break;
1353
            }
1354
            else {
1355
                variable->name[varStrPos++] = text[textStrPos++];
1356
            }
1357
        }
1358

1359
        if (FindStringToken(text, "]", 1) < 1) {
1360
            // has default values, we'll stop here and read stuff in a seperate mode
1361
            scriptCode[scriptCodePos] = 0;
1362
            StrCopy(variable->value, "");
1363
            AppendIntegerToString(variable->value, scriptCodePos);
1364
            scriptCodeOffset = scriptCodePos++;
1365
            hasValues        = true;
1366
        }
1367
        else {
1368
            // no default values, just an array size
1369

1370
            varStrPos = 0;
1371
            while (text[textStrPos]) {
1372
                if (text[textStrPos] == '[' || text[textStrPos] == ']') {
1373
                    variable->value[varStrPos] = 0;
1374
                    textStrPos++;
1375
                    break;
1376
                }
1377
                else {
1378
                    variable->value[varStrPos++] = text[textStrPos++];
1379
                }
1380
            }
1381

1382
            // array size can be an variable (alias), how cool!
1383
            for (int32 v = 0; v < scriptValueListCount; ++v) {
1384
                if (StrComp(variable->value, scriptValueList[v].name))
1385
                    StrCopy(variable->value, scriptValueList[v].value);
1386
            }
1387

1388
            if (!ConvertStringToInteger(variable->value, &scriptCode[scriptCodePos])) {
1389
                scriptCode[scriptCodePos] = 1;
1390
#if !RETRO_USE_ORIGINAL_CODE
1391
                PrintLog(PRINT_NORMAL, "WARNING: Unable to parse table size!");
1392
#endif
1393
            }
1394

1395
            StrCopy(variable->value, "");
1396
            AppendIntegerToString(variable->value, scriptCodePos);
1397

1398
            int32 valueCount = scriptCode[scriptCodePos++];
1399
            for (int32 v = 0; v < valueCount; ++v) scriptCode[scriptCodePos++] = 0;
1400
        }
1401

1402
        variable->access = ACCESS_PRIVATE;
1403
        scriptValueListCount++;
1404
    }
1405

1406
    return hasValues;
1407
}
1408
void RSDK::Legacy::v4::ConvertArithmaticSyntax(char *text)
1409
{
1410
    int32 token  = 0;
1411
    int32 offset = 0;
1412
    int32 findID = 0;
1413
    char dest[260];
1414

1415
    for (int32 i = FUNC_EQUAL; i <= FUNC_MOD; ++i) {
1416
        findID = FindStringToken(text, scriptEvaluationTokens[i - 1], 1);
1417
        if (findID > -1) {
1418
            offset = findID;
1419
            token  = i;
1420
        }
1421
    }
1422

1423
    if (token > 0) {
1424
        StrCopy(dest, functions[token].name);
1425
        StrAdd(dest, "(");
1426
        findID = StrLength(dest);
1427
        for (int32 i = 0; i < offset; ++i) dest[findID++] = text[i];
1428
        if (functions[token].opcodeSize > 1) {
1429
            dest[findID] = ',';
1430
            int32 len    = StrLength(scriptEvaluationTokens[token - 1]);
1431
            offset += len;
1432
            ++findID;
1433
            while (text[offset]) dest[findID++] = text[offset++];
1434
        }
1435
        dest[findID] = 0;
1436
        StrAdd(dest, ")");
1437
        StrCopy(text, dest);
1438
    }
1439
}
1440
void RSDK::Legacy::v4::ConvertConditionalStatement(char *text)
1441
{
1442
    char dest[260];
1443
    int32 compareOp  = -1;
1444
    int32 strPos     = 0;
1445
    int32 destStrPos = 0;
1446

1447
    if (FindStringToken(text, "if", 1) == 0) {
1448
        for (int32 i = 0; i < 6; ++i) {
1449
            destStrPos = FindStringToken(text, scriptEvaluationTokens[i + FUNC_MOD], 1);
1450
            if (destStrPos > -1) {
1451
                strPos    = destStrPos;
1452
                compareOp = i;
1453
            }
1454
        }
1455

1456
        if (compareOp > -1) {
1457
            text[strPos] = ',';
1458
            StrCopy(dest, functions[compareOp + FUNC_IFEQUAL].name);
1459
            StrAdd(dest, "(");
1460
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
1461
            StrAdd(dest, ",");
1462

1463
            destStrPos = StrLength(dest);
1464
            for (int32 i = 2; text[i]; ++i) {
1465
                if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1466
                    dest[destStrPos++] = text[i];
1467
            }
1468
            dest[destStrPos] = 0;
1469

1470
            StrAdd(dest, ")");
1471
            StrCopy(text, dest);
1472

1473
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1474
            jumpTable[jumpTablePos++]           = -1;
1475
            jumpTable[jumpTablePos++]           = 0;
1476
        }
1477
    }
1478
    else if (FindStringToken(text, "while", 1) == 0) {
1479
        for (int32 i = 0; i < 6; ++i) {
1480
            destStrPos = FindStringToken(text, scriptEvaluationTokens[i + FUNC_MOD], 1);
1481
            if (destStrPos > -1) {
1482
                strPos    = destStrPos;
1483
                compareOp = i;
1484
            }
1485
        }
1486

1487
        if (compareOp > -1) {
1488
            text[strPos] = ',';
1489
            StrCopy(dest, functions[compareOp + FUNC_WEQUAL].name);
1490
            StrAdd(dest, "(");
1491
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
1492
            StrAdd(dest, ",");
1493

1494
            destStrPos = StrLength(dest);
1495
            for (int32 i = 5; text[i]; ++i) {
1496
                if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1497
                    dest[destStrPos++] = text[i];
1498
            }
1499
            dest[destStrPos] = 0;
1500

1501
            StrAdd(dest, ")");
1502
            StrCopy(text, dest);
1503

1504
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1505
            jumpTable[jumpTablePos++]           = scriptCodePos - scriptCodeOffset;
1506
            jumpTable[jumpTablePos++]           = 0;
1507
        }
1508
    }
1509
    else if (FindStringToken(text, "foreach", 1) == 0) {
1510
        int32 argStrPos = FindStringToken(text, ",", 2);
1511

1512
        if (argStrPos > -1) {
1513
            StrCopy(dest, functions[text[argStrPos + 2] == 'C' ? (int32)FUNC_FOREACHACTIVE : (int32)FUNC_FOREACHALL].name);
1514
            StrAdd(dest, "(");
1515
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
1516
            StrAdd(dest, ",");
1517

1518
            destStrPos = StrLength(dest);
1519
            for (int32 i = 7; text[i] && i < argStrPos; ++i) {
1520
                if (text[i] != '(' && text[i] != ')')
1521
                    dest[destStrPos++] = text[i];
1522
            }
1523
            dest[destStrPos] = 0;
1524

1525
            StrAdd(dest, ")");
1526
            StrCopy(text, dest);
1527

1528
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1529
            jumpTable[jumpTablePos++]           = scriptCodePos - scriptCodeOffset;
1530
            jumpTable[jumpTablePos++]           = 0;
1531
        }
1532
    }
1533
}
1534
bool32 RSDK::Legacy::v4::ConvertSwitchStatement(char *text)
1535
{
1536
    if (FindStringToken(text, "switch", 1) != 0)
1537
        return false;
1538

1539
    char switchText[260];
1540

1541
    StrCopy(switchText, "switch");
1542
    StrAdd(switchText, "(");
1543
    AppendIntegerToString(switchText, jumpTablePos - jumpTableOffset);
1544
    StrAdd(switchText, ",");
1545

1546
    int32 pos = StrLength(switchText);
1547
    for (int32 i = 6; text[i]; ++i) {
1548
        if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1549
            switchText[pos++] = text[i];
1550
    }
1551
    switchText[pos] = 0;
1552

1553
    StrAdd(switchText, ")");
1554
    StrCopy(text, switchText);
1555

1556
    jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1557
    jumpTable[jumpTablePos++]           = 0x10000;
1558
    jumpTable[jumpTablePos++]           = -0x10000;
1559
    jumpTable[jumpTablePos++]           = -1;
1560
    jumpTable[jumpTablePos++]           = 0;
1561

1562
    return true;
1563
}
1564
void RSDK::Legacy::v4::ConvertFunctionText(char *text)
1565
{
1566
    char arrayStr[0x80];
1567
    char funcName[132];
1568

1569
    int32 opcode     = 0;
1570
    int32 opcodeSize = 0;
1571
    int32 textPos    = 0;
1572
    int32 namePos    = 0;
1573

1574
    for (namePos = 0; text[namePos] != '(' && text[namePos]; ++namePos) funcName[namePos] = text[namePos];
1575
    funcName[namePos] = 0;
1576

1577
    for (int32 i = 0; i < FUNC_MAX_CNT; ++i) {
1578
        if (StrComp(funcName, functions[i].name)) {
1579
            opcode     = i;
1580
            opcodeSize = functions[i].opcodeSize;
1581
            textPos    = StrLength(functions[i].name);
1582
            i          = FUNC_MAX_CNT;
1583
        }
1584
    }
1585

1586
    if (opcode <= 0) {
1587
        PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Operand not found\nOPERAND: %s\nLINE: %d\nFILE: %s", funcName, lineID, scriptFile);
1588
        gameMode = ENGINE_SCRIPTERROR;
1589
    }
1590
    else {
1591
        scriptCode[scriptCodePos++] = opcode;
1592
        if (StrComp("else", functions[opcode].name))
1593
            jumpTable[jumpTableStack[jumpTableStackPos]] = scriptCodePos - scriptCodeOffset;
1594

1595
        if (StrComp("endif", functions[opcode].name) == 1) {
1596
            int32 jPos          = jumpTableStack[jumpTableStackPos];
1597
            jumpTable[jPos + 1] = scriptCodePos - scriptCodeOffset;
1598
            if (jumpTable[jPos] == -1)
1599
                jumpTable[jPos] = (scriptCodePos - scriptCodeOffset) - 1;
1600
            --jumpTableStackPos;
1601
        }
1602

1603
        if (StrComp("endswitch", functions[opcode].name)) {
1604
            int32 jPos          = jumpTableStack[jumpTableStackPos];
1605
            jumpTable[jPos + 3] = scriptCodePos - scriptCodeOffset;
1606
            if (jumpTable[jPos + 2] == -1) {
1607
                jumpTable[jPos + 2] = (scriptCodePos - scriptCodeOffset) - 1;
1608
                int32 caseCnt       = abs(jumpTable[jPos + 1] - jumpTable[jPos]) + 1;
1609

1610
                int32 jOffset = jPos + 4;
1611
                for (int32 c = 0; c < caseCnt; ++c) {
1612
                    if (jumpTable[jOffset + c] < 0)
1613
                        jumpTable[jOffset + c] = jumpTable[jPos + 2];
1614
                }
1615
            }
1616
            --jumpTableStackPos;
1617
        }
1618

1619
        if (StrComp("loop", functions[opcode].name) || StrComp("next", functions[opcode].name)) {
1620
            jumpTable[jumpTableStack[jumpTableStackPos--] + 1] = scriptCodePos - scriptCodeOffset;
1621
        }
1622

1623
        for (int32 i = 0; i < opcodeSize; ++i) {
1624
            ++textPos;
1625
            int32 funcNamePos = 0;
1626
            int32 mode        = 0;
1627
            int32 prevMode    = 0;
1628
            int32 arrayStrPos = 0;
1629
            while (((text[textPos] != ',' && text[textPos] != ')') || mode == 2) && text[textPos]) {
1630
                switch (mode) {
1631
                    case 0: // normal
1632
                        if (text[textPos] == '[')
1633
                            mode = 1;
1634
                        else if (text[textPos] == '"') {
1635
                            prevMode                = mode;
1636
                            mode                    = 2;
1637
                            funcName[funcNamePos++] = '"';
1638
                        }
1639
                        else
1640
                            funcName[funcNamePos++] = text[textPos];
1641
                        ++textPos;
1642
                        break;
1643

1644
                    case 1: // array val
1645
                        if (text[textPos] == ']')
1646
                            mode = 0;
1647
                        else if (text[textPos] == '"') {
1648
                            prevMode = mode;
1649
                            mode     = 2;
1650
                        }
1651
                        else
1652
                            arrayStr[arrayStrPos++] = text[textPos];
1653
                        ++textPos;
1654
                        break;
1655

1656
                    case 2: // string
1657
                        if (text[textPos] == '"') {
1658
                            mode                    = prevMode;
1659
                            funcName[funcNamePos++] = '"';
1660
                        }
1661
                        else
1662
                            funcName[funcNamePos++] = text[textPos];
1663
                        ++textPos;
1664
                        break;
1665
                }
1666
            }
1667
            funcName[funcNamePos] = 0;
1668
            arrayStr[arrayStrPos] = 0;
1669

1670
            for (int32 v = 0; v < scriptValueListCount; ++v) {
1671
                if (StrComp(funcName, scriptValueList[v].name)) {
1672
                    CopyAliasStr(funcName, scriptValueList[v].value, 0);
1673
                    if (FindStringToken(scriptValueList[v].value, "[", 1) > -1)
1674
                        CopyAliasStr(arrayStr, scriptValueList[v].value, 1);
1675
                }
1676
            }
1677

1678
            if (arrayStr[0]) {
1679
                char arrStrBuf[0x80];
1680
                int32 arrPos = 0;
1681
                int32 bufPos = 0;
1682
                if (arrayStr[0] == '+' || arrayStr[0] == '-')
1683
                    ++arrPos;
1684
                while (arrayStr[arrPos]) arrStrBuf[bufPos++] = arrayStr[arrPos++];
1685
                arrStrBuf[bufPos] = 0;
1686

1687
                for (int32 v = 0; v < scriptValueListCount; ++v) {
1688
                    if (StrComp(arrStrBuf, scriptValueList[v].name)) {
1689
                        char pref = arrayStr[0];
1690
                        CopyAliasStr(arrayStr, scriptValueList[v].value, 0);
1691

1692
                        if (pref == '+' || pref == '-') {
1693
                            int32 len = StrLength(arrayStr);
1694
                            for (int32 i = len; i >= 0; --i) arrayStr[i + 1] = arrayStr[i];
1695
                            arrayStr[0] = pref;
1696
                        }
1697
                    }
1698
                }
1699
            }
1700

1701
            // Eg: temp0 = game.variable
1702
            for (int32 v = 0; v < globalVariablesCount; ++v) {
1703
                if (StrComp(funcName, globalVariables[v].name)) {
1704
                    StrCopy(funcName, "global");
1705
                    arrayStr[0] = 0;
1706
                    AppendIntegerToString(arrayStr, v);
1707
                }
1708
            }
1709

1710
            // Eg: temp0 = Function1
1711
            for (int32 f = 0; f < scriptFunctionCount; ++f) {
1712
                if (StrComp(funcName, scriptFunctionList[f].name)) {
1713
                    funcName[0] = 0;
1714
                    AppendIntegerToString(funcName, f);
1715
                }
1716
            }
1717

1718
            // Eg: temp0 = TypeName[Player Object]
1719
            if (StrComp(funcName, "TypeName")) {
1720
                funcName[0] = '0';
1721
                funcName[1] = 0;
1722

1723
                int32 o = 0;
1724
                for (; o < LEGACY_v4_OBJECT_COUNT; ++o) {
1725
                    if (StrComp(arrayStr, typeNames[o])) {
1726
                        funcName[0] = 0;
1727
                        AppendIntegerToString(funcName, o);
1728
                        break;
1729
                    }
1730
                }
1731

1732
                if (o == LEGACY_v4_OBJECT_COUNT)
1733
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown typename \"%s\", on line %d", arrayStr, lineID);
1734
            }
1735

1736
            // Eg: temp0 = SfxName[Jump]
1737
            if (StrComp(funcName, "SfxName")) {
1738
                funcName[0] = '0';
1739
                funcName[1] = 0;
1740

1741
                int32 s = 0;
1742
                for (; s < SFX_COUNT; ++s) {
1743
                    if (StrComp(arrayStr, sfxNames[s])) {
1744
                        funcName[0] = 0;
1745
                        AppendIntegerToString(funcName, s);
1746
                        break;
1747
                    }
1748
                }
1749

1750
                if (s == SFX_COUNT)
1751
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown sfxName \"%s\", on line %d", arrayStr, lineID);
1752
            }
1753

1754
#if !RETRO_USE_ORIGINAL_CODE
1755
            // Eg: temp0 = VarName[player.lives]
1756
            if (StrComp(funcName, "VarName")) {
1757
                funcName[0] = '0';
1758
                funcName[1] = 0;
1759

1760
                int32 v = 0;
1761
                for (; v < globalVariablesCount; ++v) {
1762
                    if (StrComp(arrayStr, globalVariables[v].name)) {
1763
                        funcName[0] = 0;
1764
                        AppendIntegerToString(funcName, v);
1765
                        break;
1766
                    }
1767
                }
1768

1769
                if (v == globalVariablesCount)
1770
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown varName \"%s\", on line %d", arrayStr, lineID);
1771
            }
1772

1773
            // Eg: temp0 = AchievementName[ACH_RING_KING]
1774
            if (StrComp(funcName, "AchievementName")) {
1775
                funcName[0] = '0';
1776
                funcName[1] = 0;
1777

1778
                int32 a = 0;
1779
                for (; a < (int32)achievementList.size(); ++a) {
1780
                    char buf[0x40];
1781
                    const char *str = achievementList[a].identifier.c_str();
1782
                    int32 pos       = 0;
1783

1784
                    while (*str) {
1785
                        if (*str != ' ')
1786
                            buf[pos++] = *str;
1787
                        str++;
1788
                    }
1789
                    buf[pos] = 0;
1790

1791
                    if (StrComp(arrayStr, buf)) {
1792
                        funcName[0] = 0;
1793
                        AppendIntegerToString(funcName, a);
1794
                        break;
1795
                    }
1796
                }
1797

1798
                if (a == (int32)achievementList.size())
1799
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown AchievementName \"%s\", on line %d", arrayStr, lineID);
1800
            }
1801

1802
#if RETRO_USE_MOD_LOADER
1803
            // Eg: temp0 = PlayerName[SONIC]
1804
            if (StrComp(funcName, "PlayerName")) {
1805
                funcName[0] = '0';
1806
                funcName[1] = 0;
1807

1808
                int32 p = 0;
1809
                for (; p < LEGACY_PLAYERNAME_COUNT; ++p) {
1810
                    char buf[0x40];
1811
                    char *str = modSettings.playerNames[p];
1812
                    int32 pos = 0;
1813

1814
                    while (*str) {
1815
                        if (*str != ' ')
1816
                            buf[pos++] = *str;
1817
                        str++;
1818
                    }
1819
                    buf[pos] = 0;
1820

1821
                    if (StrComp(arrayStr, buf)) {
1822
                        funcName[0] = 0;
1823
                        AppendIntegerToString(funcName, p);
1824
                        break;
1825
                    }
1826
                }
1827

1828
                if (p == LEGACY_PLAYERNAME_COUNT)
1829
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown PlayerName \"%s\", on line %d", arrayStr, lineID);
1830
            }
1831

1832
            // Eg: temp0 = StageName[R - GREEN HILL ZONE 1]
1833
            if (StrComp(funcName, "StageName")) {
1834
                funcName[0] = '0';
1835
                funcName[1] = 0;
1836

1837
                int32 s = -1;
1838
                if (StrLength(arrayStr) >= 2) {
1839
                    char list = arrayStr[0];
1840
                    switch (list) {
1841
                        case 'P': list = STAGELIST_PRESENTATION; break;
1842
                        case 'R': list = STAGELIST_REGULAR; break;
1843
                        case 'B': list = STAGELIST_BONUS; break;
1844
                        case 'S': list = STAGELIST_SPECIAL; break;
1845
                    }
1846
                    if (list <= 3) {
1847
                        char scnName[0x40];
1848
                        int32 scnPos          = 0;
1849
                        int32 pos             = 0;
1850
                        const char *sceneName = &arrayStr[2];
1851

1852
                        while (sceneName[scnPos]) {
1853
                            if (sceneName[scnPos] != ' ')
1854
                                scnName[pos++] = sceneName[scnPos];
1855
                            ++scnPos;
1856
                        }
1857
                        scnName[pos] = 0;
1858
                        SceneListInfo *listCat = &sceneInfo.listCategory[list];
1859
                        int32 l                = listCat->sceneOffsetStart;
1860
                        for (int32 c = 0; c < listCat->sceneCount; ++c) {
1861
                            char nameBuffer[0x40];
1862

1863
                            scnPos = 0;
1864
                            pos    = 0;
1865
                            while (sceneInfo.listData[l].name[scnPos]) {
1866
                                if (sceneInfo.listData[l].name[scnPos] != ' ')
1867
                                    nameBuffer[pos++] = sceneInfo.listData[l].name[scnPos];
1868
                                ++scnPos;
1869
                            }
1870
                            nameBuffer[pos] = 0;
1871

1872
                            if (StrComp(scnName, nameBuffer)) {
1873
                                s = c;
1874
                                break;
1875
                            }
1876
                            l++;
1877
                        }
1878
                    }
1879
                }
1880

1881
                if (s == -1) {
1882
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown StageName \"%s\", on line %d", arrayStr, lineID);
1883
                    s = 0;
1884
                }
1885
                funcName[0] = 0;
1886
                AppendIntegerToString(funcName, s);
1887
            }
1888
#endif
1889
#endif
1890

1891
            // Storing Values
1892
            int32 constant = 0;
1893
            if (ConvertStringToInteger(funcName, &constant)) {
1894
                scriptCode[scriptCodePos++] = SCRIPTVAR_INTCONST;
1895
                scriptCode[scriptCodePos++] = constant;
1896
            }
1897
            else if (funcName[0] == '"') {
1898
                scriptCode[scriptCodePos++] = SCRIPTVAR_STRCONST;
1899
                scriptCode[scriptCodePos++] = StrLength(funcName) - 2;
1900

1901
                int32 scriptTextPos = 1;
1902
                arrayStrPos         = 0;
1903
                while (scriptTextPos > -1) {
1904
                    switch (arrayStrPos) {
1905
                        case 0:
1906
                            scriptCode[scriptCodePos] = funcName[scriptTextPos] << 24;
1907
                            ++arrayStrPos;
1908
                            break;
1909

1910
                        case 1:
1911
                            scriptCode[scriptCodePos] += funcName[scriptTextPos] << 16;
1912
                            ++arrayStrPos;
1913
                            break;
1914

1915
                        case 2:
1916
                            scriptCode[scriptCodePos] += funcName[scriptTextPos] << 8;
1917
                            ++arrayStrPos;
1918
                            break;
1919

1920
                        case 3:
1921
                            scriptCode[scriptCodePos++] += funcName[scriptTextPos];
1922
                            arrayStrPos = 0;
1923
                            break;
1924

1925
                        default: break;
1926
                    }
1927

1928
                    if (funcName[scriptTextPos] == '"') {
1929
                        if (arrayStrPos > 0)
1930
                            ++scriptCodePos;
1931
                        scriptTextPos = -1;
1932
                    }
1933
                    else {
1934
                        scriptTextPos++;
1935
                    }
1936
                }
1937
            }
1938
            else {
1939
                scriptCode[scriptCodePos++] = SCRIPTVAR_VAR;
1940

1941
                if (arrayStr[0]) {
1942
                    scriptCode[scriptCodePos] = VARARR_ARRAY;
1943

1944
                    if (arrayStr[0] == '+')
1945
                        scriptCode[scriptCodePos] = VARARR_ENTNOPLUS1;
1946

1947
                    if (arrayStr[0] == '-')
1948
                        scriptCode[scriptCodePos] = VARARR_ENTNOMINUS1;
1949

1950
                    ++scriptCodePos;
1951

1952
                    if (arrayStr[0] == '-' || arrayStr[0] == '+') {
1953
                        for (int32 i = 0; i < StrLength(arrayStr); ++i) arrayStr[i] = arrayStr[i + 1];
1954
                    }
1955

1956
                    if (ConvertStringToInteger(arrayStr, &constant) == 1) {
1957
                        scriptCode[scriptCodePos++] = 0;
1958
                        scriptCode[scriptCodePos++] = constant;
1959
                    }
1960
                    else {
1961
                        if (StrComp(arrayStr, "arrayPos0"))
1962
                            constant = 0;
1963
                        if (StrComp(arrayStr, "arrayPos1"))
1964
                            constant = 1;
1965
                        if (StrComp(arrayStr, "arrayPos2"))
1966
                            constant = 2;
1967
                        if (StrComp(arrayStr, "arrayPos3"))
1968
                            constant = 3;
1969
                        if (StrComp(arrayStr, "arrayPos4"))
1970
                            constant = 4;
1971
                        if (StrComp(arrayStr, "arrayPos5"))
1972
                            constant = 5;
1973
                        if (StrComp(arrayStr, "arrayPos6"))
1974
                            constant = 6;
1975
                        if (StrComp(arrayStr, "arrayPos7"))
1976
                            constant = 7;
1977
                        if (StrComp(arrayStr, "tempObjectPos"))
1978
                            constant = 8;
1979

1980
                        scriptCode[scriptCodePos++] = 1;
1981
                        scriptCode[scriptCodePos++] = constant;
1982
                    }
1983
                }
1984
                else {
1985
                    scriptCode[scriptCodePos++] = VARARR_NONE;
1986
                }
1987

1988
                constant = -1;
1989
                for (int32 i = 0; i < VAR_MAX_CNT; ++i) {
1990
                    if (StrComp(funcName, variableNames[i]))
1991
                        constant = i;
1992
                }
1993

1994
                if (constant == -1 && gameMode != ENGINE_SCRIPTERROR) {
1995
                    PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Operand not found\nOPERAND: %s\nLINE: %d\nFILE: %s", funcName, lineID, scriptFile);
1996

1997
                    gameMode = ENGINE_SCRIPTERROR;
1998
                    constant = 0;
1999
                }
2000

2001
                scriptCode[scriptCodePos++] = constant;
2002
            }
2003
        }
2004
    }
2005
}
2006
void RSDK::Legacy::v4::CheckCaseNumber(char *text)
2007
{
2008
    if (FindStringToken(text, "case", 1) != 0)
2009
        return;
2010

2011
    char caseString[128];
2012
    char caseChar = text[4];
2013

2014
    int32 textPos    = 5;
2015
    int32 caseStrPos = 0;
2016
    while (caseChar) {
2017
        if (caseChar != ':')
2018
            caseString[caseStrPos++] = caseChar;
2019
        caseChar = text[textPos++];
2020
    }
2021
    caseString[caseStrPos] = 0;
2022

2023
    bool foundValue = false;
2024

2025
    if (FindStringToken(caseString, "[", 1) >= 0) {
2026
        char caseValue[0x80];
2027
        char arrayStr[0x80];
2028

2029
        int32 textPos     = 0;
2030
        int32 funcNamePos = 0;
2031
        int32 mode        = 0;
2032
        int32 arrayStrPos = 0;
2033
        while (caseString[textPos] != ':' && caseString[textPos]) {
2034
            if (mode) {
2035
                if (caseString[textPos] == ']')
2036
                    mode = 0;
2037
                else
2038
                    arrayStr[arrayStrPos++] = caseString[textPos];
2039
                ++textPos;
2040
            }
2041
            else {
2042
                if (caseString[textPos] == '[')
2043
                    mode = 1;
2044
                else
2045
                    caseValue[funcNamePos++] = caseString[textPos];
2046
                ++textPos;
2047
            }
2048
        }
2049
        caseValue[funcNamePos] = 0;
2050
        arrayStr[arrayStrPos]  = 0;
2051

2052
        // Eg: temp0 = TypeName[Player Object]
2053
        if (StrComp(caseValue, "TypeName")) {
2054
            caseValue[0] = '0';
2055
            caseValue[1] = 0;
2056

2057
            int32 o = 0;
2058
            for (; o < LEGACY_v4_OBJECT_COUNT; ++o) {
2059
                if (StrComp(arrayStr, typeNames[o])) {
2060
                    caseValue[0] = 0;
2061
                    AppendIntegerToString(caseValue, o);
2062
                    break;
2063
                }
2064
            }
2065

2066
            if (o == LEGACY_v4_OBJECT_COUNT)
2067
                PrintLog(PRINT_NORMAL, "WARNING: Unknown typename \"%s\", on line %d", arrayStr, lineID);
2068
        }
2069

2070
        // Eg: temp0 = SfxName[Jump]
2071
        if (StrComp(caseValue, "SfxName")) {
2072
            caseValue[0] = '0';
2073
            caseValue[1] = 0;
2074

2075
            int32 s = 0;
2076
            for (; s < SFX_COUNT; ++s) {
2077
                if (StrComp(arrayStr, sfxNames[s])) {
2078
                    caseValue[0] = 0;
2079
                    AppendIntegerToString(caseValue, s);
2080
                    break;
2081
                }
2082
            }
2083

2084
            if (s == SFX_COUNT)
2085
                PrintLog(PRINT_NORMAL, "WARNING: Unknown sfxName \"%s\", on line %d", arrayStr, lineID);
2086
        }
2087

2088
#if !RETRO_USE_ORIGINAL_CODE
2089
        // Eg: temp0 = VarName[player.lives]
2090
        if (StrComp(caseValue, "VarName")) {
2091
            caseValue[0] = '0';
2092
            caseValue[1] = 0;
2093

2094
            int32 v = 0;
2095
            for (; v < globalVariablesCount; ++v) {
2096
                if (StrComp(arrayStr, globalVariables[v].name)) {
2097
                    caseValue[0] = 0;
2098
                    AppendIntegerToString(caseValue, v);
2099
                    break;
2100
                }
2101
            }
2102

2103
            if (v == globalVariablesCount)
2104
                PrintLog(PRINT_NORMAL, "WARNING: Unknown varName \"%s\", on line %d", arrayStr, lineID);
2105
        }
2106

2107
        // Eg: temp0 = AchievementName[ACH_RING_KING]
2108
        if (StrComp(caseValue, "AchievementName")) {
2109
            caseValue[0] = '0';
2110
            caseValue[1] = 0;
2111

2112
            int32 a = 0;
2113
            for (; a < (int32)achievementList.size(); ++a) {
2114
                char buf[0x40];
2115
                const char *str = achievementList[a].identifier.c_str();
2116
                int32 pos       = 0;
2117

2118
                while (*str) {
2119
                    if (*str != ' ')
2120
                        buf[pos++] = *str;
2121
                    str++;
2122
                }
2123
                buf[pos] = 0;
2124

2125
                if (StrComp(arrayStr, buf)) {
2126
                    caseValue[0] = 0;
2127
                    AppendIntegerToString(caseValue, a);
2128
                    break;
2129
                }
2130
            }
2131

2132
            if (a == (int32)achievementList.size())
2133
                PrintLog(PRINT_NORMAL, "WARNING: Unknown AchievementName \"%s\", on line %d", arrayStr, lineID);
2134
        }
2135

2136
#if RETRO_USE_MOD_LOADER
2137
        // Eg: temp0 = PlayerName[SONIC]
2138
        if (StrComp(caseValue, "PlayerName")) {
2139
            caseValue[0] = '0';
2140
            caseValue[1] = 0;
2141

2142
            int32 p = 0;
2143
            for (; p < LEGACY_PLAYERNAME_COUNT; ++p) {
2144
                char buf[0x40];
2145
                char *str = modSettings.playerNames[p];
2146
                int32 pos = 0;
2147

2148
                while (*str) {
2149
                    if (*str != ' ')
2150
                        buf[pos++] = *str;
2151
                    str++;
2152
                }
2153
                buf[pos] = 0;
2154

2155
                if (StrComp(arrayStr, buf)) {
2156
                    caseValue[0] = 0;
2157
                    AppendIntegerToString(caseValue, p);
2158
                    break;
2159
                }
2160
            }
2161

2162
            if (p == LEGACY_PLAYERNAME_COUNT)
2163
                PrintLog(PRINT_NORMAL, "WARNING: Unknown PlayerName \"%s\", on line %d", arrayStr, lineID);
2164
        }
2165

2166
        // Eg: temp0 = StageName[R - GREEN HILL ZONE 1]
2167
        if (StrComp(caseValue, "StageName")) {
2168
            caseValue[0] = '0';
2169
            caseValue[1] = 0;
2170

2171
            int32 s = -1;
2172
            if (StrLength(arrayStr) >= 2) {
2173
                char list = arrayStr[0];
2174
                switch (list) {
2175
                    case 'P': list = STAGELIST_PRESENTATION; break;
2176
                    case 'R': list = STAGELIST_REGULAR; break;
2177
                    case 'B': list = STAGELIST_BONUS; break;
2178
                    case 'S': list = STAGELIST_SPECIAL; break;
2179
                }
2180
                if (list <= 3) {
2181
                    char scnName[0x40];
2182
                    int32 scnPos          = 0;
2183
                    int32 pos             = 0;
2184
                    const char *sceneName = &arrayStr[2];
2185

2186
                    while (sceneName[scnPos]) {
2187
                        if (sceneName[scnPos] != ' ')
2188
                            scnName[pos++] = sceneName[scnPos];
2189
                        ++scnPos;
2190
                    }
2191
                    scnName[pos]           = 0;
2192
                    SceneListInfo *listCat = &sceneInfo.listCategory[list];
2193
                    int32 l                = listCat->sceneOffsetStart;
2194
                    for (int32 c = 0; c < listCat->sceneCount; ++c) {
2195
                        char nameBuffer[0x40];
2196

2197
                        scnPos = 0;
2198
                        pos    = 0;
2199
                        while (sceneInfo.listData[l].name[scnPos]) {
2200
                            if (sceneInfo.listData[l].name[scnPos] != ' ')
2201
                                nameBuffer[pos++] = sceneInfo.listData[l].name[scnPos];
2202
                            ++scnPos;
2203
                        }
2204
                        nameBuffer[pos] = 0;
2205

2206
                        if (StrComp(scnName, nameBuffer)) {
2207
                            s = c;
2208
                            break;
2209
                        }
2210
                        l++;
2211
                    }
2212
                }
2213
            }
2214

2215
            if (s == -1) {
2216
                PrintLog(PRINT_NORMAL, "WARNING: Unknown StageName \"%s\", on line %d", arrayStr, lineID);
2217
                s = 0;
2218
            }
2219
            caseValue[0] = 0;
2220
            AppendIntegerToString(caseValue, s);
2221
        }
2222
#endif
2223
#endif
2224
        StrCopy(caseString, caseValue);
2225
        foundValue = true;
2226
    }
2227

2228
    for (int32 a = 0; a < scriptValueListCount && !foundValue; ++a) {
2229
        if (StrComp(scriptValueList[a].name, caseString)) {
2230
            StrCopy(caseString, scriptValueList[a].value);
2231
            break;
2232
        }
2233
    }
2234

2235
    int32 caseID = 0;
2236
    if (ConvertStringToInteger(caseString, &caseID)) {
2237
        int32 stackValue = jumpTableStack[jumpTableStackPos];
2238
        if (caseID < jumpTable[stackValue])
2239
            jumpTable[stackValue] = caseID;
2240
        stackValue++;
2241
        if (caseID > jumpTable[stackValue])
2242
            jumpTable[stackValue] = caseID;
2243
    }
2244
    else {
2245
        PrintLog(PRINT_NORMAL, "WARNING: unable to convert case string \"%s\" to int32, on line %d", caseString, lineID);
2246
    }
2247
}
2248
bool32 RSDK::Legacy::v4::ReadSwitchCase(char *text)
2249
{
2250
    char caseText[0x80];
2251
    if (FindStringToken(text, "case", 1) == 0) {
2252
        int32 textPos       = 4;
2253
        int32 caseStringPos = 0;
2254
        while (text[textPos]) {
2255
            if (text[textPos] != ':')
2256
                caseText[caseStringPos++] = text[textPos];
2257
            ++textPos;
2258
        }
2259
        caseText[caseStringPos] = 0;
2260

2261
        bool foundValue = false;
2262
        if (FindStringToken(caseText, "[", 1) >= 0) {
2263
            char caseValue[0x80];
2264
            char arrayStr[0x80];
2265

2266
            int32 textPos     = 0;
2267
            int32 funcNamePos = 0;
2268
            int32 mode        = 0;
2269
            int32 arrayStrPos = 0;
2270
            while (caseText[textPos] != ':' && caseText[textPos]) {
2271
                if (mode) {
2272
                    if (caseText[textPos] == ']')
2273
                        mode = 0;
2274
                    else
2275
                        arrayStr[arrayStrPos++] = caseText[textPos];
2276
                    ++textPos;
2277
                }
2278
                else {
2279
                    if (caseText[textPos] == '[')
2280
                        mode = 1;
2281
                    else
2282
                        caseValue[funcNamePos++] = caseText[textPos];
2283
                    ++textPos;
2284
                }
2285
            }
2286
            caseValue[funcNamePos] = 0;
2287
            arrayStr[arrayStrPos]  = 0;
2288

2289
            // Eg: temp0 = TypeName[Player Object]
2290
            if (StrComp(caseValue, "TypeName")) {
2291
                caseValue[0] = '0';
2292
                caseValue[1] = 0;
2293

2294
                int32 o = 0;
2295
                for (; o < LEGACY_v4_OBJECT_COUNT; ++o) {
2296
                    if (StrComp(arrayStr, typeNames[o])) {
2297
                        caseValue[0] = 0;
2298
                        AppendIntegerToString(caseValue, o);
2299
                        break;
2300
                    }
2301
                }
2302

2303
                if (o == LEGACY_v4_OBJECT_COUNT)
2304
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown typename \"%s\", on line %d", arrayStr, lineID);
2305
            }
2306

2307
            // Eg: temp0 = SfxName[Jump]
2308
            if (StrComp(caseValue, "SfxName")) {
2309
                caseValue[0] = '0';
2310
                caseValue[1] = 0;
2311

2312
                int32 s = 0;
2313
                for (; s < SFX_COUNT; ++s) {
2314
                    if (StrComp(arrayStr, sfxNames[s])) {
2315
                        caseValue[0] = 0;
2316
                        AppendIntegerToString(caseValue, s);
2317
                        break;
2318
                    }
2319
                }
2320

2321
                if (s == SFX_COUNT)
2322
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown sfxName \"%s\", on line %d", arrayStr, lineID);
2323
            }
2324

2325
#if !RETRO_USE_ORIGINAL_CODE
2326
            // Eg: temp0 = VarName[player.lives]
2327
            if (StrComp(caseValue, "VarName")) {
2328
                caseValue[0] = '0';
2329
                caseValue[1] = 0;
2330

2331
                int32 v = 0;
2332
                for (; v < globalVariablesCount; ++v) {
2333
                    if (StrComp(arrayStr, globalVariables[v].name)) {
2334
                        caseValue[0] = 0;
2335
                        AppendIntegerToString(caseValue, v);
2336
                        break;
2337
                    }
2338
                }
2339

2340
                if (v == globalVariablesCount)
2341
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown varName \"%s\", on line %d", arrayStr, lineID);
2342
            }
2343

2344
            // Eg: temp0 = AchievementName[ACH_RING_KING]
2345
            if (StrComp(caseValue, "AchievementName")) {
2346
                caseValue[0] = '0';
2347
                caseValue[1] = 0;
2348

2349
                int32 a = 0;
2350
                for (; a < (int32)achievementList.size(); ++a) {
2351
                    char buf[0x40];
2352
                    const char *str = achievementList[a].identifier.c_str();
2353
                    int32 pos       = 0;
2354

2355
                    while (*str) {
2356
                        if (*str != ' ')
2357
                            buf[pos++] = *str;
2358
                        str++;
2359
                    }
2360
                    buf[pos] = 0;
2361

2362
                    if (StrComp(arrayStr, buf)) {
2363
                        caseValue[0] = 0;
2364
                        AppendIntegerToString(caseValue, a);
2365
                        break;
2366
                    }
2367
                }
2368

2369
                if (a == (int32)achievementList.size())
2370
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown AchievementName \"%s\", on line %d", arrayStr, lineID);
2371
            }
2372

2373
#if RETRO_USE_MOD_LOADER
2374
            // Eg: temp0 = PlayerName[SONIC]
2375
            if (StrComp(caseValue, "PlayerName")) {
2376
                caseValue[0] = '0';
2377
                caseValue[1] = 0;
2378

2379
                int32 p = 0;
2380
                for (; p < LEGACY_PLAYERNAME_COUNT; ++p) {
2381
                    char buf[0x40];
2382
                    char *str = modSettings.playerNames[p];
2383
                    int32 pos = 0;
2384

2385
                    while (*str) {
2386
                        if (*str != ' ')
2387
                            buf[pos++] = *str;
2388
                        str++;
2389
                    }
2390
                    buf[pos] = 0;
2391

2392
                    if (StrComp(arrayStr, buf)) {
2393
                        caseValue[0] = 0;
2394
                        AppendIntegerToString(caseValue, p);
2395
                        break;
2396
                    }
2397
                }
2398

2399
                if (p == LEGACY_PLAYERNAME_COUNT)
2400
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown PlayerName \"%s\", on line %d", arrayStr, lineID);
2401
            }
2402

2403
            // Eg: temp0 = StageName[R - GREEN HILL ZONE 1]
2404
            if (StrComp(caseValue, "StageName")) {
2405
                caseValue[0] = '0';
2406
                caseValue[1] = 0;
2407

2408
                int32 s = -1;
2409
                if (StrLength(arrayStr) >= 2) {
2410
                    char list = arrayStr[0];
2411
                    switch (list) {
2412
                        case 'P': list = STAGELIST_PRESENTATION; break;
2413
                        case 'R': list = STAGELIST_REGULAR; break;
2414
                        case 'B': list = STAGELIST_BONUS; break;
2415
                        case 'S': list = STAGELIST_SPECIAL; break;
2416
                    }
2417
                    if (list <= 3) {
2418
                        char scnName[0x40];
2419
                        int32 scnPos          = 0;
2420
                        int32 pos             = 0;
2421
                        const char *sceneName = &arrayStr[2];
2422

2423
                        while (sceneName[scnPos]) {
2424
                            if (sceneName[scnPos] != ' ')
2425
                                scnName[pos++] = sceneName[scnPos];
2426
                            ++scnPos;
2427
                        }
2428
                        scnName[pos]           = 0;
2429
                        SceneListInfo *listCat = &sceneInfo.listCategory[list];
2430
                        int32 l                = listCat->sceneOffsetStart;
2431
                        for (int32 c = 0; c < listCat->sceneCount; ++c) {
2432
                            char nameBuffer[0x40];
2433

2434
                            scnPos = 0;
2435
                            pos    = 0;
2436
                            while (sceneInfo.listData[l].name[scnPos]) {
2437
                                if (sceneInfo.listData[l].name[scnPos] != ' ')
2438
                                    nameBuffer[pos++] = sceneInfo.listData[l].name[scnPos];
2439
                                ++scnPos;
2440
                            }
2441
                            nameBuffer[pos] = 0;
2442

2443
                            if (StrComp(scnName, nameBuffer)) {
2444
                                s = c;
2445
                                break;
2446
                            }
2447
                            l++;
2448
                        }
2449
                    }
2450
                }
2451

2452
                if (s == -1) {
2453
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown StageName \"%s\", on line %d", arrayStr, lineID);
2454
                    s = 0;
2455
                }
2456
                caseValue[0] = 0;
2457
                AppendIntegerToString(caseValue, s);
2458
            }
2459
#endif
2460
#endif
2461
            StrCopy(caseText, caseValue);
2462
            foundValue = true;
2463
        }
2464

2465
        for (int32 v = 0; v < scriptValueListCount && !foundValue; ++v) {
2466
            if (StrComp(caseText, scriptValueList[v].name)) {
2467
                StrCopy(caseText, scriptValueList[v].value);
2468
                break;
2469
            }
2470
        }
2471

2472
        int32 val = 0;
2473

2474
        int32 jPos    = jumpTableStack[jumpTableStackPos];
2475
        int32 jOffset = jPos + 4;
2476
        if (ConvertStringToInteger(caseText, &val))
2477
            jumpTable[val - jumpTable[jPos] + jOffset] = scriptCodePos - scriptCodeOffset;
2478
        else
2479
            PrintLog(PRINT_NORMAL, "WARNING: unable to read case string \"%s\" as an int32, on line %d", caseText, lineID);
2480

2481
        return true;
2482
    }
2483
    else if (FindStringToken(text, "default", 1) == 0) {
2484
        int32 jumpTablepos          = jumpTableStack[jumpTableStackPos];
2485
        jumpTable[jumpTablepos + 2] = scriptCodePos - scriptCodeOffset;
2486
        int32 cnt                   = abs(jumpTable[jumpTablepos + 1] - jumpTable[jumpTablepos]) + 1;
2487

2488
        int32 jOffset = jumpTablepos + 4;
2489
        for (int32 i = 0; i < cnt; ++i) {
2490
            if (jumpTable[jOffset + i] < 0)
2491
                jumpTable[jOffset + i] = scriptCodePos - scriptCodeOffset;
2492
        }
2493

2494
        return true;
2495
    }
2496

2497
    return false;
2498
}
2499
void RSDK::Legacy::v4::ReadTableValues(char *text)
2500
{
2501
    int32 textStrPos = 0;
2502

2503
    char valueBuffer[256];
2504
    int32 valueBufferPos = 0;
2505

2506
    while (text[textStrPos]) {
2507
        valueBuffer[valueBufferPos++] = text[textStrPos++];
2508

2509
        while (text[textStrPos] == ',') {
2510
            valueBuffer[valueBufferPos] = 0;
2511
            ++scriptCode[scriptCodeOffset];
2512
            if (!ConvertStringToInteger(valueBuffer, &scriptCode[scriptCodePos])) {
2513
                scriptCode[scriptCodePos] = 0;
2514
#if !RETRO_USE_ORIGINAL_CODE
2515
                PrintLog(PRINT_NORMAL, "WARNING: unable to parse table value \"%s\" as an int, on line %d", valueBuffer, lineID);
2516
#endif
2517
            }
2518
            scriptCodePos++;
2519
            valueBufferPos = 0;
2520
            textStrPos++;
2521
        }
2522
    }
2523

2524
    if (StrLength(valueBuffer)) {
2525
        valueBuffer[valueBufferPos] = 0;
2526
        ++scriptCode[scriptCodeOffset];
2527
        if (!ConvertStringToInteger(valueBuffer, &scriptCode[scriptCodePos])) {
2528
            scriptCode[scriptCodePos] = 0;
2529
#if !RETRO_USE_ORIGINAL_CODE
2530
            PrintLog(PRINT_NORMAL, "WARNING: unable to parse table value \"%s\" as an int, on line %d", valueBuffer, lineID);
2531
#endif
2532
        }
2533
        scriptCodePos++;
2534
    }
2535
}
2536
void RSDK::Legacy::v4::AppendIntegerToString(char *text, int32 value)
2537
{
2538
    int32 textPos = 0;
2539
    while (true) {
2540
        if (!text[textPos])
2541
            break;
2542
        ++textPos;
2543
    }
2544

2545
    int32 cnt = 0;
2546
    int32 v   = value;
2547
    while (v != 0) {
2548
        v /= 10;
2549
        cnt++;
2550
    }
2551

2552
    v = 0;
2553
    for (int32 i = cnt - 1; i >= 0; --i) {
2554
        v = (int32)(value / pow(10, i));
2555
        v %= 10;
2556

2557
        int32 strValue = v + '0';
2558
        if (strValue < '0' || strValue > '9') {
2559
            // what
2560
        }
2561
        text[textPos++] = strValue;
2562
    }
2563
    if (value == 0)
2564
        text[textPos++] = '0';
2565
    text[textPos] = 0;
2566
}
2567
void RSDK::Legacy::v4::CopyAliasStr(char *dest, char *text, bool32 arrayIndex)
2568
{
2569
    int32 textPos   = 0;
2570
    int32 destPos   = 0;
2571
    bool arrayValue = false;
2572
    if (arrayIndex) {
2573
        while (text[textPos]) {
2574
            if (arrayValue) {
2575
                if (text[textPos] == ']')
2576
                    arrayValue = false;
2577
                else
2578
                    dest[destPos++] = text[textPos];
2579
                ++textPos;
2580
            }
2581
            else {
2582
                if (text[textPos] == '[')
2583
                    arrayValue = true;
2584
                ++textPos;
2585
            }
2586
        }
2587
    }
2588
    else {
2589
        while (text[textPos]) {
2590
            if (arrayValue) {
2591
                if (text[textPos] == ']')
2592
                    arrayValue = false;
2593
                ++textPos;
2594
            }
2595
            else {
2596
                if (text[textPos] == '[')
2597
                    arrayValue = true;
2598
                else
2599
                    dest[destPos++] = text[textPos];
2600
                ++textPos;
2601
            }
2602
        }
2603
    }
2604
    dest[destPos] = 0;
2605
}
2606
bool32 RSDK::Legacy::v4::CheckOpcodeType(char *text)
2607
{
2608
    while (*text) {
2609
        if (*text++ == '(')
2610
            return false;
2611
    }
2612
    return true;
2613
}
2614

2615
void RSDK::Legacy::v4::ParseScriptFile(char *scriptName, int32 scriptID)
2616
{
2617
    jumpTableStackPos = 0;
2618
    lineID            = 0;
2619

2620
    scriptFile = scriptName;
2621

2622
    for (int32 f = 0; f < scriptFunctionCount; ++f) {
2623
        if (scriptFunctionList[f].access != ACCESS_PUBLIC)
2624
            StrCopy(scriptFunctionList[f].name, "");
2625
    }
2626

2627
    int32 newScriptValueCount = LEGACY_v4_COMMON_SCRIPT_VAR_COUNT;
2628
    for (int32 v = LEGACY_v4_COMMON_SCRIPT_VAR_COUNT; v < scriptValueListCount; ++v) {
2629
        if (scriptValueList[v].access != ACCESS_PUBLIC) {
2630
            StrCopy(scriptValueList[v].name, "");
2631
        }
2632
        else {
2633
            if (newScriptValueCount != v)
2634
                memcpy(&scriptValueList[newScriptValueCount], &scriptValueList[v], sizeof(ScriptVariableInfo));
2635

2636
            newScriptValueCount++;
2637
        }
2638
    }
2639
    scriptValueListCount = newScriptValueCount;
2640

2641
    for (int32 v = scriptValueListCount; v < LEGACY_v4_SCRIPT_VAR_COUNT; ++v) {
2642
        MEM_ZERO(scriptValueList[v]);
2643
    }
2644

2645
    FileInfo info;
2646
    InitFileInfo(&info);
2647

2648
    char scriptPath[0x40];
2649

2650
    // Try the original script folder
2651
    StrCopy(scriptPath, "Data/Scripts/");
2652
    StrAdd(scriptPath, scriptName);
2653
    if (LoadFile(&info, scriptPath, FMODE_RB)) {
2654
        int32 readMode   = READMODE_NORMAL;
2655
        int32 parseMode  = PARSEMODE_SCOPELESS;
2656
        int32 storedPos  = 0;
2657
        char prevChar    = 0;
2658
        char curChar     = 0;
2659
        int32 switchDeep = 0;
2660

2661
        while (readMode < READMODE_EOF) {
2662
            int32 textPos               = 0;
2663
            readMode                    = READMODE_NORMAL;
2664
            bool32 disableLineIncrement = false;
2665

2666
            while (readMode < READMODE_ENDLINE) {
2667
                prevChar = curChar;
2668
                curChar  = ReadInt8(&info);
2669

2670
                if (readMode == READMODE_STRING) {
2671
                    if (curChar == '\t' || curChar == '\r' || curChar == '\n' || curChar == ';' || readMode >= READMODE_COMMENTLINE) {
2672
                        if ((curChar == '\n' && prevChar != '\r') || (curChar == '\n' && prevChar == '\r')) {
2673
                            readMode            = READMODE_ENDLINE;
2674
                            scriptText[textPos] = 0;
2675
                            if (curChar == ';')
2676
                                disableLineIncrement = true;
2677
                        }
2678
                    }
2679
                    else if (curChar != '/' || textPos <= 0) {
2680
                        scriptText[textPos++] = curChar;
2681
                        if (curChar == '"')
2682
                            readMode = READMODE_NORMAL;
2683
                    }
2684
                    else if (curChar == '/' && prevChar == '/') {
2685
                        readMode              = READMODE_COMMENTLINE;
2686
                        scriptText[--textPos] = 0;
2687
                    }
2688
                    else {
2689
                        scriptText[textPos++] = curChar;
2690
                    }
2691
                }
2692
                else if (curChar == ' ' || curChar == '\t' || curChar == '\r' || curChar == '\n' || curChar == ';'
2693
                         || readMode >= READMODE_COMMENTLINE) {
2694
                    if ((curChar == '\n' && prevChar != '\r') || (curChar == '\n' && prevChar == '\r') || curChar == ';') {
2695
                        readMode            = READMODE_ENDLINE;
2696
                        scriptText[textPos] = 0;
2697
                        if (curChar == ';')
2698
                            disableLineIncrement = true;
2699
                    }
2700
                }
2701
                else if (curChar != '/' || textPos <= 0) {
2702
                    scriptText[textPos++] = curChar;
2703
                    if (curChar == '"' && !readMode)
2704
                        readMode = READMODE_STRING;
2705
                }
2706
                else if (curChar == '/' && prevChar == '/') {
2707
                    readMode              = READMODE_COMMENTLINE;
2708
                    scriptText[--textPos] = 0;
2709
                }
2710
                else {
2711
                    scriptText[textPos++] = curChar;
2712
                }
2713

2714
                if (info.readPos >= info.fileSize) {
2715
                    scriptText[textPos] = 0;
2716
                    readMode            = READMODE_EOF;
2717
                }
2718
            }
2719

2720
            switch (parseMode) {
2721
                case PARSEMODE_SCOPELESS:
2722
                    if (!disableLineIncrement)
2723
                        ++lineID;
2724

2725
                    CheckAliasText(scriptText);
2726
                    CheckStaticText(scriptText);
2727

2728
                    if (CheckTableText(scriptText)) {
2729
                        parseMode = PARSEMODE_TABLEREAD;
2730
                        StrCopy(scriptText, "");
2731
                    }
2732

2733
                    if (StrComp(scriptText, "eventObjectUpdate")) {
2734
                        parseMode                                            = PARSEMODE_FUNCTION;
2735
                        objectScriptList[scriptID].eventUpdate.scriptCodePtr = scriptCodePos;
2736
                        objectScriptList[scriptID].eventUpdate.jumpTablePtr  = jumpTablePos;
2737
                        scriptCodeOffset                                     = scriptCodePos;
2738
                        jumpTableOffset                                      = jumpTablePos;
2739
                    }
2740

2741
                    if (StrComp(scriptText, "eventObjectDraw")) {
2742
                        parseMode                                          = PARSEMODE_FUNCTION;
2743
                        objectScriptList[scriptID].eventDraw.scriptCodePtr = scriptCodePos;
2744
                        objectScriptList[scriptID].eventDraw.jumpTablePtr  = jumpTablePos;
2745
                        scriptCodeOffset                                   = scriptCodePos;
2746
                        jumpTableOffset                                    = jumpTablePos;
2747
                    }
2748

2749
                    if (StrComp(scriptText, "eventObjectStartup")) {
2750
                        parseMode                                             = PARSEMODE_FUNCTION;
2751
                        objectScriptList[scriptID].eventStartup.scriptCodePtr = scriptCodePos;
2752
                        objectScriptList[scriptID].eventStartup.jumpTablePtr  = jumpTablePos;
2753
                        scriptCodeOffset                                      = scriptCodePos;
2754
                        jumpTableOffset                                       = jumpTablePos;
2755
                    }
2756

2757
                    if (FindStringToken(scriptText, "reservefunction", 1) == 0) { // forward decl
2758
                        char funcName[0x40];
2759
                        for (textPos = 15; scriptText[textPos]; ++textPos) funcName[textPos - 15] = scriptText[textPos];
2760
                        funcName[textPos - 15] = 0;
2761
                        int32 funcID           = -1;
2762
                        for (int32 f = 0; f < scriptFunctionCount; ++f) {
2763
                            if (StrComp(funcName, scriptFunctionList[f].name))
2764
                                funcID = f;
2765
                        }
2766

2767
                        if (scriptFunctionCount < LEGACY_v4_FUNCTION_COUNT && funcID == -1) {
2768
                            StrCopy(scriptFunctionList[scriptFunctionCount++].name, funcName);
2769
                        }
2770
                        else {
2771
                            PrintLog(PRINT_NORMAL, "WARNING: Function %s has already been reserved!", funcName);
2772
                        }
2773

2774
                        parseMode = PARSEMODE_SCOPELESS;
2775
                    }
2776
                    else if (FindStringToken(scriptText, "publicfunction", 1) == 0) { // regular public decl
2777
                        char funcName[0x40];
2778
                        for (textPos = 14; scriptText[textPos]; ++textPos) funcName[textPos - 14] = scriptText[textPos];
2779

2780
                        funcName[textPos - 14] = 0;
2781
                        int32 funcID           = -1;
2782
                        for (int32 f = 0; f < scriptFunctionCount; ++f) {
2783
                            if (StrComp(funcName, scriptFunctionList[f].name))
2784
                                funcID = f;
2785
                        }
2786

2787
                        if (funcID <= -1) {
2788
                            if (scriptFunctionCount >= LEGACY_v4_FUNCTION_COUNT) {
2789
                                parseMode = PARSEMODE_SCOPELESS;
2790
                            }
2791
                            else {
2792
                                StrCopy(scriptFunctionList[scriptFunctionCount].name, funcName);
2793
                                scriptFunctionList[scriptFunctionCount].access            = ACCESS_PUBLIC;
2794
                                scriptFunctionList[scriptFunctionCount].ptr.scriptCodePtr = scriptCodePos;
2795
                                scriptFunctionList[scriptFunctionCount].ptr.jumpTablePtr  = jumpTablePos;
2796

2797
                                scriptCodeOffset = scriptCodePos;
2798
                                jumpTableOffset  = jumpTablePos;
2799
                                parseMode        = PARSEMODE_FUNCTION;
2800
                                ++scriptFunctionCount;
2801
                            }
2802
                        }
2803
                        else {
2804
                            StrCopy(scriptFunctionList[funcID].name, funcName);
2805
                            scriptFunctionList[funcID].access            = ACCESS_PUBLIC;
2806
                            scriptFunctionList[funcID].ptr.scriptCodePtr = scriptCodePos;
2807
                            scriptFunctionList[funcID].ptr.jumpTablePtr  = jumpTablePos;
2808

2809
                            scriptCodeOffset = scriptCodePos;
2810
                            jumpTableOffset  = jumpTablePos;
2811
                            parseMode        = PARSEMODE_FUNCTION;
2812
                        }
2813
                    }
2814
                    else if (FindStringToken(scriptText, "privatefunction", 1) == 0) { // regular private decl
2815
                        char funcName[0x40];
2816
                        for (textPos = 15; scriptText[textPos]; ++textPos) funcName[textPos - 15] = scriptText[textPos];
2817

2818
                        funcName[textPos - 15] = 0;
2819
                        int32 funcID           = -1;
2820
                        for (int32 f = 0; f < scriptFunctionCount; ++f) {
2821
                            if (StrComp(funcName, scriptFunctionList[f].name))
2822
                                funcID = f;
2823
                        }
2824

2825
                        if (funcID <= -1) {
2826
                            if (scriptFunctionCount >= LEGACY_v4_FUNCTION_COUNT) {
2827
                                parseMode = PARSEMODE_SCOPELESS;
2828
                            }
2829
                            else {
2830
                                StrCopy(scriptFunctionList[scriptFunctionCount].name, funcName);
2831
                                scriptFunctionList[scriptFunctionCount].access            = ACCESS_PRIVATE;
2832
                                scriptFunctionList[scriptFunctionCount].ptr.scriptCodePtr = scriptCodePos;
2833
                                scriptFunctionList[scriptFunctionCount].ptr.jumpTablePtr  = jumpTablePos;
2834

2835
                                scriptCodeOffset = scriptCodePos;
2836
                                jumpTableOffset  = jumpTablePos;
2837
                                parseMode        = PARSEMODE_FUNCTION;
2838
                                ++scriptFunctionCount;
2839
                            }
2840
                        }
2841
                        else {
2842
                            StrCopy(scriptFunctionList[funcID].name, funcName);
2843
                            scriptFunctionList[funcID].access            = ACCESS_PRIVATE;
2844
                            scriptFunctionList[funcID].ptr.scriptCodePtr = scriptCodePos;
2845
                            scriptFunctionList[funcID].ptr.jumpTablePtr  = jumpTablePos;
2846

2847
                            scriptCodeOffset = scriptCodePos;
2848
                            jumpTableOffset  = jumpTablePos;
2849
                            parseMode        = PARSEMODE_FUNCTION;
2850
                        }
2851
                    }
2852
                    break;
2853

2854
                case PARSEMODE_PLATFORMSKIP:
2855
                    if (!disableLineIncrement)
2856
                        ++lineID;
2857

2858
                    if (FindStringToken(scriptText, "#endplatform", 1) == 0)
2859
                        parseMode = PARSEMODE_FUNCTION;
2860
                    break;
2861

2862
                case PARSEMODE_FUNCTION:
2863
                    if (!disableLineIncrement)
2864
                        ++lineID;
2865

2866
                    if (scriptText[0]) {
2867
                        if (StrComp(scriptText, "endevent")) {
2868
                            scriptCode[scriptCodePos++] = FUNC_END;
2869
                            parseMode                   = PARSEMODE_SCOPELESS;
2870
                        }
2871
                        else if (StrComp(scriptText, "endfunction")) {
2872
                            scriptCode[scriptCodePos++] = FUNC_RETURN;
2873
                            parseMode                   = PARSEMODE_SCOPELESS;
2874
                        }
2875
                        else if (FindStringToken(scriptText, "#platform:", 1) == 0) {
2876
                            if (FindStringToken(scriptText, engine.gamePlatform, 1) == -1
2877
                                && FindStringToken(scriptText, engine.gameRenderType, 1) == -1
2878
#if LEGACY_RETRO_USE_HAPTICS
2879
                                && FindStringToken(scriptText, engine.gameHapticSetting, 1) == -1
2880
#endif
2881
#if !RETRO_USE_ORIGINAL_CODE
2882
                                && FindStringToken(scriptText, engine.releaseType, 1) == -1 // general flag for new stuff origins added
2883
#endif
2884
#if !RETRO_USE_ORIGINAL_CODE
2885
                                && FindStringToken(scriptText, "USE_DECOMP", 1) == -1 // general flag for decomp-only stuff
2886
#endif
2887
#if RETRO_USE_MOD_LOADER
2888
                                && FindStringToken(scriptText, "USE_MOD_LOADER", 1) == -1
2889
#endif
2890
                            ) {
2891
                                parseMode = PARSEMODE_PLATFORMSKIP;
2892
                            }
2893
                        }
2894
                        else if (FindStringToken(scriptText, "#endplatform", 1) == -1) {
2895
                            ConvertConditionalStatement(scriptText);
2896
                            if (ConvertSwitchStatement(scriptText)) {
2897
                                parseMode  = PARSEMODE_SWITCHREAD;
2898
                                storedPos  = (int32)info.readPos;
2899
                                switchDeep = 0;
2900
                            }
2901
                            ConvertArithmaticSyntax(scriptText);
2902
                            if (!ReadSwitchCase(scriptText)) {
2903
                                ConvertFunctionText(scriptText);
2904

2905
                                if (gameMode == ENGINE_SCRIPTERROR)
2906
                                    parseMode = PARSEMODE_ERROR;
2907
                            }
2908
                        }
2909
                    }
2910
                    break;
2911

2912
                case PARSEMODE_SWITCHREAD:
2913
                    if (FindStringToken(scriptText, "switch", 1) == 0)
2914
                        ++switchDeep;
2915

2916
                    if (switchDeep) {
2917
                        if (FindStringToken(scriptText, "endswitch", 1) == 0)
2918
                            --switchDeep;
2919
                    }
2920
                    else if (FindStringToken(scriptText, "endswitch", 1) == 0) {
2921
                        Seek_Set(&info, storedPos);
2922
                        parseMode  = PARSEMODE_FUNCTION;
2923
                        int32 jPos = jumpTableStack[jumpTableStackPos];
2924
                        switchDeep = abs(jumpTable[jPos + 1] - jumpTable[jPos]) + 1;
2925
                        for (textPos = 0; textPos < switchDeep; ++textPos) jumpTable[jumpTablePos++] = -1;
2926
                    }
2927
                    else {
2928
                        CheckCaseNumber(scriptText);
2929
                    }
2930
                    break;
2931

2932
                case PARSEMODE_TABLEREAD:
2933
                    if (!disableLineIncrement)
2934
                        ++lineID;
2935

2936
                    if (FindStringToken(scriptText, "endtable", 1) == 0) {
2937
                        parseMode = PARSEMODE_SCOPELESS;
2938
                    }
2939
                    else {
2940
                        if (StrLength(scriptText) >= 1)
2941
                            ReadTableValues(scriptText);
2942

2943
                        parseMode = PARSEMODE_TABLEREAD;
2944
                    }
2945
                    break;
2946

2947
                default: break;
2948
            }
2949
        }
2950

2951
        CloseFile(&info);
2952
    }
2953
}
2954
#endif
2955

2956
void RSDK::Legacy::v4::LoadBytecode(int32 scriptID, bool32 globalCode)
2957
{
2958
    char scriptPath[0x40];
2959
    if (globalCode) {
2960
        StrCopy(scriptPath, "Bytecode/GlobalCode.bin");
2961
    }
2962
    else {
2963
        StrCopy(scriptPath, "Bytecode/");
2964
        StrAdd(scriptPath, sceneInfo.listData[sceneInfo.listPos].folder);
2965
        StrAdd(scriptPath, ".bin");
2966
    }
2967

2968
    FileInfo info;
2969
    InitFileInfo(&info);
2970
    if (LoadFile(&info, scriptPath, FMODE_RB)) {
2971
        int32 *scriptCodePtr = &scriptCode[scriptCodePos];
2972
        int32 *jumpTablePtr  = &jumpTable[jumpTablePos];
2973

2974
        int32 scriptCodeSize = ReadInt8(&info);
2975
        scriptCodeSize |= ReadInt8(&info) << 8;
2976
        scriptCodeSize |= ReadInt8(&info) << 16;
2977
        scriptCodeSize |= ReadInt8(&info) << 24;
2978

2979
        while (scriptCodeSize > 0) {
2980
            uint8 fileBuffer = ReadInt8(&info);
2981
            int32 blockSize  = fileBuffer & 0x7F;
2982
            if (fileBuffer >= 0x80) {
2983
                while (blockSize > 0) {
2984
                    *scriptCodePtr = ReadInt8(&info);
2985
                    *scriptCodePtr |= ReadInt8(&info) << 8;
2986
                    *scriptCodePtr |= ReadInt8(&info) << 16;
2987
                    *scriptCodePtr |= ReadInt8(&info) << 24;
2988

2989
                    ++scriptCodePtr;
2990
                    ++scriptCodePos;
2991
                    --scriptCodeSize;
2992
                    --blockSize;
2993
                }
2994
            }
2995
            else {
2996
                while (blockSize > 0) {
2997
                    *scriptCodePtr = ReadInt8(&info);
2998

2999
                    ++scriptCodePtr;
3000
                    ++scriptCodePos;
3001
                    --scriptCodeSize;
3002
                    --blockSize;
3003
                }
3004
            }
3005
        }
3006

3007
        int32 jumpTableSize = ReadInt8(&info);
3008
        jumpTableSize |= ReadInt8(&info) << 8;
3009
        jumpTableSize |= ReadInt8(&info) << 16;
3010
        jumpTableSize |= ReadInt8(&info) << 24;
3011

3012
        while (jumpTableSize > 0) {
3013
            uint8 fileBuffer = ReadInt8(&info);
3014
            int32 blockSize  = fileBuffer & 0x7F;
3015

3016
            if (fileBuffer >= 0x80) {
3017
                while (blockSize > 0) {
3018
                    *jumpTablePtr = ReadInt8(&info);
3019
                    *jumpTablePtr |= ReadInt8(&info) << 8;
3020
                    *jumpTablePtr |= ReadInt8(&info) << 16;
3021
                    *jumpTablePtr |= ReadInt8(&info) << 24;
3022

3023
                    ++jumpTablePtr;
3024
                    ++jumpTablePos;
3025
                    --jumpTableSize;
3026
                    --blockSize;
3027
                }
3028
            }
3029
            else {
3030
                while (blockSize > 0) {
3031
                    *jumpTablePtr = ReadInt8(&info);
3032

3033
                    ++jumpTablePtr;
3034
                    ++jumpTablePos;
3035
                    --jumpTableSize;
3036
                    --blockSize;
3037
                }
3038
            }
3039
        }
3040

3041
        int32 scriptCount = ReadInt8(&info);
3042
        scriptCount |= ReadInt8(&info) << 8;
3043

3044
        for (int32 s = 0; s < scriptCount; ++s) {
3045
            ObjectScript *script = &objectScriptList[scriptID + s];
3046

3047
            script->eventUpdate.scriptCodePtr = ReadInt8(&info);
3048
            script->eventUpdate.scriptCodePtr |= ReadInt8(&info) << 8;
3049
            script->eventUpdate.scriptCodePtr |= ReadInt8(&info) << 16;
3050
            script->eventUpdate.scriptCodePtr |= ReadInt8(&info) << 24;
3051

3052
            script->eventDraw.scriptCodePtr = ReadInt8(&info);
3053
            script->eventDraw.scriptCodePtr |= ReadInt8(&info) << 8;
3054
            script->eventDraw.scriptCodePtr |= ReadInt8(&info) << 16;
3055
            script->eventDraw.scriptCodePtr |= ReadInt8(&info) << 24;
3056

3057
            script->eventStartup.scriptCodePtr = ReadInt8(&info);
3058
            script->eventStartup.scriptCodePtr |= ReadInt8(&info) << 8;
3059
            script->eventStartup.scriptCodePtr |= ReadInt8(&info) << 16;
3060
            script->eventStartup.scriptCodePtr |= ReadInt8(&info) << 24;
3061
        }
3062

3063
        for (int32 s = 0; s < scriptCount; ++s) {
3064
            ObjectScript *script = &objectScriptList[scriptID + s];
3065

3066
            script->eventUpdate.jumpTablePtr = ReadInt8(&info);
3067
            script->eventUpdate.jumpTablePtr |= ReadInt8(&info) << 8;
3068
            script->eventUpdate.jumpTablePtr |= ReadInt8(&info) << 16;
3069
            script->eventUpdate.jumpTablePtr |= ReadInt8(&info) << 24;
3070

3071
            script->eventDraw.jumpTablePtr = ReadInt8(&info);
3072
            script->eventDraw.jumpTablePtr |= ReadInt8(&info) << 8;
3073
            script->eventDraw.jumpTablePtr |= ReadInt8(&info) << 16;
3074
            script->eventDraw.jumpTablePtr |= ReadInt8(&info) << 24;
3075

3076
            script->eventStartup.jumpTablePtr = ReadInt8(&info);
3077
            script->eventStartup.jumpTablePtr |= ReadInt8(&info) << 8;
3078
            script->eventStartup.jumpTablePtr |= ReadInt8(&info) << 16;
3079
            script->eventStartup.jumpTablePtr |= ReadInt8(&info) << 24;
3080
        }
3081

3082
        int32 functionCount = ReadInt8(&info);
3083
        functionCount |= ReadInt8(&info) << 8;
3084

3085
        for (int32 f = 0; f < functionCount; ++f) {
3086
            ScriptFunction *function = &scriptFunctionList[f];
3087

3088
            function->ptr.scriptCodePtr = ReadInt8(&info);
3089
            function->ptr.scriptCodePtr |= ReadInt8(&info) << 8;
3090
            function->ptr.scriptCodePtr |= ReadInt8(&info) << 16;
3091
            function->ptr.scriptCodePtr |= ReadInt8(&info) << 24;
3092
        }
3093

3094
        for (int32 f = 0; f < functionCount; ++f) {
3095
            ScriptFunction *function = &scriptFunctionList[f];
3096

3097
            function->ptr.jumpTablePtr = ReadInt8(&info);
3098
            function->ptr.jumpTablePtr |= ReadInt8(&info) << 8;
3099
            function->ptr.jumpTablePtr |= ReadInt8(&info) << 16;
3100
            function->ptr.jumpTablePtr |= ReadInt8(&info) << 24;
3101
        }
3102

3103
        CloseFile(&info);
3104
    }
3105
}
3106

3107
void RSDK::Legacy::v4::ClearScriptData()
3108
{
3109
    memset(scriptCode, 0, sizeof(scriptCode));
3110
    memset(jumpTable, 0, sizeof(jumpTable));
3111

3112
    memset(foreachStack, -1, sizeof(foreachStack));
3113
    memset(jumpTableStack, 0, sizeof(jumpTableStack));
3114
    memset(functionStack, 0, sizeof(functionStack));
3115

3116
    scriptFrameCount = 0;
3117

3118
    scriptCodePos     = 0;
3119
    jumpTablePos      = 0;
3120
    jumpTableStackPos = 0;
3121
    functionStackPos  = 0;
3122

3123
    scriptCodePos    = 0;
3124
    scriptCodeOffset = 0;
3125
    jumpTablePos     = 0;
3126
    jumpTableOffset  = 0;
3127

3128
#if LEGACY_RETRO_USE_COMPILER
3129
    scriptFunctionCount = 0;
3130

3131
    lineID = 0;
3132

3133
    scriptValueListCount = LEGACY_v4_COMMON_SCRIPT_VAR_COUNT;
3134
    for (int32 v = LEGACY_v4_COMMON_SCRIPT_VAR_COUNT; v < LEGACY_v4_SCRIPT_VAR_COUNT; ++v) {
3135
        MEM_ZERO(scriptValueList[v]);
3136
    }
3137
#endif
3138

3139
    ClearAnimationData();
3140

3141
    for (int32 o = 0; o < LEGACY_v4_OBJECT_COUNT; ++o) {
3142
        ObjectScript *scriptInfo               = &objectScriptList[o];
3143
        scriptInfo->eventUpdate.scriptCodePtr  = LEGACY_v4_SCRIPTCODE_COUNT - 1;
3144
        scriptInfo->eventUpdate.jumpTablePtr   = LEGACY_v4_JUMPTABLE_COUNT - 1;
3145
        scriptInfo->eventDraw.scriptCodePtr    = LEGACY_v4_SCRIPTCODE_COUNT - 1;
3146
        scriptInfo->eventDraw.jumpTablePtr     = LEGACY_v4_JUMPTABLE_COUNT - 1;
3147
        scriptInfo->eventStartup.scriptCodePtr = LEGACY_v4_SCRIPTCODE_COUNT - 1;
3148
        scriptInfo->eventStartup.jumpTablePtr  = LEGACY_v4_JUMPTABLE_COUNT - 1;
3149
        scriptInfo->frameListOffset            = 0;
3150
        scriptInfo->spriteSheetID              = 0;
3151
        scriptInfo->animFile                   = GetDefaultAnimationRef();
3152
        typeNames[o][0]                        = 0;
3153
    }
3154

3155
    for (int32 s = globalSFXCount; s < globalSFXCount + stageSFXCount; ++s) {
3156
        sfxNames[s][0] = 0;
3157
    }
3158

3159
    for (int32 f = 0; f < LEGACY_v4_FUNCTION_COUNT; ++f) {
3160
        scriptFunctionList[f].ptr.scriptCodePtr = LEGACY_v4_SCRIPTCODE_COUNT - 1;
3161
        scriptFunctionList[f].ptr.jumpTablePtr  = LEGACY_v4_JUMPTABLE_COUNT - 1;
3162
    }
3163

3164
    SetObjectTypeName("Blank Object", OBJ_TYPE_BLANKOBJECT);
3165
}
3166

3167
void RSDK::Legacy::v4::ProcessScript(int32 scriptCodeStart, int32 jumpTableStart, uint8 scriptEvent)
3168
{
3169
    bool running        = true;
3170
    int32 scriptCodePtr = scriptCodeStart;
3171
    jumpTableStackPos   = 0;
3172
    functionStackPos    = 0;
3173
    foreachStackPos     = 0;
3174

3175
    while (running) {
3176
        int32 opcode           = scriptCode[scriptCodePtr++];
3177
        int32 opcodeSize       = functions[opcode].opcodeSize;
3178
        int32 scriptCodeOffset = scriptCodePtr;
3179

3180
        scriptText[0] = '\0';
3181

3182
        // Get Values
3183
        for (int32 i = 0; i < opcodeSize; ++i) {
3184
            int32 opcodeType = scriptCode[scriptCodePtr++];
3185

3186
            if (opcodeType == SCRIPTVAR_VAR) {
3187
                int32 arrayVal = 0;
3188
                switch (scriptCode[scriptCodePtr++]) {
3189
                    case VARARR_NONE: arrayVal = objectEntityPos; break;
3190
                    case VARARR_ARRAY:
3191
                        if (scriptCode[scriptCodePtr++] == 1)
3192
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
3193
                        else
3194
                            arrayVal = scriptCode[scriptCodePtr++];
3195
                        break;
3196
                    case VARARR_ENTNOPLUS1:
3197
                        if (scriptCode[scriptCodePtr++] == 1)
3198
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]] + objectEntityPos;
3199
                        else
3200
                            arrayVal = scriptCode[scriptCodePtr++] + objectEntityPos;
3201
                        break;
3202
                    case VARARR_ENTNOMINUS1:
3203
                        if (scriptCode[scriptCodePtr++] == 1)
3204
                            arrayVal = objectEntityPos - scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
3205
                        else
3206
                            arrayVal = objectEntityPos - scriptCode[scriptCodePtr++];
3207
                        break;
3208
                    default: break;
3209
                }
3210

3211
                // Variables
3212
                switch (scriptCode[scriptCodePtr++]) {
3213
                    default: break;
3214
                    case VAR_TEMP0: scriptEng.operands[i] = scriptEng.temp[0]; break;
3215
                    case VAR_TEMP1: scriptEng.operands[i] = scriptEng.temp[1]; break;
3216
                    case VAR_TEMP2: scriptEng.operands[i] = scriptEng.temp[2]; break;
3217
                    case VAR_TEMP3: scriptEng.operands[i] = scriptEng.temp[3]; break;
3218
                    case VAR_TEMP4: scriptEng.operands[i] = scriptEng.temp[4]; break;
3219
                    case VAR_TEMP5: scriptEng.operands[i] = scriptEng.temp[5]; break;
3220
                    case VAR_TEMP6: scriptEng.operands[i] = scriptEng.temp[6]; break;
3221
                    case VAR_TEMP7: scriptEng.operands[i] = scriptEng.temp[7]; break;
3222
                    case VAR_CHECKRESULT: scriptEng.operands[i] = scriptEng.checkResult; break;
3223
                    case VAR_ARRAYPOS0: scriptEng.operands[i] = scriptEng.arrayPosition[0]; break;
3224
                    case VAR_ARRAYPOS1: scriptEng.operands[i] = scriptEng.arrayPosition[1]; break;
3225
                    case VAR_ARRAYPOS2: scriptEng.operands[i] = scriptEng.arrayPosition[2]; break;
3226
                    case VAR_ARRAYPOS3: scriptEng.operands[i] = scriptEng.arrayPosition[3]; break;
3227
                    case VAR_ARRAYPOS4: scriptEng.operands[i] = scriptEng.arrayPosition[4]; break;
3228
                    case VAR_ARRAYPOS5: scriptEng.operands[i] = scriptEng.arrayPosition[5]; break;
3229
                    case VAR_ARRAYPOS6: scriptEng.operands[i] = scriptEng.arrayPosition[6]; break;
3230
                    case VAR_ARRAYPOS7: scriptEng.operands[i] = scriptEng.arrayPosition[7]; break;
3231
                    case VAR_GLOBAL: scriptEng.operands[i] = globalVariables[arrayVal].value; break;
3232
                    case VAR_LOCAL: scriptEng.operands[i] = scriptCode[arrayVal]; break;
3233
                    case VAR_OBJECTENTITYPOS: scriptEng.operands[i] = arrayVal; break;
3234
                    case VAR_OBJECTGROUPID: {
3235
                        scriptEng.operands[i] = objectEntityList[arrayVal].groupID;
3236
                        break;
3237
                    }
3238
                    case VAR_OBJECTTYPE: {
3239
                        scriptEng.operands[i] = objectEntityList[arrayVal].type;
3240
                        break;
3241
                    }
3242
                    case VAR_OBJECTPROPERTYVALUE: {
3243
                        scriptEng.operands[i] = objectEntityList[arrayVal].propertyValue;
3244
                        break;
3245
                    }
3246
                    case VAR_OBJECTXPOS: {
3247
                        scriptEng.operands[i] = objectEntityList[arrayVal].xpos;
3248
                        break;
3249
                    }
3250
                    case VAR_OBJECTYPOS: {
3251
                        scriptEng.operands[i] = objectEntityList[arrayVal].ypos;
3252
                        break;
3253
                    }
3254
                    case VAR_OBJECTIXPOS: {
3255
                        scriptEng.operands[i] = objectEntityList[arrayVal].xpos >> 16;
3256
                        break;
3257
                    }
3258
                    case VAR_OBJECTIYPOS: {
3259
                        scriptEng.operands[i] = objectEntityList[arrayVal].ypos >> 16;
3260
                        break;
3261
                    }
3262
                    case VAR_OBJECTXVEL: {
3263
                        scriptEng.operands[i] = objectEntityList[arrayVal].xvel;
3264
                        break;
3265
                    }
3266
                    case VAR_OBJECTYVEL: {
3267
                        scriptEng.operands[i] = objectEntityList[arrayVal].yvel;
3268
                        break;
3269
                    }
3270
                    case VAR_OBJECTSPEED: {
3271
                        scriptEng.operands[i] = objectEntityList[arrayVal].speed;
3272
                        break;
3273
                    }
3274
                    case VAR_OBJECTSTATE: {
3275
                        scriptEng.operands[i] = objectEntityList[arrayVal].state;
3276
                        break;
3277
                    }
3278
                    case VAR_OBJECTROTATION: {
3279
                        scriptEng.operands[i] = objectEntityList[arrayVal].rotation;
3280
                        break;
3281
                    }
3282
                    case VAR_OBJECTSCALE: {
3283
                        scriptEng.operands[i] = objectEntityList[arrayVal].scale;
3284
                        break;
3285
                    }
3286
                    case VAR_OBJECTPRIORITY: {
3287
                        scriptEng.operands[i] = objectEntityList[arrayVal].priority;
3288
                        break;
3289
                    }
3290
                    case VAR_OBJECTDRAWORDER: {
3291
                        scriptEng.operands[i] = objectEntityList[arrayVal].drawOrder;
3292
                        break;
3293
                    }
3294
                    case VAR_OBJECTDIRECTION: {
3295
                        scriptEng.operands[i] = objectEntityList[arrayVal].direction;
3296
                        break;
3297
                    }
3298
                    case VAR_OBJECTINKEFFECT: {
3299
                        scriptEng.operands[i] = objectEntityList[arrayVal].inkEffect;
3300
                        break;
3301
                    }
3302
                    case VAR_OBJECTALPHA: {
3303
                        scriptEng.operands[i] = objectEntityList[arrayVal].alpha;
3304
                        break;
3305
                    }
3306
                    case VAR_OBJECTFRAME: {
3307
                        scriptEng.operands[i] = objectEntityList[arrayVal].frame;
3308
                        break;
3309
                    }
3310
                    case VAR_OBJECTANIMATION: {
3311
                        scriptEng.operands[i] = objectEntityList[arrayVal].animation;
3312
                        break;
3313
                    }
3314
                    case VAR_OBJECTPREVANIMATION: {
3315
                        scriptEng.operands[i] = objectEntityList[arrayVal].prevAnimation;
3316
                        break;
3317
                    }
3318
                    case VAR_OBJECTANIMATIONSPEED: {
3319
                        scriptEng.operands[i] = objectEntityList[arrayVal].animationSpeed;
3320
                        break;
3321
                    }
3322
                    case VAR_OBJECTANIMATIONTIMER: {
3323
                        scriptEng.operands[i] = objectEntityList[arrayVal].animationTimer;
3324
                        break;
3325
                    }
3326
                    case VAR_OBJECTANGLE: {
3327
                        scriptEng.operands[i] = objectEntityList[arrayVal].angle;
3328
                        break;
3329
                    }
3330
                    case VAR_OBJECTLOOKPOSX: {
3331
                        scriptEng.operands[i] = objectEntityList[arrayVal].lookPosX;
3332
                        break;
3333
                    }
3334
                    case VAR_OBJECTLOOKPOSY: {
3335
                        scriptEng.operands[i] = objectEntityList[arrayVal].lookPosY;
3336
                        break;
3337
                    }
3338
                    case VAR_OBJECTCOLLISIONMODE: {
3339
                        scriptEng.operands[i] = objectEntityList[arrayVal].collisionMode;
3340
                        break;
3341
                    }
3342
                    case VAR_OBJECTCOLLISIONPLANE: {
3343
                        scriptEng.operands[i] = objectEntityList[arrayVal].collisionPlane;
3344
                        break;
3345
                    }
3346
                    case VAR_OBJECTCONTROLMODE: {
3347
                        scriptEng.operands[i] = objectEntityList[arrayVal].controlMode;
3348
                        break;
3349
                    }
3350
                    case VAR_OBJECTCONTROLLOCK: {
3351
                        scriptEng.operands[i] = objectEntityList[arrayVal].controlLock;
3352
                        break;
3353
                    }
3354
                    case VAR_OBJECTPUSHING: {
3355
                        scriptEng.operands[i] = objectEntityList[arrayVal].pushing;
3356
                        break;
3357
                    }
3358
                    case VAR_OBJECTVISIBLE: {
3359
                        scriptEng.operands[i] = objectEntityList[arrayVal].visible;
3360
                        break;
3361
                    }
3362
                    case VAR_OBJECTTILECOLLISIONS: {
3363
                        scriptEng.operands[i] = objectEntityList[arrayVal].tileCollisions;
3364
                        break;
3365
                    }
3366
                    case VAR_OBJECTINTERACTION: {
3367
                        scriptEng.operands[i] = objectEntityList[arrayVal].objectInteractions;
3368
                        break;
3369
                    }
3370
                    case VAR_OBJECTGRAVITY: {
3371
                        scriptEng.operands[i] = objectEntityList[arrayVal].gravity;
3372
                        break;
3373
                    }
3374
                    case VAR_OBJECTUP: {
3375
                        scriptEng.operands[i] = objectEntityList[arrayVal].up;
3376
                        break;
3377
                    }
3378
                    case VAR_OBJECTDOWN: {
3379
                        scriptEng.operands[i] = objectEntityList[arrayVal].down;
3380
                        break;
3381
                    }
3382
                    case VAR_OBJECTLEFT: {
3383
                        scriptEng.operands[i] = objectEntityList[arrayVal].left;
3384
                        break;
3385
                    }
3386
                    case VAR_OBJECTRIGHT: {
3387
                        scriptEng.operands[i] = objectEntityList[arrayVal].right;
3388
                        break;
3389
                    }
3390
                    case VAR_OBJECTJUMPPRESS: {
3391
                        scriptEng.operands[i] = objectEntityList[arrayVal].jumpPress;
3392
                        break;
3393
                    }
3394
                    case VAR_OBJECTJUMPHOLD: {
3395
                        scriptEng.operands[i] = objectEntityList[arrayVal].jumpHold;
3396
                        break;
3397
                    }
3398
                    case VAR_OBJECTSCROLLTRACKING: {
3399
                        scriptEng.operands[i] = objectEntityList[arrayVal].scrollTracking;
3400
                        break;
3401
                    }
3402
                    case VAR_OBJECTFLOORSENSORL: {
3403
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[0];
3404
                        break;
3405
                    }
3406
                    case VAR_OBJECTFLOORSENSORC: {
3407
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[1];
3408
                        break;
3409
                    }
3410
                    case VAR_OBJECTFLOORSENSORR: {
3411
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[2];
3412
                        break;
3413
                    }
3414
                    case VAR_OBJECTFLOORSENSORLC: {
3415
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[3];
3416
                        break;
3417
                    }
3418
                    case VAR_OBJECTFLOORSENSORRC: {
3419
                        scriptEng.operands[i] = objectEntityList[arrayVal].floorSensors[4];
3420
                        break;
3421
                    }
3422
                    case VAR_OBJECTCOLLISIONLEFT: {
3423
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3424
                        Entity *ent             = &objectEntityList[arrayVal];
3425
                        if (animFile) {
3426
                            int32 h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3427

3428
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].left[0];
3429
                        }
3430
                        else {
3431
                            scriptEng.operands[i] = 0;
3432
                        }
3433
                        break;
3434
                    }
3435
                    case VAR_OBJECTCOLLISIONTOP: {
3436
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3437
                        Entity *ent             = &objectEntityList[arrayVal];
3438
                        if (animFile) {
3439
                            int32 h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3440

3441
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].top[0];
3442
                        }
3443
                        else {
3444
                            scriptEng.operands[i] = 0;
3445
                        }
3446
                        break;
3447
                    }
3448
                    case VAR_OBJECTCOLLISIONRIGHT: {
3449
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3450
                        Entity *ent             = &objectEntityList[arrayVal];
3451
                        if (animFile) {
3452
                            int32 h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3453

3454
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].right[0];
3455
                        }
3456
                        else {
3457
                            scriptEng.operands[i] = 0;
3458
                        }
3459
                        break;
3460
                    }
3461
                    case VAR_OBJECTCOLLISIONBOTTOM: {
3462
                        AnimationFile *animFile = objectScriptList[objectEntityList[arrayVal].type].animFile;
3463
                        Entity *ent             = &objectEntityList[arrayVal];
3464
                        if (animFile) {
3465
                            int32 h = animFrames[animationList[animFile->aniListOffset + ent->animation].frameListOffset + ent->frame].hitboxID;
3466

3467
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].bottom[0];
3468
                        }
3469
                        else {
3470
                            scriptEng.operands[i] = 0;
3471
                        }
3472
                        break;
3473
                    }
3474
                    case VAR_OBJECTOUTOFBOUNDS: {
3475
                        int32 boundX1_2P = -(0x200 << 16);
3476
                        int32 boundX2_2P = (0x200 << 16);
3477
                        int32 boundX3_2P = -(0x180 << 16);
3478
                        int32 boundX4_2P = (0x180 << 16);
3479

3480
                        int32 boundY1_2P = -(0x180 << 16);
3481
                        int32 boundY2_2P = (0x180 << 16);
3482
                        int32 boundY3_2P = -(0x100 << 16);
3483
                        int32 boundY4_2P = (0x100 << 16);
3484

3485
                        Entity *entPtr = &objectEntityList[arrayVal];
3486
                        int32 x        = entPtr->xpos >> 16;
3487
                        int32 y        = entPtr->ypos >> 16;
3488

3489
                        if (entPtr->priority == PRIORITY_BOUNDS_SMALL || entPtr->priority == PRIORITY_ACTIVE_SMALL) {
3490
                            if (stageMode == STAGEMODE_2P) {
3491
                                x = entPtr->xpos;
3492
                                y = entPtr->ypos;
3493

3494
                                int32 boundL_P1 = objectEntityList[0].xpos + boundX3_2P;
3495
                                int32 boundR_P1 = objectEntityList[0].xpos + boundX4_2P;
3496
                                int32 boundT_P1 = objectEntityList[0].ypos + boundY3_2P;
3497
                                int32 boundB_P1 = objectEntityList[0].ypos + boundY4_2P;
3498

3499
                                int32 boundL_P2 = objectEntityList[1].xpos + boundX3_2P;
3500
                                int32 boundR_P2 = objectEntityList[1].xpos + boundX4_2P;
3501
                                int32 boundT_P2 = objectEntityList[1].ypos + boundY3_2P;
3502
                                int32 boundB_P2 = objectEntityList[1].ypos + boundY4_2P;
3503

3504
                                bool32 oobP1 = scriptEng.operands[i] = x <= boundL_P1 || x >= boundR_P1 || y <= boundT_P1 || y >= boundB_P1;
3505
                                bool32 oobP2 = scriptEng.operands[i] = x <= boundL_P2 || x >= boundR_P2 || y <= boundT_P2 || y >= boundB_P2;
3506

3507
                                scriptEng.operands[i] = oobP1 && oobP2;
3508
                            }
3509
                            else {
3510
                                int32 boundL = xScrollOffset - OBJECT_BORDER_X3;
3511
                                int32 boundR = xScrollOffset + OBJECT_BORDER_X4;
3512
                                int32 boundT = yScrollOffset - OBJECT_BORDER_Y3;
3513
                                int32 boundB = yScrollOffset + OBJECT_BORDER_Y4;
3514

3515
                                scriptEng.operands[i] = x <= boundL || x >= boundR || y <= boundT || y >= boundB;
3516
                            }
3517
                        }
3518
                        else {
3519
                            if (stageMode == STAGEMODE_2P) {
3520
                                x = entPtr->xpos;
3521
                                y = entPtr->ypos;
3522

3523
                                int32 boundL_P1 = objectEntityList[0].xpos + boundX1_2P;
3524
                                int32 boundR_P1 = objectEntityList[0].xpos + boundX2_2P;
3525
                                int32 boundT_P1 = objectEntityList[0].ypos + boundY1_2P;
3526
                                int32 boundB_P1 = objectEntityList[0].ypos + boundY2_2P;
3527

3528
                                int32 boundL_P2 = objectEntityList[1].xpos + boundX1_2P;
3529
                                int32 boundR_P2 = objectEntityList[1].xpos + boundX2_2P;
3530
                                int32 boundT_P2 = objectEntityList[1].ypos + boundY1_2P;
3531
                                int32 boundB_P2 = objectEntityList[1].ypos + boundY2_2P;
3532

3533
                                bool32 oobP1 = scriptEng.operands[i] = x <= boundL_P1 || x >= boundR_P1 || y <= boundT_P1 || y >= boundB_P1;
3534
                                bool32 oobP2 = scriptEng.operands[i] = x <= boundL_P2 || x >= boundR_P2 || y <= boundT_P2 || y >= boundB_P2;
3535

3536
                                scriptEng.operands[i] = oobP1 && oobP2;
3537
                            }
3538
                            else {
3539
                                int32 boundL = xScrollOffset - OBJECT_BORDER_X1;
3540
                                int32 boundR = xScrollOffset + OBJECT_BORDER_X2;
3541
                                int32 boundT = yScrollOffset - OBJECT_BORDER_Y1;
3542
                                int32 boundB = yScrollOffset + OBJECT_BORDER_Y2;
3543

3544
                                scriptEng.operands[i] = x <= boundL || x >= boundR || y <= boundT || y >= boundB;
3545
                            }
3546
                        }
3547
                        break;
3548
                    }
3549
                    case VAR_OBJECTSPRITESHEET: {
3550
                        scriptEng.operands[i] = objectScriptList[objectEntityList[arrayVal].type].spriteSheetID;
3551
                        break;
3552
                    }
3553
                    case VAR_OBJECTVALUE0: {
3554
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[0];
3555
                        break;
3556
                    }
3557
                    case VAR_OBJECTVALUE1: {
3558
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[1];
3559
                        break;
3560
                    }
3561
                    case VAR_OBJECTVALUE2: {
3562
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[2];
3563
                        break;
3564
                    }
3565
                    case VAR_OBJECTVALUE3: {
3566
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[3];
3567
                        break;
3568
                    }
3569
                    case VAR_OBJECTVALUE4: {
3570
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[4];
3571
                        break;
3572
                    }
3573
                    case VAR_OBJECTVALUE5: {
3574
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[5];
3575
                        break;
3576
                    }
3577
                    case VAR_OBJECTVALUE6: {
3578
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[6];
3579
                        break;
3580
                    }
3581
                    case VAR_OBJECTVALUE7: {
3582
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[7];
3583
                        break;
3584
                    }
3585
                    case VAR_OBJECTVALUE8: {
3586
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[8];
3587
                        break;
3588
                    }
3589
                    case VAR_OBJECTVALUE9: {
3590
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[9];
3591
                        break;
3592
                    }
3593
                    case VAR_OBJECTVALUE10: {
3594
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[10];
3595
                        break;
3596
                    }
3597
                    case VAR_OBJECTVALUE11: {
3598
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[11];
3599
                        break;
3600
                    }
3601
                    case VAR_OBJECTVALUE12: {
3602
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[12];
3603
                        break;
3604
                    }
3605
                    case VAR_OBJECTVALUE13: {
3606
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[13];
3607
                        break;
3608
                    }
3609
                    case VAR_OBJECTVALUE14: {
3610
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[14];
3611
                        break;
3612
                    }
3613
                    case VAR_OBJECTVALUE15: {
3614
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[15];
3615
                        break;
3616
                    }
3617
                    case VAR_OBJECTVALUE16: {
3618
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[16];
3619
                        break;
3620
                    }
3621
                    case VAR_OBJECTVALUE17: {
3622
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[17];
3623
                        break;
3624
                    }
3625
                    case VAR_OBJECTVALUE18: {
3626
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[18];
3627
                        break;
3628
                    }
3629
                    case VAR_OBJECTVALUE19: {
3630
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[19];
3631
                        break;
3632
                    }
3633
                    case VAR_OBJECTVALUE20: {
3634
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[20];
3635
                        break;
3636
                    }
3637
                    case VAR_OBJECTVALUE21: {
3638
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[21];
3639
                        break;
3640
                    }
3641
                    case VAR_OBJECTVALUE22: {
3642
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[22];
3643
                        break;
3644
                    }
3645
                    case VAR_OBJECTVALUE23: {
3646
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[23];
3647
                        break;
3648
                    }
3649
                    case VAR_OBJECTVALUE24: {
3650
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[24];
3651
                        break;
3652
                    }
3653
                    case VAR_OBJECTVALUE25: {
3654
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[25];
3655
                        break;
3656
                    }
3657
                    case VAR_OBJECTVALUE26: {
3658
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[26];
3659
                        break;
3660
                    }
3661
                    case VAR_OBJECTVALUE27: {
3662
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[27];
3663
                        break;
3664
                    }
3665
                    case VAR_OBJECTVALUE28: {
3666
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[28];
3667
                        break;
3668
                    }
3669
                    case VAR_OBJECTVALUE29: {
3670
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[29];
3671
                        break;
3672
                    }
3673
                    case VAR_OBJECTVALUE30: {
3674
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[30];
3675
                        break;
3676
                    }
3677
                    case VAR_OBJECTVALUE31: {
3678
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[31];
3679
                        break;
3680
                    }
3681
                    case VAR_OBJECTVALUE32: {
3682
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[32];
3683
                        break;
3684
                    }
3685
                    case VAR_OBJECTVALUE33: {
3686
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[33];
3687
                        break;
3688
                    }
3689
                    case VAR_OBJECTVALUE34: {
3690
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[34];
3691
                        break;
3692
                    }
3693
                    case VAR_OBJECTVALUE35: {
3694
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[35];
3695
                        break;
3696
                    }
3697
                    case VAR_OBJECTVALUE36: {
3698
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[36];
3699
                        break;
3700
                    }
3701
                    case VAR_OBJECTVALUE37: {
3702
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[37];
3703
                        break;
3704
                    }
3705
                    case VAR_OBJECTVALUE38: {
3706
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[38];
3707
                        break;
3708
                    }
3709
                    case VAR_OBJECTVALUE39: {
3710
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[39];
3711
                        break;
3712
                    }
3713
                    case VAR_OBJECTVALUE40: {
3714
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[40];
3715
                        break;
3716
                    }
3717
                    case VAR_OBJECTVALUE41: {
3718
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[41];
3719
                        break;
3720
                    }
3721
                    case VAR_OBJECTVALUE42: {
3722
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[42];
3723
                        break;
3724
                    }
3725
                    case VAR_OBJECTVALUE43: {
3726
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[43];
3727
                        break;
3728
                    }
3729
                    case VAR_OBJECTVALUE44: {
3730
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[44];
3731
                        break;
3732
                    }
3733
                    case VAR_OBJECTVALUE45: {
3734
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[45];
3735
                        break;
3736
                    }
3737
                    case VAR_OBJECTVALUE46: {
3738
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[46];
3739
                        break;
3740
                    }
3741
                    case VAR_OBJECTVALUE47: {
3742
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[47];
3743
                        break;
3744
                    }
3745
                    case VAR_STAGESTATE: scriptEng.operands[i] = stageMode; break;
3746
                    case VAR_STAGEACTIVELIST: scriptEng.operands[i] = sceneInfo.activeCategory; break;
3747
                    case VAR_STAGELISTPOS:
3748
                        scriptEng.operands[i] = sceneInfo.listPos - sceneInfo.listCategory[sceneInfo.activeCategory].sceneOffsetStart;
3749
                        break;
3750
                    case VAR_STAGETIMEENABLED: scriptEng.operands[i] = timeEnabled; break;
3751
                    case VAR_STAGEMILLISECONDS: scriptEng.operands[i] = stageMilliseconds; break;
3752
                    case VAR_STAGESECONDS: scriptEng.operands[i] = stageSeconds; break;
3753
                    case VAR_STAGEMINUTES: scriptEng.operands[i] = stageMinutes; break;
3754
                    case VAR_STAGEACTNUM: scriptEng.operands[i] = actID; break;
3755
                    case VAR_STAGEPAUSEENABLED: scriptEng.operands[i] = pauseEnabled; break;
3756
                    case VAR_STAGELISTSIZE: scriptEng.operands[i] = sceneInfo.listCategory[RSDK::sceneInfo.activeCategory].sceneCount; break;
3757
                    case VAR_STAGENEWXBOUNDARY1: scriptEng.operands[i] = newXBoundary1; break;
3758
                    case VAR_STAGENEWXBOUNDARY2: scriptEng.operands[i] = newXBoundary2; break;
3759
                    case VAR_STAGENEWYBOUNDARY1: scriptEng.operands[i] = newYBoundary1; break;
3760
                    case VAR_STAGENEWYBOUNDARY2: scriptEng.operands[i] = newYBoundary2; break;
3761
                    case VAR_STAGECURXBOUNDARY1: scriptEng.operands[i] = curXBoundary1; break;
3762
                    case VAR_STAGECURXBOUNDARY2: scriptEng.operands[i] = curXBoundary2; break;
3763
                    case VAR_STAGECURYBOUNDARY1: scriptEng.operands[i] = curYBoundary1; break;
3764
                    case VAR_STAGECURYBOUNDARY2: scriptEng.operands[i] = curYBoundary2; break;
3765
                    case VAR_STAGEDEFORMATIONDATA0: scriptEng.operands[i] = bgDeformationData0[arrayVal]; break;
3766
                    case VAR_STAGEDEFORMATIONDATA1: scriptEng.operands[i] = bgDeformationData1[arrayVal]; break;
3767
                    case VAR_STAGEDEFORMATIONDATA2: scriptEng.operands[i] = bgDeformationData2[arrayVal]; break;
3768
                    case VAR_STAGEDEFORMATIONDATA3: scriptEng.operands[i] = bgDeformationData3[arrayVal]; break;
3769
                    case VAR_STAGEWATERLEVEL: scriptEng.operands[i] = waterLevel; break;
3770
                    case VAR_STAGEACTIVELAYER: scriptEng.operands[i] = activeTileLayers[arrayVal]; break;
3771
                    case VAR_STAGEMIDPOINT: scriptEng.operands[i] = tLayerMidPoint; break;
3772
                    case VAR_STAGEPLAYERLISTPOS: scriptEng.operands[i] = playerListPos; break;
3773
                    case VAR_STAGEDEBUGMODE: scriptEng.operands[i] = debugMode; break;
3774
                    case VAR_STAGEENTITYPOS: scriptEng.operands[i] = objectEntityPos; break;
3775
                    case VAR_SCREENCAMERAENABLED: scriptEng.operands[i] = currentCamera->enabled; break;
3776
                    case VAR_SCREENCAMERATARGET: scriptEng.operands[i] = currentCamera->target; break;
3777
                    case VAR_SCREENCAMERASTYLE: scriptEng.operands[i] = currentCamera->style; break;
3778
                    case VAR_SCREENCAMERAX: scriptEng.operands[i] = currentCamera->xpos; break;
3779
                    case VAR_SCREENCAMERAY: scriptEng.operands[i] = currentCamera->ypos; break;
3780
                    case VAR_SCREENDRAWLISTSIZE: scriptEng.operands[i] = drawListEntries[arrayVal].listSize; break;
3781
                    case VAR_SCREENXCENTER: scriptEng.operands[i] = SCREEN_CENTERX; break;
3782
                    case VAR_SCREENYCENTER: scriptEng.operands[i] = SCREEN_YSIZE / 2; break;
3783
                    case VAR_SCREENXSIZE: scriptEng.operands[i] = SCREEN_XSIZE; break;
3784
                    case VAR_SCREENYSIZE: scriptEng.operands[i] = SCREEN_YSIZE; break;
3785
                    case VAR_SCREENXOFFSET: scriptEng.operands[i] = xScrollOffset; break;
3786
                    case VAR_SCREENYOFFSET: scriptEng.operands[i] = yScrollOffset; break;
3787
                    case VAR_SCREENSHAKEX: scriptEng.operands[i] = cameraShakeX; break;
3788
                    case VAR_SCREENSHAKEY: scriptEng.operands[i] = cameraShakeY; break;
3789
                    case VAR_SCREENADJUSTCAMERAY: scriptEng.operands[i] = currentCamera->adjustY; break;
3790
                    case VAR_TOUCHSCREENDOWN: scriptEng.operands[i] = touchInfo.down[arrayVal]; break;
3791
                    case VAR_TOUCHSCREENXPOS: scriptEng.operands[i] = (int32)(touchInfo.x[arrayVal] * SCREEN_XSIZE); break;
3792
                    case VAR_TOUCHSCREENYPOS: scriptEng.operands[i] = (int32)(touchInfo.y[arrayVal] * SCREEN_YSIZE); break;
3793
                    case VAR_MUSICVOLUME: scriptEng.operands[i] = musicVolume; break;
3794
                    case VAR_MUSICCURRENTTRACK: scriptEng.operands[i] = musicCurrentTrack; break;
3795
                    case VAR_MUSICPOSITION: scriptEng.operands[i] = 0; break;
3796
                    case VAR_KEYDOWNUP: scriptEng.operands[i] = controller[arrayVal].keyUp.down; break;
3797
                    case VAR_KEYDOWNDOWN: scriptEng.operands[i] = controller[arrayVal].keyDown.down; break;
3798
                    case VAR_KEYDOWNLEFT: scriptEng.operands[i] = controller[arrayVal].keyLeft.down; break;
3799
                    case VAR_KEYDOWNRIGHT: scriptEng.operands[i] = controller[arrayVal].keyRight.down; break;
3800
                    case VAR_KEYDOWNBUTTONA: scriptEng.operands[i] = controller[arrayVal].keyA.down; break;
3801
                    case VAR_KEYDOWNBUTTONB: scriptEng.operands[i] = controller[arrayVal].keyB.down; break;
3802
                    case VAR_KEYDOWNBUTTONC: scriptEng.operands[i] = controller[arrayVal].keyC.down; break;
3803
                    case VAR_KEYDOWNBUTTONX: scriptEng.operands[i] = controller[arrayVal].keyX.down; break;
3804
                    case VAR_KEYDOWNBUTTONY: scriptEng.operands[i] = controller[arrayVal].keyY.down; break;
3805
                    case VAR_KEYDOWNBUTTONZ: scriptEng.operands[i] = controller[arrayVal].keyZ.down; break;
3806
                    case VAR_KEYDOWNBUTTONL: scriptEng.operands[i] = triggerL[arrayVal].keyBumper.down; break;
3807
                    case VAR_KEYDOWNBUTTONR: scriptEng.operands[i] = triggerR[arrayVal].keyBumper.down; break;
3808
                    case VAR_KEYDOWNSTART: scriptEng.operands[i] = controller[arrayVal].keyStart.down; break;
3809
                    case VAR_KEYDOWNSELECT: scriptEng.operands[i] = controller[arrayVal].keySelect.down; break;
3810
                    case VAR_KEYPRESSUP: scriptEng.operands[i] = controller[arrayVal].keyUp.press; break;
3811
                    case VAR_KEYPRESSDOWN: scriptEng.operands[i] = controller[arrayVal].keyDown.press; break;
3812
                    case VAR_KEYPRESSLEFT: scriptEng.operands[i] = controller[arrayVal].keyLeft.press; break;
3813
                    case VAR_KEYPRESSRIGHT: scriptEng.operands[i] = controller[arrayVal].keyRight.press; break;
3814
                    case VAR_KEYPRESSBUTTONA: scriptEng.operands[i] = controller[arrayVal].keyA.press; break;
3815
                    case VAR_KEYPRESSBUTTONB: scriptEng.operands[i] = controller[arrayVal].keyB.press; break;
3816
                    case VAR_KEYPRESSBUTTONC: scriptEng.operands[i] = controller[arrayVal].keyC.press; break;
3817
                    case VAR_KEYPRESSBUTTONX: scriptEng.operands[i] = controller[arrayVal].keyX.press; break;
3818
                    case VAR_KEYPRESSBUTTONY: scriptEng.operands[i] = controller[arrayVal].keyY.press; break;
3819
                    case VAR_KEYPRESSBUTTONZ: scriptEng.operands[i] = controller[arrayVal].keyZ.press; break;
3820
                    case VAR_KEYPRESSBUTTONL: scriptEng.operands[i] = triggerL[arrayVal].keyBumper.down; break;
3821
                    case VAR_KEYPRESSBUTTONR: scriptEng.operands[i] = triggerR[arrayVal].keyBumper.down; break;
3822
                    case VAR_KEYPRESSSTART: scriptEng.operands[i] = controller[arrayVal].keyStart.press; break;
3823
                    case VAR_KEYPRESSSELECT: scriptEng.operands[i] = controller[arrayVal].keySelect.press; break;
3824
                    case VAR_MENU1SELECTION: scriptEng.operands[i] = gameMenu[0].selection1; break;
3825
                    case VAR_MENU2SELECTION: scriptEng.operands[i] = gameMenu[1].selection1; break;
3826
                    case VAR_TILELAYERXSIZE: scriptEng.operands[i] = stageLayouts[arrayVal].xsize; break;
3827
                    case VAR_TILELAYERYSIZE: scriptEng.operands[i] = stageLayouts[arrayVal].ysize; break;
3828
                    case VAR_TILELAYERTYPE: scriptEng.operands[i] = stageLayouts[arrayVal].type; break;
3829
                    case VAR_TILELAYERANGLE: scriptEng.operands[i] = stageLayouts[arrayVal].angle; break;
3830
                    case VAR_TILELAYERXPOS: scriptEng.operands[i] = stageLayouts[arrayVal].xpos; break;
3831
                    case VAR_TILELAYERYPOS: scriptEng.operands[i] = stageLayouts[arrayVal].ypos; break;
3832
                    case VAR_TILELAYERZPOS: scriptEng.operands[i] = stageLayouts[arrayVal].zpos; break;
3833
                    case VAR_TILELAYERPARALLAXFACTOR: scriptEng.operands[i] = stageLayouts[arrayVal].parallaxFactor; break;
3834
                    case VAR_TILELAYERSCROLLSPEED: scriptEng.operands[i] = stageLayouts[arrayVal].scrollSpeed; break;
3835
                    case VAR_TILELAYERSCROLLPOS: scriptEng.operands[i] = stageLayouts[arrayVal].scrollPos; break;
3836
                    case VAR_TILELAYERDEFORMATIONOFFSET: scriptEng.operands[i] = stageLayouts[arrayVal].deformationOffset; break;
3837
                    case VAR_TILELAYERDEFORMATIONOFFSETW: scriptEng.operands[i] = stageLayouts[arrayVal].deformationOffsetW; break;
3838
                    case VAR_HPARALLAXPARALLAXFACTOR: scriptEng.operands[i] = hParallax.parallaxFactor[arrayVal]; break;
3839
                    case VAR_HPARALLAXSCROLLSPEED: scriptEng.operands[i] = hParallax.scrollSpeed[arrayVal]; break;
3840
                    case VAR_HPARALLAXSCROLLPOS: scriptEng.operands[i] = hParallax.scrollPos[arrayVal]; break;
3841
                    case VAR_VPARALLAXPARALLAXFACTOR: scriptEng.operands[i] = vParallax.parallaxFactor[arrayVal]; break;
3842
                    case VAR_VPARALLAXSCROLLSPEED: scriptEng.operands[i] = vParallax.scrollSpeed[arrayVal]; break;
3843
                    case VAR_VPARALLAXSCROLLPOS: scriptEng.operands[i] = vParallax.scrollPos[arrayVal]; break;
3844
                    case VAR_SCENE3DVERTEXCOUNT: scriptEng.operands[i] = vertexCount; break;
3845
                    case VAR_SCENE3DFACECOUNT: scriptEng.operands[i] = faceCount; break;
3846
                    case VAR_SCENE3DPROJECTIONX: scriptEng.operands[i] = projectionX; break;
3847
                    case VAR_SCENE3DPROJECTIONY: scriptEng.operands[i] = projectionY; break;
3848
                    case VAR_SCENE3DFOGCOLOR: scriptEng.operands[i] = fogColor; break;
3849
                    case VAR_SCENE3DFOGSTRENGTH: scriptEng.operands[i] = fogStrength; break;
3850
                    case VAR_VERTEXBUFFERX: scriptEng.operands[i] = vertexBuffer[arrayVal].x; break;
3851
                    case VAR_VERTEXBUFFERY: scriptEng.operands[i] = vertexBuffer[arrayVal].y; break;
3852
                    case VAR_VERTEXBUFFERZ: scriptEng.operands[i] = vertexBuffer[arrayVal].z; break;
3853
                    case VAR_VERTEXBUFFERU: scriptEng.operands[i] = vertexBuffer[arrayVal].u; break;
3854
                    case VAR_VERTEXBUFFERV: scriptEng.operands[i] = vertexBuffer[arrayVal].v; break;
3855
                    case VAR_FACEBUFFERA: scriptEng.operands[i] = faceBuffer[arrayVal].a; break;
3856
                    case VAR_FACEBUFFERB: scriptEng.operands[i] = faceBuffer[arrayVal].b; break;
3857
                    case VAR_FACEBUFFERC: scriptEng.operands[i] = faceBuffer[arrayVal].c; break;
3858
                    case VAR_FACEBUFFERD: scriptEng.operands[i] = faceBuffer[arrayVal].d; break;
3859
                    case VAR_FACEBUFFERFLAG: scriptEng.operands[i] = faceBuffer[arrayVal].flag; break;
3860
                    case VAR_FACEBUFFERCOLOR: scriptEng.operands[i] = faceBuffer[arrayVal].color; break;
3861
                    case VAR_SAVERAM: scriptEng.operands[i] = saveRAM[arrayVal]; break;
3862
                    case VAR_ENGINESTATE: scriptEng.operands[i] = gameMode; break;
3863
                    case VAR_ENGINELANGUAGE: scriptEng.operands[i] = language; break;
3864
                    case VAR_ENGINEONLINEACTIVE: scriptEng.operands[i] = onlineActive; break;
3865
                    case VAR_ENGINESFXVOLUME: scriptEng.operands[i] = sfxVolume; break;
3866
                    case VAR_ENGINEBGMVOLUME: scriptEng.operands[i] = bgmVolume; break;
3867
                    case VAR_ENGINETRIALMODE: scriptEng.operands[i] = trialMode; break;
3868
                    case VAR_ENGINEDEVICETYPE: scriptEng.operands[i] = deviceType; break;
3869

3870
                    // Origins Extras
3871
                    case VAR_SCREENCURRENTID: scriptEng.operands[i] = sceneInfo.currentScreenID; break;
3872
                    case VAR_CAMERAENABLED: scriptEng.operands[i] = cameras[arrayVal].enabled; break;
3873
                    case VAR_CAMERATARGET: scriptEng.operands[i] = cameras[arrayVal].target; break;
3874
                    case VAR_CAMERASTYLE: scriptEng.operands[i] = cameras[arrayVal].style; break;
3875
                    case VAR_CAMERAXPOS: scriptEng.operands[i] = cameras[arrayVal].xpos; break;
3876
                    case VAR_CAMERAYPOS: scriptEng.operands[i] = cameras[arrayVal].ypos; break;
3877
                    case VAR_CAMERAADJUSTY: scriptEng.operands[i] = cameras[arrayVal].adjustY; break;
3878

3879
#if LEGACY_RETRO_USE_HAPTICS
3880
                    case VAR_HAPTICSENABLED: scriptEng.operands[i] = hapticsEnabled; break;
3881
#endif
3882
                }
3883
            }
3884
            else if (opcodeType == SCRIPTVAR_INTCONST) { // int32 constant
3885
                scriptEng.operands[i] = scriptCode[scriptCodePtr++];
3886
            }
3887
            else if (opcodeType == SCRIPTVAR_STRCONST) { // string constant
3888
                int32 strLen       = scriptCode[scriptCodePtr++];
3889
                scriptText[strLen] = 0;
3890
                for (int32 c = 0; c < strLen; ++c) {
3891
                    switch (c % 4) {
3892
                        case 0: {
3893
                            scriptText[c] = scriptCode[scriptCodePtr] >> 24;
3894
                            break;
3895
                        }
3896
                        case 1: {
3897
                            scriptText[c] = (0xFFFFFF & scriptCode[scriptCodePtr]) >> 16;
3898
                            break;
3899
                        }
3900
                        case 2: {
3901
                            scriptText[c] = (0xFFFF & scriptCode[scriptCodePtr]) >> 8;
3902
                            break;
3903
                        }
3904
                        case 3: {
3905
                            scriptText[c] = scriptCode[scriptCodePtr++];
3906
                            break;
3907
                        }
3908
                        default: break;
3909
                    }
3910
                }
3911
                scriptCodePtr++;
3912
            }
3913
        }
3914

3915
        ObjectScript *scriptInfo = &objectScriptList[objectEntityList[objectEntityPos].type];
3916
        Entity *entity           = &objectEntityList[objectEntityPos];
3917
        SpriteFrame *spriteFrame = nullptr;
3918

3919
        // Functions
3920
        switch (opcode) {
3921
            default: break;
3922
            case FUNC_END: running = false; break;
3923
            case FUNC_EQUAL: scriptEng.operands[0] = scriptEng.operands[1]; break;
3924
            case FUNC_ADD: scriptEng.operands[0] += scriptEng.operands[1]; break;
3925
            case FUNC_SUB: scriptEng.operands[0] -= scriptEng.operands[1]; break;
3926
            case FUNC_INC: ++scriptEng.operands[0]; break;
3927
            case FUNC_DEC: --scriptEng.operands[0]; break;
3928
            case FUNC_MUL: scriptEng.operands[0] *= scriptEng.operands[1]; break;
3929
            case FUNC_DIV: scriptEng.operands[0] /= scriptEng.operands[1]; break;
3930
            case FUNC_SHR: scriptEng.operands[0] >>= scriptEng.operands[1]; break;
3931
            case FUNC_SHL: scriptEng.operands[0] <<= scriptEng.operands[1]; break;
3932
            case FUNC_AND: scriptEng.operands[0] &= scriptEng.operands[1]; break;
3933
            case FUNC_OR: scriptEng.operands[0] |= scriptEng.operands[1]; break;
3934
            case FUNC_XOR: scriptEng.operands[0] ^= scriptEng.operands[1]; break;
3935
            case FUNC_MOD: scriptEng.operands[0] %= scriptEng.operands[1]; break;
3936
            case FUNC_FLIPSIGN: scriptEng.operands[0] = -scriptEng.operands[0]; break;
3937
            case FUNC_CHECKEQUAL:
3938
                scriptEng.checkResult = scriptEng.operands[0] == scriptEng.operands[1];
3939
                opcodeSize            = 0;
3940
                break;
3941
            case FUNC_CHECKGREATER:
3942
                scriptEng.checkResult = scriptEng.operands[0] > scriptEng.operands[1];
3943
                opcodeSize            = 0;
3944
                break;
3945
            case FUNC_CHECKLOWER:
3946
                scriptEng.checkResult = scriptEng.operands[0] < scriptEng.operands[1];
3947
                opcodeSize            = 0;
3948
                break;
3949
            case FUNC_CHECKNOTEQUAL:
3950
                scriptEng.checkResult = scriptEng.operands[0] != scriptEng.operands[1];
3951
                opcodeSize            = 0;
3952
                break;
3953
            case FUNC_IFEQUAL:
3954
                if (scriptEng.operands[1] != scriptEng.operands[2])
3955
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
3956
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
3957
                opcodeSize                          = 0;
3958
                break;
3959
            case FUNC_IFGREATER:
3960
                if (scriptEng.operands[1] <= scriptEng.operands[2])
3961
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
3962
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
3963
                opcodeSize                          = 0;
3964
                break;
3965
            case FUNC_IFGREATEROREQUAL:
3966
                if (scriptEng.operands[1] < scriptEng.operands[2])
3967
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
3968
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
3969
                opcodeSize                          = 0;
3970
                break;
3971
            case FUNC_IFLOWER:
3972
                if (scriptEng.operands[1] >= scriptEng.operands[2])
3973
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
3974
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
3975
                opcodeSize                          = 0;
3976
                break;
3977
            case FUNC_IFLOWEROREQUAL:
3978
                if (scriptEng.operands[1] > scriptEng.operands[2])
3979
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
3980
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
3981
                opcodeSize                          = 0;
3982
                break;
3983
            case FUNC_IFNOTEQUAL:
3984
                if (scriptEng.operands[1] == scriptEng.operands[2])
3985
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
3986
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
3987
                opcodeSize                          = 0;
3988
                break;
3989
            case FUNC_ELSE:
3990
                opcodeSize    = 0;
3991
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--] + 1];
3992
                break;
3993
            case FUNC_ENDIF:
3994
                opcodeSize = 0;
3995
                --jumpTableStackPos;
3996
                break;
3997
            case FUNC_WEQUAL:
3998
                if (scriptEng.operands[1] != scriptEng.operands[2])
3999
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4000
                else
4001
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4002
                opcodeSize = 0;
4003
                break;
4004
            case FUNC_WGREATER:
4005
                if (scriptEng.operands[1] <= scriptEng.operands[2])
4006
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4007
                else
4008
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4009
                opcodeSize = 0;
4010
                break;
4011
            case FUNC_WGREATEROREQUAL:
4012
                if (scriptEng.operands[1] < scriptEng.operands[2])
4013
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4014
                else
4015
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4016
                opcodeSize = 0;
4017
                break;
4018
            case FUNC_WLOWER:
4019
                if (scriptEng.operands[1] >= scriptEng.operands[2])
4020
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4021
                else
4022
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4023
                opcodeSize = 0;
4024
                break;
4025
            case FUNC_WLOWEROREQUAL:
4026
                if (scriptEng.operands[1] > scriptEng.operands[2])
4027
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4028
                else
4029
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4030
                opcodeSize = 0;
4031
                break;
4032
            case FUNC_WNOTEQUAL:
4033
                if (scriptEng.operands[1] == scriptEng.operands[2])
4034
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4035
                else
4036
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4037
                opcodeSize = 0;
4038
                break;
4039
            case FUNC_LOOP:
4040
                opcodeSize    = 0;
4041
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--]];
4042
                break;
4043
            case FUNC_FOREACHACTIVE: {
4044
                int32 groupID = scriptEng.operands[1];
4045
                if (groupID < LEGACY_v4_TYPEGROUP_COUNT) {
4046
                    int32 loop                    = foreachStack[++foreachStackPos] + 1;
4047
                    foreachStack[foreachStackPos] = loop;
4048
                    if (loop >= objectTypeGroupList[groupID].listSize) {
4049
                        opcodeSize                      = 0;
4050
                        foreachStack[foreachStackPos--] = -1;
4051
                        scriptCodePtr                   = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4052
                        break;
4053
                    }
4054
                    else {
4055
                        scriptEng.operands[2]               = objectTypeGroupList[groupID].entityRefs[loop];
4056
                        jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4057
                    }
4058
                }
4059
                else {
4060
                    opcodeSize    = 0;
4061
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4062
                }
4063
                break;
4064
            }
4065
            case FUNC_FOREACHALL: {
4066
                int32 objType = scriptEng.operands[1];
4067
                if (objType < LEGACY_v4_OBJECT_COUNT) {
4068
                    int32 loop                    = foreachStack[++foreachStackPos] + 1;
4069
                    foreachStack[foreachStackPos] = loop;
4070

4071
                    if (scriptEvent == EVENT_SETUP) {
4072
                        while (true) {
4073
                            if (loop >= LEGACY_v4_TEMPENTITY_START) {
4074
                                opcodeSize                      = 0;
4075
                                foreachStack[foreachStackPos--] = -1;
4076
                                scriptCodePtr                   = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4077
                                break;
4078
                            }
4079
                            else if (objType == objectEntityList[loop].type) {
4080
                                scriptEng.operands[2]               = loop;
4081
                                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4082
                                break;
4083
                            }
4084
                            else {
4085
                                foreachStack[foreachStackPos] = ++loop;
4086
                            }
4087
                        }
4088
                    }
4089
                    else {
4090
                        while (true) {
4091
                            if (loop >= LEGACY_v4_ENTITY_COUNT) {
4092
                                opcodeSize                      = 0;
4093
                                foreachStack[foreachStackPos--] = -1;
4094
                                scriptCodePtr                   = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4095
                                break;
4096
                            }
4097
                            else if (objType == objectEntityList[loop].type) {
4098
                                scriptEng.operands[2]               = loop;
4099
                                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4100
                                break;
4101
                            }
4102
                            else {
4103
                                foreachStack[foreachStackPos] = ++loop;
4104
                            }
4105
                        }
4106
                    }
4107
                }
4108
                else {
4109
                    opcodeSize    = 0;
4110
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
4111
                }
4112
                break;
4113
            }
4114
            case FUNC_NEXT:
4115
                opcodeSize    = 0;
4116
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--]];
4117
                --foreachStackPos;
4118
                break;
4119
            case FUNC_SWITCH:
4120
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
4121
                if (scriptEng.operands[1] < jumpTable[jumpTableStart + scriptEng.operands[0]]
4122
                    || scriptEng.operands[1] > jumpTable[jumpTableStart + scriptEng.operands[0] + 1])
4123
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 2];
4124
                else
4125
                    scriptCodePtr = scriptCodeStart
4126
                                    + jumpTable[jumpTableStart + scriptEng.operands[0] + 4
4127
                                                + (scriptEng.operands[1] - jumpTable[jumpTableStart + scriptEng.operands[0]])];
4128
                opcodeSize = 0;
4129
                break;
4130
            case FUNC_BREAK:
4131
                opcodeSize    = 0;
4132
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--] + 3];
4133
                break;
4134
            case FUNC_ENDSWITCH:
4135
                opcodeSize = 0;
4136
                --jumpTableStackPos;
4137
                break;
4138
            case FUNC_RAND: scriptEng.operands[0] = rand() % scriptEng.operands[1]; break;
4139
            case FUNC_SIN: {
4140
                scriptEng.operands[0] = Sin512(scriptEng.operands[1]);
4141
                break;
4142
            }
4143
            case FUNC_COS: {
4144
                scriptEng.operands[0] = Cos512(scriptEng.operands[1]);
4145
                break;
4146
            }
4147
            case FUNC_SIN256: {
4148
                scriptEng.operands[0] = Sin256(scriptEng.operands[1]);
4149
                break;
4150
            }
4151
            case FUNC_COS256: {
4152
                scriptEng.operands[0] = Cos256(scriptEng.operands[1]);
4153
                break;
4154
            }
4155
            case FUNC_ATAN2: {
4156
                scriptEng.operands[0] = ArcTanLookup(scriptEng.operands[1], scriptEng.operands[2]);
4157
                break;
4158
            }
4159
            case FUNC_INTERPOLATE:
4160
                scriptEng.operands[0] =
4161
                    (scriptEng.operands[2] * (0x100 - scriptEng.operands[3]) + scriptEng.operands[3] * scriptEng.operands[1]) >> 8;
4162
                break;
4163
            case FUNC_INTERPOLATEXY:
4164
                scriptEng.operands[0] =
4165
                    (scriptEng.operands[3] * (0x100 - scriptEng.operands[6]) >> 8) + ((scriptEng.operands[6] * scriptEng.operands[2]) >> 8);
4166
                scriptEng.operands[1] =
4167
                    (scriptEng.operands[5] * (0x100 - scriptEng.operands[6]) >> 8) + (scriptEng.operands[6] * scriptEng.operands[4] >> 8);
4168
                break;
4169
            case FUNC_LOADSPRITESHEET:
4170
                opcodeSize                = 0;
4171
                scriptInfo->spriteSheetID = AddGraphicsFile(scriptText);
4172
                break;
4173
            case FUNC_REMOVESPRITESHEET:
4174
                opcodeSize = 0;
4175
                RemoveGraphicsFile(scriptText, -1);
4176
                break;
4177
            case FUNC_DRAWSPRITE:
4178
                opcodeSize  = 0;
4179
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4180
                DrawSprite((entity->xpos >> 16) - xScrollOffset + spriteFrame->pivotX, (entity->ypos >> 16) - yScrollOffset + spriteFrame->pivotY,
4181
                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4182
                break;
4183
            case FUNC_DRAWSPRITEXY:
4184
                opcodeSize  = 0;
4185
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4186
                DrawSprite((scriptEng.operands[1] >> 16) - xScrollOffset + spriteFrame->pivotX,
4187
                           (scriptEng.operands[2] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width, spriteFrame->height,
4188
                           spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4189
                break;
4190
            case FUNC_DRAWSPRITESCREENXY:
4191
                opcodeSize  = 0;
4192
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4193
                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY, spriteFrame->width,
4194
                           spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4195
                break;
4196
            case FUNC_DRAWTINTRECT:
4197
                opcodeSize = 0;
4198
                DrawTintRectangle(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
4199
                break;
4200
            case FUNC_DRAWNUMBERS: {
4201
                opcodeSize = 0;
4202
                int32 i    = 10;
4203
                if (scriptEng.operands[6]) {
4204
                    while (scriptEng.operands[4] > 0) {
4205
                        int32 frameID = scriptEng.operands[3] % i / (i / 10) + scriptEng.operands[0];
4206
                        spriteFrame   = &scriptFrames[scriptInfo->frameListOffset + frameID];
4207
                        DrawSprite(spriteFrame->pivotX + scriptEng.operands[1], spriteFrame->pivotY + scriptEng.operands[2], spriteFrame->width,
4208
                                   spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4209
                        scriptEng.operands[1] -= scriptEng.operands[5];
4210
                        i *= 10;
4211
                        --scriptEng.operands[4];
4212
                    }
4213
                }
4214
                else {
4215
                    int32 extra = 10;
4216
                    if (scriptEng.operands[3])
4217
                        extra = 10 * scriptEng.operands[3];
4218
                    while (scriptEng.operands[4] > 0) {
4219
                        if (extra >= i) {
4220
                            int32 frameID = scriptEng.operands[3] % i / (i / 10) + scriptEng.operands[0];
4221
                            spriteFrame   = &scriptFrames[scriptInfo->frameListOffset + frameID];
4222
                            DrawSprite(spriteFrame->pivotX + scriptEng.operands[1], spriteFrame->pivotY + scriptEng.operands[2], spriteFrame->width,
4223
                                       spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4224
                        }
4225
                        scriptEng.operands[1] -= scriptEng.operands[5];
4226
                        i *= 10;
4227
                        --scriptEng.operands[4];
4228
                    }
4229
                }
4230
                break;
4231
            }
4232
            case FUNC_DRAWACTNAME: {
4233
                opcodeSize   = 0;
4234
                int32 charID = 0;
4235
                switch (scriptEng.operands[3]) { // Draw Mode
4236
                    case 0:                      // Draw Word 1 (but aligned from the right instead of left)
4237
                        charID = 0;
4238

4239
                        for (charID = 0;; ++charID) {
4240
                            int32 nextChar = titleCardText[charID + 1];
4241
                            if (nextChar == '-' || !nextChar)
4242
                                break;
4243
                        }
4244

4245
                        while (charID >= 0) {
4246
                            int32 character = titleCardText[charID];
4247
                            if (character == ' ')
4248
                                character = -1; // special space char
4249
                            if (character == '-')
4250
                                character = 0;
4251
                            if (character >= '0' && character <= '9')
4252
                                character -= 22;
4253
                            if (character > '9' && character < 'f')
4254
                                character -= 'A';
4255

4256
                            if (character <= -1) {
4257
                                scriptEng.operands[1] -= scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4258
                            }
4259
                            else {
4260
                                character += scriptEng.operands[0];
4261
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4262

4263
                                scriptEng.operands[1] -= spriteFrame->width + scriptEng.operands[6];
4264

4265
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4266
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4267
                            }
4268
                            charID--;
4269
                        }
4270
                        break;
4271

4272
                    case 1: // Draw Word 1
4273
                        charID = 0;
4274

4275
                        // Draw the first letter as a capital letter, the rest are lowercase
4276
                        // (if scriptEng.operands[4] is trueotherwise they're all uppercase)
4277
                        if (scriptEng.operands[4] == 1 && titleCardText[charID] != 0) {
4278
                            int32 character = titleCardText[charID];
4279
                            if (character == ' ')
4280
                                character = 0;
4281
                            if (character == '-')
4282
                                character = 0;
4283
                            if (character >= '0' && character <= '9')
4284
                                character -= 22;
4285
                            if (character > '9' && character < 'f')
4286
                                character -= 'A';
4287

4288
                            if (character <= -1) {
4289
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4290
                            }
4291
                            else {
4292
                                character += scriptEng.operands[0];
4293
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4294
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4295
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4296
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4297
                            }
4298

4299
                            scriptEng.operands[0] += 26;
4300
                            charID++;
4301
                        }
4302

4303
                        while (titleCardText[charID] != 0 && titleCardText[charID] != '-') {
4304
                            int32 character = titleCardText[charID];
4305
                            if (character == ' ')
4306
                                character = 0;
4307
                            if (character == '-')
4308
                                character = 0;
4309
                            if (character > '/' && character < ':')
4310
                                character -= 22;
4311
                            if (character > '9' && character < 'f')
4312
                                character -= 'A';
4313

4314
                            if (character <= -1) {
4315
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4316
                            }
4317
                            else {
4318
                                character += scriptEng.operands[0];
4319
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4320
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4321
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4322
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4323
                            }
4324
                            charID++;
4325
                        }
4326
                        break;
4327

4328
                    case 2: // Draw Word 2
4329
                        charID = titleCardWord2;
4330

4331
                        // Draw the first letter as a capital letter, the rest are lowercase
4332
                        // (if scriptEng.operands[4] is true, otherwise they're all uppercase)
4333
                        if (scriptEng.operands[4] == 1 && titleCardText[charID] != 0) {
4334
                            int32 character = titleCardText[charID];
4335
                            if (character == ' ')
4336
                                character = 0;
4337
                            if (character == '-')
4338
                                character = 0;
4339
                            if (character >= '0' && character <= '9')
4340
                                character -= 22;
4341
                            if (character > '9' && character < 'f')
4342
                                character -= 'A';
4343

4344
                            if (character <= -1) {
4345
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4346
                            }
4347
                            else {
4348
                                character += scriptEng.operands[0];
4349
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4350
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4351
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4352
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4353
                            }
4354
                            scriptEng.operands[0] += 26;
4355
                            charID++;
4356
                        }
4357

4358
                        while (titleCardText[charID] != 0) {
4359
                            int32 character = titleCardText[charID];
4360
                            if (character == ' ')
4361
                                character = 0;
4362
                            if (character == '-')
4363
                                character = 0;
4364
                            if (character >= '0' && character <= '9')
4365
                                character -= 22;
4366
                            if (character > '9' && character < 'f')
4367
                                character -= 'A';
4368

4369
                            if (character <= -1) {
4370
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
4371
                            }
4372
                            else {
4373
                                character += scriptEng.operands[0];
4374
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
4375
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
4376
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4377
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
4378
                            }
4379
                            charID++;
4380
                        }
4381
                        break;
4382
                }
4383
                break;
4384
            }
4385
            case FUNC_DRAWMENU:
4386
                opcodeSize        = 0;
4387
                textMenuSurfaceNo = scriptInfo->spriteSheetID;
4388
                DrawTextMenu(&gameMenu[scriptEng.operands[0]], scriptEng.operands[1], scriptEng.operands[2]);
4389
                break;
4390
            case FUNC_SPRITEFRAME:
4391
                opcodeSize = 0;
4392
                if (scriptEvent == EVENT_SETUP && scriptFrameCount < LEGACY_SPRITEFRAME_COUNT) {
4393
                    scriptFrames[scriptFrameCount].pivotX = scriptEng.operands[0];
4394
                    scriptFrames[scriptFrameCount].pivotY = scriptEng.operands[1];
4395
                    scriptFrames[scriptFrameCount].width  = scriptEng.operands[2];
4396
                    scriptFrames[scriptFrameCount].height = scriptEng.operands[3];
4397
                    scriptFrames[scriptFrameCount].sprX   = scriptEng.operands[4];
4398
                    scriptFrames[scriptFrameCount].sprY   = scriptEng.operands[5];
4399
                    ++scriptFrameCount;
4400
                }
4401
                break;
4402
            case FUNC_EDITFRAME: {
4403
                opcodeSize  = 0;
4404
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4405

4406
                spriteFrame->pivotX = scriptEng.operands[1];
4407
                spriteFrame->pivotY = scriptEng.operands[2];
4408
                spriteFrame->width  = scriptEng.operands[3];
4409
                spriteFrame->height = scriptEng.operands[4];
4410
                spriteFrame->sprX   = scriptEng.operands[5];
4411
                spriteFrame->sprY   = scriptEng.operands[6];
4412
            } break;
4413
            case FUNC_LOADPALETTE:
4414
                opcodeSize = 0;
4415
                LoadPalette(scriptText, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4]);
4416
                break;
4417
            case FUNC_ROTATEPALETTE:
4418
                opcodeSize = 0;
4419
                RotatePalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
4420
                break;
4421
            case FUNC_SETSCREENFADE:
4422
                opcodeSize = 0;
4423
                SetFade(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
4424
                break;
4425
            case FUNC_SETACTIVEPALETTE:
4426
                opcodeSize = 0;
4427
                SetActivePalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]);
4428
                break;
4429
            case FUNC_SETPALETTEFADE:
4430
                SetPaletteFade(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4431
                               scriptEng.operands[5]);
4432
                break;
4433
            case FUNC_SETPALETTEENTRY: SetPaletteEntryPacked(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]); break;
4434
            case FUNC_GETPALETTEENTRY: scriptEng.operands[2] = GetPaletteEntryPacked(scriptEng.operands[0], scriptEng.operands[1]); break;
4435
            case FUNC_COPYPALETTE:
4436
                opcodeSize = 0;
4437
                CopyPalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4]);
4438
                break;
4439
            case FUNC_CLEARSCREEN:
4440
                opcodeSize = 0;
4441
                ClearScreen(scriptEng.operands[0]);
4442
                break;
4443
            case FUNC_DRAWSPRITEFX:
4444
                opcodeSize  = 0;
4445
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4446
                switch (scriptEng.operands[1]) {
4447
                    default: break;
4448

4449
                    case FX_SCALE:
4450
                        DrawSpriteScaled(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4451
                                         (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY, entity->scale,
4452
                                         entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4453
                                         scriptInfo->spriteSheetID);
4454
                        break;
4455

4456
                    case FX_ROTATE:
4457
                        DrawSpriteRotated(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4458
                                          (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
4459
                                          spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
4460
                                          scriptInfo->spriteSheetID);
4461
                        break;
4462

4463
                    case FX_ROTOZOOM:
4464
                        DrawSpriteRotozoom(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4465
                                           (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
4466
                                           spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
4467
                                           entity->scale, scriptInfo->spriteSheetID);
4468
                        break;
4469

4470
                    case FX_INK:
4471
                        switch (entity->inkEffect) {
4472
                            case INK_NONE:
4473
                                DrawSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4474
                                           (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4475
                                           spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4476
                                break;
4477

4478
                            case INK_BLEND:
4479
                                DrawBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4480
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4481
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4482
                                break;
4483

4484
                            case INK_ALPHA:
4485
                                DrawAlphaBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4486
                                                       (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4487
                                                       spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4488
                                                       scriptInfo->spriteSheetID);
4489
                                break;
4490

4491
                            case INK_ADD:
4492
                                DrawAdditiveBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4493
                                                          (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4494
                                                          spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4495
                                                          scriptInfo->spriteSheetID);
4496
                                break;
4497

4498
                            case INK_SUB:
4499
                                DrawSubtractiveBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4500
                                                             (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4501
                                                             spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4502
                                                             scriptInfo->spriteSheetID);
4503
                                break;
4504
                        }
4505
                        break;
4506
                    case FX_TINT:
4507
                        if (entity->inkEffect == INK_ALPHA) {
4508
                            DrawScaledTintMask(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4509
                                               (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
4510
                                               entity->scale, entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX,
4511
                                               spriteFrame->sprY, scriptInfo->spriteSheetID);
4512
                        }
4513
                        else {
4514
                            DrawSpriteScaled(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
4515
                                             (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY, entity->scale,
4516
                                             entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4517
                                             scriptInfo->spriteSheetID);
4518
                        }
4519
                        break;
4520

4521
                    case FX_FLIP:
4522
                        switch (entity->direction) {
4523
                            default:
4524
                            case FLIP_NONE:
4525
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4526
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4527
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_NONE, scriptInfo->spriteSheetID);
4528
                                break;
4529

4530
                            case FLIP_X:
4531
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset - spriteFrame->width - spriteFrame->pivotX,
4532
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
4533
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_X, scriptInfo->spriteSheetID);
4534
                                break;
4535

4536
                            case FLIP_Y:
4537
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
4538
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset - spriteFrame->height - spriteFrame->pivotY,
4539
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_Y,
4540
                                                  scriptInfo->spriteSheetID);
4541
                                break;
4542

4543
                            case FLIP_XY:
4544
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset - spriteFrame->width - spriteFrame->pivotX,
4545
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset - spriteFrame->height - spriteFrame->pivotY,
4546
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_XY,
4547
                                                  scriptInfo->spriteSheetID);
4548
                                break;
4549
                        }
4550
                        break;
4551
                }
4552
                break;
4553
            case FUNC_DRAWSPRITESCREENFX:
4554
                opcodeSize  = 0;
4555
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
4556

4557
                switch (scriptEng.operands[1]) {
4558
                    default: break;
4559

4560
                    case FX_SCALE:
4561
                        DrawSpriteScaled(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX, -spriteFrame->pivotY,
4562
                                         entity->scale, entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4563
                                         scriptInfo->spriteSheetID);
4564
                        break;
4565

4566
                    case FX_ROTATE:
4567
                        DrawSpriteRotated(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX, -spriteFrame->pivotY,
4568
                                          spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
4569
                                          scriptInfo->spriteSheetID);
4570
                        break;
4571

4572
                    case FX_ROTOZOOM:
4573
                        DrawSpriteRotozoom(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
4574
                                           -spriteFrame->pivotY, spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height,
4575
                                           entity->rotation, entity->scale, scriptInfo->spriteSheetID);
4576
                        break;
4577

4578
                    case FX_INK:
4579
                        switch (entity->inkEffect) {
4580
                            case INK_NONE:
4581
                                DrawSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4582
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4583
                                break;
4584

4585
                            case INK_BLEND:
4586
                                DrawBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4587
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4588
                                                  scriptInfo->spriteSheetID);
4589
                                break;
4590

4591
                            case INK_ALPHA:
4592
                                DrawAlphaBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4593
                                                       spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
4594
                                                       scriptInfo->spriteSheetID);
4595
                                break;
4596

4597
                            case INK_ADD:
4598
                                DrawAdditiveBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4599
                                                          spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4600
                                                          entity->alpha, scriptInfo->spriteSheetID);
4601
                                break;
4602

4603
                            case INK_SUB:
4604
                                DrawSubtractiveBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4605
                                                             spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
4606
                                                             entity->alpha, scriptInfo->spriteSheetID);
4607
                                break;
4608
                        }
4609
                        break;
4610

4611
                    case FX_TINT:
4612
                        if (entity->inkEffect == INK_ALPHA) {
4613
                            DrawScaledTintMask(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
4614
                                               -spriteFrame->pivotY, entity->scale, entity->scale, spriteFrame->width, spriteFrame->height,
4615
                                               spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4616
                        }
4617
                        else {
4618
                            DrawSpriteScaled(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
4619
                                             -spriteFrame->pivotY, entity->scale, entity->scale, spriteFrame->width, spriteFrame->height,
4620
                                             spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
4621
                        }
4622
                        break;
4623

4624
                    case FX_FLIP:
4625
                        switch (entity->direction) {
4626
                            default:
4627
                            case FLIP_NONE:
4628
                                DrawSpriteFlipped(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
4629
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_NONE,
4630
                                                  scriptInfo->spriteSheetID);
4631
                                break;
4632

4633
                            case FLIP_X:
4634
                                DrawSpriteFlipped(scriptEng.operands[2] - spriteFrame->width - spriteFrame->pivotX,
4635
                                                  scriptEng.operands[3] + spriteFrame->pivotY, spriteFrame->width, spriteFrame->height,
4636
                                                  spriteFrame->sprX, spriteFrame->sprY, FLIP_X, scriptInfo->spriteSheetID);
4637
                                break;
4638

4639
                            case FLIP_Y:
4640
                                DrawSpriteFlipped(scriptEng.operands[2] + spriteFrame->pivotX,
4641
                                                  scriptEng.operands[3] - spriteFrame->height - spriteFrame->pivotY, spriteFrame->width,
4642
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_Y, scriptInfo->spriteSheetID);
4643
                                break;
4644

4645
                            case FLIP_XY:
4646
                                DrawSpriteFlipped(scriptEng.operands[2] - spriteFrame->width - spriteFrame->pivotX,
4647
                                                  scriptEng.operands[3] - spriteFrame->height - spriteFrame->pivotY, spriteFrame->width,
4648
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_XY, scriptInfo->spriteSheetID);
4649
                                break;
4650
                        }
4651
                        break;
4652
                }
4653
                break;
4654

4655
            case FUNC_LOADANIMATION:
4656
                opcodeSize           = 0;
4657
                scriptInfo->animFile = AddAnimationFile(scriptText);
4658
                break;
4659

4660
            case FUNC_SETUPMENU: {
4661
                opcodeSize     = 0;
4662
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
4663
                SetupTextMenu(menu, scriptEng.operands[1]);
4664
                menu->selectionCount = scriptEng.operands[2];
4665
                menu->alignment      = scriptEng.operands[3];
4666
                break;
4667
            }
4668
            case FUNC_ADDMENUENTRY: {
4669
                opcodeSize                           = 0;
4670
                TextMenu *menu                       = &gameMenu[scriptEng.operands[0]];
4671
                menu->entryHighlight[menu->rowCount] = scriptEng.operands[2];
4672
                AddTextMenuEntry(menu, scriptText);
4673
                break;
4674
            }
4675
            case FUNC_EDITMENUENTRY: {
4676
                opcodeSize     = 0;
4677
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
4678
                EditTextMenuEntry(menu, scriptText, scriptEng.operands[2]);
4679
                menu->entryHighlight[scriptEng.operands[2]] = scriptEng.operands[3];
4680
                break;
4681
            }
4682
            case FUNC_LOADSTAGE:
4683
                opcodeSize = 0;
4684
                stageMode  = STAGEMODE_LOAD;
4685
                break;
4686
            case FUNC_DRAWRECT:
4687
                opcodeSize = 0;
4688
                DrawRectangle(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4689
                              scriptEng.operands[5], scriptEng.operands[6], scriptEng.operands[7]);
4690
                break;
4691
            case FUNC_RESETOBJECTENTITY: {
4692
                opcodeSize     = 0;
4693
                Entity *newEnt = &objectEntityList[scriptEng.operands[0]];
4694
                memset(newEnt, 0, sizeof(Entity));
4695
                newEnt->type               = scriptEng.operands[1];
4696
                newEnt->propertyValue      = scriptEng.operands[2];
4697
                newEnt->xpos               = scriptEng.operands[3];
4698
                newEnt->ypos               = scriptEng.operands[4];
4699
                newEnt->direction          = FLIP_NONE;
4700
                newEnt->priority           = PRIORITY_BOUNDS;
4701
                newEnt->drawOrder          = 3;
4702
                newEnt->scale              = 512;
4703
                newEnt->inkEffect          = INK_NONE;
4704
                newEnt->objectInteractions = true;
4705
                newEnt->visible            = true;
4706
                newEnt->tileCollisions     = true;
4707
                break;
4708
            }
4709
            case FUNC_BOXCOLLISIONTEST:
4710
                opcodeSize = 0;
4711
                switch (scriptEng.operands[0]) {
4712
                    default: break;
4713
                    case C_TOUCH:
4714
                        TouchCollision(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4715
                                       scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]], scriptEng.operands[7], scriptEng.operands[8],
4716
                                       scriptEng.operands[9], scriptEng.operands[10]);
4717
                        break;
4718
                    case C_SOLID:
4719
                        BoxCollision(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4720
                                     scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]], scriptEng.operands[7], scriptEng.operands[8],
4721
                                     scriptEng.operands[9], scriptEng.operands[10]);
4722
                        break;
4723
                    case C_SOLID2:
4724
                        BoxCollision2(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4725
                                      scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]], scriptEng.operands[7], scriptEng.operands[8],
4726
                                      scriptEng.operands[9], scriptEng.operands[10]);
4727
                        break;
4728
                    case C_PLATFORM:
4729
                        PlatformCollision(&objectEntityList[scriptEng.operands[1]], scriptEng.operands[2], scriptEng.operands[3],
4730
                                          scriptEng.operands[4], scriptEng.operands[5], &objectEntityList[scriptEng.operands[6]],
4731
                                          scriptEng.operands[7], scriptEng.operands[8], scriptEng.operands[9], scriptEng.operands[10]);
4732
                        break;
4733
                }
4734
                break;
4735
            case FUNC_CREATETEMPOBJECT: {
4736
                opcodeSize = 0;
4737
                if (objectEntityList[scriptEng.arrayPosition[8]].type > OBJ_TYPE_BLANKOBJECT
4738
                    && ++scriptEng.arrayPosition[8] == LEGACY_v4_ENTITY_COUNT)
4739
                    scriptEng.arrayPosition[8] = LEGACY_v4_TEMPENTITY_START;
4740
                Entity *temp = &objectEntityList[scriptEng.arrayPosition[8]];
4741
                memset(temp, 0, sizeof(Entity));
4742
                temp->type               = scriptEng.operands[0];
4743
                temp->propertyValue      = scriptEng.operands[1];
4744
                temp->xpos               = scriptEng.operands[2];
4745
                temp->ypos               = scriptEng.operands[3];
4746
                temp->direction          = FLIP_NONE;
4747
                temp->priority           = PRIORITY_ACTIVE;
4748
                temp->drawOrder          = 3;
4749
                temp->scale              = 512;
4750
                temp->inkEffect          = INK_NONE;
4751
                temp->objectInteractions = true;
4752
                temp->visible            = true;
4753
                temp->tileCollisions     = true;
4754
                break;
4755
            }
4756
            case FUNC_PROCESSOBJECTMOVEMENT:
4757
                opcodeSize = 0;
4758
                if (entity->tileCollisions) {
4759
                    ProcessTileCollisions(entity);
4760
                }
4761
                else {
4762
                    entity->xpos += entity->xvel;
4763
                    entity->ypos += entity->yvel;
4764
                }
4765
                break;
4766
            case FUNC_PROCESSOBJECTCONTROL:
4767
                opcodeSize = 0;
4768
                ProcessObjectControl(entity);
4769
                break;
4770
            case FUNC_PROCESSANIMATION:
4771
                opcodeSize = 0;
4772
                ProcessObjectAnimation(scriptInfo, entity);
4773
                break;
4774
            case FUNC_DRAWOBJECTANIMATION:
4775
                opcodeSize = 0;
4776
                if (entity->visible)
4777
                    DrawObjectAnimation(scriptInfo, entity, (entity->xpos >> 16) - xScrollOffset, (entity->ypos >> 16) - yScrollOffset);
4778
                break;
4779
            case FUNC_SETMUSICTRACK:
4780
                opcodeSize = 0;
4781
                if (scriptEng.operands[2] <= 1)
4782
                    SetMusicTrack(scriptText, scriptEng.operands[1], scriptEng.operands[2], 0);
4783
                else
4784
                    SetMusicTrack(scriptText, scriptEng.operands[1], true, scriptEng.operands[2]);
4785
                break;
4786
            case FUNC_PLAYMUSIC:
4787
                opcodeSize = 0;
4788
                PlayMusic(scriptEng.operands[0]);
4789
                break;
4790
            case FUNC_STOPMUSIC:
4791
                opcodeSize = 0;
4792
                StopMusic();
4793
                break;
4794
            case FUNC_PAUSEMUSIC:
4795
                opcodeSize = 0;
4796
                PauseChannel(musicChannel);
4797
                break;
4798
            case FUNC_RESUMEMUSIC:
4799
                opcodeSize = 0;
4800
                ResumeChannel(musicChannel);
4801
                break;
4802
            case FUNC_SWAPMUSICTRACK:
4803
                opcodeSize = 0;
4804
                if (scriptEng.operands[2] <= 1)
4805
                    SwapMusicTrack(scriptText, scriptEng.operands[1], 0, scriptEng.operands[3]);
4806
                else
4807
                    SwapMusicTrack(scriptText, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
4808
                break;
4809
            case FUNC_PLAYSFX:
4810
                opcodeSize = 0;
4811
                PlaySfx(scriptEng.operands[0], scriptEng.operands[1]);
4812
                break;
4813
            case FUNC_STOPSFX:
4814
                opcodeSize = 0;
4815
                StopSfx(scriptEng.operands[0]);
4816
                break;
4817
            case FUNC_SETSFXATTRIBUTES:
4818
                opcodeSize = 0;
4819
                SetSfxAttributes(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]);
4820
                break;
4821
            case FUNC_OBJECTTILECOLLISION:
4822
                opcodeSize = 0;
4823
                switch (scriptEng.operands[0]) {
4824
                    default: break;
4825
                    case CSIDE_FLOOR: ObjectFloorCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4826
                    case CSIDE_LWALL: ObjectLWallCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4827
                    case CSIDE_RWALL: ObjectRWallCollision(scriptEng.operands[1] - 1, scriptEng.operands[2], scriptEng.operands[3]); break;
4828
                    case CSIDE_ROOF: ObjectRoofCollision(scriptEng.operands[1], scriptEng.operands[2] - 1, scriptEng.operands[3]); break;
4829
                    case CSIDE_LENTITY: ObjectLWallCollision(scriptEng.operands[2], 0, objectEntityList[scriptEng.operands[1]].collisionPlane); break;
4830
                    case CSIDE_RENTITY: ObjectLWallCollision(scriptEng.operands[2] - 1, 0, objectEntityList[scriptEng.operands[1]].collisionPlane); break;
4831
                }
4832
                break;
4833
            case FUNC_OBJECTTILEGRIP:
4834
                opcodeSize = 0;
4835
                switch (scriptEng.operands[0]) {
4836
                    default: break;
4837
                    case CSIDE_FLOOR: ObjectFloorGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4838
                    case CSIDE_LWALL: ObjectLWallGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4839
                    case CSIDE_RWALL: ObjectRWallGrip(scriptEng.operands[1] - 1, scriptEng.operands[2], scriptEng.operands[3]); break;
4840
                    case CSIDE_ROOF: ObjectRoofGrip(scriptEng.operands[1], scriptEng.operands[2] - 1, scriptEng.operands[3]); break;
4841
                    case CSIDE_LENTITY: ObjectLEntityGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4842
                    case CSIDE_RENTITY: ObjectREntityGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4843
                }
4844
                break;
4845
            case FUNC_NOT: scriptEng.operands[0] = ~scriptEng.operands[0]; break;
4846
            case FUNC_DRAW3DSCENE:
4847
                opcodeSize = 0;
4848
                TransformVertexBuffer();
4849
                Sort3DDrawList();
4850
                Draw3DScene(scriptInfo->spriteSheetID);
4851
                break;
4852
            case FUNC_SETIDENTITYMATRIX:
4853
                opcodeSize = 0;
4854
                switch (scriptEng.operands[0]) {
4855
                    case MAT_WORLD: SetIdentityMatrix(&matWorld); break;
4856
                    case MAT_VIEW: SetIdentityMatrix(&matView); break;
4857
                    case MAT_TEMP: SetIdentityMatrix(&matTemp); break;
4858
                }
4859
                break;
4860
            case FUNC_MATRIXMULTIPLY:
4861
                opcodeSize = 0;
4862
                switch (scriptEng.operands[0]) {
4863
                    case MAT_WORLD:
4864
                        switch (scriptEng.operands[1]) {
4865
                            case MAT_WORLD: MatrixMultiply(&matWorld, &matWorld); break;
4866
                            case MAT_VIEW: MatrixMultiply(&matWorld, &matView); break;
4867
                            case MAT_TEMP: MatrixMultiply(&matWorld, &matTemp); break;
4868
                        }
4869
                        break;
4870

4871
                    case MAT_VIEW:
4872
                        switch (scriptEng.operands[1]) {
4873
                            case MAT_WORLD: MatrixMultiply(&matView, &matWorld); break;
4874
                            case MAT_VIEW: MatrixMultiply(&matView, &matView); break;
4875
                            case MAT_TEMP: MatrixMultiply(&matView, &matTemp); break;
4876
                        }
4877
                        break;
4878

4879
                    case MAT_TEMP:
4880
                        switch (scriptEng.operands[1]) {
4881
                            case MAT_WORLD: MatrixMultiply(&matTemp, &matWorld); break;
4882
                            case MAT_VIEW: MatrixMultiply(&matTemp, &matView); break;
4883
                            case MAT_TEMP: MatrixMultiply(&matTemp, &matTemp); break;
4884
                        }
4885
                        break;
4886
                }
4887
                break;
4888
            case FUNC_MATRIXTRANSLATEXYZ:
4889
                opcodeSize = 0;
4890
                switch (scriptEng.operands[0]) {
4891
                    case MAT_WORLD: MatrixTranslateXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4892
                    case MAT_VIEW: MatrixTranslateXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4893
                    case MAT_TEMP: MatrixTranslateXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4894
                }
4895
                break;
4896
            case FUNC_MATRIXSCALEXYZ:
4897
                opcodeSize = 0;
4898
                switch (scriptEng.operands[0]) {
4899
                    case MAT_WORLD: MatrixScaleXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4900
                    case MAT_VIEW: MatrixScaleXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4901
                    case MAT_TEMP: MatrixScaleXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4902
                }
4903
                break;
4904
            case FUNC_MATRIXROTATEX:
4905
                opcodeSize = 0;
4906
                switch (scriptEng.operands[0]) {
4907
                    case MAT_WORLD: MatrixRotateX(&matWorld, scriptEng.operands[1]); break;
4908
                    case MAT_VIEW: MatrixRotateX(&matView, scriptEng.operands[1]); break;
4909
                    case MAT_TEMP: MatrixRotateX(&matTemp, scriptEng.operands[1]); break;
4910
                }
4911
                break;
4912
            case FUNC_MATRIXROTATEY:
4913
                opcodeSize = 0;
4914
                switch (scriptEng.operands[0]) {
4915
                    case MAT_WORLD: MatrixRotateY(&matWorld, scriptEng.operands[1]); break;
4916
                    case MAT_VIEW: MatrixRotateY(&matView, scriptEng.operands[1]); break;
4917
                    case MAT_TEMP: MatrixRotateY(&matTemp, scriptEng.operands[1]); break;
4918
                }
4919
                break;
4920
            case FUNC_MATRIXROTATEZ:
4921
                opcodeSize = 0;
4922
                switch (scriptEng.operands[0]) {
4923
                    case MAT_WORLD: MatrixRotateZ(&matWorld, scriptEng.operands[1]); break;
4924
                    case MAT_VIEW: MatrixRotateZ(&matView, scriptEng.operands[1]); break;
4925
                    case MAT_TEMP: MatrixRotateZ(&matTemp, scriptEng.operands[1]); break;
4926
                }
4927
                break;
4928
            case FUNC_MATRIXROTATEXYZ:
4929
                opcodeSize = 0;
4930
                switch (scriptEng.operands[0]) {
4931
                    case MAT_WORLD: MatrixRotateXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4932
                    case MAT_VIEW: MatrixRotateXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4933
                    case MAT_TEMP: MatrixRotateXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
4934
                }
4935
                break;
4936
            case FUNC_MATRIXINVERSE:
4937
                opcodeSize = 0;
4938
                switch (scriptEng.operands[0]) {
4939
                    case MAT_WORLD: MatrixInverse(&matWorld); break;
4940
                    case MAT_VIEW: MatrixInverse(&matView); break;
4941
                    case MAT_TEMP: MatrixInverse(&matTemp); break;
4942
                }
4943
                break;
4944
            case FUNC_TRANSFORMVERTICES:
4945
                opcodeSize = 0;
4946
                switch (scriptEng.operands[0]) {
4947
                    case MAT_WORLD: TransformVertices(&matWorld, scriptEng.operands[1], scriptEng.operands[2]); break;
4948
                    case MAT_VIEW: TransformVertices(&matView, scriptEng.operands[1], scriptEng.operands[2]); break;
4949
                    case MAT_TEMP: TransformVertices(&matTemp, scriptEng.operands[1], scriptEng.operands[2]); break;
4950
                }
4951
                break;
4952
            case FUNC_CALLFUNCTION: {
4953
                opcodeSize                        = 0;
4954
                functionStack[functionStackPos++] = scriptCodePtr;
4955
                functionStack[functionStackPos++] = jumpTableStart;
4956
                functionStack[functionStackPos++] = scriptCodeStart;
4957
                scriptCodeStart                   = scriptFunctionList[scriptEng.operands[0]].ptr.scriptCodePtr;
4958
                jumpTableStart                    = scriptFunctionList[scriptEng.operands[0]].ptr.jumpTablePtr;
4959
                scriptCodePtr                     = scriptCodeStart;
4960
                break;
4961
            }
4962
            case FUNC_RETURN:
4963
                opcodeSize = 0;
4964
                if (!functionStackPos) { // event, stop running
4965
                    running = false;
4966
                }
4967
                else { // function, jump out
4968
                    scriptCodeStart = functionStack[--functionStackPos];
4969
                    jumpTableStart  = functionStack[--functionStackPos];
4970
                    scriptCodePtr   = functionStack[--functionStackPos];
4971
                }
4972
                break;
4973
            case FUNC_SETLAYERDEFORMATION:
4974
                opcodeSize = 0;
4975
                SetLayerDeformation(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
4976
                                    scriptEng.operands[5]);
4977
                break;
4978
            case FUNC_CHECKTOUCHRECT:
4979
                opcodeSize            = 0;
4980
                scriptEng.checkResult = -1;
4981

4982
                for (int32 f = 0; f < touchInfo.count; ++f) {
4983
                    if (touchInfo.down[f]) {
4984
                        int32 touchX = (int32)(touchInfo.x[f] * SCREEN_XSIZE);
4985
                        int32 touchY = (int32)(touchInfo.y[f] * SCREEN_YSIZE);
4986

4987
                        if (touchX > scriptEng.operands[0] && touchX < scriptEng.operands[2] && touchY > scriptEng.operands[1]
4988
                            && touchY < scriptEng.operands[3]) {
4989
                            scriptEng.checkResult = f;
4990
                        }
4991
                    }
4992
                }
4993
                break;
4994
            case FUNC_GETTILELAYERENTRY:
4995
                scriptEng.operands[0] = stageLayouts[scriptEng.operands[1]].tiles[scriptEng.operands[2] + 0x100 * scriptEng.operands[3]];
4996
                break;
4997
            case FUNC_SETTILELAYERENTRY:
4998
                stageLayouts[scriptEng.operands[1]].tiles[scriptEng.operands[2] + 0x100 * scriptEng.operands[3]] = scriptEng.operands[0];
4999
                break;
5000
            case FUNC_GETBIT: scriptEng.operands[0] = (scriptEng.operands[1] & (1 << scriptEng.operands[2])) >> scriptEng.operands[2]; break;
5001
            case FUNC_SETBIT:
5002
                if (scriptEng.operands[2] <= 0)
5003
                    scriptEng.operands[0] &= ~(1 << scriptEng.operands[1]);
5004
                else
5005
                    scriptEng.operands[0] |= 1 << scriptEng.operands[1];
5006
                break;
5007
            case FUNC_CLEARDRAWLIST:
5008
                opcodeSize                                      = 0;
5009
                drawListEntries[scriptEng.operands[0]].listSize = 0;
5010
                break;
5011
            case FUNC_ADDDRAWLISTENTITYREF: {
5012
                opcodeSize                                                                                           = 0;
5013
                drawListEntries[scriptEng.operands[0]].entityRefs[drawListEntries[scriptEng.operands[0]].listSize++] = scriptEng.operands[1];
5014
                break;
5015
            }
5016
            case FUNC_GETDRAWLISTENTITYREF: scriptEng.operands[0] = drawListEntries[scriptEng.operands[1]].entityRefs[scriptEng.operands[2]]; break;
5017
            case FUNC_SETDRAWLISTENTITYREF:
5018
                opcodeSize                                                               = 0;
5019
                drawListEntries[scriptEng.operands[1]].entityRefs[scriptEng.operands[2]] = scriptEng.operands[0];
5020
                break;
5021
            case FUNC_GET16X16TILEINFO: {
5022
                scriptEng.operands[4] = scriptEng.operands[1] >> 7;
5023
                scriptEng.operands[5] = scriptEng.operands[2] >> 7;
5024
                scriptEng.operands[6] = stageLayouts[0].tiles[scriptEng.operands[4] + (scriptEng.operands[5] << 8)] << 6;
5025
                scriptEng.operands[6] += ((scriptEng.operands[1] & 0x7F) >> 4) + 8 * ((scriptEng.operands[2] & 0x7F) >> 4);
5026
                int32 index = tiles128x128.tileIndex[scriptEng.operands[6]];
5027
                switch (scriptEng.operands[3]) {
5028
                    case TILEINFO_INDEX: scriptEng.operands[0] = tiles128x128.tileIndex[scriptEng.operands[6]]; break;
5029
                    case TILEINFO_DIRECTION: scriptEng.operands[0] = tiles128x128.direction[scriptEng.operands[6]]; break;
5030
                    case TILEINFO_VISUALPLANE: scriptEng.operands[0] = tiles128x128.visualPlane[scriptEng.operands[6]]; break;
5031
                    case TILEINFO_SOLIDITYA: scriptEng.operands[0] = tiles128x128.collisionFlags[0][scriptEng.operands[6]]; break;
5032
                    case TILEINFO_SOLIDITYB: scriptEng.operands[0] = tiles128x128.collisionFlags[1][scriptEng.operands[6]]; break;
5033
                    case TILEINFO_FLAGSA: scriptEng.operands[0] = collisionMasks[0].flags[index]; break;
5034
                    case TILEINFO_ANGLEA: scriptEng.operands[0] = collisionMasks[0].angles[index]; break;
5035
                    case TILEINFO_FLAGSB: scriptEng.operands[0] = collisionMasks[1].flags[index]; break;
5036
                    case TILEINFO_ANGLEB: scriptEng.operands[0] = collisionMasks[1].angles[index]; break;
5037
                    default: break;
5038
                }
5039
                break;
5040
            }
5041
            case FUNC_SET16X16TILEINFO: {
5042
                scriptEng.operands[4] = scriptEng.operands[1] >> 7;
5043
                scriptEng.operands[5] = scriptEng.operands[2] >> 7;
5044
                scriptEng.operands[6] = stageLayouts[0].tiles[scriptEng.operands[4] + (scriptEng.operands[5] << 8)] << 6;
5045
                scriptEng.operands[6] += ((scriptEng.operands[1] & 0x7F) >> 4) + 8 * ((scriptEng.operands[2] & 0x7F) >> 4);
5046
                switch (scriptEng.operands[3]) {
5047
                    case TILEINFO_INDEX:
5048
                        tiles128x128.tileIndex[scriptEng.operands[6]]  = scriptEng.operands[0];
5049
                        tiles128x128.gfxDataPos[scriptEng.operands[6]] = scriptEng.operands[0] << 8;
5050
                        break;
5051
                    case TILEINFO_DIRECTION: tiles128x128.direction[scriptEng.operands[6]] = scriptEng.operands[0]; break;
5052
                    case TILEINFO_VISUALPLANE: tiles128x128.visualPlane[scriptEng.operands[6]] = scriptEng.operands[0]; break;
5053
                    case TILEINFO_SOLIDITYA: tiles128x128.collisionFlags[0][scriptEng.operands[6]] = scriptEng.operands[0]; break;
5054
                    case TILEINFO_SOLIDITYB: tiles128x128.collisionFlags[1][scriptEng.operands[6]] = scriptEng.operands[0]; break;
5055
                    case TILEINFO_FLAGSA: collisionMasks[1].flags[tiles128x128.tileIndex[scriptEng.operands[6]]] = scriptEng.operands[0]; break;
5056
                    case TILEINFO_ANGLEA: collisionMasks[1].angles[tiles128x128.tileIndex[scriptEng.operands[6]]] = scriptEng.operands[0]; break;
5057
                    default: break;
5058
                }
5059
                break;
5060
            }
5061
            case FUNC_COPY16X16TILE:
5062
                opcodeSize = 0;
5063
                Copy16x16Tile(scriptEng.operands[0], scriptEng.operands[1]);
5064
                break;
5065
            case FUNC_GETANIMATIONBYNAME: {
5066
                AnimationFile *animFile = scriptInfo->animFile;
5067
                scriptEng.operands[0]   = -1;
5068
                int32 id                = 0;
5069
                while (scriptEng.operands[0] == -1) {
5070
                    SpriteAnimation *anim = &animationList[animFile->aniListOffset + id];
5071
                    if (StrComp(scriptText, anim->name))
5072
                        scriptEng.operands[0] = id;
5073
                    else if (++id == animFile->animCount)
5074
                        scriptEng.operands[0] = 0;
5075
                }
5076
                break;
5077
            }
5078
            case FUNC_READSAVERAM:
5079
                opcodeSize            = 0;
5080
                scriptEng.checkResult = ReadSaveRAM();
5081
                break;
5082
            case FUNC_WRITESAVERAM:
5083
                opcodeSize            = 0;
5084
                scriptEng.checkResult = WriteSaveRAM();
5085
                break;
5086
            case FUNC_LOADTEXTFILE: {
5087
                opcodeSize     = 0;
5088
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
5089
                LoadTextFile(menu, scriptText);
5090
                break;
5091
            }
5092
            case FUNC_GETTEXTINFO: {
5093
                TextMenu *menu = &gameMenu[scriptEng.operands[1]];
5094
                switch (scriptEng.operands[2]) {
5095
                    case TEXTINFO_TEXTDATA:
5096
                        scriptEng.operands[0] = menu->textData[menu->entryStart[scriptEng.operands[3]] + scriptEng.operands[4]];
5097
                        break;
5098
                    case TEXTINFO_TEXTSIZE: scriptEng.operands[0] = menu->entrySize[scriptEng.operands[3]]; break;
5099
                    case TEXTINFO_ROWCOUNT: scriptEng.operands[0] = menu->rowCount; break;
5100
                }
5101
                break;
5102
            }
5103
            case FUNC_GETVERSIONNUMBER: {
5104
                opcodeSize                           = 0;
5105
                TextMenu *menu                       = &gameMenu[scriptEng.operands[0]];
5106
                menu->entryHighlight[menu->rowCount] = scriptEng.operands[1];
5107
                AddTextMenuEntry(menu, gameVerInfo.version);
5108
                break;
5109
            }
5110
            case FUNC_GETTABLEVALUE: {
5111
                int32 arrPos = scriptEng.operands[1];
5112
                if (arrPos >= 0) {
5113
                    int32 pos     = scriptEng.operands[2];
5114
                    int32 arrSize = scriptCode[pos];
5115
                    if (arrPos < arrSize)
5116
                        scriptEng.operands[0] = scriptCode[pos + arrPos + 1];
5117
                }
5118
                break;
5119
            }
5120
            case FUNC_SETTABLEVALUE: {
5121
                opcodeSize   = 0;
5122
                int32 arrPos = scriptEng.operands[1];
5123
                if (arrPos >= 0) {
5124
                    int32 pos     = scriptEng.operands[2];
5125
                    int32 arrSize = scriptCode[pos];
5126
                    if (arrPos < arrSize)
5127
                        scriptCode[pos + arrPos + 1] = scriptEng.operands[0];
5128
                }
5129
                break;
5130
            }
5131
            case FUNC_CHECKCURRENTSTAGEFOLDER:
5132
                opcodeSize            = 0;
5133
                scriptEng.checkResult = StrComp(sceneInfo.listData[sceneInfo.listPos].folder, scriptText);
5134

5135
                // Mission Mode stuff
5136
                if (!scriptEng.checkResult) {
5137
                    int32 targetLength  = (int32)strlen(sceneInfo.listData[sceneInfo.listPos].folder);
5138
                    int32 currentLength = (int32)strlen(scriptText);
5139
                    if (targetLength > currentLength) {
5140
                        scriptEng.checkResult = StrComp(&sceneInfo.listData[sceneInfo.listPos].folder[targetLength - currentLength], scriptText);
5141
                    }
5142
                }
5143
                break;
5144
            case FUNC_ABS: {
5145
                scriptEng.operands[0] = abs(scriptEng.operands[0]);
5146
                break;
5147
            }
5148
            case FUNC_CALLNATIVEFUNCTION:
5149
                opcodeSize = 0;
5150
                if (scriptEng.operands[0] >= 0 && scriptEng.operands[0] < LEGACY_v4_NATIIVEFUNCTION_COUNT) {
5151
                    void (*func)(void) = (void (*)(void))nativeFunction[scriptEng.operands[0]];
5152
                    if (func)
5153
                        func();
5154
                }
5155
                break;
5156
            case FUNC_CALLNATIVEFUNCTION2:
5157
                if (scriptEng.operands[0] >= 0 && scriptEng.operands[0] < LEGACY_v4_NATIIVEFUNCTION_COUNT) {
5158
                    if (StrLength(scriptText)) {
5159
                        void (*func)(int32 *, char *) = (void (*)(int32 *, char *))nativeFunction[scriptEng.operands[0]];
5160
                        if (func)
5161
                            func(&scriptEng.operands[2], scriptText);
5162
                    }
5163
                    else {
5164
                        void (*func)(int32 *, int32 *) = (void (*)(int32 *, int32 *))nativeFunction[scriptEng.operands[0]];
5165
                        if (func)
5166
                            func(&scriptEng.operands[1], &scriptEng.operands[2]);
5167
                    }
5168
                }
5169
                break;
5170
            case FUNC_CALLNATIVEFUNCTION4:
5171
                if (scriptEng.operands[0] >= 0 && scriptEng.operands[0] < LEGACY_v4_NATIIVEFUNCTION_COUNT) {
5172
                    if (StrLength(scriptText)) {
5173
                        void (*func)(int32 *, char *, int32 *, int32 *) =
5174
                            (void (*)(int32 *, char *, int32 *, int32 *))nativeFunction[scriptEng.operands[0]];
5175
                        if (func)
5176
                            func(&scriptEng.operands[1], scriptText, &scriptEng.operands[3], &scriptEng.operands[4]);
5177
                    }
5178
                    else {
5179
                        void (*func)(int32 *, int32 *, int32 *, int32 *) =
5180
                            (void (*)(int32 *, int32 *, int32 *, int32 *))nativeFunction[scriptEng.operands[0]];
5181
                        if (func)
5182
                            func(&scriptEng.operands[1], &scriptEng.operands[2], &scriptEng.operands[3], &scriptEng.operands[4]);
5183
                    }
5184
                }
5185
                break;
5186
            case FUNC_SETOBJECTRANGE: {
5187
                // FUNCTION PARAMS:
5188
                // scriptEng.operands[0] = range
5189

5190
                opcodeSize       = 0;
5191
                int32 offset     = (scriptEng.operands[0] >> 1) - SCREEN_CENTERX;
5192
                OBJECT_BORDER_X1 = offset + 0x80;
5193
                OBJECT_BORDER_X2 = scriptEng.operands[0] + 0x80 - offset;
5194
                OBJECT_BORDER_X3 = offset + 0x20;
5195
                OBJECT_BORDER_X4 = scriptEng.operands[0] + 0x20 - offset;
5196
                break;
5197
            }
5198
            case FUNC_GETOBJECTVALUE: {
5199
                // FUNCTION PARAMS:
5200
                // scriptEng.operands[0] = result
5201
                // scriptEng.operands[1] = valueID
5202
                // scriptEng.operands[2] = entitySlot
5203

5204
                if (scriptEng.operands[1] < 48)
5205
                    scriptEng.operands[0] = objectEntityList[scriptEng.operands[2]].values[scriptEng.operands[1]];
5206
                break;
5207
            }
5208
            case FUNC_SETOBJECTVALUE: {
5209
                // FUNCTION PARAMS:
5210
                // scriptEng.operands[0] = value
5211
                // scriptEng.operands[1] = valueID
5212
                // scriptEng.operands[2] = entitySlot
5213

5214
                opcodeSize = 0;
5215
                if (scriptEng.operands[1] < 48)
5216
                    objectEntityList[scriptEng.operands[2]].values[scriptEng.operands[1]] = scriptEng.operands[0];
5217
                break;
5218
            }
5219
            case FUNC_COPYOBJECT: {
5220
                // FUNCTION PARAMS:
5221
                // scriptEng.operands[0] = destSlot
5222
                // scriptEng.operands[1] = srcSlot
5223
                // scriptEng.operands[2] = count
5224

5225
                Entity *dstList = &objectEntityList[scriptEng.operands[0]];
5226
                Entity *srcList = &objectEntityList[scriptEng.operands[1]];
5227
                for (int32 i = 0; i < scriptEng.operands[2]; ++i) memcpy(&dstList[i], &srcList[i], sizeof(Entity));
5228
                break;
5229
            }
5230
            case FUNC_PRINT: {
5231
                // FUNCTION PARAMS:
5232
                // scriptEng.operands[0] = message (can be a regular value or a string depending on scriptEng.operands[1])
5233
                // scriptEng.operands[1] = isInt
5234
                // scriptEng.operands[2] = useEndLine
5235

5236
                useEndLine = false;
5237
                if (scriptEng.operands[1])
5238
                    PrintLog(PRINT_NORMAL, "%d", scriptEng.operands[0]);
5239
                else
5240
                    PrintLog(PRINT_NORMAL, "%s", scriptText);
5241

5242
                if (scriptEng.operands[2])
5243
                    PrintLog(PRINT_NORMAL, "\n");
5244
                useEndLine = true;
5245
                break;
5246
            }
5247

5248
            // Extras for origins 2PVS
5249
            case FUNC_CHECKCAMERAPROXIMITY:
5250
                scriptEng.checkResult = false;
5251

5252
                // FUNCTION PARAMS:
5253
                // scriptEng.operands[0] = pos.x
5254
                // scriptEng.operands[1] = pos.y
5255
                // scriptEng.operands[2] = range.x
5256
                // scriptEng.operands[3] = range.y
5257
                //
5258
                // FUNCTION NOTES:
5259
                // - Sets scriptEng.checkResult
5260

5261
                if (scriptEng.operands[2] > 0 && scriptEng.operands[3] > 0) {
5262
                    for (int32 s = 0; s < videoSettings.screenCount; ++s) {
5263
                        int32 sx = abs(scriptEng.operands[0] - cameras[s].xpos);
5264
                        int32 sy = abs(scriptEng.operands[1] - cameras[s].ypos);
5265

5266
                        if (sx < scriptEng.operands[2] && sy < scriptEng.operands[3]) {
5267
                            scriptEng.checkResult = true;
5268
                            break;
5269
                        }
5270
                    }
5271
                }
5272
                else {
5273
                    if (scriptEng.operands[2] > 0) {
5274
                        for (int32 s = 0; s < videoSettings.screenCount; ++s) {
5275
                            int32 sx = abs(scriptEng.operands[0] - cameras[s].xpos);
5276

5277
                            if (sx < scriptEng.operands[2]) {
5278
                                scriptEng.checkResult = true;
5279
                                break;
5280
                            }
5281
                        }
5282
                    }
5283
                    else if (scriptEng.operands[3] > 0) {
5284
                        for (int32 s = 0; s < videoSettings.screenCount; ++s) {
5285
                            int32 sy = abs(scriptEng.operands[1] - cameras[s].ypos);
5286

5287
                            if (sy < scriptEng.operands[3]) {
5288
                                scriptEng.checkResult = true;
5289
                                break;
5290
                            }
5291
                        }
5292
                    }
5293
                }
5294
                break;
5295

5296
            case FUNC_SETSCREENCOUNT:
5297
                // FUNCTION PARAMS:
5298
                // scriptEng.operands[0] = screenCount
5299

5300
                RSDK::SetVideoSetting(VIDEOSETTING_SCREENCOUNT, scriptEng.operands[0]);
5301
                break;
5302

5303
            case FUNC_SETSCREENVERTICES:
5304
                // FUNCTION PARAMS:
5305
                // scriptEng.operands[0] = startVert2P_S1
5306
                // scriptEng.operands[1] = startVert2P_S2
5307
                // scriptEng.operands[2] = startVert3P_S1
5308
                // scriptEng.operands[3] = startVert3P_S2
5309
                // scriptEng.operands[4] = startVert3P_S3
5310

5311
                RSDK::SetScreenVertices(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3],
5312
                                        scriptEng.operands[4]);
5313
                break;
5314

5315
            case FUNC_GETINPUTDEVICEID:
5316
                // FUNCTION PARAMS:
5317
                // scriptEng.operands[0] = deviceID
5318
                // scriptEng.operands[1] = inputSlot
5319
                //
5320
                // FUNCTION NOTES:
5321
                // - Assigns the device's id to scriptEng.operands[0]
5322

5323
                scriptEng.operands[0] = GetInputDeviceID(scriptEng.operands[1]);
5324
                break;
5325

5326
            case FUNC_GETFILTEREDINPUTDEVICEID:
5327
                // FUNCTION PARAMS:
5328
                // scriptEng.operands[0] = deviceID
5329
                // scriptEng.operands[1] = confirmOnly
5330
                // scriptEng.operands[2] = unassignedOnly
5331
                // scriptEng.operands[3] = maxInactiveTimer
5332
                //
5333
                // FUNCTION NOTES:
5334
                // - Assigns the filtered device's id to scriptEng.operands[0]
5335

5336
                scriptEng.operands[0] = GetFilteredInputDeviceID(scriptEng.operands[1], scriptEng.operands[2] > 0, scriptEng.operands[3]);
5337
                break;
5338

5339
            case FUNC_GETINPUTDEVICETYPE:
5340
                // FUNCTION PARAMS:
5341
                // scriptEng.operands[0] = deviceType
5342
                // scriptEng.operands[1] = deviceID
5343
                //
5344
                // FUNCTION NOTES:
5345
                // - Assigns the device's type to scriptEng.operands[0]
5346

5347
                scriptEng.operands[0] = GetInputDeviceType(scriptEng.operands[1]);
5348
                break;
5349

5350
            case FUNC_ISINPUTDEVICEASSIGNED:
5351
                // FUNCTION PARAMS:
5352
                // scriptEng.operands[0] = deviceID
5353

5354
                scriptEng.checkResult = IsInputDeviceAssigned(scriptEng.operands[0]);
5355
                break;
5356

5357
            case FUNC_ASSIGNINPUTSLOTTODEVICE:
5358
                // FUNCTION PARAMS:
5359
                // scriptEng.operands[0] = inputSlot
5360
                // scriptEng.operands[1] = deviceID
5361

5362
                AssignInputSlotToDevice(scriptEng.operands[0], scriptEng.operands[1]);
5363
                break;
5364

5365
            case FUNC_ISSLOTASSIGNED:
5366
                // FUNCTION PARAMS:
5367
                // scriptEng.operands[0] = inputSlot
5368
                //
5369
                // FUNCTION NOTES:
5370
                // - Sets scriptEng.checkResult
5371

5372
                scriptEng.checkResult = IsInputSlotAssigned(scriptEng.operands[0]);
5373
                break;
5374

5375
            case FUNC_RESETINPUTSLOTASSIGNMENTS:
5376
                // FUNCTION PARAMS:
5377
                // None
5378

5379
                ResetInputSlotAssignments();
5380
                break;
5381
        }
5382

5383
        // Set Values
5384
        if (opcodeSize > 0)
5385
            scriptCodePtr -= scriptCodePtr - scriptCodeOffset;
5386
        for (int32 i = 0; i < opcodeSize; ++i) {
5387
            int32 opcodeType = scriptCode[scriptCodePtr++];
5388
            if (opcodeType == SCRIPTVAR_VAR) {
5389
                int32 arrayVal = 0;
5390
                switch (scriptCode[scriptCodePtr++]) { // variable
5391
                    case VARARR_NONE: arrayVal = objectEntityPos; break;
5392
                    case VARARR_ARRAY:
5393
                        if (scriptCode[scriptCodePtr++] == 1)
5394
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
5395
                        else
5396
                            arrayVal = scriptCode[scriptCodePtr++];
5397
                        break;
5398
                    case VARARR_ENTNOPLUS1:
5399
                        if (scriptCode[scriptCodePtr++] == 1)
5400
                            arrayVal = objectEntityPos + scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
5401
                        else
5402
                            arrayVal = objectEntityPos + scriptCode[scriptCodePtr++];
5403
                        break;
5404
                    case VARARR_ENTNOMINUS1:
5405
                        if (scriptCode[scriptCodePtr++] == 1)
5406
                            arrayVal = objectEntityPos - scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
5407
                        else
5408
                            arrayVal = objectEntityPos - scriptCode[scriptCodePtr++];
5409
                        break;
5410
                    default: break;
5411
                }
5412

5413
                // Variables
5414
                switch (scriptCode[scriptCodePtr++]) {
5415
                    default: break;
5416
                    case VAR_TEMP0: scriptEng.temp[0] = scriptEng.operands[i]; break;
5417
                    case VAR_TEMP1: scriptEng.temp[1] = scriptEng.operands[i]; break;
5418
                    case VAR_TEMP2: scriptEng.temp[2] = scriptEng.operands[i]; break;
5419
                    case VAR_TEMP3: scriptEng.temp[3] = scriptEng.operands[i]; break;
5420
                    case VAR_TEMP4: scriptEng.temp[4] = scriptEng.operands[i]; break;
5421
                    case VAR_TEMP5: scriptEng.temp[5] = scriptEng.operands[i]; break;
5422
                    case VAR_TEMP6: scriptEng.temp[6] = scriptEng.operands[i]; break;
5423
                    case VAR_TEMP7: scriptEng.temp[7] = scriptEng.operands[i]; break;
5424
                    case VAR_CHECKRESULT: scriptEng.checkResult = scriptEng.operands[i]; break;
5425
                    case VAR_ARRAYPOS0: scriptEng.arrayPosition[0] = scriptEng.operands[i]; break;
5426
                    case VAR_ARRAYPOS1: scriptEng.arrayPosition[1] = scriptEng.operands[i]; break;
5427
                    case VAR_ARRAYPOS2: scriptEng.arrayPosition[2] = scriptEng.operands[i]; break;
5428
                    case VAR_ARRAYPOS3: scriptEng.arrayPosition[3] = scriptEng.operands[i]; break;
5429
                    case VAR_ARRAYPOS4: scriptEng.arrayPosition[4] = scriptEng.operands[i]; break;
5430
                    case VAR_ARRAYPOS5: scriptEng.arrayPosition[5] = scriptEng.operands[i]; break;
5431
                    case VAR_ARRAYPOS6: scriptEng.arrayPosition[6] = scriptEng.operands[i]; break;
5432
                    case VAR_ARRAYPOS7: scriptEng.arrayPosition[7] = scriptEng.operands[i]; break;
5433
                    case VAR_GLOBAL: globalVariables[arrayVal].value = scriptEng.operands[i]; break;
5434
                    case VAR_LOCAL: scriptCode[arrayVal] = scriptEng.operands[i]; break;
5435
                    case VAR_OBJECTENTITYPOS: break;
5436
                    case VAR_OBJECTGROUPID: {
5437
                        objectEntityList[arrayVal].groupID = scriptEng.operands[i];
5438
                        break;
5439
                    }
5440
                    case VAR_OBJECTTYPE: {
5441
                        objectEntityList[arrayVal].type = scriptEng.operands[i];
5442
                        break;
5443
                    }
5444
                    case VAR_OBJECTPROPERTYVALUE: {
5445
                        objectEntityList[arrayVal].propertyValue = scriptEng.operands[i];
5446
                        break;
5447
                    }
5448
                    case VAR_OBJECTXPOS: {
5449
                        objectEntityList[arrayVal].xpos = scriptEng.operands[i];
5450
                        break;
5451
                    }
5452
                    case VAR_OBJECTYPOS: {
5453
                        objectEntityList[arrayVal].ypos = scriptEng.operands[i];
5454
                        break;
5455
                    }
5456
                    case VAR_OBJECTIXPOS: {
5457
                        objectEntityList[arrayVal].xpos = scriptEng.operands[i] << 16;
5458
                        break;
5459
                    }
5460
                    case VAR_OBJECTIYPOS: {
5461
                        objectEntityList[arrayVal].ypos = scriptEng.operands[i] << 16;
5462
                        break;
5463
                    }
5464
                    case VAR_OBJECTXVEL: {
5465
                        objectEntityList[arrayVal].xvel = scriptEng.operands[i];
5466
                        break;
5467
                    }
5468
                    case VAR_OBJECTYVEL: {
5469
                        objectEntityList[arrayVal].yvel = scriptEng.operands[i];
5470
                        break;
5471
                    }
5472
                    case VAR_OBJECTSPEED: {
5473
                        objectEntityList[arrayVal].speed = scriptEng.operands[i];
5474
                        break;
5475
                    }
5476
                    case VAR_OBJECTSTATE: {
5477
                        objectEntityList[arrayVal].state = scriptEng.operands[i];
5478
                        break;
5479
                    }
5480
                    case VAR_OBJECTROTATION: {
5481
                        objectEntityList[arrayVal].rotation = scriptEng.operands[i];
5482
                        break;
5483
                    }
5484
                    case VAR_OBJECTSCALE: {
5485
                        objectEntityList[arrayVal].scale = scriptEng.operands[i];
5486
                        break;
5487
                    }
5488
                    case VAR_OBJECTPRIORITY: {
5489
                        objectEntityList[arrayVal].priority = scriptEng.operands[i];
5490
                        break;
5491
                    }
5492
                    case VAR_OBJECTDRAWORDER: {
5493
                        objectEntityList[arrayVal].drawOrder = scriptEng.operands[i];
5494
                        break;
5495
                    }
5496
                    case VAR_OBJECTDIRECTION: {
5497
                        objectEntityList[arrayVal].direction = scriptEng.operands[i];
5498
                        break;
5499
                    }
5500
                    case VAR_OBJECTINKEFFECT: {
5501
                        objectEntityList[arrayVal].inkEffect = scriptEng.operands[i];
5502
                        break;
5503
                    }
5504
                    case VAR_OBJECTALPHA: {
5505
                        objectEntityList[arrayVal].alpha = scriptEng.operands[i];
5506
                        break;
5507
                    }
5508
                    case VAR_OBJECTFRAME: {
5509
                        objectEntityList[arrayVal].frame = scriptEng.operands[i];
5510
                        break;
5511
                    }
5512
                    case VAR_OBJECTANIMATION: {
5513
                        objectEntityList[arrayVal].animation = scriptEng.operands[i];
5514
                        break;
5515
                    }
5516
                    case VAR_OBJECTPREVANIMATION: {
5517
                        objectEntityList[arrayVal].prevAnimation = scriptEng.operands[i];
5518
                        break;
5519
                    }
5520
                    case VAR_OBJECTANIMATIONSPEED: {
5521
                        objectEntityList[arrayVal].animationSpeed = scriptEng.operands[i];
5522
                        break;
5523
                    }
5524
                    case VAR_OBJECTANIMATIONTIMER: {
5525
                        objectEntityList[arrayVal].animationTimer = scriptEng.operands[i];
5526
                        break;
5527
                    }
5528
                    case VAR_OBJECTANGLE: {
5529
                        objectEntityList[arrayVal].angle = scriptEng.operands[i];
5530
                        break;
5531
                    }
5532
                    case VAR_OBJECTLOOKPOSX: {
5533
                        objectEntityList[arrayVal].lookPosX = scriptEng.operands[i];
5534
                        break;
5535
                    }
5536
                    case VAR_OBJECTLOOKPOSY: {
5537
                        objectEntityList[arrayVal].lookPosY = scriptEng.operands[i];
5538
                        break;
5539
                    }
5540
                    case VAR_OBJECTCOLLISIONMODE: {
5541
                        objectEntityList[arrayVal].collisionMode = scriptEng.operands[i];
5542
                        break;
5543
                    }
5544
                    case VAR_OBJECTCOLLISIONPLANE: {
5545
                        objectEntityList[arrayVal].collisionPlane = scriptEng.operands[i];
5546
                        break;
5547
                    }
5548
                    case VAR_OBJECTCONTROLMODE: {
5549
                        objectEntityList[arrayVal].controlMode = scriptEng.operands[i];
5550
                        break;
5551
                    }
5552
                    case VAR_OBJECTCONTROLLOCK: {
5553
                        objectEntityList[arrayVal].controlLock = scriptEng.operands[i];
5554
                        break;
5555
                    }
5556
                    case VAR_OBJECTPUSHING: {
5557
                        objectEntityList[arrayVal].pushing = scriptEng.operands[i];
5558
                        break;
5559
                    }
5560
                    case VAR_OBJECTVISIBLE: {
5561
                        objectEntityList[arrayVal].visible = scriptEng.operands[i];
5562
                        break;
5563
                    }
5564
                    case VAR_OBJECTTILECOLLISIONS: {
5565
                        objectEntityList[arrayVal].tileCollisions = scriptEng.operands[i];
5566
                        break;
5567
                    }
5568
                    case VAR_OBJECTINTERACTION: {
5569
                        objectEntityList[arrayVal].objectInteractions = scriptEng.operands[i];
5570
                        break;
5571
                    }
5572
                    case VAR_OBJECTGRAVITY: {
5573
                        objectEntityList[arrayVal].gravity = scriptEng.operands[i];
5574
                        break;
5575
                    }
5576
                    case VAR_OBJECTUP: {
5577
                        objectEntityList[arrayVal].up = scriptEng.operands[i];
5578
                        break;
5579
                    }
5580
                    case VAR_OBJECTDOWN: {
5581
                        objectEntityList[arrayVal].down = scriptEng.operands[i];
5582
                        break;
5583
                    }
5584
                    case VAR_OBJECTLEFT: {
5585
                        objectEntityList[arrayVal].left = scriptEng.operands[i];
5586
                        break;
5587
                    }
5588
                    case VAR_OBJECTRIGHT: {
5589
                        objectEntityList[arrayVal].right = scriptEng.operands[i];
5590
                        break;
5591
                    }
5592
                    case VAR_OBJECTJUMPPRESS: {
5593
                        objectEntityList[arrayVal].jumpPress = scriptEng.operands[i];
5594
                        break;
5595
                    }
5596
                    case VAR_OBJECTJUMPHOLD: {
5597
                        objectEntityList[arrayVal].jumpHold = scriptEng.operands[i];
5598
                        break;
5599
                    }
5600
                    case VAR_OBJECTSCROLLTRACKING: {
5601
                        objectEntityList[arrayVal].scrollTracking = scriptEng.operands[i];
5602
                        break;
5603
                    }
5604
                    case VAR_OBJECTFLOORSENSORL: {
5605
                        objectEntityList[arrayVal].floorSensors[0] = scriptEng.operands[i];
5606
                        break;
5607
                    }
5608
                    case VAR_OBJECTFLOORSENSORC: {
5609
                        objectEntityList[arrayVal].floorSensors[1] = scriptEng.operands[i];
5610
                        break;
5611
                    }
5612
                    case VAR_OBJECTFLOORSENSORR: {
5613
                        objectEntityList[arrayVal].floorSensors[2] = scriptEng.operands[i];
5614
                        break;
5615
                    }
5616
                    case VAR_OBJECTFLOORSENSORLC: {
5617
                        objectEntityList[arrayVal].floorSensors[3] = scriptEng.operands[i];
5618
                        break;
5619
                    }
5620
                    case VAR_OBJECTFLOORSENSORRC: {
5621
                        objectEntityList[arrayVal].floorSensors[4] = scriptEng.operands[i];
5622
                        break;
5623
                    }
5624
                    case VAR_OBJECTCOLLISIONLEFT: {
5625
                        break;
5626
                    }
5627
                    case VAR_OBJECTCOLLISIONTOP: {
5628
                        break;
5629
                    }
5630
                    case VAR_OBJECTCOLLISIONRIGHT: {
5631
                        break;
5632
                    }
5633
                    case VAR_OBJECTCOLLISIONBOTTOM: {
5634
                        break;
5635
                    }
5636
                    case VAR_OBJECTOUTOFBOUNDS: {
5637
                        break;
5638
                    }
5639
                    case VAR_OBJECTSPRITESHEET: {
5640
                        objectScriptList[objectEntityList[arrayVal].type].spriteSheetID = scriptEng.operands[i];
5641
                        break;
5642
                    }
5643
                    case VAR_OBJECTVALUE0: {
5644
                        objectEntityList[arrayVal].values[0] = scriptEng.operands[i];
5645
                        break;
5646
                    }
5647
                    case VAR_OBJECTVALUE1: {
5648
                        objectEntityList[arrayVal].values[1] = scriptEng.operands[i];
5649
                        break;
5650
                    }
5651
                    case VAR_OBJECTVALUE2: {
5652
                        objectEntityList[arrayVal].values[2] = scriptEng.operands[i];
5653
                        break;
5654
                    }
5655
                    case VAR_OBJECTVALUE3: {
5656
                        objectEntityList[arrayVal].values[3] = scriptEng.operands[i];
5657
                        break;
5658
                    }
5659
                    case VAR_OBJECTVALUE4: {
5660
                        objectEntityList[arrayVal].values[4] = scriptEng.operands[i];
5661
                        break;
5662
                    }
5663
                    case VAR_OBJECTVALUE5: {
5664
                        objectEntityList[arrayVal].values[5] = scriptEng.operands[i];
5665
                        break;
5666
                    }
5667
                    case VAR_OBJECTVALUE6: {
5668
                        objectEntityList[arrayVal].values[6] = scriptEng.operands[i];
5669
                        break;
5670
                    }
5671
                    case VAR_OBJECTVALUE7: {
5672
                        objectEntityList[arrayVal].values[7] = scriptEng.operands[i];
5673
                        break;
5674
                    }
5675
                    case VAR_OBJECTVALUE8: {
5676
                        objectEntityList[arrayVal].values[8] = scriptEng.operands[i];
5677
                        break;
5678
                    }
5679
                    case VAR_OBJECTVALUE9: {
5680
                        objectEntityList[arrayVal].values[9] = scriptEng.operands[i];
5681
                        break;
5682
                    }
5683
                    case VAR_OBJECTVALUE10: {
5684
                        objectEntityList[arrayVal].values[10] = scriptEng.operands[i];
5685
                        break;
5686
                    }
5687
                    case VAR_OBJECTVALUE11: {
5688
                        objectEntityList[arrayVal].values[11] = scriptEng.operands[i];
5689
                        break;
5690
                    }
5691
                    case VAR_OBJECTVALUE12: {
5692
                        objectEntityList[arrayVal].values[12] = scriptEng.operands[i];
5693
                        break;
5694
                    }
5695
                    case VAR_OBJECTVALUE13: {
5696
                        objectEntityList[arrayVal].values[13] = scriptEng.operands[i];
5697
                        break;
5698
                    }
5699
                    case VAR_OBJECTVALUE14: {
5700
                        objectEntityList[arrayVal].values[14] = scriptEng.operands[i];
5701
                        break;
5702
                    }
5703
                    case VAR_OBJECTVALUE15: {
5704
                        objectEntityList[arrayVal].values[15] = scriptEng.operands[i];
5705
                        break;
5706
                    }
5707
                    case VAR_OBJECTVALUE16: {
5708
                        objectEntityList[arrayVal].values[16] = scriptEng.operands[i];
5709
                        break;
5710
                    }
5711
                    case VAR_OBJECTVALUE17: {
5712
                        objectEntityList[arrayVal].values[17] = scriptEng.operands[i];
5713
                        break;
5714
                    }
5715
                    case VAR_OBJECTVALUE18: {
5716
                        objectEntityList[arrayVal].values[18] = scriptEng.operands[i];
5717
                        break;
5718
                    }
5719
                    case VAR_OBJECTVALUE19: {
5720
                        objectEntityList[arrayVal].values[19] = scriptEng.operands[i];
5721
                        break;
5722
                    }
5723
                    case VAR_OBJECTVALUE20: {
5724
                        objectEntityList[arrayVal].values[20] = scriptEng.operands[i];
5725
                        break;
5726
                    }
5727
                    case VAR_OBJECTVALUE21: {
5728
                        objectEntityList[arrayVal].values[21] = scriptEng.operands[i];
5729
                        break;
5730
                    }
5731
                    case VAR_OBJECTVALUE22: {
5732
                        objectEntityList[arrayVal].values[22] = scriptEng.operands[i];
5733
                        break;
5734
                    }
5735
                    case VAR_OBJECTVALUE23: {
5736
                        objectEntityList[arrayVal].values[23] = scriptEng.operands[i];
5737
                        break;
5738
                    }
5739
                    case VAR_OBJECTVALUE24: {
5740
                        objectEntityList[arrayVal].values[24] = scriptEng.operands[i];
5741
                        break;
5742
                    }
5743
                    case VAR_OBJECTVALUE25: {
5744
                        objectEntityList[arrayVal].values[25] = scriptEng.operands[i];
5745
                        break;
5746
                    }
5747
                    case VAR_OBJECTVALUE26: {
5748
                        objectEntityList[arrayVal].values[26] = scriptEng.operands[i];
5749
                        break;
5750
                    }
5751
                    case VAR_OBJECTVALUE27: {
5752
                        objectEntityList[arrayVal].values[27] = scriptEng.operands[i];
5753
                        break;
5754
                    }
5755
                    case VAR_OBJECTVALUE28: {
5756
                        objectEntityList[arrayVal].values[28] = scriptEng.operands[i];
5757
                        break;
5758
                    }
5759
                    case VAR_OBJECTVALUE29: {
5760
                        objectEntityList[arrayVal].values[29] = scriptEng.operands[i];
5761
                        break;
5762
                    }
5763
                    case VAR_OBJECTVALUE30: {
5764
                        objectEntityList[arrayVal].values[30] = scriptEng.operands[i];
5765
                        break;
5766
                    }
5767
                    case VAR_OBJECTVALUE31: {
5768
                        objectEntityList[arrayVal].values[31] = scriptEng.operands[i];
5769
                        break;
5770
                    }
5771
                    case VAR_OBJECTVALUE32: {
5772
                        objectEntityList[arrayVal].values[32] = scriptEng.operands[i];
5773
                        break;
5774
                    }
5775
                    case VAR_OBJECTVALUE33: {
5776
                        objectEntityList[arrayVal].values[33] = scriptEng.operands[i];
5777
                        break;
5778
                    }
5779
                    case VAR_OBJECTVALUE34: {
5780
                        objectEntityList[arrayVal].values[34] = scriptEng.operands[i];
5781
                        break;
5782
                    }
5783
                    case VAR_OBJECTVALUE35: {
5784
                        objectEntityList[arrayVal].values[35] = scriptEng.operands[i];
5785
                        break;
5786
                    }
5787
                    case VAR_OBJECTVALUE36: {
5788
                        objectEntityList[arrayVal].values[36] = scriptEng.operands[i];
5789
                        break;
5790
                    }
5791
                    case VAR_OBJECTVALUE37: {
5792
                        objectEntityList[arrayVal].values[37] = scriptEng.operands[i];
5793
                        break;
5794
                    }
5795
                    case VAR_OBJECTVALUE38: {
5796
                        objectEntityList[arrayVal].values[38] = scriptEng.operands[i];
5797
                        break;
5798
                    }
5799
                    case VAR_OBJECTVALUE39: {
5800
                        objectEntityList[arrayVal].values[39] = scriptEng.operands[i];
5801
                        break;
5802
                    }
5803
                    case VAR_OBJECTVALUE40: {
5804
                        objectEntityList[arrayVal].values[40] = scriptEng.operands[i];
5805
                        break;
5806
                    }
5807
                    case VAR_OBJECTVALUE41: {
5808
                        objectEntityList[arrayVal].values[41] = scriptEng.operands[i];
5809
                        break;
5810
                    }
5811
                    case VAR_OBJECTVALUE42: {
5812
                        objectEntityList[arrayVal].values[42] = scriptEng.operands[i];
5813
                        break;
5814
                    }
5815
                    case VAR_OBJECTVALUE43: {
5816
                        objectEntityList[arrayVal].values[43] = scriptEng.operands[i];
5817
                        break;
5818
                    }
5819
                    case VAR_OBJECTVALUE44: {
5820
                        objectEntityList[arrayVal].values[44] = scriptEng.operands[i];
5821
                        break;
5822
                    }
5823
                    case VAR_OBJECTVALUE45: {
5824
                        objectEntityList[arrayVal].values[45] = scriptEng.operands[i];
5825
                        break;
5826
                    }
5827
                    case VAR_OBJECTVALUE46: {
5828
                        objectEntityList[arrayVal].values[46] = scriptEng.operands[i];
5829
                        break;
5830
                    }
5831
                    case VAR_OBJECTVALUE47: {
5832
                        objectEntityList[arrayVal].values[47] = scriptEng.operands[i];
5833
                        break;
5834
                    }
5835
                    case VAR_STAGESTATE: stageMode = scriptEng.operands[i]; break;
5836
                    case VAR_STAGEACTIVELIST: {
5837
                        int32 listID = scriptEng.operands[i];
5838
                        if (listID < sceneInfo.categoryCount) {
5839
                            int32 prevListPos = sceneInfo.listCategory[sceneInfo.activeCategory].sceneOffsetStart;
5840

5841
                            sceneInfo.activeCategory = listID;
5842
                            SceneListInfo *list      = &sceneInfo.listCategory[sceneInfo.activeCategory];
5843

5844
                            sceneInfo.listPos = list->sceneOffsetStart + RSDK::sceneInfo.listPos - prevListPos;
5845
                            if (sceneInfo.listPos >= list->sceneOffsetEnd)
5846
                                sceneInfo.listPos = list->sceneOffsetEnd;
5847
                        }
5848
                        break;
5849
                    }
5850
                    case VAR_STAGELISTPOS: {
5851
                        SceneListInfo *list = &sceneInfo.listCategory[sceneInfo.activeCategory];
5852

5853
                        if (list->sceneOffsetStart + scriptEng.operands[i] <= list->sceneOffsetEnd)
5854
                            sceneInfo.listPos = list->sceneOffsetStart + scriptEng.operands[i];
5855
                        break;
5856
                    }
5857
                    case VAR_STAGETIMEENABLED: timeEnabled = scriptEng.operands[i]; break;
5858
                    case VAR_STAGEMILLISECONDS: stageMilliseconds = scriptEng.operands[i]; break;
5859
                    case VAR_STAGESECONDS: stageSeconds = scriptEng.operands[i]; break;
5860
                    case VAR_STAGEMINUTES: stageMinutes = scriptEng.operands[i]; break;
5861
                    case VAR_STAGEACTNUM: actID = scriptEng.operands[i]; break;
5862
                    case VAR_STAGEPAUSEENABLED: pauseEnabled = scriptEng.operands[i]; break;
5863
                    case VAR_STAGELISTSIZE: break;
5864
                    case VAR_STAGENEWXBOUNDARY1: newXBoundary1 = scriptEng.operands[i]; break;
5865
                    case VAR_STAGENEWXBOUNDARY2: newXBoundary2 = scriptEng.operands[i]; break;
5866
                    case VAR_STAGENEWYBOUNDARY1: newYBoundary1 = scriptEng.operands[i]; break;
5867
                    case VAR_STAGENEWYBOUNDARY2: newYBoundary2 = scriptEng.operands[i]; break;
5868
                    case VAR_STAGECURXBOUNDARY1:
5869
                        if (curXBoundary1 != scriptEng.operands[i]) {
5870
                            curXBoundary1 = scriptEng.operands[i];
5871
                            newXBoundary1 = scriptEng.operands[i];
5872
                        }
5873
                        break;
5874
                    case VAR_STAGECURXBOUNDARY2:
5875
                        if (curXBoundary2 != scriptEng.operands[i]) {
5876
                            curXBoundary2 = scriptEng.operands[i];
5877
                            newXBoundary2 = scriptEng.operands[i];
5878
                        }
5879
                        break;
5880
                    case VAR_STAGECURYBOUNDARY1:
5881
                        if (curYBoundary1 != scriptEng.operands[i]) {
5882
                            curYBoundary1 = scriptEng.operands[i];
5883
                            newYBoundary1 = scriptEng.operands[i];
5884
                        }
5885
                        break;
5886
                    case VAR_STAGECURYBOUNDARY2:
5887
                        if (curYBoundary2 != scriptEng.operands[i]) {
5888
                            curYBoundary2 = scriptEng.operands[i];
5889
                            newYBoundary2 = scriptEng.operands[i];
5890
                        }
5891
                        break;
5892
                    case VAR_STAGEDEFORMATIONDATA0: bgDeformationData0[arrayVal] = scriptEng.operands[i]; break;
5893
                    case VAR_STAGEDEFORMATIONDATA1: bgDeformationData1[arrayVal] = scriptEng.operands[i]; break;
5894
                    case VAR_STAGEDEFORMATIONDATA2: bgDeformationData2[arrayVal] = scriptEng.operands[i]; break;
5895
                    case VAR_STAGEDEFORMATIONDATA3: bgDeformationData3[arrayVal] = scriptEng.operands[i]; break;
5896
                    case VAR_STAGEWATERLEVEL: waterLevel = scriptEng.operands[i]; break;
5897
                    case VAR_STAGEACTIVELAYER: activeTileLayers[arrayVal] = scriptEng.operands[i]; break;
5898
                    case VAR_STAGEMIDPOINT: tLayerMidPoint = scriptEng.operands[i]; break;
5899
                    case VAR_STAGEPLAYERLISTPOS: playerListPos = scriptEng.operands[i]; break;
5900
                    case VAR_STAGEDEBUGMODE: debugMode = scriptEng.operands[i]; break;
5901
                    case VAR_STAGEENTITYPOS: objectEntityPos = scriptEng.operands[i]; break;
5902
                    case VAR_SCREENCAMERAENABLED: currentCamera->enabled = scriptEng.operands[i]; break;
5903
                    case VAR_SCREENCAMERATARGET: currentCamera->target = scriptEng.operands[i]; break;
5904
                    case VAR_SCREENCAMERASTYLE: currentCamera->style = scriptEng.operands[i]; break;
5905
                    case VAR_SCREENCAMERAX: currentCamera->xpos = scriptEng.operands[i]; break;
5906
                    case VAR_SCREENCAMERAY: currentCamera->ypos = scriptEng.operands[i]; break;
5907
                    case VAR_SCREENDRAWLISTSIZE: drawListEntries[arrayVal].listSize = scriptEng.operands[i]; break;
5908
                    case VAR_SCREENXCENTER: break;
5909
                    case VAR_SCREENYCENTER: break;
5910
                    case VAR_SCREENXSIZE: break;
5911
                    case VAR_SCREENYSIZE: break;
5912
                    case VAR_SCREENXOFFSET: xScrollOffset = scriptEng.operands[i]; break;
5913
                    case VAR_SCREENYOFFSET: yScrollOffset = scriptEng.operands[i]; break;
5914
                    case VAR_SCREENSHAKEX: cameraShakeX = scriptEng.operands[i]; break;
5915
                    case VAR_SCREENSHAKEY: cameraShakeY = scriptEng.operands[i]; break;
5916
                    case VAR_SCREENADJUSTCAMERAY: currentCamera->adjustY = scriptEng.operands[i]; break;
5917
                    case VAR_TOUCHSCREENDOWN: break;
5918
                    case VAR_TOUCHSCREENXPOS: break;
5919
                    case VAR_TOUCHSCREENYPOS: break;
5920
                    case VAR_MUSICVOLUME: SetMusicVolume(scriptEng.operands[i]); break;
5921
                    case VAR_MUSICCURRENTTRACK: break;
5922
                    case VAR_MUSICPOSITION: break;
5923
                    case VAR_KEYDOWNUP: controller[arrayVal].keyUp.down = scriptEng.operands[i]; break;
5924
                    case VAR_KEYDOWNDOWN: controller[arrayVal].keyDown.down = scriptEng.operands[i]; break;
5925
                    case VAR_KEYDOWNLEFT: controller[arrayVal].keyLeft.down = scriptEng.operands[i]; break;
5926
                    case VAR_KEYDOWNRIGHT: controller[arrayVal].keyRight.down = scriptEng.operands[i]; break;
5927
                    case VAR_KEYDOWNBUTTONA: controller[arrayVal].keyA.down = scriptEng.operands[i]; break;
5928
                    case VAR_KEYDOWNBUTTONB: controller[arrayVal].keyB.down = scriptEng.operands[i]; break;
5929
                    case VAR_KEYDOWNBUTTONC: controller[arrayVal].keyC.down = scriptEng.operands[i]; break;
5930
                    case VAR_KEYDOWNBUTTONX: controller[arrayVal].keyX.down = scriptEng.operands[i]; break;
5931
                    case VAR_KEYDOWNBUTTONY: controller[arrayVal].keyY.down = scriptEng.operands[i]; break;
5932
                    case VAR_KEYDOWNBUTTONZ: controller[arrayVal].keyZ.down = scriptEng.operands[i]; break;
5933
                    case VAR_KEYDOWNBUTTONL: triggerL[arrayVal].keyBumper.down = scriptEng.operands[i]; break;
5934
                    case VAR_KEYDOWNBUTTONR: triggerR[arrayVal].keyBumper.down = scriptEng.operands[i]; break;
5935
                    case VAR_KEYDOWNSTART: controller[arrayVal].keyStart.down = scriptEng.operands[i]; break;
5936
                    case VAR_KEYDOWNSELECT: controller[arrayVal].keySelect.down = scriptEng.operands[i]; break;
5937
                    case VAR_KEYPRESSUP: controller[arrayVal].keyUp.press = scriptEng.operands[i]; break;
5938
                    case VAR_KEYPRESSDOWN: controller[arrayVal].keyDown.press = scriptEng.operands[i]; break;
5939
                    case VAR_KEYPRESSLEFT: controller[arrayVal].keyLeft.press = scriptEng.operands[i]; break;
5940
                    case VAR_KEYPRESSRIGHT: controller[arrayVal].keyRight.press = scriptEng.operands[i]; break;
5941
                    case VAR_KEYPRESSBUTTONA: controller[arrayVal].keyA.press = scriptEng.operands[i]; break;
5942
                    case VAR_KEYPRESSBUTTONB: controller[arrayVal].keyB.press = scriptEng.operands[i]; break;
5943
                    case VAR_KEYPRESSBUTTONC: controller[arrayVal].keyC.press = scriptEng.operands[i]; break;
5944
                    case VAR_KEYPRESSBUTTONX: controller[arrayVal].keyX.press = scriptEng.operands[i]; break;
5945
                    case VAR_KEYPRESSBUTTONY: controller[arrayVal].keyY.press = scriptEng.operands[i]; break;
5946
                    case VAR_KEYPRESSBUTTONZ: controller[arrayVal].keyZ.press = scriptEng.operands[i]; break;
5947
                    case VAR_KEYPRESSBUTTONL: triggerL[arrayVal].keyBumper.press = scriptEng.operands[i]; break;
5948
                    case VAR_KEYPRESSBUTTONR: triggerR[arrayVal].keyBumper.press = scriptEng.operands[i]; break;
5949
                    case VAR_KEYPRESSSTART: controller[arrayVal].keyStart.press = scriptEng.operands[i]; break;
5950
                    case VAR_KEYPRESSSELECT: controller[arrayVal].keySelect.press = scriptEng.operands[i]; break;
5951
                    case VAR_MENU1SELECTION: gameMenu[0].selection1 = scriptEng.operands[i]; break;
5952
                    case VAR_MENU2SELECTION: gameMenu[1].selection1 = scriptEng.operands[i]; break;
5953
                    case VAR_TILELAYERXSIZE: stageLayouts[arrayVal].xsize = scriptEng.operands[i]; break;
5954
                    case VAR_TILELAYERYSIZE: stageLayouts[arrayVal].ysize = scriptEng.operands[i]; break;
5955
                    case VAR_TILELAYERTYPE: stageLayouts[arrayVal].type = scriptEng.operands[i]; break;
5956
                    case VAR_TILELAYERANGLE: {
5957
                        int32 angle = scriptEng.operands[i] + 0x200;
5958
                        if (scriptEng.operands[i] >= 0)
5959
                            angle = scriptEng.operands[i];
5960
                        stageLayouts[arrayVal].angle = angle & 0x1FF;
5961
                        break;
5962
                    }
5963
                    case VAR_TILELAYERXPOS: stageLayouts[arrayVal].xpos = scriptEng.operands[i]; break;
5964
                    case VAR_TILELAYERYPOS: stageLayouts[arrayVal].ypos = scriptEng.operands[i]; break;
5965
                    case VAR_TILELAYERZPOS: stageLayouts[arrayVal].zpos = scriptEng.operands[i]; break;
5966
                    case VAR_TILELAYERPARALLAXFACTOR: stageLayouts[arrayVal].parallaxFactor = scriptEng.operands[i]; break;
5967
                    case VAR_TILELAYERSCROLLSPEED: stageLayouts[arrayVal].scrollSpeed = scriptEng.operands[i]; break;
5968
                    case VAR_TILELAYERSCROLLPOS: stageLayouts[arrayVal].scrollPos = scriptEng.operands[i]; break;
5969
                    case VAR_TILELAYERDEFORMATIONOFFSET: stageLayouts[arrayVal].deformationOffset = scriptEng.operands[i]; break;
5970
                    case VAR_TILELAYERDEFORMATIONOFFSETW: stageLayouts[arrayVal].deformationOffsetW = scriptEng.operands[i]; break;
5971
                    case VAR_HPARALLAXPARALLAXFACTOR: hParallax.parallaxFactor[arrayVal] = scriptEng.operands[i]; break;
5972
                    case VAR_HPARALLAXSCROLLSPEED: hParallax.scrollSpeed[arrayVal] = scriptEng.operands[i]; break;
5973
                    case VAR_HPARALLAXSCROLLPOS: hParallax.scrollPos[arrayVal] = scriptEng.operands[i]; break;
5974
                    case VAR_VPARALLAXPARALLAXFACTOR: vParallax.parallaxFactor[arrayVal] = scriptEng.operands[i]; break;
5975
                    case VAR_VPARALLAXSCROLLSPEED: vParallax.scrollSpeed[arrayVal] = scriptEng.operands[i]; break;
5976
                    case VAR_VPARALLAXSCROLLPOS: vParallax.scrollPos[arrayVal] = scriptEng.operands[i]; break;
5977
                    case VAR_SCENE3DVERTEXCOUNT: vertexCount = scriptEng.operands[i]; break;
5978
                    case VAR_SCENE3DFACECOUNT: faceCount = scriptEng.operands[i]; break;
5979
                    case VAR_SCENE3DPROJECTIONX: projectionX = scriptEng.operands[i]; break;
5980
                    case VAR_SCENE3DPROJECTIONY: projectionY = scriptEng.operands[i]; break;
5981
                    case VAR_SCENE3DFOGCOLOR: fogColor = scriptEng.operands[i]; break;
5982
                    case VAR_SCENE3DFOGSTRENGTH: fogStrength = scriptEng.operands[i]; break;
5983
                    case VAR_VERTEXBUFFERX: vertexBuffer[arrayVal].x = scriptEng.operands[i]; break;
5984
                    case VAR_VERTEXBUFFERY: vertexBuffer[arrayVal].y = scriptEng.operands[i]; break;
5985
                    case VAR_VERTEXBUFFERZ: vertexBuffer[arrayVal].z = scriptEng.operands[i]; break;
5986
                    case VAR_VERTEXBUFFERU: vertexBuffer[arrayVal].u = scriptEng.operands[i]; break;
5987
                    case VAR_VERTEXBUFFERV: vertexBuffer[arrayVal].v = scriptEng.operands[i]; break;
5988
                    case VAR_FACEBUFFERA: faceBuffer[arrayVal].a = scriptEng.operands[i]; break;
5989
                    case VAR_FACEBUFFERB: faceBuffer[arrayVal].b = scriptEng.operands[i]; break;
5990
                    case VAR_FACEBUFFERC: faceBuffer[arrayVal].c = scriptEng.operands[i]; break;
5991
                    case VAR_FACEBUFFERD: faceBuffer[arrayVal].d = scriptEng.operands[i]; break;
5992
                    case VAR_FACEBUFFERFLAG: faceBuffer[arrayVal].flag = scriptEng.operands[i]; break;
5993
                    case VAR_FACEBUFFERCOLOR: faceBuffer[arrayVal].color = scriptEng.operands[i]; break;
5994
                    case VAR_SAVERAM: saveRAM[arrayVal] = scriptEng.operands[i]; break;
5995
                    case VAR_ENGINESTATE: gameMode = scriptEng.operands[i]; break;
5996
                    case VAR_ENGINELANGUAGE: language = scriptEng.operands[i]; break;
5997
                    case VAR_ENGINEONLINEACTIVE: onlineActive = scriptEng.operands[i]; break;
5998
                    case VAR_ENGINESFXVOLUME:
5999
                        sfxVolume = scriptEng.operands[i];
6000
                        // SetGameVolumes(bgmVolume, sfxVolume);
6001
                        break;
6002
                    case VAR_ENGINEBGMVOLUME:
6003
                        bgmVolume = scriptEng.operands[i];
6004
                        // SetGameVolumes(bgmVolume, sfxVolume);
6005
                        break;
6006
                    case VAR_ENGINETRIALMODE: trialMode = scriptEng.operands[i]; break;
6007
                    case VAR_ENGINEDEVICETYPE: break;
6008

6009
                    // Origins Extras
6010
                    case VAR_SCREENCURRENTID: break;
6011
                    case VAR_CAMERAENABLED: cameras[arrayVal].enabled = scriptEng.operands[i]; break;
6012
                    case VAR_CAMERATARGET: cameras[arrayVal].target = scriptEng.operands[i]; break;
6013
                    case VAR_CAMERASTYLE: cameras[arrayVal].style = scriptEng.operands[i]; break;
6014
                    case VAR_CAMERAXPOS: cameras[arrayVal].xpos = scriptEng.operands[i]; break;
6015
                    case VAR_CAMERAYPOS: cameras[arrayVal].ypos = scriptEng.operands[i]; break;
6016
                    case VAR_CAMERAADJUSTY: cameras[arrayVal].adjustY = scriptEng.operands[i]; break;
6017

6018
#if LEGACY_RETRO_USE_HAPTICS
6019
                    case VAR_HAPTICSENABLED: hapticsEnabled = scriptEng.operands[i]; break;
6020
#endif
6021
                }
6022
            }
6023
            else if (opcodeType == SCRIPTVAR_INTCONST) { // int32 constant
6024
                scriptCodePtr++;
6025
            }
6026
            else if (opcodeType == SCRIPTVAR_STRCONST) { // string constant
6027
                int32 strLen = scriptCode[scriptCodePtr++];
6028
                for (int32 c = 0; c < strLen; ++c) {
6029
                    switch (c % 4) {
6030
                        case 0: break;
6031
                        case 1: break;
6032
                        case 2: break;
6033
                        case 3: ++scriptCodePtr; break;
6034
                        default: break;
6035
                    }
6036
                }
6037
                scriptCodePtr++;
6038
            }
6039
        }
6040
    }
6041
}
6042

6043
Product

Resources

Company
