Exemple #1
0
class Sprite(pygame.sprite.Sprite):
    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()

    def update(self, actions):
        # if actions: print '----'
        # self.rect.y += 1

        for action in actions:
            if action.key in self.keys:
                if action.key == K_UP:
                    self.rect.y -= self.speed
                elif action.key == K_DOWN:
                    self.rect.y += self.speed
                elif action.key == K_LEFT:
                    self.rect.x -= self.speed
                elif action.key == K_RIGHT:
                    self.rect.x += self.speed
Exemple #2
0
class Fruit(Sprite):
    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

    def draw(self):
        self.screen.screen.blit(self.image, self.rect)

    def set_points(self):
        if self.type_fruit == 0:
            self.points = 100
        elif self.type_fruit >= 4:
            self.points = (self.type_fruit - 3) * 1000
        elif self.type_fruit == 1:
            self.points = 300
        elif self.type_fruit == 2:
            self.points = 500
        else:
            self.points = 700
Exemple #3
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
Exemple #4
0
class ButtonTray:
    """ a strip of icon buttons anchored to the corner of the editor window """
    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
        }

    def click(self, pos):
        # returns the button constant corresponding to the pos (x,y) coords
        # or None if pos lies outside the tray
        if self.tray.collidepoint(pos):
            # convert x coord to the button number
            button = int((pos[X] - self.top_left[X]) /
                         (self.button_size + self.button_margin)) + 1
            if button in self.button_names:
                self.button_state[button] = DOWN
                return button
        return None

    def release(self):
        # revert all the buttons to their up state
        for button in self.button_names:
            self.button_state[button] = UP

    def draw(self, fg_color, bg_color):
        pygame.draw.rect(self.surface, fg_color, self.tray)

        pos = [
            self.top_left[X] + self.button_margin,
            self.top_left[Y] + self.button_margin
        ]
        for b in self.button_names:
            button_image = self.buttons[b][self.button_state[b]]
            self.surface.blit(button_image, pos)
            pos[X] += self.button_size + self.button_margin
