miniworlds-physics 2.0.0.0__tar.gz

miniworlds_physics-2.0.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: miniworlds_physics
+Version: 2.0.0.0
+Summary: Physics engine for miniworlds
+Home-page: https://github.com/asbl/miniworlds
+Download-URL: https://github.com/asbl/miniworlds
+Author: Andreas Siebel
+Author-email: andreas.siebel@it-teaching.de
+License: OSI Approved :: MIT License
+Keywords: games,education,mini-worlds,pygame
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Education
+Description-Content-Type: text/markdown
+Requires-Dist: miniworlds
+
+Physics World
+======================
+
+physics engine for miniworlds based on pymunk

miniworlds_physics-2.0.0.0/README.md

@@ -0,0 +1,4 @@
+Physics World
+======================
+
+physics engine for miniworlds based on pymunk

miniworlds_physics-2.0.0.0/miniworlds_physics/__init__.py

@@ -0,0 +1,15 @@
+import inspect
+import os
+import sys
+from miniworlds_physics.physics_world import PhysicsWorld
+
+# __import__('pkg_resources').declare_namespace(__name__)
+current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+parent_dir = os.path.dirname(current_dir)
+sys.path.insert(0, parent_dir)
+
+__all__ = []
+
+
+__all__.append(PhysicsWorld.__name__)
+__all__.append("ABC")

miniworlds_physics-2.0.0.0/miniworlds_physics/actor_physics.py

