Renamed coll callback to on_collision, moved do_nothing to Pymunk.empty_callback

Author: viblo

pymunk/__init__.py

@@ -193,4 +193,14 @@ def area_for_poly(vertices: Sequence[tuple[float, float]], radius: float = 0) ->
     return cp.cpAreaForPoly(len(vs), vs, radius)
 
 
+def empty_callback(*args, **kwargs) -> None:
+    """A default empty callback.
+
+    Can be used to reset a collsion callback to its original empty
+    function. Note that its more efficient to use this method than to
+    define your own empty/do nothing method.
+    """
+    return
+
+
 # del cp, ct, u

pymunk/examples/arrows.py

@@ -98,9 +98,7 @@ def main():
     space.add(arrow_body, arrow_shape)
 
     flying_arrows: list[pymunk.Body] = []
-    space.set_collision_callback(
-        0, 1, post_solve=post_solve_arrow_hit, data=flying_arrows
-    )
+    space.on_collision(0, 1, post_solve=post_solve_arrow_hit, data=flying_arrows)
 
     start_time = 0
     while running:

pymunk/examples/balls_and_lines.py

@@ -46,9 +46,7 @@ def main():
     mouse_shape.collision_type = COLLTYPE_MOUSE
     space.add(mouse_body, mouse_shape)
 
-    space.set_collision_callback(
-        COLLTYPE_MOUSE, COLLTYPE_BALL, pre_solve=mouse_coll_func
-    )
+    space.on_collision(COLLTYPE_MOUSE, COLLTYPE_BALL, pre_solve=mouse_coll_func)
 
     ### Static line
     line_point1 = None

pymunk/examples/breakout.py

@@ -76,7 +76,7 @@ def remove_brick(arbiter, space, data):
         brick_shape = arbiter.shapes[0]
         space.remove(brick_shape, brick_shape.body)
 
