###Flappy_bird.rpy

init python:


    class ShooterActor(renpy.Displayable):
        """Base class for Shooter objects.
        """
        def __init__(self, displayable, speed=(0, 0), start=(0, 0), *args, **kwargs):
            super(ShooterActor, self).__init__(*args, **kwargs)

            self.displayable = displayable

            self.speed_x = 0 ###Герой
            self.speed_y = 0 ###Герой

            self.max_speed_x = speed[0] ### Боты
            self.max_speed_y = speed[1] ### Боты

            self.start_x = start[0]
            self.start_y = start[1]

            self.x = start[0]
            self.y = start[1]

            # Stores the old value of the st value from render()
            self.old_st = None

            self.alive = True

            self.displayable_render = None

        @property
        def width(self):
            """Relies on the object already being rendered on screen.

            Returns: int
            """
            try:
                return self.displayable_render.get_size()[0]
            except AttributeError:
                return 0

        @property
        def height(self):
            """Relies on the object already being rendered on screen.

            Returns: int
            """
            try:
                return self.displayable_render.get_size()[1]
            except AttributeError:
                return 0

        def overlaps_with(self, other):
            """Check if this object's rectangle overlaps with another one."""

            left = self.x
            right = self.x + self.width
            top = self.y
            bottom = self.y + self.height

            other_left = other.x
            other_right = other.x + other.width
            other_top = other.y
            other_bottom = other.y + other.height

            horizontal_hit = False
            vertical_hit = False

            # Left side of self hits other
            if (left >= other_left) and (left <= other_right):
                horizontal_hit = True

            # Right side of self hits other
            if (right >= other_left) and (right <= other_right):
                horizontal_hit = True

            # Top side of self hits other
            if (top >= other_top) and (top <= other_bottom):
                vertical_hit = True

            # Bottom side of self hits other
            if (bottom >= other_top) and (bottom <= other_bottom):
                vertical_hit = True

            if horizontal_hit and vertical_hit:
                return True
            return False

        def inside_bounds(self):
            """Check if Actor is in the screen bounds."""
            if (self.x < 0) or (self.x > config.screen_width):
                return False
            elif (self.y < 0) or (self.y > config.screen_height):
                return False

            return True

init python:



    class EnemyShooterActor(ShooterActor):
        def __init__(self, *args, **kwargs):
            super(EnemyShooterActor, self).__init__(*args, **kwargs)

            self.wave = 1

        def render(self, width, height, st, at):
            render = renpy.Render(width, height)

            if self.alive:
                # Figure out the time elapsed since the previous frame.
                if self.old_st is None:
                    self.old_st = st

                dtime = st - self.old_st
                self.old_st = st


                speed_x = dtime * self.max_speed_x
                speed_y = dtime * self.max_speed_y

                self.x += speed_x
                self.y += speed_y

                self.displayable_render = renpy.render(
                    self.displayable,
                    width,
                    height,
                    st,
                    at
                )

                # Kill enemies when they leave the screen
                self.alive = self.inside_bounds()

            # Regenerate enemies at their original position
            if not self.alive:
                self.x = self.start_x
                self.y = self.start_y
                self.alive = True

            renpy.redraw(self, 0)
            render.blit(self.displayable_render, (self.x, self.y))

            return render


    class EnemyGroup(object):
        def __init__(self, start=(0, 0), enemies=None):
            for enemy in enemies:
                enemy.start_x += start[0]
                enemy.start_y += start[1]

                enemy.x += start[0]
                enemy.y += start[1]

            self.enemies = enemies

