Добавлен функционал передвижения NPC

world/npcs.gd

@@ -0,0 +1,33 @@
+extends Node2D
+
+const NPC_SCENE = preload("res://npc/npc.tscn")
+
+var npcs: Array[NPC]
+
+
+func add_npc(pos: Vector2i):
+	var npc: NPC = NPC_SCENE.instantiate()
+	npc.translate(pos*World.tile_size)
+	npcs.append(npc)
+	add_child(npc)
+
+# Called when the node enters the scene tree for the first time.
+func _ready() -> void:
+	add_npc(Vector2i(16, 8))
+	add_npc(Vector2i(40, 32))
+	set_npc_target(npcs[0], Vector2i(24, 48))
+	set_npc_target(npcs[1], Vector2i(24, 49))
+	
+
+func set_npc_target(npc: NPC, target: Vector2i):
+	var id_path = $"../TileMap".astar_grid.get_id_path(
+		$"../TileMap/ground".local_to_map(npc.global_position+$"../TileMap/ground".global_position),
+		target
+	).slice(1)
+	
+	if not id_path.is_empty():
+		npc.id_path = id_path
+
+# Called every frame. 'delta' is the elapsed time since the previous frame.
+func _process(delta: float) -> void:
+	pass

world/tile_map.gd

@@ -0,0 +1,234 @@
+class_name MyTileMap
+extends Node2D
+
+enum StructType {
+	EMPTY_ROOM,                      # 0. Пустой модуль
+	RESIDENTIAL_ROOM,                # 1. Жилой Модуль
+	LABORATORY_ROOM,                 # 2. Лабораторный Модуль
+	ENERGY_ROOM,                     # 3. Энергетический Модуль
+	FARM_ROOM,                       # 4. Фермерский Модуль
+	LIFE_SUPPORT_ROOM,               # 5. Модуль Жизнеобеспечения
+	CONTROL_ROOM,                    # 6. Модуль Управления
+	OBSERVATORY_ROOM,                # 7. Модуль Обсерватории
+	MEDICAL_ROOM,                    # 8. Медицинский Модуль
+	GEOLOGICAL_ROOM,                 # 9. Геологический Модуль
+	RESOURCE_EXTRACTION_ROOM,        # 10. Модуль Добычи и Переработки Ресурсов
+	COMMUNICATIONS_ROOM,              # 11. Модуль Связи и Навигации_
+	
+	V_WAY, H_WAY, WAY_UP, WAY_DOWN, WAY_LEFT, WAY_RIGHT,
+}
+
+enum struct_fields {
+	SOURCE_ID,
+	SIZE,
+	POS_ATLAS,
+	LAYER
+}
+
+@onready var structs = {
+	StructType.EMPTY_ROOM: {
+		struct_fields.SOURCE_ID: 1,
+		struct_fields.SIZE: Vector2i(5,5),
+		struct_fields.POS_ATLAS: Vector2i(0,0),
+		struct_fields.LAYER: $buildings/buildings0
+	},
+	StructType.V_WAY: {
+		struct_fields.SOURCE_ID: 1,
+		struct_fields.SIZE: Vector2i(3,1),
+		struct_fields.POS_ATLAS: Vector2i(0,6),
+		struct_fields.LAYER: $buildings/buildings1
+	},
+	StructType.H_WAY: {
+		struct_fields.SOURCE_ID: 1,
+		struct_fields.SIZE: Vector2i(1,3),
+		struct_fields.POS_ATLAS: Vector2i(4,5),
+		struct_fields.LAYER: $buildings/buildings1
+	},
+	StructType.WAY_UP: {
+		struct_fields.SOURCE_ID: 1,
+		struct_fields.SIZE: Vector2i(3,1),
+		struct_fields.POS_ATLAS: Vector2i(0,5),
+		struct_fields.LAYER: $buildings/buildings1
+	},
+	StructType.WAY_DOWN: {
+		struct_fields.SOURCE_ID: 1,
+		struct_fields.SIZE: Vector2i(3,1),
+		struct_fields.POS_ATLAS: Vector2i(0,7),
+		struct_fields.LAYER: $buildings/buildings1
+	},
+	StructType.WAY_LEFT: {
+		struct_fields.SOURCE_ID: 1,
+		struct_fields.SIZE: Vector2i(1,3),
+		struct_fields.POS_ATLAS: Vector2i(3,5),
+		struct_fields.LAYER: $buildings/buildings1
+	},
+	StructType.WAY_RIGHT: {
+		struct_fields.SOURCE_ID: 1,
+		struct_fields.SIZE: Vector2i(1,3),
+		struct_fields.POS_ATLAS: Vector2i(5,5),
+		struct_fields.LAYER: $buildings/buildings1
+	},
+}
+
+var layers: Array[TileMapLayer]
+var layers_dict: Dictionary
+var astar_grid: AStarGrid2D
+
+func _list_childrens(node: Node2D):
+	for child in node.get_children():
+		if child is TileMapLayer:
+			layers.append(child)
+			layers_dict.get_or_add(child.name, child)
+		elif child is Node2D:
+			_list_childrens(child)
+	pass
+
+func _ready() -> void:
+	layers = []
+	_list_childrens(self)
+	astar_grid = AStarGrid2D.new()
+	astar_grid.region = layers_dict["ground"].get_used_rect()
+	astar_grid.cell_size = Vector2i(16, 16)
+	astar_grid.diagonal_mode = AStarGrid2D.DIAGONAL_MODE_NEVER
+	astar_grid.update()
+	
+	for x in $ground.get_used_rect().size.x:
+		for y in $ground.get_used_rect().size.y:
+			var tile_pos = Vector2i(x,y)
+			astar_grid.set_point_solid(tile_pos, not is_walkable(tile_pos))
+		
+	
+	
+func get_maxZ(tile_pos: Vector2i) -> int:
+	var max_z: int = -1024
+	for layer: TileMapLayer in layers:
+		if layer.get_cell_source_id(tile_pos) != -1 and layer.z_index > max_z:
+			max_z = layer.z_index
+	return max_z
+
+func get_toplayer(pos: Vector2i) -> TileMapLayer:
+	var toplayer: TileMapLayer = null
+	for layer: TileMapLayer in layers:
+		if layer.get_cell_tile_data(pos) != null:
+			if toplayer == null: toplayer = layer
+			elif layer.z_index > toplayer.z_index: toplayer = layer
+	return toplayer
+
+func place_road(pos: Vector2i) -> bool:
+	var layer: TileMapLayer = layers_dict["roads"]
+	if get_maxZ(pos) >= layer.z_index:
+		return false
+	layer.set_cells_terrain_connect([pos], 0, 2, true)
+	return true
+func erase_road(pos: Vector2i) -> bool:
+	var layer: TileMapLayer = layers_dict["roads"]
+	layer.erase_cell(pos)
+	return true
+
+func place_way(pos1: Vector2i, pos2: Vector2i) -> bool:
+	if pos1.x == pos2.x and pos1.y == pos2.y: return false
+	if pos1.x != pos2.x and pos1.y != pos2.y: return false
+	
+	var tiledata1: TileData = layers_dict["buildings0"].get_cell_tile_data(pos1)
+	var tiledata2: TileData = layers_dict["buildings0"].get_cell_tile_data(pos2)
+	
+	if tiledata1 == null or tiledata2 == null: return false
+	
+	if not (tiledata1.get_custom_data("is_center") and tiledata1.get_custom_data("struct_name")=="EMPTY_ROOM"): return false
+	if not (tiledata2.get_custom_data("is_center") and tiledata2.get_custom_data("struct_name")=="EMPTY_ROOM"): return false
+	
+	#Check place is free
+	if pos1.x != pos2.x:
+		if abs(pos1.x-pos2.x)<=5: return false
+		for x in range(min(pos1.x,pos2.x)+2, max(pos1.x,pos2.x)-1):
+			if get_maxZ(Vector2i(x, pos1.y)) >= structs[StructType.H_WAY][struct_fields.LAYER].z_index:
+					return false
+	if pos1.y != pos2.y:
+		if abs(pos1.y-pos2.y)<=5: return false
+		for y in range(min(pos1.y,pos2.y)+2, max(pos1.y,pos2.y)-1):
+			if get_maxZ(Vector2i(pos1.x, y)) >= structs[StructType.V_WAY][struct_fields.LAYER].z_index:
+					return false
+	
+	
+	if pos1.x != pos2.x:
+		place_struct(Vector2i(min(pos1.x,pos2.x)+2, pos1.y), StructType.WAY_LEFT)
+		place_struct(Vector2i(max(pos1.x,pos2.x)-2, pos1.y), StructType.WAY_RIGHT)
+		for x in range(min(pos1.x,pos2.x)+3, max(pos1.x,pos2.x)-2):
+			place_struct(Vector2i(x, pos1.y), StructType.H_WAY)
+	if pos1.y != pos2.y:
+		place_struct(Vector2i(pos1.x, min(pos1.y,pos2.y)+2), StructType.WAY_UP)
+		place_struct(Vector2i(pos1.x, max(pos1.y,pos2.y)-2), StructType.WAY_DOWN)
+		for y in range(min(pos1.y,pos2.y)+3, max(pos1.y,pos2.y)-2):
+			place_struct(Vector2i(pos1.x, y), StructType.V_WAY)
+	return true
+
+func destroy_building(pos: Vector2i, only_ways: bool = false):
+	for layer in layers:
+		var tiledata: TileData = layer.get_cell_tile_data(pos)
+		if tiledata != null and tiledata.get_custom_data("is_center"):
+			if tiledata.get_custom_data("struct_name") == "H_WAY":
+				remove_struct(pos)
+				destroy_building(pos+Vector2i.LEFT)
+				destroy_building(pos+Vector2i.RIGHT)
+			elif tiledata.get_custom_data("struct_name") == "V_WAY":
+				remove_struct(pos)
+				destroy_building(pos+Vector2i.UP)
+				destroy_building(pos+Vector2i.DOWN)
+			elif not only_ways and tiledata.get_custom_data("struct_name") == "EMPTY_ROOM":
+				remove_struct(pos)
+				destroy_building(pos+Vector2i.LEFT*3, true)
+				destroy_building(pos+Vector2i.RIGHT*3, true)
+				destroy_building(pos+Vector2i.UP*3, true)
+				destroy_building(pos+Vector2i.DOWN*3, true)
+			elif not only_ways:
+				remove_struct(pos)
+			return
+
+func remove_struct(pos: Vector2i):
+	for layer in layers:
+		var tiledata: TileData = layer.get_cell_tile_data(pos)
+		if tiledata != null and tiledata.get_custom_data("is_center"):
+			var struct_size = tiledata.get_custom_data("struct_size")
+			var half_size = Vector2i(struct_size.x / 2, struct_size.y / 2)
+			for x in range(struct_size.x): 
+				for y in range(struct_size.y):
+					var offset = Vector2i(x, y)
+					var tile_pos = pos+offset-half_size
+					layer.erase_cell(tile_pos)
+					astar_grid.set_point_solid(tile_pos, not is_walkable(tile_pos))
+			return
+
+func place_struct(pos: Vector2i, type: StructType) -> bool:
+	if not structs.has(type):
+		return false
+	var struct_size = structs[type][struct_fields.SIZE]
+	var layer = structs[type][struct_fields.LAYER]
+	var source_id = structs[type][struct_fields.SOURCE_ID]
+	var pos_atlas = structs[type][struct_fields.POS_ATLAS]
+	
+	var half_size = Vector2i(struct_size.x / 2, struct_size.y / 2)
+	
+	#Is place free check
+	for x in range(struct_size.x):
+			for y in range(struct_size.y):
+				var offset = Vector2i(x, y)
+				var tile_pos = pos+offset-half_size
+				if get_maxZ(tile_pos) >= layer.z_index:
+					return false
+					
+	for x in range(struct_size.x):
+			for y in range(struct_size.y):
+				var offset = Vector2i(x, y)
+				var tile_pos = pos+offset-half_size
+				layer.set_cell(tile_pos, source_id, Vector2i(x,y)+pos_atlas)
+				astar_grid.set_point_solid(tile_pos, not is_walkable(tile_pos))
+	return true
+
+func is_walkable(pos: Vector2i) -> bool:
+	var state: bool = true
+	for layer in layers:
+		var tiledata: TileData = layer.get_cell_tile_data(pos)
+		if tiledata != null and not tiledata.get_custom_data("walkable"):
+			state = false
+			break
+	return state