@@ -0,0 +1,580 @@
+import math
+import sys
+from typing import Optional, Union
+
+import pymunk as pymunk_engine
+import pymunk.pygame_util
+from miniworlds.actors import actor as actor
+from miniworlds.actors.shapes import shapes
+
+
+class ActorPhysics:
+    """Defines physics-properties of a actor, used as my_actor.physics.attribute or my_actor.physics.method
+
+    Can only be used for actors on a PhysicsWorld.
+
+    Examples:
+
+        .. code-block:: python
+
+            from miniworlds import *
+
+            world = PhysicsWorld((800, 600))
+
+            a = Circle()
+            a.position = (75, 200)
+            a.color = (255,0,0)
+            a.physics.simulation = "simulated"
+            a.direction = 180
+            a.physics.shape_type = "circle"
+            a.impulse(45, 1500)
+
+            world.run()
+    """
+
+    def __init__(self, actor, world):
+        self.started: bool = False
+        self._body_type = pymunk.Body.DYNAMIC
+        self.world = world
+        self.actor: actor.Actor = actor
+        self.simulation: str = "simulated"
+        self._gravity: bool = False
+        self._stable: bool = False
+        self._can_move: bool = True
+        self._density: float = 10
+        self.moment: Optional[float] = None
+        self.damping = 1
+        self.max_velocity_x = math.inf
+        self._friction: float = 0.5
+        self._velocity_x: float = 0
+        self._velocity_y: float = 0
+        self._elasticity: float = 0.5
+        self._shape_type: str = "rect"
+        self._correct_angle: float = 90
+        self._body: Union[pymunk_engine.Body, None] = None
+        self._shape: Union[pymunk_engine.Shape, None] = None
+        self.dirty: int = 1
+        self.has_physics: bool = False
+        self.size = (1, 1)  # scale factor for physics box model
+        self.joints = []
+
+    @staticmethod
+    def velocity_function(body, gravity, damping, dt):
+        pymunk.Body.update_velocity(
+            body, gravity, body.physics_property.damping * damping, dt
+        )
+        if (
+            body.physics_property.max_velocity_x != math.inf
+            and body.velocity[0] > body.physics_property.max_velocity_x
+        ):
+            body.velocity = body.physics_property.max_velocity_x, body.velocity[1]
+        if (
+            body.physics_property.max_velocity_x != math.inf
+            and body.velocity[0] < -body.physics_property.max_velocity_x
+        ):
+            body.velocity = -body.physics_property.max_velocity_x, body.velocity[1]
+
+    def join(self, other: "actor.Actor", type="pin"):
+        """joins two actors at their center points"""
+        if not hasattr(other, "physics"):
+            raise TypeError("Other actor has no attribute physics")
+        my_body = self._body
+        other_body = other.physics._body
+        pj = pymunk.PinJoint(my_body, other_body, (0, 0), (0, 0))
+        self.joints.append(pj)
+        self.world.space.add(pj)
+        return self.actor.position_manager.get_position(), other.position
+
+    def remove_join(self, other: "actor.Actor"):
+        """Remove a joint between two actors.
+
+        Removes a joint between two actors, if a joint exists.
+
+        Examples:
+
+            Add and remove a joint on key_down:
+
+            .. code-block:: python
+
+                import random
+                from miniworlds import *
+                world = PhysicsWorld((400, 200))
+                connected = False
+                line = None
+                anchor = Rectangle()
+                anchor.size = (20,20)
+                anchor.center = (100, 20)
+                anchor.physics.simulation = "manual"
+                other_side = Line((250,100),(500,200))
+                def add_line(obj1, obj2):
+                    l = Line(obj1.center, obj2.center)
+                    l.physics.simulation = None
+                    @l.register
+                    def act(self):
+                        self.start_position = obj1.center
+                        self.end_position = obj2.center
+                    return l
+                c = Circle()
+                @c.register
+                def on_key_down(self, key):
+                    global connected
+                    global line
+                    if not connected:
+                        print("not connected")
+                        self.physics.join(anchor)
+                        line = add_line(self, anchor)
+                        connected = True
+                    else:
+                        print("connected")
+                        self.physics.remove_join(anchor)
+                        line.remove()
+
+                world.run()
+
+
+            .. raw:: html
+
+                <video loop autoplay muted width=400>
+                <source src="../_static/jointsremove1.webm" type="video/webm">
+                <source src="../_static/jointsremove1.mp4" type="video/mp4">
+                Your browser does not support the video tag.
+                </video>
+        """
+        for join in self.joints:
+            if other.physics._body == join.b:
+                self.world.space.remove(join)
+
+    def _start(self):
+        """Starts the physics-simulation
+
+        Called in world-connector
+        """
+        if not self.started:
+            self.started = True
+            self._setup_physics_model()  # After on_setup
+
+    def _get_pymunk_shape(self):
+        if self.shape_type.lower() == "rect":
+            shape = pymunk.Poly.create_box(
+                self._body,
+                (self.size[0] * self.actor.width, self.size[1] * self.actor.height),
+                1,  # small radius
+            )
+        elif self.shape_type.lower() == "circle":
+            shape = pymunk.Circle(
+                self._body,
+                self.size[0] * self.actor.width / 2,
+                (0, 0),
+            )
+        elif isinstance(self.actor, shapes.Line):
+            start = pymunk.pygame_util.from_pygame(
+                (0, -self.actor._length / 2), self.actor.world.image
+            )
+            end = pymunk.pygame_util.from_pygame(
+                (0, self.actor._length / 2), self.actor.world.image
+            )
+            shape = pymunk.Segment(self._body, start, end, self.actor.thickness)
+        else:
+            raise AttributeError("No shape set!")
+        return shape
+
+    def _setup_physics_model(self):
+        if (
+            self.dirty and self.actor.position_manager.get_position()
+        ):  # if actor is on the world
+            # create body
+            self.has_physics = False
+            self._body = pymunk_engine.Body(body_type=self.body_type)
+            self._body.physics_property = self
+            self._body.moment = math.inf
+            self._body.velocity_func = self.velocity_function
+            # self._body.damping = self.damping
+            self._set_pymunk_position()
+            self._set_pymunk_direction()
+            self._body.size = (
+                self.size[0] * self.actor.width,
+                self.size[1] * self.actor.height,
+            )
+
+            # disable velocity for actors if actor has no gravity
+            if self.simulation == "static":
+                self._body.velocity_func = lambda body, gravity, damping, dt: None
+            else:
+                self._body.velocity = self.velocity_x, self._velocity_y
+            # Adds object to space
+            if self._simulation:
+                self._shape = self._get_pymunk_shape()
+                self._shape.density = self.density
+                self._shape.friction = self.friction
+                self._shape.elasticity = self.elasticity
+                self._shape.actor = self.actor
+                self._shape.collision_type = hash(self.actor.__class__.__name__) % (
+                    (sys.maxsize + 1) * 2
+                )
+                self.world.space.add(self._body, self._shape)
+            if self.moment is not None:
+                self._body.moment = self.moment
+            if self.simulation == "static":
+                self.world.space.reindex_static()
+            self.dirty = 1
+            self.has_physics = True
+
+    def _set_pymunk_position(self):
+        pymunk_position = self.actor.center[0], self.actor.center[1]
+        self._body.position = pymunk.pygame_util.from_pygame(
+            pymunk_position, self.actor.world.image
+        )
+
+    def _set_pymunk_direction(self):
+        self._body.angle = (
+            self.actor.position_manager.get_pymunk_direction_from_miniworlds()
+        )
+
+    def _set_mwm_actor_position(self):
+        if self._body:
+            self.actor.center = pymunk.pygame_util.from_pygame(
+                self._body.position, self.actor.world.image
+            )
+            self.dirty = 0
+
+    def _set_mwm_actor_direction(self):
+        self.actor.position_manager.set_mwm_direction_from_pymunk()
+        self.dirty = 0
+
+    def reload(self):
+        """Removes actor from space and reloads physics_model"""
+        if self.started:
+            self.dirty = 1
+            # Remove shape and body from space
+            self._remove_from_space()
+            # Set new properties and reset to space
+            self._setup_physics_model()
+        else:
+            self.dirty = 1
+
+    def _remove_from_space(self):
+        if self._body:
+            for shape in list(self._body.shapes):
+                if shape in self.world.space.shapes:
+                    self.world.space.remove(shape)
+            if self._body in self.world.space.bodies:
+                self.world.space.remove(self._body)
+
+    def remove(self):
+        """Removes an object from physics-space"""
+        self._remove_from_space()
+
+    @property
+    def simulation(self):
+        """Sets simulation type for actor (`static`, `manual`, `simulated` or `None`)
+
+        Sets simulation type for actor:
+
+        * `simulated`: Actor is fully simulated by physics engine.
+        * `manual`: Actor is not affected by gravity.
+        * `static`: Actor is not moved by physics engine, but actors can collide with actor.
+        * `None`: Actor is not moved by physics engine and other actors can't collide with actor.
+        """
+        return self._simulation
+
+    @simulation.setter
+    def simulation(self, value: Union[str, None]):
+        # Sets the simulation type
+        self._simulation = value
+        if not value:
+            self._is_rotatable = False
+            self._gravity = False
+            self._can_move = False
+            self._stable = True
+        elif value.lower() == "static":
+            self._is_rotatable = False
+            self._gravity = False
+            self._can_move = False
+            self._stable = True
+            self.density = 0
+        elif value.lower() == "manual":
+            self._is_rotatable = True
+            self._gravity = False
+            self._can_move = True
+            self._stable = True
+        elif value.lower() == "simulated":
+            self._is_rotatable = True
+            self._gravity = True
+            self._can_move = True
+            self._stable = True
+        self.dirty = 1
+        self.reload()
+
+    @property
+    def body(self):
+        return self._body
+
+    @body.setter
+    def body(self, value):
+        self._body = value
+
+    @property
+    def body_type(self):
+        """Returns body type of actor
+
+        Must not be used from outside - Use property simulation instead.
+        """
+        if self.simulation is None or self.simulation == "static":
+            return pymunk.Body.STATIC
+        elif self.simulation == "manual":
+            return pymunk.Body.KINEMATIC
+        else:
+            return pymunk.Body.DYNAMIC
+
+    @property
+    def size(self):
+        """Sets size of physics_object in relation to object
+
+        * 1: Physics object size equals actor size
+        * < 1: Physics object is smaller than actor
+        * > 1: Physics object is larger than actor.
+
+        .. warning::
+
+            Actor is re-added to physics space after this operation - Velocity and impulses are lost.
+        """
+        return self._size
+
+    @size.setter
+    def size(self, value: tuple):
+        self._size = value
+        self.dirty = 1
+        self.reload()
+
+    @property
+    def shape_type(self):
+        """Sets shape type of object:
+
+        Shape Types:
+          * "rect": Rectangle
+          * "circle": Circle
+
+        .. warning::
+
+            Actor is re-added to physics space after this operation - Velocity and impulses are lost.
+
+        Examples:
+
+            Demonstrate different shape types:
+
+            .. code-block:: python
+
+                from miniworlds import *
+
+                world = PhysicsWorld(600,300)
+                Line((0,100),(100,150))
+                t = Actor((0,50))
+                t.physics.shape_type = "rect"
+                Line((200,100),(300,150))
+                t = Actor((200,50))
+                t.physics.shape_type = "circle"
+                world.run()
+
+            .. raw:: html
+
+                <video loop autoplay muted width=400>
+                <source src="../_static/shape_types.webm" type="video/webm">
+                <source src="../_static/shape_types.mp4" type="video/mp4">
+                Your browser does not support the video tag.
+                </video>
+        """
+        return self._shape_type
+
+    @shape_type.setter
+    def shape_type(self, value: str):
+        self._shape_type = value
+        self.dirty = 1
+        self.reload()
+
+    @property
+    def friction(self):
+        """Sets friction of actor
+
+        .. warning::
+
+            Actor is re-added to physics space after this operation - Velocity and impulses are lost.
+
+        """
+        return self._friction
+
+    @friction.setter
+    def friction(self, value: float):
+        self._friction = value
+        self.dirty = 1
+        self.reload()
+
+    @property
+    def elasticity(self):
+        """Sets elasticity of actor
+
+        .. warning::
+
+            Actor is re-added to physics space after this operation - Velocity and impulses are lost.
+
+        """
+        return self._elasticity
+
+    @elasticity.setter
+    def elasticity(self, value: float):
+        self._elasticity = value
+        self.dirty = 1
+        self.reload()
+
+    @property
+    def density(self):
+        """Sets density of actor
+
+        .. warning::
+
+            Actor is re-added to physics space after this operation - Velocity and impulses are lost.
+
+        """
+        return self._density
+
+    @density.setter
+    def density(self, value: float):
+        self._density = value
+        self.dirty = 1
+        self.reload()
+
+    def _simulation_preprocess_actor(self):
+        """
+        Updates the physics model in every frame
+
+        Returns:
+
+        """
+        if (
+            self._body and not self._body.body_type == pymunk_engine.Body.STATIC
+        ) and self.dirty:
+            self._set_pymunk_position()
+            self._set_pymunk_direction()
+            self.world.space.reindex_shapes_for_body(self._body)
+            self.dirty = 0
+
+    def _simulation_postprocess_actor(self):
+        """
+        Reloads physics model from pygame data
+        """
+        if self.simulation and not math.isnan(self._body.position[0]):
+            self._set_mwm_actor_position()
+            self._set_mwm_actor_direction()
+        if self._body and not self._body.body_type == pymunk_engine.Body.STATIC:
+            self.velocity_x = self._body.velocity[0]
+            self.velocity_y = self._body.velocity[1]
+            if self.world.debug:
+                options = pymunk.pygame_util.DrawOptions(self.actor.world.image)
+                options.collision_point_color = (255, 20, 30, 40)
+                self.world.space.debug_draw(options)
+
+    @property
+    def velocity_x(self):
+        """Sets velocity in x-direction. Can be positive or negative.
+
+        Examples:
+
+           Move a actor left or right.
+
+           .. code-block:: python
+
+               def on_key_pressed_d(self):
+                   self.physics.velocity_x = 50
+
+               def on_key_pressed_a(self):
+                   self.physics.velocity_x = - 50
+
+        """
+        return self._velocity_x
+
+    @velocity_x.setter
+    def velocity_x(self, value: float):
+        self._velocity_x = value
+        if self._body:
+            self._body.velocity = value, self._body.velocity[1]
+
+    @property
+    def velocity_y(self):
+        """Sets velocity in y-direction"""
+        return self._velocity_y
+
+    @velocity_y.setter
+    def velocity_y(self, value: float):
+        self._velocity_y = value
+        if self._body:
+            self._body.velocity = self._body.velocity[0], value
+
+    @property
+    def is_rotatable(self):
+        """defines, if actor will be rotated by physics-engine."""
+        return self._is_rotatable
+
+    @is_rotatable.setter
+    def is_rotatable(self, value: bool):
+        self._is_rotatable = value
+        self.dirty = 1
+        self.reload()
+
+    def impulse_in_direction(self, direction: float, power: float):
+        """
+        Adds an impulse in actor-direction
+
+        Examples:
+
+            .. code-block:: python
+
+                from miniworlds import *
+
+                world = PhysicsWorld(300, 200)
+
+                rect = Rectangle((280,120), 20, 80)
+                rect.physics.simulation = "manual"
+                ball = Circle((50,50),20)
+
+                @rect.register
+                def act(self):
+                    rect.x -= 1
+                    if rect.x == 0:
+                        rect.x = 280
+
+                @ball.register
+                def on_key_down(self, key):
+                    self.physics.impulse_in_direction(0, 5000)
+                world.run()
+
+
+        Args:
+            power: The power-value of the impulse.
+            direction: pymunk direction
+        """
+        impulse = pymunk.Vec2d(1, 0)
+        impulse = impulse.rotated_degrees(
+            360
+            - self.actor.position_manager.dir_to_unit_circle(
+                direction - self.actor.direction
+            )
+        )
+        impulse = power * 1000 * impulse.normalized()
+        self._body.apply_impulse_at_local_point(impulse)
+
+    def force_in_direction(self, direction: float, power: float):
+        """
+        Adds a force in given direction
+
+        Args:
+            power: The power-value of the force.
+            direction: pymunk direction
+        """
+        force = pymunk.Vec2d(1, 0)
+        force = force.rotated_degrees(
+            360
+            - self.actor.position_manager.dir_to_unit_circle(
+                direction - self.actor.direction
+            )
+        )
+        force = power * 10000 * force.normalized()
+        self._body.apply_force_at_local_point(force, (0, 0))

