Add some unit tests for directions

test/test_directions.py

@@ -0,0 +1,101 @@
+from math import pi, sqrt, sin, cos, atan2
+import random
+from sc2.position import Point2, EPSILON
+
+P0 = Point2((0, 0))
+P1 = Point2((1, 1))
+P2 = Point2((3, 1))
+P3 = Point2((3, 3))
+
+def rad_diff(a, b):
+    r1 = abs(a - b)
+    r2 = abs(b - a)
+    r3 = min(r1, r2)
+    r4 = abs(2*pi - r3)
+    return min(r3, r4)
+
+def test_test_rad_diff():
+    assert rad_diff(0, 0) == 0
+    assert rad_diff(0, 1) == 1
+    assert rad_diff(0, pi) == pi
+    assert rad_diff(pi, pi) == 0
+    assert rad_diff(2*pi, 0) == 0
+    assert rad_diff(2*pi+1, 0) == 1
+    assert rad_diff(2*pi+1, 1) == 0
+    assert rad_diff(pi, -pi) == 0
+
+def test_distance():
+    assert P0.distance_to(P1) == sqrt(2)
+    assert P1.distance_to(P2) == 2
+    assert P0.distance_to(P2) == sqrt(10)
+
+def test_towards():
+    assert P0.towards(P1, 1) == Point2((sqrt(2) / 2, sqrt(2) / 2))
+
+def test_random_on_distance():
+    random.seed(1)
+
+    def get_points(source, distance, n=1000):
+        return {source.random_on_distance(distance) for _ in range(n)}
+
+    def verify_distances(source, distance, n=1000):
+        for p in get_points(source, distance, n):
+            assert abs(source.distance_to(p) - distance) < 0.000001
+
+    def verify_angles(source, distance, n=1000):
+        angles_rad = {
+            atan2(p.y - source.y, p.x - source.x)
+            for p in get_points(source, distance, n)
+        }
+
+        quadrants = {(cos(a) < 0, sin(a) < 0) for a in angles_rad}
+        assert len(quadrants) == 4
+
+
+    verify_distances(P0, 1e2)
+    verify_distances(P1, 1e3)
+    verify_distances(P2, 1e4)
+
+    verify_angles(P0, 1e2)
+    verify_angles(P1, 1e3)
+    verify_angles(P2, 1e4)
+
+def test_towards_random_angle():
+    random.seed(1)
+
+    def random_points(n=1000):
+        rs = lambda: 1 - random.random() * 2
+        return {Point2((rs()*1000, rs()*1000)) for _ in range(n)}
+
+    def verify(source, target, max_difference=(pi/4), n=1000):
+        d = 1 + random.random() * 100
+        points = {
+            source.towards_with_random_angle(target, distance=d, max_difference=max_difference)
+            for _ in range(n)
+        }
+
+        dx, dy = target.x - source.x, target.y - source.y
+        src_angle = atan2(dy, dx)
+
+        for p in points:
+            angle = atan2(p.y - source.y, p.x - source.x)
+            assert rad_diff(src_angle, angle) <= max_difference
+
+            assert abs(source.distance_to(p) - d) <= EPSILON
+
+    verify(P0, P1)
+    verify(P1, P2)
+    verify(P1, P3)
+    verify(P2, P3)
+
+    verify(P1, P0)
+    verify(P2, P1)
+    verify(P3, P1)
+    verify(P3, P2)
+
+    ps = random_points(n=50)
+    for p1 in ps:
+        for p2 in ps:
+            if p1 == p2:
+                continue
+            verify(p1, p2, n=10)