spokendotcpp/MHache
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Deserialize of skills done.

Browse Source 
Resizing and fixed size policy added (with sub-menu).
This commit is contained in:
Thibault Heckel 2022-07-16 19:19:37 +02:00
parent f3de3648a0
commit c05edabf0b
16 changed files with 258 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/mhache_armor.h
View File

@ -7,7 +7,6 @@
#include <functional>
#include "mhache_skill.h"
#include "mhache_tomltools.h"
class MHacheSkill;
@ -34,8 +33,6 @@ private:
Piece _waist;
Piece _legs;
friend class MHacheTomlTools;
private:
MHacheArmor() = default;

28
include/mhache_color.h
View File

@ -1,6 +1,8 @@
#ifndef MHACHE_COLOR_H
#define MHACHE_COLOR_H
#include <unordered_map>
#include <string>
#include <array>
class MHacheColor {
@ -21,6 +23,8 @@ private:
return static_cast<float>(value) * conversion;
};
static std::unordered_map<std::string, MHacheColor> _colors;
public:
MHacheColor(int r, int g, int b, int a = 255);
MHacheColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255u);
@ -39,19 +43,23 @@ public:
template <typename T> std::array<T, 4> channels() const;
static MHacheColor LightBlue();
static MHacheColor Blue();
static MHacheColor DarkBlue();
static MHacheColor light_blue();
static MHacheColor blue();
static MHacheColor dark_blue();
static MHacheColor LightOrange();
static MHacheColor Orange();
static MHacheColor DarkOrange();
static MHacheColor light_orange();
static MHacheColor orange();
static MHacheColor dark_orange();
static MHacheColor Purple();
static MHacheColor Grey();
static MHacheColor White();
static MHacheColor green();
static MHacheColor pink();
static MHacheColor purple();
static MHacheColor gray();
static MHacheColor white();
static MHacheColor yellow();
// static std::unordered_map<std::string, MHacheColor> fixed_colors;
static MHacheColor* get_color(const std::string&);
static MHacheColor* save_color(const std::string&, MHacheColor&&);
};
#endif

24
include/mhache_factory.h
View File

@ -1,4 +1,28 @@
#ifndef MHACHE_FACTORY_H
#define MHACHE_FACTORY_H
#include <filesystem>
#include <set>
#include <toml++/toml.h>
#include "mhache_skill.h"
class MHacheFactory {
private:
std::set<MHacheSkill> _skills;
MHacheFactory() = default;
toml::table parse_root_table(const std::filesystem::path&);
public:
~MHacheFactory() = default;
static MHacheFactory& singleton();
bool load_skills(const std::filesystem::path&);
inline const std::set<MHacheSkill>& available_skills() const { return _skills; }
};
#endif

71
include/mhache_researcher.h
View File

@ -1,71 +0,0 @@
#ifndef MHACHE_RESEARCHER_H
#define MHACHE_RESEARCHER_H
#include <unordered_set>
#include <memory>
#include <filesystem>
#include "mhache_skill.h"
#include "mhache_armor.h"
class MHacheResearcher {
private:
template <typename T>
struct PtrEqualOperator {
bool operator() (const T* a, const T* b) const
{
return ((a && b) && (*a == *b));
}
bool operator() (const std::unique_ptr<T>& a, const std::unique_ptr<T>& b) const
{
return (a.get() == b.get());
}
};
template <typename T>
struct PtrLessOperator {
bool operator() (const T* a, const T* b) const
{
return ((a && b) && (*a < *b));
}
bool operator() (const std::unique_ptr<T>& a, const std::unique_ptr<T>& b) const
{
return (*this)(a.get(), b.get());
}
};
template <typename T>
struct PtrHashOperator {
size_t operator() (const T* a) const
{
return (a ? std::hash<T>{}(*a) : 0);
}
size_t operator() (const std::unique_ptr<T>& a) const
{
return (*this)(a.get());
}
};
std::unordered_set<std::unique_ptr<MHacheSkill>, PtrHashOperator<MHacheSkill>, PtrEqualOperator<MHacheSkill>> _skills;
std::unordered_set<std::unique_ptr<MHacheArmor>, PtrHashOperator<MHacheArmor>, PtrEqualOperator<MHacheArmor>> _armors;
private:
MHacheResearcher() = default;
MHacheResearcher(const MHacheResearcher&) = delete;
MHacheResearcher(MHacheResearcher&&) = delete;
MHacheResearcher& operator =(const MHacheResearcher&) = delete;
MHacheResearcher& operator =(MHacheResearcher&&) = delete;
public:
virtual ~MHacheResearcher() = default;
static MHacheResearcher& instance();
bool load_armors(const std::filesystem::path& armors_dot_toml);
bool load_skills(const std::filesystem::path& skills_dot_toml);
};
#endif

