mapcreator git · master

#include "resource/resource_data.hpp"

#include <iostream>

#include "map/tile.hpp"

namespace ResourceData {
    std::string save_tileset_resources_path = "saves/save.tileset_recources";


    const std::deque<std::string> names = {
        "Nichts",
        "Wood",
        "Stone",
        "Clay",
        "Iron",
        "Bone",
        "Something went horribly wrong"
    };

    void
    save_Resources() {
        std::ofstream file(save_tileset_resources_path, std::ios::binary);
        if (!file) return;

        // number of TileType entries
        uint32_t types_count = Tile::tilesets.size();
        file.write(reinterpret_cast<const char*>(&types_count), sizeof(types_count));

        for (const auto& [type, vec] : Tile::tilesets) {
            uint32_t t = static_cast<uint32_t>(type);
            file.write(reinterpret_cast<const char*>(&t), sizeof(t));

            uint32_t set_count = vec.size();
            file.write(reinterpret_cast<const char*>(&set_count), sizeof(set_count));

            for (const auto& tileset : vec) {
                uint64_t res_count = tileset.resources.size();
                file.write(reinterpret_cast<const char*>(&res_count), sizeof(res_count));

                for (const auto& [key, res] : tileset.resources) {
                    file.write(reinterpret_cast<const char*>(&key), sizeof(key));

                    file.write(reinterpret_cast<const char*>(&res.tileset_id), sizeof(res.tileset_id));
                    file.write(reinterpret_cast<const char*>(&res.object_id), sizeof(res.object_id));

                    int resource_type = static_cast<int>(res.resource);
                    file.write(reinterpret_cast<const char*>(&resource_type), sizeof(resource_type));

                    int methode = static_cast<int>(res.collecting_methode);
                    file.write(reinterpret_cast<const char*>(&methode), sizeof(methode));

                    file.write(reinterpret_cast<const char*>(&res.collecting_duration), sizeof(res.collecting_duration));
                    file.write(reinterpret_cast<const char*>(&res.quantity), sizeof(res.quantity));
                }
            }
        }
    }

    void
    load_Resources() {
        std::ifstream file(save_tileset_resources_path, std::ios::binary);
        if (!file) return;

        uint32_t types_count = 0;
        file.read(reinterpret_cast<char*>(&types_count), sizeof(types_count));

        for (uint32_t i = 0; i < types_count; ++i) {
            uint32_t t = 0;
            file.read(reinterpret_cast<char*>(&t), sizeof(t));
            TileType type = static_cast<TileType>(t);

            uint32_t set_count = 0;
            file.read(reinterpret_cast<char*>(&set_count), sizeof(set_count));

            auto& vec = Tile::tilesets[type];
            for (uint32_t j = 0; j < set_count && j < vec.size(); ++j) {
                uint64_t res_count = 0;
                file.read(reinterpret_cast<char*>(&res_count), sizeof(res_count));

                vec[j].resources.clear();
                for (uint64_t k = 0; k < res_count; ++k) {
                    size_t key = 0;
                    file.read(reinterpret_cast<char*>(&key), sizeof(key));

                    Resource_s res{};
                    file.read(reinterpret_cast<char*>(&res.tileset_id), sizeof(res.tileset_id));
                    file.read(reinterpret_cast<char*>(&res.object_id), sizeof(res.object_id));

                    int resource_type = 0;
                    file.read(reinterpret_cast<char*>(&resource_type), sizeof(resource_type));
                    res.resource = static_cast<ResourceType>(resource_type);

                    int methode = 0;
                    file.read(reinterpret_cast<char*>(&methode), sizeof(methode));
                    res.collecting_methode = static_cast<CollectingMethode>(methode);

                    file.read(reinterpret_cast<char*>(&res.collecting_duration), sizeof(res.collecting_duration));
                    file.read(reinterpret_cast<char*>(&res.quantity), sizeof(res.quantity));

                    vec[j].resources.emplace(key, res);
                }
            }
        }
    }


