Basic map creation and saving

actors/base_actor/base_actor.gd

@@ -0,0 +1,57 @@
+extends Node3D
+
+class_name Actor
+
+enum ACTOR_STATE {INACTIVE, ACTIVE}
+
+var actor_state = null: set = state_change
+
+const red = preload("res://tiles/base_tile/red.tres")
+
+var target = null
+var next_step = null
+
+var temp_speed = 4
+var time = 0
+
+var current_tile = null: set = change_current_tile
+var current_room = null
+
+signal current_tile_request
+
+func state_change(state):
+	actor_state = state
+	match state:
+		ACTOR_STATE.ACTIVE:
+			$SelfMesh.set_material_override(red)
+			next_step = Vector3(1, 0, 1)
+			
+
+func _process(delta: float) -> void:
+	#var velocity = Vector3.ZERO
+
+	if actor_state == ACTOR_STATE.ACTIVE:
+		
+		get_current_tile()
+		
+		if next_step:
+			if self.position.distance_to(next_step) > .1:
+				#velocity = self.position.direction_to(next_step) * temp_speed
+				position = lerp(next_step, self.position, 0.995)
+			else:
+				actor_state = ACTOR_STATE.INACTIVE
+
+func get_current_tile():
+	emit_signal("current_tile_request", self)
+
+func change_current_tile(new_tile):
+	if current_tile != new_tile:
+		current_tile = new_tile
+		get_room()
+		prints(current_tile, current_room)
+
+func get_room():
+	if current_tile.lookup_tile_to_room:
+		current_room = current_tile.lookup_tile_to_room[0] 
+	else:
+		current_room = null

actors/base_actor/base_actor.gd.uid

@@ -0,0 +1 @@
+uid://dilighbu5t233

actors/base_actor/base_actor.tscn

@@ -1,3 +1,11 @@
-[gd_scene format=3 uid="uid://jcmf542by4e6"]
+[gd_scene load_steps=3 format=3 uid="uid://jcmf542by4e6"]
+
+[ext_resource type="Script" uid="uid://dilighbu5t233" path="res://actors/base_actor/base_actor.gd" id="1_fkyrj"]
+
+[sub_resource type="CapsuleMesh" id="CapsuleMesh_wghh8"]
 
 [node name="BaseActor" type="Node3D"]
+script = ExtResource("1_fkyrj")
+
+[node name="SelfMesh" type="MeshInstance3D" parent="."]
+mesh = SubResource("CapsuleMesh_wghh8")

game.tscn

@@ -41,10 +41,24 @@ offset_right = 1142.0
 offset_bottom = 604.0
 text = "Load Map"
 
-[node name="Button" type="Button" parent="InterfaceLayer"]
+[node name="GridButton" type="Button" parent="InterfaceLayer"]
+offset_left = 18.0
+offset_top = 568.0
+offset_right = 89.0
+offset_bottom = 599.0
+text = "Init Grid"
+
+[node name="DoorButton" type="Button" parent="InterfaceLayer"]
+offset_left = 255.0
+offset_top = 603.0
+offset_right = 347.0
+offset_bottom = 634.0
+text = "Place Door"
+
+[node name="WorkerButton" type="Button" parent="InterfaceLayer"]
 offset_right = 8.0
 offset_bottom = 8.0
-text = "Init Grid"
+text = "Place Worker"
 
 [node name="GameCam" type="Camera3D" parent="."]
 transform = Transform3D(1, 0, 0, 0, 0.182236, 0.983255, 0, -0.983255, 0.182236, 24.5127, 23.2849, 20.9667)
@@ -60,5 +74,6 @@ script = ExtResource("5_7jktm")
 [connection signal="pressed" from="InterfaceLayer/BuildButton" to="PlaceManager" method="_on_confirm_button_pressed"]
 [connection signal="pressed" from="InterfaceLayer/SaveButton" to="SaveLoad" method="_on_save_button_pressed"]
 [connection signal="pressed" from="InterfaceLayer/LoadButton" to="SaveLoad" method="_on_load_button_pressed"]
-[connection signal="pressed" from="InterfaceLayer/Button" to="PlaceManager" method="_on_init_grid_button_pressed"]
+[connection signal="pressed" from="InterfaceLayer/GridButton" to="PlaceManager" method="_on_init_grid_button_pressed"]
-[connection signal="room_built" from="PlaceManager" to="InterfaceLayer/BuildToggle" method="_on_room_built"]
+[connection signal="pressed" from="InterfaceLayer/DoorButton" to="PlaceManager" method="_on_door_button_pressed"]
+[connection signal="pressed" from="InterfaceLayer/WorkerButton" to="PlaceManager" method="_on_worker_button_pressed"]

interface/save_load.gd

@@ -1,27 +1,35 @@
 extends Node
 
 class SaveData:
+	var id: int
 	var type: String
-	var position: Vector3
 	var parent: String
 	var scene_file_path: String
-	var id: int
+
+	var position: Vector3
+	var rotation_degrees
 
 #Connections
 	var place_id: int
