CoCalc -- OptionsMenu.cpp

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

3
void OptionsMenu_Create(void *objPtr)
4
{
5
    RSDK_THIS(OptionsMenu);
6
    self->menuControl      = (NativeEntity_MenuControl *)GetNativeObject(0);
7
    self->labelPtr         = CREATE_ENTITY(TextLabel);
8
    self->labelPtr->fontID = FONT_HEADING;
9
    if (Engine.language == RETRO_RU)
10
        self->labelPtr->scale = 0.125;
11
    else
12
        self->labelPtr->scale = 0.2;
13
    self->labelPtr->alpha = 0;
14
    self->labelPtr->z     = 0;
15
    self->labelPtr->state = TEXTLABEL_STATE_IDLE;
16
    SetStringToFont(self->labelPtr->text, strHelpAndOptions, FONT_HEADING);
17
    self->labelPtr->alignOffset = 512.0;
18
    self->labelRotateY          = DegreesToRad(22.5);
19
    MatrixRotateYF(&self->labelPtr->renderMatrix, self->labelRotateY);
20
    MatrixTranslateXYZF(&self->matrix1, -128.0, 80.0, 160.0);
21
    MatrixMultiplyF(&self->labelPtr->renderMatrix, &self->matrix1);
22
    self->labelPtr->useRenderMatrix = true;
23

24
    float y = 48.0;
25
    for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) {
26
        self->buttons[i] = CREATE_ENTITY(SubMenuButton);
27

28
        self->buttons[i]->matXOff = 512.0;
29
        self->buttons[i]->textY   = -4.0;
30
        self->buttons[i]->matZ    = 0.0;
31
        self->buttons[i]->scale   = 0.1;
32
        self->buttonRotateY[i]    = DegreesToRad(16.0);
33
        MatrixRotateYF(&self->buttons[i]->matrix, self->buttonRotateY[i]);
34
        MatrixTranslateXYZF(&self->matrix1, -128.0, y, 160.0);
35
        MatrixMultiplyF(&self->buttons[i]->matrix, &self->matrix1);
36
        self->buttons[i]->useMatrix = true;
37
        y -= 30.0;
38
    }
39
#if !RETRO_USE_ORIGINAL_CODE
40
    if (!Engine.devMenu)
41
        SetStringToFont(self->buttons[OPTIONSMENU_BUTTON_INSTRUCTIONS]->text, strInstructions, FONT_LABEL);
42
    else
43
        SetStringToFont(self->buttons[OPTIONSMENU_BUTTON_INSTRUCTIONS]->text, strDevMenu, FONT_LABEL);
44
#else
45
    SetStringToFont(self->buttons[OPTIONSMENU_BUTTON_INSTRUCTIONS]->text, strInstructions, FONT_LABEL);
46
#endif
47
    SetStringToFont(self->buttons[OPTIONSMENU_BUTTON_SETTINGS]->text, strSettings, FONT_LABEL);
48
    SetStringToFont(self->buttons[OPTIONSMENU_BUTTON_ABOUT]->text, strAbout, FONT_LABEL);
49
    SetStringToFont(self->buttons[OPTIONSMENU_BUTTON_CREDITS]->text, strStaffCredits, FONT_LABEL);
