GitHub/Super-Mario-Bros.-Remastered-Public
1
0
Fork 0
mirror of https://github.com/JHDev2006/Super-Mario-Bros.-Remastered-Public.git synced 2025-10-31 19:59:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
d4eb6e630cc4ea73c7af6f9f849ac60b61c59e67
Super-Mario-Bros.-Remastere…/addons/better-terrain/BetterTerrainData.gd
JHDev2006 3773bdaf64 added the game
2025-09-13 16:30:32 +01:00

599 lines
21 KiB
GDScript
Executable File
Raw Blame History

@tool
## Data functions for [TileSet] properties.
##
## This data class has functions for retrieving data regarding the mathematical
## properties of a tile set.
const _terrain_peering_square_tiles : Array[int] = [0, 3, 4, 7, 8, 11, 12, 15]
const _terrain_peering_square_vertices : Array[int] = [3, 7, 11, 15]
const _terrain_peering_isometric_tiles : Array[int] = [1, 2, 5, 6, 9, 10, 13, 14]
const _terrain_peering_isometric_vertices : Array[int] = [1, 5, 9, 13]
const _terrain_peering_horiztonal_tiles : Array[int] = [0, 2, 6, 8, 10, 14]
const _terrain_peering_horiztonal_vertices : Array[int] = [3, 5, 7, 11, 13, 15]
const _terrain_peering_vertical_tiles : Array[int] = [2, 4, 6, 10, 12, 14]
const _terrain_peering_vertical_vertices : Array[int] = [1, 3, 7, 9, 11, 15]
const _terrain_peering_non_modifying : Array[int] = []
const _terrain_peering_hflip : Array[int] = [8, 9, 6, 7, 4, 5, 2, 3, 0, 1, 14, 15, 12, 13, 10, 11]
const _terrain_peering_vflip : Array[int] = [0, 1, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3]
const _terrain_peering_transpose : Array[int] = [4, 5, 2, 3, 0, 1, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7]
const symmetry_mapping := {
BetterTerrain.SymmetryType.NONE: [0],
BetterTerrain.SymmetryType.MIRROR: [0, TileSetAtlasSource.TRANSFORM_FLIP_H],
BetterTerrain.SymmetryType.FLIP: [0, TileSetAtlasSource.TRANSFORM_FLIP_V],
BetterTerrain.SymmetryType.REFLECT: [
0,
TileSetAtlasSource.TRANSFORM_FLIP_H,
TileSetAtlasSource.TRANSFORM_FLIP_V,
TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_FLIP_V
],
BetterTerrain.SymmetryType.ROTATE_CLOCKWISE: [0, TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_TRANSPOSE],
BetterTerrain.SymmetryType.ROTATE_COUNTER_CLOCKWISE: [0, TileSetAtlasSource.TRANSFORM_FLIP_V | TileSetAtlasSource.TRANSFORM_TRANSPOSE],
BetterTerrain.SymmetryType.ROTATE_180: [0, TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_FLIP_V],
BetterTerrain.SymmetryType.ROTATE_ALL: [
0,
TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_TRANSPOSE,
TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_FLIP_V,
TileSetAtlasSource.TRANSFORM_FLIP_V | TileSetAtlasSource.TRANSFORM_TRANSPOSE
],
BetterTerrain.SymmetryType.ALL: [
0,
TileSetAtlasSource.TRANSFORM_FLIP_H,
TileSetAtlasSource.TRANSFORM_FLIP_V,
TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_FLIP_V,
TileSetAtlasSource.TRANSFORM_TRANSPOSE,
TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_TRANSPOSE,
TileSetAtlasSource.TRANSFORM_FLIP_V | TileSetAtlasSource.TRANSFORM_TRANSPOSE,
TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_FLIP_V | TileSetAtlasSource.TRANSFORM_TRANSPOSE
]
}
## Returns an [Array] of ints of type [enum TileSet.CellNeighbor] which represent
## the valid neighboring tiles for a terrain of [code]type[/code] in TileSet
static func get_terrain_peering_cells(ts: TileSet, type: int) -> Array[int]:
if !ts or type < 0 or type >= BetterTerrain.TerrainType.MAX:
return []
if type == BetterTerrain.TerrainType.CATEGORY:
return _terrain_peering_non_modifying
if type == BetterTerrain.TerrainType.DECORATION:
type = BetterTerrain.TerrainType.MATCH_TILES
match [ts.tile_shape, type]:
[TileSet.TILE_SHAPE_SQUARE, BetterTerrain.TerrainType.MATCH_TILES]:
return _terrain_peering_square_tiles
[TileSet.TILE_SHAPE_SQUARE, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _terrain_peering_square_vertices
[TileSet.TILE_SHAPE_ISOMETRIC, BetterTerrain.TerrainType.MATCH_TILES]:
return _terrain_peering_isometric_tiles
[TileSet.TILE_SHAPE_ISOMETRIC, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _terrain_peering_isometric_vertices
match [ts.tile_offset_axis, type]:
[TileSet.TILE_OFFSET_AXIS_VERTICAL, BetterTerrain.TerrainType.MATCH_TILES]:
return _terrain_peering_vertical_tiles
[TileSet.TILE_OFFSET_AXIS_VERTICAL, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _terrain_peering_vertical_vertices
[TileSet.TILE_OFFSET_AXIS_HORIZONTAL, BetterTerrain.TerrainType.MATCH_TILES]:
return _terrain_peering_horiztonal_tiles
[TileSet.TILE_OFFSET_AXIS_HORIZONTAL, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _terrain_peering_horiztonal_vertices
return []
## Returns true if [code]peering[/code] is a valid neighboring cell for a terrain of
## [code]type[/code] in [TileSet]
static func is_terrain_peering_cell(ts: TileSet, type: int, peering: int) -> bool:
return peering in get_terrain_peering_cells(ts, type)
static func _peering_polygon_square_tiles(peering: int) -> PackedVector2Array:
const t := 1.0 / 3.0
var result : PackedVector2Array
match peering:
TileSet.CELL_NEIGHBOR_RIGHT_SIDE: result.append(Vector2(2*t, t))
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER: result.append(Vector2(2*t, 2*t))
TileSet.CELL_NEIGHBOR_BOTTOM_SIDE: result.append(Vector2(t, 2*t))
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_CORNER: result.append(Vector2(0, 2*t))
TileSet.CELL_NEIGHBOR_LEFT_SIDE: result.append(Vector2(0, t))
TileSet.CELL_NEIGHBOR_TOP_LEFT_CORNER: result.append(Vector2(0, 0))
TileSet.CELL_NEIGHBOR_TOP_SIDE: result.append(Vector2(t, 0))
TileSet.CELL_NEIGHBOR_TOP_RIGHT_CORNER: result.append(Vector2(2*t, 0))
-1: result.append(Vector2(t, t))
result.append(result[0] + Vector2(t, 0))
result.append(result[0] + Vector2(t, t))
result.append(result[0] + Vector2(0, t))
return result
static func _peering_polygon_square_vertices(peering: int) -> PackedVector2Array:
const t := 1.0 / 2.0
var result : PackedVector2Array
match peering:
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
result.append(Vector2(1, t))
result.append(Vector2(1, 1))
result.append(Vector2(t, 1))
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
result.append(Vector2(0, t))
result.append(Vector2(t, 1))
result.append(Vector2(0, 1))
TileSet.CELL_NEIGHBOR_TOP_LEFT_CORNER:
result.append(Vector2(0, 0))
result.append(Vector2(t, 0))
result.append(Vector2(0, t))
TileSet.CELL_NEIGHBOR_TOP_RIGHT_CORNER:
result.append(Vector2(t, 0))
result.append(Vector2(1, 0))
result.append(Vector2(1, t))
-1:
result.append(Vector2(t, 0))
result.append(Vector2(1, t))
result.append(Vector2(t, 1))
result.append(Vector2(0, t))
return result
static func _peering_polygon_isometric_tiles(peering: int) -> PackedVector2Array:
const t := 1.0 / 4.0
match peering:
-1: return PackedVector2Array([Vector2(2 * t, t), Vector2(3 * t, 2 * t), Vector2(2 * t, 3 * t), Vector2(t, 2 * t)])
TileSet.CELL_NEIGHBOR_RIGHT_CORNER:
return PackedVector2Array([Vector2(3 * t, 2 * t), Vector2(1, t), Vector2(1, 3 * t)])
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
return PackedVector2Array([Vector2(3 * t, 2 * t), Vector2(1, 3 * t), Vector2(3 * t, 1), Vector2(2 * t, 3 * t)])
TileSet.CELL_NEIGHBOR_BOTTOM_CORNER:
return PackedVector2Array([Vector2(2 * t, 3 * t), Vector2(3 * t, 1), Vector2(t, 1)])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
return PackedVector2Array([Vector2(t, 2 * t), Vector2(2 * t, 3 * t), Vector2(t, 1), Vector2(0, 3 * t)])
TileSet.CELL_NEIGHBOR_LEFT_CORNER:
return PackedVector2Array([Vector2(0, t), Vector2(t, 2 * t), Vector2(0, 3 * t)])
TileSet.CELL_NEIGHBOR_TOP_LEFT_SIDE:
return PackedVector2Array([Vector2(t, 0), Vector2(2 * t, t), Vector2(t, 2 * t), Vector2(0, t)])
TileSet.CELL_NEIGHBOR_TOP_CORNER:
return PackedVector2Array([Vector2(t, 0), Vector2(3 * t, 0), Vector2(2 * t, t)])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_SIDE:
return PackedVector2Array([Vector2(3 * t, 0), Vector2(1, t), Vector2(3 * t, 2 * t), Vector2(2 * t, t)])
return PackedVector2Array()
static func _peering_polygon_isometric_vertices(peering: int) -> PackedVector2Array:
const t := 1.0 / 4.0
const ttt := 3.0 * t
match peering:
-1: return PackedVector2Array([Vector2(t, t), Vector2(ttt, t), Vector2(ttt, ttt), Vector2(t, ttt)])
TileSet.CELL_NEIGHBOR_RIGHT_CORNER:
return PackedVector2Array([Vector2(ttt, t), Vector2(1, 0), Vector2(1, 1), Vector2(ttt, ttt)])
TileSet.CELL_NEIGHBOR_BOTTOM_CORNER:
return PackedVector2Array([Vector2(t, ttt), Vector2(ttt, ttt), Vector2(1, 1), Vector2(0, 1)])
TileSet.CELL_NEIGHBOR_LEFT_CORNER:
return PackedVector2Array([Vector2(0, 0), Vector2(t, t), Vector2(t, ttt), Vector2(0, 1)])
TileSet.CELL_NEIGHBOR_TOP_CORNER:
return PackedVector2Array([Vector2(0, 0), Vector2(1, 0), Vector2(ttt, t), Vector2(t, t)])
return PackedVector2Array()
static func _peering_polygon_horizontal_tiles(peering: int) -> PackedVector2Array:
const e := 1.0 / (2.0 * sqrt(3.0))
const w := sqrt(3.0) / 8.0
const t := 1.0 / 2.0
const s := 1.0 / 8.0
match peering:
-1:
return PackedVector2Array([
Vector2(t, 2 * s),
Vector2(t + w, t - s),
Vector2(t + w, t + s),
Vector2(t, 6 * s),
Vector2(t - w, t + s),
Vector2(t - w, t - s)
])
TileSet.CELL_NEIGHBOR_RIGHT_SIDE:
return PackedVector2Array([
Vector2(t + w, t - s),
Vector2(1, t - e),
Vector2(1, t + e),
Vector2(t + w, t + s)
])
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
return PackedVector2Array([
Vector2(t + w, t + s),
Vector2(1, t + e),
Vector2(t, 1),
Vector2(t, 6 * s)
])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
return PackedVector2Array([
Vector2(t, 6 * s),
Vector2(t, 1),
Vector2(0, t + e),
Vector2(t - w, t + s)
])
TileSet.CELL_NEIGHBOR_LEFT_SIDE:
return PackedVector2Array([
Vector2(t - w, t + s),
Vector2(0, t + e),
Vector2(0, t - e),
Vector2(t - w, t - s)
])
TileSet.CELL_NEIGHBOR_TOP_LEFT_SIDE:
return PackedVector2Array([
Vector2(t - w, t - s),
Vector2(0, t - e),
Vector2(t, 0),
Vector2(t, 2 * s)
])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_SIDE:
return PackedVector2Array([
Vector2(t, 2 * s),
Vector2(t, 0),
Vector2(1, t - e),
Vector2(t + w, t - s)
])
return PackedVector2Array()
static func _peering_polygon_horizontal_vertices(peering: int) -> PackedVector2Array:
const e := 1.0 / (2.0 * sqrt(3.0))
const w := sqrt(3.0) / 8.0
const t := 1.0 / 2.0
const s := 1.0 / 8.0
match peering:
-1:
return PackedVector2Array([
Vector2(t - s, t - w),
Vector2(t + s, t - w),
Vector2(6 * s, t),
Vector2(t + s, t + w),
Vector2(t - s, t + w),
Vector2(2 * s, t)
])
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
return PackedVector2Array([
Vector2(6 * s, t),
Vector2(1, t),
Vector2(1, t + e),
Vector2(t + e, 1 - s),
Vector2(t + s, t + w)
])
TileSet.CELL_NEIGHBOR_BOTTOM_CORNER:
return PackedVector2Array([
Vector2(t - s, t + w),
Vector2(t + s, t + w),
Vector2(t + e, 1 - s),
Vector2(t, 1),
Vector2(t - e, 1 - s)
])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
return PackedVector2Array([
Vector2(0, t),
Vector2(2 * s, t),
Vector2(t - s, t + w),
Vector2(t - e, 1 - s),
Vector2(0, t + e)
])
TileSet.CELL_NEIGHBOR_TOP_LEFT_CORNER:
return PackedVector2Array([
Vector2(t - e, s),
Vector2(t - s, t - w),
Vector2(2 * s, t),
Vector2(0, t),
Vector2(0, t - e)
])
TileSet.CELL_NEIGHBOR_TOP_CORNER:
return PackedVector2Array([
Vector2(t, 0),
Vector2(t + e, s),
Vector2(t + s, t - w),
Vector2(t - s, t - w),
Vector2(t - e, s)
])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_CORNER:
return PackedVector2Array([
Vector2(t + e, s),
Vector2(1, t - e),
Vector2(1, t),
Vector2(6 * s, t),
Vector2(t + s, t - w)
])
return PackedVector2Array()
static func _peering_polygon_vertical_tiles(peering: int) -> PackedVector2Array:
const e := 1.0 / (2.0 * sqrt(3.0))
const w := sqrt(3.0) / 8.0
const t := 1.0 / 2.0
const s := 1.0 / 8.0
match peering:
-1:
return PackedVector2Array([
Vector2(t - s, t - w),
Vector2(t + s, t - w),
Vector2(6 * s, t),
Vector2(t + s, t + w),
Vector2(t - s, t + w),
Vector2(2 * s, t)
])
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
return PackedVector2Array([
Vector2(6 * s, t),
Vector2(1, t),
Vector2(t + e, 1),
Vector2(t + s, t + w)
])
TileSet.CELL_NEIGHBOR_BOTTOM_SIDE:
return PackedVector2Array([
Vector2(t - s, t + w),
Vector2(t + s, t + w),
Vector2(t + e, 1),
Vector2(t - e, 1)
])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
return PackedVector2Array([
Vector2(0, t),
Vector2(2 * s, t),
Vector2(t - s, t + w),
Vector2(t - e, 1)
])
TileSet.CELL_NEIGHBOR_TOP_LEFT_SIDE:
return PackedVector2Array([
Vector2(t - e, 0),
Vector2(t - s, t - w),
Vector2(2 * s, t),
Vector2(0, t)
])
TileSet.CELL_NEIGHBOR_TOP_SIDE:
return PackedVector2Array([
Vector2(t - e, 0),
Vector2(t + e, 0),
Vector2(t + s, t - w),
Vector2(t - s, t - w)
])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_SIDE:
return PackedVector2Array([
Vector2(t + e, 0),
Vector2(1, t),
Vector2(6 * s, t),
Vector2(t + s, t - w)
])
return PackedVector2Array()
static func _peering_polygon_vertical_vertices(peering: int) -> PackedVector2Array:
const e := 1.0 / (2.0 * sqrt(3.0))
const w := sqrt(3.0) / 8.0
const t := 1.0 / 2.0
const s := 1.0 / 8.0
match peering:
-1:
return PackedVector2Array([
Vector2(t, 2 * s),
Vector2(t + w, t - s),
Vector2(t + w, t + s),
Vector2(t, 6 * s),
Vector2(t - w, t + s),
Vector2(t - w, t - s)
])
TileSet.CELL_NEIGHBOR_RIGHT_CORNER:
return PackedVector2Array([
Vector2(1 - s, t - e),
Vector2(1, t),
Vector2(1 - s, t + e),
Vector2(t + w, t + s),
Vector2(t + w, t - s)
])
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
return PackedVector2Array([
Vector2(t + w, t + s),
Vector2(1 - s, t + e),
Vector2(t + e, 1),
Vector2(t, 1),
Vector2(t, 6 * s)
])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
return PackedVector2Array([
Vector2(t - w, t + s),
Vector2(t, 6 * s),
Vector2(t, 1),
Vector2(t - e, 1),
Vector2(s, t + e)
])
TileSet.CELL_NEIGHBOR_LEFT_CORNER:
return PackedVector2Array([
Vector2(s, t - e),
Vector2(t - w, t - s),
Vector2(t - w, t + s),
Vector2(s, t + e),
Vector2(0, t)
])
TileSet.CELL_NEIGHBOR_TOP_LEFT_CORNER:
return PackedVector2Array([
Vector2(t - e, 0),
Vector2(t, 0),
Vector2(t, 2 * s),
Vector2(t - w, t - s),
Vector2(s, t - e)
])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_CORNER:
return PackedVector2Array([
Vector2(t, 0),
Vector2(t + e, 0),
Vector2(1 - s, t - e),
Vector2(t + w, t - s),
Vector2(t, 2 * s)
])
return PackedVector2Array()
static func _peering_non_modifying() -> PackedVector2Array:
const t := 1.0 / 3.0
return PackedVector2Array([
Vector2(t, 0),
Vector2(2 * t, 0),
Vector2(1, t),
Vector2(1, 2 * t),
Vector2(2 * t, 1),
Vector2(t, 1),
Vector2(0, 2 * t),
Vector2(0, t)
])
## Returns a parameterized polygon (coordinated are between 0 and 1) for [code]peering[/code]
## direction for a terrain of [code]type[/code] in [TileSet]
static func peering_polygon(ts: TileSet, type: int, peering: int) -> PackedVector2Array:
if type == BetterTerrain.TerrainType.CATEGORY:
return _peering_non_modifying()
if type == BetterTerrain.TerrainType.DECORATION:
type = BetterTerrain.TerrainType.MATCH_TILES
match [ts.tile_shape, type]:
[TileSet.TILE_SHAPE_SQUARE, BetterTerrain.TerrainType.MATCH_TILES]:
return _peering_polygon_square_tiles(peering)
[TileSet.TILE_SHAPE_SQUARE, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _peering_polygon_square_vertices(peering)
[TileSet.TILE_SHAPE_ISOMETRIC, BetterTerrain.TerrainType.MATCH_TILES]:
return _peering_polygon_isometric_tiles(peering)
[TileSet.TILE_SHAPE_ISOMETRIC, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _peering_polygon_isometric_vertices(peering)
match [ts.tile_offset_axis, type]:
[TileSet.TILE_OFFSET_AXIS_VERTICAL, BetterTerrain.TerrainType.MATCH_TILES]:
return _peering_polygon_vertical_tiles(peering)
[TileSet.TILE_OFFSET_AXIS_VERTICAL, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _peering_polygon_vertical_vertices(peering)
[TileSet.TILE_OFFSET_AXIS_HORIZONTAL, BetterTerrain.TerrainType.MATCH_TILES]:
return _peering_polygon_horizontal_tiles(peering)
[TileSet.TILE_OFFSET_AXIS_HORIZONTAL, BetterTerrain.TerrainType.MATCH_VERTICES]:
return _peering_polygon_horizontal_vertices(peering)
return PackedVector2Array()
## Returns as polygon centered on 0, 0 which represents the shape of the cell of
## a tile from [TileSet].
static func cell_polygon(ts: TileSet) -> PackedVector2Array:
const t := 1.0 / 2.0
if ts.tile_shape in [TileSet.TILE_SHAPE_SQUARE, TileSet.TILE_SHAPE_HALF_OFFSET_SQUARE]:
return PackedVector2Array([Vector2(-t, -t), Vector2(t, -t), Vector2(t, t), Vector2(-t, t)])
if ts.tile_shape == TileSet.TILE_SHAPE_ISOMETRIC:
return PackedVector2Array([Vector2(0, -t), Vector2(t, 0), Vector2(0, t), Vector2(-t, 0)])
const e := t - 1.0 / (2.0 * sqrt(3.0))
if ts.tile_offset_axis == TileSet.TILE_OFFSET_AXIS_HORIZONTAL:
return PackedVector2Array([
Vector2(0, -t),
Vector2(t, -e),
Vector2(t, e),
Vector2(0, t),
Vector2(-t, e),
Vector2(-t, -e),
])
return PackedVector2Array([
Vector2(-t, 0),
Vector2(-e, -t),
Vector2(e, -t),
Vector2(t, 0),
Vector2(e, t),
Vector2(-e, t),
])
## Returns an [Array] of coordinated that neighbor [code]coord[/code] based on [code]peering[/code]
## [Array] of [enum TileSet.CellNeighbor] for a [TileSet].
static func neighboring_coords(tm: TileMapLayer, coord: Vector2i, peerings: Array) -> Array:
return peerings.map(func(p): return tm.get_neighbor_cell(coord, p))
## Returns an [Array] of coordinates which neighbor the vertex describe by [code]corner[/code]
## (which is of type [enum TileSet.CellNeighbor]) from [code]coord[/code] in [TileSet].
static func associated_vertex_cells(tm: TileMapLayer, coord: Vector2i, corner: int) -> Array:
# get array of associated peering bits
if tm.tile_set.tile_shape in [TileSet.TILE_SHAPE_SQUARE, TileSet.TILE_SHAPE_ISOMETRIC]:
match corner:
# Square
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
return neighboring_coords(tm, coord, [0, 3, 4])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
return neighboring_coords(tm, coord, [4, 7, 8])
TileSet.CELL_NEIGHBOR_TOP_LEFT_CORNER:
return neighboring_coords(tm, coord, [8, 11, 12])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_CORNER:
return neighboring_coords(tm, coord, [12, 15, 0])
# Isometric
TileSet.CELL_NEIGHBOR_RIGHT_CORNER:
return neighboring_coords(tm, coord, [14, 1, 2])
TileSet.CELL_NEIGHBOR_BOTTOM_CORNER:
return neighboring_coords(tm, coord, [2, 5, 6])
TileSet.CELL_NEIGHBOR_LEFT_CORNER:
return neighboring_coords(tm, coord, [6, 9, 10])
TileSet.CELL_NEIGHBOR_TOP_CORNER:
return neighboring_coords(tm, coord, [10, 13, 14])
if tm.tile_set.tile_offset_axis == TileSet.TILE_OFFSET_AXIS_HORIZONTAL:
match corner:
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
return neighboring_coords(tm, coord, [0, 2])
TileSet.CELL_NEIGHBOR_BOTTOM_CORNER:
return neighboring_coords(tm, coord, [2, 6])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
return neighboring_coords(tm, coord, [6, 8])
TileSet.CELL_NEIGHBOR_TOP_LEFT_CORNER:
return neighboring_coords(tm, coord, [8, 10])
TileSet.CELL_NEIGHBOR_TOP_CORNER:
return neighboring_coords(tm, coord, [10, 14])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_CORNER:
return neighboring_coords(tm, coord, [14, 0])
# TileSet.TILE_OFFSET_AXIS_VERTICAL
match corner:
TileSet.CELL_NEIGHBOR_RIGHT_CORNER:
return neighboring_coords(tm, coord, [14, 2])
TileSet.CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
return neighboring_coords(tm, coord, [2, 4])
TileSet.CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
return neighboring_coords(tm, coord, [4, 6])
TileSet.CELL_NEIGHBOR_LEFT_CORNER:
return neighboring_coords(tm, coord, [6, 10])
TileSet.CELL_NEIGHBOR_TOP_LEFT_CORNER:
return neighboring_coords(tm, coord, [10, 12])
TileSet.CELL_NEIGHBOR_TOP_RIGHT_CORNER:
return neighboring_coords(tm, coord, [12, 14])
return []
## Returns an [Array] of [enum TileSet.CellNeighbor] suitable for flood filling
## an area in [TileSet].
static func cells_adjacent_for_fill(ts: TileSet) -> Array[int]:
if ts.tile_shape == TileSet.TILE_SHAPE_SQUARE:
return [0, 4, 8, 12]
if ts.tile_shape == TileSet.TILE_SHAPE_ISOMETRIC:
return [2, 6, 10, 14]
if ts.tile_offset_axis == TileSet.TILE_OFFSET_AXIS_HORIZONTAL:
return _terrain_peering_horiztonal_tiles
return _terrain_peering_vertical_tiles
static func peering_bit_after_symmetry(bit: int, altflags: int) -> int:
if altflags & TileSetAtlasSource.TRANSFORM_TRANSPOSE:
bit = _terrain_peering_transpose[bit]
if altflags & TileSetAtlasSource.TRANSFORM_FLIP_H:
bit = _terrain_peering_hflip[bit]
if altflags & TileSetAtlasSource.TRANSFORM_FLIP_V:
bit = _terrain_peering_vflip[bit]
return bit
static func peering_bits_after_symmetry(dict: Dictionary, altflags: int) -> Dictionary:
# rearrange dictionary keys based on altflags
var result := {}
for k in dict:
result[peering_bit_after_symmetry(k, altflags)] = dict[k]
return result
Reference in New Issue View Git Blame Copy Permalink