-	var room_array: Array
+	var room_ids: Array
+	var tile_ids: Array
+	
+	var door_to_tile: Dictionary
 
 #Tile data
 	var grid_pos: Vector3i
 	var face_dict: Array
 	var construction_mode: int
 
+#
+
 func _init():
 	ObjectSerializer.register_scripts({
 	"SaveData": SaveData,
 	"Tile": Tile,
 	"Room": Room,
 	"Wall": Wall,
+	"Door": Door,
 })
 
 func _on_save_button_pressed() -> void:
@@ -57,22 +65,20 @@ func _on_load_button_pressed():
 		if i:
 			i.free()
 	
-	#if get_node("/root/Game/PlaceManager/BasePlace"):
-		#get_node("/root/Game/PlaceManager/BasePlace").free()
-	
 	var save_file = FileAccess.open("user://savegame.save", FileAccess.READ)
 	
 	var place_id_dict: Dictionary = {}
 	var room_id_dict: Dictionary = {}
+	var tile_id_dict: Dictionary = {}
 	
-	var load_place_room_array: Dictionary = {}
+	var load_place_to_room: Dictionary = {}
-	var load_place_tile_dict: Dictionary = {}
+	var load_place_to_tile: Dictionary = {}
-	var load_room_tile_array: Dictionary = {}
+	var load_room_to_tile: Dictionary = {}
+	var load_room_to_door: Dictionary = {}
+	var load_tile_to_door: Array = []
 	
 	while save_file.get_position() < save_file.get_length():
 		
-		
-		
 		var next_load_bytes = save_file.get_var()
 		var next_load = bytes_to_var(next_load_bytes)
 		var load_object = load(next_load["scene_file_path"]).instantiate()
@@ -80,55 +86,100 @@ func _on_load_button_pressed():
 		
 		match next_load["type"]:
 			"Place":
-				var new_place_id = load_object.get_instance_id()
+				place_id_dict[id] = load_object.get_instance_id()
-				place_id_dict[id] = new_place_id
+				load_place_to_room[load_object] = []
-				load_place_room_array[load_object] = []
+				load_place_to_tile[load_object] = {}
-				load_place_tile_dict[load_object] = {}
+				
 				for j in next_load.keys():
 					load_object.set(j, next_load[j])
 				get_node(next_load["parent"]).add_child(load_object)
 				
 			"Room":
 				room_id_dict[id] = load_object.get_instance_id()
-				load_room_tile_array[load_object] = []
+				load_room_to_tile[load_object] = []
+				load_room_to_door[load_object] = []
+				
 				for j in next_load.keys():
 					if j == "place_id":
 						var new_place_id = place_id_dict[next_load[j]]
 						var place = instance_from_id(new_place_id)
-						load_place_room_array[place].append(load_object)
+						load_place_to_room[place].append(load_object)
 						load_object.set(j, new_place_id)
 					else:
 						load_object.set(j, next_load[j])
-				get_node(next_load["parent"]).add_child(load_object)
+				instance_from_id(load_object["place_id"]).get_node("RoomContainer").add_child(load_object)
 				
 			"Tile":
+				tile_id_dict[id] = load_object.get_instance_id()
+				
 				for j in next_load.keys():
 					if j == "place_id":
 						var new_place_id = place_id_dict[next_load[j]]
 						var place = instance_from_id(new_place_id)
-						load_place_tile_dict[place].merge({next_load["grid_pos"]: load_object})
+						load_place_to_tile[place].merge({next_load["grid_pos"]: load_object})
 						load_object.set(j, new_place_id)
-					elif j == "room_array":
+					elif j == "room_ids":
-						for k in next_load["room_array"]:
+						for k in next_load["room_ids"]:
 							var new_room_id = room_id_dict[k]
 							var room = instance_from_id(new_room_id)
-							load_room_tile_array[room].append(load_object)
+							load_room_to_tile[room].append(load_object)
-							load_object[j].append(room)
+							load_object["lookup_tile_to_room"].append(room)
+					elif j == "face_dict":
+						if next_load[j]:
+							var temp_new_dict: Dictionary
+							for k in next_load[j]:
+								temp_new_dict[k] = null
+							load_object[j] = temp_new_dict.duplicate()
+					
 					else:
 						load_object.set(j, next_load[j])
-				get_node(next_load["parent"]).add_child(load_object)
+				instance_from_id(load_object["place_id"]).get_node("TileContainer").add_child(load_object)
+			
+			"Door":
+				for j in next_load.keys():
+					if j == "place_id":
+						var new_place_id = place_id_dict[next_load[j]]
+						var place = instance_from_id(new_place_id)
+						load_object.set(j, new_place_id)
+					elif j == "room_ids":
+						for k in next_load["room_ids"]:
+							var new_room_id = room_id_dict[k]
+							var room = instance_from_id(new_room_id)
+							load_room_to_door[room].append(load_object)
+							load_object["lookup_door_to_room"].append(room)
+					elif j == "door_to_tile":
+						var tile_dict = next_load["door_to_tile"]
+						for k in tile_dict.keys():
+							var new_tile_id = tile_id_dict[tile_dict[k]]
+							var tile = instance_from_id(new_tile_id)
+							
+							load_tile_to_door.append({tile: {k: load_object}})
+
+							load_object["lookup_door_to_tile"].merge({k: tile})
+					else:
+						load_object.set(j, next_load[j])
+				instance_from_id(load_object["place_id"]).get_node("ObjectContainer").add_child(load_object)
 
 			_:
 				for j in next_load.keys():
 					load_object.set(j, next_load[j])
 				get_node(next_load["parent"]).add_child(load_object)
 		
