Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-05-13· OpenAIAi2 WildChat-4.8M (AI2)

помоги разобраться как добавить вместо квадратов и линий текстуры из тайловыйх карт вот…

  1. User

    помоги разобраться как добавить вместо квадратов и линий текстуры из тайловыйх карт вот код генерации подземелий для 2д игры на движке Годот 4 extends Node2D

    Параметры генерации

    @export var room_count: int = 5 @export var room_min_size: Vector2 = Vector2(40, 40) @export var room_max_size: Vector2 = Vector2(100, 100)

    Структуры данных для хранения данных о комнатах и проходах

    var rooms = [] var corridors = []

    Начальная точка генерации

    var start_position: Vector2 = Vector2(0, 0)

    func _ready(): generate_dungeon()

    func generate_dungeon(): rooms.clear() corridors.clear()

    generate_rooms()
    connect_rooms()
    generate_corridors()
    queue_redraw()  # Обновить сцену для отрисовки
    

    func generate_rooms(): var rng = RandomNumberGenerator.new()

    for i in range(room_count):
    	var room_size = Vector2(
    		rng.randi_range(room_min_size.x, room_max_size.x),
    		rng.randi_range(room_min_size.y, room_max_size.y)
    	)
    	var room_position = Vector2(
    		rng.randi_range(-300, 300),
    		rng.randi_range(-300, 300)
    	)
    	var room = Rect2(room_position, room_size)
    	rooms.append(room)
    

    func connect_rooms(): # Сортировка комнат по расстоянию от начальной точки rooms.sort_custom(Callable(self, "_compare_rooms"))

    for i in range(rooms.size() - 1):
    	var room_a = rooms[i]
    	var room_b = rooms[i + 1]
    	var pos_a = room_a.position + room_a.size / 2
    	var pos_b = room_b.position + room_b.size / 2
    	
    	if randi() % 2 == 0:
    		# сначала горизонтальный, потом вертикальный
    		corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
    		corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
    	else:
    		# сначала вертикальный, потом горизонтальный
    		corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
    		corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    

    func _compare_rooms(a, b) -> int: return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))

    func generate_corridors(): # Тут добавь логику для генерации и рисования коридоров pass

    func _draw(): # Используем _draw() для рисования комнат и коридоров for room in rooms: # Нарисуй комнаты (например, рисуем квадраты на экране) draw_rect(Rect2(room.position, room.size), Color(1, 0, 0))

    for corridor in corridors:
    	# Нарисуй коридоры (например, рисуем линии на экране)
    	draw_line(corridor[0], corridor[1], Color(0, 1, 0), 2)
    
  2. Assistant

    Для того чтобы заменить рисунки квадратов и линий на текстуры из тайловых карт, вам потребуется использовать узел TileMap и создать тайловую карту заранее. Возможно, придется создать нужные тайлы, такие как пол, стены и уголки, в редакторе Godot и сохранить их в ресурсе типа TileSet.

    Ниже приведен пример того, как можно модифицировать ваш код для использования TileMap и тайлов.

    1. Создайте TileSet и добавьте необходимые тайлы.
    2. Создайте узел TileMap в вашем сцене и привяжите к нему TileSet.

    После подготовки тайловых карт, вам нужно будет изменить ваш код генерации карт, чтобы заполнялся TileMap, а не непосредственно рисовались примитивы.

    Вот пример изменений в вашем коде:

    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(10, 10) # более подходящие размеры для тайлов
    @export var room_max_size: Vector2 = Vector2(25, 25)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms: Array[Rect2] = []
    var corridors: Array[Array[Vector2]] = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map: TileMap
    
    func _ready():
    	# Находим узел TileMap
    	tile_map = $TileMap
    	generate_dungeon()
    
    func generate_dungeon():
    	rooms.clear()
    	corridors.clear()
    	tile_map.clear()  # очищаем карту перед генерацией
    
    	generate_rooms()
    	connect_rooms()
    	generate_corridors()
    	render_dungeon()  # Отображаем сгенерированные комнаты и коридоры
    
    func generate_rooms():
    	var rng = RandomNumberGenerator.new()
    
    	for i in range(room_count):
    		var room_size = Vector2(
    			rng.randi_range(room_min_size.x, room_max_size.x),
    			rng.randi_range(room_min_size.y, room_max_size.y)
    		)
    		var room_position = Vector2(
    			rng.randi_range(-30, 30),
    			rng.randi_range(-30, 30)
    		)
    		var room = Rect2(room_position.floor(), room_size.floor())
    		rooms.append(room)
    
    func connect_rooms():
    	# Сортировка комнат по расстоянию от начальной точки
    	rooms.sort_custom(Callable(self, "_compare_rooms"))
    	
    	for i in range(rooms.size() - 1):
    		var room_a = rooms[i]
    		var room_b = rooms[i + 1]
    		var pos_a = room_a.position + room_a.size / 2
    		var pos_b = room_b.position + room_b.size / 2
    		
    		if randi() % 2 == 0:
    			# сначала горизонтальный, потом вертикальный
    			corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
    			corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
    		else:
    			# сначала вертикальный, потом горизонтальный
    			corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
    			corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
    	return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func generate_corridors():
    	# Тут добавь логику для генерации и рисования коридоров
    	pass
    
    func render_dungeon():
    	# Используем TileMap для рисования комнат и коридоров
    	for room in rooms:
    		for x in range(room.position.x, room.position.x + room.size.x):
    			for y in range(room.position.y, room.position.y + room.size.y):
    				tile_map.set_cellv(Vector2(x, y), 1)  # Предполагаем, что 1 это id плитки пола
    	
    	for corridor in corridors:
    		var start = corridor[0]
    		var end = corridor[1]
    		if start.x == end.x:  # Вертикальный коридор
    			for y in range(min(start.y, end.y), max(start.y, end.y) + 1):
    				tile_map.set_cellv(Vector2(start.x, y), 1)  # 1 это id плитки коридора
    		elif start.y == end.y:  # Горизонтальный коридор
    			for x in range(min(start.x, end.x), max(start.x, end.x) + 1):
    				tile_map.set_cellv(Vector2(x, start.y), 1)  # 1 это id плитки коридора
    

    В этом коде предполагается, что 1 - это id тайлов пола или коридора в TileSet. Ваша задача сделать так, чтобы тайлы отображались корректно, поэтому убедитесь, что TileSet имеет соответствующие id для плиток.

    Это изменение сделает ваш код более наглядным, используя заранее подготовленные тайлы для визуализации подземелий.

  3. User

    у меня 2 тайловых карты TileMap_floor для поло и TileMap_wall для стен каждая содержит 1 текстуру 16х16 пиксилий

  4. Assistant

    Если у вас есть два TileMap для пола и стен, каждый из которых содержит по одной текстуре 16x16 пикселей, вам нужно будет обновить вашу процедуру генерации, чтобы учесть оба тайловых слоя и правильно размещать тайлы пола и стен.

    Вот пример, который показывает, как можно сделать это:

    1. Убедитесь, что ваши TileMap узлы называются TileMap_floor и TileMap_wall и содержат соответствующие текстуры.
    2. Измените свой код, чтобы корректно ставить тайлы на карте для пола и стен.
    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(10, 10)  # Более подходящие размеры для тайлов
    @export var room_max_size: Vector2 = Vector2(25, 25)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms: Array[Rect2] = []
    var corridors: Array[Array[Vector2]] = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map_floor: TileMap
    var tile_map_wall: TileMap
    
    func _ready():
        # Находим узлы TileMap
        tile_map_floor = $TileMap_floor
        tile_map_wall = $TileMap_wall
        generate_dungeon()
    
    func generate_dungeon():
        rooms.clear()
        corridors.clear()
        tile_map_floor.clear()  # Очищаем карту перед генерацией
        tile_map_wall.clear()  # Очищаем карту перед генерацией
    
        generate_rooms()
        connect_rooms()
        generate_corridors()
        render_dungeon()  # Отображаем сгенерированные комнаты и коридоры
    
    func generate_rooms():
        var rng = RandomNumberGenerator.new()
    
        for i in range(room_count):
            var room_size = Vector2(
                rng.randi_range(room_min_size.x, room_max_size.x),
                rng.randi_range(room_min_size.y, room_max_size.y)
            )
            var room_position = Vector2(
                rng.randi_range(-30, 30),
                rng.randi_range(-30, 30)
            )
            var room = Rect2(room_position.floor(), room_size.floor())
            rooms.append(room)
    
    func connect_rooms():
        # Сортировка комнат по расстоянию от начальной точки
        rooms.sort_custom(Callable(self, "_compare_rooms"))
    
        for i in range(rooms.size() - 1):
            var room_a = rooms[i]
            var room_b = rooms[i + 1]
            var pos_a = room_a.position + room_a.size / 2
            var pos_b = room_b.position + room_b.size / 2
    
            if randi() % 2 == 0:
                # сначала горизонтальный, потом вертикальный
                corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
                corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
            else:
                # сначала вертикальный, потом горизонтальный
                corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
                corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
        return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func render_dungeon():
        # Используем TileMap для рисования комнат и коридоров
        for room in rooms:
            for x in range(room.position.x, room.position.x + room.size.x):
                for y in range(room.position.y, room.position.y + room.size.y):
                    tile_map_floor.set_cellv(Vector2(x, y), 1)  # 1 это ID плитки пола
    
                    # Если блок находится на границе комнаты, задаём стену
                    if x == room.position.x or x == room.position.x + room.size.x - 1 or y == room.position.y or y == room.position.y + room.size.y - 1:
                        tile_map_wall.set_cellv(Vector2(x, y), 1)  # 1 это ID плитки стены
    
        for corridor in corridors:
            var start = corridor[0]
            var end = corridor[1]
    
            if start.x == end.x:  # Вертикальный коридор
                for y in range(min(start.y, end.y), max(start.y, end.y) + 1):
                    tile_map_floor.set_cellv(Vector2(start.x, y), 1)  # 1 это ID плитки коридора
            elif start.y == end.y:  # Горизонтальный коридор
                for x in range(min(start.x, end.x), max(start.x, end.x) + 1):
                    tile_map_floor.set_cellv(Vector2(x, start.y), 1)  # 1 это ID плитки коридора
    

    Обратите внимание, что в этом примере мы добавляем тайлы пола на TileMap_floor, и если тайл находится на границе комнаты, мы также добавляем тайл стены на TileMap_wall.

    Также, чтобы улучшить видимые переходы между комнатами и коридорами, можно указывать стены для коридоров или дополнительные правила для границ, чтобы создать стены вокруг коридоров.

  5. User

    я сделал 1 таилмап с названием TileMap

  6. Assistant

    Отлично! Если у вас есть только один TileMap, вам нужно управлять прорисовкой и пола, и стен в этом одном TileMap. Вы можете сделать это, присваивая различные ID тайлов в TileMap для пола и стен.

    Вот как можно изменить ваш код, чтобы использовать один TileMap для обоих типов тайлов:

    1. Создайте TileSet, добавьте тайлы для пола и стен, и назначьте различные ID для этих тайлов, например:

      • 0: Ничего (пустой тайл)
      • 1: Пол
      • 2: Стена
    2. Модифицируйте свой код для установки тайлов в одном TileMap.

    Пример кода:

    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(10, 10)  # Более подходящие размеры для тайлов
    @export var room_max_size: Vector2 = Vector2(25, 25)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms: Array[Rect2] = []
    var corridors: Array[Array[Vector2]] = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map: TileMap
    
    func _ready():
        # Находим узел TileMap
        tile_map = $TileMap
        generate_dungeon()
    
    func generate_dungeon():
        rooms.clear()
        corridors.clear()
        tile_map.clear()  # Очищаем карту перед генерацией
    
        generate_rooms()
        connect_rooms()
        generate_corridors()
        render_dungeon()  # Отображаем сгенерированные комнаты и коридоры
    
    func generate_rooms():
        var rng = RandomNumberGenerator.new()
    
        for i in range(room_count):
            var room_size = Vector2(
                rng.randi_range(room_min_size.x, room_max_size.x),
                rng.randi_range(room_min_size.y, room_max_size.y)
            )
            var room_position = Vector2(
                rng.randi_range(-30, 30),
                rng.randi_range(-30, 30)
            )
            var room = Rect2(room_position.floor(), room_size.floor())
            rooms.append(room)
    
    func connect_rooms():
        # Сортировка комнат по расстоянию от начальной точки
        rooms.sort_custom(Callable(self, "_compare_rooms"))
    
        for i in range(rooms.size() - 1):
            var room_a = rooms[i]
            var room_b = rooms[i + 1]
            var pos_a = room_a.position + room_a.size / 2
            var pos_b = room_b.position + room_b.size / 2
    
            if randi() % 2 == 0:
                # Сначала горизонтальный, потом вертикальный
                corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
                corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
            else:
                # Сначала вертикальный, потом горизонтальный
                corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
                corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
        return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func render_dungeon():
        # Используем TileMap для рисования комнат и коридоров
        for room in rooms:
            for x in range(room.position.x, room.position.x + room.size.x):
                for y in range(room.position.y, room.position.y + room.size.y):
                    tile_map.set_cellv(Vector2(x, y), 1)  # 1 это ID плитки пола
    
                    # Если блок находится на границе комнаты, задаём стену
                    if x == room.position.x or x == room.position.x + room.size.x - 1 or y == room.position.y or y == room.position.y + room.size.y - 1:
                        tile_map.set_cellv(Vector2(x, y), 2)  # 2 это ID плитки стены
    
        for corridor in corridors:
            var start = corridor[0]
            var end = corridor[1]
    
            if start.x == end.x:  # Вертикальный коридор
                for y in range(min(start.y, end.y), max(start.y, end.y) + 1):
                    tile_map.set_cellv(Vector2(start.x, y), 1)  # 1 это ID плитки коридора
            elif start.y == end.y:  # Горизонтальный коридор
                for x in range(min(start.x, end.x), max(start.x, end.x) + 1):
                    tile_map.set_cellv(Vector2(x, start.y), 1)  # 1 это ID плитки коридора
    

    В этом примере предполагается, что у вас есть тайлсет, где:

    • 0 — пустой тайл.
    • 1 — тайл пола.
    • 2 — тайл стены.

    Такой подход позволяет вам управлять двумя типами тайлов (стены и пол) в одном TileMap. Используя if-условия при генерации тайлов, можно более гибко определять, где должны быть полы и стены.

  7. User

    Строка 10:Nested typed collections are not supported.

  8. Assistant

    Если ваше сообщение об ошибке связано с использованием вложенных типов в переменных (таких как Array[Array[Vector2]]), вам нужно их заменить на простые типы или по умолчанию использовать Array[Godot.Variant], так как Godot не поддерживает вложенные типы коллекций в GDScript.

    Вы можете использовать обычные массивы и просто обращаться к элементам аккуратно. Вот исправленный пример с использованием обычных массивов:

    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(10, 10)  # Более подходящие размеры для тайлов
    @export var room_max_size: Vector2 = Vector2(25, 25)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms = []
    var corridors = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map: TileMap
    
    func _ready():
        # Находим узел TileMap
        tile_map = $TileMap
        generate_dungeon()
    
    func generate_dungeon():
        rooms.clear()
        corridors.clear()
        tile_map.clear()  # Очищаем карту перед генерацией
    
        generate_rooms()
        connect_rooms()
        generate_corridors()
        render_dungeon()  # Отображаем сгенерированные комнаты и коридоры
    
    func generate_rooms():
        var rng = RandomNumberGenerator.new()
    
        for i in range(room_count):
            var room_size = Vector2(
                rng.randi_range(room_min_size.x, room_max_size.x),
                rng.randi_range(room_min_size.y, room_max_size.y)
            )
            var room_position = Vector2(
                rng.randi_range(-30, 30),
                rng.randi_range(-30, 30)
            )
            var room = Rect2(room_position.floor(), room_size.floor())
            rooms.append(room)
    
    func connect_rooms():
        # Сортировка комнат по расстоянию от начальной точки
        rooms.sort_custom(Callable(self, "_compare_rooms"))
    
        for i in range(rooms.size() - 1):
            var room_a = rooms[i]
            var room_b = rooms[i + 1]
            var pos_a = room_a.position + room_a.size / 2
            var pos_b = room_b.position + room_b.size / 2
    
            if randi() % 2 == 0:
                # сначала горизонтальный, потом вертикальный
                corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
                corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
            else:
                # сначала вертикальный, потом горизонтальный
                corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
                corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
        return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func render_dungeon():
        # Используем TileMap для рисования комнат и коридоров
        for room in rooms:
            for x in range(room.position.x, room.position.x + room.size.x):
                for y in range(room.position.y, room.position.y + room.size.y):
                    tile_map.set_cellv(Vector2(x, y), 1)  # 1 это ID плитки пола
    
                    # Если блок находится на границе комнаты, задаём стену
                    if x == room.position.x or x == room.position.x + room.size.x - 1 or y == room.position.y or y == room.position.y + room.size.y - 1:
                        tile_map.set_cellv(Vector2(x, y), 2)  # 2 это ID плитки стены
    
        for corridor in corridors:
            var start = corridor[0]
            var end = corridor[1]
    
            if start.x == end.x:  # Вертикальный коридор
                for y in range(min(start.y, end.y), max(start.y, end.y) + 1):
                    tile_map.set_cellv(Vector2(start.x, y), 1)  # 1 это ID плитки коридора
            elif start.y == end.y:  # Горизонтальный коридор
                for x in range(min(start.x, end.x), max(start.x, end.x) + 1):
                    tile_map.set_cellv(Vector2(x, start.y), 1)  # 1 это ID плитки коридора
    

    В этом исправленном коде массив corridors не имеет явного типа, а rooms объявлен как массив без типа. Это позволяет избежать ошибки с вложенными коллекциями типов.

  9. User

    Строка 30:Function "generate_corridors()" not found in base self.

  10. Assistant

    Ошибки типа Function not found часто возникают, если функция объявлена, но не реализована, неправильно написана или если её вызов происходит до её объявления. В вашем случае generate_corridors можно либо удалить (если она не используется), либо реализовать (если она должна быть использована).

    Однако в текущем контексте функция generate_corridors() нигде не вызывается и не используется в коде, так что нам нет необходимости её объявлять.

    Давайте скорректируем ваш код, удалив её и убедимся, что основная функциональность работает правильно:

    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(10, 10)  # Более подходящие размеры для тайлов
    @export var room_max_size: Vector2 = Vector2(25, 25)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms = []
    var corridors = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map: TileMap
    
    func _ready():
        # Находим узел TileMap
        tile_map = $TileMap
        generate_dungeon()
    
    func generate_dungeon():
        rooms.clear()
        corridors.clear()
        tile_map.clear()  # Очищаем карту перед генерацией
    
        generate_rooms()
        connect_rooms()
        render_dungeon()  # Отображаем сгенерированные комнаты и коридоры
    
    func generate_rooms():
        var rng = RandomNumberGenerator.new()
    
        for i in range(room_count):
            var room_size = Vector2(
                rng.randi_range(room_min_size.x, room_max_size.x),
                rng.randi_range(room_min_size.y, room_max_size.y)
            )
            var room_position = Vector2(
                rng.randi_range(-30, 30),
                rng.randi_range(-30, 30)
            )
            var room = Rect2(room_position.floor(), room_size.floor())
            rooms.append(room)
    
    func connect_rooms():
        # Сортировка комнат по расстоянию от начальной точки
        rooms.sort_custom(Callable(self, "_compare_rooms"))
    
        for i in range(rooms.size() - 1):
            var room_a = rooms[i]
            var room_b = rooms[i + 1]
            var pos_a = room_a.position + room_a.size / 2
            var pos_b = room_b.position + room_b.size / 2
    
            if randi() % 2 == 0:
                # сначала горизонтальный, потом вертикальный
                corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
                corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
            else:
                # сначала вертикальный, потом горизонтальный
                corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
                corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
        return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func render_dungeon():
        # Используем TileMap для рисования комнат и коридоров
        for room in rooms:
            for x in range(room.position.x, room.position.x + room.size.x):
                for y in range(room.position.y, room.position.y + room.size.y):
                    tile_map.set_cellv(Vector2(x, y), 1)  # 1 это ID плитки пола
    
                    # Если блок находится на границе комнаты, задаём стену
                    if x == room.position.x or x == room.position.x + room.size.x - 1 or y == room.position.y or y == room.position.y + room.size.y - 1:
                        tile_map.set_cellv(Vector2(x, y), 2)  # 2 это ID плитки стены
    
        for corridor in corridors:
            var start = corridor[0]
            var end = corridor[1]
    
            if start.x == end.x:  # Вертикальный коридор
                for y in range(min(start.y, end.y), max(start.y, end.y) + 1):
                    tile_map.set_cellv(Vector2(start.x, y), 1)  # 1 это ID плитки коридора
            elif start.y == end.y:  # Горизонтальный коридор
                for x in range(min(start.x, end.x), max(start.x, end.x) + 1):
                    tile_map.set_cellv(Vector2(x, start.y), 1)  # 1 это ID плитки коридора
    

    В этом обновленном коде я:

    1. Удалил generate_corridors из всех мест.
    2. Убедился, что функции generate_rooms(), connect_rooms() и render_dungeon() вызываются в правильном порядке для корректной генерации и отрисовки подземелья.
  11. User

    [Игнорировать]Строка 37 (NARROWING_CONVERSION):Narrowing conversion (float is converted to int and loses precision). [Игнорировать]Строка 37 (NARROWING_CONVERSION):Narrowing conversion (float is converted to int and loses precision). [Игнорировать]Строка 38 (NARROWING_CONVERSION):Narrowing conversion (float is converted to int and loses precision). [Игнорировать]Строка 38 (NARROWING_CONVERSION):Narrowing conversion (float is converted to int and loses precision).

  12. Assistant

    Ошибки "Narrowing conversion" означают, что происходит преобразование данных, которое может привести к потере точности, например, преобразование из float в int.

    В контексте преобразования координат векторов, вероятно, проблема в функции Vector2.floor(), которая возвращает Vector2 с округлением вниз значений. Однако, когда вы преобразуете одно значение float в int, это может вызвать предупреждение.

    Для безопасного преобразования вы можете использовать методы приведения типов. Давайте поправим код:

    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(10, 10)  # Более подходящие размеры для тайлов
    @export var room_max_size: Vector2 = Vector2(25, 25)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms = []
    var corridors = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map: TileMap
    
    func _ready():
        # Находим узел TileMap
        tile_map = $TileMap
        generate_dungeon()
    
    func generate_dungeon():
        rooms.clear()
        corridors.clear()
        tile_map.clear()  # Очищаем карту перед генерацией
    
        generate_rooms()
        connect_rooms()
        render_dungeon()  # Отображаем сгенерированные комнаты и коридоры
    
    func generate_rooms():
        var rng = RandomNumberGenerator.new()
    
        for i in range(room_count):
            var room_size = Vector2(
                rng.randi_range(int(room_min_size.x), int(room_max_size.x)),
                rng.randi_range(int(room_min_size.y), int(room_max_size.y))
            )
            var room_position = Vector2(
                rng.randi_range(-30, 30),
                rng.randi_range(-30, 30)
            )
            var room = Rect2(room_position.floor(), room_size.floor())
            rooms.append(room)
    
    func connect_rooms():
        # Сортировка комнат по расстоянию от начальной точки
        rooms.sort_custom(Callable(self, "_compare_rooms"))
    
        for i in range(rooms.size() - 1):
            var room_a = rooms[i]
            var room_b = rooms[i + 1]
            var pos_a = room_a.position + room_a.size / 2
            var pos_b = room_b.position + room_b.size / 2
    
            if randi() % 2 == 0:
                # сначала горизонтальный, потом вертикальный
                corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
                corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
            else:
                # сначала вертикальный, потом горизонтальный
                corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
                corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
        return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func render_dungeon():
        # Используем TileMap для рисования комнат и коридоров
        for room in rooms:
            for x in range(int(room.position.x), int(room.position.x + room.size.x)):
                for y in range(int(room.position.y), int(room.position.y + room.size.y)):
                    tile_map.set_cellv(Vector2(x, y), 1)  # 1 это ID плитки пола
    
                    # Если блок находится на границе комнаты, задаём стену
                    if x == int(room.position.x) or x == int(room.position.x + room.size.x) - 1 or y == int(room.position.y) or y == int(room.position.y + room.size.y) - 1:
                        tile_map.set_cellv(Vector2(x, y), 2)  # 2 это ID плитки стены
    
        for corridor in corridors:
            var start = corridor[0]
            var end = corridor[1]
    
            if start.x == end.x:  # Вертикальный коридор
                for y in range(int(min(start.y, end.y)), int(max(start.y, end.y)) + 1):
                    tile_map.set_cellv(Vector2(start.x, y), 1)  # 1 это ID плитки коридора
            elif start.y == end.y:  # Горизонтальный коридор
                for x in range(int(min(start.x, end.x)), int(max(start.x, end.x)) + 1):
                    tile_map.set_cellv(Vector2(x, start.y), 1)  # 1 это ID плитки коридора
    

    В этом обновленном коде я добавил явное преобразование типов с float на int с помощью int(), что должно устранить предупреждения о сужающем преобразовании.

  13. User

    invalid call. Nonexistent function 'set_cellv' in base 'TeleMap'

  14. Assistant

    Ошибки типа invalid call. Nonexistent function 'set_cellv' in base 'TileMap' означают, что в Godot 4 метод set_cellv() был заменён на set_cell().

    Актуальные методы для установки тайлов заново:

    • set_cell(): установка тайлов в определённую координату.
    • set_cellv(): установка тайлов вектором в определённую координату (deprecated в последних версиях).

    Используем правильные методы:

    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(10, 10)  # Более подходящие размеры для тайлов
    @export var room_max_size: Vector2 = Vector2(25, 25)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms = []
    var corridors = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map: TileMap
    
    func _ready():
        # Находим узел TileMap
        tile_map = $TileMap
        generate_dungeon()
    
    func generate_dungeon():
        rooms.clear()
        corridors.clear()
        tile_map.clear()  # Очищаем карту перед генерацией
    
        generate_rooms()
        connect_rooms()
        render_dungeon()
    
    func generate_rooms():
        var rng = RandomNumberGenerator.new()
    
        for i in range(room_count):
            var room_size = Vector2(
                rng.randi_range(int(room_min_size.x), int(room_max_size.x)),
                rng.randi_range(int(room_min_size.y), int(room_max_size.y))
            )
            var room_position = Vector2(
                rng.randi_range(-30, 30),
                rng.randi_range(-30, 30)
            )
            var room = Rect2(room_position, room_size)
            rooms.append(room)
    
    func connect_rooms():
        # Сортировка комнат по расстоянию от начальной точки
        rooms.sort_custom(Callable(self, "_compare_rooms"))
    
        for i in range(rooms.size() - 1):
            var room_a = rooms[i]
            var room_b = rooms[i + 1]
            var pos_a = room_a.position + room_a.size / 2
            var pos_b = room_b.position + room_b.size / 2
    
            if randi() % 2 == 0:
                # сначала горизонтальный, потом вертикальный
                corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
                corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
            else:
                # сначала вертикальный, потом горизонтальный
                corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
                corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
        return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func render_dungeon():
        # Используем TileMap для рисования комнат и коридоров
        for room in rooms:
            for x in range(int(room.position.x), int(room.position.x + room.size.x)):
                for y in range(int(room.position.y), int(room.position.y + room.size.y)):
                    tile_map.set_cell(0, Vector2i(x, y), 1)  # 1 это ID плитки пола
    
                    # Если блок находится на границе комнаты, задаём стену
                    if x == int(room.position.x) or x == int(room.position.x + room.size.x) - 1 or y == int(room.position.y) or y == int(room.position.y + room.size.y) - 1:
                        tile_map.set_cell(0, Vector2i(x, y), 2)  # 2 это ID плитки стены
    
        for corridor in corridors:
            var start = corridor[0]
            var end = corridor[1]
    
            if start.x == end.x:  # Вертикальный коридор
                for y in range(int(min(start.y, end.y)), int(max(start.y, end.y)) + 1):
                    tile_map.set_cell(0, Vector2i(start.x, y), 1)  # 1 это ID плитки коридора
            elif start.y == end.y:  # Горизонтальный коридор
                for x in range(int(min(start.x, end.x)), int(max(start.x, end.x)) + 1):
                    tile_map.set_cell(0, Vector2i(x, start.y), 1)  # 1 это ID плитки коридора
    

    В этом коде мы изменили метод set_cellv на set_cell, а также использовали Vector2i для задания координат.

    Основные изменения:

    • Использование tile_map.set_cell(0, Vector2i(x, y), 1) вместо tile_map.set_cellv(Vector2(x, y), 1).
    • Vector2i это целочисленный вектор, который ожидается методом set_cell в Godot 4.
  15. User

    нечего не рисует хотя код вроде как работает

  16. Assistant

    Если код работает, но ничего не рисует, существуют несколько возможных причин:

    1. Плиты тайлов не устанавливаются правильно.
    2. Координаты могут быть неверными или недоступными для отображения.
    3. Отступ (offset) в TileMap может быть настроен неправильно.
    4. Проблемы с видимостью или слоями (layers).

    Давайте разберём ситуацию:

    1. Проверьте правильность координат:
      • Возможно, вы создаете комнаты и коридоры в диапазонах, которые находятся вне экрана или области видимости камеры.
    2. Убедитесь, что на TileMap установлена TileSet с тайлами:
      • Проверьте, что ваш TileMap реально использует тот TileSet, который имеет плитки с указанными ID (1 для пола и 2 для стены).

    Попробуем обновить код, добавив возможность отладки, рисуя сетку или выводя координаты:

    extends Node2D
    
    # Параметры генерации
    @export var room_count: int = 5
    @export var room_min_size: Vector2 = Vector2(5, 5)  # Сделаем комнаты поменьше, чтобы видеть больше
    @export var room_max_size: Vector2 = Vector2(10, 10)
    
    # Структуры данных для хранения данных о комнатах и проходах
    var rooms = []
    var corridors = []
    
    # Начальная точка генерации
    var start_position: Vector2 = Vector2(0, 0)
    
    # TileMap для отображения
    var tile_map: TileMap
    
    func _ready():
        # Находим узел TileMap
        tile_map = $TileMap
        generate_dungeon()
    
    func generate_dungeon():
        rooms.clear()
        corridors.clear()
        tile_map.clear()  # Очищаем карту перед генерацией
    
        generate_rooms()
        connect_rooms()
        render_dungeon()
    
    func generate_rooms():
        var rng = RandomNumberGenerator.new()
    
        for i in range(room_count):
            var room_size = Vector2(
                rng.randi_range(int(room_min_size.x), int(room_max_size.x)),
                rng.randi_range(int(room_min_size.y), int(room_max_size.y))
            )
            var room_position = Vector2(
                rng.randi_range(-30, 30),
                rng.randi_range(-30, 30)
            )
            var room = Rect2(room_position, room_size)
            rooms.append(room)
            print("Room ", i, ": position = ", room.position, " size = ", room.size)  # Вывод информации о комнатах
    
    func connect_rooms():
        # Сортировка комнат по расстоянию от начальной точки
        rooms.sort_custom(Callable(self, "_compare_rooms"))
    
        for i in range(rooms.size() - 1):
            var room_a = rooms[i]
            var room_b = rooms[i + 1]
            var pos_a = room_a.position + room_a.size / 2
            var pos_b = room_b.position + room_b.size / 2
    
            if randi() % 2 == 0:
                # сначала горизонтальный, потом вертикальный
                corridors.append([pos_a, Vector2(pos_b.x, pos_a.y)])
                corridors.append([Vector2(pos_b.x, pos_a.y), pos_b])
            else:
                # сначала вертикальный, потом горизонтальный
                corridors.append([pos_a, Vector2(pos_a.x, pos_b.y)])
                corridors.append([Vector2(pos_a.x, pos_b.y), pos_b])
            print("Corridor ", i, ": from ", pos_a, " to ", pos_b)  # Вывод информации о коридорах
    
    func _compare_rooms(a: Rect2, b: Rect2) -> int:
        return int(a.position.distance_to(start_position) - b.position.distance_to(start_position))
    
    func render_dungeon():
        # Используем TileMap для рисования комнат и коридоров
        for room in rooms:
            for x in range(int(room.position.x), int(room.position.x + room.size.x)):
                for y in range(int(room.position.y), int(room.position.y + room.size.y)):
                    tile_map.set_cell(0, Vector2i(x, y), 1)  # 1 это ID плитки пола
    
                    # Если блок находится на границе комнаты, задаём стену
                    if x == int(room.position.x) or x == int(room.position.x + room.size.x) - 1 or y == int(room.position.y) or y == int(room.position.y + room.size.y) - 1:
                        tile_map.set_cell(0, Vector2i(x, y), 2)  # 2 это ID плитки стены
    
        for corridor in corridors:
            var start = corridor[0]
            var end = corridor[1]
    
            if start.x == end.x:  # Вертикальный коридор
                for y in range(int(min(start.y, end.y)), int(max(start.y, end.y)) + 1):
                    tile_map.set_cell(0, Vector2i(start.x, y), 1)  # 1 это ID плитки коридора
            elif start.y == end.y:  # Горизонтальный коридор
                for x in range(int(min(start.x, end.x)), int(max(start.x, end.x)) + 1):
                    tile_map.set_cell(0, Vector2i(x, start.y), 1)  # 1 это ID плитки коридора
    

    Добавив больше отладочной информации и уменьшив размеры комнат, вы сможете увидеть, что происходит в процессе генерации. Убедитесь также, что настроили камеру или начальные координаты так, чтобы они отображались на экране.

    Если по-прежнему ничего не отображается, обязательно проконтролируйте следующее:

    1. Удостоверьтесь, что TileMap узел и тайлсет корректно настроены и привязаны.
    2. Проверьте слои видимости (visibility layers) и убедитесь, что TileMap узел отчеканен, видим и не перекрыт другими объектами.
    3. Убедитесь, что размеры, координаты и сдвиги (offsets) также корректны и соответствуют вашему экрану.