CoCalc -- SceneLegacyv3.cpp

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

2
int32 RSDK::Legacy::v3::yScrollA    = 0;
3
int32 RSDK::Legacy::v3::yScrollB    = SCREEN_YSIZE;
4
int32 RSDK::Legacy::v3::xScrollA    = 0;
5
int32 RSDK::Legacy::v3::xScrollB    = Legacy::SCREEN_XSIZE;
6
int32 RSDK::Legacy::v3::yScrollMove = 0;
7

8
#if RETRO_USE_MOD_LOADER
9
namespace RSDK
10
{
11
namespace Legacy
12
{
13
namespace v3
14
{
15

16
bool32 loadGlobalScripts = false; // stored here so I can use it later
17
int32 globalObjCount     = 0;
18

19
} // namespace v3
20
} // namespace Legacy
21
} // namespace RSDK
22
#endif
23

24
void RSDK::Legacy::v3::InitFirstStage()
25
{
26
    xScrollOffset = 0;
27
    yScrollOffset = 0;
28
    StopMusic();
29
    fadeMode = 0;
30
    ClearGraphicsData();
31
    ClearAnimationData();
32
    activePalette = fullPalette[0];
33
    LoadPalette("MasterPalette.act", 0, 0, 0, 256);
34
#if RETRO_USE_MOD_LOADER
35
    LoadGameXML(true);
36
#endif
37

38
    stageMode = STAGEMODE_LOAD;
39
    gameMode  = ENGINE_MAINGAME;
40
}
41

42
void RSDK::Legacy::v3::ProcessStage()
43
{
44

45
#if !RETRO_USE_ORIGINAL_CODE
46
    debugHitboxCount = 0;
47
#endif
48

49
    switch (stageMode) {
50
        case STAGEMODE_LOAD: // Startup
51
            fadeMode = 0;
52
            SetActivePalette(0, 0, 256);
53
            InitCameras();
54
            videoSettings.dimLimit = (5 * 60) * videoSettings.refreshRate;
55

56
            xScrollOffset = 0;
57
            yScrollOffset = 0;
58
            yScrollA      = 0;
59
            yScrollB      = SCREEN_YSIZE;
60
            xScrollA      = 0;
61
            xScrollB      = SCREEN_XSIZE;
62
            yScrollMove   = 0;
63
            cameraShakeX  = 0;
64
            cameraShakeY  = 0;
65

66
            vertexCount = 0;
67
            faceCount   = 0;
68

69
#if RSDK_AUTOBUILD
70
            // Prevent playing as Knuckles or Amy if on autobuilds
71
            if (GetGlobalVariableByName("PLAYER_KNUCKLES") && playerListPos == GetGlobalVariableByName("PLAYER_KNUCKLES"))
72
                playerListPos = 0;
73
            else if (GetGlobalVariableByName("PLAYER_KNUCKLES_TAILS") && playerListPos == GetGlobalVariableByName("PLAYER_KNUCKLES_TAILS"))
74
                playerListPos = 0;
75
            else if (GetGlobalVariableByName("PLAYER_AMY") && playerListPos == GetGlobalVariableByName("PLAYER_AMY"))
76
                playerListPos = 0;
77
            else if (GetGlobalVariableByName("PLAYER_AMY_TAILS") && playerListPos == GetGlobalVariableByName("PLAYER_AMY_TAILS"))
78
                playerListPos = 0;
79
#endif
80

81
            for (int32 p = 0; p < LEGACY_v3_PLAYER_COUNT; ++p) {
82
                memset(&playerList[p], 0, sizeof(playerList[p]));
83
                playerList[p].visible            = true;
84
                playerList[p].gravity            = 1; // Air
85
                playerList[p].tileCollisions     = true;
86
                playerList[p].objectInteractions = true;
87
            }
88

89
            pauseEnabled      = false;
90
            timeEnabled       = false;
91
            frameCounter      = 0;
92
            stageMilliseconds = 0;
93
            stageSeconds      = 0;
94
            stageMinutes      = 0;
95
            stageMode         = STAGEMODE_NORMAL;
96

97
            sceneInfo.currentScreenID = 0;
98
            currentScreen             = screens;
99
#if RETRO_USE_MOD_LOADER
100
            if (devMenu.modsChanged)
101
                RefreshModFolders();
102
#endif
103
            ResetBackgroundSettings();
104
            LoadStageFiles();
105
            break;
106

107
        case STAGEMODE_NORMAL:
108
            if (fadeMode > 0)
109
                fadeMode--;
110

111
            if (paletteMode > 0) {
112
                paletteMode = 0;
113
                SetActivePalette(0, 0, 256);
114
            }
115

116
            lastXSize = -1;
117
            lastYSize = -1;
118

119
            ProcessInput();
120

121
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
122
                stageMode = STAGEMODE_PAUSED;
123
                PauseSound();
124
            }
125

126
            ProcessSceneTimer();
127

128
            // Update
129
            ProcessObjects();
130
            HandleCameras();
131
            ProcessParallaxAutoScroll();
132

133
#if !RETRO_USE_ORIGINAL_CODE
134
            for (int32 i = 1; i < engine.gameSpeed; ++i) {
135
                ProcessSceneTimer();
136

137
                // Update
138
                ProcessObjects();
139
                HandleCameras();
140
                ProcessParallaxAutoScroll();
141
            }
142
#endif
143

144
            DrawStageGFX();
145
            break;
146

147
        case STAGEMODE_PAUSED:
148
            if (fadeMode > 0)
149
                fadeMode--;
150

151
            lastXSize = -1;
152
            lastYSize = -1;
153

154
            ProcessInput();
155

156
            if (controller[CONT_ANY].keyC.press || engine.frameStep) {
157
#if !RETRO_USE_ORIGINAL_CODE
158
                if (!engine.frameStep) {
159
                    for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
160
                }
161
                engine.frameStep = false;
162
#else
163
                for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
164
#endif
165

166
                ProcessSceneTimer();
167
                ProcessObjects();
168
                HandleCameras();
169

170
                DrawStageGFX();
171

172
                if (fadeMode)
173
                    DrawRectangle(0, 0, SCREEN_XSIZE, SCREEN_YSIZE, fadeR, fadeG, fadeB, fadeA);
174
            }
175
            else {
176
                // Update
177
                ProcessPausedObjects();
178

179
                DrawObjectList(0);
180
                DrawObjectList(1);
181
                DrawObjectList(2);
182
                DrawObjectList(3);
183
                DrawObjectList(4);
184
                DrawObjectList(5);
185
                DrawObjectList(7); // ???
186
                DrawObjectList(6);
187
            }
188

189
#if !RETRO_USE_ORIGINAL_CODE
190
            DrawDebugOverlays();
191
#endif
192

193
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
194
                stageMode = STAGEMODE_NORMAL;
195
                ResumeSound();
196
            }
