예제 #1
0
class TimerCounter(Customer, Subject):

    def __init__(self, waiter, end, font_size, pos, color):
        self.end = 0
        self.font_size = font_size
        self.pos = pos
        self.color = color

        self.time = end
        Customer.__init__(self, waiter)

        self.timer = None

        Subject.__init__(self)
        subject_unit = SubjectUnit()
        self.add_subject_unit(subject_unit, 'time_up')

    def run(self):

        font = pygame.font.Font("resources/font.ttf", self.font_size)

        def work():
            drawable_object = Drawable(font.render(str(self.time), True, self.color), self.pos, DRAWABLE_INDEX.TIMER_COUNTER)
            self.register_waiter(CUSTOMER_KEY.TIMER_COUNTER, drawable_object)

            drawable_object = Drawable(font.render('Time remaining:', True, (255, 0, 0)), (self.pos[0] - 280, self.pos[1]), DRAWABLE_INDEX.TIMER_COUNTER)
            self.register_waiter(CUSTOMER_KEY.TIMER_COUNTER+'sub', drawable_object)

            self.time -= 1
            if self.time < self.end + 1:
                self.set_change('time_up', 'time_up')

        self.timer = Timer(1, work)
        self.timer.start()

    def close(self):
        if self.timer is not None:
            self.timer.close()
