rgmap.h

#ifndef RGMAP_H
#define RGMAP_H
 
#define _USE_MATH_DEFINES
 
#include <Godot.hpp>
#include <Node.hpp>
#include <Vector2.hpp>
#include <Array.hpp>
#include <AStar2D.hpp>
#include <Rect2.hpp>
#include <TileSet.hpp>
#include <Texture.hpp>
#include <ShaderMaterial.hpp>
#include <Color.hpp>
#include <Dictionary.hpp>
#include <cmath>
#include <vector>
#include <algorithm>
 
namespace godot {
class RGMap : public Reference {
    GODOT_CLASS(RGMap, Node)
 
    // Structure needed for RPAS algorithm
    struct CellAngles{
        float near;
        float center;
        float far;
    };
 
    // Structure that stores data about one type of tile
    struct RGTile {
        String name;
        String display_name;
        bool passable = false;
        bool transparent = false;
        Dictionary custom_properties;
        int z_index = 0;
        Ref<Texture> texture;
        Ref<Texture> normal_map;
        Vector2 texture_offset = Vector2(0,0);
        Ref<ShaderMaterial> material;
        Color modulate = Color(1.0,1.0,1.0);
    };
 
    // Structure of one chunk
    struct Chunk {
        // Flat arrays that contain all data about the cells
        std::vector<int> values;
        std::vector<int> memory;
        std::vector<int> entities;
        bool loaded = false;
        bool rendered = false;
    };
 
    // Structure of entity
    struct Entity {
        Vector2 position = Vector2(0,0);
        bool passable = true;
        bool transparent = true;
        bool discovered = false;
        bool rewrite = false;
    };
 
private:
    // All tiles in a game
    std::vector<RGTile> tiles;
    // Store all chunks
    std::vector<Chunk> chunks;
    // Epsilon for float error calculation
    const float FLOAT_EPSILON = 0.00001;
    // Visibility of cells within fov radius. Temporary variable
    std::vector<int> visibility;
    // Opaque obstacles for FOV. Temporary variable
    std::vector<int> fov_obstacles;
    // Current fov zone
    Rect2 fov_zone = Rect2(Vector2(0,0), Vector2(0,0));
    std::vector<Vector2> pathfinding_exception_allowed;
    std::vector<Vector2> pathfinding_exception_disallowed;
    // Number of Arrays stored in Chunk structure
    const int NUM_CHUNK_ARRAYS = 2;
    // Array with all registered entities
    std::vector<Entity> entities;
    // Ids of loaded chunks
    std::vector<int> loaded_chunks;
    // Ids of rendered chunks
    std::vector<int> rendered_chunks;
    // Dictionary with custom tile property names as keys and their default values
    Dictionary custom_tile_properties;
 
    // Functions for Restrictive Precise Angle Shadowcasting. More details in rpas.cpp
    PoolVector2Array rpas_visible_cells_in_quadrant_from(Vector2 center, Vector2 quad, int radius);
    PoolVector2Array rpas_visible_cells_in_octant_from(Vector2 center, Vector2 quad, int radius, bool is_vertical);
    Vector2 rpas_cell_at(Vector2 center, Vector2 quad, int step, int iteration, bool is_vertical);
    bool rpas_cell_in_radius(Vector2 center, Vector2 cell, int radius);
    bool rpas_cell_is_visible(CellAngles cell_angles, std::vector<CellAngles>& obstructions);
    void rpas_add_obstruction(std::vector<CellAngles> & obstructions, CellAngles new_obstruction);
    bool rpas_combine_obstructions(CellAngles &old_o, CellAngles &new_o);
    // Draw points based on 4-way symmetry (for Bresenham's ellipse algorithm)
    void draw_4_way_symmetry(int xc, int yc, int x, int y, int value, float start_angle, float end_angle);
 