197
            break;
198

199
        case STAGEMODE_NORMAL + STAGEMODE_STEPOVER:
200
            if (fadeMode > 0)
201
                fadeMode--;
202

203
            lastXSize = -1;
204
            lastYSize = -1;
205

206
            ProcessInput();
207

208
            if (controller[CONT_ANY].keyC.press || engine.frameStep) {
209
#if !RETRO_USE_ORIGINAL_CODE
210
                if (!engine.frameStep) {
211
                    for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
212
                }
213
                engine.frameStep = false;
214
#else
215
                for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
216
#endif
217

218
                ProcessSceneTimer();
219

220
                ProcessObjects();
221
                HandleCameras();
222

223
                DrawStageGFX();
224
                ProcessParallaxAutoScroll();
225

226
#if !RETRO_USE_ORIGINAL_CODE
227
                engine.frameStep = false;
228
#endif
229
            }
230

231
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
232
                stageMode -= STAGEMODE_STEPOVER;
233
                ResumeSound();
234
            }
235
            break;
236

237
        case STAGEMODE_PAUSED + STAGEMODE_STEPOVER:
238
            if (fadeMode > 0)
239
                fadeMode--;
240

241
            lastXSize = -1;
242
            lastYSize = -1;
243

244
            ProcessInput();
245

246
            if (controller[CONT_ANY].keyC.press || engine.frameStep) {
247
#if !RETRO_USE_ORIGINAL_CODE
248
                if (!engine.frameStep) {
249
                    for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
250
                }
251
                engine.frameStep = false;
252
#else
253
                for (int32 c = CONT_ANY; c <= CONT_P1; ++c) controller[c].keyC.press = false;
254
#endif
255

256
                ProcessPausedObjects();
257

258
                DrawObjectList(0);
259
                DrawObjectList(1);
260
                DrawObjectList(2);
261
                DrawObjectList(3);
262
                DrawObjectList(4);
263
                DrawObjectList(5);
264
                DrawObjectList(7); // ???
265
                DrawObjectList(6);
266

267
#if !RETRO_USE_ORIGINAL_CODE
268
                DrawDebugOverlays();
269
#endif
270
            }
271

272
            if (pauseEnabled && controller[CONT_ANY].keyStart.press) {
273
                stageMode -= STAGEMODE_STEPOVER;
274
                ResumeSound();
275
            }
276
            break;
277
    }
278
}
279

280
void RSDK::Legacy::v3::HandleCameras()
281
{
282
    if (currentCamera->target >= LEGACY_v3_ENTITY_COUNT)
283
        return;
284

285
    if (currentCamera->enabled) {
286
        switch (currentCamera->style) {
287
            case CAMERASTYLE_FOLLOW: SetPlayerScreenPosition(&playerList[currentCamera->target]); break;
288
            case CAMERASTYLE_EXTENDED:
289
            case CAMERASTYLE_EXTENDED_OFFSET_L:
290
            case CAMERASTYLE_EXTENDED_OFFSET_R: SetPlayerScreenPositionCDStyle(&playerList[currentCamera->target]); break;
291
            case CAMERASTYLE_HLOCKED: SetPlayerHLockedScreenPosition(&playerList[currentCamera->target]); break;
292
            default: break;
293
        }
294
    }
295
    else {
296
        SetPlayerLockedScreenPosition(&playerList[currentCamera->target]);
297
    }
298
}
299

300
void RSDK::Legacy::v3::ProcessParallaxAutoScroll()
301
{
302
    for (int32 i = 0; i < hParallax.entryCount; ++i) hParallax.scrollPos[i] += hParallax.scrollSpeed[i];
303
    for (int32 i = 0; i < vParallax.entryCount; ++i) vParallax.scrollPos[i] += vParallax.scrollSpeed[i];
304
}
305

