Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
rubberduckycooly
GitHub Repository: rubberduckycooly/Sonic-1-2-2013-Decompilation
 Path: blob/main/RSDKv4/NativeObjects/PlayerSelectScreen.cpp
817 views
1
#include "RetroEngine.hpp"

2


3
void PlayerSelectScreen_Create(void *objPtr)

4
{

5
    RSDK_THIS(PlayerSelectScreen);

6
    self->labelPtr                  = CREATE_ENTITY(TextLabel);

7
    self->labelPtr->useRenderMatrix = true;

8
    self->labelPtr->fontID          = FONT_HEADING;

9
    self->labelPtr->scale           = 0.2;

10
    self->labelPtr->alpha           = 256;

11
    self->labelPtr->x               = -144.0;

12
    self->labelPtr->y               = 100.0;

13
    self->labelPtr->z               = 16.0;

14
    self->labelPtr->state           = TEXTLABEL_STATE_IDLE;

15
    SetStringToFont(self->labelPtr->text, strPlayerSelect, FONT_HEADING);

16


17
    SetStringToFont(self->textSonic, strSonic, FONT_TEXT);

18


19
    self->sonicX = (GetTextWidth(self->textSonic, FONT_TEXT, 0.2) * -0.5) - 88.0;

20


21
    SetStringToFont(self->textTails, strTails, FONT_TEXT);

22
    self->tailsX = GetTextWidth(self->textTails, FONT_TEXT, 0.2) * -0.5;

23


24
    SetStringToFont(self->textKnux, strKnuckles, FONT_TEXT);

25
    self->knuxX = (GetTextWidth(self->textKnux, FONT_TEXT, 0.2) * -0.5) + 88.0;

26


27
    self->meshPanel = LoadMesh("Data/Game/Models/Panel.bin", 255);

28
    SetMeshVertexColors(self->meshPanel, 0, 0, 0, 0xC0);

29


30
    self->textureArrows    = LoadTexture("Data/Game/Menu/ArrowButtons.png", TEXFMT_RGBA4444);

31
    self->texturePlayerSel = LoadTexture("Data/Game/Menu/PlayerSelect.png", TEXFMT_RGBA8888);

32
    self->backPressed      = false;

33
    self->flag             = true;

34
}

35
void PlayerSelectScreen_Main(void *objPtr)

