CoCalc -- SceneLegacyv4.cpp

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

2
#if RETRO_USE_MOD_LOADER
3
namespace RSDK
4
{
5
namespace Legacy
6
{
7
namespace v4
8
{
9

10
bool32 loadGlobalScripts = false; // stored here so I can use it later
11
int32 globalObjCount     = 0;
12

13
} // namespace v4
14
} // namespace Legacy
15
} // namespace RSDK
16
#endif
17

18
void RSDK::Legacy::v4::InitFirstStage(void)
19
{
20
    xScrollOffset = 0;
21
    yScrollOffset = 0;
22
    StopMusic();
23
    fadeMode = 0;
24
    ClearGraphicsData();
25
    ClearAnimationData();
26
    activePalette = fullPalette[0];
27
    stageMode     = STAGEMODE_LOAD;
28
    gameMode      = ENGINE_MAINGAME;
29
}
30

31
void RSDK::Legacy::v4::ProcessStage(void)
32
{
33
#if !RETRO_USE_ORIGINAL_CODE
34
    debugHitboxCount = 0;
35
#endif
36

37
    switch (stageMode) {
38
        case STAGEMODE_LOAD: // Startup
39
            SetActivePalette(0, 0, 256);
40
            gameMenu[0].visibleRowOffset = 0;
41
            gameMenu[1].visibleRowOffset = 0;
42
            videoSettings.dimLimit       = (5 * 60) * videoSettings.refreshRate;
43
            fadeMode                     = 0;
44
            InitCameras();
45
            cameraShift       = 0;
46
            cameraLockedY     = 0;
47
            xScrollOffset     = 0;
48
            yScrollOffset     = 0;
49
            cameraShakeX      = 0;
50
            cameraShakeY      = 0;
51
            vertexCount       = 0;
52
            faceCount         = 0;
53
            frameCounter      = 0;
54
            pauseEnabled      = false;
55
            timeEnabled       = false;
56
            stageMilliseconds = 0;
57
            stageSeconds      = 0;
58
            stageMinutes      = 0;
59
            stageMode         = STAGEMODE_NORMAL;
60

61
#if RSDK_AUTOBUILD
62
            // Prevent playing as Amy if on autobuilds
63
            if (GetGlobalVariableByName("PLAYER_AMY") && playerListPos == GetGlobalVariableByName("PLAYER_AMY"))
64
                playerListPos = 0;
65
            else if (GetGlobalVariableByName("PLAYER_AMY_TAILS") && playerListPos == GetGlobalVariableByName("PLAYER_AMY_TAILS"))
66
                playerListPos = 0;
67
#endif
68

69
#if RETRO_USE_MOD_LOADER
70
            if (devMenu.modsChanged)
71
                RefreshModFolders();
72
#endif
73
            ResetBackgroundSettings();
74
            LoadStageFiles();
75
            break;
76

77
        case STAGEMODE_NORMAL:
78
            if (fadeMode > 0)
79
                fadeMode--;
80

81
            lastXSize = -1;
82
            lastYSize = -1;
83

84
            ProcessInput();
85

86
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
87
                stageMode += STAGEMODE_STEPOVER;
88
                PauseSound();
89
            }
90

91
            ProcessSceneTimer();
92

93
            // Update
94
            ProcessObjects();
95
            HandleCameras();
96
            ProcessParallaxAutoScroll();
97

98
#if !RETRO_USE_ORIGINAL_CODE
99
            for (int32 i = 1; i < engine.gameSpeed; ++i) {
100
                ProcessSceneTimer();
101

102
                // Update
103
                ProcessObjects();
104
                HandleCameras();
105
                ProcessParallaxAutoScroll();
106
            }
107
#endif
108

109
            currentScreen             = &screens[0];
110
            sceneInfo.currentScreenID = 0;
111
            DrawStageGFX();
112
            break;
113

114
        case STAGEMODE_PAUSED:
115
            if (fadeMode > 0)
116
                fadeMode--;
117

118
            lastXSize = -1;
119
            lastYSize = -1;
120

121
            ProcessInput();
122

123
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
124
                stageMode += STAGEMODE_STEPOVER;
125
                PauseSound();
126
            }
127

128
            // Update
129
            ProcessPausedObjects();
130

131
#if !RETRO_USE_ORIGINAL_CODE
132
            for (int32 i = 1; i < engine.gameSpeed; ++i) {
133
                ProcessPausedObjects();
134
            }
135
#endif
136

137
            for (int32 s = 0; s < videoSettings.screenCount; ++s) {
138
                currentScreen             = &screens[s];
139
                sceneInfo.currentScreenID = s;
140

141
                DrawObjectList(0);
142
                DrawObjectList(1);
143
                DrawObjectList(2);
144
                DrawObjectList(3);
145
                DrawObjectList(4);
146
                DrawObjectList(5);
147
                DrawObjectList(7); // ???
148
                DrawObjectList(6);
149
            }
150

151
            currentScreen             = &screens[0];
152
            sceneInfo.currentScreenID = 0;
153

154
#if !RETRO_USE_ORIGINAL_CODE
155
            DrawDebugOverlays();
156
#endif
157
            break;
158

159
        case STAGEMODE_FROZEN:
160
            if (fadeMode > 0)
161
                fadeMode--;
162

163
            lastXSize = -1;
164
            lastYSize = -1;
165

166
            ProcessInput();
167

168
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
169
                stageMode += STAGEMODE_STEPOVER;
170
                PauseSound();
171
            }
172

173
            // Update
174
            ProcessFrozenObjects();
175
            HandleCameras();
176

177
#if !RETRO_USE_ORIGINAL_CODE
178
            for (int32 i = 1; i < engine.gameSpeed; ++i) {
179
                ProcessFrozenObjects();
180
                HandleCameras();
181
            }
182
#endif
183

184
            currentScreen             = &screens[0];
185
            sceneInfo.currentScreenID = 0;
186
            DrawStageGFX();
187
            break;
188

189
        case STAGEMODE_2P:
190
            if (fadeMode > 0)
191
                fadeMode--;
192

193
            lastXSize = -1;
194
            lastYSize = -1;
195

196
            ProcessInput();
197

198
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
199
                stageMode += STAGEMODE_STEPOVER;
200
                PauseSound();
201
            }
202

203
            ProcessSceneTimer();
204

205
            // Update
206
            Process2PObjects();
207
            ProcessParallaxAutoScroll();
208

209
#if !RETRO_USE_ORIGINAL_CODE
210
            for (int32 i = 1; i < engine.gameSpeed; ++i) {
211
                ProcessSceneTimer();
212

213
                Process2PObjects();
214
                ProcessParallaxAutoScroll();
215
            }
216
#endif
217

218
            for (int32 s = 0; s < videoSettings.screenCount; ++s) {
219
                currentScreen             = &screens[s];
220
                sceneInfo.currentScreenID = s;
221

222
                HandleCameras();
223
                DrawStageGFX();
224
            }
225

226
            currentScreen             = &screens[0];
227
            sceneInfo.currentScreenID = 0;
228

229
            break;
230

231
        case STAGEMODE_NORMAL + STAGEMODE_STEPOVER:
232
            if (fadeMode > 0)
233
                fadeMode--;
234

235
            lastXSize = -1;
236
            lastYSize = -1;
237

238
            ProcessInput();
239

240
            if (controller[CONT_ANY].keyC.press || engine.frameStep) {
241
#if !RETRO_USE_ORIGINAL_CODE
242
                if (!engine.frameStep) {
243
                    for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
244
                }
245
                engine.frameStep = false;
246
#else
247
                for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
248
#endif
249

250
                ProcessSceneTimer();
251

252
                ProcessObjects();
253
                HandleCameras();
254

255
                DrawStageGFX();
256
                ProcessParallaxAutoScroll();
257

258
#if !RETRO_USE_ORIGINAL_CODE
259
                engine.frameStep = false;
260
#endif
261
            }
262

263
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
264
                stageMode -= STAGEMODE_STEPOVER;
265
                ResumeSound();
266
            }
267
            break;
268

269
        case STAGEMODE_PAUSED + STAGEMODE_STEPOVER:
270
            if (fadeMode > 0)
271
                fadeMode--;
272

273
            lastXSize = -1;
274
            lastYSize = -1;
275

276
            ProcessInput();
277

278
            if (controller[CONT_ANY].keyC.press || engine.frameStep) {
279
#if !RETRO_USE_ORIGINAL_CODE
280
                if (!engine.frameStep) {
281
                    for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
282
                }
283
                engine.frameStep = false;
284
#else
285
                for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
286
#endif
287

288
                ProcessPausedObjects();
289

290
                DrawObjectList(0);
291
                DrawObjectList(1);
292
                DrawObjectList(2);
293
                DrawObjectList(3);
294
                DrawObjectList(4);
295
                DrawObjectList(5);
296
                DrawObjectList(7); // ???
297
                DrawObjectList(6);
298

299
#if !RETRO_USE_ORIGINAL_CODE
300
                DrawDebugOverlays();
301
#endif
302
            }