306
void RSDK::Legacy::v3::LoadStageFiles()
307
{
308
    int32 scriptID = 1;
309
    char strBuffer[0x100];
310

311
    FileInfo info;
312
    InitFileInfo(&info);
313

314
    if (!CheckCurrentStageFolder()) {
315
        PrintLog(PRINT_NORMAL, "Loading Scene %s - %s", sceneInfo.listCategory[sceneInfo.activeCategory].name,
316
                 sceneInfo.listData[sceneInfo.listPos].name);
317

318
        // Unload stage sfx & audio channels
319
        ClearStageSfx();
320

321
        LoadPalette("MasterPalette.act", 0, 0, 0, 256);
322
#if RETRO_USE_MOD_LOADER
323
        LoadGameXML(true);
324
#endif
325

326
        ClearScriptData();
327

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

330
#if RETRO_USE_MOD_LOADER
331
        loadGlobalScripts = false;
332
#else
333
        bool32 loadGlobalScripts = false;
334
#endif
335

336
        if (LoadStageFile("StageConfig.bin", &info)) {
337
            loadGlobalScripts = ReadInt8(&info);
338
            CloseFile(&info);
339
        }
340

341
        InitFileInfo(&info);
342
        if (loadGlobalScripts && LoadFile(&info, "Data/Game/GameConfig.bin", FMODE_RB)) {
343
            ReadString(&info, strBuffer); // Title
344
            ReadString(&info, strBuffer); // "Data"
345
            ReadString(&info, strBuffer); // Description
346

347
            uint8 globalObjectCount = ReadInt8(&info);
348
            for (uint8 i = 0; i < globalObjectCount; ++i) {
349
                ReadString(&info, strBuffer);
350
                SetObjectTypeName(strBuffer, i + scriptID);
351
            }
352

353
#if RETRO_USE_MOD_LOADER
354
            for (uint8 i = 0; i < modObjCount && loadGlobalScripts; ++i) {
355
                SetObjectTypeName(modTypeNames[i], globalObjectCount + i + 1);
356
            }
357
#endif
358

359
#if LEGACY_RETRO_USE_COMPILER
360
#if RETRO_USE_MOD_LOADER
361
            char scriptPath[0x40];
362
            StrCopy(scriptPath, "Data/Scripts/ByteCode/GlobalCode.bin");
363

364
            bool32 bytecodeExists = false;
365
            FileInfo bytecodeInfo;
366
            InitFileInfo(&bytecodeInfo);
367
            if (LoadFile(&bytecodeInfo, scriptPath, FMODE_RB)) {
368
                bytecodeExists = true;
369
                CloseFile(&bytecodeInfo);
370
            }
371

372
            if (bytecodeExists && !modSettings.forceScripts) {
373
#else
374
            if (usingBytecode) {
375
#endif
376
                LoadBytecode(scriptID, true);
377
                scriptID += globalObjectCount;
378
            }
379
            else {
380
                for (uint8 i = 0; i < globalObjectCount; ++i) {
381
                    ReadString(&info, strBuffer);
382

383
                    ParseScriptFile(strBuffer, scriptID++);
384

385
                    if (gameMode == ENGINE_SCRIPTERROR)
386
                        return;
387
                }
388
            }
389
#else
390
            LoadBytecode(scriptID, true);
391
            scriptID += globalObjectCount;
392
#endif
393
            CloseFile(&info);
394

395
#if RETRO_USE_MOD_LOADER && LEGACY_RETRO_USE_COMPILER
396
            globalObjCount = globalObjectCount;
397
            for (uint8 i = 0; i < modObjCount && loadGlobalScripts; ++i) {
398
                SetObjectTypeName(modTypeNames[i], scriptID);
399

400
                ParseScriptFile(modScriptPaths[i], scriptID++);
401
                if (gameMode == ENGINE_SCRIPTERROR)
402
                    return;
403
            }
404
#endif
405
        }
406

407
        InitFileInfo(&info);
408
        if (LoadStageFile("StageConfig.bin", &info)) {
409
            ReadInt8(&info); // Load Globals
410

411
            for (int32 i = 96; i < 128; ++i) {
412
                uint8 clr[3];
413
                ReadBytes(&info, &clr, 3);
414
                SetPaletteEntry(-1, i, clr[0], clr[1], clr[2]);
415
            }
416

417
            uint8 stageObjectCount = ReadInt8(&info);
418
            for (uint8 i = 0; i < stageObjectCount; ++i) {
419
                ReadString(&info, strBuffer);
420

421
                SetObjectTypeName(strBuffer, scriptID + i);
422
            }
423

424
#if LEGACY_RETRO_USE_COMPILER
425
#if RETRO_USE_MOD_LOADER
426
            char scriptPath[0x40];
427
            switch (sceneInfo.activeCategory) {
428
                case STAGELIST_PRESENTATION:
429
                case STAGELIST_REGULAR:
430
                case STAGELIST_BONUS:
431
                case STAGELIST_SPECIAL:
432
                    StrCopy(scriptPath, "Data/Scripts/ByteCode/");
433
                    StrAdd(scriptPath, sceneInfo.listData[sceneInfo.listPos].folder);
434
                    StrAdd(scriptPath, ".bin");
435
                    break;
436
                default: break;
437
            }
438

439
            bool32 bytecodeExists = false;
440
            FileInfo bytecodeInfo;
441
            InitFileInfo(&bytecodeInfo);
442
            if (LoadFile(&bytecodeInfo, scriptPath, FMODE_RB)) {
443
                bytecodeExists = true;
444
                CloseFile(&bytecodeInfo);
445
            }
446

447
            if (bytecodeExists && !modSettings.forceScripts) {
448
#else
449
            if (usingBytecode) {
450
#endif
451
                for (uint8 i = 0; i < stageObjectCount; ++i) ReadString(&info, strBuffer);
452

453
                LoadBytecode(scriptID, false);
454
            }
455
            else {
456
                for (uint8 i = 0; i < stageObjectCount; ++i) {
457
                    ReadString(&info, strBuffer);
458

459
                    ParseScriptFile(strBuffer, scriptID + i);
460

461
                    if (gameMode == ENGINE_SCRIPTERROR)
462
                        return;
463
                }
464
            }
465
#else
466
            for (uint8 i = 0; i < stageObjectCount; ++i) ReadString(&info, strBuffer);
467

468
            LoadBytecode(scriptID, false);
469
#endif
470

471
            stageSFXCount = ReadInt8(&info);
472
            for (int32 i = 0; i < stageSFXCount; ++i) {
473
                ReadString(&info, strBuffer);
474

475
                RSDK::Legacy::LoadSfx(strBuffer, globalSFXCount + i, SCOPE_STAGE);
476

477
#if RETRO_USE_MOD_LOADER
478
                SetSfxName(strBuffer, i, false);
479
#endif
480
            }
481
            CloseFile(&info);
482
        }
483

484
        LoadStageGIFFile();
485
        LoadStageCollisions();
486
        LoadStageBackground();
487
    }
488
    else {
489
        PrintLog(PRINT_NORMAL, "Reloading Scene %s - %s", sceneInfo.listCategory[sceneInfo.activeCategory].name,
490
                 sceneInfo.listData[sceneInfo.listPos].name);
491
    }
492
    LoadStageChunks();
493

494
    for (int32 i = 0; i < LEGACY_TRACK_COUNT; ++i) SetMusicTrack((char *)"", i, 0, 0);
495
    for (int32 i = 0; i < LEGACY_v3_ENTITY_COUNT; ++i) {
496
        memset(&objectEntityList[i], 0, sizeof(objectEntityList[i]));
497

498
        objectEntityList[i].drawOrder = 3;
499
        objectEntityList[i].scale     = 512;
500
    }
501

502
    LoadActLayout();
503
    Init3DFloorBuffer(0);
504
    ProcessStartupObjects();
505

506
    xScrollA = (playerList[0].XPos >> 16) - SCREEN_CENTERX;
507
    xScrollB = (playerList[0].XPos >> 16) - SCREEN_CENTERX + SCREEN_XSIZE;
508
    yScrollA = (playerList[0].YPos >> 16) - LEGACY_SCREEN_SCROLL_UP;
509
    yScrollB = (playerList[0].YPos >> 16) - LEGACY_SCREEN_SCROLL_UP + SCREEN_YSIZE;
510
}
511
void RSDK::Legacy::v3::LoadActLayout()
512
{
513
    FileInfo info;
514
    InitFileInfo(&info);
515

516
    if (LoadActFile(".bin", &info)) {
517
        uint8 length   = ReadInt8(&info);
518
        titleCardWord2 = (uint8)length;
519
        for (int32 i = 0; i < length; i++) {
520
            titleCardText[i] = ReadInt8(&info);
521
            if (titleCardText[i] == '-')
522
                titleCardWord2 = (uint8)(i + 1);
523
        }
524
        titleCardText[length] = '\0';
525

526
        // READ TILELAYER
527
        ReadBytes(&info, activeTileLayers, 4);
528
        tLayerMidPoint = ReadInt8(&info);
529

530
        stageLayouts[0].xsize = ReadInt8(&info);
531
        stageLayouts[0].ysize = ReadInt8(&info);
532
        curXBoundary1         = 0;
533
        newXBoundary1         = 0;
534
        curYBoundary1         = 0;
535
        newYBoundary1         = 0;
536
        curXBoundary2         = stageLayouts[0].xsize << 7;
537
        curYBoundary2         = stageLayouts[0].ysize << 7;
538
        waterLevel            = curYBoundary2 + 128;
539
        newXBoundary2         = stageLayouts[0].xsize << 7;
540
        newYBoundary2         = stageLayouts[0].ysize << 7;
541

542
        for (int32 i = 0; i < 0x10000; ++i) stageLayouts[0].tiles[i] = 0;
543

544
        for (int32 y = 0; y < stageLayouts[0].ysize; ++y) {
545
            uint16 *tiles = &stageLayouts[0].tiles[y * 0x100];
546
            for (int32 x = 0; x < stageLayouts[0].xsize; ++x) {
547
                tiles[x] = ReadInt8(&info) << 8;
548
                tiles[x] |= ReadInt8(&info);
549
            }
550
        }
551

552
        // READ TYPENAMES
553
        int32 typenameCount = ReadInt8(&info);
554
        for (int32 i = 0; i < typenameCount; ++i) {
555
            int32 nameLen = ReadInt8(&info);
556
            for (int32 l = 0; l < nameLen; ++l) ReadInt8(&info);
557
        }
558

559
        // READ OBJECTS
560
        int32 entityCount = ReadInt8(&info) << 8;
561
        entityCount |= ReadInt8(&info);
562

563
#if !RETRO_USE_ORIGINAL_CODE
564
        if (entityCount > 0x400)
565
            PrintLog(PRINT_NORMAL, "WARNING: entity count %d exceeds the entity limit", entityCount);
566
#endif
567

568
#if RETRO_USE_MOD_LOADER
569
        int32 offsetCount = 0;
570
        for (int32 m = 0; m < modObjCount; ++m)
571
            if (modScriptFlags[m])
572
                ++offsetCount;
573
#endif
574

575
        Entity *entity = &objectEntityList[32];
576
        for (int32 i = 0; i < entityCount; ++i) {
577
            entity->type = ReadInt8(&info);
578

579
#if RETRO_USE_MOD_LOADER
580
            if (loadGlobalScripts && offsetCount && entity->type > globalObjCount)
581
                entity->type += offsetCount; // offset it by our mod count
582
#endif
583

584
            entity->propertyValue = ReadInt8(&info);
585

586
            entity->XPos = ReadInt8(&info) << 8;
587
            entity->XPos |= ReadInt8(&info);
588
            entity->XPos <<= 16;
589

590
            entity->YPos = ReadInt8(&info) << 8;
591
            entity->YPos |= ReadInt8(&info);
592
            entity->YPos <<= 16;
593

594
            ++entity;
595
        }
596
        CloseFile(&info);
597
    }
598
    stageLayouts[0].type = LAYER_HSCROLL;
599
}
600
void RSDK::Legacy::v3::LoadStageBackground()
601
{
602
    for (int32 i = 0; i < LEGACY_LAYER_COUNT; ++i) {
603
        stageLayouts[i].type               = LAYER_NOSCROLL;
604
        stageLayouts[i].deformationOffset  = 0;
605
        stageLayouts[i].deformationOffsetW = 0;
606
    }
607
    for (int32 i = 0; i < LEGACY_PARALLAX_COUNT; ++i) {
608
        hParallax.scrollPos[i] = 0;
609
        vParallax.scrollPos[i] = 0;
610
    }
611

612
    FileInfo info;
613
    InitFileInfo(&info);
614
    if (LoadStageFile("Backgrounds.bin", &info)) {
615
        uint8 layerCount = ReadInt8(&info);
616

617
        hParallax.entryCount = ReadInt8(&info);
618
        for (int32 i = 0; i < hParallax.entryCount; ++i) {
619
            hParallax.parallaxFactor[i] = ReadInt8(&info) << 8;
620
            hParallax.parallaxFactor[i] |= ReadInt8(&info);
621

622
            hParallax.scrollSpeed[i] = ReadInt8(&info) << 10;
623

624
            hParallax.scrollPos[i] = 0;
625

626
            hParallax.deform[i] = ReadInt8(&info);
627
        }
628

629
        vParallax.entryCount = ReadInt8(&info);
630
        for (int32 i = 0; i < vParallax.entryCount; ++i) {
631
            vParallax.parallaxFactor[i] = ReadInt8(&info) << 8;
632
            vParallax.parallaxFactor[i] |= ReadInt8(&info);
633

634
            vParallax.scrollSpeed[i] = ReadInt8(&info) << 10;
635

636
            vParallax.scrollPos[i] = 0;
637

638
            vParallax.deform[i] = ReadInt8(&info);
639
        }
640

641
        for (int32 i = 1; i < layerCount + 1; ++i) {
642
            stageLayouts[i].xsize = ReadInt8(&info);
643
            stageLayouts[i].ysize = ReadInt8(&info);
644

645
            stageLayouts[i].type = ReadInt8(&info);
646

647
            stageLayouts[i].parallaxFactor = ReadInt8(&info) << 8;
648
            stageLayouts[i].parallaxFactor |= ReadInt8(&info);
649

650
            stageLayouts[i].scrollSpeed = ReadInt8(&info) << 10;
651
            stageLayouts[i].scrollPos   = 0;
652

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

657
            // Read Line Scroll
658
            uint8 buf[3];
659
            while (true) {
660
                buf[0] = ReadInt8(&info);
661
                if (buf[0] == 0xFF) {
662
                    buf[1] = ReadInt8(&info);
663
                    if (buf[1] == 0xFF) {
664
                        break;
665
                    }
666
                    else {
667
                        buf[2]    = ReadInt8(&info);
668
                        int32 val = buf[1];
669
                        int32 cnt = buf[2] - 1;
670
                        for (int32 c = 0; c < cnt; ++c) *lineScrollPtr++ = val;
671
                    }
672
                }
673
                else {
674
                    *lineScrollPtr++ = buf[0];
675
                }
676
            }
677

678
            // Read Layout
679
            for (int32 y = 0; y < stageLayouts[i].ysize; ++y) {
680
                uint16 *chunks = &stageLayouts[i].tiles[y * 0x100];
681
                for (int32 x = 0; x < stageLayouts[i].xsize; ++x) {
682
                    *chunks = ReadInt8(&info) << 8;
683
                    *chunks |= ReadInt8(&info);
684

685
                    ++chunks;
686
                }
687
            }
688
        }
689

690
        CloseFile(&info);
691
    }
692
}
693

694
void RSDK::Legacy::v3::SetPlayerScreenPosition(Player *player)
695
{
696
    int32 playerXPos = player->XPos >> 16;
697
    int32 playerYPos = player->YPos >> 16;
698
    if (newYBoundary1 > curYBoundary1) {
699
        if (yScrollOffset <= newYBoundary1)
700
            curYBoundary1 = yScrollOffset;
701
        else
702
            curYBoundary1 = newYBoundary1;
703
    }
704
    if (newYBoundary1 < curYBoundary1) {
705
        if (yScrollOffset <= curYBoundary1)
706
            --curYBoundary1;
707
        else
708
            curYBoundary1 = newYBoundary1;
709
    }
710
    if (newYBoundary2 < curYBoundary2) {
711
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2 || yScrollOffset + SCREEN_YSIZE <= newYBoundary2)
712
            --curYBoundary2;
713
        else
714
            curYBoundary2 = yScrollOffset + SCREEN_YSIZE;
715
    }
716
    if (newYBoundary2 > curYBoundary2) {
717
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2)
718
            ++curYBoundary2;
719
        else
720
            curYBoundary2 = newYBoundary2;
721
    }
722
    if (newXBoundary1 > curXBoundary1) {
723
        if (xScrollOffset <= newXBoundary1)
724
            curXBoundary1 = xScrollOffset;
725
        else
726
            curXBoundary1 = newXBoundary1;
727
    }
728
    if (newXBoundary1 < curXBoundary1) {
729
        if (xScrollOffset <= curXBoundary1) {
730
            --curXBoundary1;
731
            if (player->XVelocity < 0) {
732
                curXBoundary1 += player->XVelocity >> 16;
733
                if (curXBoundary1 < newXBoundary1)
734
                    curXBoundary1 = newXBoundary1;
735
            }
736
        }
737
        else {
738
            curXBoundary1 = newXBoundary1;
739
        }
740
    }
741
    if (newXBoundary2 < curXBoundary2) {
742
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2)
743
            curXBoundary2 = SCREEN_XSIZE + xScrollOffset;
744
        else
745
            curXBoundary2 = newXBoundary2;
746
    }