miniworlds_physics-2.0.0.0/miniworlds_physics/physics_world.py

@@ -0,0 +1,227 @@
+import pymunk as pymunk_engine
+from miniworlds import Line, World
+from miniworlds.tools import actor_inspection
+import miniworlds_physics.physics_world_event_manager as event_manager
+import miniworlds_physics.physics_world_connector as world_connector
+
+
+class PhysicsWorld(World):
+    """
+    A PhysicsWorld is a playing field on which objects follow physical laws.
+
+    The PhysicsWorld itself defines some values with which the physics engine can be influenced, e.g.
+    the gravity in the world.
+
+    All actors on a PhysicsWorld have an attribute ``actor.physics``, with which you can change the physical properties
+    of the object.
+    """
+
+    def __init__(
+        self,
+        columns: int = 40,
+        rows: int = 40,
+    ):
+        super().__init__(columns, rows)
+        self.gravity_x: float = 0
+        self.gravity_y: float = 900
+        self.debug: bool = False
+        self._accuracy = 1
+        self.space = pymunk_engine.Space()
+        self.space.gravity = self.gravity_x, self.gravity_y
+        self.space.iterations = 35
+        self.space.damping = 0.9
+        self.space.collision_persistence = 10
+        self._damping = 0
+        self.physics_actors = list()
+        self.touching_methods = set()  # filled in actor_manager
+        self.separate_methods = set()  # filled in actor_manager
+
+    def _create_event_manager(self):
+        return event_manager.PhysicsWorldEventManager(self)
+
+    @property
+    def accuracy(self):
+        """Sets number of physics-steps performed in each frame.
+
+        Default: 1
+        """
+        return self._accuracy
+
+    @accuracy.setter
+    def accuracy(self, value: int):
+        self._accuracy = value
+
+    @staticmethod
+    def _get_world_connector_class():
+        """needed by get_world_connector in parent class"""
+        return world_connector.PhysicsWorldConnector
+
+
+    def get_physics_collision_methods_for_actor(self, actor):
+        """Gets all collision methods for actor
+
+        :meta private:
+        """
+        # gets all method names
+        methods = [
+            method_name
+            for method_name in dir(actor)
+            if method_name.startswith("on_touching_")
+            or method_name.startswith("on_separation_from_")
+        ]
+        # get methods from method names
+        return [
+            getattr(actor, method_name)
+            for method_name in methods
+            if hasattr(actor, method_name) and callable(getattr(actor, method_name))
+        ]
+
+    def on_new_actor(self, actor):
+        print("new actor", actor, actor.physics.simulation)
+        if not actor.physics.simulation:
+            connector = world_connector.PhysicsWorldConnector(self, actor)
+            connector.remove_actor_from_physics()
+    
+    def _act_all(self):
+        """Handles acting of actors - Calls the physics-simulation in each frame.
+
+        :meta private:
+        """
+        super()._act_all()
+        self.simulate_all_physics_actors()
+
+    def simulate_all_physics_actors(self):
+        """Iterates over all actors and process physics-simulation
+
+        Processes phyisics-simulation in three steps
+
+        * Convert miniworlds-position/direction to pymunk position/direction
+        * Simulate a step in physics-engine
+        * Convert pymunk position/direction to miniworlds position/direction
+
+        :meta private:
+        """
+        if len(self.physics_actors) > 0:
+            # pre-process
+            [
+                actor.physics._simulation_preprocess_actor()
+                for actor in self.physics_actors
+            ]
+            # simulate
+            steps = self.accuracy
+            for _ in range(steps):
+                # if self.physics.space is not None: - can be removed
+                self.space.step(1 / (60 * steps))
+            # post-process
+            [
+                actor.physics._simulation_postprocess_actor()
+                for actor in self.physics_actors
+            ]
+
+    @property
+    def gravity(self) -> tuple:
+        """Defines gravity in physics world.
+
+        Gravity is a 2-tuple with gravy in x-direction and y-direction.
+
+        Default gravity: x=0, y=500
+
+        Examples:
+
+          Get all actors at mouse position:
+
+          .. code-block:: python
+
+            world = PhysicsWorld(400,400)
+            world.gravity = (0, 0)
+        """
+        return self.gravity_x, self.gravity_y
+
+    @gravity.setter
+    def gravity(self, value: tuple):
+        self.gravity_x = value[0]
+        self.gravity_y = value[1]
+        self.space.gravity = self.gravity_x, self.gravity_y
+
+    @property
+    def damping(self):
+        """Amount of simple damping to apply to the space.
+
+        A value of 0.9 means that each body will lose 10% of its velocity per second. Defaults to 1.
+        """
+        return self.gravity_x, self.gravity_y
+
+    @damping.setter
+    def damping(self, value: tuple):
+        self._damping = value
+        self.space.damping = self._damping
+
+    def pymunk_touching_collision_listener(self, arbiter, space, data):
+        """Handles collisions - Handled by pymunk engine
+
+        :meta private:
+        """
+        # Translate pymunk variables to miniworlds variables.
+        # Arbiter contains the two colliding actors.
+        t1 = arbiter.shapes[0].actor
+        t2 = arbiter.shapes[1].actor
+        collision = dict()
+        # get touching methods, e.g. `on_touching_circle`
+        for method in self.touching_methods:
+            # _cls_search_string = method.__name__[len("on_touching_"):].lower() # Get class by method name
+            # filter_class = actor_class_inspection.ActorClassInspection(self).find_actor_class_by_classname(
+            #    _cls_search_string
+            # )
+            # sets parameter for method
+            if method.__self__ == t1:
+                other = t2
+            else:
+                other = t1
+            # call instance method with correct parameters
+            # if isinstance(other, filter_class):
+            actor_inspection.ActorInspection(method.__self__).get_and_call_method(
+                method.__name__, [other, collision]
+            )
+        return True
+
+    def pymunk_separation_collision_listener(self, arbiter, space, data):
+        """Handles collisions - Handled by pymunk engine
+
+        :meta private:
+        """
+        # Translate pymunk variables to miniworlds variables.
+        # Arbiter contains the two colliding actors.
+        t1 = arbiter.shapes[0].actor
+        t2 = arbiter.shapes[1].actor
+        collision = dict()
+        # get touching methods, e.g. `on_touching_circle`
+        for method in self.separate_methods:
+            # _cls_search_string = method.__name__[len("on_separation_from_"):].lower() # Get class by method name
+            # filter_class = actor_class_inspection.ActorClassInspection(self).find_actor_class_by_classname(
+            #    _cls_search_string
+            # )
+            # sets parameter for method
+            if method.__self__ == t1:
+                other = t2
+            else:
+                other = t1
+            # call instance method with correct parameters
+            # if isinstance(other, filter_class):
+            actor_inspection.ActorInspection(method.__self__).get_and_call_method(
+                method.__name__, [other, collision]
+            )
+        return True
+
+    def connect(self, actor1, actor2) -> "Line":
+        line = Line(actor1.center, actor2.center)
+        line.physics.simulation = None
+        line.border = 1
+        line.fill = True
+        line.color = (255, 0, 0, 100)
+
+        @line.register
+        def act(self):
+            self.start_position = actor1.center
+            self.end_position = actor2.center
+
+        return line

