play_objects.py

from base_objects import PlayObject

_SPIKE_ROTATION_KEYS = {
    0: "spr_stand_spikes_0_degrees",
    90: "spr_stand_spikes_90_degrees",
    180: "spr_stand_spikes_180_degrees",
    270: "spr_stand_spikes_270_degrees",
}
import pygame
import random
from utils import SCREEN_WIDTH, SCREEN_HEIGHT

class PlayWall(PlayObject):
    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_walls
        super().__init__(pos, play_sprites, images["spr_wall"])

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlayReverseWall(PlayObject):
    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_reverse_walls
        image = pygame.Surface((24, 24), pygame.SRCALPHA)
        image.fill((0, 0, 0, 0))
        super().__init__(pos, play_sprites, image)

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlayFlyer(PlayObject):
    SPEED = 1
    WALL_BOUNDARY_THRESHOLD = 5

    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_flyers
        self._registry = registry
        super().__init__(pos, play_sprites, images["spr_flyer"])
        self.images = images
        self.left_speed = PlayFlyer.SPEED * -1
        self.right_speed = PlayFlyer.SPEED
        self.right_or_left = random.choice([self.left_speed, self.right_speed])

    def update(self):
        self.rect.topleft = (self.rect.topleft[0] + self.right_or_left, self.rect.topleft[1])
        for wall in self._registry.play_walls:
            if self.rect.colliderect(wall.rect):
                if (self.rect.bottom > wall.rect.top + PlayFlyer.WALL_BOUNDARY_THRESHOLD and
                        self.rect.top < wall.rect.bottom - PlayFlyer.WALL_BOUNDARY_THRESHOLD):
                    self.right_or_left = self.right_or_left * -1
                    self.rect.topleft = (self.rect.topleft[0] + self.right_or_left, self.rect.topleft[1])
        for reverse_wall in self._registry.play_reverse_walls:
            if self.rect.colliderect(reverse_wall.rect):
                if (self.rect.bottom > reverse_wall.rect.top + PlayFlyer.WALL_BOUNDARY_THRESHOLD and
                        self.rect.top < reverse_wall.rect.bottom - PlayFlyer.WALL_BOUNDARY_THRESHOLD):
                    self.right_or_left = self.right_or_left * -1
                    self.rect.topleft = (self.rect.topleft[0] + self.right_or_left, self.rect.topleft[1])
        for sticky_block in self._registry.play_sticky_blocks:
            if self.rect.colliderect(sticky_block.rect):
                if (self.rect.bottom > sticky_block.rect.top + PlayFlyer.WALL_BOUNDARY_THRESHOLD and
                        self.rect.top < sticky_block.rect.bottom - PlayFlyer.WALL_BOUNDARY_THRESHOLD):
                    self.right_or_left = self.right_or_left * -1
                    self.rect.topleft = (self.rect.topleft[0] + self.right_or_left, self.rect.topleft[1])
        if self.rect.right > SCREEN_WIDTH or self.rect.left < 0:
            self.right_or_left = self.right_or_left * -1
            self.rect.topleft = (self.rect.topleft[0] + self.right_or_left, self.rect.topleft[1])
        self.sprite_direction(self.images)

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

    def sprite_direction(self, images):
        if self.right_or_left == self.right_speed:
            self.image = images["spr_flyer"]
        elif self.right_or_left == self.left_speed:
            self.image = pygame.transform.flip(images["spr_flyer"], 1, 0)

class PlayDiamonds(PlayObject):
    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_diamonds
        super().__init__(pos, play_sprites, images["spr_diamonds"])
        self.images = images
        self.pos = pos

    def restart(self):
        self.rect.topleft = self.pos
        self.image = self.images["spr_diamonds"]

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlayDoor(PlayObject):
    def __init__(self, pos, play_sprites, images):
        super().__init__(pos, play_sprites, images["spr_door_closed"])
        self.pos = pos
        self.images = images

    def open_or_close(self, score, diamonds_list):
        if score == len(diamonds_list):
            return self.images["spr_door_open"]
        return self.images["spr_door_closed"]

    def restart(self):
        self.rect.topleft = self.pos