747
    if (newXBoundary2 > curXBoundary2) {
748
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2) {
749
            ++curXBoundary2;
750
            if (player->XVelocity > 0) {
751
                curXBoundary2 += player->XVelocity >> 16;
752
                if (curXBoundary2 > newXBoundary2)
753
                    curXBoundary2 = newXBoundary2;
754
            }
755
        }
756
        else {
757
            curXBoundary2 = newXBoundary2;
758
        }
759
    }
760
    int32 xscrollA     = xScrollA;
761
    int32 xscrollB     = xScrollB;
762
    int32 scrollAmount = playerXPos - (SCREEN_CENTERX + xScrollA);
763
    if (abs(playerXPos - (SCREEN_CENTERX + xScrollA)) >= 25) {
764
        if (scrollAmount <= 0)
765
            xscrollA -= 16;
766
        else
767
            xscrollA += 16;
768
        xscrollB = SCREEN_XSIZE + xscrollA;
769
    }
770
    else {
771
        if (playerXPos > (SCREEN_CENTERX + 8) + xscrollA) {
772
            xscrollA = playerXPos - (SCREEN_CENTERX + 8);
773
            xscrollB = SCREEN_XSIZE + playerXPos - (SCREEN_CENTERX + 8);
774
        }
775
        if (playerXPos < (SCREEN_CENTERX - 8) + xscrollA) {
776
            xscrollA = playerXPos - (SCREEN_CENTERX - 8);
777
            xscrollB = SCREEN_XSIZE + playerXPos - (SCREEN_CENTERX - 8);
778
        }
779
    }