-	for i in load_place_room_array.keys():
+	for i in load_place_to_room.keys():
-		i.place_room_array = load_place_room_array[i]
+		i.lookup_place_to_room = load_place_to_room[i]
 	
-	for i in load_place_tile_dict.keys():
+	for i in load_place_to_tile.keys():
-		i.place_tile_dict.merge(load_place_tile_dict[i])
+		i.lookup_place_to_tile.merge(load_place_to_tile[i])
 
-	for i in load_room_tile_array.keys():
+	for i in load_room_to_tile.keys():
-		i.room_tile_array = load_room_tile_array[i]
+		i.room_to_tile = load_room_to_tile[i]
 	
+	for i in load_room_to_door.keys():
+		i.room_to_door = load_room_to_door[i]
+		
+	for i in load_tile_to_door:
+		for j in i.keys():
+			for k in i[j].keys():
+				var one = i[j]
+				var two = one[k]
+				j.face_dict[k] = two

objects/base_object.gd

@@ -0,0 +1,5 @@
+extends Node3D
+
+class_name GameObject
+
+enum PLACEMENTS {DOOR}

objects/base_object.gd.uid

@@ -0,0 +1 @@
+uid://ca63k51v37jyg

places/base_place/base_place.gd

@@ -1,24 +1,26 @@
 extends Node3D
-
 class_name Place
 
-var tile_grid_size: int = 8
+var tile_grid_size: int = 32
 
 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")
+var load_actor = preload("res://actors/base_actor/base_actor.tscn")
 
 #Contains all tiles in a workplace.
-var place_tile_dict: Dictionary = {}
+var lookup_place_to_tile: Dictionary = {}
+#Contains all rooms in a workplace.
+var lookup_place_to_room: Array = []
+
+
 
 #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
@@ -26,64 +28,17 @@ var tile_count_z_hist: int = 0
 #Tracks is confirming a build is allowed
 var build_confirm_allowed: bool = true
 
+var current_object: Object = null
+var current_placement: Array = []
+
 #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(),
+		"type": "Place",
 		"scene_file_path": scene_file_path,
 		"parent": get_parent().get_path(),
 #	Connections
@@ -91,13 +46,30 @@ func save():
 	}
 	return save_data
 
+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
+			
+			$TileContainer.add_child(tile)
+
 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 lookup_place_to_tile.has(build_start_pos):
-		if not place_tile_dict[build_start_pos].construction_mode == Tile.CON_MODE.BUILT:
+		if not lookup_place_to_tile[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):
@@ -119,8 +91,8 @@ func init_select_drag(float_build_start_pos, float_build_mouse_pos):
 		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 lookup_place_to_tile.has(select_drag_pos):
-					if not place_tile_dict[select_drag_pos].construction_mode == Tile.CON_MODE.BUILT:
+					if not lookup_place_to_tile[select_drag_pos].construction_mode == Tile.CON_MODE.BUILT:
 						select_drag_array.append(select_drag_pos)
 		
 		if select_drag_array:
@@ -129,9 +101,9 @@ func init_select_drag(float_build_start_pos, float_build_mouse_pos):
 func draw_select_drag(array):
 #Clears previous drag, then calls tile selection on all currently dragged tiles
 
-	for i in place_tile_dict:
+	for i in lookup_place_to_tile:
 		if not selection_dict.has(i):
-			var tile: Object = place_tile_dict[i]
+			var tile: Object = lookup_place_to_tile[i]
 			tile.selection_mode = Tile.SEL_MODE.NONE
 				
 	selection_drag_dict.clear()
@@ -142,7 +114,7 @@ func draw_select_drag(array):
 func select_tile(pos):
 #Tells tiles to be selected
 
-	var tile: Object = place_tile_dict[pos]
+	var tile: Object = lookup_place_to_tile[pos]
 	
 	selection_drag_dict[pos] = tile
 	
@@ -165,7 +137,7 @@ func verify_room():
 
 		var verify_pos: Vector3i = verify_queue_array.pop_back()
 		
-		var verify_neighbor_array: Array = place_tile_dict[verify_pos].direction_vector_dict.values()
+		var verify_neighbor_array: Array = lookup_place_to_tile[verify_pos].direction_vector_dict.values()
 		
 		for n in verify_neighbor_array:
 		
@@ -181,28 +153,22 @@ func verify_room():
 
 func end_select_drag():
 #Adds dragged tiles to the current selection on mouse-up
+	if not selection_drag_dict:
+		return
 	
 	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
