Ejemplo n.º 1
0
    def __init__(self, screen, on_next):
        super(OnWinScene, self).__init__(screen, on_next,
                                         './assets/ganar_nivel.ogg')
        self.loop = False

        mantillin_sprites = SpriteSheet("mantillin").load_strip(
            (432, 0, 108, 121.5), 1)
        hearts_sprites = SpriteSheet("hearts_un").load_strip((0, 0, 51, 48), 6)

        self.mantillin = sprite.Group([
            Particle(mantillin_sprites,
                     (SCREEN_WIDTH / 2 - mantillin_sprites[0].get_width() / 8,
                      SCREEN_HEIGHT / 3 + mantillin_sprites[0].get_height()),
                     0, 0, 0),
            Particle(
                hearts_sprites,
                (SCREEN_WIDTH / 2 + 1.25 * hearts_sprites[0].get_width(),
                 SCREEN_HEIGHT / 3 + 1.5 * hearts_sprites[0].get_height()), 0,
                0, 0)
        ])

        self.text_title = HeadingFont(60).render("YOU WON", True,
                                                 (3, 169, 244))
        self.text_continue = PixelFont(26).render("press enter to continue",
                                                  True, (255, 255, 255))
        self.star = image.load("assets/star.png").convert_alpha()
    def __init__(self, parent, start_position=Vector2(0.0, 0.0)):
        self.width = globals.screen.get_width()
        self.height = globals.screen.get_height()
        self.font = pygame.font.SysFont('arial', 12)

        UIFrame.__init__(self, start_position, self.width, self.height, parent)
        #WorldObject.__init__(self, start_position, self.screen_size_x, self.screen_size_y, velocity, image_list)

        #self.pause_menu = PauseMenu(font, self.screen_size_x, self.screen_size_y, screen)

        # # Make a chat box.
        # self.chat_box = ChatBox(player_heads_up_display=self)

        # Load sprite sheets.
        self.health = 0
        self.max_health = 0
        crosshair_sheet = SpriteSheet("resources/images/Crosshair Sheet.png")
        sprite_sheet = SpriteSheet("resources/images/Sprite Sheet1.png")

        # Load crosshair.
        self.crosshair = BlitData(
            crosshair_sheet.imageAt(pygame.Rect(176, 158, 46, 48)))

        # load health bar info
        self.hp_overlay = BlitData(
            sprite_sheet.imageAt(pygame.Rect(652, 373, 290, 90)), (0, 0))
        self.hp_bar = BlitData(
            sprite_sheet.imageAt(pygame.Rect(722, 485, 213, 40)), (64, 22))
        self.mana_bar = BlitData(
            sprite_sheet.imageAt(pygame.Rect(722, 529, 146, 20)), (68, 65),
            (0, 0, 159, 20))

        # set colorkey so black pixels will be transparent
        # self.image.set_colorkey(BLACK)  # set black to transparent
        # self.image.fill(BLACK)

        # ammo and weapon data
        self.ammo_string = "send me text"
        self.weapon_string = "send me text"
        self.ammo_string_surface = self.font.render(self.ammo_string, True,
                                                    [255, 255, 255])
        self.weapon_string_surface = self.font.render(self.weapon_string, True,
                                                      [255, 255, 255])
        self.ammo_blit = BlitData(self.ammo_string_surface,
                                  (globals.screen.get_width() / 1.16,
                                   globals.screen.get_height() / 1.11))
        self.weapon_blit = BlitData(self.weapon_string_surface,
                                    (globals.screen.get_width() / 1.16,
                                     globals.screen.get_height() / 1.066))
        # order this list in which one you want blit first.  top picture = last in the list.
        #self.blit_list = [self.hp_overlay, self.hp_bar, self.ammo_blit, self.weapon_blit, self.crosshair]
        self.blit_list = [
            self.hp_overlay, self.hp_bar, self.mana_bar, self.ammo_blit,
            self.weapon_blit, self.crosshair
        ]
Ejemplo n.º 3
0
def run_game():
    # Initialize pygame, settings, and screen object.
    pygame.mixer.pre_init(44100, -16, 2, 2048)
    pygame.mixer.init()
    pygame.init()
    game_settings = GameSettings()
    screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height))
    pygame.display.set_caption("Pac Man Portal")

    # Open sprite sheet
    sprite_sheet = SpriteSheet(file_name='images/spritesheet.png')

    # Make the Play and Scores button.
    play_button = Button(screen=screen, msg="Play", order=0)
    score_button = Button(screen=screen, msg="High Scores", order=1)

    # Open high score file
    try:
        high_score_file = open("high_score_file.txt", "r+")
    except FileNotFoundError:
        high_score_file = open("high_score_file.txt", "w+")

    # Open maze layout file
    maze_file = open('mazelayout.txt', 'r')

    # Make sound manager
    sounds = Sounds()

    # Initialize game stats and scoreboard
    stats = GameStats(game_settings=game_settings)
    sb = Scoreboard(screen=screen, game_settings=game_settings, stats=stats, sprite_sheet=sprite_sheet,
                    high_score_file=high_score_file, sounds=sounds)

    # Initialize pacman
    pacman = Pacman(screen=screen, game_settings=game_settings, stats=stats, sb=sb,
                    image_list=sprite_sheet.pacman_image, death_anim_list=sprite_sheet.pacman_death_image,
                    sounds=sounds)

    # Initialize maze
    maze = Maze(screen=screen, game_settings=game_settings, maze_file=maze_file, sprite_sheet=sprite_sheet,
                pacman=pacman, sounds=sounds)

    # Initialize the event handler
    event_handler = EventHandler(pacman=pacman, play_button=play_button, score_button=score_button, stats=stats, sb=sb,
                                 maze=maze, sounds=sounds)

    # Initialize the display manager
    display = Display(screen=screen, game_settings=game_settings, stats=stats, sb=sb, sprite_sheet=sprite_sheet,
                      play_button=play_button, score_button=score_button, maze=maze, pacman=pacman,
                      event_handler=event_handler, sounds=sounds)

    # Start the main loop for the game
    while True:
        event_handler.check_events()
        if stats.game_active:
            pacman.update(maze=maze, display=display)
            maze.update_ghosts()
            maze.update_bullets()
            maze.update_portals()
        display.update_screen()
