CoCalc -- AboutScreen.cpp

GitHub Repository: rubberduckycooly/Sonic-1-2-2013-Decompilation
Path: blob/main/RSDKv4/NativeObjects/AboutScreen.cpp
⁸¹⁷ views
1
#include "RetroEngine.hpp"
2
#include <string>
3

4
void AboutScreen_Create(void *objPtr)
5
{
6
    RSDK_THIS(AboutScreen);
7

8
    self->label                  = CREATE_ENTITY(TextLabel);
9
    self->label->useRenderMatrix = true;
10
    self->label->fontID          = FONT_HEADING;
11
    self->label->scale           = 0.2;
12
    self->label->alpha           = 256;
13
    self->label->x               = -144.0;
14
    self->label->y               = 100.0;
15
    self->label->z               = 16.0;
16
    self->label->state           = TEXTLABEL_STATE_IDLE;
17
    SetStringToFont(self->label->text, strAbout, FONT_HEADING);
18

19
    char title[0x40];
20
    for (int i = 0; i < StrLength(Engine.gameWindowText); ++i) title[i] = toupper(Engine.gameWindowText[i]);
21
    SetStringToFont8(self->gameTitle, title, FONT_LABEL);
22
    SetStringToFont(self->versionNameText, strVersionName, FONT_LABEL);
23
    SetStringToFont8(self->versionText, Engine.gameVersion, FONT_LABEL);
24

25
    self->meshPanel = LoadMesh("Data/Game/Models/Panel.bin", -1);
26
    SetMeshVertexColors(self->meshPanel, 0, 0, 0, 0xC0);
27
    self->textureArrows = LoadTexture("Data/Game/Menu/ArrowButtons.png", TEXFMT_RGBA4444);
28

29
    int package = 0;
30
    switch (Engine.globalBoxRegion) {
31
        case REGION_JP:
32
            package       = LoadTexture("Data/Game/Models/Package_JP.png", TEXFMT_RGBA5551);
33
            self->meshBox = LoadMesh("Data/Game/Models/JPBox.bin", package);
34
            break;
35
        case REGION_US:
36
            package       = LoadTexture("Data/Game/Models/Package_US.png", TEXFMT_RGBA5551);
37
            self->meshBox = LoadMesh("Data/Game/Models/Box.bin", package);
38
            break;
39
        case REGION_EU:
40
            package       = LoadTexture("Data/Game/Models/Package_EU.png", TEXFMT_RGBA5551);
41
            self->meshBox = LoadMesh("Data/Game/Models/Box.bin", package);
42
            break;
43
        default: break;
44
    }
45

46
    SetMeshAnimation(self->meshBox, &self->animator, 16, 16, 0.0);
47
    AnimateMesh(self->meshBox, &self->animator);
48

49
    float y = -24.0f;
50
    for (int i = 0; i < ABOUT_BTN_COUNT; ++i) {
51
        self->buttons[i]                  = CREATE_ENTITY(PushButton);
52
        self->buttons[i]->useRenderMatrix = true;
53
        self->buttons[i]->x               = 64.0;
54
        self->buttons[i]->y               = y;
55
        self->buttons[i]->z               = 0.0;
56
        self->buttons[i]->scale           = 0.175;
57
        self->buttons[i]->bgColor         = 0x00A048;
58
        self->buttons[i]->bgColorSelected = 0x00C060;
59

60
        y -= 32.0f;
61
    }
62

63
    SetStringToFont(self->buttons[ABOUT_BTN_PRIVACY]->text, strPrivacy, FONT_LABEL);
64
    SetStringToFont(self->buttons[ABOUT_BTN_TERMS]->text, strTerms, FONT_LABEL);
65
}
66
void AboutScreen_Main(void *objPtr)
67
{
68
    RSDK_THIS(AboutScreen);
69
    NativeEntity_OptionsMenu *optionsMenu = (NativeEntity_OptionsMenu *)self->optionsMenu;
70

71
    switch (self->state) {
72
        case ABOUT_STATE_ENTER: {
73
            if (self->arrowAlpha < 0x100)
74
                self->arrowAlpha += 8;
75

76
            float maxWidth = 0;
77
            for (int i = 0; i < ABOUT_BTN_COUNT; ++i) {
78
                if (self->buttons[i]->textWidth > maxWidth)
79
                    maxWidth = self->buttons[i]->textWidth;
80
            }
81
            for (int i = 0; i < ABOUT_BTN_COUNT; ++i) {
82
                self->buttons[i]->textWidth = maxWidth;
83
            }
84

85
            self->scale = fminf(self->scale + ((1.05 - self->scale) / ((60.0 * Engine.deltaTime) * 8.0)), 1.0f);
86

87
            NewRenderState();
88
            MatrixScaleXYZF(&self->renderMatrix, self->scale, self->scale, 1.0);
89
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);
90
            MatrixMultiplyF(&self->renderMatrix, &self->matrixTemp);
91
            SetRenderMatrix(&self->renderMatrix);
92

93
            memcpy(&self->label->renderMatrix, &self->renderMatrix, sizeof(MatrixF));
94
            for (int i = 0; i < ABOUT_BTN_COUNT; ++i) memcpy(&self->buttons[i]->renderMatrix, &self->renderMatrix, sizeof(MatrixF));
95

96
            self->timer += Engine.deltaTime;
97
            if (self->timer > 0.5) {
98
                self->arrowAlpha = 256;
99
                self->timer      = 0.0;
100
                self->state      = ABOUT_STATE_MAIN;
101
            }
102
            break;
103
        }
104
        case ABOUT_STATE_MAIN: {
105
            CheckKeyDown(&keyDown);
106
            CheckKeyPress(&keyPress);
107
            SetRenderMatrix(&self->renderMatrix);
108

109
            if (usePhysicalControls) {
110
                if (touches > 0) {
111
                    usePhysicalControls = false;
112
                }
113
                else {
114
                    if (keyPress.up) {
115
                        PlaySfxByName("Menu Move", false);
116
                        self->selectedButton--;
117
                        if (self->selectedButton < 0)
118
                            self->selectedButton = 1;
119
                    }
120
                    else if (keyPress.down) {
121
                        PlaySfxByName("Menu Move", false);
122
                        self->selectedButton++;
123
                        if (self->selectedButton >= 2)
124
                            self->selectedButton = 0;
125
                    }
126

127
                    for (int i = 0; i < ABOUT_BTN_COUNT; ++i) self->buttons[i]->state = 0;
128
                    self->buttons[self->selectedButton]->state = 1;
129

130
                    if (keyPress.start || keyPress.A) {
131
                        PlaySfxByName("Menu Select", false);
132
                        self->buttons[self->selectedButton]->state = 2;
133
                        self->state                                = ABOUT_STATE_ACTION;
134
                    }
135
                    else if (keyPress.B) {
136
                        PlaySfxByName("Menu Back", false);
137
                        self->backPressed = false;
138
                        self->state       = ABOUT_STATE_EXIT;
139
                    }
140
                }
141
            }
142
            else {
143
                if (touches > 0) {
144
                    float y = -32.0f;
145
                    for (int i = 0; i < ABOUT_BTN_COUNT; ++i) {
146
                        bool valid = CheckTouchRect(64.0, y, ((64.0 * self->buttons[i]->scale) + self->buttons[i]->textWidth) * 0.75, 12.0) >= 0;
147
                        self->buttons[i]->state = valid;
148

149
                        y -= 32.0f;
150
                    }
151
                    self->backPressed = CheckTouchRect(128.0, -92.0, 32.0, 32.0) >= 0;
152
                    if (self->state == ABOUT_STATE_MAIN) {
153
                        if (keyDown.up) {
154
                            self->selectedButton = 1;
155
                            usePhysicalControls  = true;
156
                        }
157
                        if (keyDown.down) {
158
                            self->selectedButton = 0;
159
                            usePhysicalControls  = true;
160
                        }
161
                    }
162
                }
163
                else {
164
                    for (int i = 0; i < ABOUT_BTN_COUNT; ++i) {
165
                        if (self->buttons[i]->state == 1) {
166
                            PlaySfxByName("Menu Select", false);
167
                            self->buttons[i]->state = 2;
168
                            self->selectedButton    = i;
169
                            self->state             = ABOUT_STATE_ACTION;
170
                            break;
171
                        }
172
                    }
173

174
                    if (keyPress.B || self->backPressed) {
175
                        PlaySfxByName("Menu Back", false);
176
                        self->backPressed = false;
177
                        self->state       = ABOUT_STATE_EXIT;
178
                    }
179
                    else {
180
                        if (self->state == ABOUT_STATE_MAIN) {
181
                            if (keyDown.up) {
182
                                self->selectedButton = 1;
183
                                usePhysicalControls  = true;
184
                            }
185
                            if (keyDown.down) {
186
                                self->selectedButton = 0;
187
                                usePhysicalControls  = true;
188
                            }
189
                        }
190
                    }
191
                }
192
            }
193
            break;
194
        }
195
        case ABOUT_STATE_ACTION: {
196
            CheckKeyDown(&keyDown);
197
            SetRenderMatrix(&self->renderMatrix);
198

199
            if (self->buttons[self->selectedButton]->state) {
200
                switch (self->selectedButton) {
201
                    default: break;
202
                    case ABOUT_BTN_PRIVACY: ShowWebsite(0); break;
203
                    case ABOUT_BTN_TERMS: ShowWebsite(1); break;
204
                }
205
                self->state = ABOUT_STATE_MAIN;
206
            }
207
            break;
208
        }
209
        case ABOUT_STATE_EXIT: {
210
            if (self->arrowAlpha > 0)
211
                self->arrowAlpha -= 8;
212

213
            if (self->timer < 0.2)
214
                self->scale = fmaxf(self->scale + ((1.5f - self->scale) / ((Engine.deltaTime * 60.0) * 8.0)), 0.0);
215
            else
216
                self->scale = fmaxf(self->scale + ((-1.0f - self->scale) / ((Engine.deltaTime * 60.0) * 8.0)), 0.0);
217

218
            NewRenderState();
219
            MatrixScaleXYZF(&self->renderMatrix, self->scale, self->scale, 1.0);
220
            MatrixTranslateXYZF(&self->matrixTemp, 0.0, -8.0, 160.0);
221
            MatrixMultiplyF(&self->renderMatrix, &self->matrixTemp);
222
            SetRenderMatrix(&self->renderMatrix);
223

224
            memcpy(&self->label->renderMatrix, &self->renderMatrix, sizeof(MatrixF));
225
            for (int i = 0; i < ABOUT_BTN_COUNT; ++i) memcpy(&self->buttons[i]->renderMatrix, &self->renderMatrix, sizeof(MatrixF));
226

227
            self->timer += Engine.deltaTime;
228
            if (self->timer > 0.5) {
229
                optionsMenu->state = OPTIONSMENU_STATE_EXITSUBMENU;
230
                RemoveNativeObject(self->label);
231
                for (int i = 0; i < ABOUT_BTN_COUNT; ++i) RemoveNativeObject(self->buttons[i]);
232
                RemoveNativeObject(self);
233
                return;
234
            }
235
            break;
236
        }
237
    }