303

304
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
305
                stageMode -= STAGEMODE_STEPOVER;
306
                ResumeSound();
307
            }
308
            break;
309

310
        case STAGEMODE_FROZEN + STAGEMODE_STEPOVER:
311
            if (fadeMode > 0)
312
                fadeMode--;
313

314
            lastXSize = -1;
315
            lastYSize = -1;
316

317
            ProcessInput();
318

319
            if (controller[CONT_ANY].keyC.press || engine.frameStep) {
320
#if !RETRO_USE_ORIGINAL_CODE
321
                if (!engine.frameStep) {
322
                    for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
323
                }
324
                engine.frameStep = false;
325
#else
326
                for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
327
#endif
328

329
                // Update
330
                ProcessFrozenObjects();
331
                HandleCameras();
332

333
                DrawStageGFX();
334
            }
335

336
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
337
                stageMode -= STAGEMODE_STEPOVER;
338
                ResumeSound();
339
            }
340
            break;
341

342
        case STAGEMODE_2P + STAGEMODE_STEPOVER:
343
            if (fadeMode > 0)
344
                fadeMode--;
345

346
            lastXSize = -1;
347
            lastYSize = -1;
348

349
            ProcessInput();
350

351
            if (controller[CONT_ANY].keyC.press || engine.frameStep) {
352
#if !RETRO_USE_ORIGINAL_CODE
353
                if (!engine.frameStep) {
354
                    for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
355
                }
356
                engine.frameStep = false;
357
#else
358
                for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
359
#endif
360

361
                ProcessSceneTimer();
362

363
                // Update
364
                Process2PObjects();
365
                HandleCameras();
366

367
                DrawStageGFX();
368
                ProcessParallaxAutoScroll();
369
            }
370

371
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
372
                stageMode -= STAGEMODE_STEPOVER;
373
                ResumeSound();
374
            }
375
            break;
376
    }
377
}
378

379
void RSDK::Legacy::v4::HandleCameras()
380
{
381
    currentCamera = &cameras[sceneInfo.currentScreenID];
382
    if (currentCamera->target >= LEGACY_v4_ENTITY_COUNT)
383
        return;
384

385
    if (currentCamera->enabled == 1) {
386
        switch (currentCamera->style) {
387
            case CAMERASTYLE_FOLLOW: SetPlayerScreenPosition(&objectEntityList[currentCamera->target]); break;
388
            case CAMERASTYLE_EXTENDED:
389
            case CAMERASTYLE_EXTENDED_OFFSET_L:
390
            case CAMERASTYLE_EXTENDED_OFFSET_R: SetPlayerScreenPositionCDStyle(&objectEntityList[currentCamera->target]); break;
391
            case CAMERASTYLE_HLOCKED: SetPlayerHLockedScreenPosition(&objectEntityList[currentCamera->target]); break;
392
            case CAMERASTYLE_FIXED: SetPlayerScreenPositionFixed(&objectEntityList[currentCamera->target]); break;
393
            case CAMERASTYLE_STATIC: SetPlayerScreenPositionStatic(&objectEntityList[currentCamera->target]); break;
394
            default: break;
395
        }
396
    }
397
    else {
398
        SetPlayerLockedScreenPosition(&objectEntityList[currentCamera->target]);
399
    }
400
}
401

402
void RSDK::Legacy::v4::ProcessParallaxAutoScroll()
403
{
404
    for (int32 i = 0; i < hParallax.entryCount; ++i) hParallax.scrollPos[i] += hParallax.scrollSpeed[i];
405
    for (int32 i = 0; i < vParallax.entryCount; ++i) vParallax.scrollPos[i] += vParallax.scrollSpeed[i];
406
}
407