780
    if (xscrollA < curXBoundary1) {
781
        xscrollA = curXBoundary1;
782
        xscrollB = SCREEN_XSIZE + curXBoundary1;
783
    }
784
    if (xscrollB > curXBoundary2) {
785
        xscrollB = curXBoundary2;
786
        xscrollA = curXBoundary2 - SCREEN_XSIZE;
787
    }
788

789
    xScrollA = xscrollA;
790
    xScrollB = xscrollB;
791
    if (playerXPos <= SCREEN_CENTERX + xscrollA) {
792
        player->screenXPos = cameraShakeX + playerXPos - xscrollA;
793
        xScrollOffset      = xscrollA - cameraShakeX;
794
    }
795
    else {
796
        xScrollOffset      = cameraShakeX + playerXPos - SCREEN_CENTERX;
797
        player->screenXPos = SCREEN_CENTERX - cameraShakeX;
798
        if (playerXPos > xscrollB - SCREEN_CENTERX) {
799
            player->screenXPos = cameraShakeX + SCREEN_CENTERX + playerXPos - (xscrollB - SCREEN_CENTERX);
800
            xScrollOffset      = xscrollB - SCREEN_XSIZE - cameraShakeX;
801
        }
802
    }
803

804
    int32 yscrollA     = yScrollA;
805
    int32 yscrollB     = yScrollB;
806
    int32 adjustYPos   = currentCamera->adjustY + playerYPos;
807
    int32 adjustAmount = player->lookPos + adjustYPos - (yscrollA + LEGACY_SCREEN_SCROLL_UP);
808
    if (player->trackScroll) {
809
        yScrollMove = 32;
810
    }
811
    else {
812
        if (yScrollMove == 32) {
813
            yScrollMove = 2 * ((LEGACY_SCREEN_SCROLL_UP - player->screenYPos - player->lookPos) >> 1);
814
            if (yScrollMove > 32)
815
                yScrollMove = 32;
816
            if (yScrollMove < -32)
817
                yScrollMove = -32;
818
        }
819
        if (yScrollMove > 0)
820
            yScrollMove -= 6;
821
        yScrollMove += yScrollMove < 0 ? 6 : 0;
822
    }
823

824
    if (abs(adjustAmount) >= abs(yScrollMove) + 17) {
825
        if (adjustAmount <= 0)
826
            yscrollA -= 16;
827
        else
828
            yscrollA += 16;
829
        yscrollB = yscrollA + SCREEN_YSIZE;
830
    }
831
    else if (yScrollMove == 32) {
832
        if (player->lookPos + adjustYPos > yscrollA + yScrollMove + LEGACY_SCREEN_SCROLL_UP) {
833
            yscrollA = player->lookPos + adjustYPos - (yScrollMove + LEGACY_SCREEN_SCROLL_UP);
834
            yscrollB = yscrollA + SCREEN_YSIZE;
835
        }
836
        if (player->lookPos + adjustYPos < yscrollA + LEGACY_SCREEN_SCROLL_UP - yScrollMove) {
837
            yscrollA = player->lookPos + adjustYPos - (LEGACY_SCREEN_SCROLL_UP - yScrollMove);
838
            yscrollB = yscrollA + SCREEN_YSIZE;
839
        }
840
    }
841
    else {
842
        yscrollA = player->lookPos + adjustYPos + yScrollMove - LEGACY_SCREEN_SCROLL_UP;
843
        yscrollB = yscrollA + SCREEN_YSIZE;
844
    }
