Пример #1
0
    def __init__(self, avatar):
        self.done = False
        self.avatar = avatar
        self.currentAnim = Anim('subWalkSquash', 5)
        #img = data.pngs['avatar.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        events.AddListener(self)
        self.blinkingCounter = 0.0

        self.yoyo = yoyo.YoYo()

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width)/self.shadow.width
        self.shadow.opacity = 128

        self.on_key_press = window.window.event(self.on_key_press)
        self.on_key_release = window.window.event(self.on_key_release)
        self.mouseButton = None
        self.on_mouse_press = window.window.event(self.on_mouse_press)
        self.on_mouse_release = window.window.event(self.on_mouse_release)

        self.attackImgs = {Facing.left: data.pngs[self.avatar.attackImg +'_left'],
                           Facing.right: data.pngs[self.avatar.attackImg]}
        self.deadImgs = {Facing.left: data.pngs[self.avatar.deadImg +'_left'],
                         Facing.right: data.pngs[self.avatar.deadImg]}
Пример #2
0
class TeddySprite(EnemySprite):
    imgPrefix = 'ted'

    def __init__(self, enemy):
        self.enemy = enemy
        events.AddListener(self)
        self.currentAnim = Anim(self.imgPrefix + 'Walk', 5)
        #img = data.pngs['enemy.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        self.blinkingCounter = 0.0

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width) / self.shadow.width
        self.shadow.opacity = 100

        self.hugImgs = {
            Facing.left: data.pngs[self.imgPrefix + 'Hug_left'],
            Facing.right: data.pngs[self.imgPrefix + 'Hug']
        }
        self.stunImgs = {
            Facing.left: data.pngs[self.imgPrefix + 'Stun_left'],
            Facing.right: data.pngs[self.imgPrefix + 'Stun']
        }
        self.idleImg = data.pngs[self.imgPrefix + 'Stand']
        self.walkImg = self.currentAnim.animation

    def draw(self):
        self.shadow.draw()
        if hasattr(self.enemy, 'mad') and self.enemy.mad:
            self.color = (200, 10, 10)
        EnemySprite.draw(self)

    def update(self, timeChange=None):
        EnemySprite.update(self, timeChange)
        if self.enemy.state in State.walkingStates:
            if self.enemy.facing != self.currentAnim.facing:
                self.currentAnim.flip()
                self.image = self.currentAnim.animation
            elif self.image != self.currentAnim.animation:
                self.image = self.currentAnim.animation
        elif self.enemy.state in State.attackingStates:
            self.image = self.hugImgs[self.enemy.facing]
        elif self.enemy.state == State.stunned:
            self.image = self.stunImgs[self.enemy.facing]
        elif self.enemy.state == State.idle:
            self.image = self.idleImg
        self.shadow.x = self.x
        self.shadow.y = self.y - (self.shadow.height / 2
                                  )  #shadow center = feetpos
Пример #3
0
    def __init__(self, sprites, start_tile, exit_spawn_path, square_size, map,
                 player_rect, move_time, move_speed, choose_target_tile,
                 start_at_power_points):
        self.sprites = sprites
        self.start_tile = start_tile
        self.exit_spawn_path = exit_spawn_path
        self.square_size = square_size
        self.map = map
        self.move_time = move_time
        self.reset_move_speed = self.move_speed = move_speed

        self.state = "normal"  # the other state is "chased"
        self.chassed_sprite_kind = "chased"

        self.move_anim = Anim(self.sprites["right"], speed=0.12)

        self.start_at_power_points = start_at_power_points  # will start if less than X power points are eaten

        self.move_timer = 0

        self.chased_change_color_timer = 0

        self.pos = [
            self.start_tile[0] * self.square_size,
            self.start_tile[1] * self.square_size
        ]
        self.rect = pygame.Rect(self.pos[0], self.pos[1], self.square_size,
                                self.square_size)
        level_nb = 1
        self.timer = Timer(level_nb)

        # "Scatter" # Scatter -> fixed tile to reach (outside screen) | Chase -> attack pac man | Frightened -> random
        self.mode = self.timer.phases[self.timer.current_phase_index][0]

        self.move_direction = "left"

        self.moving_to = (
            8, 7
        )  # the first move after the ghost left the spawn (going to the left tile)

        self.choose_target_tile = choose_target_tile

        self.direction_conversion = {
            "right": (1, 0),
            "left": (-1, 0),
            "down": (0, 1),
            "up": (0, -1)
        }
Пример #4
0
    def __init__(self, avatar):
        self.done = False
        self.avatar = avatar
        self.currentAnim = Anim("subWalkSquash", 5)
        # img = data.pngs['avatar.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        events.AddListener(self)
        self.blinkingCounter = 0.0

        self.yoyo = yoyo.YoYo()

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width) / self.shadow.width
        self.shadow.opacity = 128

        self.on_key_press = window.window.event(self.on_key_press)
        self.on_key_release = window.window.event(self.on_key_release)
        self.mouseButton = None
        self.on_mouse_press = window.window.event(self.on_mouse_press)
        self.on_mouse_release = window.window.event(self.on_mouse_release)

        self.attackImgs = {
            Facing.left: data.pngs[self.avatar.attackImg + "_left"],
            Facing.right: data.pngs[self.avatar.attackImg],
        }
        self.deadImgs = {
            Facing.left: data.pngs[self.avatar.deadImg + "_left"],
            Facing.right: data.pngs[self.avatar.deadImg],
        }