    // Get a set of points in Bresenham's line
    PoolVector2Array get_line_bresenham(Vector2 start, Vector2 end, bool allow_diagonal);
    // Draw ellipse using Bresenham's midpoint algorithm
    void draw_ellipse_bresenham(Vector2 center, Vector2 radius, float start_angle, float end_angle, int value, bool allow_diagonal);
    // Get loaded chunk
    Chunk& get_chunk(int index);
    // Find path from start to end using A* algorithm
    PoolVector2Array _find_path(Vector2 start, Vector2 end, Rect2 pathfinding_zone, bool exclude_undiscovered=false);
 
public:
 
    Vector2 chunk_size = Vector2(50,50);
    Vector2 size = Vector2(3,3);
 
    int load_distance = 1;
 
    int render_distance = 1;
    bool allow_diagonal_pathfinding = true;
 
 
    int fov_radius = 15;
    float RPAS_RADIUS_FUDGE = 1.0 / 3.0; 
    bool RPAS_NOT_VISIBLE_BLOCKS_VISION = true; 
 
    int RPAS_RESTRICTIVENESS = 1;
    bool RPAS_VISIBLE_ON_EQUAL = true; 
 
    // Note: these functions placed here to ease documentation generation with Doxygen
    // Tell me if you know a better way to do so
 
 
    PoolIntArray chunks_load_requested() {return PoolIntArray();}
    PoolIntArray chunks_free_requested() {return PoolIntArray();}
    PoolIntArray chunks_render_requested() {return PoolIntArray();}
    PoolIntArray chunks_hide_requested() {return PoolIntArray();}
    int chunk_loaded() {return 0;}
    int chunk_freed() {return 0;}
 
 
    static void _register_methods();
    RGMap();
    ~RGMap();
    void _init();
    void _ready();
 
    // tiles.cpp
 
 
 
    int add_tile(String name, String display_name);
    void set_tile_transparency(int index, bool value);
    void set_tile_passability(int index, bool value);
 
    void add_tile_property(String property_name, Variant default_value);
    void set_tile_z_index(int index, int z_index);
    void set_tile_texture_offset(int index, Vector2 offset);
    void set_tile_texture(int index, Ref<Texture> texture);
    void set_tile_normal_map(int index, Ref<Texture> texture);
    void set_tile_material(int index, Ref<Material> material);
    void set_tile_modulate(int index, Color color);
    void set_tile_property(int index, String property_name, Variant new_value);
    int get_tiles_count();
    int get_tile_index(String name);
    String get_tile_name(int index);
    String get_tile_display_name(int index);
    bool is_tile_passable(int index);
    bool is_tile_transparent(int index);
    int get_tile_z_index(int index);
    Vector2 get_tile_texture_offset(int index);
    Ref<Texture> get_tile_texture(int index);
    Ref<Texture> get_tile_normal_map(int index);
    Ref<Material> get_tile_material(int index);
    Color get_tile_modulate(int index);
    Variant get_tile_property(int index, String property_name);
    Ref<TileSet> generate_tileset();
 
    // chunks.cpp
 
    
    int get_chunk_index(Vector2 position);
    Vector2 chunk_index_int_to_v2(int index);
    int chunk_index_v2_to_int(Vector2 index);
    bool is_chunk_in_bounds(int index);
    bool is_chunk_loaded(int index);
    void load_chunk(int index, PoolIntArray data = PoolIntArray());
    PoolIntArray dump_chunk_data(int index);
    void free_chunk(int index);
    void reset_chunk(int index);
    bool is_chunk_rendered(int index);
    void set_chunk_rendered(int index, bool value);
    PoolIntArray get_loaded_chunks();
    PoolIntArray get_chunks_in_distance(Vector2 point, int distance);
 
    PoolIntArray get_chunks_to_load(Vector2 player_position);
 
    PoolIntArray get_chunks_to_free(Vector2 player_position);
 
    void request_chunks_load(Vector2 player_position);
    PoolIntArray get_rendered_chunks();
 
    PoolIntArray get_chunks_to_render(Vector2 player_position);
 
    PoolIntArray get_chunks_to_hide(Vector2 player_position);
 
