예제 #1
0
void PGE_QuestionBox::updateSize()
{
    PGE_Rect menuRect = _menu.rectFull();
    if(menuRect.width()>title_size.w())
        width = menuRect.width()/2;
    else
        width = title_size.w()/2;
    height=(title_size.h()+menuRect.height())/2;

    if((_pos.x()==-1)&&(_pos.y()==-1))
    {
        _sizeRect.setLeft(PGE_Window::Width/2-width-padding);
        _sizeRect.setTop(PGE_Window::Height/2-height-padding);
        _sizeRect.setRight(PGE_Window::Width/2 + width + padding);
        _sizeRect.setBottom(PGE_Window::Height/2+height + padding);
        if(_sizeRect.top() < padding)
            _sizeRect.setY(padding);
    }
    else
    {
        _sizeRect.setLeft( _pos.x() - width-padding);
        _sizeRect.setTop(_pos.y() - height-padding);
        _sizeRect.setRight(_pos.x() + width + padding);
        _sizeRect.setBottom(_pos.y() + height + padding);
    }

    _menu.setPos(_sizeRect.right() - ( menuRect.width()>title_size.w() ? menuRect.width() : title_size.w() ),
                 _sizeRect.bottom() - menuRect.height() + _menu.topOffset() - padding);
}
예제 #2
0
PGE_Rect PGE_Menu::rectFull()
{
    PGE_Rect tRect = menuRect;
    tRect.setWidth( menuRect.width() + (_selector.w!=0 ? _selector.w : 20)+10 );

    if(_items.size()>_itemsOnScreen)
    {
        if (alignment == menuAlignment::VERTICLE)
        {
            tRect.setHeight(menuRect.height() +
                            (_scroll_up.w!=0 ? _scroll_up.h : 10 )+
                            (_scroll_down.w!=0 ? _scroll_down.h : 10 )+20-_font_offset);
        }
        else if (alignment == menuAlignment::HORIZONTAL)
        {
            tRect.setWidth( menuRect.width() +
                            (_scroll_up.w!=0 ? _scroll_up.h : 10 )+
                            (_scroll_down.w!=0 ? _scroll_down.h : 10 ));
            tRect.setHeight(menuRect.height() + (_selector.h!=0 ? _selector.h : 20)+10);
        }
    }
    else if (alignment == menuAlignment::HORIZONTAL)
    {
        tRect.setWidth( menuRect.width() );
    }
    return tRect;
}
예제 #3
0
void FontManager::SDL_string_texture_create(QFont &font, PGE_Rect limitRect, int fontFlags, QRgb color, QString &text, PGE_Texture *texture, bool borders)
{
    if(!isInit) return;

    QImage text_image;
    int off = (borders ? 4 : 0);
    QPainterPath path;
    text_image = QImage(QSize(limitRect.width(), limitRect.height()), QImage::Format_ARGB32);
    text_image.fill(Qt::transparent);
    QFont font_i = font;

    if(borders)
        font_i.setPixelSize(font_i.pixelSize() - 1);

    QFontMetrics meter(font_i);
    QPainter x(&text_image);
    x.setFont(font_i);
    x.setBrush(QBrush(color));
    x.setPen(QPen(color));

    if(borders)
    {
        path.addText(off, meter.height() + off * 2, font_i, text);
        x.strokePath(path, QPen(QColor(Qt::black), off));
        x.fillPath(path, QBrush(color));
    }
    else
        x.drawText(text_image.rect(), fontFlags, text);

    x.end();

    if(double_pixled)
    {
        //Pixelizing
        text_image = text_image.scaled(text_image.width() / 2, text_image.height() / 2);
        text_image = text_image.scaled(text_image.width() * 2, text_image.height() * 2);
    }

    GlRenderer::QImage2Texture(&text_image, *texture);
}
예제 #4
0
void LevelScene::placeItemByMouse(int x, int y)
{
    if(!placingMode) return;
    for(int i=0;i<cameras.size(); i++)
    {
        PGE_Rect camRect;
        camRect.setRect(0, cameras[i].h()*i, cameras[i].w(), cameras[i].h());
        if(camRect.collidePoint(x, y))
        {
            x+=cameras[i].posX();
            y+=cameras[i].posY();
            break;
        }
    }

    qDebug()<<"Placed:" << placingMode_item_type<<" in pos:" << x << y;

    switch(placingMode_item_type)
    {
        case 0:
            placingMode_block.x=x;
            placingMode_block.y=y;
            spawnBlock(placingMode_block);
            break;
        case 1:
            placingMode_bgo.x=x;
            placingMode_bgo.y=y;
            spawnBGO(placingMode_bgo);
            break;
        case 2:
            placingMode_npc.x=x;
            placingMode_npc.y=y;
            spawnNPC(placingMode_npc, GENERATOR_APPEAR, SPAWN_UP);
            break;
    }
}
예제 #5
0
void TitleScene::setMenu(TitleScene::CurrentMenu _menu)
{
    if(_menu < menuFirst) return;
    if(_menu > menuLast) return;

    m_currentMenu = _menu;
    m_menu.clear();
    m_menu.setTextLenLimit(22);
    switch(int(_menu))
    {
    case menu_main:
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //% "1 Player Game"
        m_menu.addMenuItem("game1p", qtTrId("MAINMENU_1_PLAYER_GAME"));
        //% "2 Player Game"
        m_menu.addMenuItem("game2p", qtTrId("MAINMENU_2_PLAYER_GAME"));
        //% "Play level"
        m_menu.addMenuItem("playlevel", qtTrId("MAINMENU_PLAY_SINGLE_LEVEL"));
        //% "Options"
        m_menu.addMenuItem("Options", qtTrId("MAINMENU_OPTIONS"));
        //% "Exit"
        m_menu.addMenuItem("Exit", qtTrId("MAINMENU_EXIT"));
        break;
    case menu_options:
        m_menu.setPos(260, 284);
        m_menu.setItemsNumber(9);
        //% "Test of screens"
        m_menu.addMenuItem("tests", qtTrId("MAINMENU_OPTIONS_TEST_SCRS"));
        //% "Test of message boxes"
        m_menu.addMenuItem("testboxes", qtTrId("MAINMENU_OPTIONS_TEST_MSGS"));
        //% "Player controlling"
        m_menu.addMenuItem("controls", qtTrId("MAINMENU_OPTIONS_CONTROLLS"));
        //% "Video settings"
        m_menu.addMenuItem("videosetup", qtTrId("MAINMENU_OPTIONS_VIDEO"));
        //% "Music volume"
        m_menu.addIntMenuItem(&g_AppSettings.volume_music, 0, 128, "vlm_music", qtTrId("MAINMENU_OPTIONS_MUS_VOL"), false,
                            []()->void{ PGE_MusPlayer::setVolume(g_AppSettings.volume_music); });
        //% "Sound volume"
        m_menu.addIntMenuItem(&g_AppSettings.volume_sound, 0, 128, "vlm_sound", qtTrId("MAINMENU_OPTIONS_SND_VOL"), false);
        //% "Full Screen mode"
        m_menu.addBoolMenuItem(&g_AppSettings.fullScreen, "full_screen", qtTrId("MAINMENU_OPTIONS_FULLSCR"),
                             []()->void{ PGE_Window::setFullScreen(g_AppSettings.fullScreen); }
                            );
        break;
    case menu_tests:
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //% "Credits"
        m_menu.addMenuItem("credits",     qtTrId("TESTSCR_CREDITS"));
        //% "Loading screen"
        m_menu.addMenuItem("loading",     qtTrId("TESTSCR_LOADING_SCREEN"));
        //% "Game over screen"
        m_menu.addMenuItem("gameover",    qtTrId("TESTSCR_GAMEOVER"));
        break;
    case menu_testboxes:
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //% "Message box"
        m_menu.addMenuItem("messagebox",  qtTrId("TEST_MSGBOX"));
        //% "Menu box"
        m_menu.addMenuItem("menubox",     qtTrId("TEST_MENUBOX"));
        //% "Text Input box"
        m_menu.addMenuItem("inputbox",    qtTrId("TEST_TEXTINPUTBOX"));
        //% "Question box"
        m_menu.addMenuItem("questionbox", qtTrId("TEST_QUESTION_BOX"));
        break;
    case menu_videosettings:
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //% "Show debug info"
        m_menu.addBoolMenuItem(&g_AppSettings.showDebugInfo, "dbg_flag", qtTrId("VIDEO_SHOW_DEBUG"));
        //% "Enable frame-skip"
        m_menu.addBoolMenuItem(&g_AppSettings.frameSkip, "frame_skip", qtTrId("VIDEO_ENABLE_FRSKIP"));
        //% "Enable V-Sync"
        m_menu.addBoolMenuItem(&g_AppSettings.vsync, "vsync", qtTrId("VIDEO_ENABLE_VSYNC"),
                             [this]()->void
        {
            PGE_Window::vsync = g_AppSettings.vsync;
            PGE_Window::toggleVSync(g_AppSettings.vsync);
            g_AppSettings.timeOfFrame = PGE_Window::TimeOfFrame;
            m_menu.setEnabled("phys_step", !PGE_Window::vsync);
        },
        PGE_Window::vsyncIsSupported
                            );

        //% "Frame time (ms.)"
        m_menu.addIntMenuItem(&g_AppSettings.timeOfFrame, 2, 17, "phys_step", qtTrId("VIDEO_FRAME_TIME"), false,
                            [this]()->void
        {
            if(!PGE_Window::vsync)
            {
                PGE_Window::TicksPerSecond = 1000.0 / double(g_AppSettings.timeOfFrame);
                PGE_Window::TimeOfFrame = g_AppSettings.timeOfFrame;
                g_AppSettings.TicksPerSecond = 1000.0 / double(g_AppSettings.timeOfFrame);
                this->updateTickValue();
            }
            else
                g_AppSettings.timeOfFrame = PGE_Window::TimeOfFrame;
        },
        !PGE_Window::vsync
                           );
        break;
    case menu_controls:
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //% "Player 1 controls"
        m_menu.addMenuItem("control_plr1", qtTrId("CONTROLLS_SETUP_PLAYER1"));
        //% "Player 2 controls"
        m_menu.addMenuItem("control_plr2", qtTrId("CONTROLLS_SETUP_PLAYER2"));
        break;
    case menu_controls_plr1:
    case menu_controls_plr2:
    {

        KeyMap *mp_p;
        int *mct_p = 0;
        SDL_Joystick *jdev = NULL;
        std::function<void()> ctrlSwitch;

        if(_menu == menu_controls_plr1)
        {
            ctrlSwitch = [this]()->void
            {
                setMenu(menu_controls_plr1);
            };
            mct_p = &g_AppSettings.player1_controller;
            if((*mct_p >= 0) && (*mct_p < static_cast<int>(g_AppSettings.player1_joysticks.size())))
            {
                if(*mct_p < static_cast<int>(g_AppSettings.joysticks.size()))
                    jdev = g_AppSettings.joysticks[size_t(*mct_p)];
                mp_p = &g_AppSettings.player1_joysticks[size_t(*mct_p)];
            }
            else
                mp_p = &g_AppSettings.player1_keyboard;
        }
        else
        {
            ctrlSwitch = [this]()->void
            {
                setMenu(menu_controls_plr2);
            };
            mct_p  = &g_AppSettings.player2_controller;
            if((*mct_p >= 0) && (*mct_p < static_cast<int>(g_AppSettings.player2_joysticks.size())))
            {
                if(*mct_p < static_cast<int>(g_AppSettings.joysticks.size()))
                    jdev = g_AppSettings.joysticks[size_t(*mct_p)];
                mp_p = &g_AppSettings.player2_joysticks[size_t(*mct_p)];
            }
            else
                mp_p = &g_AppSettings.player2_keyboard;
        }

        m_menu.setPos(300, 216);
        m_menu.setItemsNumber(11);
        std::vector<NamedIntItem> ctrls;
        NamedIntItem controller;
        controller.value = -1;
        //% "Keyboard"
        controller.label =   qtTrId("PLAYER_CONTROLS_SETUP_KEYBOARD");
        ctrls.push_back(controller);
        for(size_t i = 0; i < g_AppSettings.joysticks.size(); i++)
        {
            controller.value = int(i);
            //FIXME: missing in-string arguments support
            //% "Joystick: %1"
            controller.label = fmt::qformat(qtTrId("PLAYER_CONTROLS_SETUP_JOYSTICK"), SDL_JoystickName(g_AppSettings.joysticks[i]));
            ctrls.push_back(controller);
        }
        //% "Input:"
        m_menu.addNamedIntMenuItem(mct_p, ctrls, "ctrl_type", qtTrId("PLAYER_CONTROLS_SETUP_INPUT_TYPE"), true, ctrlSwitch);
        m_menu.setItemWidth(300);
        m_menu.setValueOffset(150);
        m_menu.addKeyGrabMenuItem(&mp_p->left, "key1",        "Left.........", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->right, "key2",       "Right........", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->up, "key3",          "Up...........", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->down, "key4",        "Down.........", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->jump, "key5",        "Jump.........", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->jump_alt, "key6",    "Alt-Jump....", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->run, "key7",         "Run..........", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->run_alt, "key8",     "Alt-Run.....", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->drop, "key9",        "Drop.........", jdev);
        m_menu.setValueOffset(210);
        m_menu.addKeyGrabMenuItem(&mp_p->start, "key10",      "Start........", jdev);
        m_menu.setValueOffset(210);
    }
    break;
    case menu_playepisode_wait:
    {
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //% "Please wait..."
        m_menu.addMenuItem("waitinginprocess", qtTrId("MSG_PLEASEWAIT"));
        m_filefind_finished = false;
        m_filefind_folder = ConfigManager::dirs.worlds;
        m_filefind_thread = SDL_CreateThread(findEpisodes, "EpisodeFinderThread", NULL);
    }
    break;
    case menu_playepisode:
    {
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //Build list of episodes
        for(size_t i = 0; i < m_filefind_found_files.size(); i++)
        {
            std::pair<std::string, std::string > &item = m_filefind_found_files[i];
            bool enabled = true;
            if(i == 0) enabled = (item.first != "noworlds");
            m_menu.addMenuItem(item.first, item.second, []()->void{}, enabled);
        }
        m_menu.sort();
    }
    break;
    case menu_playlevel_wait:
    {
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //% "Please wait..."
        m_menu.addMenuItem("waitinginprocess", qtTrId("MSG_PLEASEWAIT"));
        m_filefind_finished = false;
        m_filefind_folder = ConfigManager::dirs.worlds;
        m_filefind_thread = SDL_CreateThread(findLevels, "LevelFinderThread", NULL);
    }
    break;
    case menu_playlevel:
    {
        m_menu.setPos(300, 350);
        m_menu.setItemsNumber(5);
        //Build list of levels
        for(size_t i = 0; i < m_filefind_found_files.size(); i++)
        {
            std::pair<std::string, std::string > &item = m_filefind_found_files[i];
            bool enabled = true;
            if(i == 0) enabled = (item.first != "noworlds");
            m_menu.addMenuItem(item.first, item.second, []()->void{}, enabled);
        }
        m_menu.sort();
    }
    break;
    default:
        break;
    }

    PGE_Rect menuBox = m_menu.rect();
    m_menu.setPos(PGE_Window::Width / 2 - menuBox.width() / 2, menuBox.y());
    pLogDebug("Menuitem ID: %d, scrolling offset: %d", m_menustates[_menu].first, m_menustates[_menu].second);
    m_menu.setCurrentItem(m_menustates[_menu].first);
    m_menu.setOffset(m_menustates[_menu].second);
}
예제 #6
0
void TitleScene::setMenu(TitleScene::CurrentMenu _menu)
{
    if(_menu<menuFirst) return;
    if(_menu>menuLast) return;

    _currentMenu=_menu;
    menu.clear();
    menu.setTextLenLimit(22);
    switch(_menu)
    {
        case menu_main:
            menu.setPos(300, 350);
            menu.setItemsNumber(5);
            menu.addMenuItem("game1p", "1 Player Game");
            menu.addMenuItem("game2p", "2 Player Game");
            menu.addMenuItem("playlevel", "Play level");
            menu.addMenuItem("Options", "Options");
            menu.addMenuItem("Exit", "Exit");
        break;
            case menu_options:
                menu.setPos(260,284);
                menu.setItemsNumber(9);
                menu.addMenuItem("tests", "Test of screens");
                menu.addMenuItem("testboxes", "Test of message boxes");
                menu.addMenuItem("controls", "Player controlling");
                menu.addMenuItem("videosetup", "Video settings");
                menu.addIntMenuItem(&AppSettings.volume_music, 0, 128, "vlm_music", "Music volume", false,
                                    []()->void{ PGE_MusPlayer::MUS_changeVolume(AppSettings.volume_music); });
                menu.addIntMenuItem(&AppSettings.volume_sound, 0, 128, "vlm_sound", "Sound volume", false);
                menu.addBoolMenuItem(&AppSettings.fullScreen, "full_screen", "Full Screen mode",
                                     []()->void{ PGE_Window::setFullScreen(AppSettings.fullScreen); }
                                     );
            break;
                case menu_tests:
                    menu.setPos(300, 350);
                    menu.setItemsNumber(5);
                    menu.addMenuItem("credits", "Credits");
                    menu.addMenuItem("loading", "Loading screen");
                    menu.addMenuItem("gameover", "Game over screen");
                break;
                case menu_testboxes:
                    menu.setPos(300, 350);
                    menu.setItemsNumber(5);
                    menu.addMenuItem("messagebox", "Message box");
                    menu.addMenuItem("menubox", "Menu box");
                    menu.addMenuItem("inputbox", "Text Input box");
                    menu.addMenuItem("questionbox", "Question box");
                break;
                    case menu_videosettings:
                        menu.setPos(300, 350);
                        menu.setItemsNumber(5);
                        menu.addBoolMenuItem(&AppSettings.showDebugInfo, "dbg_flag", "Show debug info");
                        menu.addBoolMenuItem(&AppSettings.frameSkip, "frame_skip", "Enable frame-skip");
                        menu.addBoolMenuItem(&AppSettings.vsync, "vsync", "Enable V-Sync",
                                                 [this]()->void{
                                                     PGE_Window::vsync=AppSettings.vsync;
                                                     PGE_Window::toggleVSync(AppSettings.vsync);
                                                     AppSettings.timeOfFrame=PGE_Window::TimeOfFrame;
                                                 }
                                             );
                        //menu.addIntMenuItem(&AppSettings.MaxFPS, 65, 1000, "max_fps", "Max FPS");
                        menu.addIntMenuItem(&AppSettings.timeOfFrame, 2, 16, "phys_step", "Frame time (ms.)", false,
                                            [this]()->void{
                                                if(!PGE_Window::vsync)
                                                {
                                                    PGE_Window::TicksPerSecond=1000.0f/AppSettings.timeOfFrame;
                                                    PGE_Window::TimeOfFrame=AppSettings.timeOfFrame;
                                                    AppSettings.TicksPerSecond=1000.0f/AppSettings.timeOfFrame;
                                                    //PGE_Window::TicksPerSecond =AppSettings.TicksPerSecond;
                                                    this->updateTickValue();
                                                } else {
                                                    AppSettings.timeOfFrame=PGE_Window::TimeOfFrame;
                                                }
                                            }
                                            );
                    break;
                    case menu_controls:
                        menu.setPos(300, 350);
                        menu.setItemsNumber(5);
                        menu.addMenuItem("control_plr1", "Player 1 controls");
                        menu.addMenuItem("control_plr2", "Player 2 controls");
                    break;
                        case menu_controls_plr1:
                        case menu_controls_plr2:
                        {

                        KeyMap *mp_p;
                        int *mct_p=0;
                        SDL_Joystick* jdev=NULL;
                        std::function<void()> ctrlSwitch;

                        if(_menu==menu_controls_plr1)
                        {
                            ctrlSwitch = [this]()->void{
                                setMenu(menu_controls_plr1);
                                };
                            mct_p = &AppSettings.player1_controller;
                            if((*mct_p>=0)&&(*mct_p<AppSettings.player1_joysticks.size()))
                            {
                                if(*mct_p<AppSettings.joysticks.size())
                                    jdev        = AppSettings.joysticks[*mct_p];
                                mp_p         = &AppSettings.player1_joysticks[*mct_p];
                            }
                            else
                                mp_p = &AppSettings.player1_keyboard;
                        }
                        else{
                            ctrlSwitch = [this]()->void{
                                setMenu(menu_controls_plr2);
                                };
                            mct_p  = &AppSettings.player2_controller;
                            if((*mct_p>=0)&&(*mct_p<AppSettings.player2_joysticks.size()))
                            {
                                if(*mct_p<AppSettings.joysticks.size())
                                    jdev        = AppSettings.joysticks[*mct_p];
                                mp_p = &AppSettings.player2_joysticks[*mct_p];
                            }
                            else
                                mp_p = &AppSettings.player2_keyboard;
                        }

                            menu.setPos(300, 216);
                            menu.setItemsNumber(11);
                            QList<NamedIntItem> ctrls;
                            NamedIntItem controller;
                            controller.value=-1;
                            controller.label="Keyboard";
                            ctrls.push_back(controller);
                            for(int i=0;i<AppSettings.joysticks.size();i++)
                            {
                                controller.value=i;
                                controller.label=QString("Joystick: %1").arg(SDL_JoystickName(AppSettings.joysticks[i]));
                                ctrls.push_back(controller);
                            }
                            menu.addNamedIntMenuItem(mct_p, ctrls, "ctrl_type", "Input:", true, ctrlSwitch);
                            menu.setItemWidth(300);
                            menu.setValueOffset(150);
                            menu.addKeyGrabMenuItem(&mp_p->left, "key1",        "Left.........", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->right, "key2",       "Right........", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->up, "key3",          "Up...........", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->down, "key4",        "Down.........", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->jump, "key5",        "Jump.........", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->jump_alt, "key6",    "Alt-Jump....", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->run, "key7",         "Run..........", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->run_alt, "key8",     "Alt-Run.....", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->drop, "key9",        "Drop.........", jdev);
                            menu.setValueOffset(210);
                            menu.addKeyGrabMenuItem(&mp_p->start, "key10",      "Start........", jdev);
                            menu.setValueOffset(210);
                        }
                        break;
        case menu_playepisode_wait:
            {
                menu.setPos(300, 350);
                menu.setItemsNumber(5);
                menu.addMenuItem("waitinginprocess", "Please wait...");
                filefind_finished=false;
                filefind_folder=ConfigManager::dirs.worlds;
                filefind_thread=SDL_CreateThread( findEpisodes, "EpisodeFinderThread", NULL);
            }
            break;
        case menu_playepisode:
            {
                menu.setPos(300, 350);
                menu.setItemsNumber(5);
                //Build list of episodes
                for(int i=0;i<filefind_found_files.size();i++)
                    menu.addMenuItem(filefind_found_files[i].first, filefind_found_files[i].second);
                menu.sort();
            }
        break;
        case menu_playlevel_wait:
            {
                menu.setPos(300, 350);
                menu.setItemsNumber(5);
                menu.addMenuItem("waitinginprocess", "Please wait...");
                filefind_finished=false;
                filefind_folder=ConfigManager::dirs.worlds;
                filefind_thread=SDL_CreateThread( findLevels, "LevelFinderThread", NULL);
            }
        break;
        case menu_playlevel:
            {
                menu.setPos(300, 350);
                menu.setItemsNumber(5);
                //Build list of episodes
                for(int i=0;i<filefind_found_files.size();i++)
                    menu.addMenuItem(filefind_found_files[i].first, filefind_found_files[i].second);
                menu.sort();
            }
        break;
    default:
        break;
    }
    PGE_Rect menuBox = menu.rect();
    menu.setPos(PGE_Window::Width/2-menuBox.width()/2, menuBox.y());
    qDebug()<<"Menuitem ID: "<<menustates[_menu].first << ", scrolling offset: "<<menustates[_menu].second;
    menu.setCurrentItem(menustates[_menu].first);
    menu.setOffset(menustates[_menu].second);
}