miniworlds_physics-2.0.0.0/miniworlds_physics/physics_world_connector.py

@@ -0,0 +1,162 @@
+import miniworlds.worlds.manager.world_connector as world_connector
+import miniworlds.worlds.manager.sensor_manager as sensor_manager
+import miniworlds.tools.actor_class_inspection as actor_class_inspection
+import miniworlds_physics.physics_world as world_mod
+import miniworlds_physics.actor_physics as actor_physics
+import miniworlds_physics.physics_world_position_manager as physics_position_manager
+import miniworlds.actors.actor as actor_mod
+import sys
+
+
+class PhysicsWorldConnector(world_connector.WorldConnector):
+    count_actors = 0
+
+    def __init__(self, world: "world_mod.PhysicsWorld", actor: "actor_mod.Actor"):
+        super().__init__(world, actor)
+        self.world: "world_mod.PhysicsWorld" = world
+        self.actor.register(self.impulse, force=True)
+        self.actor.register(self.force, force=True)
+        self.actor.register(self.set_simulation, force=True)
+        self.actor.register(self.set_velocity_x, force=True)
+        self.actor.register(self.set_velocity_y, force=True)
+        self.actor.register(self.set_velocity, force=True)
+
+
+    def impulse(self, direction: float, power: int):
+        """this method will be registered to an Actor-Instance
+        """
+        self.position_manager.impulse(direction, power)
+    
+    def force(self, direction: float, power: int):
+        self.position_manager.force(direction, power)
+
+    def set_simulation(self, simulation_type: str):
+        self.position_manager.set_simulation(simulation_type)
+        
+    def set_velocity_x(self, value):
+        self.position_manager.set_velocity_x(value)
+
+    def set_velocity_y(self, value):
+        self.position_manager.set_velocity_y(value)
+        
+    def set_velocity(self, value):
+        self.position_manager.set_velocity(value)
+    @staticmethod
+    def get_position_manager_class():
+        return physics_position_manager.PhysicsWorldPositionManager
+
+    @staticmethod
+    def get_sensor_manager_class():
+        return sensor_manager.SensorManager
+
+    def add_to_world(self, position):
+        # add actor.physics attribute with physics properties to actor
+        self.actor.physics = actor_physics.ActorPhysics(self.actor, self.actor.world)
+        if hasattr(self.actor, "_set_physics"):
+            self.actor._set_physics()
+        super().add_to_world(position)
+        self.register_all_physics_collision_managers_for_actor()
+        self.actor.physics._start()
+        self.world.physics_actors.append(self.actor)
+        if hasattr(self.actor, "on_begin_simulation"):
+            self.actor.on_begin_simulation()
+
+    def remove_actor_from_world(self):
+        super().remove_actor_from_world()
+        self.actor.physics._remove_from_space()
+        if self in self.physics_actors:
+            self.physics_actors.remove(self)
+        try:
+            self.world.physics_actors.remove(self.actor)
+        except ValueError:
+            pass # actor not in physics actors
+        
+    def remove_actor_from_physics(self):
+        print("remove from physics", self.actor)
+        self.actor.physics._remove_from_space()
+        if self in self.world.physics_actors:
+            self.world.physics_actors.remove(self.actor)
+        try:
+            self.world.physics_actors.remove(self.actor)
+        except ValueError:
+            pass # actor not in physics actors
+            
+    def register_all_physics_collision_managers_for_actor(self):
+        """Registers on__touching and on_separation-Methods to actor.
+        If new_class is set, only methods with new class (e.g. on_touching_new_class are set)
+
+        :meta private:
+        """
+        collision_methods = self.world.get_physics_collision_methods_for_actor(self.actor)
+        for method in collision_methods:
+            if method.__name__.startswith("on_touching_"):
+                self.register_touching_method(method)
+            elif method.__name__.startswith("on_separation_from_"):
+                self.register_separate_method(method)
+
+    def register_touching_method(self, method):
+        """
+        Registers on_touching_[class] method
+
+        :meta private:
+        """
+        event = "begin"
+        other_cls_name = method.__name__[len("on_touching_"):].lower()
+        other_cls = actor_class_inspection.ActorClassInspection(self).find_actor_class_by_classname(other_cls_name)
+        if self._register_physics_listener_method(method, event, other_cls):
+            self.world.touching_methods.add(method)
+
+    def register_separate_method(self, method):
+        """
+        Registers on_separation_from_[class] method
+
+        :meta private:
+        """
+        event = "separate"
+        other_cls_name = method.__name__[len("on_separation_from_"):].lower()
+        other_cls = actor_class_inspection.ActorClassInspection(self).find_actor_class_by_classname(other_cls_name)
+        if self._register_physics_listener_method(method, event, other_cls):
+            self.world.separate_methods.add(method)
+
+    def _register_physics_listener_method(self, method, event, other_cls):
+        """Registers a physics listener method. (on touching or on_separation.)
+        Called from register_touching_method and register_separate_method
+
+        :meta private:
+        """
+        actor_class_inspect = actor_class_inspection.ActorClassInspection(self)
+        all_actor_classes = actor_class_inspect.get_all_actor_classes()
+        if other_cls not in all_actor_classes:
+            return False
+        else:
+            subclasses_of_other_actor = actor_class_inspection.ActorClassInspection(other_cls).get_subclasses_for_cls()
+            for other_subcls in set(subclasses_of_other_actor).union({other_cls}):
+                # If you register a Collision with a Actor, collisions with subclasses of the actor
+                # are also registered
+                self._pymunk_register_collision_manager(method.__self__, other_subcls, event, method)
+            return True
+
+    def _pymunk_register_collision_manager(self, actor, other_class, event, method):
+        """Adds pymunk collision handler, which is evaluated by pymunk engine.
+
+        The event (begin, end) and the method (on_touching...) are added as data to the handler
+
+        Args:
+            actor: The actor
+            other_class: The class which should be detected by collision handler
+            event: The pymunk-event  (begin or separate)
+            method: The method, e.g. on_touching_actor or on_separation_from_actor. Last part is a class name
+
+        :meta private:
+        """
+
+        space = self.world.space
+        actor_id = hash(actor.__class__.__name__) % ((sys.maxsize + 1) * 2)
+        other_id = hash(other_class.__name__) % ((sys.maxsize + 1) * 2)
+        handler = space.add_collision_handler(actor_id, other_id)
+        handler.data["method"] = getattr(actor, method.__name__)
+        handler.data["type"] = event
+        if event == "begin":
+            handler.begin = self.world.pymunk_touching_collision_listener
+        if event == "separate":
+            handler.separate = self.world.pymunk_separation_collision_listener