845
    if (yscrollA < curYBoundary1) {
846
        yscrollA = curYBoundary1;
847
        yscrollB = curYBoundary1 + SCREEN_YSIZE;
848
    }
849
    if (yscrollB > curYBoundary2) {
850
        yscrollB = curYBoundary2;
851
        yscrollA = curYBoundary2 - SCREEN_YSIZE;
852
    }
853
    yScrollA = yscrollA;
854
    yScrollB = yscrollB;
855
    if (player->lookPos + adjustYPos <= yScrollA + LEGACY_SCREEN_SCROLL_UP) {
856
        player->screenYPos = adjustYPos - yScrollA - cameraShakeY;
857
        yScrollOffset      = cameraShakeY + yScrollA;
858
    }
859
    else {
860
        yScrollOffset      = cameraShakeY + adjustYPos + player->lookPos - LEGACY_SCREEN_SCROLL_UP;
861
        player->screenYPos = LEGACY_SCREEN_SCROLL_UP - player->lookPos - cameraShakeY;
862
        if (player->lookPos + adjustYPos > yScrollB - LEGACY_SCREEN_SCROLL_DOWN) {
863
            player->screenYPos = adjustYPos - (yScrollB - LEGACY_SCREEN_SCROLL_DOWN) + cameraShakeY + LEGACY_SCREEN_SCROLL_UP;
864
            yScrollOffset      = yScrollB - SCREEN_YSIZE - cameraShakeY;
865
        }
866
    }
867
    player->screenYPos -= currentCamera->adjustY;
868

869
    if (cameraShakeX) {
870
        if (cameraShakeX <= 0) {
871
            cameraShakeX = ~cameraShakeX;
872
        }
873
        else {
874
            cameraShakeX = -cameraShakeX;
875
        }
876
    }
877

878
    if (cameraShakeY) {
879
        if (cameraShakeY <= 0) {
880
            cameraShakeY = ~cameraShakeY;
881
        }
882
        else {
883
            cameraShakeY = -cameraShakeY;
884
        }
885
    }
886
}
887
void RSDK::Legacy::v3::SetPlayerScreenPositionCDStyle(Player *player)
888
{
889
    int32 playerXPos = player->XPos >> 16;
890
    int32 playerYPos = player->YPos >> 16;
891

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

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

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

913
    if (newYBoundary2 > curYBoundary2) {
914
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2)
915
            ++curYBoundary2;
916
        else
917
            curYBoundary2 = newYBoundary2;
918
    }
919

920
    if (newXBoundary1 > curXBoundary1) {
921
        if (xScrollOffset <= newXBoundary1)
922
            curXBoundary1 = xScrollOffset;
923
        else
924
            curXBoundary1 = newXBoundary1;
925
    }
926

927
    if (newXBoundary1 < curXBoundary1) {
928
        if (xScrollOffset <= curXBoundary1) {
929
            --curXBoundary1;
930
            if (player->XVelocity < 0) {
931
                curXBoundary1 += player->XVelocity >> 16;
932
                if (curXBoundary1 < newXBoundary1)
933
                    curXBoundary1 = newXBoundary1;
934
            }
935
        }
936
        else {
937
            curXBoundary1 = newXBoundary1;
938
        }
939
    }
940

941
    if (newXBoundary2 < curXBoundary2) {
942
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2)
943
            curXBoundary2 = SCREEN_XSIZE + xScrollOffset;
944
        else
945
            curXBoundary2 = newXBoundary2;
946
    }
947

948
    if (newXBoundary2 > curXBoundary2) {
949
        if (SCREEN_XSIZE + xScrollOffset >= curXBoundary2) {
950
            ++curXBoundary2;
951
            if (player->XVelocity > 0) {
952
                curXBoundary2 += player->XVelocity >> 16;
953
                if (curXBoundary2 > newXBoundary2)
954
                    curXBoundary2 = newXBoundary2;
955
            }
956
        }
957
        else {
958
            curXBoundary2 = newXBoundary2;
959
        }
960
    }
961

962
    if (!player->gravity) {
963
        if (player->boundEntity->direction) {
964
            if (currentCamera->style == CAMERASTYLE_EXTENDED_OFFSET_R || player->speed < -0x5F5C2)
965
                cameraLagStyle = 2;
966
            else
967
                cameraLagStyle = 0;
968
        }
969
        else {
970
            cameraLagStyle = (currentCamera->style == CAMERASTYLE_EXTENDED_OFFSET_L || player->speed > 0x5F5C2) != 0;
971
        }
972
    }
973

974
    if (cameraLagStyle) {
975
        if (cameraLagStyle == 1) {
976
            if (cameraLag > -64)
977
                cameraLag -= 2;
978
        }
979
        else if (cameraLagStyle == 2 && cameraLag < 64) {
980
            cameraLag += 2;
981
        }
982
    }
983
    else {
984
        cameraLag += cameraLag < 0 ? 2 : 0;
985
        if (cameraLag > 0)
986
            cameraLag -= 2;
987
    }
988
    if (playerXPos <= cameraLag + SCREEN_CENTERX + curXBoundary1) {
989
        player->screenXPos = cameraShakeX + playerXPos - curXBoundary1;
990
        xScrollOffset      = curXBoundary1 - cameraShakeX;
991
    }
992
    else {
993
        xScrollOffset      = cameraShakeX + playerXPos - SCREEN_CENTERX - cameraLag;
994
        player->screenXPos = cameraLag + SCREEN_CENTERX - cameraShakeX;
995
        if (playerXPos - cameraLag > curXBoundary2 - SCREEN_CENTERX) {
996
            player->screenXPos = cameraShakeX + SCREEN_CENTERX + playerXPos - (curXBoundary2 - SCREEN_CENTERX);
997
            xScrollOffset      = curXBoundary2 - SCREEN_XSIZE - cameraShakeX;
998
        }
999
    }
1000
    xScrollA           = xScrollOffset;
1001
    xScrollB           = SCREEN_XSIZE + xScrollOffset;
1002
    int32 yscrollA     = yScrollA;
1003
    int32 yscrollB     = yScrollB;
1004
    int32 adjustY      = currentCamera->adjustY + playerYPos;
1005
    int32 adjustOffset = player->lookPos + adjustY - (yScrollA + LEGACY_SCREEN_SCROLL_UP);
1006
    if (player->trackScroll == 1) {
1007
        yScrollMove = 32;
1008
    }
1009
    else {
1010
        if (yScrollMove == 32) {
1011
            yScrollMove = 2 * ((LEGACY_SCREEN_SCROLL_UP - player->screenYPos - player->lookPos) >> 1);
1012
            if (yScrollMove > 32)
1013
                yScrollMove = 32;
1014
            if (yScrollMove < -32)
1015
                yScrollMove = -32;
1016
        }
1017
        if (yScrollMove > 0)
1018
            yScrollMove -= 6;
1019
        yScrollMove += yScrollMove < 0 ? 6 : 0;
1020
    }