예제 #2
0
class Head(Customer):

    def __init__(self, name, waiter, stick_time):

        Customer.__init__(self, waiter)

        self.name = name

        self.appear_index = 0
        self.die_index = 0
        self.disappear_index = 0
        self.stand_index = 0

        self.appear_timer = None
        self.die_timer = None
        self.disappear_timer = None
        self.stand_timer = None
        self.main_timer = None

        self.alive = True
        self.showing = False

        self.size = (40, 40)
        self.rect_bound = pygame.Rect(0, 0, self.size[0], self.size[1])

        appear_avatars = Factory.get_avatars('head_appear_avatars')
        if appear_avatars is None:
            raise BaseException('Can not load avatar for Head')
        self.appear_drawable_avatars = []
        for avatar in appear_avatars:
            pos = (0, 0)
            drawable_item = Drawable(avatar, pos, DRAWABLE_INDEX.HEAD)
            self.appear_drawable_avatars.append(drawable_item)

        die_avatars = Factory.get_avatars('head_die_avatars')
        if die_avatars is None:
            raise BaseException('Can not load avatar for Head')
        self.die_drawable_avatars = []
        for avatar in die_avatars:
            pos = (0, 0)
            drawable_item = Drawable(avatar, pos, DRAWABLE_INDEX.HEAD)
            self.die_drawable_avatars.append(drawable_item)

        disappear_avatars = Factory.get_avatars('head_disappear_avatars')
        if disappear_avatars is None:
            raise BaseException('Can not load avatar for Head')
        self.disappear_drawable_avatars = []
        for avatar in disappear_avatars:
            pos = (0, 0)
            drawable_item = Drawable(avatar, pos, DRAWABLE_INDEX.HEAD)
            self.disappear_drawable_avatars.append(drawable_item)

        stand_avatars = Factory.get_avatars('head_stand_avatars')
        if disappear_avatars is None:
            raise BaseException('Can not load avatar for Head')
        self.stand_drawable_avatars = []
        for avatar in stand_avatars:
            pos = (0, 0)
            drawable_item = Drawable(avatar, pos, DRAWABLE_INDEX.HEAD)
            self.stand_drawable_avatars.append(drawable_item)

        self.stick_time = stick_time

        self.sound_head_appear = Factory.get_sound('head_appear')
        self.sound_head_disappear = Factory.get_sound('head_disappear')
        self.sound_head_hit = Factory.get_sound('head_hit')

        return

    def appear(self, pos):
        self.showing = True
        self.alive = True

        self.rect_bound = pygame.Rect(pos[0] + 15, pos[1] + 15, self.size[0], self.size[1])

        # Update position to draw on screen
        for drawable_avatar in self.appear_drawable_avatars:
            drawable_avatar.pos = pos
        # Update position to draw on screen
        for drawable_avatar in self.disappear_drawable_avatars:
            drawable_avatar.pos = pos
        # Update position to draw on screen
        for drawable_avatar in self.die_drawable_avatars:
            drawable_avatar.pos = pos
        # Update position to draw on screen
        for drawable_avatar in self.stand_drawable_avatars:
            drawable_avatar.pos = pos

        drawable_object = self.appear_drawable_avatars[self.appear_index]
        # Start drawing
        self.register_waiter(str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name, drawable_object)

        def do_animation():
            self.appear_index += 1
            if self.appear_index > (self.appear_drawable_avatars.__len__() - 1):
                self.appear_index = 0
                self.appear_timer.stop()

                # After appearing animation is standing animation
                self.stand()
                return
            drawable_object = self.appear_drawable_avatars[self.appear_index]
            key = str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name
            # Insert index as prefix keyword to sort
            self.register_waiter(key, drawable_object)

            # blank = Factory.get_avatars('blank')
            # drawable_object1 = Drawable(blank[0], (self.get_rect_bound()[0], self.get_rect_bound()[1]), 2)
            # self.register_waiter('blank1', drawable_object1)
            # drawable_object2 = Drawable(blank[0], (self.get_rect_bound()[0] + self.get_rect_bound()[2],
            #                                        self.get_rect_bound()[1] + self.get_rect_bound()[3]), 2)
            # self.register_waiter('blank2', drawable_object2)

        if self.appear_timer is None:
            self.appear_timer = Timer(self.stick_time, do_animation)

        self.appear_timer.start()
        self.sound_head_appear.play()

    def disappear(self):
        self.alive = False

        drawable_object = self.disappear_drawable_avatars[self.disappear_index]
        # Start drawing
        self.register_waiter(str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name, drawable_object)

        def do_animation():
            self.disappear_index += 1
            if self.disappear_index > (self.disappear_drawable_avatars.__len__() - 1):
                # Disappear actually from screen
                key = str(self.disappear_drawable_avatars[0].index) + CUSTOMER_KEY.HEAD + self.name
                self.unregister_waiter(key)

                self.disappear_index = 0
                self.showing = False
                self.disappear_timer.stop()

                # Close all timer
                self.close()

                return
            drawable_object = self.disappear_drawable_avatars[self.disappear_index]
            key = str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name
            # Insert index as prefix keyword to sort
            self.register_waiter(key, drawable_object)

        if self.disappear_timer is None:
            self.disappear_timer = Timer(self.stick_time, do_animation)

        self.disappear_timer.start()
        self.sound_head_disappear.play()

    def show(self, pos, duration):
        self.appear(pos)
        start = datetime.datetime.now()

        def work():
            end = datetime.datetime.now()
            if (end - start).total_seconds() > duration:
                if self.stand_timer is not None:
                    self.stand_timer.stop()
                if self.main_timer is not None:
                    self.main_timer.stop()
                self.disappear()
        self.main_timer = Timer(0.1, work)
        self.main_timer.start()

    def stand(self):
        drawable_object = self.stand_drawable_avatars[self.stand_index]
        # Start drawing
        self.register_waiter(str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name, drawable_object)

        def do_animation():
            self.stand_index += 1
            if self.stand_index > (self.stand_drawable_avatars.__len__() - 1):
                self.stand_index = 0
                return
            drawable_object = self.stand_drawable_avatars[self.stand_index]
            key = str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name
            # Insert index as prefix keyword to sort
            self.register_waiter(key, drawable_object)

        if self.stand_timer is None:
            self.stand_timer = Timer(self.stick_time, do_animation)

        self.stand_timer.start()

    def die(self):
        self.alive = False
        drawable_object = self.die_drawable_avatars[self.die_index]
        # Start drawing
        self.register_waiter(str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name, drawable_object)

        def do_animation():
            self.die_index += 1
            if self.die_index > (self.die_drawable_avatars.__len__() - 1):
                self.die_index = 0
                self.die_timer.stop()
                self.disappear()
                return

            drawable_object = self.die_drawable_avatars[self.die_index]
            key = str(drawable_object.index) + CUSTOMER_KEY.HEAD + self.name
            # Insert index as prefix keyword to sort
            self.register_waiter(key, drawable_object)

        if self.die_timer is None:
            self.die_timer = Timer(0.1, do_animation)

        if self.appear_timer is not None:
            self.appear_timer.stop()
        if self.stand_timer is not None:
            self.stand_timer.stop()
        if self.main_timer is not None:
            self.main_timer.stop()

        self.die_timer.start()
        self.sound_head_hit.play()

    def get_rect_bound(self):
        return self.rect_bound

    def set_stick_time(self, stick_time):
        self.stick_time = stick_time

    def close(self):
        if self.appear_timer is not None:
            self.appear_timer.close()

        if self.die_timer is not None:
            self.die_timer.close()

        if self.disappear_timer is not None:
            self.disappear_timer.close()

        if self.stand_timer is not None:
            self.stand_timer.close()

        if self.main_timer is not None:
            self.main_timer.close()