    void
    set_ObjectPropsResource(Input& input) {
        static ResourceType last_resource_choice = ResourceType::NONE;
        static CollectingMethode last_collecting_choice = CollectingMethode::NONE;
        static float last_collecting_duration_choice = 1.0;
        static unsigned last_quantity_choice = 1;
        static Resource_s* resource_p = nullptr;
        static bool resource_is_new = true;
        static Resource_s change_resource;
        static size_t id;
        static int function_iteration = 0;
        // init setting up
        if (input.click_left_released) {
            function_iteration = 0;
            Tile::object_props_setting_state = TileObjectPropSettingStates::OBJECT_SETTING_STATE_TYPE;

            id = Tile::get_ObjectIdFromTileset({input.mouse_tile_position.x, 
                                                input.mouse_tile_position.y});
            if (id == SIZE_MAX) return;

            TilesetObject object = Tile::active_tileset->objects[id];
            if (Default::modify_state == MODIFY_OBJECTS_PROPS_RESOURCE && !object.collectable)
                return;

            Tile::object_selected = true;
            Tile::selected_object_id = id;
            Tile::selected_position = {input.mouse_tile_position.x, input.mouse_tile_position.y};

            Tile::tile_selected = false;

            // --- Retrieve or create resource ---

            // init variables for setting
            auto it = Tile::active_tileset->resources.find(id);
            if (it != Tile::active_tileset->resources.end()) {
                resource_p = &it->second;
                last_resource_choice            = resource_p->resource;
                last_collecting_choice          = resource_p->collecting_methode;
                last_collecting_duration_choice = resource_p->collecting_duration;
                last_quantity_choice            = resource_p->quantity;
                change_resource = *resource_p;
                resource_is_new = false;
                std::cout << "SETTING PROPS RESOURCE FOR: existing object\n";
                // std::cout << id << "   : " << ResourceData::to_String(resource_p->resource) << std::endl;

            } else {
                change_resource = {Tile::active_tileset_id,
                                      id,
                                      last_resource_choice,
                                      last_collecting_choice,
                                      last_collecting_duration_choice,
                                      last_quantity_choice };
                resource_is_new = true;
                std::cout << "SETTING PROPS RESOURCE FOR: new object\n---\n";
            }
            std::cout << "Resource Type " << ResourceData::to_String(last_resource_choice) << std::endl; 
            std::cout << "Collecting Methode " << ResourceData::to_String(last_collecting_choice) << std::endl; 
            std::cout << "Collecting Duration " << last_collecting_duration_choice << "s ?\n"; 
            std::cout << "Quantity " << last_quantity_choice << "\n"; 
            std::cout << "---" << "\n"; 

        }
        // key handling
        if (input.pressed_return_released) {
            function_iteration++;
            std::cout << "---" << std::endl;
            std::cout << "Iteration: " << function_iteration << std::endl;
            std::cout << "Resource Type " << ResourceData::to_String(last_resource_choice) << std::endl; 
            std::cout << "Collecting Methode " << ResourceData::to_String(last_collecting_choice) << std::endl; 
            std::cout << "Collecting Duration " << last_collecting_duration_choice << "s ?\n"; 
            std::cout << "Quantity " << last_quantity_choice << "\n"; 
            std::cout << "---" << "\n"; 
            if (function_iteration == 5) {
                change_resource.resource            = last_resource_choice;
                change_resource.collecting_methode  = last_collecting_choice;
                change_resource.collecting_duration = last_collecting_duration_choice;
                change_resource.quantity            = last_quantity_choice;

                if (!resource_is_new) {
                    std::cout << "Save Existing\n";
                    *resource_p = change_resource;
                } else {
                    Tile::active_tileset->resources.emplace(id, change_resource);
                    std::cout << "Save New\n";
                }
                ResourceData::save_Resources();
                function_iteration = 0;
                return;
            }
        }
        if ( input.pressed_arrowdown_released || input.pressed_arrowup_released || input.pressed_return_released) {
            switch ( function_iteration ) {
                case 0: {
                    if (input.pressed_arrowup_released) {
                        int type = static_cast<int>(last_resource_choice);
                        int last = static_cast<int>(ResourceType::LAST);
                        type = (type - 1 + last) % last;
                        last_resource_choice = static_cast<ResourceType>(type);
                    } else if (input.pressed_arrowdown_released) {
                        last_resource_choice = static_cast<ResourceType>(
                                (static_cast<int>(last_resource_choice) + 1) % static_cast<int>(ResourceType::LAST)
                                );
                    }
                    std::cout << "Resource Type " << ResourceData::to_String(last_resource_choice) << std::endl; 
                    break;
                    }
                case 1:
                    if (input.pressed_arrowup_released) {
                        int type = static_cast<int>(last_collecting_choice);
                        int last = static_cast<int>(CollectingMethode::LAST);
                        type = (type - 1 + last) % last;
                        last_collecting_choice = static_cast<CollectingMethode>(type);
                    } else if (input.pressed_arrowdown_released) {
                        last_collecting_choice = static_cast<CollectingMethode>(
                                (static_cast<int>(last_collecting_choice) + 1) % static_cast<int>(CollectingMethode::LAST)
                                );
                    }
                    std::cout << "Collecting Methode " << ResourceData::to_String(last_collecting_choice) << std::endl; 
                    break;
                case 2:
                    if (input.pressed_arrowup_released) {
                        last_collecting_duration_choice -= 0.2;
                    } else if (input.pressed_arrowdown_released) {
                        last_collecting_duration_choice += 0.2;
                    }
                    if (last_collecting_duration_choice < 0)
                        last_collecting_duration_choice = 0.0;
                    std::cout << "Collecting Duration " << last_collecting_duration_choice << "s ?\n"; 
                    break;
                case 3:
                    if (input.pressed_arrowup_released) {
                        last_quantity_choice -= 1;
                    } else if (input.pressed_arrowdown_released) {
                        last_quantity_choice += 1;
                    }
                    if (last_quantity_choice < 1)
                        last_quantity_choice = 1;
                    std::cout << "Quantity " << last_quantity_choice << "\n"; 
                    break;
                default:
                    break;
            }
        }

    }


    const char* to_String(CollectingMethode methode) {
        switch (methode) {
            case CollectingMethode::NONE:        return "NONE";
            case CollectingMethode::HAND:        return "HAND";
            case CollectingMethode::AXE_STONE:   return "AXE STONE";
            case CollectingMethode::SWORD_WOOD:  return "SWORD WOOD";
            case CollectingMethode::KNIFE:       return "KNIFE";
            case CollectingMethode::FISHINGROT:  return "FISHINGROT";
            case CollectingMethode::PICKAXE_STONE: return "PICKAXE STONE";
            default:                             return "UNKNOWN";
        }
    }

    const char* to_String(ResourceType resource) {
        size_t idx = static_cast<size_t>(resource);
        if (idx >= ResourceData::names.size()) {
            std::cerr << "ResourceType out of range: " << static_cast<int>(resource) << std::endl;
            return "No valid ResourceType!";
        }
        return ResourceData::names[idx].c_str();
    }
}