mapcreator git · master

#pragma once

#include <SDL3/SDL.h>

#include <vector>
#include <unordered_map>
#include <fstream>
#include <iostream>

#include "defaults/defaults.hpp"
#include "defaults/input.hpp"
#include "resource/resource_data.hpp"

// Tile


enum class ObjectType;

struct TileObject {
    SDL_Point position;
    bool      draw_from_this_tile;
    size_t    object_id;
};

enum TileType {
    TILE_TYPE_FIRST,
    TILE_BACKGROUND,
    TILE_OBJECT,
    TILE_BUILDING,
    TILE_OVERLAY,
    TILE_FARM,
    TILE_TYPE_LAST
};

enum TileCategory {
    TILE_GROUND,
    TILE_WALL,
    TILE_WATER,
    TILE_TREE,
    TILE_ROCK,
    TILE_VEGETATION,
    TILE_FURNITURE,
    TILE_FLOORS,
    TILE_PROPS,
    TILE_ROOFS,
    TILE_WALLS,
    TILE_DUNGEON,
    TILE_WALL_VARIATION,
    TILE_WORKBENCH,
    TILE_FARMING,
    TILE_OVERLAY_FARM,
};

struct Tile_s {
    size_t set_id;
    size_t object_id;

    TileCategory set_category;
    SDL_Point    set_position;
};

struct TilesetObject {
    SDL_Rect   position;
    bool       draw_from_this_tile;
    ObjectType object_type;

    bool collectable;
    int  z_index;

    Tile_s tileset_info;
    size_t object_id;
};

enum TileTypeFloors {
    NONE,
    MEADOW,
    CLAY,
    SOIL,
    BRICKS,
    ICE,
    DESERT,
    WATER,
    LAST
};

struct FloorProps {
    TileTypeFloors type;
    bool can_buid_on;
    bool can_plant_on;
};

struct TilesetFloorProps {
    TileTypeFloors tiletype;
    int z_index;
};

enum class TileObjectPropSettingStates {
    OBJECT_SETTING_STATE_FIRST,
    OBJECT_SETTING_STATE_TYPE,
    OBJECT_SETTING_STATE_COLLECTING_METHODE,
    OBJECT_SETTING_STATE_ZINDEX_METHODE,
    OBJECT_SETTING_STATE_SAVE,
    OBJECT_SETTING_STATE_LAST,
};

enum class TileBuildingStatus {
    NONE,
    CONSTRUCT,
    DECONSTRUCT,
    BUILD
};

struct TileSet {
    SDL_Texture*  texture;
    SDL_Point size;
    TileCategory  category;
    std::vector<bool> collission_map;
    std::unordered_map<size_t, TilesetObject> objects;
    std::unordered_map<size_t, Resource_s> resources;
};

struct TileSettingHistory {
    TileType tileset_type;
    size_t   index;
    Tile_s   old_tile;
};


struct OLDMapTileObject {
    TilesetObject position_and_size;
    Tile_s tile_info;
};

namespace Tile {
    constexpr int tile_size = 16;
    constexpr int tile_collider_size = 4;

    extern size_t   active_tileset_id;
    extern TileType active_tileset_type;
    extern TileSet* active_tileset;

    extern bool draw_tile_set;
    extern bool tile_selected; // make this an enum so we can select object or tile in one type..
    extern bool      object_selected;
    extern size_t    selected_object;
    extern size_t    selected_object_id;
    extern SDL_Point selected_position;

    extern TileObjectPropSettingStates object_props_setting_state;

    extern std::unordered_map<TileType, std::vector<TileSet>> tilesets;

    extern std::vector<FloorProps> floor_props;
    extern std::unordered_map<TileCategory, std::unordered_map<size_t,TilesetFloorProps>> tileset_floor_props;

    extern SDL_FPoint tileset_offset;
    extern SDL_FPoint tileset_offset_to_set;
    extern bool setting_tileset_offset;

    extern float tileset_scale;
    extern float tileset_scale_to_set;
    extern bool  setting_tileset_scale;

    extern std::vector<SDL_Point> selected_tiles;

    extern SDL_Point selection_tile_dimension;
    extern SDL_Point selected_tile_dimension;

    extern std::string save_tileset_collission_path;
    extern std::string save_tileset_objects_path;
    extern std::string save_tileset_resources_path;
    extern std::string save_tileset_floortype_path;

    extern std::vector<TileSettingHistory> tile_setting_history;

    extern bool hovering_set;


    bool Init(SDL_Renderer* renderer);


    TileType get_Type(TileCategory category);
    size_t   get_Size();
    size_t   get_SelectionSize(ModifyState_s modify_state);
    size_t   get_ObjectIdFromTileset(SDL_Point selected_tile, TileSet tileset = *active_tileset);

    void set_HoveringTileset(SDL_FPoint mouse_state);

    TileSet& get_TilesetFromMapTile(Tile_s tile);

    void save_Objects();
    void load_Objects();

    void save_Collissions();
    void load_Collissions();

    void load_TilesetFloorProps();
    void save_TilesetFloorProps();

    void set_TilesetOffset(Input& input);

    void draw_SelectedObject(SDL_Renderer* renderer, Input input);
    void draw_Tileset(SDL_Renderer* renderer, Input input);

    void clear_Objects(Input& input);

    void set_Object(Input& input);
    void set_ObjectProps(Input& input);

    void set_Collission(Input& input);

    const char* to_String(TileTypeFloors type);
    void set_FloorType(Input& input);
    TileTypeFloors
         get_FloorType(Tile_s&);
    TileTypeFloors
        get_FloorType(SDL_Point& world_tile);

    bool objec_HasCollission(TilesetObject& object);
    std::vector<bool> get_CollissionsOfTileFromObject(TilesetObject& obj, SDL_Point tile);

    void transfer_ToMap(Input& input);

    Resource_s    get_ResourceFromTileSet(size_t tileset_id, size_t object_id);
    TilesetObject get_ObjectFromTileSet(size_t tileset_id, size_t object_id, TileType type = TILE_OBJECT);
    std::vector<bool> get_ObjectCollisionsFromTileset(size_t tileset_id, size_t object_id, TileType type = TILE_OBJECT);

    void print_CollisionMap(const TilesetObject& obj);
    void print_TileObject(const TilesetObject& obj);

}