CoCalc -- ScriptLegacyv3.cpp

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

2
RSDK::Legacy::v3::ObjectScript RSDK::Legacy::v3::objectScriptList[LEGACY_v3_OBJECT_COUNT];
3

4
RSDK::Legacy::v3::ScriptFunction RSDK::Legacy::v3::scriptFunctionList[LEGACY_v3_FUNCTION_COUNT];
5
int32 RSDK::Legacy::v3::scriptFunctionCount = 0;
6

7
int32 RSDK::Legacy::v3::scriptCode[LEGACY_v3_SCRIPTDATA_COUNT];
8
int32 RSDK::Legacy::v3::jumpTable[LEGACY_v3_JUMPTABLE_COUNT];
9
int32 RSDK::Legacy::v3::jumpTableStack[LEGACY_v3_JUMPSTACK_COUNT];
10
int32 RSDK::Legacy::v3::functionStack[LEGACY_v3_FUNCSTACK_COUNT];
11

12
int32 RSDK::Legacy::v3::scriptCodePos     = 0;
13
int32 RSDK::Legacy::v3::scriptCodeOffset  = 0;
14
int32 RSDK::Legacy::v3::jumpTablePos      = 0;
15
int32 RSDK::Legacy::v3::jumpTableOffset   = 0;
16
int32 RSDK::Legacy::v3::jumpTableStackPos = 0;
17
int32 RSDK::Legacy::v3::functionStackPos  = 0;
18

19
RSDK::Legacy::v3::ScriptEngine RSDK::Legacy::v3::scriptEng = Legacy::v3::ScriptEngine();
20
char RSDK::Legacy::v3::scriptText[0x100];
21

22
#define LEGACY_v3_COMMONALIAS_COUNT (0x20)
23
#define LEGACY_v3_ALIAS_COUNT       (LEGACY_v3_COMMONALIAS_COUNT + 0x60)
24
int32 RSDK::Legacy::v3::aliasCount = 0;
25

26
int32 RSDK::Legacy::v3::lineID = 0;
27

28
namespace RSDK
29
{
30

31
namespace Legacy
32
{
33

34
namespace v3
35
{
36

37
const char *scriptFile = "";
38

39
#if LEGACY_RETRO_USE_COMPILER
40
struct AliasInfo {
41
    AliasInfo()
42
    {
43
        StrCopy(name, "");
44
        StrCopy(value, "");
45
    }
46
    AliasInfo(const char *aliasName, const char *aliasVal)
47
    {
48
        StrCopy(name, aliasName);
49
        StrCopy(value, aliasVal);
50
    }
51

52
    char name[0x20];
53
    char value[0x20];
54
};
55
#endif
56

57
struct FunctionInfo {
58
    FunctionInfo()
59
    {
60
        StrCopy(name, "");
61
        opcodeSize = 0;
62
    }
63
    FunctionInfo(const char *functionName, int32 opSize)
64
    {
65
        StrCopy(name, functionName);
66
        opcodeSize = opSize;
67
    }
68

69
    char name[0x20];
70
    int32 opcodeSize;
71
};
72

73
#if LEGACY_RETRO_USE_COMPILER
74
const char variableNames[][0x20] = {
75
    "TempValue0",
76
    "TempValue1",
77
    "TempValue2",
78
    "TempValue3",
79
    "TempValue4",
80
    "TempValue5",
81
    "TempValue6",
82
    "TempValue7",
83
    "CheckResult",
84
    "ArrayPos0",
85
    "ArrayPos1",
86
    "Global",
87
    "Object.EntityNo",
88
    "Object.Type",
89
    "Object.PropertyValue",
90
    "Object.XPos",
91
    "Object.YPos",
92
    "Object.iXPos",
93
    "Object.iYPos",
94
    "Object.State",
95
    "Object.Rotation",
96
    "Object.Scale",
97
    "Object.Priority",
98
    "Object.DrawOrder",
99
    "Object.Direction",
100
    "Object.InkEffect",
101
    "Object.Alpha",
102
    "Object.Frame",
103
    "Object.Animation",
104
    "Object.PrevAnimation",
105
    "Object.AnimationSpeed",
106
    "Object.AnimationTimer",
107
    "Object.Value0",
108
    "Object.Value1",
109
    "Object.Value2",
110
    "Object.Value3",
111
    "Object.Value4",
112
    "Object.Value5",
113
    "Object.Value6",
114
    "Object.Value7",
115
    "Object.OutOfBounds",
116
    "Player.State",
117
    "Player.ControlMode",
118
    "Player.ControlLock",
119
    "Player.CollisionMode",
120
    "Player.CollisionPlane",
121
    "Player.XPos",
122
    "Player.YPos",
123
    "Player.iXPos",
124
    "Player.iYPos",
125
    "Player.ScreenXPos",
126
    "Player.ScreenYPos",
127
    "Player.Speed",
128
    "Player.XVelocity",
129
    "Player.YVelocity",
130
    "Player.Gravity",
131
    "Player.Angle",
132
    "Player.Skidding",
133
    "Player.Pushing",
134
    "Player.TrackScroll",
135
    "Player.Up",
136
    "Player.Down",
137
    "Player.Left",
138
    "Player.Right",
139
    "Player.JumpPress",
140
    "Player.JumpHold",
141
    "Player.FollowPlayer1",
142
    "Player.LookPos",
143
    "Player.Water",
144
    "Player.TopSpeed",
145
    "Player.Acceleration",
146
    "Player.Deceleration",
147
    "Player.AirAcceleration",
148
    "Player.AirDeceleration",
149
    "Player.GravityStrength",
150
    "Player.JumpStrength",
151
    "Player.JumpCap",
152
    "Player.RollingAcceleration",
153
    "Player.RollingDeceleration",
154
    "Player.EntityNo",
155
    "Player.CollisionLeft",
156
    "Player.CollisionTop",
157
    "Player.CollisionRight",
158
    "Player.CollisionBottom",
159
    "Player.Flailing",
160
    "Player.Timer",
161
    "Player.TileCollisions",
162
    "Player.ObjectInteraction",
163
    "Player.Visible",
164
    "Player.Rotation",
165
    "Player.Scale",
166
    "Player.Priority",
167
    "Player.DrawOrder",
168
    "Player.Direction",
169
    "Player.InkEffect",
170
    "Player.Alpha",
171
    "Player.Frame",
172
    "Player.Animation",
173
    "Player.PrevAnimation",
174
    "Player.AnimationSpeed",
175
    "Player.AnimationTimer",
176
    "Player.Value0",
177
    "Player.Value1",
178
    "Player.Value2",
179
    "Player.Value3",
180
    "Player.Value4",
181
    "Player.Value5",
182
    "Player.Value6",
183
    "Player.Value7",
184
    "Player.Value8",
185
    "Player.Value9",
186
    "Player.Value10",
187
    "Player.Value11",
188
    "Player.Value12",
189
    "Player.Value13",
190
    "Player.Value14",
191
    "Player.Value15",
192
    "Player.OutOfBounds",
193
    "Stage.State",
194
    "Stage.ActiveList",
195
    "Stage.ListPos",
196
    "Stage.TimeEnabled",
197
    "Stage.MilliSeconds",
198
    "Stage.Seconds",
199
    "Stage.Minutes",
200
    "Stage.ActNo",
201
    "Stage.PauseEnabled",
202
    "Stage.ListSize",
203
    "Stage.NewXBoundary1",
204
    "Stage.NewXBoundary2",
205
    "Stage.NewYBoundary1",
206
    "Stage.NewYBoundary2",
207
    "Stage.XBoundary1",
208
    "Stage.XBoundary2",
209
    "Stage.YBoundary1",
210
    "Stage.YBoundary2",
211
    "Stage.DeformationData0",
212
    "Stage.DeformationData1",
213
    "Stage.DeformationData2",
214
    "Stage.DeformationData3",
215
    "Stage.WaterLevel",
216
    "Stage.ActiveLayer",
217
    "Stage.MidPoint",
218
    "Stage.PlayerListPos",
219
    "Stage.ActivePlayer",
220
    "Screen.CameraEnabled",
221
    "Screen.CameraTarget",
222
    "Screen.CameraStyle",
223
    "Screen.DrawListSize",
224
    "Screen.CenterX",
225
    "Screen.CenterY",
226
    "Screen.XSize",
227
    "Screen.YSize",
228
    "Screen.XOffset",
229
    "Screen.YOffset",
230
    "Screen.ShakeX",
231
    "Screen.ShakeY",
232
    "Screen.AdjustCameraY",
233
    "TouchScreen.Down",
234
    "TouchScreen.XPos",
235
    "TouchScreen.YPos",
236
    "Music.Volume",
237
    "Music.CurrentTrack",
238
    "KeyDown.Up",
239
    "KeyDown.Down",
240
    "KeyDown.Left",
241
    "KeyDown.Right",
242
    "KeyDown.ButtonA",
243
    "KeyDown.ButtonB",
244
    "KeyDown.ButtonC",
245
    "KeyDown.Start",
246
    "KeyPress.Up",
247
    "KeyPress.Down",
248
    "KeyPress.Left",
249
    "KeyPress.Right",
250
    "KeyPress.ButtonA",
251
    "KeyPress.ButtonB",
252
    "KeyPress.ButtonC",
253
    "KeyPress.Start",
254
    "Menu1.Selection",
255
    "Menu2.Selection",
256
    "TileLayer.XSize",
257
    "TileLayer.YSize",
258
    "TileLayer.Type",
259
    "TileLayer.Angle",
260
    "TileLayer.XPos",
261
    "TileLayer.YPos",
262
    "TileLayer.ZPos",
263
    "TileLayer.ParallaxFactor",
264
    "TileLayer.ScrollSpeed",
265
    "TileLayer.ScrollPos",
266
    "TileLayer.DeformationOffset",
267
    "TileLayer.DeformationOffsetW",
268
    "HParallax.ParallaxFactor",
269
    "HParallax.ScrollSpeed",
270
    "HParallax.ScrollPos",
271
    "VParallax.ParallaxFactor",
272
    "VParallax.ScrollSpeed",
273
    "VParallax.ScrollPos",
274
    "3DScene.NoVertices",
275
    "3DScene.NoFaces",
276
    "VertexBuffer.x",
277
    "VertexBuffer.y",
278
    "VertexBuffer.z",
279
    "VertexBuffer.u",
280
    "VertexBuffer.v",
281
    "FaceBuffer.a",
282
    "FaceBuffer.b",
283
    "FaceBuffer.c",
284
    "FaceBuffer.d",
285
    "FaceBuffer.Flag",
286
    "FaceBuffer.Color",
287
    "3DScene.ProjectionX",
288
    "3DScene.ProjectionY",
289
    "Engine.State",
290
    "Stage.DebugMode",
291
    "Engine.Message",
292
    "SaveRAM",
293
    "Engine.Language",
294
    "Object.SpriteSheet",
295
    "Engine.OnlineActive",
296
    "Engine.FrameSkipTimer",
297
    "Engine.FrameSkipSetting",
298
    "Engine.SFXVolume",
299
    "Engine.BGMVolume",
300
    "Engine.PlatformID",
301
    "Engine.TrialMode",
302
    "KeyPress.AnyStart",
303
#if LEGACY_RETRO_USE_HAPTICS
304
    "Engine.HapticsEnabled",
305
#endif
306
};
307
#endif
308

309
const FunctionInfo functions[] = {
310
    FunctionInfo("End", 0),
311
    FunctionInfo("Equal", 2),
312
    FunctionInfo("Add", 2),
313
    FunctionInfo("Sub", 2),
314
    FunctionInfo("Inc", 1),
315
    FunctionInfo("Dec", 1),
316
    FunctionInfo("Mul", 2),
317
    FunctionInfo("Div", 2),
318
    FunctionInfo("ShR", 2),
319
    FunctionInfo("ShL", 2),
320
    FunctionInfo("And", 2),
321
    FunctionInfo("Or", 2),
322
    FunctionInfo("Xor", 2),
323
    FunctionInfo("Mod", 2),
324
    FunctionInfo("FlipSign", 1),
325
    FunctionInfo("CheckEqual", 2),
326
    FunctionInfo("CheckGreater", 2),
327
    FunctionInfo("CheckLower", 2),
328
    FunctionInfo("CheckNotEqual", 2),
329
    FunctionInfo("IfEqual", 3),
330
    FunctionInfo("IfGreater", 3),
331
    FunctionInfo("IfGreaterOrEqual", 3),
332
    FunctionInfo("IfLower", 3),
333
    FunctionInfo("IfLowerOrEqual", 3),
334
    FunctionInfo("IfNotEqual", 3),
335
    FunctionInfo("else", 0),
336
    FunctionInfo("endif", 0),
337
    FunctionInfo("WEqual", 3),
338
    FunctionInfo("WGreater", 3),
339
    FunctionInfo("WGreaterOrEqual", 3),
340
    FunctionInfo("WLower", 3),
341
    FunctionInfo("WLowerOrEqual", 3),
342
    FunctionInfo("WNotEqual", 3),
343
    FunctionInfo("loop", 0),
344
    FunctionInfo("switch", 2),
345
    FunctionInfo("break", 0),
346
    FunctionInfo("endswitch", 0),
347
    FunctionInfo("Rand", 2),
348
    FunctionInfo("Sin", 2),
349
    FunctionInfo("Cos", 2),
350
    FunctionInfo("Sin256", 2),
351
    FunctionInfo("Cos256", 2),
352
    FunctionInfo("SinChange", 5),
353
    FunctionInfo("CosChange", 5),
354
    FunctionInfo("ATan2", 3),
355
    FunctionInfo("Interpolate", 4),
356
    FunctionInfo("InterpolateXY", 7),
357
    FunctionInfo("LoadSpriteSheet", 1),
358
    FunctionInfo("RemoveSpriteSheet", 1),
359
    FunctionInfo("DrawSprite", 1),
360
    FunctionInfo("DrawSpriteXY", 3),
361
    FunctionInfo("DrawSpriteScreenXY", 3),
362
    FunctionInfo("DrawTintRect", 4),
363
    FunctionInfo("DrawNumbers", 7),
364
    FunctionInfo("DrawActName", 7),
365
    FunctionInfo("DrawMenu", 3),
366
    FunctionInfo("SpriteFrame", 6),
367
    FunctionInfo("EditFrame", 7),
368
    FunctionInfo("LoadPalette", 5),
369
    FunctionInfo("RotatePalette", 3),
370
    FunctionInfo("SetScreenFade", 4),
371
    FunctionInfo("SetActivePalette", 3),
372
    FunctionInfo("SetPaletteFade", 7),
373
    FunctionInfo("CopyPalette", 2),
374
    FunctionInfo("ClearScreen", 1),
375
    FunctionInfo("DrawSpriteFX", 4),
376
    FunctionInfo("DrawSpriteScreenFX", 4),
377
    FunctionInfo("LoadAnimation", 1),
378
    FunctionInfo("SetupMenu", 4),
379
    FunctionInfo("AddMenuEntry", 3),
380
    FunctionInfo("EditMenuEntry", 4),
381
    FunctionInfo("LoadStage", 0),
382
    FunctionInfo("DrawRect", 8),
383
    FunctionInfo("ResetObjectEntity", 5),
384
    FunctionInfo("PlayerObjectCollision", 5),
385
    FunctionInfo("CreateTempObject", 4),
386
    FunctionInfo("BindPlayerToObject", 2),
387
    FunctionInfo("PlayerTileCollision", 0),
388
    FunctionInfo("ProcessPlayerControl", 0),
389
    FunctionInfo("ProcessAnimation", 0),
390
    FunctionInfo("DrawObjectAnimation", 0),
391
    FunctionInfo("DrawPlayerAnimation", 0),
392
    FunctionInfo("SetMusicTrack", 3),
393
    FunctionInfo("PlayMusic", 1),
394
    FunctionInfo("StopMusic", 0),
395
    FunctionInfo("PlaySfx", 2),
396
    FunctionInfo("StopSfx", 1),
397
    FunctionInfo("SetSfxAttributes", 3),
398
    FunctionInfo("ObjectTileCollision", 4),
399
    FunctionInfo("ObjectTileGrip", 4),
400
    FunctionInfo("LoadVideo", 1),
401
    FunctionInfo("NextVideoFrame", 0),
402
    FunctionInfo("PlayStageSfx", 2),
403
    FunctionInfo("StopStageSfx", 1),
404
    FunctionInfo("Not", 1),
405
    FunctionInfo("Draw3DScene", 0),
406
    FunctionInfo("SetIdentityMatrix", 1),
407
    FunctionInfo("MatrixMultiply", 2),
408
    FunctionInfo("MatrixTranslateXYZ", 4),
409
    FunctionInfo("MatrixScaleXYZ", 4),
410
    FunctionInfo("MatrixRotateX", 2),
411
    FunctionInfo("MatrixRotateY", 2),
412
    FunctionInfo("MatrixRotateZ", 2),
413
    FunctionInfo("MatrixRotateXYZ", 4),
414
    FunctionInfo("TransformVertices", 3),
415
    FunctionInfo("CallFunction", 1),
416
    FunctionInfo("EndFunction", 0),
417
    FunctionInfo("SetLayerDeformation", 6),
418
    FunctionInfo("CheckTouchRect", 4),
419
    FunctionInfo("GetTileLayerEntry", 4),
420
    FunctionInfo("SetTileLayerEntry", 4),
421
    FunctionInfo("GetBit", 3),
422
    FunctionInfo("SetBit", 3),
423
    FunctionInfo("PauseMusic", 0),
424
    FunctionInfo("ResumeMusic", 0),
425
    FunctionInfo("ClearDrawList", 1),
426
    FunctionInfo("AddDrawListEntityRef", 2),
427
    FunctionInfo("GetDrawListEntityRef", 3),
428
    FunctionInfo("SetDrawListEntityRef", 3),
429
    FunctionInfo("Get16x16TileInfo", 4),
430
    FunctionInfo("Copy16x16Tile", 2),
431
    FunctionInfo("Set16x16TileInfo", 4),
432
    FunctionInfo("GetAnimationByName", 2),
433
    FunctionInfo("ReadSaveRAM", 0),
434
    FunctionInfo("WriteSaveRAM", 0),
435
    FunctionInfo("LoadTextFont", 1),
436
    FunctionInfo("LoadTextFile", 3),
437
    FunctionInfo("DrawText", 7),
438
    FunctionInfo("GetTextInfo", 5),
439
    FunctionInfo("GetVersionNumber", 2),
440
    FunctionInfo("SetAchievement", 2),
441
    FunctionInfo("SetLeaderboard", 2),
442
    FunctionInfo("LoadOnlineMenu", 1),
443
    FunctionInfo("EngineCallback", 1),
444
#if LEGACY_RETRO_USE_HAPTICS
445
    FunctionInfo("HapticEffect", 4),
446
#endif
447
};
448

449
#if LEGACY_RETRO_USE_COMPILER
450
AliasInfo aliases[0x80] = { AliasInfo("true", "1"),
451
                            AliasInfo("false", "0"),
452
                            AliasInfo("FX_SCALE", "0"),
453
                            AliasInfo("FX_ROTATE", "1"),
454
                            AliasInfo("FX_ROTOZOOM", "2"),
455
                            AliasInfo("FX_INK", "3"),
456
                            AliasInfo("PRESENTATION_STAGE", "0"),
457
                            AliasInfo("REGULAR_STAGE", "1"),
458
                            AliasInfo("BONUS_STAGE", "2"),
459
                            AliasInfo("SPECIAL_STAGE", "3"),
460
                            AliasInfo("MENU_1", "0"),
461
                            AliasInfo("MENU_2", "1"),
462
                            AliasInfo("C_TOUCH", "0"),
463
                            AliasInfo("C_BOX", "1"),
464
                            AliasInfo("C_BOX2", "2"),
465
                            AliasInfo("C_PLATFORM", "3"),
466
                            AliasInfo("MAT_WORLD", "0"),
467
                            AliasInfo("MAT_VIEW", "1"),
468
                            AliasInfo("MAT_TEMP", "2"),
469
                            AliasInfo("FX_FLIP", "5"),
470
                            AliasInfo("FACING_LEFT", "1"),
471
                            AliasInfo("FACING_RIGHT", "0"),
472
                            AliasInfo("STAGE_PAUSED", "2"),
473
                            AliasInfo("STAGE_RUNNING", "1"),
474
                            AliasInfo("RESET_GAME", "2"),
475
                            AliasInfo("RETRO_WIN", "0"),
476
                            AliasInfo("RETRO_OSX", "1"),
477
                            AliasInfo("RETRO_XBOX_360", "2"),
478
                            AliasInfo("RETRO_PS3", "3"),
479
                            AliasInfo("RETRO_iOS", "4"),
480
                            AliasInfo("RETRO_ANDROID", "5"),
481
                            AliasInfo("RETRO_WP7", "6") };
482

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

486
enum ScriptReadModes { READMODE_NORMAL = 0, READMODE_STRING = 1, READMODE_COMMENTLINE = 2, READMODE_ENDLINE = 3, READMODE_EOF = 4 };
487
enum ScriptParseModes {
488
    PARSEMODE_SCOPELESS    = 0,
489
    PARSEMODE_PLATFORMSKIP = 1,
490
    PARSEMODE_FUNCTION     = 2,
491
    PARSEMODE_SWITCHREAD   = 3,
492
    PARSEMODE_ERROR        = 0xFF
493
};
494
#endif
495

496
enum ScriptVarTypes { SCRIPTVAR_VAR = 1, SCRIPTVAR_INTCONST = 2, SCRIPTVAR_STRCONST = 3 };
497
enum ScriptVarArrTypes { VARARR_NONE = 0, VARARR_ARRAY = 1, VARARR_ENTNOPLUS1 = 2, VARARR_ENTNOMINUS1 = 3 };
498

499
enum ScrVariable {
500
    VAR_TEMPVALUE0,
501
    VAR_TEMPVALUE1,
502
    VAR_TEMPVALUE2,
503
    VAR_TEMPVALUE3,
504
    VAR_TEMPVALUE4,
505
    VAR_TEMPVALUE5,
506
    VAR_TEMPVALUE6,
507
    VAR_TEMPVALUE7,
508
    VAR_CHECKRESULT,
509
    VAR_ARRAYPOS0,
510
    VAR_ARRAYPOS1,
511
    VAR_GLOBAL,
512
    VAR_OBJECTENTITYNO,
513
    VAR_OBJECTTYPE,
514
    VAR_OBJECTPROPERTYVALUE,
515
    VAR_OBJECTXPOS,
516
    VAR_OBJECTYPOS,
517
    VAR_OBJECTIXPOS,
518
    VAR_OBJECTIYPOS,
519
    VAR_OBJECTSTATE,
520
    VAR_OBJECTROTATION,
521
    VAR_OBJECTSCALE,
522
    VAR_OBJECTPRIORITY,
523
    VAR_OBJECTDRAWORDER,
524
    VAR_OBJECTDIRECTION,
525
    VAR_OBJECTINKEFFECT,
526
    VAR_OBJECTALPHA,
527
    VAR_OBJECTFRAME,
528
    VAR_OBJECTANIMATION,
529
    VAR_OBJECTPREVANIMATION,
530
    VAR_OBJECTANIMATIONSPEED,
531
    VAR_OBJECTANIMATIONTIMER,
532
    VAR_OBJECTVALUE0,
533
    VAR_OBJECTVALUE1,
534
    VAR_OBJECTVALUE2,
535
    VAR_OBJECTVALUE3,
536
    VAR_OBJECTVALUE4,
537
    VAR_OBJECTVALUE5,
538
    VAR_OBJECTVALUE6,
539
    VAR_OBJECTVALUE7,
540
    VAR_OBJECTOUTOFBOUNDS,
541
    VAR_PLAYERSTATE,
542
    VAR_PLAYERCONTROLMODE,
543
    VAR_PLAYERCONTROLLOCK,
544
    VAR_PLAYERCOLLISIONMODE,
545
    VAR_PLAYERCOLLISIONPLANE,
546
    VAR_PLAYERXPOS,
547
    VAR_PLAYERYPOS,
548
    VAR_PLAYERIXPOS,
549
    VAR_PLAYERIYPOS,
550
    VAR_PLAYERSCREENXPOS,
551
    VAR_PLAYERSCREENYPOS,
552
    VAR_PLAYERSPEED,
553
    VAR_PLAYERXVELOCITY,
554
    VAR_PLAYERYVELOCITY,
555
    VAR_PLAYERGRAVITY,
556
    VAR_PLAYERANGLE,
557
    VAR_PLAYERSKIDDING,
558
    VAR_PLAYERPUSHING,
559
    VAR_PLAYERTRACKSCROLL,
560
    VAR_PLAYERUP,
561
    VAR_PLAYERDOWN,
562
    VAR_PLAYERLEFT,
563
    VAR_PLAYERRIGHT,
564
    VAR_PLAYERJUMPPRESS,
565
    VAR_PLAYERJUMPHOLD,
566
    VAR_PLAYERFOLLOWPLAYER1,
567
    VAR_PLAYERLOOKPOS,
568
    VAR_PLAYERWATER,
569
    VAR_PLAYERTOPSPEED,
570
    VAR_PLAYERACCELERATION,
571
    VAR_PLAYERDECELERATION,
572
    VAR_PLAYERAIRACCELERATION,
573
    VAR_PLAYERAIRDECELERATION,
574
    VAR_PLAYERGRAVITYSTRENGTH,
575
    VAR_PLAYERJUMPSTRENGTH,
576
    VAR_PLAYERJUMPCAP,
577
    VAR_PLAYERROLLINGACCELERATION,
578
    VAR_PLAYERROLLINGDECELERATION,
579
    VAR_PLAYERENTITYNO,
580
    VAR_PLAYERCOLLISIONLEFT,
581
    VAR_PLAYERCOLLISIONTOP,
582
    VAR_PLAYERCOLLISIONRIGHT,
583
    VAR_PLAYERCOLLISIONBOTTOM,
584
    VAR_PLAYERFLAILING,
585
    VAR_PLAYERTIMER,
586
    VAR_PLAYERTILECOLLISIONS,
587
    VAR_PLAYEROBJECTINTERACTION,
588
    VAR_PLAYERVISIBLE,
589
    VAR_PLAYERROTATION,
590
    VAR_PLAYERSCALE,
591
    VAR_PLAYERPRIORITY,
592
    VAR_PLAYERDRAWORDER,
593
    VAR_PLAYERDIRECTION,
594
    VAR_PLAYERINKEFFECT,
595
    VAR_PLAYERALPHA,
596
    VAR_PLAYERFRAME,
597
    VAR_PLAYERANIMATION,
598
    VAR_PLAYERPREVANIMATION,
599
    VAR_PLAYERANIMATIONSPEED,
600
    VAR_PLAYERANIMATIONTIMER,
601
    VAR_PLAYERVALUE0,
602
    VAR_PLAYERVALUE1,
603
    VAR_PLAYERVALUE2,
604
    VAR_PLAYERVALUE3,
605
    VAR_PLAYERVALUE4,
606
    VAR_PLAYERVALUE5,
607
    VAR_PLAYERVALUE6,
608
    VAR_PLAYERVALUE7,
609
    VAR_PLAYERVALUE8,
610
    VAR_PLAYERVALUE9,
611
    VAR_PLAYERVALUE10,
612
    VAR_PLAYERVALUE11,
613
    VAR_PLAYERVALUE12,
614
    VAR_PLAYERVALUE13,
615
    VAR_PLAYERVALUE14,
616
    VAR_PLAYERVALUE15,
617
    VAR_PLAYEROUTOFBOUNDS,
618
    VAR_STAGESTATE,
619
    VAR_STAGEACTIVELIST,
620
    VAR_STAGELISTPOS,
621
    VAR_STAGETIMEENABLED,
622
    VAR_STAGEMILLISECONDS,
623
    VAR_STAGESECONDS,
624
    VAR_STAGEMINUTES,
625
    VAR_STAGEACTNO,
626
    VAR_STAGEPAUSEENABLED,
627
    VAR_STAGELISTSIZE,
628
    VAR_STAGENEWXBOUNDARY1,
629
    VAR_STAGENEWXBOUNDARY2,
630
    VAR_STAGENEWYBOUNDARY1,
631
    VAR_STAGENEWYBOUNDARY2,
632
    VAR_STAGEXBOUNDARY1,
633
    VAR_STAGEXBOUNDARY2,
634
    VAR_STAGEYBOUNDARY1,
635
    VAR_STAGEYBOUNDARY2,
636
    VAR_STAGEDEFORMATIONDATA0,
637
    VAR_STAGEDEFORMATIONDATA1,
638
    VAR_STAGEDEFORMATIONDATA2,
639
    VAR_STAGEDEFORMATIONDATA3,
640
    VAR_STAGEWATERLEVEL,
641
    VAR_STAGEACTIVELAYER,
642
    VAR_STAGEMIDPOINT,
643
    VAR_STAGEPLAYERLISTPOS,
644
    VAR_STAGEACTIVEPLAYER,
645
    VAR_SCREENCAMERAENABLED,
646
    VAR_SCREENCAMERATARGET,
647
    VAR_SCREENCAMERASTYLE,
648
    VAR_SCREENDRAWLISTSIZE,
649
    VAR_SCREENCENTERX,
650
    VAR_SCREENCENTERY,
651
    VAR_SCREENXSIZE,
652
    VAR_SCREENYSIZE,
653
    VAR_SCREENXOFFSET,
654
    VAR_SCREENYOFFSET,
655
    VAR_SCREENSHAKEX,
656
    VAR_SCREENSHAKEY,
657
    VAR_SCREENADJUSTCAMERAY,
658
    VAR_TOUCHSCREENDOWN,
659
    VAR_TOUCHSCREENXPOS,
660
    VAR_TOUCHSCREENYPOS,
661
    VAR_MUSICVOLUME,
662
    VAR_MUSICCURRENTTRACK,
663
    VAR_KEYDOWNUP,
664
    VAR_KEYDOWNDOWN,
665
    VAR_KEYDOWNLEFT,
666
    VAR_KEYDOWNRIGHT,
667
    VAR_KEYDOWNBUTTONA,
668
    VAR_KEYDOWNBUTTONB,
669
    VAR_KEYDOWNBUTTONC,
670
    VAR_KEYDOWNSTART,
671
    VAR_KEYPRESSUP,
672
    VAR_KEYPRESSDOWN,
673
    VAR_KEYPRESSLEFT,
674
    VAR_KEYPRESSRIGHT,
675
    VAR_KEYPRESSBUTTONA,
676
    VAR_KEYPRESSBUTTONB,
677
    VAR_KEYPRESSBUTTONC,
678
    VAR_KEYPRESSSTART,
679
    VAR_MENU1SELECTION,
680
    VAR_MENU2SELECTION,
681
    VAR_TILELAYERXSIZE,
682
    VAR_TILELAYERYSIZE,
683
    VAR_TILELAYERTYPE,
684
    VAR_TILELAYERANGLE,
685
    VAR_TILELAYERXPOS,
686
    VAR_TILELAYERYPOS,
687
    VAR_TILELAYERZPOS,
688
    VAR_TILELAYERPARALLAXFACTOR,
689
    VAR_TILELAYERSCROLLSPEED,
690
    VAR_TILELAYERSCROLLPOS,
691
    VAR_TILELAYERDEFORMATIONOFFSET,
692
    VAR_TILELAYERDEFORMATIONOFFSETW,
693
    VAR_HPARALLAXPARALLAXFACTOR,
694
    VAR_HPARALLAXSCROLLSPEED,
695
    VAR_HPARALLAXSCROLLPOS,
696
    VAR_VPARALLAXPARALLAXFACTOR,
697
    VAR_VPARALLAXSCROLLSPEED,
698
    VAR_VPARALLAXSCROLLPOS,
699
    VAR_3DSCENENOVERTICES,
700
    VAR_3DSCENENOFACES,
701
    VAR_VERTEXBUFFERX,
702
    VAR_VERTEXBUFFERY,
703
    VAR_VERTEXBUFFERZ,
704
    VAR_VERTEXBUFFERU,
705
    VAR_VERTEXBUFFERV,
706
    VAR_FACEBUFFERA,
707
    VAR_FACEBUFFERB,
708
    VAR_FACEBUFFERC,
709
    VAR_FACEBUFFERD,
710
    VAR_FACEBUFFERFLAG,
711
    VAR_FACEBUFFERCOLOR,
712
    VAR_3DSCENEPROJECTIONX,
713
    VAR_3DSCENEPROJECTIONY,
714
    VAR_ENGINESTATE,
715
    VAR_STAGEDEBUGMODE,
716
    VAR_ENGINEMESSAGE,
717
    VAR_SAVERAM,
718
    VAR_ENGINELANGUAGE,
719
    VAR_OBJECTSPRITESHEET,
720
    VAR_ENGINEONLINEACTIVE,
721
    VAR_ENGINEFRAMESKIPTIMER,
722
    VAR_ENGINEFRAMESKIPSETTING,
723
    VAR_ENGINESFXVOLUME,
724
    VAR_ENGINEBGMVOLUME,
725
    VAR_ENGINEPLATFORMID,
726
    VAR_ENGINETRIALMODE,
727
    VAR_KEYPRESSANYSTART,
728
#if LEGACY_RETRO_USE_HAPTICS
729
    VAR_ENGINEHAPTICSENABLED,
730
#endif
731
    VAR_MAX_CNT
732
};
733

734
enum ScrFunction {
735
    FUNC_END,
736
    FUNC_EQUAL,
737
    FUNC_ADD,
738
    FUNC_SUB,
739
    FUNC_INC,
740
    FUNC_DEC,
741
    FUNC_MUL,
742
    FUNC_DIV,
743
    FUNC_SHR,
744
    FUNC_SHL,
745
    FUNC_AND,
746
    FUNC_OR,
747
    FUNC_XOR,
748
    FUNC_MOD,
749
    FUNC_FLIPSIGN,
750
    FUNC_CHECKEQUAL,
751
    FUNC_CHECKGREATER,
752
    FUNC_CHECKLOWER,
753
    FUNC_CHECKNOTEQUAL,
754
    FUNC_IFEQUAL,
755
    FUNC_IFGREATER,
756
    FUNC_IFGREATEROREQUAL,
757
    FUNC_IFLOWER,
758
    FUNC_IFLOWEROREQUAL,
759
    FUNC_IFNOTEQUAL,
760
    FUNC_ELSE,
761
    FUNC_ENDIF,
762
    FUNC_WEQUAL,
763
    FUNC_WGREATER,
764
    FUNC_WGREATEROREQUAL,
765
    FUNC_WLOWER,
766
    FUNC_WLOWEROREQUAL,
767
    FUNC_WNOTEQUAL,
768
    FUNC_LOOP,
769
    FUNC_SWITCH,
770
    FUNC_BREAK,
771
    FUNC_ENDSWITCH,
772
    FUNC_RAND,
773
    FUNC_SIN,
774
    FUNC_COS,
775
    FUNC_SIN256,
776
    FUNC_COS256,
777
    FUNC_SINCHANGE,
778
    FUNC_COSCHANGE,
779
    FUNC_ATAN2,
780
    FUNC_INTERPOLATE,
781
    FUNC_INTERPOLATEXY,
782
    FUNC_LOADSPRITESHEET,
783
    FUNC_REMOVESPRITESHEET,
784
    FUNC_DRAWSPRITE,
785
    FUNC_DRAWSPRITEXY,
786
    FUNC_DRAWSPRITESCREENXY,
787
    FUNC_DRAWTINTRECT,
788
    FUNC_DRAWNUMBERS,
789
    FUNC_DRAWACTNAME,
790
    FUNC_DRAWMENU,
791
    FUNC_SPRITEFRAME,
792
    FUNC_EDITFRAME,
793
    FUNC_LOADPALETTE,
794
    FUNC_ROTATEPALETTE,
795
    FUNC_SETSCREENFADE,
796
    FUNC_SETACTIVEPALETTE,
797
    FUNC_SETPALETTEFADE,
798
    FUNC_COPYPALETTE,
799
    FUNC_CLEARSCREEN,
800
    FUNC_DRAWSPRITEFX,
801
    FUNC_DRAWSPRITESCREENFX,
802
    FUNC_LOADANIMATION,
803
    FUNC_SETUPMENU,
804
    FUNC_ADDMENUENTRY,
805
    FUNC_EDITMENUENTRY,
806
    FUNC_LOADSTAGE,
807
    FUNC_DRAWRECT,
808
    FUNC_RESETOBJECTENTITY,
809
    FUNC_PLAYEROBJECTCOLLISION,
810
    FUNC_CREATETEMPOBJECT,
811
    FUNC_BINDPLAYERTOOBJECT,
812
    FUNC_PLAYERTILECOLLISION,
813
    FUNC_PROCESSPLAYERCONTROL,
814
    FUNC_PROCESSANIMATION,
815
    FUNC_DRAWOBJECTANIMATION,
816
    FUNC_DRAWPLAYERANIMATION,
817
    FUNC_SETMUSICTRACK,
818
    FUNC_PLAYMUSIC,
819
    FUNC_STOPMUSIC,
820
    FUNC_PLAYSFX,
821
    FUNC_STOPSFX,
822
    FUNC_SETSFXATTRIBUTES,
823
    FUNC_OBJECTTILECOLLISION,
824
    FUNC_OBJECTTILEGRIP,
825
    FUNC_LOADVIDEO,
826
    FUNC_NEXTVIDEOFRAME,
827
    FUNC_PLAYSTAGESFX,
828
    FUNC_STOPSTAGESFX,
829
    FUNC_NOT,
830
    FUNC_DRAW3DSCENE,
831
    FUNC_SETIDENTITYMATRIX,
832
    FUNC_MATRIXMULTIPLY,
833
    FUNC_MATRIXTRANSLATEXYZ,
834
    FUNC_MATRIXSCALEXYZ,
835
    FUNC_MATRIXROTATEX,
836
    FUNC_MATRIXROTATEY,
837
    FUNC_MATRIXROTATEZ,
838
    FUNC_MATRIXROTATEXYZ,
839
    FUNC_TRANSFORMVERTICES,
840
    FUNC_CALLFUNCTION,
841
    FUNC_ENDFUNCTION,
842
    FUNC_SETLAYERDEFORMATION,
843
    FUNC_CHECKTOUCHRECT,
844
    FUNC_GETTILELAYERENTRY,
845
    FUNC_SETTILELAYERENTRY,
846
    FUNC_GETBIT,
847
    FUNC_SETBIT,
848
    FUNC_PAUSEMUSIC,
849
    FUNC_RESUMEMUSIC,
850
    FUNC_CLEARDRAWLIST,
851
    FUNC_ADDDRAWLISTENTITYREF,
852
    FUNC_GETDRAWLISTENTITYREF,
853
    FUNC_SETDRAWLISTENTITYREF,
854
    FUNC_GET16X16TILEINFO,
855
    FUNC_COPY16X16TILE,
856
    FUNC_SET16X16TILEINFO,
857
    FUNC_GETANIMATIONBYNAME,
858
    FUNC_READSAVERAM,
859
    FUNC_WRITESAVERAM,
860
    FUNC_LOADTEXTFONT,
861
    FUNC_LOADTEXTFILE,
862
    FUNC_DRAWTEXT,
863
    FUNC_GETTEXTINFO,
864
    FUNC_GETVERSIONNUMBER,
865
    FUNC_SETACHIEVEMENT,
866
    FUNC_SETLEADERBOARD,
867
    FUNC_LOADONLINEMENU,
868
    FUNC_ENGINECALLBACK,
869
#if LEGACY_RETRO_USE_HAPTICS
870
    FUNC_HAPTICEFFECT,
871
#endif
872
    FUNC_MAX_CNT
873
};
874
} // namespace v3
875

876
} // namespace Legacy
877

878
} // namespace RSDK
879

