示例#1
0
    def __init__(self):
        super( TestLayer, self ).__init__()

        x,y = director.get_window_size()
        assets = "../assets/"
        runner = pyglet.image.load(assets + 'runner.png')
        runner_seq = pyglet.image.ImageGrid(runner, 3, 9)
        anis = {}
        anis['W'] = Animation.from_image_sequence(runner_seq[9*2:9*2+3], 0.5)
        anis['w'] = Animation.from_image_sequence(runner_seq[9*2+3:9*2+6], 0.5)
        anis['U'] = Animation.from_image_sequence(runner_seq[9*2+6:9*2+8], 0.5)
        anis['D'] = runner_seq[9*2+8]
        anis['d'] = runner_seq[8]
        anis['R'] = Animation.from_image_sequence(runner_seq[9*0:9*0+3], 0.5)
        anis['r'] = Animation.from_image_sequence(runner_seq[9*0+3:9*0+6], 0.5)
        anis['H'] = runner_seq[9*0+6]
        anis['h'] = runner_seq[9*0+7]
        self.anis = anis

        self.ani_keys=['W','w','U','D','d','R','r','H','h']
        self.ani_idx = 0
        self.sprite = Sprite(anis[self.ani_keys[self.ani_idx]])
        #self.sprite = Sprite(runner_seq[8])
        self.sprite.position = x//3, y//3
        self.add( self.sprite  )
示例#2
0
    def __init__(self, x, y):
        super(Player, self).__init__('assets/runner1.png', x, y)
        self.speed_h = eu.Vector2(200, 0)
        self.speed_v = eu.Vector2(0, 200)

        assets = "assets/"
        runner = pyglet.image.load(assets + 'runner.png')
        self.runner_stand = pyglet.image.load(assets + 'runner1.png')
        runner_seq = pyglet.image.ImageGrid(runner, 3, 9)
        anis = {}
        dur = 0.01
        anis['W'] = Animation.from_image_sequence(runner_seq[9 * 2:9 * 2 + 3],
                                                  dur)
        anis['w'] = Animation.from_image_sequence(
            runner_seq[9 * 2 + 3:9 * 2 + 6], dur)
        anis['U'] = Animation.from_image_sequence(
            runner_seq[9 * 2 + 6:9 * 2 + 8], dur)
        anis['D'] = runner_seq[9 * 2 + 8]
        anis['d'] = runner_seq[8]
        anis['R'] = Animation.from_image_sequence(runner_seq[9 * 0:9 * 0 + 3],
                                                  dur)
        anis['r'] = Animation.from_image_sequence(
            runner_seq[9 * 0 + 3:9 * 0 + 6], dur)
        anis['H'] = runner_seq[9 * 0 + 6]
        anis['h'] = runner_seq[9 * 0 + 7]
        self.anis = anis

        self.last_move = ""
        self.move_act = {
            'd': self.anis['W'],
            'a': self.anis['w'],
            'w': self.anis['U'],
            's': self.runner_stand
        }
示例#3
0
    def __init__(self):
        super(TestLayer, self).__init__()

        x, y = director.get_window_size()
        assets = "../assets/"
        hole_img = pyglet.image.load(assets + 'hole.png')
        hole_seq1 = pyglet.image.ImageGrid(hole_img, 2, 9)
        hole_seq2 = pyglet.image.ImageGrid(hole_img, 4, 9)
        anis = {}
        anis['T'] = Animation.from_image_sequence(hole_seq1[9 * 0:9 * 0 + 9],
                                                  0.1)
        anis['t'] = Animation.from_image_sequence(hole_seq1[9 * 1:9 * 1 + 9],
                                                  0.1)
        flats = []
        flats.append(hole_seq2[9 * 2 + 8])
        flats.append(hole_seq2[9 * 3 + 8])
        flats.append(hole_seq2[9 * 0 + 8])
        anis['F'] = Animation.from_image_sequence(flats, 1)

        self.anis = anis

        self.ani_keys = ['T', 't', 'F']
        self.ani_idx = 0
        self.sprite = Sprite(anis[self.ani_keys[self.ani_idx]])
        #self.sprite = Sprite(runner_seq[8])
        self.sprite.position = x // 3, y // 3
        self.add(self.sprite)
示例#4
0
 def set_animation(self, item={}):
     '''设置动画'''
     image = pyglet.resource.image(item['file'])
     img_seq = pyglet.image.ImageGrid(image, item['rows'], 1)
     for img in img_seq:
         self.set_image_center(img)
     self.alive_img = Animation.from_image_sequence(img_seq[:3:-1], 0.2)
     self.dead_img = Animation.from_image_sequence(img_seq[3::-1], 0.2)
示例#5
0
def load_sprites(filename, row, col, grid_mapping):
    grid = TextureGrid(ImageGrid(load_image(filename), row, col))
    sprites = {}
    index = 0

    for item in grid_mapping:
        if isinstance(item, Img):
            grid_index = get_grid_index(index, row, col)
            sprites[item.name] = grid[grid_index]
            index += 1
        elif isinstance(item, Anim):
            sprites[item.name] = Animation.from_image_sequence(
                [
                    grid[get_grid_index(index + offset, row, col)]
                    for offset in range(item.nb_frame)
                ],
                item.period,
                item.loop,
            )
            index += item.nb_frame
        elif isinstance(item, Skip):
            index += item.skip_nb
        else:
            raise WrongGridMappingError(item)

    return sprites
示例#6
0
    def explode(self):
        # 停止前行
        self.stop_move()
        # 精灵图片
        animation = Animation.from_image_sequence(
            map(
                lambda x: pyglet.resource.image('imgs/enemy/enemy_small%d.png'
                                                % x),
                [x for x in range(2, 5)]), 0.05, False)
        self.image = animation
        # 播放音效
        audio.pygame.mixer.init()
        sound = audio.pygame.mixer.Sound('sounds/enemy_die.ogg')
        sound.play(0, 0)

        # 消失
        def disppear(dt):
            self.position = -10, -10
            self.cshape.center = collision.eu.Vector2(-10, -10)
            # 发送重用敌机的事件
            fj_event_dispatcher.dispatch_event('on_small_enemy_reuseable',
                                               self)
            self.unschedule(disppear)

        self.schedule_interval(disppear, 0.15)
示例#7
0
 def make_sprite(self):
     img  = self.game.load_image('smoke.png')
     grid = list(pyglet.image.ImageGrid(img, 1, 8))
     [(pixelate(g), center_image(g)) for g in grid]
     ani = Animation.from_image_sequence(grid, 0.1, loop=False)
     sprite = pyglet.sprite.Sprite(ani, batch=self.game.effect_batch)
     sprite.position = map(int, self.position)
     sprite.scale = 2
     return sprite
