Esempio n. 1
0
 def __init__(self, game_display: DTGameDisplay):
     super().__init__(game_display=game_display)
     self.one_player_button = DTButton(
         game_display, (0, 0),
         (self.game_display.width, self.game_display.height / 4),
         action=self.set_players,
         action_args=[1],
         color=DTColor.BUTTON_GRAY,
         text='One player')
     self.two_player_button = DTButton(
         game_display, (0, self.game_display.height / 4),
         (self.game_display.width, self.game_display.height / 4),
         action=self.set_players,
         action_args=[2],
         color=DTColor.BUTTON_GRAY,
         text='Two players')
     self.three_player_button = DTButton(
         game_display, (0, (self.game_display.height / 4) * 2),
         (self.game_display.width, self.game_display.height / 4),
         action=self.set_players,
         action_args=[3],
         color=DTColor.BUTTON_GRAY,
         text='Three Players')
     self.four_player_button = DTButton(
         game_display, (0, (self.game_display.height / 4) * 3),
         (self.game_display.width, self.game_display.height / 4),
         action=self.set_players,
         action_args=[4],
         color=DTColor.BUTTON_GRAY,
         text='Four Players')
Esempio n. 2
0
 def __init__(self, game_display: DTGameDisplay):
     super().__init__(game_display=game_display)
     self.level_one_button = DTButton(
         game_display,
         (0, 0),
         (self.game_display.width, self.game_display.height/3),
         action=self.set_diff,
         action_args=[1],
         color=DTColor.BUTTON_GRAY,
         text='level one')
     self.level_two_button = DTButton(
         game_display,
         (0, self.game_display.height/3),
         (self.game_display.width, self.game_display.height / 3),
         action=self.set_diff,
         action_args=[2],
         color=DTColor.BUTTON_GRAY,
         text='level two')
     self.level_three_button = DTButton(
         game_display,
         (0, (self.game_display.height/3) * 2),
         (self.game_display.width, self.game_display.height / 3),
         action=self.set_diff,
         action_args=[3],
         color=DTColor.BUTTON_GRAY,
         text='level three')
Esempio n. 3
0
    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)
        self.brigand_image = load_image('brigands.jpg')
        self.warrior_image = load_image('warriors.jpg')
        self.brigands = 0
        self.rewards = []
        self.round_time = 0
        self.last_sound = 0
        self.cool_down = 3000
        self.new_round = True
        self.round_outcome = None
        self.cancel = False
        self.battle_start = True
        self.battle_end = False
        self.config_battle()

        self.cancel_button = DTButton(
            game_display,
            (self.game_display.width / 4, (self.game_display.height / 4) * 2.8),
            (self.game_display.width / 2, self.game_display.height / 4),
            action=self.cancel_battle,
            color=DTColor.BUTTON_BLUE,
            text='Cancel',
            font_size=40)
Esempio n. 4
0
class SelectPlayersView(BaseView):
    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)
        self.one_player_button = DTButton(
            game_display, (0, 0),
            (self.game_display.width, self.game_display.height / 4),
            action=self.set_players,
            action_args=[1],
            color=DTColor.BUTTON_GRAY,
            text='One player')
        self.two_player_button = DTButton(
            game_display, (0, self.game_display.height / 4),
            (self.game_display.width, self.game_display.height / 4),
            action=self.set_players,
            action_args=[2],
            color=DTColor.BUTTON_GRAY,
            text='Two players')
        self.three_player_button = DTButton(
            game_display, (0, (self.game_display.height / 4) * 2),
            (self.game_display.width, self.game_display.height / 4),
            action=self.set_players,
            action_args=[3],
            color=DTColor.BUTTON_GRAY,
            text='Three Players')
        self.four_player_button = DTButton(
            game_display, (0, (self.game_display.height / 4) * 3),
            (self.game_display.width, self.game_display.height / 4),
            action=self.set_players,
            action_args=[4],
            color=DTColor.BUTTON_GRAY,
            text='Four Players')

    def set_players(self, num_players: int):
        self.game_display.num_players = num_players
        player_event = pygame.event.Event(
            DTUserEvent.DT_SELECTION, {'dt_event': DTEvent.START_PLAYER_TURN})
        pygame.event.post(player_event)

    def display(self):
        self.one_player_button.draw()
        self.two_player_button.draw()
        self.three_player_button.draw()
        self.four_player_button.draw()