880
#if LEGACY_RETRO_USE_COMPILER
881
void RSDK::Legacy::v3::CheckAliasText(char *text)
882
{
883
    if (FindStringToken(text, "#alias", 1) != 0)
884
        return;
885

886
#if !RETRO_USE_ORIGINAL_CODE
887
    if (aliasCount >= LEGACY_v3_ALIAS_COUNT) {
888
        RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Too many aliases\nFILE: %s", scriptFile);
889
        gameMode = ENGINE_SCRIPTERROR;
890
        return;
891
    }
892
#endif
893

894
    int32 textPos     = 6;
895
    int32 aliasStrPos = 0;
896
    int32 parseMode   = 0;
897

898
    while (parseMode < 2) {
899
        if (parseMode) {
900
            if (parseMode == 1) {
901
                aliases[aliasCount].name[aliasStrPos] = text[textPos];
902
                if (text[textPos]) {
903
                    aliasStrPos++;
904
                }
905
                else {
906
                    aliasStrPos = 0;
907
                    ++parseMode;
908
                }
909
            }
910
        }
911
        else if (text[textPos] == ':') {
912
            aliases[aliasCount].value[aliasStrPos] = 0;
913
            aliasStrPos                            = 0;
914
            parseMode                              = 1;
915
        }
916
        else {
917
            aliases[aliasCount].value[aliasStrPos++] = text[textPos];
918
        }
919
        ++textPos;
920
    }
921

922
    ++aliasCount;
923
}
924
void RSDK::Legacy::v3::ConvertArithmaticSyntax(char *text)
925
{
926
    int32 token  = 0;
927
    int32 offset = 0;
928
    int32 findID = 0;
929
    char dest[260];
930

931
    for (int32 i = FUNC_EQUAL; i <= FUNC_MOD; ++i) {
932
        findID = FindStringToken(text, scriptEvaluationTokens[i - 1], 1);
933
        if (findID > -1) {
934
            offset = findID;
935
            token  = i;
936
        }
937
    }
938

939
    if (token > 0) {
940
        StrCopy(dest, functions[token].name);
941
        StrAdd(dest, "(");
942
        findID = StrLength(dest);
943
        for (int32 i = 0; i < offset; ++i) dest[findID++] = text[i];
944
        if (functions[token].opcodeSize > 1) {
945
            dest[findID] = ',';
946
            int32 len    = StrLength(scriptEvaluationTokens[token - 1]);
947
            offset += len;
948
            ++findID;
949
            while (text[offset]) dest[findID++] = text[offset++];
950
        }
951
        dest[findID] = 0;
952
        StrAdd(dest, ")");
953
        StrCopy(text, dest);
954
    }
955
}
956
void RSDK::Legacy::v3::ConvertIfWhileStatement(char *text)
957
{
958
    char dest[260];
959
    int32 compareOp  = -1;
960
    int32 strPos     = 0;
961
    int32 destStrPos = 0;
962

963
    if (FindStringToken(text, "if", 1) == 0) {
964
        for (int32 i = 0; i < 6; ++i) {
965
            destStrPos = FindStringToken(text, scriptEvaluationTokens[i + FUNC_MOD], 1);
966
            if (destStrPos > -1) {
967
                strPos    = destStrPos;
968
                compareOp = i;
969
            }
970
        }
971

972
        if (compareOp > -1) {
973
            text[strPos] = ',';
974

975
            StrCopy(dest, functions[compareOp + FUNC_IFEQUAL].name);
976
            StrAdd(dest, "(");
977
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
978
            StrAdd(dest, ",");
979

980
            destStrPos = StrLength(dest);
981
            for (int32 i = 2; text[i]; ++i) {
982
                if (text[i] != '=' && text[i] != '(' && text[i] != ')')
983
                    dest[destStrPos++] = text[i];
984
            }
985
            dest[destStrPos] = 0;
986

987
            StrAdd(dest, ")");
988
            StrCopy(text, dest);
989

990
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
991
            jumpTable[jumpTablePos++]           = -1;
992
            jumpTable[jumpTablePos++]           = 0;
993
        }
994
    }
995
    else if (FindStringToken(text, "while", 1) == 0) {
996
        for (int32 i = 0; i < 6; ++i) {
997
            destStrPos = FindStringToken(text, scriptEvaluationTokens[i + FUNC_MOD], 1);
998
            if (destStrPos > -1) {
999
                strPos    = destStrPos;
1000
                compareOp = i;
1001
            }
1002
        }
1003

1004
        if (compareOp > -1) {
1005
            text[strPos] = ',';
1006

1007
            StrCopy(dest, functions[compareOp + FUNC_WEQUAL].name);
1008
            StrAdd(dest, "(");
1009
            AppendIntegerToString(dest, jumpTablePos - jumpTableOffset);
1010
            StrAdd(dest, ",");
1011

1012
            destStrPos = StrLength(dest);
1013
            for (int32 i = 5; text[i]; ++i) {
1014
                if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1015
                    dest[destStrPos++] = text[i];
1016
            }
1017
            dest[destStrPos] = 0;
1018

1019
            StrAdd(dest, ")");
1020
            StrCopy(text, dest);
1021

1022
            jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1023
            jumpTable[jumpTablePos++]           = scriptCodePos - scriptCodeOffset;
1024
            jumpTable[jumpTablePos++]           = 0;
1025
        }
1026
    }
1027
}
1028
bool32 RSDK::Legacy::v3::ConvertSwitchStatement(char *text)
1029
{
1030
    if (FindStringToken(text, "switch", 1))
1031
        return false;
1032

1033
    char switchText[260];
1034
    StrCopy(switchText, "switch");
1035
    StrAdd(switchText, "(");
1036
    AppendIntegerToString(switchText, jumpTablePos - jumpTableOffset);
1037
    StrAdd(switchText, ",");
1038
    int32 pos = StrLength(switchText);
1039
    for (int32 i = 6; text[i]; ++i) {
1040
        if (text[i] != '=' && text[i] != '(' && text[i] != ')')
1041
            switchText[pos++] = text[i];
1042
    }
1043
    switchText[pos] = 0;
1044
    StrAdd(switchText, ")");
1045
    StrCopy(text, switchText);
1046

1047
    jumpTableStack[++jumpTableStackPos] = jumpTablePos;
1048
    jumpTable[jumpTablePos++]           = 0x10000;
1049
    jumpTable[jumpTablePos++]           = -0x10000;
1050
    jumpTable[jumpTablePos++]           = -1;
1051
    jumpTable[jumpTablePos++]           = 0;
1052

1053
    return true;
1054
}
1055
void RSDK::Legacy::v3::ConvertFunctionText(char *text)
1056
{
1057
    char arrayStr[128];
1058
    char funcName[132];
1059
    int32 opcode     = 0;
1060
    int32 opcodeSize = 0;
1061
    int32 textPos    = 0;
1062

1063
    int32 namePos = 0;
1064
    for (namePos = 0; text[namePos] != '(' && text[namePos]; ++namePos) funcName[namePos] = text[namePos];
1065
    funcName[namePos] = 0;
1066

1067
    for (int32 i = 0; i < FUNC_MAX_CNT; ++i) {
1068
        if (StrComp(funcName, functions[i].name)) {
1069
            opcode     = i;
1070
            opcodeSize = functions[i].opcodeSize;
1071
            textPos    = StrLength(functions[i].name);
1072
            i          = FUNC_MAX_CNT;
1073
        }
1074
    }
1075

1076
    if (opcode <= 0) {
1077
        RSDK::PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Opcode not found\nOPCODE: %s\nLINE: %d\nFILE: %s", funcName, lineID, scriptFile);
1078

1079
        gameMode = ENGINE_SCRIPTERROR;
1080
    }
1081
    else {
1082
        scriptCode[scriptCodePos++] = opcode;
1083
        if (StrComp("else", functions[opcode].name))
1084
            jumpTable[jumpTableStack[jumpTableStackPos]] = scriptCodePos - scriptCodeOffset;
1085

1086
        if (StrComp("endif", functions[opcode].name) == 1) {
1087
            int32 jPos          = jumpTableStack[jumpTableStackPos];
1088
            jumpTable[jPos + 1] = scriptCodePos - scriptCodeOffset;
1089
            if (jumpTable[jPos] == -1)
1090
                jumpTable[jPos] = (scriptCodePos - scriptCodeOffset) - 1;
1091
            --jumpTableStackPos;
1092
        }
1093

1094
        if (StrComp("endswitch", functions[opcode].name)) {
1095
            int32 jPos          = jumpTableStack[jumpTableStackPos];
1096
            jumpTable[jPos + 3] = scriptCodePos - scriptCodeOffset;
1097
            if (jumpTable[jPos + 2] == -1) {
1098
                jumpTable[jPos + 2] = (scriptCodePos - scriptCodeOffset) - 1;
1099
                int32 caseCnt       = abs(jumpTable[jPos + 1] - jumpTable[jPos]) + 1;
1100

1101
                int32 jOffset = jPos + 4;
1102
                for (int32 c = 0; c < caseCnt; ++c) {
1103
                    if (jumpTable[jOffset + c] < 0)
1104
                        jumpTable[jOffset + c] = jumpTable[jPos + 2];
1105
                }
1106
            }
1107
            --jumpTableStackPos;
1108
        }
1109

1110
        if (StrComp("loop", functions[opcode].name)) {
1111
            jumpTable[jumpTableStack[jumpTableStackPos--] + 1] = scriptCodePos - scriptCodeOffset;
1112
        }
1113

1114
        for (int32 i = 0; i < opcodeSize; ++i) {
1115
            ++textPos;
1116
            int32 varNamePos  = 0;
1117
            int32 parseMode   = 0;
1118
            int32 arrayStrPos = 0;
1119

1120
            while (text[textPos] != ',' && text[textPos] != ')' && text[textPos]) {
1121
                if (parseMode) {
1122
                    if (text[textPos] == ']')
1123
                        parseMode = 0;
1124
                    else
1125
                        arrayStr[arrayStrPos++] = text[textPos];
1126
                    ++textPos;
1127
                }
1128
                else {
1129
                    if (text[textPos] == '[')
1130
                        parseMode = 1;
1131
                    else
1132
                        funcName[varNamePos++] = text[textPos];
1133
                    ++textPos;
1134
                }
1135
            }
1136
            funcName[varNamePos]  = 0;
1137
            arrayStr[arrayStrPos] = 0;
1138

1139
            // Eg: TempValue0 = FX_SCALE
1140
            for (int32 a = 0; a < aliasCount; ++a) {
1141
                if (StrComp(funcName, aliases[a].name)) {
1142
                    CopyAliasStr(funcName, aliases[a].value, 0);
1143
                    if (FindStringToken(aliases[a].value, "[", 1) > -1)
1144
                        CopyAliasStr(arrayStr, aliases[a].value, 1);
1145
                }
1146
            }
1147

1148
            // Eg: TempValue0 = Game.Variable
1149
            for (int32 v = 0; v < globalVariablesCount; ++v) {
1150
                if (StrComp(funcName, globalVariables[v].name)) {
1151
                    StrCopy(funcName, "Global");
1152
                    arrayStr[0] = 0;
1153
                    AppendIntegerToString(arrayStr, v);
1154
                }
1155
            }
1156

1157
            // Eg: TempValue0 = Function1
1158
            for (int32 f = 0; f < scriptFunctionCount; ++f) {
1159
                if (StrComp(funcName, scriptFunctionList[f].name)) {
1160
                    funcName[0] = 0;
1161
                    AppendIntegerToString(funcName, f);
1162
                }
1163
            }
1164

1165
            // Eg: TempValue0 = TypeName[PlayerObject]
1166
            if (StrComp(funcName, "TypeName")) {
1167
                funcName[0] = '0';
1168
                funcName[1] = 0;
1169

1170
                for (int32 o = 0; o < LEGACY_v3_OBJECT_COUNT; ++o) {
1171
                    if (StrComp(arrayStr, typeNames[o])) {
1172
                        funcName[0] = 0;
1173
                        AppendIntegerToString(funcName, o);
1174
                    }
1175
                }
1176
            }
1177

1178
#if RETRO_USE_MOD_LOADER
1179
            // Eg: TempValue0 = SfxName[Jump]
1180
            if (StrComp(funcName, "SfxName")) {
1181
                funcName[0] = '0';
1182
                funcName[1] = 0;
1183

1184
                int32 s = 0;
1185
                for (; s < globalSFXCount; ++s) {
1186
                    if (StrComp(arrayStr, globalSfxNames[s])) {
1187
                        funcName[0] = 0;
1188
                        AppendIntegerToString(funcName, s);
1189
                        break;
1190
                    }
1191
                }
1192

1193
                if (s == globalSFXCount) {
1194
                    s = 0;
1195
                    for (; s < stageSFXCount; ++s) {
1196
                        if (StrComp(arrayStr, stageSfxNames[s])) {
1197
                            funcName[0] = 0;
1198
                            AppendIntegerToString(funcName, s);
1199
                            break;
1200
                        }
1201
                    }
1202

1203
                    if (s == stageSFXCount)
1204
                        PrintLog(PRINT_NORMAL, "WARNING: Unknown SfxName \"%s\"", arrayStr);
1205
                }
1206
            }
1207

1208
            // Eg: TempValue0 = AchievementName[ACH_RING_KING]
1209
            if (StrComp(funcName, "AchievementName")) {
1210
                funcName[0] = '0';
1211
                funcName[1] = 0;
1212

1213
                int32 a = 0;
1214
                for (; a < (int32)achievementList.size(); ++a) {
1215
                    char buf[0x40];
1216
                    const char *str = achievementList[a].identifier.c_str();
1217
                    int32 pos       = 0;
1218

1219
                    while (*str) {
1220
                        if (*str != ' ')
1221
                            buf[pos++] = *str;
1222
                        str++;
1223
                    }
1224
                    buf[pos] = 0;
1225

1226
                    if (StrComp(arrayStr, buf)) {
1227
                        funcName[0] = 0;
1228
                        AppendIntegerToString(funcName, a);
1229
                        break;
1230
                    }
1231
                }
1232

1233
                if (a == (int32)achievementList.size())
1234
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown AchievementName \"%s\"", arrayStr);
1235
            }
1236

1237
            // Eg: TempValue0 = PlayerName[SONIC]
1238
            if (StrComp(funcName, "PlayerName")) {
1239
                funcName[0] = '0';
1240
                funcName[1] = 0;
1241

1242
                int32 p = 0;
1243
                for (; p < LEGACY_PLAYERNAME_COUNT; ++p) {
1244
                    char buf[0x40];
1245
                    char *str = modSettings.playerNames[p];
1246
                    int32 pos = 0;
1247

1248
                    while (*str) {
1249
                        if (*str != ' ')
1250
                            buf[pos++] = *str;
1251
                        str++;
1252
                    }
1253
                    buf[pos] = 0;
1254

1255
                    if (StrComp(arrayStr, buf)) {
1256
                        funcName[0] = 0;
1257
                        AppendIntegerToString(funcName, p);
1258
                        break;
1259
                    }
1260
                }
1261

1262
                if (p == LEGACY_PLAYERNAME_COUNT)
1263
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown PlayerName \"%s\", on line %d", arrayStr, lineID);
1264
            }
1265

1266
            // Eg: TempValue0 = StageName[R - PALMTREE PANIC ZONE 1 A]
1267
            if (StrComp(funcName, "StageName")) {
1268
                funcName[0] = '0';
1269
                funcName[1] = 0;
1270

1271
                int32 s = -1;
1272
                if (StrLength(arrayStr) >= 2) {
1273
                    char list = arrayStr[0];
1274
                    switch (list) {
1275
                        case 'P': list = STAGELIST_PRESENTATION; break;
1276
                        case 'R': list = STAGELIST_REGULAR; break;
1277
                        case 'B': list = STAGELIST_BONUS; break;
1278
                        case 'S': list = STAGELIST_SPECIAL; break;
1279
                    }
1280
                    if (list <= 3) {
1281
                        char scnName[0x40];
1282
                        int32 scnPos          = 0;
1283
                        int32 pos             = 0;
1284
                        const char *sceneName = &arrayStr[2];
1285

1286
                        while (sceneName[scnPos]) {
1287
                            if (sceneName[scnPos] != ' ')
1288
                                scnName[pos++] = sceneName[scnPos];
1289
                            ++scnPos;
1290
                        }
1291
                        scnName[pos]           = 0;
1292
                        SceneListInfo *listCat = &sceneInfo.listCategory[list];
1293
                        int32 l                = listCat->sceneOffsetStart;
1294
                        for (int32 c = 0; c < listCat->sceneCount; ++c) {
1295
                            char nameBuffer[0x40];
1296

1297
                            scnPos = 0;
1298
                            pos    = 0;
1299
                            while (sceneInfo.listData[l].name[scnPos]) {
1300
                                if (sceneInfo.listData[l].name[scnPos] != ' ')
1301
                                    nameBuffer[pos++] = sceneInfo.listData[l].name[scnPos];
1302
                                ++scnPos;
1303
                            }
1304
                            nameBuffer[pos] = 0;
1305

1306
                            if (StrComp(scnName, nameBuffer)) {
1307
                                s = c;
1308
                                break;
1309
                            }
1310
                            l++;
1311
                        }
1312
                    }
1313
                }
1314

1315
                if (s == -1) {
1316
                    PrintLog(PRINT_NORMAL, "WARNING: Unknown StageName \"%s\", on line %d", arrayStr, lineID);
1317
                    s = 0;
1318
                }
1319

1320
                funcName[0] = 0;
1321
                AppendIntegerToString(funcName, s);
1322
            }
1323
#endif
1324

1325
            int32 constant = 0;
1326
            if (ConvertStringToInteger(funcName, &constant)) {
1327
                scriptCode[scriptCodePos++] = SCRIPTVAR_INTCONST;
1328
                scriptCode[scriptCodePos++] = constant;
1329
            }
1330
            else if (funcName[0] == '"') {
1331
                scriptCode[scriptCodePos++] = SCRIPTVAR_STRCONST;
1332
                scriptCode[scriptCodePos++] = StrLength(funcName) - 2;
1333

1334
                int32 scriptTextPos = 1;
1335
                arrayStrPos         = 0;
1336
                while (scriptTextPos > -1) {
1337
                    switch (arrayStrPos) {
1338
                        case 0:
1339
                            scriptCode[scriptCodePos] = funcName[scriptTextPos] << 24;
1340
                            ++arrayStrPos;
1341
                            break;
1342

1343
                        case 1:
1344
                            scriptCode[scriptCodePos] += funcName[scriptTextPos] << 16;
1345
                            ++arrayStrPos;
1346
                            break;
1347

1348
                        case 2:
1349
                            scriptCode[scriptCodePos] += funcName[scriptTextPos] << 8;
1350
                            ++arrayStrPos;
1351
                            break;
1352

1353
                        case 3:
1354
                            scriptCode[scriptCodePos++] += funcName[scriptTextPos];
1355
                            arrayStrPos = 0;
1356
                            break;
1357

1358
                        default: break;
1359
                    }
1360

1361
                    if (funcName[scriptTextPos] == '"') {
1362
                        if (arrayStrPos > 0)
1363
                            ++scriptCodePos;
1364
                        scriptTextPos = -1;
1365
                    }
1366
                    else {
1367
                        scriptTextPos++;
1368
                    }
1369
                }
1370
            }
1371
            else {
1372
                scriptCode[scriptCodePos++] = SCRIPTVAR_VAR;
1373
                if (arrayStr[0]) {
1374
                    scriptCode[scriptCodePos] = VARARR_ARRAY;
1375

1376
                    if (arrayStr[0] == '+')
1377
                        scriptCode[scriptCodePos] = VARARR_ENTNOPLUS1;
1378

1379
                    if (arrayStr[0] == '-')
1380
                        scriptCode[scriptCodePos] = VARARR_ENTNOMINUS1;
1381

1382
                    ++scriptCodePos;
1383

1384
                    if (arrayStr[0] == '-' || arrayStr[0] == '+') {
1385
                        for (int32 i = 0; i < StrLength(arrayStr); ++i) arrayStr[i] = arrayStr[i + 1];
1386
                    }
1387

1388
                    if (ConvertStringToInteger(arrayStr, &constant)) {
1389
                        scriptCode[scriptCodePos++] = 0;
1390
                        scriptCode[scriptCodePos++] = constant;
1391
                    }
1392
                    else {
1393
                        if (StrComp(arrayStr, "ArrayPos0"))
1394
                            constant = 0;
1395
                        if (StrComp(arrayStr, "ArrayPos1"))
1396
                            constant = 1;
1397
                        if (StrComp(arrayStr, "TempObjectPos"))
1398
                            constant = 2;
1399

1400
                        scriptCode[scriptCodePos++] = 1;
1401
                        scriptCode[scriptCodePos++] = constant;
1402
                    }
1403
                }
1404
                else {
1405
                    scriptCode[scriptCodePos++] = VARARR_NONE;
1406
                }
1407

1408
                constant = -1;
1409
                for (int32 i = 0; i < VAR_MAX_CNT; ++i) {
1410
                    if (StrComp(funcName, variableNames[i]))
1411
                        constant = i;
1412
                }
1413

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

1417
                    gameMode = ENGINE_SCRIPTERROR;
1418
                    constant = 0;
1419
                }
1420

1421
                scriptCode[scriptCodePos++] = constant;
1422
            }