示例#8
0
 def __init__(self, src: str, background: tuple = None, speed: Union[int, float] = 1, damage: Union[int, float] = 1,
              acceleration: Union[int, float] = 0, animated: bool = False, animation_rows: int = None,
              animation_columns: int = None,
              animation_item_width: int = None, animation_item_height: int = None, animation_period: float = 0.1,
              animation_main_frame: int = 0, *args, **kwargs) -> None:
     """
     :param src:                     File of the image to load
     :param background:              A tuple representing RGBA values for the background
     :param speed:                   Speed at which the projectile will move
     :param damage:                  Damage the projectile will deal
     :param acceleration:            Acceleration in m/s^2
     :param animated:                Flag saying if the projectile uses an animation
     :param animation_rows:          The number of rows in the animation sequence source
     :param animation_columns:       The number of columns in the animation sequence source
     :param animation_item_width:    The width of each frame of the animation in the source
     :param animation_item_height:   The height of each frame in the source
     :param animation_period:        Time to show each frame
     :param animation_main_frame:    The frame in which the hitbox bounds will be calculated
     :param args:
     :param kwargs:
     """
     if animated:
         image = load(src)
         image_seq = ImageGrid(image, rows=animation_rows, columns=animation_columns,
                               item_width=animation_item_width, item_height=animation_item_height)
         image_texture = TextureGrid(image_seq)
         img = Animation.from_image_sequence(image_texture[0:], period=animation_period, loop=True)
         # self.src =
         image_array = cv.imread(src)
         x1 = animation_item_width * animation_main_frame
         x2 = x1 + animation_item_width
         self.np = image_array[:, x1:x2]  # The numpy array used for the collision test will be the slice
     else:
         img = load(src)
         self.np = cv.imread(src)  # The whole image will be read
     self.src = img
     self.background = background
     self.speed = speed
     self.acceleration = acceleration
     self.damage = damage
     super().__init__(img, *args, **kwargs)
     self.radians = 0
     # self.anchor
     if animated:
         for frame in self.image.frames:
             frame.image.anchor_x = image.width / animation_columns / 2
             frame.image.anchor_y = image.height / animation_rows / 2
     else:
         self.image.anchor_x = self.image.width / 2
         self.image.anchor_y = self.image.height / 2
     self.init_time = time.time()
     self.update(x=self.x, y=self.y)
     self.refresh_threshold()
     if self.background:
         self.rectangle = Rectangle(x=self.get_left_bound(), y=self.get_bot_bound(), width=self.width,
                                    height=self.height, color=self.background)
示例#9
0
 def make_sprite(self):
     img  = self.game.load_image('firebolt.png')
     grid = list(pyglet.image.ImageGrid(img, 1, 5))
     [(pixelate(g), center_image(g)) for g in grid]
     ani = Animation.from_image_sequence(grid, 0.05)
     sprite = pyglet.sprite.Sprite(ani, batch=self.game.object_batch)
     sprite.position = map(int, self.position)
     sprite.rotation = self.rotation
     sprite.scale = 2
     return sprite
示例#10
0
    def explode(self):
        self.unschedule(self.run_enemy)

        frames = []
        for x in range(2, 5):
            texure = pyglet.resource.image('img/enemy/enemy_small%d.png' % x)
            frames.append(texure)
        anim = Animation.from_image_sequence(frames, 0.05, False)
        self.image = anim

        self.schedule_interval(self._prepare_to_use, 0.15)
