349 lines
9.7 KiB
GDScript
349 lines
9.7 KiB
GDScript
extends Control
|
|
|
|
onready var map_menu := ($menu/menubar/MapMenu as MenuButton).get_popup()
|
|
onready var map_node := $map
|
|
onready var cursor := $map/cursor
|
|
onready var cursor_sprite := $map/cursor/preview
|
|
|
|
const MAP_SCALE_MAX := 8.0
|
|
const MAP_SCALE_MIN := 0.25
|
|
|
|
const TileTabScene := preload("res://Scenes/Editor/TileTab.tscn")
|
|
|
|
const objects = {
|
|
"Machines": [
|
|
GameObjectComputer,
|
|
GameObjectDoor,
|
|
GameObjectEngine,
|
|
GameObjectLightbulb,
|
|
GameObjectPowerStorage
|
|
]
|
|
}
|
|
|
|
func _ready():
|
|
# Add tiles
|
|
add_tile_tab("Base", $map/tiles/base)
|
|
add_tile_tab("Cables", $map/tiles/cables)
|
|
add_tile_tab("Floors", $map/tiles/floor)
|
|
add_tile_tab("Walls", $map/tiles/walls)
|
|
# Add objects
|
|
for cat in objects:
|
|
add_object_list(cat, objects[cat])
|
|
|
|
enum PlacingMode {
|
|
NONE,
|
|
TILEMAP,
|
|
OBJECT
|
|
}
|
|
|
|
enum Tool {
|
|
NONE
|
|
TILE_FREEHAND,
|
|
TILE_RECT,
|
|
TILE_FILL,
|
|
OBJ_PLACE,
|
|
OBJ_EDIT,
|
|
OBJ_REMOVE
|
|
}
|
|
|
|
# Prevent input handler from running when other dialogs/actions are focused
|
|
var input_lock := false
|
|
|
|
# Drag variables
|
|
var dragging := false
|
|
var view_origin := Vector2.ZERO
|
|
var mouse_origin := Vector2.ZERO
|
|
|
|
# Placing variables
|
|
var placing := false
|
|
var deleting := false
|
|
var placing_mode = PlacingMode.NONE
|
|
var placing_layer = null
|
|
var placing_tile_id := -1
|
|
var current_tool = Tool.NONE
|
|
|
|
# Cursor variables
|
|
var cursor_pos := Vector2.ZERO
|
|
var pressed_pos := Vector2.ZERO
|
|
|
|
const TILE_SIZE := 32
|
|
|
|
func _input(ev: InputEvent):
|
|
if input_lock:
|
|
return
|
|
|
|
if ev is InputEventMouseMotion:
|
|
if dragging:
|
|
map_node.global_position = view_origin - (mouse_origin - ev.global_position)
|
|
else:
|
|
# Map cursor location to grid
|
|
var tile_snap: Vector2 = map_node.scale * TILE_SIZE
|
|
var mouse_offset: Vector2 = (ev.global_position - map_node.global_position) / tile_snap
|
|
var new_cursor_pos := Vector2(floor(mouse_offset.x), floor(mouse_offset.y))
|
|
if new_cursor_pos != cursor_pos:
|
|
var old_pos = cursor_pos
|
|
cursor_pos = new_cursor_pos
|
|
if placing or deleting:
|
|
if current_tool != Tool.NONE:
|
|
tile_mouse_move(old_pos, cursor_pos)
|
|
cursor.position = cursor_pos * TILE_SIZE
|
|
|
|
if ev is InputEventMouseButton:
|
|
var mouse := ev as InputEventMouseButton
|
|
if mouse.pressed:
|
|
match ev.button_index:
|
|
BUTTON_LEFT, BUTTON_RIGHT:
|
|
if current_tool != Tool.NONE:
|
|
tile_pressed(ev.button_index, cursor_pos)
|
|
BUTTON_WHEEL_UP:
|
|
# Zoom in
|
|
var old_scale = map_node.scale
|
|
if map_node.scale.x < MAP_SCALE_MAX:
|
|
if map_node.scale.x < 1:
|
|
map_node.scale *= 2
|
|
else:
|
|
map_node.scale += Vector2.ONE
|
|
map_node.position -= (map_node.position + mouse.position * map_node.scale)- (map_node.position + mouse.position * old_scale)
|
|
BUTTON_WHEEL_DOWN:
|
|
# Zoom out
|
|
var old_scale = map_node.scale
|
|
if map_node.scale.x > MAP_SCALE_MIN:
|
|
if map_node.scale.x <= 1:
|
|
map_node.scale /= 2
|
|
else:
|
|
map_node.scale -= Vector2.ONE
|
|
map_node.position -= (map_node.position + mouse.position * map_node.scale)- (map_node.position + mouse.position * old_scale)
|
|
BUTTON_MIDDLE:
|
|
view_origin = map_node.global_position
|
|
mouse_origin = ev.global_position
|
|
dragging = true
|
|
else:
|
|
match ev.button_index:
|
|
BUTTON_LEFT, BUTTON_RIGHT:
|
|
if current_tool != Tool.NONE:
|
|
tile_released(ev.button_index, cursor_pos)
|
|
BUTTON_MIDDLE:
|
|
dragging = false
|
|
map_node.global_position = view_origin - (mouse_origin - ev.global_position)
|
|
|
|
func place_rect(a: Vector2, b: Vector2, id: int):
|
|
if placing_layer == null:
|
|
return
|
|
var layer := placing_layer as TileMap
|
|
# Sort coordinates
|
|
var x_ord = Vector2(a.x, b.x)
|
|
var y_ord = Vector2(a.y, b.y)
|
|
if a.x > b.x:
|
|
x_ord = Vector2(b.x, a.x)
|
|
if a.y > b.y:
|
|
y_ord = Vector2(b.y, a.y)
|
|
for x in range(x_ord.x, x_ord.y+1):
|
|
place_tile(layer, Vector2(x, a.y), id)
|
|
place_tile(layer, Vector2(x, b.y), id)
|
|
for y in range(y_ord.x, y_ord.y+1):
|
|
place_tile(layer, Vector2(a.x, y), id)
|
|
place_tile(layer, Vector2(b.x, y), id)
|
|
layer.update_bitmask_region(a, b)
|
|
|
|
func place_tile(tilemap: TileMap, pos: Vector2, id: int):
|
|
# Place tile
|
|
tilemap.set_cellv(pos, id)
|
|
# If no base is under that tile, add it
|
|
if id != -1 and tilemap != $map/tiles/base:
|
|
if $map/tiles/base.get_cellv(pos) == -1:
|
|
$map/tiles/base.set_cellv(pos, 1)
|
|
|
|
func place_tiles(tilemap: TileMap, positions: Array, id: int):
|
|
for pos in positions:
|
|
place_tile(tilemap, pos, id)
|
|
for pos in positions:
|
|
# Update bitmask
|
|
tilemap.update_bitmask_area(pos)
|
|
|
|
var group := ButtonGroup.new()
|
|
|
|
func add_tile_tab(name: String, tilemap: TileMap):
|
|
var tab := add_tab(name)
|
|
tab.connect("tile_selected", self, "_tile_selected", [name, tilemap])
|
|
var tileset := tilemap.tile_set
|
|
var ids := tileset.get_tiles_ids()
|
|
for id in ids:
|
|
var tile_icon := make_tile_texture(tileset, id)
|
|
tab.add_entry(id, group, tile_icon)
|
|
|
|
func add_tab(name: String) -> TileTab:
|
|
var tab := TileTabScene.instance() as TileTab
|
|
tab.name = name
|
|
$layers/tabs.add_child(tab)
|
|
return tab
|
|
|
|
func add_object_list(name: String, objects: Array):
|
|
var tab := ItemList.new()
|
|
tab.connect("item_selected", self, "_item_selected", [tab])
|
|
tab.name = name
|
|
for obj in objects:
|
|
var editor_info = obj.editor_info()
|
|
tab.add_item(editor_info.name, editor_info.icon)
|
|
tab.set_item_metadata(tab.get_item_count()-1, editor_info)
|
|
$objects/tabs.add_child(tab)
|
|
|
|
func _item_selected(idx: int, tab: ItemList):
|
|
var meta = tab.get_item_metadata(idx)
|
|
cursor_sprite.texture = meta.icon
|
|
|
|
func _toggle_tile_input(enable: bool):
|
|
input_lock = not enable
|
|
|
|
func _tile_selected(id: int, _name: String, tilemap: TileMap):
|
|
cursor_sprite.texture = make_tile_texture(tilemap.tile_set, id)
|
|
placing_mode = PlacingMode.TILEMAP
|
|
placing_layer = tilemap
|
|
placing_tile_id = id
|
|
|
|
func make_tile_texture(tileset: TileSet, id: int) -> AtlasTexture:
|
|
var tile_mode := tileset.tile_get_tile_mode(id)
|
|
var tile_icon := AtlasTexture.new()
|
|
tile_icon.atlas = tileset.tile_get_texture(id)
|
|
match tile_mode:
|
|
TileSet.AUTO_TILE:
|
|
var tile_size := tileset.autotile_get_size(id)
|
|
tile_icon.region = Rect2(
|
|
tileset.autotile_get_icon_coordinate(id) * tile_size,
|
|
tile_size
|
|
)
|
|
TileSet.SINGLE_TILE:
|
|
tile_icon.region = tileset.tile_get_region(id)
|
|
return tile_icon
|
|
|
|
onready var layers_panel = $layers
|
|
onready var objects_panel = $objects
|
|
onready var brush_panel = $tools/brushPanel
|
|
onready var obj_action_panel = $tools/objPanel
|
|
func _tool_selected(tool_type):
|
|
layers_panel.visible = false
|
|
brush_panel.visible = false
|
|
objects_panel.visible = false
|
|
obj_action_panel.visible = false
|
|
placing_mode = PlacingMode.NONE
|
|
match tool_type:
|
|
"tile":
|
|
layers_panel.visible = tool_type(current_tool) == "brush"
|
|
brush_panel.visible = true
|
|
placing_mode = PlacingMode.TILEMAP
|
|
"obj":
|
|
obj_action_panel.visible = true
|
|
objects_panel.visible = tool_type(current_tool) == "obj"
|
|
placing_mode = PlacingMode.OBJECT
|
|
|
|
func _set_brush(brush_type: String):
|
|
match brush_type:
|
|
"freehand":
|
|
current_tool = Tool.TILE_FREEHAND
|
|
"rect":
|
|
current_tool = Tool.TILE_RECT
|
|
"fill":
|
|
current_tool = Tool.TILE_FILL
|
|
layers_panel.visible = true
|
|
|
|
func tool_type(brush):
|
|
match brush:
|
|
Tool.TILE_FILL, Tool.TILE_FREEHAND, Tool.TILE_RECT:
|
|
return "brush"
|
|
Tool.OBJ_EDIT, Tool.OBJ_PLACE, Tool.OBJ_REMOVE:
|
|
return "obj"
|
|
_:
|
|
return "none"
|
|
|
|
var ff_cells = {}
|
|
var ff_origin = Vector2.ZERO
|
|
|
|
const BOUNDS_MAX_X = 40
|
|
const BOUNDS_MAX_Y = 40
|
|
|
|
# Sanity check: force bounds for cell
|
|
func ff_is_inbound(cell: Vector2):
|
|
return abs(cell.x-ff_origin.x) < BOUNDS_MAX_X and abs(cell.y-ff_origin.y) < BOUNDS_MAX_Y
|
|
|
|
func ff_is_valid(tilemap: TileMap, cell: Vector2, matching_tile: int) -> bool:
|
|
return ff_is_inbound(cell) and (not ff_cells.has(cell)) and tilemap.get_cellv(cell) == matching_tile
|
|
|
|
func ff_get_neighbours(tilemap: TileMap, cell: Vector2, matching_tile: int) -> Array:
|
|
var neighbours = [Vector2(cell.x, cell.y-1),Vector2(cell.x-1, cell.y),Vector2(cell.x+1, cell.y), Vector2(cell.x, cell.y+1)]
|
|
var out = []
|
|
for neighbour in neighbours:
|
|
# Have we checked this already?
|
|
if not ff_is_valid(tilemap, neighbour, matching_tile):
|
|
continue
|
|
out.push_back(neighbour)
|
|
return out
|
|
|
|
func flood_fill(tilemap: TileMap, pos: Vector2, id: int):
|
|
# Reset lists
|
|
ff_cells = {}
|
|
ff_origin = pos
|
|
var current_tile = tilemap.get_cellv(pos)
|
|
var queue = ff_get_neighbours(tilemap, pos, current_tile)
|
|
place_tile(tilemap, pos, id)
|
|
ff_cells[pos] = true
|
|
# Depth-first search
|
|
while not queue.empty():
|
|
var current = queue.pop_front()
|
|
# Have we checked this already?
|
|
if not ff_is_valid(tilemap, current, current_tile):
|
|
continue
|
|
var tile_id = tilemap.get_cellv(current)
|
|
if tile_id == current_tile:
|
|
ff_cells[current] = true
|
|
place_tile(tilemap, current, id)
|
|
for neighbour in ff_get_neighbours(tilemap, current, current_tile):
|
|
queue.push_front(neighbour)
|
|
tilemap.update_bitmask_region()
|
|
|
|
func _set_obj_action(action):
|
|
match action:
|
|
"add":
|
|
current_tool = Tool.OBJ_PLACE
|
|
"edit":
|
|
current_tool = Tool.OBJ_EDIT
|
|
"remove":
|
|
current_tool = Tool.OBJ_REMOVE
|
|
objects_panel.visible = true
|
|
|
|
func tile_pressed(button: int, pos: Vector2):
|
|
match button:
|
|
BUTTON_LEFT:
|
|
placing = true
|
|
BUTTON_RIGHT:
|
|
deleting = true
|
|
match current_tool:
|
|
Tool.TILE_FREEHAND:
|
|
if placing_layer != null:
|
|
place_tiles(placing_layer, [pos], get_active_tile())
|
|
Tool.OBJ_PLACE:
|
|
pass
|
|
pressed_pos = pos
|
|
|
|
func tile_released(button: int, pos: Vector2):
|
|
match current_tool:
|
|
Tool.TILE_RECT:
|
|
if placing_layer != null:
|
|
place_rect(pressed_pos, pos, get_active_tile())
|
|
Tool.TILE_FILL:
|
|
if placing_layer != null:
|
|
flood_fill(placing_layer, pos, get_active_tile())
|
|
match button:
|
|
BUTTON_LEFT:
|
|
placing = false
|
|
BUTTON_RIGHT:
|
|
deleting = false
|
|
|
|
func tile_mouse_move(_from: Vector2, to: Vector2):
|
|
match current_tool:
|
|
Tool.TILE_FREEHAND:
|
|
if placing_layer != null:
|
|
place_tiles(placing_layer, [to], get_active_tile())
|
|
|
|
func get_active_tile():
|
|
if deleting:
|
|
return -1
|
|
return placing_tile_id
|