1423
        }
1424
    }
1425
}
1426
void RSDK::Legacy::v3::CheckCaseNumber(char *text)
1427
{
1428
    if (FindStringToken(text, "case", 1) != 0)
1429
        return;
1430

1431
    char caseString[128];
1432
    char caseChar = text[4];
1433

1434
    int32 textPos    = 5;
1435
    int32 caseStrPos = 0;
1436
    while (caseChar) {
1437
        if (caseChar != ':')
1438
            caseString[caseStrPos++] = caseChar;
1439
        caseChar = text[textPos++];
1440
    }
1441
    caseString[caseStrPos] = 0;
1442

1443
    for (int32 a = 0; a < aliasCount; ++a) {
1444
        if (StrComp(aliases[a].name, caseString)) {
1445
            StrCopy(caseString, aliases[a].value);
1446
            break;
1447
        }
1448
    }
1449

1450
    int32 caseID = 0;
1451
    if (ConvertStringToInteger(caseString, &caseID)) {
1452
        int32 stackValue = jumpTableStack[jumpTableStackPos];
1453
        if (caseID < jumpTable[stackValue])
1454
            jumpTable[stackValue] = caseID;
1455
        stackValue++;
1456
        if (caseID > jumpTable[stackValue])
1457
            jumpTable[stackValue] = caseID;
1458
    }
1459
    else {
1460
        PrintLog(PRINT_SCRIPTERR, "SCRIPT ERROR: Invalid switch case\nOPCODE: %s\nLINE: %d\nFILE: %s", caseString, lineID, scriptFile);
1461
        gameMode = ENGINE_SCRIPTERROR;
1462
    }
1463
}
1464
bool32 RSDK::Legacy::v3::ReadSwitchCase(char *text)
1465
{
1466
    char caseText[0x80];
1467
    if (FindStringToken(text, "case", 1) == 0) {
1468
        int32 textPos       = 4;
1469
        int32 caseStringPos = 0;
1470
        while (text[textPos]) {
1471
            if (text[textPos] != ':')
1472
                caseText[caseStringPos++] = text[textPos];
1473
            ++textPos;
1474
        }
1475
        caseText[caseStringPos] = 0;
1476
        for (int32 a = 0; a < aliasCount; ++a) {
1477
            if (StrComp(caseText, aliases[a].name))
1478
                StrCopy(caseText, aliases[a].value);
1479
        }
1480

1481
        int32 val = 0;
1482

1483
        int32 jPos    = jumpTableStack[jumpTableStackPos];
1484
        int32 jOffset = jPos + 4;
1485
        if (ConvertStringToInteger(caseText, &val))
1486
            jumpTable[val - jumpTable[jPos] + jOffset] = scriptCodePos - scriptCodeOffset;
1487
        return true;
1488
    }
1489
    else if (FindStringToken(text, "default", 1) == 0) {
1490
        int32 jumpTablepos          = jumpTableStack[jumpTableStackPos];
1491
        jumpTable[jumpTablepos + 2] = scriptCodePos - scriptCodeOffset;
1492
        int32 cnt                   = abs(jumpTable[jumpTablepos + 1] - jumpTable[jumpTablepos]) + 1;
1493

1494
        int32 jOffset = jumpTablepos + 4;
1495
        for (int32 i = 0; i < cnt; ++i) {
1496
            if (jumpTable[jOffset + i] < 0)
1497
                jumpTable[jOffset + i] = scriptCodePos - scriptCodeOffset;
1498
        }
1499
        return true;
1500
    }
1501

1502
    return false;
1503
}
1504
void RSDK::Legacy::v3::AppendIntegerToString(char *text, int32 value)
1505
{
1506
    int32 textPos = 0;
1507
    while (text[textPos]) {
1508
        ++textPos;
1509
    }
1510

1511
    int32 cnt = 0;
1512
    int32 v   = value;
1513
    while (v != 0) {
1514
        v /= 10;
1515
        cnt++;
1516
    }
1517

1518
    v = 0;
1519
    for (int32 i = cnt - 1; i >= 0; --i) {
1520
        v = (int32)(value / pow(10, i));
1521
        v %= 10;
1522

1523
        int32 strValue = v + '0';
1524
        if (strValue < '0' || strValue > '9') {
1525
            // what
1526
        }
1527
        text[textPos++] = strValue;
1528
    }
1529
    if (value == 0)
1530
        text[textPos++] = '0';
1531
    text[textPos] = 0;
1532
}
1533
void RSDK::Legacy::v3::CopyAliasStr(char *dest, char *text, bool32 arrayIndex)
1534
{
1535
    int32 textPos     = 0;
1536
    int32 destPos     = 0;
1537
    bool32 arrayValue = false;
1538

1539
    if (arrayIndex) {
1540
        while (text[textPos]) {
1541
            if (arrayValue) {
1542
                if (text[textPos] == ']')
1543
                    arrayValue = false;
1544
                else
1545
                    dest[destPos++] = text[textPos];
1546
                ++textPos;
1547
            }
1548
            else {
1549
                if (text[textPos] == '[')
1550
                    arrayValue = true;
1551
                ++textPos;
1552
            }
1553
        }
1554
    }
1555
    else {
1556
        while (text[textPos]) {
1557
            if (arrayValue) {
1558
                if (text[textPos] == ']')
1559
                    arrayValue = false;
1560
                ++textPos;
1561
            }
1562
            else {
1563
                if (text[textPos] == '[')
1564
                    arrayValue = true;
1565
                else
1566
                    dest[destPos++] = text[textPos];
1567
                ++textPos;
1568
            }
1569
        }
1570
    }
1571
    dest[destPos] = 0;
1572
}
1573
bool32 RSDK::Legacy::v3::CheckOpcodeType(char *text)
1574
{
1575
    while (*text) {
1576
        if (*text++ == '(')
1577
            return false;
1578
    }
1579
    return true;
1580
}
1581

1582
void RSDK::Legacy::v3::ParseScriptFile(char *scriptName, int32 scriptID)
1583
{
1584
    jumpTableStackPos = 0;
1585
    lineID            = 0;
1586
    aliasCount        = LEGACY_v3_COMMONALIAS_COUNT;
1587
    for (int32 i = LEGACY_v3_COMMONALIAS_COUNT; i < LEGACY_v3_ALIAS_COUNT; ++i) {
1588
        StrCopy(aliases[i].name, "");
1589
        StrCopy(aliases[i].value, "");
1590
    }
1591

1592
    scriptFile = scriptName;
1593

1594
    char scriptPath[0x40];
1595
    StrCopy(scriptPath, "Data/Scripts/");
1596
    StrAdd(scriptPath, scriptName);
1597

1598
    FileInfo info;
1599
    InitFileInfo(&info);
1600

1601
    if (LoadFile(&info, scriptPath, FMODE_RB)) {
1602
        int32 readMode   = READMODE_NORMAL;
1603
        int32 parseMode  = PARSEMODE_SCOPELESS;
1604
        int32 storedPos  = 0;
1605
        char prevChar    = 0;
1606
        char curChar     = 0;
1607
        int32 switchDeep = 0;
1608

1609
        while (readMode < READMODE_EOF) {
1610
            int32 textPos = 0;
1611
            readMode      = READMODE_NORMAL;
1612
            while (readMode < READMODE_ENDLINE) {
1613
                prevChar = curChar;
1614
                curChar  = ReadInt8(&info);
1615

1616
                if (readMode == READMODE_STRING) {
1617
                    if (curChar == '\t' || curChar == '\r' || curChar == '\n' || curChar == ';' || readMode >= READMODE_COMMENTLINE) {
1618
                        if ((curChar == '\n' && prevChar != '\r') || (curChar == '\n' && prevChar == '\r')) {
1619
                            readMode            = READMODE_ENDLINE;
1620
                            scriptText[textPos] = 0;
1621
                        }
1622
                    }
1623
                    else if (curChar != '/' || textPos <= 0) {
1624
                        scriptText[textPos++] = curChar;
1625
                        if (curChar == '"')
1626
                            readMode = READMODE_NORMAL;
1627
                    }
1628
                    else if (curChar == '/' && prevChar == '/') {
1629
                        readMode              = READMODE_COMMENTLINE;
1630
                        scriptText[--textPos] = 0;
1631
                    }
1632
                    else {
1633
                        scriptText[textPos++] = curChar;
1634
                    }
1635
                }
1636
                else if (curChar == ' ' || curChar == '\t' || curChar == '\r' || curChar == '\n' || curChar == ';'
1637
                         || readMode >= READMODE_COMMENTLINE) {
1638
                    if ((curChar == '\n' && prevChar != '\r') || (curChar == '\n' && prevChar == '\r')) {
1639
                        readMode            = READMODE_ENDLINE;
1640
                        scriptText[textPos] = 0;
1641
                    }
1642
                }
1643
                else if (curChar != '/' || textPos <= 0) {
1644
                    scriptText[textPos++] = curChar;
1645
                    if (curChar == '"' && !readMode)
1646
                        readMode = READMODE_STRING;
1647
                }
1648
                else if (curChar == '/' && prevChar == '/') {
1649
                    readMode              = READMODE_COMMENTLINE;
1650
                    scriptText[--textPos] = 0;
1651
                }
1652
                else {
1653
                    scriptText[textPos++] = curChar;
1654
                }
1655

1656
                if (info.readPos >= info.fileSize) {
1657
                    scriptText[textPos] = 0;
1658
                    readMode            = READMODE_EOF;
1659
                }
1660
            }
1661

1662
            switch (parseMode) {
1663
                case PARSEMODE_SCOPELESS:
1664
                    ++lineID;
1665

1666
                    CheckAliasText(scriptText);
1667

1668
                    if (StrComp(scriptText, "subObjectMain")) {
1669
                        parseMode                                        = PARSEMODE_FUNCTION;
1670
                        objectScriptList[scriptID].subMain.scriptCodePtr = scriptCodePos;
1671
                        objectScriptList[scriptID].subMain.jumpTablePtr  = jumpTablePos;
1672
                        scriptCodeOffset                                 = scriptCodePos;
1673
                        jumpTableOffset                                  = jumpTablePos;
1674
                    }
1675

1676
                    if (StrComp(scriptText, "subObjectPlayerInteraction")) {
1677
                        parseMode                                                     = PARSEMODE_FUNCTION;
1678
                        objectScriptList[scriptID].subPlayerInteraction.scriptCodePtr = scriptCodePos;
1679
                        objectScriptList[scriptID].subPlayerInteraction.jumpTablePtr  = jumpTablePos;
1680
                        scriptCodeOffset                                              = scriptCodePos;
1681
                        jumpTableOffset                                               = jumpTablePos;
1682
                    }
1683

1684
                    if (StrComp(scriptText, "subObjectDraw")) {
1685
                        parseMode                                        = PARSEMODE_FUNCTION;
1686
                        objectScriptList[scriptID].subDraw.scriptCodePtr = scriptCodePos;
1687
                        objectScriptList[scriptID].subDraw.jumpTablePtr  = jumpTablePos;
1688
                        scriptCodeOffset                                 = scriptCodePos;
1689
                        jumpTableOffset                                  = jumpTablePos;
1690
                    }
1691

1692
                    if (StrComp(scriptText, "subObjectStartup")) {
1693
                        parseMode                                           = PARSEMODE_FUNCTION;
1694
                        objectScriptList[scriptID].subStartup.scriptCodePtr = scriptCodePos;
1695
                        objectScriptList[scriptID].subStartup.jumpTablePtr  = jumpTablePos;
1696
                        scriptCodeOffset                                    = scriptCodePos;
1697
                        jumpTableOffset                                     = jumpTablePos;
1698
                    }
1699

1700
                    if (FindStringToken(scriptText, "function", 1) == 0) { // regular decl.
1701
                        char funcName[0x20];
1702
                        for (textPos = 8; scriptText[textPos]; ++textPos) funcName[textPos - 8] = scriptText[textPos];
1703
                        funcName[textPos - 8] = 0;
1704

1705
                        int32 funcID = -1;
1706
                        for (int32 f = 0; f < scriptFunctionCount; ++f) {
1707
                            if (StrComp(funcName, scriptFunctionList[f].name))
1708
                                funcID = f;
1709
                        }
1710

1711
                        if (funcID <= -1) {
1712
                            if (scriptFunctionCount >= LEGACY_v3_FUNCTION_COUNT) {
1713
                                parseMode = PARSEMODE_SCOPELESS;
1714
                            }
1715
                            else {
1716
                                StrCopy(scriptFunctionList[scriptFunctionCount].name, funcName);
1717
                                scriptFunctionList[scriptFunctionCount].ptr.scriptCodePtr = scriptCodePos;
1718
                                scriptFunctionList[scriptFunctionCount].ptr.jumpTablePtr  = jumpTablePos;
1719
                                scriptCodeOffset                                          = scriptCodePos;
1720
                                jumpTableOffset                                           = jumpTablePos;
1721
                                parseMode                                                 = PARSEMODE_FUNCTION;
1722
                                ++scriptFunctionCount;
1723
                            }
1724
                        }
1725
                        else {
1726
                            StrCopy(scriptFunctionList[funcID].name, funcName);
1727
                            scriptFunctionList[funcID].ptr.scriptCodePtr = scriptCodePos;
1728
                            scriptFunctionList[funcID].ptr.jumpTablePtr  = jumpTablePos;
1729
                            scriptCodeOffset                             = scriptCodePos;
1730
                            jumpTableOffset                              = jumpTablePos;
1731
                            parseMode                                    = PARSEMODE_FUNCTION;
1732
                        }
1733
                    }
1734
                    else if (FindStringToken(scriptText, "function", 1) == 1) { // forward decl.
1735
                        char funcName[0x20];
1736
                        for (textPos = 9; scriptText[textPos]; ++textPos) funcName[textPos - 9] = scriptText[textPos];
1737
                        funcName[textPos - 9] = 0;
1738

1739
                        int32 funcID = -1;
1740
                        for (int32 f = 0; f < scriptFunctionCount; ++f) {
1741
                            if (StrComp(funcName, scriptFunctionList[f].name))
1742
                                funcID = f;
1743
                        }
1744

1745
                        if (scriptFunctionCount < LEGACY_v3_FUNCTION_COUNT && funcID == -1) {
1746
                            StrCopy(scriptFunctionList[scriptFunctionCount++].name, funcName);
1747
                        }
1748

1749
                        parseMode = PARSEMODE_SCOPELESS;
1750
                    }
1751
                    break;
1752

1753
                case PARSEMODE_PLATFORMSKIP:
1754
                    ++lineID;
1755

1756
                    if (FindStringToken(scriptText, "#endplatform", 1) == 0)
1757
                        parseMode = PARSEMODE_FUNCTION;
1758
                    break;
1759

1760
                case PARSEMODE_FUNCTION:
1761
                    ++lineID;
1762

1763
                    if (scriptText[0]) {
1764
                        if (StrComp(scriptText, "endsub")) {
1765
                            scriptCode[scriptCodePos++] = FUNC_END;
1766
                            parseMode                   = PARSEMODE_SCOPELESS;
1767
                        }
1768
                        else if (StrComp(scriptText, "endfunction")) {
1769
                            scriptCode[scriptCodePos++] = FUNC_ENDFUNCTION;
1770
                            parseMode                   = PARSEMODE_SCOPELESS;
1771
                        }
1772
                        else if (FindStringToken(scriptText, "#platform:", 1) == 0) {
1773
                            if (FindStringToken(scriptText, engine.gamePlatform, 1) == -1
1774
                                && FindStringToken(scriptText, engine.gameRenderType, 1) == -1
1775
#if LEGACY_RETRO_USE_HAPTICS
1776
                                && FindStringToken(scriptText, engine.gameHapticSetting, 1) == -1
1777
#endif
1778
#if !RETRO_USE_ORIGINAL_CODE
1779
                                && FindStringToken(scriptText, engine.releaseType, 1) == -1 // general flag for new stuff origins added
1780
#endif
1781
#if !RETRO_USE_ORIGINAL_CODE
1782
                                && FindStringToken(scriptText, "Use_Decomp", 1) == -1
1783
#endif
1784
#if RETRO_USE_MOD_LOADER
1785
                                && FindStringToken(scriptText, "Use_Mod_Loader", 1) == -1
1786
#endif
1787
                            ) { // if NONE of these checks succeeded, then we skip everything until "end platform"
1788
                                parseMode = PARSEMODE_PLATFORMSKIP;
1789
                            }
1790
                        }
1791
                        else if (FindStringToken(scriptText, "#endplatform", 1) == -1) {
1792
                            ConvertIfWhileStatement(scriptText);
1793

1794
                            if (ConvertSwitchStatement(scriptText)) {
1795
                                parseMode  = PARSEMODE_SWITCHREAD;
1796
                                storedPos  = (int32)info.readPos;
1797
                                switchDeep = 0;
1798
                            }
1799

1800
                            ConvertArithmaticSyntax(scriptText);
1801

1802
                            if (!ReadSwitchCase(scriptText)) {
1803
                                ConvertFunctionText(scriptText);
1804

1805
                                if (gameMode == ENGINE_SCRIPTERROR) {
1806
                                    parseMode = PARSEMODE_ERROR;
1807
                                }
1808
                            }
1809
                        }
1810
                    }
1811
                    break;
1812

1813
                case PARSEMODE_SWITCHREAD:
1814
                    if (FindStringToken(scriptText, "switch", 1) == 0)
1815
                        ++switchDeep;
1816

1817
                    if (switchDeep) {
1818
                        if (FindStringToken(scriptText, "endswitch", 1) == 0)
1819
                            --switchDeep;
1820
                    }
1821
                    else if (FindStringToken(scriptText, "endswitch", 1) == 0) {
1822
                        Seek_Set(&info, storedPos);
1823
                        parseMode  = PARSEMODE_FUNCTION;
1824
                        int32 jPos = jumpTableStack[jumpTableStackPos];
1825
                        switchDeep = abs(jumpTable[jPos + 1] - jumpTable[jPos]) + 1;
1826
                        for (textPos = 0; textPos < switchDeep; ++textPos) jumpTable[jumpTablePos++] = -1;
1827
                    }
1828
                    else {
1829
                        CheckCaseNumber(scriptText);
1830
                    }
1831
                    break;
1832

1833
                default: break;
1834
            }
1835
        }
1836

1837
        CloseFile(&info);
1838
    }
1839
}
1840
#endif
1841

1842
void RSDK::Legacy::v3::LoadBytecode(int32 scriptID, bool32 globalCode)
1843
{
1844
    char scriptPath[0x40];
1845
    if (globalCode) {
1846
        StrCopy(scriptPath, "Data/Scripts/Bytecode/GlobalCode.bin");
1847
    }
1848
    else {
1849
        StrCopy(scriptPath, "Data/Scripts/Bytecode/");
1850
        StrAdd(scriptPath, sceneInfo.listData[sceneInfo.listPos].folder);
1851
        StrAdd(scriptPath, ".bin");
1852
    }
1853

1854
    FileInfo info;
1855
    InitFileInfo(&info);
1856
    if (LoadFile(&info, scriptPath, FMODE_RB)) {
1857
        int32 *scriptCodePtr = &scriptCode[scriptCodePos];
1858
        int32 *jumpTablePtr  = &jumpTable[jumpTablePos];
1859

1860
        int32 scriptCodeSize = ReadInt8(&info);
1861
        scriptCodeSize |= ReadInt8(&info) << 8;
1862
        scriptCodeSize |= ReadInt8(&info) << 16;
1863
        scriptCodeSize |= ReadInt8(&info) << 24;
1864

1865
        while (scriptCodeSize > 0) {
1866
            int32 fileBuffer = ReadInt8(&info);
1867
            int32 blockSize  = fileBuffer & 0x7F;
1868

1869
            if (fileBuffer >= 0x80) {
1870
                while (blockSize > 0) {
1871
                    *scriptCodePtr = ReadInt8(&info);
1872
                    *scriptCodePtr |= ReadInt8(&info) << 8;
1873
                    *scriptCodePtr |= ReadInt8(&info) << 16;
1874
                    *scriptCodePtr |= ReadInt8(&info) << 24;
1875

1876
                    ++scriptCodePtr;
1877
                    ++scriptCodePos;
1878
                    --scriptCodeSize;
1879
                    --blockSize;
1880
                }
1881
            }
1882
            else {
1883
                while (blockSize > 0) {
1884
                    *scriptCodePtr = ReadInt8(&info);
1885

1886
                    ++scriptCodePtr;
1887
                    ++scriptCodePos;
1888
                    --scriptCodeSize;
1889
                    --blockSize;
1890
                }
1891
            }
1892
        }
1893

1894
        int32 jumpTableSize = ReadInt8(&info);
1895
        jumpTableSize |= ReadInt8(&info) << 8;
1896
        jumpTableSize |= ReadInt8(&info) << 16;
1897
        jumpTableSize |= ReadInt8(&info) << 24;
1898

1899
        while (jumpTableSize > 0) {
1900
            int32 fileBuffer = ReadInt8(&info);
1901
            int32 blockSize  = fileBuffer & 0x7F;
1902

1903
            if (fileBuffer >= 0x80) {
1904
                while (blockSize > 0) {
1905
                    *jumpTablePtr = ReadInt8(&info);
1906
                    *jumpTablePtr |= ReadInt8(&info) << 8;
1907
                    *jumpTablePtr |= ReadInt8(&info) << 16;
1908
                    *jumpTablePtr |= ReadInt8(&info) << 24;
1909

1910
                    ++jumpTablePtr;
1911
                    ++jumpTablePos;
1912
                    --jumpTableSize;
1913
                    --blockSize;
1914
                }
1915
            }
1916
            else {
1917
                while (blockSize > 0) {
1918
                    *jumpTablePtr = ReadInt8(&info);
1919

1920
                    ++jumpTablePtr;
1921
                    ++jumpTablePos;
1922
                    --jumpTableSize;
1923
                    --blockSize;
1924
                }
1925
            }
1926
        }
1927

1928
        int32 scriptCount = ReadInt8(&info);
1929
        scriptCount |= ReadInt8(&info) << 8;
1930

1931
        for (int32 s = 0; s < scriptCount; ++s) {
1932
            ObjectScript *script = &objectScriptList[scriptID + s];
1933

1934
            script->subMain.scriptCodePtr = ReadInt8(&info);
1935
            script->subMain.scriptCodePtr |= ReadInt8(&info) << 8;
1936
            script->subMain.scriptCodePtr |= ReadInt8(&info) << 16;
1937
            script->subMain.scriptCodePtr |= ReadInt8(&info) << 24;
1938

1939
            script->subPlayerInteraction.scriptCodePtr = ReadInt8(&info);
1940
            script->subPlayerInteraction.scriptCodePtr |= ReadInt8(&info) << 8;
1941
            script->subPlayerInteraction.scriptCodePtr |= ReadInt8(&info) << 16;
1942
            script->subPlayerInteraction.scriptCodePtr |= ReadInt8(&info) << 24;
1943

1944
            script->subDraw.scriptCodePtr = ReadInt8(&info);
1945
            script->subDraw.scriptCodePtr |= ReadInt8(&info) << 8;
1946
            script->subDraw.scriptCodePtr |= ReadInt8(&info) << 16;
1947
            script->subDraw.scriptCodePtr |= ReadInt8(&info) << 24;
1948

1949
            script->subStartup.scriptCodePtr = ReadInt8(&info);
1950
            script->subStartup.scriptCodePtr |= ReadInt8(&info) << 8;
1951
            script->subStartup.scriptCodePtr |= ReadInt8(&info) << 16;
1952
            script->subStartup.scriptCodePtr |= ReadInt8(&info) << 24;
1953
        }
1954

1955
        for (int32 s = 0; s < scriptCount; ++s) {
1956
            ObjectScript *script = &objectScriptList[scriptID + s];
1957

1958
            script->subMain.jumpTablePtr = ReadInt8(&info);
1959
            script->subMain.jumpTablePtr |= ReadInt8(&info) << 8;
1960
            script->subMain.jumpTablePtr |= ReadInt8(&info) << 16;
1961
            script->subMain.jumpTablePtr |= ReadInt8(&info) << 24;
1962

1963
            script->subPlayerInteraction.jumpTablePtr = ReadInt8(&info);
1964
            script->subPlayerInteraction.jumpTablePtr |= ReadInt8(&info) << 8;
1965
            script->subPlayerInteraction.jumpTablePtr |= ReadInt8(&info) << 16;
1966
            script->subPlayerInteraction.jumpTablePtr |= ReadInt8(&info) << 24;
1967

1968
            script->subDraw.jumpTablePtr = ReadInt8(&info);
1969
            script->subDraw.jumpTablePtr |= ReadInt8(&info) << 8;
1970
            script->subDraw.jumpTablePtr |= ReadInt8(&info) << 16;
1971
            script->subDraw.jumpTablePtr |= ReadInt8(&info) << 24;
1972

1973
            script->subStartup.jumpTablePtr = ReadInt8(&info);
1974
            script->subStartup.jumpTablePtr |= ReadInt8(&info) << 8;
1975
            script->subStartup.jumpTablePtr |= ReadInt8(&info) << 16;
1976
            script->subStartup.jumpTablePtr |= ReadInt8(&info) << 24;
1977
        }
1978

1979
        int32 functionCount = ReadInt8(&info);
1980
        functionCount |= ReadInt8(&info) << 8;
1981

1982
        for (int32 f = 0; f < functionCount; ++f) {
1983
            ScriptFunction *function = &scriptFunctionList[f];
1984

1985
            function->ptr.scriptCodePtr = ReadInt8(&info);
1986
            function->ptr.scriptCodePtr |= ReadInt8(&info) << 8;
1987
            function->ptr.scriptCodePtr |= ReadInt8(&info) << 16;
1988
            function->ptr.scriptCodePtr |= ReadInt8(&info) << 24;
1989
        }
1990

1991
        for (int32 f = 0; f < functionCount; ++f) {
1992
            ScriptFunction *function = &scriptFunctionList[f];
1993

1994
            function->ptr.jumpTablePtr = ReadInt8(&info);
1995
            function->ptr.jumpTablePtr |= ReadInt8(&info) << 8;
1996
            function->ptr.jumpTablePtr |= ReadInt8(&info) << 16;
1997
            function->ptr.jumpTablePtr |= ReadInt8(&info) << 24;
1998
        }
1999

2000
        CloseFile(&info);
2001
    }
2002
}
2003