Ejemplo n.º 4
0
    def __init__(self, bullet_image_list):

        sprite_sheet_1 = SpriteSheet("resources/images/Sprite Sheet1.png")
        image_list = [
            sprite_sheet_1.imageAt(pygame.Rect(732, 316, 58, 30)),
            sprite_sheet_1.imageAt(pygame.Rect(811, 315, 84, 40))
        ]

        reload_time = 2
        accuracy = .1
        damage = 10
        ammo = 30
        max_ammo = 30
        delay = .8
        bullet_velocity = 1000
        width = 58
        height = 30
        look_left_offset = 16
        gun_x_position = -9.0
        gun_y_position = -13.0

        Gun.__init__(self, bullet_velocity, delay, damage, ammo, max_ammo,
                     reload_time, accuracy, image_list, gun_x_position,
                     gun_y_position, width, height, look_left_offset)

        ServerPistol.__init__(self)
        self.bullet_image_list = bullet_image_list
Ejemplo n.º 5
0
    def __init__(self, bullet_image_list):
        bullet_velocity = 800
        sprite_sheet_1 = SpriteSheet("resources/images/Sprite Sheet1.png")
        image_list = [
            sprite_sheet_1.imageAt(pygame.Rect(966, 332, 35, 21)),
            sprite_sheet_1.imageAt(pygame.Rect(471, 93, 102, 40))
        ]
        gun_x_position = 7.0
        gun_y_position = 0.0
        delay = 1
        damage = 5
        ammo = 30
        max_ammo = 30
        reload_time = 2.0
        accuracy = .07
        width = 35
        height = 21
        look_left_offset = -16

        Gun.__init__(self, bullet_velocity, delay, damage, ammo, max_ammo,
                     reload_time, accuracy, image_list, gun_x_position,
                     gun_y_position, width, height, look_left_offset)

        ServerShotgun.__init__(self)

        self.bullet_image_list = bullet_image_list
Ejemplo n.º 6
0
    def __init__(self):
        sprites = SpriteSheet("pecha").load_strip((0, 0, 109, 85), 4)
        super(Pechatron, self).__init__(sprites, (SCREEN_WIDTH / 2, SCREEN_HEIGHT * .2), 0.1)

        self.movement_vectors = [(1, 0)]
        self.max_life = 100
        self.life = 100
Ejemplo n.º 7
0
    def load_shields(self):
        sprites = SpriteSheet("shields").load_strip((0, 0, 87, 84), 4)

        return [
            Shield([sprites[i]],
                   (.20 * (i + 1) * SCREEN_WIDTH, SCREEN_HEIGHT * 0.75))
            for i in range(len(sprites))
        ]
Ejemplo n.º 8
0
 def __init__(self, rect, order):
     self.surface = None
     self.rect = rect
     self.order = int(order)
     self.sound_pickup = self.sound_pickup = pygame.mixer.Sound(
         self.__SOUND_PICKUP)
     self.__frames = SpriteSheet(self.__IMAGE_PATH, (25, 25)).frames
     self.reset()
     self.index = Lamp._current_index
     Lamp._current_index += 1
     print "Index %s is order %s " % (self.index, self.order)
    def __init__(self, start_position, ready=False):
        MenuObject.__init__(self, start_position)

        self.ready = False if not ready else True

        # Import ready status indicator images.
        ready_status_indicator_sheet = SpriteSheet(
            'resources/images/ready_status_indicators.png')
        ready_status_image_list = [
            ready_status_indicator_sheet.imageAt(pygame.Rect(0, 0, 15, 15)),
            ready_status_indicator_sheet.imageAt(pygame.Rect(15, 0, 15, 15))
        ]
        self.image_list = ready_status_image_list
Ejemplo n.º 10
0
def init():
    global camera
    global current_screen
    global online_game
    global screen

    #menu images
    global button_img_list
    global join_game_img_list
    global forward_button_img_list
    global back_button_img_list
    global text_field_img_list
    global ready_button_img_list
    global small_forward_button_img_list
    global small_back_button_img_list
    global close_button_img_list

    #cycle button contents
    global map_names

    #sounds
    global button_1_sound

    current_screen = "main menu"
    screen_size = pygame.display.list_modes()[0]
    screen = pygame.display.set_mode(screen_size, DOUBLEBUF)

    #import button images
    button_sheet = SpriteSheet("resources/images/ButtonSpriteSheet.png")
    button_img_list = [button_sheet.imageAt(pygame.Rect(475, 306, 80, 19), None)]
    join_game_img_list = [button_sheet.imageAt(pygame.Rect(497, 281, 33, 10))]
    forward_button_img_list = [button_sheet.imageAt(pygame.Rect(0, 76, 50, 278), None)]
    back_button_img_list = [button_sheet.imageAt(pygame.Rect(54, 76, 50, 278), None)]
    small_forward_button_img_list = [button_sheet.imageAt(pygame.Rect(494, 226, 18, 15)),
                                     button_sheet.imageAt(pygame.Rect(494, 243, 18, 15))]
    small_back_button_img_list = [button_sheet.imageAt(pygame.Rect(516, 242, 18, 15)),
                                  button_sheet.imageAt(pygame.Rect(516, 225, 18, 15))]
    text_field_img_list = [button_sheet.imageAt(pygame.Rect(479, 278, 75, 12), None),
                           button_sheet.imageAt(pygame.Rect(479, 293, 75, 12), None)]
    ready_button_img_list = [button_sheet.imageAt(pygame.Rect(0, 0, 157, 38), None),
                             button_sheet.imageAt(pygame.Rect(0, 38, 157, 38), None)]
    close_button_img_list = [button_sheet.imageAt(pygame.Rect(108, 77, 44, 44), None)]

    #populate cycle_button elements
    map_names = [Label(euclid.Vector2(0, 0), "Matt World"),
                 Label(euclid.Vector2(0, 0), "Fun Zone"),
                 Label(euclid.Vector2(0, 0), "Snake Juice")]

    #sounds
    button_1_sound = pygame.mixer.Sound("resources/sounds/menu_button.wav")