Пример #5
0
class TeddySprite(EnemySprite):
    imgPrefix = 'ted'
    def __init__(self, enemy):
        self.enemy = enemy
        events.AddListener(self)
        self.currentAnim = Anim(self.imgPrefix+'Walk', 5)
        #img = data.pngs['enemy.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        self.blinkingCounter = 0.0

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width)/self.shadow.width
        self.shadow.opacity = 100

        self.hugImgs = {Facing.left: data.pngs[self.imgPrefix+'Hug_left'],
                        Facing.right: data.pngs[self.imgPrefix+'Hug']}
        self.stunImgs = {Facing.left: data.pngs[self.imgPrefix+'Stun_left'],
                        Facing.right: data.pngs[self.imgPrefix+'Stun']}
        self.idleImg = data.pngs[self.imgPrefix+'Stand']
        self.walkImg = self.currentAnim.animation

    def draw(self):
        self.shadow.draw()
        if hasattr(self.enemy, 'mad') and self.enemy.mad:
            self.color = (200, 10, 10)
        EnemySprite.draw(self)

    def update(self, timeChange=None):
        EnemySprite.update(self, timeChange)
        if self.enemy.state in State.walkingStates:
            if self.enemy.facing != self.currentAnim.facing:
                self.currentAnim.flip()
                self.image = self.currentAnim.animation
            elif self.image != self.currentAnim.animation:
                self.image = self.currentAnim.animation
        elif self.enemy.state in State.attackingStates:
            self.image = self.hugImgs[self.enemy.facing]
        elif self.enemy.state == State.stunned:
            self.image = self.stunImgs[self.enemy.facing]
        elif self.enemy.state == State.idle:
            self.image = self.idleImg
        self.shadow.x = self.x
        self.shadow.y = self.y - (self.shadow.height/2) #shadow center = feetpos
Пример #6
0
    def __init__(self, square_size, obstacles, sprites):
        self.square_size = square_size
        self.obstacles = obstacles
        self.sprites = sprites
        self.move_anim = Anim(sprites["moving"]["right"], speed=0.12)
        self.death_anim = Anim(sprites["death"], speed=0.1)
        self.font = pygame.font.SysFont("coopbl", 55)

        self.timer = {"move": 0}

        self.move_time = 0.02

        self.portals = {1: None, 2: None, "space_pressed": False}

        # initial amount of lives
        self.lives = 3

        # the player will move 2 pixel every move_time sec
        self.reset_move_speed = self.move_speed = 3

        self.color = (211, 144, 11)

        self.direction = {"current": "left",
                          "next": None,
                          "previous": None,
                          "right": (1, 0),
                          "left": (-1, 0),
                          "down": (0, 1),
                          "up": (0, -1)}

        self.killed = False
        self.make_death_anim = False
        self.make_ghost_respawn = False
        self.start_pos = [self.square_size * 9, self.square_size * 11]
        self.rect = pygame.Rect(self.start_pos[0],
                                self.start_pos[1],
                                self.square_size,
                                self.square_size)

        self.define_current_tile()

        self.score = 0
Пример #7
0
    def __init__(self, enemy):
        self.enemy = enemy
        events.AddListener(self)
        self.currentAnim = Anim(self.imgPrefix + 'Walk', 5)
        #img = data.pngs['enemy.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        self.blinkingCounter = 0.0

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width) / self.shadow.width
        self.shadow.opacity = 100

        self.hugImgs = {
            Facing.left: data.pngs[self.imgPrefix + 'Hug_left'],
            Facing.right: data.pngs[self.imgPrefix + 'Hug']
        }
        self.stunImgs = {
            Facing.left: data.pngs[self.imgPrefix + 'Stun_left'],
            Facing.right: data.pngs[self.imgPrefix + 'Stun']
        }
        self.idleImg = data.pngs[self.imgPrefix + 'Stand']
        self.walkImg = self.currentAnim.animation
Пример #8
0
    def __init__(self, enemy):
        self.enemy = enemy
        events.AddListener(self)
        self.currentAnim = Anim(self.imgPrefix+'Walk', 5)
        #img = data.pngs['enemy.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        self.blinkingCounter = 0.0

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width)/self.shadow.width
        self.shadow.opacity = 100

        self.hugImgs = {Facing.left: data.pngs[self.imgPrefix+'Hug_left'],
                        Facing.right: data.pngs[self.imgPrefix+'Hug']}
        self.stunImgs = {Facing.left: data.pngs[self.imgPrefix+'Stun_left'],
                        Facing.right: data.pngs[self.imgPrefix+'Stun']}
        self.idleImg = data.pngs[self.imgPrefix+'Stand']
        self.walkImg = self.currentAnim.animation