miniworlds_physics-2.0.0.0/miniworlds_physics/physics_world_event_manager.py

@@ -0,0 +1,44 @@
+import miniworlds.tools.inspection as inspection
+import miniworlds.worlds.manager.event_manager as event_manager
+from miniworlds.actors import actor as actor_mod
+from miniworlds.tools import actor_class_inspection
+from miniworlds_physics import (
+    physics_world_connector as physics_world_connector_mod,
+)
+
+
+class PhysicsWorldEventManager(event_manager.EventManager):
+    """Adds on_touching and on separation events"""
+
+    @classmethod
+    def setup_event_list(cls):
+        super().setup_event_list()
+        touching_actor_methods = []
+        separation_actor_methods = []
+        for actor_cls in actor_class_inspection.ActorClassInspection(
+            actor_mod.Actor
+        ).get_subclasses_for_cls():
+            touching_actor_methods.append("on_touching_" + actor_cls.__name__.lower())
+        for actor_cls in actor_class_inspection.ActorClassInspection(
+            actor_mod.Actor
+        ).get_subclasses_for_cls():
+            separation_actor_methods.append(
+                "on_separation_from_" + actor_cls.__name__.lower()
+            )
+        cls.actor_class_events["on_touching"] = touching_actor_methods
+        cls.actor_class_events["on_separation"] = separation_actor_methods
+        cls.fill_event_sets()
+
+    def register_event(self, member, instance):
+        super().register_event(member, instance)
+        method = inspection.Inspection(instance).get_instance_method(member)
+        if member.startswith("on_touching_"):
+            connector = physics_world_connector_mod.PhysicsWorldConnector(
+                self.world, instance
+            )
+            connector.register_touching_method(method)
+        elif member.startswith("on_separation_from_"):
+            connector = physics_world_connector_mod.PhysicsWorldConnector(
+                self.world, instance
+            )
+            connector.register_separate_method(method)