36
{

37
    RSDK_THIS(PlayerSelectScreen);

38


39
    NativeEntity_SaveSelect *saveSel = self->saveSel;

40
    NativeEntity_TextLabel *label    = self->labelPtr;

41
    SaveGame *saveGame               = (SaveGame *)saveRAM;

42


43
    switch (self->state) {

44
        case PLAYERSELECTSCREEN_STATE_ENTER:

45
            if (self->alpha < 0x100)

46
                self->alpha += 8;

47


48
            self->scale += ((1.025 - self->scale) / ((60.0 * Engine.deltaTime) * 8.0));

49
            if (self->scale < -8.0)

50
                self->scale = -8.0;

51


52
            NewRenderState();

53
            MatrixScaleXYZF(&self->matrix1, self->scale, self->scale, 1.0);

54
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);

55
            MatrixMultiplyF(&self->matrix1, &self->matrixTemp);

56
            SetRenderMatrix(&self->matrix1);

57
            label->renderMatrix = self->matrix1;

58


59
            self->timer += Engine.deltaTime;

60
            if (self->timer > 0.5) {

61
                self->timer      = 0.0;

62
                self->state      = PLAYERSELECTSCREEN_STATE_MAIN;

63
                keyPress.start = false;

64
                keyPress.A     = false;

65
                self->alpha      = 256;

66
                if (usePhysicalControls)

67
                    self->playerID = SAVESEL_SONIC;

68
            }

69
            break;

70


71
        case PLAYERSELECTSCREEN_STATE_MAIN:

72
            CheckKeyDown(&keyDown);

73
            CheckKeyPress(&keyPress);

74
            SetRenderMatrix(&self->matrixTemp);

75
            if (usePhysicalControls) {

76
                if (touches > 0) {

77
                    usePhysicalControls = false;

78
                }

79
                else {

80
                    if (keyPress.left) {

81
                        if (saveGame->knuxUnlocked) {

82
                            PlaySfxByName("Menu Move", false);

83
                            if (--self->playerID < SAVESEL_SONIC)

84
                                self->playerID = SAVESEL_KNUX;

85
                        }

86
                        else if (saveGame->tailsUnlocked) {

87
                            PlaySfxByName("Menu Move", false);

88
                            if (--self->playerID > SAVESEL_SONIC)

89
                                self->playerID = SAVESEL_TAILS;

90
                        }

91
                    }

92
                    else if (keyPress.right) {

93
                        if (saveGame->knuxUnlocked) {

94
                            PlaySfxByName("Menu Move", false);

95


96
                            if (++self->playerID > SAVESEL_KNUX)

97
                                self->playerID = SAVESEL_SONIC;

98
                        }

99
                        else if (saveGame->tailsUnlocked) {

100
                            PlaySfxByName("Menu Move", false);

101


102
                            if (++self->playerID > SAVESEL_TAILS)

103
                                self->playerID = SAVESEL_SONIC;

104
                        }

105
                        else {

106
                            self->playerID = SAVESEL_SONIC;

107
                        }

108
                    }

109
                    if (keyPress.start || keyPress.A) {

110
                        PlaySfxByName("Menu Select", false);

111
                        StopMusic(true);

112
                        self->state = PLAYERSELECTSCREEN_STATE_ACTION;

113
                    }

114
                    else if (keyPress.B) {

115
                        PlaySfxByName("Menu Back", false);

116
                        self->backPressed = false;

117
                        self->state       = PLAYERSELECTSCREEN_STATE_EXIT;

118
                    }

119
                }

120
            }

121
            else {

122
                if (touches > 0) {

123
                    if (CheckTouchRect(-88.0, 24.0, 40.0, 40.0) < 0) {

124
                        if (self->playerID == SAVESEL_SONIC)

125
                            self->playerID = SAVESEL_NONE;

126
                    }

127
                    else {

128
                        self->playerID = SAVESEL_SONIC;

129
                    }

130
                    if (saveGame->tailsUnlocked) {

131
                        if (CheckTouchRect(-84.0, -64.0, 16.0, 16.0) < 0) {

132
                            if (self->playerID == SAVESEL_ST)

133
                                self->playerID = SAVESEL_SONIC;

134
                        }

135
                        else {

136
                            self->playerID = SAVESEL_ST;

137
                        }

138
                        if (CheckTouchRect(0.0, -16.0, 40.0, 40.0) < 0) {

139
                            if (self->playerID == SAVESEL_TAILS)

140
                                self->playerID = SAVESEL_NONE;

141
                        }

142
                        else {

143
                            self->playerID = SAVESEL_TAILS;

144
                        }

145
                    }

146
                    if (saveGame->knuxUnlocked) {

147
                        if (CheckTouchRect(88.0, 24.0, 40.0, 40.0) < 0) {

148
                            if (self->playerID == SAVESEL_KNUX)

149
                                self->playerID = SAVESEL_NONE;

150
                        }

151
                        else {

152
                            self->playerID = SAVESEL_KNUX;

153
                        }

154
                    }

155
                    self->backPressed = CheckTouchRect(128.0, -92.0, 32.0, 32.0) >= 0;

156
                    if (self->state == PLAYERSELECTSCREEN_STATE_MAIN && (keyDown.left || keyDown.right)) {

157
                        usePhysicalControls = true;

158
                        self->playerID      = SAVESEL_SONIC;

159
                    }

160
                }

161
                else {

162
                    if (self->playerID > 0) {

163
                        PlaySfxByName("Menu Select", false);

164
                        StopMusic(true);

165
                        self->state = PLAYERSELECTSCREEN_STATE_ACTION;

166
                    }

167
                    if (self->backPressed || keyPress.B) {

168
                        PlaySfxByName("Menu Back", false);

169
                        self->backPressed = false;

170
                        self->state       = PLAYERSELECTSCREEN_STATE_EXIT;

171
                    }

172
                    else if (self->state == PLAYERSELECTSCREEN_STATE_MAIN && (keyDown.left || keyDown.right)) {

173
                        usePhysicalControls = true;

174
                        self->playerID      = SAVESEL_SONIC;

175
                    }

176
                }

177
            }

178
            break;

179


180
        case PLAYERSELECTSCREEN_STATE_ACTION:

181
            SetRenderMatrix(&self->matrixTemp);

182


183
            self->timer2 += Engine.deltaTime;

184
            self->timer += Engine.deltaTime;

185
            if (self->timer2 > 0.1) {

186
                self->timer2 -= 0.1;

187
            }

188
            self->flag = self->timer2 > 0.05;

189


190
            if (self->timer > 1.0) {

191
                self->flag  = true;

192
                self->timer = 0.0;

193
                self->state = PLAYERSELECTSCREEN_STATE_IDLE;

194
                if (saveSel->selectedButton <= 0) {

195
                    SetGlobalVariableByName("options.saveSlot", 0);

196
                    SetGlobalVariableByName("options.gameMode", 0);

197
                }

198
                else {

199
                    SetGlobalVariableByName("options.saveSlot", saveSel->selectedButton - 1);

200
                    SetGlobalVariableByName("options.gameMode", 1);

201


202
                    switch (self->playerID) {

203
                        case SAVESEL_SONIC: saveGame->files[saveSel->selectedButton - 1].characterID = 0; break;

204
                        case SAVESEL_TAILS: saveGame->files[saveSel->selectedButton - 1].characterID = 1; break;

205
                        case SAVESEL_KNUX: saveGame->files[saveSel->selectedButton - 1].characterID = 2; break;

206
                        case SAVESEL_ST: saveGame->files[saveSel->selectedButton - 1].characterID = 3; break;

207
                    }

208


209
                    saveGame->files[saveSel->selectedButton - 1].lives          = 3;

210
                    saveGame->files[saveSel->selectedButton - 1].score          = 0;

211
                    saveGame->files[saveSel->selectedButton - 1].scoreBonus     = 500000;

212
                    saveGame->files[saveSel->selectedButton - 1].stageID        = 1;

213
                    saveGame->files[saveSel->selectedButton - 1].emeralds       = 0;

214
                    saveGame->files[saveSel->selectedButton - 1].specialStageID = 0;

215
                    WriteSaveRAMData();

216
                }

217
                SetGlobalVariableByName("options.stageSelectFlag", 0);

218
                SetGlobalVariableByName("player.lives", 3);

219
                SetGlobalVariableByName("player.score", 0);

220
                SetGlobalVariableByName("player.scoreBonus", 50000);

221
                SetGlobalVariableByName("specialStage.listPos", 0);

222
                SetGlobalVariableByName("specialStage.emeralds", 0);

223
                SetGlobalVariableByName("specialStage.nextZone", 0);

224
                SetGlobalVariableByName("timeAttack.result", 0);

225
                SetGlobalVariableByName("lampPostID", 0);

226
                SetGlobalVariableByName("starPostID", 0);

227
                debugMode = false;

228


229
                int charID = 0;

230
                switch (self->playerID) {

231
                    case SAVESEL_SONIC: charID = 0; break;

232
                    case SAVESEL_TAILS: charID = 1; break;

233
                    case SAVESEL_KNUX: charID = 2; break;

234
                    case SAVESEL_ST: charID = 3; break;

235
                }

236
                InitStartingStage(STAGELIST_PRESENTATION, 0, charID);

237


238
                CREATE_ENTITY(FadeScreen);

239
            }

240
            break;

241


242
        case PLAYERSELECTSCREEN_STATE_IDLE: SetRenderMatrix(&self->matrixTemp); break;

243


244
        case PLAYERSELECTSCREEN_STATE_EXIT:

245
            if (self->alpha > 0)

246
                self->alpha -= 8;

247


248
            if (self->timer >= 0.2)

249
                self->scale += ((-1.0f - self->scale) / ((60.0 * Engine.deltaTime) * 8.0));

250
            else

251
                self->scale += ((1.5 - self->scale) / ((60.0 * Engine.deltaTime) * 8.0));

252
            if (self->scale < 0.0)

253
                self->scale = 0.0;

254


255
            NewRenderState();

256
            MatrixScaleXYZF(&self->matrix1, self->scale, self->scale, 1.0);

257
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);

