~widelands-dev/widelands/trunk

/*

 * Copyright (C) 2006-2025 by the Widelands Development Team

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, see <https://www.gnu.org/licenses/>.

 *

 */

#include "wlapplication.h"

#include <cassert>

#ifndef _WIN32

#include <csignal>

#endif

#include <cstdlib>

#include <cstring>

#include <iostream>

#include <memory>

#include <regex>

#include <SDL.h>

#include <SDL_mouse.h>

#include <SDL_ttf.h>

#ifdef __APPLE__

#include <mach-o/dyld.h>

#include <unistd.h>

#endif

#include <sys/stat.h>

#include <sys/types.h>

#include "base/i18n.h"

#include "base/log.h"

#include "base/macros.h"

#include "base/multithreading.h"

#include "base/random.h"

#include "base/string.h"

#include "base/time_string.h"

#include "base/warning.h"

#include "base/wexception.h"

#include "build_info.h"

#include "config.h"

#include "editor/editorinteractive.h"

#include "editor/ui_menus/main_menu_random_map.h"

#include "graphic/default_resolution.h"

#include "graphic/font_handler.h"

#include "graphic/graphic.h"

#include "graphic/graphic_functions.h"

#include "graphic/mouse_cursor.h"

#include "graphic/style_manager.h"

#include "graphic/text/font_set.h"

#include "io/filesystem/disk_filesystem.h"

#include "io/filesystem/filesystem_exceptions.h"

#include "io/filesystem/layered_filesystem.h"

#include "logic/addons.h"

#include "logic/filesystem_constants.h"

#include "logic/game.h"

#include "logic/game_data_error.h"

#include "logic/game_settings.h"

#include "logic/map.h"

#include "logic/replay.h"

#include "logic/single_player_game_controller.h"

#include "logic/single_player_game_settings_provider.h"

#include "map_io/map_loader.h"

#include "network/gameclient.h"

#include "network/gamehost.h"

#include "network/host_game_settings_provider.h"

#include "network/internet_gaming.h"

#include "sound/sound_handler.h"

#include "ui_basic/color_chooser.h"

#include "ui_basic/messagebox.h"

#include "ui_basic/progresswindow.h"

#include "ui_fsmenu/about.h"

#include "ui_fsmenu/crash_report.h"

#include "ui_fsmenu/launch_spg.h"

#include "ui_fsmenu/loadgame.h"

#include "ui_fsmenu/main.h"

#include "ui_fsmenu/mapselect.h"

#include "ui_fsmenu/options.h"

#include "wlapplication_messages.h"

#include "wlapplication_mousewheel_options.h"

#include "wlapplication_options.h"

#include "wui/game_chat_panel.h"

#include "wui/interactive_player.h"

#include "wui/interactive_spectator.h"

#include "wui/maptable.h"

std::string get_executable_directory(const bool logdir) {

	std::string executabledir;

#ifdef __APPLE__

	uint32_t buffersize = 0;

	_NSGetExecutablePath(nullptr, &buffersize);

	std::unique_ptr<char[]> buffer(new char[buffersize]);

	int32_t check = _NSGetExecutablePath(buffer.get(), &buffersize);

	if (check != 0) {

		throw wexception("could not find the path of the main executable");

	}

	executabledir = std::string(buffer.get());

	executabledir.resize(executabledir.rfind('/') + 1);

#endif

#ifdef __linux__

	char buffer[PATH_MAX];

	size_t size = readlink("/proc/self/exe", buffer, PATH_MAX);

	if (size <= 0) {

		throw wexception("could not find the path of the main executable");

	}

	executabledir = std::string(buffer, size);

	executabledir.resize(executabledir.rfind('/') + 1);

#endif

#ifdef _WIN32

	char filename[_MAX_PATH + 1] = {0};

	GetModuleFileName(nullptr, filename, MAX_PATH);

	executabledir = filename;

	executabledir = executabledir.substr(0, executabledir.rfind('\\'));

#endif

	if (logdir) {

		log_info("Widelands executable directory: %s\n", executabledir.c_str());

	}

	return executabledir;

}

