это скрипт для мяча который отскакивает от поверхность extends CharacterBody2D @export…
- User
это скрипт для мяча который отскакивает от поверхность extends CharacterBody2D
@export var speed = 200
func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() velocity = Vector2(randf_range(-1, 1), randf_range(-1, 1)).normalized() * speed
func _physics_process(delta): # Двигаем объект move_and_slide()
# Проверяем столкновение if get_slide_collision_count() > 0: # Находим нормали всех столкновений и используем их для изменения направления for i in range(get_slide_collision_count()): var collision = get_slide_collision(i) velocity = velocity.bounce(collision.get_normal()) # Добавляем немного случайности для более естественного поведения velocity += Vector2(randf_range(-0.5, 0.5), randf_range(-0.5, 0.5)) * speed * 0.1 # Нормализуем скорость и умножаем её на значение скорости velocity = velocity.normalized() * speed но он это делает под нереальными углами может отскочить от поверхности в которой столкнулся назад или под прямым углом - Assistant
Проблема с неожиданным поведением отскоков, скорее всего, связана с накоплением случайных векторов и их влиянием на нормализованный вектор скорости. Чтобы исправить это, можно удалить или уменьшить коэффициент случайности и внимательно следить за расчетом новой скорости после столкновений.
Вот исправленный скрипт, в котором изменения сделаны для улучшения логики отскоков:
extends CharacterBody2D @export var speed = 200 func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() velocity = Vector2(randf_range(-1, 1), randf_range(-1, 1)).normalized() * speed func _physics_process(delta): # Двигаем объект move_and_slide() # Проверяем столкновение if get_slide_collision_count() > 0: # Находим нормали всех столкновений и используем их для изменения направления for i in range(get_slide_collision_count()): var collision = get_slide_collision(i) velocity = velocity.bounce(collision.get_normal()).normalized() * speed # Добавляем гораздо меньше случайности для более естественного поведения var random_vector = Vector2(randf_range(-0.1, 0.1), randf_range(-0.1, 0.1)) velocity += random_vector * speed * 0.05 # Нормализуем скорость и умножаем её на значение скорости velocity = velocity.normalized() * speedОсновные изменения:
- Уменьшен диапазон случайных значений от (-0.5, 0.5) до (-0.1, 0.1).
- Уменьшен коэффициент умножения для случайного вектора с 0.1 до 0.05.
- Убедитесь, что вектор скорости всегда нормально ориентирован и умножен на значение скорости в конце каждого кадра.
Эти изменения должны сделать поведение мяча более предсказуемым и реалистичным, предотвращая при этом появление непредсказуемых отскоков под прямыми углами или назад.
- User
теперь он отскакивает под 90 градусов ели даже прилетает под прямым углов в стену
- Assistant
Проблема с отскоками под прямым углом действительно может быть связана с тем, как векторы обрабатываются после столкновения. Давайте упростим логику для обработки столкновений и устраним добавление случайных векторов, чтобы мяч отскакивал более предсказуемо.
Вместо добавления случайных значений, мы можем оставить логику, которая просто изменяет направление скорости на основе нормали поверхности столкновения и нормализует вектор скорости.
Попробуйте следующий исправленный скрипт:
extends CharacterBody2D @export var speed = 200 func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() velocity = Vector2(rand_range(-1, 1), rand_range(-1, 1)).normalized() * speed func _physics_process(delta): # Двигаем объект move_and_slide() # Проверяем столкновение if get_slide_collision_count() > 0: # Находим нормали всех столкновений и используем их для изменения направления for i in range(get_slide_collision_count()): var collision = get_slide_collision(i) velocity = velocity.bounce(collision.get_normal()) # Нормализуем скорость и умножаем её на значение скорости velocity = velocity.normalized() * speedИзменения, которые произведены:
- Удалено добавление случайных значений к вектору скорости после столкновения, чтобы избежать непредсказуемого поведения.
- Используем
rand_rangeвместоrandf_rangeдля задания начального случайного направления (приводя к тем же результатам, но с использованием правильного метода, так как он лучше читается и в данной версии может быть понятнее).
Теперь, когда вектор скорости изменяется только на основе нормали столкновения, мяч должен вести себя более предсказуемо и отскакивать под правильными углами.
- User
Строка 8:Function "rand_range()" not found in base self. Did you mean to use "randf_range()"? Строка 8:Function "rand_range()" not found in base self. Did you mean to use "randf_range()"?
- Assistant
Извиняюсь за недоразумение. Действительно, в Godot нужно использовать
randf_rangeдля работы с числами с плавающей запятой. Вернемся к использованиюrandf_rangeдля случайных значений.Вот исправленный скрипт:
extends CharacterBody2D @export var speed = 200 func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speed func _physics_process(delta): # Двигаем объект move_and_slide() # Проверяем столкновение if get_slide_collision_count() > 0: # Находим нормали всех столкновений и используем их для изменения направления for i in range(get_slide_collision_count()): var collision = get_slide_collision(i) velocity = velocity.bounce(collision.get_normal()) # Нормализуем скорость и умножаем её на значение скорости velocity = velocity.normalized() * speedВ этом скрипте:
- Используется
randf_rangeдля генерации случайных чисел с плавающей запятой. - Удалена логика, которая добавляла случайные векторы к скорости после столкновения.
Этот скрипт должен обеспечить более предсказуемое поведение мяча при отскоках.
- Используется
- User
стало ещё хуже
- Assistant
Извините за неудобства. Давайте пересмотрим подход и попробуем определить и устранить основные проблемы.
Возможное решение:
- Убедитесь, что
move_and_slide()получает правильные параметры для корректной работы с характером тела. - Обработайте направление
velocityболее тщательно после столкновения.
Попробуем следующую версию скрипта:
extends CharacterBody2D @export var speed = 200 func _ready(): randomize() velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speed func _physics_process(delta): # Двигаем объект с заданием препятствий velocity = move_and_slide(velocity) # Проверяем столкновение после перемещения if get_slide_collision_count() > 0: # Получаем первое столкновение (предполагаем одно столкновение за кадр) var collision = get_slide_collision(0) # Изменяем направление скорости на основе нормали столкновения velocity = velocity.bounce(collision.get_normal()) # Устанавливаем фиксированное расстояние между объектом и поверхностью для предотвращения застревания while get_slide_collision_count() > 0: position += collision.get_remainder() # Выравниваем скорость к ее нормализованной форме умноженной на скорость velocity = velocity.normalized() * speedОбъяснение:
- Использование
move_and_slideс параметромvelocity:- Это необходимо для того, чтобы движение и столкновения учитывались системой физики Godot.
- Обработка первого столкновения:
- Предполагаем, что каждый кадр будет одно столкновение, и берем нормаль коллизии, чтобы корректировать направление скорости.
- Устранение застревания:
- Добавление кода для перемещения объекта в случае застревания из-за остающихся векторов после коллизии.
- Нормализация скорости:
- Скорость всегда нормализуется и умножается на установленную подвижную скорость для поддержания постоянной величины.
Этот подход должен обеспечивать более естественное и предсказуемое поведение мяча при столкновениях. Помните, что работа с физикой может требовать итераций и настройки параметров в зависимости от характеристик вашей сцены и требуемого поведения.
- Убедитесь, что
- User
теперь при первом касания всё останавливается зависает
- Assistant
Понял, давайте используем более простой и надежный способ обработки отскоков и подключения
move_and_slide()для обработки правильных столкновений. Убедимся, что нормаль столкновения правильно используется для корректировки вектора скорости.Возьмем всё самое рабочее из предыдущих версий и упростим скрипт:
extends CharacterBody2D @export var speed = 200 var velocity : Vector2 func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speed func _physics_process(delta): # Двигаем объект velocity = move_and_slide(velocity) # Проверяем столкновение if get_slide_collision_count() > 0: # Возьмем первую коллизию var collision = get_slide_collision(0) # Изменяем направление скорости на основе нормали столкновения velocity = velocity.bounce(collision.get_normal()) # Ограничиваем скорость, чтобы избежать накопления ошибок и поддерживать постоянное значение velocity = velocity.normalized() * speedОбъяснение:
- Начальное значение
velocity:- Используем
randomize(), чтобы задать случайное направление начальной скорости.
- Используем
- Использование
move_and_slide():- Этот метод обрабатывает движение и возвращает новую скорость в случае столкновений.
- Проверка коллизий:
- Проверяем, были ли столкновения, и берем первое из них, чтобы изменить направление скорости на основе нормали столкновения.
- Корректировка скорости:
- Нормализуем вектор скорости после столкновения, чтобы поддерживать постоянное значение.
Этот упрощенный подход должен устранить проблему зависания и обеспечить более естественное поведение мяча при отскоках.
- Начальное значение
- User
этот скрипт для мячики из игры пинг понг он должен отскакивать от ракеток под естественным углом как в жизни а также и от бортов а он это делает как попала но чаще мяч просто скользит по поверхности стенки редко отскакивая как надо
- Assistant
Понял, для игры типа пинг-понг нам нужно обеспечить, чтобы мяч отскакивал естественно и предсказуемо от ракеток и стенок. Важно убедиться, что нормаль поверхности используется правильно при отскоках, и что мяч корректно двигается без скольжения. Давайте попробуем следующий скрипт, который упростит обработку столкновений и улучшит поведение мяча.
Мы будем использовать методы
move_and_slide()иbounce()для обеспечения правильных отскоков. Также мы будем использовать переменнуюvelocityдля хранения текущей скорости:extends CharacterBody2D @export var speed = 200 var velocity = Vector2() func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speed func _physics_process(delta): # Двигаем объект с учетом скорости velocity = move_and_slide(velocity) # Проверяем столкновение после перемещения if get_slide_collision_count() > 0: # Получаем первое столкновение var collision = get_slide_collision(0) # Изменяем направление скорости на основе нормали столкновения velocity = velocity.bounce(collision.get_normal()) # Нормализуем скорость и умножаем на установленное значение скорости velocity = velocity.normalized() * speed func _on_reset_ball(): # Сброс мяча в начальное положение position = Vector2(0, 0) velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speedОбъяснение:
- Начальное значение
velocity:- Используем
randf_rangeдля задания случайного начального направления скорости и нормализуем вектор.
- Используем
move_and_slide(velocity):- Этот метод обрабатывает движение и возвращает новый вектор скорости при столкновении.
- Проверка коллизий:
- Проверяем, были ли столкновения, и берем первую коллизию, чтобы изменить направление скорости на основе нормали столкновения.
- Корректировка скорости:
- Нормализуем полученный вектор скорости, чтобы сохранить постоянное значение скорости после столкновения.
- Добавили метод
_on_reset_ball():- Метод для сброса мяча в начальное положение с целью тестирования.
Попробуйте этот скрипт. Он должен обеспечить лучшее, более естественное поведение мяча при отскоках от ракеток и стенок. Если проблемы сохраняются, возможно, стоит проверить настройки объектов в сцене (например, физические тела ракеток и стенок) и их взаимодействие с шариком.
- Начальное значение
- User
вот так пиши метод move_and_slide() extends CharacterBody2D
@export var speed = 200
func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speed
func _physics_process(delta): # Двигаем объект с учетом скорости move_and_slide()
# Проверяем столкновение после перемещения if get_slide_collision_count() > 0: # Получаем первое столкновение var collision = get_slide_collision(0) # Изменяем направление скорости на основе нормали столкновения velocity = velocity.bounce(collision.get_normal()) # Нормализуем скорость и умножаем на установленное значение скорости velocity = velocity.normalized() * speedfunc _on_reset_ball(): # Сброс мяча в начальное положение position = Vector2(0, 0) velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speed
- Assistant
Понял тебя. Если метод
move_and_slide()требуется использовать, чтобы обновить скорость и позицию на основе коллизий, он должен принимать вектор скорости и возвращать обновленное значение скорости. Мы исправим этот момент.Вот правильный способ использования
move_and_slide():extends CharacterBody2D @export var speed = 200 var velocity = Vector2() func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() reset_ball() func _physics_process(delta): # Двигаем объект с учетом скорости velocity = move_and_slide(velocity) # Проверяем столкновение после перемещения if get_slide_collision_count() > 0: # Получаем первое столкновение var collision = get_slide_collision(0) # Изменяем направление скорости на основе нормали столкновения velocity = velocity.bounce(collision.get_normal()) # Нормализуем скорость и умножаем на установленное значение скорости velocity = velocity.normalized() * speed func reset_ball(): # Сброс мяча в начальное положение position = Vector2(0, 0) velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speedОбоснования изменений:
- Использование
velocity:velocityтеперь инициализируется в_ready()через методreset_ball().
- Передача
velocityвmove_and_slide():- Системе физики Godot нужно передать текущую скорость, чтобы она могла корректно обрабатывать движение и коллизии.
- Корректировка направления и нормализация скорости после коллизии:
- Проверяем первую коллизию и меняем направление скорости с помощью
bounce(). - Нормализуем вектор скорости и умножаем его на установленное значение скорости для поддержки постоянной скорости.
- Проверяем первую коллизию и меняем направление скорости с помощью
Использование метода
reset_ball:- Метод
reset_ballможно вызвать для сброса мяча в начальное положение, когда это необходимо (например, при начале новой игры).
Теперь мяч должен отскакивать от стен и ракеток более естественно и предсказуемо, как в игре пинг-понг.
- Использование
- User
ты можешь сделать так чтобы мяч отскакивал под правильным углом
- Assistant
Давайте убедимся, что мяч отскакивает под правильным углом от всех поверхностей. Важно учитывать точность коллизий и корректное обновление скорости. Попробуем предусмотреть все необходимые аспекты.
Вот полный исправленный скрипт:
extends CharacterBody2D @export var speed = 200 var velocity = Vector2() func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() reset_ball() func _physics_process(delta): # Двигаем объект с учетом скорости velocity = move_and_slide(velocity) # Проверяем столкновение после перемещения if get_slide_collision_count() > 0: # Получим коллизии в цикле for i in range(get_slide_collision_count()): var collision = get_slide_collision(i) # Изменяем направление скорости на основе нормали столкновения velocity = velocity.bounce(collision.get_normal()) # Нормализуем скорость и умножаем на установленное значение скорости velocity = velocity.normalized() * speed func reset_ball(): # Сброс мяча в начальное положение и задание случайного направления position = Vector2(0, 0) velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speedОбъяснение:
- Передача
velocityвmove_and_slide():- Мы передаем текущую скорость в метод
move_and_slide(), чтобы корректно учесть движение и коллизии.
- Мы передаем текущую скорость в метод
- Проверка всех коллизий:
- Внутри
_physics_process(delta)мы перебираем все коллизии в каждом кадре, чтобы корректно обработать все столкновения. Это полезно при многократных столкновениях в одном кадре.
- Внутри
- Корректировка направления и нормализация скорости:
- Изменяем направление скорости на основе нормали коллизии с помощью метода
bounce(). - Нормализуем вектор скорости и умножаем его на значение скорости, чтобы сохранить постоянное значение после каждого кадра.
- Изменяем направление скорости на основе нормали коллизии с помощью метода
Использование метода
reset_ball:- Метод
reset_ballиспользуется для сброса мяча в начальное положение и задания случайного направления скорости при запуске игры или рестарте.
Этот скрипт должен эффективно обеспечивать правильные и естественные отскоки от всех поверхностей. Если мяч всё еще ведет себя неправильно, возможно, стоит проверить физические свойства объектов в сцене, такие как размеры коллайдеров, и убедиться, что они настроены должным образом для корректного взаимодействия с мячом.
- Передача
- User
мяч не меняет направления по оси x когда прилетает в ракетку вместо этого он летит под прямым углов в верх по оси y
- Assistant
Понял. Давайте попробуем устранить эту проблему, тщательно проверив обработку коллизий и обеспечив, чтобы мяч корректно менял направление по обеим осям при столкновении с ракеткой. Мы также будем использовать метод
move_and_collideдля более точного управления столкновениями.Вот исправленный скрипт:
extends CharacterBody2D @export var speed = 200 var velocity : Vector2 func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() reset_ball() func _physics_process(delta): move_and_bounce(delta) func move_and_bounce(delta): var collision = move_and_collide(velocity * delta) if collision: # Обрабатываем изменение направления при столкновении velocity = velocity.bounce(collision.normal).normalized() * speed func reset_ball(): # Сброс мяча в начальное положение и задание случайного направления position = Vector2(0, 0) velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speed # Пример использования функции для сброса мяча # func _on_reset_ball(): # reset_ball()Объяснение изменений:
- Использование
move_and_collide:- Методу
move_and_collideпередается вектор скорости, умноженный наdelta, что обеспечивает более точное управление столкновениями. Метод возвращает объект коллизии.
- Методу
- Обработка столкновений:
- Если происходит столкновение, направление скорости корректируется на основе нормали коллижена с помощью
bounce(). - Обновленный вектор скорости нормализуется и умножается на заданное значение скорости. Это предотвращает частое увеличение скорости при многоразовых столкновениях.
- Если происходит столкновение, направление скорости корректируется на основе нормали коллижена с помощью
- Метод
reset_ball():- Метод сбрасывает мяч в начальное положение и задает ему случайное направление.
Замечания:
- Убедитесь, что
velocityкорректно обрабатывается при столкновении с ракетками. - Возможно, придется настроить размеры коллайдеров на ракетках и мече для обеспечения правильного взаимодействия (удостоверьтесь, что они имеют правильные размеры и позиции).
- Для сбрасывания мяча используется метод
reset_ball(), который задает начальное положение и направление мяча. Вы можете вызвать его в событии или функции, когда требуется сброс.
Этот скрипт должен обеспечивать корректное изменение направления мяча при столкновении с ракетками и стенками. Если проблемы сохраняются, возможно, стоит проверить физические настройки сцены и взаимодействие объектов на более низком уровне.
- Использование
- User
Отсутствует подключённый метод '_on_body_entered' для сигнала 'body_entered' от узла 'RigidBody2D' к узлу 'RigidBody2D'.
- Assistant
Извините за путаницу. Давайте добавим и подключим слот для обработки сигнала
body_entered, чтобы корректно управлять событиями столкновений.- Добавим необходимый метод для обработки
body_entered. - Убедимся, что сигнал действительно подключен.
Шаги для подключения сигнала:
- В Godot Editor выберите
RigidBody2D(или тот узел, где у вас находится мяч). - Перейдите на вкладку "Node" и найдите сигнал
body_entered. - Кликните правой кнопкой мыши на сигнале и выберите "Connect".
- Выберите узел (например, тот же
RigidBody2Dили любой другой, в котором хотите обработать событие), и метод подключения будет автоматически создан.
Скрипт с учетом обработки сигнала
body_entered:extends RigidBody2D @export var speed = 200 var velocity: Vector2 func _ready(): # Задаем начальное случайное направление и нормализуем вектор randomize() reset_ball() # Подключаем сигнал body_entered к методу _on_body_entered self.connect("body_entered", self, "_on_body_entered") func _physics_process(delta): move_and_bounce(delta) func move_and_bounce(delta): velocity = move_and_slide(velocity) if get_colliding_bodies().size() > 0: # Получаем первую коллизию var collision = get_slide_collision(0) # Изменяем направление скорости на основе нормали столкновения velocity = velocity.bounce(collision.get_normal()) # Нормализуем скорость и умножаем на установленное значение скорости velocity = velocity.normalized() * speed func _on_body_entered(body): # Обработка логики при столкновении с другими телами if body.is_in_group("paddle"): # Предполагается, что ракетки в группе "paddle" # Корректируем направление для более естественного отскока, если это необходимо # Например, используя угол, под которым мяч прилетает к ракетке velocity.x = -velocity.x func reset_ball(): # Сброс мяча в начальное положение и задание случайного направления position = Vector2(0, 0) velocity = Vector2(randf_range(-1.0, 1.0), randf_range(-1.0, 1.0)).normalized() * speedОбъяснение изменений:
- Подключение сигнала
body_entered:- В методе
_readyподключаем сигналbody_enteredк методу_on_body_entered.
- В методе
- Метод
_on_body_entered(body):- Когда происходит столкновение с другим телом, метод
_on_body_enteredвызывается. - Проверяем, принадлежит ли столкнувшееся тело к группе
"paddle". Если да, корректируем направление скорости по оси X для точного отскока от ракеток.
- Когда происходит столкновение с другим телом, метод
- Метод
move_and_bounce(delta):- Используем
move_and_slideдля обработки перемещения и коллизий. - Если обнаружены коллизии, меняем направление скорости на основе нормали поверхности столкновения и нормализуем скорость.
- Используем
Примечание:
- Убедитесь, что ракетки добавлены в группу
"paddle". Это можно сделать в редакторе, выбрав ракетку и нажавNode -> Groups -> Add..., затем введя"paddle". - Если возникают проблемы с направлением скорости, возможно, потребуется дополнительная настройка логики внутри
_on_body_entered.
Этот скрипт должен помочь мяч корректно отскакивать от ракеток и других поверхностей под естественным углом.
- Добавим необходимый метод для обработки