408
void RSDK::Legacy::v4::LoadStageFiles()
409
{
410
    int32 scriptID = 1;
411
    char strBuffer[0x100];
412

413
    FileInfo info;
414
    InitFileInfo(&info);
415

416
    if (!CheckCurrentStageFolder()) {
417
        PrintLog(PRINT_NORMAL, "Loading Scene %s - %s", sceneInfo.listCategory[sceneInfo.activeCategory].name,
418
                 sceneInfo.listData[sceneInfo.listPos].name);
419

420
        // Unload stage sfx & audio channels
421
        ClearStageSfx();
422

423
        ClearScriptData();
424

425
        for (int32 i = LEGACY_SURFACE_COUNT; i > 0; i--) RemoveGraphicsFile((char *)"", i - 1);
426

427
#if RETRO_USE_MOD_LOADER
428
        loadGlobalScripts = false;
429
#else
430
        bool32 loadGlobalScripts = false;
431
#endif
432

433
        InitFileInfo(&info);
434
        if (LoadStageFile("StageConfig.bin", &info)) {
435
            loadGlobalScripts = ReadInt8(&info);
436
            CloseFile(&info);
437
        }
438

439
        InitFileInfo(&info);
440
        if (loadGlobalScripts && LoadFile(&info, "Data/Game/GameConfig.bin", FMODE_RB)) {
441
            ReadString(&info, strBuffer); // Title
442
            ReadString(&info, strBuffer); // Subtitle
443

444
            uint8 buf[3];
445
            for (int32 c = 0; c < 0x60; ++c) {
446
                ReadBytes(&info, buf, 3);
447
                SetPaletteEntry(-1, c, buf[0], buf[1], buf[2]);
448
            }
449

450
            uint8 globalObjectCount = ReadInt8(&info);
451
            for (uint8 i = 0; i < globalObjectCount; ++i) {
452
                ReadString(&info, strBuffer);
453
                SetObjectTypeName(strBuffer, scriptID + i);
454
            }
455

456
#if RETRO_USE_MOD_LOADER && LEGACY_RETRO_USE_COMPILER
457
            for (uint8 i = 0; i < modObjCount && loadGlobalScripts; ++i) {
458
                SetObjectTypeName(modTypeNames[i], globalObjectCount + i + 1);
459
            }
460
#endif
461

462
#if LEGACY_RETRO_USE_COMPILER
463
#if RETRO_USE_MOD_LOADER
464
            bool32 bytecodeExists = false;
465
            FileInfo bytecodeInfo;
466
            InitFileInfo(&bytecodeInfo);
467

468
            if (LoadFile(&bytecodeInfo, "Bytecode/GlobalCode.bin", FMODE_RB)) {
469
                bytecodeExists = true;
470
                CloseFile(&bytecodeInfo);
471
            }
472

473
            if (bytecodeExists && !modSettings.forceScripts) {
474
#else
475
            if (usingBytecode) {
476
#endif
477
                LoadBytecode(scriptID, true);
478
                scriptID += globalObjectCount;
479
            }
480
            else {
481
                for (uint8 i = 0; i < globalObjectCount; ++i) {
482
                    ReadString(&info, strBuffer);
483
                    ParseScriptFile(strBuffer, scriptID++);
484

485
                    if (gameMode == ENGINE_SCRIPTERROR)
486
                        return;
487
                }
488
            }
489
#else
490
            LoadBytecode(scriptID, true);
491
            scriptID += globalObjectCount;
492
#endif
493
            CloseFile(&info);
494

495
#if RETRO_USE_MOD_LOADER
496
            LoadGameXML(true);
497
#endif
498

499
#if RETRO_USE_MOD_LOADER && LEGACY_RETRO_USE_COMPILER
500
            globalObjCount = globalObjectCount;
501
            for (uint8 i = 0; i < modObjCount && loadGlobalScripts; ++i) {
502
                SetObjectTypeName(modTypeNames[i], scriptID);
503

504
                ParseScriptFile(modScriptPaths[i], scriptID++);
505
                if (gameMode == ENGINE_SCRIPTERROR)
506
                    return;
507
            }
508
#endif
509
        }
510

511
        InitFileInfo(&info);
512
        if (LoadStageFile("StageConfig.bin", &info)) {
513
            ReadInt8(&info); // Load Globals
514

515
            uint8 clr[3];
516
            for (int32 i = 0x60; i < 0x80; ++i) {
517
                ReadBytes(&info, clr, 3);
518
                SetPaletteEntry(-1, i, clr[0], clr[1], clr[2]);
519
            }
520

521
            stageSFXCount = ReadInt8(&info);
522
            for (uint8 i = 0; i < stageSFXCount; ++i) {
523
                ReadString(&info, strBuffer);
524
                SetSfxName(strBuffer, i + globalSFXCount);
525
            }
526

527
            for (uint8 i = 0; i < stageSFXCount; ++i) {
528
                ReadString(&info, strBuffer);
529

530
                RSDK::Legacy::LoadSfx(strBuffer, globalSFXCount + i, SCOPE_STAGE);
531
            }
532

533
            uint8 stageObjectCount = ReadInt8(&info);
534
            for (uint8 i = 0; i < stageObjectCount; ++i) {
535
                ReadString(&info, strBuffer);
536

537
                SetObjectTypeName(strBuffer, scriptID + i);
538
            }
539

540
#if LEGACY_RETRO_USE_COMPILER
541
#if RETRO_USE_MOD_LOADER
542
            char scriptPath[0x40];
543
            switch (sceneInfo.activeCategory) {
544
                case STAGELIST_PRESENTATION:
545
                case STAGELIST_REGULAR:
546
                case STAGELIST_BONUS:
547
                case STAGELIST_SPECIAL:
548
                    StrCopy(scriptPath, "Bytecode/");
549
                    StrAdd(scriptPath, sceneInfo.listData[sceneInfo.listPos].folder);
550
                    StrAdd(scriptPath, ".bin");
551
                    break;
552
                default: break;
553
            }
554

555
            bool32 bytecodeExists = false;
556
            FileInfo bytecodeInfo;
557
            InitFileInfo(&bytecodeInfo);
558
            if (LoadFile(&bytecodeInfo, scriptPath, FMODE_RB)) {
559
                bytecodeExists = true;
560
                CloseFile(&bytecodeInfo);
561
            }
562

563
            if (bytecodeExists && !modSettings.forceScripts) {
564
#else
565
            if (usingBytecode) {
566
#endif
567
                for (uint8 i = 0; i < stageObjectCount; ++i) {
568
                    ReadString(&info, strBuffer);
569
                }
570

571
                LoadBytecode(scriptID, false);
572
            }
573
            else {
574
                for (uint8 i = 0; i < stageObjectCount; ++i) {
575
                    ReadString(&info, strBuffer);
576
                    ParseScriptFile(strBuffer, scriptID + i);
577

578
                    if (gameMode == ENGINE_SCRIPTERROR)
579
                        return;
580
                }
581
            }
582
#else
583
            for (uint8 i = 0; i < stageObjectCount; ++i) {
584
                ReadString(&info, strBuffer);
585
            }
586
            LoadBytecode(scriptID, false);
587
#endif
588
            CloseFile(&info);
589
        }
590

591
        LoadStageGIFFile();
592
        LoadStageCollisions();
593
        LoadStageBackground();
594
    }
595
    else {
596
        PrintLog(PRINT_NORMAL, "Reloading Scene %s - %s", sceneInfo.listCategory[sceneInfo.activeCategory].name,
597
                 sceneInfo.listData[sceneInfo.listPos].name);
598
    }
599
    LoadStageChunks();
600

601
    for (int32 i = 0; i < LEGACY_TRACK_COUNT; ++i) SetMusicTrack("", i, false, 0);
602

603
    memset(objectEntityList, 0, LEGACY_v4_ENTITY_COUNT * sizeof(Entity));
604
    for (int32 i = 0; i < LEGACY_v4_ENTITY_COUNT; ++i) {
605
        objectEntityList[i].drawOrder          = 3;
606
        objectEntityList[i].scale              = 512;
607
        objectEntityList[i].objectInteractions = true;
608
        objectEntityList[i].visible            = true;
609
        objectEntityList[i].tileCollisions     = true;
610
    }
611

612
    LoadActLayout();
613
    Init3DFloorBuffer(0);
614
    ProcessStartupObjects();
615
}
616
void RSDK::Legacy::v4::LoadActLayout()
617
{
618
    FileInfo info;
619
    InitFileInfo(&info);
620

621
    for (int32 a = 0; a < 4; ++a) activeTileLayers[a] = 9; // disables missing scenes from rendering
622

623
    if (LoadActFile(".bin", &info)) {
624
        int32 tCardWordLen = ReadInt8(&info);
625
        titleCardWord2     = tCardWordLen;
626
        for (int32 i = 0; i < tCardWordLen; ++i) {
627
            titleCardText[i] = ReadInt8(&info);
628
            if (titleCardText[i] == '-')
629
                titleCardWord2 = (uint8)(i + 1);
630
        }
631
        titleCardText[tCardWordLen] = '\0';
632

633
        // READ TILELAYER
634
        ReadBytes(&info, activeTileLayers, 4);
635
        tLayerMidPoint = ReadInt8(&info);
636

637
        stageLayouts[0].xsize = ReadInt8(&info);
638
        ReadInt8(&info); // Unused
639

640
        stageLayouts[0].ysize = ReadInt8(&info);
641
        ReadInt8(&info); // Unused
642

643
        curXBoundary1 = 0;
644
        newXBoundary1 = 0;
645
        curYBoundary1 = 0;
646
        newYBoundary1 = 0;
647
        curXBoundary2 = stageLayouts[0].xsize << 7;
648
        curYBoundary2 = stageLayouts[0].ysize << 7;
649
        waterLevel    = curYBoundary2 + 128;
650
        newXBoundary2 = stageLayouts[0].xsize << 7;
651
        newYBoundary2 = stageLayouts[0].ysize << 7;
652

653
        memset(stageLayouts[0].tiles, 0, LEGACY_TILELAYER_CHUNK_COUNT * sizeof(uint16));
654
        memset(stageLayouts[0].lineScroll, 0, 0x7FFF);
655

656
        for (int32 y = 0; y < stageLayouts[0].ysize; ++y) {
657
            uint16 *tiles = &stageLayouts[0].tiles[(y * LEGACY_TILELAYER_CHUNK_H)];
658
            for (int32 x = 0; x < stageLayouts[0].xsize; ++x) {
659
                tiles[x] = ReadInt8(&info);
660
                tiles[x] |= ReadInt8(&info) << 8;
661
            }
662
        }
663

664
        // READ OBJECTS
665
        int32 objectCount = ReadInt8(&info);
666
        objectCount |= ReadInt8(&info) << 8;
667
#if !RETRO_USE_ORIGINAL_CODE
668
        if (objectCount > 0x400)
669
            PrintLog(PRINT_NORMAL, "WARNING: object count %d exceeds the object limit", objectCount);
670
#endif
671

672
#if RETRO_USE_MOD_LOADER
673
        int32 offsetCount = 0;
674
        for (int32 m = 0; m < modObjCount; ++m)
675
            if (modScriptFlags[m])
676
                ++offsetCount;
677
#endif
678

679
        Entity *object = &objectEntityList[32];
680
        for (int32 i = 0; i < objectCount; ++i) {
681
            int32 activeVars = ReadInt8(&info);
682
            activeVars |= ReadInt8(&info) << 8;
683

684
            object->type = ReadInt8(&info);
685

686
#if RETRO_USE_MOD_LOADER
687
            if (loadGlobalScripts && offsetCount && object->type > globalObjCount)
688
                object->type += offsetCount; // offset it by our mod count
689
#endif
690

691
            object->propertyValue = ReadInt8(&info);
692

693
            object->xpos = ReadInt8(&info);
694
            object->xpos |= ReadInt8(&info) << 8;
695
            object->xpos |= ReadInt8(&info) << 16;
696
            object->xpos |= ReadInt8(&info) << 24;
697

698
            object->ypos = ReadInt8(&info);
699
            object->ypos |= ReadInt8(&info) << 8;
700
            object->ypos |= ReadInt8(&info) << 16;
701
            object->ypos |= ReadInt8(&info) << 24;
702

703
            if (activeVars & 0x1) {
704
                object->state = ReadInt8(&info);
705
                object->state |= ReadInt8(&info) << 8;
706
                object->state |= ReadInt8(&info) << 16;
707
                object->state |= ReadInt8(&info) << 24;
708
            }
709

710
            if (activeVars & 0x2)
711
                object->direction = ReadInt8(&info);
712

713
            if (activeVars & 0x4) {
714
                object->scale = ReadInt8(&info);
715
                object->scale |= ReadInt8(&info) << 8;
716
                object->scale |= ReadInt8(&info) << 16;
717
                object->scale |= ReadInt8(&info) << 24;
718
            }
719

720
            if (activeVars & 0x8) {
721
                object->rotation = ReadInt8(&info);
722
                object->rotation |= ReadInt8(&info) << 8;
723
                object->rotation |= ReadInt8(&info) << 16;
724
                object->rotation |= ReadInt8(&info) << 24;
725
            }
726

727
            if (activeVars & 0x10)
728
                object->drawOrder = ReadInt8(&info);
729

730
            if (activeVars & 0x20)
731
                object->priority = ReadInt8(&info);
732

733
            if (activeVars & 0x40)
734
                object->alpha = ReadInt8(&info);
735

736
            if (activeVars & 0x80)
737
                object->animation = ReadInt8(&info);
738

739
            if (activeVars & 0x100) {
740
                object->animationSpeed = ReadInt8(&info);
741
                object->animationSpeed |= ReadInt8(&info) << 8;
742
                object->animationSpeed |= ReadInt8(&info) << 16;
743
                object->animationSpeed |= ReadInt8(&info) << 24;
744
            }
745

746
            if (activeVars & 0x200)
747
                object->frame = ReadInt8(&info);
748

749
            if (activeVars & 0x400)
750
                object->inkEffect = ReadInt8(&info);
751

752
            if (activeVars & 0x800) {
753
                object->values[0] = ReadInt8(&info);
754
                object->values[0] |= ReadInt8(&info) << 8;
755
                object->values[0] |= ReadInt8(&info) << 16;
756
                object->values[0] |= ReadInt8(&info) << 24;
757
            }
758

759
            if (activeVars & 0x1000) {
760
                object->values[1] = ReadInt8(&info);
761
                object->values[1] |= ReadInt8(&info) << 8;
762
                object->values[1] |= ReadInt8(&info) << 16;
763
                object->values[1] |= ReadInt8(&info) << 24;
764
            }
765

766
            if (activeVars & 0x2000) {
767
                object->values[2] = ReadInt8(&info);
768
                object->values[2] |= ReadInt8(&info) << 8;
769
                object->values[2] |= ReadInt8(&info) << 16;
770
                object->values[2] |= ReadInt8(&info) << 24;
771
            }
772

773
            if (activeVars & 0x4000) {
774
                object->values[3] = ReadInt8(&info);
775
                object->values[3] |= ReadInt8(&info) << 8;
776
                object->values[3] |= ReadInt8(&info) << 16;
777
                object->values[3] |= ReadInt8(&info) << 24;
778
            }
779

780
            ++object;
781
        }
782

783
        CloseFile(&info);
784
    }
785

786
    stageLayouts[0].type = LAYER_HSCROLL;
787
}
788
void RSDK::Legacy::v4::LoadStageBackground()
789
{
790
    for (int32 i = 0; i < LEGACY_LAYER_COUNT; ++i) {
791
        stageLayouts[i].type               = LAYER_NOSCROLL;
792
        stageLayouts[i].deformationOffset  = 0;
793
        stageLayouts[i].deformationOffsetW = 0;
794
    }
795

796
    for (int32 i = 0; i < LEGACY_PARALLAX_COUNT; ++i) {
797
        hParallax.scrollPos[i] = 0;
798
        vParallax.scrollPos[i] = 0;
799
    }
800

801
    FileInfo info;
802
    InitFileInfo(&info);
803
    if (LoadStageFile("Backgrounds.bin", &info)) {
804
        uint8 layerCount = ReadInt8(&info);
805

806
        hParallax.entryCount = ReadInt8(&info);
807
        for (uint8 i = 0; i < hParallax.entryCount; ++i) {
808
            hParallax.parallaxFactor[i] = ReadInt8(&info);
809
            hParallax.parallaxFactor[i] |= ReadInt8(&info) << 8;
810

811
            hParallax.scrollSpeed[i] = ReadInt8(&info) << 10;
812

813
            hParallax.scrollPos[i] = 0;
814

815
            hParallax.deform[i] = ReadInt8(&info);
816
        }
817

818
        vParallax.entryCount = ReadInt8(&info);
819
        for (uint8 i = 0; i < vParallax.entryCount; ++i) {
820
            vParallax.parallaxFactor[i] = ReadInt8(&info);
821
            vParallax.parallaxFactor[i] |= ReadInt8(&info) << 8;
822

823
            vParallax.scrollSpeed[i] = ReadInt8(&info) << 10;
824

825
            vParallax.scrollPos[i] = 0;
826

827
            vParallax.deform[i] = ReadInt8(&info);
828
        }
829

830
        for (uint8 i = 1; i < layerCount + 1; ++i) {
831
            stageLayouts[i].xsize = ReadInt8(&info);
832
            ReadInt8(&info); // unused
833

834
            stageLayouts[i].ysize = ReadInt8(&info);
835
            ReadInt8(&info);
836

837
            stageLayouts[i].type = ReadInt8(&info);
838

839
            stageLayouts[i].parallaxFactor = ReadInt8(&info);
840
            stageLayouts[i].parallaxFactor |= ReadInt8(&info) << 8;
841

842
            stageLayouts[i].scrollSpeed = ReadInt8(&info) << 10;
843
            stageLayouts[i].scrollPos   = 0;
844

845
            memset(stageLayouts[i].tiles, 0, LEGACY_TILELAYER_CHUNK_COUNT * sizeof(uint16));
846
            uint8 *lineScrollPtr = stageLayouts[i].lineScroll;
847
            memset(stageLayouts[i].lineScroll, 0, 0x7FFF);
848

849
            // Read Line Scroll
850
            uint8 buf[3];
851
            while (true) {
852
                buf[0] = ReadInt8(&info);
853

854
                if (buf[0] == 0xFF) {
855
                    buf[1] = ReadInt8(&info);
856
                    if (buf[1] == 0xFF) {
857
                        break;
858
                    }
859
                    else {
860
                        buf[2]      = ReadInt8(&info);
861
                        int32 index = buf[1];
862
                        int32 cnt   = buf[2] - 1;
863
                        for (int32 c = 0; c < cnt; ++c) *lineScrollPtr++ = index;
864
                    }
865
                }
866
                else {
867
                    *lineScrollPtr++ = buf[0];
868
                }
869
            }
870

871
            // Read Layout
872
            for (int32 y = 0; y < stageLayouts[i].ysize; ++y) {
873
                uint16 *chunks = &stageLayouts[i].tiles[y * LEGACY_TILELAYER_CHUNK_H];
874
                for (int32 x = 0; x < stageLayouts[i].xsize; ++x) {
875
                    *chunks = ReadInt8(&info);
876
                    *chunks |= ReadInt8(&info) << 8;
877

878
                    ++chunks;
879
                }
880
            }
881
        }
882

883
        CloseFile(&info);
884
    }
885
}
886

887
void RSDK::Legacy::v4::SetPlayerScreenPosition(Entity *target)
888
{
889
    int32 targetX = target->xpos >> 16;
890
    int32 targetY = currentCamera->adjustY + (target->ypos >> 16);
891

892
    if (newYBoundary1 > curYBoundary1) {
893
        if (newYBoundary1 >= yScrollOffset)
894
            curYBoundary1 = yScrollOffset;
895
        else
896
            curYBoundary1 = newYBoundary1;
897
    }
898

899
    if (newYBoundary1 < curYBoundary1) {
900
        if (curYBoundary1 >= yScrollOffset)
901
            --curYBoundary1;
902
        else
903
            curYBoundary1 = newYBoundary1;
904
    }
905

906
    if (newYBoundary2 < curYBoundary2) {
907
        if (curYBoundary2 <= yScrollOffset + SCREEN_YSIZE || newYBoundary2 >= yScrollOffset + SCREEN_YSIZE)
908
            --curYBoundary2;
909
        else
910
            curYBoundary2 = yScrollOffset + SCREEN_YSIZE;
911
    }
912

913
    if (newYBoundary2 > curYBoundary2) {
914
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2) {
915
            ++curYBoundary2;
916
            if (target->yvel > 0) {
917
                int32 buf = curYBoundary2 + (target->yvel >> 16);
918
                if (newYBoundary2 < buf) {
919
                    curYBoundary2 = newYBoundary2;
920
                }
921
                else {
922
                    curYBoundary2 += target->yvel >> 16;
923
                }
924
            }
925
        }
926
        else
927
            curYBoundary2 = newYBoundary2;
928
    }
929
    if (newXBoundary1 > curXBoundary1) {
930
        if (xScrollOffset <= newXBoundary1)
931
            curXBoundary1 = xScrollOffset;
932
        else
933
            curXBoundary1 = newXBoundary1;
934
    }
935
    if (newXBoundary1 < curXBoundary1) {
936
        if (xScrollOffset <= curXBoundary1) {
937
            --curXBoundary1;
938
            if (target->xvel < 0) {
939
                curXBoundary1 += target->xvel >> 16;
940
                if (curXBoundary1 < newXBoundary1)
941
                    curXBoundary1 = newXBoundary1;
942
            }
943
        }
944
        else {
945
            curXBoundary1 = newXBoundary1;
946
        }
947
    }
948

949
    if (newXBoundary2 < curXBoundary2) {
950
        if (newXBoundary2 > SCREEN_XSIZE + xScrollOffset)
951
            curXBoundary2 = newXBoundary2;
952
        else
953
            curXBoundary2 = SCREEN_XSIZE + xScrollOffset;
954
    }
955

956
    if (newXBoundary2 > curXBoundary2) {
957
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2) {
958
            ++curXBoundary2;
959
            if (target->xvel > 0) {
960
                curXBoundary2 += target->xvel >> 16;
961
                if (curXBoundary2 > newXBoundary2)
962
                    curXBoundary2 = newXBoundary2;
963
            }
964
        }
965
        else {
966
            curXBoundary2 = newXBoundary2;
967
        }
968
    }
969

970
    int32 xPosDif = targetX - currentCamera->xpos;
971
    if (targetX > currentCamera->xpos) {
972
        xPosDif -= 8;
973
        if (xPosDif >= 0) {
974
            if (xPosDif >= 17)
975
                xPosDif = 16;
976
        }
977
        else {
978
            xPosDif = 0;
979
        }
980
    }
981
    else {
982
        xPosDif += 8;
983
        if (xPosDif > 0) {
984
            xPosDif = 0;
985
        }
986
        else if (xPosDif <= -17) {
987
            xPosDif = -16;
988
        }
989
    }
990

991
    int32 centeredXBound1 = currentCamera->xpos + xPosDif;
992
    currentCamera->xpos   = centeredXBound1;
993
    if (centeredXBound1 < SCREEN_CENTERX + curXBoundary1) {
994
        currentCamera->xpos = SCREEN_CENTERX + curXBoundary1;
995
        centeredXBound1     = SCREEN_CENTERX + curXBoundary1;
996
    }
997

998
    int32 centeredXBound2 = curXBoundary2 - SCREEN_CENTERX;
999
    if (centeredXBound2 < centeredXBound1) {
1000
        currentCamera->xpos = centeredXBound2;
1001
        centeredXBound1     = centeredXBound2;
1002
    }
1003

1004
    int32 yPosDif = 0;
1005
    if (target->scrollTracking) {
1006
        if (targetY <= currentCamera->ypos) {
1007
            yPosDif = (targetY - currentCamera->ypos) + 32;
1008
            if (yPosDif <= 0) {
1009
                if (yPosDif <= -17)
1010
                    yPosDif = -16;
1011
            }
1012
            else
1013
                yPosDif = 0;
1014
        }
1015
        else {
1016
            yPosDif = (targetY - currentCamera->ypos) - 32;
1017
            if (yPosDif >= 0) {
1018
                if (yPosDif >= 17)
1019
                    yPosDif = 16;
1020
            }
1021
            else
1022
                yPosDif = 0;
1023
        }
1024
        cameraLockedY = false;
1025
    }
1026
    else if (cameraLockedY) {
1027
        yPosDif             = 0;
1028
        currentCamera->ypos = targetY;
1029
    }
1030
    else if (targetY <= currentCamera->ypos) {
1031
        yPosDif = targetY - currentCamera->ypos;
1032
        if (targetY - currentCamera->ypos <= 0) {
1033
            if (yPosDif >= -32 && abs(target->yvel) <= 0x60000) {
1034
                if (yPosDif < -6) {
1035
                    yPosDif = -6;
1036
                }
1037
            }
1038
            else if (yPosDif < -16) {
1039
                yPosDif = -16;
1040
            }
1041
        }
1042
        else {
1043
            yPosDif       = 0;
1044
            cameraLockedY = true;
1045
        }
1046
    }
1047
    else {
1048
        yPosDif = targetY - currentCamera->ypos;
1049
        if (targetY - currentCamera->ypos < 0) {
1050
            yPosDif       = 0;
1051
            cameraLockedY = true;
1052
        }
1053
        else if (yPosDif > 32 || abs(target->yvel) > 0x60000) {
1054
            if (yPosDif > 16) {
1055
                yPosDif = 16;
1056
            }
1057
            else {
1058
                cameraLockedY = true;
1059
            }
1060
        }
1061
        else {
1062
            if (yPosDif <= 6) {
1063
                cameraLockedY = true;
1064
            }
1065
            else {
1066
                yPosDif = 6;
1067
            }
1068
        }
1069
    }
1070

1071
    int32 newCamY = currentCamera->ypos + yPosDif;
1072
    if (newCamY <= curYBoundary1 + (LEGACY_SCREEN_SCROLL_UP - 1))
1073
        newCamY = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1074
    currentCamera->ypos = newCamY;
1075
    if (curYBoundary2 - (LEGACY_SCREEN_SCROLL_DOWN - 1) <= newCamY) {
1076
        currentCamera->ypos = curYBoundary2 - LEGACY_SCREEN_SCROLL_DOWN;
1077
    }
1078

1079
    xScrollOffset = cameraShakeX + centeredXBound1 - SCREEN_CENTERX;
1080

1081
    int32 pos = currentCamera->ypos + target->lookPosY - LEGACY_SCREEN_SCROLL_UP;
1082
    if (pos < curYBoundary1) {
1083
        yScrollOffset = curYBoundary1;
1084
    }
1085
    else {
1086
        yScrollOffset = currentCamera->ypos + target->lookPosY - LEGACY_SCREEN_SCROLL_UP;
1087
    }
1088

1089
    int32 y = curYBoundary2 - SCREEN_YSIZE;
1090
    if (curYBoundary2 - (SCREEN_YSIZE - 1) > yScrollOffset)
1091
        y = yScrollOffset;
1092
    yScrollOffset = cameraShakeY + y;
1093

1094
    if (cameraShakeX) {
1095
        if (cameraShakeX <= 0) {
1096
            cameraShakeX = ~cameraShakeX;
1097
        }
1098
        else {
1099
            cameraShakeX = -cameraShakeX;
1100
        }
1101
    }
1102

1103
    if (cameraShakeY) {
1104
        if (cameraShakeY <= 0) {
1105
            cameraShakeY = ~cameraShakeY;
1106
        }
1107
        else {
1108
            cameraShakeY = -cameraShakeY;
1109
        }
1110
    }
1111
}
1112
void RSDK::Legacy::v4::SetPlayerScreenPositionCDStyle(Entity *target)
1113
{
1114
    int32 targetX = target->xpos >> 16;
1115
    int32 targetY = currentCamera->adjustY + (target->ypos >> 16);
1116

1117
    if (newYBoundary1 > curYBoundary1) {
1118
        if (newYBoundary1 >= yScrollOffset)
1119
            curYBoundary1 = yScrollOffset;
1120
        else
1121
            curYBoundary1 = newYBoundary1;
1122
    }
1123

1124
    if (newYBoundary1 < curYBoundary1) {
1125
        if (curYBoundary1 >= yScrollOffset)
1126
            --curYBoundary1;
1127
        else
1128
            curYBoundary1 = newYBoundary1;
1129
    }
1130

1131
    if (newYBoundary2 < curYBoundary2) {
1132
        if (curYBoundary2 <= yScrollOffset + SCREEN_YSIZE || newYBoundary2 >= yScrollOffset + SCREEN_YSIZE)
1133
            --curYBoundary2;
1134
        else
1135
            curYBoundary2 = yScrollOffset + SCREEN_YSIZE;
1136
    }
1137

1138
    if (newYBoundary2 > curYBoundary2) {
1139
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2) {
1140
            ++curYBoundary2;
1141
            if (target->yvel > 0) {
1142
                int32 buf = curYBoundary2 + (target->yvel >> 16);
1143
                if (newYBoundary2 < buf) {
1144
                    curYBoundary2 = newYBoundary2;
1145
                }
1146
                else {
1147
                    curYBoundary2 += target->yvel >> 16;
1148
                }
1149
            }
1150
        }
1151
        else
1152
            curYBoundary2 = newYBoundary2;
1153
    }
