zv0n/game
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Game main menu/retry scenes

Browse Source
This commit is contained in:
zvon
2022-09-19 22:56:50 +02:00
parent 65edc9e8a0
commit 5201d10e20
8 changed files with 463 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mario/scenes/editor_main.cpp
+8 -1
View File
@@ -1052,6 +1052,13 @@ void openMapEditor(std::shared_ptr<SDLPP::Scene> &scene,
} else {
loadMap(scene, global_vars.mario, filename, global_vars.objects, true,
MAP_WIDTH);
for(int i = 0; i < global_vars.objects.size(); i++) {
for(int j = 0; j < 16; j++) {
if(global_vars.objects[i][j].hasCharacter() && global_vars.objects[i][j].getCharacterId() == MARIO_ID) {
global_vars.mario_pos = {i,j};
}
}
}
}
// map
@@ -1368,4 +1375,4 @@ SceneStruct createEditorScene(std::shared_ptr<SDLPP::Renderer> &renderer) {
mainMenuScene = createEditorMainMenuScene(renderer);
// fileChoiceScene = createEditorFileChoiceScene(renderer);
return ret;
}
}
mario/scenes/editor_scenes.hpp
+3 -18
View File
@@ -1,15 +1,10 @@
#ifndef EDITOR_MAIN_HPP
#define EDITOR_MAIN_HPP
#ifndef EDITOR_SCENES_HPP
#define EDITOR_SCENES_HPP
#include "../../sdlpp/sdlpp_scene.hpp"
#include "../gui/gui.hpp"
#include <functional>
struct SceneStruct {
std::shared_ptr<SDLPP::Scene> scene;
std::function<void(std::shared_ptr<SDLPP::Scene> &)> doInput;
std::function<void(std::shared_ptr<SDLPP::Scene> &)> additionalRender;
};
#include "shared_scenes.hpp"
extern std::mutex render_mutex;
extern std::vector<SceneStruct> game_scenes;
@@ -22,15 +17,5 @@ SceneStruct
createEditorMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer);
SceneStruct
createEditorFileChoiceScene(std::shared_ptr<SDLPP::Renderer> &renderer);
// TODO move to a shared header
SceneStruct createYesNoScene(std::shared_ptr<SDLPP::Renderer> renderer,
const std::string &text,
std::function<void(bool)> finalizer);
SceneStruct createOkScene(std::shared_ptr<SDLPP::Renderer> renderer,
const std::string &text,
std::function<void()> finalizer);
SceneStruct createLoadScene(std::shared_ptr<SDLPP::Renderer> renderer,
const std::string &path,
std::function<void(const std::string &)> finalizer);
#endif
mario/scenes/game_main_menu.cpp
+229
View File
@@ -0,0 +1,229 @@
#include "editor_scenes.hpp"
#include "../../sdlpp/sdlpp.hpp"
#include "../../sdlpp/sdlpp_mouse.hpp"
#include "../global_vars.hpp"
#include "../objectids.hpp"
#include "../editor_visitor.hpp"
#include <functional>
bool __update_scenes_main_menu = false;
bool __quit_scenes_main_menu = false;
bool __started_main_menu = false;
uint64_t __cur_button_index_main_menu = -1;
uint64_t __cur_button_index_main_menu_down = -1;
std::vector<std::shared_ptr<Button>> __buttons_main_menu{};
std::shared_ptr<SDLPP::RectangleRender> __mouse_main_menu{};
extern void loadLevel(const std::string &level);
void quitMainMenu() {
g_quit = true;
}
void resumeMainMenu() {
__quit_scenes_main_menu = true;
}
void quitMainMenuCallback(void * /*UNUSED*/, Button * /*UNUSED*/) {
quitMainMenu();
}
void resumeMainMenuCallback(void * /*UNUSED*/, Button * /*UNUSED*/) {
resumeMainMenu();
}
void resetGlobals() {
__update_scenes_main_menu = false;
__quit_scenes_main_menu = false;
__started_main_menu = false;
__cur_button_index_main_menu_down = -1;
__mouse_main_menu.reset();
__buttons_main_menu.clear();
}
void showLoadMenu(void */*UNUSED*/, Button */*UNUSED*/) {
auto loadMenu = createLoadScene(__buttons_main_menu.back()->getRenderer(), "levels", loadLevel, false);
std::lock_guard<std::mutex> lock(render_mutex);
game_scenes.pop_back();
resetGlobals();
game_scenes.push_back(loadMenu);
}
void __updateSelectedButton_MainMenu(uint64_t new_index) {
if (new_index != __cur_button_index_main_menu &&
new_index != (uint64_t)-1) {
__buttons_main_menu[new_index]->setHighlight();
if (__cur_button_index_main_menu != (uint64_t)-1) {
__buttons_main_menu[__cur_button_index_main_menu]
->unsetHighlight();
}
__cur_button_index_main_menu = new_index;
}
}
void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
switch (key) {
case SDLK_ESCAPE:
resumeMainMenu();
break;
case SDLK_DOWN:
case SDLK_s:
if(__cur_button_index_main_menu == __buttons_main_menu.size() - 1) {
__updateSelectedButton_MainMenu(0);
} else {
__updateSelectedButton_MainMenu(__cur_button_index_main_menu + 1);
}
break;
case SDLK_UP:
case SDLK_w:
if(__cur_button_index_main_menu == 0) {
__updateSelectedButton_MainMenu(__buttons_main_menu.size() - 1);
} else {
__updateSelectedButton_MainMenu(__cur_button_index_main_menu - 1);
}
break;
case SDLK_RETURN:
if(__cur_button_index_main_menu >= 0 && __cur_button_index_main_menu < __buttons_main_menu.size()) {
__buttons_main_menu[__cur_button_index_main_menu]
->performFunction();
}
break;
default:
break;
}
}
std::shared_ptr<SDLPP::Scene>
createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer, bool include_resume) {
auto scene = std::make_shared<SDLPP::Scene>(renderer);
auto bg = std::make_shared<SDLPP::RectangleRender>(0, 0, 10, 10, renderer,
"#00000088", true);
bg->setPermanent();
bg->setId(1);
scene->addObject(bg);
__mouse_main_menu =
std::make_shared<SDLPP::RectangleRender>(0.01, 0.01, 0, 0, renderer);
__mouse_main_menu->setMinWidth(1);
__mouse_main_menu->setMinHeight(1);
__mouse_main_menu->setAlignment(SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER);
__mouse_main_menu->setId(EDITOR_MOUSE_ID);
__mouse_main_menu->setColiderColor("#00FF00");
__mouse_main_menu->addCollision(SDLPP::RectColider({ 0, 0 }, { 1, 1 }));
scene->addObject(__mouse_main_menu);
ButtonConfig default_button_theme{};
default_button_theme.bg_color = "#FFFFFF88";
default_button_theme.bg_color_highlight = "#FFFFFFBB";
default_button_theme.bg_color_disabled = "#AAAAAA88";
default_button_theme.font_color = "#000000";
default_button_theme.font_color_highlight = "#000000";
default_button_theme.font_color_disabled = "#555555";
default_button_theme.font_outline_color = "#FFFFFF88";
default_button_theme.font_outline_color_highlight = "#FFFFFFAA";
default_button_theme.font_outline_color_disabled = "#787878";
default_button_theme.outline = 0.1;
// buttons
if(include_resume) {
__buttons_main_menu.emplace_back(std::make_shared<Button>(
0.2, 0.25, 0.6, 0.1, renderer, "RESUME", default_button_theme,
resumeMainMenuCallback, nullptr));
__buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
__buttons_main_menu.back()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
}
__buttons_main_menu.emplace_back(std::make_shared<Button>(
0.2, 0.4, 0.6, 0.1, renderer, "LOAD", default_button_theme,
showLoadMenu, nullptr));
__buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
__buttons_main_menu.back()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
__buttons_main_menu.emplace_back(std::make_shared<Button>(
0.2, 0.7, 0.6, 0.1, renderer, "QUIT", default_button_theme,
quitMainMenuCallback, nullptr));
__buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
SDLPP::OBJ_CENTER);
__buttons_main_menu.back()->setPermanent();
__buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
for (auto &button : __buttons_main_menu) {
scene->addObject(button);
}
return scene;
}
void additionalRenderMainMenu(std::shared_ptr<SDLPP::Scene> & /*UNUSED*/) {
if (__update_scenes_main_menu) {
for (auto &_scene : game_scenes) {
_scene.scene->updateSizeAndPosition();
}
if (__started_main_menu) {
__update_scenes_main_menu = false;
} else {
__started_main_menu = true;
}
}
if (__quit_scenes_main_menu) {
game_scenes.pop_back();
resetGlobals();
}
}
void getMousePositionFlagsMainMenu(SDLPP::Scene &scene) {
auto mouse = scene.getObjects({ EDITOR_MOUSE_ID })[0];
// move mouse colider to mouse position
mouse->setPos(SDLPP::Mouse::getMousePositionDouble(
scene.getRenderer(), SDLPP::OBJ_CENTER, SDLPP::OBJ_CENTER));
MouseVisitor visitor;
scene.visitCollisions(*mouse, visitor);
__updateSelectedButton_MainMenu(visitor.getCurButton());
}
void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
SDL_Event event;
while (SDLPP::getSDLEvent(event)) {
switch (event.type) {
case SDL_QUIT:
quitMainMenu();
break;
case SDL_KEYUP:
handleKeyUpMainMenu(event.key.keysym.sym, *scene);
break;
case SDL_WINDOWEVENT:
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
__update_scenes_main_menu = true;
}
break;
case SDL_MOUSEMOTION:
getMousePositionFlagsMainMenu(*scene);
break;
case SDL_MOUSEBUTTONUP:
if (__cur_button_index_main_menu_down ==
__cur_button_index_main_menu &&
__cur_button_index_main_menu != (uint64_t)-1) {
__buttons_main_menu[__cur_button_index_main_menu]
->performFunction();
}
break;
case SDL_MOUSEBUTTONDOWN:
// store current mouse flags in previous mouse flags
__cur_button_index_main_menu_down = __cur_button_index_main_menu;
break;
default:
break;
}
}
}
SceneStruct
createGameMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer, bool include_resume) {
SceneStruct ret{};
ret.scene = createSceneMainMenu(renderer, include_resume);
ret.additionalRender = additionalRenderMainMenu;
ret.doInput = pollEventsMainMenu;
__update_scenes_main_menu = true;
__updateSelectedButton_MainMenu(0);
return ret;
}
mario/scenes/game_scenes.hpp
+15
View File
@@ -0,0 +1,15 @@
#ifndef GAME_SCENES_HPP
#define GAME_SCENES_HPP
#include "../../sdlpp/sdlpp_scene.hpp"
#include "../gui/gui.hpp"
#include <functional>
#include "shared_scenes.hpp"
extern std::mutex render_mutex;
extern std::vector<SceneStruct> game_scenes;
SceneStruct createGameMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer, bool include_resume = true);
SceneStruct createGameRetryScene(std::shared_ptr<SDLPP::Renderer> &renderer);
#endif
mario/scenes/load_scene.cpp
+12 -4
View File
@@ -1,3 +1,5 @@
#include <utility>
#include "SDL2/SDL_keycode.h"
#include "editor_scenes.hpp"
#include "../../sdlpp/sdlpp.hpp"
@@ -10,6 +12,7 @@
bool __update_scenes_load_dialog = false;
bool __quit_scenes_load_dialog = false;
bool __started_load_dialog = false;
bool __pop_at_finish_load_dialog = false;
uint64_t __cur_button_index_load_dialog = -1;
uint64_t __cur_button_index_load_dialog_down = -1;
std::vector<std::shared_ptr<Button>> __buttons_load_dialog{};
@@ -50,7 +53,7 @@ void __selectUpperButton() {
if (__cur_button_index_load_dialog > 0) {
__updateSelectedButton_LoadDialog(__cur_button_index_load_dialog - 1);
if (__buttons_load_dialog[__cur_button_index_load_dialog]
->getPos()
->getPos()
.getY() < 0.49) {
__moveButtons(0.25);
}
@@ -172,6 +175,7 @@ void __resetGlobals_LoadDialog() {
__update_scenes_load_dialog = false;
__quit_scenes_load_dialog = false;
__started_load_dialog = false;
__pop_at_finish_load_dialog = false;
__cur_button_index_load_dialog = -1;
__cur_button_index_load_dialog_down = -1;
__buttons_load_dialog.clear();
@@ -192,7 +196,9 @@ void __additionalRender_LoadDialog(std::shared_ptr<SDLPP::Scene> & /*UNUSED*/) {
}
if (__quit_scenes_load_dialog) {
__load_dialog_finalizer(__selected_level_load_dialog);
game_scenes.pop_back();
if(__pop_at_finish_load_dialog) {
game_scenes.pop_back();
}
__resetGlobals_LoadDialog();
}
}
@@ -256,8 +262,10 @@ void __pollEvents_LoadDialog(std::shared_ptr<SDLPP::Scene> &scene) {
SceneStruct
createLoadScene(std::shared_ptr<SDLPP::Renderer> renderer,
const std::string &path,
std::function<void(const std::string &)> finalizer) {
__load_dialog_finalizer = finalizer;
std::function<void(const std::string &)> finalizer,
bool pop_at_finish) {
__load_dialog_finalizer = std::move(finalizer);
__pop_at_finish_load_dialog = pop_at_finish;
SceneStruct ret{};
ret.scene = createSceneLoadDialog(renderer, path);
ret.additionalRender = __additionalRender_LoadDialog;
mario/scenes/shared_scenes.hpp
+24
View File
@@ -0,0 +1,24 @@
#ifndef SHARED_SCENES_HPP
#define SHARED_SCENES_HPP
#include "../../sdlpp/sdlpp_scene.hpp"
#include <functional>
struct SceneStruct {
std::shared_ptr<SDLPP::Scene> scene;
std::function<void(std::shared_ptr<SDLPP::Scene> &)> doInput;
std::function<void(std::shared_ptr<SDLPP::Scene> &)> additionalRender;
};
SceneStruct createYesNoScene(std::shared_ptr<SDLPP::Renderer> renderer,
const std::string &text,
std::function<void(bool)> finalizer);
SceneStruct createOkScene(std::shared_ptr<SDLPP::Renderer> renderer,
const std::string &text,
std::function<void()> finalizer);
SceneStruct createLoadScene(std::shared_ptr<SDLPP::Renderer> renderer,
const std::string &path,
std::function<void(const std::string &)> finalizer,
bool pop_at_finish = true);
#endif