1021

1022
    int32 absAdjust = abs(adjustOffset);
1023
    if (absAdjust >= abs(yScrollMove) + 17) {
1024
        if (adjustOffset <= 0)
1025
            yscrollA -= 16;
1026
        else
1027
            yscrollA += 16;
1028
        yscrollB = yscrollA + SCREEN_YSIZE;
1029
    }
1030
    else if (yScrollMove == 32) {
1031
        if (player->lookPos + adjustY > yscrollA + yScrollMove + LEGACY_SCREEN_SCROLL_UP) {
1032
            yscrollA = player->lookPos + adjustY - (yScrollMove + LEGACY_SCREEN_SCROLL_UP);
1033
            yscrollB = yscrollA + SCREEN_YSIZE;
1034
        }
1035
        if (player->lookPos + adjustY < yscrollA + LEGACY_SCREEN_SCROLL_UP - yScrollMove) {
1036
            yscrollA = player->lookPos + adjustY - (LEGACY_SCREEN_SCROLL_UP - yScrollMove);
1037
            yscrollB = yscrollA + SCREEN_YSIZE;
1038
        }
1039
    }
1040
    else {
1041
        yscrollA = player->lookPos + adjustY + yScrollMove - LEGACY_SCREEN_SCROLL_UP;
1042
        yscrollB = yscrollA + SCREEN_YSIZE;
1043
    }
1044
    if (yscrollA < curYBoundary1) {
1045
        yscrollA = curYBoundary1;
1046
        yscrollB = curYBoundary1 + SCREEN_YSIZE;
1047
    }
1048
    if (yscrollB > curYBoundary2) {
1049
        yscrollB = curYBoundary2;
1050
        yscrollA = curYBoundary2 - SCREEN_YSIZE;
1051
    }
1052
    yScrollA = yscrollA;
1053
    yScrollB = yscrollB;
1054
    if (player->lookPos + adjustY <= yscrollA + LEGACY_SCREEN_SCROLL_UP) {
1055
        player->screenYPos = adjustY - yscrollA - cameraShakeY;
1056
        yScrollOffset      = cameraShakeY + yscrollA;
1057
    }
1058
    else {
1059
        yScrollOffset      = cameraShakeY + adjustY + player->lookPos - LEGACY_SCREEN_SCROLL_UP;
1060
        player->screenYPos = LEGACY_SCREEN_SCROLL_UP - player->lookPos - cameraShakeY;
1061
        if (player->lookPos + adjustY > yscrollB - LEGACY_SCREEN_SCROLL_DOWN) {
1062
            player->screenYPos = adjustY - (yscrollB - LEGACY_SCREEN_SCROLL_DOWN) + cameraShakeY + LEGACY_SCREEN_SCROLL_UP;
1063
            yScrollOffset      = yscrollB - SCREEN_YSIZE - cameraShakeY;
1064
        }
1065
    }
1066
    player->screenYPos -= currentCamera->adjustY;
1067

1068
    if (cameraShakeX) {
1069
        if (cameraShakeX <= 0) {
1070
            cameraShakeX = ~cameraShakeX;
1071
        }
1072
        else {
1073
            cameraShakeX = -cameraShakeX;
1074
        }
1075
    }
1076

1077
    if (cameraShakeY) {
1078
        if (cameraShakeY <= 0) {
1079
            cameraShakeY = ~cameraShakeY;
1080
        }
1081
        else {
1082
            cameraShakeY = -cameraShakeY;
1083
        }
1084
    }
1085
}
1086
void RSDK::Legacy::v3::SetPlayerHLockedScreenPosition(Player *player)
1087
{
1088
    int32 playerXPos = player->XPos >> 16;
1089
    int32 playerYPos = player->YPos >> 16;
1090
    if (newYBoundary1 > curYBoundary1) {
1091
        if (yScrollOffset <= newYBoundary1)
1092
            curYBoundary1 = yScrollOffset;
1093
        else
1094
            curYBoundary1 = newYBoundary1;
1095
    }
1096
    if (newYBoundary1 < curYBoundary1) {
1097
        if (yScrollOffset <= curYBoundary1)
1098
            --curYBoundary1;
1099
        else
1100
            curYBoundary1 = newYBoundary1;
1101
    }
1102
    if (newYBoundary2 < curYBoundary2) {
1103
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2 || yScrollOffset + SCREEN_YSIZE <= newYBoundary2)
1104
            --curYBoundary2;
1105
        else
1106
            curYBoundary2 = yScrollOffset + SCREEN_YSIZE;
1107
    }
1108
    if (newYBoundary2 > curYBoundary2) {
1109
        if (yScrollOffset + SCREEN_YSIZE >= curYBoundary2)
1110
            ++curYBoundary2;
1111
        else
1112
            curYBoundary2 = newYBoundary2;
1113
    }
1114

1115
    int32 xscrollA = xScrollA;
1116
    int32 xscrollB = xScrollB;
1117
    if (playerXPos <= SCREEN_CENTERX + xScrollA) {
1118
        player->screenXPos = cameraShakeX + playerXPos - xScrollA;
1119
        xScrollOffset      = xscrollA - cameraShakeX;
1120
    }
1121
    else {
1122
        xScrollOffset      = cameraShakeX + playerXPos - SCREEN_CENTERX;
1123
        player->screenXPos = SCREEN_CENTERX - cameraShakeX;
1124
        if (playerXPos > xscrollB - SCREEN_CENTERX) {
1125
            player->screenXPos = cameraShakeX + SCREEN_CENTERX + playerXPos - (xscrollB - SCREEN_CENTERX);
1126
            xScrollOffset      = xscrollB - SCREEN_XSIZE - cameraShakeX;
1127
        }
1128
    }
1129

1130
    int32 yscrollA   = yScrollA;
1131
    int32 yscrollB   = yScrollB;
1132
    int32 adjustY    = currentCamera->adjustY + playerYPos;
1133
    int32 lookOffset = player->lookPos + adjustY - (yScrollA + LEGACY_SCREEN_SCROLL_UP);
1134
    if (player->trackScroll == 1) {
1135
        yScrollMove = 32;
1136
    }
1137
    else {
1138
        if (yScrollMove == 32) {
1139
            yScrollMove = 2 * ((LEGACY_SCREEN_SCROLL_UP - player->screenYPos - player->lookPos) >> 1);
1140
            if (yScrollMove > 32)
1141
                yScrollMove = 32;
1142
            if (yScrollMove < -32)
1143
                yScrollMove = -32;
1144
        }
1145
        if (yScrollMove > 0)
1146
            yScrollMove -= 6;
1147
        yScrollMove += yScrollMove < 0 ? 6 : 0;
1148
    }