1154

1155
    if (newXBoundary1 > curXBoundary1) {
1156
        if (xScrollOffset <= newXBoundary1)
1157
            curXBoundary1 = xScrollOffset;
1158
        else
1159
            curXBoundary1 = newXBoundary1;
1160
    }
1161

1162
    if (newXBoundary1 < curXBoundary1) {
1163
        if (xScrollOffset <= curXBoundary1) {
1164
            --curXBoundary1;
1165
            if (target->xvel < 0) {
1166
                curXBoundary1 += target->xvel >> 16;
1167
                if (curXBoundary1 < newXBoundary1)
1168
                    curXBoundary1 = newXBoundary1;
1169
            }
1170
        }
1171
        else {
1172
            curXBoundary1 = newXBoundary1;
1173
        }
1174
    }
1175

1176
    if (newXBoundary2 < curXBoundary2) {
1177
        if (newXBoundary2 > SCREEN_XSIZE + xScrollOffset)
1178
            curXBoundary2 = newXBoundary2;
1179
        else
1180
            curXBoundary2 = SCREEN_XSIZE + xScrollOffset;
1181
    }
1182

1183
    if (newXBoundary2 > curXBoundary2) {
1184
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2) {
1185
            ++curXBoundary2;
1186
            if (target->xvel > 0) {
1187
                curXBoundary2 += target->xvel >> 16;
1188
                if (curXBoundary2 > newXBoundary2)
1189
                    curXBoundary2 = newXBoundary2;
1190
            }
1191
        }