Exemple #5
0
class Ghost(Sprite):
    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

    def update(self):
        if not self.screen.game_active:
            self.moving_down()
            self.moving_up()
            self.moving_left()
            self.moving_right()
            self.moving()
            if self.is_dead:
                self.ismoving = False
                self.position = (19, 130, 15, 15)
                if self.screen.ghosts_destroyed == 1:
                    self.position = (3, 130, 15, 15)
                if self.screen.ghosts_destroyed == 2:
                    self.position = (19, 130, 15, 15)
                if self.screen.ghosts_destroyed == 3:
                    self.position = (35, 130, 16, 15)
                if self.screen.ghosts_destroyed == 4:
                    self.position = (50, 130, 17, 15)
                self.image = self.sprite_sheet.image_at(self.position, None)
                if self.screen.ghosts_destroyed == 3 and not self.destroyed:
                    self.screen.ghosts_destroyed = 4
                if self.screen.ghosts_destroyed == 2 and not self.destroyed:
                    self.screen.ghosts_destroyed = 3
                if self.screen.ghosts_destroyed == 1 and not self.destroyed:
                    self.screen.ghosts_destroyed = 2
                if self.screen.ghosts_destroyed == 0 and not self.destroyed:
                    self.screen.ghosts_destroyed = 1
                self.destroyed = True
                now = pygame.time.get_ticks()
                if self.destroy_last == 0:
                    self.destroy_last = now
                if self.destroy_last + self.destroy_wait < now:
                    self.position = self.eye_right
                    self.image = self.sprite_sheet.image_at(self.position, None)
                    self.image = pygame.transform.scale(self.image, (30, 30))
                    self.ismoving = True
                    self.is_dead = False
                    self.eye = True

        if self.screen.game_active:
            self.moving()
            # print(self.node_count)
            # print(self.route)
            self.next_route = False
            if self.node_count >= len(self.route)-1:
                self.next_route = True
                self.node_count = 1
            current = self.route[self.node_count-1]  # aA
            next_destination = self.route[self.node_count]
            # print(next_destination)
            destinations = self.dijkstra_graph.get(self.route[self.node_count-1])  # dijkstra_route[i] this is aA
            # print(self.route)
            # print(next_destination)
            self.final_distance = destinations.get(next_destination)
            # print(self.final_distance)

            # these if statements compare the letters of each destination I.E aA and cB
            # if the first letter is smaller then it should be going down
            # if the second letter is smaller then it should be going right
            if current[0] < next_destination[0] and current[1] == next_destination[1]:
                # print('going down')
                self.ismoving = True
                self.ismoving_down = True
                self.ismoving_left = False
                self.ismoving_up = False
                self.ismoving_right = False
            if current[0] > next_destination[0] and current[1] == next_destination[1]:
                # print('going up')
                self.ismoving = True
                self.ismoving_down = False
                self.ismoving_left = False
                self.ismoving_up = True
                self.ismoving_right = False
            if current[1] < next_destination[1] and current[0] == next_destination[0]:
                # print('going right')
                self.ismoving = True
                self.ismoving_down = False
                self.ismoving_left = False
                self.ismoving_up = False
                self.ismoving_right = True
            if current[1] > next_destination[1] and current[0] == next_destination[0]:
                # print('going left')
                self.ismoving = True
                self.ismoving_down = False
                self.ismoving_left = True
                self.ismoving_up = False
                self.ismoving_right = False
            # print(self.move_count)
            # print(self.final_distance)
            if self.move_count < self.final_distance and self.ismoving_up:
                # print('yes')
                self.rect.centery -= self.speed
            elif self.move_count >= self.final_distance and self.ismoving_up:
                # print('no')
                self.node_count += 1
                self.move_count = 0
            if self.move_count < self.final_distance and self.ismoving_down:
                # print('yes')
                self.rect.centery += self.speed
            elif self.move_count >= self.final_distance and self.ismoving_down:
                # print('no')
                self.node_count += 1
                self.move_count = 0
            if self.move_count < self.final_distance and self.ismoving_right:
                # print('yes')
                self.rect.centerx += self.speed
            elif self.move_count >= self.final_distance and self.ismoving_right:
                # print('no')
                self.node_count += 1
                self.move_count = 0
            if self.move_count < self.final_distance and self.ismoving_left:
                # print('yes')
                self.rect.centerx -= self.speed
            elif self.move_count >= self.final_distance and self.ismoving_left:
                # print('no')
                self.node_count += 1
                self.move_count = 0
            self.move_count += 1

    def draw(self):
        self.screen.screen.blit(self.image, self.rect)

    def change_location(self, x_location, y_location):
        self.rect.x = x_location
        self.rect.y = y_location

    def change_type(self, position):
        self.position = position

    def moving_right(self):
        if self.ismoving_right and not self.screen.game_active:
            self.rect.x = self.rect.x + self.moving_speed

    def moving_left(self):
        if self.ismoving_left and not self.screen.game_active:
            self.rect.x = self.rect.x - self.moving_speed

    def moving_up(self):
        if self.ismoving_up and not self.screen.game_active:
            self.rect.y = self.rect.y - self.moving_speed

    def moving_down(self):
        if self.ismoving_down and not self.screen.game_active:
            self.rect.y = self.rect.y + self.moving_speed

    def moving(self):
        if self.ismoving:
            if self.ismoving_down:
                self.position = [self.down, self.down_in]
            if self.ismoving_up:
                self.position = [self.up, self.up_in]
            if self.ismoving_right:
                self.position = [self.right, self.right_in]
            if self.ismoving_left:
                self.position = [self.left, self.left_in]
            if self.is_blue:
                now = pygame.time.get_ticks()
                self.position = [self.blue, self.blue_in]
                if self.blue_last == 0:
                    self.blue_last = now
                if self.blue_last + self.blue_wait < now:
                    self.is_white = True
                    self.position = [self.blue, self.white_in]
                    now_two = pygame.time.get_ticks()
                    if self.white_last == 0:
                        self.white_last = now_two
                    if self.white_last + self.white_wait < now_two:
                        self.is_white = False
                        self.is_blue = False
                        self.screen.ghosts_destroyed = 0
            if self.eye and self.ismoving_left:
                self.position = [self.eye_left, self.eye_left]
            if self.eye and self.ismoving_right:
                self.position = [self.eye_right, self.eye_right]
            if self.eye and self.ismoving_up:
                self.position = [self.eye_up, self.eye_up]
            if self.eye and self.ismoving_down:
                self.position = [self.eye_down, self.eye_down]

            now = pygame.time.get_ticks()
            if self.last == 0:
                self.last = now
            if self.last + self.wait_count < now:
                self.position = self.position[self.animation_counter]
                self.image = self.sprite_sheet.image_at(self.position, None)
                self.image = pygame.transform.scale(self.image, (30, 30))
                self.animation_counter += 1
                self.wait_count += 250
                if self.animation_counter > 1:
                    self.animation_counter = 0