50
}
51
void OptionsMenu_Main(void *objPtr)
52
{
53
    RSDK_THIS(OptionsMenu);
54
    switch (self->state) {
55
        case OPTIONSMENU_STATE_SETUP: {
56
            self->timer += Engine.deltaTime;
57
            if (self->timer > 1.0) {
58
                self->timer = 0.0;
59
                self->state = OPTIONSMENU_STATE_ENTER;
60
            }
61
            break;
62
        }
63
        case OPTIONSMENU_STATE_ENTER: {
64
            self->labelPtr->alignOffset /= (1.125 * (60.0 * Engine.deltaTime));
65

66
            float div = (60.0 * Engine.deltaTime) * 16.0;
67
            for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) self->buttons[i]->matXOff += ((-176.0 - self->buttons[i]->matXOff) / div);
68

69
            self->timer += (Engine.deltaTime + Engine.deltaTime);
70
            self->labelPtr->alpha = (256.0 * self->timer);
71
            if (self->timer > 1.0) {
72
                self->timer      = 0.0;
73
                self->state      = OPTIONSMENU_STATE_MAIN;
74
                keyPress.start = false;
75
                keyPress.A     = false;
76
            }
77
            break;
78
        }
79
        case OPTIONSMENU_STATE_MAIN: {
80
            if (self->menuControl->state == MENUCONTROL_STATE_EXITSUBMENU) {
81
                self->state = OPTIONSMENU_STATE_EXIT;
82
            }
83
            else if (usePhysicalControls) {
84
                if (touches > 0) {
85
                    usePhysicalControls = false;
86
                }
87
                else {
88
                    if (keyPress.up) {
89
                        PlaySfxByName("Menu Move", false);
90
                        self->selectedButton--;
91
                        if (self->selectedButton < 0)
92
                            self->selectedButton = OPTIONSMENU_BUTTON_COUNT - 1;
93
                    }
94
                    else if (keyPress.down) {
95
                        PlaySfxByName("Menu Move", false);
96
                        self->selectedButton++;
97
                        if (self->selectedButton >= OPTIONSMENU_BUTTON_COUNT)
98
                            self->selectedButton = 0;
99
                    }
100
                    for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) self->buttons[i]->b = 0xFF;
101
                    self->buttons[self->selectedButton]->b = 0x00;
102

103
                    if (self->buttons[self->selectedButton]->g > 0x80 && (keyPress.start || keyPress.A)) {
104
                        PlaySfxByName("Menu Select", false);
105
                        self->buttons[self->selectedButton]->state = SUBMENUBUTTON_STATE_FLASHING2;
106
                        self->buttons[self->selectedButton]->b     = 0xFF;
107
                        self->state                                = OPTIONSMENU_STATE_ACTION;
108
#if !RETRO_USE_ORIGINAL_CODE
109
                        self->unused1 = Engine.devMenu && self->selectedButton == OPTIONSMENU_BUTTON_INSTRUCTIONS && !keyDown.X;
110
                        if (self->unused1)
111
                            StopMusic(true);
112
#endif
113
                    }
114
                }
115
            }
116
            else {
117
                float y = 48.0;
118
                for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) {
119
                    if (touches > 0) {
120
                        if (CheckTouchRect(-64.0, y, 96.0, 12.0) >= 0)
121
                            self->buttons[i]->b = 0x00;
122
                        else
123
                            self->buttons[i]->b = 0xFF;
124
                    }
125
                    else if (!self->buttons[i]->b) {
126
                        self->selectedButton = i;
127
                        PlaySfxByName("Menu Select", false);
128
                        self->buttons[i]->state = SUBMENUBUTTON_STATE_FLASHING2;
129
                        self->buttons[i]->b     = 0xFF;
130
                        self->state             = OPTIONSMENU_STATE_ACTION;
131
#if !RETRO_USE_ORIGINAL_CODE
132
                        self->unused1 = Engine.devMenu && self->selectedButton == OPTIONSMENU_BUTTON_INSTRUCTIONS;
133
                        if (self->unused1)
134
                            StopMusic(true);
135
#endif
136
                        break;
137
                    }
138
                    y -= 30.0;
139
                }
140

141
                if (self->state == OPTIONSMENU_STATE_MAIN && (keyDown.up || keyDown.down)) {
142
                    self->selectedButton = 0;
143
                    usePhysicalControls  = true;
144
                }
145
            }
146
            break;
147
        }
148
        case OPTIONSMENU_STATE_EXIT: {
149
            self->labelPtr->alignOffset = (10.0 * (60.0 * Engine.deltaTime)) + self->labelPtr->alignOffset;
150
            self->timer += (Engine.deltaTime + Engine.deltaTime);
151

152
            for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) self->buttons[i]->matXOff += (12.0 * (60.0 * Engine.deltaTime));
153

