Minor fixes to docs of new features

Author: viblo

README.rst

@@ -19,7 +19,7 @@ the Pymunk webpage for some examples.
 2007 - 2025, Victor Blomqvist - [email protected], MIT License
 
 This release is based on the latest Pymunk release (7.0.0), 
-using Munk2D 1.0 rev 9c3026aded65c439d64d1cb4fa537544fa8a3989.
+using Munk2D 1.0 rev fc7ecea12aad22df30f89f7cfc0b6aa271f864ee.
 
 
 Installation

pymunk/__init__.py

@@ -54,6 +54,10 @@
     "moment_for_poly",
     "moment_for_segment",
     "moment_for_box",
+    "area_for_circle",
+    "area_for_segment",
+    "area_for_poly",
+    "empty_callback",
     "SegmentQueryInfo",
     "ContactPoint",
     "ContactPointSet",

pymunk/_version.py

@@ -32,9 +32,9 @@
 cp = _chipmunk_cffi.lib
 ffi = _chipmunk_cffi.ffi
 
-version = "7.0.0"
+version = "1.0.0"
 
 chipmunk_version = "%s-%s" % (
     ffi.string(cp.cpVersionString).decode("utf-8"),
-    "9c3026aded65c439d64d1cb4fa537544fa8a3989",
+    "fc7ecea12aad22df30f89f7cfc0b6aa271f864ee",
 )

pymunk/arbiter.py

@@ -43,14 +43,17 @@ def __init__(self, _arbiter: ffi.CData, space: "Space") -> None:
     def process_collision(self) -> bool:
         """Decides if the collision should be processed or rejected.
 
-        Set this during a begin() or pre_solve() callback to override
-        the default (True) value.
-
-        Set this to true to process the collision normally or
-        false to cause pymunk to ignore the collision entirely. If you set it to
-        false from a `begin` callback, the `pre_solve` and `post_solve` callbacks will never be run,
-        but you will still recieve a separate event when the shapes stop
-        overlapping.
+        Set this during a `begin()` or `pre_solve()` callback to override
+        the default (`True`) value.
+
+        Set this to `true` to process the collision normally or
+        `false` to cause Pymunk to ignore the collision entirely. Note that
+        while `post_solve` might be skipped if this is `false`, `separate`
+        will always be called when the shapes stop overlapping.
+
+        .. note::
+            No collision will be processed for a sensor Shape, or a Shape
+            attached to a STATIC or KINEMATIC Body.
 
         """
         return lib.cpArbiterGetProcessCollision(self._arbiter)

pymunk/space.py

@@ -596,28 +596,48 @@ def on_collision(
         separate: Optional[_CollisionCallback] = None,
         data: Any = None,
     ) -> None:
-        """Set callbacks that will be called during the 4 phases of collision handling.
-
-        Use None to indicate any collision_type.
-
-        Fill the desired collision callback functions, for details see the
-        :py:class:`CollisionHandler` object.
+        """Set callbacks that will be called during the 4 phases of collision
+        handling.
 
         Whenever shapes with collision types (:py:attr:`Shape.collision_type`)
-        a and b collide, this handler will be used to process the collision
-        events. If no handler is set, the default is to process collision as
+        a and b collide, the callback will be used to process the collision
+        events. If no callback is set, the default is to process collision
         normally.
 
-        If multiple handlers match the collision, the order will be that the
-        most specific handler is called first.
+        Its possible to pass in None for one or both of the collision types.
+        None matches any collision type on a Shape.
 
-        Note that if a handler already exist for the a,b pair, that existing
-        handler will be returned.
+        If you call this multiple times with the same combination of
+        collision_type_a and collision_type_b, then the last call will
+        overwrite the earlier.
+
+        If multiple callbacks match the collision, the order will be that the
+        most specific handler is called first.
 
-        :param int collision_type_a: Collision type a
-        :param int collision_type_b: Collision type b
+        Callback phases:
+
+            - **begin**: Two shapes just started touching for the first time
+              this step.
+            - **pre_solve**: Two shapes are touching during this step, before
+              collision resolution. You may override collision values using
+              Arbiter.friction, Arbiter.elasticity or Arbiter.surfaceVelocity
+              to provide custom friction, elasticity, or surface velocity
+              values. See Arbiter for more info.
+            - **post_solve**: Two shapes are touching and their collision response
+              has been processed. You can retrieve the collision impulse or
+              kinetic energy at this time if you want to use it to calculate
+              sound volumes or damage amounts. See Arbiter for more info.
+            - **separate**: Two shapes have just stopped touching for the
+              first time this step. To ensure that begin()/separate() are
+              always called in balanced pairs, it will also be called when
+              removing a shape while its in contact with something or when
+              de-allocating the space.
+
+        From each callback you can set process_collision on the Arbiter,
+        which decides if the collision should be processed or not.
+
+        data will be passed in to the callback function unchanged.
 
-        :rtype: :py:class:`CollisionHandler`
         """
         # key = min(collision_type_a, collision_type_b), max(
         #     collision_type_a, collision_type_b