2023-01-05 13:25:55 +01:00
|
|
|
/**************************************************************************/
|
|
|
|
/* tile_map.h */
|
|
|
|
/**************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* https://godotengine.org */
|
|
|
|
/**************************************************************************/
|
|
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/**************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#ifndef TILE_MAP_H
|
|
|
|
#define TILE_MAP_H
|
|
|
|
|
2024-03-05 13:55:23 +01:00
|
|
|
#include "scene/2d/tile_map_layer.h"
|
2021-03-16 07:27:53 +01:00
|
|
|
#include "scene/resources/2d/tile_set.h"
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2024-01-05 11:58:21 +01:00
|
|
|
class Control;
|
|
|
|
class TileMapLayer;
|
|
|
|
class TerrainConstraint;
|
2019-02-06 00:45:40 +01:00
|
|
|
|
2024-01-05 11:58:21 +01:00
|
|
|
enum TileMapDataFormat {
|
2024-03-05 13:55:23 +01:00
|
|
|
TILE_MAP_DATA_FORMAT_1 = 0,
|
|
|
|
TILE_MAP_DATA_FORMAT_2,
|
|
|
|
TILE_MAP_DATA_FORMAT_3,
|
|
|
|
TILE_MAP_DATA_FORMAT_MAX,
|
2023-06-16 14:16:37 +02:00
|
|
|
};
|
|
|
|
|
2024-03-05 13:55:23 +01:00
|
|
|
class TileMap : public Node2D {
|
|
|
|
GDCLASS(TileMap, Node2D)
|
2023-06-16 14:16:37 +02:00
|
|
|
|
|
|
|
public:
|
2024-02-28 17:17:46 +01:00
|
|
|
// Kept for compatibility, but should use TileMapLayer::VisibilityMode instead.
|
2021-05-24 12:33:22 +02:00
|
|
|
enum VisibilityMode {
|
|
|
|
VISIBILITY_MODE_DEFAULT,
|
|
|
|
VISIBILITY_MODE_FORCE_SHOW,
|
|
|
|
VISIBILITY_MODE_FORCE_HIDE,
|
|
|
|
};
|
|
|
|
|
2021-05-07 15:41:39 +02:00
|
|
|
private:
|
|
|
|
friend class TileSetPlugin;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2021-05-24 12:33:22 +02:00
|
|
|
// A compatibility enum to specify how is the data if formatted.
|
2024-03-05 13:55:23 +01:00
|
|
|
mutable TileMapDataFormat format = TileMapDataFormat::TILE_MAP_DATA_FORMAT_3;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2021-07-28 18:10:01 +02:00
|
|
|
static constexpr float FP_ADJUST = 0.00001;
|
|
|
|
|
2021-05-24 12:33:22 +02:00
|
|
|
// Properties.
|
2024-03-05 13:55:23 +01:00
|
|
|
Ref<TileSet> tile_set;
|
2023-08-24 13:31:14 +02:00
|
|
|
int rendering_quadrant_size = 16;
|
2021-09-15 15:23:58 +02:00
|
|
|
bool collision_animatable = false;
|
2021-07-28 18:10:01 +02:00
|
|
|
VisibilityMode collision_visibility_mode = VISIBILITY_MODE_DEFAULT;
|
|
|
|
VisibilityMode navigation_visibility_mode = VISIBILITY_MODE_DEFAULT;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Layers.
|
2024-01-12 17:23:53 +01:00
|
|
|
LocalVector<TileMapLayer *> layers;
|
|
|
|
TileMapLayer *default_layer; // Dummy layer to fetch default values.
|
2021-07-28 18:10:01 +02:00
|
|
|
|
2024-01-12 17:23:53 +01:00
|
|
|
// Transforms for collision_animatable.
|
2021-09-15 15:23:58 +02:00
|
|
|
Transform2D last_valid_transform;
|
|
|
|
Transform2D new_transform;
|
2021-10-22 16:32:06 +02:00
|
|
|
|
2024-03-05 13:55:23 +01:00
|
|
|
void _tile_set_changed();
|
|
|
|
|
2024-01-19 17:25:14 +01:00
|
|
|
void _emit_changed();
|
2014-10-03 05:10:51 +02:00
|
|
|
|
2024-03-05 13:55:23 +01:00
|
|
|
// Kept for compatibility with TileMap. With TileMapLayers as individual nodes, the format is stored directly in the array.
|
|
|
|
void _set_tile_map_data_using_compatibility_format(int p_layer, TileMapDataFormat p_format, const Vector<int> &p_data);
|
|
|
|
Vector<int> _get_tile_map_data_using_compatibility_format(int p_layer) const;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
protected:
|
2017-10-22 03:42:23 +02:00
|
|
|
bool _set(const StringName &p_name, const Variant &p_value);
|
|
|
|
bool _get(const StringName &p_name, Variant &r_ret) const;
|
|
|
|
void _get_property_list(List<PropertyInfo> *p_list) const;
|
2023-10-24 13:38:29 +02:00
|
|
|
bool _property_can_revert(const StringName &p_name) const;
|
|
|
|
bool _property_get_revert(const StringName &p_name, Variant &r_property) const;
|
2017-10-22 03:42:23 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void _notification(int p_what);
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
#ifndef DISABLE_DEPRECATED
|
|
|
|
Rect2i _get_used_rect_bind_compat_78328();
|
2023-08-24 13:31:14 +02:00
|
|
|
void _set_quadrant_size_compat_81070(int p_quadrant_size);
|
|
|
|
int _get_quadrant_size_compat_81070() const;
|
2024-01-12 17:23:53 +01:00
|
|
|
VisibilityMode _get_collision_visibility_mode_bind_compat_87115();
|
|
|
|
VisibilityMode _get_navigation_visibility_mode_bind_compat_87115();
|
2023-08-24 13:31:14 +02:00
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
static void _bind_compatibility_methods();
|
|
|
|
#endif
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
public:
|
2019-10-21 23:37:07 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual Rect2 _edit_get_rect() const override;
|
2019-10-21 23:37:07 +02:00
|
|
|
#endif
|
2018-07-29 23:09:59 +02:00
|
|
|
|
2023-08-24 13:31:14 +02:00
|
|
|
#ifndef DISABLE_DEPRECATED
|
|
|
|
void force_update(int p_layer);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void set_rendering_quadrant_size(int p_size);
|
|
|
|
int get_rendering_quadrant_size() const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2023-12-15 19:20:03 +01:00
|
|
|
static void draw_tile(RID p_canvas_item, const Vector2 &p_position, const Ref<TileSet> p_tile_set, int p_atlas_source_id, const Vector2i &p_atlas_coords, int p_alternative_tile, int p_frame = -1, Color p_modulation = Color(1.0, 1.0, 1.0, 1.0), const TileData *p_tile_data_override = nullptr, real_t p_normalized_animation_offset = 0.0);
|
2021-07-28 18:10:01 +02:00
|
|
|
|
2024-03-05 13:55:23 +01:00
|
|
|
// Accessors.
|
|
|
|
void set_tileset(const Ref<TileSet> &p_tileset);
|
|
|
|
Ref<TileSet> get_tileset() const;
|
|
|
|
|
2021-07-28 18:10:01 +02:00
|
|
|
// Layers management.
|
|
|
|
int get_layers_count() const;
|
2021-08-31 10:48:45 +02:00
|
|
|
void add_layer(int p_to_pos);
|
|
|
|
void move_layer(int p_layer, int p_to_pos);
|
|
|
|
void remove_layer(int p_layer);
|
2023-06-16 14:16:37 +02:00
|
|
|
|
2021-07-28 18:10:01 +02:00
|
|
|
void set_layer_name(int p_layer, String p_name);
|
|
|
|
String get_layer_name(int p_layer) const;
|
|
|
|
void set_layer_enabled(int p_layer, bool p_visible);
|
|
|
|
bool is_layer_enabled(int p_layer) const;
|
2021-10-10 17:04:25 +02:00
|
|
|
void set_layer_modulate(int p_layer, Color p_modulate);
|
|
|
|
Color get_layer_modulate(int p_layer) const;
|
2021-07-28 18:10:01 +02:00
|
|
|
void set_layer_y_sort_enabled(int p_layer, bool p_enabled);
|
|
|
|
bool is_layer_y_sort_enabled(int p_layer) const;
|
|
|
|
void set_layer_y_sort_origin(int p_layer, int p_y_sort_origin);
|
|
|
|
int get_layer_y_sort_origin(int p_layer) const;
|
|
|
|
void set_layer_z_index(int p_layer, int p_z_index);
|
|
|
|
int get_layer_z_index(int p_layer) const;
|
2023-10-13 17:22:51 +02:00
|
|
|
void set_layer_navigation_enabled(int p_layer, bool p_enabled);
|
|
|
|
bool is_layer_navigation_enabled(int p_layer) const;
|
2023-06-16 14:16:37 +02:00
|
|
|
void set_layer_navigation_map(int p_layer, RID p_map);
|
|
|
|
RID get_layer_navigation_map(int p_layer) const;
|
|
|
|
|
2024-01-12 17:23:53 +01:00
|
|
|
void set_collision_animatable(bool p_collision_animatable);
|
2021-09-15 15:23:58 +02:00
|
|
|
bool is_collision_animatable() const;
|
|
|
|
|
2021-10-21 16:42:06 +02:00
|
|
|
// Debug visibility modes.
|
2021-05-24 12:33:22 +02:00
|
|
|
void set_collision_visibility_mode(VisibilityMode p_show_collision);
|
2024-01-12 17:23:53 +01:00
|
|
|
VisibilityMode get_collision_visibility_mode() const;
|
2021-05-24 12:33:22 +02:00
|
|
|
|
|
|
|
void set_navigation_visibility_mode(VisibilityMode p_show_navigation);
|
2024-01-12 17:23:53 +01:00
|
|
|
VisibilityMode get_navigation_visibility_mode() const;
|
2021-05-24 12:33:22 +02:00
|
|
|
|
2021-10-21 16:42:06 +02:00
|
|
|
// Cells accessors.
|
2023-01-18 13:35:58 +01:00
|
|
|
void set_cell(int p_layer, const Vector2i &p_coords, int p_source_id = TileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = 0);
|
2022-03-01 19:25:18 +01:00
|
|
|
void erase_cell(int p_layer, const Vector2i &p_coords);
|
2021-07-28 18:10:01 +02:00
|
|
|
int get_cell_source_id(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
|
|
|
|
Vector2i get_cell_atlas_coords(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
|
|
|
|
int get_cell_alternative_tile(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
|
2021-11-03 14:58:12 +01:00
|
|
|
// Helper method to make accessing the data easier.
|
|
|
|
TileData *get_cell_tile_data(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2021-10-21 16:42:06 +02:00
|
|
|
// Patterns.
|
2021-09-29 17:48:27 +02:00
|
|
|
Ref<TileMapPattern> get_pattern(int p_layer, TypedArray<Vector2i> p_coords_array);
|
2022-12-12 11:33:42 +01:00
|
|
|
Vector2i map_pattern(const Vector2i &p_position_in_tilemap, const Vector2i &p_coords_in_pattern, Ref<TileMapPattern> p_pattern);
|
|
|
|
void set_pattern(int p_layer, const Vector2i &p_position, const Ref<TileMapPattern> p_pattern);
|
2015-08-02 17:29:37 +02:00
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Terrains (Not exposed).
|
|
|
|
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_constraints(int p_layer, const Vector<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> &p_constraints);
|
|
|
|
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_connect(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
|
|
|
|
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_path(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
|
|
|
|
HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_pattern(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains = true);
|
2022-02-23 17:25:50 +01:00
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Terrains (exposed).
|
2022-02-23 17:25:50 +01:00
|
|
|
void set_cells_terrain_connect(int p_layer, TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
|
|
|
|
void set_cells_terrain_path(int p_layer, TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
|
2021-10-21 16:42:06 +02:00
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Not exposed to users.
|
2021-07-28 18:10:01 +02:00
|
|
|
TileMapCell get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
|
|
|
|
int get_effective_quadrant_size(int p_layer) const;
|
2017-10-22 03:42:23 +02:00
|
|
|
|
2020-09-23 21:49:50 +02:00
|
|
|
virtual void set_y_sort_enabled(bool p_enable) override;
|
2018-07-22 15:26:14 +02:00
|
|
|
|
2022-08-20 18:39:05 +02:00
|
|
|
Vector2 map_to_local(const Vector2i &p_pos) const;
|
|
|
|
Vector2i local_to_map(const Vector2 &p_pos) const;
|
2021-05-07 15:41:39 +02:00
|
|
|
bool is_existing_neighbor(TileSet::CellNeighbor p_cell_neighbor) const;
|
|
|
|
Vector2i get_neighbor_cell(const Vector2i &p_coords, TileSet::CellNeighbor p_cell_neighbor) const;
|
2019-07-01 22:43:52 +02:00
|
|
|
|
2021-07-28 18:10:01 +02:00
|
|
|
TypedArray<Vector2i> get_used_cells(int p_layer) const;
|
2023-01-18 13:35:58 +01:00
|
|
|
TypedArray<Vector2i> get_used_cells_by_id(int p_layer, int p_source_id = TileSet::INVALID_SOURCE, const Vector2i p_atlas_coords = TileSetSource::INVALID_ATLAS_COORDS, int p_alternative_tile = TileSetSource::INVALID_TILE_ALTERNATIVE) const;
|
2023-06-16 14:16:37 +02:00
|
|
|
Rect2i get_used_rect() const;
|
2017-02-20 22:02:03 +01:00
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Override some methods of the CanvasItem class to pass the changes to the quadrants CanvasItems.
|
2020-07-10 12:34:39 +02:00
|
|
|
virtual void set_light_mask(int p_light_mask) override;
|
2024-02-28 17:17:46 +01:00
|
|
|
virtual void set_self_modulate(const Color &p_self_modulate) override;
|
2020-02-19 22:26:24 +01:00
|
|
|
virtual void set_texture_filter(CanvasItem::TextureFilter p_texture_filter) override;
|
|
|
|
virtual void set_texture_repeat(CanvasItem::TextureRepeat p_texture_repeat) override;
|
|
|
|
|
2021-09-15 15:23:58 +02:00
|
|
|
// For finding tiles from collision.
|
|
|
|
Vector2i get_coords_for_body_rid(RID p_physics_body);
|
2023-04-19 06:22:46 +02:00
|
|
|
// For getting their layers as well.
|
|
|
|
int get_layer_for_body_rid(RID p_physics_body);
|
2021-09-15 15:23:58 +02:00
|
|
|
|
2022-02-23 17:25:50 +01:00
|
|
|
// Fixing and clearing methods.
|
2018-02-24 06:56:48 +01:00
|
|
|
void fix_invalid_tiles();
|
2021-07-28 18:10:01 +02:00
|
|
|
|
2024-03-05 13:55:23 +01:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
// Moving layers outside of TileMap.
|
|
|
|
TileMapLayer *duplicate_layer_from_internal(int p_layer);
|
|
|
|
#endif // TOOLS_ENABLED
|
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Clears tiles from a given layer.
|
2021-07-28 18:10:01 +02:00
|
|
|
void clear_layer(int p_layer);
|
2014-02-10 02:10:30 +01:00
|
|
|
void clear();
|
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Force a TileMap update.
|
2023-08-24 13:31:14 +02:00
|
|
|
void update_internals();
|
|
|
|
void notify_runtime_tile_data_update(int p_layer = -1);
|
2021-10-22 16:32:06 +02:00
|
|
|
|
|
|
|
// Helpers?
|
2024-01-19 17:25:14 +01:00
|
|
|
TypedArray<Vector2i> get_surrounding_cells(const Vector2i &p_coords);
|
2021-05-07 15:41:39 +02:00
|
|
|
|
2023-06-16 14:16:37 +02:00
|
|
|
// Virtual function to modify the TileData at runtime.
|
2021-10-22 16:32:06 +02:00
|
|
|
GDVIRTUAL2R(bool, _use_tile_data_runtime_update, int, Vector2i);
|
|
|
|
GDVIRTUAL3(_tile_data_runtime_update, int, Vector2i, TileData *);
|
|
|
|
|
2021-07-28 18:10:01 +02:00
|
|
|
// Configuration warnings.
|
2024-02-17 19:03:21 +01:00
|
|
|
PackedStringArray get_configuration_warnings() const override;
|
2021-07-28 18:10:01 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
TileMap();
|
|
|
|
~TileMap();
|
|
|
|
};
|
2021-05-24 12:33:22 +02:00
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(TileMap::VisibilityMode);
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#endif // TILE_MAP_H
|