+			lookup_place_to_tile[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
+			lookup_place_to_tile[i].selection_mode = Tile.SEL_MODE.INVALID
 			
 	selection_drag_dict.clear()
 
@@ -217,13 +183,13 @@ func build_selection():
 		var room: Object = create_room(selection_dict)
 		
 		for i in selection_dict:
-			var tile: Object = place_tile_dict[i]
+			var tile: Object = lookup_place_to_tile[i]
 			tile.selection_mode = Tile.SEL_MODE.NONE
 			tile.construction_mode = Tile.CON_MODE.BUILT
 		
 		selection_dict.clear()
 		
-		#return room
+		return room
 
 func clear_selection():
 #When the clear button is clicked, it clears the selected tiles without doing anything.
@@ -233,13 +199,11 @@ func clear_selection():
 		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.
 
@@ -247,99 +211,150 @@ func create_room(selection):
 	
 	room.position = (selection.keys().min())
 	
-	room.room_tile_array = selection.values()
+	room.room_to_tile = 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:
+	for i in room.room_to_tile:
-		i.room_array.append(room)
+		i.lookup_tile_to_room.append(room)
 	
-	place_room_array.append(room)
+	lookup_place_to_room.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
+func init_object(object):
 	
-	add_child(door)
+	match object: 
+		"door":
+			var door: Object = load_door.instantiate()
 			
-	current_door = door
+			init_object_locations(door)
 			
-func hover_door(mouse_pos):
+			door.place_id = self.get_instance_id()
+			door.visible = false
+			
+			$ObjectContainer.add_child(door)
+			
+			current_object = door
+			
+		"actor":
+			var actor: Actor = load_actor.instantiate()
+			
+			current_object = actor
+			
+			actor.visible = false
+			
+			$ActorContainer.add_child(actor)
+			
+		
+	
+
+func init_object_locations(object):
+	
+	match object.placement:
+		GameObject.PLACEMENTS.DOOR:
+
+			for i in lookup_place_to_tile.keys():
+				for j in lookup_place_to_tile[i].face_dict.keys():
+					if lookup_place_to_tile[i].face_dict[j] is not Door:
+						current_placement.append((Vector3(i) + Vector3(0.5, 0, 0.5)) + Vector3(j) / 2)
+
+func hover_object(mouse_pos):
 #Hovers the door at the closest wall segment to the mouse in the current room
 	
-	if not current_door:
+	current_object.visible = true
-		create_door()
 	
-	var closest: Vector3
+	if current_placement:
-	var closest_distance: float = INF
+		var closest: Vector3
+		var closest_distance: float = INF
 
-	for i in current_room_walls:
+		for i in current_placement:
-		var distance: float = mouse_pos.distance_to(i)
+			var distance: float = mouse_pos.distance_to(i)
-		if closest_distance > distance:
+			if closest_distance > distance:
-			closest_distance = distance
+				closest_distance = distance
-			closest = i
+				closest = i
 		
-	current_door.position = closest
+		current_object.position = closest
-	current_door.rotation_degrees = Vector3(0, 180 * fmod(closest.z, 1), 0)
+		current_object.rotation_degrees = Vector3(0, 180 * fmod(closest.x, 1), 0)
 		
-#func confirm_door():
+	else:
-##Builds the door at the hovered location
+		current_object.position = mouse_pos
-#
+
-	#var tile_1: Object
+func confirm_object():
-	#var tile_2: Object
+	
-#
+	var check = current_object.get_class()
-	#if fmod(current_door.position.x, 1) == 0:
+	if current_object is Door:
-		#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)]
+		var tile_1: Object
-	#else:
+		var tile_2: Object
-		#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)]
+		if fmod(current_object.position.x, 1) == 0:
-	#
+			tile_1 = lookup_place_to_tile[Vector3i(current_object.position.x, 0, current_object.position.z)]
-	#var tile_1_door_face: Vector3i = tile_2.position - tile_1.position
+			tile_2 = lookup_place_to_tile[Vector3i(current_object.position.x - 1, 0, current_object.position.z)]
-#
+		else:
-	#var tile_1_door_face_direction: int = tile_1.direction_vector_array.find(tile_1_door_face)
+			tile_1 = lookup_place_to_tile[Vector3i(current_object.position.x, 0, current_object.position.z)]
-	#
+			tile_2 = lookup_place_to_tile[Vector3i(current_object.position.x, 0, current_object.position.z - 1)]
-	#tile_1.update_face(tile_1_door_face_direction, Tile.FACE_MODE.DOOR, current_door)
+		
-	#
+		var tile_1_new_dict = tile_1.face_dict.duplicate()
-	#var tile_1_room: Object = tile_1.room_id
+		var tile_2_new_dict = tile_2.face_dict.duplicate()
-	#
+		
-	#tile_1_room.room_door_array.append(current_door)
+		var tile_1_door_face: Vector3i = tile_2.position - tile_1.position
-	#
+		
-	#var tile_2_door_face: Vector3i = tile_1.position - tile_2.position
+		tile_1_new_dict[tile_1_door_face] = current_object
-	#
+		
-	#var tile_2_door_face_direction: int = tile_2.direction_vector_array.find(tile_2_door_face)
+		tile_1.update_faces(tile_1_new_dict)
-	#
+		
-	#tile_2.update_face(tile_2_door_face_direction, Tile.FACE_MODE.DOOR, current_door)
+		tile_1.lookup_tile_to_room[0].room_to_door.append(current_object)
-	#
+		
-	#var tile_2_room: Object = tile_2.room_id
+		var tile_2_door_face: Vector3i = tile_1.position - tile_2.position
-	#
+		
-	#tile_2_room.room_door_array.append(current_door)
+		tile_2_new_dict[tile_2_door_face] = current_object
-	#
+		
-	#current_door.door_room_array = [tile_1_room, tile_2_room]
+		tile_2.update_faces(tile_2_new_dict)
-	#
+		
-	#current_room = null
+		tile_2.lookup_tile_to_room[0].room_to_door.append(current_object)
-	#current_room_walls = []
+		
-	#current_door = null
+		current_object.lookup_door_to_room.append(tile_1.lookup_tile_to_room[0])
+		current_object.lookup_door_to_room.append(tile_2.lookup_tile_to_room[0])
+		current_object.lookup_door_to_tile[tile_1] = tile_1_door_face
+		current_object.lookup_door_to_tile[tile_2] = tile_2_door_face
+	
+	elif current_object is Actor:
+		current_object.actor_state = Actor.ACTOR_STATE.ACTIVE
+	
+	current_room = null
+	current_placement = []
+	current_object = 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):
+		if lookup_place_to_tile.has(directions[i] + grid_pos):
-			neighbor_dict[directions[i]] = place_tile_dict[directions[i] + grid_pos]
+			neighbor_dict[directions[i]] = lookup_place_to_tile[directions[i] + grid_pos]
 	tile.neighbor_dict = neighbor_dict
 