namespace {

/**

 * Shut the hardware down: stop graphics mode, stop sound handler

 */

#ifndef _WIN32

void terminate(int /*unused*/) {

	// The logger can already be shut down, so we use cout

	std::cout

	   << "Waited 5 seconds to close audio. There are some problems here, so killing Widelands."

	      " Update your sound driver and/or SDL to fix this problem\n";

	raise(SIGKILL);

}

#endif

#ifdef SIGUSR1

void toggle_verbose(int /*unused*/) {

	g_verbose = !g_verbose;

}

#endif

bool is_absolute_path(const std::string& path) {

	std::regex re("^/|\\w:");

	return std::regex_search(path.c_str(), re);

}

// Returns the absolute path of 'path' which might be relative.

std::string absolute_path_if_not_windows(const std::string& path) {

#ifndef _WIN32

	char buffer[PATH_MAX];

	// https://pubs.opengroup.org/onlinepubs/009695399/functions/realpath.html

	char* rp = realpath(path.c_str(), buffer);

	log_info("Realpath: %s\n", rp);

	if (rp == nullptr) {

		throw wexception("Unable to get absolute path for %s", path.c_str());

	}

	return std::string(rp);

#else

	return path;

#endif

}

// On Mac OS, we bundle the shared libraries that Widelands needs directly in

// the executable directory. This is so that SDL_Image and SDL_Mixer can load

// them dynamically. Unfortunately, linking them statically has led to problems

// in the past.

//

// Changing LD_LIBRARY_PATH does not work, so we resort to the hack of chdir()

// in the directory so that dlopen() finds the library.

void changedir_on_mac() {

#ifdef __APPLE__

	chdir(get_executable_directory().c_str());

#endif

}

// Extracts a long from 'text' into 'val' returning true if all of the string

// was valid. If not, the content of 'val' is undefined.

bool to_long(const std::string& text, int64_t* val) {

	const char* start = text.c_str();

	char* end;

	*val = strtol(start, &end, 10);

	return *end == '\0';

}

// Extracts the creation date from 'path' which is expected to

// match "YYYY-MM-DD*". Returns false if no date could be extracted.

bool extract_creation_day(const std::string& path, tm* tfile) {

	const std::string filename = FileSystem::fs_filename(path.c_str());

	memset(tfile, 0, sizeof(tm));

	int64_t day;

	int64_t month;

	int64_t year;

	if (!to_long(filename.substr(8, 2), &day)) {

		return false;

	}

	if (!to_long(filename.substr(5, 2), &month)) {

		return false;

	}

	if (!to_long(filename.substr(0, 4), &year)) {

		return false;

	}

	tfile->tm_mday = day;

	tfile->tm_mon = month - 1;

	tfile->tm_year = year - 1900;

	return tfile != nullptr;

}

// Returns true if 'filename' was autogenerated, i.e. if 'extract_creation_day'

// can return a date and it is old enough to be deleted.

bool is_autogenerated_and_expired(const std::string& filename, const double keep_time) {

	tm tfile;

	if (!extract_creation_day(filename, &tfile)) {

		return false;

	}

	return std::difftime(time(nullptr), mktime(&tfile)) > keep_time;

}

// A simple wrapper around the game logic thread. It ensures the thread is

// always joined when this class goes out of scope. This is important when an

// exception is thrown within the game anywhere, because without this, we will

// not join the thread and this means the exception will never be caught and

// printed, making debugging hard.

// See

// https://stackoverflow.com/questions/25397874/deleting-stdthread-pointer-raises-exception-libcabi-dylib-terminating

// TODO(klaus-halfman/Noordfrees): move this to base/multithreading.h as generic concept.

class GameLogicThread {

public:

	explicit GameLogicThread(std::atomic_bool* should_die)

	   : should_die_(should_die), thread_(&UI::Panel::logic_thread) {

	}

	DISALLOW_COPY_AND_ASSIGN(GameLogicThread);

	~GameLogicThread() {

		*should_die_ = true;

		thread_.join();

	}

private:

	std::atomic_bool* should_die_;  // signals using object that thread is dead.

	std::thread thread_;

};

}  // namespace

std::string WLApplication::segfault_backtrace_dir;

// Set up the homedir. Exit 1 if the homedir is illegal or the logger couldn't be initialized for

// Windows.

// Also sets the config directory. This defaults to $XDG_CONFIG_HOME/widelands/config on Unix.

// Defaults to homedir/config everywhere else, if homedir is set manually or if

// built without XDG-support.

void WLApplication::setup_homedir() {

	// Check if we have a command line override

	if (commandline_.count("homedir") != 0u) {

		// We don't have a destination dir for the logger yet

		std::cout << "Adding home directory: " << commandline_["homedir"].c_str() << std::endl;

		homedir_ = commandline_["homedir"];

#ifdef USE_XDG

		// This commandline option should probably also affect the

		// configuration file.

		userconfigdir_ = commandline_["homedir"];

#endif

		commandline_.erase("homedir");

	}

#ifdef REDIRECT_OUTPUT

	if (!redirect_output())

		redirect_output(homedir_);

#endif

	// If we don't have a home directory, we exit with an error

	if (homedir_.empty()) {

		std::cout << "Unable to start Widelands, because the given homedir is empty" << std::endl;

		delete g_fs;

		exit(1);

	} else {

		try {

			std::unique_ptr<FileSystem> home(new RealFSImpl(homedir_));

			home->ensure_directory_exists(".");

			g_fs->set_home_file_system(home.release());

		} catch (const std::exception& e) {

			std::cout

			   << "Unable to start Widelands, because we were unable to add the home directory: "

			   << e.what() << std::endl;

			delete g_fs;

			exit(1);

		}

#ifdef _WIN32

		// Initialize the logger for Windows. Exit on failure.

		if (!set_logging_dir(homedir_)) {

			delete g_fs;

			exit(1);

		}

#endif

		// Homedir is ready, so we can log normally from now on

		log_info("Set home directory: %s\n", homedir_.c_str());

		// Create directory structure

		g_fs->ensure_directory_exists("save");

		g_fs->ensure_directory_exists("replays");

		g_fs->ensure_directory_exists(kMyMapsDirFull);

		g_fs->ensure_directory_exists(kDownloadedMapsDirFull);

		g_fs->ensure_directory_exists(kCrashDir);

		segfault_backtrace_dir = homedir_;

		segfault_backtrace_dir += "/";

		segfault_backtrace_dir += kCrashDir;

	}

#ifdef USE_XDG

	set_config_directory(userconfigdir_);

#else

	set_config_directory(homedir_);

#endif

	i18n::set_homedir(homedir_);

}

/**

 * The main entry point for the WLApplication singleton.

 *

 * Regardless of circumstances, this will return the one and only valid

 * WLApplication object when called. If necessary, a new WLApplication instance

 * is created.

 *

 * While you \e can do the first call to this method without parameters, it does

 * not make much sense.

 *

 * \param argc The number of command line arguments

 * \param argv Array of command line arguments

 * \return A reference to the WLApplication singleton

 */

WLApplication& WLApplication::get(int const argc, char const** argv) {

	static WLApplication the_singleton{argc, argv};

	return the_singleton;

}

/**

 * Initialize an instance of WLApplication.

 *

 * Exits with code 2 if the SDL/TTF system is not available.

 *

 * This constructor is protected \e on \e purpose !

 * Use WLApplication::get() instead and look at the class description.

 *

 * For easier access, we repackage argc/argv into an STL map here.

 * If you specify the same option more than once, only the last occurrence

 * is effective.

 *

 * \param argc The number of command line arguments

 * \param argv Array of command line arguments

 */

WLApplication::WLApplication(int const argc, char const* const* const argv)

   :

#ifdef _WIN32

     homedir_(FileSystem::get_homedir() + "\\.widelands")

#elif defined USE_XDG

     // To enable backwards compatibility, the program name is passed with the

     // path.

     homedir_(FileSystem::get_userdatadir()),

     userconfigdir_(FileSystem::get_userconfigdir())