238

239
    RenderMesh(self->meshPanel, MESH_COLORS, false);
240
    RenderText(self->gameTitle, FONT_LABEL, 24.0, 56.0, 0.0, 0.125, 255);
241
    RenderText(self->versionNameText, FONT_LABEL, 24.0, 32.0, 0.0, 0.125, 255);
242
    RenderText(self->versionText, FONT_LABEL, 24.0, 8.0, 0.0, 0.125, 255);
243
    NewRenderState();
244

245
    self->rotationY -= Engine.deltaTime;
246
    if (self->rotationY < -(M_PI_2))
247
        self->rotationY += (M_PI_2);
248

249
    MatrixScaleXYZF(&self->renderMatrix2, 0.6 * self->scale, 0.6 * self->scale, 0.6 * self->scale);
250
    MatrixRotateYF(&self->matrixTemp, self->rotationY);
251
    MatrixMultiplyF(&self->renderMatrix2, &self->matrixTemp);
252
    MatrixTranslateXYZF(&self->matrixTemp, -56.0, -8.0, 160.0);
253
    MatrixMultiplyF(&self->renderMatrix2, &self->matrixTemp);
254
    SetRenderMatrix(&self->renderMatrix2);
255
    RenderMesh(self->meshBox, MESH_NORMALS, true);
256
    SetRenderMatrix(NULL);
257

258
    if (self->backPressed)
259
        RenderImage(128.0, -92.0, 160.0, 0.3, 0.3, 64.0, 64.0, 128.0, 128.0, 128.0, 128.0, self->arrowAlpha, self->textureArrows);
260
    else
261
        RenderImage(128.0, -92.0, 160.0, 0.3, 0.3, 64.0, 64.0, 128.0, 128.0, 128.0, 0.0, self->arrowAlpha, self->textureArrows);
262
}
263

264
Product

Resources

Company