-
 func _on_tile_container_child_entered_tree(node: Node) -> void:
+	lookup_place_to_tile[node.grid_pos] = node
 	node.connect("neighbor_request", give_neighbors)
+
+func give_tile(actor):
+	
+	var closest: Vector3
+	var closest_distance: float = INF
+	
+	for i in lookup_place_to_tile:
+		var distance: float = actor.position.distance_to(i)
+		if closest_distance > distance:
+			closest_distance = distance
+			closest = i
+	
+	actor.current_tile = lookup_place_to_tile[Vector3i(closest)]
+
+func _on_actor_container_child_entered_tree(node: Node) -> void:
+	node.connect("current_tile_request", give_tile)

places/base_place/base_place.tscn

@@ -12,6 +12,9 @@ transform = Transform3D(1, 0, 0, 0, 0.345446, 0.938439, 0, -0.938439, 0.345446,
 
 [node name="TileContainer" type="Node" parent="."]
 
-[node name="Objects" type="Node" parent="."]
+[node name="ObjectContainer" type="Node" parent="."]
+
+[node name="ActorContainer" type="Node" parent="."]
 
 [connection signal="child_entered_tree" from="TileContainer" to="." method="_on_tile_container_child_entered_tree"]
+[connection signal="child_entered_tree" from="ActorContainer" to="." method="_on_actor_container_child_entered_tree"]

places/base_place/base_room.gd

@@ -1,30 +1,21 @@
 extends Node
 class_name Room
 
-var room_tile_array = []: set = setup_path_grid
+var room_to_tile = []: set = setup_path_grid
 
 var path_grid = AStar3D.new()
 
-var room_door_array = []
+var room_to_door = []
 
 var place_id: int = 0
 
-#TODO: replace with global dict?
-var direction_array = [
-	Vector3i(0, 0, -1),
-	Vector3i(1, 0, 0),
-	Vector3i(0, 0, 1),
-	Vector3i(-1, 0, 0),
-]
-
 func save():
 	var save_data = {
 #	Basics
-		"name": name,
-		"type": "Room",
 		"id": self.get_instance_id(),
+		"type": "Room",
 		"scene_file_path": scene_file_path,
-		"parent": get_parent().get_path(),
+		"parent": get_parent().get_instance_id(),
 #	Connections
 		"place_id": place_id,
 #	Data
@@ -36,17 +27,16 @@ func init_room(new_dict):
 	for i in new_dict.values():
 		i.room = self
 
-
 func setup_path_grid(new_array):
 	
-	room_tile_array = new_array
+	room_to_tile = new_array
 		
-	for i in room_tile_array:
+	for i in room_to_tile:
 		var id = path_grid.get_available_point_id()
 		path_grid.add_point(id, i.grid_pos)
 
-		for n in direction_array:
+		for n in Tile.direction_vector_dict.values():
-			if room_tile_array.has(i.grid_pos + n):
+			if room_to_tile.has(i.grid_pos + n):
 				var closest = path_grid.get_closest_point(i + n)
 				if (i + n) == Vector3i(path_grid.get_point_position(closest)):
 					path_grid.connect_points(id, closest)

places/place_manager.gd

@@ -3,63 +3,48 @@ extends Node3D
 var load_place = preload("res://places/base_place/base_place.tscn")
 var place = null
 
-enum ROOM_BUILD_STATE {NONE, ALLOWED, BUILDING, IS_PLACING_DOOR}
+enum ROOM_BUILD_STATE {NONE, SELECT, DRAG, CONFIRM, PLACE}
 
 #Tracks the current build state.
 var room_build_state = 0
 
+var current_room = null
 
-var last_room = null
+var current_object = null
 
 #Tracks the position that was first clicked to start a build drag
 var build_drag_start_pos = null
 
 signal room_built
 
+func _on_child_entered_tree(node: Node) -> void:
+	if node is Place:
+		place = node
+
 func _on_build_toggle(toggled_on):
 #Responds to the 'Build A Room' toggle
 	if toggled_on:
-		room_build_state = ROOM_BUILD_STATE.ALLOWED
+		room_build_state = ROOM_BUILD_STATE.SELECT
 	else:
 		place.clear_selection()
 		room_build_state = ROOM_BUILD_STATE.NONE
 
-func _on_area_3d_input_event(_camera, _event, event_position, _normal, _shade_id):
-#Checks input events from the mouse plane
-
-	match room_build_state:
-		ROOM_BUILD_STATE.ALLOWED:
-			if Input.is_action_pressed("select"):
-				room_build_state = ROOM_BUILD_STATE.BUILDING
-				build_drag_start_pos = event_position
-				place.draw_tile_click(build_drag_start_pos)
-	
-		ROOM_BUILD_STATE.BUILDING:
-			if Input.is_action_pressed("select"):
-				place.init_select_drag(build_drag_start_pos, event_position)
-			else:
-				room_build_state = ROOM_BUILD_STATE.ALLOWED
-				place.end_select_drag()
-			
-		#ROOM_BUILD_STATE.IS_PLACING_DOOR:
-			#if Input.is_action_pressed("select"):
-				#room_build_state = ROOM_BUILD_STATE.NONE
-				#place.confirm_door()
-				#emit_signal("room_built")
-			#else:
-				#place.hover_door(event_position)
-				
-
 func _on_confirm_button_pressed() -> void:
 	if place.selection_dict:
-		if room_build_state == ROOM_BUILD_STATE.ALLOWED:
+		if room_build_state == ROOM_BUILD_STATE.SELECT:
 			if place.build_confirm_allowed:
-				last_room = place.build_selection()
+				current_room = place.build_selection()
-				room_build_state = ROOM_BUILD_STATE.IS_PLACING_DOOR
+				room_build_state = ROOM_BUILD_STATE.NONE
+				#if not current_room.lookup_room_to_door:
+					#current_object = "door"
+					#place.current_room = current_room
+					#place.init_object(current_object)
+					#room_build_state = ROOM_BUILD_STATE.PLACE
 				
+			else:
+				prints("Building not allowed.")
 	else:
-		pass
+		prints("Nothing selected.")
-
 
 func _on_init_grid_button_pressed() -> void:
 	if place:
@@ -68,6 +53,50 @@ func _on_init_grid_button_pressed() -> void:
 	add_child(new_place)
 	place.init_grid()
 
-func _on_child_entered_tree(node: Node) -> void:
+func _on_door_button_pressed() -> void:
-	if node is Place:
+	match room_build_state:
-		place = node
+		ROOM_BUILD_STATE.NONE:
+			current_object = "door"
+			place.current_room = current_room
+			place.init_object(current_object)
+			room_build_state = ROOM_BUILD_STATE.PLACE
+		_:
+			return
+
+func _on_worker_button_pressed() -> void:
+	match room_build_state:
+		ROOM_BUILD_STATE.NONE:
+			current_object = "actor"
+			place.init_object(current_object)
+			room_build_state = ROOM_BUILD_STATE.PLACE
+
+func _on_area_3d_input_event(_camera, _event, event_position, _normal, _shade_id):
+#Checks input events from the mouse plane
+
+	match room_build_state:
+		ROOM_BUILD_STATE.SELECT:
+			if Input.is_action_pressed("select"):
+				room_build_state = ROOM_BUILD_STATE.DRAG
+				build_drag_start_pos = event_position
+				place.draw_tile_click(build_drag_start_pos)
+	
+		ROOM_BUILD_STATE.DRAG:
+			if Input.is_action_pressed("select"):
+				place.init_select_drag(build_drag_start_pos, event_position)
+			else:
+				room_build_state = ROOM_BUILD_STATE.SELECT
+				place.end_select_drag()
+			
+		ROOM_BUILD_STATE.PLACE:
+			if Input.is_action_pressed("select"):
+				room_build_state = ROOM_BUILD_STATE.NONE
+				place.confirm_object()
+				emit_signal("room_built")
+			else:
+				place.hover_object(event_position)
+
+
+
+		
+			
+	pass # Replace with function body.

places/place_manager.tscn182623054522.tmp

@@ -0,0 +1,18 @@
+[gd_scene load_steps=3 format=3 uid="uid://0d1d5e1u2fys"]
+
+[ext_resource type="Script" uid="uid://d24sr2dat4lj0" path="res://places/place_manager.gd" id="1_rcbs8"]
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_rcbs8"]
+size = Vector3(256, 0, 256)
+
+[node name="PlaceManager" type="Node3D"]
+script = ExtResource("1_rcbs8")
+
+[node name="FloorPlane" type="Area3D" parent="."]
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="FloorPlane"]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 128, 0, 128)
+shape = SubResource("BoxShape3D_rcbs8")
+
+[connection signal="child_entered_tree" from="." to="." method="_on_child_entered_tree"]
+[connection signal="input_event" from="FloorPlane" to="." method="_on_area_3d_input_event"]

