2017-07-13 10:26:03 +02:00
|
|
|
/*
|
|
|
|
* CMT.cpp, part of VCMI engine
|
|
|
|
*
|
|
|
|
* Authors: listed in file AUTHORS in main folder
|
|
|
|
*
|
|
|
|
* License: GNU General Public License v2.0 or later
|
|
|
|
* Full text of license available in license.txt file, in main folder
|
|
|
|
*
|
|
|
|
*/
|
2023-04-30 00:03:50 +02:00
|
|
|
|
2007-06-06 22:29:40 +03:00
|
|
|
// CMT.cpp : Defines the entry point for the console application.
|
2011-12-14 00:23:17 +03:00
|
|
|
#include "StdInc.h"
|
2023-04-30 00:03:50 +02:00
|
|
|
#include "CMT.h"
|
2016-11-28 20:00:56 +02:00
|
|
|
|
2008-08-04 18:56:36 +03:00
|
|
|
#include "CGameInfo.h"
|
2018-01-05 19:21:07 +02:00
|
|
|
#include "mainmenu/CMainMenu.h"
|
2023-01-05 19:34:37 +02:00
|
|
|
#include "gui/CursorHandler.h"
|
2023-05-18 19:32:29 +02:00
|
|
|
#include "eventsSDL/InputHandler.h"
|
2007-11-19 00:58:28 +02:00
|
|
|
#include "CPlayerInterface.h"
|
2010-12-20 23:22:53 +02:00
|
|
|
#include "CVideoHandler.h"
|
2023-02-01 20:42:06 +02:00
|
|
|
#include "CMusicHandler.h"
|
|
|
|
#include "gui/CGuiHandler.h"
|
2023-05-16 14:10:26 +02:00
|
|
|
#include "gui/WindowHandler.h"
|
2023-02-01 20:42:06 +02:00
|
|
|
#include "CServerHandler.h"
|
|
|
|
#include "ClientCommandManager.h"
|
|
|
|
#include "windows/CMessage.h"
|
2023-05-08 12:22:01 +02:00
|
|
|
#include "render/IScreenHandler.h"
|
2023-02-01 20:42:06 +02:00
|
|
|
|
|
|
|
#include "../lib/filesystem/Filesystem.h"
|
2010-12-20 23:22:53 +02:00
|
|
|
#include "../lib/CGeneralTextHandler.h"
|
2009-10-10 08:47:59 +03:00
|
|
|
#include "../lib/VCMIDirs.h"
|
2023-06-23 17:02:48 +02:00
|
|
|
#include "../lib/VCMI_Lib.h"
|
2023-05-18 19:32:29 +02:00
|
|
|
#include "../lib/CConfigHandler.h"
|
2023-04-30 00:03:50 +02:00
|
|
|
|
2013-04-09 17:31:36 +03:00
|
|
|
#include "../lib/logging/CBasicLogConfigurator.h"
|
2018-01-05 19:21:07 +02:00
|
|
|
|
2023-02-01 20:42:06 +02:00
|
|
|
#include <boost/program_options.hpp>
|
2018-04-03 03:37:09 +02:00
|
|
|
#include <vstd/StringUtils.h>
|
2023-04-30 00:38:28 +02:00
|
|
|
|
2023-05-19 19:03:04 +02:00
|
|
|
#include <SDL_main.h>
|
2023-08-06 12:31:10 +02:00
|
|
|
#include <SDL.h>
|
2023-05-19 19:03:04 +02:00
|
|
|
|
2017-05-25 19:57:20 +02:00
|
|
|
#ifdef VCMI_ANDROID
|
2023-02-25 09:15:09 +02:00
|
|
|
#include "../lib/CAndroidVMHelper.h"
|
2023-04-30 00:38:28 +02:00
|
|
|
#include <SDL_system.h>
|
2017-05-25 19:57:20 +02:00
|
|
|
#endif
|
2023-01-06 18:52:18 +02:00
|
|
|
|
2009-02-08 17:39:26 +02:00
|
|
|
#if __MINGW32__
|
|
|
|
#undef main
|
|
|
|
#endif
|
2009-04-15 17:03:31 +03:00
|
|
|
|
2010-12-22 22:14:40 +02:00
|
|
|
namespace po = boost::program_options;
|
2017-06-26 01:40:48 +02:00
|
|
|
namespace po_style = boost::program_options::command_line_style;
|
2014-08-11 00:42:39 +03:00
|
|
|
namespace bfs = boost::filesystem;
|
2010-12-22 22:14:40 +02:00
|
|
|
|
2014-06-01 19:50:19 +03:00
|
|
|
extern boost::thread_specific_ptr<bool> inGuiThread;
|
|
|
|
|
2013-06-21 23:59:32 +03:00
|
|
|
static po::variables_map vm;
|
|
|
|
|
2022-09-27 06:05:10 +02:00
|
|
|
#ifndef VCMI_IOS
|
2009-08-17 11:50:31 +03:00
|
|
|
void processCommand(const std::string &message);
|
2022-09-27 06:05:10 +02:00
|
|
|
#endif
|
2009-06-24 09:56:36 +03:00
|
|
|
void playIntro();
|
2014-06-01 18:31:37 +03:00
|
|
|
static void mainLoop();
|
2009-06-24 09:56:36 +03:00
|
|
|
|
2019-05-10 11:35:28 +02:00
|
|
|
static CBasicLogConfigurator *logConfig;
|
|
|
|
|
2009-06-24 09:56:36 +03:00
|
|
|
void init()
|
|
|
|
{
|
2018-07-25 00:36:48 +02:00
|
|
|
CStopWatch tmh;
|
2009-06-24 09:56:36 +03:00
|
|
|
|
2012-12-12 14:13:57 +03:00
|
|
|
loadDLLClasses();
|
2010-12-19 00:11:28 +02:00
|
|
|
const_cast<CGameInfo*>(CGI)->setFromLib();
|
2014-03-10 19:00:58 +03:00
|
|
|
|
2017-08-10 20:59:55 +02:00
|
|
|
logGlobal->info("Initializing VCMI_Lib: %d ms", tmh.getDiff());
|
2009-06-24 09:56:36 +03:00
|
|
|
|
2023-04-02 18:56:10 +02:00
|
|
|
// Debug code to load all maps on start
|
|
|
|
//ClientCommandManager commandController;
|
|
|
|
//commandController.processCommand("convert txt", false);
|
2009-06-24 09:56:36 +03:00
|
|
|
}
|
2009-04-14 15:47:09 +03:00
|
|
|
|
2018-01-13 10:43:26 +02:00
|
|
|
static void prog_version()
|
2010-04-04 01:06:50 +03:00
|
|
|
{
|
2011-12-14 00:23:17 +03:00
|
|
|
printf("%s\n", GameConstants::VCMI_VERSION.c_str());
|
2014-03-20 21:17:40 +03:00
|
|
|
std::cout << VCMIDirs::get().genHelpString();
|
2010-04-04 01:06:50 +03:00
|
|
|
}
|
|
|
|
|
2012-01-03 04:55:26 +03:00
|
|
|
static void prog_help(const po::options_description &opts)
|
2010-04-04 01:06:50 +03:00
|
|
|
{
|
2017-06-26 01:40:48 +02:00
|
|
|
auto time = std::time(0);
|
2011-12-14 00:23:17 +03:00
|
|
|
printf("%s - A Heroes of Might and Magic 3 clone\n", GameConstants::VCMI_VERSION.c_str());
|
2017-06-26 01:40:48 +02:00
|
|
|
printf("Copyright (C) 2007-%d VCMI dev team - see AUTHORS file\n", std::localtime(&time)->tm_year + 1900);
|
2015-12-13 21:14:37 +02:00
|
|
|
printf("This is free software; see the source for copying conditions. There is NO\n");
|
|
|
|
printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
|
2010-04-04 01:06:50 +03:00
|
|
|
printf("\n");
|
2012-01-03 04:55:26 +03:00
|
|
|
std::cout << opts;
|
2010-04-04 01:06:50 +03:00
|
|
|
}
|
|
|
|
|
2017-08-16 15:29:18 +02:00
|
|
|
#if defined(VCMI_WINDOWS) && !defined(__GNUC__) && defined(VCMI_WITH_DEBUG_CONSOLE)
|
|
|
|
int wmain(int argc, wchar_t* argv[])
|
2023-02-27 12:00:13 +02:00
|
|
|
#elif defined(VCMI_MOBILE)
|
2012-12-01 09:30:52 +03:00
|
|
|
int SDL_main(int argc, char *argv[])
|
2008-08-04 18:56:36 +03:00
|
|
|
#else
|
2017-08-09 00:09:29 +02:00
|
|
|
int main(int argc, char * argv[])
|
2008-08-04 18:56:36 +03:00
|
|
|
#endif
|
2009-02-08 17:39:26 +02:00
|
|
|
{
|
2014-11-02 15:19:14 +02:00
|
|
|
#ifdef VCMI_ANDROID
|
2023-02-25 09:34:37 +02:00
|
|
|
CAndroidVMHelper::initClassloader(SDL_AndroidGetJNIEnv());
|
2014-11-02 15:19:14 +02:00
|
|
|
// boost will crash without this
|
|
|
|
setenv("LANG", "C", 1);
|
|
|
|
#endif
|
2017-08-13 16:20:57 +02:00
|
|
|
|
2023-02-27 12:00:13 +02:00
|
|
|
#if !defined(VCMI_MOBILE)
|
2014-03-23 15:59:03 +03:00
|
|
|
// Correct working dir executable folder (not bundle folder) so we can use executable relative paths
|
2017-08-13 16:20:57 +02:00
|
|
|
boost::filesystem::current_path(boost::filesystem::system_complete(argv[0]).parent_path());
|
2012-12-01 09:30:52 +03:00
|
|
|
#endif
|
2020-10-06 01:27:04 +02:00
|
|
|
std::cout << "Starting... " << std::endl;
|
2010-12-22 22:14:40 +02:00
|
|
|
po::options_description opts("Allowed options");
|
|
|
|
opts.add_options()
|
|
|
|
("help,h", "display help and exit")
|
|
|
|
("version,v", "display version information and exit")
|
2017-06-04 14:59:11 +02:00
|
|
|
("disable-shm", "force disable shared memory usage")
|
|
|
|
("enable-shm-uuid", "use UUID for shared memory identifier")
|
2017-03-12 09:54:24 +02:00
|
|
|
("testmap", po::value<std::string>(), "")
|
2018-01-05 19:21:07 +02:00
|
|
|
("testsave", po::value<std::string>(), "")
|
2017-06-03 07:25:10 +02:00
|
|
|
("spectate,s", "enable spectator interface for AI-only games")
|
|
|
|
("spectate-ignore-hero", "wont follow heroes on adventure map")
|
|
|
|
("spectate-hero-speed", po::value<int>(), "hero movement speed on adventure map")
|
|
|
|
("spectate-battle-speed", po::value<int>(), "battle animation speed for spectator")
|
|
|
|
("spectate-skip-battle", "skip battles in spectator view")
|
|
|
|
("spectate-skip-battle-result", "skip battle result window")
|
2018-01-05 19:21:07 +02:00
|
|
|
("onlyAI", "allow to run without human player, all players will be default AI")
|
2017-03-12 09:54:24 +02:00
|
|
|
("headless", "runs without GUI, implies --onlyAI")
|
2013-06-21 23:59:32 +03:00
|
|
|
("ai", po::value<std::vector<std::string>>(), "AI to be used for the player, can be specified several times for the consecutive players")
|
2012-02-29 04:31:48 +03:00
|
|
|
("oneGoodAI", "puts one default AI and the rest will be EmptyAI")
|
2012-01-03 04:55:26 +03:00
|
|
|
("autoSkip", "automatically skip turns in GUI")
|
2012-05-05 11:32:55 +03:00
|
|
|
("disable-video", "disable video player")
|
2014-10-19 14:47:09 +03:00
|
|
|
("nointro,i", "skips intro movies")
|
2016-09-16 19:01:44 +02:00
|
|
|
("donotstartserver,d","do not attempt to start server and just connect to it instead server")
|
2017-06-04 07:49:23 +02:00
|
|
|
("serverport", po::value<si64>(), "override port specified in config file")
|
2022-11-07 11:44:58 +02:00
|
|
|
("savefrequency", po::value<si64>(), "limit auto save creation to each N days")
|
2022-11-08 02:44:34 +02:00
|
|
|
("lobby", "parameters address, port, uuid to connect ro remote lobby session")
|
|
|
|
("lobby-address", po::value<std::string>(), "address to remote lobby")
|
|
|
|
("lobby-port", po::value<ui16>(), "port to remote lobby")
|
|
|
|
("lobby-host", "if this client hosts session")
|
|
|
|
("lobby-uuid", po::value<std::string>(), "uuid to the server")
|
2022-11-13 23:48:13 +02:00
|
|
|
("lobby-connections", po::value<ui16>(), "connections of server")
|
2022-12-26 00:37:35 +02:00
|
|
|
("lobby-username", po::value<std::string>(), "player name")
|
2023-01-03 14:11:12 +02:00
|
|
|
("lobby-gamemode", po::value<ui16>(), "use 0 for new game and 1 for load game")
|
2022-11-08 02:44:34 +02:00
|
|
|
("uuid", po::value<std::string>(), "uuid for the client");
|
2010-12-22 22:14:40 +02:00
|
|
|
|
|
|
|
if(argc > 1)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
2017-06-26 01:40:48 +02:00
|
|
|
po::store(po::parse_command_line(argc, argv, opts, po_style::unix_style|po_style::case_insensitive), vm);
|
2010-12-22 22:14:40 +02:00
|
|
|
}
|
2014-03-07 16:21:09 +03:00
|
|
|
catch(std::exception &e)
|
2010-12-22 22:14:40 +02:00
|
|
|
{
|
2020-10-06 01:27:04 +02:00
|
|
|
std::cerr << "Failure during parsing command-line options:\n" << e.what() << std::endl;
|
2010-04-04 01:06:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-22 22:14:40 +02:00
|
|
|
po::notify(vm);
|
|
|
|
if(vm.count("help"))
|
|
|
|
{
|
2012-01-03 04:55:26 +03:00
|
|
|
prog_help(opts);
|
2022-08-05 13:32:29 +02:00
|
|
|
#ifdef VCMI_IOS
|
|
|
|
exit(0);
|
|
|
|
#else
|
2010-12-22 22:14:40 +02:00
|
|
|
return 0;
|
2022-08-05 13:32:29 +02:00
|
|
|
#endif
|
2010-12-22 22:14:40 +02:00
|
|
|
}
|
|
|
|
if(vm.count("version"))
|
|
|
|
{
|
|
|
|
prog_version();
|
2022-08-05 13:32:29 +02:00
|
|
|
#ifdef VCMI_IOS
|
|
|
|
exit(0);
|
|
|
|
#else
|
2010-12-22 22:14:40 +02:00
|
|
|
return 0;
|
2022-08-05 13:32:29 +02:00
|
|
|
#endif
|
2010-04-04 01:06:50 +03:00
|
|
|
}
|
2013-01-21 01:49:34 +03:00
|
|
|
|
2015-12-13 21:14:37 +02:00
|
|
|
// Init old logging system and new (temporary) logging system
|
2011-12-17 21:59:59 +03:00
|
|
|
CStopWatch total, pomtime;
|
2008-11-15 15:44:32 +02:00
|
|
|
std::cout.flags(std::ios::unitbuf);
|
2022-09-27 06:05:10 +02:00
|
|
|
#ifndef VCMI_IOS
|
2017-07-16 11:58:05 +02:00
|
|
|
console = new CConsoleHandler();
|
2023-01-15 02:09:58 +02:00
|
|
|
|
|
|
|
auto callbackFunction = [](std::string buffer, bool calledFromIngameConsole)
|
|
|
|
{
|
|
|
|
ClientCommandManager commandController;
|
|
|
|
commandController.processCommand(buffer, calledFromIngameConsole);
|
|
|
|
};
|
|
|
|
|
|
|
|
*console->cb = callbackFunction;
|
2009-06-23 11:14:49 +03:00
|
|
|
console->start();
|
2022-09-27 06:05:10 +02:00
|
|
|
#endif
|
2008-11-09 00:29:19 +02:00
|
|
|
|
2022-09-17 15:56:01 +02:00
|
|
|
const bfs::path logPath = VCMIDirs::get().userLogsPath() / "VCMI_Client_log.txt";
|
2019-05-10 11:35:28 +02:00
|
|
|
logConfig = new CBasicLogConfigurator(logPath, console);
|
|
|
|
logConfig->configureDefault();
|
2023-04-30 00:03:50 +02:00
|
|
|
logGlobal->info("Starting client of '%s'", GameConstants::VCMI_VERSION);
|
2017-08-10 20:59:55 +02:00
|
|
|
logGlobal->info("Creating console and configuring logger: %d ms", pomtime.getDiff());
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->info("The log file will be saved to %s", logPath);
|
2013-04-09 17:31:36 +03:00
|
|
|
|
2015-12-13 21:14:37 +02:00
|
|
|
// Init filesystem and settings
|
2013-04-11 18:58:01 +03:00
|
|
|
preinitDLL(::console);
|
2023-03-14 15:59:33 +02:00
|
|
|
|
2017-03-12 09:54:24 +02:00
|
|
|
Settings session = settings.write["session"];
|
2018-04-03 03:37:09 +02:00
|
|
|
auto setSettingBool = [](std::string key, std::string arg) {
|
|
|
|
Settings s = settings.write(vstd::split(key, "/"));
|
|
|
|
if(::vm.count(arg))
|
|
|
|
s->Bool() = true;
|
|
|
|
else if(s->isNull())
|
|
|
|
s->Bool() = false;
|
|
|
|
};
|
|
|
|
auto setSettingInteger = [](std::string key, std::string arg, si64 defaultValue) {
|
|
|
|
Settings s = settings.write(vstd::split(key, "/"));
|
|
|
|
if(::vm.count(arg))
|
|
|
|
s->Integer() = ::vm[arg].as<si64>();
|
|
|
|
else if(s->isNull())
|
|
|
|
s->Integer() = defaultValue;
|
|
|
|
};
|
|
|
|
|
|
|
|
setSettingBool("session/onlyai", "onlyAI");
|
2017-03-12 09:54:24 +02:00
|
|
|
if(vm.count("headless"))
|
|
|
|
{
|
|
|
|
session["headless"].Bool() = true;
|
2017-03-14 01:40:39 +02:00
|
|
|
session["onlyai"].Bool() = true;
|
2017-03-12 09:54:24 +02:00
|
|
|
}
|
2018-01-05 19:21:07 +02:00
|
|
|
else if(vm.count("spectate"))
|
|
|
|
{
|
|
|
|
session["spectate"].Bool() = true;
|
|
|
|
session["spectate-ignore-hero"].Bool() = vm.count("spectate-ignore-hero");
|
|
|
|
session["spectate-skip-battle"].Bool() = vm.count("spectate-skip-battle");
|
|
|
|
session["spectate-skip-battle-result"].Bool() = vm.count("spectate-skip-battle-result");
|
|
|
|
if(vm.count("spectate-hero-speed"))
|
|
|
|
session["spectate-hero-speed"].Integer() = vm["spectate-hero-speed"].as<int>();
|
|
|
|
if(vm.count("spectate-battle-speed"))
|
|
|
|
session["spectate-battle-speed"].Float() = vm["spectate-battle-speed"].as<int>();
|
|
|
|
}
|
2017-06-26 01:40:48 +02:00
|
|
|
// Server settings
|
2018-04-03 03:37:09 +02:00
|
|
|
setSettingBool("session/donotstartserver", "donotstartserver");
|
2017-06-26 01:40:48 +02:00
|
|
|
|
2017-06-04 14:59:11 +02:00
|
|
|
// Shared memory options
|
2018-04-03 03:37:09 +02:00
|
|
|
setSettingBool("session/disable-shm", "disable-shm");
|
|
|
|
setSettingBool("session/enable-shm-uuid", "enable-shm-uuid");
|
2013-04-09 17:31:36 +03:00
|
|
|
|
2015-12-13 21:14:37 +02:00
|
|
|
// Init special testing settings
|
2018-04-03 03:37:09 +02:00
|
|
|
setSettingInteger("session/serverport", "serverport", 0);
|
|
|
|
setSettingInteger("general/saveFrequency", "savefrequency", 1);
|
2015-12-13 21:14:37 +02:00
|
|
|
|
|
|
|
// Initialize logging based on settings
|
2019-05-10 11:35:28 +02:00
|
|
|
logConfig->configure();
|
2018-04-03 03:37:09 +02:00
|
|
|
logGlobal->debug("settings = %s", settings.toJsonNode().toJson());
|
2012-08-02 14:03:26 +03:00
|
|
|
|
2013-03-12 17:56:23 +03:00
|
|
|
// Some basic data validation to produce better error messages in cases of incorrect install
|
2023-08-08 11:50:16 +02:00
|
|
|
auto testFile = [](std::string filename, std::string message)
|
2013-03-12 17:56:23 +03:00
|
|
|
{
|
2023-08-08 11:50:16 +02:00
|
|
|
if (!CResourceHandler::get()->existsResource(ResourceID(filename)))
|
|
|
|
handleFatalError(message, false);
|
2013-03-12 17:56:23 +03:00
|
|
|
};
|
|
|
|
|
2023-08-06 17:12:36 +02:00
|
|
|
testFile("DATA/HELP.TXT", "VCMI requires Heroes III: Shadow of Death or Heroes III: Complete data files to run!");
|
|
|
|
testFile("MODS/VCMI/MOD.JSON", "VCMI installation is corrupted! Built-in mod was not found!");
|
2023-08-08 11:50:16 +02:00
|
|
|
testFile("DATA/PLAYERS.PAL", "Heroes III data files are missing or corruped! Please reinstall them.");
|
|
|
|
testFile("SPRITES/DEFAULT.DEF", "Heroes III data files are missing or corruped! Please reinstall them.");
|
2023-08-06 17:12:36 +02:00
|
|
|
testFile("DATA/TENTCOLR.TXT", "Heroes III: Restoration of Erathia (including HD Edition) data files are not supported!");
|
2013-03-12 17:56:23 +03:00
|
|
|
|
2020-10-01 10:38:06 +02:00
|
|
|
srand ( (unsigned int)time(nullptr) );
|
2014-03-07 16:21:09 +03:00
|
|
|
|
2017-03-12 09:54:24 +02:00
|
|
|
if(!settings["session"]["headless"].Bool())
|
2023-01-16 12:26:43 +02:00
|
|
|
GH.init();
|
2016-01-18 15:05:43 +02:00
|
|
|
|
2017-07-16 11:58:05 +02:00
|
|
|
CCS = new CClientState();
|
|
|
|
CGI = new CGameInfo(); //contains all global informations about game (texts, lodHandlers, map handler etc.)
|
2018-01-05 19:21:07 +02:00
|
|
|
CSH = new CServerHandler();
|
2022-10-01 16:28:45 +02:00
|
|
|
|
2009-08-17 11:50:31 +03:00
|
|
|
// Initialize video
|
2014-05-24 16:52:43 +03:00
|
|
|
#ifdef DISABLE_VIDEO
|
2017-07-16 11:58:05 +02:00
|
|
|
CCS->videoh = new CEmptyVideoPlayer();
|
2011-08-08 10:12:18 +03:00
|
|
|
#else
|
2017-03-12 09:54:24 +02:00
|
|
|
if (!settings["session"]["headless"].Bool() && !vm.count("disable-video"))
|
2017-07-16 11:58:05 +02:00
|
|
|
CCS->videoh = new CVideoPlayer();
|
2012-05-05 11:32:55 +03:00
|
|
|
else
|
2017-07-16 11:58:05 +02:00
|
|
|
CCS->videoh = new CEmptyVideoPlayer();
|
2011-08-08 10:12:18 +03:00
|
|
|
#endif
|
2012-08-18 13:29:54 +03:00
|
|
|
|
2017-08-10 20:59:55 +02:00
|
|
|
logGlobal->info("\tInitializing video: %d ms", pomtime.getDiff());
|
2009-08-17 11:50:31 +03:00
|
|
|
|
2018-01-05 19:21:07 +02:00
|
|
|
if(!settings["session"]["headless"].Bool())
|
|
|
|
{
|
|
|
|
//initializing audio
|
|
|
|
CCS->soundh = new CSoundHandler();
|
|
|
|
CCS->soundh->init();
|
2020-10-01 10:38:06 +02:00
|
|
|
CCS->soundh->setVolume((ui32)settings["general"]["sound"].Float());
|
2018-01-05 19:21:07 +02:00
|
|
|
CCS->musich = new CMusicHandler();
|
|
|
|
CCS->musich->init();
|
2020-10-01 10:38:06 +02:00
|
|
|
CCS->musich->setVolume((ui32)settings["general"]["music"].Float());
|
2018-01-05 19:21:07 +02:00
|
|
|
logGlobal->info("Initializing screen and sound handling: %d ms", pomtime.getDiff());
|
|
|
|
}
|
2023-01-16 12:26:43 +02:00
|
|
|
|
2014-07-02 22:53:23 +03:00
|
|
|
#ifndef VCMI_NO_THREADED_LOAD
|
|
|
|
//we can properly play intro only in the main thread, so we have to move loading to the separate thread
|
|
|
|
boost::thread loading(init);
|
2016-01-18 15:05:43 +02:00
|
|
|
#else
|
2014-02-20 21:53:18 +03:00
|
|
|
init();
|
2014-07-02 22:53:23 +03:00
|
|
|
#endif
|
2010-12-22 22:14:40 +02:00
|
|
|
|
2017-03-12 09:54:24 +02:00
|
|
|
if(!settings["session"]["headless"].Bool())
|
2013-06-17 18:45:55 +03:00
|
|
|
{
|
2014-08-04 14:03:57 +03:00
|
|
|
if(!vm.count("battle") && !vm.count("nointro") && settings["video"]["showIntro"].Bool())
|
2013-06-17 18:45:55 +03:00
|
|
|
playIntro();
|
2023-05-08 12:22:01 +02:00
|
|
|
GH.screenHandler().clearScreen();
|
2013-06-17 18:45:55 +03:00
|
|
|
}
|
2018-07-25 00:36:48 +02:00
|
|
|
|
|
|
|
|
2014-07-02 22:53:23 +03:00
|
|
|
#ifndef VCMI_NO_THREADED_LOAD
|
2017-05-25 19:57:20 +02:00
|
|
|
#ifdef VCMI_ANDROID // android loads the data quite slowly so we display native progressbar to prevent having only black screen for few seconds
|
|
|
|
{
|
|
|
|
CAndroidVMHelper vmHelper;
|
|
|
|
vmHelper.callStaticVoidMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "showProgress");
|
|
|
|
#endif // ANDROID
|
|
|
|
loading.join();
|
|
|
|
#ifdef VCMI_ANDROID
|
|
|
|
vmHelper.callStaticVoidMethod(CAndroidVMHelper::NATIVE_METHODS_DEFAULT_CLASS, "hideProgress");
|
|
|
|
}
|
|
|
|
#endif // ANDROID
|
|
|
|
#endif // THREADED
|
2018-07-25 00:36:48 +02:00
|
|
|
|
|
|
|
if(!settings["session"]["headless"].Bool())
|
|
|
|
{
|
|
|
|
pomtime.getDiff();
|
2022-12-18 22:32:07 +02:00
|
|
|
graphics = new Graphics(); // should be before curh
|
2018-07-25 00:36:48 +02:00
|
|
|
|
2023-01-05 19:34:37 +02:00
|
|
|
CCS->curh = new CursorHandler();
|
2018-07-25 00:36:48 +02:00
|
|
|
logGlobal->info("Screen handler: %d ms", pomtime.getDiff());
|
|
|
|
|
|
|
|
CMessage::init();
|
|
|
|
logGlobal->info("Message handler: %d ms", pomtime.getDiff());
|
|
|
|
|
|
|
|
CCS->curh->show();
|
|
|
|
}
|
|
|
|
|
2017-08-10 20:59:55 +02:00
|
|
|
logGlobal->info("Initialization of VCMI (together): %d ms", total.getDiff());
|
2009-08-17 11:50:31 +03:00
|
|
|
|
2017-07-01 15:30:13 +02:00
|
|
|
session["autoSkip"].Bool() = vm.count("autoSkip");
|
|
|
|
session["oneGoodAI"].Bool() = vm.count("oneGoodAI");
|
|
|
|
session["aiSolo"].Bool() = false;
|
2022-12-26 00:37:35 +02:00
|
|
|
std::shared_ptr<CMainMenu> mmenu;
|
2022-11-07 11:44:58 +02:00
|
|
|
|
2022-12-26 00:37:35 +02:00
|
|
|
if(vm.count("testmap"))
|
|
|
|
{
|
|
|
|
session["testmap"].String() = vm["testmap"].as<std::string>();
|
|
|
|
session["onlyai"].Bool() = true;
|
|
|
|
boost::thread(&CServerHandler::debugStartTest, CSH, session["testmap"].String(), false);
|
|
|
|
}
|
|
|
|
else if(vm.count("testsave"))
|
|
|
|
{
|
|
|
|
session["testsave"].String() = vm["testsave"].as<std::string>();
|
|
|
|
session["onlyai"].Bool() = true;
|
|
|
|
boost::thread(&CServerHandler::debugStartTest, CSH, session["testsave"].String(), true);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mmenu = CMainMenu::create();
|
|
|
|
GH.curInt = mmenu.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<std::string> names;
|
2022-11-08 02:44:34 +02:00
|
|
|
session["lobby"].Bool() = false;
|
2022-11-07 11:44:58 +02:00
|
|
|
if(vm.count("lobby"))
|
|
|
|
{
|
|
|
|
session["lobby"].Bool() = true;
|
2022-11-08 02:44:34 +02:00
|
|
|
session["host"].Bool() = false;
|
|
|
|
session["address"].String() = vm["lobby-address"].as<std::string>();
|
2022-12-26 00:37:35 +02:00
|
|
|
if(vm.count("lobby-username"))
|
|
|
|
session["username"].String() = vm["lobby-username"].as<std::string>();
|
|
|
|
else
|
|
|
|
session["username"].String() = settings["launcher"]["lobbyUsername"].String();
|
|
|
|
if(vm.count("lobby-gamemode"))
|
|
|
|
session["gamemode"].Integer() = vm["lobby-gamemode"].as<ui16>();
|
|
|
|
else
|
|
|
|
session["gamemode"].Integer() = 0;
|
2022-11-08 02:44:34 +02:00
|
|
|
CSH->uuid = vm["uuid"].as<std::string>();
|
|
|
|
session["port"].Integer() = vm["lobby-port"].as<ui16>();
|
2022-11-11 16:00:09 +02:00
|
|
|
logGlobal->info("Remote lobby mode at %s:%d, uuid is %s", session["address"].String(), session["port"].Integer(), CSH->uuid);
|
2022-11-08 02:44:34 +02:00
|
|
|
if(vm.count("lobby-host"))
|
|
|
|
{
|
|
|
|
session["host"].Bool() = true;
|
2022-11-13 23:48:13 +02:00
|
|
|
session["hostConnections"].String() = std::to_string(vm["lobby-connections"].as<ui16>());
|
2022-11-08 02:44:34 +02:00
|
|
|
session["hostUuid"].String() = vm["lobby-uuid"].as<std::string>();
|
2022-11-11 16:00:09 +02:00
|
|
|
logGlobal->info("This client will host session, server uuid is %s", session["hostUuid"].String());
|
2022-11-08 02:44:34 +02:00
|
|
|
}
|
2022-11-21 18:23:50 +02:00
|
|
|
|
|
|
|
//we should not reconnect to previous game in online mode
|
|
|
|
Settings saveSession = settings.write["server"]["reconnect"];
|
|
|
|
saveSession->Bool() = false;
|
2022-12-26 00:37:35 +02:00
|
|
|
|
|
|
|
//start lobby immediately
|
|
|
|
names.push_back(session["username"].String());
|
|
|
|
ESelectionScreen sscreen = session["gamemode"].Integer() == 0 ? ESelectionScreen::newGame : ESelectionScreen::loadGame;
|
|
|
|
mmenu->openLobby(sscreen, session["host"].Bool(), &names, ELoadMode::MULTI);
|
2010-12-22 22:14:40 +02:00
|
|
|
}
|
2022-10-01 16:28:45 +02:00
|
|
|
|
|
|
|
// Restore remote session - start game immediately
|
|
|
|
if(settings["server"]["reconnect"].Bool())
|
|
|
|
{
|
|
|
|
CSH->restoreLastSession();
|
|
|
|
}
|
2013-06-17 18:45:55 +03:00
|
|
|
|
2017-03-12 09:54:24 +02:00
|
|
|
if(!settings["session"]["headless"].Bool())
|
2013-06-17 18:45:55 +03:00
|
|
|
{
|
2014-06-01 18:31:37 +03:00
|
|
|
mainLoop();
|
2013-06-17 18:45:55 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
while(true)
|
|
|
|
boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
|
|
|
|
}
|
2009-10-26 07:39:30 +02:00
|
|
|
|
|
|
|
return 0;
|
2007-06-07 20:45:56 +03:00
|
|
|
}
|
2008-09-17 13:18:22 +03:00
|
|
|
|
2009-06-24 09:56:36 +03:00
|
|
|
//plays intro, ends when intro is over or button has been pressed (handles events)
|
|
|
|
void playIntro()
|
|
|
|
{
|
2018-07-25 00:36:48 +02:00
|
|
|
if(CCS->videoh->openAndPlayVideo("3DOLOGO.SMK", 0, 1, true, true))
|
2009-06-24 09:56:36 +03:00
|
|
|
{
|
2023-07-13 16:11:38 +02:00
|
|
|
if (CCS->videoh->openAndPlayVideo("NWCLOGO.SMK", 0, 1, true, true))
|
|
|
|
CCS->videoh->openAndPlayVideo("H3INTRO.SMK", 0, 1, true, true);
|
2009-06-24 09:56:36 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-01 18:31:37 +03:00
|
|
|
static void mainLoop()
|
|
|
|
{
|
2014-06-01 19:50:19 +03:00
|
|
|
inGuiThread.reset(new bool(true));
|
2014-06-01 18:31:37 +03:00
|
|
|
|
|
|
|
while(1) //main SDL events loop
|
|
|
|
{
|
2023-05-18 19:32:29 +02:00
|
|
|
GH.input().fetchEvents();
|
2018-01-05 19:21:07 +02:00
|
|
|
CSH->applyPacksOnLobbyScreen();
|
2014-06-01 18:31:37 +03:00
|
|
|
GH.renderFrame();
|
2009-08-17 13:47:08 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
static void quitApplication()
|
2013-06-17 18:45:55 +03:00
|
|
|
{
|
2022-12-16 16:53:21 +02:00
|
|
|
if(!settings["session"]["headless"].Bool())
|
2013-12-07 21:26:15 +03:00
|
|
|
{
|
2022-12-16 16:53:21 +02:00
|
|
|
if(CSH->client)
|
|
|
|
CSH->endGameplay();
|
|
|
|
}
|
2018-11-07 10:11:07 +02:00
|
|
|
|
2023-05-16 15:07:03 +02:00
|
|
|
GH.windows().clear();
|
2018-11-07 10:11:07 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
CMM.reset();
|
2018-11-07 10:11:07 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
if(!settings["session"]["headless"].Bool())
|
|
|
|
{
|
|
|
|
// cleanup, mostly to remove false leaks from analyzer
|
|
|
|
if(CCS)
|
2018-11-07 10:11:07 +02:00
|
|
|
{
|
2022-12-16 16:53:21 +02:00
|
|
|
CCS->musich->release();
|
|
|
|
CCS->soundh->release();
|
2018-11-07 10:11:07 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
vstd::clear_pointer(CCS);
|
2021-05-16 14:39:38 +02:00
|
|
|
}
|
2022-12-16 16:53:21 +02:00
|
|
|
CMessage::dispose();
|
2018-11-07 10:11:07 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
vstd::clear_pointer(graphics);
|
|
|
|
}
|
2018-11-07 10:11:07 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
vstd::clear_pointer(VLC);
|
2020-03-22 15:57:13 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
vstd::clear_pointer(console);// should be removed after everything else since used by logging
|
2018-07-25 00:36:48 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
boost::this_thread::sleep(boost::posix_time::milliseconds(750));//???
|
2013-06-17 18:45:55 +03:00
|
|
|
|
2023-04-30 00:03:50 +02:00
|
|
|
if(!settings["session"]["headless"].Bool())
|
2023-05-08 12:22:01 +02:00
|
|
|
GH.screenHandler().close();
|
2018-07-25 00:36:48 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
if(logConfig != nullptr)
|
|
|
|
{
|
|
|
|
logConfig->deconfigure();
|
|
|
|
delete logConfig;
|
|
|
|
logConfig = nullptr;
|
|
|
|
}
|
2018-07-25 00:36:48 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
std::cout << "Ending...\n";
|
|
|
|
exit(0);
|
|
|
|
}
|
2018-07-25 00:36:48 +02:00
|
|
|
|
2022-12-16 16:53:21 +02:00
|
|
|
void handleQuit(bool ask)
|
|
|
|
{
|
2018-01-05 19:21:07 +02:00
|
|
|
if(CSH->client && LOCPLINT && ask)
|
2013-12-07 21:26:15 +03:00
|
|
|
{
|
2022-12-18 22:32:07 +02:00
|
|
|
CCS->curh->set(Cursor::Map::POINTER);
|
2023-05-18 22:31:05 +02:00
|
|
|
LOCPLINT->showYesNoDialog(CGI->generaltexth->allTexts[69], quitApplication, nullptr);
|
2013-12-07 21:26:15 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
quitApplication();
|
|
|
|
}
|
2013-06-17 18:45:55 +03:00
|
|
|
}
|
2023-08-06 12:31:10 +02:00
|
|
|
|
2023-08-06 17:12:36 +02:00
|
|
|
void handleFatalError(const std::string & message, bool terminate)
|
2023-08-06 12:31:10 +02:00
|
|
|
{
|
|
|
|
logGlobal->error("FATAL ERROR ENCOUTERED, VCMI WILL NOW TERMINATE");
|
|
|
|
logGlobal->error("Reason: %s", message);
|
|
|
|
|
2023-08-06 17:12:36 +02:00
|
|
|
std::string messageToShow = "Fatal error! " + message;
|
2023-08-06 12:31:10 +02:00
|
|
|
|
2023-08-06 17:12:36 +02:00
|
|
|
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Fatal error!", messageToShow.c_str(), nullptr);
|
|
|
|
|
|
|
|
if (terminate)
|
|
|
|
throw std::runtime_error(message);
|
|
|
|
else
|
|
|
|
exit(1);
|
2023-08-06 12:31:10 +02:00
|
|
|
}
|