-    space.set_collision_callback(
+    space.on_collision(
         collision_types["brick"], collision_types["ball"], separate=remove_brick
     )
 
@@ -116,7 +116,7 @@ def remove_first(arbiter, space, data):
         ball_shape = arbiter.shapes[0]
         space.remove(ball_shape, ball_shape.body)
 
-    space.set_collision_callback(
+    space.on_collision(
         collision_types["ball"], collision_types["bottom"], begin=remove_first
     )
 
@@ -143,7 +143,7 @@ def pre_solve(arbiter, space, data):
             set_.points[0].distance = 0
         arbiter.contact_point_set = set_
 
-    space.set_collision_callback(
+    space.on_collision(
         collision_types["player"], collision_types["ball"], pre_solve=pre_solve
     )
 

pymunk/examples/collisions.py

@@ -109,7 +109,7 @@ def main():
     space.add(shapes[selected_shape_idx])
 
     data = {}
-    h = space.set_collision_callback(
+    h = space.on_collision(
         0,
         1,
         begin=begin,

pymunk/examples/contact_and_no_flipy.py

@@ -42,7 +42,7 @@ def main():
 
     ticks_to_next_ball = 10
 
-    space.set_collision_callback(0, 0, post_solve=draw_collision, data=screen)
+    space.on_collision(0, 0, post_solve=draw_collision, data=screen)
 
     while running:
         for event in pygame.event.get():

pymunk/examples/contact_with_friction.py

@@ -52,7 +52,7 @@ def main():
 
     ticks_to_next_ball = 10
 
-    space.set_collision_callback(0, 0, post_solve=draw_collision, data=screen)
+    space.on_collision(0, 0, post_solve=draw_collision, data=screen)
 
     while running:
         for event in pygame.event.get():

pymunk/examples/deformable.py

@@ -82,7 +82,7 @@ def pre_solve(arb, space, data):
         space.remove(s.body, s)
         arb.process_collision = False
 
-    space.set_collision_callback(0, 1, pre_solve=pre_solve)
+    space.on_collision(0, 1, pre_solve=pre_solve)
 
     terrain_surface = pygame.Surface((600, 600))
     terrain_surface.fill(pygame.Color("white"))

pymunk/examples/platformer.py

@@ -139,7 +139,7 @@ def passthrough_handler(arbiter: pymunk.Arbiter, space: pymunk.Space, data):
         else:
             arbiter.process_collision = False
 
-    space.set_collision_callback(1, 2, begin=passthrough_handler)
+    space.on_collision(1, 2, begin=passthrough_handler)
 
     # player
     body = pymunk.Body(5, float("inf"))

pymunk/space.py

@@ -586,7 +586,7 @@ def step(self, dt: float) -> None:
 
         self._post_step_callbacks.clear()
 
-    def set_collision_callback(
+    def on_collision(
         self,
         collision_type_a: Optional[int] = None,
         collision_type_b: Optional[int] = None,
@@ -643,38 +643,31 @@ def set_collision_callback(
         else:
             ch = self._handlers[key]
 
-        if begin == Space.do_nothing:
+        # to avoid circular dep
+        from . import empty_callback
+
+        if begin == empty_callback:
             ch.begin = None
         elif begin != None:
             ch.begin = begin
             ch.data["begin"] = data
-        if pre_solve == Space.do_nothing:
+        if pre_solve == empty_callback:
             ch.pre_solve = None
         elif pre_solve != None:
             ch.pre_solve = pre_solve
             ch.data["pre_solve"] = data
-        if post_solve == Space.do_nothing:
+        if post_solve == empty_callback:
             ch.post_solve = None
         elif post_solve != None:
             ch.post_solve = post_solve
             ch.data["post_solve"] = data
-        if separate == Space.do_nothing:
+        if separate == empty_callback:
             ch.separate = None
         elif separate != None:
             ch.separate = separate
             ch.data["separate"] = data
         return
 
-    @staticmethod
-    def do_nothing(arbiter: Arbiter, space: "Space", data: Any) -> None:
-        """The default do nothing method used for the collision callbacks.
-
-        Can be used to reset a collsion callback to its original do nothing
-        function. Note that its more efficient to use this method than to
-        define your own do nothing method.
-        """
-        return
-
     def add_post_step_callback(
         self,
         callback_function: Callable[
@@ -989,16 +982,19 @@ def __getstate__(self) -> _State:
         d["special"].append(("shapes", list(self.shapes)))
         d["special"].append(("constraints", list(self.constraints)))
 
+        # to avoid circular dep
+        from . import empty_callback
+
         handlers = []
         for k, v in self._handlers.items():
             h: dict[str, Any] = {}
-            if v._begin != Space.do_nothing:
+            if v._begin != empty_callback:
                 h["_begin"] = v._begin
-            if v._pre_solve != Space.do_nothing:
+            if v._pre_solve != empty_callback:
                 h["_pre_solve"] = v._pre_solve
-            if v._post_solve != Space.do_nothing:
+            if v._post_solve != empty_callback:
                 h["_post_solve"] = v._post_solve
-            if v._separate != Space.do_nothing:
+            if v._separate != empty_callback:
                 h["_separate"] = v._separate
             handlers.append((k, h))
 
@@ -1061,7 +1057,7 @@ def __setstate__(self, state: _State) -> None:
                     if "_separate" in hd:
                         separate = hd["_separate"]
                     if k2 == None:
-                        self.set_collision_callback(
+                        self.on_collision(
                             None,
                             None,
                             begin=begin,
@@ -1070,7 +1066,7 @@ def __setstate__(self, state: _State) -> None:
                             separate=separate,
                         )
                     elif isinstance(k2, tuple):
-                        self.set_collision_callback(
+                        self.on_collision(
                             k2[0],
                             k2[1],
                             begin=begin,
@@ -1079,7 +1075,7 @@ def __setstate__(self, state: _State) -> None:
                             separate=separate,
                         )
                     else:
-                        self.set_collision_callback(
+                        self.on_collision(
                             k2,
                             None,
                             begin=begin,

pymunk/tests/test_arbiter.py

@@ -28,7 +28,7 @@ def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertEqual(arb.restitution, 0.18)
             arb.restitution = 1
 
-        s.set_collision_callback(1, 2, pre_solve=pre_solve)
+        s.on_collision(1, 2, pre_solve=pre_solve)
 
         for x in range(10):
             s.step(0.1)
@@ -56,7 +56,7 @@ def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertEqual(arb.friction, 0.18)
             arb.friction = 1
 
-        s.set_collision_callback(1, 2, pre_solve=pre_solve)
+        s.on_collision(1, 2, pre_solve=pre_solve)
 
         for x in range(10):
             s.step(0.1)
@@ -87,7 +87,7 @@ def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             arb.surface_velocity = (10, 10)
             # TODO: add assert check that setting surface_velocity has any effect
 
-        s.set_collision_callback(1, 2, pre_solve=pre_solve)
+        s.on_collision(1, 2, pre_solve=pre_solve)
         for x in range(5):
             s.step(0.1)
 
@@ -142,7 +142,7 @@ def f() -> None:
 
             self.assertRaises(Exception, f)
 
-        s.set_collision_callback(2, 1, pre_solve=pre_solve)
+        s.on_collision(2, 1, pre_solve=pre_solve)
 
         s.step(0.1)
 
@@ -170,7 +170,7 @@ def post_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertAlmostEqual(arb.total_impulse.y, 4.3438914027)
             self.post_solve_done = True
 
-        s.set_collision_callback(1, 2, post_solve=post_solve)
+        s.on_collision(1, 2, post_solve=post_solve)
 
         s.step(0.1)
 
@@ -197,7 +197,7 @@ def testTotalKE(self) -> None:
         def post_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             r["ke"] = arb.total_ke
 
-        s.set_collision_callback(1, 2, post_solve=post_solve)
+        s.on_collision(1, 2, post_solve=post_solve)
 
         s.step(0.1)
 
@@ -223,14 +223,14 @@ def testIsFirstContact(self) -> None:
         def pre_solve1(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertTrue(arb.is_first_contact)
 
-        s.set_collision_callback(1, 2, pre_solve=pre_solve1)
+        s.on_collision(1, 2, pre_solve=pre_solve1)
 
         s.step(0.1)
 
         def pre_solve2(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertFalse(arb.is_first_contact)
 
-        s.set_collision_callback(1, 2, pre_solve=pre_solve2)
+        s.on_collision(1, 2, pre_solve=pre_solve2)
 
         s.step(0.1)
 
@@ -251,7 +251,7 @@ def testNormal(self) -> None:
         def pre_solve1(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             r["n"] = Vec2d(*arb.normal)
 
-        s.set_collision_callback(1, 2, pre_solve=pre_solve1)
+        s.on_collision(1, 2, pre_solve=pre_solve1)
 
         s.step(0.1)
 
@@ -281,7 +281,7 @@ def separate1(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.called1 = True
             self.assertFalse(arb.is_removal)
 
-        s.set_collision_callback(1, 2, separate=separate1)
+        s.on_collision(1, 2, separate=separate1)
 
         for x in range(10):
             s.step(0.1)
@@ -296,7 +296,7 @@ def separate2(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.called2 = True
             self.assertTrue(arb.is_removal)
 
-        s.set_collision_callback(1, 2, separate=separate2)
+        s.on_collision(1, 2, separate=separate2)
         s.remove(b1, c1)
 
         self.assertTrue(self.called2)
@@ -328,7 +328,7 @@ def pre_solve(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.assertEqual(arb.bodies[0], arb.shapes[0].body)
             self.assertEqual(arb.bodies[1], arb.shapes[1].body)
 
-        s.set_collision_callback(1, 2, post_solve=pre_solve)
+        s.on_collision(1, 2, post_solve=pre_solve)
 
         s.step(0.1)
         self.assertTrue(self.called)
@@ -412,7 +412,7 @@ def callback(
             hdata["process_values"] = process_values
             hdata["expected"] = expected_calls
             hdata["result"] = []
-            s.set_collision_callback(
+            s.on_collision(
                 1,
                 2,
                 begin=functools.partial(callback, "b"),

pymunk/tests/test_common.py

@@ -126,7 +126,7 @@ def remove_first(arbiter: p.Arbiter, space: p.Space, data: Any) -> None:
             # space.add_post_step_callback(space.remove, first_shape, first_shape.body)
             # space.remove(c1)
 
-        space.set_collision_callback(2, 0, separate=remove_first)
+        space.on_collision(2, 0, separate=remove_first)
         # print(1)
         space.step(1.0 / 60)
         # print(2)
@@ -166,7 +166,7 @@ def separate(arbiter: p.Arbiter, space: p.Space, data: Any) -> None:
             # space.add_post_step_callback(space.remove, first_shape, first_shape.body)
             # space.remove(c1)
 
-        space.set_collision_callback(2, 0, separate=separate)
+        space.on_collision(2, 0, separate=separate)
         # print(1)
         space.step(1)
         # print(2)

pymunk/tests/test_shape.py

@@ -301,7 +301,7 @@ def testSegmentSegmentCollision(self) -> None:
         def begin(arb: p.Arbiter, space: p.Space, data: Any) -> None:
             self.num_of_begins += 1
 
-        s.set_collision_callback(begin=begin)
+        s.on_collision(begin=begin)
         s.step(0.1)
 
         self.assertEqual(1, self.num_of_begins)