tiles/base_tile/base_door.gd

@@ -1,5 +1,45 @@
-extends Node3D
+extends GameObject
 
-var room = null
+class_name Door
 
-var door_room_array = []
+var place_id: int
+
+var lookup_door_to_room = []
+
+var lookup_door_to_tile = {}
+
+var direction = null
+
+var placement = GameObject.PLACEMENTS.DOOR
+
+func save():
+	
+	var room_ids: Array
+	var door_to_tile: Dictionary
+	var door_to_tile_direction: Dictionary = {}
+	
+	for i in lookup_door_to_room:
+		room_ids.append(i.get_instance_id())
+		
+	for i in lookup_door_to_tile.keys():
+		var id = i.get_instance_id()
+		door_to_tile[lookup_door_to_tile[i]] = id
+		door_to_tile_direction[id] = i.face_dict.find_key(self)
+	
+	var save_data = {
+#	Basics
+		"id": self.get_instance_id(),
+		"type": "Door",
+		"scene_file_path": scene_file_path,
+		"parent": get_parent().get_path(),
+#	Connections
+		"place_id": place_id,
+		"room_ids": room_ids,
+		"door_to_tile": door_to_tile,
+		"door_to_tile_direction": door_to_tile_direction,
+#	Data
+		"position": position,
+		"rotation_degrees": rotation_degrees
+	}
+	
+	return save_data

