// SPDX-License-Identifier: GPL-3.0-only #include "content/package.hpp" #include "launch/game_data.hpp" #include "launch/process.hpp" #include "launch/rml_path.hpp" #include "launch/rml_video.hpp" #include "modern/ui/controls.hpp" #include "modern/ui/desktop.hpp" #include "modern/ui/gui_assets.hpp" #include "modern/ui/model.hpp" #include "modern/ui/ticket_popover.hpp" #include "modern/ui/view.hpp" #include "version.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace bmh::modern_ui { namespace { std::string esc(std::string_view value) { return editor::escaped(value); } std::string scalar(double n) { std::ostringstream s; s.imbue(std::locale::classic()); s << n; return s.str(); } std::string mixed_color(const std::string &first, const std::string &second, double amount) { std::ostringstream out; out << '#' << std::hex << std::setfill('0'); for (size_t i = 1; i < 7; i += 2) { const int a = std::stoi(first.substr(i, 2), nullptr, 16), b = std::stoi(second.substr(i, 2), nullptr, 16); out << std::setw(2) << int(std::round(a * (1 - amount) + b * amount)); } return out.str(); } std::string rect(double x, double y, double w, double h) { return "left:" + scalar(x) + "dp;top:" + scalar(y) + "dp;width:" + scalar(w) + "dp;height:" + scalar(h) + "dp;"; } std::string btn(const std::string &action, const std::string &label, const std::string &css = {}, const std::string &attrs = {}) { return button_markup(action, label, css, attrs); } const std::array routes = { "tables", "league", "strengths", "lineup", "achievements", "other", "friendlies", "postpone", "calendar", "indoor", "load", "save", "kickoff", "toto", "bank", "camp", "training", "transfer", "tactics", "settings", "scorers", "advertising", "stadium", "statistics", "environment", "fairplay", "highscore", "contracts", "balance", "newplayer", "news"}; const std::array titles = {"Tabellen", "Ligaspiele", "Stärken", "Aufstellung", "Erfolge", "Übrige Spiele", "Freundschaftsspiele", "Verlegen", "Kalender", "Hallentabellen", "Laden", "Speichern", "Anstoß", "TOTO", "Bank", "Trainingslager", "Training", "Transfermarkt", "Taktik", "Einstellungen", "Spielerstatistiken", "Werbung", "Stadion", "Statistiken", "Umfeld", "Fairplay", "Highscore", "Verträge", "Bilanz", "Neuer Spieler", "Nachrichten"}; std::string title(const std::string &route) { const auto i = std::find(routes.begin(), routes.end(), route); if (i != routes.end()) return titles[size_t(i - routes.begin())]; if (route == "widgets") return "Widget hinzufügen"; if (route == "view-save") return "Ansicht speichern"; if (route == "view-load") return "Ansicht laden"; if (route == "background") return "Hintergrundbild ändern"; if (route == "newgame") return "Neues Spiel"; if (route == "mods") return "Mod"; if (route == "opening") return "Saisonvorbereitung"; return "OpenBMH"; } struct Picture { std::string token; int width = 1, height = 1; }; class Renderer final : public rml::Renderer { GuiAssets &gui_; fs::path assets_; std::shared_ptr world_; struct Entry { std::string key; bool world; int pixels; editor::images::Raster raster; }; std::map entries_; std::map keys_; size_t serial_ = 0; public: Renderer(rml::Video &video, GuiAssets &gui, fs::path assets) : rml::Renderer(video), gui_(gui), assets_(std::move(assets)) {} Picture local_image(const fs::path &file, int pixels) { const auto identity = editor::utf8(file) + ":" + std::to_string(std::chrono::duration_cast( fs::last_write_time(file).time_since_epoch()) .count()); if (!keys_.contains(identity)) { auto raster = editor::images::decode( editor::read_file(file), editor::utf8(file.extension()), pixels); const auto token = "modern-image-" + std::to_string(serial_++) + ".png"; entries_[token] = {identity, false, pixels, std::move(raster)}; keys_[identity] = token; } const auto token = keys_.at(identity); const auto &r = entries_.at(token).raster; return {token, r.width, r.height}; } void world(std::shared_ptr value) { Rml::ReleaseTextures(this); entries_.clear(); keys_.clear(); world_ = std::move(value); } Picture image(const std::string &key, bool world = false, int pixels = 512) { const auto identity = (world ? "world:" : "gui:") + key + ":" + std::to_string(pixels); auto found = keys_.find(identity); if (found == keys_.end()) { auto token = "modern-image-" + std::to_string(serial_++) + ".png"; editor::images::Raster raster; if (world) { if (!world_) return {}; const auto bytes = world_->asset(key, pixels); if (bytes.first.empty()) return {}; raster = editor::images::decode(bytes.first, bytes.second, pixels); } else if (key.starts_with("icon.")) { auto name = key.substr(5); const bool ink = name.ends_with("-ink"); if (ink) name.resize(name.size() - 4); if (name.empty() || name.find_first_not_of("abcdefghijklmnopqrstuvwxyz-") != name.npos) return {}; auto svg = editor::read_file(assets_ / "icons" / (name + ".svg")); if (ink) { size_t at = 0; while ((at = svg.find("#dceae7", at)) != std::string::npos) { svg.replace(at, 7, "#426071"); at += 7; } } raster = editor::images::decode(svg, ".svg", pixels); } else if (gui_.contains(key)) raster = gui_.decode(key, pixels); else if (key == "background") raster = editor::images::decode( editor::read_file(assets_.parent_path() / "launcher" / "stadium.tga"), ".tga", pixels); else return {}; // Decode at source fidelity, then bound GPU storage to the requested // display detail. const auto largest = std::max(raster.width, raster.height); if (largest > pixels) { const double scale = double(pixels) / largest; editor::images::Raster thumbnail{ std::max(1, int(std::round(raster.width * scale))), std::max(1, int(std::round(raster.height * scale))), {}}; thumbnail.pixels.resize(size_t(thumbnail.width) * thumbnail.height * 4); SDL_Surface *source = SDL_CreateRGBSurfaceWithFormatFrom( raster.pixels.data(), raster.width, raster.height, 32, raster.width * 4, SDL_PIXELFORMAT_RGBA32); SDL_Surface *destination = SDL_CreateRGBSurfaceWithFormatFrom( thumbnail.pixels.data(), thumbnail.width, thumbnail.height, 32, thumbnail.width * 4, SDL_PIXELFORMAT_RGBA32); if (!source || !destination) { if (source) SDL_FreeSurface(source); if (destination) SDL_FreeSurface(destination); throw std::runtime_error(SDL_GetError()); } SDL_SetSurfaceBlendMode(source, SDL_BLENDMODE_NONE); SDL_BlitScaled(source, nullptr, destination, nullptr); SDL_FreeSurface(source); SDL_FreeSurface(destination); raster = std::move(thumbnail); } entries_[token] = {key, world, pixels, std::move(raster)}; keys_[identity] = token; found = keys_.find(identity); } const auto &r = entries_.at(found->second).raster; return {found->second, r.width, r.height}; } Rml::TextureHandle LoadTexture(Rml::Vector2i &dimensions, const Rml::String &source) override { const auto token = editor::utf8(editor::path(source).filename()); auto found = entries_.find(token); if (found == entries_.end()) return rml::Renderer::LoadTexture(dimensions, source); auto pixels = found->second.raster.pixels; for (size_t i = 0; i < pixels.size(); i += 4) for (int c = 0; c < 3; ++c) pixels[i + c] = uint8_t((unsigned(pixels[i + c]) * pixels[i + 3] + 127) / 255); dimensions = {found->second.raster.width, found->second.raster.height}; return GenerateTexture(pixels, dimensions); } }; struct Mod { std::string name, type, error; fs::path file; Json manifest; }; class App final : public Rml::EventListener { fs::path executable_, root_, assets_, gui_root_; launch::SaveMigrator migrate_; Config config_; GuiAssets gui_; rml::Video video_; rml::AssetFiles files_; SystemInterface_SDL system_; Renderer renderer_; TextInputMethodEditor_SDL ime_; Rml::Context *context_ = nullptr; Rml::ElementDocument *doc_ = nullptr; bool initialized_ = false, closed_ = false, dirty_ = true, needs_render_ = true; double scale_ = 1, canvas_left_ = 0, canvas_top_ = 0; std::string scene_ = "main", menu_, theme_ = "midnight", active_mod_, selected_mod_, notice_, country_ = "nation:de", league_, selected_club_; std::vector mods_; std::shared_ptr world_; std::unique_ptr source_; std::unique_ptr ticket_; bool focus_ticket_ = false; std::set pending_selects_; std::string focus_after_render_; float device_ratio_ = 1.f; Json desktop_ = Json::object(), saved_desktop_ = Json::object(), options_ = Json::object(); Json managers_draft_ = Json::array(), start_options_ = {{"duration", 5}, {"difficulty", 3}, {"players", 1}, {"mode", 3}, {"league", true}, {"world", true}}; int manager_index_ = 0; bool manager_picker_ = false, adding_manager_ = false; struct Drag { bool active = false, moved = false; std::string id; float x = 0, y = 0; double left = 0, top = 0; }; Drag drag_; bool suppress_click_ = false; std::vector undo_; std::function confirm_; std::string popup_, rendered_popup_; bool rendered_confirm_ = false; std::string popup_input_, popup_extra_, popup_accept_ = "Bestätigen"; bool popup_has_input_ = false, quit_after_save_ = false; std::function text_accept_; bool context_open_ = false, context_dirty_ = false; std::string context_id_; int context_x_ = 0, context_y_ = 0; int opening_page_ = 0, draw_revealed_ = 0; bool draw_playing_ = true; uint64_t draw_at_ = 0; std::string settings_category_ = "display"; Json draft_preferences_; std::map selections_; Rml::Element *element(const std::string &id) const { return doc_->GetElementById(id); } std::string field(const std::string &id) const { auto *p = dynamic_cast(element(id)); return p ? p->GetValue() : ""; } Snapshot snap() const { return source_->snapshot(); } const Json &manager(const Snapshot &s) const { return s.state.at("managers").at(0); } const Json *club(const Snapshot &s) const { return s.world->find("clubs", manager(s).value("club", "")); } std::string cash(int64_t value) const { return money(value, world_ ? world_->manifest().value("currency", Json::object()) : Json::object()); } fs::path user_dir() const { const auto id = world_ ? world_->manifest().value("id", std::string("none")) : std::string("none"); return root_ / "userdata" / "ui-demo" / content::sha256(id); } std::string img(const std::string &key, double w, double h, bool world = false, bool cover = false, int pixels = 512) { const auto p = renderer_.image(key, world, pixels); if (p.token.empty()) return "
"; double iw = w, ih = h; std::string crop; if (cover) { const auto a = double(p.width) / p.height, b = w / h; double x = 0, y = 0, sw = p.width, sh = p.height; if (a > b) { sw = sh * b; x = (p.width - sw) / 2; } else { sh = sw / b; y = (p.height - sh) / 2; } crop = " rect=\"" + scalar(x) + " " + scalar(y) + " " + scalar(sw) + " " + scalar(sh) + "\""; } else { const auto factor = std::min(w / p.width, h / p.height); iw = p.width * factor; ih = p.height * factor; } return "
"; } std::string crest(const Json *c, double size) { return c ? img(c->value("crest", ""), size, size, true) : ""; } std::string glyph(const std::string &name, double size) { return img("icon." + name + (theme_ == "silver" ? "-ink" : ""), size, size, false, false, int(size)); } std::string label(const Json *c, double size = 40) { return c ? "" + crest(c, size) + "" + esc(world_->name(*c)) + "" : ""; } std::string window(const std::string &heading, const std::string &content, bool close = true) { return "
" + (close ? btn("close", "×", "close") : "") + "