Ejemplo n.º 11
0
    def __init__(self, screen, on_next):
        super(OnLoseScene, self).__init__(screen, on_next,
                                          './assets/muerte.ogg')

        mantillin_sprites = SpriteSheet("mantillin").load_strip(
            (540, 0, 108, 121.5), 1)
        self.mantillin = sprite.Group([
            Particle(mantillin_sprites,
                     (SCREEN_WIDTH / 2 - mantillin_sprites[0].get_width() / 8,
                      SCREEN_HEIGHT / 2), 0, 0, 0)
        ])
        self.text_title = HeadingFont(60).render("GAME OVER", True,
                                                 (233, 30, 99))
        self.text_continue = PixelFont(26).render("press enter to continue",
                                                  True, (255, 255, 255))
        self.star = image.load("assets/star.png").convert_alpha()
Ejemplo n.º 12
0
    def __init__(self, image):
        #initialize the class with the base class
        pygame.sprite.Sprite.__init__(self)
        self.size = 50
        try:
            self.ss = SpriteSheet(image)
            self.image = self.ss.image_at((0, 0, 32, 32), (255, 0, 255))
            self.image.convert()
            self.image = pygame.transform.scale(self.image, [self.size] * 2)
        except:
            self.image = pygame.Surface([self.size] * 2)
            self.image.fill((0, 0, 0))
        # print self.image
        self.speed = self.size
        # self.image.fill((255, 255, 255))

        self.keys = [K_UP, K_DOWN, K_LEFT, K_RIGHT]
        self.rect = self.image.get_rect()
Ejemplo n.º 13
0
    def __init__(self, screen):
        super(StartScene, self).__init__(screen)

        mantillin_sprites = SpriteSheet("mantillin").load_strip(
            (0, 0, 108, 121.5), 4)

        self.text_title = HeadingFont(45).render("UNAL", True, (3, 169, 244))
        self.text_subtitle = HeadingFont(60).render("INVADERS", True,
                                                    (233, 30, 99))
        self.text_start = PixelFont(26).render("press enter to start", True,
                                               (255, 255, 255))
        self.star = pygame.image.load("assets/star.png").convert_alpha()

        self.mantillin = sprite.Group([
            Particle(mantillin_sprites,
                     (SCREEN_WIDTH / 2 - mantillin_sprites[0].get_width() / 8,
                      SCREEN_HEIGHT / 3 + 2 * self.text_subtitle.get_height()),
                     0, 0, 0)
        ])
Ejemplo n.º 14
0
    def __init__(self, name, x, y, animation_speed=200):
        super().__init__()

        self.sprite_sheet = SpriteSheet(f'{name}.png')
        self.image = pygame.image.load('cell.png')
        self.rect = self.image.get_rect()
        self.position = [x, y]
        self.feet = pygame.Rect(0, 0, self.rect.width * 0.5, 12)

        # vie
        self.health = 100
        self.max_health = 100

        # animation
        self.old_position = self.position
        self.current_animation_index = 0
        self.animation_speed = animation_speed
        self.cooldown = 0
        self.speed = 1
Ejemplo n.º 15
0
    def __init__(self, icon_filename, surface):
        self.button_names = (RUN, STOP, SAVE, LOAD, CHANGE_COLOR)
        self.surface = surface
        self.button_count = 5
        self.button_size = 16
        self.button_margin = 2
        width = ((self.button_size * self.button_count) +
                 (self.button_margin * (self.button_count + 1)))
        height = self.button_size + self.button_margin * 2
        self.tray_size = (width, height)
        self.top_left = [(surface.get_size()[X] - width - 3),
                         (surface.get_size()[Y] - height) - 3]
        self.tray = pygame.Rect(self.top_left, self.tray_size)

        self.sprites = SpriteSheet(icon_filename)
        # the icons don't use alpha transparency - bg color is fixed
        #self.up_buttons = self.sprites.load_strip(
        #    pygame.Rect(0, 0, self.button_size, self.button_size),
        #    self.button_count)
        #self.down_buttons = self.sprites.load_strip(
        #    pygame.Rect(self.button_size * self.button_count, 0,
        #                self.button_size, self.button_size),
        #    self.button_count)
        self.buttons = {}
        up_pos = [0, 0]
        down_pos = [self.button_size * self.button_count, 0]
        size = (self.button_size, self.button_size)
        self.buttons = {}
        for name in self.button_names:
            self.buttons[name] = \
                     {UP: self.sprites.image_at(pygame.Rect(up_pos, size)),
                      DOWN: self.sprites.image_at(pygame.Rect(down_pos, size))}
            up_pos[X] += self.button_size
            down_pos[X] += self.button_size

        self.button_state = {
            RUN: UP,
            SAVE: UP,
            STOP: UP,
            LOAD: UP,
            CHANGE_COLOR: UP
        }
Ejemplo n.º 16
0
    def __init__(self, screen, type_fruit):
        super(Fruit, self).__init__()
        self.is_dead = False
        self.type_fruit = type_fruit
        self.points = 0
        self.position = [(35, 50, 14, 14), (52, 50, 14, 14), (67, 50, 14, 14),
                         (83, 50, 14, 14), (100, 50, 14, 14),
                         (115, 50, 14, 14), (132, 50, 14, 14),
                         (147, 50, 14, 14)]
        self.location_x = 600
        self.location_y = 585
        self.screen = screen
        self.sprite_sheet = SpriteSheet('sprites/pacman.png')

        self.image = self.sprite_sheet.image_at(self.position[self.type_fruit],
                                                None)
        self.image = pygame.transform.scale(self.image, (30, 30))
        self.rect = self.image.get_rect()
        self.rect.x = self.location_x
        self.rect.y = self.location_y
