220 lines
7.5 KiB
C++
220 lines
7.5 KiB
C++
#include "menu.h"
|
|
#include "menu_commons.h"
|
|
|
|
#include "../../coders/png.h"
|
|
#include "../../content/ContentLUT.h"
|
|
#include "../../engine.h"
|
|
#include "../../files/WorldFiles.h"
|
|
#include "../../graphics/ui/gui_util.h"
|
|
#include "../../logic/LevelController.h"
|
|
#include "../../util/stringutil.h"
|
|
#include "../../world/Level.h"
|
|
#include "../../world/World.h"
|
|
#include "../locale/langs.h"
|
|
#include "../screens.h"
|
|
|
|
#include <glm/glm.hpp>
|
|
|
|
using namespace gui;
|
|
|
|
std::shared_ptr<Container> create_pack_panel(
|
|
const ContentPack& pack,
|
|
Engine* engine,
|
|
packconsumer callback,
|
|
packconsumer remover
|
|
) {
|
|
auto assets = engine->getAssets();
|
|
auto packpanel = std::dynamic_pointer_cast<Container>(guiutil::create(
|
|
"<container size='540,80' color='#0F1E2DB2'>"
|
|
"</container>"
|
|
));
|
|
if (callback) {
|
|
packpanel->listenAction([=](GUI*) {
|
|
callback(pack);
|
|
});
|
|
}
|
|
auto runtime = engine->getContent() ? engine->getContent()->getPackRuntime(pack.id) : nullptr;
|
|
auto idtext = (runtime && runtime->getStats().hasSavingContent())
|
|
? "*["+pack.id+"]"
|
|
: "["+pack.id+"]";
|
|
|
|
packpanel->add(guiutil::create(
|
|
"<label pos='215,2' color='#FFFFFF80' size='300,25' align='right'>" +
|
|
idtext +
|
|
"</label>"
|
|
));
|
|
|
|
auto titlelabel = std::make_shared<Label>(pack.title);
|
|
packpanel->add(titlelabel, glm::vec2(78, 6));
|
|
|
|
std::string icon = pack.id+".icon";
|
|
if (assets->getTexture(icon) == nullptr) {
|
|
auto iconfile = pack.folder/fs::path("icon.png");
|
|
if (fs::is_regular_file(iconfile)) {
|
|
assets->store(png::load_texture(iconfile.string()), icon);
|
|
} else {
|
|
icon = "gui/no_icon";
|
|
}
|
|
}
|
|
|
|
if (!pack.creator.empty()) {
|
|
packpanel->add(guiutil::create(
|
|
"<label color='#CCFFE5B2' size='300,20' align='right' pos='215,60'>"+
|
|
pack.creator+
|
|
"</label>"
|
|
));
|
|
}
|
|
|
|
auto descriptionlabel = std::make_shared<Label>(pack.description);
|
|
descriptionlabel->setColor(glm::vec4(1, 1, 1, 0.7f));
|
|
packpanel->add(descriptionlabel, glm::vec2(80, 28));
|
|
|
|
packpanel->add(std::make_shared<Image>(icon, glm::vec2(64)), glm::vec2(8));
|
|
|
|
if (remover && pack.id != "base") {
|
|
auto rembtn = guiutil::create(
|
|
"<button color='#00000000' hover-color='#FFFFFF2B'>"
|
|
" <image src='gui/cross' size='32,32'/>"
|
|
"</button>"
|
|
);
|
|
rembtn->listenAction([=](GUI* gui) {
|
|
remover(pack);
|
|
});
|
|
packpanel->add(rembtn, glm::vec2(470, 22));
|
|
}
|
|
return packpanel;
|
|
}
|
|
|
|
std::shared_ptr<Panel> menus::create_packs_panel(
|
|
const std::vector<ContentPack>& packs,
|
|
Engine* engine,
|
|
bool backbutton,
|
|
packconsumer callback,
|
|
packconsumer remover
|
|
){
|
|
auto panel = std::make_shared<Panel>(glm::vec2(550, 200), glm::vec4(5.0f));
|
|
panel->setColor(glm::vec4(1.0f, 1.0f, 1.0f, 0.07f));
|
|
panel->setMaxLength(400);
|
|
panel->setScrollable(true);
|
|
|
|
for (auto& pack : packs) {
|
|
panel->add(create_pack_panel(pack, engine, callback, remover));
|
|
}
|
|
if (backbutton) {
|
|
panel->add(guiutil::backButton(engine->getGUI()->getMenu()));
|
|
}
|
|
return panel;
|
|
}
|
|
|
|
static void reopen_world(Engine* engine, World* world) {
|
|
std::string wname = world->wfile->directory.stem().u8string();
|
|
engine->setScreen(nullptr);
|
|
engine->setScreen(std::make_shared<MenuScreen>(engine));
|
|
menus::open_world(wname, engine, true);
|
|
}
|
|
|
|
// FIXME
|
|
static bool try_add_dependency(Engine* engine, World* world, const ContentPack& pack, std::string& missing) {
|
|
auto paths = engine->getPaths();
|
|
for (const auto& dependency : pack.dependencies) {
|
|
fs::path folder = ContentPack::findPack(
|
|
paths,
|
|
world->wfile->directory,
|
|
dependency
|
|
);
|
|
if (!fs::is_directory(folder)) {
|
|
missing = dependency;
|
|
return true;
|
|
}
|
|
if (!world->hasPack(dependency)) {
|
|
world->wfile->addPack(world, dependency);
|
|
}
|
|
}
|
|
world->wfile->addPack(world, pack.id);
|
|
return false;
|
|
}
|
|
|
|
void create_content_panel(Engine* engine, LevelController* controller) {
|
|
auto level = controller->getLevel();
|
|
auto menu = engine->getGUI()->getMenu();
|
|
auto mainPanel = menus::create_page(engine, "content", 550, 0.0f, 5);
|
|
|
|
std::vector<ContentPack> scanned;
|
|
ContentPack::scan(engine->getPaths(), scanned);
|
|
for (const auto& pack : engine->getContentPacks()) {
|
|
for (size_t i = 0; i < scanned.size(); i++) {
|
|
if (scanned[i].id == pack.id) {
|
|
scanned.erase(scanned.begin()+i);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
auto panel = menus::create_packs_panel(
|
|
engine->getContentPacks(), engine, false, nullptr,
|
|
[=](const ContentPack& pack) {
|
|
auto world = level->getWorld();
|
|
auto runtime = engine->getContent()->getPackRuntime(pack.id);
|
|
if (runtime->getStats().hasSavingContent()) {
|
|
guiutil::confirm(engine->getGUI(), langs::get(L"remove-confirm", L"pack")+
|
|
L" ("+util::str2wstr_utf8(pack.id)+L")", [=]() {
|
|
controller->saveWorld();
|
|
world->wfile->removePack(world, pack.id);
|
|
reopen_world(engine, world);
|
|
});
|
|
} else {
|
|
controller->saveWorld();
|
|
world->wfile->removePack(world, pack.id);
|
|
reopen_world(engine, world);
|
|
}
|
|
}
|
|
);
|
|
mainPanel->add(panel);
|
|
mainPanel->add(menus::create_button(
|
|
langs::get(L"Add", L"content"), glm::vec4(10.0f), glm::vec4(1), [=](GUI* gui) {
|
|
auto panel = menus::create_packs_panel(scanned, engine, true,
|
|
[=](const ContentPack& pack) {
|
|
auto world = level->getWorld();
|
|
std::string missing;
|
|
if (try_add_dependency(engine, world, pack, missing)) {
|
|
guiutil::alert(
|
|
gui, langs::get(L"error.dependency-not-found")+
|
|
L": "+util::str2wstr_utf8(missing)
|
|
);
|
|
return;
|
|
}
|
|
world->wfile->addPack(world, pack.id);
|
|
controller->saveWorld();
|
|
reopen_world(engine, world);
|
|
}, nullptr);
|
|
menu->addPage("content-packs", panel);
|
|
menu->setPage("content-packs");
|
|
}));
|
|
mainPanel->add(guiutil::backButton(menu));
|
|
}
|
|
|
|
void menus::create_pause_panel(Engine* engine, LevelController* controller) {
|
|
auto menu = engine->getGUI()->getMenu();
|
|
auto panel = create_page(engine, "pause", 400, 0.0f, 1);
|
|
|
|
panel->add(create_button(L"Continue", glm::vec4(10.0f), glm::vec4(1), [=](GUI*){
|
|
menu->reset();
|
|
}));
|
|
panel->add(create_button(L"Content", glm::vec4(10.0f), glm::vec4(1), [=](GUI*) {
|
|
create_content_panel(engine, controller);
|
|
menu->setPage("content");
|
|
}));
|
|
panel->add(guiutil::gotoButton(L"Settings", "settings", menu));
|
|
|
|
panel->add(create_button(L"Save and Quit to Menu", glm::vec4(10.f), glm::vec4(1), [=](GUI*){
|
|
engine->postRunnable([=]() {
|
|
// save world
|
|
controller->saveWorld();
|
|
// destroy LevelScreen and run quit callbacks
|
|
engine->setScreen(nullptr);
|
|
// create and go to menu screen
|
|
engine->setScreen(std::make_shared<MenuScreen>(engine));
|
|
});
|
|
}));
|
|
}
|