36
include/mhache_skill.h
View File

@ -3,19 +3,15 @@
#include <string>
#include <vector>
#include <functional>
#include "mhache_tomltools.h"
#include "mhache_color.h"
class MHacheSkill {
private:
std::string _name;
std::string _description;
MHacheColor* _color;
std::vector<std::string> _levels;
std::string _name;
std::string _description;
const MHacheColor* _color;
std::vector<std::string> _levels;
private:
MHacheSkill() = delete;
@ -25,21 +21,27 @@ private:
MHacheSkill& operator=(MHacheSkill&&) = delete;
public:
MHacheSkill(const std::string& name, const std::string& description, const std::vector<std::string>& levels);
inline
MHacheSkill(const std::string& name, const std::string& description, const MHacheColor* color, const std::vector<std::string>& levels)
: _name(name), _description(description), _color(color), _levels(levels)
{}
~MHacheSkill() = default;
inline const std::string& name() const { return _name; }
inline const std::string& description() const { return _description; }
inline const std::vector<std::string>& levels() const { return _levels; }
inline const MHacheColor* color() const { return _color; }
bool operator < (const MHacheSkill&) const;
bool operator == (const MHacheSkill&) const;
const std::string& name() const;
const std::string& description() const;
const std::vector<std::string>& levels() const;
inline bool operator < (const MHacheSkill& obj) const { return _name < obj._name; };
inline bool operator == (const MHacheSkill& obj) const { return _name == obj._name; };
};
template<>
struct std::hash<MHacheSkill>
struct std::hash<MHacheSkill>
{
std::size_t operator()(const MHacheSkill& skill) const noexcept
size_t operator() (const MHacheSkill& skill) const
{
return std::hash<std::string>{}(skill.name());
}

32
include/mhache_tomltools.h
View File

@ -1,32 +0,0 @@
#ifndef MHACHE_TOMLTOOLS_H
#define MHACHE_TOMLTOOLS_H
#include <vector>
#include <memory>
#include <filesystem>
#include <toml++/toml.h>
#include "mhache_skill.h"
#include "mhache_armor.h"
class MHacheSkill;
class MHacheArmor;
/*
* Pure static class of services.
*
*/
class MHacheTomlTools {
private:
MHacheTomlTools() = delete;
~MHacheTomlTools() = delete;
public:
static toml::table parse_root_table(const std::filesystem::path& file_dot_toml);
static std::unique_ptr<MHacheSkill> make_skill(const toml::const_table_iterator::value_type& skill);
static std::unique_ptr<MHacheArmor> make_armor(const toml::const_table_iterator::value_type& armor);
};
#endif

1
include/mhache_window.h
View File

@ -39,6 +39,7 @@ public:
MHacheWindow(int width, int height);
~MHacheWindow();
void resize(int width, int height);
bool ready();
void display();
};

2
skills.toml
View File