init python:
    import pygame




    class ShooterPlayer(ShooterActor):
        def __init__(self, displayable=None, bullet=None, speed=(0, 0), start=(0, 0), *args, **kwargs):
            super(ShooterPlayer, self).__init__(
                displayable, speed, start, *args, **kwargs)

            self.weapon = ShooterWeapon(self, bullet=bullet)
            self.enemies = []

        def check_overlap(self):
            for enemy in self.enemies:
                for bullet in self.weapon.bullets:
                    if bullet.overlaps_with(enemy):
                        enemy.alive = False

                if self.overlaps_with(enemy):
                    self.alive = False

        def move_player(self):
            if self.y <= 600:
                self.speed_y = self.max_speed_y / 2
            else:
                self.speed_y = 0
            keys = pygame.key.get_pressed()

            #if keys[pygame.K_LEFT]:
                #self.speed_x = -self.max_speed_x
            #elif keys[pygame.K_RIGHT]:
                #self.speed_x = self.max_speed_x

            if keys[pygame.K_SPACE]:
                if self.y >= 0:
                    self.speed_y = -self.max_speed_y
                else:
                    self.speed_y = 0
            #elif keys[pygame.K_DOWN]:
                #self.speed_y = self.max_speed_y

        def render(self, width, height, st, at):
            render = renpy.Render(width, height)

            # Figure out the time elapsed since the previous frame.
            if self.old_st is None:
                self.old_st = st

            dtime = st - self.old_st
            self.old_st = st

            self.check_overlap()

            self.move_player()

            speed_x = dtime * self.speed_x
            speed_y = dtime * self.speed_y

            self.x += speed_x
            self.y += speed_y

            self.displayable_render = renpy.render(
                self.displayable,
                width,
                height,
                st,
                at
            )

            # Drawing bullets in ShooterPlayer's render so they
            # implicitly get added to the screen
            for bullet in self.weapon.bullets:
                b = renpy.render(bullet, width, height, st, at)
                render.blit(b, (0, 0))

            renpy.redraw(self, 0)
            render.blit(self.displayable_render, (self.x, self.y))

            return render

        def event(self, ev, x, y, st):
            if ev.type == pygame.KEYUP:
                self.speed_x = 0
                self.speed_y = 0

            #elif ev.type == pygame.KEYDOWN:
                #if ev.key == pygame.K_SPACE:
                    #self.weapon.generate_bullets()

            if not self.alive:
                return False
            else:
                raise renpy.IgnoreEvent()

init python:
    import copy




    class ShooterWeapon(object):
        def __init__(self, player, bullet=None, *args, **kwargs):
            self.player = player
            self.bullet = bullet

            self.bullets = []
            self.max_bullets = 6

        def generate_bullets(self):
            # TODO: Don't create new bullet objects, recycle the existing ones.

            # If a bullet is dead, remove it from the list
            for item in self.bullets:
                if not item.alive:
                    self.bullets.remove(item)

            # If less than the max number of bullets allowed, add a new bullet
            if len(self.bullets) < (self.max_bullets - 1):
                self.bullet.x = self.player.x
                self.bullet.y = self.player.y
                self.bullets.append(copy.deepcopy(self.bullet))


    class ShooterBullet(ShooterActor):
        def __init__(self, displayable=None, speed=(0, 0), *args, **kwargs):
            super(ShooterBullet, self).__init__(
                displayable, speed, *args, **kwargs)

            self.alive = True

        def render(self, width, height, st, at):
            render = renpy.Render(width, height)

            # Figure out the time elapsed since the previous frame.
            if self.old_st is None:
                self.old_st = st

            dtime = st - self.old_st
            self.old_st = st

            speed_x = dtime * self.max_speed_x
            speed_y = dtime * self.max_speed_y

            self.x += speed_x
            self.y -= speed_y

            self.displayable_render = renpy.render(
                self.displayable,
                width,
                height,
                st,
                at
            )

            renpy.redraw(self, 0)
            render.blit(self.displayable_render, (self.x, self.y))

            # Kill bullets when they leave the screen
            self.alive = self.inside_bounds()

            return render


###script.rpy
default standard_bullet = ShooterBullet(Image("bullet.png"), speed=(300, 0))
default actor = ShooterPlayer(Image("actor.png"), bullet=standard_bullet, start=(1100, 100), speed=(300, 300))

default enemy1 = EnemyShooterActor(Image("enemy.png"), speed=(150, 0), start=(-950, 0))
default enemy2 = EnemyShooterActor(Image("enemy.png"), speed=(150, 0), start=(-900, 50))
default enemy3 = EnemyShooterActor(Image("enemy.png"), speed=(150, 0), start=(-850, 150))

default enemy4 = EnemyShooterActor(Image("enemy.png"), speed=(120, 0), start=(-950, 400))
default enemy5 = EnemyShooterActor(Image("enemy.png"), speed=(120, 0), start=(-900, 500))
default enemy6 = EnemyShooterActor(Image("enemy.png"), speed=(120, 0), start=(-850, 550))


default enemy_group = EnemyGroup(start=(980, 100), enemies=[enemy1, enemy2, enemy3, enemy4, enemy5, enemy6])

screen shooter_main():
    add actor

    for enemy in enemy_group.enemies:
        add enemy

label start:
    $ actor.enemies = [enemy1, enemy2, enemy3, enemy4, enemy5, enemy6]
    call screen shooter_main

    "Game Over"