示例#11
0
 def init_image(self):
     frames = []
     for x in range(1, 3):
         texure = pyglet.resource.image('img/hero/hero%d.png' % x)
         frames.append(texure)
     anim = Animation.from_image_sequence(frames, 0.05)
     super(Hero, self).__init__(anim)
     self.scale = 0.5
     self.position = config.WINDOS_WIDTH // 2, 200
     self.cshape = collision.AARectShape(
         collision.eu.Vector2(*self.position), self.width // 4,
         self.height // 4)
示例#12
0
    def explode(self):
        frames = []
        for x in range(3, 6):
            texure = pyglet.resource.image('img/hero/hero%d.png' % x)
            frames.append(texure)
        anim = Animation.from_image_sequence(frames, 0.05, False)
        self.image = anim

        sound = pygame.mixer.Sound('sounds/hero_die.ogg')
        sound.play()

        self.schedule_interval(self._game_over, 1)
示例#13
0
 def __init__(self, p_level, *args, **kws):
     self.anim_default = Animation.from_image_sequence(ImageGrid(load(fp(
                 self.image_file)), 1, 1), 5, True)
     applyAnchor(self.anim_default, 25, 0)
     self.anim_default_left = self.anim_default.get_transform(True)
     super(Character, self).__init__(self.anim_default, *args, **kws)
     self.p_level = p_level
     self.movement = None
     self.keys = None
     self.velocity_y = 0
     self.touch_ground = True
     self.orientation_right = True
示例#14
0
文件: p2-4.py 项目: cometwk/myblog
    def __init__(self, descfile):
        str = self.readStrFromFile(descfile + '.desc')
        desc = json.loads(str)

        texture = image.load(desc["name"] + '.png')
        list = []
        for w in desc["frames"] :
            frame = texture.get_region(w["x"], w["y"], w["width"], 64) # TODO: 64 修改为 desc 的坐标有些问题, TODO
            list.append(frame)
        period = 0.2 # TODO: 参数

        self.animation = Animation.from_image_sequence(list, period, False)
 def collide(self, node):
     if node is not None:
         for other in self.man_col.iter_colliding(node):
             if self.children.count((1, other)) != 0:
                 other.kill()
                 if isinstance(other, Enemigo):
                     self.HUD.puntos += 10
                     self.HUD.update()
             if self.children.count((1, node)) != 0:
                 node.kill()
             seq = ImageGrid(load('Explosion.png'), 1, 1)
             anim = Animation.from_image_sequence(seq, 0.05, False)
             self.sprite = Sprite(anim, (other.x, other.y))
             self.add(self.sprite)
             self.do(Delay(0.8) + CallFunc(self.sprite.kill))
示例#16
0
    def die_action(self):
        # 改变被撞的精灵图片
        image = Animation.from_image_sequence(
            map(lambda x: pyglet.resource.image('imgs/hero/hero%d.png' % x),
                [x for x in range(3, 6)]), 0.05, False)
        self.image = image

        # 停止发射
        self.stop_fire()

        # 播放爆炸的声音
        audio.pygame.mixer.init()
        sound = audio.pygame.mixer.Sound('sounds/hero_die.ogg')
        sound.play(0, 0)

        # 闪几下后消失
        self.do(actions.Blink(2, 1) + actions.Hide())
示例#17
0
    def __init__(self, p_level, *args, **kws):
        super(Player, self).__init__(p_level, *args, **kws)
        ig_step = ImageGrid(load(fp('panda_bounce_test.png')), 1, 7)
        self.animation = self.anim_default
        self.anim_step_right = Animation.from_image_sequence(
                                ig_step, 0.1, True) 
        applyAnchor(self.anim_step_right, 25, 0)
        self.anim_step_left = self.anim_step_right.get_transform(True)
        # Convenience class for key handling, pushed to window
        self.keys = key.KeyStateHandler()
        self.default_movement = DefaultMove(self)
        self.movement = self.default_movement

        self.collision_box = property(self.get_collision_box, None)
        self.attack_box = property(self.get_attack_box, None)

        self.init()
示例#18
0
    def load_textures(self):
        img = self.game.load_image('player.png')
        grid = pyglet.image.ImageGrid(img, 4, 4)
        for img in grid:
            pixelate(img)
            img.width  *= 2
            img.height *= 2
            center_image(img, 0.5, 0.3)

        self.ani_running = {}
        self.ani_standing = {}
        for row, name in enumerate(('up','right','left','down')):
            ani_run   = [grid[row*4+col] for col in (1,2,3,2)]
            img_stand = grid[row*4+0]
            self.ani_running[name] = Animation.from_image_sequence(ani_run, 0.15)
            self.ani_standing[name] = img_stand

        self.sprite = pyglet.sprite.Sprite(self.ani_standing['down'], batch=self.game.object_batch)
        self.sprite.position = self.position
        self.moves = False
示例#19
0
    def __init__(self):
        image = Animation.from_image_sequence(
            map(lambda x: pyglet.resource.image('imgs/hero/hero%d.png' % x),
                [x for x in range(1, 3)]), 0.05, True)
        super(Hero, self).__init__(image)
        self.scale = 0.5
        self.position = config.WIN_WIDTH // 2, 70
        self._alive = True

        # 精灵batch
        self.batch_bullets = batch.BatchNode()
        self.all_bullets = set()
        self.active_bullets = set()
        self.reuse_bullets = set()

        # cshape
        self.cshape = collision.AARectShape(
            collision.eu.Vector2(*self.position), self.width // 2,
            self.height // 2)

        # 事件调度
        self.schedule_interval(self.fire, 0.2)
示例#20
0
class Image:
    resource.path.append("../res/image")
    resource.reindex()

    try:
        background = resource.image("background.png")
        menu = resource.image("menu.png")
        mario = resource.image("mario.png")
        sprite_set = resource.image("sprite_set.png")
    except resource.ResourceNotFoundException:
        raise SystemExit("cannot find images!")

    sprite_set_small = ImageGrid(sprite_set, 20, 20)
    sprite_set_big = ImageGrid(sprite_set, 10, 20)

    # mario
    mario_walk_right_small = [sprite_set_small[(18, 0)], sprite_set_small[(18, 1)], sprite_set_small[(18, 2)]]
    mario_walk_left_small = [image.get_transform(flip_x=True) for image in mario_walk_right_small]

    mario_walk_right_big = [sprite_set_big[(8, 0)], sprite_set_big[(8, 1)], sprite_set_big[(8, 2)]]
    mario_walk_left_big = [image.get_transform(flip_x=True) for image in mario_walk_right_big]

    mario_walk_right_fire = [sprite_set_big[(7, 0)], sprite_set_big[(7, 1)], sprite_set_big[(7, 2)]]
    mario_walk_left_fire = [image.get_transform(flip_x=True) for image in mario_walk_right_fire]

    mario_walk = [[mario_walk_right_small, mario_walk_left_small],
                  [mario_walk_right_big, mario_walk_left_big],
                  [mario_walk_right_fire, mario_walk_left_fire]]

    mario_jump_right_small = sprite_set_small[(18, 4)]
    mario_jump_left_small = mario_jump_right_small.get_transform(flip_x=True)

    mario_jump_right_big = sprite_set_big[(8, 4)]
    mario_jump_left_big = mario_jump_right_big.get_transform(flip_x=True)

    mario_jump_right_fire = sprite_set_big[(7, 4)]
    mario_jump_left_fire = mario_jump_right_fire.get_transform(flip_x=True)

    mario_jump = [[mario_jump_right_small, mario_jump_left_small],
                  [mario_jump_right_big, mario_jump_left_big],
                  [mario_jump_right_fire, mario_jump_left_fire]]

    mario_stand_right_small = sprite_set_small[(18, 6)]
    mario_stand_left_small = mario_stand_right_small.get_transform(flip_x=True)

    mario_stand_right_big = sprite_set_big[(8, 6)]
    mario_stand_left_big = mario_stand_right_big.get_transform(flip_x=True)

    mario_stand_right_fire = sprite_set_big[(7, 6)]
    mario_stand_left_fire = mario_stand_right_fire.get_transform(flip_x=True)

    mario_stand = [[mario_stand_right_small, mario_stand_left_small],
                   [mario_stand_right_big, mario_stand_left_big],
                   [mario_stand_right_fire, mario_stand_left_fire]]

    mario_die = sprite_set_small[(18, 5)]

    mario_walk_to_castle = [Animation.from_image_sequence(mario_walk_right_small, 0.1),
                            Animation.from_image_sequence(mario_walk_right_big, 0.1),
                            Animation.from_image_sequence(mario_walk_right_fire, 0.1)]

    mario_lower_flag_small = [sprite_set_small[(18, 7)], sprite_set_small[(18, 8)]]
    mario_lower_flag_big = [sprite_set_big[(8, 7)], sprite_set_big[(8, 8)]]
    mario_lower_flag_fire = [sprite_set_big[(7, 7)], sprite_set_big[(7, 8)]]

    mario_lower_flag = [Animation.from_image_sequence(mario_lower_flag_small, 0.2),
                        Animation.from_image_sequence(mario_lower_flag_big, 0.2),
                        Animation.from_image_sequence(mario_lower_flag_fire, 0.2)]

    mario_lower_flag_turn_around = [sprite_set_small[(18, 8)].get_transform(flip_x=True),
                                    sprite_set_big[(8, 8)].get_transform(flip_x=True),
                                    sprite_set_big[(7, 8)].get_transform(flip_x=True)]

    # prop
    normal_mushroom = sprite_set_small[(7, 0)]
    life_mushroom = sprite_set_small[(7, 1)]

    frames = [sprite_set_small[(5, 0)], sprite_set_small[(5, 1)]]
    fire_flower_blink = Animation.from_image_sequence(frames, 0.3)

    # enemy
    frames = [sprite_set_small[(10, 7)], sprite_set_small[(10, 8)]]
    goomba_move = Animation.from_image_sequence(frames, 0.3)
    goomba_die = sprite_set_small[(10, 9)]

    frames = [sprite_set_big[(5, 0)], sprite_set_big[(5, 1)]]
    koopa_move = Animation.from_image_sequence(frames, 0.3)
    koopa_die = sprite_set_small[(10, 4)]

    # others
    # cliff is a total transparent image
    cliff = sprite_set_small[(2, 2)]

    coin = sprite_set_big[(3, 4)]

    flag = sprite_set_small[(0, 0)]
    castle_flag = sprite_set_small[(2, 0)]

    normal_brick = sprite_set_small[(0, 3)]
    unknown_brick = sprite_set_small[(0, 6)]

    try:
        normal_brick2 = load("../res/image/brick.png")
    except Exception as e:
        raise SystemExit(e)
示例#21
0
'''
程序:动画演示
作者:苏秦@小海豚科学馆公众号
来源:图书《Python趣味编程:从入门到人工智能》
'''
import pyglet
from pyglet.image import ImageGrid
from pyglet.image import Animation

game_win = pyglet.window.Window(width=1024, height=768)
image = pyglet.resource.image('fish2.png')

img_seq = ImageGrid(image, 8, 1)
print(len(img_seq))
animation = Animation.from_image_sequence(img_seq[:3:-1], 0.2)
fish = pyglet.sprite.Sprite(animation, 500, 300)


@game_win.event
def on_draw():
    game_win.clear()
    img_seq[0].blit(0, 0)
    fish.draw()


if __name__ == '__main__':
    pyglet.app.run()
示例#22
0
class Wyvern(cocos.layer.Layer):
    gravity = -9.8
    secondsPerFrame = 0.075

    # Create a texture atlas from the individual frames of the wyvern animations
    wyvernBin = pyglet.image.atlas.TextureBin()
    wyvernTextures = []
    for i in range(0, 24):
        name = "images/wyvernNE{}.png".format(i)
        wyvernTextures.append(wyvernBin.add(pyglet.image.load(name)))

    wyvernsTextures = []
    for i in range(0, 24):
        names = "images/wyvernsNE{}.png".format(i)
        wyvernsTextures.append(wyvernBin.add(pyglet.image.load(names)))

    #############################################################################
    animation = {
        'hover':
        Anim.from_image_sequence(wyvernTextures[0:8],
                                 secondsPerFrame,
                                 loop=True),
        'fly':
        Anim.from_image_sequence(wyvernTextures[8:16],
                                 secondsPerFrame,
                                 loop=True),
        'die':
        Anim.from_image_sequence(wyvernTextures[16:24],
                                 secondsPerFrame,
                                 loop=False),
    }
    animations = {
        'hover':
        Anim.from_image_sequence(wyvernsTextures[0:8],
                                 secondsPerFrame,
                                 loop=True),
        'fly':
        Anim.from_image_sequence(wyvernsTextures[8:16],
                                 secondsPerFrame,
                                 loop=True),
        'die':
        Anim.from_image_sequence(wyvernsTextures[16:24],
                                 secondsPerFrame,
                                 loop=False),
    }

    #############################################################################
    def __init__(self):
        """ Constructor """
        super(Wyvern, self).__init__()
        self.altitude = 0
        self.verticalVelocity = 0
        self.horizontalVelocity = 0
        self.lateralVelocity = 0
        self.sprite = cocos.sprite.Sprite(Wyvern.animation['hover'])
        self.sprite.position = 200, 80 + self.altitude
        self.sprites = cocos.sprite.Sprite(Wyvern.animations['hover'])
        self.sprites.position = 200, 100
        self.mapPosition = (4, 0, 0)
        self.animationName = 'hover'
        self.sprite.image = Wyvern.animation[self.animationName]
        self.sprites.image = Wyvern.animations[self.animationName]
        self.isDead = False

    #############################################################################
    def moveLeft(self):
        if not self.isDead:
            self.lateralVelocity -= 0.1

    #############################################################################
    def moveRight(self):
        if not self.isDead:
            self.lateralVelocity += 0.1

    #############################################################################
    def flap(self):
        if not self.isDead:
            self.verticalVelocity += 3
            self.horizontalVelocity = min(0.3, self.horizontalVelocity + 0.02)

    #############################################################################
    def respawn(self):
        self.isDead = False

    #############################################################################
    def update(self, dt):
        self.verticalVelocity = self.verticalVelocity + Wyvern.gravity * dt
        self.altitude += self.verticalVelocity

        if self.altitude <= 0:
            self.altitude = 0
            self.verticalVelocity = 0
            self.horizontalVelocity = max(0, self.horizontalVelocity - 0.1)
        elif self.altitude > 500:
            self.altitude = 500
            self.verticalVelocity = 0

        x, y, z = self.mapPosition
        x = min(max(-1.0, x + self.lateralVelocity), 6.0)
        self.lateralVelocity *= 0.9  # make lateralVelocity decay
        y = self.altitude / 96
        z += self.horizontalVelocity
        self.mapPosition = (x, y, z)
        self.sprite.position = Map.Map.positionForMapPosition(x, y, z)
        self.sprites.position = Map.Map.positionForMapPosition(x, 0, z)

        if self.isDead:
            if self.animationName != 'die':
                self.animationName = 'die'
                self.sprite.image = Wyvern.animation[self.animationName]
                self.sprites.image = Wyvern.animations[self.animationName]

        elif self.horizontalVelocity < 0.05:
            if self.animationName != 'hover':
                self.animationName = 'hover'
                self.sprite.image = Wyvern.animation[self.animationName]
                self.sprites.image = Wyvern.animations[self.animationName]

        elif self.animationName != 'fly':
            self.animationName = 'fly'
            self.sprite.image = Wyvern.animation[self.animationName]
            self.sprites.image = Wyvern.animations[self.animationName]
    def __init__(self, enable_neat=False, *args, **kwargs):
        # Inherit the pyglet window
        super().__init__(*args, **kwargs)

        # Save the configuration that determines if the NEAT algorithm is used
        self.enable_neat = enable_neat

        # Generate the font style
        pyglet.font.add_file('data/fonts/press_start_2p.ttf')
        pyglet.font.load("Press Start 2P")

        # Save and draw the FPS
        self.frame_rate = 1/60
        self.fps_display = FPSDisplay(self)
        self.fps_display.label.x = self.width - 10
        self.fps_display.label.y = 10
        self.fps_display.label.anchor_x = "right"
        self.fps_display.label.font_name = "Press Start 2P"
        self.fps_display.label.font_size = 20
        self.fps_display.label.color = (192, 192, 192, 192)

        # Set the FPS
        pyglet.clock.schedule_interval(self.update, self.frame_rate)

        # Control the horizontal velocity of the obstacles
        self.obstacle_velx = -600

        # Create batches
        self.bg_batch = pyglet.graphics.Batch()
        self.main_batch = pyglet.graphics.Batch()
        if self.enable_neat:
            self.neat_batch = pyglet.graphics.Batch()
        else:
            self.game_over_batch = pyglet.graphics.Batch()

        # Preload the images into memory and save them
        game_sprites = self.preload_image("sprites.png")
        self.terrain_img = game_sprites.get_region(2, 0, 2402, 27)
        self.dinosaur_run_animation = Animation.from_image_sequence(
            ImageGrid(
                game_sprites.get_region(1854, 33, 176, 95),
                1,
                2,
                item_width=88,
                item_height=96
            ),
            0.3,
            loop=True
        )
        self.dinosaur_duck_animation = Animation.from_image_sequence(
            ImageGrid(
                game_sprites.get_region(2203, 33, 240, 61),
                1,
                2,
                item_width=118,
                item_height=62
            ),
            0.3,
            loop=True
        )
        self.dinosaur_jump_img = game_sprites.get_region(1678, 33, 88, 95)
        self.dinosaur_collision_img = game_sprites.get_region(2030, 33, 88, 95)
        self.cacti_imgs = (
            game_sprites.get_region(446, 58, 34, 70),  # Small cacti 1
            game_sprites.get_region(480, 58, 68, 70),  # Small cacti 2
            game_sprites.get_region(548, 58, 102, 70), # Small cacti 3
            game_sprites.get_region(652, 32, 50, 98),  # Large cacti 1
            game_sprites.get_region(702, 32, 100, 98), # Large cacti 2
            game_sprites.get_region(802, 30, 150, 98), # Large cacti 3

        )
        self.bird_animation = Animation.from_image_sequence(
            ImageGrid(
                game_sprites.get_region(260, 48, 184, 80),
                1, 2, item_width=92, item_height=80
            ),
            0.3,
            loop=True
        )
        self.cloud_img = game_sprites.get_region(165, 100, 95, 28)
        self.moon_phases = cycle((
            game_sprites.get_region(1234, 47, 40, 82),
            game_sprites.get_region(1194, 47, 40, 82),
            game_sprites.get_region(1154, 47, 40, 82),
            game_sprites.get_region(1074, 47, 80, 82),
            game_sprites.get_region(1034, 47, 40, 82),
            game_sprites.get_region(994, 47, 40, 82),
            game_sprites.get_region(954, 47, 40, 82)
        ))
        self.reset_button_img = game_sprites.get_region(2, 63, 72, 65)

        # Score and label
        self.score = 0
        self.score_label = pyglet.text.Label(
            f"{self.score:05}",
            font_name="Press Start 2P",
            font_size=20,
            x=self.width - 10,
            y=self.height - 10,
            anchor_x="right",
            anchor_y="top",
            batch=self.bg_batch
        )

        # Game over label (only if the user plays the game manually)
        if not self.enable_neat:
            self.game_over_label = pyglet.text.Label(
                "G A M E  O V E R",
                font_name="Press Start 2P",
                font_size=30,
                x=self.width / 2,
                y=self.height / 2 + 100,
                anchor_x="center",
                anchor_y="center",
                batch=self.game_over_batch
            )
        
        # Initialize the sprites
        self.terrain_1 = GameSprite(
            self.terrain_img,
            0,
            50,
            velx=self.obstacle_velx,
            batch=self.bg_batch
        )
        self.terrain_2 = GameSprite(
            self.terrain_img,
            2400,
            50,
            velx=self.obstacle_velx,
            batch=self.bg_batch
        )
        self.moon = GameSprite(next(self.moon_phases), 2920, 275, velx=-20, batch=self.main_batch)
        self.clouds = [] # Elements will be randomly generated as the game progresses
        self.obstacles = [] # Elements will be randomly generated as the game progresses
        
        # Reset button is only available when the user plays manually
        if not self.enable_neat:
            self.reset_button = GameSprite(
                self.reset_button_img,
                564,
                150,
                batch=self.game_over_batch
            )
        
        # Generate the user's dinosaur if the user plays manually
        if not self.enable_neat:
            self.dinosaur = Dinosaur(self.dinosaur_run_animation, 65, 45, batch=self.main_batch)

            # Set variables to track user inputs
            self.trigger_duck = False
            self.trigger_jump = False

            # Keep track of any user collisions
            self.user_collision = False

        # Add a delays to control when events happen
        self.next_score_increment = 0.1
        self.next_cloud_spawn = 3 * random() + 1
        self.next_obstacle_spawn = 2 * random() + 1
        self.next_velocity_increase = 1

        # Set up the NEAT algorithm if true. Otherwise, let the user play manually
        if self.enable_neat:
            # Locate the NEAT configuration file
            config_file = os.path.join(os.path.dirname(__file__), 'config-feedforward.txt')

            # Configure the NEAT algorithm
            config = neat.config.Config(
                neat.DefaultGenome,
                neat.DefaultReproduction,
                neat.DefaultSpeciesSet,
                neat.DefaultStagnation,
                config_file
            )

            # Generate the population
            population = neat.Population(config)

            # Add a reporter to show progress in the terminal
            population.add_reporter(neat.StdOutReporter(True))
            population.add_reporter(neat.StatisticsReporter())

            # Generation label
            self.generation = -1
            self.generation_label = pyglet.text.Label(
                f"GENERATION: {self.generation:02}",
                font_name="Press Start 2P",
                font_size=20,
                x=10,
                y=self.height - 10,
                anchor_x="left",
                anchor_y="top",
                batch=self.neat_batch
            )

            # Number of dinosaurs label
            self.number_of_dinosaurs = 0
            self.number_of_dinosaurs_label = pyglet.text.Label(
                f"DINOSAURS: {self.number_of_dinosaurs:03}",
                font_name="Press Start 2P",
                font_size=20,
                x=10,
                y=self.height - 40,
                anchor_x="left",
                anchor_y="top",
                batch=self.neat_batch
            )
            # Run the NEAT algorithm and find the best "player"
            winner = population.run(self.eval_genomes, 25)
        else:
            # Run the main loop and play the game manually
            pyglet.app.run()
示例#24
0
 def __init__(self, seq, row, *args, **kwargs):
     super(Enemy, self).__init__(Sprite(Animation.from_image_sequence(seq, ENEMY_ANIM_SPEED), *args, **kwargs))
     self.direction = 'right'
     self.row = row
     self.game.objects.append(self)
示例#25
0
 def load_animation(imgage):
     """
     Animation for each image
     """
     seq = ImageGrid(load(imgage), 2, 1)
     return Animation.from_image_sequence(seq, 0.5)
示例#26
0
 def set_animation(self, score):
     '''设置动画'''
     image = silver_coin_img if score <= 20 else gold_coin_img
     coin_seq = pyglet.image.ImageGrid(image, 10, 1)
     self.coin_img = Animation.from_image_sequence(coin_seq, 0.02)
     self.set_image_center(self.coin_img)
示例#27
0
import math

import cocos.sprite
import cocos.audio
import cocos.actions as ac
import cocos.euclid as eu
import cocos.collision_model as cm

import pyglet.image
from pyglet.image import Animation

raw = pyglet.image.load('assets/explosion.png')
seq = pyglet.image.ImageGrid(raw, 1, 8)
explosion_img = Animation.from_image_sequence(seq, 0.07, False)


class Explosion(cocos.sprite.Sprite):
    def __init__(self, pos):
        super(Explosion, self).__init__(explosion_img, pos)
        self.do(ac.Delay(1) + ac.CallFunc(self.kill))


class Shoot(cocos.sprite.Sprite):
    def __init__(self, pos, offset, target):
        super(Shoot, self).__init__('shoot.png', position=pos)
        self.do(ac.MoveBy(offset, 0.1) +
                ac.CallFunc(self.kill) +
                ac.CallFunc(target.hit))


class Hit(ac.IntervalAction):
示例#28
0
def load_animation(img, x, y, loop):
    raw = pyglet.image.load(img)
    seq = pyglet.image.ImageGrid(raw, x, y)
    return Animation.from_image_sequence(seq, 0.25, loop)
示例#29
0
 def __init__(self, res_img_path_seq: List[ResourceImage], duration: float=1/20, loop: bool=True):
     self.path_seq = [res.path for res in res_img_path_seq]
     self.duration = duration
     self.loop = loop
     self.animation = Animation.from_image_sequence(sequence=[res.img for res in res_img_path_seq], duration=self.duration, loop=self.loop)
示例#30
0
image_paths = glob.glob(pathname="resources/*R.png")
image_paths.sort()
# Create pigboy animation
pigboy_imgs = []
for path in image_paths:
    path = os.path.basename(path)
    img = pyglet.resource.image(path)
    img.anchor_x = img.width // 2
    img.anchor_y = img.height // 2
    pigboy_imgs.append(pyglet.resource.image(path))

pigboy_imgsL = []
for img in pigboy_imgs:
    pigboy_imgsL.append(img.get_transform(flip_x=True))

pigboy_animationR = Animation.from_image_sequence(pigboy_imgs, 1/20.0)
pigboy_animationL = Animation.from_image_sequence(pigboy_imgsL, 1/20.0)

# Pig lives image
pig_heart = pyglet.resource.image("extras/pig_heart.png")

### Platform Resources ###
pltfm_short_grass = pyglet.resource.image("platform_grass.png")
pltfm_short_grass.anchor_x = pltfm_short_grass.width // 2
pltfm_short_grass.anchor_y = pltfm_short_grass.height // 2

### Enemy Class ###
enemy_ghostL = pyglet.resource.image("enemies/enemyL0.png")
enemy_ghostL.anchor_x = enemy_ghostL.width // 2
enemy_ghostL.anchor_y = enemy_ghostL.height // 2
enemy_ghostR = enemy_ghostL.get_transform(flip_x=True)
示例#31
0
 def load_animation(image):
     seq = ImageGrid(load(image), 2, 1)
     return Animation.from_image_sequence(seq, 0.5)
示例#32
0
import pyglet
from pyglet_utils.tutorial import resources
from pyglet.window import Window
from pyglet.image import Animation
from pyglet.sprite import Sprite

# Create and open a window
window = Window(width=500, height=500, caption='Bird Atlas')

bird_anim = Animation.from_image_sequence(sequence=resources.bird_seq,
                                          duration=1 / 20,
                                          loop=True)
bird_sprite = Sprite(img=bird_anim, x=50, y=150)
bird_sprite.scale = 2


@window.event
def on_draw():
    window.clear()
    bird_sprite.draw()


if __name__ == '__main__':
    pyglet.app.run()
示例#33
0
 def load_animation(self, imgage, delay):
     seq = ImageGrid(load(imgage), 1, 6)
     return Animation.from_image_sequence(seq, delay, loop=False)
示例#34
0
 def load_animation(imgage):
     seq = ImageGrid(load(imgage), 2, 1)
     return Animation.from_image_sequence(seq, 0.5)
 def load_animation(imgage):  #載入動畫
     seq = ImageGrid(load(imgage), 2, 1)  #載入一個圖片網格
     return Animation.from_image_sequence(seq, 0.5)  #每0.5秒變換一次圖片
示例#36
0
class Hit(ac.IntervalAction):
    # runs for 0.5 seconds
    def init(self, duration=0.5):
        self.duration = duration

    # called several times with t in the (0, 1) range
    # t is the percent of the duration that has elapsed
    def update(self, t):
        # Red overlay gradually fades as t gets closer to 1
        self.target.color = (255, 255 * t, 255 * t)


# load this outside a class/function so it only happens once
raw = pyglet.image.load('assets/explosion.png')
seq = pyglet.image.ImageGrid(raw, 1, 8)
explosion_img = Animation.from_image_sequence(seq, 0.07, False)


# just a sprite, not an actor
class Explosion(cocos.sprite.Sprite):
    def __init__(self, pos):
        super(Explosion, self).__init__(explosion_img, pos)
        self.do(ac.Delay(1) + ac.CallFunc(self.kill))


class Enemy(Actor):
    # initial position and actions come from Scenario
    def __init__(self, x, y, actions):
        super(Enemy, self).__init__('tank.png', x, y)
        self.health = 100
        self.points = 20
示例#37
0
def load_animation(image):
    # 2 rows, 1 column on sprite sheet
    seq = ImageGrid(load(image), 2, 1)
    # show each image for half a second
    return Animation.from_image_sequence(seq, 0.5)
示例#38
0
class Resources(ABC):
	pyglet.options['audio'] = ('openal', 'pulse', 'directsound', 'silent')
	audioPath = "res/audio/"

	pyglet.font.add_file("res/font.ttf")

	# gameOverMusic = pyglet.media.load(audioPath + "", streaming=False)

	owMusic = pyglet.media.load(audioPath + "ow.wav", streaming=False)
	owMusicFast = pyglet.media.load(audioPath + "ow_fast.wav", streaming=False)
	ugMusic = pyglet.media.load(audioPath + "ug.wav", streaming=False)
	ugMusicFast = pyglet.media.load(audioPath + "ug_fast.wav", streaming=False)
	jumpSmall = pyglet.media.load(audioPath + "jump_small.wav", streaming=False)
	jumpSuper = pyglet.media.load(audioPath + "jump_super.wav", streaming=False)
	breakblock = pyglet.media.load(audioPath + "breakblock.wav", streaming=False)

	stomp = pyglet.media.load(audioPath + "stomp.wav", streaming=False)
	kick = pyglet.media.load(audioPath + "kick.wav", streaming=False)
	bump = pyglet.media.load(audioPath + "bump.wav", streaming=False)

	coin = pyglet.media.load(audioPath + "coin.wav", streaming=False)
	fireball = pyglet.media.load(audioPath + "fireball.wav", streaming=False)

	powerupAppears = pyglet.media.load(audioPath + "powerup_appears.wav", streaming=False)
	powerup = pyglet.media.load(audioPath + "powerup.wav", streaming=False)
	powerdown = pyglet.media.load(audioPath + "powerdown.wav", streaming=False)

	flagpole = pyglet.media.load(audioPath + "flagpole.wav", streaming=False)

	mariodie = pyglet.media.load(audioPath + "mariodie.wav", streaming=False)
	hurryUp = pyglet.media.load(audioPath + "hurry_up.wav", streaming=False)

	oneup = pyglet.media.load(audioPath + "1_up.wav", streaming=False)
	star = pyglet.media.load(audioPath + "starlong.wav", streaming=False)

	bgMusic = None

	###

	spritesPath = "res/sprites/"

	playerSmallSize = Vector2(16, 16)
	playerBigSize = Vector2(16, 32)
	enemySmallSize = Vector2(16, 16)
	enemyBigSize = Vector2(16, 24)
	fireBallSize = Vector2(8, 8)
	fireBallExplosionSize = Vector2(16, 16)
	powerUpSize = Vector2(16, 16)


	bg = image.load(spritesPath + "bgLevel1-1.png")
	player = image.load(spritesPath + "player.png")

	tileset = image.load(spritesPath + "tileset.png")
	items = image.load(spritesPath + "items.png")
	misc = image.load(spritesPath + "misc.png")
	castle = image.load(spritesPath + "castle.png")
	enemies = image.load(spritesPath + "enemies.png")

	platform = image.load(spritesPath + "platform.png")

	theme = {
		"ow": {
			"ground": getRegion(tileset, 0, 0, tileSize),
			"brick": getRegion(tileset, 0 + tileSizeNum, 0, tileSize),
			"brickPieces": [
				getRegion(misc, 304, 112 + 8, Vector2(8, 8)),
				getRegion(misc, 304 + 8, 112 + 8, Vector2(8, 8)),
				getRegion(misc, 304, 112, Vector2(8, 8)),
				getRegion(misc, 304 + 8, 112, Vector2(8, 8)),
			],
			"hardBlock": getRegion(tileset, 0, 16, tileSize),
			"questionBlock": Animation.from_image_sequence([
				getRegion(tileset, 384, 0, tileSize),
				getRegion(tileset, 384 + tileSizeNum, 0, tileSize),
				getRegion(tileset, 384 + 2 * tileSizeNum, 0, tileSize),
				getRegion(tileset, 384 + tileSizeNum, 0, tileSize),
				getRegion(tileset, 384, 0, tileSize),
				getRegion(tileset, 384, 0, tileSize)
			], 0.125),
			"questionBlockHit": getRegion(tileset, 432, 0, tileSize),
			"coin": Animation.from_image_sequence([
				getRegion(items, 0, 96, powerUpSize),
				getRegion(items, 16, 96, powerUpSize),
				getRegion(items, 32, 96, powerUpSize),
				getRegion(items, 16, 96, powerUpSize),
				getRegion(items, 0, 96, powerUpSize),
				getRegion(items, 0, 96, powerUpSize)
			], 0.125),
			"pillar": getRegion(tileset, 80, 16, tileSize),
			"grassLeft": getRegion(tileset, 80, 128, tileSize),
			"grassMiddle": getRegion(tileset, 96, 128, tileSize),
			"grassRight": getRegion(tileset, 112, 128, tileSize),

			###

			"goombaWalking": Animation.from_image_sequence([
				getRegion(enemies, 0, 16, enemySmallSize),
				getRegion(enemies, 16, 16, enemySmallSize)
			], 0.20),
			"goombaSmashed": getRegion(enemies, 32, 16, enemySmallSize),
			"goombaFlipped": getRegion(enemies, 0, 16, enemySmallSize),

			"green": {
				"koopaTroopaWalking": Animation.from_image_sequence([
					getRegion(enemies, 96, 8, enemyBigSize),
					getRegion(enemies, 112, 8, enemyBigSize)
				], 0.25),
				"koopaTroopaStomped": getRegion(enemies, 160, 16, enemySmallSize),
				"koopaTroopaRecovering": Animation.from_image_sequence([
					getRegion(enemies, 160, 16, enemySmallSize),
					getRegion(enemies, 176, 16, enemySmallSize)
				], 0.25),
			},

			"red": {
				"koopaTroopaWalking": Animation.from_image_sequence([
					getRegion(enemies, 96, 8 + 64, enemyBigSize),
					getRegion(enemies, 112, 8 + 64, enemyBigSize)
				], 0.25),
				"koopaTroopaStomped": getRegion(enemies, 160, 16 + 64, enemySmallSize),
				"koopaTroopaRecovering": Animation.from_image_sequence([
					getRegion(enemies, 160, 16 + 64, enemySmallSize),
					getRegion(enemies, 176, 16 + 64, enemySmallSize)
				], 0.25),
			},

			"piranhaPlant": Animation.from_image_sequence([
				getRegion(enemies, 192, 8, enemyBigSize),
				getRegion(enemies, 192 + 16, 8, enemyBigSize),
			], 0.25),

			###

			"vPipeHead": getRegion(tileset, 0, 128, Vector2(32, 16)),
			"vPipeBody": getRegion(tileset, 2, 144, Vector2(28, 16)),
			"hPipeHead": getRegion(tileset, 32, 128, Vector2(16, 32)),
			"hPipeBody": getRegion(tileset, 48, 129, Vector2(16, 30)),
			"hPipeConnection": getRegion(tileset, 64, 128, Vector2(16, 32)),

			###

			"flagPoleBody": getRegion(tileset, 256, 144, tileSize),
			"flagPoleHead": getRegion(tileset, 256, 128, tileSize),
			"flag": getRegion(items, 128, 32, tileSize),

			###

			"superMushroom": getRegion(items, 0, 0, powerUpSize),
			"oneUp": getRegion(items, 16, 0, powerUpSize),

			"fireFlower": Animation.from_image_sequence([
				getRegion(items, 0, 32, powerUpSize),
				getRegion(items, 16, 32, powerUpSize),
				getRegion(items, 32, 32, powerUpSize),
				getRegion(items, 48, 32, powerUpSize)
			], 0.02),
			"superStar": Animation.from_image_sequence([
				getRegion(items, 0, 48, powerUpSize),
				getRegion(items, 16, 48, powerUpSize),
				getRegion(items, 32, 48, powerUpSize),
				getRegion(items, 48, 48, powerUpSize)
			], 0.02)
		},

		"ug": {
			"ground": getRegion(tileset, 0, 0+32, tileSize),
			"brick": getRegion(tileset, 16 + tileSizeNum, 0+32, tileSize),
			"brickPieces": [
				getRegion(misc, 304, 112 + 16 + 8, Vector2(8, 8)),
				getRegion(misc, 304 + 8, 112 + 16 + 8, Vector2(8, 8)),
				getRegion(misc, 304, 112 + 16, Vector2(8, 8)),
				getRegion(misc, 304 + 8, 112 + 16, Vector2(8, 8)),
			],
			"hardBlock": getRegion(tileset, 0, 16+32, tileSize),
			"questionBlock": Animation.from_image_sequence([
				getRegion(tileset, 384, 0+32, tileSize),
				getRegion(tileset, 384 + tileSizeNum, 0+32, tileSize),
				getRegion(tileset, 384 + 2 * tileSizeNum, 0+32, tileSize),
				getRegion(tileset, 384 + tileSizeNum, 0+32, tileSize),
				getRegion(tileset, 384, 0+32, tileSize),
				getRegion(tileset, 384, 0+32, tileSize)
			], 0.125),
			"questionBlockHit": getRegion(tileset, 432, 0+32, tileSize),
			"coin": Animation.from_image_sequence([
				getRegion(items, 144, 96, powerUpSize),
				getRegion(items, 160, 96, powerUpSize),
				getRegion(items, 176, 96, powerUpSize),
				getRegion(items, 160, 96, powerUpSize),
				getRegion(items, 144, 96, powerUpSize),
				getRegion(items, 144, 96, powerUpSize)
			], 0.125),

			###

			"goombaWalking": Animation.from_image_sequence([
				getRegion(enemies, 0, 16 + 32, enemySmallSize),
				getRegion(enemies, 16, 16 + 32, enemySmallSize)
			], 0.20),
			"goombaSmashed": getRegion(enemies, 32, 16 + 32, enemySmallSize),
			"goombaFlipped": getRegion(enemies, 0, 16 + 32, enemySmallSize),

			"green": {
				"koopaTroopaWalking": Animation.from_image_sequence([
					getRegion(enemies, 96, 8 + 32, enemyBigSize),
					getRegion(enemies, 112, 8 + 32, enemyBigSize)
				], 0.25),
				"koopaTroopaStomped": getRegion(enemies, 160, 16 + 32, enemySmallSize),
				"koopaTroopaRecovering": Animation.from_image_sequence([
					getRegion(enemies, 160, 16 + 32, enemySmallSize),
					getRegion(enemies, 176, 16 + 32, enemySmallSize)
				], 0.25),
			},

			"red": {
				"koopaTroopaWalking": Animation.from_image_sequence([
					getRegion(enemies, 96, 8 + 64, enemyBigSize),
					getRegion(enemies, 112, 8 + 64, enemyBigSize)
				], 0.25),
				"koopaTroopaStomped": getRegion(enemies, 160, 16 + 64, enemySmallSize),
				"koopaTroopaRecovering": Animation.from_image_sequence([
					getRegion(enemies, 160, 16 + 64, enemySmallSize),
					getRegion(enemies, 176, 16 + 64, enemySmallSize)
				], 0.25),
			},

			"piranhaPlant": Animation.from_image_sequence([
				getRegion(enemies, 192, 8 + 32, enemyBigSize),
				getRegion(enemies, 192 + 16, 8 + 32, enemyBigSize),
			], 0.25),


			###

			"vPipeHead": getRegion(tileset, 0, 128+32, Vector2(32, 16)),
			"vPipeBody": getRegion(tileset, 2, 144+32, Vector2(28, 16)),
			"hPipeHead": getRegion(tileset, 32, 128+32, Vector2(16, 32)),
			"hPipeBody": getRegion(tileset, 48, 129+32, Vector2(16, 30)),
			"hPipeConnection": getRegion(tileset, 64, 128+32, Vector2(16, 32)),

			###

			"flagPoleBody": getRegion(tileset, 256, 144+32, tileSize),
			"flagPoleHead": getRegion(tileset, 256, 128+32, tileSize),
			"flag": getRegion(items, 272, 32, tileSize),
		},

		"castle": {
			"ground": getRegion(tileset, 32, 80, tileSize),
			"wave": getRegion(tileset, 48, 384, tileSize),
			"liquid": getRegion(tileset, 48, 384+tileSizeNum, tileSize)
		}
	}

	redKoopaTroopaWalking = Animation.from_image_sequence([
		getRegion(enemies, 96, 8 + 32, enemyBigSize),
		getRegion(enemies, 112, 8 + 32, enemyBigSize)
	], 0.25)
	redKoopaTroopaStomped = getRegion(enemies, 160, 16 + 32, enemySmallSize)
	redKoopaTroopaRecovering = Animation.from_image_sequence([
		getRegion(enemies, 160, 16 + 32, enemySmallSize),
		getRegion(enemies, 176, 16 + 32, enemySmallSize)
	], 0.25)

	fireBall = Animation.from_image_sequence([
		getRegion(items, 96, 144, fireBallSize),
		getRegion(items, 104, 144, fireBallSize),
		getRegion(items, 96, 152, fireBallSize),
		getRegion(items, 104, 152, fireBallSize),
	], 0.05)

	fireBallExplosion = Animation.from_image_sequence([
		getRegion(items, 112, 144, fireBallExplosionSize),
		getRegion(items, 112, 160, fireBallExplosionSize),
		getRegion(items, 112, 176, fireBallExplosionSize),
	], 0.02, False)

	rotatingCoin = Animation.from_image_sequence([
		getRegion(items, 0, 112, tileSize),
		getRegion(items, 0 + tileSizeNum, 112, tileSize),
		getRegion(items, 0 + 2 * tileSizeNum, 112, tileSize),
		getRegion(items, 0 + 3 * tileSizeNum, 112, tileSize),
	], 0.05)

	playerSprites = {
		"mario": {
			"small": {
				"stand": getRegion(player, 80, 34, playerSmallSize),
				"walk": Animation.from_image_sequence([
					getRegion(player, 97, 34, playerSmallSize),
					getRegion(player, 114, 34, playerSmallSize),
					getRegion(player, 131, 34, playerSmallSize), ], 0.1),
				"run": Animation.from_image_sequence([
					getRegion(player, 97, 34, playerSmallSize),
					getRegion(player, 114, 34, playerSmallSize),
					getRegion(player, 131, 34, playerSmallSize), ], 0.05),
				"break": getRegion(player, 148, 34, playerSmallSize),
				"jump": getRegion(player, 165, 34, playerSmallSize),
				"crouch": getRegion(player, 80, 34, playerSmallSize),
				"die": getRegion(player, 182, 34, playerSmallSize)
			},

			"big": {
				"stand": getRegion(player, 80, 1, playerBigSize),
				"walk": Animation.from_image_sequence([
					getRegion(player, 97, 1, playerBigSize),
					getRegion(player, 114, 1, playerBigSize),
					getRegion(player, 131, 1, playerBigSize), ], 0.1),
				"run": Animation.from_image_sequence([
					getRegion(player, 97, 1, playerBigSize),
					getRegion(player, 114, 1, playerBigSize),
					getRegion(player, 131, 1, playerBigSize), ], 0.05),
				"break": getRegion(player, 148, 1, playerBigSize),
				"jump": getRegion(player, 165, 1, playerBigSize),
				"crouch": getRegion(player, 182, 1, playerBigSize)
			}
		},

		"luigi": {
			"small": {
				"stand": getRegion(player, 80, 99, playerSmallSize),
				"walk": Animation.from_image_sequence([
					getRegion(player, 97, 99, playerSmallSize),
					getRegion(player, 114, 99, playerSmallSize),
					getRegion(player, 131, 99, playerSmallSize), ], 0.1),
				"run": Animation.from_image_sequence([
					getRegion(player, 97, 99, playerSmallSize),
					getRegion(player, 114, 99, playerSmallSize),
					getRegion(player, 131, 99, playerSmallSize), ], 0.05),
				"break": getRegion(player, 148, 99, playerSmallSize),
				"jump": getRegion(player, 165, 99, playerSmallSize),
				"crouch": getRegion(player, 80, 99, playerSmallSize),
				"die": getRegion(player, 182, 99, playerSmallSize)
			},

			"big": {
				"stand": getRegion(player, 80, 66, playerBigSize),
				"walk": Animation.from_image_sequence([
					getRegion(player, 97, 66, playerBigSize),
					getRegion(player, 114, 66, playerBigSize),
					getRegion(player, 131, 66, playerBigSize), ], 0.1),
				"run": Animation.from_image_sequence([
					getRegion(player, 97, 66, playerBigSize),
					getRegion(player, 114, 66, playerBigSize),
					getRegion(player, 131, 66, playerBigSize), ], 0.05),
				"break": getRegion(player, 148, 66, playerBigSize),
				"jump": getRegion(player, 165, 66, playerBigSize),
				"crouch": getRegion(player, 182, 66, playerBigSize)
			}
		},

		"fire": {
			"stand": getRegion(player, 80, 129, playerBigSize),
			"walk": Animation.from_image_sequence([
				getRegion(player, 97, 129, playerBigSize),
				getRegion(player, 114, 129, playerBigSize),
				getRegion(player, 131, 129, playerBigSize),
			], 0.1),
			"run": Animation.from_image_sequence([
				getRegion(player, 97, 129, playerBigSize),
				getRegion(player, 114, 129, playerBigSize),
				getRegion(player, 131, 129, playerBigSize),
			], 0.05),
			"break": getRegion(player, 148, 129, playerBigSize),
			"jump": getRegion(player, 165, 129, playerBigSize),
			"crouch": getRegion(player, 182, 129, playerBigSize)
		},

		"invincible": {
			"small": {
				"stand": getRegion(player, 80, 225, playerSmallSize),
				"walk": Animation.from_image_sequence([
					getRegion(player, 97, 225, playerSmallSize),
					getRegion(player, 114, 225, playerSmallSize),
					getRegion(player, 131, 225, playerSmallSize), ], 0.1),
				"run": Animation.from_image_sequence([
					getRegion(player, 97, 225, playerSmallSize),
					getRegion(player, 114, 225, playerSmallSize),
					getRegion(player, 131, 225, playerSmallSize), ], 0.05),
				"break": getRegion(player, 148, 225, playerSmallSize),
				"jump": getRegion(player, 165, 225, playerSmallSize),
				"crouch": getRegion(player, 80, 225, playerSmallSize),
			},

			"big": {
				"stand": getRegion(player, 80, 192, playerBigSize),
				"walk": Animation.from_image_sequence([
					getRegion(player, 97, 192, playerBigSize),
					getRegion(player, 114, 192, playerBigSize),
					getRegion(player, 131, 192, playerBigSize), ], 0.1),
				"run": Animation.from_image_sequence([
					getRegion(player, 97, 192, playerBigSize),
					getRegion(player, 114, 192, playerBigSize),
					getRegion(player, 131, 192, playerBigSize), ], 0.05),
				"break": getRegion(player, 148, 192, playerBigSize),
				"jump": getRegion(player, 165, 192, playerBigSize),
				"crouch": getRegion(player, 182, 192, playerBigSize)
			}
		}
	}

	castle1 = getRegion(castle, 0, 0, Vector2(47, 80))
	castle2 = getRegion(castle, 48, 0, Vector2(32, 80))
import math

import cocos
import cocos.actions as ac
import cocos.collision_model as cm
import cocos.euclid as eu
import cocos.sprite
import pyglet.image
from pyglet.image import Animation

EXPLOSION_IMG = Animation.from_image_sequence(
    pyglet.image.ImageGrid(pyglet.image.load("assets\explosion.png"), 1, 8),
    0.07, False)


class Actor(cocos.sprite.Sprite):
    def __init__(self, img, x, y):
        super(Actor, self).__init__(img, position=(x, y))
        self._cshape = cm.CircleShape(self.position, self.width * 0.5)

    @property
    def cshape(self):
        """
        Actions like MoveBy only update the sprite position, not the cshape.center
        With this construct, when the cshape is read, we also update the cshape.center
        """
        self._cshape.center = eu.Vector2(self.x, self.y)
        return self._cshape


class Turret(Actor):