@ -946,7 +946,7 @@ levels = [
"Also increases the level of other skills by +1. (Stacks with previous Bonus.)",
]
[skills."Stun REsistance"]
[skills."Stun Resistance"]
color = "yellow"
description = "Reduces stun duration."
levels = [

6
src/CMakeLists.txt
View File

@ -3,11 +3,13 @@ find_package(OpenGL REQUIRED)
add_executable(
${PROJECT_NAME}
main.cpp
# mhache_object.cpp
mhache_color.cpp
mhache_skill.cpp
mhache_armor.cpp
mhache_tomltools.cpp
mhache_researcher.cpp
mhache_factory.cpp
# mhache_tomltools.cpp
# mhache_researcher.cpp
mhache_window.cpp
)

2
src/main.cpp
View File

@ -7,7 +7,7 @@
int main(int argc, char** argv)
{
auto window = std::make_unique<MHacheWindow>(620, 480);
auto window = std::make_unique<MHacheWindow>(640, 480);
window->display();
return 0;
}

53
src/mhache_color.cpp
View File

@ -1,10 +1,11 @@
#include "mhache_color.h"
#include <unordered_map>
MHacheColor::MHacheColor(int r, int g, int b, int a /* = 255 */)
: MHacheColor(
static_cast<unsigned char>(r),
static_cast<unsigned char>(g),
static_cast<unsigned char>(b),
static_cast<unsigned char>(r),
static_cast<unsigned char>(g),
static_cast<unsigned char>(b),
static_cast<unsigned char>(a))
{}
@ -36,6 +37,46 @@ template<> std::array<float, 4> MHacheColor::channels() const
return { red<float>(), green<float>(), blue<float>(), alpha<float>() };
}
MHacheColor MHacheColor::LightBlue() { return MHacheColor(164, 204, 254); }
MHacheColor MHacheColor::Blue() { return MHacheColor(96, 169, 250); }
MHacheColor MHacheColor::DarkBlue() { return MHacheColor(77, 105, 209); }
MHacheColor MHacheColor::light_blue() { return MHacheColor(164, 204, 254); }
MHacheColor MHacheColor::blue() { return MHacheColor(96, 169, 250); }
MHacheColor MHacheColor::dark_blue() { return MHacheColor(77, 105, 209); }
MHacheColor MHacheColor::light_orange() { return MHacheColor(236, 167, 82); }
MHacheColor MHacheColor::orange() { return MHacheColor(225, 99, 18); }
MHacheColor MHacheColor::dark_orange() { return MHacheColor(248, 77, 20); }
MHacheColor MHacheColor::green() { return MHacheColor(39, 222, 150); }
MHacheColor MHacheColor::pink() { return MHacheColor(227, 116, 179); }
MHacheColor MHacheColor::purple() { return MHacheColor(158, 62, 212); }
MHacheColor MHacheColor::gray() { return MHacheColor(169, 168, 168); }
MHacheColor MHacheColor::white() { return MHacheColor(252, 251, 251); }
MHacheColor MHacheColor::yellow() { return MHacheColor(249, 250, 116); }
std::unordered_map<std::string, MHacheColor> MHacheColor::_colors =
{
{ "light blue", light_blue() },
{ "blue", blue() },
{ "dark blue", dark_blue() },
{ "light orange", light_orange() },
{ "orange", orange() },
{ "dark orange", dark_orange() },
{ "green", green() },
{ "pink", pink() },
{ "purple", purple() },
{ "gray", gray() },
{ "white", white() },
{ "yellow", yellow() },
};
MHacheColor*
MHacheColor::get_color(const std::string& name)
{
const auto it = _colors.find(name);
return (_colors.end() == it) ? nullptr : &(it->second);
}
MHacheColor*
MHacheColor::save_color(const std::string& name, MHacheColor&& color)
{
return &(_colors.insert_or_assign(name, std::forward<MHacheColor>(color)).first->second);
}

76
src/mhache_factory.cpp Normal file
View File