class PlaySmilyRobot(PlayObject):
    SPEED = 2
    GRAVITY = 0.25
    OUT_OF_PLAY_TOPLEFT = (-100, SCREEN_HEIGHT + 100)

    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_smily_robots
        self._registry = registry
        super().__init__(pos, play_sprites, images["spr_smily_robot"])
        self.pos = pos
        self.rect.topleft = self.pos
        self.images = images
        self.speed_x = self.SPEED * random.choice([-1, 1])
        self.animatetimer = 0
        self.speed_y = 0

    def update(self):
        self.handle_movement()
        self.check_horizontal_collisions()
        self.calc_grav()
        self.check_vertical_collisions()
        self.handle_reverse_walls()
        self.animate()

    def restart(self):
        self.rect.topleft = self.pos
        self.speed_x = self.SPEED * random.choice([-1, 1])

    def handle_movement(self):
        self.rect.x += self.speed_x
        if self.rect.left <= 0 or self.rect.right >= SCREEN_WIDTH:
            self.speed_x *= -1

    def check_horizontal_collisions(self):
        collided_blocks = pygame.sprite.spritecollide(
            self, self._registry.play_walls + self._registry.play_sticky_blocks, False)
        if collided_blocks:
            if self.speed_x > 0:
                self.rect.right = min(block.rect.left for block in collided_blocks)
            elif self.speed_x < 0:
                self.rect.left = max(block.rect.right for block in collided_blocks)
            self.speed_x *= -1

    def check_vertical_collisions(self):
        next_position = self.rect.y + self.speed_y
        self.rect.y = next_position
        collided_blocks = pygame.sprite.spritecollide(
            self, self._registry.play_walls + self._registry.play_sticky_blocks, False)
        if collided_blocks:
            if self.speed_y > 0:
                self.rect.bottom = min(block.rect.top for block in collided_blocks)
                self.speed_y = 0
            elif self.speed_y < 0:
                self.rect.top = max(block.rect.bottom for block in collided_blocks)
                self.speed_y = 0

    def handle_reverse_walls(self):
        collided_reverse_walls = pygame.sprite.spritecollide(
            self, self._registry.play_reverse_walls, False)
        if collided_reverse_walls:
            self.speed_x *= -1
            self.rect.x += self.speed_x

    def calc_grav(self):
        if self.rect.top < SCREEN_HEIGHT:
            self.speed_y += self.GRAVITY
        else:
            self.speed_y = 0
            self.rect.topleft = self.OUT_OF_PLAY_TOPLEFT
        self.rect.y += self.speed_y

    def animate(self):
        self.animatetimer += 1
        if self.animatetimer > 5:
            self.image = self.images["spr_smily_robot_2"]
        if self.animatetimer > 10:
            self.image = self.images["spr_smily_robot"]
            self.animatetimer = 0

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlayStickyBlock(PlayObject):
    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_sticky_blocks
        super().__init__(pos, play_sprites, images["spr_sticky_block"])
        self.pos = pos
        self.rect.topleft = self.pos

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlayStandSpikes(PlayObject):
    def __init__(self, pos, play_sprites, images, registry, rotate=0):
        self._registry_list = registry.play_stand_spikes
        super().__init__(pos, play_sprites, images["spr_stand_spikes_0_degrees"])
        self.images = images
        self.rotate = rotate
        self.image = self.images[_SPIKE_ROTATION_KEYS[self.rotate]]
        self.pos = pos
        self.fall_var = 0

    def restart(self):
        self.rect.topleft = self.pos

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlayFallSpikes(PlayObject):
    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_fall_spikes
        super().__init__(pos, play_sprites, images["spr_fall_spikes"])
        self.pos = pos
        self.fall_var = 0

    def restart(self):
        self.rect.topleft = self.pos
        self.fall_var = 0

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlaySpring(PlayObject):
    def __init__(self, pos, play_sprites, images, registry):
        self._registry_list = registry.play_springs
        super().__init__(pos, play_sprites, images["spr_spring"])
        self.pos = pos

    def restart(self):
        self.rect.topleft = self.pos

    def add_to_class_list(self):
        self._registry_list.append(self)

    def remove_from_class_list(self):
        self._registry_list.remove(self)

