mirror of
https://github.com/JHDev2006/Super-Mario-Bros.-Remastered-Public.git
synced 2025-10-23 07:58:09 +00:00
added the game
This commit is contained in:
896
addons/better-terrain/editor/TileView.gd
Executable file
896
addons/better-terrain/editor/TileView.gd
Executable file
@@ -0,0 +1,896 @@
|
||||
@tool
|
||||
extends Control
|
||||
|
||||
signal paste_occurred
|
||||
signal change_zoom_level(value)
|
||||
signal terrain_updated(index)
|
||||
|
||||
@onready var checkerboard := get_theme_icon("Checkerboard", "EditorIcons")
|
||||
|
||||
@onready var paint_symmetry_icons := [
|
||||
null,
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryMirror.svg"),
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryFlip.svg"),
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryReflect.svg"),
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryRotateClockwise.svg"),
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryRotateCounterClockwise.svg"),
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryRotate180.svg"),
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryRotateAll.svg"),
|
||||
preload("res://addons/better-terrain/icons/paint-symmetry/SymmetryAll.svg"),
|
||||
]
|
||||
|
||||
# Draw checkerboard and tiles with specific materials in
|
||||
# individual canvas items via rendering server
|
||||
var _canvas_item_map = {}
|
||||
var _canvas_item_background : RID
|
||||
|
||||
var tileset: TileSet
|
||||
var disabled_sources: Array[int] = []: set = set_disabled_sources
|
||||
|
||||
var paint := BetterTerrain.TileCategory.NON_TERRAIN
|
||||
var paint_symmetry := BetterTerrain.SymmetryType.NONE
|
||||
var highlighted_tile_part := { valid = false }
|
||||
var zoom_level := 1.0
|
||||
|
||||
var tiles_size : Vector2
|
||||
var tile_size : Vector2i
|
||||
var tile_part_size : Vector2
|
||||
var alternate_size : Vector2
|
||||
var alternate_lookup := []
|
||||
var initial_click : Vector2i
|
||||
var prev_position : Vector2i
|
||||
var current_position : Vector2i
|
||||
|
||||
var selection_start : Vector2i
|
||||
var selection_end : Vector2i
|
||||
var selection_rect : Rect2i
|
||||
var selected_tile_states : Array[Dictionary] = []
|
||||
var copied_tile_states : Array[Dictionary] = []
|
||||
var staged_paste_tile_states : Array[Dictionary] = []
|
||||
|
||||
var pick_icon_terrain : int = -1
|
||||
var pick_icon_terrain_cancel := false
|
||||
|
||||
var undo_manager : EditorUndoRedoManager
|
||||
var terrain_undo
|
||||
|
||||
# Modes for painting
|
||||
enum PaintMode {
|
||||
NO_PAINT,
|
||||
PAINT_TYPE,
|
||||
PAINT_PEERING,
|
||||
PAINT_SYMMETRY,
|
||||
SELECT,
|
||||
PASTE
|
||||
}
|
||||
|
||||
var paint_mode := PaintMode.NO_PAINT
|
||||
|
||||
# Actual interactions for painting
|
||||
enum PaintAction {
|
||||
NO_ACTION,
|
||||
DRAW_TYPE,
|
||||
ERASE_TYPE,
|
||||
DRAW_PEERING,
|
||||
ERASE_PEERING,
|
||||
DRAW_SYMMETRY,
|
||||
ERASE_SYMMETRY,
|
||||
SELECT,
|
||||
PASTE
|
||||
}
|
||||
|
||||
var paint_action := PaintAction.NO_ACTION
|
||||
|
||||
const ALTERNATE_TILE_MARGIN := 18
|
||||
|
||||
func _enter_tree() -> void:
|
||||
_canvas_item_background = RenderingServer.canvas_item_create()
|
||||
RenderingServer.canvas_item_set_parent(_canvas_item_background, get_canvas_item())
|
||||
RenderingServer.canvas_item_set_draw_behind_parent(_canvas_item_background, true)
|
||||
|
||||
|
||||
func _exit_tree() -> void:
|
||||
RenderingServer.free_rid(_canvas_item_background)
|
||||
for p in _canvas_item_map:
|
||||
RenderingServer.free_rid(_canvas_item_map[p])
|
||||
_canvas_item_map.clear()
|
||||
|
||||
|
||||
func refresh_tileset(ts: TileSet) -> void:
|
||||
tileset = ts
|
||||
|
||||
tiles_size = Vector2.ZERO
|
||||
alternate_size = Vector2.ZERO
|
||||
alternate_lookup = []
|
||||
disabled_sources = []
|
||||
|
||||
if !tileset:
|
||||
return
|
||||
|
||||
for s in tileset.get_source_count():
|
||||
var source_id := tileset.get_source_id(s)
|
||||
var source := tileset.get_source(source_id) as TileSetAtlasSource
|
||||
if !source or !source.texture:
|
||||
continue
|
||||
|
||||
tiles_size.x = max(tiles_size.x, source.texture.get_width())
|
||||
tiles_size.y += source.texture.get_height()
|
||||
|
||||
tile_size = source.texture_region_size
|
||||
tile_part_size = Vector2(tile_size) / 3.0
|
||||
|
||||
for t in source.get_tiles_count():
|
||||
var coord := source.get_tile_id(t)
|
||||
var alt_count := source.get_alternative_tiles_count(coord)
|
||||
if alt_count <= 1:
|
||||
continue
|
||||
|
||||
var rect := source.get_tile_texture_region(coord, 0)
|
||||
alternate_lookup.append([rect.size, source_id, coord])
|
||||
alternate_size.x = max(alternate_size.x, rect.size.x * (alt_count - 1))
|
||||
alternate_size.y += rect.size.y
|
||||
|
||||
_on_zoom_value_changed(zoom_level)
|
||||
|
||||
|
||||
func is_tile_in_source(source: TileSetAtlasSource, coord: Vector2i) -> bool:
|
||||
var origin := source.get_tile_at_coords(coord)
|
||||
if origin == Vector2i(-1, -1):
|
||||
return false
|
||||
|
||||
# Animation frames are not needed
|
||||
var size := source.get_tile_size_in_atlas(origin)
|
||||
return coord.x < origin.x + size.x and coord.y < origin.y + size.y
|
||||
|
||||
|
||||
func _build_tile_part_from_position(result: Dictionary, position: Vector2i, rect: Rect2) -> void:
|
||||
result.rect = rect
|
||||
var type := BetterTerrain.get_tile_terrain_type(result.data)
|
||||
if type == BetterTerrain.TileCategory.NON_TERRAIN:
|
||||
return
|
||||
result.terrain_type = type
|
||||
|
||||
var normalize_position := (Vector2(position) - rect.position) / rect.size
|
||||
|
||||
var terrain := BetterTerrain.get_terrain(tileset, type)
|
||||
if !terrain.valid:
|
||||
return
|
||||
for p in BetterTerrain.data.get_terrain_peering_cells(tileset, terrain.type):
|
||||
var side_polygon = BetterTerrain.data.peering_polygon(tileset, terrain.type, p)
|
||||
if Geometry2D.is_point_in_polygon(normalize_position, side_polygon):
|
||||
result.peering = p
|
||||
result.polygon = side_polygon
|
||||
break
|
||||
|
||||
|
||||
func tile_part_from_position(position: Vector2i) -> Dictionary:
|
||||
if !tileset:
|
||||
return { valid = false }
|
||||
|
||||
var offset := Vector2.ZERO
|
||||
var alt_offset := Vector2.RIGHT * (zoom_level * tiles_size.x + ALTERNATE_TILE_MARGIN)
|
||||
if Rect2(alt_offset, zoom_level * alternate_size).has_point(position):
|
||||
for a in alternate_lookup:
|
||||
if a[1] in disabled_sources:
|
||||
continue
|
||||
var next_offset_y = alt_offset.y + zoom_level * a[0].y
|
||||
if position.y > next_offset_y:
|
||||
alt_offset.y = next_offset_y
|
||||
continue
|
||||
|
||||
var source := tileset.get_source(a[1]) as TileSetAtlasSource
|
||||
if !source:
|
||||
break
|
||||
|
||||
var count := source.get_alternative_tiles_count(a[2])
|
||||
var index := int((position.x - alt_offset.x) / (zoom_level * a[0].x)) + 1
|
||||
|
||||
if index < count:
|
||||
var alt_id := source.get_alternative_tile_id(a[2], index)
|
||||
var target_rect := Rect2(
|
||||
alt_offset + Vector2.RIGHT * (index - 1) * zoom_level * a[0].x,
|
||||
zoom_level * a[0]
|
||||
)
|
||||
|
||||
var result := {
|
||||
valid = true,
|
||||
source_id = a[1],
|
||||
coord = a[2],
|
||||
alternate = alt_id,
|
||||
data = source.get_tile_data(a[2], alt_id)
|
||||
}
|
||||
_build_tile_part_from_position(result, position, target_rect)
|
||||
return result
|
||||
|
||||
else:
|
||||
for s in tileset.get_source_count():
|
||||
var source_id := tileset.get_source_id(s)
|
||||
if source_id in disabled_sources:
|
||||
continue
|
||||
var source := tileset.get_source(source_id) as TileSetAtlasSource
|
||||
if !source || !source.texture:
|
||||
continue
|
||||
for t in source.get_tiles_count():
|
||||
var coord := source.get_tile_id(t)
|
||||
var rect := source.get_tile_texture_region(coord, 0)
|
||||
var target_rect := Rect2(offset + zoom_level * rect.position, zoom_level * rect.size)
|
||||
if !target_rect.has_point(position):
|
||||
continue
|
||||
|
||||
var result := {
|
||||
valid = true,
|
||||
source_id = source_id,
|
||||
coord = coord,
|
||||
alternate = 0,
|
||||
data = source.get_tile_data(coord, 0)
|
||||
}
|
||||
_build_tile_part_from_position(result, position, target_rect)
|
||||
return result
|
||||
|
||||
offset.y += zoom_level * source.texture.get_height()
|
||||
|
||||
return { valid = false }
|
||||
|
||||
|
||||
func tile_rect_from_position(position: Vector2i) -> Rect2:
|
||||
if !tileset:
|
||||
return Rect2(-1,-1,0,0)
|
||||
|
||||
var offset := Vector2.ZERO
|
||||
var alt_offset := Vector2.RIGHT * (zoom_level * tiles_size.x + ALTERNATE_TILE_MARGIN)
|
||||
if Rect2(alt_offset, zoom_level * alternate_size).has_point(position):
|
||||
for a in alternate_lookup:
|
||||
if a[1] in disabled_sources:
|
||||
continue
|
||||
var next_offset_y = alt_offset.y + zoom_level * a[0].y
|
||||
if position.y > next_offset_y:
|
||||
alt_offset.y = next_offset_y
|
||||
continue
|
||||
|
||||
var source := tileset.get_source(a[1]) as TileSetAtlasSource
|
||||
if !source:
|
||||
break
|
||||
|
||||
var count := source.get_alternative_tiles_count(a[2])
|
||||
var index := int((position.x - alt_offset.x) / (zoom_level * a[0].x)) + 1
|
||||
|
||||
if index < count:
|
||||
var target_rect := Rect2(
|
||||
alt_offset + Vector2.RIGHT * (index - 1) * zoom_level * a[0].x,
|
||||
zoom_level * a[0]
|
||||
)
|
||||
return target_rect
|
||||
|
||||
else:
|
||||
for s in tileset.get_source_count():
|
||||
var source_id := tileset.get_source_id(s)
|
||||
if source_id in disabled_sources:
|
||||
continue
|
||||
var source := tileset.get_source(source_id) as TileSetAtlasSource
|
||||
if !source:
|
||||
continue
|
||||
for t in source.get_tiles_count():
|
||||
var coord := source.get_tile_id(t)
|
||||
var rect := source.get_tile_texture_region(coord, 0)
|
||||
var target_rect := Rect2(offset + zoom_level * rect.position, zoom_level * rect.size)
|
||||
if target_rect.has_point(position):
|
||||
return target_rect
|
||||
|
||||
offset.y += zoom_level * source.texture.get_height()
|
||||
|
||||
return Rect2(-1,-1,0,0)
|
||||
|
||||
|
||||
func tile_parts_from_rect(rect:Rect2) -> Array[Dictionary]:
|
||||
if !tileset:
|
||||
return []
|
||||
|
||||
var tiles:Array[Dictionary] = []
|
||||
|
||||
var offset := Vector2.ZERO
|
||||
var alt_offset := Vector2.RIGHT * (zoom_level * tiles_size.x + ALTERNATE_TILE_MARGIN)
|
||||
for s in tileset.get_source_count():
|
||||
var source_id := tileset.get_source_id(s)
|
||||
if source_id in disabled_sources:
|
||||
continue
|
||||
var source := tileset.get_source(source_id) as TileSetAtlasSource
|
||||
if !source:
|
||||
continue
|
||||
for t in source.get_tiles_count():
|
||||
var coord := source.get_tile_id(t)
|
||||
var tile_rect := source.get_tile_texture_region(coord, 0)
|
||||
var target_rect := Rect2(offset + zoom_level * tile_rect.position, zoom_level * tile_rect.size)
|
||||
if target_rect.intersects(rect):
|
||||
var result := {
|
||||
valid = true,
|
||||
source_id = source_id,
|
||||
coord = coord,
|
||||
alternate = 0,
|
||||
data = source.get_tile_data(coord, 0)
|
||||
}
|
||||
var pos = target_rect.position + target_rect.size/2
|
||||
_build_tile_part_from_position(result, pos, target_rect)
|
||||
tiles.push_back(result)
|
||||
var alt_count := source.get_alternative_tiles_count(coord)
|
||||
for a in alt_count:
|
||||
var alt_id := 0
|
||||
if a == 0:
|
||||
continue
|
||||
|
||||
target_rect = Rect2(alt_offset + zoom_level * (a - 1) * tile_rect.size.x * Vector2.RIGHT, zoom_level * tile_rect.size)
|
||||
alt_id = source.get_alternative_tile_id(coord, a)
|
||||
if target_rect.intersects(rect):
|
||||
var td := source.get_tile_data(coord, alt_id)
|
||||
var result := {
|
||||
valid = true,
|
||||
source_id = source_id,
|
||||
coord = coord,
|
||||
alternate = alt_id,
|
||||
data = td
|
||||
}
|
||||
var pos = target_rect.position + target_rect.size/2
|
||||
_build_tile_part_from_position(result, pos, target_rect)
|
||||
tiles.push_back(result)
|
||||
if alt_count > 1:
|
||||
alt_offset.y += zoom_level * tile_rect.size.y
|
||||
|
||||
offset.y += zoom_level * source.texture.get_height()
|
||||
|
||||
return tiles
|
||||
|
||||
|
||||
func _get_canvas_item(td: TileData) -> RID:
|
||||
if !td.material:
|
||||
return self.get_canvas_item()
|
||||
if _canvas_item_map.has(td.material):
|
||||
return _canvas_item_map[td.material]
|
||||
|
||||
var rid = RenderingServer.canvas_item_create()
|
||||
RenderingServer.canvas_item_set_material(rid, td.material.get_rid())
|
||||
RenderingServer.canvas_item_set_parent(rid, get_canvas_item())
|
||||
RenderingServer.canvas_item_set_draw_behind_parent(rid, true)
|
||||
RenderingServer.canvas_item_set_default_texture_filter(rid, RenderingServer.CANVAS_ITEM_TEXTURE_FILTER_NEAREST)
|
||||
_canvas_item_map[td.material] = rid
|
||||
return rid
|
||||
|
||||
|
||||
func _draw_tile_data(texture: Texture2D, rect: Rect2, src_rect: Rect2, td: TileData, draw_sides: bool = true) -> void:
|
||||
var flipped_rect := rect
|
||||
if td.flip_h:
|
||||
flipped_rect.size.x = -rect.size.x
|
||||
if td.flip_v:
|
||||
flipped_rect.size.y = -rect.size.y
|
||||
|
||||
RenderingServer.canvas_item_add_texture_rect_region(
|
||||
_get_canvas_item(td),
|
||||
flipped_rect,
|
||||
texture.get_rid(),
|
||||
src_rect,
|
||||
td.modulate,
|
||||
td.transpose
|
||||
)
|
||||
|
||||
var type := BetterTerrain.get_tile_terrain_type(td)
|
||||
if type == BetterTerrain.TileCategory.NON_TERRAIN:
|
||||
draw_rect(rect, Color(0.1, 0.1, 0.1, 0.5), true)
|
||||
return
|
||||
|
||||
var terrain := BetterTerrain.get_terrain(tileset, type)
|
||||
if !terrain.valid:
|
||||
return
|
||||
|
||||
var transform := Transform2D(0.0, rect.size, 0.0, rect.position)
|
||||
var center_polygon = transform * BetterTerrain.data.peering_polygon(tileset, terrain.type, -1)
|
||||
draw_colored_polygon(center_polygon, Color(terrain.color, 0.6))
|
||||
if terrain.type == BetterTerrain.TerrainType.DECORATION:
|
||||
center_polygon.append(center_polygon[0])
|
||||
draw_polyline(center_polygon, Color.BLACK)
|
||||
|
||||
if paint < BetterTerrain.TileCategory.EMPTY or paint >= BetterTerrain.terrain_count(tileset):
|
||||
return
|
||||
|
||||
if not draw_sides:
|
||||
return
|
||||
|
||||
var paint_terrain := BetterTerrain.get_terrain(tileset, paint)
|
||||
for p in BetterTerrain.data.get_terrain_peering_cells(tileset, terrain.type):
|
||||
if paint in BetterTerrain.tile_peering_types(td, p):
|
||||
var side_polygon = transform * BetterTerrain.data.peering_polygon(tileset, terrain.type, p)
|
||||
draw_colored_polygon(side_polygon, Color(paint_terrain.color, 0.6))
|
||||
if paint_terrain.type == BetterTerrain.TerrainType.DECORATION:
|
||||
side_polygon.append(side_polygon[0])
|
||||
draw_polyline(side_polygon, Color.BLACK)
|
||||
|
||||
|
||||
func _draw_tile_symmetry(texture: Texture2D, rect: Rect2, src_rect: Rect2, td: TileData, draw_icon: bool = true) -> void:
|
||||
var flipped_rect := rect
|
||||
if td.flip_h:
|
||||
flipped_rect.size.x = -rect.size.x
|
||||
if td.flip_v:
|
||||
flipped_rect.size.y = -rect.size.y
|
||||
|
||||
RenderingServer.canvas_item_add_texture_rect_region(
|
||||
_get_canvas_item(td),
|
||||
flipped_rect,
|
||||
texture.get_rid(),
|
||||
src_rect,
|
||||
td.modulate,
|
||||
td.transpose
|
||||
)
|
||||
|
||||
if not draw_icon:
|
||||
return
|
||||
|
||||
var symmetry_type = BetterTerrain.get_tile_symmetry_type(td)
|
||||
if symmetry_type == 0:
|
||||
return
|
||||
var symmetry_icon = paint_symmetry_icons[symmetry_type]
|
||||
|
||||
RenderingServer.canvas_item_add_texture_rect_region(
|
||||
_get_canvas_item(td),
|
||||
rect,
|
||||
symmetry_icon.get_rid(),
|
||||
Rect2(Vector2.ZERO, symmetry_icon.get_size()),
|
||||
Color(1,1,1,0.5)
|
||||
)
|
||||
|
||||
|
||||
func _draw() -> void:
|
||||
if !tileset:
|
||||
return
|
||||
|
||||
# Clear material-based render targets
|
||||
RenderingServer.canvas_item_clear(_canvas_item_background)
|
||||
for p in _canvas_item_map:
|
||||
RenderingServer.canvas_item_clear(_canvas_item_map[p])
|
||||
|
||||
var offset := Vector2.ZERO
|
||||
var alt_offset := Vector2.RIGHT * (zoom_level * tiles_size.x + ALTERNATE_TILE_MARGIN)
|
||||
|
||||
RenderingServer.canvas_item_add_texture_rect(
|
||||
_canvas_item_background,
|
||||
Rect2(alt_offset, zoom_level * alternate_size),
|
||||
checkerboard.get_rid(),
|
||||
true
|
||||
)
|
||||
|
||||
for s in tileset.get_source_count():
|
||||
var source_id := tileset.get_source_id(s)
|
||||
if source_id in disabled_sources:
|
||||
continue
|
||||
var source := tileset.get_source(source_id) as TileSetAtlasSource
|
||||
if !source or !source.texture:
|
||||
continue
|
||||
|
||||
RenderingServer.canvas_item_add_texture_rect(
|
||||
_canvas_item_background,
|
||||
Rect2(offset, zoom_level * source.texture.get_size()),
|
||||
checkerboard.get_rid(),
|
||||
true
|
||||
)
|
||||
for t in source.get_tiles_count():
|
||||
var coord := source.get_tile_id(t)
|
||||
var rect := source.get_tile_texture_region(coord, 0)
|
||||
var alt_count := source.get_alternative_tiles_count(coord)
|
||||
var target_rect : Rect2
|
||||
for a in alt_count:
|
||||
var alt_id := 0
|
||||
if a == 0:
|
||||
target_rect = Rect2(offset + zoom_level * rect.position, zoom_level * rect.size)
|
||||
else:
|
||||
target_rect = Rect2(alt_offset + zoom_level * (a - 1) * rect.size.x * Vector2.RIGHT, zoom_level * rect.size)
|
||||
alt_id = source.get_alternative_tile_id(coord, a)
|
||||
|
||||
var td := source.get_tile_data(coord, alt_id)
|
||||
var drawing_current = BetterTerrain.get_tile_terrain_type(td) == paint
|
||||
if paint_mode == PaintMode.PAINT_SYMMETRY:
|
||||
_draw_tile_symmetry(source.texture, target_rect, rect, td, drawing_current)
|
||||
else:
|
||||
_draw_tile_data(source.texture, target_rect, rect, td)
|
||||
|
||||
if drawing_current:
|
||||
draw_rect(target_rect.grow(-1), Color(0,0,0, 0.75), false, 1)
|
||||
draw_rect(target_rect, Color(1,1,1, 0.75), false, 1)
|
||||
|
||||
if paint_mode == PaintMode.SELECT:
|
||||
if selected_tile_states.any(func(v):
|
||||
return v.part.data == td
|
||||
):
|
||||
draw_rect(target_rect.grow(-1), Color.DEEP_SKY_BLUE, false, 2)
|
||||
|
||||
if alt_count > 1:
|
||||
alt_offset.y += zoom_level * rect.size.y
|
||||
|
||||
# Blank out unused or uninteresting tiles
|
||||
var size := source.get_atlas_grid_size()
|
||||
for y in size.y:
|
||||
for x in size.x:
|
||||
var pos := Vector2i(x, y)
|
||||
if !is_tile_in_source(source, pos):
|
||||
var atlas_pos := source.margins + pos * (source.separation + source.texture_region_size)
|
||||
draw_rect(Rect2(offset + zoom_level * atlas_pos, zoom_level * source.texture_region_size), Color(0.0, 0.0, 0.0, 0.8), true)
|
||||
|
||||
offset.y += zoom_level * source.texture.get_height()
|
||||
|
||||
# Blank out unused alternate tile sections
|
||||
alt_offset = Vector2.RIGHT * (zoom_level * tiles_size.x + ALTERNATE_TILE_MARGIN)
|
||||
for a in alternate_lookup:
|
||||
if a[1] in disabled_sources:
|
||||
continue
|
||||
var source := tileset.get_source(a[1]) as TileSetAtlasSource
|
||||
if source:
|
||||
var count := source.get_alternative_tiles_count(a[2]) - 1
|
||||
var occupied_width = count * zoom_level * a[0].x
|
||||
var area := Rect2(
|
||||
alt_offset.x + occupied_width,
|
||||
alt_offset.y,
|
||||
zoom_level * alternate_size.x - occupied_width,
|
||||
zoom_level * a[0].y
|
||||
)
|
||||
draw_rect(area, Color(0.0, 0.0, 0.0, 0.8), true)
|
||||
alt_offset.y += zoom_level * a[0].y
|
||||
|
||||
if highlighted_tile_part.valid:
|
||||
if paint_mode == PaintMode.PAINT_PEERING and highlighted_tile_part.has("polygon"):
|
||||
var transform := Transform2D(0.0, highlighted_tile_part.rect.size - 2 * Vector2.ONE, 0.0, highlighted_tile_part.rect.position + Vector2.ONE)
|
||||
draw_colored_polygon(transform * highlighted_tile_part.polygon, Color(Color.WHITE, 0.2))
|
||||
if paint_mode != PaintMode.NO_PAINT:
|
||||
var inner_rect := Rect2(highlighted_tile_part.rect.position + Vector2.ONE, highlighted_tile_part.rect.size - 2 * Vector2.ONE)
|
||||
draw_rect(inner_rect, Color.WHITE, false)
|
||||
if paint_mode == PaintMode.PAINT_SYMMETRY:
|
||||
if paint_symmetry > 0:
|
||||
var symmetry_icon = paint_symmetry_icons[paint_symmetry]
|
||||
draw_texture_rect(symmetry_icon, highlighted_tile_part.rect, false, Color(0.5,0.75,1,0.5))
|
||||
|
||||
if paint_mode == PaintMode.SELECT:
|
||||
draw_rect(selection_rect, Color.WHITE, false)
|
||||
|
||||
if paint_mode == PaintMode.PASTE:
|
||||
if staged_paste_tile_states.size() > 0:
|
||||
var base_rect = staged_paste_tile_states[0].base_rect
|
||||
var paint_terrain := BetterTerrain.get_terrain(tileset, paint)
|
||||
var paint_terrain_type = paint_terrain.type
|
||||
if paint_terrain_type == BetterTerrain.TerrainType.CATEGORY:
|
||||
paint_terrain_type = 0
|
||||
for state in staged_paste_tile_states:
|
||||
var staged_rect:Rect2 = state.base_rect
|
||||
staged_rect.position -= base_rect.position + base_rect.size / 2
|
||||
|
||||
staged_rect.position *= zoom_level
|
||||
staged_rect.size *= zoom_level
|
||||
|
||||
staged_rect.position += Vector2(current_position)
|
||||
|
||||
var real_rect = tile_rect_from_position(staged_rect.get_center())
|
||||
if real_rect.position.x >= 0:
|
||||
draw_rect(real_rect, Color(0,0,0, 0.3), true)
|
||||
var transform := Transform2D(0.0, real_rect.size, 0.0, real_rect.position)
|
||||
var tile_sides = BetterTerrain.data.get_terrain_peering_cells(tileset, paint_terrain_type)
|
||||
for p in tile_sides:
|
||||
if state.paint in BetterTerrain.tile_peering_types(state.part.data, p):
|
||||
var side_polygon = BetterTerrain.data.peering_polygon(tileset, paint_terrain_type, p)
|
||||
var color = Color(paint_terrain.color, 0.6)
|
||||
draw_colored_polygon(transform * side_polygon, color)
|
||||
|
||||
draw_rect(staged_rect, Color.DEEP_PINK, false)
|
||||
|
||||
|
||||
|
||||
func delete_selection():
|
||||
undo_manager.create_action("Delete tile terrain peering types", UndoRedo.MERGE_DISABLE, tileset)
|
||||
for t in selected_tile_states:
|
||||
for side in range(16):
|
||||
var old_peering = BetterTerrain.tile_peering_types(t.part.data, side)
|
||||
if old_peering.has(paint):
|
||||
undo_manager.add_do_method(BetterTerrain, &"remove_tile_peering_type", tileset, t.part.data, side, paint)
|
||||
undo_manager.add_undo_method(BetterTerrain, &"add_tile_peering_type", tileset, t.part.data, side, paint)
|
||||
|
||||
undo_manager.add_do_method(self, &"queue_redraw")
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
|
||||
|
||||
func toggle_selection():
|
||||
undo_manager.create_action("Toggle tile terrain", UndoRedo.MERGE_DISABLE, tileset, true)
|
||||
for t in selected_tile_states:
|
||||
var type := BetterTerrain.get_tile_terrain_type(t.part.data)
|
||||
var goal := paint if paint != type else BetterTerrain.TileCategory.NON_TERRAIN
|
||||
|
||||
terrain_undo.add_do_method(undo_manager, BetterTerrain, &"set_tile_terrain_type", [tileset, t.part.data, goal])
|
||||
if goal == BetterTerrain.TileCategory.NON_TERRAIN:
|
||||
terrain_undo.create_peering_restore_point_tile(
|
||||
undo_manager,
|
||||
tileset,
|
||||
t.part.source_id,
|
||||
t.part.coord,
|
||||
t.part.alternate
|
||||
)
|
||||
else:
|
||||
undo_manager.add_undo_method(BetterTerrain, &"set_tile_terrain_type", tileset, t.part.data, type)
|
||||
|
||||
terrain_undo.add_do_method(undo_manager, self, &"queue_redraw", [])
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
terrain_undo.action_count += 1
|
||||
|
||||
|
||||
func copy_selection():
|
||||
copied_tile_states = selected_tile_states
|
||||
|
||||
|
||||
func paste_selection():
|
||||
staged_paste_tile_states = copied_tile_states
|
||||
selected_tile_states = []
|
||||
paint_mode = PaintMode.PASTE
|
||||
paint_action = PaintAction.PASTE
|
||||
paste_occurred.emit()
|
||||
queue_redraw()
|
||||
|
||||
|
||||
func set_disabled_sources(list):
|
||||
disabled_sources = list
|
||||
queue_redraw()
|
||||
|
||||
|
||||
func emit_terrain_updated(index):
|
||||
terrain_updated.emit(index)
|
||||
|
||||
|
||||
func _gui_input(event) -> void:
|
||||
if event is InputEventKey and event.is_pressed():
|
||||
if event.keycode == KEY_DELETE and not event.echo:
|
||||
accept_event()
|
||||
delete_selection()
|
||||
if event.keycode == KEY_ENTER and not event.echo:
|
||||
accept_event()
|
||||
toggle_selection()
|
||||
if event.keycode == KEY_ESCAPE and not event.echo:
|
||||
accept_event()
|
||||
if paint_action == PaintAction.PASTE:
|
||||
staged_paste_tile_states = []
|
||||
paint_mode = PaintMode.SELECT
|
||||
paint_action = PaintAction.NO_ACTION
|
||||
selection_start = Vector2i(-1,-1)
|
||||
if event.keycode == KEY_C and (event.ctrl_pressed or event.meta_pressed) and not event.echo:
|
||||
accept_event()
|
||||
copy_selection()
|
||||
if event.keycode == KEY_X and (event.ctrl_pressed or event.meta_pressed) and not event.echo:
|
||||
accept_event()
|
||||
copy_selection()
|
||||
delete_selection()
|
||||
if event.keycode == KEY_V and (event.ctrl_pressed or event.meta_pressed) and not event.echo:
|
||||
accept_event()
|
||||
paste_selection()
|
||||
if event is InputEventMouseButton:
|
||||
if event.button_index == MOUSE_BUTTON_WHEEL_UP and (event.ctrl_pressed or event.meta_pressed):
|
||||
accept_event()
|
||||
change_zoom_level.emit(zoom_level * 1.1)
|
||||
if event.button_index == MOUSE_BUTTON_WHEEL_DOWN and (event.ctrl_pressed or event.meta_pressed):
|
||||
accept_event()
|
||||
change_zoom_level.emit(zoom_level / 1.1)
|
||||
|
||||
var released : bool = event is InputEventMouseButton and (not event.pressed and (event.button_index == MOUSE_BUTTON_LEFT or event.button_index == MOUSE_BUTTON_RIGHT))
|
||||
if released:
|
||||
paint_action = PaintAction.NO_ACTION
|
||||
|
||||
if event is InputEventMouseMotion:
|
||||
prev_position = current_position
|
||||
current_position = event.position
|
||||
var tile := tile_part_from_position(event.position)
|
||||
if tile.valid != highlighted_tile_part.valid or\
|
||||
(tile.valid and tile.data != highlighted_tile_part.data) or\
|
||||
(tile.valid and tile.get("peering") != highlighted_tile_part.get("peering")) or\
|
||||
event.button_mask & MOUSE_BUTTON_LEFT and paint_action == PaintAction.SELECT:
|
||||
queue_redraw()
|
||||
highlighted_tile_part = tile
|
||||
|
||||
var clicked : bool = event is InputEventMouseButton and (event.pressed and (event.button_index == MOUSE_BUTTON_LEFT or event.button_index == MOUSE_BUTTON_RIGHT))
|
||||
if clicked:
|
||||
initial_click = current_position
|
||||
selection_start = Vector2i(-1,-1)
|
||||
terrain_undo.action_index += 1
|
||||
terrain_undo.action_count = 0
|
||||
if released:
|
||||
terrain_undo.finish_action()
|
||||
selection_rect = Rect2i(0,0,0,0)
|
||||
queue_redraw()
|
||||
|
||||
if paint_action == PaintAction.PASTE:
|
||||
if event is InputEventMouseMotion:
|
||||
queue_redraw()
|
||||
|
||||
if clicked:
|
||||
if event.button_index == MOUSE_BUTTON_LEFT and staged_paste_tile_states.size() > 0:
|
||||
undo_manager.create_action("Paste tile terrain peering types", UndoRedo.MERGE_DISABLE, tileset)
|
||||
var base_rect = staged_paste_tile_states[0].base_rect
|
||||
for p in staged_paste_tile_states:
|
||||
var staged_rect:Rect2 = p.base_rect
|
||||
staged_rect.position -= base_rect.position + base_rect.size / 2
|
||||
|
||||
staged_rect.position *= zoom_level
|
||||
staged_rect.size *= zoom_level
|
||||
|
||||
staged_rect.position += Vector2(current_position)
|
||||
|
||||
var old_tile_part = tile_part_from_position(staged_rect.get_center())
|
||||
var new_tile_state = p
|
||||
if (not old_tile_part.valid) or (not new_tile_state.part.valid):
|
||||
continue
|
||||
|
||||
for side in range(16):
|
||||
var old_peering = BetterTerrain.tile_peering_types(old_tile_part.data, side)
|
||||
var new_sides = new_tile_state.sides
|
||||
if new_sides.has(side) and not old_peering.has(paint):
|
||||
undo_manager.add_do_method(BetterTerrain, &"add_tile_peering_type", tileset, old_tile_part.data, side, paint)
|
||||
undo_manager.add_undo_method(BetterTerrain, &"remove_tile_peering_type", tileset, old_tile_part.data, side, paint)
|
||||
elif old_peering.has(paint) and not new_sides.has(side):
|
||||
undo_manager.add_do_method(BetterTerrain, &"remove_tile_peering_type", tileset, old_tile_part.data, side, paint)
|
||||
undo_manager.add_undo_method(BetterTerrain, &"add_tile_peering_type", tileset, old_tile_part.data, side, paint)
|
||||
|
||||
var old_symmetry = BetterTerrain.get_tile_symmetry_type(old_tile_part.data)
|
||||
var new_symmetry = new_tile_state.symmetry
|
||||
if new_symmetry != old_symmetry:
|
||||
undo_manager.add_do_method(BetterTerrain, &"set_tile_symmetry_type", tileset, old_tile_part.data, new_symmetry)
|
||||
undo_manager.add_undo_method(BetterTerrain, &"set_tile_symmetry_type", tileset, old_tile_part.data, old_symmetry)
|
||||
|
||||
undo_manager.add_do_method(self, &"queue_redraw")
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
|
||||
staged_paste_tile_states = []
|
||||
paint_mode = PaintMode.SELECT
|
||||
paint_action = PaintAction.SELECT
|
||||
return
|
||||
|
||||
if clicked and pick_icon_terrain >= 0:
|
||||
highlighted_tile_part = tile_part_from_position(current_position)
|
||||
if !highlighted_tile_part.valid:
|
||||
return
|
||||
|
||||
var t = BetterTerrain.get_terrain(tileset, paint)
|
||||
var prev_icon = t.icon.duplicate()
|
||||
var icon = {
|
||||
source_id = highlighted_tile_part.source_id,
|
||||
coord = highlighted_tile_part.coord
|
||||
}
|
||||
undo_manager.create_action("Edit terrain details", UndoRedo.MERGE_DISABLE, tileset)
|
||||
undo_manager.add_do_method(BetterTerrain, &"set_terrain", tileset, paint, t.name, t.color, t.type, t.categories, icon)
|
||||
undo_manager.add_do_method(self, &"emit_terrain_updated", paint)
|
||||
undo_manager.add_undo_method(BetterTerrain, &"set_terrain", tileset, paint, t.name, t.color, t.type, t.categories, prev_icon)
|
||||
undo_manager.add_undo_method(self, &"emit_terrain_updated", paint)
|
||||
undo_manager.commit_action()
|
||||
pick_icon_terrain = -1
|
||||
return
|
||||
|
||||
if pick_icon_terrain_cancel:
|
||||
pick_icon_terrain = -1
|
||||
pick_icon_terrain_cancel = false
|
||||
|
||||
if paint != BetterTerrain.TileCategory.NON_TERRAIN and clicked:
|
||||
paint_action = PaintAction.NO_ACTION
|
||||
if highlighted_tile_part.valid:
|
||||
match [paint_mode, event.button_index]:
|
||||
[PaintMode.PAINT_TYPE, MOUSE_BUTTON_LEFT]: paint_action = PaintAction.DRAW_TYPE
|
||||
[PaintMode.PAINT_TYPE, MOUSE_BUTTON_RIGHT]: paint_action = PaintAction.ERASE_TYPE
|
||||
[PaintMode.PAINT_PEERING, MOUSE_BUTTON_LEFT]: paint_action = PaintAction.DRAW_PEERING
|
||||
[PaintMode.PAINT_PEERING, MOUSE_BUTTON_RIGHT]: paint_action = PaintAction.ERASE_PEERING
|
||||
[PaintMode.PAINT_SYMMETRY, MOUSE_BUTTON_LEFT]: paint_action = PaintAction.DRAW_SYMMETRY
|
||||
[PaintMode.PAINT_SYMMETRY, MOUSE_BUTTON_RIGHT]: paint_action = PaintAction.ERASE_SYMMETRY
|
||||
[PaintMode.SELECT, MOUSE_BUTTON_LEFT]: paint_action = PaintAction.SELECT
|
||||
else:
|
||||
match [paint_mode, event.button_index]:
|
||||
[PaintMode.SELECT, MOUSE_BUTTON_LEFT]: paint_action = PaintAction.SELECT
|
||||
|
||||
if (clicked or event is InputEventMouseMotion) and paint_action != PaintAction.NO_ACTION:
|
||||
|
||||
if paint_action == PaintAction.SELECT:
|
||||
if clicked:
|
||||
selection_start = Vector2i(-1,-1)
|
||||
queue_redraw()
|
||||
if selection_start.x < 0:
|
||||
selection_start = current_position
|
||||
selection_end = current_position
|
||||
|
||||
selection_rect = Rect2i(selection_start, selection_end - selection_start).abs()
|
||||
var selected_tile_parts = tile_parts_from_rect(selection_rect)
|
||||
selected_tile_states = []
|
||||
for t in selected_tile_parts:
|
||||
var state := {
|
||||
part = t,
|
||||
base_rect = Rect2(t.rect.position / zoom_level, t.rect.size / zoom_level),
|
||||
paint = paint,
|
||||
sides = BetterTerrain.tile_peering_for_type(t.data, paint),
|
||||
symmetry = BetterTerrain.get_tile_symmetry_type(t.data)
|
||||
}
|
||||
selected_tile_states.push_back(state)
|
||||
else:
|
||||
if !highlighted_tile_part.valid:
|
||||
return
|
||||
#slightly crude and non-optimal but way simpler than the "correct" solution
|
||||
var current_position_vec2 = Vector2(current_position)
|
||||
var prev_position_vec2 = Vector2(prev_position)
|
||||
var mouse_dist = current_position_vec2.distance_to(prev_position_vec2)
|
||||
var step_size = (tile_part_size.x * zoom_level)
|
||||
var steps = ceil(mouse_dist / step_size) + 1
|
||||
for i in range(steps):
|
||||
var t = float(i) / steps
|
||||
var check_position = prev_position_vec2.lerp(current_position_vec2, t)
|
||||
highlighted_tile_part = tile_part_from_position(check_position)
|
||||
|
||||
if !highlighted_tile_part.valid:
|
||||
continue
|
||||
|
||||
if paint_action == PaintAction.DRAW_TYPE or paint_action == PaintAction.ERASE_TYPE:
|
||||
var type := BetterTerrain.get_tile_terrain_type(highlighted_tile_part.data)
|
||||
var goal := paint if paint_action == PaintAction.DRAW_TYPE else BetterTerrain.TileCategory.NON_TERRAIN
|
||||
if type != goal:
|
||||
undo_manager.create_action("Set tile terrain type " + str(terrain_undo.action_index), UndoRedo.MERGE_ALL, tileset, true)
|
||||
terrain_undo.add_do_method(undo_manager, BetterTerrain, &"set_tile_terrain_type", [tileset, highlighted_tile_part.data, goal])
|
||||
terrain_undo.add_do_method(undo_manager, self, &"queue_redraw", [])
|
||||
if goal == BetterTerrain.TileCategory.NON_TERRAIN:
|
||||
terrain_undo.create_peering_restore_point_tile(
|
||||
undo_manager,
|
||||
tileset,
|
||||
highlighted_tile_part.source_id,
|
||||
highlighted_tile_part.coord,
|
||||
highlighted_tile_part.alternate
|
||||
)
|
||||
else:
|
||||
undo_manager.add_undo_method(BetterTerrain, &"set_tile_terrain_type", tileset, highlighted_tile_part.data, type)
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
terrain_undo.action_count += 1
|
||||
elif paint_action == PaintAction.DRAW_PEERING:
|
||||
if highlighted_tile_part.has("peering"):
|
||||
if !(paint in BetterTerrain.tile_peering_types(highlighted_tile_part.data, highlighted_tile_part.peering)):
|
||||
undo_manager.create_action("Set tile terrain peering type " + str(terrain_undo.action_index), UndoRedo.MERGE_ALL, tileset, true)
|
||||
terrain_undo.add_do_method(undo_manager, BetterTerrain, &"add_tile_peering_type", [tileset, highlighted_tile_part.data, highlighted_tile_part.peering, paint])
|
||||
terrain_undo.add_do_method(undo_manager, self, &"queue_redraw", [])
|
||||
undo_manager.add_undo_method(BetterTerrain, &"remove_tile_peering_type", tileset, highlighted_tile_part.data, highlighted_tile_part.peering, paint)
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
terrain_undo.action_count += 1
|
||||
elif paint_action == PaintAction.ERASE_PEERING:
|
||||
if highlighted_tile_part.has("peering"):
|
||||
if paint in BetterTerrain.tile_peering_types(highlighted_tile_part.data, highlighted_tile_part.peering):
|
||||
undo_manager.create_action("Remove tile terrain peering type " + str(terrain_undo.action_index), UndoRedo.MERGE_ALL, tileset, true)
|
||||
terrain_undo.add_do_method(undo_manager, BetterTerrain, &"remove_tile_peering_type", [tileset, highlighted_tile_part.data, highlighted_tile_part.peering, paint])
|
||||
terrain_undo.add_do_method(undo_manager, self, &"queue_redraw", [])
|
||||
undo_manager.add_undo_method(BetterTerrain, &"add_tile_peering_type", tileset, highlighted_tile_part.data, highlighted_tile_part.peering, paint)
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
terrain_undo.action_count += 1
|
||||
elif paint_action == PaintAction.DRAW_SYMMETRY:
|
||||
if paint == BetterTerrain.get_tile_terrain_type(highlighted_tile_part.data):
|
||||
undo_manager.create_action("Set tile symmetry type " + str(terrain_undo.action_index), UndoRedo.MERGE_ALL, tileset, true)
|
||||
var old_symmetry = BetterTerrain.get_tile_symmetry_type(highlighted_tile_part.data)
|
||||
terrain_undo.add_do_method(undo_manager, BetterTerrain, &"set_tile_symmetry_type", [tileset, highlighted_tile_part.data, paint_symmetry])
|
||||
terrain_undo.add_do_method(undo_manager, self, &"queue_redraw", [])
|
||||
undo_manager.add_undo_method(BetterTerrain, &"set_tile_symmetry_type", tileset, highlighted_tile_part.data, old_symmetry)
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
terrain_undo.action_count += 1
|
||||
elif paint_action == PaintAction.ERASE_SYMMETRY:
|
||||
if paint == BetterTerrain.get_tile_terrain_type(highlighted_tile_part.data):
|
||||
undo_manager.create_action("Remove tile symmetry type " + str(terrain_undo.action_index), UndoRedo.MERGE_ALL, tileset, true)
|
||||
var old_symmetry = BetterTerrain.get_tile_symmetry_type(highlighted_tile_part.data)
|
||||
terrain_undo.add_do_method(undo_manager, BetterTerrain, &"set_tile_symmetry_type", [tileset, highlighted_tile_part.data, BetterTerrain.SymmetryType.NONE])
|
||||
terrain_undo.add_do_method(undo_manager, self, &"queue_redraw", [])
|
||||
undo_manager.add_undo_method(BetterTerrain, &"set_tile_symmetry_type", tileset, highlighted_tile_part.data, old_symmetry)
|
||||
undo_manager.add_undo_method(self, &"queue_redraw")
|
||||
undo_manager.commit_action()
|
||||
terrain_undo.action_count += 1
|
||||
|
||||
|
||||
func _on_zoom_value_changed(value) -> void:
|
||||
zoom_level = value
|
||||
custom_minimum_size.x = zoom_level * tiles_size.x
|
||||
if alternate_size.x > 0:
|
||||
custom_minimum_size.x += ALTERNATE_TILE_MARGIN + zoom_level * alternate_size.x
|
||||
custom_minimum_size.y = zoom_level * max(tiles_size.y, alternate_size.y)
|
||||
queue_redraw()
|
||||
|
||||
|
||||
func clear_highlighted_tile() -> void:
|
||||
highlighted_tile_part = { valid = false }
|
||||
queue_redraw()
|
Reference in New Issue
Block a user