#else

     homedir_(FileSystem::get_homedir() + "/.widelands")

#endif

{

	g_fs = new LayeredFileSystem();

	parse_commandline(argc, argv);  // throws ParameterError, handled by main.cc

	setup_homedir();

	init_settings();  // Also sets up the filesystems and language support.

	set_initializer_thread();

#ifdef SIGUSR1

	signal(SIGUSR1, toggle_verbose);

#endif

	changedir_on_mac();

#ifndef SDL_BYTEORDER

	log_info("Byte order: unknown, assuming little-endian\n");

#elif SDL_BYTEORDER == SDL_LIL_ENDIAN

	log_info("Byte order: little-endian\n");

#else

	log_info("Byte order: big-endian\n");

#endif

	// Start the SDL core

	if (SDL_Init(SDL_INIT_VIDEO) == -1) {

		// We sometimes run into a missing video driver in our CI environment, so we exit 0 to prevent

		// too frequent failures

		log_err("Failed to initialize SDL, no valid video driver: %s", SDL_GetError());

		exit(2);

	}

	// Start intro music before splashscreen: it takes slightly less time,

	// and the music starts with some delay

	g_sh = new SoundHandler();

	g_sh->register_songs("music", Songset::kIntro);

	g_sh->register_songs("music", Songset::kMenu);

	g_sh->change_music(get_config_bool("play_intro_music", true) ? Songset::kIntro : Songset::kMenu);

	g_gr = new Graphic();

	g_gr->initialize(

	   get_config_bool("debug_gl_trace", false) ? Graphic::TraceGl::kYes : Graphic::TraceGl::kNo,

	   get_config_int("display", -1), get_config_int("xres", kDefaultResolutionW),

	   get_config_int("yres", kDefaultResolutionH), get_config_bool("fullscreen", false),

	   get_config_bool("maximized", false));

	{

		// The window manager may resize the window on creation, so we have to handle resize events

		// first to be able to draw the splash screen in the right size. This also creates mousemove

		// events that we may mess up when we set the cursor.

		// We throw away everything else, hopefully we don't have much yet...

		// Window event and mouse cursor handling needs g_gr.

		SDL_PumpEvents();

		// Known harmless events we'd drop anyway

		SDL_FlushEvent(SDL_AUDIODEVICEADDED);

		SDL_FlushEvent(SDL_TEXTEDITING);  // reported on windows

		// end of ignored events

		SDL_Event ev;

		int ignored = 0;

		int handled = 0;

		while (SDL_PollEvent(&ev) != 0) {

			if (ev.type == SDL_WINDOWEVENT) {

				handle_window_event(ev);

				++handled;

			} else if (ev.type == SDL_MOUSEMOTION) {

				mouse_position_ = Vector2i(ev.motion.x, ev.motion.y);

			} else {

				verb_log_dbg("Ignoring SDL event 0x%04x", ev.type);

				++ignored;

			}

		}

		if (ignored > 0) {

			log_warn("Ignored %d non-mousemove SDL events at start up", ignored);

		}

		if (handled > 0) {

			// Initial creation already creates some events

			verb_log_info("Handled %d SDL window events at start up", handled);

		}

	}

	init_mouse_cursor();

	// Prepare for drawing splash screen

	/*****

	 * These could be moved later if we decide to show some graphic (an hourglass?) instead

	 * of the text label in the initial splash screen to draw it faster.

	 */

	if (TTF_Init() == -1) {

		log_err("True Type library did not initialize: %s\n", TTF_GetError());

		exit(2);

	}

	UI::g_fh = UI::create_fonthandler(

	   g_image_cache, i18n::get_locale());  // This will create the fontset, so loading it first.

	verb_log_info("Font handler created");

	set_template_dir("");

	verb_log_info("Loaded default styles");

	/*

	 * End of text rendering dependencies

	 *****/

	// The initital splash screen is only drawn once, it doesn't get updates until the main menu

	// overrides it. Normally it shouldn't take more than a few seconds.

	RenderTarget* r = g_gr->get_render_target();

	draw_splashscreen(*r, _("Loading…"), 1.0f);

	g_gr->refresh();

	verb_log_info("Splash screen shown");

	// This was taken out of Graphic::initialize() to allow showing the splashscreen earlier.

	// This is one of the slowest parts of the start up.

	g_gr->rebuild_texture_atlas();

	// Try to detect configurations with inverted horizontal scroll

	SDL_version sdl_ver = {SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL};

	SDL_GetVersion(&sdl_ver);

	const char* sdl_video = SDL_GetCurrentVideoDriver();

	assert(sdl_video != nullptr);

	bool sdl_scroll_x_bug = false;

	// SDL version < 2.0 is not supported, >= 2.1 will have the changes

	if (sdl_ver.major == 2 && sdl_ver.minor == 0) {

		if (std::strcmp(sdl_video, "x11") == 0) {

			sdl_scroll_x_bug = sdl_ver.patch < 18;

		} else if (std::strcmp(sdl_video, "wayland") == 0) {

			sdl_scroll_x_bug = sdl_ver.patch < 20;

		}

	}

	if (sdl_scroll_x_bug) {

		log_info("Inverting horizontal mousewheel scrolling for SDL %d.%d.%d with %s\n",

		         sdl_ver.major, sdl_ver.minor, sdl_ver.patch, sdl_video);

		set_mousewheel_option_bool(MousewheelOptionID::kInvertedXDetected, true);

		update_mousewheel_settings();

	}

	// Keep cursor in window while dragging

	SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_MODE_WARP, "1");

	verb_log_info("Cleaning up temporary files");

	cleanup_replays();

	cleanup_ai_files();

	cleanup_temp_files();

	cleanup_temp_backups();

	verb_log_info("Loading songsets");

	g_sh->register_songs("music", Songset::kIngame);

	g_sh->register_songs("music", Songset::kCustom);

	UI::ColorChooser::read_favorites_settings();

	verb_log_info("Initializing Add-Ons");

	initialize_g_addons();

	verb_log_info("Done initializing Add-Ons");

	// Register the click sound for UI::Panel.

	// We do it here to ensure that the sound handler has been created first, and we only want to

	// register it once.

	UI::Panel::register_click();

	// Make sure we didn't forget to read any global option

	check_config_used();

	// Save configuration now. Otherwise, the UUID and sound options

	// are not saved, when the game crashes

	write_config();

	if (get_config_bool("save_chat_history", false)) {

		g_chat_sent_history.load(kChatSentHistoryFile);

	}

	if (g_allow_script_console) {

		log_info("Developer tools are enabled.");

		g_script_console_history.load(kScriptConsoleHistoryFile);

	}

	verb_log_info("WLApplication created");

}