Ejemplo n.º 17
0
    def __init__(self, bullet_image_list):
        #load image for bigbertha
        image_list = []  # override gun's image list
        sprite_sheet_1 = SpriteSheet("resources/images/Sprite Sheet1.png")
        image_list.append(
            sprite_sheet_1.imageAt(pygame.Rect(726, 131, 146, 34)))
        image_list.append(
            sprite_sheet_1.imageAt(pygame.Rect(726, 187, 146, 34)))
        bullet_velocity = 1100
        delay = .8
        damage = 420
        ammo = 10
        max_ammo = 10
        reload_time = 1.5
        accuracy = 0.2

        Gun.__init__(self, bullet_velocity, delay, damage, ammo, max_ammo,
                     reload_time, accuracy, image_list)

        ServerGrenadeLauncher.__init__(self)

        self.bullet_image_list = bullet_image_list
Ejemplo n.º 18
0
 def __init__(self, position):
     sprites = SpriteSheet("aliens").load_strip((264, 0, 70, 54), 4)
     super(TennisAlien, self).__init__(sprites, position, 0.25)
Ejemplo n.º 19
0
    def __init__(self, screen, pacmen, ghosts, maze, scoreboard):
        super(PacMan, self).__init__()

        self.maze = maze
        self.scoreboard = scoreboard
        self.pacmen = pacmen
        self.ghosts = ghosts
        self.next_direction = ''
        self.direction = ''
        self.no_node = False
        self.right_stopper = False
        self.left_stopper = False
        self.up_stopper = False
        self.down_stopper = False
        self.dont_stop = False
        self.right_allowed = False
        self.left_allowed = False
        self.up_allowed = False
        self.down_allowed = False

        self.a = False
        self.b = False
        self.c = False
        self.d = False
        self.e = False
        self.f = False
        self.g = False
        self.h = False
        self.i = False
        self.j = False
        self.k = False
        self.l = False
        self.m = False

        # each of these are coordinates to the location and size
        # of the sprite on the sheet
        self.is_big = False
        self.big_open = (35, 15, 30, 35)
        self.big_mid = (65, 15, 34, 35)
        self.big_close = (97, 15, 35, 34)

        self.up_open = (4, 30, 16, 16)
        self.up_mid = (19, 30, 16, 16)
        self.close = (34, 0, 15, 15)

        self.down_open = (4, 47, 16, 16)
        self.down_mid = (19, 47, 16, 16)

        self.left_open = (4, 15, 16, 16)
        self.left_mid = (19, 15, 16, 16)

        self.right_open = (4, 0, 15, 15)
        self.right_mid = (20, 0, 15, 15)

        self.destroy_wait = 100
        self.destroy_last = 0
        self.animate = 0
        self.is_dead = False
        self.destroy = [(50, 0, 15, 15), (67, 0, 15, 15), (83, 0, 15, 15),
                        (98, 0, 16, 15), (115, 0, 16, 15), (130, 0, 16, 15),
                        (146, 0, 16, 15), (161, 0, 16, 15), (176, 0, 16, 15),
                        (191, 0, 16, 15), (208, 0, 16, 16)]

        self.position = self.big_open
        self.location_x = 0
        self.location_y = 220
        self.screen = screen
        self.sprite_sheet = SpriteSheet('sprites/pacman.png')

        self.image = self.sprite_sheet.image_at(self.position, None)
        if not self.is_big:
            self.image = pygame.transform.scale(self.image, (30, 30))
        self.rect = self.image.get_rect()
        self.rect.x = self.location_x
        self.rect.y = self.location_y

        self.ismoving = False
        self.ismoving_up = False
        self.ismoving_down = False
        self.ismoving_right = False
        self.ismoving_left = False

        self.wait_count = 100
        self.last = 0
        self.time = pygame.time.get_ticks()
        self.animation_counter = 1
        self.moving_speed = 4.00