2004
void RSDK::Legacy::v3::ClearScriptData()
2005
{
2006
    memset(scriptCode, 0, LEGACY_v3_SCRIPTDATA_COUNT * sizeof(int32));
2007
    memset(jumpTable, 0, LEGACY_v3_JUMPTABLE_COUNT * sizeof(int32));
2008

2009
    scriptFrameCount = 0;
2010

2011
    scriptCodePos     = 0;
2012
    jumpTablePos      = 0;
2013
    jumpTableStackPos = 0;
2014
    functionStackPos  = 0;
2015

2016
    scriptCodePos    = 0;
2017
    scriptCodeOffset = 0;
2018
    jumpTablePos     = 0;
2019
    jumpTableOffset  = 0;
2020

2021
#if LEGACY_RETRO_USE_COMPILER
2022
    scriptFunctionCount = 0;
2023
#endif
2024

2025
    aliasCount = LEGACY_v3_COMMONALIAS_COUNT;
2026
    lineID     = 0;
2027

2028
    ClearGraphicsData();
2029
    ClearAnimationData();
2030

2031
    for (int32 p = 0; p < LEGACY_v3_PLAYER_COUNT; ++p) {
2032
        playerList[p].animationFile = GetDefaultAnimationRef();
2033
        playerList[p].boundEntity   = &objectEntityList[p];
2034
    }
2035

2036
    for (int32 o = 0; o < LEGACY_v3_OBJECT_COUNT; ++o) {
2037
        ObjectScript *scriptInfo                       = &objectScriptList[o];
2038
        scriptInfo->subMain.scriptCodePtr              = LEGACY_v3_SCRIPTDATA_COUNT - 1;
2039
        scriptInfo->subMain.jumpTablePtr               = LEGACY_v3_JUMPTABLE_COUNT - 1;
2040
        scriptInfo->subPlayerInteraction.scriptCodePtr = LEGACY_v3_SCRIPTDATA_COUNT - 1;
2041
        scriptInfo->subPlayerInteraction.jumpTablePtr  = LEGACY_v3_JUMPTABLE_COUNT - 1;
2042
        scriptInfo->subDraw.scriptCodePtr              = LEGACY_v3_SCRIPTDATA_COUNT - 1;
2043
        scriptInfo->subDraw.jumpTablePtr               = LEGACY_v3_JUMPTABLE_COUNT - 1;
2044
        scriptInfo->subStartup.scriptCodePtr           = LEGACY_v3_SCRIPTDATA_COUNT - 1;
2045
        scriptInfo->subStartup.jumpTablePtr            = LEGACY_v3_JUMPTABLE_COUNT - 1;
2046
        scriptInfo->frameListOffset                    = 0;
2047
        scriptInfo->spriteSheetID                      = 0;
2048
        scriptInfo->animFile                           = GetDefaultAnimationRef();
2049
        typeNames[o][0]                                = 0;
2050
    }
2051

2052
    for (int32 f = 0; f < LEGACY_v3_FUNCTION_COUNT; ++f) {
2053
        scriptFunctionList[f].ptr.scriptCodePtr = LEGACY_v3_SCRIPTDATA_COUNT - 1;
2054
        scriptFunctionList[f].ptr.jumpTablePtr  = LEGACY_v3_JUMPTABLE_COUNT - 1;
2055
    }
2056

2057
    SetObjectTypeName((char *)"Blank Object", 0);
2058
}
2059

2060
void RSDK::Legacy::v3::ProcessScript(int32 scriptCodeStart, int32 jumpTableStart, uint8 scriptSub)
2061
{
2062
    bool running        = true;
2063
    int32 scriptCodePtr = scriptCodeStart;
2064

2065
    jumpTableStackPos = 0;
2066
    functionStackPos  = 0;
2067
    while (running) {
2068
        int32 opcode           = scriptCode[scriptCodePtr++];
2069
        int32 opcodeSize       = functions[opcode].opcodeSize;
2070
        int32 scriptCodeOffset = scriptCodePtr;
2071

2072
        // Get Values
2073
        for (int32 i = 0; i < opcodeSize; ++i) {
2074
            int32 opcodeType = scriptCode[scriptCodePtr++];
2075

2076
            if (opcodeType == SCRIPTVAR_VAR) {
2077
                int32 arrayVal = 0;
2078
                switch (scriptCode[scriptCodePtr++]) {
2079
                    case VARARR_NONE: arrayVal = objectLoop; break;
2080
                    case VARARR_ARRAY:
2081
                        if (scriptCode[scriptCodePtr++] == 1)
2082
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
2083
                        else
2084
                            arrayVal = scriptCode[scriptCodePtr++];
2085
                        break;
2086
                    case VARARR_ENTNOPLUS1:
2087
                        if (scriptCode[scriptCodePtr++] == 1)
2088
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]] + objectLoop;
2089
                        else
2090
                            arrayVal = scriptCode[scriptCodePtr++] + objectLoop;
2091
                        break;
2092
                    case VARARR_ENTNOMINUS1:
2093
                        if (scriptCode[scriptCodePtr++] == 1)
2094
                            arrayVal = objectLoop - scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
2095
                        else
2096
                            arrayVal = objectLoop - scriptCode[scriptCodePtr++];
2097
                        break;
2098
                    default: break;
2099
                }
2100

2101
                // Variables
2102
                switch (scriptCode[scriptCodePtr++]) {
2103
                    default: break;
2104
                    case VAR_TEMPVALUE0: scriptEng.operands[i] = scriptEng.tempValue[0]; break;
2105
                    case VAR_TEMPVALUE1: scriptEng.operands[i] = scriptEng.tempValue[1]; break;
2106
                    case VAR_TEMPVALUE2: scriptEng.operands[i] = scriptEng.tempValue[2]; break;
2107
                    case VAR_TEMPVALUE3: scriptEng.operands[i] = scriptEng.tempValue[3]; break;
2108
                    case VAR_TEMPVALUE4: scriptEng.operands[i] = scriptEng.tempValue[4]; break;
2109
                    case VAR_TEMPVALUE5: scriptEng.operands[i] = scriptEng.tempValue[5]; break;
2110
                    case VAR_TEMPVALUE6: scriptEng.operands[i] = scriptEng.tempValue[6]; break;
2111
                    case VAR_TEMPVALUE7: scriptEng.operands[i] = scriptEng.tempValue[7]; break;
2112
                    case VAR_CHECKRESULT: scriptEng.operands[i] = scriptEng.checkResult; break;
2113
                    case VAR_ARRAYPOS0: scriptEng.operands[i] = scriptEng.arrayPosition[0]; break;
2114
                    case VAR_ARRAYPOS1: scriptEng.operands[i] = scriptEng.arrayPosition[1]; break;
2115
                    case VAR_GLOBAL: scriptEng.operands[i] = globalVariables[arrayVal].value; break;
2116
                    case VAR_OBJECTENTITYNO: scriptEng.operands[i] = arrayVal; break;
2117
                    case VAR_OBJECTTYPE: {
2118
                        scriptEng.operands[i] = objectEntityList[arrayVal].type;
2119
                        break;
2120
                    }
2121
                    case VAR_OBJECTPROPERTYVALUE: {
2122
                        scriptEng.operands[i] = objectEntityList[arrayVal].propertyValue;
2123
                        break;
2124
                    }
2125
                    case VAR_OBJECTXPOS: {
2126
                        scriptEng.operands[i] = objectEntityList[arrayVal].XPos;
2127
                        break;
2128
                    }
2129
                    case VAR_OBJECTYPOS: {
2130
                        scriptEng.operands[i] = objectEntityList[arrayVal].YPos;
2131
                        break;
2132
                    }
2133
                    case VAR_OBJECTIXPOS: {
2134
                        scriptEng.operands[i] = objectEntityList[arrayVal].XPos >> 16;
2135
                        break;
2136
                    }
2137
                    case VAR_OBJECTIYPOS: {
2138
                        scriptEng.operands[i] = objectEntityList[arrayVal].YPos >> 16;
2139
                        break;
2140
                    }
2141
                    case VAR_OBJECTSTATE: {
2142
                        scriptEng.operands[i] = objectEntityList[arrayVal].state;
2143
                        break;
2144
                    }
2145
                    case VAR_OBJECTROTATION: {
2146
                        scriptEng.operands[i] = objectEntityList[arrayVal].rotation;
2147
                        break;
2148
                    }
2149
                    case VAR_OBJECTSCALE: {
2150
                        scriptEng.operands[i] = objectEntityList[arrayVal].scale;
2151
                        break;
2152
                    }
2153
                    case VAR_OBJECTPRIORITY: {
2154
                        scriptEng.operands[i] = objectEntityList[arrayVal].priority;
2155
                        break;
2156
                    }
2157
                    case VAR_OBJECTDRAWORDER: {
2158
                        scriptEng.operands[i] = objectEntityList[arrayVal].drawOrder;
2159
                        break;
2160
                    }
2161
                    case VAR_OBJECTDIRECTION: {
2162
                        scriptEng.operands[i] = objectEntityList[arrayVal].direction;
2163
                        break;
2164
                    }
2165
                    case VAR_OBJECTINKEFFECT: {
2166
                        scriptEng.operands[i] = objectEntityList[arrayVal].inkEffect;
2167
                        break;
2168
                    }
2169
                    case VAR_OBJECTALPHA: {
2170
                        scriptEng.operands[i] = objectEntityList[arrayVal].alpha;
2171
                        break;
2172
                    }
2173
                    case VAR_OBJECTFRAME: {
2174
                        scriptEng.operands[i] = objectEntityList[arrayVal].frame;
2175
                        break;
2176
                    }
2177
                    case VAR_OBJECTANIMATION: {
2178
                        scriptEng.operands[i] = objectEntityList[arrayVal].animation;
2179
                        break;
2180
                    }
2181
                    case VAR_OBJECTPREVANIMATION: {
2182
                        scriptEng.operands[i] = objectEntityList[arrayVal].prevAnimation;
2183
                        break;
2184
                    }
2185
                    case VAR_OBJECTANIMATIONSPEED: {
2186
                        scriptEng.operands[i] = objectEntityList[arrayVal].animationSpeed;
2187
                        break;
2188
                    }
2189
                    case VAR_OBJECTANIMATIONTIMER: {
2190
                        scriptEng.operands[i] = objectEntityList[arrayVal].animationTimer;
2191
                        break;
2192
                    }
2193
                    case VAR_OBJECTVALUE0: {
2194
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[0];
2195
                        break;
2196
                    }
2197
                    case VAR_OBJECTVALUE1: {
2198
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[1];
2199
                        break;
2200
                    }
2201
                    case VAR_OBJECTVALUE2: {
2202
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[2];
2203
                        break;
2204
                    }
2205
                    case VAR_OBJECTVALUE3: {
2206
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[3];
2207
                        break;
2208
                    }
2209
                    case VAR_OBJECTVALUE4: {
2210
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[4];
2211
                        break;
2212
                    }
2213
                    case VAR_OBJECTVALUE5: {
2214
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[5];
2215
                        break;
2216
                    }
2217
                    case VAR_OBJECTVALUE6: {
2218
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[6];
2219
                        break;
2220
                    }
2221
                    case VAR_OBJECTVALUE7: {
2222
                        scriptEng.operands[i] = objectEntityList[arrayVal].values[7];
2223
                        break;
2224
                    }
2225
                    case VAR_OBJECTOUTOFBOUNDS: {
2226
                        int32 pos = objectEntityList[arrayVal].XPos >> 16;
2227
                        if (pos <= xScrollOffset - OBJECT_BORDER_X1 || pos >= OBJECT_BORDER_X2 + xScrollOffset) {
2228
                            scriptEng.operands[i] = 1;
2229
                        }
2230
                        else {
2231
                            int32 pos             = objectEntityList[arrayVal].YPos >> 16;
2232
                            scriptEng.operands[i] = pos <= yScrollOffset - OBJECT_BORDER_Y1 || pos >= yScrollOffset + OBJECT_BORDER_Y2;
2233
                        }
2234
                        break;
2235
                    }
2236
                    case VAR_PLAYERSTATE: {
2237
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->state;
2238
                        break;
2239
                    }
2240
                    case VAR_PLAYERCONTROLMODE: {
2241
                        scriptEng.operands[i] = playerList[activePlayer].controlMode;
2242
                        break;
2243
                    }
2244
                    case VAR_PLAYERCONTROLLOCK: {
2245
                        scriptEng.operands[i] = playerList[activePlayer].controlLock;
2246
                        break;
2247
                    }
2248
                    case VAR_PLAYERCOLLISIONMODE: {
2249
                        scriptEng.operands[i] = playerList[activePlayer].collisionMode;
2250
                        break;
2251
                    }
2252
                    case VAR_PLAYERCOLLISIONPLANE: {
2253
                        scriptEng.operands[i] = playerList[activePlayer].collisionPlane;
2254
                        break;
2255
                    }
2256
                    case VAR_PLAYERXPOS: {
2257
                        scriptEng.operands[i] = playerList[activePlayer].XPos;
2258
                        break;
2259
                    }
2260
                    case VAR_PLAYERYPOS: {
2261
                        scriptEng.operands[i] = playerList[activePlayer].YPos;
2262
                        break;
2263
                    }
2264
                    case VAR_PLAYERIXPOS: {
2265
                        scriptEng.operands[i] = playerList[activePlayer].XPos >> 16;
2266
                        break;
2267
                    }
2268
                    case VAR_PLAYERIYPOS: {
2269
                        scriptEng.operands[i] = playerList[activePlayer].YPos >> 16;
2270
                        break;
2271
                    }
2272
                    case VAR_PLAYERSCREENXPOS: {
2273
                        scriptEng.operands[i] = playerList[activePlayer].screenXPos;
2274
                        break;
2275
                    }
2276
                    case VAR_PLAYERSCREENYPOS: {
2277
                        scriptEng.operands[i] = playerList[activePlayer].screenYPos;
2278
                        break;
2279
                    }
2280
                    case VAR_PLAYERSPEED: {
2281
                        scriptEng.operands[i] = playerList[activePlayer].speed;
2282
                        break;
2283
                    }
2284
                    case VAR_PLAYERXVELOCITY: {
2285
                        scriptEng.operands[i] = playerList[activePlayer].XVelocity;
2286
                        break;
2287
                    }
2288
                    case VAR_PLAYERYVELOCITY: {
2289
                        scriptEng.operands[i] = playerList[activePlayer].YVelocity;
2290
                        break;
2291
                    }
2292
                    case VAR_PLAYERGRAVITY: {
2293
                        scriptEng.operands[i] = playerList[activePlayer].gravity;
2294
                        break;
2295
                    }
2296
                    case VAR_PLAYERANGLE: {
2297
                        scriptEng.operands[i] = playerList[activePlayer].angle;
2298
                        break;
2299
                    }
2300
                    case VAR_PLAYERSKIDDING: {
2301
                        scriptEng.operands[i] = playerList[activePlayer].skidding;
2302
                        break;
2303
                    }
2304
                    case VAR_PLAYERPUSHING: {
2305
                        scriptEng.operands[i] = playerList[activePlayer].pushing;
2306
                        break;
2307
                    }
2308
                    case VAR_PLAYERTRACKSCROLL: {
2309
                        scriptEng.operands[i] = playerList[activePlayer].trackScroll;
2310
                        break;
2311
                    }
2312
                    case VAR_PLAYERUP: {
2313
                        scriptEng.operands[i] = playerList[activePlayer].up;
2314
                        break;
2315
                    }
2316
                    case VAR_PLAYERDOWN: {
2317
                        scriptEng.operands[i] = playerList[activePlayer].down;
2318
                        break;
2319
                    }
2320
                    case VAR_PLAYERLEFT: {
2321
                        scriptEng.operands[i] = playerList[activePlayer].left;
2322
                        break;
2323
                    }
2324
                    case VAR_PLAYERRIGHT: {
2325
                        scriptEng.operands[i] = playerList[activePlayer].right;
2326
                        break;
2327
                    }
2328
                    case VAR_PLAYERJUMPPRESS: {
2329
                        scriptEng.operands[i] = playerList[activePlayer].jumpPress;
2330
                        break;
2331
                    }
2332
                    case VAR_PLAYERJUMPHOLD: {
2333
                        scriptEng.operands[i] = playerList[activePlayer].jumpHold;
2334
                        break;
2335
                    }
2336
                    case VAR_PLAYERFOLLOWPLAYER1: {
2337
                        scriptEng.operands[i] = playerList[activePlayer].followPlayer1;
2338
                        break;
2339
                    }
2340
                    case VAR_PLAYERLOOKPOS: {
2341
                        scriptEng.operands[i] = playerList[activePlayer].lookPos;
2342
                        break;
2343
                    }
2344
                    case VAR_PLAYERWATER: {
2345
                        scriptEng.operands[i] = playerList[activePlayer].water;
2346
                        break;
2347
                    }
2348
                    case VAR_PLAYERTOPSPEED: {
2349
                        scriptEng.operands[i] = playerList[activePlayer].topSpeed;
2350
                        break;
2351
                    }
2352
                    case VAR_PLAYERACCELERATION: {
2353
                        scriptEng.operands[i] = playerList[activePlayer].acceleration;
2354
                        break;
2355
                    }
2356
                    case VAR_PLAYERDECELERATION: {
2357
                        scriptEng.operands[i] = playerList[activePlayer].deceleration;
2358
                        break;
2359
                    }
2360
                    case VAR_PLAYERAIRACCELERATION: {
2361
                        scriptEng.operands[i] = playerList[activePlayer].airAcceleration;
2362
                        break;
2363
                    }
2364
                    case VAR_PLAYERAIRDECELERATION: {
2365
                        scriptEng.operands[i] = playerList[activePlayer].airDeceleration;
2366
                        break;
2367
                    }
2368
                    case VAR_PLAYERGRAVITYSTRENGTH: {
2369
                        scriptEng.operands[i] = playerList[activePlayer].gravityStrength;
2370
                        break;
2371
                    }
2372
                    case VAR_PLAYERJUMPSTRENGTH: {
2373
                        scriptEng.operands[i] = playerList[activePlayer].jumpStrength;
2374
                        break;
2375
                    }
2376
                    case VAR_PLAYERJUMPCAP: {
2377
                        scriptEng.operands[i] = playerList[activePlayer].jumpCap;
2378
                        break;
2379
                    }
2380
                    case VAR_PLAYERROLLINGACCELERATION: {
2381
                        scriptEng.operands[i] = playerList[activePlayer].rollingAcceleration;
2382
                        break;
2383
                    }
2384
                    case VAR_PLAYERROLLINGDECELERATION: {
2385
                        scriptEng.operands[i] = playerList[activePlayer].rollingDeceleration;
2386
                        break;
2387
                    }
2388
                    case VAR_PLAYERENTITYNO: {
2389
                        scriptEng.operands[i] = playerList[activePlayer].entityNo;
2390
                        break;
2391
                    }
2392
                    case VAR_PLAYERCOLLISIONLEFT: {
2393
                        AnimationFile *animFile = playerList[activePlayer].animationFile;
2394
                        Player *plr             = &playerList[activePlayer];
2395
                        if (animFile) {
2396
                            int32 h = animFrames[animationList[animFile->aniListOffset + plr->boundEntity->animation].frameListOffset
2397
                                                 + plr->boundEntity->frame]
2398
                                          .hitboxID;
2399

2400
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].left[0];
2401
                        }
2402
                        else {
2403
                            scriptEng.operands[i] = 0;
2404
                        }
2405
                        break;
2406
                    }
2407
                    case VAR_PLAYERCOLLISIONTOP: {
2408
                        AnimationFile *animFile = playerList[activePlayer].animationFile;
2409
                        Player *plr             = &playerList[activePlayer];
2410
                        if (animFile) {
2411
                            int32 h = animFrames[animationList[animFile->aniListOffset + plr->boundEntity->animation].frameListOffset
2412
                                                 + plr->boundEntity->frame]
2413
                                          .hitboxID;
2414

2415
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].top[0];
2416
                        }
2417
                        else {
2418
                            scriptEng.operands[i] = 0;
2419
                        }
2420
                        break;
2421
                    }
2422
                    case VAR_PLAYERCOLLISIONRIGHT: {
2423
                        AnimationFile *animFile = playerList[activePlayer].animationFile;
2424
                        Player *plr             = &playerList[activePlayer];
2425
                        if (animFile) {
2426
                            int32 h = animFrames[animationList[animFile->aniListOffset + plr->boundEntity->animation].frameListOffset
2427
                                                 + plr->boundEntity->frame]
2428
                                          .hitboxID;
2429

2430
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].right[0];
2431
                        }
2432
                        else {
2433
                            scriptEng.operands[i] = 0;
2434
                        }
2435
                        break;
2436
                    }
2437
                    case VAR_PLAYERCOLLISIONBOTTOM: {
2438
                        AnimationFile *animFile = playerList[activePlayer].animationFile;
2439
                        Player *plr             = &playerList[activePlayer];
2440
                        if (animFile) {
2441
                            int32 h = animFrames[animationList[animFile->aniListOffset + plr->boundEntity->animation].frameListOffset
2442
                                                 + plr->boundEntity->frame]
2443
                                          .hitboxID;
2444

2445
                            scriptEng.operands[i] = hitboxList[animFile->hitboxListOffset + h].bottom[0];
2446
                        }
2447
                        else {
2448
                            scriptEng.operands[i] = 0;
2449
                        }
2450
                        break;
2451
                    }
2452
                    case VAR_PLAYERFLAILING: {
2453
                        scriptEng.operands[i] = playerList[activePlayer].flailing[arrayVal];
2454
                        break;
2455
                    }
2456
                    case VAR_PLAYERTIMER: {
2457
                        scriptEng.operands[i] = playerList[activePlayer].timer;
2458
                        break;
2459
                    }
2460
                    case VAR_PLAYERTILECOLLISIONS: {
2461
                        scriptEng.operands[i] = playerList[activePlayer].tileCollisions;
2462
                        break;
2463
                    }
2464
                    case VAR_PLAYEROBJECTINTERACTION: {
2465
                        scriptEng.operands[i] = playerList[activePlayer].objectInteractions;
2466
                        break;
2467
                    }
2468
                    case VAR_PLAYERVISIBLE: {
2469
                        scriptEng.operands[i] = playerList[activePlayer].visible;
2470
                        break;
2471
                    }
2472
                    case VAR_PLAYERROTATION: {
2473
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->rotation;
2474
                        break;
2475
                    }
2476
                    case VAR_PLAYERSCALE: {
2477
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->scale;
2478
                        break;
2479
                    }
2480
                    case VAR_PLAYERPRIORITY: {
2481
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->priority;
2482
                        break;
2483
                    }
2484
                    case VAR_PLAYERDRAWORDER: {
2485
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->drawOrder;
2486
                        break;
2487
                    }
2488
                    case VAR_PLAYERDIRECTION: {
2489
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->direction;
2490
                        break;
2491
                    }
2492
                    case VAR_PLAYERINKEFFECT: {
2493
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->inkEffect;
2494
                        break;
2495
                    }
2496
                    case VAR_PLAYERALPHA: {
2497
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->alpha;
2498
                        break;
2499
                    }
2500
                    case VAR_PLAYERFRAME: {
2501
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->frame;
2502
                        break;
2503
                    }
2504
                    case VAR_PLAYERANIMATION: {
2505
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->animation;
2506
                        break;
2507
                    }
2508
                    case VAR_PLAYERPREVANIMATION: {
2509
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->prevAnimation;
2510
                        break;
2511
                    }
2512
                    case VAR_PLAYERANIMATIONSPEED: {
2513
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->animationSpeed;
2514
                        break;
2515
                    }
2516
                    case VAR_PLAYERANIMATIONTIMER: {
2517
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->animationTimer;
2518
                        break;
2519
                    }
2520
                    case VAR_PLAYERVALUE0: {
2521
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[0];
2522
                        break;
2523
                    }
2524
                    case VAR_PLAYERVALUE1: {
2525
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[1];
2526
                        break;
2527
                    }
2528
                    case VAR_PLAYERVALUE2: {
2529
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[2];
2530
                        break;
2531
                    }
2532
                    case VAR_PLAYERVALUE3: {
2533
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[3];
2534
                        break;
2535
                    }
