Readd data to collision callbacks, fix tests

Author: viblo

pymunk/__init__.py

@@ -58,7 +58,6 @@
     "ContactPoint",
     "ContactPointSet",
     "Arbiter",
-    "CollisionHandler",
     "BB",
     "ShapeFilter",
     "Transform",
@@ -80,7 +79,6 @@
 from .arbiter import Arbiter
 from .bb import BB
 from .body import Body
-from .collision_handler import CollisionHandler
 from .constraints import *
 from .contact_point_set import ContactPoint, ContactPointSet
 from .query_info import PointQueryInfo, SegmentQueryInfo, ShapeQueryInfo

pymunk/_callbacks.py

@@ -203,23 +203,27 @@ def ext_cpCollisionBeginFunc(
     _arb: ffi.CData, _space: ffi.CData, data: ffi.CData
 ) -> None:
     handler = ffi.from_handle(data)
-    handler._begin(Arbiter(_arb, handler._space), handler._space)
+    handler._begin(Arbiter(_arb, handler._space), handler._space, handler.data["begin"])
 
 
 @ffi.def_extern()
 def ext_cpCollisionPreSolveFunc(
     _arb: ffi.CData, _space: ffi.CData, data: ffi.CData
 ) -> None:
     handler = ffi.from_handle(data)
-    handler._pre_solve(Arbiter(_arb, handler._space), handler._space)
+    handler._pre_solve(
+        Arbiter(_arb, handler._space), handler._space, handler.data["pre_solve"]
+    )
 
 
 @ffi.def_extern()
 def ext_cpCollisionPostSolveFunc(
     _arb: ffi.CData, _space: ffi.CData, data: ffi.CData
 ) -> None:
     handler = ffi.from_handle(data)
-    handler._post_solve(Arbiter(_arb, handler._space), handler._space)
+    handler._post_solve(
+        Arbiter(_arb, handler._space), handler._space, handler.data["post_solve"]
+    )
 
 
 @ffi.def_extern()
