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,