Exemple #6
0
class PacMan(Sprite):
    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

    def update(self):
        if self.screen.game_active:
            if self.ismoving_right or self.ismoving_left and self.no_node:
                self.ismoving_up = False
                self.ismoving_down = False
            if self.ismoving_up or self.ismoving_down and self.no_node:
                self.ismoving_right = False
                self.ismoving_left = False
            if self.ismoving_right and self.right_stopper:
                self.ismoving_right = False
                self.ismoving = False
                self.change_type(self.right_mid)
            if self.ismoving_left and self.left_stopper:
                self.ismoving_left = False
                self.ismoving = False
                self.change_type(self.left_mid)
            if self.ismoving_up and self.up_stopper:
                self.change_type(self.up_mid)
                self.ismoving_up = False
                self.ismoving = False
            if self.ismoving_down and self.down_stopper:
                self.ismoving_down = False
                self.ismoving = False
                self.change_type(self.down_mid)

            if self.direction == 'right' and self.right_allowed or (
                    self.next_direction == 'right' and self.right_allowed):
                self.ismoving_down = False
                self.ismoving_up = False
                self.ismoving_left = False
                self.ismoving_right = True
                self.ismoving = True
            elif self.direction == 'left' and self.left_allowed or (
                    self.next_direction == 'left' and self.left_allowed):
                self.ismoving_down = False
                self.ismoving_up = False
                self.ismoving_right = False
                self.ismoving_left = True
                self.ismoving = True
            elif self.direction == 'up' and self.up_allowed or (
                    self.next_direction == 'up' and self.up_allowed):
                self.ismoving_down = False
                self.ismoving_left = False
                self.ismoving_right = False
                self.ismoving_up = True
                self.ismoving = True
            elif self.direction == 'down' and self.down_allowed or (
                    self.next_direction == 'down' and self.down_allowed):
                self.ismoving_up = False
                self.ismoving_left = False
                self.ismoving_right = False
                self.ismoving_down = True
                self.ismoving = True

        self.moving_down()
        self.moving_up()
        self.moving_left()
        self.moving_right()
        self.moving()
        if self.is_dead:
            now = pygame.time.get_ticks()
            if self.destroy_last == 0:
                self.destroy_last = now
            if self.destroy_last + self.destroy_wait < now:
                self.position = self.destroy[self.animate]
                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.animate += 1
                self.destroy_wait += 75
                if self.animate >= 11:
                    self.remove(self.pacmen)
                    # self.screen.reset_the_game(self.maze, self.scoreboard, self, self.ghosts)
                    self.screen.reset_game = True

    def draw(self):
        self.screen.screen.blit(self.image, self.rect)

    def change_location(self, x_location, y_location):
        self.rect.x = x_location
        self.rect.y = y_location

    def change_type(self, position):
        self.position = position

    def moving_right(self):
        if self.ismoving_right:
            self.rect.x = self.rect.x + self.moving_speed

    def moving_left(self):
        if self.ismoving_left:
            self.rect.x = self.rect.x - self.moving_speed

    def moving_up(self):
        if self.ismoving_up:
            self.rect.y = self.rect.y - self.moving_speed

    def moving_down(self):
        if self.ismoving_down:
            self.rect.y = self.rect.y + self.moving_speed

    def moving(self):
        if self.ismoving:
            if self.ismoving_down:
                self.position = [
                    self.down_open, self.down_mid, self.close, self.down_mid
                ]
            if self.ismoving_up:
                self.position = [
                    self.up_open, self.up_mid, self.close, self.up_mid
                ]
            if self.ismoving_right:
                self.position = [
                    self.right_open, self.right_mid, self.close, self.right_mid
                ]
            if self.ismoving_left:
                self.position = [
                    self.left_open, self.left_mid, self.close, self.left_mid
                ]
            if not self.screen.game_active and self.is_big:
                self.position = [
                    self.big_open, self.big_mid, self.big_close, self.big_mid
                ]

            now = pygame.time.get_ticks()
            if self.last == 0:
                self.last = now
            if self.last + self.wait_count < now:
                self.position = self.position[self.animation_counter]
                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.animation_counter += 1
                self.wait_count += 75
                if self.animation_counter >= 4:
                    self.animation_counter = 0

    def destroy_pacman(self):
        self.ismoving = False
        self.ismoving_down = False
        self.ismoving_left = False
        self.ismoving_right = False
        self.ismoving_up = False
        self.is_dead = True
        self.update()
    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