2536
                    case VAR_PLAYERVALUE4: {
2537
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[4];
2538
                        break;
2539
                    }
2540
                    case VAR_PLAYERVALUE5: {
2541
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[5];
2542
                        break;
2543
                    }
2544
                    case VAR_PLAYERVALUE6: {
2545
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[6];
2546
                        break;
2547
                    }
2548
                    case VAR_PLAYERVALUE7: {
2549
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[7];
2550
                        break;
2551
                    }
2552
                    case VAR_PLAYERVALUE8: {
2553
                        scriptEng.operands[i] = playerList[activePlayer].values[0];
2554
                        break;
2555
                    }
2556
                    case VAR_PLAYERVALUE9: {
2557
                        scriptEng.operands[i] = playerList[activePlayer].values[1];
2558
                        break;
2559
                    }
2560
                    case VAR_PLAYERVALUE10: {
2561
                        scriptEng.operands[i] = playerList[activePlayer].values[2];
2562
                        break;
2563
                    }
2564
                    case VAR_PLAYERVALUE11: {
2565
                        scriptEng.operands[i] = playerList[activePlayer].values[3];
2566
                        break;
2567
                    }
2568
                    case VAR_PLAYERVALUE12: {
2569
                        scriptEng.operands[i] = playerList[activePlayer].values[4];
2570
                        break;
2571
                    }
2572
                    case VAR_PLAYERVALUE13: {
2573
                        scriptEng.operands[i] = playerList[activePlayer].values[5];
2574
                        break;
2575
                    }
2576
                    case VAR_PLAYERVALUE14: {
2577
                        scriptEng.operands[i] = playerList[activePlayer].values[6];
2578
                        break;
2579
                    }
2580
                    case VAR_PLAYERVALUE15: {
2581
                        scriptEng.operands[i] = playerList[activePlayer].values[7];
2582
                        break;
2583
                    }
2584
                    case VAR_PLAYEROUTOFBOUNDS: {
2585
                        int32 pos = playerList[activePlayer].XPos >> 16;
2586
                        if (pos <= xScrollOffset - OBJECT_BORDER_X1 || pos >= OBJECT_BORDER_X2 + xScrollOffset) {
2587
                            scriptEng.operands[i] = 1;
2588
                        }
2589
                        else {
2590
                            int32 pos             = playerList[activePlayer].YPos >> 16;
2591
                            scriptEng.operands[i] = pos <= yScrollOffset - OBJECT_BORDER_Y1 || pos >= yScrollOffset + OBJECT_BORDER_Y2;
2592
                        }
2593
                        break;
2594
                    }
2595
                    case VAR_STAGESTATE: scriptEng.operands[i] = stageMode; break;
2596
                    case VAR_STAGEACTIVELIST: scriptEng.operands[i] = sceneInfo.activeCategory; break;
2597
                    case VAR_STAGELISTPOS:
2598
                        scriptEng.operands[i] = sceneInfo.listPos - sceneInfo.listCategory[sceneInfo.activeCategory].sceneOffsetStart;
2599
                        break;
2600
                    case VAR_STAGETIMEENABLED: scriptEng.operands[i] = timeEnabled; break;
2601
                    case VAR_STAGEMILLISECONDS: scriptEng.operands[i] = stageMilliseconds; break;
2602
                    case VAR_STAGESECONDS: scriptEng.operands[i] = stageSeconds; break;
2603
                    case VAR_STAGEMINUTES: scriptEng.operands[i] = stageMinutes; break;
2604
                    case VAR_STAGEACTNO: scriptEng.operands[i] = actID; break;
2605
                    case VAR_STAGEPAUSEENABLED: scriptEng.operands[i] = pauseEnabled; break;
2606
                    case VAR_STAGELISTSIZE: scriptEng.operands[i] = sceneInfo.listCategory[RSDK::sceneInfo.activeCategory].sceneCount; break;
2607
                    case VAR_STAGENEWXBOUNDARY1: scriptEng.operands[i] = newXBoundary1; break;
2608
                    case VAR_STAGENEWXBOUNDARY2: scriptEng.operands[i] = newXBoundary2; break;
2609
                    case VAR_STAGENEWYBOUNDARY1: scriptEng.operands[i] = newYBoundary1; break;
2610
                    case VAR_STAGENEWYBOUNDARY2: scriptEng.operands[i] = newYBoundary2; break;
2611
                    case VAR_STAGEXBOUNDARY1: scriptEng.operands[i] = curXBoundary1; break;
2612
                    case VAR_STAGEXBOUNDARY2: scriptEng.operands[i] = curXBoundary2; break;
2613
                    case VAR_STAGEYBOUNDARY1: scriptEng.operands[i] = curYBoundary1; break;
2614
                    case VAR_STAGEYBOUNDARY2: scriptEng.operands[i] = curYBoundary2; break;
2615
                    case VAR_STAGEDEFORMATIONDATA0: scriptEng.operands[i] = bgDeformationData0[arrayVal]; break;
2616
                    case VAR_STAGEDEFORMATIONDATA1: scriptEng.operands[i] = bgDeformationData1[arrayVal]; break;
2617
                    case VAR_STAGEDEFORMATIONDATA2: scriptEng.operands[i] = bgDeformationData2[arrayVal]; break;
2618
                    case VAR_STAGEDEFORMATIONDATA3: scriptEng.operands[i] = bgDeformationData3[arrayVal]; break;
2619
                    case VAR_STAGEWATERLEVEL: scriptEng.operands[i] = waterLevel; break;
2620
                    case VAR_STAGEACTIVELAYER: scriptEng.operands[i] = activeTileLayers[arrayVal]; break;
2621
                    case VAR_STAGEMIDPOINT: scriptEng.operands[i] = tLayerMidPoint; break;
2622
                    case VAR_STAGEPLAYERLISTPOS: scriptEng.operands[i] = playerListPos; break;
2623
                    case VAR_STAGEACTIVEPLAYER: scriptEng.operands[i] = activePlayer; break;
2624
                    case VAR_SCREENCAMERAENABLED: scriptEng.operands[i] = currentCamera->enabled; break;
2625
                    case VAR_SCREENCAMERATARGET: scriptEng.operands[i] = currentCamera->target; break;
2626
                    case VAR_SCREENCAMERASTYLE: scriptEng.operands[i] = currentCamera->style; break;
2627
                    case VAR_SCREENDRAWLISTSIZE: scriptEng.operands[i] = drawListEntries[arrayVal].listSize; break;
2628
                    case VAR_SCREENCENTERX: scriptEng.operands[i] = SCREEN_CENTERX; break;
2629
                    case VAR_SCREENCENTERY: scriptEng.operands[i] = SCREEN_CENTERY; break;
2630
                    case VAR_SCREENXSIZE: scriptEng.operands[i] = SCREEN_XSIZE; break;
2631
                    case VAR_SCREENYSIZE: scriptEng.operands[i] = SCREEN_YSIZE; break;
2632
                    case VAR_SCREENXOFFSET: scriptEng.operands[i] = xScrollOffset; break;
2633
                    case VAR_SCREENYOFFSET: scriptEng.operands[i] = yScrollOffset; break;
2634
                    case VAR_SCREENSHAKEX: scriptEng.operands[i] = cameraShakeX; break;
2635
                    case VAR_SCREENSHAKEY: scriptEng.operands[i] = cameraShakeY; break;
2636
                    case VAR_SCREENADJUSTCAMERAY: scriptEng.operands[i] = currentCamera->adjustY; break;
2637
                    case VAR_TOUCHSCREENDOWN: scriptEng.operands[i] = touchInfo.down[arrayVal]; break;
2638
                    case VAR_TOUCHSCREENXPOS: scriptEng.operands[i] = (int32)(touchInfo.x[arrayVal] * SCREEN_XSIZE); break;
2639
                    case VAR_TOUCHSCREENYPOS: scriptEng.operands[i] = (int32)(touchInfo.y[arrayVal] * SCREEN_YSIZE); break;
2640
                    case VAR_MUSICVOLUME: scriptEng.operands[i] = musicVolume; break;
2641
                    case VAR_MUSICCURRENTTRACK: scriptEng.operands[i] = musicCurrentTrack; break;
2642
                    case VAR_KEYDOWNUP: scriptEng.operands[i] = controller[arrayVal].keyUp.down; break;
2643
                    case VAR_KEYDOWNDOWN: scriptEng.operands[i] = controller[arrayVal].keyDown.down; break;
2644
                    case VAR_KEYDOWNLEFT: scriptEng.operands[i] = controller[arrayVal].keyLeft.down; break;
2645
                    case VAR_KEYDOWNRIGHT: scriptEng.operands[i] = controller[arrayVal].keyRight.down; break;
2646
                    case VAR_KEYDOWNBUTTONA: scriptEng.operands[i] = controller[arrayVal].keyA.down; break;
2647
                    case VAR_KEYDOWNBUTTONB: scriptEng.operands[i] = controller[arrayVal].keyB.down; break;
2648
                    case VAR_KEYDOWNBUTTONC: scriptEng.operands[i] = controller[arrayVal].keyC.down; break;
2649
                    case VAR_KEYDOWNSTART: scriptEng.operands[i] = controller[arrayVal].keyStart.down; break;
2650
                    case VAR_KEYPRESSUP: scriptEng.operands[i] = controller[arrayVal].keyUp.press; break;
2651
                    case VAR_KEYPRESSDOWN: scriptEng.operands[i] = controller[arrayVal].keyDown.press; break;
2652
                    case VAR_KEYPRESSLEFT: scriptEng.operands[i] = controller[arrayVal].keyLeft.press; break;
2653
                    case VAR_KEYPRESSRIGHT: scriptEng.operands[i] = controller[arrayVal].keyRight.press; break;
2654
                    case VAR_KEYPRESSBUTTONA: scriptEng.operands[i] = controller[arrayVal].keyA.press; break;
2655
                    case VAR_KEYPRESSBUTTONB: scriptEng.operands[i] = controller[arrayVal].keyB.press; break;
2656
                    case VAR_KEYPRESSBUTTONC: scriptEng.operands[i] = controller[arrayVal].keyC.press; break;
2657
                    case VAR_KEYPRESSSTART: scriptEng.operands[i] = controller[arrayVal].keyStart.press; break;
2658
                    case VAR_MENU1SELECTION: scriptEng.operands[i] = gameMenu[0].selection1; break;
2659
                    case VAR_MENU2SELECTION: scriptEng.operands[i] = gameMenu[1].selection1; break;
2660
                    case VAR_TILELAYERXSIZE: scriptEng.operands[i] = stageLayouts[arrayVal].xsize; break;
2661
                    case VAR_TILELAYERYSIZE: scriptEng.operands[i] = stageLayouts[arrayVal].ysize; break;
2662
                    case VAR_TILELAYERTYPE: scriptEng.operands[i] = stageLayouts[arrayVal].type; break;
2663
                    case VAR_TILELAYERANGLE: scriptEng.operands[i] = stageLayouts[arrayVal].angle; break;
2664
                    case VAR_TILELAYERXPOS: scriptEng.operands[i] = stageLayouts[arrayVal].xpos; break;
2665
                    case VAR_TILELAYERYPOS: scriptEng.operands[i] = stageLayouts[arrayVal].ypos; break;
2666
                    case VAR_TILELAYERZPOS: scriptEng.operands[i] = stageLayouts[arrayVal].zpos; break;
2667
                    case VAR_TILELAYERPARALLAXFACTOR: scriptEng.operands[i] = stageLayouts[arrayVal].parallaxFactor; break;
2668
                    case VAR_TILELAYERSCROLLSPEED: scriptEng.operands[i] = stageLayouts[arrayVal].scrollSpeed; break;
2669
                    case VAR_TILELAYERSCROLLPOS: scriptEng.operands[i] = stageLayouts[arrayVal].scrollPos; break;
2670
                    case VAR_TILELAYERDEFORMATIONOFFSET: scriptEng.operands[i] = stageLayouts[arrayVal].deformationOffset; break;
2671
                    case VAR_TILELAYERDEFORMATIONOFFSETW: scriptEng.operands[i] = stageLayouts[arrayVal].deformationOffsetW; break;
2672
                    case VAR_HPARALLAXPARALLAXFACTOR: scriptEng.operands[i] = hParallax.parallaxFactor[arrayVal]; break;
2673
                    case VAR_HPARALLAXSCROLLSPEED: scriptEng.operands[i] = hParallax.scrollSpeed[arrayVal]; break;
2674
                    case VAR_HPARALLAXSCROLLPOS: scriptEng.operands[i] = hParallax.scrollPos[arrayVal]; break;
2675
                    case VAR_VPARALLAXPARALLAXFACTOR: scriptEng.operands[i] = vParallax.parallaxFactor[arrayVal]; break;
2676
                    case VAR_VPARALLAXSCROLLSPEED: scriptEng.operands[i] = vParallax.scrollSpeed[arrayVal]; break;
2677
                    case VAR_VPARALLAXSCROLLPOS: scriptEng.operands[i] = vParallax.scrollPos[arrayVal]; break;
2678
                    case VAR_3DSCENENOVERTICES: scriptEng.operands[i] = vertexCount; break;
2679
                    case VAR_3DSCENENOFACES: scriptEng.operands[i] = faceCount; break;
2680
                    case VAR_VERTEXBUFFERX: scriptEng.operands[i] = vertexBuffer[arrayVal].x; break;
2681
                    case VAR_VERTEXBUFFERY: scriptEng.operands[i] = vertexBuffer[arrayVal].y; break;
2682
                    case VAR_VERTEXBUFFERZ: scriptEng.operands[i] = vertexBuffer[arrayVal].z; break;
2683
                    case VAR_VERTEXBUFFERU: scriptEng.operands[i] = vertexBuffer[arrayVal].u; break;
2684
                    case VAR_VERTEXBUFFERV: scriptEng.operands[i] = vertexBuffer[arrayVal].v; break;
2685
                    case VAR_FACEBUFFERA: scriptEng.operands[i] = faceBuffer[arrayVal].a; break;
2686
                    case VAR_FACEBUFFERB: scriptEng.operands[i] = faceBuffer[arrayVal].b; break;
2687
                    case VAR_FACEBUFFERC: scriptEng.operands[i] = faceBuffer[arrayVal].c; break;
2688
                    case VAR_FACEBUFFERD: scriptEng.operands[i] = faceBuffer[arrayVal].d; break;
2689
                    case VAR_FACEBUFFERFLAG: scriptEng.operands[i] = faceBuffer[arrayVal].flag; break;
2690
                    case VAR_FACEBUFFERCOLOR: scriptEng.operands[i] = faceBuffer[arrayVal].color; break;
2691
                    case VAR_3DSCENEPROJECTIONX: scriptEng.operands[i] = projectionX; break;
2692
                    case VAR_3DSCENEPROJECTIONY: scriptEng.operands[i] = projectionY; break;
2693
                    case VAR_ENGINESTATE: scriptEng.operands[i] = gameMode; break;
2694
                    case VAR_STAGEDEBUGMODE: scriptEng.operands[i] = debugMode; break;
2695
                    case VAR_ENGINEMESSAGE: scriptEng.operands[i] = engineMessage; break;
2696
                    case VAR_SAVERAM: scriptEng.operands[i] = saveRAM[arrayVal]; break;
2697
                    case VAR_ENGINELANGUAGE: scriptEng.operands[i] = language; break;
2698
                    case VAR_OBJECTSPRITESHEET: {
2699
                        scriptEng.operands[i] = objectScriptList[objectEntityList[arrayVal].type].spriteSheetID;
2700
                        break;
2701
                    }
2702
                    case VAR_ENGINEONLINEACTIVE: scriptEng.operands[i] = onlineActive; break;
2703
                    case VAR_ENGINEFRAMESKIPTIMER: break;
2704
                    case VAR_ENGINEFRAMESKIPSETTING: break;
2705
                    case VAR_ENGINESFXVOLUME: scriptEng.operands[i] = sfxVolume; break;
2706
                    case VAR_ENGINEBGMVOLUME: scriptEng.operands[i] = bgmVolume; break;
2707
                    case VAR_ENGINEPLATFORMID: scriptEng.operands[i] = gamePlatformID; break;
2708
                    case VAR_ENGINETRIALMODE: scriptEng.operands[i] = trialMode; break;
2709
                    case VAR_KEYPRESSANYSTART: scriptEng.operands[i] = anyPress; break;
2710
#if LEGACY_RETRO_USE_HAPTICS
2711
                    case VAR_ENGINEHAPTICSENABLED: scriptEng.operands[i] = hapticsEnabled; break;
2712
#endif
2713
                }
2714
            }
2715
            else if (opcodeType == SCRIPTVAR_INTCONST) { // int32 constant
2716
                scriptEng.operands[i] = scriptCode[scriptCodePtr++];
2717
            }
2718
            else if (opcodeType == SCRIPTVAR_STRCONST) { // string constant
2719
                int32 strLen       = scriptCode[scriptCodePtr++];
2720
                scriptText[strLen] = 0;
2721
                for (int32 c = 0; c < strLen; ++c) {
2722
                    switch (c % 4) {
2723
                        case 0: {
2724
                            scriptText[c] = scriptCode[scriptCodePtr] >> 24;
2725
                            break;
2726
                        }
2727
                        case 1: {
2728
                            scriptText[c] = (0xFFFFFF & scriptCode[scriptCodePtr]) >> 16;
2729
                            break;
2730
                        }
2731
                        case 2: {
2732
                            scriptText[c] = (0xFFFF & scriptCode[scriptCodePtr]) >> 8;
2733
                            break;
2734
                        }
2735
                        case 3: {
2736
                            scriptText[c] = scriptCode[scriptCodePtr++];
2737
                            break;
2738
                        }
2739
                        default: break;
2740
                    }
2741
                }
2742
                scriptCodePtr++;
2743
            }
2744
        }
2745

2746
        ObjectScript *scriptInfo = &objectScriptList[objectEntityList[objectLoop].type];
2747
        Entity *entity           = &objectEntityList[objectLoop];
2748
        Player *player           = &playerList[activePlayer];
2749
        SpriteFrame *spriteFrame = nullptr;
2750

2751
        // Functions
2752
        switch (opcode) {
2753
            default: break;
2754
            case FUNC_END: running = false; break;
2755
            case FUNC_EQUAL: scriptEng.operands[0] = scriptEng.operands[1]; break;
2756
            case FUNC_ADD: scriptEng.operands[0] += scriptEng.operands[1]; break;
2757
            case FUNC_SUB: scriptEng.operands[0] -= scriptEng.operands[1]; break;
2758
            case FUNC_INC: ++scriptEng.operands[0]; break;
2759
            case FUNC_DEC: --scriptEng.operands[0]; break;
2760
            case FUNC_MUL: scriptEng.operands[0] *= scriptEng.operands[1]; break;
2761
            case FUNC_DIV: scriptEng.operands[0] /= scriptEng.operands[1]; break;
2762
            case FUNC_SHR: scriptEng.operands[0] >>= scriptEng.operands[1]; break;
2763
            case FUNC_SHL: scriptEng.operands[0] <<= scriptEng.operands[1]; break;
2764
            case FUNC_AND: scriptEng.operands[0] &= scriptEng.operands[1]; break;
2765
            case FUNC_OR: scriptEng.operands[0] |= scriptEng.operands[1]; break;
2766
            case FUNC_XOR: scriptEng.operands[0] ^= scriptEng.operands[1]; break;
2767
            case FUNC_MOD: scriptEng.operands[0] %= scriptEng.operands[1]; break;
2768
            case FUNC_FLIPSIGN: scriptEng.operands[0] = -scriptEng.operands[0]; break;
2769
            case FUNC_CHECKEQUAL:
2770
                scriptEng.checkResult = scriptEng.operands[0] == scriptEng.operands[1];
2771
                opcodeSize            = 0;
2772
                break;
2773
            case FUNC_CHECKGREATER:
2774
                scriptEng.checkResult = scriptEng.operands[0] > scriptEng.operands[1];
2775
                opcodeSize            = 0;
2776
                break;
2777
            case FUNC_CHECKLOWER:
2778
                scriptEng.checkResult = scriptEng.operands[0] < scriptEng.operands[1];
2779
                opcodeSize            = 0;
2780
                break;
2781
            case FUNC_CHECKNOTEQUAL:
2782
                scriptEng.checkResult = scriptEng.operands[0] != scriptEng.operands[1];
2783
                opcodeSize            = 0;
2784
                break;
2785
            case FUNC_IFEQUAL:
2786
                if (scriptEng.operands[1] != scriptEng.operands[2])
2787
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
2788
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2789
                opcodeSize                          = 0;
2790
                break;
2791
            case FUNC_IFGREATER:
2792
                if (scriptEng.operands[1] <= scriptEng.operands[2])
2793
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
2794
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2795
                opcodeSize                          = 0;
2796
                break;
2797
            case FUNC_IFGREATEROREQUAL:
2798
                if (scriptEng.operands[1] < scriptEng.operands[2])
2799
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
2800
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2801
                opcodeSize                          = 0;
2802
                break;
2803
            case FUNC_IFLOWER:
2804
                if (scriptEng.operands[1] >= scriptEng.operands[2])
2805
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
2806
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2807
                opcodeSize                          = 0;
2808
                break;
2809
            case FUNC_IFLOWEROREQUAL:
2810
                if (scriptEng.operands[1] > scriptEng.operands[2])
2811
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
2812
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2813
                opcodeSize                          = 0;
2814
                break;
2815
            case FUNC_IFNOTEQUAL:
2816
                if (scriptEng.operands[1] == scriptEng.operands[2])
2817
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0]];
2818
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2819
                opcodeSize                          = 0;
2820
                break;
2821
            case FUNC_ELSE:
2822
                opcodeSize    = 0;
2823
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--] + 1];
2824
                break;
2825
            case FUNC_ENDIF:
2826
                opcodeSize = 0;
2827
                --jumpTableStackPos;
2828
                break;
2829
            case FUNC_WEQUAL:
2830
                if (scriptEng.operands[1] != scriptEng.operands[2])
2831
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
2832
                else
2833
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2834
                opcodeSize = 0;
2835
                break;
2836
            case FUNC_WGREATER:
2837
                if (scriptEng.operands[1] <= scriptEng.operands[2])
2838
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
2839
                else
2840
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2841
                opcodeSize = 0;
2842
                break;
2843
            case FUNC_WGREATEROREQUAL:
2844
                if (scriptEng.operands[1] < scriptEng.operands[2])
2845
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
2846
                else
2847
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2848
                opcodeSize = 0;
2849
                break;
2850
            case FUNC_WLOWER:
2851
                if (scriptEng.operands[1] >= scriptEng.operands[2])
2852
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
2853
                else
2854
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2855
                opcodeSize = 0;
2856
                break;
2857
            case FUNC_WLOWEROREQUAL:
2858
                if (scriptEng.operands[1] > scriptEng.operands[2])
2859
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
2860
                else
2861
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2862
                opcodeSize = 0;
2863
                break;
2864
            case FUNC_WNOTEQUAL:
2865
                if (scriptEng.operands[1] == scriptEng.operands[2])
2866
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 1];
2867
                else
2868
                    jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2869
                opcodeSize = 0;
2870
                break;
2871
            case FUNC_LOOP:
2872
                opcodeSize    = 0;
2873
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--]];
2874
                break;
2875
            case FUNC_SWITCH:
2876
                jumpTableStack[++jumpTableStackPos] = scriptEng.operands[0];
2877
                if (scriptEng.operands[1] < jumpTable[jumpTableStart + scriptEng.operands[0]]
2878
                    || scriptEng.operands[1] > jumpTable[jumpTableStart + scriptEng.operands[0] + 1])
2879
                    scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + scriptEng.operands[0] + 2];
2880
                else
2881
                    scriptCodePtr = scriptCodeStart
2882
                                    + jumpTable[jumpTableStart + scriptEng.operands[0] + 4
2883
                                                + (scriptEng.operands[1] - jumpTable[jumpTableStart + scriptEng.operands[0]])];
2884
                opcodeSize = 0;
2885
                break;
2886
            case FUNC_BREAK:
2887
                opcodeSize    = 0;
2888
                scriptCodePtr = scriptCodeStart + jumpTable[jumpTableStart + jumpTableStack[jumpTableStackPos--] + 3];
2889
                break;
2890
            case FUNC_ENDSWITCH:
2891
                opcodeSize = 0;
2892
                --jumpTableStackPos;
2893
                break;
2894
            case FUNC_RAND: scriptEng.operands[0] = rand() % scriptEng.operands[1]; break;
2895
            case FUNC_SIN: {
2896
                scriptEng.operands[0] = Sin512(scriptEng.operands[1]);
2897
                break;
2898
            }
2899
            case FUNC_COS: {
2900
                scriptEng.operands[0] = Cos512(scriptEng.operands[1]);
2901
                break;
2902
            }
2903
            case FUNC_SIN256: {
2904
                scriptEng.operands[0] = Sin256(scriptEng.operands[1]);
2905
                break;
2906
            }
2907
            case FUNC_COS256: {
2908
                scriptEng.operands[0] = Cos256(scriptEng.operands[1]);
2909
                break;
2910
            }
2911
            case FUNC_SINCHANGE: {
2912
                scriptEng.operands[0] = scriptEng.operands[3] + (Sin512(scriptEng.operands[1]) >> scriptEng.operands[2]) - scriptEng.operands[4];
2913
                break;
2914
            }
2915
            case FUNC_COSCHANGE: {
2916
                scriptEng.operands[0] = scriptEng.operands[3] + (Cos512(scriptEng.operands[1]) >> scriptEng.operands[2]) - scriptEng.operands[4];
2917
                break;
2918
            }
2919
            case FUNC_ATAN2: {
2920
                scriptEng.operands[0] = ArcTanLookup(scriptEng.operands[1], scriptEng.operands[2]);
2921
                break;
2922
            }
2923
            case FUNC_INTERPOLATE:
2924
                scriptEng.operands[0] =
2925
                    (scriptEng.operands[2] * (0x100 - scriptEng.operands[3]) + scriptEng.operands[3] * scriptEng.operands[1]) >> 8;
2926
                break;
2927
            case FUNC_INTERPOLATEXY:
2928
                scriptEng.operands[0] =
2929
                    (scriptEng.operands[3] * (0x100 - scriptEng.operands[6]) >> 8) + ((scriptEng.operands[6] * scriptEng.operands[2]) >> 8);
2930
                scriptEng.operands[1] =
2931
                    (scriptEng.operands[5] * (0x100 - scriptEng.operands[6]) >> 8) + (scriptEng.operands[6] * scriptEng.operands[4] >> 8);
2932
                break;
2933
            case FUNC_LOADSPRITESHEET:
2934
                opcodeSize                = 0;
2935
                scriptInfo->spriteSheetID = AddGraphicsFile(scriptText);
2936
                break;
2937
            case FUNC_REMOVESPRITESHEET:
2938
                opcodeSize = 0;
2939
                RemoveGraphicsFile(scriptText, -1);
2940
                break;
2941
            case FUNC_DRAWSPRITE:
2942
                opcodeSize  = 0;
