184 lines
6.4 KiB
GDScript
184 lines
6.4 KiB
GDScript
extends Node
|
|
class_name PlaceMap
|
|
|
|
var temp_map_height :int = 1
|
|
var temp_map_x :int = 32
|
|
var temp_map_z :int = 32
|
|
var tile_map :Dictionary = {}
|
|
var wall_map :Dictionary = {}
|
|
var room_map :Dictionary = {}
|
|
var place_nav :AStar3D = AStar3D.new()
|
|
|
|
enum TILE_STATE {CLOSED, OPEN}
|
|
enum WALL_STATE {OPEN, CLOSED, DOOR}
|
|
|
|
const direction_vectors :Array = [
|
|
Vector3i(0, 0, -12),
|
|
Vector3i(12, 0, 0),
|
|
Vector3i(0, 0, 12),
|
|
Vector3i(-12, 0, 0)
|
|
]
|
|
|
|
func _process(_delta: float) -> void:
|
|
var color_tile_built :Color = Color(0.939, 0.741, 0.73, 1.0)
|
|
var color_wall_built :Color = Color(0.81, 0.299, 0.316, 1.0)
|
|
var built_tiles :Array = []
|
|
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:
|
|
tiles.append(pos)
|
|
elif tile_map[i]["state"] == TILE_STATE.OPEN:
|
|
built_tiles.append(pos)
|
|
for i :Vector3i in wall_map.keys():
|
|
var pos :Vector3 = Vector3(i) / 12
|
|
if wall_map[i]["state"] == WALL_STATE.OPEN:
|
|
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.
|
|
for y :int in range(temp_map_height):
|
|
for x :int in range(temp_map_x):
|
|
for z :int in range(temp_map_z):
|
|
var map_pos :Vector3i = Vector3i(x * 12, y, z * 12)
|
|
tile_map[map_pos] = {
|
|
"object": null,
|
|
"state": TILE_STATE.CLOSED
|
|
}
|
|
|
|
for i :Vector3i in tile_map.keys():
|
|
for v :Vector3i in direction_vectors:
|
|
var map_pos :Vector3i = i - (v / 2)
|
|
wall_map[map_pos] = {
|
|
"object": null,
|
|
"state": WALL_STATE.OPEN,
|
|
}
|
|
|
|
func give_walls(tile :Tile) -> void:
|
|
var temp_dict :Dictionary
|
|
for i :Vector3i in direction_vectors:
|
|
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]["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
|