예제 #3
0
class Hammer(Customer, Observer):
    """
    This class managers hammer of player, detail:
    - Animation when hammer
    - Sound effect when hammer
    - Avatar of hammer
    - Replace cursor with avatar
    """

    def __init__(self, waiter, subject):
        """
        Constructor
        :param waiter: waiter for implement hammer action
        :return: None
        """

        # Constructor of base class
        Customer.__init__(self, waiter)
        Observer.__init__(self)
        self.register(subject, 'player_motion')

        avatars = Factory.get_avatars('hammer_avatars')
        if avatars is None:
            raise BaseException('Can not load avatar for hammer')
        self.drawable_avatars = []
        for avatar in avatars:
            drawable_item = Drawable(avatar, (0, 0), DRAWABLE_INDEX.PLAYER)
            self.drawable_avatars.append(drawable_item)

        # Default is the first one
        self.drawable_avatar = self.drawable_avatars[0]

        self.sound_hit = Factory.get_sound('hammer_hit')
        if self.sound_hit is None:
            raise BaseException('Can not load "hit" sound effect of hammer')

        # Used to step counter, change image when hammer
        self.index = 0

        # Used to prevent hammer when hammering
        self.hammering = False

        self.timer = None

        self.pos = (0, 0)

        self.size = (10, 15)     # Height, Width

        self.distance = (150, 150)

    def hit(self):
        """
        This function play a sound in new thread, so it can be call
         2 times concurrent
        :return:
        """
        if not self.hammering:
            self.sound_hit.play()

        # Hammer action effect
        # TODO Need to improve effect
        def work():
            self.hammering = True
            self.index += 1
            if self.index > 8:
                self.index = 0
                self.hammering = False
                self.timer.stop()

            avatar_index = 4 - abs(self.index - 4)
            self.drawable_avatar = self.drawable_avatars[avatar_index]
            self.drawable_avatar.pos = self.pos

            # Insert index as prefix keyword to sort
            key = str(self.drawable_avatar.index) + CUSTOMER_KEY.HAMMER
            self.register_waiter(key, self.drawable_avatar)

        if self.timer is None:
            self.timer = Timer(0.01, work)

        if not self.hammering:
            self.timer.start()

        rect = pygame.Rect(self.pos[0] + 10, self.pos[1] + 130, 30, 30)

        return rect

    def get_avatar(self):
            return self.drawable_avatar.bitmap

    def update(self, type_key, data):
        """
        Override function of base class: Observer
        :param event:
        :return:
        """
        if type_key == 'player_motion' or type_key == 'player_hammer':
            self.pos = (data[0] - self.distance[0], data[1] - self.distance[1])

    def close(self):
        if self.timer is not None:
            self.timer.close()