class PlayPlayer(PlayObject):
    GRAVITY = 0.35
    PROP_GRAVITY = 0.01
    MAX_PROP_SPEED = -2
    PROP_ACCELERATION = 0.25
    JUMP_SPEED = -7
    DOUBLE_JUMP_SPEED = -2
    MOVE_SPEED = 4

    def __init__(self, pos, play_sprites, images, sounds, registry):
        self._registry = registry
        super().__init__(pos, play_sprites, images["spr_player"])
        self.images = images
        self.sounds = sounds
        self.pos = pos
        self.speed_x, self.speed_y = 0, 0
        self.jumps_left = 2
        self.propeller, self.playerproptimer = 0, 0
        self.last_pressed_r = 1
        self.score = 0
        self.death_count = 0
        self.wall_hit_list = []
        self.stickyblock_hit_list = []
        self.jump_counter = 0

    def update(self):
        self.calc_grav()
        self.rect.x += self.speed_x

        self.wall_hit_list = pygame.sprite.spritecollide(self, self._registry.play_walls, False)
        for wall in self.wall_hit_list:
            if self.speed_x > 0:
                self.rect.right = wall.rect.left
            elif self.speed_x < 0:
                self.rect.left = wall.rect.right
        self.stickyblock_hit_list = pygame.sprite.spritecollide(self, self._registry.play_sticky_blocks, False)
        for stickyblock in self.stickyblock_hit_list:
            if self.speed_x > 0:
                self.rect.right = stickyblock.rect.left
            elif self.speed_x < 0:
                self.rect.left = stickyblock.rect.right
        if self.rect.left < 0:
            self.rect.left = 0
        if self.rect.right > SCREEN_WIDTH:
            self.rect.right = SCREEN_WIDTH
        self.rect.y += self.speed_y
        self.wall_hit_list = pygame.sprite.spritecollide(self, self._registry.play_walls, False)
        for wall in self.wall_hit_list:
            if self.speed_y > 0:
                self.rect.bottom = wall.rect.top
                self.jumps_left = 2
            elif self.speed_y < 0:
                self.rect.top = wall.rect.bottom
            self.speed_y = 0
            self.propeller = 0
        self.stickyblock_hit_list = pygame.sprite.spritecollide(self, self._registry.play_sticky_blocks, False)
        for stickyblock in self.stickyblock_hit_list:
            if self.speed_y > 0:
                self.rect.bottom = stickyblock.rect.top
                self.jumps_left = 2
            elif self.speed_y < 0:
                self.rect.top = stickyblock.rect.bottom
            self.speed_y = 0
            self.propeller = 0
        self.animate_images()

    def move_left(self):
        self.speed_x = -self.MOVE_SPEED
        self.last_pressed_r = 0

    def move_right(self):
        self.speed_x = self.MOVE_SPEED
        self.last_pressed_r = 1

    def stop(self):
        self.speed_x = 0

    def calc_grav(self):
        if self.speed_y == 0:
            self.speed_y = 1
        elif self.propeller:
            self.speed_y += self.PROP_GRAVITY
            if self.speed_y >= self.MAX_PROP_SPEED:
                self.sounds["snd_propeller"].play()
            if self.speed_y > -1.5:
                self.propeller = 0
                self.speed_y += self.PROP_ACCELERATION
        else:
            self.sounds["snd_propeller"].stop()
            self.speed_y += self.GRAVITY

    def on_ground(self):
        self.rect.y += 1
        wall_hit_list = pygame.sprite.spritecollide(self, self._registry.play_walls, False)
        stickyblock_hit_list = pygame.sprite.spritecollide(self, self._registry.play_sticky_blocks, False)
        self.rect.y -= 1
        on_ground = bool(wall_hit_list or stickyblock_hit_list)
        on_sticky = bool(stickyblock_hit_list)
        return on_ground, on_sticky

    def jump(self):
        on_ground, on_sticky = self.on_ground()
        if on_ground and not on_sticky:
            self.speed_y = self.JUMP_SPEED
            self.jumps_left = 1
            self.animate_jump()
        elif not on_ground and self.jumps_left >= 1:
            self.speed_y = self.DOUBLE_JUMP_SPEED
            self.propeller = 1
            self.jumps_left = 0
            self.animate_jump()

    def animate_images(self):
        if self.propeller == 1:
            self.playerproptimer += 1
            if self.last_pressed_r == 1:
                if self.playerproptimer > 1:
                    self.image = self.images["spr_player_propeller"]
                if self.playerproptimer > 3:
                    self.image = self.images["spr_player"]
                    self.playerproptimer = 0
            if self.last_pressed_r == 0:
                if self.playerproptimer > 1:
                    self.image = pygame.transform.flip(self.images["spr_player_propeller"], 1, 0)
                if self.playerproptimer > 3:
                    self.image = pygame.transform.flip(self.images["spr_player"], 1, 0)
                    self.playerproptimer = 0
        else:
            if self.last_pressed_r == 1:
                self.image = self.images["spr_player"]
            else:
                self.image = pygame.transform.flip(self.images["spr_player"], 1, 0)

    def animate_jump(self):
        if self.propeller:
            self.playerproptimer = 0
            if "snd_propeller" in self.sounds:
                self.sounds["snd_propeller"].play()
        else:
            self.image = self.images["spr_player"]
            if "snd_jump" in self.sounds:
                self.sounds["snd_jump"].play()

    def restart(self):
        self.jumps_left = 2
        self.speed_y = 0
        self.propeller = 0
        self.last_pressed_r = 1
        self.score = 0
        self.death_count += 1
        self.rect.topleft = self.pos