@ -0,0 +1,76 @@
#include <iostream>
#include <string>
#include "mhache_factory.h"
#include "mhache_skill.h"
#include "mhache_color.h"
MHacheFactory&
MHacheFactory::singleton()
{
static MHacheFactory factory;
return factory;
}
toml::table
MHacheFactory::parse_root_table(const std::filesystem::path& tomlfile)
{
auto result = toml::parse_file(tomlfile.u8string());
if (!result) {
std::cerr << "Parsing of TOML file << " << tomlfile << " failed." << std::endl;
std::cerr << "-> " << result.error().description() << std::endl;
}
return result.table();
}
bool
MHacheFactory::load_skills(const std::filesystem::path& tomlfile)
{
const toml::table root = parse_root_table(tomlfile);
if (root.empty()) return false;
const toml::table* skills = root["skills"].as_table();
if (!skills) return false;
for (const auto& sentry: *skills) {
const auto stable = sentry.second.as_table();
if (!stable) continue;
const std::string name = std::string(sentry.first.str());
if (name.empty()) continue;
MHacheColor* color = nullptr;
{
const auto scolor = stable->get_as<std::string>("color");
if (scolor) color = MHacheColor::get_color(scolor->get());
if (!color) continue;
}
std::string description;
{
const auto sdescription = stable->get_as<std::string>("description");
if (!sdescription) continue;
description = sdescription->get();
}
std::vector<std::string> levels;
{
const auto slevels = stable->get_as<toml::array>("levels");
if (!slevels) continue;
levels.reserve(slevels->size());
for (const auto& slevel: *slevels) {
if (!slevel.is_string()) continue;
levels.push_back(slevel.as_string()->get());
}
if (levels.empty()) continue;
}
_skills.emplace(name, description, color, levels);
}
return !_skills.empty();
}

53
src/mhache_researcher.cpp
View File

@ -1,53 +0,0 @@
#include "mhache_researcher.h"
#include <iostream>
#include <string>
#include <filesystem>
#include <toml++/toml.h>
#include "mhache_tomltools.h"
MHacheResearcher& MHacheResearcher::instance()
{
static MHacheResearcher researcher;
return researcher;
}
bool
MHacheResearcher::load_armors(const std::filesystem::path& armors_dot_toml)
{
return false;
}
bool
MHacheResearcher::load_skills(const std::filesystem::path& skills_dot_toml)
{
const toml::table table_root = MHacheTomlTools::parse_root_table(skills_dot_toml);
if (0 == table_root.size())
return false;
const auto node_skills = table_root["skills"];
if (!(node_skills.is_homogeneous() && node_skills.is_table()))
return false;
const toml::table* table_skills = node_skills.as_table();
if (!table_skills)
return false;
for (const auto& it_skill: *table_skills) {
std::unique_ptr<MHacheSkill> mhache_skill = MHacheTomlTools::make_skill(it_skill);
if (mhache_skill)
_skills.insert(std::move(mhache_skill));
}
for (const auto& s: _skills) {
std::cerr << s->name() << ": " << s->description() << std::endl;
for (const auto& l: s->levels()) {
std::cerr << " --| " << l << std::endl;
}
}
return true;
}

36
src/mhache_skill.cpp
View File

@ -1,37 +1 @@
#include "mhache_skill.h"
MHacheSkill::MHacheSkill(const std::string& name, const std::string& description, const std::vector<std::string>& levels)
: _name(name)
, _description(description)
, _levels(levels)
{}
bool
MHacheSkill::operator < (const MHacheSkill& other) const
{
return _name < other._name;
}
bool
MHacheSkill::operator == (const MHacheSkill& other) const
{
return _name == other._name;
}
const std::string&
MHacheSkill::name() const
{
return _name;
}
const std::string&
MHacheSkill::description() const
{
return _description;
}
const std::vector<std::string>&
MHacheSkill::levels() const
{
return _levels;
}

56
src/mhache_tomltools.cpp
View File

@ -1,56 +0,0 @@
#include "mhache_tomltools.h"
#include <iostream>
#include <string>
#include <vector>
std::unique_ptr<MHacheSkill>
MHacheTomlTools::make_skill(const toml::const_table_iterator::value_type& skill)
{
const toml::node& node = skill.second;
const toml::table* members = node.as_table();
if (!members)
return nullptr;
const auto description = members->get_as<std::string>("description");
if (!description)
return nullptr;
const auto levels = members->get_as<toml::array>("levels");
if (!levels)
return nullptr;
std::vector<std::string> skill_levels;
for (const auto& level: *levels) {
const auto level_description = level.as_string();
if (level_description)
skill_levels.push_back(level_description->get());
}
if (skill_levels.empty())
return nullptr;
return std::make_unique<MHacheSkill>(std::string(skill.first.str()), description->get(), skill_levels);
}
std::unique_ptr<MHacheArmor>
MHacheTomlTools::make_armor(const toml::const_table_iterator::value_type& armor)
{
return {};
}
toml::table
MHacheTomlTools::parse_root_table(const std::filesystem::path& file_dot_toml)
{
const toml::parse_result result = toml::parse_file(file_dot_toml.u8string());
if (!result) {
std::cerr << "Parsing of TOML file << " << file_dot_toml << " failed." << std::endl;
std::cerr << "-> " << result.error().description() << std::endl;
}
return std::move(result.table());
}