Esempio n. 5
0
    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)
        self.yes_button = DTButton(
            game_display,
            (0, (self.game_display.height/5)*3),
            (self.game_display.width/2, self.game_display.height/5),
            action=self.set_selection,
            action_args=[BazaarSelection.YES],
            color=DTColor.BUTTON_GREEN,
            text='Yes')
        self.no_button = DTButton(
            game_display,
            (self.game_display.width/2, (self.game_display.height/5)*3),
            (self.game_display.width/2, self.game_display.height / 5),
            action=self.set_selection,
            action_args=[BazaarSelection.NO],
            color=DTColor.BUTTON_NO_RED,
            text='No')
        self.haggle_button = DTButton(
            game_display,
            (0, (self.game_display.height/5)*4),
            (self.game_display.width/2, self.game_display.height / 5),
            action=self.set_selection,
            action_args=[BazaarSelection.HAGGLE],
            color=DTColor.BUTTON_ORANGE,
            text='Haggle')
        self.exit_button = DTButton(
            game_display,
            (self.game_display.width/2, (self.game_display.height/5)*4),
            (self.game_display.width/2, self.game_display.height / 5),
            action=self.set_selection,
            action_args=[BazaarSelection.EXIT],
            color=DTColor.BUTTON_BLUE,
            text='Exit')

        self.items = self.get_bazaar_items()
        self.selected_item = InventoryItems.FOOD
        self.bazaar_image = load_image(INVENTORY_IMAGES[self.selected_item])
        self.purchase = False
        self.purchase_count = 1
Esempio n. 6
0
class SelectDifficultyView(BaseView):
    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)
        self.level_one_button = DTButton(
            game_display,
            (0, 0),
            (self.game_display.width, self.game_display.height/3),
            action=self.set_diff,
            action_args=[1],
            color=DTColor.BUTTON_GRAY,
            text='level one')
        self.level_two_button = DTButton(
            game_display,
            (0, self.game_display.height/3),
            (self.game_display.width, self.game_display.height / 3),
            action=self.set_diff,
            action_args=[2],
            color=DTColor.BUTTON_GRAY,
            text='level two')
        self.level_three_button = DTButton(
            game_display,
            (0, (self.game_display.height/3) * 2),
            (self.game_display.width, self.game_display.height / 3),
            action=self.set_diff,
            action_args=[3],
            color=DTColor.BUTTON_GRAY,
            text='level three')

    def set_diff(self, diff: int):
        self.game_display.difficulty = diff
        diff_event = pygame.event.Event(DTUserEvent.DT_SELECTION, {'dt_event': DTEvent.SELECT_PLAYERS})
        pygame.event.post(diff_event)

    def display(self):
        self.level_one_button.draw()
        self.level_two_button.draw()
        self.level_three_button.draw()
