sep-pm-platformer/project/physics/PhysicsElementsHandler.py

from typing import Optional

from physics.CollisionDirection import CollisionDirection
from physics.TickData import TickData
from sprite.DynamicSprite import DynamicSprite
from sprite.Sprite import Sprite
from sprite.StaticSprite import StaticSprite
from ui_elements.UiElement import UiElement

MOTION_STEPS = 10
TOLERANCE = 1


class PhysicsElementsHandler:
    def __init__(self):
        self.collision_callbacks = []

    def add_collision_callback(self, callback):
        self.collision_callbacks.append(callback)

    def remove_collision_callback(self, callback):
        self.collision_callbacks.remove(callback)

    def tick(self, tick_data: TickData, layers: dict[str, list[UiElement]]):
        sprites = []
        for layer in layers:
            for sprite in layers[layer]:
                sprite.tick(tick_data)
                if isinstance(sprite, Sprite):
                    sprites.append(sprite)

        # handle motion and collisions. To do this:
        # 1. Find all sprites that have collision enabled and store them in a list
        # 2. Create a list of all sprites that are dynamic sprites
        # 3. Sort the sprites by their y position
        # 4. For each sprite:
        #  4.1. Divide the motion into MOTION_STEPS steps
        #  4.2. For each step:
        #   4.2.1. Check if the sprite collides with any other sprite
        #   4.2.2. If it does, move the sprite back to the previous position and stop the motion
        #   4.2.3. If it doesn't, move the sprite to the new position

        colliders = [sprite for sprite in sprites
                     if isinstance(sprite, StaticSprite) and (sprite.is_collider or sprite.register_collisions)]

        for collider in colliders:
            collider.reset_collides_with()

        dynamic_sprites = [sprite for sprite in sprites if isinstance(sprite, DynamicSprite)]
        sorted_dynamic_sprites = sorted(dynamic_sprites, key=lambda spr: spr.position_scale.position[1])

        for sprite in sorted_dynamic_sprites:
            collides_with = self.attempt_move(tick_data.dt, sprite, colliders, MOTION_STEPS)
            if collides_with is not None:
                for callback in self.collision_callbacks:
                    callback(sprite, collides_with)

    def attempt_move(self, dt: float, sprite: DynamicSprite, colliders: list[StaticSprite],
                     motion_steps: int) -> Optional[StaticSprite]:
        total_motion = sprite.motion
        motion_step = ((total_motion[0] * dt) / motion_steps, (total_motion[1] * dt) / motion_steps)

        collides_with_last = None
        collided = [False, False]

        for i in range(motion_steps):
            if not collided[0]:
                sprite.position_scale.position = (
                    sprite.position_scale.position[0] + motion_step[0],
                    sprite.position_scale.position[1]
                )

                # print('Elements: ', list(filter(lambda spr: str(type(spr)) == "<class 'level.elements.LeverInputLevelElement.LeverInputLevelElement'>", colliders)))

                collides_with = self.check_collides(sprite, colliders)
                for collider in collides_with:
                    if collider is not None:
                        if sprite.is_collider and collider.is_collider:
                            if sprite.motion[0] > 0:
                                if sprite.register_collisions:
                                    sprite.add_collides_with(
                                        CollisionDirection(CollisionDirection.RIGHT, sprite, collider))
                                if collider.register_collisions:
                                    collider.add_collides_with(
                                        CollisionDirection(CollisionDirection.LEFT, collider, sprite))

                            if sprite.motion[0] < 0:
                                if sprite.register_collisions:
                                    sprite.add_collides_with(
                                        CollisionDirection(CollisionDirection.LEFT, sprite, collider))
                                if collider.register_collisions:
                                    collider.add_collides_with(
                                        CollisionDirection(CollisionDirection.RIGHT, collider, sprite))
                        else:
                            if sprite.register_collisions:
                                sprite.add_collides_with(
                                    CollisionDirection(CollisionDirection.INSIDE, sprite, collider))
                            if collider.register_collisions:
                                collider.add_collides_with(
                                    CollisionDirection(CollisionDirection.INSIDE, collider, sprite))

                        if collider.is_collider:
                            sprite.position_scale.position = (
                                sprite.position_scale.position[0] - motion_step[0],
                                sprite.position_scale.position[1]
                            )

                            sprite.motion = (0, sprite.motion[1])

                            collides_with_last = collider
                            collided[0] = True

            if not collided[1]:
                sprite.position_scale.position = (
                    sprite.position_scale.position[0],
                    sprite.position_scale.position[1] + motion_step[1]
                )

                collides_with = self.check_collides(sprite, colliders)
                for collider in collides_with:
                    if collider is not None:
                        if sprite.is_collider and collider.is_collider:
                            if sprite.motion[1] > 0:
                                if sprite.register_collisions:
                                    sprite.add_collides_with(
                                        CollisionDirection(CollisionDirection.BOTTOM, sprite, collider))
                                if collider.register_collisions:
                                    collider.add_collides_with(
                                        CollisionDirection(CollisionDirection.TOP, collider, sprite))

                            if sprite.motion[1] < 0:
                                if sprite.register_collisions:
                                    sprite.add_collides_with(
                                        CollisionDirection(CollisionDirection.TOP, sprite, collider))
                                if collider.register_collisions:
                                    collider.add_collides_with(
                                        CollisionDirection(CollisionDirection.BOTTOM, collider, sprite))
                        else:
                            if sprite.register_collisions:
                                sprite.add_collides_with(
                                    CollisionDirection(CollisionDirection.INSIDE, sprite, collider))
                            if collider.register_collisions:
                                collider.add_collides_with(
                                    CollisionDirection(CollisionDirection.INSIDE, collider, sprite))

                        if collider.is_collider:
                            sprite.position_scale.position = (
                                sprite.position_scale.position[0],
                                sprite.position_scale.position[1] - motion_step[1]
                            )

                            sprite.motion = (sprite.motion[0], 0)

                            collides_with_last = collider
                            collided[1] = True

        return collides_with_last

    def check_collides(self, sprite: StaticSprite, colliders: list[StaticSprite]) -> list[StaticSprite]:
        collides_with = []

        for collider in colliders:
            if sprite is not collider:
                if sprite.collides_with(collider, TOLERANCE):
                    collides_with.append(collider)
                    if len(collides_with) >= 2:
                        break

        return collides_with