miniworlds_physics-2.0.0.0/miniworlds_physics/physics_world_position_manager.py

@@ -0,0 +1,90 @@
+from math import radians, degrees
+from typing import Tuple
+
+import miniworlds.worlds.manager.position_manager as position_manager
+from miniworlds.base.exceptions import (
+    PhysicsSimulationTypeError,
+)
+from miniworlds.actors import actor as actor_mod
+
+
+class PhysicsWorldPositionManager(position_manager.Positionmanager):
+    def __init__(self, actor: "actor_mod.Actor", world, position):
+        super().__init__(actor, world, position)
+
+    def set_position(
+        self, value: Tuple[float, float]
+    ) -> Tuple[float, float]:
+        pos = super().set_position(value)
+        if hasattr(self.actor, "physics"):
+            self.actor.physics.dirty = 1
+        return pos
+
+    def set_center(self, value):
+        pos = super().set_center(value)
+        if hasattr(self.actor, "physics"):
+            self.actor.physics.dirty = 1
+        return pos
+
+    def set_size(self, value, scale=False):
+        super().set_size(value, scale)
+        if hasattr(self.actor, "physics"):
+            self.actor.physics.dirty = 1
+
+    def move_to(self, position: Tuple[float, float]):
+        super().move_to(position)
+        if hasattr(self.actor, "physics"):
+            self.actor.physics.reload()
+
+    def get_direction(self):
+        return self._direction
+
+    def set_direction(self, value):
+        if hasattr(self.actor, "physics") and self.actor.physics.body:
+            pymunk_direction = self.get_pymunk_direction(value)
+            self.actor.physics.body.angle = pymunk_direction
+            super().set_direction((value + 360) % 360)
+        else:
+            super().set_direction(value)
+
+    def get_pymunk_direction_from_miniworlds(self):
+        mwm_direction = self._direction
+        return self.get_pymunk_direction(mwm_direction)
+
+    def get_pymunk_direction(self, value):
+        mwm_direction = (value + 360) % 360
+        direction = radians(mwm_direction)
+        return direction
+
+    def set_mwm_direction_from_pymunk(self):
+        pymunk_dir_in_degrees = degrees(self.actor.physics.body.angle)
+        mwm_direction = (pymunk_dir_in_degrees + 360) % 360
+        super().set_direction(mwm_direction)
+
+    def impulse(self, direction: float, power: int):
+        self.actor.physics.impulse_in_direction(direction, power)
+
+    def force(self, direction: float, power: int):
+        self.actor.physics.force_in_direction(direction, power)
+
+    def set_simulation(self, simulation_type: str):
+        if simulation_type in ["simulated", "manual", "static", None]:
+            self.actor.physics.simulation = simulation_type
+            self.actor.physics.reload()
+        else:
+            raise PhysicsSimulationTypeError()
+
+    def set_velocity_y(self, value):
+        self.actor.physics.velocity_y = value
+
+    def set_velocity_x(self, value):
+        self.actor.physics.velocity_x = value
+
+    def set_velocity(self, value):
+        self.actor.physics.velocity_x, self.actor.physics.velocity_y = (
+            value[0],
+            value[1],
+        )
+
+    def self_remove(self):
+        self.actor.physics._remove_from_space()