world/world.gd

@@ -0,0 +1,110 @@
+class_name World
+extends Node2D
+
+const tile_size: int = 16
+
+# Переменная для хранения ссылки на TileMap
+@onready var ground: TileMapLayer = $TileMap/ground
+@onready var tileMap: Node2D = $TileMap
+
+const SELECTION_SCENE = preload("res://UI/selection/selection.tscn")
+
+var selected_instrument: instruments
+var selected_tile: Vector2i
+var selected_tile2: Vector2i
+var selected: bool
+var selected2: bool
+var selection: Node
+var selection2: Node
+var lmb: bool
+var rmb: bool
+
+func _ready():
+	selection = SELECTION_SCENE.instantiate()
+	selection2 = SELECTION_SCENE.instantiate()
+	add_child(selection)
+	add_child(selection2)
+	change_instrument(instruments.NULL)
+
+enum instruments {
+	NULL,
+	DESTROY,
+	CONSTRUCT,
+	BUILD_ROAD
+}
+
+func select_tile(pos: Vector2i) -> Vector2i:
+	var toplayer: TileMapLayer = tileMap.get_toplayer(pos)
+	var tiledata: TileData = toplayer.get_cell_tile_data(pos)
+	if tiledata == null: return pos
+	
+	while tiledata.get_custom_data("center_direction") != Vector2i.ZERO:
+		pos+=tiledata.get_custom_data("center_direction")
+		tiledata = toplayer.get_cell_tile_data(pos)
+	return pos
+
+func _physics_process(delta: float) -> void:
+	if Input.is_action_just_released("left_mouse") and lmb:
+		selected_tile = select_tile(ground.local_to_map(get_global_mouse_position()-tileMap.global_position))
+		selected = true
+		if(selected_tile==selected_tile2):
+			selected_tile2 = Vector2i(-128,-128)
+			selected2 = false
+		print(tileMap.is_walkable(selected_tile))
+	if Input.is_action_just_released("right_mouse") and rmb:
+		selected_tile2 = select_tile(ground.local_to_map(get_global_mouse_position()-tileMap.global_position))
+		if(selected_tile!=selected_tile2): selected2 = true
+		else:
+			selected_tile2 = Vector2i(-128,-128)
+			selected2 = false
+
+	if Input.is_action_just_pressed("ui_cancel"):
+		change_instrument(instruments.NULL)
+	if Input.is_action_just_pressed("ui_right"):
+		change_instrument(selected_instrument+1)
+	if Input.is_action_just_pressed("ui_left"):
+		change_instrument(selected_instrument-1)
+	
+	match selected_instrument:
+		instruments.NULL:
+			pass
+		instruments.DESTROY:
+			if Input.is_action_just_pressed("ui_accept") and selected:
+				tileMap.destroy_building(selected_tile)
+		instruments.CONSTRUCT:
+			if Input.is_action_just_pressed("ui_accept") and selected and selected2:
+				tileMap.place_way(selected_tile, selected_tile2)
+			elif Input.is_action_just_pressed("ui_accept") and selected:
+				tileMap.place_struct(selected_tile, tileMap.StructType.EMPTY_ROOM)
+		instruments.BUILD_ROAD:
+			selected_tile = ground.local_to_map(get_global_mouse_position()-tileMap.global_position)
+			if Input.is_mouse_button_pressed(MOUSE_BUTTON_LEFT):
+				tileMap.place_road(selected_tile)
+			elif Input.is_mouse_button_pressed(MOUSE_BUTTON_RIGHT):
+				tileMap.erase_road(selected_tile)
+	selection.offset = ground.map_to_local(selected_tile)+tileMap.global_position
+	selection2.offset = ground.map_to_local(selected_tile2)+tileMap.global_position
+
+func change_instrument(new: instruments):
+	selected_tile = Vector2i(-128, -128)
+	selected_tile2 = Vector2i(-128, -128)
+	selected = false
+	selected2 = false
+	selected_instrument = new
+	
+	match selected_instrument:
+		instruments.NULL:
+			lmb = true
+			rmb = false
+		instruments.DESTROY:
+			lmb = true
+			rmb = false
+		instruments.CONSTRUCT:
+			lmb = true
+			rmb = true
+		instruments.BUILD_ROAD:
+			lmb = false
+			rmb = false
+
+func _input(event):
+	pass