258
            MatrixMultiplyF(&self->matrix1, &self->matrixTemp);

259
            SetRenderMatrix(&self->matrix1);

260
            label->renderMatrix = self->matrix1;

261


262
            self->timer += Engine.deltaTime;

263
            if (self->timer > 0.5) {

264
                saveSel->state = SAVESELECT_STATE_EXITSUBMENU;

265
                RemoveNativeObject(label);

266
                RemoveNativeObject(self);

267
                return;

268
            }

269
            break;

270


271
        default: break;

272
    }

273


274
    RenderMesh(self->meshPanel, MESH_COLORS, false);

275
    if ((self->playerID == SAVESEL_SONIC || self->playerID == SAVESEL_ST) && self->flag) {

276
        SetRenderVertexColor(255, 192, 0);

277
        if (self->playerID == SAVESEL_SONIC && usePhysicalControls) {

278
            RenderImage(-88.0, 28.0, 8.0, 0.325, 0.325, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 255, self->texturePlayerSel);

279
        }

280
        else {

281
            RenderImage(-88.0, 28.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 255, self->texturePlayerSel);

282
        }

283
    }

284
    else {

285
        SetRenderVertexColor(255, 255, 0);

286
        RenderImage(-88.0, 28.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 255, self->texturePlayerSel);

287
    }