154
            if (self->timer > 1.0) {
155
                self->timer = 0.0;
156
                RemoveNativeObject(self->labelPtr);
157
                for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) RemoveNativeObject(self->buttons[i]);
158
                RemoveNativeObject(self);
159
            }
160
            break;
161
        }
162
        case OPTIONSMENU_STATE_ACTION: {
163
            self->menuControl->state = MENUCONTROL_STATE_NONE;
164
            if (!self->buttons[self->selectedButton]->state) {
165
#if !RETRO_USE_ORIGINAL_CODE
166
                if (!self->unused1) {
167
#endif
168
                    self->state = OPTIONSMENU_STATE_ENTERSUBMENU;
169

170
                    self->labelRotateYVelocity = 0.0;
171
                    self->targetLabelRotateY   = DegreesToRad(-90.0);
172
                    for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) self->targetButtonRotateY[i] = DegreesToRad(-90.0);
173
                    float val = 0.02;
174
                    for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) {
175
                        self->buttonRotateYVelocity[i] = val;
176
                        val += 0.02;
177
                    }
178
#if !RETRO_USE_ORIGINAL_CODE
179
                }
180
                else {
181
                    self->state = OPTIONSMENU_STATE_SUBMENU;
182
                    CREATE_ENTITY(FadeScreen);
183
                    Engine.gameMode = ENGINE_INITDEVMENU;
184
                }
185
#endif
186
            }
187
            break;
188
        }
189
        case OPTIONSMENU_STATE_ENTERSUBMENU: {
190
            if (self->labelRotateY > self->targetLabelRotateY) {
191
                self->labelRotateYVelocity -= 0.0025 * (Engine.deltaTime * 60.0);
192
                self->labelRotateY += (Engine.deltaTime * 60.0) * self->labelRotateYVelocity;
193
                self->labelRotateYVelocity -= 0.0025 * (Engine.deltaTime * 60.0);
194
                MatrixRotateYF(&self->labelPtr->renderMatrix, self->labelRotateY);
195
                MatrixTranslateXYZF(&self->matrix1, -128.0, 80.0, 160.0);
196
                MatrixMultiplyF(&self->labelPtr->renderMatrix, &self->matrix1);
197
            }
198

199
            float y = 48.0;
200
            for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) {
201
                if (self->buttonRotateY[i] > self->targetButtonRotateY[i]) {
202
                    self->buttonRotateYVelocity[i] -= 0.0025 * (60.0 * Engine.deltaTime);
203
                    if (self->buttonRotateYVelocity[i] < 0.0)
204
                        self->buttonRotateY[i] += ((60.0 * Engine.deltaTime) * self->buttonRotateYVelocity[i]);
205
                    self->buttonRotateYVelocity[i] -= 0.0025 * (60.0 * Engine.deltaTime);
206
                    MatrixRotateYF(&self->buttons[i]->matrix, self->buttonRotateY[i]);
207
                    MatrixTranslateXYZF(&self->matrix1, -128.0, y, 160.0);
208
                    MatrixMultiplyF(&self->buttons[i]->matrix, &self->matrix1);
209
                }
210
                y -= 30.0;
211
            }
212

213
            if (self->targetButtonRotateY[OPTIONSMENU_BUTTON_COUNT - 1] >= self->buttonRotateY[OPTIONSMENU_BUTTON_COUNT - 1]) {
214
                self->state                = OPTIONSMENU_STATE_SUBMENU;
215
                self->labelRotateYVelocity = 0.0;
216
                self->targetLabelRotateY   = DegreesToRad(22.5);
217
                for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) self->targetButtonRotateY[i] = DegreesToRad(16.0);
218
                float val = -0.02;
219
                for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) {
220
                    self->buttonRotateYVelocity[i] = val;
221
                    val -= 0.02;
222
                }
223

