Update Munk2D to 2.0.1, fixes #289

Author: viblo

pymunk/_version.py

@@ -32,9 +32,9 @@
 cp = _chipmunk_cffi.lib
 ffi = _chipmunk_cffi.ffi
 
-version = "7.0.1"
+version = "7.0.2"
 
 chipmunk_version = "%s-%s" % (
     ffi.string(cp.cpVersionString).decode("utf-8"),
-    "5ef7498946f0e956f294cb3fea283626921e4128",
+    "ade7ed72849e60289eefb7a41e79ae6322fefaf3",
 )

pymunk/tests/test_space.py

@@ -858,6 +858,79 @@ def callback(
         ]
         self.assertListEqual(callback_calls, expected_calls)
 
+    def testSameTypeCollisionHandler(self) -> None:
+        s = p.Space()
+
+        callback_calls = []
+
+        def callback(
+            name: str,
+            types: tuple[Optional[int], Optional[int]],
+            arb: p.Arbiter,
+            space: p.Space,
+            data: dict[Any, Any],
+        ) -> None:
+            callback_calls.append(
+                (
+                    name,
+                    types,
+                    (arb.shapes[0].friction, arb.shapes[1].friction),
+                )
+            )
+
+        handler_order = [
+            (1, 1),
+            (1, None),
+            (None, None),
+        ]
+
+        for t1, t2 in handler_order:
+            s.on_collision(
+                t1,
+                t2,
+                begin=functools.partial(callback, "begin", (t1, t2)),
+                pre_solve=functools.partial(callback, "pre_solve", (t1, t2)),
+                post_solve=functools.partial(callback, "post_solve", (t1, t2)),
+                separate=functools.partial(callback, "separate", (t1, t2)),
+            )
+
+        b1 = p.Body(1, 30)
+        c1 = p.Circle(b1, 10)
+        b1.position = 5, 3
+        c1.collision_type = 1
+        c1.friction = 1
+
+        b2 = p.Body(body_type=p.Body.STATIC)
+        c2 = p.Circle(b2, 10)
+        c2.collision_type = 1
+        c2.friction = 2
+
+        s.add(b1, c1, b2, c2)
+
+        s.step(0.1)
+        b1.position = 100, 100
+        s.step(0.1)
+
+        expected_calls = [
+            ("begin", (1, 1), (2, 1)),
+            ("begin", (1, None), (2, 1)),
+            ("begin", (1, None), (1, 2)),
+            ("begin", (None, None), (2, 1)),
+            ("pre_solve", (1, 1), (2, 1)),
+            ("pre_solve", (1, None), (2, 1)),
+            ("pre_solve", (1, None), (1, 2)),
+            ("pre_solve", (None, None), (2, 1)),
+            ("post_solve", (1, 1), (2, 1)),
+            ("post_solve", (1, None), (2, 1)),
+            ("post_solve", (1, None), (1, 2)),
+            ("post_solve", (None, None), (2, 1)),
+            ("separate", (1, 1), (2, 1)),
+            ("separate", (1, None), (2, 1)),
+            ("separate", (1, None), (1, 2)),
+            ("separate", (None, None), (2, 1)),
+        ]
+        self.assertListEqual(callback_calls, expected_calls)
+
     def testWildcardCollisionHandler(self) -> None:
         s = p.Space()
         b1 = p.Body(1, 1)