tiles/base_tile/base_door.tscn

@@ -1,12 +1,16 @@
-[gd_scene load_steps=3 format=3 uid="uid://b6qehpvvnv5r3"]
+[gd_scene load_steps=4 format=3 uid="uid://b6qehpvvnv5r3"]
 
 [ext_resource type="Script" uid="uid://dptw3xl225fxk" path="res://tiles/base_tile/base_door.gd" id="1_8olbq"]
 
 [sub_resource type="BoxMesh" id="BoxMesh_8olbq"]
 
-[node name="BaseDoor" type="Node3D"]
+[sub_resource type="StandardMaterial3D" id="StandardMaterial3D_8olbq"]
+albedo_color = Color(0.625824, 0.328179, 0.426969, 1)
+
+[node name="BaseDoor" type="Node3D" groups=["SaveObjects"]]
 script = ExtResource("1_8olbq")
 
 [node name="MeshInstance3D" type="MeshInstance3D" parent="."]
-transform = Transform3D(-3.93403e-08, 0, 0.2, 0, 0.5, 0, -0.9, 0, -8.74228e-09, 0, 0.25, 0)
+transform = Transform3D(-4.37114e-08, 0, 0.4, 0, 0.5, 0, -1, 0, -1.74846e-08, 0, 0.25, 0)
 mesh = SubResource("BoxMesh_8olbq")
+surface_material_override/0 = SubResource("StandardMaterial3D_8olbq")

tiles/base_tile/base_tile.gd