" + esc(heading) + "

" + content + "
"; } std::string select(const std::string &id, const std::vector> &rows, const std::string &value, const std::string &action = {}) { std::string out = ""; } bool apply(const std::string &kind, const Json &value) { const auto r = source_->apply({source_->snapshot().revision, kind, value}); if (!r.ok) { message("Die Eingabe konnte nicht übernommen werden: " + r.error); return false; } return true; } void reset_popup() { popup_has_input_ = false; popup_input_.clear(); popup_extra_.clear(); popup_accept_ = "Bestätigen"; text_accept_ = {}; rendered_popup_.clear(); } void message(const std::string &text) { reset_popup(); popup_ = text; confirm_ = {}; dirty_ = true; } void confirmation(const std::string &text, std::function accepted) { reset_popup(); popup_ = text; confirm_ = std::move(accepted); dirty_ = true; } void text_dialog(const std::string &text, const std::string &initial, std::function accepted) { confirmation(text, {}); popup_has_input_ = true; popup_input_ = initial; text_accept_ = std::move(accepted); dirty_ = true; } void refresh() { needs_render_ = true; dirty_ = true; } void collect_mods() { mods_.clear(); const auto folder = root_ / "mods"; if (!fs::exists(folder)) return; for (const auto &entry : fs::directory_iterator(folder)) { if (!entry.is_directory() || entry.is_symlink() || editor::utf8(entry.path().filename()).starts_with('.')) continue; Mod m{editor::utf8(entry.path().filename()), "", {}, entry.path() / "content.obw", {}}; try { auto store = editor::ArchiveStore::open(m.file); m.manifest = Json::parse(store->read("manifest.json")); m.type = Catalog::modern_manifest(m.manifest) ? "Modern" : "Classic"; } catch (const std::exception &e) { m.error = e.what(); m.type = "Unbekannt"; } mods_.push_back(std::move(m)); } std::sort(mods_.begin(), mods_.end(), [](const auto &a, const auto &b) { return a.name < b.name; }); } Mod *mod(const std::string &name) { for (auto &m : mods_) if (m.name == name) return &m; return nullptr; } void load_world(const fs::path &file) { auto next = Catalog::open(file); auto demo = std::make_unique(next); ticket_.reset(); renderer_.world(next); world_ = std::move(next); source_ = std::move(demo); desktop_ = Json::object(); ticket_ = std::make_unique(*context_, *doc_, *source_, [this] { focus_ticket_ = true; refresh(); }); league_ = world_->leagues("nation:de").empty() ? "" : world_->leagues("nation:de").front()->value("id", ""); selected_club_ = manager(snap()).value("club", ""); } std::string main_menu() { const auto *m = mod(active_mod_); std::string out = "