miniworlds_physics-2.0.0.0/miniworlds_physics.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: miniworlds_physics
+Version: 2.0.0.0
+Summary: Physics engine for miniworlds
+Home-page: https://github.com/asbl/miniworlds
+Download-URL: https://github.com/asbl/miniworlds
+Author: Andreas Siebel
+Author-email: andreas.siebel@it-teaching.de
+License: OSI Approved :: MIT License
+Keywords: games,education,mini-worlds,pygame
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Education
+Description-Content-Type: text/markdown
+Requires-Dist: miniworlds
+
+Physics World
+======================
+
+physics engine for miniworlds based on pymunk

miniworlds_physics-2.0.0.0/miniworlds_physics.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+setup.py
+miniworlds_physics/__init__.py
+miniworlds_physics/actor_physics.py
+miniworlds_physics/physics_world.py
+miniworlds_physics/physics_world_connector.py
+miniworlds_physics/physics_world_event_manager.py
+miniworlds_physics/physics_world_position_manager.py
+miniworlds_physics.egg-info/PKG-INFO
+miniworlds_physics.egg-info/SOURCES.txt
+miniworlds_physics.egg-info/dependency_links.txt
+miniworlds_physics.egg-info/requires.txt
+miniworlds_physics.egg-info/top_level.txt