288


289
    SetRenderVertexColor(255, 255, 255);

290
    RenderImage(-88.0, 32.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 0.0, 0.0, 255, self->texturePlayerSel);

291
    if ((self->playerID == SAVESEL_TAILS || self->playerID == SAVESEL_ST) && self->flag) {

292
        SetRenderVertexColor(0, 96, 0xFF);

293
    }

294
    else {

295
        SetRenderVertexColor(0, 0x80, 0xFF);

296
        RenderImage(0.0, -12.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 255, self->texturePlayerSel);

297
    }

298
    if (self->playerID == SAVESEL_TAILS && usePhysicalControls) {

299
        RenderImage(0.0, -12.0, 8.0, 0.325, 0.325, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 0xFF, self->texturePlayerSel);

300
    }

301
    else {

302
        RenderImage(0.0, -12.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 0xFF, self->texturePlayerSel);

303
    }

304


305
    if (saveGame->tailsUnlocked)

306
        SetRenderVertexColor(255, 255, 255);

307
    else

308
        SetRenderVertexColor(0, 0, 0);

309
    RenderImage(0.0, -8.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 256.0, 0.0, 255, self->texturePlayerSel);

310
    if (self->playerID == SAVESEL_KNUX && self->flag) {

311
        SetRenderVertexColor(0, 128, 0);

312
        if (usePhysicalControls) {

313
            RenderImage(88.0, 28.0, 8.0, 0.325, 0.325, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 0xFF, self->texturePlayerSel);

314
        }

315
        else {

316
            RenderImage(88.0, 28.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 0xFF, self->texturePlayerSel);

317
        }

318
    }

319
    else {

320
        SetRenderVertexColor(0, 144, 0);

321
        RenderImage(88.0, 28.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 0xFF, self->texturePlayerSel);

322
    }

323


324
    if (saveGame->knuxUnlocked)

325
        SetRenderVertexColor(0xFF, 0xFF, 0xFF);

326
    else

327
        SetRenderVertexColor(0, 0, 0);

328
    RenderImage(88.0, 32.0, 8.0, 0.3, 0.3, 128.0, 128.0, 256.0, 256.0, 0.0, 256.0, 0xFF, self->texturePlayerSel);

329