class MainController(Observer, Waiter):
    """Control common stage of game, include:
    - Init game
    - Load background
    - Load model
    This class has role:
    - Waiter: update screen
    - Observer: listen and resolve special event, such as: QUIT
    """

    def __init__(self, event_controller, env):

        # Save event_controller to use later
        self.event_controller = event_controller
        self.env = env

        #set some value for head
        self.number_of_enemy = NUM_SPRITES.NUMBER_OF_ENEMY
        self.time_to_create_new = DURATION.TIME_CREATE_NEW
        self.max_of_current_enemy = NUM_SPRITES.MAX_OF_CURRENT_ENEMY
        self.totalCreatedEnemy = 0

        # Constructor of base class
        Observer.__init__(self)
        # Register to receive some special events
        self.register(event_controller, 'special')

        Waiter.__init__(self)

        # Attribute declare
        self.quit_game = False
        self.player = None

        #self.drawable_components = []
        self.heads = []
        self.head_timer = None

        # Init pygame
        pygame.init()
        pygame.mixer.init()
        self.screen = pygame.display.set_mode(self.env.screen_size)
        pygame.mouse.set_visible(False)    # Hide default mouse cursor

    def update(self, type_key, event):
        """
        Override function of base class: Observer
        This function is called when expected event is happened
        :param event: event is happened
        :return: None
        """
        if type_key == 'special':
            if event.type == pygame.QUIT:
                self.close()
                self.quit_game = True
        elif type_key == 'player_hammer':
            rect_bound_hammer = event
            head = self.__check_collision(rect_bound_hammer)
            if head:
                self.player.increase_score()
                head.die()
            else:
                self.player.decrease_score()

    def init_game(self):
        """
        Init logically game
        :return: None
        """
        self.screen.fill((255, 255, 255))
        background = Factory.get_background()
        if background is not None:
            drawable_object = Drawable(background, (0, 0), DRAWABLE_INDEX.BACKGROUND)
            key = str(drawable_object.index) + CUSTOMER_KEY.BACKGROUND      # Insert index as prefix keyword to sort
            self.register_waiter(key, drawable_object)
        else:
            raise 'Can not load background image'

        self.player = Player(self.event_controller, self, self.screen)
        self.register(self.player, 'player_hammer')

        # Init list of heads
        head = Head('1', self)
        self.heads.append(head)
        head = Head('2', self)
        self.heads.append(head)
        head = Head('3', self)
        self.heads.append(head)

        #Draft
        self.original_head_pos = (20, 200)

        self.pos_index = 0

        self.id = 0
        # Define work of timer: choose random a head and show it
        def work():
            if self.pos_index > 7:
                self.pos_index = 0
            i = 0
            
            self.id += 1
            self.pos_index += 1
            self.original_head_pos = HolePosition.POS[self.pos_index]
            head = Head(str(self.id), self)
            head.show(self.original_head_pos,3)

        self.head_timer = Timer(3, work)
        self.head_timer.start()

    def run(self):
        """
        Implement from Waiter. This function clear and then draw whole screen.
        :return: None
        """
        self.screen.fill((255, 255, 255))
        for key in sorted(self.objects.keys()):     # TODO: Need to improve
            self.screen.blit(self.objects[key].bitmap, self.objects[key].pos)

    def __check_collision(self, rect_bound_hammer):
        """
        Check collision between player and head
        :return:
        """
        for head in self.heads:
            if head.alive and head.showing:
                if rect_bound_hammer.colliderect(head.get_rect_bound()):
                    return head
        return None

    def close(self):
        self.player.close()
        for head in self.heads:
            head.close()

        if self.head_timer is not None:
            self.head_timer.stop()
            self.head_timer.close()
