예제 #1
0
class GameBoard:

    MYSTIC_INDEX = 6
    HEAVY_INDEX = 7
    CULTIST_INDEX = 8
    
    def __init__(self):
        self._mystics = DeckFactory.build_mystic_deck()
        self._heavies = DeckFactory.build_heavy_deck()
        self._deck = DeckFactory.build_center_deck()
        self._board = Hand()
        self._cultist = Cultist()
        for _ in range(6):
            self.draw_card()
        
    def draw_card(self):
        card = self._deck.draw_card()
        if(card == None):
            return
        self._board.add_card(card)
    
    def get_card(self, index):
        self.assert_is_valid_index(index)
        
        if(index == self.MYSTIC_INDEX):
            return self._mystics.peek()
        if(index == self.HEAVY_INDEX):
            return self._heavies.peek()
        if(index == self.CULTIST_INDEX):
            return self._cultist
        return self._board.get_card_at_index(index)
        
    def acquire_card(self, index):
        self.assert_is_valid_index(index)
        
        if(index == self.MYSTIC_INDEX):
            return self.acquire_mystic()
        if(index == self.HEAVY_INDEX):
            return self.acquire_heavy()
        if(index == self.CULTIST_INDEX):
            self._cultist.acquire()
        
        card = self._board.remove_card(index)
        try:
            card.acquire()
            self.draw_card()
            return card
        except Exception as e:
            self._board.add_card_at_index(card, index)
            raise e
            
    def acquire_heavy(self):
        card = self._heavies.draw_card()
        return card
    
    def acquire_mystic(self):
        card = self._mystics.draw_card()
        return card
        
    def defeat_card(self, index):
        self.assert_is_valid_index(index)
        
        if(index == self.CULTIST_INDEX):
            return self._cultist.defeat()
        
        card = self._board.remove_card(index)
        try:
            honor = card.defeat()
            self.draw_card()
            return honor
        except Exception as e:
            self._board.add_card_at_index(card, index)
            raise e
    
    def print(self):
        for i in range(self._board.get_size()):
            print(str(i) + ". " + self._board.get_card_at_index(i).get_name() + " - " + str(self._board.get_card_at_index(i).get_cost()))
        print(str(GameBoard.MYSTIC_INDEX) + ". " + self._mystics.peek().get_name())
        print(str(GameBoard.HEAVY_INDEX) + ". " + self._heavies.peek().get_name())
        print(str(GameBoard.CULTIST_INDEX) + ". " + self._cultist.get_name())
    
    def assert_is_valid_index(self, index):
        if(self.is_valid_index(index) == False):
            raise Exception("Invalid index.")
    
    def is_valid_index(self, index):
        if(index == GameBoard.MYSTIC_INDEX):
            return True
        if(index == GameBoard.HEAVY_INDEX):
            return True
        if(index == GameBoard.CULTIST_INDEX):
            return True;
        if(index < 0):
            return False
        if(index >= self._board.get_size()):
            return False
        return True
예제 #2
0
class Player:
    def __init__(self, name):
        self._name = name
        self._current_power = 0
        self._current_runes = 0
        self._honor = 0
        self._deck = DeckFactory.build_player_deck()
        self._hand = Hand()
        self._in_play = InPlay()
        self.end_turn()

    def remove_power(self, power):
        self.add_power(-1 * power)

    def add_power(self, power):
        self._current_power += power
        print(self.get_name() + " now has " + str(self._current_power) +
              " power.")

    def remove_runes(self, runes):
        self.add_runes(-1 * runes)

    def add_runes(self, runes):
        self._current_runes += runes
        print(self.get_name() + " now has " + str(self._current_runes) +
              " runes.")

    def add_honor(self, honor):
        self._honor += honor
        print(self.get_name() + " now has " + str(self._honor) + " honor.")

    def draw_card(self):
        card = self._deck.draw_card()
        if (card == None):
            return
        self._hand.add_card(card)
        print(self.get_name() + " now has " + str(self._hand.get_size()) +
              " cards in hand.")

    def acquire_card(self, card):
        self._deck.add_to_graveyard(card)
        print(self.get_name() + " has acquired " + card.get_name() + ".")

    def add_card_to_graveyard(self, card):
        self._deck.add_to_graveyard(card)

    def banish_card_from_hand(self, index):
        self._hand.remove_card(index)

    def print_hand(self):
        self._hand.print()

    def get_name(self):
        return self._name

    def get_honor(self):
        return self._honor

    def get_runes(self):
        return self._current_runes

    def get_power(self):
        return self._current_power

    def get_card_from_hand(self, index):
        return self._hand.get_card_at_index(index)

    def remove_card_from_hand(self, index):
        return self._hand.remove_card(index)

    def add_card_to_hand(self, card, index):
        self._hand.add_card_at_index(card, index)

    def end_turn(self):
        self._current_power = 0
        self._current_runes = 0
        self._in_play.reset()
        while (self._hand.get_size() != 0):
            self._deck.add_to_graveyard(self._hand.remove_card(0))
        while (self._hand.get_size() != 5):
            self._hand.add_card(self._deck.draw_card())

    def print(self, is_print_full):
        print("Player " + self.get_name() + " - " + str(self.get_honor()) +
              " honor")
        print(str(self._hand.get_size()) + " cards in hand")
        self._hand.print()
        self._in_play.print()
        if (is_print_full):
            print(
                str(self.get_runes()) + " runes; " + str(self.get_power()) +
                " power")