1192
        else {
1193
            curXBoundary2 = newXBoundary2;
1194
        }
1195
    }
1196

1197
    if (!target->gravity) {
1198
        if (target->direction) {
1199
            if (currentCamera->style == CAMERASTYLE_EXTENDED_OFFSET_R || target->speed < -0x5F5C2) {
1200
                cameraShift = 2;
1201
                if (target->lookPosX <= 63) {
1202
                    target->lookPosX += 2;
1203
                }
1204
            }
1205
            else {
1206
                cameraShift = 0;
1207
                if (target->lookPosX < 0) {
1208
                    target->lookPosX += 2;
1209
                }
1210

1211
                if (target->lookPosX > 0) {
1212
                    target->lookPosX -= 2;
1213
                }
1214
            }
1215
        }
1216
        else {
1217
            if (currentCamera->style == CAMERASTYLE_EXTENDED_OFFSET_L || target->speed > 0x5F5C2) {
1218
                cameraShift = 1;
1219
                if (target->lookPosX >= -63) {
1220
                    target->lookPosX -= 2;
1221
                }
1222
            }
1223
            else {
1224
                cameraShift = 0;
1225
                if (target->lookPosX < 0) {
1226
                    target->lookPosX += 2;
1227
                }
1228

1229
                if (target->lookPosX > 0) {
1230
                    target->lookPosX -= 2;
1231
                }
1232
            }
1233
        }
1234
    }