class MainController(Observer, Waiter):
    """Control common stage of game, include:
    - Init game
    - Load background
    - Load model
    This class has role:
    - Waiter: update screen
    - Observer: listen and resolve special event, such as: QUIT
    """

    def __init__(self, event_controller, env):

        # Init pygame
        pygame.init()
        pygame.mixer.init()

        # Save event_controller to use later
        self.event_controller = event_controller
        self.env = env

        # Set some value for head
        self.number_of_enemy = NUM_SPRITES.NUMBER_OF_ENEMY
        self.time_to_create_new = DURATION.TIME_CREATE_NEW
        self.max_of_current_enemy = NUM_SPRITES.MAX_OF_CURRENT_ENEMY
        self.totalCreatedEnemy = 0

        # Constructor of base class
        Observer.__init__(self)
        # Register to receive some special events
        self.register(event_controller, 'special')

        Waiter.__init__(self)

        # Attribute declare
        self.quit_game = False
        self.player = None

        self.heads = []
        self.head_timer = None
        self.interval_section = 3
        self.appear_delay = 3
        self.stick_time = 0.12
        self.is_first_blood = True

        self.sound_prepare4battle = Factory.get_sound('prepare4battle')
        if self.sound_prepare4battle is None:
            raise NotImplementedError
        self.sound_prepare4battle_playing = False
        self.sound_first_blood = Factory.get_sound('first_blood')
        if self.sound_first_blood is None:
            raise NotImplementedError
        self.sound_double_kill = Factory.get_sound('double_kill')
        if self.sound_double_kill is None:
            raise NotImplementedError
        self.sound_triple_kill = Factory.get_sound('triple_kill')
        if self.sound_triple_kill is None:
            raise NotImplementedError
        self.sound_ultra_kill = Factory.get_sound('ultra_kill')
        if self.sound_ultra_kill is None:
            raise NotImplementedError
        self.sound_rampage_kill = Factory.get_sound('rampage')
        if self.sound_rampage_kill is None:
            raise NotImplementedError

        self.screen = pygame.display.set_mode(self.env.screen_size)
        pygame.mouse.set_visible(False)    # Hide default mouse cursor

        self.timer_counter = None
        self.stage = None
        self.id = 0
        self.finish = False
        self.num_head_kill_in_section = 0

    def update(self, type_key, event):
        """
        Override function of base class: Observer
        This function is called when expected event is happened
        :param event: event is happened
        :return: None
        """
        if type_key == 'special':
            if event.type == pygame.QUIT:
                self.close()
                self.quit_game = True
        elif type_key == 'player_hammer':
            rect_bound_hammer = event
            head = self.__check_collision(rect_bound_hammer)

            if head:
                self.player.increase_score()
                head.die()
                if self.is_first_blood:
                    self.sound_first_blood.play()
                    self.is_first_blood = False

                self.num_head_kill_in_section += 1
                print self.num_head_kill_in_section
                if self.num_head_kill_in_section == 2:
                    self.sound_double_kill.play()
                if self.num_head_kill_in_section == 3:
                    self.sound_triple_kill.play()
                if self.num_head_kill_in_section == 4:
                    self.sound_ultra_kill.play()
                if self.num_head_kill_in_section == 5:
                    self.sound_rampage_kill.play()
            else:
                self.player.decrease_score()
        elif type_key == 'time_up':
            self.finish = True
            self.finish_game()

    def init_game(self):
        """
        Init logically game
        :return: None
        """
        start_time = time.time()
        self.screen.fill((255, 255, 255))
        background = Factory.get_background()
        if background is not None:
            drawable_object = Drawable(background, (0, 20), DRAWABLE_INDEX.BACKGROUND)
            key = str(drawable_object.index) + CUSTOMER_KEY.BACKGROUND      # Insert index as prefix keyword to sort
            self.register_waiter(key, drawable_object)
        else:
            raise 'Can not load background image'

        self.player = Player(self.event_controller, self)
        self.register(self.player, 'player_hammer')

    def start_game(self):
        self.id = 0

        # Define work of timer: choose random a number of head and show them
        def work():
            self.num_head_kill_in_section = 0
            num_head = 7 #random.randint(1, 5)
            positions = range(8)
            random.shuffle(positions)

            self.interval_section = random.random() * 2 + 0.5

            for i in range(num_head):
                self.interval_head = random.random() * 0.1 + 0.2

                self.stick_time = random.random() * 0.05 + 0.05

                self.appear_delay = random.random() * 1.5
                if self.appear_delay < 6 * self.stick_time + 0.01:
                    self.appear_delay = 6 * self.stick_time + 0.01

                # Position of top left corner of bitmap
                original_head_pos = HolePosition.POS[positions[i]]
                head = Head(str(self.id), self, self.stick_time)

                # Actually position
                pos = (original_head_pos[0] - 30, original_head_pos[1] - 40)

                head.show(pos, self.appear_delay)

                self.heads.append(head)
                self.id += 1
                time.sleep(self.interval_head)
        # Finish work() function

        self.head_timer = Timer(self.interval_section, work)

        self.head_timer.start()

        self.timer_counter = TimerCounter(self, 60, 40, (570, 490), (240, 5, 12))
        self.register(self.timer_counter, 'time_up')
        self.timer_counter.run()

        font = pygame.font.Font("resources/font.ttf", 40)
        drawable_object = Drawable(font.render('Score: ', True, (255, 0, 0)), (15, 490), DRAWABLE_INDEX.TIMER_COUNTER)
        self.register_waiter('score_text', drawable_object)

        drawable_object = Drawable(font.render('0', True, (255, 0, 0)), (150, 490), DRAWABLE_INDEX.TIMER_COUNTER)
        self.register_waiter('score', drawable_object)

    def run(self):
        """
        Implement from Waiter. This function clear and then draw whole screen.
        :return: None
        """
        if not self.finish:
            self.screen.fill((0, 0, 0))
            for key in sorted(self.objects.keys()):     # TODO: Need to improve
                if key in self.objects.keys():
                    try:
                        self.screen.blit(self.objects[key].bitmap, self.objects[key].pos)
                    except KeyError:
                        continue

    def __check_collision(self, rect_bound_hammer):
        """
        Check collision between player and head
        :return:
        """
        heads = []
        for head in self.heads:
            if head.alive:
                heads.append(head)
                if rect_bound_hammer.colliderect(head.get_rect_bound()):
                    return head
            # if head.showing:
            #     heads.append(head)
            # self.heads = heads
        return None

    def close(self):
        self.player.close()

        if self.head_timer is not None:
            self.head_timer.stop()
            self.head_timer.close()

        for head in self.heads:
            head.close()
        if self.head_timer is not None:
            self.head_timer.close()
        if self.timer_counter is not None:
            self.timer_counter.close()

    def intro(self, clock):
        logo = pygame.image.load('resources/Logo.png')
        i = 0
        while i < 58:
            self.screen.fill((0, 0, 0))
            img = pygame.image.load('resources/intro/tmp-' + str(i) + '.gif')
            i += 1
            self.screen.blit(img, (30, 150))
            self.screen.blit(logo, (i * 2, 30))
            self.screen.blit(logo, (480 - i * 2, 30))
            Font = pygame.font.Font("resources/HorrorFont.ttf", 64)
            self.screen.blit(Font.render('PUNCH ZOMBIE ', True, (255, 0, 0)), (100, 100))
            pygame.display.flip()
            clock.tick(10)

    def prepare(self):
        self.stage = 'prepare'

        def work():
            if not self.sound_prepare4battle_playing:
                self.sound_prepare4battle.play()
                self.sound_prepare4battle_playing = True
            else:
                time.sleep(4)
                self.prepare_timer.stop()
                self.start_game()

        self.prepare_timer = Timer(0.001, work)
        self.prepare_timer.start()

    def finish_game(self):
        self.close()
        self.screen.fill((0, 0, 0))
        end_background = pygame.image.load('resources/endgame.jpg')
        self.screen.blit(end_background, (20, 10))
        font = pygame.font.Font("resources/HorrorFont.ttf", 64)
        self.screen.blit(font.render('Your score:', True, (255, 0, 0)), (130, 100))
        self.screen.blit(font.render(str(self.player.score), True, (255, 0, 0)), (300, 200))
        pygame.display.flip()
        time.sleep(10)

        self.quit_game = True