Пример #9
0
class AvatarSprite(pyglet.sprite.Sprite):
    def __init__(self, avatar):
        self.done = False
        self.avatar = avatar
        self.currentAnim = Anim("subWalkSquash", 5)
        # img = data.pngs['avatar.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        events.AddListener(self)
        self.blinkingCounter = 0.0

        self.yoyo = yoyo.YoYo()

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width) / self.shadow.width
        self.shadow.opacity = 128

        self.on_key_press = window.window.event(self.on_key_press)
        self.on_key_release = window.window.event(self.on_key_release)
        self.mouseButton = None
        self.on_mouse_press = window.window.event(self.on_mouse_press)
        self.on_mouse_release = window.window.event(self.on_mouse_release)

        self.attackImgs = {
            Facing.left: data.pngs[self.avatar.attackImg + "_left"],
            Facing.right: data.pngs[self.avatar.attackImg],
        }
        self.deadImgs = {
            Facing.left: data.pngs[self.avatar.deadImg + "_left"],
            Facing.right: data.pngs[self.avatar.deadImg],
        }

    def draw(self):
        self.shadow.draw()
        pyglet.sprite.Sprite.draw(self)
        if self.avatar.yoyo and not self.avatar.health == 0:
            if self.avatar.selectedAttack:
                self.avatar.selectedAttack.draw(self.avatar, self.yoyo)
            else:
                self.yoyo.draw()

    def update(self, timeChange=None):
        self.avatar.update(timeChange)
        if self.done:
            return self.cleanup()

        if self.avatar.state == State.attacking:
            self.image = self.attackImgs[self.avatar.facing]
        elif self.avatar.health == 0:
            self.image = self.deadImgs[self.avatar.facing]
        else:
            if self.avatar.facing != self.currentAnim.facing:
                self.currentAnim.flip()
                self.image = self.currentAnim.animation
            elif self.image != self.currentAnim.animation:
                self.image = self.currentAnim.animation

        if self.blinkingCounter > 0:
            self.opacity = (10 + self.opacity) % 255
            self.blinkingCounter -= timeChange
        elif not self.opacity == 255:
            self.opacity = 255

        self.x = self.avatar.x
        self.y = self.avatar.y

        self.x += window.bgOffset[0]
        self.y += window.bgOffset[1]

        if self.avatar.yoyo:
            self.avatar.yoyo.gfxYoyo = self.yoyo
            self.yoyo.moveToFeetPos(self.avatar.feetPos, self.avatar.facing)
            self.yoyo.stringMaxLength = self.avatar.getStringLength() * 30

            if not self.avatar.selectedAttack:
                self.yoyo.update(timeChange)

        self.shadow.x = self.x
        self.shadow.y = self.y - (self.shadow.height / 2)  # shadow center = feetpos
        if self.avatar.health == 0:
            self.shadow.y += 10

    def On_AttackHit(self, attack, attacker, victim):
        if victim == self.avatar:
            self.blinkingCounter = 1.0

    def On_LevelCompletedEvent(self, *args):
        # clean up
        self.done = True

    def cleanup():
        events.RemoveListener(self)
        del self.avatar
        del self.currentAnim
        del self.yoyo
        del self.shadow
        del self.mouseButton
        del self.attackImgs
        del self.deadImgs
        del self.on_key_press
        del self.on_key_release
        del self.on_mouse_press
        del self.on_mouse_release

    def press(self):
        from pyglet.window import key

        if keysPressed.get(key.DOWN):
            self.yoyo.throw("walkthedog")
            self.avatar.setAttack("walkthedog")
        elif keysPressed.get(key.UP):
            self.yoyo.throw("shootthemoon")
            self.avatar.setAttack("shootthemoon")
        else:
            self.yoyo.throw("looping")
            self.avatar.setAttack("looping")
        self.avatar.doAttack()

    def on_key_press(self, symbol, modifiers):
        if self.avatar.health == 0:
            return

        from pyglet.window import key

        keysPressed[symbol] = True

        if keysPressed.get(key.LCTRL) or keysPressed.get(key.SPACE):
            self.press()
        else:
            moveDict = {
                key.UP: self.avatar.On_UpKeyPress,
                key.W: self.avatar.On_UpKeyPress,
                key.RIGHT: self.avatar.On_RightKeyPress,
                key.D: self.avatar.On_RightKeyPress,
                key.DOWN: self.avatar.On_DownKeyPress,
                key.S: self.avatar.On_DownKeyPress,
                key.LEFT: self.avatar.On_LeftKeyPress,
                key.A: self.avatar.On_DownKeyPress,
            }
            fn = moveDict.get(symbol)
            if fn:
                # oldFacing = self.avatar.facing
                fn()
                # print 'old', oldFacing, 'new', self.avatar.facing
                # if self.avatar.facing != oldFacing:
                # self.currentAnim.flip()

    def release(self):
        self.yoyo.yoyoReturn = True
        self.avatar.fireSpecial()

    def on_key_release(self, symbol, modifiers):
        from pyglet.window import key

        keysPressed[symbol] = False

        if symbol in [key.LCTRL, key.SPACE] and self.yoyo.moveType:
            self.release()

        moveDict = {
            key.UP: self.avatar.On_UpKeyRelease,
            key.W: self.avatar.On_UpKeyRelease,
            key.RIGHT: self.avatar.On_RightKeyRelease,
            key.D: self.avatar.On_RightKeyRelease,
            key.DOWN: self.avatar.On_DownKeyRelease,
            key.S: self.avatar.On_DownKeyRelease,
            key.LEFT: self.avatar.On_LeftKeyRelease,
            key.A: self.avatar.On_LeftKeyRelease,
        }
        fn = moveDict.get(symbol)
        if fn:
            fn()

    def on_mouse_press(self, x, y, button, modifiers):
        self.mouseButton = button
        self.press()

    def on_mouse_release(self, x, y, button, modifiers):
        if self.mouseButton == button:
            self.release()
Пример #10
0
bulletDir = 1
bonusItem = []
bonusItemDropRate = 100         # Higher value is less drops, default 120

# Audio effects
snd_select = sounds.select_8b
snd_bonus = sounds.bonus_8b
snd_extralife = sounds.extralife_8b
snd_extratime = sounds.extratime_8b
snd_freeze = sounds.freeze_8b
snd_hurt = sounds.injury_8b
snd_shoot = sounds.shoot_8b
snd_complete = sounds.complete_8b

