diff --git a/actors/base_actor/base_actor.gd b/actors/base_actor/base_actor.gd index f88fc09..78ce887 100644 --- a/actors/base_actor/base_actor.gd +++ b/actors/base_actor/base_actor.gd @@ -9,22 +9,20 @@ var actor_state = null: set = state_change const red = preload("res://tiles/base_tile/red.tres") const blue = preload("res://tiles/base_tile/lightblue.tres") -var current_place_path: Array +var current_task_path: Array var current_room_path: Array -var temp_speed = 2 -var time = 0 - var current_tile = null: set = change_current_tile var current_room = null -var lookup_actor_to_task = [] +var lookup_actor_to_task :Array = [] var current_task: Dictionary : set = task_change @onready var task_creator: TaskCreator = $TaskCreator signal current_tile_request -signal map_request +signal task_path_request +signal room_path_request func _process(delta: float) -> void: match actor_state: @@ -34,19 +32,23 @@ func _process(delta: float) -> void: if current_tile.place_position == current_task.location: temp_complete_task() - if current_room_path: - if self.position.distance_to(current_room_path[0]) > .1: - position += position.direction_to(Vector3(current_room_path[0])) * 3 * delta - DebugDraw3D.draw_line(self.position, current_room_path[0]) - for i in current_room_path.size(): - if i > 0: - var j = current_room_path[i - 1] - DebugDraw3D.draw_line(current_room_path[i], j) + if current_task_path: + if current_room_path: + if self.position.distance_to(current_room_path[0]) > .1: + position += position.direction_to(Vector3(current_room_path[0])) * 6 * delta + DebugDraw3D.draw_line(self.position, current_room_path[0]) + for i in current_room_path.size(): + if i > 0: + var j = current_room_path[i - 1] + DebugDraw3D.draw_line(current_room_path[i], j) + else: + current_room_path.pop_front() + if not current_room_path: + current_task_path.pop_front() else: - current_room_path.pop_front() - current_place_path.pop_front() + get_room_path(current_tile.place_position, current_task_path[0]) else: - get_room_path(current_tile.place_position, current_place_path[0]) + get_task_path() ACTOR_STATE.IDLE: if not lookup_actor_to_task.is_empty(): @@ -57,7 +59,7 @@ func _process(delta: float) -> void: ACTOR_STATE.PAUSED: pass -func state_change(state): +func state_change(state :int ) -> void: actor_state = state match state: ACTOR_STATE.ACTIVE: @@ -111,19 +113,20 @@ func temp_complete_task(): task_creator.complete_task(self, completed_task) actor_state = ACTOR_STATE.IDLE -func get_task_path(): +func get_task_path() -> void: get_current_tile() - var start = current_tile.place_position - var end = current_task.location + var start :Vector3i = current_tile.place_position + var end :Vector3i = current_task.location - if destination_in_current_room(end): - current_place_path = [start, end] - else: - temp_complete_task() - #emit_signal("map_request", self, start, end) + #if destination_in_current_room(end): + #current_task_path = [start, end] + #else: + ##temp_complete_task() + emit_signal("task_path_request", self, start, end) -func get_room_path(start, end): - current_room_path = current_room.get_room_path(start, end) +func get_room_path(start :Vector3i, end :Vector3i) -> void: + emit_signal("room_path_request", self, start, end) + #current_room_path = current_room.get_room_path(start, end) func destination_in_current_room(destination): for i in current_room.room_to_tile: diff --git a/places/base_place/base_place.gd b/places/base_place/base_place.gd index 8c73a0e..8e55b73 100644 --- a/places/base_place/base_place.gd +++ b/places/base_place/base_place.gd @@ -27,13 +27,13 @@ var tile_count_z_hist: int = 0 var build_confirm_allowed: bool = true #The object that's currently being built -var current_object: Object = null +var current_object #Where that object can be placed var available_placements :Array = [] var current_placement :Vector3 #Tracks parts of the room currently being built -var current_room: Object = null +var current_room @onready var map :PlaceMap = $PlaceMap @@ -188,6 +188,12 @@ func build_selection() -> void: create_room(selection_dict) + for i :Vector3i in selection_dict.keys(): + map.tile_map[i * 12]["state"] = PlaceMap.TILE_STATE.OPEN + for j :Vector3i in Tile.direction_vector_dict.values(): + if not selection_dict.keys().has(i - j): + map.wall_map[(i * 12) - (j * 6)]["state"] = PlaceMap.WALL_STATE.CLOSED + for i :Vector3i in selection_dict.keys(): var tile: Object = lookup_place_to_tile[i] tile.selection_mode = Tile.SEL_MODE.NONE @@ -219,22 +225,19 @@ func create_room(selection :Dictionary) -> Room: $RoomContainer.add_child(room) - for i :Vector3i in selection.keys(): - map.tile_map[i * 12]["state"] = PlaceMap.TILE_STATE.OPEN - for j :Vector3i in Tile.direction_vector_dict.values(): - if not selection.keys().has(i - j): - map.wall_map[(i * 12) - (j * 6)]["state"] = PlaceMap.WALL_STATE.CLOSED - - map.room_map[room] = selection.values() - + map.room_map[room] = { + "tiles": selection.values(), + "doors": [], + } + for i :Tile in room.room_to_tile: i.lookup_tile_to_room = room - - + room.init_room(selection) + return room -func init_object(object): +func init_object(object) -> void: #Instantiates the object to be placed match object: @@ -296,7 +299,7 @@ func hover_object(mouse_pos :Vector3) -> void: closest_distance = distance closest = i - current_placement = closest + current_placement = closest current_object.position = current_placement current_object.rotation_degrees = Vector3(0, 180 * fmod(closest.x, 1), 0) @@ -305,11 +308,47 @@ func hover_object(mouse_pos :Vector3) -> void: func confirm_object() -> void: #Places the object at the hovered location -#TODO: this is very sloppy if current_object is Door: + var pos :Vector3i = Vector3i(current_placement * 12) + #map.wall_map[pos]["state"] = map.WALL_STATE.DOOR + #if pos.x % 12 == 0: + #tile_1_pos = pos + Vector3i(0, 0, -6) + #tile_2_pos = pos + Vector3i(0, 0, 6) + #else: + #tile_1_pos = pos + Vector3i(-6, 0, 0) + #tile_2_pos = pos + Vector3i(6, 0, 0) + #var tile_1 :Tile = map.tile_map[tile_1_pos]["object"] + #var tile_2 :Tile = map.tile_map[tile_2_pos]["object"] - pass + #tile_1.update_faces() + #tile_2.update_faces() + map.write_door(pos) + #map.room_map[tile_1.lookup_tile_to_room]["tiles"].append(tile_2) + #tile_1.lookup_tile_to_room.update_nav() + #var point_pos_1 :Vector3i = pos - ((pos - tile_1_pos) / 2) + #var id_1 :int = map.place_nav.get_available_point_id() + #map.place_nav.add_point(id_1, point_pos_1) + #for i :Vector3i in map.room_map[tile_1.lookup_tile_to_room]["doors"]: + #var id :int = map.place_nav.get_closest_point(i) + #map.place_nav.connect_points(id_1, id) + #map.room_map[tile_1.lookup_tile_to_room]["doors"].append(point_pos_1) + #map.room_map[tile_2.lookup_tile_to_room]["tiles"].append(tile_1) + #tile_2.lookup_tile_to_room.update_nav() + #var point_pos_2 :Vector3i = pos - ((pos - tile_2_pos) / 2) + #var id_2 :int = map.place_nav.get_available_point_id() + #map.place_nav.add_point(id_2, point_pos_2) + #for i :Vector3i in map.room_map[tile_2.lookup_tile_to_room]["doors"]: + #var id :int = map.place_nav.get_closest_point(i) + #map.place_nav.connect_points(id_2, id) + #map.room_map[tile_2.lookup_tile_to_room]["doors"].append(point_pos_2) + # + #map.place_nav.connect_points(id_1, id_2) + + + + + current_object.queue_free() # #var tile_1: Object #var tile_2: Object @@ -395,7 +434,8 @@ func _on_actor_container_child_entered_tree(node: Node) -> void: #Connects signals from created actors node.connect("current_tile_request", give_tile) - node.connect("map_request", give_map) + node.connect("task_path_request", give_path) + node.connect("room_path_request", give_room) if node.has_node("TaskCreator"): var tasker = node.get_node("TaskCreator") tasker.connect("record_task", record_task) @@ -403,38 +443,49 @@ func _on_actor_container_child_entered_tree(node: Node) -> void: func _on_room_container_child_entered_tree(node: Node) -> void: #Connects signals from created rooms - pass -func give_map(actor, start, end): - var end_tile:Tile = lookup_place_to_tile[end] - if end_tile.construction_mode == Tile.CON_MODE.BUILT: - - var start_id = map.get_available_point_id() - map.add_point(start_id, start) - var start_room_doors = lookup_place_to_tile[start].lookup_tile_to_room.room_to_door - if start_room_doors == []: - actor.temp_complete_task() - return - for i in start_room_doors: - var door_id = map.get_closest_point(i.position) - map.connect_points(start_id, door_id) - - var end_id = map.get_available_point_id() - map.add_point(end_id, end) - var end_room_doors = lookup_place_to_tile[end].lookup_tile_to_room.room_to_door - if end_room_doors == []: - actor.temp_complete_task() - return - for i in end_room_doors: - var door_id = map.get_closest_point(i.position) - map.connect_points(end_id, door_id) - var place_path_id = map.get_id_path(start_id, end_id) - var place_path_pos = [] - for i in place_path_id: - place_path_pos.append(map.get_point_position(i)) - actor.current_place_path = place_path_pos - else: - actor.temp_complete_task() + node.connect("nav_request", give_nav) + +func give_nav(room): + map.give_nav(room) + +func give_path(actor :Actor, start :Vector3i, end :Vector3i) -> void: + var start_tile :Tile = lookup_place_to_tile[start] + var end_tile :Tile = lookup_place_to_tile[end] + map.give_path(actor, start_tile, end_tile) + +func give_room(actor, start, end): + map.give_room(actor, start, end) + + #var end_tile:Tile = lookup_place_to_tile[end] + #if end_tile.construction_mode == Tile.CON_MODE.BUILT: + # + #var start_id = map.get_available_point_id() + #map.add_point(start_id, start) + #var start_room_doors = lookup_place_to_tile[start].lookup_tile_to_room.room_to_door + #if start_room_doors == []: + #actor.temp_complete_task() + #return + #for i in start_room_doors: + #var door_id = map.get_closest_point(i.position) + #map.connect_points(start_id, door_id) + # + #var end_id = map.get_available_point_id() + #map.add_point(end_id, end) + #var end_room_doors = lookup_place_to_tile[end].lookup_tile_to_room.room_to_door + #if end_room_doors == []: + #actor.temp_complete_task() + #return + #for i in end_room_doors: + #var door_id = map.get_closest_point(i.position) + #map.connect_points(end_id, door_id) + #var place_path_id = map.get_id_path(start_id, end_id) + #var place_path_pos = [] + #for i in place_path_id: + #place_path_pos.append(map.get_point_position(i)) + #actor.current_place_path = place_path_pos + #else: + #actor.temp_complete_task() func give_tile(actor): #Responds to an actor's request for its current tile diff --git a/places/base_place/base_room.gd b/places/base_place/base_room.gd index d5594c0..b9d04d4 100644 --- a/places/base_place/base_room.gd +++ b/places/base_place/base_room.gd @@ -1,19 +1,21 @@ extends Node class_name Room -var room_to_tile = []: set = setup_path_grid +var room_to_tile :Array = [] -var path_grid = AStar3D.new() +var nav :AStar3D = AStar3D.new() -var room_to_door = [] +var lookup_room_to_door :Array = [] var place_id: int = 0 +signal nav_request + func _process(delta: float) -> void: - for i in path_grid.get_point_ids(): - for j in path_grid.get_point_connections(i): - var i_pos = path_grid.get_point_position(i) - var j_pos = path_grid.get_point_position(j) + for i in nav.get_point_ids(): + for j in nav.get_point_connections(i): + var i_pos :Vector3 = nav.get_point_position(i) + var j_pos :Vector3 = nav.get_point_position(j) if i > 0: DebugDraw3D.draw_line(i_pos, j_pos, Color(0.613, 0.613, 0.613, 1.0)) @@ -33,36 +35,78 @@ func save(): func init_room(new_dict): #When a room is created, run through these steps - setup_path_grid(new_dict) + #setup_path_grid(new_dict) + update_nav() for i in new_dict.values(): - i.room = self + i.lookup_tile_to_room = self + +func update_nav() -> void: + emit_signal("nav_request", self) func setup_path_grid(new_array): #Sets up the A* grid of tiles that are in this room. #TODO: Better grid changing + pass + #nav.clear() + #room_to_tile = new_array + #var room_to_tile_positions: Array + # + #for i in room_to_tile: + #var id = nav.get_available_point_id() + #var point_pos = Vector3(i.place_position) + #nav.add_point(id, point_pos) + #room_to_tile_positions.append(point_pos) +# + #for n in Tile.direction_vector_dict.values(): + #var neighbor_pos = point_pos + Vector3(n) + #if room_to_tile_positions.has(neighbor_pos): + #var closest = nav.get_closest_point(neighbor_pos) + #if (neighbor_pos) == Vector3(nav.get_point_position(closest)): + #nav.connect_points(id, closest) + +func get_room_path(start :Vector3i, end :Vector3i) -> Array: + + var start_point = nav.get_closest_point(Vector3(start)) + var end_point = nav.get_closest_point(Vector3(end)) + var path = nav.get_point_path(start_point, end_point) + return path + - path_grid.clear() - room_to_tile = new_array - var room_to_tile_positions: Array - for i in room_to_tile: - var id = path_grid.get_available_point_id() - var point_pos = Vector3(i.place_position) - path_grid.add_point(id, point_pos) - room_to_tile_positions.append(point_pos) + + + + + + #for i in room_to_tile: + #var place_end :Vector3 = Vector3(end) + #var pos = Vector3(i.place_position) + #if pos == place_end: - for n in Tile.direction_vector_dict.values(): - var neighbor_pos = point_pos + Vector3(n) - if room_to_tile_positions.has(neighbor_pos): - var closest = path_grid.get_closest_point(neighbor_pos) - if (neighbor_pos) == Vector3(path_grid.get_point_position(closest)): - path_grid.connect_points(id, closest) - -func get_room_path(start, end): - for i in room_to_tile: - if i.place_position == Vector3i(end): - var start_point = path_grid.get_closest_point(Vector3(start)) - var end_point = path_grid.get_closest_point(Vector3(end)) - var path = path_grid.get_point_path(start_point, end_point) - return path - return false + #if fmod(place_end.x, 1) != 0: + #var tst1 = place_end + Vector3(-0.5, 0, 0) + #var tst2 = place_end + Vector3(0.5, 0, 0) + #if pos == tst1: + #var start_point = nav.get_closest_point(Vector3(start)) + #var end_point = nav.get_closest_point(pos) + #var path = nav.get_point_path(start_point, end_point) + #return path + #if pos == tst2: + #var start_point = nav.get_closest_point(Vector3(start)) + #var end_point = nav.get_closest_point(pos) + #var path = nav.get_point_path(start_point, end_point) + #return path + #elif fmod(place_end.z, 1) != 0: + #var tst1 = place_end + Vector3(0, 0, -0.5) + #var tst2 = place_end + Vector3(0, 0, 0.5) + #if pos == tst1: + #var start_point = nav.get_closest_point(Vector3(start)) + #var end_point = nav.get_closest_point(pos) + #var path = nav.get_point_path(start_point, end_point) + #return path + #if pos == tst2: + #var start_point = nav.get_closest_point(Vector3(start)) + #var end_point = nav.get_closest_point(pos) + #var path = nav.get_point_path(start_point, end_point) + #return path + return [] diff --git a/places/base_place/place_map.gd b/places/base_place/place_map.gd index 42b05fb..ee5a01d 100644 --- a/places/base_place/place_map.gd +++ b/places/base_place/place_map.gd @@ -10,7 +10,7 @@ var room_map :Dictionary = {} var place_nav :AStar3D = AStar3D.new() enum TILE_STATE {CLOSED, OPEN} -enum WALL_STATE {CLOSED, OPEN, DOOR} +enum WALL_STATE {OPEN, CLOSED, DOOR} const direction_vectors :Array = [ Vector3i(0, 0, -12), @@ -26,6 +26,8 @@ func _process(_delta: float) -> void: var built_walls :Array = [] var tiles :Array = [] var walls :Array = [] + var astar_points :Array = place_nav.get_point_ids() + var astar_pos :Array = [] for i :Vector3i in tile_map.keys(): var pos :Vector3 = Vector3(i) / 12 if tile_map[i]["state"] == TILE_STATE.CLOSED: @@ -38,10 +40,13 @@ func _process(_delta: float) -> void: walls.append(pos) elif wall_map[i]["state"] == WALL_STATE.CLOSED: built_walls.append(pos) + for i :int in astar_points: + astar_pos.append(Vector3(place_nav.get_point_position(i)) / 12) DebugDraw3D.draw_points(built_tiles, 0, 0.2, color_tile_built) DebugDraw3D.draw_points(built_walls, 0, 0.2, color_wall_built) DebugDraw3D.draw_points(tiles, 0, 0.2, Color(0.459, 0.404, 0.866, 1.0)) DebugDraw3D.draw_points(walls, 0, 0.2, Color(0.343, 0.409, 0.528, 1.0)) + DebugDraw3D.draw_points(astar_pos, 0, 0.2, Color(0.657, 0.004, 0.956, 1.0)) func temp_create_map() -> void: #TEMP: just makes a square. Should be replaced with premade maps eventually. @@ -68,8 +73,111 @@ func give_walls(tile :Tile) -> void: if tile_map.has(tile.map_position + i): var neighbor :Tile = tile_map[tile.map_position + i]["object"] var room :Room = tile.lookup_tile_to_room - if not room_map[room].has(neighbor): - if wall_map[tile.map_position + (i / 2)]["state"] == PlaceMap.WALL_STATE.CLOSED : - temp_dict[Vector3(i / 2) / 12] = PlaceMap.WALL_STATE.CLOSED + if not room_map[room]["tiles"].has(neighbor): + temp_dict[Vector3(i / 2) / 12] = wall_map[tile.map_position + (i / 2)]["state"] if temp_dict: tile.face_dict = temp_dict.duplicate() + +func give_nav(room :Room) -> void: + var nav :AStar3D = room.nav + nav.clear() + var pos_array :Array = [] + for i :Tile in room_map[room]["tiles"]: + var id :int = nav.get_available_point_id() + var point_pos :Vector3 = Vector3(i.place_position) + nav.add_point(id, point_pos) + pos_array.append(point_pos) + + for n :Vector3 in Tile.direction_vector_dict.values(): + var neighbor_pos :Vector3 = point_pos + Vector3(n) + if pos_array.has(neighbor_pos): + var closest :int = nav.get_closest_point(neighbor_pos) + if (neighbor_pos) == Vector3(nav.get_point_position(closest)): + nav.connect_points(id, closest) + +func give_path(actor :Actor, start :Tile, end :Tile) -> void: +# TODO: Sloppy + + if tile_map[end.map_position]["state"] == TILE_STATE.OPEN: + + if start.lookup_tile_to_room == end.lookup_tile_to_room: + actor.current_task_path = [start.map_position, end.map_position] + return + + var start_id :int = place_nav.get_available_point_id() + place_nav.add_point(start_id, start.map_position) + var start_room_doors :Array = room_map[start.lookup_tile_to_room]["doors"] + if start_room_doors == []: + actor.temp_complete_task() + return + for i :Vector3i in start_room_doors: + var door_id :int = place_nav.get_closest_point(i) + place_nav.connect_points(start_id, door_id) + + var end_id :int = place_nav.get_available_point_id() + place_nav.add_point(end_id, end.map_position) + var end_room_doors :Array = room_map[end.lookup_tile_to_room]["doors"] + if end_room_doors == []: + actor.temp_complete_task() + return + for i :Vector3i in end_room_doors: + var door_id :int = place_nav.get_closest_point(i) + place_nav.connect_points(end_id, door_id) + var place_path_id :Array = place_nav.get_id_path(start_id, end_id) + var place_path_pos :Array = [] + for i :int in place_path_id: + place_path_pos.append(place_nav.get_point_position(i)) + actor.current_task_path = place_path_pos + place_nav.remove_point(start_id) + place_nav.remove_point(end_id) + else: + actor.temp_complete_task() + +func write_door(pos :Vector3i) -> void: + var tile_1_pos :Vector3i + var tile_2_pos :Vector3i + if pos.x % 12 == 0: + tile_1_pos = pos + Vector3i(0, 0, -6) + tile_2_pos = pos + Vector3i(0, 0, 6) + else: + tile_1_pos = pos + Vector3i(-6, 0, 0) + tile_2_pos = pos + Vector3i(6, 0, 0) + var tile_1 :Tile = tile_map[tile_1_pos]["object"] + var tile_2 :Tile = tile_map[tile_2_pos]["object"] + + wall_map[pos]["state"] = WALL_STATE.DOOR + tile_1.update_faces() + tile_2.update_faces() + + room_map[tile_1.lookup_tile_to_room]["tiles"].append(tile_2) + tile_1.lookup_tile_to_room.update_nav() + var point_pos_1 :Vector3i = pos - ((pos - tile_1_pos) / 2) + var id_1 :int = place_nav.get_available_point_id() + place_nav.add_point(id_1, point_pos_1) + for i :Vector3i in room_map[tile_1.lookup_tile_to_room]["doors"]: + var id :int = place_nav.get_closest_point(i) + place_nav.connect_points(id_1, id) + room_map[tile_1.lookup_tile_to_room]["doors"].append(point_pos_1) + + room_map[tile_2.lookup_tile_to_room]["tiles"].append(tile_1) + tile_2.lookup_tile_to_room.update_nav() + var point_pos_2 :Vector3i = pos - ((pos - tile_2_pos) / 2) + var id_2 :int = place_nav.get_available_point_id() + place_nav.add_point(id_2, point_pos_2) + for i :Vector3i in room_map[tile_2.lookup_tile_to_room]["doors"]: + var id :int = place_nav.get_closest_point(i) + place_nav.connect_points(id_2, id) + room_map[tile_2.lookup_tile_to_room]["doors"].append(point_pos_2) + + place_nav.connect_points(id_1, id_2) + +func give_room(actor, start, end) -> void: + for i in room_map.keys(): + for j in room_map[i]["tiles"]: + if Vector3i(end) == j.map_position: + actor.current_room_path = i.get_room_path(start, j.place_position) + return + for j in room_map[i]["doors"]: + if Vector3i(end) == j: + actor.current_room_path = i.get_room_path(start, Vector3i(round(Vector3(end) / 12))) + return diff --git a/tiles/base_tile/base_tile.gd b/tiles/base_tile/base_tile.gd index 9f62f99..146e666 100644 --- a/tiles/base_tile/base_tile.gd +++ b/tiles/base_tile/base_tile.gd @@ -74,26 +74,29 @@ func save(): -func update_faces(): +func update_faces() -> void: #Changes the walls when relevant emit_signal("wall_request", self) func build_faces(dict :Dictionary) -> void: - face_dict = dict for i :Vector3 in dict: - var wall :Wall = load_wall.instantiate() - wall.position = Vector3(i) - $Walls.add_child(wall) - match i: - Vector3(0, 0, 0.5): - wall.rotation_degrees = Vector3(0, -180, 0) - Vector3(-0.5, 0, 0): - wall.rotation_degrees = Vector3(0, -270, 0) - Vector3(0.5, 0, 0): - wall.rotation_degrees = Vector3(0, -90, 0) - - - + match dict[i]: + PlaceMap.WALL_STATE.OPEN: + face_dict[i].queue_free() + PlaceMap.WALL_STATE.CLOSED: + var wall :Wall = load_wall.instantiate() + wall.position = Vector3(i) + $Walls.add_child(wall) + match i: + Vector3(0, 0, 0.5): + wall.rotation_degrees = Vector3(0, -180, 0) + Vector3(-0.5, 0, 0): + wall.rotation_degrees = Vector3(0, -270, 0) + Vector3(0.5, 0, 0): + wall.rotation_degrees = Vector3(0, -90, 0) + face_dict[i] = wall + PlaceMap.WALL_STATE.DOOR: + face_dict[i].queue_free() #for i in new_dict.keys(): #if face_dict.has(i):