Esempio n. 7
0
class BattleView(BaseView):

    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)
        self.brigand_image = load_image('brigands.jpg')
        self.warrior_image = load_image('warriors.jpg')
        self.brigands = 0
        self.rewards = []
        self.round_time = 0
        self.last_sound = 0
        self.cool_down = 3000
        self.new_round = True
        self.round_outcome = None
        self.cancel = False
        self.battle_start = True
        self.battle_end = False
        self.config_battle()

        self.cancel_button = DTButton(
            game_display,
            (self.game_display.width / 4, (self.game_display.height / 4) * 2.8),
            (self.game_display.width / 2, self.game_display.height / 4),
            action=self.cancel_battle,
            color=DTColor.BUTTON_BLUE,
            text='Cancel',
            font_size=40)

    def refresh(self, **extra_refresh_args):
        self.config_battle()

    def display(self):
        if self.battle_end:
            return

        now = pygame.time.get_ticks()
        if self.new_round and self.cancel:
            self.finish_battle()
            return

        if self.battle_start:
            #if now > (self.round_time + 1500):
            self.show_brigands()
            self.play_beep(now)
            if now > (self.round_time + self.cool_down):
                self.battle_start = False
                self.next_round()
            else:
                return

        self.decide_round()

        if now < (self.round_time + self.cool_down):
            self.play_beep(now)
            self.show_warriors()
            self.cancel_button.draw(DTColor.BUTTON_BLUE_DIM if self.cancel else None)
        elif now < (self.round_time + (self.cool_down * 2)):
            self.show_brigands()
            self.cancel_button.draw(DTColor.BUTTON_BLUE_DIM if self.cancel else None)
            self.play_beep(now)
        elif now < (self.round_time + (self.cool_down * 3)):
            if self.battle_start:
                self.battle_start = False
                self.next_round()

            self.play_outcome_audio(now)
        elif now < (self.round_time + (self.cool_down * 3.25)):
            self.next_round()

    def show_brigands(self):
        self.game_display.game.blit(self.brigand_image, (20, 20))
        self.show_text(self.brigands)

    def show_warriors(self):
        self.game_display.game.blit(self.warrior_image, (20, 20))
        self.show_text(self.game_display.current_warriors)

    def show_text(self, text):
        bazaar_price_text = pygame.font.Font(
            CLOCK_FONT, 90).render(
            str(text), True, DTColor.BUTTON_NO_RED)

        text_rect = bazaar_price_text.get_rect()
        text_rect.center = ((self.game_display.width / 4) * 3, self.game_display.height / 4)
        self.game_display.game.blit(bazaar_price_text, text_rect)

    def decide_round(self):
        if self.battle_start:
            return

        if not self.new_round:
            return

        outcome = random.randrange(0, 100)
        # Give player advantage when their numbers are greater
        diff = min(1, self.game_display.current_warriors - self.brigands)
        outcome -= min(35, int(pow(diff, (diff/5)).real))
        if outcome <= 55:
            self.brigands = floor(self.brigands / 2)
            if self.brigands <= 0:
                self.round_outcome = BattleEvent.PLAYER_WON_BATTLE
                self.decide_winnings()
            else:
                self.round_outcome = BattleEvent.PLAYER_WON_ROUND
        else:
            self.game_display.current_warriors -= 1
            if self.game_display.current_warriors <= 1:
                self.round_outcome = BattleEvent.BRIGAND_WON_BATTLE
            else:
                self.round_outcome = BattleEvent.BRIGAND_WON_ROUND

        self.new_round = False

    def next_round(self):
        if self.round_outcome in (BattleEvent.BRIGAND_WON_BATTLE, BattleEvent.PLAYER_WON_BATTLE):
            self.cancel = True
            self.finish_battle()
            self.battle_end = True
            return

        self.new_round = True
        self.round_time = pygame.time.get_ticks()

    def play_outcome_audio(self, now):
        if now < (self.last_sound + self.cool_down):
            return

        if self.round_outcome in (BattleEvent.PLAYER_WON_ROUND, BattleEvent.PLAYER_WON_BATTLE):
            audio_event = pygame.event.Event(DTUserEvent.PLAY_AUDIO, {'audio': AudioFile.BATTLE_ROUND_WON})
            pygame.event.post(audio_event)
        elif self.round_outcome in (BattleEvent.BRIGAND_WON_ROUND, BattleEvent.BRIGAND_WON_BATTLE):
            audio_event = pygame.event.Event(DTUserEvent.PLAY_AUDIO, {'audio': AudioFile.BATTLE_ROUND_LOST})
            pygame.event.post(audio_event)

        self.last_sound = pygame.time.get_ticks()

    def play_beep(self, now):
        if now < (self.last_sound + self.cool_down):
            return

        exit_event = pygame.event.Event(DTUserEvent.PLAY_AUDIO, {'audio': AudioFile.BEEP})
        pygame.event.post(exit_event)
        self.last_sound = pygame.time.get_ticks()

    def config_battle(self):
        self.round_time = 0
        self.last_sound = 0
        self.new_round = True
        self.round_outcome = None
        self.cancel = False
        self.battle_start = True
        self.battle_end = False
        self.rewards = []
        self.round_time = pygame.time.get_ticks()
        self.brigands = random.randrange(
            self.game_display.current_warriors - 3,
            self.game_display.current_warriors + 3
        )

    def decide_winnings(self):
        self.rewards = utilities.decide_winnings(self.game_display, odds=1.5)

    def cancel_battle(self):
        self.cancel = True

    def finish_battle(self):
        if self.rewards:
            print('Rewards:\n{}'.format(self.rewards))
            self.rewards.append(InventoryItems.WARRIOR)
            end_event = pygame.event.Event(DTUserEvent.DT_SELECTION, {'dt_event': DTEvent.SHOW_INVENTORY,
                                                                      'items': self.rewards})
        else:
            end_event = pygame.event.Event(DTUserEvent.DT_SELECTION, {'dt_event': DTEvent.SHOW_INVENTORY,
                                                                      'items': [InventoryItems.WARRIOR]})
        pygame.event.post(end_event)