1235
    else {
1236
        if (cameraShift == 1) {
1237
            if (target->lookPosX >= -63) {
1238
                target->lookPosX -= 2;
1239
            }
1240
        }
1241
        else if (cameraShift < 1) {
1242
            if (target->lookPosX < 0) {
1243
                target->lookPosX += 2;
1244
            }
1245
            if (target->lookPosX > 0) {
1246
                target->lookPosX -= 2;
1247
            }
1248
        }
1249
        else if (cameraShift == 2) {
1250
            if (target->lookPosX <= 63) {
1251
                target->lookPosX += 2;
1252
            }
1253
        }
1254
    }
1255
    currentCamera->xpos = targetX - target->lookPosX;
1256

1257
    if (!target->scrollTracking) {
1258
        if (cameraLockedY) {
1259
            currentCamera->ypos = targetY;
1260
            if (currentCamera->ypos < curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1261
                currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1262
            }
1263
        }
1264
        else if (targetY > currentCamera->ypos) {
1265
            int32 dif = targetY - currentCamera->ypos;
1266
            if (targetY - currentCamera->ypos < 0) {
1267
                cameraLockedY = true;
1268
                if (currentCamera->ypos < curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1269
                    currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1270
                }
1271
            }
1272
            else {
1273
                if (dif > 32 || abs(target->yvel) > 0x60000) {
1274
                    if (dif > 16) {
1275
                        dif = 16;
1276
                        if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1277
                            currentCamera->ypos += dif;
1278
                        }
1279
                        else {
1280
                            currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1281
                        }
1282
                    }
1283
                    else {
1284
                        cameraLockedY = true;
1285
                        if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1286
                            currentCamera->ypos += dif;
1287
                        }
1288
                        else {
1289
                            currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1290
                        }
1291
                    }
1292
                }
1293
                else if (dif > 6) {
1294
                    dif = 6;
1295
                    if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1296
                        currentCamera->ypos += dif;
1297
                    }
1298
                    else {
1299
                        currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1300
                    }
1301
                }
1302
                else {
1303
                    cameraLockedY = true;
1304
                    if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1305
                        currentCamera->ypos += dif;
1306
                    }
1307
                    else {
1308
                        currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1309
                    }
1310
                }
1311
            }
1312
        }
1313
        else {
1314
            int32 dif = targetY - currentCamera->ypos;
1315
            if (targetY - currentCamera->ypos <= 0) {
1316
                if (dif < -32 || abs(target->yvel) > 0x60000) {
1317
                    if (dif < -16) {
1318
                        dif = -16;
1319
                        if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1320
                            currentCamera->ypos += dif;
1321
                        }
1322
                        else {
1323
                            currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1324
                        }
1325
                    }
1326
                    else {
1327
                        cameraLockedY = true;
1328
                        if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1329
                            currentCamera->ypos += dif;
1330
                        }
1331
                        else {
1332
                            currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1333
                        }
1334
                    }
1335
                }
1336
                else if (dif < -6) {
1337
                    dif = -6;
1338
                    if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1339
                        currentCamera->ypos += dif;
1340
                    }
1341
                    else {
1342
                        currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1343
                    }
1344
                }
1345
            }
1346
            else {
1347
                dif = 0;
1348
                if (abs(target->yvel) > 0x60000) {
1349
                    cameraLockedY = true;
1350
                    if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1351
                        currentCamera->ypos += dif;
1352
                    }
1353
                    else {
1354
                        currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1355
                    }
1356
                }
1357
                else {
1358
                    cameraLockedY = true;
1359
                    if (currentCamera->ypos + dif >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1360
                        currentCamera->ypos += dif;
1361
                    }
1362
                    else {
1363
                        currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1364
                    }
1365
                }
1366
            }
1367
        }
1368
    }
1369
    else {
1370
        int32 dif  = targetY - currentCamera->ypos;
1371
        int32 difY = 0;
1372
        if (targetY > currentCamera->ypos) {
1373
            difY = dif - 32;
1374
            if (difY >= 0) {
1375
                if (difY >= 17)
1376
                    difY = 16;
1377

1378
                cameraLockedY = false;
1379
                if (currentCamera->ypos + difY >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1380
                    currentCamera->ypos += difY;
1381
                }
1382
                else {
1383
                    currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1384
                }
1385
            }
1386
            else {
1387
                cameraLockedY = false;
1388
                if (currentCamera->ypos < curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1389
                    currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1390
                }
1391
            }
1392
        }
1393
        else {
1394
            difY = dif + 32;
1395
            if (difY > 0) {
1396
                difY = 0;
1397

1398
                cameraLockedY = false;
1399
                if (currentCamera->ypos < curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1400
                    currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1401
                }
1402
            }
1403
            else if (difY <= -17) {
1404
                difY = -16;
1405

1406
                cameraLockedY = false;
1407
                if (currentCamera->ypos + difY >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1408
                    currentCamera->ypos += difY;
1409
                }
1410
                else {
1411
                    currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1412
                }
1413
            }
1414
            else {
1415
                cameraLockedY = false;
1416
                if (currentCamera->ypos + difY >= curYBoundary1 + LEGACY_SCREEN_SCROLL_UP) {
1417
                    currentCamera->ypos += difY;
1418
                }
1419
                else {
1420
                    currentCamera->ypos = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1421
                }
1422
            }
1423
        }
1424
    }
1425

1426
    if (currentCamera->ypos >= curYBoundary2 - LEGACY_SCREEN_SCROLL_DOWN - 1) {
1427
        currentCamera->ypos = curYBoundary2 - LEGACY_SCREEN_SCROLL_DOWN;
1428
    }
1429

1430
    xScrollOffset = currentCamera->xpos - SCREEN_CENTERX;
1431
    yScrollOffset = target->lookPosY + currentCamera->ypos - LEGACY_SCREEN_SCROLL_UP;
1432

1433
    int32 x = curXBoundary1;
1434
    if (x <= xScrollOffset)
1435
        x = xScrollOffset;
1436
    else
1437
        xScrollOffset = x;
1438

1439
    if (x > curXBoundary2 - SCREEN_XSIZE) {
1440
        x             = curXBoundary2 - SCREEN_XSIZE;
1441
        xScrollOffset = curXBoundary2 - SCREEN_XSIZE;
1442
    }
1443

1444
    int32 y = curYBoundary1;
1445
    if (yScrollOffset >= y)
1446
        y = yScrollOffset;
1447
    else
1448
        yScrollOffset = y;
1449

1450
    if (curYBoundary2 - SCREEN_YSIZE - 1 <= y)
1451
        y = curYBoundary2 - SCREEN_YSIZE;
1452

1453
    xScrollOffset = cameraShakeX + x;
1454
    yScrollOffset = cameraShakeY + y;
1455

1456
    if (cameraShakeX) {
1457
        if (cameraShakeX <= 0) {
1458
            cameraShakeX = ~cameraShakeX;
1459
        }
1460
        else {
1461
            cameraShakeX = -cameraShakeX;
1462
        }
1463
    }
1464

