#include "supertux/screen_manager.hpp"
#include "audio/sound_manager.hpp"
-#include "control/joystickkeyboardcontroller.hpp"
+#include "control/input_manager.hpp"
#include "gui/menu.hpp"
#include "gui/menu_manager.hpp"
#include "scripting/squirrel_util.hpp"
#include "scripting/time_scheduler.hpp"
-#include "supertux/constants.hpp"
#include "supertux/console.hpp"
+#include "supertux/constants.hpp"
#include "supertux/gameconfig.hpp"
#include "supertux/globals.hpp"
#include "supertux/main.hpp"
+#include "supertux/menu/menu_storage.hpp"
#include "supertux/player_status.hpp"
#include "supertux/resources.hpp"
-#include "supertux/screen_fade.hpp"
#include "supertux/screen.hpp"
+#include "supertux/screen_fade.hpp"
#include "supertux/timer.hpp"
#include "video/drawing_context.hpp"
#include "video/renderer.hpp"
+#include <stdio.h>
/** ticks (as returned from SDL_GetTicks) per frame */
static const Uint32 TICKS_PER_FRAME = (Uint32) (1000.0 / LOGICAL_FPS);
/** don't skip more than every 2nd frame */
static const int MAX_FRAME_SKIP = 2;
-float g_game_speed = 1.0f;
-
-ScreenManager* g_screen_manager = NULL;
-
ScreenManager::ScreenManager() :
waiting_threads(),
+ m_menu_storage(new MenuStorage),
+ m_menu_manager(new MenuManager),
running(),
speed(1.0),
nextpop(false),
screen_stack(),
screenshot_requested(false)
{
- using namespace Scripting;
+ using namespace scripting;
TimeScheduler::instance = new TimeScheduler();
}
ScreenManager::~ScreenManager()
{
- using namespace Scripting;
+ using namespace scripting;
delete TimeScheduler::instance;
TimeScheduler::instance = NULL;
-
- for(std::vector<Screen*>::iterator i = screen_stack.begin();
- i != screen_stack.end(); ++i) {
- delete *i;
- }
}
void
-ScreenManager::push_screen(Screen* screen, ScreenFade* screen_fade)
+ScreenManager::push_screen(std::unique_ptr<Screen> screen, std::unique_ptr<ScreenFade> screen_fade)
{
- this->next_screen.reset(screen);
- this->screen_fade.reset(screen_fade);
+ assert(!this->next_screen);
+ this->next_screen = std::move(screen);
+ this->screen_fade = std::move(screen_fade);
nextpush = !nextpop;
nextpop = false;
speed = 1.0f;
}
void
-ScreenManager::exit_screen(ScreenFade* screen_fade)
+ScreenManager::exit_screen(std::unique_ptr<ScreenFade> screen_fade)
{
- next_screen.reset(NULL);
- this->screen_fade.reset(screen_fade);
+ next_screen.reset();
+ this->screen_fade = std::move(screen_fade);
nextpop = true;
nextpush = false;
}
void
-ScreenManager::set_screen_fade(ScreenFade* screen_fade)
+ScreenManager::set_screen_fade(std::unique_ptr<ScreenFade> screen_fade)
{
- this->screen_fade.reset(screen_fade);
+ this->screen_fade = std::move(screen_fade);
}
void
-ScreenManager::quit(ScreenFade* screen_fade)
+ScreenManager::quit(std::unique_ptr<ScreenFade> screen_fade)
{
- for(std::vector<Screen*>::iterator i = screen_stack.begin();
- i != screen_stack.end(); ++i)
- delete *i;
screen_stack.clear();
-
- exit_screen(screen_fade);
+ exit_screen(std::move(screen_fade));
}
void
static int frame_count = 0;
current_screen->draw(context);
- if(MenuManager::current() != NULL)
- MenuManager::current()->draw(context);
+ if(MenuManager::instance().current() != NULL)
+ MenuManager::instance().current()->draw(context);
if(screen_fade.get() != NULL)
screen_fade->draw(context);
Console::instance->draw(context);
void
ScreenManager::update_gamelogic(float elapsed_time)
{
- Scripting::update_debugger();
- Scripting::TimeScheduler::instance->update(game_time);
+ scripting::update_debugger();
+ scripting::TimeScheduler::instance->update(game_time);
current_screen->update(elapsed_time);
- if (MenuManager::current() != NULL)
- MenuManager::current()->update();
+ if (MenuManager::instance().current() != NULL)
+ MenuManager::instance().current()->update();
if(screen_fade.get() != NULL)
screen_fade->update(elapsed_time);
Console::instance->update(elapsed_time);
void
ScreenManager::process_events()
{
- g_main_controller->update();
- Uint8* keystate = SDL_GetKeyState(NULL);
+ g_input_manager->update();
SDL_Event event;
while(SDL_PollEvent(&event))
{
- g_main_controller->process_event(event);
+ g_input_manager->process_event(event);
- if(MenuManager::current() != NULL)
- MenuManager::current()->event(event);
+ if(MenuManager::instance().current() != NULL)
+ MenuManager::instance().current()->event(event);
switch(event.type)
{
quit();
break;
- case SDL_VIDEORESIZE:
- Renderer::instance()->resize(event.resize.w, event.resize.h);
- MenuManager::recalc_pos();
+ case SDL_WINDOWEVENT:
+ switch(event.window.event)
+ {
+ case SDL_WINDOWEVENT_RESIZED:
+ Renderer::instance()->resize(event.window.data1,
+ event.window.data2);
+ MenuManager::instance().recalc_pos();
+ break;
+ }
break;
case SDL_KEYDOWN:
{
g_config->use_fullscreen = !g_config->use_fullscreen;
Renderer::instance()->apply_config();
- MenuManager::recalc_pos();
+ MenuManager::instance().recalc_pos();
}
- else if (event.key.keysym.sym == SDLK_PRINT ||
+ else if (event.key.keysym.sym == SDLK_PRINTSCREEN ||
event.key.keysym.sym == SDLK_F12)
{
take_screenshot();
}
else if (event.key.keysym.sym == SDLK_F1 &&
- (keystate[SDLK_LCTRL] || keystate[SDLK_RCTRL]) &&
- keystate[SDLK_c])
+ event.key.keysym.mod & KMOD_CTRL)
{
Console::instance->toggle();
g_config->console_enabled = true;
void
ScreenManager::handle_screen_switch()
{
- while( (next_screen.get() != NULL || nextpop) &&
- has_no_pending_fadeout()) {
- if(current_screen.get() != NULL) {
+ while((next_screen || nextpop) &&
+ has_no_pending_fadeout())
+ {
+ if(current_screen) {
current_screen->leave();
}
running = false;
break;
}
- next_screen.reset(screen_stack.back());
+ next_screen = std::move(screen_stack.back());
screen_stack.pop_back();
}
- if(nextpush && current_screen.get() != NULL) {
- screen_stack.push_back(current_screen.release());
+ if(nextpush && current_screen) {
+ screen_stack.push_back(std::move(current_screen));
}
nextpush = false;
nextpop = false;
speed = 1.0;
- Screen* next_screen_ptr = next_screen.release();
- next_screen.reset(0);
- if(next_screen_ptr)
- next_screen_ptr->setup();
- current_screen.reset(next_screen_ptr);
- screen_fade.reset(NULL);
+ current_screen = std::move(next_screen);
+ if(current_screen)
+ current_screen->setup();
+ screen_fade.reset();
waiting_threads.wakeup();
}
while(running) {
handle_screen_switch();
- if(!running || current_screen.get() == NULL)
+ if(!running || !current_screen)
break;
Uint32 ticks = SDL_GetTicks();
projects / supertux.git / blobdiff