224
                switch (self->selectedButton) {
225
                    default: break;
226
                    case OPTIONSMENU_BUTTON_INSTRUCTIONS:
227
                        self->instructionsScreen              = CREATE_ENTITY(InstructionsScreen);
228
                        self->instructionsScreen->optionsMenu = self;
229
                        break;
230
                    case OPTIONSMENU_BUTTON_SETTINGS:
231
                        self->settingsScreen              = CREATE_ENTITY(SettingsScreen);
232
                        self->settingsScreen->optionsMenu = self;
233
                        break;
234
                    case OPTIONSMENU_BUTTON_ABOUT:
235
                        self->aboutScreen              = CREATE_ENTITY(AboutScreen);
236
                        self->aboutScreen->optionsMenu = self;
237
                        break;
238
                    case OPTIONSMENU_BUTTON_CREDITS:
239
                        self->staffCredits              = CREATE_ENTITY(StaffCredits);
240
                        self->staffCredits->optionsMenu = self;
241
                        break;
242
                }
243
            }
244

245
            float div                               = (60.0 * Engine.deltaTime) * 16.0;
246
            NativeEntity_AchievementsButton *button = self->menuControl->buttons[self->menuControl->buttonID];
247
            NativeEntity_BackButton *backButton     = self->menuControl->backButton;
248
            button->x += ((512.0 - button->x) / div);
249
            backButton->x += ((1024.0 - backButton->x) / div);
250
            break;
251
        }
252
        case OPTIONSMENU_STATE_SUBMENU: // sub menu idle
253
            break;
254
        case OPTIONSMENU_STATE_EXITSUBMENU: {
255
            if (self->targetLabelRotateY > self->labelRotateY) {
256
                self->labelRotateYVelocity += 0.0025 * (Engine.deltaTime * 60.0);
257
                self->labelRotateY += (Engine.deltaTime * 60.0) * self->labelRotateYVelocity;
258
                self->labelRotateYVelocity += 0.0025 * (Engine.deltaTime * 60.0);
259
                if (self->labelRotateY > self->targetLabelRotateY)
260
                    self->labelRotateY = self->targetLabelRotateY;
261
                MatrixRotateYF(&self->labelPtr->renderMatrix, self->labelRotateY);
262
                MatrixTranslateXYZF(&self->matrix1, -128.0, 80.0, 160.0);
263
                MatrixMultiplyF(&self->labelPtr->renderMatrix, &self->matrix1);
264
            }
265

266
            float y = 48.0;
267
            for (int i = 0; i < OPTIONSMENU_BUTTON_COUNT; ++i) {
268
                if (self->targetButtonRotateY[i] > self->buttonRotateY[i]) {
269
                    self->buttonRotateYVelocity[i] += 0.0025 * (60.0 * Engine.deltaTime);
270
                    if (self->buttonRotateYVelocity[i] > 0.0)
271
                        self->buttonRotateY[i] += ((60.0 * Engine.deltaTime) * self->buttonRotateYVelocity[i]);
272
                    self->buttonRotateYVelocity[i] += 0.0025 * (60.0 * Engine.deltaTime);
273
                    if (self->buttonRotateY[i] > self->targetButtonRotateY[i])
274
                        self->buttonRotateY[i] = self->targetButtonRotateY[i];
275
                    MatrixRotateYF(&self->buttons[i]->matrix, self->buttonRotateY[i]);
276
                    MatrixTranslateXYZF(&self->matrix1, -128.0, y, 160.0);
277
                    MatrixMultiplyF(&self->buttons[i]->matrix, &self->matrix1);
278
                }
279
                y -= 30.0;
280
            }
281

282
            float div                               = (60.0 * Engine.deltaTime) * 16.0;
283
            NativeEntity_AchievementsButton *button = self->menuControl->buttons[self->menuControl->buttonID];
284
            NativeEntity_BackButton *backButton     = self->menuControl->backButton;
285
            button->x += ((112.0 - button->x) / div);
286
            backButton->x += ((230.0 - backButton->x) / div);
287

288
            if (backButton->x < SCREEN_YSIZE) {
289
                backButton->x            = SCREEN_YSIZE;
290
                self->state              = OPTIONSMENU_STATE_MAIN;
291
                self->menuControl->state = MENUCONTROL_STATE_SUBMENU;
292
            }
293
            break;
294
        }
295
        default: break;
296
    }
297
}
298

299
Product

Resources

Company