2943
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
2944
                DrawSprite((entity->XPos >> 16) - xScrollOffset + spriteFrame->pivotX, (entity->YPos >> 16) - yScrollOffset + spriteFrame->pivotY,
2945
                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
2946
                break;
2947
            case FUNC_DRAWSPRITEXY:
2948
                opcodeSize  = 0;
2949
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
2950
                DrawSprite((scriptEng.operands[1] >> 16) - xScrollOffset + spriteFrame->pivotX,
2951
                           (scriptEng.operands[2] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width, spriteFrame->height,
2952
                           spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
2953
                break;
2954
            case FUNC_DRAWSPRITESCREENXY:
2955
                opcodeSize  = 0;
2956
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
2957
                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY, spriteFrame->width,
2958
                           spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
2959
                break;
2960
            case FUNC_DRAWTINTRECT:
2961
                opcodeSize = 0;
2962
                DrawTintRectangle(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
2963
                break;
2964
            case FUNC_DRAWNUMBERS: {
2965
                opcodeSize = 0;
2966
                int32 i    = 10;
2967
                if (scriptEng.operands[6]) {
2968
                    while (scriptEng.operands[4] > 0) {
2969
                        int32 frameID = scriptEng.operands[3] % i / (i / 10) + scriptEng.operands[0];
2970
                        spriteFrame   = &scriptFrames[scriptInfo->frameListOffset + frameID];
2971
                        DrawSprite(spriteFrame->pivotX + scriptEng.operands[1], spriteFrame->pivotY + scriptEng.operands[2], spriteFrame->width,
2972
                                   spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
2973
                        scriptEng.operands[1] -= scriptEng.operands[5];
2974
                        i *= 10;
2975
                        --scriptEng.operands[4];
2976
                    }
2977
                }
2978
                else {
2979
                    int32 extra = 10;
2980
                    if (scriptEng.operands[3])
2981
                        extra = 10 * scriptEng.operands[3];
2982
                    while (scriptEng.operands[4] > 0) {
2983
                        if (extra >= i) {
2984
                            int32 frameID = scriptEng.operands[3] % i / (i / 10) + scriptEng.operands[0];
2985
                            spriteFrame   = &scriptFrames[scriptInfo->frameListOffset + frameID];
2986
                            DrawSprite(spriteFrame->pivotX + scriptEng.operands[1], spriteFrame->pivotY + scriptEng.operands[2], spriteFrame->width,
2987
                                       spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
2988
                        }
2989
                        scriptEng.operands[1] -= scriptEng.operands[5];
2990
                        i *= 10;
2991
                        --scriptEng.operands[4];
2992
                    }
2993
                }
2994
                break;
2995
            }
2996
            case FUNC_DRAWACTNAME: {
2997
                opcodeSize   = 0;
2998
                int32 charID = 0;
2999

3000
                switch (scriptEng.operands[3]) {
3001
                    default: break;
3002

3003
                    case 1: // Draw Word 1
3004
                        charID = 0;
3005

3006
                        // Draw the first letter as a capital letter, the rest are lowercase (if scriptEng.operands[4] is true, otherwise they're all
3007
                        // uppercase)
3008
                        if (scriptEng.operands[4] == 1 && titleCardText[charID] != 0) {
3009
                            int32 character = titleCardText[charID];
3010
                            if (character == ' ')
3011
                                character = 0;
3012
                            if (character == '-')
3013
                                character = 0;
3014
                            if (character >= '0' && character <= '9')
3015
                                character -= 22;
3016
                            if (character > '9' && character < 'f')
3017
                                character -= 'A';
3018

3019
                            if (character <= -1) {
3020
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
3021
                            }
3022
                            else {
3023
                                character += scriptEng.operands[0];
3024
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
3025
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
3026
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3027
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
3028
                            }
3029

3030
                            scriptEng.operands[0] += 26;
3031
                            charID++;
3032
                        }
3033

3034
                        while (titleCardText[charID] != 0 && titleCardText[charID] != '-') {
3035
                            int32 character = titleCardText[charID];
3036
                            if (character == ' ')
3037
                                character = 0;
3038
                            if (character == '-')
3039
                                character = 0;
3040
                            if (character > '/' && character < ':')
3041
                                character -= 22;
3042
                            if (character > '9' && character < 'f')
3043
                                character -= 'A';
3044

3045
                            if (character <= -1) {
3046
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
3047
                            }
3048
                            else {
3049
                                character += scriptEng.operands[0];
3050
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
3051
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
3052
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3053
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
3054
                            }
3055
                            charID++;
3056
                        }
3057
                        break;
3058

3059
                    case 2: // Draw Word 2
3060
                        charID = titleCardWord2;
3061

3062
                        // Draw the first letter as a capital letter, the rest are lowercase (if scriptEng.operands[4] is true, otherwise they're all
3063
                        // uppercase)
3064
                        if (scriptEng.operands[4] == 1 && titleCardText[charID] != 0) {
3065
                            int32 character = titleCardText[charID];
3066
                            if (character == ' ')
3067
                                character = 0;
3068
                            if (character == '-')
3069
                                character = 0;
3070
                            if (character >= '0' && character <= '9')
3071
                                character -= 22;
3072
                            if (character > '9' && character < 'f')
3073
                                character -= 'A';
3074

3075
                            if (character <= -1) {
3076
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
3077
                            }
3078
                            else {
3079
                                character += scriptEng.operands[0];
3080
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
3081
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
3082
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3083
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
3084
                            }
3085
                            scriptEng.operands[0] += 26;
3086
                            charID++;
3087
                        }
3088

3089
                        while (titleCardText[charID] != 0) {
3090
                            int32 character = titleCardText[charID];
3091
                            if (character == ' ')
3092
                                character = -1;
3093
                            if (character == '-')
3094
                                character = 0;
3095
                            if (character >= '0' && character <= '9')
3096
                                character -= 22;
3097
                            if (character > '9' && character < 'f')
3098
                                character -= 'A';
3099

3100
                            if (character <= -1) {
3101
                                scriptEng.operands[1] += scriptEng.operands[5] + scriptEng.operands[6]; // spaceWidth + spacing
3102
                            }
3103
                            else {
3104
                                character += scriptEng.operands[0];
3105
                                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + character];
3106
                                DrawSprite(scriptEng.operands[1] + spriteFrame->pivotX, scriptEng.operands[2] + spriteFrame->pivotY,
3107
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3108
                                scriptEng.operands[1] += spriteFrame->width + scriptEng.operands[6];
3109
                            }
3110
                            charID++;
3111
                        }
3112
                        break;
3113
                }
3114
                break;
3115
            }
3116
            case FUNC_DRAWMENU:
3117
                opcodeSize        = 0;
3118
                textMenuSurfaceNo = scriptInfo->spriteSheetID;
3119
                DrawTextMenu(&gameMenu[scriptEng.operands[0]], scriptEng.operands[1], scriptEng.operands[2]);
3120
                break;
3121
            case FUNC_SPRITEFRAME:
3122
                opcodeSize = 0;
3123
                if (scriptSub == SUB_SETUP && scriptFrameCount < LEGACY_SPRITEFRAME_COUNT) {
3124
                    scriptFrames[scriptFrameCount].pivotX = scriptEng.operands[0];
3125
                    scriptFrames[scriptFrameCount].pivotY = scriptEng.operands[1];
3126
                    scriptFrames[scriptFrameCount].width  = scriptEng.operands[2];
3127
                    scriptFrames[scriptFrameCount].height = scriptEng.operands[3];
3128
                    scriptFrames[scriptFrameCount].sprX   = scriptEng.operands[4];
3129
                    scriptFrames[scriptFrameCount].sprY   = scriptEng.operands[5];
3130
                    ++scriptFrameCount;
3131
                }
3132
                break;
3133
            case FUNC_EDITFRAME: {
3134
                opcodeSize  = 0;
3135
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
3136

3137
                spriteFrame->pivotX = scriptEng.operands[1];
3138
                spriteFrame->pivotY = scriptEng.operands[2];
3139
                spriteFrame->width  = scriptEng.operands[3];
3140
                spriteFrame->height = scriptEng.operands[4];
3141
                spriteFrame->sprX   = scriptEng.operands[5];
3142
                spriteFrame->sprY   = scriptEng.operands[6];
3143
                break;
3144
            }
3145
            case FUNC_LOADPALETTE:
3146
                opcodeSize = 0;
3147
                LoadPalette(scriptText, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4]);
3148
                break;
3149
            case FUNC_ROTATEPALETTE:
3150
                opcodeSize = 0;
3151
                RotatePalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]);
3152
                break;
3153
            case FUNC_SETSCREENFADE:
3154
                opcodeSize = 0;
3155
                SetFade(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]);
3156
                break;
3157
            case FUNC_SETACTIVEPALETTE:
3158
                opcodeSize = 0;
3159
                SetActivePalette(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2]);
3160
                break;
3161
            case FUNC_SETPALETTEFADE:
3162
                opcodeSize = 0;
3163
                SetLimitedFade(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
3164
                               scriptEng.operands[5], scriptEng.operands[6]);
3165
                break;
3166
            case FUNC_COPYPALETTE:
3167
                opcodeSize = 0;
3168
                CopyPalette(scriptEng.operands[0], scriptEng.operands[1]);
3169
                break;
3170
            case FUNC_CLEARSCREEN:
3171
                opcodeSize = 0;
3172
                ClearScreen(scriptEng.operands[0]);
3173
                break;
3174
            case FUNC_DRAWSPRITEFX:
3175
                opcodeSize  = 0;
3176
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
3177
                switch (scriptEng.operands[1]) {
3178
                    default: break;
3179
                    case FX_SCALE:
3180
                        DrawSpriteScaled(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
3181
                                         (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY, entity->scale,
3182
                                         entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
3183
                                         scriptInfo->spriteSheetID);
3184
                        break;
3185
                    case FX_ROTATE:
3186
                        DrawSpriteRotated(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
3187
                                          (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
3188
                                          spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
3189
                                          scriptInfo->spriteSheetID);
3190
                        break;
3191
                    case FX_ROTOZOOM:
3192
                        DrawSpriteRotozoom(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
3193
                                           (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
3194
                                           spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
3195
                                           entity->scale, scriptInfo->spriteSheetID);
3196
                        break;
3197
                    case FX_INK:
3198
                        switch (entity->inkEffect) {
3199
                            case INK_NONE:
3200
                                DrawSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
3201
                                           (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
3202
                                           spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3203
                                break;
3204
                            case INK_BLEND:
3205
                                DrawBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
3206
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
3207
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3208
                                break;
3209
                            case INK_ALPHA:
3210
                                DrawAlphaBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
3211
                                                       (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
3212
                                                       spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
3213
                                                       scriptInfo->spriteSheetID);
3214
                                break;
3215
                            case INK_ADD:
3216
                                DrawAdditiveBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
3217
                                                          (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
3218
                                                          spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
3219
                                                          scriptInfo->spriteSheetID);
3220
                                break;
3221
                            case INK_SUB:
3222
                                DrawSubtractiveBlendedSprite((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
3223
                                                             (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
3224
                                                             spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
3225
                                                             scriptInfo->spriteSheetID);
3226
                                break;
3227
                        }
3228
                        break;
3229
                    case FX_TINT:
3230
                        if (entity->inkEffect == INK_ALPHA) {
3231
                            DrawScaledTintMask(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
3232
                                               (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY,
3233
                                               entity->scale, entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX,
3234
                                               spriteFrame->sprY, scriptInfo->spriteSheetID);
3235
                        }
3236
                        else {
3237
                            DrawSpriteScaled(entity->direction, (scriptEng.operands[2] >> 16) - xScrollOffset,
3238
                                             (scriptEng.operands[3] >> 16) - yScrollOffset, -spriteFrame->pivotX, -spriteFrame->pivotY, entity->scale,
3239
                                             entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
3240
                                             scriptInfo->spriteSheetID);
3241
                        }
3242
                        break;
3243
                    case FX_FLIP:
3244
                        switch (entity->direction) {
3245
                            default:
3246
                            case FLIP_NONE:
3247
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
3248
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
3249
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_NONE, scriptInfo->spriteSheetID);
3250
                                break;
3251
                            case FLIP_X:
3252
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset - spriteFrame->width - spriteFrame->pivotX,
3253
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset + spriteFrame->pivotY, spriteFrame->width,
3254
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_X, scriptInfo->spriteSheetID);
3255
                                break;
3256
                            case FLIP_Y:
3257
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset + spriteFrame->pivotX,
3258
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset - spriteFrame->height - spriteFrame->pivotY,
3259
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_Y,
3260
                                                  scriptInfo->spriteSheetID);
3261
                                break;
3262
                            case FLIP_XY:
3263
                                DrawSpriteFlipped((scriptEng.operands[2] >> 16) - xScrollOffset - spriteFrame->width - spriteFrame->pivotX,
3264
                                                  (scriptEng.operands[3] >> 16) - yScrollOffset - spriteFrame->height - spriteFrame->pivotY,
3265
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_XY,
3266
                                                  scriptInfo->spriteSheetID);
3267
                                break;
3268
                        }
3269
                        break;
3270
                }
3271
                break;
3272
            case FUNC_DRAWSPRITESCREENFX:
3273
                opcodeSize  = 0;
3274
                spriteFrame = &scriptFrames[scriptInfo->frameListOffset + scriptEng.operands[0]];
3275
                switch (scriptEng.operands[1]) {
3276
                    default: break;
3277
                    case FX_SCALE:
3278
                        DrawSpriteScaled(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX, -spriteFrame->pivotY,
3279
                                         entity->scale, entity->scale, spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
3280
                                         scriptInfo->spriteSheetID);
3281
                        break;
3282
                    case FX_ROTATE:
3283
                        DrawSpriteRotated(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX, -spriteFrame->pivotY,
3284
                                          spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height, entity->rotation,
3285
                                          scriptInfo->spriteSheetID);
3286
                        break;
3287
                    case FX_ROTOZOOM:
3288
                        DrawSpriteRotozoom(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
3289
                                           -spriteFrame->pivotY, spriteFrame->sprX, spriteFrame->sprY, spriteFrame->width, spriteFrame->height,
3290
                                           entity->rotation, entity->scale, scriptInfo->spriteSheetID);
3291
                        break;
3292
                    case FX_INK:
3293
                        switch (entity->inkEffect) {
3294
                            case INK_NONE:
3295
                                DrawSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
3296
                                           spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3297
                                break;
3298
                            case INK_BLEND:
3299
                                DrawBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
3300
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
3301
                                                  scriptInfo->spriteSheetID);
3302
                                break;
3303
                            case INK_ALPHA:
3304
                                DrawAlphaBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
3305
                                                       spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, entity->alpha,
3306
                                                       scriptInfo->spriteSheetID);
3307
                                break;
3308
                            case INK_ADD:
3309
                                DrawAdditiveBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
3310
                                                          spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
3311
                                                          entity->alpha, scriptInfo->spriteSheetID);
3312
                                break;
3313
                            case INK_SUB:
3314
                                DrawSubtractiveBlendedSprite(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
3315
                                                             spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY,
3316
                                                             entity->alpha, scriptInfo->spriteSheetID);
3317
                                break;
3318
                        }
3319
                        break;
3320
                    case FX_TINT:
3321
                        if (entity->inkEffect == INK_ALPHA) {
3322
                            DrawScaledTintMask(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
3323
                                               -spriteFrame->pivotY, entity->scale, entity->scale, spriteFrame->width, spriteFrame->height,
3324
                                               spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3325
                        }
3326
                        else {
3327
                            DrawSpriteScaled(entity->direction, scriptEng.operands[2], scriptEng.operands[3], -spriteFrame->pivotX,
3328
                                             -spriteFrame->pivotY, entity->scale, entity->scale, spriteFrame->width, spriteFrame->height,
3329
                                             spriteFrame->sprX, spriteFrame->sprY, scriptInfo->spriteSheetID);
3330
                        }
3331
                        break;
3332
                    case FX_FLIP:
3333
                        switch (entity->direction) {
3334
                            default:
3335
                            case FLIP_NONE:
3336
                                DrawSpriteFlipped(scriptEng.operands[2] + spriteFrame->pivotX, scriptEng.operands[3] + spriteFrame->pivotY,
3337
                                                  spriteFrame->width, spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_NONE,
3338
                                                  scriptInfo->spriteSheetID);
3339
                                break;
3340
                            case FLIP_X:
3341
                                DrawSpriteFlipped(scriptEng.operands[2] - spriteFrame->width - spriteFrame->pivotX,
3342
                                                  scriptEng.operands[3] + spriteFrame->pivotY, spriteFrame->width, spriteFrame->height,
3343
                                                  spriteFrame->sprX, spriteFrame->sprY, FLIP_X, scriptInfo->spriteSheetID);
3344
                                break;
3345
                            case FLIP_Y:
3346
                                DrawSpriteFlipped(scriptEng.operands[2] + spriteFrame->pivotX,
3347
                                                  scriptEng.operands[3] - spriteFrame->height - spriteFrame->pivotY, spriteFrame->width,
3348
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_Y, scriptInfo->spriteSheetID);
3349
                                break;
3350
                            case FLIP_XY:
3351
                                DrawSpriteFlipped(scriptEng.operands[2] - spriteFrame->width - spriteFrame->pivotX,
3352
                                                  scriptEng.operands[3] - spriteFrame->height - spriteFrame->pivotY, spriteFrame->width,
3353
                                                  spriteFrame->height, spriteFrame->sprX, spriteFrame->sprY, FLIP_XY, scriptInfo->spriteSheetID);
3354
                                break;
3355
                        }
3356
                        break;
3357
                }
3358
                break;
3359
            case FUNC_LOADANIMATION:
3360
                opcodeSize           = 0;
3361
                scriptInfo->animFile = AddAnimationFile(scriptText);
3362
                break;
3363
            case FUNC_SETUPMENU: {
3364
                opcodeSize     = 0;
3365
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
3366
                SetupTextMenu(menu, scriptEng.operands[1]);
3367
                menu->selectionCount = scriptEng.operands[2];
3368
                menu->alignment      = scriptEng.operands[3];
3369
                break;
3370
            }
3371
            case FUNC_ADDMENUENTRY: {
3372
                opcodeSize                           = 0;
3373
                TextMenu *menu                       = &gameMenu[scriptEng.operands[0]];
3374
                menu->entryHighlight[menu->rowCount] = scriptEng.operands[2];
3375
                AddTextMenuEntry(menu, scriptText);
3376
                break;
3377
            }
3378
            case FUNC_EDITMENUENTRY: {
3379
                opcodeSize     = 0;
3380
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
3381
                EditTextMenuEntry(menu, scriptText, scriptEng.operands[2]);
3382
                menu->entryHighlight[scriptEng.operands[2]] = scriptEng.operands[3];
3383
                break;
3384
            }
3385
            case FUNC_LOADSTAGE:
3386
                opcodeSize = 0;
3387
                stageMode  = STAGEMODE_LOAD;
3388
                break;
3389
            case FUNC_DRAWRECT:
3390
                opcodeSize = 0;
3391
                DrawRectangle(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
3392
                              scriptEng.operands[5], scriptEng.operands[6], scriptEng.operands[7]);
3393
                break;
3394
            case FUNC_RESETOBJECTENTITY: {
3395
                opcodeSize            = 0;
3396
                Entity *newEnt        = &objectEntityList[scriptEng.operands[0]];
3397
                newEnt->type          = scriptEng.operands[1];
3398
                newEnt->propertyValue = scriptEng.operands[2];
3399
                newEnt->XPos          = scriptEng.operands[3];
3400
                newEnt->YPos          = scriptEng.operands[4];
3401
                newEnt->direction     = FLIP_NONE;
3402
                newEnt->frame         = 0;
3403
                newEnt->priority      = PRIORITY_BOUNDS;
3404
                newEnt->rotation      = 0;
3405
                newEnt->state         = 0;
3406
                newEnt->drawOrder     = 3;
3407
                newEnt->scale         = 512;
3408
                newEnt->inkEffect     = INK_NONE;
3409
                newEnt->values[0]     = 0;
3410
                newEnt->values[1]     = 0;
3411
                newEnt->values[2]     = 0;
3412
                newEnt->values[3]     = 0;
3413
                newEnt->values[4]     = 0;
3414
                newEnt->values[5]     = 0;
3415
                newEnt->values[6]     = 0;
3416
                newEnt->values[7]     = 0;
3417
                break;
3418
            }
3419
            case FUNC_PLAYEROBJECTCOLLISION:
3420
                opcodeSize = 0;
3421
                switch (scriptEng.operands[0]) {
3422
                    default: break;
3423
                    case C_TOUCH:
3424
                        scriptEng.operands[5] = entity->XPos >> 16;
3425
                        scriptEng.operands[6] = entity->YPos >> 16;
3426
                        TouchCollision(scriptEng.operands[5] + scriptEng.operands[1], scriptEng.operands[6] + scriptEng.operands[2],
3427
                                       scriptEng.operands[5] + scriptEng.operands[3], scriptEng.operands[6] + scriptEng.operands[4]);
3428
                        break;
3429
                    case C_BOX:
3430
                        BoxCollision(entity->XPos + (scriptEng.operands[1] << 16), entity->YPos + (scriptEng.operands[2] << 16),
3431
                                     entity->XPos + (scriptEng.operands[3] << 16), entity->YPos + (scriptEng.operands[4] << 16));
3432
                        break;
3433
                    case C_BOX2:
3434
                        BoxCollision2(entity->XPos + (scriptEng.operands[1] << 16), entity->YPos + (scriptEng.operands[2] << 16),
3435
                                      entity->XPos + (scriptEng.operands[3] << 16), entity->YPos + (scriptEng.operands[4] << 16));
3436
                        break;
3437
                    case C_PLATFORM:
3438
                        PlatformCollision(entity->XPos + (scriptEng.operands[1] << 16), entity->YPos + (scriptEng.operands[2] << 16),
3439
                                          entity->XPos + (scriptEng.operands[3] << 16), entity->YPos + (scriptEng.operands[4] << 16));
3440
                        break;
3441
                    case C_BOX3:
3442
                        BoxCollision3(entity->XPos + (scriptEng.operands[1] << 16), entity->YPos + (scriptEng.operands[2] << 16),
3443
                                      entity->XPos + (scriptEng.operands[3] << 16), entity->YPos + (scriptEng.operands[4] << 16));
3444
                        break;
3445
                    case C_ENEMY:
3446
                        scriptEng.operands[5] = entity->XPos >> 16;
3447
                        scriptEng.operands[6] = entity->YPos >> 16;
3448
                        EnemyCollision(scriptEng.operands[5] + scriptEng.operands[1], scriptEng.operands[6] + scriptEng.operands[2],
3449
                                       scriptEng.operands[5] + scriptEng.operands[3], scriptEng.operands[6] + scriptEng.operands[4]);
3450
                        break;
3451
                }
3452
                break;
3453
            case FUNC_CREATETEMPOBJECT: {
3454
                opcodeSize = 0;
3455
                if (objectEntityList[scriptEng.arrayPosition[2]].type > 0 && ++scriptEng.arrayPosition[2] == LEGACY_v3_ENTITY_COUNT)
3456
                    scriptEng.arrayPosition[2] = LEGACY_v3_TEMPENTITY_START;
3457
                Entity *temp         = &objectEntityList[scriptEng.arrayPosition[2]];
3458
                temp->type           = scriptEng.operands[0];
3459
                temp->propertyValue  = scriptEng.operands[1];
3460
                temp->XPos           = scriptEng.operands[2];
3461
                temp->YPos           = scriptEng.operands[3];
3462
                temp->direction      = FLIP_NONE;
3463
                temp->frame          = 0;
3464
                temp->priority       = PRIORITY_ACTIVE;
3465
                temp->rotation       = 0;
3466
                temp->state          = 0;
3467
                temp->drawOrder      = 3;
3468
                temp->scale          = 512;
3469
                temp->inkEffect      = INK_NONE;
3470
                temp->alpha          = 0;
3471
                temp->animation      = 0;
3472
                temp->prevAnimation  = 0;
3473
                temp->animationSpeed = 0;
3474
                temp->animationTimer = 0;
3475
                temp->values[0]      = 0;
3476
                temp->values[1]      = 0;
3477
                temp->values[2]      = 0;
3478
                temp->values[3]      = 0;
3479
                temp->values[4]      = 0;
3480
                temp->values[5]      = 0;
3481
                temp->values[6]      = 0;
3482
                temp->values[7]      = 0;
3483
                break;
3484
            }
3485
            case FUNC_BINDPLAYERTOOBJECT: {
3486
                opcodeSize   = 0;
3487
                Entity *pEnt = &objectEntityList[scriptEng.operands[1]];
3488

3489
                playerList[scriptEng.operands[0]].animationFile = scriptInfo->animFile;
3490
                playerList[scriptEng.operands[0]].boundEntity   = pEnt;
3491
                playerList[scriptEng.operands[0]].entityNo      = scriptEng.operands[1];
3492
                break;
3493
            }
3494
            case FUNC_PLAYERTILECOLLISION:
3495
                opcodeSize = 0;
3496
                if (player->tileCollisions) {
3497
                    ProcessPlayerTileCollisions(player);
3498
                }
3499
                else {
3500
                    player->XPos += player->XVelocity;
3501
                    player->YPos += player->YVelocity;
3502
                }
3503
                break;
3504
            case FUNC_PROCESSPLAYERCONTROL:
3505
                opcodeSize = 0;
3506
                ProcessPlayerControl(player);
3507
                break;
3508
            case FUNC_PROCESSANIMATION:
3509
                ProcessObjectAnimation(scriptInfo, entity);
3510
                opcodeSize = 0;
3511
                break;
3512
            case FUNC_DRAWOBJECTANIMATION:
3513
                opcodeSize = 0;
3514
                DrawObjectAnimation(scriptInfo, entity, (entity->XPos >> 16) - xScrollOffset, (entity->YPos >> 16) - yScrollOffset);
3515
                break;
3516
            case FUNC_DRAWPLAYERANIMATION:
3517
                opcodeSize = 0;
3518
                if (player->visible) {
3519
                    if (currentCamera->target == activePlayer)
3520
                        DrawObjectAnimation(scriptInfo, entity, player->screenXPos, player->screenYPos);
3521
                    else
3522
                        DrawObjectAnimation(scriptInfo, entity, (player->XPos >> 16) - xScrollOffset, (player->YPos >> 16) - yScrollOffset);
3523
                }
3524
                break;
3525
            case FUNC_SETMUSICTRACK:
3526
                opcodeSize = 0;
3527
                if (scriptEng.operands[2] <= 1)
3528
                    SetMusicTrack(scriptText, scriptEng.operands[1], scriptEng.operands[2], 0);
3529
                else
3530
                    SetMusicTrack(scriptText, scriptEng.operands[1], true, scriptEng.operands[2]);
3531
                break;
3532
            case FUNC_PLAYMUSIC:
3533
                opcodeSize = 0;
3534
                PlayMusic(scriptEng.operands[0]);
3535
                break;
3536
            case FUNC_STOPMUSIC:
3537
                opcodeSize = 0;
3538
                StopMusic();
3539
                break;
3540
            case FUNC_PLAYSFX:
3541
                opcodeSize = 0;
3542
                PlaySfx(scriptEng.operands[0], scriptEng.operands[1]);
3543
                break;
3544
            case FUNC_STOPSFX:
3545
                opcodeSize = 0;
3546
                StopSfx(scriptEng.operands[0]);
3547
                break;
3548
            case FUNC_SETSFXATTRIBUTES: {
3549
                opcodeSize      = 0;
3550
                int32 channelID = PlaySfx(scriptEng.operands[0], false);
3551
                SetSfxAttributes(channelID, scriptEng.operands[1], scriptEng.operands[2]);
3552
                break;
3553
            }
3554
            case FUNC_OBJECTTILECOLLISION:
3555
                opcodeSize = 0;
3556
                switch (scriptEng.operands[0]) {
3557
                    default: break;
3558
                    case CSIDE_FLOOR: ObjectFloorCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3559
                    case CSIDE_LWALL: ObjectLWallCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3560
                    case CSIDE_RWALL: ObjectRWallCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3561
                    case CSIDE_ROOF: ObjectRoofCollision(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3562
                }
3563
                break;
3564
            case FUNC_OBJECTTILEGRIP:
3565
                opcodeSize = 0;
3566
                switch (scriptEng.operands[0]) {
3567
                    default: break;
3568
                    case CSIDE_FLOOR: ObjectFloorGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3569
                    case CSIDE_LWALL: ObjectLWallGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3570
                    case CSIDE_RWALL: ObjectRWallGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3571
                    case CSIDE_ROOF: ObjectRoofGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3572
                    case CSIDE_ENTITY: ObjectEntityGrip(scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3573
                }
3574
                break;
3575
            case FUNC_LOADVIDEO:
3576
                opcodeSize = 0;
3577
                StrAdd(scriptText, ".ogv");
3578
                LoadVideo(scriptText, 0.0, VideoSkipCB);
3579
                break;
3580
            case FUNC_NEXTVIDEOFRAME: opcodeSize = 0; break;
3581
            case FUNC_PLAYSTAGESFX:
3582
                opcodeSize = 0;
3583
                PlaySfx(globalSFXCount + scriptEng.operands[0], scriptEng.operands[1]);
3584
                break;
3585
            case FUNC_STOPSTAGESFX:
3586
                opcodeSize = 0;
3587
                StopSfx(globalSFXCount + scriptEng.operands[0]);
3588
                break;
3589
            case FUNC_NOT: scriptEng.operands[0] = ~scriptEng.operands[0]; break;
3590
            case FUNC_DRAW3DSCENE:
3591
                opcodeSize = 0;
3592
                TransformVertexBuffer();
3593
                Sort3DDrawList();
3594
                Draw3DScene(scriptInfo->spriteSheetID);
3595
                break;
3596
            case FUNC_SETIDENTITYMATRIX:
3597
                opcodeSize = 0;
3598
                switch (scriptEng.operands[0]) {
3599
                    case MAT_WORLD: SetIdentityMatrix(&matWorld); break;
3600
                    case MAT_VIEW: SetIdentityMatrix(&matView); break;
3601
                    case MAT_TEMP: SetIdentityMatrix(&matTemp); break;
3602
                }
3603
                break;
3604
            case FUNC_MATRIXMULTIPLY:
3605
                opcodeSize = 0;
3606
                switch (scriptEng.operands[0]) {
3607
                    case MAT_WORLD:
3608
                        switch (scriptEng.operands[1]) {
3609
                            case MAT_WORLD: MatrixMultiply(&matWorld, &matWorld); break;
3610
                            case MAT_VIEW: MatrixMultiply(&matWorld, &matView); break;
3611
                            case MAT_TEMP: MatrixMultiply(&matWorld, &matTemp); break;
3612
                        }
3613
                        break;
3614
                    case MAT_VIEW:
3615
                        switch (scriptEng.operands[1]) {
3616
                            case MAT_WORLD: MatrixMultiply(&matView, &matWorld); break;
3617
                            case MAT_VIEW: MatrixMultiply(&matView, &matView); break;
3618
                            case MAT_TEMP: MatrixMultiply(&matView, &matTemp); break;
3619
                        }
3620
                        break;
3621
                    case MAT_TEMP:
3622
                        switch (scriptEng.operands[1]) {
3623
                            case MAT_WORLD: MatrixMultiply(&matTemp, &matWorld); break;
3624
                            case MAT_VIEW: MatrixMultiply(&matTemp, &matView); break;
3625
                            case MAT_TEMP: MatrixMultiply(&matTemp, &matTemp); break;
3626
                        }
3627
                        break;
3628
                }
3629
                break;
3630
            case FUNC_MATRIXTRANSLATEXYZ:
3631
                opcodeSize = 0;
3632
                switch (scriptEng.operands[0]) {
3633
                    case MAT_WORLD: MatrixTranslateXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3634
                    case MAT_VIEW: MatrixTranslateXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3635
                    case MAT_TEMP: MatrixTranslateXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3636
                }
3637
                break;
3638
            case FUNC_MATRIXSCALEXYZ:
3639
                opcodeSize = 0;
3640
                switch (scriptEng.operands[0]) {
3641
                    case MAT_WORLD: MatrixScaleXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3642
                    case MAT_VIEW: MatrixScaleXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3643
                    case MAT_TEMP: MatrixScaleXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3644
                }
3645
                break;
3646
            case FUNC_MATRIXROTATEX:
3647
                opcodeSize = 0;
3648
                switch (scriptEng.operands[0]) {
3649
                    case MAT_WORLD: MatrixRotateX(&matWorld, scriptEng.operands[1]); break;
3650
                    case MAT_VIEW: MatrixRotateX(&matView, scriptEng.operands[1]); break;
3651
                    case MAT_TEMP: MatrixRotateX(&matTemp, scriptEng.operands[1]); break;
3652
                }
3653
                break;
3654
            case FUNC_MATRIXROTATEY:
3655
                opcodeSize = 0;
3656
                switch (scriptEng.operands[0]) {
3657
                    case MAT_WORLD: MatrixRotateY(&matWorld, scriptEng.operands[1]); break;
3658
                    case MAT_VIEW: MatrixRotateY(&matView, scriptEng.operands[1]); break;
3659
                    case MAT_TEMP: MatrixRotateY(&matTemp, scriptEng.operands[1]); break;
3660
                }
3661
                break;
3662
            case FUNC_MATRIXROTATEZ:
3663
                opcodeSize = 0;
3664
                switch (scriptEng.operands[0]) {
3665
                    case MAT_WORLD: MatrixRotateZ(&matWorld, scriptEng.operands[1]); break;
3666
                    case MAT_VIEW: MatrixRotateZ(&matView, scriptEng.operands[1]); break;
3667
                    case MAT_TEMP: MatrixRotateZ(&matTemp, scriptEng.operands[1]); break;
3668
                }
3669
                break;
3670
            case FUNC_MATRIXROTATEXYZ:
3671
                opcodeSize = 0;
3672
                switch (scriptEng.operands[0]) {
3673
                    case MAT_WORLD: MatrixRotateXYZ(&matWorld, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3674
                    case MAT_VIEW: MatrixRotateXYZ(&matView, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3675
                    case MAT_TEMP: MatrixRotateXYZ(&matTemp, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3]); break;
3676
                }
3677
                break;
3678
            case FUNC_TRANSFORMVERTICES:
3679
                opcodeSize = 0;
3680
                switch (scriptEng.operands[0]) {
3681
                    case MAT_WORLD: TransformVerticies(&matWorld, scriptEng.operands[1], scriptEng.operands[2]); break;
3682
                    case MAT_VIEW: TransformVerticies(&matView, scriptEng.operands[1], scriptEng.operands[2]); break;
3683
                    case MAT_TEMP: TransformVerticies(&matTemp, scriptEng.operands[1], scriptEng.operands[2]); break;
3684
                }
3685
                break;
3686
            case FUNC_CALLFUNCTION: {
3687
                opcodeSize                        = 0;
3688
                functionStack[functionStackPos++] = scriptCodePtr;
3689
                functionStack[functionStackPos++] = jumpTableStart;
3690
                functionStack[functionStackPos++] = scriptCodeStart;
3691
                scriptCodeStart                   = scriptFunctionList[scriptEng.operands[0]].ptr.scriptCodePtr;
3692
                jumpTableStart                    = scriptFunctionList[scriptEng.operands[0]].ptr.jumpTablePtr;
3693
                scriptCodePtr                     = scriptCodeStart;
3694
            } break;
3695
            case FUNC_ENDFUNCTION:
3696
                opcodeSize      = 0;
3697
                scriptCodeStart = functionStack[--functionStackPos];
3698
                jumpTableStart  = functionStack[--functionStackPos];
3699
                scriptCodePtr   = functionStack[--functionStackPos];
3700
                break;
3701
            case FUNC_SETLAYERDEFORMATION:
3702
                opcodeSize = 0;
3703
                SetLayerDeformation(scriptEng.operands[0], scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
3704
                                    scriptEng.operands[5]);
3705
                break;
3706
            case FUNC_CHECKTOUCHRECT:
3707
                opcodeSize            = 0;
3708
                scriptEng.checkResult = -1;
3709

3710
                for (int32 f = 0; f < touchInfo.count; ++f) {
3711
                    if (touchInfo.down[f]) {
3712
                        int32 touchX = (int32)(touchInfo.x[f] * SCREEN_XSIZE);
3713
                        int32 touchY = (int32)(touchInfo.y[f] * SCREEN_YSIZE);
3714

3715
                        if (touchX > scriptEng.operands[0] && touchX < scriptEng.operands[2] && touchY > scriptEng.operands[1]
3716
                            && touchY < scriptEng.operands[3]) {
3717
                            scriptEng.checkResult = f;
3718
                        }
3719
                    }
3720
                }
3721
                break;
3722
            case FUNC_GETTILELAYERENTRY:
3723
                scriptEng.operands[0] = stageLayouts[scriptEng.operands[1]].tiles[scriptEng.operands[2] + 0x100 * scriptEng.operands[3]];
3724
                break;
3725
            case FUNC_SETTILELAYERENTRY:
3726
                stageLayouts[scriptEng.operands[1]].tiles[scriptEng.operands[2] + 0x100 * scriptEng.operands[3]] = scriptEng.operands[0];
3727
                break;
3728
            case FUNC_GETBIT: scriptEng.operands[0] = (scriptEng.operands[1] & (1 << scriptEng.operands[2])) >> scriptEng.operands[2]; break;
3729
            case FUNC_SETBIT:
3730
                if (scriptEng.operands[2] <= 0)
3731
                    scriptEng.operands[0] &= ~(1 << scriptEng.operands[1]);
3732
                else
3733
                    scriptEng.operands[0] |= 1 << scriptEng.operands[1];
3734
                break;
3735
            case FUNC_PAUSEMUSIC:
3736
                opcodeSize = 0;
3737
                PauseChannel(musicChannel);
3738
                break;
3739
            case FUNC_RESUMEMUSIC:
3740
                opcodeSize = 0;
3741
                ResumeChannel(musicChannel);
3742
                break;
3743
            case FUNC_CLEARDRAWLIST:
3744
                opcodeSize                                      = 0;
3745
                drawListEntries[scriptEng.operands[0]].listSize = 0;
3746
                break;
3747
            case FUNC_ADDDRAWLISTENTITYREF: {
3748
                opcodeSize                                                                                           = 0;
3749
                drawListEntries[scriptEng.operands[0]].entityRefs[drawListEntries[scriptEng.operands[0]].listSize++] = scriptEng.operands[1];
3750
                break;
3751
            }
3752
            case FUNC_GETDRAWLISTENTITYREF: scriptEng.operands[0] = drawListEntries[scriptEng.operands[1]].entityRefs[scriptEng.operands[2]]; break;
3753
            case FUNC_SETDRAWLISTENTITYREF:
3754
                opcodeSize                                                               = 0;
3755
                drawListEntries[scriptEng.operands[1]].entityRefs[scriptEng.operands[2]] = scriptEng.operands[0];
3756
                break;
3757
            case FUNC_GET16X16TILEINFO: {
3758
                scriptEng.operands[4] = scriptEng.operands[1] >> 7;
3759
                scriptEng.operands[5] = scriptEng.operands[2] >> 7;
3760
                scriptEng.operands[6] = stageLayouts[0].tiles[scriptEng.operands[4] + (scriptEng.operands[5] << 8)] << 6;
3761
                scriptEng.operands[6] += ((scriptEng.operands[1] & 0x7F) >> 4) + 8 * ((scriptEng.operands[2] & 0x7F) >> 4);
3762
                int32 index = tiles128x128.tileIndex[scriptEng.operands[6]];
3763
                switch (scriptEng.operands[3]) {
3764
                    case TILEINFO_INDEX: scriptEng.operands[0] = tiles128x128.tileIndex[scriptEng.operands[6]]; break;
3765
                    case TILEINFO_DIRECTION: scriptEng.operands[0] = tiles128x128.direction[scriptEng.operands[6]]; break;
3766
                    case TILEINFO_VISUALPLANE: scriptEng.operands[0] = tiles128x128.visualPlane[scriptEng.operands[6]]; break;
3767
                    case TILEINFO_SOLIDITYA: scriptEng.operands[0] = tiles128x128.collisionFlags[0][scriptEng.operands[6]]; break;
3768
                    case TILEINFO_SOLIDITYB: scriptEng.operands[0] = tiles128x128.collisionFlags[1][scriptEng.operands[6]]; break;
3769
                    case TILEINFO_FLAGSA: scriptEng.operands[0] = collisionMasks[0].flags[index]; break;
3770
                    case TILEINFO_ANGLEA: scriptEng.operands[0] = collisionMasks[0].angles[index]; break;
3771
                    case TILEINFO_FLAGSB: scriptEng.operands[0] = collisionMasks[1].flags[index]; break;
3772
                    case TILEINFO_ANGLEB: scriptEng.operands[0] = collisionMasks[1].angles[index]; break;
3773
                    default: break;
3774
                }
3775
                break;
3776
            }
3777
            case FUNC_COPY16X16TILE:
3778
                opcodeSize = 0;
3779
                Copy16x16Tile(scriptEng.operands[0], scriptEng.operands[1]);
3780
                break;
3781
            case FUNC_SET16X16TILEINFO: {
3782
                scriptEng.operands[4] = scriptEng.operands[1] >> 7;
3783
                scriptEng.operands[5] = scriptEng.operands[2] >> 7;
3784
                scriptEng.operands[6] = stageLayouts[0].tiles[scriptEng.operands[4] + (scriptEng.operands[5] << 8)] << 6;
3785
                scriptEng.operands[6] += ((scriptEng.operands[1] & 0x7F) >> 4) + 8 * ((scriptEng.operands[2] & 0x7F) >> 4);
3786
                switch (scriptEng.operands[3]) {
3787
                    case TILEINFO_INDEX:
3788
                        tiles128x128.tileIndex[scriptEng.operands[6]]  = scriptEng.operands[0];
3789
                        tiles128x128.gfxDataPos[scriptEng.operands[6]] = scriptEng.operands[0] << 8;
3790
                        break;
3791
                    case TILEINFO_DIRECTION: tiles128x128.direction[scriptEng.operands[6]] = scriptEng.operands[0]; break;
3792
                    case TILEINFO_VISUALPLANE: tiles128x128.visualPlane[scriptEng.operands[6]] = scriptEng.operands[0]; break;
3793
                    case TILEINFO_SOLIDITYA: tiles128x128.collisionFlags[0][scriptEng.operands[6]] = scriptEng.operands[0]; break;
3794
                    case TILEINFO_SOLIDITYB: tiles128x128.collisionFlags[1][scriptEng.operands[6]] = scriptEng.operands[0]; break;
3795
                    case TILEINFO_FLAGSA: collisionMasks[1].flags[tiles128x128.tileIndex[scriptEng.operands[6]]] = scriptEng.operands[0]; break;
3796
                    case TILEINFO_ANGLEA: collisionMasks[1].angles[tiles128x128.tileIndex[scriptEng.operands[6]]] = scriptEng.operands[0]; break;
3797
                    default: break;
3798
                }
3799
                break;
3800
            }
3801
            case FUNC_GETANIMATIONBYNAME: {
3802
                AnimationFile *animFile = scriptInfo->animFile;
3803
                scriptEng.operands[0]   = -1;
3804
                int32 id                = 0;
3805
                while (scriptEng.operands[0] == -1) {
3806
                    SpriteAnimation *anim = &animationList[animFile->aniListOffset + id];
3807
                    if (StrComp(scriptText, anim->name))
3808
                        scriptEng.operands[0] = id;
3809
                    else if (++id == animFile->animCount)
3810
                        scriptEng.operands[0] = 0;
3811
                }
3812
                break;
3813
            }
3814
            case FUNC_READSAVERAM:
3815
                opcodeSize            = 0;
3816
                scriptEng.checkResult = ReadSaveRAM();
3817
                break;
3818
            case FUNC_WRITESAVERAM:
3819
                opcodeSize            = 0;
3820
                scriptEng.checkResult = WriteSaveRAM();
3821
                break;
3822
            case FUNC_LOADTEXTFONT:
3823
                opcodeSize = 0;
3824
                LoadFontFile(scriptText);
3825
                break;
3826
            case FUNC_LOADTEXTFILE: {
3827
                opcodeSize     = 0;
3828
                TextMenu *menu = &gameMenu[scriptEng.operands[0]];
3829
                LoadTextFile(menu, scriptText, scriptEng.operands[2] != 0);
3830
                break;
3831
            }
3832
            case FUNC_DRAWTEXT: {
3833
                opcodeSize        = 0;
3834
                textMenuSurfaceNo = scriptInfo->spriteSheetID;
3835
                TextMenu *menu    = &gameMenu[scriptEng.operands[0]];
3836
                DrawBitmapText(menu, scriptEng.operands[1], scriptEng.operands[2], scriptEng.operands[3], scriptEng.operands[4],
3837
                               scriptEng.operands[5], scriptEng.operands[6]);
3838
                break;
3839
            }
3840
            case FUNC_GETTEXTINFO: {
3841
                TextMenu *menu = &gameMenu[scriptEng.operands[1]];
3842
                switch (scriptEng.operands[2]) {
3843
                    case TEXTINFO_TEXTDATA:
3844
                        scriptEng.operands[0] = menu->textData[menu->entryStart[scriptEng.operands[3]] + scriptEng.operands[4]];
3845
                        break;
3846
                    case TEXTINFO_TEXTSIZE: scriptEng.operands[0] = menu->entrySize[scriptEng.operands[3]]; break;
3847
                    case TEXTINFO_ROWCOUNT: scriptEng.operands[0] = menu->rowCount; break;
3848
                }
3849
                break;
3850
            }
3851
            case FUNC_GETVERSIONNUMBER: {
3852
                opcodeSize                           = 0;
3853
                TextMenu *menu                       = &gameMenu[scriptEng.operands[0]];
3854
                menu->entryHighlight[menu->rowCount] = scriptEng.operands[1];
3855
                AddTextMenuEntry(menu, gameVerInfo.version);
3856
                break;
3857
            }
3858
            case FUNC_SETACHIEVEMENT:
3859
                opcodeSize = 0;
3860
                SetAchievement(scriptEng.operands[0], scriptEng.operands[1]);
3861
                break;
3862
            case FUNC_SETLEADERBOARD:
3863
                opcodeSize = 0;
3864
                SetLeaderboard(scriptEng.operands[0], scriptEng.operands[1]);
3865
                break;
3866
            case FUNC_LOADONLINEMENU:
3867
                opcodeSize = 0;
3868
                switch (scriptEng.operands[0]) {
3869
                    default: break;
3870
                    case 0: LoadAchievementsMenu(); break;
3871
                    case 1: LoadLeaderboardsMenu(); break;
3872
                }
3873
                break;
3874
            case FUNC_ENGINECALLBACK:
3875
                opcodeSize = 0;
3876
                RetroEngineCallback(scriptEng.operands[0]);
3877
                break;
3878
#if LEGACY_RETRO_USE_HAPTICS
3879
            case FUNC_HAPTICEFFECT: opcodeSize = 0; break;
3880
#endif
3881
        }
3882

3883
        // Set Values
3884
        if (opcodeSize > 0)
3885
            scriptCodePtr -= scriptCodePtr - scriptCodeOffset;
3886
        for (int32 i = 0; i < opcodeSize; ++i) {
3887
            int32 opcodeType = scriptCode[scriptCodePtr++];
3888
            if (opcodeType == SCRIPTVAR_VAR) {
3889
                int32 arrayVal = 0;
3890
                switch (scriptCode[scriptCodePtr++]) { // variable
3891
                    case VARARR_NONE: arrayVal = objectLoop; break;
3892
                    case VARARR_ARRAY:
3893
                        if (scriptCode[scriptCodePtr++] == 1)
3894
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
3895
                        else
3896
                            arrayVal = scriptCode[scriptCodePtr++];
3897
                        break;
3898
                    case VARARR_ENTNOPLUS1:
3899
                        if (scriptCode[scriptCodePtr++] == 1)
3900
                            arrayVal = scriptEng.arrayPosition[scriptCode[scriptCodePtr++]] + objectLoop;
3901
                        else
3902
                            arrayVal = scriptCode[scriptCodePtr++] + objectLoop;
3903
                        break;
3904
                    case VARARR_ENTNOMINUS1:
3905
                        if (scriptCode[scriptCodePtr++] == 1)
3906
                            arrayVal = objectLoop - scriptEng.arrayPosition[scriptCode[scriptCodePtr++]];
3907
                        else
3908
                            arrayVal = objectLoop - scriptCode[scriptCodePtr++];
3909
                        break;
3910
                    default: break;
3911
                }
3912

3913
                // Variables
3914
                switch (scriptCode[scriptCodePtr++]) {
3915
                    default: break;
3916
                    case VAR_TEMPVALUE0: scriptEng.tempValue[0] = scriptEng.operands[i]; break;
3917
                    case VAR_TEMPVALUE1: scriptEng.tempValue[1] = scriptEng.operands[i]; break;
3918
                    case VAR_TEMPVALUE2: scriptEng.tempValue[2] = scriptEng.operands[i]; break;
3919
                    case VAR_TEMPVALUE3: scriptEng.tempValue[3] = scriptEng.operands[i]; break;
3920
                    case VAR_TEMPVALUE4: scriptEng.tempValue[4] = scriptEng.operands[i]; break;
3921
                    case VAR_TEMPVALUE5: scriptEng.tempValue[5] = scriptEng.operands[i]; break;
3922
                    case VAR_TEMPVALUE6: scriptEng.tempValue[6] = scriptEng.operands[i]; break;
3923
                    case VAR_TEMPVALUE7: scriptEng.tempValue[7] = scriptEng.operands[i]; break;
3924
                    case VAR_CHECKRESULT: scriptEng.checkResult = scriptEng.operands[i]; break;
3925
                    case VAR_ARRAYPOS0: scriptEng.arrayPosition[0] = scriptEng.operands[i]; break;
3926
                    case VAR_ARRAYPOS1: scriptEng.arrayPosition[1] = scriptEng.operands[i]; break;
3927
                    case VAR_GLOBAL: globalVariables[arrayVal].value = scriptEng.operands[i]; break;
3928
                    case VAR_OBJECTENTITYNO: break;
3929
                    case VAR_OBJECTTYPE: {
3930
                        objectEntityList[arrayVal].type = scriptEng.operands[i];
3931
                        break;
3932
                    }
3933
                    case VAR_OBJECTPROPERTYVALUE: {
3934
                        objectEntityList[arrayVal].propertyValue = scriptEng.operands[i];
3935
                        break;
3936
                    }
3937
                    case VAR_OBJECTXPOS: {
3938
                        objectEntityList[arrayVal].XPos = scriptEng.operands[i];
3939
                        break;
3940
                    }
3941
                    case VAR_OBJECTYPOS: {
3942
                        objectEntityList[arrayVal].YPos = scriptEng.operands[i];
3943
                        break;
3944
                    }
3945
                    case VAR_OBJECTIXPOS: {
3946
                        objectEntityList[arrayVal].XPos = scriptEng.operands[i] << 16;
3947
                        break;
3948
                    }
3949
                    case VAR_OBJECTIYPOS: {
3950
                        objectEntityList[arrayVal].YPos = scriptEng.operands[i] << 16;
3951
                        break;
3952
                    }
3953
                    case VAR_OBJECTSTATE: {
3954
                        objectEntityList[arrayVal].state = scriptEng.operands[i];
3955
                        break;
3956
                    }
3957
                    case VAR_OBJECTROTATION: {
3958
                        objectEntityList[arrayVal].rotation = scriptEng.operands[i];
3959
                        break;
3960
                    }
3961
                    case VAR_OBJECTSCALE: {
3962
                        objectEntityList[arrayVal].scale = scriptEng.operands[i];
3963
                        break;
3964
                    }
3965
                    case VAR_OBJECTPRIORITY: {
3966
                        objectEntityList[arrayVal].priority = scriptEng.operands[i];
3967
                        break;
3968
                    }
3969
                    case VAR_OBJECTDRAWORDER: {
3970
                        objectEntityList[arrayVal].drawOrder = scriptEng.operands[i];
3971
                        break;
3972
                    }
3973
                    case VAR_OBJECTDIRECTION: {
3974
                        objectEntityList[arrayVal].direction = scriptEng.operands[i];
3975
                        break;
3976
                    }
3977
                    case VAR_OBJECTINKEFFECT: {
3978
                        objectEntityList[arrayVal].inkEffect = scriptEng.operands[i];
3979
                        break;
3980
                    }
3981
                    case VAR_OBJECTALPHA: {
3982
                        objectEntityList[arrayVal].alpha = scriptEng.operands[i];
3983
                        break;
3984
                    }
3985
                    case VAR_OBJECTFRAME: {
3986
                        objectEntityList[arrayVal].frame = scriptEng.operands[i];
3987
                        break;
3988
                    }
3989
                    case VAR_OBJECTANIMATION: {
3990
                        objectEntityList[arrayVal].animation = scriptEng.operands[i];
3991
                        break;
3992
                    }
3993
                    case VAR_OBJECTPREVANIMATION: {
3994
                        objectEntityList[arrayVal].prevAnimation = scriptEng.operands[i];
3995
                        break;
3996
                    }
3997
                    case VAR_OBJECTANIMATIONSPEED: {
3998
                        objectEntityList[arrayVal].animationSpeed = scriptEng.operands[i];
3999
                        break;
4000
                    }
4001
                    case VAR_OBJECTANIMATIONTIMER: {
4002
                        objectEntityList[arrayVal].animationTimer = scriptEng.operands[i];
4003
                        break;
4004
                    }
4005
                    case VAR_OBJECTVALUE0: {
4006
                        objectEntityList[arrayVal].values[0] = scriptEng.operands[i];
4007
                        break;
4008
                    }
4009
                    case VAR_OBJECTVALUE1: {
4010
                        objectEntityList[arrayVal].values[1] = scriptEng.operands[i];
4011
                        break;
4012
                    }
4013
                    case VAR_OBJECTVALUE2: {
4014
                        objectEntityList[arrayVal].values[2] = scriptEng.operands[i];
4015
                        break;
4016
                    }
4017
                    case VAR_OBJECTVALUE3: {
4018
                        objectEntityList[arrayVal].values[3] = scriptEng.operands[i];
4019
                        break;
4020
                    }
4021
                    case VAR_OBJECTVALUE4: {
4022
                        objectEntityList[arrayVal].values[4] = scriptEng.operands[i];
4023
                        break;
4024
                    }
4025
                    case VAR_OBJECTVALUE5: {
4026
                        objectEntityList[arrayVal].values[5] = scriptEng.operands[i];
4027
                        break;
4028
                    }
4029
                    case VAR_OBJECTVALUE6: {
4030
                        objectEntityList[arrayVal].values[6] = scriptEng.operands[i];
4031
                        break;
4032
                    }
4033
                    case VAR_OBJECTVALUE7: {
4034
                        objectEntityList[arrayVal].values[7] = scriptEng.operands[i];
4035
                        break;
4036
                    }
4037
                    case VAR_OBJECTOUTOFBOUNDS: break;
4038
                    case VAR_PLAYERSTATE: {
4039
                        playerList[activePlayer].boundEntity->state = scriptEng.operands[i];
4040
                        break;
4041
                    }
4042
                    case VAR_PLAYERCONTROLMODE: {
4043
                        playerList[activePlayer].controlMode = scriptEng.operands[i];
4044
                        break;
4045
                    }
4046
                    case VAR_PLAYERCONTROLLOCK: {
4047
                        playerList[activePlayer].controlLock = scriptEng.operands[i];
4048
                        break;
4049
                    }
4050
                    case VAR_PLAYERCOLLISIONMODE: {
4051
                        playerList[activePlayer].collisionMode = scriptEng.operands[i];
4052
                        break;
4053
                    }
4054
                    case VAR_PLAYERCOLLISIONPLANE: {
4055
                        playerList[activePlayer].collisionPlane = scriptEng.operands[i];
4056
                        break;
4057
                    }
4058
                    case VAR_PLAYERXPOS: {
4059
                        playerList[activePlayer].XPos = scriptEng.operands[i];
4060
                        break;
4061
                    }
4062
                    case VAR_PLAYERYPOS: {
4063
                        playerList[activePlayer].YPos = scriptEng.operands[i];
4064
                        break;
4065
                    }
4066
                    case VAR_PLAYERIXPOS: {
4067
                        playerList[activePlayer].XPos = scriptEng.operands[i] << 16;
4068
                        break;
4069
                    }
4070
                    case VAR_PLAYERIYPOS: {
4071
                        playerList[activePlayer].YPos = scriptEng.operands[i] << 16;
4072
                        break;
4073
                    }
4074
                    case VAR_PLAYERSCREENXPOS: {
4075
                        playerList[activePlayer].screenXPos = scriptEng.operands[i];
4076
                        break;
4077
                    }
4078
                    case VAR_PLAYERSCREENYPOS: {
4079
                        playerList[activePlayer].screenYPos = scriptEng.operands[i];
4080
                        break;
4081
                    }
4082
                    case VAR_PLAYERSPEED: {
4083
                        playerList[activePlayer].speed = scriptEng.operands[i];
4084
                        break;
4085
                    }
4086
                    case VAR_PLAYERXVELOCITY: {
4087
                        playerList[activePlayer].XVelocity = scriptEng.operands[i];
4088
                        break;
4089
                    }
4090
                    case VAR_PLAYERYVELOCITY: {
4091
                        playerList[activePlayer].YVelocity = scriptEng.operands[i];
4092
                        break;
4093
                    }
4094
                    case VAR_PLAYERGRAVITY: {
4095
                        playerList[activePlayer].gravity = scriptEng.operands[i];
4096
                        break;
4097
                    }
4098
                    case VAR_PLAYERANGLE: {
4099
                        playerList[activePlayer].angle = scriptEng.operands[i];
4100
                        break;
4101
                    }
4102
                    case VAR_PLAYERSKIDDING: {
4103
                        playerList[activePlayer].skidding = scriptEng.operands[i];
4104
                        break;
4105
                    }
4106
                    case VAR_PLAYERPUSHING: {
4107
                        playerList[activePlayer].pushing = scriptEng.operands[i];
4108
                        break;
4109
                    }
4110
                    case VAR_PLAYERTRACKSCROLL: {
4111
                        playerList[activePlayer].trackScroll = scriptEng.operands[i];
4112
                        break;
4113
                    }
4114
                    case VAR_PLAYERUP: {
4115
                        playerList[activePlayer].up = scriptEng.operands[i];
4116
                        break;
4117
                    }
4118
                    case VAR_PLAYERDOWN: {
4119
                        playerList[activePlayer].down = scriptEng.operands[i];
4120
                        break;
4121
                    }
4122
                    case VAR_PLAYERLEFT: {
4123
                        playerList[activePlayer].left = scriptEng.operands[i];
4124
                        break;
4125
                    }
4126
                    case VAR_PLAYERRIGHT: {
4127
                        playerList[activePlayer].right = scriptEng.operands[i];
4128
                        break;
4129
                    }
4130
                    case VAR_PLAYERJUMPPRESS: {
4131
                        playerList[activePlayer].jumpPress = scriptEng.operands[i];
4132
                        break;
4133
                    }
4134
                    case VAR_PLAYERJUMPHOLD: {
4135
                        playerList[activePlayer].jumpHold = scriptEng.operands[i];
4136
                        break;
4137
                    }
4138
                    case VAR_PLAYERFOLLOWPLAYER1: {
4139
                        playerList[activePlayer].followPlayer1 = scriptEng.operands[i];
4140
                        break;
4141
                    }
4142
                    case VAR_PLAYERLOOKPOS: {
4143
                        playerList[activePlayer].lookPos = scriptEng.operands[i];
4144
                        break;
4145
                    }
4146
                    case VAR_PLAYERWATER: {
4147
                        playerList[activePlayer].water = scriptEng.operands[i];
4148
                        break;
4149
                    }
4150
                    case VAR_PLAYERTOPSPEED: {
4151
                        playerList[activePlayer].topSpeed = scriptEng.operands[i];
4152
                        break;
4153
                    }
4154
                    case VAR_PLAYERACCELERATION: {
4155
                        playerList[activePlayer].acceleration = scriptEng.operands[i];
4156
                        break;
4157
                    }
4158
                    case VAR_PLAYERDECELERATION: {
4159
                        playerList[activePlayer].deceleration = scriptEng.operands[i];
4160
                        break;
4161
                    }
4162
                    case VAR_PLAYERAIRACCELERATION: {
4163
                        playerList[activePlayer].airAcceleration = scriptEng.operands[i];
4164
                        break;
4165
                    }
4166
                    case VAR_PLAYERAIRDECELERATION: {
4167
                        playerList[activePlayer].airDeceleration = scriptEng.operands[i];
4168
                        break;
4169
                    }
4170
                    case VAR_PLAYERGRAVITYSTRENGTH: {
4171
                        playerList[activePlayer].gravityStrength = scriptEng.operands[i];
4172
                        break;
4173
                    }
4174
                    case VAR_PLAYERJUMPSTRENGTH: {
4175
                        playerList[activePlayer].jumpStrength = scriptEng.operands[i];
4176
                        break;
4177
                    }
4178
                    case VAR_PLAYERJUMPCAP: {
4179
                        playerList[activePlayer].jumpCap = scriptEng.operands[i];
4180
                        break;
4181
                    }
4182
                    case VAR_PLAYERROLLINGACCELERATION: {
4183
                        scriptEng.operands[i] = playerList[activePlayer].rollingAcceleration = scriptEng.operands[i];
4184
                        break;
4185
                    }
4186
                    case VAR_PLAYERROLLINGDECELERATION: {
4187
                        scriptEng.operands[i] = playerList[activePlayer].rollingDeceleration = scriptEng.operands[i];
4188
                        break;
4189
                    }
4190
                    case VAR_PLAYERENTITYNO: break;
4191
                    case VAR_PLAYERCOLLISIONLEFT: break;
4192
                    case VAR_PLAYERCOLLISIONTOP: break;
4193
                    case VAR_PLAYERCOLLISIONRIGHT: break;
4194
                    case VAR_PLAYERCOLLISIONBOTTOM: break;
4195
                    case VAR_PLAYERFLAILING: {
4196
                        scriptEng.operands[i] = playerList[activePlayer].flailing[arrayVal] = scriptEng.operands[i];
4197
                        break;
4198
                    }
4199
                    case VAR_PLAYERTIMER: {
4200
                        playerList[activePlayer].timer = scriptEng.operands[i];
4201
                        break;
4202
                    }
4203
                    case VAR_PLAYERTILECOLLISIONS: {
4204
                        playerList[activePlayer].tileCollisions = scriptEng.operands[i];
4205
                        break;
4206
                    }
4207
                    case VAR_PLAYEROBJECTINTERACTION: {
4208
                        scriptEng.operands[i] = playerList[activePlayer].objectInteractions = scriptEng.operands[i];
4209
                        break;
4210
                    }
4211
                    case VAR_PLAYERVISIBLE: {
4212
                        playerList[activePlayer].visible = scriptEng.operands[i];
4213
                        break;
4214
                    }
4215
                    case VAR_PLAYERROTATION: {
4216
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->rotation = scriptEng.operands[i];
4217
                        break;
4218
                    }
4219
                    case VAR_PLAYERSCALE: {
4220
                        playerList[activePlayer].boundEntity->scale = scriptEng.operands[i];
4221
                        break;
4222
                    }
4223
                    case VAR_PLAYERPRIORITY: {
4224
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->priority = scriptEng.operands[i];
4225
                        break;
4226
                    }
4227
                    case VAR_PLAYERDRAWORDER: {
4228
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->drawOrder = scriptEng.operands[i];
4229
                        break;
4230
                    }
4231
                    case VAR_PLAYERDIRECTION: {
4232
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->direction = scriptEng.operands[i];
4233
                        break;
4234
                    }
4235
                    case VAR_PLAYERINKEFFECT: {
4236
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->inkEffect = scriptEng.operands[i];
4237
                        break;
4238
                    }
4239
                    case VAR_PLAYERALPHA: {
4240
                        playerList[activePlayer].boundEntity->alpha = scriptEng.operands[i];
4241
                        break;
4242
                    }
4243
                    case VAR_PLAYERFRAME: {
4244
                        playerList[activePlayer].boundEntity->frame = scriptEng.operands[i];
4245
                        break;
4246
                    }
4247
                    case VAR_PLAYERANIMATION: {
4248
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->animation = scriptEng.operands[i];
4249
                        break;
4250
                    }
4251
                    case VAR_PLAYERPREVANIMATION: {
4252
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->prevAnimation = scriptEng.operands[i];
4253
                        break;
4254
                    }
4255
                    case VAR_PLAYERANIMATIONSPEED: {
4256
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->animationSpeed = scriptEng.operands[i];
4257
                        break;
4258
                    }
4259
                    case VAR_PLAYERANIMATIONTIMER: {
4260
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->animationTimer = scriptEng.operands[i];
4261
                        break;
4262
                    }
4263
                    case VAR_PLAYERVALUE0: {
4264
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[0] = scriptEng.operands[i];
4265
                        break;
4266
                    }
4267
                    case VAR_PLAYERVALUE1: {
4268
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[1] = scriptEng.operands[i];
4269
                        break;
4270
                    }
4271
                    case VAR_PLAYERVALUE2: {
4272
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[2] = scriptEng.operands[i];
4273
                        break;
4274
                    }
4275
                    case VAR_PLAYERVALUE3: {
4276
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[3] = scriptEng.operands[i];
4277
                        break;
4278
                    }
4279
                    case VAR_PLAYERVALUE4: {
4280
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[4] = scriptEng.operands[i];
4281
                        break;
4282
                    }
4283
                    case VAR_PLAYERVALUE5: {
4284
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[5] = scriptEng.operands[i];
4285
                        break;
4286
                    }
4287
                    case VAR_PLAYERVALUE6: {
4288
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[6] = scriptEng.operands[i];
4289
                        break;
4290
                    }
4291
                    case VAR_PLAYERVALUE7: {
4292
                        scriptEng.operands[i] = playerList[activePlayer].boundEntity->values[7] = scriptEng.operands[i];
4293
                        break;
4294
                    }
4295
                    case VAR_PLAYERVALUE8: {
4296
                        playerList[activePlayer].values[0] = scriptEng.operands[i];
4297
                        break;
4298
                    }
4299
                    case VAR_PLAYERVALUE9: {
4300
                        playerList[activePlayer].values[1] = scriptEng.operands[i];
4301
                        break;
4302
                    }
4303
                    case VAR_PLAYERVALUE10: {
4304
                        playerList[activePlayer].values[2] = scriptEng.operands[i];
4305
                        break;
4306
                    }
4307
                    case VAR_PLAYERVALUE11: {
4308
                        playerList[activePlayer].values[3] = scriptEng.operands[i];
4309
                        break;
4310
                    }
4311
                    case VAR_PLAYERVALUE12: {
4312
                        playerList[activePlayer].values[4] = scriptEng.operands[i];
4313
                        break;
4314
                    }
4315
                    case VAR_PLAYERVALUE13: {
4316
                        playerList[activePlayer].values[5] = scriptEng.operands[i];
4317
                        break;
4318
                    }
4319
                    case VAR_PLAYERVALUE14: {
4320
                        playerList[activePlayer].values[6] = scriptEng.operands[i];
4321
                        break;
4322
                    }
4323
                    case VAR_PLAYERVALUE15: {
4324
                        playerList[activePlayer].values[7] = scriptEng.operands[i];
4325
                        break;
4326
                    }
4327
                    case VAR_PLAYEROUTOFBOUNDS: break;
4328
                    case VAR_STAGESTATE: stageMode = scriptEng.operands[i]; break;
4329
                    case VAR_STAGEACTIVELIST: {
4330
                        int32 listSlots[] = { 0, 1, 3, 2 };
4331

4332
                        int32 listID = scriptEng.operands[i];
4333
                        if (listID <= 3)
4334
                            listID = listSlots[listID];
4335
                        else
4336
                            listID = 2; // BONUS_STAGE
4337

4338
                        if (listID < sceneInfo.categoryCount) {
4339
                            int32 listPos = sceneInfo.listPos - sceneInfo.listCategory[sceneInfo.activeCategory].sceneOffsetStart;
4340

4341
                            sceneInfo.activeCategory = listID;
4342
                            SceneListInfo *list      = &sceneInfo.listCategory[sceneInfo.activeCategory];
4343

4344
                            sceneInfo.listPos = list->sceneOffsetStart + listPos;
4345
                            if (sceneInfo.listPos >= list->sceneOffsetEnd)
4346
                                sceneInfo.listPos = list->sceneOffsetEnd;
4347
                        }
4348
                        break;
4349
                    }
4350
                    case VAR_STAGELISTPOS: {
4351
                        SceneListInfo *list = &sceneInfo.listCategory[sceneInfo.activeCategory];
4352

4353
                        if (list->sceneOffsetStart + scriptEng.operands[i] <= list->sceneOffsetEnd)
4354
                            sceneInfo.listPos = list->sceneOffsetStart + scriptEng.operands[i];
4355
                        break;
4356
                    }
4357
                    case VAR_STAGETIMEENABLED: timeEnabled = scriptEng.operands[i]; break;
4358
                    case VAR_STAGEMILLISECONDS: stageMilliseconds = scriptEng.operands[i]; break;
4359
                    case VAR_STAGESECONDS: stageSeconds = scriptEng.operands[i]; break;
4360
                    case VAR_STAGEMINUTES: stageMinutes = scriptEng.operands[i]; break;
4361
                    case VAR_STAGEACTNO: actID = scriptEng.operands[i]; break;
4362
                    case VAR_STAGEPAUSEENABLED: pauseEnabled = scriptEng.operands[i]; break;
4363
                    case VAR_STAGELISTSIZE: break;
4364
                    case VAR_STAGENEWXBOUNDARY1: newXBoundary1 = scriptEng.operands[i]; break;
4365
                    case VAR_STAGENEWXBOUNDARY2: newXBoundary2 = scriptEng.operands[i]; break;
4366
                    case VAR_STAGENEWYBOUNDARY1: newYBoundary1 = scriptEng.operands[i]; break;
4367
                    case VAR_STAGENEWYBOUNDARY2: newYBoundary2 = scriptEng.operands[i]; break;
4368
                    case VAR_STAGEXBOUNDARY1:
4369
                        if (curXBoundary1 != scriptEng.operands[i]) {
4370
                            curXBoundary1 = scriptEng.operands[i];
4371
                            newXBoundary1 = scriptEng.operands[i];
4372
                        }
4373
                        break;
4374
                    case VAR_STAGEXBOUNDARY2:
4375
                        if (curXBoundary2 != scriptEng.operands[i]) {
4376
                            curXBoundary2 = scriptEng.operands[i];
4377
                            newXBoundary2 = scriptEng.operands[i];
4378
                        }
4379
                        break;
4380
                    case VAR_STAGEYBOUNDARY1:
4381
                        if (curYBoundary1 != scriptEng.operands[i]) {
4382
                            curYBoundary1 = scriptEng.operands[i];
4383
                            newYBoundary1 = scriptEng.operands[i];
4384
                        }
4385
                        break;
4386
                    case VAR_STAGEYBOUNDARY2:
4387
                        if (curYBoundary2 != scriptEng.operands[i]) {
4388
                            curYBoundary2 = scriptEng.operands[i];
4389
                            newYBoundary2 = scriptEng.operands[i];
4390
                        }
4391
                        break;
4392
                    case VAR_STAGEDEFORMATIONDATA0: bgDeformationData0[arrayVal] = scriptEng.operands[i]; break;
4393
                    case VAR_STAGEDEFORMATIONDATA1: bgDeformationData1[arrayVal] = scriptEng.operands[i]; break;
4394
                    case VAR_STAGEDEFORMATIONDATA2: bgDeformationData2[arrayVal] = scriptEng.operands[i]; break;
4395
                    case VAR_STAGEDEFORMATIONDATA3: bgDeformationData3[arrayVal] = scriptEng.operands[i]; break;
4396
                    case VAR_STAGEWATERLEVEL: waterLevel = scriptEng.operands[i]; break;
4397
                    case VAR_STAGEACTIVELAYER: activeTileLayers[arrayVal] = scriptEng.operands[i]; break;
4398
                    case VAR_STAGEMIDPOINT: tLayerMidPoint = scriptEng.operands[i]; break;
4399
                    case VAR_STAGEPLAYERLISTPOS: playerListPos = scriptEng.operands[i]; break;
4400
                    case VAR_STAGEACTIVEPLAYER: activePlayer = scriptEng.operands[i]; break;
4401
                    case VAR_SCREENCAMERAENABLED: currentCamera->enabled = scriptEng.operands[i]; break;
4402
                    case VAR_SCREENCAMERATARGET: currentCamera->target = scriptEng.operands[i]; break;
4403
                    case VAR_SCREENCAMERASTYLE: currentCamera->style = scriptEng.operands[i]; break;
4404
                    case VAR_SCREENDRAWLISTSIZE: drawListEntries[arrayVal].listSize = scriptEng.operands[i]; break;
4405
                    case VAR_SCREENCENTERX: break;
4406
                    case VAR_SCREENCENTERY: break;
4407
                    case VAR_SCREENXSIZE: break;
4408
                    case VAR_SCREENYSIZE: break;
4409
                    case VAR_SCREENXOFFSET:
4410
                        xScrollOffset = scriptEng.operands[i];
4411
                        xScrollA      = xScrollOffset;
4412
                        xScrollB      = SCREEN_XSIZE + xScrollOffset;
4413
                        break;
4414
                    case VAR_SCREENYOFFSET:
4415
                        yScrollOffset = scriptEng.operands[i];
4416
                        yScrollA      = yScrollOffset;
4417
                        yScrollB      = SCREEN_YSIZE + yScrollOffset;
4418
                        break;
4419
                    case VAR_SCREENSHAKEX: cameraShakeX = scriptEng.operands[i]; break;
4420
                    case VAR_SCREENSHAKEY: cameraShakeY = scriptEng.operands[i]; break;
4421
                    case VAR_SCREENADJUSTCAMERAY: currentCamera->adjustY = scriptEng.operands[i]; break;
4422
                    case VAR_TOUCHSCREENDOWN: break;
4423
                    case VAR_TOUCHSCREENXPOS: break;
4424
                    case VAR_TOUCHSCREENYPOS: break;
4425
                    case VAR_MUSICVOLUME: SetMusicVolume(scriptEng.operands[i]); break;
4426
                    case VAR_MUSICCURRENTTRACK: break;
4427
                    case VAR_KEYDOWNUP: controller[arrayVal].keyUp.down = scriptEng.operands[i]; break;
4428
                    case VAR_KEYDOWNDOWN: controller[arrayVal].keyDown.down = scriptEng.operands[i]; break;
4429
                    case VAR_KEYDOWNLEFT: controller[arrayVal].keyLeft.down = scriptEng.operands[i]; break;
4430
                    case VAR_KEYDOWNRIGHT: controller[arrayVal].keyRight.down = scriptEng.operands[i]; break;
4431
                    case VAR_KEYDOWNBUTTONA: controller[arrayVal].keyA.down = scriptEng.operands[i]; break;
4432
                    case VAR_KEYDOWNBUTTONB: controller[arrayVal].keyB.down = scriptEng.operands[i]; break;
4433
                    case VAR_KEYDOWNBUTTONC: controller[arrayVal].keyC.down = scriptEng.operands[i]; break;
4434
                    case VAR_KEYDOWNSTART: controller[arrayVal].keyStart.down = scriptEng.operands[i]; break;
4435
                    case VAR_KEYPRESSUP: controller[arrayVal].keyUp.press = scriptEng.operands[i]; break;
4436
                    case VAR_KEYPRESSDOWN: controller[arrayVal].keyDown.press = scriptEng.operands[i]; break;
4437
                    case VAR_KEYPRESSLEFT: controller[arrayVal].keyLeft.press = scriptEng.operands[i]; break;
4438
                    case VAR_KEYPRESSRIGHT: controller[arrayVal].keyRight.press = scriptEng.operands[i]; break;
4439
                    case VAR_KEYPRESSBUTTONA: controller[arrayVal].keyA.press = scriptEng.operands[i]; break;
4440
                    case VAR_KEYPRESSBUTTONB: controller[arrayVal].keyB.press = scriptEng.operands[i]; break;
4441
                    case VAR_KEYPRESSBUTTONC: controller[arrayVal].keyC.press = scriptEng.operands[i]; break;
4442
                    case VAR_KEYPRESSSTART: controller[arrayVal].keyStart.press = scriptEng.operands[i]; break;
4443
                    case VAR_MENU1SELECTION: gameMenu[0].selection1 = scriptEng.operands[i]; break;
4444
                    case VAR_MENU2SELECTION: gameMenu[1].selection1 = scriptEng.operands[i]; break;
4445
                    case VAR_TILELAYERXSIZE: stageLayouts[arrayVal].xsize = scriptEng.operands[i]; break;
4446
                    case VAR_TILELAYERYSIZE: stageLayouts[arrayVal].ysize = scriptEng.operands[i]; break;
4447
                    case VAR_TILELAYERTYPE: stageLayouts[arrayVal].type = scriptEng.operands[i]; break;
4448
                    case VAR_TILELAYERANGLE:
4449
                        stageLayouts[arrayVal].angle = scriptEng.operands[i];
4450
                        if (stageLayouts[arrayVal].angle < 0)
4451
                            stageLayouts[arrayVal].angle += 0x200;
4452
                        stageLayouts[arrayVal].angle &= 0x1FF;
4453
                        break;
4454
                    case VAR_TILELAYERXPOS: stageLayouts[arrayVal].xpos = scriptEng.operands[i]; break;
4455
                    case VAR_TILELAYERYPOS: stageLayouts[arrayVal].ypos = scriptEng.operands[i]; break;
4456
                    case VAR_TILELAYERZPOS: stageLayouts[arrayVal].zpos = scriptEng.operands[i]; break;
4457
                    case VAR_TILELAYERPARALLAXFACTOR: stageLayouts[arrayVal].parallaxFactor = scriptEng.operands[i]; break;
4458
                    case VAR_TILELAYERSCROLLSPEED: stageLayouts[arrayVal].scrollSpeed = scriptEng.operands[i]; break;
4459
                    case VAR_TILELAYERSCROLLPOS: stageLayouts[arrayVal].scrollPos = scriptEng.operands[i]; break;
4460
                    case VAR_TILELAYERDEFORMATIONOFFSET:
4461
                        stageLayouts[arrayVal].deformationOffset = scriptEng.operands[i];
4462
                        stageLayouts[arrayVal].deformationOffset &= 0xFFu;
4463
                        break;
4464
                    case VAR_TILELAYERDEFORMATIONOFFSETW:
4465
                        stageLayouts[arrayVal].deformationOffsetW = scriptEng.operands[i];
4466
                        stageLayouts[arrayVal].deformationOffsetW &= 0xFFu;
4467
                        break;
4468
                    case VAR_HPARALLAXPARALLAXFACTOR: hParallax.parallaxFactor[arrayVal] = scriptEng.operands[i]; break;
4469
                    case VAR_HPARALLAXSCROLLSPEED: hParallax.scrollSpeed[arrayVal] = scriptEng.operands[i]; break;
4470
                    case VAR_HPARALLAXSCROLLPOS: hParallax.scrollPos[arrayVal] = scriptEng.operands[i]; break;
4471
                    case VAR_VPARALLAXPARALLAXFACTOR: vParallax.parallaxFactor[arrayVal] = scriptEng.operands[i]; break;
4472
                    case VAR_VPARALLAXSCROLLSPEED: vParallax.scrollSpeed[arrayVal] = scriptEng.operands[i]; break;
4473
                    case VAR_VPARALLAXSCROLLPOS: vParallax.scrollPos[arrayVal] = scriptEng.operands[i]; break;
4474
                    case VAR_3DSCENENOVERTICES: vertexCount = scriptEng.operands[i]; break;
4475
                    case VAR_3DSCENENOFACES: faceCount = scriptEng.operands[i]; break;
4476
                    case VAR_VERTEXBUFFERX: vertexBuffer[arrayVal].x = scriptEng.operands[i]; break;
4477
                    case VAR_VERTEXBUFFERY: vertexBuffer[arrayVal].y = scriptEng.operands[i]; break;
4478
                    case VAR_VERTEXBUFFERZ: vertexBuffer[arrayVal].z = scriptEng.operands[i]; break;
4479
                    case VAR_VERTEXBUFFERU: vertexBuffer[arrayVal].u = scriptEng.operands[i]; break;
4480
                    case VAR_VERTEXBUFFERV: vertexBuffer[arrayVal].v = scriptEng.operands[i]; break;
4481
                    case VAR_FACEBUFFERA: faceBuffer[arrayVal].a = scriptEng.operands[i]; break;
4482
                    case VAR_FACEBUFFERB: faceBuffer[arrayVal].b = scriptEng.operands[i]; break;
4483
                    case VAR_FACEBUFFERC: faceBuffer[arrayVal].c = scriptEng.operands[i]; break;
4484
                    case VAR_FACEBUFFERD: faceBuffer[arrayVal].d = scriptEng.operands[i]; break;
4485
                    case VAR_FACEBUFFERFLAG: faceBuffer[arrayVal].flag = scriptEng.operands[i]; break;
4486
                    case VAR_FACEBUFFERCOLOR: faceBuffer[arrayVal].color = scriptEng.operands[i]; break;
4487
                    case VAR_3DSCENEPROJECTIONX: projectionX = scriptEng.operands[i]; break;
4488
                    case VAR_3DSCENEPROJECTIONY: projectionY = scriptEng.operands[i]; break;
4489
                    case VAR_ENGINESTATE: gameMode = scriptEng.operands[i]; break;
4490
                    case VAR_STAGEDEBUGMODE: debugMode = scriptEng.operands[i]; break;
4491
                    case VAR_ENGINEMESSAGE: break;
4492
                    case VAR_SAVERAM: saveRAM[arrayVal] = scriptEng.operands[i]; break;
4493
                    case VAR_ENGINELANGUAGE: language = scriptEng.operands[i]; break;
4494
                    case VAR_OBJECTSPRITESHEET: {
4495
                        objectScriptList[objectEntityList[arrayVal].type].spriteSheetID = scriptEng.operands[i];
4496
                        break;
4497
                    }
4498
                    case VAR_ENGINEONLINEACTIVE: break;
4499
                    case VAR_ENGINEFRAMESKIPTIMER: break;
4500
                    case VAR_ENGINEFRAMESKIPSETTING: break;
4501
                    case VAR_ENGINESFXVOLUME:
4502
                        sfxVolume = scriptEng.operands[i];
4503
                        // SetGameVolumes(bgmVolume, sfxVolume);
4504
                        break;
4505
                    case VAR_ENGINEBGMVOLUME:
4506
                        bgmVolume = scriptEng.operands[i];
4507
                        // SetGameVolumes(bgmVolume, sfxVolume);
4508
                        break;
4509
                    case VAR_ENGINEPLATFORMID: break;
4510
                    case VAR_ENGINETRIALMODE: break;
4511
                    case VAR_KEYPRESSANYSTART: break;
4512
#if LEGACY_RETRO_USE_HAPTICS
4513
                    case VAR_ENGINEHAPTICSENABLED: hapticsEnabled = scriptEng.operands[i]; break;
4514
#endif
4515
                }
4516
            }
4517
            else if (opcodeType == SCRIPTVAR_INTCONST) { // int32 constant
4518
                scriptCodePtr++;
4519
            }
4520
            else if (opcodeType == SCRIPTVAR_STRCONST) { // string constant
4521
                int32 strLen = scriptCode[scriptCodePtr++];
4522
                for (int32 c = 0; c < strLen; ++c) {
4523
                    switch (c % 4) {
4524
                        case 0: break;
4525
                        case 1: break;
4526
                        case 2: break;
4527
                        case 3: ++scriptCodePtr; break;
4528
                        default: break;
4529
                    }
4530
                }
4531
                scriptCodePtr++;
4532
            }
4533
        }
4534
    }
4535
}
4536

4537
Product

Resources

Company