71
src/mhache_window.cpp
View File

@ -1,5 +1,6 @@
#include "mhache_window.h"
#include <array>
#include <csignal>
#include <iostream>
#include <functional>
@ -10,7 +11,8 @@
#include <GLFW/glfw3.h>
#include "mhache_researcher.h"
#include "mhache_color.h"
#include "mhache_factory.h"
volatile std::sig_atomic_t MHacheWindow::_signal_status = 0;
@ -22,6 +24,7 @@ MHacheWindow::MHacheWindow(int width, int height)
if (GLFW_TRUE == glfwInit()) {
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, _opengl_major_version);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, _opengl_minor_version);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
_window = glfwCreateWindow(_width, _height, _title, nullptr, nullptr);
@ -41,9 +44,8 @@ MHacheWindow::MHacheWindow(int width, int height)
}
}
MHacheResearcher& mhr = MHacheResearcher::instance();
mhr.load_armors("../../armors.toml");
mhr.load_skills("../../skills.toml");
MHacheFactory& mhf = MHacheFactory::singleton();
mhf.load_skills("../../skills.toml");
}
MHacheWindow::~MHacheWindow()
@ -115,11 +117,44 @@ MHacheWindow::build_widgets()
if (main_viewport) {
ImGui::SetNextWindowPos(main_viewport->WorkPos);
ImGui::SetNextWindowSize(main_viewport->WorkSize);
ImGui::SetNextWindowSizeConstraints(main_viewport->WorkSize, main_viewport->WorkSize);
}
ImGui::Begin(_title, nullptr, window_flags);
//--
build_menu();
ImGuiTextFilter filter;
filter.Draw();
const auto& skills = MHacheFactory::singleton().available_skills();
for (const auto& skill: skills) {
if (filter.PassFilter(skill.name().c_str())) {
const MHacheColor* color = skill.color();
if (!color) {
std::cerr << "Missing color for " << skill.name() << std::endl;
continue;
}
const auto rgba = color->channels<float>();
ImGui::TextColored(
ImVec4(rgba[0], rgba[1], rgba[2], rgba[3]),
"%s",
skill.name().c_str()
);
if (ImGui::IsItemHovered()) {
ImGui::BeginTooltip();
ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
ImGui::TextUnformatted(skill.description().c_str());
ImGui::PopTextWrapPos();
ImGui::EndTooltip();
}
}
}
//--
ImGui::End();
}
@ -129,15 +164,43 @@ MHacheWindow::build_menu()
{
if (ImGui::BeginMenuBar()) {
if (ImGui::BeginMenu("App")) {
if (ImGui::BeginMenu("Resize")) {
if (ImGui::MenuItem("640x480")) { resize(640, 480); }
if (ImGui::MenuItem("800x600")) { resize(800, 600); }
if (ImGui::MenuItem("1024x768")) { resize(1024, 768); }
if (ImGui::MenuItem("1280x720")) { resize(1280, 720); }
ImGui::EndMenu();
}
if (ImGui::MenuItem("Quit", "Alt+F4")) {
glfwSetWindowShouldClose(_window, GLFW_TRUE);
}
ImGui::EndMenu();
}
ImGui::EndMenuBar();
}
}
void
MHacheWindow::resize(int width, int height)
{
if (!ready()) return;
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
if (!monitor) return;
const GLFWvidmode* videomode = glfwGetVideoMode(monitor);
if (!videomode) return;
_width = width;
_height = height;
glfwSetWindowPos(_window, (videomode->width - _width) * 0.5, (videomode->height - _height) * 0.5);
glfwSetWindowSize(_window, width, height);
}
bool
MHacheWindow::ready()
{