346 lines
9.3 KiB
GDScript
346 lines
9.3 KiB
GDScript
extends Node3D
|
|
|
|
class_name Place
|
|
|
|
var tile_grid_size: int = 8
|
|
|
|
var load_tile = preload("res://tiles/base_tile/base_tile.tscn")
|
|
var load_room = preload("res://places/base_place/base_room.tscn")
|
|
var load_door = preload("res://tiles/base_tile/base_door.tscn")
|
|
|
|
#Contains all tiles in a workplace.
|
|
var place_tile_dict: Dictionary = {}
|
|
|
|
#Contains the tiles in the current selection drag
|
|
var selection_drag_dict: Dictionary = {}
|
|
#Contains all the tiles that have been selected in the current build
|
|
var selection_dict: Dictionary = {}
|
|
|
|
#Contains all rooms in a workplace.
|
|
var place_room_array: Array = []
|
|
|
|
#Tracks the previous amount of tiles counted in a selection drac
|
|
var tile_count_x_hist: int = 0
|
|
var tile_count_z_hist: int = 0
|
|
|
|
#Tracks is confirming a build is allowed
|
|
var build_confirm_allowed: bool = true
|
|
|
|
#Tracks parts of the room currently being built
|
|
var current_room: Object = null
|
|
var current_room_walls: Array = []
|
|
var current_door: Object = null
|
|
|
|
func _ready():
|
|
|
|
pass
|
|
|
|
func place_tile_check(new_dict):
|
|
place_tile_dict = new_dict
|
|
#if type_string(typeof(new_dict)) == "Array":
|
|
#for i in new_dict:
|
|
#
|
|
#place_tile_dict[]
|
|
|
|
|
|
func init_grid():
|
|
|
|
#TEMP: Sets up a simple 2D grid of blank tiles.
|
|
|
|
for x in range(tile_grid_size):
|
|
for z in range (tile_grid_size):
|
|
var pos = Vector3i(x, 0, z)
|
|
|
|
var tile: Object = load_tile.instantiate()
|
|
tile.set_position(pos)
|
|
|
|
tile.grid_pos = pos
|
|
tile.name = str("Tile", tile.get_instance_id())
|
|
tile.place_id = self.get_instance_id()
|
|
tile.selection_mode = Tile.SEL_MODE.NONE
|
|
tile.construction_mode = Tile.CON_MODE.CLOSED
|
|
|
|
place_tile_dict[pos] = tile
|
|
|
|
$TileContainer.add_child(tile)
|
|
|
|
#var pos = Vector3i(1, 0, 1)
|
|
#
|
|
#var tile = place_tile_dict[pos]
|
|
#
|
|
#var trickydict = {pos: tile}
|
|
#
|
|
#tile.room = create_room(trickydict)
|
|
#
|
|
#tile.construction_mode = Tile.CON_MODE.BUILT
|
|
#
|
|
#selection_drag_dict[pos] = tile
|
|
#end_select_drag()
|
|
#build_selection()
|
|
|
|
func save():
|
|
var save_data = {
|
|
# Basics
|
|
"name": name,
|
|
"type": "Place",
|
|
"id": self.get_instance_id(),
|
|
"scene_file_path": scene_file_path,
|
|
"parent": get_parent().get_path(),
|
|
# Connections
|
|
# Data
|
|
}
|
|
return save_data
|
|
|
|
func draw_tile_click(click_pos):
|
|
#starts a selection drag
|
|
|
|
var build_start_pos: Vector3i = click_pos.floor()
|
|
|
|
if place_tile_dict.has(build_start_pos):
|
|
if not place_tile_dict[build_start_pos].construction_mode == Tile.CON_MODE.BUILT:
|
|
select_tile(build_start_pos)
|
|
|
|
func init_select_drag(float_build_start_pos, float_build_mouse_pos):
|
|
#Creats an array of dragged tiles between mouse start and current position
|
|
|
|
var select_drag_array: Array = []
|
|
|
|
var build_start_pos: Vector3i = float_build_start_pos.floor()
|
|
var build_mouse_pos: Vector3i = float_build_mouse_pos.floor()
|
|
|
|
var tile_count_x: int = build_mouse_pos.x - build_start_pos.x
|
|
var tile_count_z: int = build_mouse_pos.z - build_start_pos.z
|
|
|
|
if not tile_count_x_hist == tile_count_x or not tile_count_z_hist == tile_count_z:
|
|
|
|
tile_count_x_hist = tile_count_x
|
|
tile_count_z_hist = tile_count_z
|
|
|
|
for x in range(min(0, tile_count_x), max(0, tile_count_x) + 1):
|
|
for z in range(min(0, tile_count_z), max(0, tile_count_z) + 1):
|
|
var select_drag_pos: Vector3i = build_start_pos + Vector3i(x, 0, z)
|
|
if place_tile_dict.has(select_drag_pos):
|
|
if not place_tile_dict[select_drag_pos].construction_mode == Tile.CON_MODE.BUILT:
|
|
select_drag_array.append(select_drag_pos)
|
|
|
|
if select_drag_array:
|
|
draw_select_drag(select_drag_array)
|
|
|
|
func draw_select_drag(array):
|
|
#Clears previous drag, then calls tile selection on all currently dragged tiles
|
|
|
|
for i in place_tile_dict:
|
|
if not selection_dict.has(i):
|
|
var tile: Object = place_tile_dict[i]
|
|
tile.selection_mode = Tile.SEL_MODE.NONE
|
|
|
|
selection_drag_dict.clear()
|
|
|
|
for i in array:
|
|
select_tile(i)
|
|
|
|
func select_tile(pos):
|
|
#Tells tiles to be selected
|
|
|
|
var tile: Object = place_tile_dict[pos]
|
|
|
|
selection_drag_dict[pos] = tile
|
|
|
|
if build_confirm_allowed:
|
|
tile.selection_mode = Tile.SEL_MODE.BUILD
|
|
else:
|
|
tile.selection_mode = Tile.SEL_MODE.INVALID
|
|
|
|
func verify_room():
|
|
#Verifies that a given selection is fully contiguous
|
|
|
|
var verify_array: Array = selection_dict.keys()
|
|
var verify_queue_array: Array = [verify_array[0]]
|
|
var verify_checked_array: Array = []
|
|
|
|
while verify_array:
|
|
if not verify_queue_array:
|
|
|
|
return false
|
|
|
|
var verify_pos: Vector3i = verify_queue_array.pop_back()
|
|
|
|
var verify_neighbor_array: Array = place_tile_dict[verify_pos].direction_vector_dict.values()
|
|
|
|
for n in verify_neighbor_array:
|
|
|
|
if selection_dict.has(verify_pos + n):
|
|
if not verify_checked_array.has(verify_pos + n):
|
|
if not verify_queue_array.has(verify_pos + n):
|
|
verify_queue_array.append(verify_pos + n)
|
|
|
|
verify_checked_array.append(verify_pos)
|
|
verify_array.erase(verify_pos)
|
|
|
|
return true
|
|
|
|
func end_select_drag():
|
|
#Adds dragged tiles to the current selection on mouse-up
|
|
|
|
tile_count_x_hist = 0
|
|
tile_count_z_hist = 0
|
|
|
|
selection_dict.merge(selection_drag_dict)
|
|
|
|
#for i in selection_dict.keys():
|
|
#var tile:Object = selection_dict[i]
|
|
#for j in range(4):
|
|
#tile.update_face(j, Tile.FACE_MODE.NONE)
|
|
#for j in range(4):
|
|
#if not selection_dict.has(i + tile.direction_vector_array[j]):
|
|
#tile.update_face(j, Tile.FACE_MODE.FULL)
|
|
|
|
if verify_room():
|
|
build_confirm_allowed = true
|
|
for i in selection_dict:
|
|
place_tile_dict[i].selection_mode = Tile.SEL_MODE.BUILD
|
|
else:
|
|
build_confirm_allowed = false
|
|
for i in selection_dict:
|
|
place_tile_dict[i].selection_mode = Tile.SEL_MODE.INVALID
|
|
|
|
selection_drag_dict.clear()
|
|
|
|
func build_selection():
|
|
#When the build button is clicked, changes the selected tiles to match the button's request
|
|
|
|
if not build_confirm_allowed:
|
|
return
|
|
|
|
if selection_dict:
|
|
|
|
var room: Object = create_room(selection_dict)
|
|
|
|
for i in selection_dict:
|
|
var tile: Object = place_tile_dict[i]
|
|
tile.selection_mode = Tile.SEL_MODE.NONE
|
|
tile.construction_mode = Tile.CON_MODE.BUILT
|
|
|
|
selection_dict.clear()
|
|
|
|
#return room
|
|
|
|
func clear_selection():
|
|
#When the clear button is clicked, it clears the selected tiles without doing anything.
|
|
|
|
for i in selection_dict:
|
|
var tile: Object = selection_dict[i]
|
|
tile.selection_mode = Tile.SEL_MODE.NONE
|
|
build_confirm_allowed = true
|
|
|
|
#for i in selection_dict.keys():
|
|
#var tile: Object = selection_dict[i]
|
|
#for j in range(4):
|
|
#tile.update_face(j, Tile.FACE_MODE.NONE)
|
|
|
|
selection_dict.clear()
|
|
|
|
func create_room(selection):
|
|
#Creates a room from the selected tiles.
|
|
|
|
var room: Object = load_room.instantiate()
|
|
|
|
room.position = (selection.keys().min())
|
|
|
|
room.room_tile_array = selection.values()
|
|
room.place_id = self.get_instance_id()
|
|
|
|
room.name = str("Room", room.get_instance_id())
|
|
|
|
$RoomContainer.add_child(room)
|
|
|
|
for i in room.room_tile_array:
|
|
i.room_array.append(room)
|
|
|
|
place_room_array.append(room)
|
|
|
|
return room
|
|
|
|
func create_door():
|
|
#Creates a door to be placed.
|
|
|
|
for i in current_room.room_tile_dict.keys():
|
|
for j in current_room.room_tile_dict[i].wall_dict.keys():
|
|
current_room_walls.append((Vector3(i) + Vector3(0.5, 0, 0.5)) + Vector3(j) / 2)
|
|
|
|
var door: Object = load_door.instantiate()
|
|
|
|
door.room = current_room
|
|
|
|
add_child(door)
|
|
|
|
current_door = door
|
|
|
|
func hover_door(mouse_pos):
|
|
#Hovers the door at the closest wall segment to the mouse in the current room
|
|
|
|
if not current_door:
|
|
create_door()
|
|
|
|
var closest: Vector3
|
|
var closest_distance: float = INF
|
|
|
|
for i in current_room_walls:
|
|
var distance: float = mouse_pos.distance_to(i)
|
|
if closest_distance > distance:
|
|
closest_distance = distance
|
|
closest = i
|
|
|
|
current_door.position = closest
|
|
current_door.rotation_degrees = Vector3(0, 180 * fmod(closest.z, 1), 0)
|
|
|
|
#func confirm_door():
|
|
##Builds the door at the hovered location
|
|
#
|
|
#var tile_1: Object
|
|
#var tile_2: Object
|
|
#
|
|
#if fmod(current_door.position.x, 1) == 0:
|
|
#tile_1 = place_tile_dict[Vector3i(current_door.position.x, 0, current_door.position.z)]
|
|
#tile_2 = place_tile_dict[Vector3i(current_door.position.x - 1, 0, current_door.position.z)]
|
|
#else:
|
|
#tile_1 = place_tile_dict[Vector3i(current_door.position.x, 0, current_door.position.z)]
|
|
#tile_2 = place_tile_dict[Vector3i(current_door.position.x, 0, current_door.position.z - 1)]
|
|
#
|
|
#var tile_1_door_face: Vector3i = tile_2.position - tile_1.position
|
|
#
|
|
#var tile_1_door_face_direction: int = tile_1.direction_vector_array.find(tile_1_door_face)
|
|
#
|
|
#tile_1.update_face(tile_1_door_face_direction, Tile.FACE_MODE.DOOR, current_door)
|
|
#
|
|
#var tile_1_room: Object = tile_1.room_id
|
|
#
|
|
#tile_1_room.room_door_array.append(current_door)
|
|
#
|
|
#var tile_2_door_face: Vector3i = tile_1.position - tile_2.position
|
|
#
|
|
#var tile_2_door_face_direction: int = tile_2.direction_vector_array.find(tile_2_door_face)
|
|
#
|
|
#tile_2.update_face(tile_2_door_face_direction, Tile.FACE_MODE.DOOR, current_door)
|
|
#
|
|
#var tile_2_room: Object = tile_2.room_id
|
|
#
|
|
#tile_2_room.room_door_array.append(current_door)
|
|
#
|
|
#current_door.door_room_array = [tile_1_room, tile_2_room]
|
|
#
|
|
#current_room = null
|
|
#current_room_walls = []
|
|
#current_door = null
|
|
|
|
func give_neighbors(tile, grid_pos, directions):
|
|
var neighbor_dict = {}
|
|
for i in directions.keys():
|
|
if place_tile_dict.has(directions[i] + grid_pos):
|
|
neighbor_dict[directions[i]] = place_tile_dict[directions[i] + grid_pos]
|
|
tile.neighbor_dict = neighbor_dict
|
|
|
|
|
|
func _on_tile_container_child_entered_tree(node: Node) -> void:
|
|
node.connect("neighbor_request", give_neighbors)
|