miniworlds_physics-2.0.0.0/miniworlds_physics.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

miniworlds_physics-2.0.0.0/miniworlds_physics.egg-info/requires.txt

@@ -0,0 +1 @@
+miniworlds

miniworlds_physics-2.0.0.0/miniworlds_physics.egg-info/top_level.txt

@@ -0,0 +1 @@
+miniworlds_physics

miniworlds_physics-2.0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

miniworlds_physics-2.0.0.0/setup.py

@@ -0,0 +1,37 @@
+from codecs import open
+from os import path
+
+from setuptools import setup, find_packages
+
+here = path.abspath(path.dirname(__file__))
+
+# Get the long description from the README file
+with open(path.join(here, "README.md"), encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="miniworlds_physics",
+    version="2.0.0.0",
+    description="Physics engine for miniworlds",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    keywords=["games", "education", "mini-worlds", "pygame"],  # arbitrary keywords
+    author="Andreas Siebel",
+    author_email="andreas.siebel@it-teaching.de",
+    url="https://github.com/asbl/miniworlds",
+    download_url="https://github.com/asbl/miniworlds",
+    license="OSI Approved :: MIT License",
+    classifiers=[
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python",
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Education",
+        "Topic :: Education",
+    ],
+    packages=find_packages(
+        exclude=["contrib", "docs", "tests", "examples"]
+    ),  # Required
+    package_dir={"miniworlds_physics": "miniworlds_physics"},
+    install_requires=["miniworlds"],
+    include_package_data=True,
+)