FUSSBALLMANAGER

OpenBMH

"; const std::array, 6> actions = { {{"new", "Neues Spiel"}, {"load", "Spiel laden"}, {"network", "Netzwerk"}, {"mods", "Mod"}, {"settings", "Einstellungen"}, {"exit", "Beenden"}}}; for (const auto &[key, name] : actions) out += btn( key, (key == "network" ? "" + esc(name) + "" : esc(name)) + (key == "network" ? "Demnächst" : ""), {}, key == "network" || (key == "new" && !m && !world_) ? "disabled" : ""); out += "
Aktive Mod

" + esc(m ? m->name : world_ ? world_->title() : "Keine Mod aktiviert") + "

v" + std::string(kOpenBmhVersion) + (m && m->type == "Classic" ? "" : " · Modern UI Demo") + "
"; return out; } std::string mods_page() { if (selected_mod_.empty() && !mods_.empty()) selected_mod_ = mods_.front().name; std::string left = "

Installierte Mods

"; for (const auto &m : mods_) left += btn( "mod-select", "" + esc(m.name) + "" + esc(m.type) + "", std::string("row choice ") + (m.name == selected_mod_ ? "selected" : ""), "data-id=\"" + esc(m.name) + "\" style=\"width:100%;margin-bottom:12dp;min-height:120dp;\""); left += "
"; std::string right; if (auto *m = mod(selected_mod_)) right = "
" + img("background", 1300, 400, false, true, 1600) + "