Esempio n. 8
0
class BazaarView(BaseView):
    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)
        self.yes_button = DTButton(
            game_display,
            (0, (self.game_display.height/5)*3),
            (self.game_display.width/2, self.game_display.height/5),
            action=self.set_selection,
            action_args=[BazaarSelection.YES],
            color=DTColor.BUTTON_GREEN,
            text='Yes')
        self.no_button = DTButton(
            game_display,
            (self.game_display.width/2, (self.game_display.height/5)*3),
            (self.game_display.width/2, self.game_display.height / 5),
            action=self.set_selection,
            action_args=[BazaarSelection.NO],
            color=DTColor.BUTTON_NO_RED,
            text='No')
        self.haggle_button = DTButton(
            game_display,
            (0, (self.game_display.height/5)*4),
            (self.game_display.width/2, self.game_display.height / 5),
            action=self.set_selection,
            action_args=[BazaarSelection.HAGGLE],
            color=DTColor.BUTTON_ORANGE,
            text='Haggle')
        self.exit_button = DTButton(
            game_display,
            (self.game_display.width/2, (self.game_display.height/5)*4),
            (self.game_display.width/2, self.game_display.height / 5),
            action=self.set_selection,
            action_args=[BazaarSelection.EXIT],
            color=DTColor.BUTTON_BLUE,
            text='Exit')

        self.items = self.get_bazaar_items()
        self.selected_item = InventoryItems.FOOD
        self.bazaar_image = load_image(INVENTORY_IMAGES[self.selected_item])
        self.purchase = False
        self.purchase_count = 1

    def refresh(self):
        self.items = self.get_bazaar_items()
        self.selected_item = InventoryItems.FOOD
        self.bazaar_image = load_image(INVENTORY_IMAGES[self.selected_item])
        self.purchase_count = 1
        self.purchase = False

    def set_selection(self, selection: int):
        self.play_beep()
        if selection == BazaarSelection.NO:
            if not self.purchase:
                self.next_item()
            else:
                self.purchase_item()
        elif selection == BazaarSelection.YES:
            if not self.purchase:
                self.purchase = True
            elif not self.selected_item_single():
                self.purchase_count += 1
        elif selection == BazaarSelection.HAGGLE:
            self.haggle()
        elif selection == BazaarSelection.EXIT:
            if self.purchase:
                self.purchase_count = 1
                self.purchase = False
            else:
                self.exit_bazaar(DTEvent.END_TURN)

    @staticmethod
    def exit_bazaar(event):
        exit_event = pygame.event.Event(DTUserEvent.DT_SELECTION, {'dt_event': event})
        pygame.event.post(exit_event)

    def next_item(self):
        items_keys = list(self.items.keys())
        item_index = items_keys.index(self.selected_item)
        item_index += 1
        if item_index > len(self.items) - 1:
            item_index = 0
        self.selected_item = items_keys[item_index]
        self.bazaar_image = load_image(INVENTORY_IMAGES[self.selected_item])

    def haggle(self):
        result = random.randrange(0, 100)
        if result < 50:
            new_price = self.items[self.selected_item] - 1
            self.items[self.selected_item] = max(new_price, 1)
        else:
            self.exit_bazaar(DTEvent.BAZAAR_CLOSED)

    def purchase_item(self):
        total_price = self.purchase_count * self.items[self.selected_item]

        purchase_event = self.game_display.attempt_purchase(total_price, self.selected_item, self.purchase_count)
        pygame.event.post(purchase_event)

    def selected_item_single(self):
        if self.selected_item in (InventoryItems.HEALER, InventoryItems.SCOUT, InventoryItems.BEAST):
            return True
        return False

    def play_beep(self):
        exit_event = pygame.event.Event(DTUserEvent.PLAY_AUDIO, {'audio': AudioFile.BEEP})
        pygame.event.post(exit_event)

    def display(self):
        self.yes_button.draw()
        self.no_button.draw()
        if not self.purchase:
            self.haggle_button.draw()
        self.exit_button.draw()

        bazaar_price = self.items[self.selected_item]
        self.game_display.game.blit(self.bazaar_image, (20, 20))

        if not self.purchase:
            clock_text = bazaar_price
        else:
            clock_text = self.purchase_count

        bazaar_price_text = pygame.font.Font(
            CLOCK_FONT, 90).render(
            str(clock_text), True, DTColor.BUTTON_NO_RED)

        text_rect = bazaar_price_text.get_rect()
        text_rect.center = ((self.game_display.width / 4)*3, self.game_display.height / 4)
        self.game_display.game.blit(bazaar_price_text, text_rect)

    def get_bazaar_items(self):
        items = {
            InventoryItems.FOOD: 1,
            InventoryItems.WARRIOR: random.randrange(4, 10),
            InventoryItems.BEAST: random.randrange(15, 20),
            InventoryItems.SCOUT: random.randrange(15, 20),
            InventoryItems.HEALER: random.randrange(15, 20)
        }

        # If user already owns one time buy item don't offer it
        for item in (InventoryItems.HEALER, InventoryItems.SCOUT, InventoryItems.BEAST):
            if self.game_display.current_items[item]:
                del items[item]

        return items
    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)

        self.game_display = game_display
        self.beeped = False
        self.enabled = True
        self.bazaar_button = DTButton(
            game_display,
            (self.game_display.width/3, self.game_display.height/4),
            (self.game_display.width/3, self.game_display.height/4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_BAZAAR],
            color=DTColor.BUTTON_BLUE,
            text='Bazaar',
            font_size=40)
        self.tomb_ruin_button = DTButton(
            game_display,
            (0, (self.game_display.height/4) * 2),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_TOMB_RUIN],
            color=DTColor.BUTTON_BLUE,
            text='Tomb|Ruin',
            font_size=40)
        self.move_button = DTButton(
            game_display,
            (self.game_display.width/3, (self.game_display.height/4) * 2),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_MOVE],
            color=DTColor.BUTTON_BLUE,
            text='Move',
            font_size=40)
        self.sanctuary_citadel_button = DTButton(
            game_display,
            ((self.game_display.width/3)*2, (self.game_display.height/4) * 2),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_SANCTUARY_CITADEL],
            color=DTColor.BUTTON_BLUE,
            text='Sanctuary',
            font_size=40)
        self.dark_tower_button = DTButton(
            game_display,
            (0, (self.game_display.height / 4) * 3),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_DARK_TOWER],
            color=DTColor.BUTTON_RED,
            text='DarkTower',
            font_size=40)
        self.frontier_button = DTButton(
            game_display,
            (self.game_display.width/3, (self.game_display.height / 4) * 3),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_FRONTIER],
            color=DTColor.BUTTON_BLUE,
            text='Frontier',
            font_size=40)
        self.inventory_button = DTButton(
            game_display,
            ((self.game_display.width/3)*2, (self.game_display.height / 4) * 3),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_INVENTORY],
            color=DTColor.BUTTON_DARK_TAN,
            text='Inventory',
            font_size=40)

        self.player_text = pygame.font.Font(
            CLOCK_FONT, DEFAULT_FONT_SIZE).render(
            'P{}'.format(self.game_display.current_player + 1), True, DTColor.BUTTON_NO_RED)