330
    if (saveGame->tailsUnlocked) {

331
        if (self->playerID == SAVESEL_ST && self->flag) {

332
            SetRenderVertexColor(255, 64, 0);

333
            RenderImage(-88.0, -56.0, 8.0, 0.135, 0.135, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 0xFF, self->texturePlayerSel);

334
            RenderRect(-96.0, -54.0, 8.0, 16.0, 4.0, 0xFF, 255, 0x40, 0xFF);

335
            RenderRect(-90.0, -48.0, 8.0, 4.0, 16.0, 0xFF, 255, 0x40, 0xFF);

336
            RenderRect(-36.0, -54.0, 8.0, 10.0, 4.0, 0xFF, 255, 0x40, 0xFF);

337
            RenderRect(-52.0, -54.0, 8.0, 10.0, 4.0, 0xFF, 255, 0x40, 0xFF);

338
            RenderRect(-68.0, -54.0, 8.0, 10.0, 4.0, 0xFF, 255, 0x40, 0xFF);

339
            RenderRect(-90.0, -26.0, 8.0, 4.0, 10.0, 0xFF, 255, 0x40, 0xFF);

340
        }

341
        else {

342
            SetRenderVertexColor(255, 0, 0);

343
            RenderImage(-88.0, -56.0, 8.0, 0.125, 0.125, 128.0, 128.0, 256.0, 256.0, 256.0, 256.0, 0xFF, self->texturePlayerSel);

344
            RenderRect(-96.0, -54.0, 8.0, 16.0, 4.0, 0xFF, 0xFF, 0xFF, 0xFF);

345
            RenderRect(-90.0, -48.0, 8.0, 4.0, 16.0, 0xFF, 0xFF, 0xFF, 0xFF);

346
            RenderRect(-36.0, -54.0, 8.0, 10.0, 4.0, 0xFF, 0xFF, 0xFF, 0xFF);

347
            RenderRect(-52.0, -54.0, 8.0, 10.0, 4.0, 0xFF, 0xFF, 0xFF, 0xFF);

348
            RenderRect(-68.0, -54.0, 8.0, 10.0, 4.0, 0xFF, 0xFF, 0xFF, 0xFF);

349
            RenderRect(-90.0, -26.0, 8.0, 4.0, 10.0, 0xFF, 0xFF, 0xFF, 0xFF);

350
        }

351
    }

352
    if ((self->playerID == SAVESEL_SONIC || self->playerID == SAVESEL_ST) && self->flag)

353
        SetRenderVertexColor(0xFF, 0xFF, 0x40);

354
    else

355
        SetRenderVertexColor(0xFF, 0xFF, 0xFF);

356
    RenderText(self->textSonic, FONT_TEXT, self->sonicX, -22.0, 8.0, 0.2, 255);

357


358
    if (saveGame->tailsUnlocked) {

359
        if ((self->playerID == SAVESEL_TAILS || self->playerID == SAVESEL_ST) && self->flag)

360
            SetRenderVertexColor(0xFF, 0xFF, 0x40);

361
        else

362
            SetRenderVertexColor(0xFF, 0xFF, 0xFF);

363
    }

364
    else {

365
        SetRenderVertexColor(0xA0, 0xA0, 0xA0);

366
    }

367
    RenderText(self->textTails, FONT_TEXT, self->tailsX, -64.0, 8.0, 0.2, 0xFF);

368
    if (saveGame->knuxUnlocked) {

369
        if (self->playerID == SAVESEL_KNUX && self->flag)

370
            SetRenderVertexColor(0xFF, 0xFF, 0x40);

371
        else

372
            SetRenderVertexColor(0xFF, 0xFF, 0xFF);

373
    }

374
    else {

375
        SetRenderVertexColor(0xA0, 0xA0, 0xA0);

376
    }

377
    RenderText(self->textKnux, FONT_TEXT, self->knuxX, -22.0, 8.0, 0.2, 0xFF);

378


379
    NewRenderState();

380
    SetRenderMatrix(NULL);

381
    SetRenderVertexColor(0xFF, 0xFF, 0xFF);

382
    if (self->backPressed)

383
        RenderImage(128.0, -92.0, 160.0, 0.3, 0.3, 64.0, 64.0, 128.0, 128.0, 128.0, 128.0, self->alpha, self->textureArrows);

384
    else

385
        RenderImage(128.0, -92.0, 160.0, 0.3, 0.3, 64.0, 64.0, 128.0, 128.0, 128.0, 0.0, self->alpha, self->textureArrows);

386
}

387


388