bool PGE_OSXApplication::event(QEvent *event)
{
if(event->type() == QEvent::FileOpen)
{
QFileOpenEvent *openEvent = static_cast<QFileOpenEvent *>(event);
if(openEvent)
{
if(m_connected)
{
QString file = openEvent->file();
std::string file_s = file.toStdString();
pLogDebug("Opened file %s (signal)", file_s.c_str());
emit openFileRequested(file);
}
else
{
QString file = openEvent->file();
std::string file_s = file.toStdString();
pLogDebug("Opened file %s (queue)", file_s.c_str());
m_openFileRequests.enqueue(file);
}
}
else
pLogWarning("Failed to process openEvent: pointer is null!");
}
return QApplication::event(event);
}
void PGE_Translator::init()
{
if(m_isInit)
return;
QString defaultLocale = QLocale::system().name();
defaultLocale.truncate(defaultLocale.lastIndexOf('_'));
m_langPath = ApplicationPath;
m_langPath.append("/languages");
pLogDebug( "Initializing translator in the path: %s", m_langPath.toStdString().c_str() );
toggleLanguage(defaultLocale);
pLogDebug( "Locale detected: %s", m_currLang.toStdString().c_str() );
}
void obj_sound_index::play()
{
if(chunk)
Mix_PlayChannel(channel, chunk, 0);
else
pLogDebug("obj_sound_index::play() Null chunk!, file path: %s", path.c_str());
}
bool ConfigManager::soundIniChanged()
{
bool s = sound_lastIniFile_changed;
sound_lastIniFile_changed = false;
#ifdef DEBUG_BUILD
pLogDebug("Last Sounds.INI was changed: %d", s);
#endif
return s;
}
/**
* @brief Receive an opened file from the Finder (Must be created at least one window!)
*/
static void macosReceiveOpenFile()
{
if(g_fileToOpen.empty())
{
pLogDebug("Attempt to take Finder args...");
SDL_EventState(SDL_DROPFILE, SDL_ENABLE);
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(event.type == SDL_DROPFILE)
{
std::string file(event.drop.file);
if(Files::fileExists(file))
{
g_fileToOpen = file;
pLogDebug("Got file path: [%s]", file.c_str());
}
else
pLogWarning("Invalid file path, sent by Mac OS X Finder event: [%s]", file.c_str());
}
}
SDL_EventState(SDL_DROPFILE, SDL_DISABLE);
}
}
int main(int argc, char *argv[])
{
std::vector<std::string> args;
for(int i = 0; i < argc; i++)
args.emplace_back(argv[i]);
#ifdef __EMSCRIPTEN__
args.emplace_back(PGE_RUN_SINGLE_LEVEL);
#endif
// Parse --version or --install low args
if(!PGEEngineApp::parseLowArgs(args))
return 0;
// RAII for loaded/initialized libraries and modules
PGEEngineApp app;
//Initialize Qt's subsystem
AppPathManager::initAppPath();
//Load settings
app.loadSettings();
//Init log writer
app.loadLogger();
//Initialize translation sub-system
app.loadTr();
// Parse high arguments
app.parseHighArgs(args);
// Initializing SDL
if(app.initSDL())
{
//% "Unable to init SDL!"
PGE_Window::printSDLError(qtTrId("SDL_INIT_ERROR"));
pLogDebug("<Application closed with failure>");
return 1;
}
if(g_flags.audioEnabled && app.initAudio(g_flags.audioEnabled))
{
std::string msg = "Unable to load audio sub-system!\n";
msg += app.errorAudio();
msg += "\n\nContinuing without sound...";
pLogWarning(msg.c_str());
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_WARNING,
"Audio subsystem Error",
msg.c_str(),
nullptr);
g_flags.audioEnabled = false;
}
if(app.initWindow(INITIAL_WINDOW_TITLE, g_flags.rendererType))
{
pLogDebug("<Application closed with failure>");
return 1;
}
app.loadJoysticks();
SDL_PumpEvents();
if(g_AppSettings.fullScreen)
pLogDebug("Toggle fullscreen...");
#ifdef __APPLE__
macosReceiveOpenFile();
#endif
PGE_Window::setFullScreen(g_AppSettings.fullScreen);
GlRenderer::resetViewport();
//Init font manager
app.initFontBasics();
pLogDebug("Showing window...");
SDL_ShowWindow(PGE_Window::window);
pLogDebug("Clear screen...");
GlRenderer::clearScreen();
GlRenderer::flush();
GlRenderer::repaint();
SDL_PumpEvents();
/************************************************
* Check & ask for configuration pack *
************************************************/
//Process config manager screen
{
// Create configs folder if not exists
app.createConfigsDir();
// Initialize config selection screen
ConfigSelectScene GOScene;
// Are any config packs exists?
if(!GOScene.hasConfigPacks())
{
pLogCritical("Config packs not found");
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,
//% "Config packs not found"
qtTrId("ERROR_NO_CONFIG_PACKS_TTL").c_str(),
/*% "Can't start game, because available\n"
"configuration packages are not found!" */
qtTrId("ERROR_NO_CONFIG_PACKS_TEXT").c_str(),
PGE_Window::window);
return 2;
}
std::string configPath_manager = GOScene.isPreLoaded();
if(!g_fileToOpen.empty())
{
//% "Choose a game to test:"
GOScene.setLabel(qtTrId("CONFIG_SELECT_TEST"));
}
//If application have ran a first time or target configuration is not exist
if(configPath_manager.empty() && g_configPackPath.empty())
{
//Ask for configuration
if(GOScene.exec() == 1)
g_configPackPath = GOScene.currentConfigPath;
else
return 2;
}
else if(!configPath_manager.empty() && g_configPackPath.empty())
g_configPackPath = GOScene.currentConfigPath;
pLogDebug("Opening of the configuration package...");
ConfigManager::setConfigPath(g_configPackPath);
pLogDebug("Initialization of basic properties...");
if(!ConfigManager::loadBasics())
{
pLogDebug("<Application closed with failure>");
return 1;
}
app.enableConfigManager();
if(!ConfigManager::config_name.empty())
PGE_Window::setWindowTitle(ConfigManager::config_name);
pLogDebug("Current scene resolution: %d x %d", PGE_Window::Width, PGE_Window::Height);
pLogDebug("Config pack scene resolution: %d x %d", ConfigManager::viewport_width, ConfigManager::viewport_height);
if(ConfigManager::viewport_width != static_cast<unsigned int>(PGE_Window::Width) ||
ConfigManager::viewport_height != static_cast<unsigned int>(PGE_Window::Height))
{
PGE_Window::changeViewportResolution(ConfigManager::viewport_width, ConfigManager::viewport_height);
pLogDebug("Using scene resolution: %d x %d", ConfigManager::viewport_width, ConfigManager::viewport_height);
}
pLogDebug("Configuration package successfully loaded!");
if(g_flags.audioEnabled)
{
PGE_MusPlayer::setVolume(g_AppSettings.volume_music);
pLogDebug("Build SFX index cache...");
ConfigManager::buildSoundIndex(); //Load all sound effects into memory
}
//Init font manager
app.initFontFull();
}
if(!g_fileToOpen.empty())
{
g_GameState.reset();
//Apply custom game parameters from command line
g_flags.applyTestSettings(g_GameState);
if(Files::hasSuffix(g_fileToOpen, ".lvl") || Files::hasSuffix(g_fileToOpen, ".lvlx"))
{
g_GameState.LevelFile = g_fileToOpen;
g_GameState.isEpisode = false;
g_GameState.isTestingModeL = true;
g_GameState.isTestingModeW = false;
g_flags.testLevel = true;
g_flags.testWorld = false;
goto PlayLevel;
}
else if(Files::hasSuffix(g_fileToOpen, ".wld") || Files::hasSuffix(g_fileToOpen, ".wldx"))
{
g_Episode.character = 1;
g_Episode.savefile = "save1.savx";
g_Episode.worldfile = g_fileToOpen;
g_GameState._episodePath = DirMan(Files::dirname(g_fileToOpen)).absolutePath() + "/";
g_GameState.saveFileName = g_Episode.savefile;
g_GameState.isEpisode = true;
g_GameState.WorldFile = g_fileToOpen;
g_GameState.isTestingModeL = false;
g_GameState.isTestingModeW = true;
g_flags.testLevel = false;
g_flags.testWorld = true;
goto PlayWorldMap;
}
}
if(g_AppSettings.interprocessing)
{
//Apply custom game parameters from command line
g_flags.applyTestSettings(g_GameState);
goto PlayLevel;
}
LoadingScreen:
{
LoadingScene ttl;
ttl.setWaitTime(15000);
ttl.init();
ttl.m_fader.setFade(10, 0.0, 0.01);
int ret = ttl.exec();
if(ttl.doShutDown())
ret = -1;
if(ret == -1)
goto ExitFromApplication;
goto MainMenu;
}
CreditsScreen:
{
CreditsScene ttl;
ttl.setWaitTime(30000);
ttl.init();
ttl.m_fader.setFade(10, 0.0, 0.01);
int ret = ttl.exec();
if(ttl.doShutDown())
ret = -1;
if(ret == -1) goto ExitFromApplication;
if(g_flags.testWorld)
goto ExitFromApplication;
goto MainMenu;
}
GameOverScreen:
{
GameOverScene GOScene;
int result = GOScene.exec();
if(result == GameOverSceneResult::CONTINUE)
{
if(g_GameState.isHubLevel)
goto PlayLevel;
else
goto PlayWorldMap;
}
if(g_flags.testWorld)
goto ExitFromApplication;
goto MainMenu;
}
MainMenu:
{
g_GameState.reset();
std::shared_ptr<TitleScene> iScene(new TitleScene());
iScene->init();
iScene->m_fader.setFade(10, 0.0, 0.02);
int answer = iScene->exec();
PlayLevelResult res_level = iScene->m_result_level;
PlayEpisodeResult res_episode = iScene->m_result_episode;
if(iScene->doShutDown())
answer = TitleScene::ANSWER_EXIT;
switch(answer)
{
case TitleScene::ANSWER_EXIT:
goto ExitFromApplication;
case TitleScene::ANSWER_CREDITS:
goto CreditsScreen;
case TitleScene::ANSWER_LOADING:
goto LoadingScreen;
case TitleScene::ANSWER_GAMEOVER:
goto GameOverScreen;
case TitleScene::ANSWER_PLAYLEVEL:
{
g_jumpOnLevelEndTo = RETURN_TO_MAIN_MENU;
g_GameState.isEpisode = false;
g_GameState.numOfPlayers = 1;
g_GameState.LevelFile = res_level.levelfile;
g_GameState._episodePath.clear();
g_GameState.saveFileName.clear();
g_GameState.isTestingModeL = true;
goto PlayLevel;
}
case TitleScene::ANSWER_PLAYEPISODE:
case TitleScene::ANSWER_PLAYEPISODE_2P:
{
g_jumpOnLevelEndTo = RETURN_TO_WORLDMAP;
g_GameState.numOfPlayers = (answer == TitleScene::ANSWER_PLAYEPISODE_2P) ? 2 : 1;
PlayerState plr;
plr._chsetup = FileFormats::CreateSavCharacterState();
plr.characterID = 1;
plr.stateID = 1;
plr._chsetup.id = 1;
plr._chsetup.state = 1;
g_GameState.setPlayerState(1, plr);
plr.characterID = 2;
plr.stateID = 1;
plr._chsetup.id = 2;
plr._chsetup.state = 1;
g_GameState.setPlayerState(2, plr);
g_GameState.isEpisode = true;
g_Episode = res_episode;
g_GameState._episodePath = DirMan(Files::dirname(g_Episode.worldfile)).absolutePath() + "/";
g_GameState.saveFileName = g_Episode.savefile;
g_GameState.load();
goto PlayWorldMap;
}
default:
goto PlayWorldMap;
}
//goto PlayLevel;
}
PlayWorldMap:
{
WldExit::ExitWorldCodes wldExitCode = WldExit::EXIT_close;
std::shared_ptr<WorldScene> wScene;
wScene.reset(new WorldScene());
bool sceneResult = true;
if(g_Episode.worldfile.empty())
{
sceneResult = false;
//% "No opened files"
PGE_MsgBox::warn(qtTrId("ERROR_NO_OPEN_FILES_MSG"));
if(g_AppSettings.debugMode || g_flags.testWorld)
goto ExitFromApplication;
else
goto MainMenu;
}
else
{
sceneResult = wScene->loadFile(g_Episode.worldfile);
wScene->setGameState(&g_GameState); //Load game state to the world map
if(!sceneResult)
{
//% "ERROR:\nFail to start world map\n\n%1"
PGE_MsgBox::error( fmt::qformat(qtTrId("ERROR_FAIL_START_WLD"), wScene->getLastError()) );
wldExitCode = WldExit::EXIT_error;
}
}
if(sceneResult)
sceneResult = wScene->init();
if(sceneResult)
wScene->m_fader.setFade(10, 0.0, 0.02);
if(sceneResult)
wldExitCode = (WldExit::ExitWorldCodes)wScene->exec();
if(!sceneResult)
{
wldExitCode = WldExit::EXIT_error;
//% "World map was closed with error.\n%1"
PGE_MsgBox::error( fmt::qformat(qtTrId("WLD_ERROR_LVLCLOSED"), wScene->errorString()) );
}
g_GameState._recent_ExitCode_world = (int)wldExitCode;
if(wScene->doShutDown())
{
wScene.reset();
goto ExitFromApplication;
}
if(g_AppSettings.debugMode)
{
if(wldExitCode == WldExit::EXIT_beginLevel)
{
std::string msg;
//% "Start level\n%1"
msg += fmt::qformat(qtTrId("MSG_START_LEVEL"), g_GameState.LevelFile) + "\n\n";
//% "Type an exit code (signed integer)"
msg += qtTrId("MSG_WLDTEST_EXIT_CODE");
PGE_TextInputBox text(nullptr, msg, PGE_BoxBase::msg_info_light,
PGE_Point(-1, -1),
ConfigManager::setup_message_box.box_padding,
ConfigManager::setup_message_box.sprite);
text.exec();
g_GameState._recent_ExitCode_level = LvlExit::EXIT_Neutral;
if(PGEFile::IsIntS(text.inputText()))
g_GameState._recent_ExitCode_level = SDL_atoi(text.inputText().c_str());
if(g_GameState.isHubLevel)
goto ExitFromApplication;
goto PlayWorldMap;
}
else
goto ExitFromApplication;
}
switch(wldExitCode)
{
case WldExit::EXIT_beginLevel:
goto PlayLevel;
case WldExit::EXIT_close:
break;
case WldExit::EXIT_error:
break;
case WldExit::EXIT_exitNoSave:
break;
case WldExit::EXIT_exitWithSave:
break;
default:
break;
}
if(g_flags.testWorld)
goto ExitFromApplication;
goto MainMenu;
}
PlayLevel:
{
bool playAgain = true;
unsigned long entranceID = 0;
std::shared_ptr<LevelScene> lScene(nullptr);
while(playAgain)
{
entranceID = g_GameState.LevelTargetWarp;
if(g_GameState.LevelFile_hub == g_GameState.LevelFile)
{
g_GameState.isHubLevel = true;
entranceID = g_GameState.game_state.last_hub_warp;
}
int levelExitCode = 0;
lScene.reset(new LevelScene());
if(g_AppSettings.interprocessing)
g_GameState.isTestingModeL = true;
lScene->setGameState(&g_GameState);
bool sceneResult = true;
if(g_GameState.LevelFile.empty())
{
if(g_AppSettings.interprocessing && IntProc::isEnabled())
{
sceneResult = lScene->loadFileIP();
if((!sceneResult) && (!lScene->isExiting()))
{
//SDL_Delay(50);
levelExitCode = LvlExit::EXIT_Error;
PGE_MsgBox msgBox(nullptr, fmt::format_ne("ERROR:\nFail to start level\n\n{0}",
lScene->getLastError()),
PGE_MsgBox::msg_error);
msgBox.exec();
}
}
else
{
sceneResult = false;
levelExitCode = LvlExit::EXIT_Error;
//% "No opened files"
PGE_MsgBox::warn(qtTrId("ERROR_NO_OPEN_FILES_MSG"));
}
}
else
{
sceneResult = lScene->loadFile(g_GameState.LevelFile);
if(!sceneResult)
{
SDL_Delay(50);
PGE_MsgBox msgBox(nullptr,
fmt::format_ne("ERROR:\nFail to start level\n\n"
"{0}", lScene->getLastError()),
PGE_MsgBox::msg_error);
msgBox.exec();
}
}
if(sceneResult)
sceneResult = lScene->setEntrance(entranceID);
if(sceneResult)
sceneResult = lScene->init();
if(sceneResult)
{
lScene->m_fader.setFade(10, 0.0, 0.02);
levelExitCode = lScene->exec();
g_GameState._recent_ExitCode_level = levelExitCode;
}
if(!sceneResult)
levelExitCode = LvlExit::EXIT_Error;
switch(levelExitCode)
{
case LvlExit::EXIT_Warp:
{
if(lScene->m_warpToWorld)
{
g_GameState.game_state.worldPosX = lScene->toWorldXY().x();
g_GameState.game_state.worldPosY = lScene->toWorldXY().y();
g_GameState.LevelFile.clear();
entranceID = 0;
g_jumpOnLevelEndTo = g_GameState.isEpisode ? RETURN_TO_WORLDMAP : RETURN_TO_MAIN_MENU;
}
else
{
g_GameState.LevelFile = lScene->toAnotherLevel();
g_GameState.LevelTargetWarp = lScene->toAnotherEntrance();
entranceID = g_GameState.LevelTargetWarp;
if(g_GameState.isHubLevel)
{
g_GameState.isHubLevel = false;
g_GameState.game_state.last_hub_warp = lScene->m_lastWarpID;
}
}
if(g_GameState.LevelFile.empty())
playAgain = false;
if(g_AppSettings.debugMode)
{
std::string target;
if(lScene->m_warpToWorld)
{
target = fmt::format_ne("X={0}, Y={1}",
g_GameState.game_state.worldPosX,
g_GameState.game_state.worldPosY);
}
else
target = g_GameState.LevelFile;
if(!target.empty())
{
//% "Warp exit\n\nExit into:\n%1\n\nEntrance point: %2"
PGE_MsgBox::warn( fmt::qformat(qtTrId("LVL_EXIT_WARP_INFO"), target, entranceID) );
}
playAgain = false;
}
}
break;
case LvlExit::EXIT_Closed:
{
g_jumpOnLevelEndTo = RETURN_TO_EXIT;
playAgain = false;
}
break;
case LvlExit::EXIT_ReplayRequest:
{
playAgain = true;
}
break;
case LvlExit::EXIT_MenuExit:
{
g_jumpOnLevelEndTo = g_GameState.isEpisode ? RETURN_TO_WORLDMAP : RETURN_TO_MAIN_MENU;
if(g_GameState.isHubLevel)
g_jumpOnLevelEndTo = g_flags.testLevel ? RETURN_TO_EXIT : RETURN_TO_MAIN_MENU;
playAgain = false;
}
break;
case LvlExit::EXIT_PlayerDeath:
{
playAgain = g_GameState.isEpisode ? g_GameState.replay_on_fail : true;
g_jumpOnLevelEndTo = g_GameState.isEpisode ? RETURN_TO_WORLDMAP : RETURN_TO_MAIN_MENU;
//check the number of player lives here and decided to return worldmap or gameover
if(g_GameState.isEpisode)
{
g_GameState.game_state.lives--;
if(g_GameState.game_state.lives < 0)
{
playAgain = false;
g_GameState.game_state.coins = 0;
g_GameState.game_state.points = 0;
g_GameState.game_state.lives = 3;
g_jumpOnLevelEndTo = RETURN_TO_GAMEOVER_SCREEN;
}
}
}
break;
case LvlExit::EXIT_Error:
{
g_jumpOnLevelEndTo = (g_GameState.isEpisode) ? RETURN_TO_WORLDMAP : RETURN_TO_MAIN_MENU;
playAgain = false;
//% "Level was closed with error.\n%1"
PGE_MsgBox::error( fmt::qformat(qtTrId("LVL_ERROR_LVLCLOSED"), lScene->errorString()) );
}
break;
default:
g_jumpOnLevelEndTo = g_GameState.isEpisode ? RETURN_TO_WORLDMAP : RETURN_TO_MAIN_MENU;
playAgain = false;
}
if(g_flags.testLevel || g_AppSettings.debugMode)
g_jumpOnLevelEndTo = RETURN_TO_EXIT;
ConfigManager::unloadLevelConfigs();
lScene.reset();
}
if(g_AppSettings.interprocessing)
goto ExitFromApplication;
switch(g_jumpOnLevelEndTo)
{
case RETURN_TO_WORLDMAP:
goto PlayWorldMap;
case RETURN_TO_MAIN_MENU:
goto MainMenu;
case RETURN_TO_EXIT:
goto ExitFromApplication;
case RETURN_TO_GAMEOVER_SCREEN:
goto GameOverScreen;
case RETURN_TO_CREDITS_SCREEN:
goto CreditsScreen;
}
}
ExitFromApplication:
return 0;
}
int main(int argc, char* argv[])
{
int exitCode = EXIT_SUCCESS;
PActivity* activity = pNew(PActivity(argc, argv));
// Enable memory leak checks and heap validation.
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
_CrtSetBreakAlloc(-1);
pMain(argc, argv);
// Set console title.
SetConsoleTitle(L"protoss debug console");
// Disable the close button of the console window.
HWND hConsoleWindow = GetConsoleWindow();
if (hConsoleWindow != NULL)
{
HMENU hMenu = GetSystemMenu(hConsoleWindow, 0);
if (hMenu != NULL)
{
DeleteMenu(hMenu, SC_CLOSE, MF_BYCOMMAND);
DrawMenuBar(hConsoleWindow);
}
}
PContext* context = activity->findContext(pUint32(0));
pAssert(context != P_NULL);
if (context == P_NULL)
{
exitCode = EXIT_FAILURE;
pDelete(activity);
return exitCode;
}
PWin32Window window(context);
if (!window.create())
{
exitCode = EXIT_FAILURE;
pDelete(activity);
return exitCode;
}
// Initialize the context.
// kzaPlatformSetInstanceHandle(context, GetModuleHandle(NULL));
context->setState(P_CONTEXT_STATE_UNINITIALIZED);
if (!context->initialize())
{
exitCode = EXIT_FAILURE;
}
if (!context->onInitialized())
{
context->setState(P_CONTEXT_STATE_ERROR);
}
else
{
pLogDebug("Starting program main loop");
context->setState(P_CONTEXT_STATE_RUNNING);
}
if (context->getState() == P_CONTEXT_STATE_ERROR)
{
exitCode = EXIT_FAILURE;
}
// The mainloop of window.
window.run();
// Right before destroy the context, user might have
// something to do.
context->onDestroy();
context->destroy();
// Destroy native window.
window.destroy();
// Destroy the activity
pDelete(activity);
// If debugger is present, a pause is required to keep the console output
// visible. Otherwise the pause is automatic.
if (IsDebuggerPresent())
{
system("pause");
}
return exitCode;
}
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);
}
void RasterFont::loadFontMap(QString fontmap_ini)
{
QFileInfo fm_ini(fontmap_ini);
QString root = fm_ini.absoluteDir().absolutePath() + "/";
if(!fm_ini.exists())
{
pLogWarning("Can't load font map %s: file not exist", fontmap_ini.toStdString().c_str());
return;
}
QSettings font(fontmap_ini, QSettings::IniFormat);
font.setIniCodec("UTF-8");
QString texFile;
int w = letter_width, h = letter_height;
font.beginGroup("font-map");
texFile = font.value("texture", "").toString();
w = font.value("width", 0).toInt();
h = font.value("height", 0).toInt();
matrix_width = w;
matrix_height = h;
if((w <= 0) || (h <= 0))
{
pLogWarning("Wrong width and height values! %d x %d", w, h);
return;
}
if(!QFileInfo(root + texFile).exists())
{
pLogWarning("Failed to load font texture! file not exists: %s",
(root + texFile).toStdString().c_str());
return;
}
PGE_Texture fontTexture;
GlRenderer::loadTextureP(fontTexture, root + texFile);
if(!fontTexture.inited)
pLogWarning("Failed to load font texture! Invalid image!");
textures.push_back(fontTexture);
PGE_Texture *loadedTexture = &textures.last();
if((letter_width == 0) || (letter_height == 0))
{
letter_width = fontTexture.w / w;
letter_height = fontTexture.h / h;
if(space_width == 0)
space_width = letter_width;
if(newline_offset == 0)
newline_offset = letter_height;
}
font.endGroup();
font.beginGroup("entries");
QStringList entries = font.allKeys();
//qDebug()<<entries;
for(QString &x : entries)
{
bool okX = false;
bool okY = false;
x = x.trimmed();
QString charPosX = "0", charPosY = "0";
QStringList tmp = x.split('-');
if(tmp.isEmpty()) continue;
charPosX = tmp[0];
charPosX.toInt(&okX);
if(!okX)
{
pLogDebug("=invalid-X=%d=", x.toStdString().c_str());
continue;
}
if(matrix_width > 1)
{
if(tmp.size() < 2) continue;
charPosY = tmp[1];
charPosY.toInt(&okY);
if(!okY)
{
pLogDebug("=invalid-Y=%d=", x.toStdString().c_str());
continue;
}
}
QString charX = font.value(x, "").toString();
/*Format of entry: X23
* X - UTF-8 Symbol
* 2 - padding left [for non-mono fonts]
* 3 - padding right [for non-mono fonts]
*/
if(charX.isEmpty()) continue;
QChar ch = charX[0];
//qDebug()<<"=char=" << ch << "=id="<<charPosX.toInt()<<charPosY.toInt()<<"=";
RasChar rch;
rch.valid = true;
rch.tx = loadedTexture;
rch.l = charPosY.toFloat(&okY) / matrix_width;
rch.r = (charPosY.toFloat(&okY) + 1.0f) / matrix_width;
rch.padding_left = (charX.size() > 1) ? char2int(charX[1]) : 0;
rch.padding_right = (charX.size() > 2) ? char2int(charX[2]) : 0;
rch.t = charPosX.toFloat(&okX) / matrix_height;
rch.b = (charPosX.toFloat(&okX) + 1.0f) / matrix_height;
fontMap[ch] = rch;
}
font.endGroup();
if(!fontMap.isEmpty())
isReady = true;
}