/**

 * Shut down all subsystems in an orderly manner

 */

// TODO(unknown): Handle errors that happen here!

WLApplication::~WLApplication() {

	// Do use the opposite order of WLApplication::init()

	if (!g_gr->fullscreen() && !g_gr->maximized()) {

		set_config_int("xres", g_gr->get_xres());

		set_config_int("yres", g_gr->get_yres());

	}

	set_config_bool("maximized", g_gr->maximized());

	shutdown_hardware();

	shutdown_settings();

	if (get_config_bool("save_chat_history", false)) {

		g_chat_sent_history.save(kChatSentHistoryFile);

	}

	if (g_allow_script_console) {

		g_script_console_history.save(kScriptConsoleHistoryFile);

	}

	// To be proper, release our textdomain

	i18n::release_textdomain();

	assert(UI::g_fh);

	delete UI::g_fh;

	UI::g_fh = nullptr;

	TTF_Quit();  // TODO(unknown): not here

	delete g_fs;

	g_fs = nullptr;

	if (redirected_stdio_) {

		std::cout.flush();

		fclose(stdout);

		std::cerr.flush();

		fclose(stderr);

	}

	SDL_Quit();

}

void WLApplication::init_mouse_cursor() {

	// Fix mouse_position_ initialisation when we don't have mousemove events at startup.

	// This is actually only needed by soft mode, but we do it for SDL mode too to make the

	// cursor appear at the right position if the user has to use the keyboard to turn SDL

	// mode off.

	if (mouse_position_ == Vector2i::zero()) {

		// Initialize the mouse position to the current one.

		// Unfortunately we have to do it the hard way, because SDL_GetMouseState() doesn't work

		// right until we had a mousemove event.

		int mouse_global_x;

		int mouse_global_y;

		int window_x;

		int window_y;

		SDL_Window* sdl_window = g_gr->get_sdlwindow();

		SDL_GetWindowPosition(sdl_window, &window_x, &window_y);

		SDL_GetGlobalMouseState(&mouse_global_x, &mouse_global_y);

		mouse_position_.x = mouse_global_x - window_x;

		mouse_position_.y = mouse_global_y - window_y;

		// Fix SDL's internal notion of the relative cursor position too by generating some motion

		// events. Must be done before g_mouse_cursor->initialize().

		// TODO(tothxa): I don't know why, but all these steps seem to be necessary on my system to

		//               fix the case in soft mode when the mouse is first moved while it is hidden.

		//               Without these, it is resumed at the position where it was hidden.

		SDL_PumpEvents();

		SDL_WarpMouseInWindow(sdl_window, mouse_position_.x - 1, mouse_position_.y - 1);

		SDL_PumpEvents();

		SDL_Delay(2);  // 1 tick doesn't work

		SDL_WarpMouseInWindow(sdl_window, mouse_position_.x, mouse_position_.y);

		SDL_PumpEvents();

	}

	if (!get_config_bool("sdl_cursor", true)) {

		// Set system's "waiting" mouse cursor in case setting our own cursor in

		// g_mouse_cursor->initialize() fails. Maybe it works, maybe not.

		SDL_Cursor* tmp_cursor = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_WAIT);

		SDL_SetCursor(tmp_cursor);

		SDL_FreeCursor(tmp_cursor);

	}

	// The cursor initialization itself

	// We always init it in SDL mode to have a chance of a working cursor in the splash screen,

	// before we start refreshing the screen ourselves.

	// TODO(tothxa): May not work if the system doesn't support color cursors? What happens then?

	//               No cursor, default system cursor or error?

	//               Remove argument if this works out. And move initialize() into the constructor?

	g_mouse_cursor = new MouseCursor();

	g_mouse_cursor->initialize(true);

	// TODO(tothxa): Do this in g_mouse_cursor->initialize() or the constructor too?

	g_mouse_cursor->change_wait(true);

}

