382 lines
10 KiB
GDScript
382 lines
10 KiB
GDScript
@tool
|
|
extends Control
|
|
class_name AreaDraw
|
|
|
|
signal connect_mode_toggled(toggled : bool)
|
|
|
|
enum Shape {
|
|
RECTANGLE,
|
|
SLOPE_TL,
|
|
SLOPE_TR,
|
|
SLOPE_BR,
|
|
SLOPE_BL,
|
|
HARD_RECTANGLE,
|
|
HILL_TOP,
|
|
HILL_BOTTOM,
|
|
HILL_RIGHT,
|
|
HILL_LEFT,
|
|
ISLAND,
|
|
RECTANGLE_BASIC
|
|
}
|
|
var shape := Shape.RECTANGLE_BASIC
|
|
var preview_container : GridContainer
|
|
|
|
const TL := Vector2i(3, 0)
|
|
const TR := Vector2i(5, 0)
|
|
const TM := Vector2i(4, 0)
|
|
const BL := Vector2i(3, 2)
|
|
const BR := Vector2i(5, 2)
|
|
const BM := Vector2i(4, 2)
|
|
const LM := Vector2i(3, 1)
|
|
const RM := Vector2i(5, 1)
|
|
const CM := Vector2i(4, 1)
|
|
const XX := null
|
|
|
|
const SHAPE_MAP := {
|
|
Shape.RECTANGLE_BASIC: [
|
|
[CM, CM, CM, CM, CM],
|
|
[CM, CM, CM, CM, CM],
|
|
[CM, CM, CM, CM, CM],
|
|
[CM, CM, CM, CM, CM],
|
|
[CM, CM, CM, CM, CM],
|
|
],
|
|
Shape.RECTANGLE: [
|
|
[TL, TM, TM, TM, TR],
|
|
[LM, CM, CM, CM, RM],
|
|
[LM, CM, CM, CM, RM],
|
|
[BL, BM, BM, BM, BR],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.SLOPE_TL: [
|
|
[XX, XX, XX, TL, TM],
|
|
[XX, XX, TL, CM, CM],
|
|
[XX, TL, CM, CM, CM],
|
|
[TL, CM, CM, CM, CM],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.SLOPE_TR: [
|
|
[TM, TR, XX, XX, XX],
|
|
[CM, CM, TR, XX, XX],
|
|
[CM, CM, CM, TR, XX],
|
|
[CM, CM, CM, CM, TR],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.SLOPE_BR: [
|
|
[CM, CM, CM, CM, BR],
|
|
[CM, CM, CM, BR, XX],
|
|
[CM, CM, BR, XX, XX],
|
|
[BM, BR, XX, XX, XX],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.SLOPE_BL: [
|
|
[BL, CM, CM, CM, CM],
|
|
[XX, BL, CM, CM, CM],
|
|
[XX, XX, BL, CM, CM],
|
|
[XX, XX, XX, BL, BM],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.HARD_RECTANGLE: [
|
|
[TM, TM, TM, TM, TM],
|
|
[LM, CM, CM, CM, RM],
|
|
[LM, CM, CM, CM, RM],
|
|
[BM, BM, BM, BM, BM],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.HILL_TOP: [
|
|
[XX, TL, TM, TR, XX],
|
|
[TL, CM, CM, CM, TR],
|
|
[LM, CM, CM, CM, RM],
|
|
[LM, CM, CM, CM, RM],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.HILL_BOTTOM: [
|
|
[LM, CM, CM, CM, RM],
|
|
[LM, CM, CM, CM, RM],
|
|
[BL, CM, CM, CM, BR],
|
|
[XX, BL, BM, BR, XX],
|
|
[XX, XX, XX, XX, XX],
|
|
],
|
|
Shape.HILL_LEFT: [
|
|
[XX, TL, TM, TM, TM],
|
|
[TL, CM, CM, CM, CM],
|
|
[LM, CM, CM, CM, CM],
|
|
[BL, CM, CM, CM, CM],
|
|
[XX, BL, BM, BM, BM],
|
|
],
|
|
Shape.HILL_RIGHT: [
|
|
[TM, TM, TM, TR, XX],
|
|
[CM, CM, CM, CM, TR],
|
|
[CM, CM, CM, CM, RM],
|
|
[CM, CM, CM, CM, BR],
|
|
[BM, BM, BM, BR, XX],
|
|
],
|
|
Shape.ISLAND: [
|
|
[XX, TL, TM, TR, XX],
|
|
[TL, CM, CM, CM, TR],
|
|
[CM, CM, CM, CM, RM],
|
|
[BL, CM, CM, CM, BR],
|
|
[XX, BL, BM, BR, XX],
|
|
],
|
|
}
|
|
|
|
var cur_terrain_texture : Texture2D
|
|
var cur_tile_size : Vector2i
|
|
var connect_terrains_button : Button
|
|
var tile_button : Button
|
|
|
|
|
|
func _enter_tree() -> void:
|
|
preview_container = find_child("PreviewGridContainer")
|
|
connect_terrains_button = find_child("ConnectTerrainsButton")
|
|
tile_button = find_child("TileButton1")
|
|
|
|
|
|
func _get_empty_tex(tile_size : Vector2i) -> Texture2D:
|
|
var plc_tex := GradientTexture2D.new()
|
|
plc_tex.width = tile_size.x
|
|
plc_tex.height = tile_size.y
|
|
plc_tex.gradient = Gradient.new()
|
|
plc_tex.gradient.colors = [Color.TRANSPARENT]
|
|
return plc_tex
|
|
|
|
|
|
func update_grid_preview(terrain_texture : Texture2D = cur_terrain_texture, tile_size : Vector2i = cur_tile_size):
|
|
tile_button.icon = AtlasTexture.new()
|
|
tile_button.icon.atlas = terrain_texture
|
|
tile_button.icon.region = Rect2i(CM * tile_size, tile_size)
|
|
cur_terrain_texture = terrain_texture
|
|
cur_tile_size = tile_size
|
|
var i := 0
|
|
for y in range(SHAPE_MAP[shape].size()):
|
|
for x in range(SHAPE_MAP[shape][y].size()):
|
|
var tex_rect : TextureRect = preview_container.get_child(i)
|
|
i += 1
|
|
if not is_instance_valid(tex_rect):
|
|
continue
|
|
if SHAPE_MAP[shape][y][x] == null:
|
|
tex_rect.texture = _get_empty_tex(tile_size)
|
|
continue
|
|
var atlas_texture : AtlasTexture = tex_rect.texture if tex_rect.texture is AtlasTexture else AtlasTexture.new()
|
|
atlas_texture.atlas = terrain_texture
|
|
atlas_texture.region = Rect2i(SHAPE_MAP[shape][y][x] * tile_size, tile_size)
|
|
tex_rect.texture = atlas_texture
|
|
|
|
|
|
static func get_cells_rectangle_basic(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var cells := {}
|
|
for x in range(p1.x, p2.x + 1):
|
|
for y in range(p1.y, p2.y + 1):
|
|
cells[Vector2i(x, y)] = CM
|
|
return cells
|
|
|
|
|
|
static func get_cells_rectangle(p1 : Vector2i, p2 : Vector2i, soft := false) -> Dictionary:
|
|
var cells := {}
|
|
for x in range(p1.x, p2.x + 1):
|
|
for y in range(p1.y, p2.y + 1):
|
|
if x == p1.x and y == p1.y and soft:
|
|
cells[Vector2i(x, y)] = TL
|
|
elif x == p2.x and y == p1.y and soft:
|
|
cells[Vector2i(x, y)] = TR
|
|
elif x == p1.x and y == p2.y and soft:
|
|
cells[Vector2i(x, y)] = BL
|
|
elif x == p2.x and y == p2.y and soft:
|
|
cells[Vector2i(x, y)] = BR
|
|
elif x == p2.x and y > p1.y and y < p2.y:
|
|
cells[Vector2i(x, y)] = RM
|
|
elif x == p1.x and y > p1.y and y < p2.y:
|
|
cells[Vector2i(x, y)] = LM
|
|
elif y == p2.y:
|
|
cells[Vector2i(x, y)] = BM
|
|
elif y == p1.y:
|
|
cells[Vector2i(x, y)] = TM
|
|
else:
|
|
cells[Vector2i(x, y)] = CM
|
|
return cells
|
|
|
|
|
|
static func get_cells_slope_tl(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var cells := {}
|
|
var width := p2.x - p1.x + 1
|
|
var height := p2.y - p1.y + 1
|
|
var sq_siz := min(width, height)
|
|
for y : int in range(sq_siz):
|
|
var range_start = sq_siz - y - 1 if sq_siz - y - 1 > 0 else 0
|
|
for x in range(range_start, sq_siz):
|
|
cells[Vector2i(p1.x + x, p1.y + y)] = TL if x == range_start else CM
|
|
if width > sq_siz:
|
|
for x in range(sq_siz, width):
|
|
for y in range(height):
|
|
cells[Vector2i(p1.x + x, p1.y + y)] = TM if y == 0 else CM
|
|
else:
|
|
for y in range(sq_siz, height):
|
|
for x in range(width):
|
|
cells[Vector2i(p1.x + x, p1.y + y)] = LM if x == 0 else CM
|
|
return cells
|
|
|
|
static func get_cells_slope_tr(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var cells := {}
|
|
var width := p2.x - p1.x + 1
|
|
var height := p2.y - p1.y + 1
|
|
var sq_siz := min(width, height)
|
|
for y : int in range(sq_siz):
|
|
var range_start = sq_siz - y - 1 if sq_siz - y - 1 > 0 else 0
|
|
for x in range(range_start, sq_siz):
|
|
cells[Vector2i(p1.x + (width-x-1), p1.y + y)] = TR if x == range_start else CM
|
|
if width > sq_siz:
|
|
for x in range(sq_siz, width):
|
|
for y in range(height):
|
|
cells[Vector2i(p1.x + (width-x-1), p1.y + y)] = TM if y == 0 else CM
|
|
else:
|
|
for y in range(sq_siz, height):
|
|
for x in range(width):
|
|
cells[Vector2i(p1.x + (width-x-1), p1.y + y)] = RM if x == 0 else CM
|
|
return cells
|
|
|
|
static func get_cells_slope_bl(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var cells := {}
|
|
var width := p2.x - p1.x + 1
|
|
var height := p2.y - p1.y + 1
|
|
var sq_siz := min(width, height)
|
|
for y : int in range(sq_siz):
|
|
var range_start = sq_siz - y - 1 if sq_siz - y - 1 > 0 else 0
|
|
for x in range(range_start, sq_siz):
|
|
cells[Vector2i(p1.x + x, p1.y + (height - y - 1))] = BL if x == range_start else CM
|
|
if width > sq_siz:
|
|
for x in range(sq_siz, width):
|
|
for y in range(height):
|
|
cells[Vector2i(p1.x + x, p1.y + (height - y - 1))] = BM if y == 0 else CM
|
|
else:
|
|
for y in range(sq_siz, height):
|
|
for x in range(width):
|
|
cells[Vector2i(p1.x + x, p1.y + (height - y - 1))] = LM if x == 0 else CM
|
|
return cells
|
|
|
|
static func get_cells_slope_br(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var cells := {}
|
|
var width := p2.x - p1.x + 1
|
|
var height := p2.y - p1.y + 1
|
|
var sq_siz := min(width, height)
|
|
for y : int in range(sq_siz):
|
|
var range_start = sq_siz - y - 1 if sq_siz - y - 1 > 0 else 0
|
|
for x in range(range_start, sq_siz):
|
|
cells[Vector2i(p1.x + (width-x-1), p1.y + (height - y - 1))] = BR if x == range_start else CM
|
|
if width > sq_siz:
|
|
for x in range(sq_siz, width):
|
|
for y in range(height):
|
|
cells[Vector2i(p1.x + (width-x-1), p1.y + (height - y - 1))] = BM if y == 0 else CM
|
|
else:
|
|
for y in range(sq_siz, height):
|
|
for x in range(width):
|
|
cells[Vector2i(p1.x + (width-x-1), p1.y + (height - y - 1))] = RM if x == 0 else CM
|
|
return cells
|
|
|
|
static func get_cells_hill_top(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var width := p2.x - p1.x
|
|
var height := p2.y - p1.y
|
|
var out = get_cells_slope_tl(p1, p1 + Vector2i(ceil(width / 2.0) - 1, height))
|
|
out.merge(get_cells_slope_tr(p1 + Vector2i(ceil(width / 2.0), 0), p2))
|
|
return out
|
|
|
|
|
|
static func get_cells_hill_bottom(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var width := p2.x - p1.x
|
|
var height := p2.y - p1.y
|
|
var out = get_cells_slope_bl(p1, p1 + Vector2i(ceil(width / 2.0) - 1, height))
|
|
out.merge(get_cells_slope_br(p1 + Vector2i(ceil(width / 2.0), 0), p2))
|
|
return out
|
|
|
|
static func get_cells_hill_left(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var width := p2.x - p1.x
|
|
var height := p2.y - p1.y
|
|
var out = get_cells_slope_tl(p1, p1 + Vector2i(width, ceil(height / 2.0) - 1))
|
|
out.merge(get_cells_slope_bl(p1 + Vector2i(0, ceil(height / 2.0)), p2))
|
|
return out
|
|
|
|
|
|
static func get_cells_hill_right(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var width := p2.x - p1.x
|
|
var height := p2.y - p1.y
|
|
var out = get_cells_slope_tr(p1, p1 + Vector2i(width, ceil(height / 2.0) - 1))
|
|
out.merge(get_cells_slope_br(p1 + Vector2i(0, ceil(height / 2.0)), p2))
|
|
return out
|
|
|
|
|
|
static func get_cells_island(p1 : Vector2i, p2 : Vector2i) -> Dictionary:
|
|
var width := p2.x - p1.x
|
|
var height := p2.y - p1.y
|
|
var out = get_cells_slope_tl(p1, p1 + Vector2i(ceil(width / 2.0) - 1, ceil(height / 2.0) - 1))
|
|
out.merge(get_cells_slope_tr(p1 + Vector2i(ceil(width / 2.0), 0), Vector2i(p2.x, p1.y + ceil(height / 2.0) - 1)))
|
|
out.merge(get_cells_slope_bl(p1 + Vector2i(0, ceil(height / 2.0)), Vector2i(p1.x + ceil(width / 2.0) - 1, p2.y)))
|
|
out.merge(get_cells_slope_br(p1 + Vector2i(ceil(width / 2.0), ceil(height / 2.0)), p2), true)
|
|
return out
|
|
|
|
|
|
|
|
func _on_connect_terrains_button_pressed() -> void:
|
|
connect_mode_toggled.emit(true)
|
|
|
|
|
|
func _on_tile_button_1_pressed() -> void:
|
|
connect_mode_toggled.emit(false)
|
|
|
|
|
|
func _on_rectangles_button_pressed() -> void:
|
|
shape = Shape.RECTANGLE
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_slopes_tl_button_pressed() -> void:
|
|
shape = Shape.SLOPE_TL
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_slopes_tr_button_pressed() -> void:
|
|
shape = Shape.SLOPE_TR
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_slopes_br_button_pressed() -> void:
|
|
shape = Shape.SLOPE_BR
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_slopes_bl_button_pressed() -> void:
|
|
shape = Shape.SLOPE_BL
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_hard_rectangles_button_pressed() -> void:
|
|
shape = Shape.HARD_RECTANGLE
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_hill_top_button_pressed() -> void:
|
|
shape = Shape.HILL_TOP
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_hill_bottom_button_pressed() -> void:
|
|
shape = Shape.HILL_BOTTOM
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_hill_left_button_pressed() -> void:
|
|
shape = Shape.HILL_LEFT
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_hill_right_button_pressed() -> void:
|
|
shape = Shape.HILL_RIGHT
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_island_button_pressed() -> void:
|
|
shape = Shape.ISLAND
|
|
update_grid_preview()
|
|
|
|
|
|
func _on_rectangles_basic_button_pressed() -> void:
|
|
shape = Shape.RECTANGLE_BASIC
|
|
update_grid_preview()
|