245 lines
8.9 KiB
Python
245 lines
8.9 KiB
Python
"""Tests der Kollisionserkennung für alle Formpaarungen einschließlich Randfällen."""
|
||
|
||
import random
|
||
|
||
import pytest
|
||
|
||
from sandbox.physics import Body, Vector2, collide
|
||
from sandbox.physics.collision import (
|
||
COINCIDENT_NORMAL,
|
||
collide_box_half_plane,
|
||
collide_boxes,
|
||
collide_circle_box,
|
||
collide_circle_half_plane,
|
||
collide_circles,
|
||
)
|
||
from tests.helpers import material
|
||
|
||
|
||
def circle(x: float, y: float, radius: float) -> Body:
|
||
return Body.circle(Vector2(x, y), radius, material())
|
||
|
||
|
||
def box(x: float, y: float, half_width: float, half_height: float) -> Body:
|
||
return Body.box(Vector2(x, y), half_width, half_height, material())
|
||
|
||
|
||
def floor_at(y: float) -> Body:
|
||
return Body.wall(Vector2(0, -1), -y, material()) # frei ist alles oberhalb von y
|
||
|
||
|
||
# --------------------------------------------------------------------- Kreis–Kreis
|
||
|
||
|
||
def test_separated_circles_do_not_collide() -> None:
|
||
assert collide_circles(circle(0, 0, 10), circle(21, 0, 10)) is None
|
||
|
||
|
||
def test_touching_circles_form_a_contact_without_penetration() -> None:
|
||
contact = collide_circles(circle(0, 0, 10), circle(20, 0, 10))
|
||
assert contact is not None
|
||
assert contact.penetration == pytest.approx(0)
|
||
|
||
|
||
def test_overlapping_circles() -> None:
|
||
a = circle(0, 0, 10)
|
||
b = circle(15, 0, 10)
|
||
contact = collide_circles(a, b)
|
||
assert contact is not None
|
||
assert contact.body_a is a
|
||
assert contact.body_b is b
|
||
assert contact.normal.is_close(Vector2(1, 0))
|
||
assert contact.penetration == pytest.approx(5)
|
||
assert contact.point.is_close(Vector2(7.5, 0)) # Mitte des Überlappungsbereichs
|
||
|
||
|
||
def test_coincident_circles_use_a_fixed_fallback_normal() -> None:
|
||
contact = collide_circles(circle(5, 5, 10), circle(5, 5, 8))
|
||
assert contact is not None
|
||
assert contact.normal == COINCIDENT_NORMAL
|
||
assert contact.penetration == pytest.approx(18)
|
||
|
||
|
||
# --------------------------------------------------------------------- Kreis–Rechteck
|
||
|
||
|
||
def test_circle_touching_the_top_face_of_a_box() -> None:
|
||
contact = collide_circle_box(circle(0, -14, 5), box(0, 0, 20, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(0, 1)) # vom Kreis (oben) zur Box (unten)
|
||
assert contact.penetration == pytest.approx(1)
|
||
assert contact.point.is_close(Vector2(0, -10))
|
||
|
||
|
||
def test_circle_touching_the_right_face_of_a_box() -> None:
|
||
contact = collide_circle_box(circle(24, 0, 5), box(0, 0, 20, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(-1, 0))
|
||
assert contact.penetration == pytest.approx(1)
|
||
|
||
|
||
def test_circle_touching_a_corner_gets_a_diagonal_normal() -> None:
|
||
contact = collide_circle_box(circle(23, -13, 5), box(0, 0, 20, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(-1, 1).normalized())
|
||
assert contact.penetration == pytest.approx(5 - 18**0.5)
|
||
assert contact.point.is_close(Vector2(20, -10))
|
||
|
||
|
||
def test_circle_near_a_corner_but_outside_does_not_collide() -> None:
|
||
# Die umschließenden Boxen überlappen, der Kreis verfehlt die Ecke aber knapp.
|
||
assert collide_circle_box(circle(24, -14, 5), box(0, 0, 20, 10)) is None
|
||
|
||
|
||
def test_circle_center_inside_box_is_pushed_out_through_the_nearest_side_face() -> None:
|
||
contact = collide_circle_box(circle(15, 2, 5), box(0, 0, 20, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(-1, 0)) # Kreis bewegt sich entlang −n nach rechts
|
||
assert contact.penetration == pytest.approx(5 + 5) # Radius + Abstand zur Kante
|
||
assert contact.point.is_close(Vector2(20, 2))
|
||
|
||
|
||
def test_circle_center_inside_box_is_pushed_out_through_the_nearest_top_face() -> None:
|
||
contact = collide_circle_box(circle(3, -8, 5), box(0, 0, 20, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(0, 1)) # Kreis bewegt sich nach oben
|
||
assert contact.penetration == pytest.approx(5 + 2)
|
||
assert contact.point.is_close(Vector2(3, -10))
|
||
|
||
|
||
# --------------------------------------------------------------------- Rechteck–Rechteck
|
||
|
||
|
||
def test_boxes_are_separated_along_the_axis_of_least_overlap() -> None:
|
||
a = box(0, 0, 10, 10)
|
||
contact = collide_boxes(a, box(15, 5, 10, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(1, 0))
|
||
assert contact.penetration == pytest.approx(5)
|
||
assert contact.point.is_close(Vector2(7.5, 2.5)) # Mitte des Überlappungsrechtecks
|
||
|
||
contact = collide_boxes(a, box(5, -18, 10, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(0, -1))
|
||
assert contact.penetration == pytest.approx(2)
|
||
|
||
|
||
def test_equal_overlap_prefers_the_vertical_axis() -> None:
|
||
contact = collide_boxes(box(0, 0, 10, 10), box(15, 15, 10, 10))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(0, 1))
|
||
|
||
|
||
@pytest.mark.parametrize(("x", "y"), [(21, 0), (0, 25), (-21, 5), (3, -20.5)])
|
||
def test_separated_boxes_do_not_collide(x: float, y: float) -> None:
|
||
assert collide_boxes(box(0, 0, 10, 10), box(x, y, 10, 10)) is None
|
||
|
||
|
||
# --------------------------------------------------------------------- Wände
|
||
|
||
|
||
def test_circle_resting_on_the_floor() -> None:
|
||
contact = collide_circle_half_plane(circle(50, 95, 10), floor_at(100))
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(0, 1)) # vom Kreis in die Wand
|
||
assert contact.penetration == pytest.approx(5)
|
||
assert contact.point.is_close(Vector2(50, 100))
|
||
|
||
|
||
def test_circle_above_the_floor_does_not_collide() -> None:
|
||
assert collide_circle_half_plane(circle(50, 80, 10), floor_at(100)) is None
|
||
|
||
|
||
def test_circle_completely_behind_the_wall_is_still_detected() -> None:
|
||
# Der "Tunnel"-Fall: Selbst ein Körper hinter der Wandlinie wird erkannt
|
||
# und in den freien Raum zurückgeschoben.
|
||
contact = collide_circle_half_plane(circle(50, 130, 10), floor_at(100))
|
||
assert contact is not None
|
||
assert contact.penetration == pytest.approx(40)
|
||
assert contact.normal.is_close(Vector2(0, 1))
|
||
|
||
|
||
def test_box_against_floor_and_side_wall() -> None:
|
||
contact = collide_box_half_plane(box(50, 95, 20, 10), floor_at(100))
|
||
assert contact is not None
|
||
assert contact.penetration == pytest.approx(5)
|
||
|
||
left_wall = Body.wall(Vector2(1, 0), 0, material())
|
||
contact = collide_box_half_plane(box(15, 50, 20, 10), left_wall)
|
||
assert contact is not None
|
||
assert contact.normal.is_close(Vector2(-1, 0))
|
||
assert contact.penetration == pytest.approx(5)
|
||
assert collide_box_half_plane(box(25, 50, 20, 10), left_wall) is None
|
||
|
||
|
||
# --------------------------------------------------------------------- Zuordnung
|
||
|
||
|
||
def test_collide_orders_bodies_canonically() -> None:
|
||
c = circle(0, -14, 5)
|
||
b = box(0, 0, 20, 10)
|
||
for first, second in ((c, b), (b, c)):
|
||
contact = collide(first, second)
|
||
assert contact is not None
|
||
assert contact.body_a is c
|
||
assert contact.body_b is b
|
||
assert contact.normal.is_close(Vector2(0, 1))
|
||
|
||
wall = floor_at(100)
|
||
contact = collide(wall, circle(50, 95, 10))
|
||
assert contact is not None
|
||
assert contact.body_b is wall
|
||
|
||
|
||
def test_two_walls_never_collide() -> None:
|
||
assert collide(floor_at(100), floor_at(50)) is None
|
||
|
||
|
||
def test_contact_key_and_repr() -> None:
|
||
a = circle(0, 0, 10)
|
||
b = circle(15, 0, 10)
|
||
contact = collide(a, b)
|
||
assert contact is not None
|
||
assert contact.key == (a.id, b.id)
|
||
assert "penetration=5.000" in repr(contact)
|
||
|
||
|
||
# --------------------------------------------------------------------- Eigenschaften
|
||
|
||
|
||
def _random_body(rng: random.Random) -> Body:
|
||
x = rng.uniform(-40, 40)
|
||
y = rng.uniform(-40, 40)
|
||
if rng.random() < 0.5:
|
||
return circle(x, y, rng.uniform(5, 30))
|
||
return box(x, y, rng.uniform(5, 30), rng.uniform(5, 30))
|
||
|
||
|
||
def _random_wall(rng: random.Random) -> Body:
|
||
normal = rng.choice([Vector2(1, 0), Vector2(-1, 0), Vector2(0, 1), Vector2(0, -1)])
|
||
return Body.wall(normal, rng.uniform(-40, 40), material())
|
||
|
||
|
||
def test_random_contacts_are_consistent_and_resolvable() -> None:
|
||
"""Zufällige Kontakte sind in sich stimmig und lassen sich exakt auflösen.
|
||
|
||
Für viele Zufallspaare gilt: Die Normale ist ein Einheitsvektor, die Tiefe ist ≥ 0, und
|
||
verschiebt man Körper A um (Tiefe + ε) entgegen der Normalen, berühren sich die Körper
|
||
nicht mehr. Genau diese Information braucht die Kollisionsauflösung.
|
||
"""
|
||
rng = random.Random(1234)
|
||
checked = 0
|
||
for _ in range(3000):
|
||
first = _random_body(rng)
|
||
second = _random_wall(rng) if rng.random() < 0.25 else _random_body(rng)
|
||
contact = collide(first, second)
|
||
if contact is None:
|
||
continue
|
||
checked += 1
|
||
assert contact.normal.length() == pytest.approx(1)
|
||
assert contact.penetration >= 0
|
||
mover = contact.body_a
|
||
mover.position = mover.position - contact.normal * (contact.penetration + 1e-6)
|
||
assert collide(contact.body_a, contact.body_b) is None
|
||
assert checked > 500 # genug echte Kontakte geprüft
|