void WLApplication::initialize_g_addons() {

	init_plugin_shortcuts();

	AddOns::g_addons.clear();

	if (g_fs->is_directory(kAddOnDir)) {

		std::set<std::string> found;

		for (std::string desired_addons = get_config_string("addons", ""); !desired_addons.empty();) {

			const size_t commapos = desired_addons.find(',');

			const std::string substring = desired_addons.substr(0, commapos);

			const size_t colonpos = desired_addons.find(':');

			if (colonpos == std::string::npos) {

				log_warn("Ignoring malformed add-ons config substring '%s'\n", substring.c_str());

			} else {

				const std::string name = substring.substr(0, colonpos);

				if (name.find(kAddOnExtension) != name.length() - kAddOnExtension.length()) {

					log_warn("Not loading add-on '%s' (wrong file name extension)\n", name.c_str());

				} else {

					std::string path(kAddOnDir);

					path += FileSystem::file_separator();

					path += name;

					if (g_fs->file_exists(path)) {

						try {

							found.insert(name);

							AddOns::g_addons.emplace_back(

							   AddOns::preload_addon(name), substring.substr(colonpos) == ":true");

						} catch (const std::exception& e) {

							log_warn("Not loading add-on '%s' (%s)", name.c_str(), e.what());

						}

					} else {

						log_warn("Not loading add-on '%s' (not found)\n", name.c_str());

					}

				}

			}

			if (commapos == std::string::npos) {

				break;

			}

			desired_addons = desired_addons.substr(commapos + 1);