@@ -234,7 +238,9 @@ def ext_cpCollisionSeparateFunc(
         # this try is needed since a separate callback will be called
         # if a colliding object is removed, regardless if its in a
         # step or not. Meaning the unlock must succeed
-        handler._separate(Arbiter(_arb, handler._space), handler._space)
+        handler._separate(
+            Arbiter(_arb, handler._space), handler._space, handler.data["separate"]
+        )
     finally:
         handler._space._locked = orig_locked
 

pymunk/collision_handler.py renamed to pymunk/_collision_handler.py

@@ -1,14 +1,14 @@
 __docformat__ = "reStructuredText"
 
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 if TYPE_CHECKING:
     from .space import Space
 
 from ._chipmunk_cffi import ffi, lib
 from .arbiter import Arbiter
 
-_CollisionCallback = Callable[[Arbiter, "Space"], None]
+_CollisionCallback = Callable[[Arbiter, "Space", Any], None]
 
 
 class CollisionHandler(object):
@@ -41,10 +41,10 @@ def __init__(self, _handler: Any, space: "Space") -> None:
         self._handler.userData = self._userData
 
         self._space = space
-        self._begin: _CollisionCallback = CollisionHandler.do_nothing
-        self._pre_solve: _CollisionCallback = CollisionHandler.do_nothing
-        self._post_solve: _CollisionCallback = CollisionHandler.do_nothing
-        self._separate: _CollisionCallback = CollisionHandler.do_nothing
+        self._begin: Optional[_CollisionCallback] = None
+        self._pre_solve: Optional[_CollisionCallback] = None
+        self._post_solve: Optional[_CollisionCallback] = None
+        self._separate: Optional[_CollisionCallback] = None
 
         self._data: dict[Any, Any] = {}
 
@@ -60,7 +60,7 @@ def data(self) -> dict[Any, Any]:
         return self._data
 
     @property
-    def begin(self) -> _CollisionCallback:
+    def begin(self) -> Optional[_CollisionCallback]:
         """Two shapes just started touching for the first time this step.
 
         ``func(arbiter, space, data)``
@@ -74,16 +74,16 @@ def begin(self) -> _CollisionCallback:
         return self._begin
 
     @begin.setter
-    def begin(self, func: _CollisionCallback) -> None:
+    def begin(self, func: Optional[_CollisionCallback]) -> None:
         self._begin = func
 
-        if self._begin == CollisionHandler.do_nothing:
+        if self._begin == None:
             self._handler.beginFunc = ffi.addressof(lib, "DoNothing")
         else:
             self._handler.beginFunc = lib.ext_cpCollisionBeginFunc
 
     @property
-    def pre_solve(self) -> _CollisionCallback:
+    def pre_solve(self) -> Optional[_CollisionCallback]:
         """Two shapes are touching during this step.
 
         ``func(arbiter, space, data)``
@@ -96,16 +96,16 @@ def pre_solve(self) -> _CollisionCallback:
         return self._pre_solve
 
     @pre_solve.setter
-    def pre_solve(self, func: _CollisionCallback) -> None:
+    def pre_solve(self, func: Optional[_CollisionCallback]) -> None:
         self._pre_solve = func
 
-        if self._pre_solve == CollisionHandler.do_nothing:
+        if self._pre_solve == None:
             self._handler.preSolveFunc = ffi.addressof(lib, "DoNothing")
         else:
             self._handler.preSolveFunc = lib.ext_cpCollisionPreSolveFunc
 
     @property
-    def post_solve(self) -> _CollisionCallback:
+    def post_solve(self) -> Optional[_CollisionCallback]:
         """Two shapes are touching and their collision response has been
         processed.
 
@@ -118,16 +118,16 @@ def post_solve(self) -> _CollisionCallback:
         return self._post_solve
 
     @post_solve.setter
-    def post_solve(self, func: _CollisionCallback) -> None:
+    def post_solve(self, func: Optional[_CollisionCallback]) -> None:
         self._post_solve = func
 
-        if self._post_solve == CollisionHandler.do_nothing:
+        if self._post_solve == None:
             self._handler.postSolveFunc = ffi.addressof(lib, "DoNothing")
         else:
             self._handler.postSolveFunc = lib.ext_cpCollisionPostSolveFunc
 
     @property
-    def separate(self) -> _CollisionCallback:
+    def separate(self) -> Optional[_CollisionCallback]:
         """Two shapes have just stopped touching for the first time this
         step.
 
@@ -140,20 +140,10 @@ def separate(self) -> _CollisionCallback:
         return self._separate
 
     @separate.setter
-    def separate(self, func: _CollisionCallback) -> None:
+    def separate(self, func: Optional[_CollisionCallback]) -> None:
         self._separate = func
 
-        if self._separate == CollisionHandler.do_nothing:
+        if self._separate == None:
             self._handler.separateFunc = ffi.addressof(lib, "DoNothing")
         else:
             self._handler.separateFunc = lib.ext_cpCollisionSeparateFunc
-
-    @staticmethod
-    def do_nothing(arbiter: Arbiter, space: "Space") -> None:
-        """The default do nothing method used for the post_solve and seprate
-        callbacks.
-
-        Note that its more efficient to set this method than to define your own
-        do nothing method.
-        """
-        return

pymunk/examples/arrows.py

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

pymunk/examples/balls_and_lines.py

@@ -1,6 +1,5 @@
-"""This example lets you dynamically create static walls and dynamic balls
+"""This example lets you dynamically create static walls and dynamic balls"""
 
-"""
 __docformat__ = "reStructuredText"
 
 import pygame
@@ -24,7 +23,7 @@ def mouse_coll_func(arbiter, space, data):
     """Simple callback that increases the radius of circles touching the mouse"""
     s1, s2 = arbiter.shapes
     s2.unsafe_set_radius(s2.radius + 0.15)
-    return False
+    arbiter.process_collision = False
 
 
 def main():
@@ -47,9 +46,9 @@ def main():
     mouse_shape.collision_type = COLLTYPE_MOUSE
     space.add(mouse_body, mouse_shape)
 
-    space.add_collision_handler(
-        COLLTYPE_MOUSE, COLLTYPE_BALL
-    ).pre_solve = mouse_coll_func
+    space.set_collision_callback(
+        COLLTYPE_MOUSE, COLLTYPE_BALL, pre_solve=mouse_coll_func
+    )
 
     ### Static line
     line_point1 = None

pymunk/examples/breakout.py

@@ -1,7 +1,7 @@
-"""Very simple breakout clone. A circle shape serves as the paddle, then 
-breakable bricks constructed of Poly-shapes. 
+"""Very simple breakout clone. A circle shape serves as the paddle, then
+breakable bricks constructed of Poly-shapes.
 
-The code showcases several pymunk concepts such as elasitcity, impulses, 
+The code showcases several pymunk concepts such as elasitcity, impulses,
 constant object speed, joints, collision handlers and post step callbacks.
 """
 
@@ -48,7 +48,7 @@ def constant_velocity(body, gravity, damping, dt):
 def setup_level(space, player_body):
 
     # Remove balls and bricks
-    for s in space.shapes[:]:
+    for s in list(space.shapes):
         if s.body.body_type == pymunk.Body.DYNAMIC and s.body not in [player_body]:
             space.remove(s.body, s)
 
@@ -76,8 +76,9 @@ def remove_brick(arbiter, space, data):
         brick_shape = arbiter.shapes[0]
         space.remove(brick_shape, brick_shape.body)
 
-    h = space.add_collision_handler(collision_types["brick"], collision_types["ball"])
-    h.separate = remove_brick
+    space.set_collision_callback(
+        collision_types["brick"], collision_types["ball"], separate=remove_brick
+    )
 
 
 def main():
@@ -114,11 +115,10 @@ def main():
     def remove_first(arbiter, space, data):
         ball_shape = arbiter.shapes[0]
         space.remove(ball_shape, ball_shape.body)
-        return True
 
-    h = space.add_collision_handler(collision_types["ball"], collision_types["bottom"])
-    h.begin = remove_first
-    space.add(bottom)
+    space.set_collision_callback(
+        collision_types["ball"], collision_types["bottom"], begin=remove_first
+    )
 
     ### Player ship
     player_body = pymunk.Body(500, float("inf"))
@@ -142,10 +142,10 @@ def pre_solve(arbiter, space, data):
             set_.normal = normal
             set_.points[0].distance = 0
         arbiter.contact_point_set = set_
-        return True
 
-    h = space.add_collision_handler(collision_types["player"], collision_types["ball"])
-    h.pre_solve = pre_solve
+    space.set_collision_callback(
+        collision_types["player"], collision_types["ball"], pre_solve=pre_solve
+    )
 
     # restrict movement of player to a straigt line
     move_joint = pymunk.GrooveJoint(

pymunk/examples/collisions.py

@@ -1,6 +1,6 @@
-"""This example attempts to display collision points, and the callbacks
-"""
+"""This example attempts to display collision points, and the callbacks"""
 
+import functools
 import math
 import random
 import sys
@@ -20,8 +20,6 @@ def begin(arbiter, space, data):
         "separate": 0,
     }
 
-    return True
-
 
 def pre_solve(arbiter: pymunk.Arbiter, space, data):
     data["log"]["pre_solve"] += 1
@@ -54,8 +52,6 @@ def pre_solve(arbiter: pymunk.Arbiter, space, data):
             (p.point_a.interpolate_to(p.point_b, 0.5)),
         )
 
-    return True
-
 
 def post_solve(arbiter, space, data):
     # Will not be called, since the shapes are kinematic sensors
@@ -64,7 +60,6 @@ def post_solve(arbiter, space, data):
 
 def separate(arbiter, space, data):
     data["log"]["separate"] += 1
-    pass
 
 
 def main():
@@ -113,14 +108,19 @@ def main():
     selected_shape_idx = 0
     space.add(shapes[selected_shape_idx])
 
-    h = space.add_collision_handler(0, 1)
-    h.data["screen"] = screen
-    h.data["log"] = {"begin": 0, "pre_solve": 0, "post_solve": 0, "separate": 0}
-    h.data["font"] = font
-    h.begin = begin
-    h.pre_solve = pre_solve
-    h.post_solve = post_solve
-    h.separate = separate
+    data = {}
+    h = space.set_collision_callback(
+        0,
+        1,
+        begin=begin,
+        pre_solve=pre_solve,
+        post_solve=post_solve,
+        separate=separate,
+        data=data,
+    )
+    data["screen"] = screen
+    data["log"] = {"begin": 0, "pre_solve": 0, "post_solve": 0, "separate": 0}
+    data["font"] = font
 
     while True:
         for event in pygame.event.get():
@@ -155,10 +155,10 @@ def main():
         )
 
         y = 30
-        for k in h.data["log"]:
+        for k in data["log"]:
             screen.blit(
                 font.render(
-                    f"{k}: {h.data['log'][k]}",
+                    f"{k}: {data['log'][k]}",
                     True,
                     pygame.Color("black"),
                 ),