" + esc(m->name) + "

" + esc(m->type) + (m->type == "Modern" ? " · Oberfläche bis zum Anstoß" : "") + "

" + esc(m->error) + "

" + btn("mod-activate", m->name == active_mod_ ? "Aktiv" : "Aktivieren", "primary", m->name == active_mod_ ? "disabled" : "") + "
"; return window( "Mod", "
" + left + "
" + right + "
" + btn("import-modern", "OBW-Paket hinzufügen") + btn("import-classic", "BMH / Football Limited") + btn("mod-rename", "Umbenennen") + btn("mod-remove", "Löschen") + "
"); } std::string render_desktop(); void init_desktop(); std::string widget(const std::string &, const Json &); std::string render_table(bool strengths = false, bool indoor = false); std::string render_camp(); std::string render_settings(); std::string render_save(bool save); std::string render_desktop_tools(const std::string &); void render_context(); void context_menu(const std::string &id, int x, int y); void drag_event(Rml::Event &); std::string render_newgame(); std::string render_manager(); std::string render_opening(); std::string render_menu(const std::string &); void dispatch(const std::string &, Rml::Element *); void change(Rml::Element *); void flush_selects() { std::vector ready; for (const auto &id : pending_selects_) { auto *select = dynamic_cast(element(id)); if (!select || !select->IsSelectBoxVisible()) ready.push_back(id); } for (const auto &id : ready) { pending_selects_.erase(id); if (auto *select = element(id)) change(select); } } void input(Rml::Element *); void resize() { int w, h, pw, ph; SDL_GetWindowSize(video_.window, &w, &h); video_.drawable_size(pw, ph); if (w <= 0 || h <= 0 || pw <= 0 || ph <= 0) return; scale_ = std::min(double(pw) / 3840, double(ph) / 2160); canvas_left_ = (pw - 3840 * scale_) / 2; canvas_top_ = (ph - 2160 * scale_) / 2; device_ratio_ = float(pw) / w; renderer_.SetViewport(pw, ph); context_->SetDimensions({pw, ph}); context_->SetDensityIndependentPixelRatio(float(scale_)); element("canvas")->SetProperty("left", scalar(canvas_left_) + "px"); element("canvas")->SetProperty("top", scalar(canvas_top_) + "px"); if (ticket_) ticket_->resize(device_ratio_); dirty_ = true; } void render() { if (ticket_) ticket_->close(false); context_open_ = false; context_dirty_ = true; doc_->SetClassNames(theme_); std::string markup; if (scene_ == "main") markup = main_menu(); else if (scene_ == "mods") markup = mods_page(); else if (scene_ == "newgame") markup = render_newgame(); else if (scene_ == "manager") markup = render_manager(); else if (scene_ == "opening") markup = render_opening(); else if (source_) markup = render_desktop(); if (!menu_.empty()) markup += render_menu(menu_); element("canvas")->SetInnerRML(markup); const auto size = context_->GetDimensions(); const auto background = img("background", size.x / scale_, size.y / scale_, false, true, 2048); element("background")->SetInnerRML(background); element("background") ->SetProperty("filter", scene_ == "main" ? "none" : theme_ == "silver" ? "saturate(0.2) brightness(0.9)" : theme_ == "matchday" ? "saturate(0.13) brightness(0.56)" : "saturate(0.34) brightness(0.70)"); needs_render_ = false; dirty_ = true; if (focus_ticket_) { if (auto *n = element("desktop-ticket")) n->Focus(); focus_ticket_ = false; } if (!focus_after_render_.empty()) { if (auto *node = element(focus_after_render_)) node->Focus(true); focus_after_render_.clear(); } } void render_popup() { if (popup_.empty()) { element("popup")->SetClass("visible", false); rendered_popup_.clear(); return; } element("popup")->SetClass("visible", true); if (popup_ == rendered_popup_ && bool(confirm_) == rendered_confirm_) return; element("popup")->SetInnerRML( "