    void request_chunks_render(Vector2 player_position);
 
    // cells.cpp
 
 
    int get_local_index(Vector2 position);
    int get_value(Vector2 position);
    String get_name(Vector2 position);
    String get_display_name(Vector2 position);
    Variant get_property(Vector2 position, String property_name);
    bool is_in_bounds(Vector2 position);
    bool is_transparent(Vector2 position);
    bool is_passable(Vector2 position);
    bool is_visible(Vector2 position);
    bool is_discovered(Vector2 position);
    void set_value(Vector2 position, int value);
    void set_visibility(Vector2 position, bool value);
    void set_discovered(Vector2 position, bool value);
 
    // view.cpp
 
 
    PoolVector2Array rpas_calc_visible_cells_from(Vector2 center, int radius);
    void calculate_fov(Vector2 view_position);
    void add_pathfinding_exception(Vector2 position, bool value);
    void remove_pathfinding_exception(Vector2 position);
 
    PoolVector2Array show_pathfinding_exceptions(bool exception_type);
    bool is_pathfinding_allowed(Vector2 position);
 
    PoolVector2Array find_path(Vector2 start, Vector2 end, Rect2 pathfinding_zone);
 
    PoolVector2Array find_discovered_path(Vector2 start, Vector2 end, Rect2 pathfinding_zone);
 
    PoolVector2Array get_line(Vector2 start, Vector2 end);
    PoolVector2Array get_line_orthogonal(Vector2 start, Vector2 end);
    Vector2 raycast_vision(Vector2 start, Vector2 end);
    Vector2 raycast_path(Vector2 start, Vector2 end);
 
    bool visibility_between(Vector2 start, Vector2 end, int max_distance);
 
    // editing.cpp
 
 
    void clean_map();
    void resize_map(Vector2 new_size, Vector2 new_chunk_size);
    void place_map(RGMap* another_map, Vector2 start);
    void draw_line(Vector2 start, Vector2 end, int value);
    void draw_line_orthogonal(Vector2 start, Vector2 end, int value);
    void draw_rect(Rect2 rect, int value);
    void fill_rect(Rect2 rect, int value);
 
    void draw_ellipse(Vector2 center, Vector2 radius, float start_angle, float end_angle, int value);
    void draw_ellipse_orthogonal(Vector2 center, Vector2 radius, float start_angle, float end_angle, int value);
    void fill_ellipse(Vector2 center, Vector2 radius, float start_angle, float end_angle, int value);
    void draw_circle(Vector2 center, float radius, int value);
    void draw_circle_orthogonal(Vector2 center, float radius, int value);
    void fill_circle(Vector2 center, float radius, int value);
    void draw_arc(Vector2 center, float radius, float start_angle, float end_angle, int value);
    void draw_arc_orthogonal(Vector2 center, float radius, float start_angle, float end_angle, int value);
    void fill_arc(Vector2 center, float radius, float start_angle, float end_angle, int value);
 
    // entities.cpp
 
 
    int add_entity(Vector2 position, bool passability, bool transparency);
    void remove_entity(int id);
    void move_entity(int id, Vector2 position);
    void set_entity_transparency(int id, bool value);
    void set_entity_passability(int id, bool value);
    void set_entity_discovered(int id, bool value);
    bool is_entity_visible(int id);
    bool is_entity_transparent(int id);
    bool is_entity_passable(int id);
    bool is_entity_discovered(int id);
    bool is_entity_chunk_loaded(int id);
    bool is_entity_chunk_rendered(int id);
    Vector2 get_entity_position(int id);
    PoolIntArray get_entities_in_position(Vector2 position);
    PoolIntArray get_entities_in_rect(Rect2 rect);
    PoolIntArray get_entities_in_radius(Vector2 position, int radius);
    PoolIntArray get_entities_in_chunk(int chunk_index);
 
 
    PoolIntArray dump_map_data();
    void load_map_data(PoolIntArray map_data);
};
 
}
 
#endif