# Animation setup - Array of graphic images and the speed of the animation (lower = faster)
playerAnimWalk = Anim([graphics.g_player.ply01, graphics.g_player.ply02, graphics.g_player.ply03, graphics.g_player.ply04, graphics.g_player.ply05], 4 // moveSpeed)
playerIdle = graphics.g_player.ply03
playerWarp = graphics.g_player.ply06
enemy1 = Anim([graphics.g_enemies.enemy0_0, graphics.g_enemies.enemy0_1, graphics.g_enemies.enemy0_2], 4)
enemy2 = Anim([graphics.g_enemies.enemy1_0, graphics.g_enemies.enemy1_1, graphics.g_enemies.enemy1_2], 2)
enemy3 = Anim([graphics.g_enemies.enemy2_0, graphics.g_enemies.enemy2_1, graphics.g_enemies.enemy2_2], 4)
item_stop = Anim([graphics.g_collectibles.stop_0, graphics.g_collectibles.stop_1], 20)
item_heart = Anim([graphics.g_collectibles.heart_0, graphics.g_collectibles.heart_1], 5)
item_clock = Anim([graphics.g_collectibles.clock_0, graphics.g_collectibles.clock_1], 7)
item_bonus = Anim([graphics.g_collectibles.bonus_0, graphics.g_collectibles.bonus_1, graphics.g_collectibles.bonus_2], 1)
instructionsGraphic1 = [graphics.g_player.ply01, graphics.g_player.arrow_left, graphics.g_player.arrow_right, graphics.g_player.arrow_up]
instructionsGraphic4 = [graphics.g_collectibles.stop_0, graphics.g_collectibles.heart_0, graphics.g_collectibles.clock_0, graphics.g_collectibles.bonus_0, graphics.g_imps.imp0_0]
imp1Anim = Anim([graphics.g_imps.imp0_0, graphics.g_imps.imp0_1], 10)
imp2Anim = Anim([graphics.g_imps.imp1_0, graphics.g_imps.imp1_1], 11)
imp3Anim = Anim([graphics.g_imps.imp2_0, graphics.g_imps.imp2_1], 12)
imp4Anim = Anim([graphics.g_imps.imp3_0, graphics.g_imps.imp3_1], 13)
Пример #11
0
class Player:
    def __init__(self, square_size, obstacles, sprites):
        self.square_size = square_size
        self.obstacles = obstacles
        self.sprites = sprites
        self.move_anim = Anim(sprites["moving"]["right"], speed=0.12)
        self.death_anim = Anim(sprites["death"], speed=0.1)
        self.font = pygame.font.SysFont("coopbl", 55)

        self.timer = {"move": 0}

        self.move_time = 0.02

        self.portals = {1: None, 2: None, "space_pressed": False}

        # initial amount of lives
        self.lives = 3

        # the player will move 2 pixel every move_time sec
        self.reset_move_speed = self.move_speed = 3

        self.color = (211, 144, 11)

        self.direction = {"current": "left",
                          "next": None,
                          "previous": None,
                          "right": (1, 0),
                          "left": (-1, 0),
                          "down": (0, 1),
                          "up": (0, -1)}

        self.killed = False
        self.make_death_anim = False
        self.make_ghost_respawn = False
        self.start_pos = [self.square_size * 9, self.square_size * 11]
        self.rect = pygame.Rect(self.start_pos[0],
                                self.start_pos[1],
                                self.square_size,
                                self.square_size)

        self.define_current_tile()

        self.score = 0

    def define_current_tile(self):
        current_tile_x = int(self.rect.centerx / self.square_size)
        current_tile_y = int(self.rect.centery / self.square_size)
        self.current_tile = [current_tile_x, current_tile_y]

    def user_input(self):
        keys_pressed = pygame.key.get_pressed()
        if ((keys_pressed[pygame.K_LEFT] or keys_pressed[pygame.K_a]) and not (
                keys_pressed[pygame.K_RIGHT] or keys_pressed[pygame.K_d])):
            self.direction["next"] = "left"

        if ((keys_pressed[pygame.K_RIGHT] or keys_pressed[pygame.K_d]) and not (
                keys_pressed[pygame.K_LEFT] or keys_pressed[pygame.K_a])):
            self.direction["next"] = "right"

        if ((keys_pressed[pygame.K_DOWN] or keys_pressed[pygame.K_s]) and not (
                keys_pressed[pygame.K_UP] or keys_pressed[pygame.K_w])):
            self.direction["next"] = "down"

        if ((keys_pressed[pygame.K_UP] or keys_pressed[pygame.K_w]) and not (
                keys_pressed[pygame.K_DOWN] or keys_pressed[pygame.K_s])):
            self.direction["next"] = "up"

    def change_direction(self, surface):
        if self.direction["next"] is not None:
            next_rect = self.rect.copy()

            next_rect.x += self.move_speed * self.direction[self.direction["next"]][0]

            next_rect.y += self.move_speed * self.direction[self.direction["next"]][1]

            if next_rect.right > 0 and next_rect.left < surface.get_width():

                if next_rect.collidelist(self.obstacles) == -1:
                    self.direction["current"] = self.direction["next"]
                    self.direction["previous"] = self.direction["current"]
                    self.direction["next"] = None

    def move(self, surface):
        self.user_input()

        if time.time() > self.timer["move"]:
            self.timer["move"] = time.time() + self.move_time
            self.define_current_tile()

            self.change_direction(surface)

            if self.direction["current"] is not None:

                self.rect.x += self.move_speed * self.direction[self.direction["current"]][0]
                self.rect.y += self.move_speed * self.direction[self.direction["current"]][1]

                # if the player is outside the screen at the right
                if self.rect.x > surface.get_width():
                    self.rect.x = 0 - self.square_size

                # if the player is outside the screen at the left
                if self.rect.x < 0 - self.square_size:
                    self.rect.x = surface.get_width()

                if self.current_tile == self.portals[2]:
                    self.current_tile = self.portals[1]
                    self.rect.x = self.portals[1][0] * self.square_size
                    self.rect.y = self.portals[1][1] * self.square_size

                # if the player HAS collide with an obstacle
                collide_index = self.rect.collidelist(self.obstacles)
                if collide_index != -1:

                    if self.direction["current"] == "up":
                        self.rect.y = self.obstacles[collide_index].bottom

                    elif self.direction["current"] == "down":
                        self.rect.y = self.obstacles[collide_index].top - self.square_size

                    elif self.direction["current"] == "right":
                        self.rect.x = self.obstacles[collide_index].left - self.square_size

                    elif self.direction["current"] == "left":
                        self.rect.x = self.obstacles[collide_index].right

                    self.direction["previous"] = self.direction["current"]
                    self.direction["current"] = None

    def draw_score(self, surface):
        label = self.font.render(f"Score : {self.score}", 1, (222, 222, 222))
        x_pos = surface.get_width() - label.get_width() - self.square_size
        y_pos = self.square_size // 2 - label.get_height() // 2
        surface.blit(label, (x_pos, y_pos))

    def draw_lives(self, surface):
        label = self.font.render(f"Lives : {self.lives}", 1, (222, 222, 222))
        x_pos = surface.get_width() // 2 - label.get_width() // 2
        y_pos = surface.get_height() - label.get_height() - 4
        surface.blit(label, (x_pos, y_pos))

    def draw(self, surface):
        self.draw_score(surface)
        self.draw_lives(surface)
        self.draw_portals(surface)

        if not self.make_death_anim:
            self.move_anim.do()
            if self.direction["current"] is None:
                self.move_anim.s_index = 0
                direction = "right"
            else:
                direction = self.direction["current"]
            sprite = self.sprites["moving"][direction][self.move_anim.s_index]
            pos_x = self.rect.x + (self.square_size - sprite.get_width()) / 2
            pos_y = (self.rect.y +
                     (self.square_size - sprite.get_height()) / 2 + 1)
            surface.blit(sprite, (pos_x, pos_y))

        # death anim
        if self.make_death_anim:
            self.move_speed = 0
            sprite = self.death_anim.current_sprite
            pos_x = self.rect.x + (self.square_size - sprite.get_width()) / 2
            pos_y = (self.rect.y +
                     (self.square_size - sprite.get_height()) / 2 + 1)
            surface.blit(sprite, (pos_x, pos_y))

            if self.death_anim.do() == "end":
                # reset
                self.make_death_anim = False
                self.make_ghost_respawn = True
                self.reset_pos()

    def reset_pos(self):
        self.rect.x = self.start_pos[0]
        self.rect.y = self.start_pos[1]
        self.move_speed = self.reset_move_speed
        self.direction["current"] = "left"
        self.portals = {1: None, 2: None, "space_pressed": False}

    # Tests if the player is killed or not
    def test_kill(self):
        if self.killed is True:
            self.killed = False
            self.lives -= 1
            self.death_anim.s_index = 0
            self.make_death_anim = True
            self.portals = {1: None, 2: None, "space_pressed": False}
            return True

    def create_portals(self):
        keys_pressed = pygame.key.get_pressed()
        if keys_pressed[pygame.K_SPACE]:
            if not self.portals["space_pressed"]:
                self.portals["space_pressed"] = True
                tile = self.current_tile.copy()
                if self.portals[1] == None:
                    self.portals[1] = tile
                elif self.portals[2] == None:
                    self.portals[2] = tile
        else:
            self.portals["space_pressed"] = False

    def draw_portals(self, surface):
        if self.portals[1] != None:
            surface.blit(self.sprites["portals"]["blue"],
                         (self.portals[1][0] * self.square_size, self.portals[1][1] * self.square_size ))
        if self.portals[2] != None:
            surface.blit(self.sprites["portals"]["orange"],
                         (self.portals[2][0] * self.square_size, self.portals[2][1] * self.square_size ))
Пример #12
0
monsterPos = [110, 3, False, 30 + random.getrandbits(4)
              ]  # Monster x/y pos, shooting bool and shooting timer
smokePos = [50, 0, 5]  # Smoke plume, smoke speed
scoreSaved = False
gameOverY = -88  # Start pos for game over bg pos
sfxPlaying = False  # Used for checking sfx is playing
sfxTimer = 23  # Timer for sfx

# Init classes
player = Player(playerX, playerY, playerHeight)
audio = Audio(g_sound, isThisRealHardware)
shake = Shake()

# Animation setup - Array of graphic images and the speed of the animation (lower = faster)
playerAnim = Anim([
    graphics.g_player.man01, graphics.g_player.man02, graphics.g_player.man03,
    graphics.g_player.man04
], 1)
birdAnimList = []

######################################
# Sprites, images, objects
######################################
logo = graphics.g_logo.logo
gameBg = graphics.g_background.gameBg
gameBg2 = graphics.g_background.gameBg2
gameOverBg = graphics.g_background.gameOver
floors = [
    graphics.g_tiles.floor01, graphics.g_tiles.floor02,
    graphics.g_tiles.floor03, graphics.g_tiles.floor04
]
walls = [
Пример #13
0
    rho = rho1 + rho2
    vx = (vx1 + vx2) / 2
    vy = (vy1 + vy2) / 2
    vsq = vx**2 + vy**2
    W = 1 / np.sqrt(1 - vsq)
    KE = rho * W * (W - 1)

    return KE


if __name__ == '__main__':

    #  Model Comparison

    if not 'Ideal' in locals():
        Ideal = Anim('Ideal/HighRes/Data/TimeSeries/UserDef/')
        idealT = Ideal.t.index(min(Ideal.t, key=lambda x: abs(x - 3.0)))
        Nideal = Ideal.final.c['nx'] // 2
        KESpecIdeal = getPowerSpectrumSq(Ideal.final,
                                         GetKESF(Ideal, Ideal.frame[idealT]))

    if not 'Resistive' in locals():
        Resistive = Anim('Resistive/Sigma10/HighRes/Data/TimeSeries/UserDef/')
        resistiveT = Resistive.t.index(
            min(Resistive.t, key=lambda x: abs(x - 3.0)))
        Nresistive = Resistive.final.c['nx'] // 2
        KESpecResistive = getPowerSpectrumSq(
            Resistive.final, GetKESF(Resistive, Resistive.frame[resistiveT]))

    if not 'TwoFluid' in locals():
        TwoFluid = Anim(
Пример #14
0
gameOverPlayed = False  # Trigger to pay gameover sound when dead
aquariumBg = [
    graphics.bg1, graphics.bg2, graphics.bg3, graphics.bg4, graphics.bg5
]

# Init classes
interface = Interface()
bg = Background()
player = Player()
food = Food()
hunger = Hunger(hungerMax)
audio = Audio(g_sound)
tmusic = Music(g_sound, isThisRealHardware)

# Animation setup - Array of graphic images and the speed of the animation (lower = faster)
coinAnim = Anim([graphics.coin, graphics.coin1], 3)
fish1AnimSpeed = random.getrandbits(3) + 1
fish1AnimLeft = Anim([graphics.fish1_left, graphics.fish1_left1],
                     fish1AnimSpeed)
fish1AnimRight = Anim([graphics.fish1_right, graphics.fish1_right1],
                      fish1AnimSpeed)
fish2AnimLeft = Anim([graphics.fish2_left, graphics.fish2_left1],
                     fish1AnimSpeed)
fish2AnimRight = Anim([graphics.fish2_right, graphics.fish2_right1],
                      fish1AnimSpeed)
jellyAnim = Anim([graphics.jelly1, graphics.jelly2], fish1AnimSpeed)
playerAnimLeft = Anim([graphics.crab1_left, graphics.crab2_left], 3)
playerAnimRight = Anim([graphics.crab1_right, graphics.crab2_right], 3)
playerAnimIdle = Anim(
    [graphics.crab_idle1, graphics.crab_idle2, graphics.crab_idle1], 20)
Пример #15
0
class Ghost:
    def __init__(self, sprites, start_tile, exit_spawn_path, square_size, map,
                 player_rect, move_time, move_speed, choose_target_tile,
                 start_at_power_points):
        self.sprites = sprites
        self.start_tile = start_tile
        self.exit_spawn_path = exit_spawn_path
        self.square_size = square_size
        self.map = map
        self.move_time = move_time
        self.reset_move_speed = self.move_speed = move_speed

        self.state = "normal"  # the other state is "chased"
        self.chassed_sprite_kind = "chased"

        self.move_anim = Anim(self.sprites["right"], speed=0.12)

        self.start_at_power_points = start_at_power_points  # will start if less than X power points are eaten

        self.move_timer = 0

        self.chased_change_color_timer = 0

        self.pos = [
            self.start_tile[0] * self.square_size,
            self.start_tile[1] * self.square_size
        ]
        self.rect = pygame.Rect(self.pos[0], self.pos[1], self.square_size,
                                self.square_size)
        level_nb = 1
        self.timer = Timer(level_nb)

        # "Scatter" # Scatter -> fixed tile to reach (outside screen) | Chase -> attack pac man | Frightened -> random
        self.mode = self.timer.phases[self.timer.current_phase_index][0]

        self.move_direction = "left"

        self.moving_to = (
            8, 7
        )  # the first move after the ghost left the spawn (going to the left tile)

        self.choose_target_tile = choose_target_tile

        self.direction_conversion = {
            "right": (1, 0),
            "left": (-1, 0),
            "down": (0, 1),
            "up": (0, -1)
        }

    # def shortest_path_to(self, target_tile):
    #     return target_tile

    def move(self, player_current_tile, surface, power_points_infos):
        if self.start_at_power_points <= power_points_infos["total"] - len(
                power_points_infos["current"]) and time.time(
                ) > self.move_timer:

            self.player_current_tile = player_current_tile

            self.move_timer = time.time() + self.move_time

            if len(self.exit_spawn_path) != 0:
                move_direction = self.exit_spawn_path[0][0]
                moving_to = self.exit_spawn_path[0][1]

            else:  # if the ghost is outside the spawn cage
                move_direction = self.move_direction
                moving_to = self.moving_to

            if move_direction == "left":
                self.pos[0] -= self.move_speed
                self.rect.x = self.pos[0]
                if self.pos[0] / self.square_size < moving_to[
                        0]:  # if exceed the target tile
                    self.pos[0] = moving_to[0] * self.square_size
                    self.rect.x = self.pos[0]

                    if self.rect.right <= 0:  # if outside the screen
                        self.rect.x = surface.get_width()
                        self.pos[0] = self.rect.x
                        self.moving_to = (
                            surface.get_width() // self.square_size - 1,
                            moving_to[1])
                    else:
                        if len(self.exit_spawn_path) != 0:
                            self.exit_spawn_path.pop(0)
                        else:
                            self.moving_to = self.choose_next_tile()

            elif move_direction == "right":
                self.pos[0] += self.move_speed
                self.rect.x = self.pos[0]

                if self.pos[0] / self.square_size > moving_to[
                        0]:  # if exceed the target tile
                    self.pos[0] = moving_to[0] * self.square_size
                    self.rect.x = self.pos[0]

                    if self.rect.left >= surface.get_width():
                        self.rect.right = 0
                        self.pos[0] = self.rect.x
                        self.moving_to = (0, moving_to[1])

                    else:
                        if len(self.exit_spawn_path) != 0:
                            self.exit_spawn_path.pop(0)
                        else:
                            self.moving_to = self.choose_next_tile()

            elif move_direction == "up":
                self.pos[1] -= self.move_speed
                self.rect.y = self.pos[1]

                if self.pos[1] / self.square_size < moving_to[
                        1]:  # if exceed the target tile
                    self.pos[1] = moving_to[1] * self.square_size
                    self.rect.y = self.pos[1]
                    if len(self.exit_spawn_path) != 0:
                        self.exit_spawn_path.pop(0)
                    else:
                        self.moving_to = self.choose_next_tile()

            elif move_direction == "down":
                self.pos[1] += self.move_speed
                self.rect.y = self.pos[1]

                if self.pos[1] / self.square_size > moving_to[
                        1]:  # if exceed the target tile
                    self.pos[1] = moving_to[1] * self.square_size
                    self.rect.y = self.pos[1]
                    if len(self.exit_spawn_path) != 0:
                        self.exit_spawn_path.pop(0)
                    else:
                        self.moving_to = self.choose_next_tile()

    def possible_next_tile_algo(self):
        adjacency_tiles = {}
        if self.move_direction != "up":
            adjacency_tiles["down"] = self.map[self.moving_to[1] +
                                               1][self.moving_to[0]]
        if self.move_direction != "down":
            adjacency_tiles["up"] = self.map[self.moving_to[1] -
                                             1][self.moving_to[0]]
        if self.move_direction != "left":
            adjacency_tiles["right"] = self.map[self.moving_to[1]][
                self.moving_to[0] + 1]
        if self.move_direction != "right":
            adjacency_tiles["left"] = self.map[self.moving_to[1]][
                self.moving_to[0] - 1]

        while True:
            for direction, tile in adjacency_tiles.items():

                if tile == "#" or tile == "b":
                    del adjacency_tiles[direction]
                    break
            else:
                break

        return list(adjacency_tiles.keys())

    def choose_next_tile(self):
        # update the timer
        self.timer.update()
        if self.timer.timer > self.timer.phases[
                self.timer.current_phase_index][1]:
            self.timer.start_time = time.time()
            self.timer.current_phase_index += 1
            self.mode = self.timer.phases[self.timer.current_phase_index][0]

        target_tile, possibles_next_direction = self.choose_target_tile()

        if len(possibles_next_direction) == 1:
            next_direction = possibles_next_direction[0]
        # shortest path (in a straight line) to the target tile
        else:
            shortest_line = float("+inf")
            current_chosen_direction = None
            for direction in possibles_next_direction:
                conv = self.direction_conversion[direction]
                tile = (self.moving_to[0] + conv[0],
                        self.moving_to[1] + conv[1])
                # lenght from this tile to the target tile
                line_lenght = math.sqrt(
                    abs(tile[0] - target_tile[0])**2 +
                    abs(tile[1] - target_tile[1])**2)
                if line_lenght < shortest_line:
                    shortest_line = line_lenght
                    current_chosen_direction = direction

            next_direction = current_chosen_direction

        if next_direction == "right":
            next_tile = [self.moving_to[0] + 1, self.moving_to[1]]
        elif next_direction == "left":
            next_tile = [self.moving_to[0] - 1, self.moving_to[1]]
        elif next_direction == "down":
            next_tile = [self.moving_to[0], self.moving_to[1] + 1]
        elif next_direction == "up":
            next_tile = [self.moving_to[0], self.moving_to[1] - 1]

        self.move_direction = next_direction

        return next_tile

    def draw(self, surface):
        # if self.state == "chased":

        self.move_anim.do()
        if self.state == "chased":
            if self.chased_start_time + 10 > time.time():
                if self.chased_start_time + 7 < time.time(
                ) and self.chased_change_color_timer < time.time():
                    self.chased_change_color_timer = time.time() + 0.3
                    if self.chassed_sprite_kind == "chased":
                        self.chassed_sprite_kind = "chased_white"
                    else:
                        self.chassed_sprite_kind = "chased"
            else:
                self.chassed_sprite_kind = "chased"
                self.state = "normal"

            sprite = self.sprites[self.chassed_sprite_kind][
                self.move_anim.s_index]
        else:  # draw the normal sprite
            self.move_speed = self.reset_move_speed
            sprite = self.sprites[self.move_direction][self.move_anim.s_index]
        # pygame.draw.rect(surface, sprite, self.rect)
        surface.blit(
            sprite, (self.rect.x +
                     (self.square_size - sprite.get_width()) / 2, self.rect.y +
                     (self.square_size - sprite.get_height()) / 2 + 1.5))

    def collide(self, surface, player):

        if self.rect.colliderect(player.rect):
            if self.state == "chased":
                # self.pos = [self.start_tile[0] * self.square_size, self.start_tile[1] * self.square_size]

                self.pos[0] = 9 * self.square_size
                self.pos[1] = 9 * self.square_size
                self.rect = pygame.Rect(self.pos[0], self.pos[1],
                                        self.square_size, self.square_size)
                self.exit_spawn_path = [("up", (9, 8)), ("up", (9, 7))]
                player.score += 200
                self.moving_to = (8, 7)
                self.move_direction = "left"
                self.state = "normal"
                print("pac man eat ghost")
            else:
                player.killed = True
                print("ghost eat pac man")
Пример #16
0
    graphics.g_explosion.explode03, graphics.g_explosion.explode04,
    graphics.g_explosion.explode05, graphics.g_explosion.explode06,
    graphics.g_explosion.explode07, graphics.g_explosion.explode08,
    graphics.g_explosion.explode09
]
popFrames = [
    graphics.g_explosion.pop01, graphics.g_explosion.pop02,
    graphics.g_explosion.pop03, graphics.g_explosion.pop04,
    graphics.g_explosion.pop05
]

# Init classes
player = Player(playerPos[0], playerPos[1], 20, 75, 1)
audio = Audio(g_sound)

waves = Anim(oceanWaves, 8)
# Animation setup - Array of graphic images and the speed of the animation (lower = faster)
#playerAnimTurnLeft = Anim([graphics.g_player., graphics.g_player., graphics.g_player.], 4)
#playerAnimTurnRight = Anim([graphics.g_player., graphics.g_player., graphics.g_player.], 4)

print("free", gc.mem_free())


#################################################################################################################
# Init Game
#################################################################################################################
def startLevel(level):
    global enemyList, enemyShips, milkStations, kittyList, dropItem, kittyBoatX, levelComplete

    enemyList = []
    milkStations = []
Пример #17
0
class AvatarSprite(pyglet.sprite.Sprite):
    def __init__(self, avatar):
        self.done = False
        self.avatar = avatar
        self.currentAnim = Anim('subWalkSquash', 5)
        #img = data.pngs['avatar.png']
        pyglet.sprite.Sprite.__init__(self, self.currentAnim.animation, 0, 0)
        events.AddListener(self)
        self.blinkingCounter = 0.0

        self.yoyo = yoyo.YoYo()

        self.shadow = ShadowSprite()
        self.shadow.scale = float(self.width)/self.shadow.width
        self.shadow.opacity = 128

        self.on_key_press = window.window.event(self.on_key_press)
        self.on_key_release = window.window.event(self.on_key_release)
        self.mouseButton = None
        self.on_mouse_press = window.window.event(self.on_mouse_press)
        self.on_mouse_release = window.window.event(self.on_mouse_release)

        self.attackImgs = {Facing.left: data.pngs[self.avatar.attackImg +'_left'],
                           Facing.right: data.pngs[self.avatar.attackImg]}
        self.deadImgs = {Facing.left: data.pngs[self.avatar.deadImg +'_left'],
                         Facing.right: data.pngs[self.avatar.deadImg]}

    def draw(self):
        self.shadow.draw()
        pyglet.sprite.Sprite.draw(self)
        if self.avatar.yoyo and not self.avatar.health == 0:
            if self.avatar.selectedAttack:
                self.avatar.selectedAttack.draw(self.avatar, self.yoyo)
            else:
                self.yoyo.draw()

    def update(self, timeChange=None):
        self.avatar.update(timeChange)
        if self.done:
            return self.cleanup()

        if self.avatar.state == State.attacking:
            self.image = self.attackImgs[self.avatar.facing]
        elif self.avatar.health == 0:
            self.image = self.deadImgs[self.avatar.facing]
        else:
            if self.avatar.facing != self.currentAnim.facing:
                self.currentAnim.flip()
                self.image = self.currentAnim.animation
            elif self.image != self.currentAnim.animation:
                self.image = self.currentAnim.animation
            

        if self.blinkingCounter > 0:
            self.opacity = (10 + self.opacity) % 255
            self.blinkingCounter -= timeChange
        elif not self.opacity == 255:
            self.opacity = 255

        self.x = self.avatar.x
        self.y = self.avatar.y

        self.x += window.bgOffset[0]
        self.y += window.bgOffset[1]

        if self.avatar.yoyo:
            self.avatar.yoyo.gfxYoyo = self.yoyo
            self.yoyo.moveToFeetPos(self.avatar.feetPos,
                                    self.avatar.facing)
            self.yoyo.stringMaxLength = self.avatar.getStringLength()*30

            if not self.avatar.selectedAttack:
                self.yoyo.update(timeChange)

        self.shadow.x = self.x
        self.shadow.y = self.y - (self.shadow.height/2) #shadow center = feetpos
        if self.avatar.health == 0:
            self.shadow.y += 10

    def On_AttackHit(self, attack, attacker, victim):
        if victim == self.avatar:
            self.blinkingCounter = 1.0

    def On_LevelCompletedEvent(self, *args):
        # clean up
        self.done = True

    def cleanup():
        events.RemoveListener(self)
        del self.avatar
        del self.currentAnim
        del self.yoyo
        del self.shadow
        del self.mouseButton
        del self.attackImgs
        del self.deadImgs
        del self.on_key_press
        del self.on_key_release
        del self.on_mouse_press
        del self.on_mouse_release

    def press(self):
        from pyglet.window import key
        if keysPressed.get(key.DOWN):
            self.yoyo.throw('walkthedog')
            self.avatar.setAttack('walkthedog')
        elif keysPressed.get(key.UP):
            self.yoyo.throw('shootthemoon')
            self.avatar.setAttack('shootthemoon')
        else:
            self.yoyo.throw('looping')
            self.avatar.setAttack('looping')
        self.avatar.doAttack()
        
    def on_key_press(self, symbol, modifiers):
        if self.avatar.health == 0:
            return

        from pyglet.window import key
        keysPressed[symbol] = True

        if (keysPressed.get(key.LCTRL) or
            keysPressed.get(key.SPACE)):
            self.press()
        else:
            moveDict = {
                key.UP: self.avatar.On_UpKeyPress,
                key.W: self.avatar.On_UpKeyPress,
                key.RIGHT: self.avatar.On_RightKeyPress,
                key.D: self.avatar.On_RightKeyPress,
                key.DOWN: self.avatar.On_DownKeyPress,
                key.S: self.avatar.On_DownKeyPress,
                key.LEFT: self.avatar.On_LeftKeyPress,
                key.A: self.avatar.On_DownKeyPress,
                }
            fn = moveDict.get(symbol)
            if fn:
                #oldFacing = self.avatar.facing
                fn()
                #print 'old', oldFacing, 'new', self.avatar.facing
                #if self.avatar.facing != oldFacing:
                    #self.currentAnim.flip()


    def release(self):
        self.yoyo.yoyoReturn = True
        self.avatar.fireSpecial()

    def on_key_release(self, symbol, modifiers):
        from pyglet.window import key
        keysPressed[symbol] = False

        if symbol in [key.LCTRL,key.SPACE] and self.yoyo.moveType:
            self.release()

        moveDict = {
            key.UP: self.avatar.On_UpKeyRelease,
            key.W: self.avatar.On_UpKeyRelease,
            key.RIGHT: self.avatar.On_RightKeyRelease,
            key.D: self.avatar.On_RightKeyRelease,
            key.DOWN: self.avatar.On_DownKeyRelease,
            key.S: self.avatar.On_DownKeyRelease,
            key.LEFT: self.avatar.On_LeftKeyRelease,
            key.A: self.avatar.On_LeftKeyRelease,
            }
        fn = moveDict.get(symbol)
        if fn:
            fn()

    def on_mouse_press(self, x, y, button, modifiers):
        self.mouseButton = button
        self.press()
    def on_mouse_release(self, x, y, button, modifiers):
        if self.mouseButton == button:
            self.release()