class PlayerTurnSelectView(BaseView):
    def __init__(self, game_display: DTGameDisplay):
        super().__init__(game_display=game_display)

        self.game_display = game_display
        self.beeped = False
        self.enabled = True
        self.bazaar_button = DTButton(
            game_display,
            (self.game_display.width/3, self.game_display.height/4),
            (self.game_display.width/3, self.game_display.height/4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_BAZAAR],
            color=DTColor.BUTTON_BLUE,
            text='Bazaar',
            font_size=40)
        self.tomb_ruin_button = DTButton(
            game_display,
            (0, (self.game_display.height/4) * 2),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_TOMB_RUIN],
            color=DTColor.BUTTON_BLUE,
            text='Tomb|Ruin',
            font_size=40)
        self.move_button = DTButton(
            game_display,
            (self.game_display.width/3, (self.game_display.height/4) * 2),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_MOVE],
            color=DTColor.BUTTON_BLUE,
            text='Move',
            font_size=40)
        self.sanctuary_citadel_button = DTButton(
            game_display,
            ((self.game_display.width/3)*2, (self.game_display.height/4) * 2),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_SANCTUARY_CITADEL],
            color=DTColor.BUTTON_BLUE,
            text='Sanctuary',
            font_size=40)
        self.dark_tower_button = DTButton(
            game_display,
            (0, (self.game_display.height / 4) * 3),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_DARK_TOWER],
            color=DTColor.BUTTON_RED,
            text='DarkTower',
            font_size=40)
        self.frontier_button = DTButton(
            game_display,
            (self.game_display.width/3, (self.game_display.height / 4) * 3),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_FRONTIER],
            color=DTColor.BUTTON_BLUE,
            text='Frontier',
            font_size=40)
        self.inventory_button = DTButton(
            game_display,
            ((self.game_display.width/3)*2, (self.game_display.height / 4) * 3),
            (self.game_display.width/3, self.game_display.height / 4),
            action=self.make_selection,
            action_args=[DTEvent.SELECT_INVENTORY],
            color=DTColor.BUTTON_DARK_TAN,
            text='Inventory',
            font_size=40)

        self.player_text = pygame.font.Font(
            CLOCK_FONT, DEFAULT_FONT_SIZE).render(
            'P{}'.format(self.game_display.current_player + 1), True, DTColor.BUTTON_NO_RED)

    def make_selection(self, event: DTEvent):
        self.enabled = False
        selection_event = pygame.event.Event(DTUserEvent.DT_SELECTION, {'dt_event': event})
        pygame.event.post(selection_event)

    def refresh(self):
        self.beeped = False
        self.enabled = True
        self.player_text = pygame.font.Font(
            CLOCK_FONT, DEFAULT_FONT_SIZE).render(
            'P{}'.format(self.game_display.current_player + 1), True, DTColor.BUTTON_NO_RED)

    def display(self):
        self.play_beep()
        self.bazaar_button.draw(enabled=self.enabled)
        self.tomb_ruin_button.draw(enabled=self.enabled)
        self.move_button.draw(enabled=self.enabled)
        self.sanctuary_citadel_button.draw(enabled=self.enabled)
        self.dark_tower_button.draw(enabled=self.enabled)
        self.frontier_button.draw(enabled=self.enabled)
        self.inventory_button.draw(enabled=self.enabled)

        text_rect = self.player_text.get_rect()
        text_rect.center = (self.game_display.width/2, self.game_display.height/8)
        self.game_display.game.blit(self.player_text, text_rect)

    def play_beep(self):
        if not self.beeped:
            exit_event = pygame.event.Event(DTUserEvent.PLAY_AUDIO, {'audio': AudioFile.BEEP})
            pygame.event.post(exit_event)
            self.beeped = True