1465
    if (cameraShakeY) {
1466
        if (cameraShakeY <= 0) {
1467
            cameraShakeY = ~cameraShakeY;
1468
        }
1469
        else {
1470
            cameraShakeY = -cameraShakeY;
1471
        }
1472
    }
1473
}
1474
void RSDK::Legacy::v4::SetPlayerHLockedScreenPosition(Entity *target)
1475
{
1476
    int32 targetY = currentCamera->adjustY + (target->ypos >> 16);
1477

1478
    if (newYBoundary1 <= curYBoundary1) {
1479
        if (curYBoundary1 > yScrollOffset)
1480
            --curYBoundary1;
1481
        else
1482
            curYBoundary1 = newYBoundary1;
1483
    }
1484
    else {
1485
        if (newYBoundary1 >= yScrollOffset)
1486
            curYBoundary1 = yScrollOffset;
1487
        else
1488
            curYBoundary1 = newYBoundary1;
1489
    }
1490

1491
    if (newYBoundary2 < curYBoundary2) {
1492
        if (curYBoundary2 <= yScrollOffset + SCREEN_YSIZE || newYBoundary2 >= yScrollOffset + SCREEN_YSIZE)
1493
            --curYBoundary2;
1494
        else
1495
            curYBoundary2 = yScrollOffset + SCREEN_YSIZE;
1496
    }
1497
    if (newYBoundary2 > curYBoundary2) {
1498
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2) {
1499
            ++curYBoundary2;
1500
            if (target->yvel > 0) {
1501
                if (newYBoundary2 < curYBoundary2 + (target->yvel >> 16)) {
1502
                    curYBoundary2 = newYBoundary2;
1503
                }
1504
                else {
1505
                    curYBoundary2 += target->yvel >> 16;
1506
                }
1507
            }
1508
        }
1509
        else
1510
            curYBoundary2 = newYBoundary2;
1511
    }
1512

1513
    if (newXBoundary1 > curXBoundary1) {
1514
        if (xScrollOffset <= newXBoundary1)
1515
            curXBoundary1 = xScrollOffset;
1516
        else
1517
            curXBoundary1 = newXBoundary1;
1518
    }
1519
    if (newXBoundary1 < curXBoundary1) {
1520
        if (xScrollOffset <= curXBoundary1) {
1521
            --curXBoundary1;
1522
            if (target->xvel < 0) {
1523
                curXBoundary1 += target->xvel >> 16;
1524
                if (curXBoundary1 < newXBoundary1)
1525
                    curXBoundary1 = newXBoundary1;
1526
            }
1527
        }
1528
        else {
1529
            curXBoundary1 = newXBoundary1;
1530
        }
1531
    }
1532

1533
    if (newXBoundary2 < curXBoundary2) {
1534
        if (newXBoundary2 > SCREEN_XSIZE + xScrollOffset)
1535
            curXBoundary2 = newXBoundary2;
1536
        else
1537
            curXBoundary2 = SCREEN_XSIZE + xScrollOffset;
1538
    }
1539

1540
    if (newXBoundary2 > curXBoundary2) {
1541
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2) {
1542
            ++curXBoundary2;
1543
            if (target->xvel > 0) {
1544
                curXBoundary2 += target->xvel >> 16;
1545
                if (curXBoundary2 > newXBoundary2)
1546
                    curXBoundary2 = newXBoundary2;
1547
            }
1548
        }
1549
        else {
1550
            curXBoundary2 = newXBoundary2;
1551
        }
1552
    }
1553

1554
    int32 camScroll = 0;
1555
    if (target->scrollTracking) {
1556
        if (targetY <= currentCamera->ypos) {
1557
            camScroll = targetY - currentCamera->ypos + 32;
1558
            if (camScroll <= 0) {
1559
                if (camScroll <= -17)
1560
                    camScroll = -16;
1561
            }
1562
            else
1563
                camScroll = 0;
1564
        }
1565
        else {
1566
            camScroll = targetY - currentCamera->ypos - 32;
1567
            if (camScroll >= 0) {
1568
                if (camScroll >= 17)
1569
                    camScroll = 16;
1570
            }
1571
            else
1572
                camScroll = 0;
1573
        }
1574
        cameraLockedY = false;
1575
    }
1576
    else if (cameraLockedY) {
1577
        camScroll           = 0;
1578
        currentCamera->ypos = targetY;
1579
    }
1580
    else if (targetY > currentCamera->ypos) {
1581
        camScroll = targetY - currentCamera->ypos;
1582
        if (camScroll >= 0) {
1583
            if (camScroll > 32 || abs(target->yvel) > 0x60000) {
1584
                if (camScroll > 16) {
1585
                    camScroll = 16;
1586
                }
1587
                else {
1588
                    cameraLockedY = true;
1589
                }
1590
            }
1591
            else if (camScroll > 6) {
1592
                camScroll = 6;
1593
            }
1594
            else {
1595
                cameraLockedY = true;
1596
            }
1597
        }
1598
        else {
1599
            camScroll     = 0;
1600
            cameraLockedY = true;
1601
        }
1602
    }
1603
    else {
1604
        camScroll = targetY - currentCamera->ypos;
1605
        if (camScroll > 0) {
1606
            camScroll     = 0;
1607
            cameraLockedY = true;
1608
        }
1609
        else if (camScroll < -32 || abs(target->yvel) > 0x60000) {
1610
            if (camScroll < -16) {
1611
                camScroll = -16;
1612
            }
1613
            else {
1614
                cameraLockedY = true;
1615
            }
1616
        }
1617
        else {
1618
            if (camScroll >= -6)
1619
                cameraLockedY = true;
1620
            else
1621
                camScroll = -6;
1622
        }
1623
    }
1624

1625
    int32 newCamY = currentCamera->ypos + camScroll;
1626
    if (newCamY <= curYBoundary1 + (LEGACY_SCREEN_SCROLL_UP - 1))
1627
        newCamY = curYBoundary1 + LEGACY_SCREEN_SCROLL_UP;
1628
    currentCamera->ypos = newCamY;
1629
    if (curYBoundary2 - (LEGACY_SCREEN_SCROLL_DOWN - 1) <= newCamY) {
1630
        newCamY             = curYBoundary2 - LEGACY_SCREEN_SCROLL_DOWN;
1631
        currentCamera->ypos = curYBoundary2 - LEGACY_SCREEN_SCROLL_DOWN;
1632
    }
1633

1634
    xScrollOffset = cameraShakeX + currentCamera->xpos - SCREEN_CENTERX;
1635

1636
    int32 pos = newCamY + target->lookPosY - LEGACY_SCREEN_SCROLL_UP;
1637
    if (pos < curYBoundary1) {
1638
        yScrollOffset = curYBoundary1;
1639
    }
1640
    else {
1641
        yScrollOffset = newCamY + target->lookPosY - LEGACY_SCREEN_SCROLL_UP;
1642
    }
1643
    int32 y1 = curYBoundary2 - (SCREEN_YSIZE - 1);
1644
    int32 y2 = curYBoundary2 - SCREEN_YSIZE;
1645
    if (y1 > yScrollOffset)
1646
        y2 = yScrollOffset;
1647
    yScrollOffset = cameraShakeY + y2;
1648

1649
    if (cameraShakeX) {
1650
        if (cameraShakeX <= 0) {
1651
            cameraShakeX = ~cameraShakeX;
1652
        }
1653
        else {
1654
            cameraShakeX = -cameraShakeX;
1655
        }
1656
    }
1657

1658
    if (cameraShakeY) {
1659
        if (cameraShakeY <= 0) {
1660
            cameraShakeY = ~cameraShakeY;
1661
        }
1662
        else {
1663
            cameraShakeY = -cameraShakeY;
1664
        }
1665
    }
1666
}
1667
void RSDK::Legacy::v4::SetPlayerLockedScreenPosition(Entity *target)
1668
{
1669
    if (newYBoundary1 > curYBoundary1) {
1670
        if (yScrollOffset <= newYBoundary1)
1671
            curYBoundary1 = yScrollOffset;
1672
        else
1673
            curYBoundary1 = newYBoundary1;
1674
    }
1675
    if (newYBoundary1 < curYBoundary1) {
1676
        if (yScrollOffset <= curYBoundary1)
1677
            --curYBoundary1;
1678
        else
1679
            curYBoundary1 = newYBoundary1;
1680
    }
1681

1682
    if (newYBoundary2 < curYBoundary2) {
1683
        if (curYBoundary2 <= yScrollOffset + SCREEN_YSIZE || newYBoundary2 >= yScrollOffset + SCREEN_YSIZE)
1684
            --curYBoundary2;
1685
        else
1686
            curYBoundary2 = yScrollOffset + SCREEN_YSIZE;
1687
    }
1688

1689
    if (newYBoundary2 > curYBoundary2) {
1690
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2)
1691
            ++curYBoundary2;
1692
        else
1693
            curYBoundary2 = newYBoundary2;
1694
    }