OpenBMH

" + esc(popup_) + "

" + (popup_has_input_ ? "" : "") + "
"); rendered_popup_ = popup_; rendered_confirm_ = bool(confirm_); if (auto *button = element("popup")->QuerySelector("button")) button->Focus(); } void frame() { flush_selects(); if (ticket_) ticket_->update(); if (needs_render_) render(); render_popup(); render_context(); context_->Update(); if (center_selects(*doc_)) context_->Update(); renderer_.Clear(); renderer_.BeginFrame(); context_->Render(); renderer_.EndFrame(); video_.present(); dirty_ = false; } void screenshot(const fs::path &file) { frame(); int w, h; auto bytes = video_.capture(w, h); fs::create_directories(file.parent_path()); editor::write_atomic(file, editor::images::encode_png({w, h, std::move(bytes)})); } void load_fonts() { bool regular = false, bold = false; #ifdef _WIN32 const char *base = std::getenv("WINDIR"); if (base) { const auto folder = fs::path(base) / "Fonts"; regular = Rml::LoadFontFace(rml::asset_path(folder / "segoeui.ttf"), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Normal); bold = Rml::LoadFontFace(rml::asset_path(folder / "segoeuib.ttf"), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Bold); } #elif defined(__APPLE__) const fs::path system = "/System/Library/Fonts/SFNS.ttf"; if (fs::exists(system)) { regular = Rml::LoadFontFace(rml::asset_path(system), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Normal); bold = Rml::LoadFontFace(rml::asset_path(system), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Bold); } #else const fs::path fonts = fs::exists("/usr/share/fonts/truetype/liberation2") ? "/usr/share/fonts/truetype/liberation2" : "/usr/share/fonts/truetype/liberation"; if (fs::exists(fonts)) { regular = Rml::LoadFontFace( rml::asset_path(fonts / "LiberationSans-Regular.ttf"), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Normal); bold = Rml::LoadFontFace( rml::asset_path(fonts / "LiberationSans-Bold.ttf"), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Bold); } #endif if (!regular) regular = Rml::LoadFontFace( rml::asset_path(assets_ / "LatoLatin-Regular.ttf"), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Normal); if (!bold) bold = Rml::LoadFontFace(rml::asset_path(assets_ / "LatoLatin-Bold.ttf"), "Modern", Rml::Style::FontStyle::Normal, Rml::Style::FontWeight::Bold); if (!regular || !bold) throw std::runtime_error( "GUI-Schriften fehlen. Bitte das vollständige Paket entpacken."); } void script(); public: App(fs::path executable, launch::SaveMigrator migrate, Config config) : executable_(std::move(executable)), root_(executable_.parent_path()), assets_(root_ / "assets" / "modern"), gui_root_(config.gui_assets.empty() ? assets_ / "gui" : config.gui_assets), migrate_(std::move(migrate)), config_(std::move(config)), gui_(gui_root_), video_("OpenBMH", config_.width, config_.height, 960, 540), system_(video_.window), renderer_(video_, gui_, assets_) { try { Rml::SetSystemInterface(&system_); Rml::SetFileInterface(&files_); Rml::SetRenderInterface(&renderer_); Rml::SetTextInputHandler(&ime_); initialized_ = Rml::Initialise(); if (!initialized_) throw std::runtime_error("RmlUI initialization failed"); load_fonts(); context_ = Rml::CreateContext("modern-ui", {config_.width, config_.height}); if (!context_) throw std::runtime_error("Modern UI context failed"); doc_ = context_->LoadDocument(rml::asset_path(assets_ / "modern.rml")); if (!doc_) throw std::runtime_error("Modern UI layout missing"); for (const char *event : {"click", "dblclick", "change", "input", "keydown", "mousedown", "mouseup", "mousemove", "contextmenu"}) doc_->AddEventListener(event, this); if (!config_.theme.empty()) theme_ = config_.theme; if (theme_ != "midnight" && theme_ != "silver" && theme_ != "matchday") throw editor::Error("Unbekanntes Modern-Theme."); collect_mods(); if (!mods_.empty()) active_mod_ = mods_.front().name; if (!config_.world.empty()) { active_mod_.clear(); load_world(config_.world); scene_ = config_.scene; if (scene_ != "main" && scene_ != "newgame" && scene_ != "manager" && scene_ != "opening" && scene_ != "desktop") { menu_ = scene_; scene_ = "desktop"; } } if (!config_.state.empty() && source_) { desktop_ = source_->load(config_.state); saved_desktop_ = desktop_; if (config_.theme.empty()) theme_ = snap().state.at("preferences").value("theme", theme_); } if (source_ && !config_.theme.empty()) { auto preferences = snap().state.at("preferences"); preferences["theme"] = theme_; apply("preferences", preferences); } if (scene_ == "manager" && selections_["manager-name"].empty()) selections_["manager-name"] = "Alex Berger"; doc_->Show(); resize(); render(); SDL_ShowWindow(video_.window); frame(); } catch (...) { shutdown(); throw; } } void shutdown() { ticket_.reset(); if (doc_) { doc_->Close(); doc_ = nullptr; } if (context_) { const auto name = context_->GetName(); context_ = nullptr; Rml::RemoveContext(name); } if (initialized_) { Rml::Shutdown(); initialized_ = false; } } ~App() { shutdown(); } void ProcessEvent(Rml::Event &event) override; int run() { if (!config_.commands.empty()) script(); if (!config_.screenshot.empty()) { screenshot(config_.screenshot); return 0; } while (!closed_) { if (scene_ == "opening" && opening_page_ == 3 && draw_revealed_ < 64 && draw_playing_ && SDL_GetTicks64() >= draw_at_ && (SDL_GetWindowFlags(video_.window) & SDL_WINDOW_INPUT_FOCUS)) { ++draw_revealed_; draw_at_ = SDL_GetTicks64() + 900; if (draw_revealed_ == 64) opening_page_ = 4; refresh(); } if (needs_render_ || dirty_) frame(); SDL_Event event; const auto timeout = int(std::clamp(context_->GetNextUpdateDelay(), 0.0, .2) * 1000); bool got = SDL_WaitEventTimeout(&event, timeout) != 0; while (got) { if (event.type == SDL_QUIT) { if (source_ && scene_ != "main") { dispatch("context-quit", nullptr); } else closed_ = true; } else { if (event.type == SDL_WINDOWEVENT) resize(); int w, h, pw, ph; SDL_GetWindowSize(video_.window, &w, &h); video_.drawable_size(pw, ph); if (w > 0 && h > 0) { if (event.type == SDL_MOUSEMOTION) { event.motion.x = int(double(event.motion.x) * pw / w); event.motion.y = int(double(event.motion.y) * ph / h); } if (event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) { event.button.x = int(double(event.button.x) * pw / w); event.button.y = int(double(event.button.y) * ph / h); context_->ProcessMouseMove(event.button.x, event.button.y, RmlSDL::GetKeyModifierState()); } } RmlSDL::InputEventHandler(context_, video_.window, event); dirty_ = true; } got = SDL_PollEvent(&event) != 0; } if (context_->GetNextUpdateDelay() <= 0) dirty_ = true; } return 0; } }; #include "modern/ui/controls.inc" #include "modern/ui/desktop_screens.inc" #include "modern/ui/screens.inc" } // namespace bool is_modern_world(const fs::path &file) { try { auto store = editor::ArchiveStore::open(file); return Catalog::modern_manifest(Json::parse(store->read("manifest.json"))); } catch (const std::exception &) { return false; } } int run(const fs::path &executable, const launch::SaveMigrator &migrate, const Config &config) { App app(executable, migrate, config); return app.run(); } } // namespace bmh::modern_ui