Ejemplo n.º 20
0
    def __init__(self, **argd):
        self.__dict__.update(**argd)
        super(MainScreen, self).__init__(**argd)

        # create a display image. standard pygame stuff
        self.display = pygame.display.set_mode(self.size, 0)
        self.background = pygame.Surface(SCREEN_RECT.size)

        # Initialize camera
        if ARGS.camera:
            self.init_cams(0)

        # Load graphics
        deafy_sheet = SpriteSheet("data/Undertale_Annoying_Dog.png")
        cat_sheet = SpriteSheet("data/cat.png")

        Deafy.images = [
            deafy_sheet.image_at((2, 101, 22 - 2, 119 - 101),
                                 colorkey=-1,
                                 width_height=(20 * 2, 18 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((2, 204, 26 - 2, 216 - 204),
                                 colorkey=-1,
                                 width_height=(24 * 2, 12 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((2, 182, 23 - 2, 200 - 182),
                                 colorkey=-1,
                                 width_height=(21 * 2, 18 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((25, 182, 44 - 25, 200 - 182),
                                 colorkey=-1,
                                 width_height=(19 * 2, 18 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((2, 101, 22 - 2, 119 - 101),
                                 colorkey=-1,
                                 width_height=(20 * 2, 18 * 2),
                                 flip_x=True,
                                 flip_y=True),
        ]
        Sky.images = [load_image('sky.png', (32, 32))]
        Ground.images = [load_image('grass.png', (32, 32))]
        GroundObstacle.images = [
            load_image('grass.png', (32, 32)),
            load_image('sky.png', (32, 32))
        ]
        CatObstacle.images = [
            cat_sheet.image_at((0, 0, 54, 42), colorkey=-1),
            cat_sheet.image_at((1, 158, 54, 42), colorkey=-1),
            cat_sheet.image_at((1 + 54, 158, 54, 42), colorkey=-1),
            cat_sheet.image_at((1 + 54 * 2, 158, 54, 42), colorkey=-1),
            cat_sheet.image_at((1 + 54 * 3, 158, 54, 42), colorkey=-1),
        ]
        # Load sounds
        Deafy.sounds = [
            load_sound("normal.ogg"),
            load_sound("jump.ogg"),
            load_sound("victory.ogg")
        ]

        # Initialize Game Groups
        self.all = pygame.sprite.RenderUpdates()
        self.background_group = pygame.sprite.RenderUpdates()
        self.obstacle_group = pygame.sprite.RenderUpdates()
        # Sprites in this group are rendered after background so that they appear on the top.
        self.front_group = pygame.sprite.RenderUpdates()

        # assign default groups to each sprite class
        Deafy.containers = self.all, self.front_group
        Ground.containers = self.all, self.background_group
        Sky.containers = self.all, self.background_group
        GroundObstacle.containers = self.all, self.obstacle_group
        CatObstacle.containers = self.all, self.front_group
        Dialog.containers = self.all

        # initialize stage
        self.stage = Stage(num=1)
        self.current_items = []

        # TODO: Maybe the height and width are the other way around
        self.ground_sprites = [
            Ground(pos=(w * BACKGROUND_OBJECT_WIDTH,
                        h * BACKGROUND_OBJECT_HEIGHT))
            for w in range(SCREEN_WIDTH / BACKGROUND_OBJECT_WIDTH + 1)
            for h in range(GROUND_Y_LIMITS[0] / BACKGROUND_OBJECT_HEIGHT +
                           1, GROUND_Y_LIMITS[1] / BACKGROUND_OBJECT_HEIGHT +
                           1)
        ]
        self.sky_sprites = [
            Sky(pos=(w * BACKGROUND_OBJECT_WIDTH,
                     h * BACKGROUND_OBJECT_HEIGHT))
            for w in range(SCREEN_WIDTH / BACKGROUND_OBJECT_WIDTH + 1)
            for h in range(SKY_Y_LIMITS[0] / BACKGROUND_OBJECT_HEIGHT +
                           1, SKY_Y_LIMITS[1] / BACKGROUND_OBJECT_HEIGHT + 1)
        ]
        self.deafy = Deafy(pos=DEAFY_SCREEN_POS)
        self.ground_obstacle_sprites = []
        self.cat_obstacles = []

        # Now initialize the FacialLandmarkDetector
        self.fld = FacialLandmarkDetector(SCREEN_WIDTH, SCREEN_HEIGHT,
                                          FACIAL_LANDMARK_PREDICTOR_WIDTH)
        self.dx = INITIAL_DX
        self.visible_xrange = [0, SCREEN_WIDTH]

        # to track of which dialog frame shold be rendered
        self.dialog_frame = 0
        # To trach whether dialog is displayed now. If so, disable user control.
        self.is_dialog_active = True
Ejemplo n.º 21
0
def run_game():
    # Initialize pygame, settings, and screen object.
    pygame.mixer.pre_init(44100, -16, 2, 2048)
    pygame.mixer.init()
    pygame.init()
    clock = pygame.time.Clock()
    clock.tick(60)
    ai_settings = Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Alien Invader")

    # Import sprite sheet
    sprite_sheet = SpriteSheet(file_name='images/spritesheet.png')

    # Make the Play and Scores button.
    play_button = Button(screen=screen, msg="Play", order=0)
    score_button = Button(screen=screen, msg="High Scores", order=1)

    # Open high score file
    try:
        high_score_file = open("high_score_file.txt", "r+")
    except FileNotFoundError:
        high_score_file = open("high_score_file.txt", "w+")

    # Make sound manager
    sounds = Sounds()

    # Create an instance to store game statistics and create a scoreboard.
    stats = GameStats(ai_settings=ai_settings)
    sb = Scoreboard(ai_settings=ai_settings,
                    screen=screen,
                    stats=stats,
                    sprite_sheet=sprite_sheet,
                    high_score_file=high_score_file)

    # Make the game objects.
    ship = Ship(ai_settings=ai_settings,
                screen=screen,
                sprite_sheet=sprite_sheet,
                stats=stats,
                sb=sb,
                sounds=sounds)
    explosions = Group()
    barriers = []
    fleet = Fleet(ai_settings=ai_settings,
                  screen=screen,
                  sprite_sheet=sprite_sheet,
                  sounds=sounds)
    bullets = Bullets(ai_settings=ai_settings,
                      screen=screen,
                      sprite_sheet=sprite_sheet,
                      stats=stats,
                      sb=sb,
                      ship=ship,
                      fleet=fleet,
                      barriers=barriers,
                      explosions=explosions,
                      sounds=sounds)

    # Make the event handler
    event_handler = EventHandler(ai_settings=ai_settings,
                                 play_button=play_button,
                                 score_button=score_button,
                                 stats=stats,
                                 sb=sb,
                                 ship=ship,
                                 bullets=bullets,
                                 fleet=fleet,
                                 sounds=sounds)

    # Make the display manager
    display = Display(ai_settings=ai_settings,
                      screen=screen,
                      sprite_sheet=sprite_sheet,
                      play_button=play_button,
                      score_button=score_button,
                      stats=stats,
                      sb=sb,
                      ship=ship,
                      bullets=bullets,
                      fleet=fleet,
                      barriers=barriers,
                      explosions=explosions,
                      event_handler=event_handler)

    # Start the main loop for the game.
    while True:
        event_handler.check_events(display=display)

        if stats.game_active:
            ship.update()
            bullets.update_bullets(display=display)
            fleet.update_aliens(ship=ship, display=display, bullets=bullets)
            fleet.update_ufos()

        display.update_screen()
Ejemplo n.º 22
0
    def __init__(self, screen, color):
        super(Ghost, self).__init__()
        self.screen = screen

        # the number of the color will be 0 through 5
        # 0 = pink, 1 = red, 2 = orange, 3 = blue, 4 = white, 5 = blue
        self.color = color

        self.right = (4, self.color, 15, 15)
        self.right_in = (20, self.color, 15, 15)
        self.left = (35, self.color, 15, 15)
        self.left_in = (52, self.color, 15, 15)
        self.up = (68, self.color, 15, 15)
        self.up_in = (84, self.color, 15, 15)
        self.down = (100, self.color, 15, 15)
        self.down_in = (115, self.color, 15, 15)

        self.is_blue = False
        self.blue_last = 0
        self.blue_wait = 5000
        self.is_white = False
        self.white_last = 0
        self.white_wait = 1000
        self.white = (163, 65, 15, 15)
        self.white_in = (180, 65, 15, 15)
        self.blue = (132, 65, 15, 15)
        self.blue_in = (148, 65, 15, 15)

        self.eye = False
        self.is_dead = False
        self.destroyed = False
        self.destroy_last = 0
        self.destroy_wait = 1000
        self.eye_right = (132, 81, 15, 15)
        self.eye_left = (148, 81, 15, 15)
        self.eye_up = (163, 81, 15, 15)
        self.eye_down = (180, 81, 15, 15)

        self.position = [self.up, self.up_in]
        self.location_x = 100
        self.location_y = 220
        self.screen = screen
        self.sprite_sheet = SpriteSheet('sprites/pacman.png')

        self.image = self.sprite_sheet.image_at(self.position[0], None)
        self.image = pygame.transform.scale(self.image, (30, 30))
        self.rect = self.image.get_rect()
        self.rect.x = self.location_x
        self.rect.y = self.location_y

        self.ismoving = False
        self.ismoving_up = False
        self.ismoving_down = False
        self.ismoving_right = False
        self.ismoving_left = False

        self.wait_count = 0
        self.time = pygame.time.get_ticks()
        self.animation_counter = 0
        self.moving_speed = 4

        self.intro = False
        self.intro_blinky = False
        self.intro_pinky = False
        self.intro_inky = False
        self.intro_clyde = False
        self.title_blinky = False
        self.title_pinky = False
        self.title_inky = False
        self.title_clyde = False
        self.title_last = 0
        self.wait = 1000
        self.wait_count = 100
        self.last = 0

        self.route = ['dG', 'dH', 'fH', 'hH', 'iH', 'iG', 'jG', 'jF']
        self.speed = 1
        self.dijkstra_graph = {}
        self.node_count = 1
        self.next_route = True
        self.move_nodes = True
        self.final_distance = 0
        self.move_count = 0
Ejemplo n.º 23
0
 def __init__(self, position):
     gun = SpriteSheet('bullets').load_strip((0, 0, 23, 22), 4)
     super(TennisBullet, self).__init__(gun, position, 10, 5, (-1, 1))
     self.life = 10
Ejemplo n.º 24
0
from settings import (SCREEN_WIDTH, SCREEN_HEIGHT, SPRITE_SCALE)
from sprite_sheet import SpriteSheet
from player import Player
from enemy import Enemy
from beam import Beam

#사운드 초기화
pygame.mixer.init()

pygame.init()

screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])

#스프라이트 로드
#스프라이트는 opengameart.org
sheet = SpriteSheet("sprites\\sheet.png", "sprites\\sheet.xml")

#배경 서피스 설정
bg = pygame.image.load("sprites\\bg_darkPurple.png")
bg_width = bg.get_width()
bg_height = bg.get_height()
bg_surface = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT))
for y in range(0, SCREEN_HEIGHT, bg_height):
    for x in range(0, SCREEN_WIDTH, bg_width):
        bg_surface.blit(bg, (x, y))

#게임 속도 설정을 위한 시계
clock = pygame.time.Clock()

#event는 int로 정의되는데,
#USEREVENT가 가장 마지막에 위치하므로 +1로 새로운 이벤트 정의
Ejemplo n.º 25
0
    def __init__(self,
                 always_visible=False,
                 x_offset=0,
                 y_offset=0,
                 box_width=None,
                 box_height=None,
                 max_chars=65,
                 player_heads_up_display=None,
                 screen=None):
        self.screen = screen
        self.always_visible = always_visible
        self.max_chars = max_chars
        self.view_offset = 0  # The part of the text log you're viewing.  0 is the most recent on the bottom.

        # These values move the ChatBox from it's default position at the bottom left hand corner of the screen.
        self.x_offset = x_offset
        self.y_offset = y_offset

        self.hidden = not self.always_visible  # while this is true the ChatBox shouldn't be displayed.
        self.alpha = 255
        self.delaying_to_fade = False
        self.is_fading = False  # while this is true, the ChatBox text is fading to transparency.
        self.fade_delay = 3  # seconds after the ChatBox is deselected until the text starts to fade.
        self.fade_time = 2  # seconds that it fades for after the fadeDelay
        self.last_deselect_time = 0  # time that the fade process started.
        self.last_fade_start_time = 0
        self.selected = False
        self.fade_proportion = 0  # This will hold the proportion to convert the time to terms of opacity (0-255)
        self.font = pygame.font.SysFont('arial', 12)

        self.cursor_blink_time = 1.5  # the cursor will change every half of this number
        self.last_cursor_blink = 0
        self.cursor_is_blinking = False
        self.cursor_surface = self.font.render("|", True, [255, 255, 255])

        self.text_content = []  # list of strings. lower index = older
        self.input = None  # a string of input to send to the textBox.
        self.surface_content = [
        ]  # a list of surface slices. lower index = older
        self.border_offset = 14  # offset text by ten pixels to account for the border of the chatBox
        self.blit_dict = {}
        self.alpha_blit_dict = {}

        temp_sprite_sheet = SpriteSheet("resources/images/Sprite Sheet1.png")
        self.box_image = temp_sprite_sheet.imageAt(pygame.Rect(
            5, 15, 370, 135))
        # this image is cursed to never change color.
        self.unfocused_image = temp_sprite_sheet.imageAt(
            pygame.Rect(6, 158, 368, 130))
        if box_width is not None and box_height is not None:
            self.box_image = pygame.transform.scale(self.box_image,
                                                    (box_width, box_height))
            self.unfocused_image = pygame.transform.scale(
                self.box_image, (box_width, box_height))
        self.image = self.box_image  # everything will be blit onto here.

        self.shift_is_pressed = False

        if hasattr(globals, 'online_game'):
            self.last_message_received = 0
            self.get_new_messages_thread = RepeatTask(1, self.get_new_messages)
            self.get_new_messages_thread.start()

        self.player_heads_up_display = player_heads_up_display
        self.last_paused = datetime.now()
    def load_sprite_images(self):
        """
        gets images from sprite sheets
        """

        # sprite sheets
        effectSheet = SpriteSheet("resources/images/Effects Spritesheet.png")
        explosionSheet = SpriteSheet("resources/images/explosion.png")
        lunar_pioneer_sheet = SpriteSheet("resources/images/lunar pioneer.png")
        background_objects_sheet = SpriteSheet(
            "resources/images/grandfather clock.png")
        dust_sheet = SpriteSheet("resources/images/Dust Spritesheet.png")

        #lightning
        self.lightning_animation = [
            effectSheet.imageAt(pygame.Rect(654, 886, 34, 14)),
            effectSheet.imageAt(pygame.Rect(705, 885, 32, 14)),
            effectSheet.imageAt(pygame.Rect(750, 872, 62, 40)),
            effectSheet.imageAt(pygame.Rect(826, 871, 68, 37)),
            effectSheet.imageAt(pygame.Rect(911, 881, 72, 29))
        ]
        #putting explosion into big bertha
        berthaImage.append(explosionSheet.imageAt(pygame.Rect(22, 115, 72,
                                                              63)))
        berthaImage.append(
            explosionSheet.imageAt(pygame.Rect(110, 108, 99, 81)))
        berthaImage.append(
            explosionSheet.imageAt(pygame.Rect(384, 116, 103, 88)))
        berthaImage.append(
            explosionSheet.imageAt(pygame.Rect(509, 27, 110, 80)))
        berthaImage.append(explosionSheet.imageAt(pygame.Rect(650, 29, 84,
                                                              72)))

        #lunar pioneer images
        self.lunar_pioneer_images = [
            lunar_pioneer_sheet.imageAt(pygame.Rect(35, 25, 20, 20)),
            lunar_pioneer_sheet.imageAt(pygame.Rect(101, 26, 20, 20))
        ]
        #grandfather clock images
        self.grandfather_clock = [
            background_objects_sheet.imageAt(pygame.Rect(7, 12, 18, 71)),
            background_objects_sheet.imageAt(pygame.Rect(39, 12, 18, 71)),
            background_objects_sheet.imageAt(pygame.Rect(71, 12, 18, 71)),
            background_objects_sheet.imageAt(pygame.Rect(39, 12, 18, 71))
        ]
        #spawn images
        self.spawn_animation = [
            effectSheet.imageAt(pygame.Rect(291, 695, 2, 217)),
            effectSheet.imageAt(pygame.Rect(281, 695, 2, 217)),
            effectSheet.imageAt(pygame.Rect(270, 695, 2, 217)),
            effectSheet.imageAt(pygame.Rect(270, 695, 2, 217)),
            effectSheet.imageAt(pygame.Rect(260, 695, 4, 217)),
            effectSheet.imageAt(pygame.Rect(242, 695, 12, 216)),
            effectSheet.imageAt(pygame.Rect(215, 695, 22, 217)),
            effectSheet.imageAt(pygame.Rect(180, 695, 30, 217)),
            effectSheet.imageAt(pygame.Rect(148, 695, 22, 217)),
            effectSheet.imageAt(pygame.Rect(108, 695, 30, 217)),
            effectSheet.imageAt(pygame.Rect(53, 695, 48, 217)),
            effectSheet.imageAt(pygame.Rect(4, 695, 46, 217))
        ]

        self.spawn_animation = normalize_rects(self.spawn_animation)
        #dust cloud
        #dust_sheet.imageAt(pygame.Rect(544, 250, 82, 17))  # this image is just broken for no reason.
        self.dust_cloud = [
            dust_sheet.imageAt(pygame.Rect(156, 28, 150, 41)),
            dust_sheet.imageAt(pygame.Rect(351, 20, 189, 58)),
            dust_sheet.imageAt(pygame.Rect(2, 130, 196, 61)),
            dust_sheet.imageAt(pygame.Rect(257, 141, 194, 57)),
            dust_sheet.imageAt(pygame.Rect(3, 230, 198, 57)),
            dust_sheet.imageAt(pygame.Rect(257, 253, 197, 57))
        ]
Ejemplo n.º 27
0
    def __init__(self, **argd):
        self.__dict__.update(**argd)
        super(MainScreen, self).__init__(**argd)

        # create a display image. standard pygame stuff
        self.display = pygame.display.set_mode(self.size, 0)
        self.background = pygame.Surface(GAME_SCREEN_RECT.size)

        # Create text display helper class.
        self.text = Text()

        # Initialize the stop flag. When the game stops, we need to stop the subprocess as well. Set the flag to any
        # value other than 0 to stop the subprocesses.
        self.stop_flag = Value('i', 0)

        # Load graphics
        deafy_sheet = SpriteSheet("data/Undertale_Annoying_Dog.png")
        cat_sheet = SpriteSheet("data/cat.png")

        Deafy.images = [
            deafy_sheet.image_at((2, 101, 22 - 2, 119 - 101),
                                 colorkey=-1,
                                 width_height=(20 * 2, 18 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((2, 204, 26 - 2, 216 - 204),
                                 colorkey=-1,
                                 width_height=(24 * 2, 12 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((2, 182, 23 - 2, 200 - 182),
                                 colorkey=-1,
                                 width_height=(21 * 2, 18 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((25, 182, 44 - 25, 200 - 182),
                                 colorkey=-1,
                                 width_height=(19 * 2, 18 * 2),
                                 flip_x=True),
            deafy_sheet.image_at((2, 101, 22 - 2, 119 - 101),
                                 colorkey=-1,
                                 width_height=(20 * 2, 18 * 2),
                                 flip_x=True,
                                 flip_y=True),
        ]
        Sky.images = [load_image('space-1.png', BATTLE_SCREEN_SIZE)]
        GroundObstacle.images = [
            load_image('grass.png', (32, 32)),
            load_image('sky.png', (32, 32))
        ]
        CatOpponent.images = [
            cat_sheet.image_at((0, 0, 54, 42), colorkey=-1),
            cat_sheet.image_at((1, 158, 54, 42), colorkey=-1),
            cat_sheet.image_at((1 + 54, 158, 54, 42), colorkey=-1),
            cat_sheet.image_at((1 + 54 * 2, 158, 54, 42), colorkey=-1),
            cat_sheet.image_at((1 + 54 * 3, 158, 54, 42), colorkey=-1),
        ]

        self.default_face_photo = load_image(
            'Barack-Obama-Funny-Face-Image.jpg')
        # Load sounds
        Deafy.sounds = [
            load_sound("normal.ogg"),
            load_sound("jump.ogg"),
            load_sound("victory.ogg")
        ]
        CatOpponent.sounds = [
            load_sound("cat_meow.wav"),
            load_sound("Cat-meow-nervous.wav"),
            load_sound("Angry-cat-sound.wav")
        ]
        self.background_sounds = [
            load_sound("2A03_fluidvolt-Pallid_Underbrush.wav"),
            load_sound("2A03_Kevvviiinnn-Superfusion.wav"),
            load_sound("Class_gyms-Pastorale.wav"),
            load_sound("Class_Kulor-SpaceDolphinsSpaceCave.wav"),
            load_sound("Class_Zephemeros-Asymmetrical.wav"),
            load_sound("FDS_Kevvviiinnn_-_The_Devourer's_Wrath.wav"),
            load_sound("FDS_rushjet1_-_fdx.wav"),
            load_sound("FDS_SriK_-_F%!&_Dis_S#!%.wav"),
            load_sound("miku-joker.wav"),
            load_sound("MMC5_moviemovies1-Rubicon.wav"),
            load_sound(
                "N163_Jayster_-_TMNT_Tournament_Fighters_Scrapyard_Swing.wav"),
            load_sound("VRC6_Anon-3DGalax.wav"),
            load_sound(
                "VRC6_ArchJ-MegaManRemixesArchj - Track 01 Mega Man Elecman.wav"
            ),
            load_sound(
                "VRC6_Ares64-smurfity smurf - Track 01 (Smurfs (GB) Title).wav"
            ),
            load_sound(
                "VRC6_Ares64-smurfity smurf - Track 02 (Smurfs (GB) Volcano).wav"
            ),
            load_sound(
                "VRC6_Ares64-smurfity smurf - Track 03 (Smurfs (GB) River Smurf).wav"
            ),
            load_sound(
                "VRC6_Raijin-Thunderforce III - Haides (Truth) Devil Crash - Main Theme - Track 01 (Thunderforce III Truth).wav"
            ),
            load_sound(
                "VRC6_Raijin-Thunderforce III - Haides (Truth) Devil Crash - Main Theme - Track 02 (Devil Crash Main Theme).wav"
            )
        ]
        self.background_channel = pygame.mixer.Channel(BGM_CHANNEL_ID)
        self.background_channel.set_endevent(END_BGM_EVENT)

        # Initialize Game Groups
        self.all = pygame.sprite.RenderUpdates()
        self.background_group = pygame.sprite.RenderUpdates()
        self.obstacle_group = pygame.sprite.RenderUpdates()
        # Sprites in this group are rendered after background so that they appear on the top.
        self.front_group = pygame.sprite.RenderUpdates()
        self.player_group = pygame.sprite.Group(
        )  # Not an ui group, just for collision detection.

        # assign default groups to each sprite class
        Deafy.containers = self.all, self.front_group, self.player_group
        Ground.containers = self.all, self.background_group
        Sky.containers = self.all, self.background_group
        GroundObstacle.containers = self.all, self.obstacle_group
        CatOpponent.containers = self.all, self.front_group, self.player_group
        Bullet.containers = self.all, self.front_group
        HPBar.containers = self.all, self.background_group
        Face.containers = self.all, self.background_group
        dialog.Dialog.containers = self.all, self.background_group

        self.deafy_player_photos = []
        self.cat_player_photos = []
        # Initialize camera
        if ARGS.camera:
            # HeadPoseEstimator
            self.hpe = HeadPoseEstimator(CAMERA_INPUT_WIDTH,
                                         CAMERA_INPUT_HEIGHT)

            if ARGS.deafy_camera_index is not None:
                # Facial landmark detector.
                self.deafy_fld = FacialLandmarkDetector(CAMERA_INPUT_WIDTH,
                                                        CAMERA_INPUT_HEIGHT,
                                                        name="Deafy")
                self.init_cams(ARGS.deafy_camera_index,
                               DEAFY_CAMERA_DISPLAY_LOCATION)
                self.deafy_cam_on = True
                self.deafy_player_face = Face(CAMERA_INPUT_SIZE,
                                              FACE_DEAFY_BOTTOMLEFT)
                self.deafy_queue = Queue()
                self.deafy_features_q = Queue()
            else:
                self.deafy_fld = None
                self.deafy_cam_on = False
                self.deafy_player_face = None
                self.deafy_queue = None
                self.deafy_features_q = None
            if ARGS.cat_camera_index is not None:
                # Facial landmark detector.
                self.cat_fld = FacialLandmarkDetector(CAMERA_INPUT_WIDTH,
                                                      CAMERA_INPUT_HEIGHT,
                                                      name="Cat")
                self.init_cams(ARGS.cat_camera_index,
                               CAT_CAMERA_DISPLAY_LOCATION)
                self.cat_cam_on = True
                self.cat_player_face = Face(CAMERA_INPUT_SIZE,
                                            FACE_CAT_BOTTOMLEFT)
                self.cat_queue = Queue()
                self.cat_features_q = Queue()
            else:
                self.cat_fld = None
                self.cat_cam_on = False
                self.cat_player_face = None
                self.cat_queue = None
                self.cat_features_q = None
Ejemplo n.º 28
0
 def __init__(self):
     sprites = SpriteSheet('bonus').load_strip((0, 0, 93, 49), 2)
     super(Bonus, self).__init__(sprites, (-93, SCREEN_HEIGHT * .1), 5, 5,
                                 0)
Ejemplo n.º 29
0
 def __init__(self, position):
     gun = SpriteSheet('bullets').load_strip((102, 0, 24, 22), 6)
     super(BonusBullet, self).__init__(gun, position, 10, 0, (0, 1))
Ejemplo n.º 30
0
 def __init__(self):
     sprites = SpriteSheet("ship").load_strip((0, 0, 87, 100), 4)
     super(Character,
           self).__init__(sprites, (SCREEN_WIDTH / 2, SCREEN_HEIGHT * 0.9),
                          1, 25, 5)