diff --git a/.gitmodules b/.gitmodules index e540fcd..10ec53e 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,12 @@ +[submodule "external/spdlog"] + path = external/spdlog + url = https://github.com/gabime/spdlog.git +[submodule "external/json"] + path = external/json + url = https://github.com/nlohmann/json.git [submodule "external/catch2"] path = external/catch2 url = https://github.com/catchorg/Catch2.git +[submodule "external/svector"] + path = external/svector + url = https://github.com/martinus/svector.git diff --git a/.idea/cmake.xml b/.idea/cmake.xml index 221a8cc..4f2501f 100644 --- a/.idea/cmake.xml +++ b/.idea/cmake.xml @@ -2,9 +2,9 @@ - - - + + + \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 1258457..eca249a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,10 +1,6 @@ cmake_minimum_required(VERSION 3.19 FATAL_ERROR) project(BillySheet LANGUAGES CXX) -include(GNUInstallDirs) -include(CMakePackageConfigHelpers) -include(FetchContent) - file(GLOB_RECURSE SOURCE_HEADERS include/*.h include/*.hpp) file(GLOB_RECURSE SOURCE_FILES src/*.cpp) @@ -14,9 +10,6 @@ set(SOURCES ${SOURCE_FILES} ) -find_package(PkgConfig REQUIRED) -pkg_check_modules(Jemalloc REQUIRED IMPORTED_TARGET jemalloc) - find_program(CCACHE_FOUND ccache) if (CCACHE_FOUND) message(STATUS "ccache found !") @@ -28,11 +21,20 @@ else () message(STATUS "ccache not found") endif () -fetchcontent_declare(json URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz) +add_subdirectory(external/svector) + +option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled header to speed up compilation time" ON) +option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" ON) +option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" ON) +option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" ON) +option(SPDLOG_NO_TLS "prevent spdlog from using thread local storage" ON) +option(SPDLOG_NO_ATOMIC_LEVELS "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently" ON) +add_subdirectory(external/spdlog) + set(JSON_BuildTests OFF CACHE INTERNAL "") option(JSON_ImplicitConversions "Enable implicit conversions." OFF) option(JSON_SystemInclude "Include as system headers (skip for clang-tidy)." ON) -fetchcontent_makeavailable(json) +add_subdirectory(external/json) option(CATCH_INSTALL_DOCS "Install documentation alongside library" OFF) option(CATCH_INSTALL_EXTRAS "Install extras alongside library" OFF) @@ -62,6 +64,10 @@ set(LINKER_OPTIONS -fdevirtualize-at-ltrans ) +set(LINKER_FLAGS + jemalloc +) + option(ENABLE_COVERAGE "Enabling coverage" OFF) if (${ENABLE_COVERAGE}) @@ -71,58 +77,43 @@ if (${ENABLE_COVERAGE}) list(APPEND LINKER_FLAGS gcov) endif () +add_subdirectory("Unit testing") + add_library(BillySheet SHARED ${SOURCES}) -target_include_directories(BillySheet - PUBLIC - $ - $ -) +target_include_directories(BillySheet PRIVATE include include/imgui external/ImFileDialog) -set_target_properties(BillySheet PROPERTIES +set_target_properties(BillySheet spdlog svector PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF INTERPROCEDURAL_OPTIMIZATION ON - UNITY_BUILD ON - PUBLIC_HEADER "include/billy_objects.hpp;include/character_sheet.hpp;include/generic_object.hpp;include/characteristic.hpp" + # UNITY_BUILD ON ) +set_target_properties(spdlog svector PROPERTIES UNITY_BUILD ON) + target_compile_definitions(BillySheet PRIVATE $<$:_GLIBCXX_DEBUG> -) + $<$:SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_DEBUG> + $<$:SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_ERROR>) +target_compile_definitions(spdlog PRIVATE $<$:_GLIBCXX_DEBUG>) +target_compile_definitions(svector INTERFACE $<$:_GLIBCXX_DEBUG>) + +target_compile_options(spdlog PRIVATE ${COMPILE_FLAGS}) +target_compile_options(svector INTERFACE ${COMPILE_FLAGS}) target_compile_options(BillySheet PRIVATE ${COMPILE_FLAGS}) +target_link_options(spdlog PRIVATE ${LINKER_OPTIONS}) +target_link_options(svector INTERFACE ${LINKER_OPTIONS}) target_link_options(BillySheet PRIVATE ${LINKER_OPTIONS}) -target_link_libraries(BillySheet PUBLIC +target_link_libraries(spdlog PRIVATE ${LINKER_FLAGS}) +target_link_libraries(svector INTERFACE ${LINKER_FLAGS}) +target_link_libraries(BillySheet glfw + spdlog::spdlog_header_only + svector::svector nlohmann_json::nlohmann_json - PkgConfig::Jemalloc + ${LINKER_FLAGS} ) - -install(TARGETS BillySheet nlohmann_json - EXPORT billySheetTargets - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/billySheet" -) - -install(EXPORT billySheetTargets - FILE billySheetTargets.cmake - NAMESPACE billySheet:: - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/billySheet -) - -configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/Config.cmake.in - "${CMAKE_CURRENT_BINARY_DIR}/billySheetConfig.cmake" - INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/billySheet -) - -install(FILES - "${CMAKE_CURRENT_BINARY_DIR}/billySheetConfig.cmake" - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/billySheet -) - -add_subdirectory("Unit testing") diff --git a/Config.cmake.in b/Config.cmake.in deleted file mode 100644 index 849e51d..0000000 --- a/Config.cmake.in +++ /dev/null @@ -1,7 +0,0 @@ -@PACKAGE_INIT@ - -include("${CMAKE_CURRENT_LIST_DIR}/billySheetTargets.cmake") -include(CMakeFindDependencyMacro) -find_dependency(PkgConfig REQUIRED) - -check_required_components(billySheet) \ No newline at end of file diff --git a/Unit testing/CMakeLists.txt b/Unit testing/CMakeLists.txt index 554d3fd..d8086de 100644 --- a/Unit testing/CMakeLists.txt +++ b/Unit testing/CMakeLists.txt @@ -6,6 +6,7 @@ include(../external/catch2/extras/Catch.cmake) add_executable(UnitTest adummy.cpp characteristics_tests.cpp + ../src/billy_objects.cpp billy_objects_tests.cpp ) @@ -18,9 +19,9 @@ set_target_properties(Catch2 UnitTest svector PROPERTIES ) target_include_directories(UnitTest PRIVATE ${CMAKE_SOURCE_DIR}/include) target_compile_definitions(UnitTest PRIVATE ${DEF_COMP}) -target_compile_options(UnitTest PRIVATE ${COMPILE_FLAGS} -fdiagnostics-all-candidates) +target_compile_options(UnitTest PRIVATE ${COMPILE_FLAGS}) target_link_options(UnitTest PRIVATE ${LINKER_OPTIONS}) -target_link_libraries(UnitTest ${LINKER_FLAGS} spdlog::spdlog_header_only Catch2::Catch2WithMain nlohmann_json::nlohmann_json svector::svector BillySheet) +target_link_libraries(UnitTest ${LINKER_FLAGS} spdlog::spdlog_header_only Catch2::Catch2WithMain nlohmann_json::nlohmann_json svector::svector) enable_testing() catch_discover_tests(UnitTest WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} REPORTER junit OUTPUT_DIR ${CMAKE_SOURCE_DIR} OUTPUT_PREFIX cppspec- OUTPUT_SUFFIX .xml) diff --git a/external/json b/external/json new file mode 160000 index 0000000..9cca280 --- /dev/null +++ b/external/json @@ -0,0 +1 @@ +Subproject commit 9cca280a4d0ccf0c08f47a99aa71d1b0e52f8d03 diff --git a/external/spdlog b/external/spdlog new file mode 160000 index 0000000..27cb4c7 --- /dev/null +++ b/external/spdlog @@ -0,0 +1 @@ +Subproject commit 27cb4c76708608465c413f6d0e6b8d99a4d84302 diff --git a/external/svector b/external/svector new file mode 160000 index 0000000..cbeced4 --- /dev/null +++ b/external/svector @@ -0,0 +1 @@ +Subproject commit cbeced42e061da03b881ba1d09621d4604de030a diff --git a/include/billy_objects.hpp b/include/billy_objects.hpp index 7a9e765..8e3125d 100644 --- a/include/billy_objects.hpp +++ b/include/billy_objects.hpp @@ -10,23 +10,46 @@ #include #include #include -#include -#include -#include "generic_object.hpp" +#include +#include "characteristic/characteristic.hpp" +// helper type for the visitor +template +struct overloaded : Ts ... { using Ts::operator()...; }; +template +overloaded(Ts...) -> overloaded; namespace character { class CharacterSheet; - namespace characteristic{ - class Characteristic; - } + + enum class weapons : std::uint8_t { + Sword = 0, + Lance = 1, + Morgenstern = 2, + Bow = 3 + }; + + enum class equipments : std::uint8_t { + Chainmail = 4, + CookingPot = 5, + PamphletTourist = 6, + MedicKit = 7 + }; + + enum class tools : std::uint8_t { + Fourche = 8, + Dagger = 9, + RockClimbingKit = 10, + SackOfGrain = 11 + }; class BillyObjects final { public: - using json = nlohmann::json; - using container = std::unordered_map; + static constexpr std::size_t max_num_obj{ 3 }; + using billyObject = std::variant; + using container = ankerl::svector; - static constexpr std::array all_objects{ + static constexpr std::array all_objects{ weapons::Sword, weapons::Lance, weapons::Morgenstern, @@ -43,7 +66,22 @@ namespace character { static constexpr std::string_view json_key{ "billy_objects" }; - static std::string_view billy_object_to_string(const billyObjects &object) noexcept; + static constexpr std::string_view sword{ "Sword" }; + static constexpr std::string_view lance{ "Lance" }; + static constexpr std::string_view morgenstern{ "Morgenstern" }; + static constexpr std::string_view bow{ "Bow" }; + + static constexpr std::string_view chainmail{ "Chainmail" }; + static constexpr std::string_view cooking_pot{ "Cooking pot" }; + static constexpr std::string_view pamphlet_tourist{ "Touristic pamphlet" }; + static constexpr std::string_view medic_kit{ "Medic kit" }; + + static constexpr std::string_view fourche{ "Fourche" }; + static constexpr std::string_view dagger{ "Dagger" }; + static constexpr std::string_view rock_climbing_kit{ "Rock climbing kit" }; + static constexpr std::string_view sack_of_grain{ "Sack of grain" }; + + static std::string_view billy_object_to_string(const billyObject &object) noexcept; static void to_json(json &j, const BillyObjects::container &billy); @@ -53,30 +91,47 @@ namespace character { ~BillyObjects() noexcept = default; - [[nodiscard]] bool insert_object(CharacterSheet &sheet, const billyEnums objType) noexcept; + [[nodiscard]] bool push_object(const billyObject &object, CharacterSheet &sheet) noexcept; - void erase_object(CharacterSheet &sheet, const billyEnums objToErase) noexcept; + void pop_object(CharacterSheet &sheet) noexcept; + + [[nodiscard]] static ankerl::svector check_conformity(const CharacterSheet &sheet) noexcept; [[nodiscard]] const std::plus &get_plus_operation() const { return plus; } [[nodiscard]] const std::minus &get_minus_operation() const { return minus; } - static void check_dagger_conditions(const CharacterSheet &sheet, - characteristic::Characteristic &localHabilete, - const std::function &operation); - private: std::plus plus; - std::minus minus; - static void change_carac(const billyObjects &arg, + static void change_carac_weapon(const weapons &arg, + CharacterSheet &sheet, + characteristic::Characteristic &localHabilete, + characteristic::Characteristic &localAdresse, + characteristic::Characteristic &localEndurance, + const std::function &operation) noexcept; + + static void change_carac_equipment(const equipments &arg, + CharacterSheet &sheet, + characteristic::Characteristic &localHabilete, + characteristic::Characteristic &localAdresse, + characteristic::Characteristic &localEndurance, + characteristic::Characteristic &localChance, + const std::function &primary, + const std::function &complement) noexcept; + + static void change_carac_tools(const tools &arg, CharacterSheet &sheet, characteristic::Characteristic &localHabilete, characteristic::Characteristic &localAdresse, characteristic::Characteristic &localEndurance, characteristic::Characteristic &localChance, const std::function &operation) noexcept; + + static void check_dagger_conditions(const CharacterSheet &sheet, + characteristic::Characteristic &localHabilete, + const std::function &operation); }; } diff --git a/include/character_sheet.hpp b/include/character_sheet.hpp index c9ec58a..339a97c 100644 --- a/include/character_sheet.hpp +++ b/include/character_sheet.hpp @@ -1,7 +1,7 @@ #ifndef BILLYSHEET_CHARACTER_SHEET_HPP #define BILLYSHEET_CHARACTER_SHEET_HPP -#include "characteristic.hpp" +#include "characteristic/characteristic.hpp" #include "billy_objects.hpp" #include @@ -32,7 +32,7 @@ namespace character { BillyObjects::container objects; - std::unordered_set available_objects{ + std::unordered_set available_objects{ BillyObjects::all_objects.cbegin(), BillyObjects::all_objects.cend() }; diff --git a/include/characteristic.hpp b/include/characteristic/characteristic.hpp similarity index 100% rename from include/characteristic.hpp rename to include/characteristic/characteristic.hpp diff --git a/include/generic_object.hpp b/include/generic_object.hpp index 56d5fb0..0d2e45d 100644 --- a/include/generic_object.hpp +++ b/include/generic_object.hpp @@ -9,6 +9,7 @@ #include #include #include +#include "characteristic/characteristic.hpp" // helper type for the visitor template @@ -17,10 +18,6 @@ template overloaded(Ts...) -> overloaded; namespace character { - namespace characteristic { - enum class characType : std::uint8_t; - } - using namespace std::string_literals; enum class weapons : std::uint8_t { @@ -62,7 +59,7 @@ namespace character { [[nodiscard]] virtual std::uint32_t add_damage() const noexcept = 0; - [[nodiscard]] virtual std::int32_t add_materiel(const characteristic::characType &inType) const noexcept = 0; + [[nodiscard]] virtual std::int32_t add_materiel(const characteristic::characType inType) const noexcept = 0; [[nodiscard]] virtual std::string_view to_string() const noexcept = 0; @@ -71,11 +68,13 @@ namespace character { using billyObjects = std::unique_ptr; + static billyObjects new_object(const billyEnums &inputObject) noexcept; + class Weapons final : virtual public GenericObject { public: const weapons type{ weapons::Sword }; - explicit Weapons(const weapons type) : type(type) {} + friend billyObjects new_object(const billyEnums &inputObject) noexcept; Weapons() = delete; @@ -87,18 +86,21 @@ namespace character { [[nodiscard]] std::uint32_t add_damage() const noexcept final; - [[nodiscard]] std::int32_t add_materiel(const characteristic::characType &inType) const noexcept final; + [[nodiscard]] std::int32_t add_materiel(const characteristic::characType inType) const noexcept final; [[nodiscard]] std::string_view to_string() const noexcept final; [[nodiscard]] billyEnums get_type() const noexcept final { return type; } + + private: + explicit Weapons(const weapons type) : type(type) {} }; class Equipments final : virtual public GenericObject { public: const equipments type{ equipments::Chainmail }; - explicit Equipments(const equipments type) : type(type) {} + friend billyObjects new_object(const billyEnums &inputObject) noexcept; Equipments() = delete; @@ -110,18 +112,21 @@ namespace character { [[nodiscard]] std::uint32_t add_damage() const noexcept final; - [[nodiscard]] std::int32_t add_materiel(const characteristic::characType &inType) const noexcept final; + [[nodiscard]] std::int32_t add_materiel(const characteristic::characType inType) const noexcept final; [[nodiscard]] std::string_view to_string() const noexcept final; [[nodiscard]] billyEnums get_type() const noexcept final { return type; } + + private: + explicit Equipments(const equipments type) : type(type) {} }; class Tools final : virtual public GenericObject { public: const tools type{ tools::Fourche }; - explicit Tools(const tools type) : type(type) {} + friend billyObjects new_object(const billyEnums &inputObject) noexcept; Tools() = delete; @@ -133,11 +138,14 @@ namespace character { [[nodiscard]] std::uint32_t add_damage() const noexcept final; - [[nodiscard]] std::int32_t add_materiel(const characteristic::characType &inType) const noexcept final; + [[nodiscard]] std::int32_t add_materiel(const characteristic::characType inType) const noexcept final; [[nodiscard]] std::string_view to_string() const noexcept final; [[nodiscard]] billyEnums get_type() const noexcept final { return type; } + + private: + explicit Tools(const tools type) : type(type) {} }; } // character diff --git a/src/billy_objects.cpp b/src/billy_objects.cpp index 6b7ce6e..b4488e8 100644 --- a/src/billy_objects.cpp +++ b/src/billy_objects.cpp @@ -1,7 +1,10 @@ +// +// Created by postaron on 23/02/24. +// #include "billy_objects.hpp" -#include "characteristic.hpp" +#include +#include "characteristic/characteristic.hpp" #include "character_sheet.hpp" -#include std::uint32_t constexpr const_hash(const char *input) { return *input ? static_cast(*input) + 33 * const_hash(input + 1) : 5381; @@ -14,16 +17,10 @@ constexpr std::uint32_t toolsHash = const_hash("tools"); namespace character { using characteristic::Characteristic; - - bool BillyObjects::insert_object(CharacterSheet &sheet, const billyEnums objType) noexcept { + bool BillyObjects::push_object(const billyObject &object, CharacterSheet &sheet) noexcept { if (sheet.objects.size() < 3) { - sheet.objects.emplace(objType, std::visit(overloaded{ - [](const weapons &arg) { return std::unique_ptr(std::make_unique(arg)); }, - [](const equipments &arg) { return std::unique_ptr(std::make_unique(arg)); }, - [](const tools &arg) { return std::unique_ptr(std::make_unique(arg)); }, - }, objType)); - const auto &object = sheet.objects[objType]; - sheet.available_objects.erase(objType); + sheet.objects.emplace_back(object); + sheet.available_objects.erase(object); auto &local_habilete = static_cast(sheet.habilete); auto &local_adresse = static_cast(sheet.adresse); @@ -31,21 +28,42 @@ namespace character { auto &local_chance = static_cast(sheet.chance); std::visit(overloaded{ - [&](const weapons &arg) { ++sheet.nb_weapons; }, - [&](const equipments &arg) { ++sheet.nb_equipments; }, - [&](const tools &arg) { ++sheet.nb_tools; }, - }, objType); - change_carac(object, sheet, local_habilete, local_adresse, local_endurance, local_chance, plus); + [&](const weapons &arg) { + ++sheet.nb_weapons; + change_carac_weapon(arg, sheet, local_habilete, local_adresse, local_endurance, plus); + }, + [&](const equipments &arg) { + ++sheet.nb_equipments; + change_carac_equipment(arg, + sheet, + local_habilete, + local_adresse, + local_endurance, + local_chance, + plus, + minus); + }, + [&](const tools &arg) { + ++sheet.nb_tools; + change_carac_tools(arg, + sheet, + local_habilete, + local_adresse, + local_endurance, + local_chance, + plus); + }, + }, object); return true; } return false; } - void BillyObjects::erase_object(CharacterSheet &sheet, const billyEnums objToErase) noexcept { + void BillyObjects::pop_object(CharacterSheet &sheet) noexcept { if (!sheet.objects.empty()) { - const billyObjects obj{ sheet.objects[objToErase].release() }; - sheet.objects.erase(objToErase); - sheet.available_objects.insert(objToErase); + const billyObject obj = sheet.objects.back(); + sheet.objects.pop_back(); + sheet.available_objects.insert(obj); auto &local_habilete = static_cast(sheet.habilete); auto &local_adresse = static_cast(sheet.adresse); @@ -53,49 +71,171 @@ namespace character { auto &local_chance = static_cast(sheet.chance); std::visit(overloaded{ - [&](const weapons &arg) { --sheet.nb_weapons; }, - [&](const equipments &arg) { --sheet.nb_equipments; }, - [&](const tools &arg) { --sheet.nb_tools; } - }, objToErase); - change_carac(obj, sheet, local_habilete, local_adresse, local_endurance, local_chance, minus); + [&](const weapons &arg) { + --sheet.nb_weapons; + change_carac_weapon(arg, sheet, local_habilete, local_adresse, local_endurance, minus); + }, + [&](const equipments &arg) { + --sheet.nb_equipments; + change_carac_equipment(arg, + sheet, + local_habilete, + local_adresse, + local_endurance, + local_chance, + minus, + plus); + }, + [&](const tools &arg) { + --sheet.nb_tools; + change_carac_tools(arg, + sheet, + local_habilete, + local_adresse, + local_endurance, + local_chance, + minus); + } + }, obj); } } - void BillyObjects::change_carac(const billyObjects &arg, + void BillyObjects::change_carac_tools(const tools &arg, CharacterSheet &sheet, Characteristic &localHabilete, Characteristic &localAdresse, Characteristic &localEndurance, Characteristic &localChance, const std::function &operation) noexcept { - localHabilete.materiel = operation(localHabilete.materiel, arg->add_materiel(localHabilete.type)); - localAdresse.materiel = operation(localAdresse.materiel, arg->add_materiel(localAdresse.type)); - localEndurance.materiel = operation(localEndurance.materiel, arg->add_materiel(localEndurance.type)); - localChance.materiel = operation(localChance.materiel, arg->add_materiel(localChance.type)); - sheet.armor = operation(sheet.armor, arg->add_armor()); - sheet.damage = operation(sheet.armor, arg->add_damage()); - sheet.critique = operation(sheet.critique, arg->add_critique()); + switch (arg) { + case tools::Fourche: + localHabilete.materiel = operation(localHabilete.materiel, 1); + localEndurance.materiel = operation(localEndurance.materiel, 3); + break; + case tools::Dagger: + sheet.critique = operation(sheet.critique, 6); + break; + case tools::RockClimbingKit: + localAdresse.materiel = operation(localAdresse.materiel, 1); + break; + case tools::SackOfGrain: + localEndurance.materiel = operation(localEndurance.materiel, 2); + localChance.materiel = operation(localChance.materiel, 2); + break; + } + } + + void BillyObjects::change_carac_equipment(const equipments &arg, + CharacterSheet &sheet, + Characteristic &localHabilete, + Characteristic &localAdresse, + Characteristic &localEndurance, + Characteristic &localChance, + const std::function &primary, + const std::function &complement) noexcept { + switch (arg) { + case equipments::Chainmail: + localHabilete.materiel = complement(localHabilete.materiel, 1); + localAdresse.materiel = complement(localAdresse.materiel, 1); + localEndurance.materiel = primary(localEndurance.materiel, 1); + sheet.armor = primary(sheet.armor, 2); + break; + case equipments::CookingPot: + localEndurance.materiel = primary(localEndurance.materiel, 2); + sheet.armor = primary(sheet.armor, 1); + break; + case equipments::PamphletTourist: + localChance.materiel = primary(localChance.materiel, 4); + break; + case equipments::MedicKit: + localChance.materiel = primary(localChance.materiel, 1); + break; + } + } + + void BillyObjects::change_carac_weapon(const weapons &arg, + CharacterSheet &sheet, + Characteristic &localHabilete, + Characteristic &localAdresse, + Characteristic &localEndurance, + const std::function &operation) noexcept { + switch (arg) { + case weapons::Sword: + localHabilete.materiel = operation(localHabilete.materiel, 4); + break; + case weapons::Lance: + localHabilete.materiel = operation(localHabilete.materiel, 3); + localAdresse.materiel = operation(localAdresse.materiel, 1); + break; + case weapons::Morgenstern: + localHabilete.materiel = operation(localHabilete.materiel, 1); + localEndurance.materiel = operation(localEndurance.materiel, 1); + sheet.damage = operation(sheet.damage, 1); + break; + case weapons::Bow: + localHabilete.materiel = operation(localHabilete.materiel, 3); + localAdresse.materiel = operation(localAdresse.materiel, 1); + break; + } } void BillyObjects::check_dagger_conditions(const CharacterSheet &sheet, Characteristic &localHabilete, const std::function &operation) { - if (const auto it_dagger = sheet.objects.find(tools::Dagger); it_dagger != sheet.objects.cend()) { - const std::size_t count_weapons = std::count_if(sheet.objects.cbegin(), - sheet.objects.cend(), - [](container::const_reference node) { - return std::get_if(&node.first) != nullptr; - }); - const bool is_there_bow = sheet.objects.find(weapons::Bow) != sheet.objects.cend(); - if (count_weapons > 1 || is_there_bow) { - localHabilete.materiel = operation(localHabilete.materiel, - -it_dagger->second->add_materiel(localHabilete.type)); + int count_weapons = 0; + bool is_there_bow = false; + std::for_each(sheet.objects.cbegin(), sheet.objects.cend(), [&](const billyObject &object) -> void { + if (const weapons *p = std::get_if(std::addressof(object)); p != nullptr) { + ++count_weapons; + if (*p == weapons::Bow) { + is_there_bow = true; + } } + }); + if (count_weapons < 2 && !is_there_bow) { + localHabilete.materiel = operation(localHabilete.materiel, 1); } } - std::string_view BillyObjects::billy_object_to_string(const billyObjects &object) noexcept { - return object->to_string(); + std::string_view BillyObjects::billy_object_to_string(const billyObject &object) noexcept { + return std::visit(overloaded{ + [](const weapons &arg) { + switch (arg) { + case weapons::Sword: + return sword; + case weapons::Lance: + return lance; + case weapons::Morgenstern: + return morgenstern; + case weapons::Bow: + return bow; + } + }, + [](const equipments &arg) { + switch (arg) { + case equipments::Chainmail: + return chainmail; + case equipments::CookingPot: + return cooking_pot; + case equipments::MedicKit: + return medic_kit; + case equipments::PamphletTourist: + return pamphlet_tourist; + } + }, + [](const tools &arg) { + switch (arg) { + case tools::Fourche: + return fourche; + case tools::Dagger: + return dagger; + case tools::RockClimbingKit: + return rock_climbing_kit; + case tools::SackOfGrain: + return sack_of_grain; + } + } + }, object); } void BillyObjects::from_json(const json &j, BillyObjects::container &billy) { @@ -104,21 +244,20 @@ namespace character { const std::uint8_t value = element[1].get(); switch (key) { case weaponsHash: - billy.emplace(static_cast(value), std::make_unique(static_cast(value))); + billy.push_back(static_cast(value)); break; case equipmentHash: - billy.emplace(static_cast(value), - std::make_unique(static_cast(value))); + billy.push_back(static_cast(value)); break; case toolsHash: - billy.emplace(static_cast(value), std::make_unique(static_cast(value))); + billy.push_back(static_cast(value)); break; } } } void BillyObjects::to_json(json &j, const BillyObjects::container &billy) { - for (const auto &[object_type, _]: billy) { + for (const auto &object: billy) { std::visit(overloaded{ [&j](const weapons weapon) { j.emplace_back(std::pair{ weaponsHash, static_cast(weapon) }); @@ -129,7 +268,27 @@ namespace character { [&j](const tools tool) { j.emplace_back(std::pair{ toolsHash, static_cast(tool) }); } - }, object_type); + }, object); } } + + ankerl::svector BillyObjects::check_conformity(const CharacterSheet &sheet) noexcept { + ankerl::svector output; + std::transform(sheet.get_objects().cbegin(), + sheet.get_objects().cend(), std::back_inserter(output), + [&sheet](const billyObject &object) -> bool { + return std::visit(overloaded{ + [](const weapons weapon) { return false; }, + [](const equipments equipment) { return false; }, + [](const tools tool) { return false; }, + }, object); + }); + const int total = std::accumulate(sheet.get_objects().cbegin(), + sheet.get_objects().cend(), + 0, + [](const int a, const billyObject &object) -> int { + return 0; + }); + return output; + } } \ No newline at end of file diff --git a/src/character_sheet.cpp b/src/character_sheet.cpp new file mode 100644 index 0000000..aae9853 --- /dev/null +++ b/src/character_sheet.cpp @@ -0,0 +1 @@ +#include "character_sheet.hpp" diff --git a/src/generic_object.cpp b/src/generic_object.cpp index c0536df..a09f2c9 100644 --- a/src/generic_object.cpp +++ b/src/generic_object.cpp @@ -3,7 +3,6 @@ // #include "generic_object.hpp" -#include "characteristic.hpp" namespace character { using characteristic::characType; @@ -31,7 +30,7 @@ namespace character { std::uint32_t Weapons::add_damage() const noexcept { return type == weapons::Morgenstern ? 1 : 0; } - std::int32_t Weapons::add_materiel(const characteristic::characType &inType) const noexcept { + std::int32_t Weapons::add_materiel(const characteristic::characType inType) const noexcept { switch (type) { case weapons::Sword: if (inType == characType::Habilete) { @@ -94,7 +93,7 @@ namespace character { std::uint32_t Equipments::add_damage() const noexcept { return 0; } - std::int32_t Equipments::add_materiel(const characteristic::characType &inType) const noexcept { + std::int32_t Equipments::add_materiel(const characteristic::characType inType) const noexcept { switch (type) { case equipments::Chainmail: if (inType == characType::Habilete || @@ -130,7 +129,7 @@ namespace character { std::uint32_t Tools::add_damage() const noexcept { return 0; } - std::int32_t Tools::add_materiel(const characteristic::characType &inType) const noexcept { + std::int32_t Tools::add_materiel(const characteristic::characType inType) const noexcept { switch (type) { case tools::Fourche: switch (inType) { @@ -166,4 +165,12 @@ namespace character { return sackOfGrain; } } + + billyObjects new_object(const billyEnums &inputObject) noexcept { + return std::visit(overloaded{ + [](const weapons input) { return billyObjects{ new Weapons{ input }}; }, + [](const equipments input) { return billyObjects{ new Equipments{ input }}; }, + [](const tools input) { return billyObjects{ new Tools{ input }}; } + }, inputObject); + } }