1695

1696
    if (newXBoundary1 > curXBoundary1) {
1697
        if (xScrollOffset <= newXBoundary1)
1698
            curXBoundary1 = xScrollOffset;
1699
        else
1700
            curXBoundary1 = newXBoundary1;
1701
    }
1702

1703
    if (newXBoundary1 < curXBoundary1) {
1704
        if (xScrollOffset <= curXBoundary1) {
1705
            --curXBoundary1;
1706
            if (target->xvel < 0) {
1707
                curXBoundary1 += target->xvel >> 16;
1708
                if (curXBoundary1 < newXBoundary1)
1709
                    curXBoundary1 = newXBoundary1;
1710
            }
1711
        }
1712
        else {
1713
            curXBoundary1 = newXBoundary1;
1714
        }
1715
    }
1716

1717
    if (newXBoundary2 < curXBoundary2) {
1718
        if (newXBoundary2 > SCREEN_XSIZE + xScrollOffset)
1719
            curXBoundary2 = newXBoundary2;
1720
        else
1721
            curXBoundary2 = SCREEN_XSIZE + xScrollOffset;
1722
    }
1723

1724
    if (newXBoundary2 > curXBoundary2) {
1725
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2) {
1726
            ++curXBoundary2;
1727
            if (target->xvel > 0) {
1728
                curXBoundary2 += target->xvel >> 16;
1729
                if (curXBoundary2 > newXBoundary2)
1730
                    curXBoundary2 = newXBoundary2;
1731
            }
1732
        }
1733
        else {
1734
            curXBoundary2 = newXBoundary2;
1735
        }
1736
    }
1737

1738
    if (cameraShakeX) {
1739
        if (cameraShakeX <= 0) {
1740
            cameraShakeX = ~cameraShakeX;
1741
        }
1742
        else {
1743
            cameraShakeX = -cameraShakeX;
1744
        }
1745
    }
1746

1747
    if (cameraShakeY) {
1748
        if (cameraShakeY <= 0) {
1749
            cameraShakeY = ~cameraShakeY;
1750
        }
1751
        else {
1752
            cameraShakeY = -cameraShakeY;
1753
        }
1754
    }
1755
}
1756
void RSDK::Legacy::v4::SetPlayerScreenPositionFixed(Entity *target)
1757
{
1758
    int32 targetX = target->xpos >> 16;
1759
    int32 targetY = currentCamera->adjustY + (target->ypos >> 16);
1760

1761
    if (newYBoundary1 > curYBoundary1) {
1762
        if (newYBoundary1 >= yScrollOffset)
1763
            curYBoundary1 = yScrollOffset;
1764
        else
1765
            curYBoundary1 = newYBoundary1;
1766
    }
1767

1768
    if (newYBoundary1 < curYBoundary1) {
1769
        if (curYBoundary1 >= yScrollOffset)
1770
            --curYBoundary1;
1771
        else
1772
            curYBoundary1 = newYBoundary1;
1773
    }
1774

1775
    if (newYBoundary2 < curYBoundary2) {
1776
        if (curYBoundary2 <= yScrollOffset + SCREEN_YSIZE || newYBoundary2 >= yScrollOffset + SCREEN_YSIZE)
1777
            --curYBoundary2;
1778
        else
1779
            curYBoundary2 = yScrollOffset + SCREEN_YSIZE;
1780
    }
1781

1782
    if (newYBoundary2 > curYBoundary2) {
1783
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2) {
1784
            ++curYBoundary2;
1785
            if (target->yvel > 0) {
1786
                int32 buf = curYBoundary2 + (target->yvel >> 16);
1787
                if (newYBoundary2 < buf) {
1788
                    curYBoundary2 = newYBoundary2;
1789
                }
1790
                else {
1791
                    curYBoundary2 += target->yvel >> 16;
1792
                }
1793
            }
1794
        }
1795
        else
1796
            curYBoundary2 = newYBoundary2;
1797
    }
1798

1799
    if (newXBoundary1 > curXBoundary1) {
1800
        if (xScrollOffset <= newXBoundary1)
1801
            curXBoundary1 = xScrollOffset;
1802
        else
1803
            curXBoundary1 = newXBoundary1;
1804
    }
1805

1806
    if (newXBoundary1 < curXBoundary1) {
1807
        if (xScrollOffset <= curXBoundary1) {
1808
            --curXBoundary1;
1809
            if (target->xvel < 0) {
1810
                curXBoundary1 += target->xvel >> 16;
1811
                if (curXBoundary1 < newXBoundary1)
1812
                    curXBoundary1 = newXBoundary1;
1813
            }
1814
        }
1815
        else {
1816
            curXBoundary1 = newXBoundary1;
1817
        }
1818
    }
1819

1820
    if (newXBoundary2 < curXBoundary2) {
1821
        if (newXBoundary2 > SCREEN_XSIZE + xScrollOffset)
1822
            curXBoundary2 = newXBoundary2;
1823
        else
1824
            curXBoundary2 = SCREEN_XSIZE + xScrollOffset;
1825
    }
1826

1827
    if (newXBoundary2 > curXBoundary2) {
1828
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2) {
1829
            ++curXBoundary2;
1830
            if (target->xvel > 0) {
1831
                curXBoundary2 += target->xvel >> 16;
1832
                if (curXBoundary2 > newXBoundary2)
1833
                    curXBoundary2 = newXBoundary2;
1834
            }
1835
        }
1836
        else {
1837
            curXBoundary2 = newXBoundary2;
1838
        }
1839
    }
1840

1841
    currentCamera->xpos = targetX;
1842
    if (targetX < SCREEN_CENTERX + curXBoundary1) {
1843
        targetX             = SCREEN_CENTERX + curXBoundary1;
1844
        currentCamera->xpos = SCREEN_CENTERX + curXBoundary1;
1845
    }
1846
    int32 boundX2 = curXBoundary2 - SCREEN_CENTERX;
1847
    if (boundX2 < targetX) {
1848
        targetX             = boundX2;
1849
        currentCamera->xpos = boundX2;
1850
    }
1851

1852
    if (targetY <= curYBoundary1 + 119) {
1853
        targetY             = curYBoundary1 + 120;
1854
        currentCamera->ypos = curYBoundary1 + 120;
1855
    }
1856
    else {
1857
        currentCamera->ypos = targetY;
1858
    }
1859
    if (curYBoundary2 - ((SCREEN_YSIZE / 2) - 1) <= targetY) {
1860
        targetY             = curYBoundary2 - (SCREEN_YSIZE / 2);
1861
        currentCamera->ypos = curYBoundary2 - (SCREEN_YSIZE / 2);
1862
    }
1863

1864
    xScrollOffset = cameraShakeX + targetX - SCREEN_CENTERX;
1865
    int32 camY    = targetY + target->lookPosY - (SCREEN_YSIZE / 2);
1866
    if (curYBoundary1 > camY) {
1867
        yScrollOffset = curYBoundary1;
1868
    }
1869
    else {
1870
        yScrollOffset = targetY + target->lookPosY - (SCREEN_YSIZE / 2);
1871
    }
1872

1873
    int32 newCamY = curYBoundary2 - SCREEN_YSIZE;
1874
    if (curYBoundary2 - (SCREEN_YSIZE - 1) > yScrollOffset)
1875
        newCamY = yScrollOffset;
1876
    yScrollOffset = cameraShakeY + newCamY;
1877

1878
    if (cameraShakeX) {
1879
        if (cameraShakeX <= 0) {
1880
            cameraShakeX = ~cameraShakeX;
1881
        }
1882
        else {
1883
            cameraShakeX = -cameraShakeX;
1884
        }
1885
    }
1886

1887
    if (cameraShakeY) {
1888
        if (cameraShakeY <= 0) {
1889
            cameraShakeY = ~cameraShakeY;
1890
        }
1891
        else {
1892
            cameraShakeY = -cameraShakeY;
1893
        }
1894
    }
1895
}
1896
void RSDK::Legacy::v4::SetPlayerScreenPositionStatic(Entity *target)
1897
{
1898
    xScrollOffset = currentCamera->xpos - SCREEN_CENTERX;
1899
    yScrollOffset = currentCamera->ypos + target->lookPosY - LEGACY_SCREEN_SCROLL_UP;
1900

1901
    if (yScrollOffset < curYBoundary1)
1902
        yScrollOffset = curYBoundary1;
1903
    if (yScrollOffset > curYBoundary2 - SCREEN_YSIZE)
1904
        yScrollOffset = curYBoundary2 - SCREEN_YSIZE;
1905
}
1906

1907
Product

Resources

Company