@@ -24,7 +24,7 @@ const direction_vector_dict = {
 	"North": Vector3i(0, 0, -1),
 	"East": Vector3i(1, 0, 0),
 	"South": Vector3i(0, 0, 1),
-	"West":	Vector3i(-1, 0, 0),
+	"West": Vector3i(-1, 0, 0),
 }
 
 const wall_position_dict = {
@@ -36,37 +36,31 @@ const wall_position_dict = {
 
 const load_wall = preload("res://tiles/base_tile/base_wall.tscn")
 
-@export var grid_pos = null
+var grid_pos = null
 
-@export var face_dict = {}: set = update_faces
+var face_dict = {}: set = update_faces
 
-@export var room_array = []
+var lookup_tile_to_room = []
 
 var neighbor_dict = {}
 
 signal neighbor_request
 
-func _ready():
-	
-	pass
-
 func save():
 	
-	var room_id_array: Array
+	var room_ids: Array
-	
+	for i in lookup_tile_to_room:
-	for i in room_array:
+		room_ids.append(i.get_instance_id())
-		room_id_array.append(i.get_instance_id())
 	
 	var save_data = {
 #	Basics
-		"name": name,
-		"type": "Tile",
 		"id": self.get_instance_id(),
+		"type": "Tile",
 		"scene_file_path": scene_file_path,
 		"parent": get_parent().get_path(),
 #	Connections
 		"place_id": place_id,
-		"room_array": room_id_array,
+		"room_ids": room_ids,
 #	Data
 		"position": position,
 		"grid_pos": grid_pos,
@@ -77,18 +71,18 @@ func save():
 
 func update_faces(new_dict):
 
-	#for i in $Walls.get_children():
-		#i.queue_free()
-
-	if type_string(typeof(new_dict)) == "Array":
-		var temp_new_dict: Dictionary
-		for i in new_dict:
-			temp_new_dict[i] = null
-		new_dict = temp_new_dict.duplicate()
-
 	for i in new_dict.keys():
+		if face_dict.has(i):
+			if face_dict[i] == new_dict[i]:
+				continue
+		
+			face_dict[i].queue_free()
+			face_dict[i] = null
+		
+		if new_dict[i] is Door:
+			face_dict[i] = new_dict[i]
+			continue
 		var direction: String = direction_vector_dict.find_key(i)
-		var wall_pos = wall_position_dict[direction]
 		var wall = load_wall.instantiate()
 		wall.position = wall_position_dict[direction]
 		wall.name = str(direction, "Wall")
@@ -114,39 +108,38 @@ func update_construction(mode):
 	match mode:
 		CON_MODE.NON_INTERACTABLE:
 			face_dict = {}
-			pass
 		
 		CON_MODE.CLOSED:
 			face_dict = {}
 			$Floor/FloorMesh.set_material_override(gray)
-			pass
 		
 		CON_MODE.OPEN:
 			face_dict = {}
-			pass
 	
 		CON_MODE.BUILT:
 			$Floor/FloorMesh.set_material_override(null)
 			
-			update_neighbors()
+			if not face_dict:
+				update_neighbors()
 				
-			var temp_face_dict = {}
+				var temp_face_dict = {}
 				
-			for i in neighbor_dict.keys():
+				for i in neighbor_dict.keys():
-				if not neighbor_dict[i].room_array == room_array:
+					if not neighbor_dict[i].lookup_tile_to_room == lookup_tile_to_room:
-					temp_face_dict[i] = null
+						temp_face_dict[i] = null
 			
-			face_dict = temp_face_dict.duplicate()
+				face_dict = temp_face_dict.duplicate()
 	
 		CON_MODE.REINFORCED:
 			face_dict = {}
-			pass
 		
 		CON_MODE.CONSTRUCTION:
-			pass
+			face_dict = {}
-	pass
 
 func update_selection(mode):
+	
+	selection_mode = mode
+	
 	match mode:
 		SEL_MODE.NONE:
 			$Floor/FloorMesh.set_material_overlay(null)
@@ -160,87 +153,3 @@ func update_selection(mode):
 		
 		SEL_MODE.INVALID:
 			$Floor/FloorMesh.set_material_overlay(orange)
-
-func update_face(direction, mode, door = null):
-	print("face update blanked")
-	pass
-##Updates the faces of this tile.
-	#var face = direction_vector_array[direction]
-	#
-	#
-	#
-	#match mode:
-		#FACE_MODE.NONE:
-			#for i in wall_dict.keys():
-				#wall_dict[i].queue_free()
-				#wall_dict.erase(i)
-		#
-		#FACE_MODE.FULL:
-			#if not wall_dict.has(face):
-				#
-				#var wall = load_wall.instantiate()
-			#
-				#wall.position = wall_position_array[direction]
-#
-				#wall.rotation_degrees = Vector3(0, direction * -90, 0)
-				#
-				#wall_dict[face] = wall
-				#
-				#emit_signal("wall_built", room_id)
-				#
-				#add_child(wall)
-			#
-		#FACE_MODE.DOOR:
-			#wall_dict[face].queue_free()
-			#wall_dict.erase(face)
-			#wall_dict[face] = door
-#
-#
-func update(sel_mode: int = SEL_MODE.NONE, con_mode: int = CON_MODE.NONE):
-	print("update blanked")
-	pass
-##Updates the selection and construction modes of this tile.
-	#
-	#if sel_mode != selection_mode:
-		#
-		#selection_mode = sel_mode
-		#
-		#match sel_mode:
-			#SEL_MODE.NONE:
-				#$Floor/FloorMesh.set_material_overlay(null)
-			#
-			#SEL_MODE.ROOM:
-				#for i in $Walls.get_children():
-					#i.Mesh.set_material_override(orange)
-				#
-			#SEL_MODE.BUILD:
-				#$Floor/FloorMesh.set_material_overlay(lightblue)
-			#
-			#SEL_MODE.INVALID:
-				#$Floor/FloorMesh.set_material_overlay(orange)
-				#
-	##if con_mode:
-		##if con_mode != construction_mode:
-			##
-			##construction_mode = con_mode
-			##
-			##match con_mode:
-				##CON_MODE.NON_INTERACTABLE:
-					##pass
-				##
-				##CON_MODE.CLOSED:
-					##$Floor/FloorMesh.set_material_override(gray)
-					##pass
-				##
-				##CON_MODE.OPEN:
-					##pass
-			##
-				##CON_MODE.BUILT:
-					##$Floor/FloorMesh.set_material_override(null)
-					##pass
-			##
-				##CON_MODE.REINFORCED:
-					##pass
-				##
-				##CON_MODE.CONSTRUCTION:
-					##pass