1149

1150
    int32 absLook = abs(lookOffset);
1151
    if (absLook >= abs(yScrollMove) + 17) {
1152
        if (lookOffset <= 0)
1153
            yscrollA -= 16;
1154
        else
1155
            yscrollA += 16;
1156
        yscrollB = yscrollA + SCREEN_YSIZE;
1157
    }
1158
    else if (yScrollMove == 32) {
1159
        if (player->lookPos + adjustY > yscrollA + yScrollMove + LEGACY_SCREEN_SCROLL_UP) {
1160
            yscrollA = player->lookPos + adjustY - (yScrollMove + LEGACY_SCREEN_SCROLL_UP);
1161
            yscrollB = yscrollA + SCREEN_YSIZE;
1162
        }
1163
        if (player->lookPos + adjustY < yscrollA + LEGACY_SCREEN_SCROLL_UP - yScrollMove) {
1164
            yscrollA = player->lookPos + adjustY - (LEGACY_SCREEN_SCROLL_UP - yScrollMove);
1165
            yscrollB = yscrollA + SCREEN_YSIZE;
1166
        }
1167
    }
1168
    else {
1169
        yscrollA = player->lookPos + adjustY + yScrollMove - LEGACY_SCREEN_SCROLL_UP;
1170
        yscrollB = yscrollA + SCREEN_YSIZE;
1171
    }
1172
    if (yscrollA < curYBoundary1) {
1173
        yscrollA = curYBoundary1;
1174
        yscrollB = curYBoundary1 + SCREEN_YSIZE;
1175
    }
1176
    if (yscrollB > curYBoundary2) {
1177
        yscrollB = curYBoundary2;
1178
        yscrollA = curYBoundary2 - SCREEN_YSIZE;
1179
    }
1180
    yScrollA = yscrollA;
1181
    yScrollB = yscrollB;
1182
    if (player->lookPos + adjustY <= yscrollA + LEGACY_SCREEN_SCROLL_UP) {
1183
        player->screenYPos = adjustY - yscrollA - cameraShakeY;
1184
        yScrollOffset      = cameraShakeY + yscrollA;
1185
    }
1186
    else {
1187
        yScrollOffset      = cameraShakeY + adjustY + player->lookPos - LEGACY_SCREEN_SCROLL_UP;
1188
        player->screenYPos = LEGACY_SCREEN_SCROLL_UP - player->lookPos - cameraShakeY;
1189
        if (player->lookPos + adjustY > yscrollB - LEGACY_SCREEN_SCROLL_DOWN) {
1190
            player->screenYPos = adjustY - (yscrollB - LEGACY_SCREEN_SCROLL_DOWN) + cameraShakeY + LEGACY_SCREEN_SCROLL_UP;
1191
            yScrollOffset      = yscrollB - SCREEN_YSIZE - cameraShakeY;
1192
        }
1193
    }
1194
    player->screenYPos -= currentCamera->adjustY;
1195

1196
    if (cameraShakeX) {
1197
        if (cameraShakeX <= 0) {
1198
            cameraShakeX = ~cameraShakeX;
1199
        }
1200
        else {
1201
            cameraShakeX = -cameraShakeX;
1202
        }
1203
    }
1204

1205
    if (cameraShakeY) {
1206
        if (cameraShakeY <= 0) {
1207
            cameraShakeY = ~cameraShakeY;
1208
        }
1209
        else {
1210
            cameraShakeY = -cameraShakeY;
1211
        }
1212
    }
1213
}
1214
void RSDK::Legacy::v3::SetPlayerLockedScreenPosition(Player *player)
1215
{
1216
    int32 playerXPos = player->XPos >> 16;
1217
    int32 playerYPos = player->YPos >> 16;
1218
    int32 xscrollA   = xScrollA;
1219
    int32 xscrollB   = xScrollB;
1220
    if (playerXPos <= SCREEN_CENTERX + xScrollA) {
1221
        player->screenXPos = cameraShakeX + playerXPos - xScrollA;
1222
        xScrollOffset      = xscrollA - cameraShakeX;
1223
    }
1224
    else {
1225
        xScrollOffset      = cameraShakeX + playerXPos - SCREEN_CENTERX;
1226
        player->screenXPos = SCREEN_CENTERX - cameraShakeX;
1227
        if (playerXPos > xscrollB - SCREEN_CENTERX) {
1228
            player->screenXPos = cameraShakeX + SCREEN_CENTERX + playerXPos - (xscrollB - SCREEN_CENTERX);
1229
            xScrollOffset      = xscrollB - SCREEN_XSIZE - cameraShakeX;
1230
        }
1231
    }
1232

1233
    int32 yscrollA = yScrollA;
1234
    int32 yscrollB = yScrollB;
1235
    int32 adjustY  = currentCamera->adjustY + playerYPos;
1236
    // int32 adjustOffset = player->lookPos + adjustY - (yScrollA + LEGACY_SCREEN_SCROLL_UP);
1237
    if (player->lookPos + adjustY <= yScrollA + LEGACY_SCREEN_SCROLL_UP) {
1238
        player->screenYPos = adjustY - yScrollA - cameraShakeY;
1239
        yScrollOffset      = cameraShakeY + yscrollA;
1240
    }
1241
    else {
1242
        yScrollOffset      = cameraShakeY + adjustY + player->lookPos - LEGACY_SCREEN_SCROLL_UP;
1243
        player->screenYPos = LEGACY_SCREEN_SCROLL_UP - player->lookPos - cameraShakeY;
1244
        if (player->lookPos + adjustY > yscrollB - LEGACY_SCREEN_SCROLL_DOWN) {
1245
            player->screenYPos = adjustY - (yscrollB - LEGACY_SCREEN_SCROLL_DOWN) + cameraShakeY + LEGACY_SCREEN_SCROLL_UP;
1246
            yScrollOffset      = yscrollB - SCREEN_YSIZE - cameraShakeY;
1247
        }
1248
    }
1249
    player->screenYPos -= currentCamera->adjustY;
1250

1251
    if (cameraShakeX) {
1252
        if (cameraShakeX <= 0) {
1253
            cameraShakeX = ~cameraShakeX;
1254
        }
1255
        else {
1256
            cameraShakeX = -cameraShakeX;
1257
        }
1258
    }
1259

1260
    if (cameraShakeY) {
1261
        if (cameraShakeY <= 0) {
1262
            cameraShakeY = ~cameraShakeY;
1263
        }
1264
        else {
1265
            cameraShakeY = -cameraShakeY;
1266
        }
1267
    }
1268
}
1269

1270
Product

Resources

Company
