class SklearnIterator:
    def __init__(self, training_size, AI="minimax", AI_iteration=0):
        self.game = None
        self.X = None  # X is the state
        self.Y = None  # Y is the play choice
        self.AI = AI
        self.clf = None
        self.AI_iteration = AI_iteration
        self.training_size = training_size
        self.training_count = [0]

    def initialize(self):
        if self.AI == "sklearn":
            print("importing training_set_X")
            from training_set_X_5000_0_test import X as training_set_X
            from training_set_Y_5000_0_test import Y as training_set_Y
            self.clf = svm.SVR(kernel='linear')
            print("fitting sklearn")
            self.clf.fit(training_set_X, training_set_Y)
        self.X = open(
            "C:\\Users\\Zhi Li\\Desktop\\CIS 667 Introduction to AI\\Project\\codes\\gaming part\\20181122 game with coin\\training_data\\training_set_X_%d_%d_test.py"
            % (training_size, AI_iteration), "w+")
        self.Y = open(
            "C:\\Users\\Zhi Li\\Desktop\\CIS 667 Introduction to AI\\Project\\codes\\gaming part\\20181122 game with coin\\training_data\\training_set_Y_%d_%d_test.py"
            % (training_size, AI_iteration), "w+")
        self.X.write("X = [\n")
        self.Y.write("Y = [\n")

    def reset_game(self):
        self.game = MagicCardGame()
        self.game.initialize()

    def get_current_choice(self):
        if randint(0, 9) < 8:
            ## random choice
            available_set = ()

            if len(self.game.available_attackers()) != 0:
                available_set += (2, )
            elif len(self.game.available_play_cards()) != 0:
                available_set += (1, )
            else:
                available_set += (3, )

            inp = available_set[0]
            if inp == 1:
                card_id = random.choice(self.game.available_play_cards())
                available_set += (card_id, )
                target = None
                if cards[card_id][3] is not None:
                    target = random.choice(
                        self.game.available_play_card_targets(card_id))
                available_set += (target, )
            elif inp == 2:
                attacker_position = random.choice(
                    self.game.available_attackers())
                target_position = random.choice(
                    self.game.available_attacking_targets(attacker_position))
                available_set += (
                    attacker_position,
                    target_position,
                )
            elif inp == 3:
                available_set += (None, None)
            else:
                print("Invalid option!")
            return available_set, None

        elif self.AI == "minimax":
            ## minimax choice
            minimax = MinimaxWithSampling(self.game,
                                          self.X,
                                          self.Y,
                                          training_count=self.training_count)
            current_choice = minimax.search()
            win_rate = minimax.max_utility
            return current_choice, win_rate

        elif self.AI_iteration > 0:
            ## sklearn AI choice
            return SklearnAI(
                self.game,
                self.clf,
                self.X,
                self.Y,
                training_count=self.training_count).get_best_choice()
        else:
            raise Exception("Invalid AI!")

    def play_game(self, verbose=False):
        if verbose:
            self.game.show_state()
        while not self.game.is_end():
            self.game.start_turn()
            if self.game.is_end():
                break

            inp = 0
            while inp != 3:
                ##                input("Enter any key to continue: ")
                if verbose:
                    self.game.show_state()
                    self.game.show_available_play_cards()
                    self.game.show_available_attackers()

                current_choice, win_rate = self.get_current_choice()

                inp = current_choice[0]
                if verbose:
                    print("Action:", inp)
                if inp == 1:
                    card_id = current_choice[1]
                    if verbose:
                        print("Playing card:", cards[card_id][0])
                    target = current_choice[2]
                    if verbose:
                        print("Target =", target)
                    self.game.play_card(card_id, target=target)
                    if self.game.is_end():
                        break
                elif inp == 2:
                    attacker_position = current_choice[1]
                    if verbose:
                        print("Attacker: ", attacker_position)
                        self.game.show_available_attacking_targets(
                            attacker_position)
                    target_position = current_choice[2]
                    if verbose:
                        print("Attacked target:", target_position)
                    self.game.attack(attacker_position, target_position)
                    if self.game.is_end():
                        break
                elif inp == 3:
                    break
                else:
                    print("Invalid option!")

            if self.game.is_end():
                break
            self.game.end_turn()
        if verbose:
            self.game.show_state()
            self.game.end_game()
        print("Winner is player %s!" % self.game.get_winner())

        print("training_count = %d" % self.training_count[0])

        return self.training_count[0]

    def end_game(self):
        self.X.write("\n]")
        self.Y.write("\n]")
        self.X.close()
        self.Y.close()
class WildPlay:
    def __init__(self, AI=("random", "random"), AI_iteration=(0, 0)):
        self.game = None
        self.turn = 0
        self.AI = AI
        self.clf = None
        self.AI_iteration = AI_iteration

    def initialize(self):
        if self.AI[0] == "sklearn" or self.AI[1] == "sklearn":
            print("importing training_set_X")
            from training_set_X_10000_1_test import X as training_set_X
            from training_set_Y_10000_1_test import Y as training_set_Y
            self.clf = svm.SVR(kernel='linear')
            print("fitting sklearn")
            self.clf.fit(training_set_X, training_set_Y)

    def reset_game(self):
        self.game = MagicCardGame()
        self.game.initialize()
        self.turn = 0

    def get_current_choice(self):
        if self.AI[self.game.get_current_player()] == "random":
            ## random choice
            available_set = ()
            if len(self.game.available_attackers()) != 0:
                available_set += (2, )
            elif len(self.game.available_play_cards()) != 0:
                available_set += (1, )
            else:
                available_set += (3, )

            inp = available_set[0]
            if inp == 1:
                card_id = random.choice(self.game.available_play_cards())
                available_set += (card_id, )
                target = None
                if cards[card_id][3] is not None:
                    target = random.choice(
                        self.game.available_play_card_targets(card_id))
                available_set += (target, )
            elif inp == 2:
                attacker_position = random.choice(
                    self.game.available_attackers())
                target_position = random.choice(
                    self.game.available_attacking_targets(attacker_position))
                available_set += (
                    attacker_position,
                    target_position,
                )
            elif inp == 3:
                available_set += (None, None)
            else:
                print("Invalid option!")
            return available_set, None

        elif self.AI[self.game.get_current_player()] == "minimax":
            ## minimax choice
            minimax = MinimaxWithSampling(self.game)
            current_choice = minimax.search()
            win_rate = minimax.max_utility
            return current_choice, win_rate

        elif self.AI_iteration[self.game.get_current_player()] > 0:
            ## sklearn AI choice
            return SklearnAI(self.game, self.clf).get_best_choice()
        else:
            raise Exception("Invalid AI!")

    def play_game(self, verbose=False):
        if verbose:
            self.game.show_state()
        while not self.game.is_end():
            self.turn += 1
            self.game.start_turn()
            if self.game.is_end():
                break
            inp = 0
            while inp != 3:
                ##                input("Enter any key to continue: ")
                if verbose:
                    self.game.show_state()
                    self.game.show_available_play_cards()
                    self.game.show_available_attackers()
                current_choice, win_rate = self.get_current_choice()
                inp = current_choice[0]
                if verbose:
                    print("Action:", inp)
                if inp == 1:
                    card_id = current_choice[1]
                    if verbose:
                        print("Playing card:", cards[card_id][0])
                    target = current_choice[2]
                    if verbose:
                        print("Target =", target)
                    self.game.play_card(card_id, target=target)
                    if self.game.is_end():
                        break
                elif inp == 2:
                    attacker_position = current_choice[1]
                    if verbose:
                        print("Attacker: ", attacker_position)
                        self.game.show_available_attacking_targets(
                            attacker_position)
                    target_position = current_choice[2]
                    if verbose:
                        print("Attacked target:", target_position)
                    self.game.attack(attacker_position, target_position)
                    if self.game.is_end():
                        break
                elif inp == 3:
                    break
                else:
                    print("Invalid option!")
            if self.game.is_end():
                break
            self.game.end_turn()
        if verbose:
            self.game.show_state()
            self.game.end_game()
        print(" run_turns = %d, Winner is player %s!" %
              (self.turn, self.game.get_winner()))
Esempio n. 3
0
class SklearnIterator:
    def __init__(self, AI = "minimax", AI_iteration = 0):
        self.game = None
        self.X = None # X is the state
        self.Y = None # Y is the play choice
        self.AI = AI
        self.clf = None
        self.AI_iteration = AI_iteration

    def initialize(self):
        if self.AI == "sklearn":
            print("importing training_set_X")
            from training_set_X0 import X as training_set_X
            from training_set_Y0 import Y as training_set_Y
            self.clf = svm.SVR(kernel = 'linear')
            print("fitting sklearn")
            self.clf.fit(training_set_X, training_set_Y)
        self.X = open("C:\\Users\\Zhi Li\\Desktop\\CIS 667 Introduction to AI\\Project\\codes\\gaming part\\20181122 game with coin\\training_data\\training_set_X 50 %d.py" % AI_iteration, "w+")
        self.Y = open("C:\\Users\\Zhi Li\\Desktop\\CIS 667 Introduction to AI\\Project\\codes\\gaming part\\20181122 game with coin\\training_data\\training_set_Y 50 %d.py" % AI_iteration, "w+")
        self.X.write("X = [\n")
        self.Y.write("Y = [\n")

    def reset_game(self):
        self.game = MagicCardGame()
        self.game.initialize()

    def get_current_choice(self):
        lst = [0] * (Constants.AVAILABLE_CARDS + Constants.PLAYER_MINION_UPPERBOUND * 4 + 3 + 1)
        ##           hand0(134),                    target0(14),  battlefield0(7),battlefield_target0(7)  hero0,h1,h1, end_turn
        if self.AI == "minimax":
            minimax = MinimaxWithSampling(self.game, self.X, self.Y)
            current_choice = minimax.search()
            win_rate = minimax.max_utility
            return current_choice, win_rate
        
        elif self.AI_iteration > 0:
            return SklearnAI(self.game, self.clf, self.X, self.Y).get_best_choice()
        else:
            raise Exception ("Invalid AI!")

        

    def play_game(self, verbose = False):
        if verbose:
            self.game.show_state()
        while not self.game.is_end():
            self.game.start_turn()
            if self.game.is_end():
                break

            inp = 0
            while inp != 3:
##                input("Enter any key to continue: ")
                if verbose:
                    self.game.show_state()
                    self.game.show_available_play_cards()
                    self.game.show_available_attackers()


                current_choice, win_rate = self.get_current_choice()

                
                inp = current_choice[0]
                if verbose:
                    print("Action:", inp)
                if inp == 1:
                    card_id = current_choice[1]
                    if verbose:
                        print("Playing card:", cards[card_id][0])
                    if cards[card_id][3] is not None:
                        if verbose:
                            self.game.show_available_play_card_targets(card_id)
                        target = current_choice[2]
                    else:
                        target = None
                    if verbose:
                        print("Target =", target)
                    self.game.play_card(card_id, target = target)
                    if self.game.is_end():
                        break
                elif inp == 2:
                    attacker_position = current_choice[1]
                    if verbose:
                        print("Attacker: ", attacker_position)
                        self.game.show_available_attacking_targets(attacker_position)
                    target_position = current_choice[2]
                    if verbose:
                        print("Attacked target:", target_position)
                    self.game.attack(attacker_position, target_position)
                    if self.game.is_end():
                        break
                elif inp == 3:
                    break
                else:
                    print("Invalid option!")








                
            if self.game.is_end():
                break
            self.game.end_turn()
        if verbose:
            self.game.show_state()
            self.game.end_game()
        print("Winner is player %s!" % self.game.get_winner())




        
        

    def end_game(self):
        self.X.write("\n]")
        self.Y.write("\n]")
        self.X.close()
        self.Y.close()
class PlayMinimaxSamplingWithRandom:
    def __init__(self):
        self.game = MagicCardGame()

    def play(self, AI_player=0, verbose=False):
        self.game.initialize()
        if verbose:
            self.game.show_state()

        r = 0
        while not self.game.is_end():
            r += 1
            self.game.start_turn()
            if self.game.is_end():
                break
            inp = -10
            while inp != 3:
                if verbose:
                    ##                    input("Enter any key to continue: ")
                    self.game.show_state()
                    self.game.show_available_play_cards()
                    self.game.show_available_attackers()
                available_set = ()
                if len(self.game.available_play_cards()) != 0:
                    available_set += (1, )
                if len(self.game.available_attackers()) != 0:
                    available_set += (2, )
                available_set += (3, )

                minimax_result = MinimaxWithSampling(self.game).search()
                inp = minimax_result[0]

                if verbose:
                    print("Action:", inp)
                if inp == 1:
                    card_id = minimax_result[1]
                    if verbose:
                        print("Playing card:", cards[card_id][0])
                    if cards[card_id][3] is not None:
                        if verbose:
                            self.game.show_available_play_card_targets(card_id)
                        target = minimax_result[2]
                    else:
                        target = None
                    if verbose:
                        print("Target =", target)
                    self.game.play_card(card_id, target=target)
                    if self.game.is_end():
                        break
                elif inp == 2:
                    attacker_position = minimax_result[1]
                    if verbose:
                        print("Attacker: ", attacker_position)
                        self.game.show_available_attacking_targets(
                            attacker_position)
                    target_position = minimax_result[2]
                    if verbose:
                        print("Attacked target:", target_position)
                    self.game.attack(attacker_position, target_position)
                    if self.game.is_end():
                        break
                elif inp == 3:
                    break
                else:
                    print("Invalid option!")
            if self.game.is_end():
                break
            self.game.end_turn()
        if verbose:
            self.game.show_state()
            self.game.end_game()
        print("round = %s" % r, end="  ")
        return self.game.get_winner()
Esempio n. 5
0
class RandomSamplingPlay:
    def __init__(self, verbose=False):
        self.game = MagicCardGame()
        self.verbose = verbose
        self.winner = -10000

    def initialize(self):
        self.game.initialize()

    def set_state(self, new_game):
        self.game = new_game

    def get_winner(self):
        return self.winner

    def start_game(self):
        if self.verbose:
            self.game.show_state()

        while not self.game.is_end():
            self.game.start_turn()
            if self.game.is_end():
                break

            inp = 0
            while inp != 3:
                ##                input("Enter any key to continue: ")
                if self.verbose:
                    self.game.show_state()
                    self.game.show_available_play_cards()
                    self.game.show_available_attackers()
                available_set = ()
                if len(self.game.available_play_cards()) != 0:
                    available_set += (1, )
                if len(self.game.available_attackers()) != 0:
                    available_set += (2, )
                available_set += (3, )
                inp = available_set[0]
                if self.verbose:
                    print("Action:", inp)
                if inp == 1:
                    card_id = random.choice(self.game.available_play_cards())
                    if self.verbose:
                        print("Playing card:", cards[card_id][0])
                    if cards[card_id][3] is not None:
                        if self.verbose:
                            self.game.show_available_play_card_targets(card_id)
                        target = random.choice(
                            self.game.available_play_card_targets(card_id))
                    else:
                        target = None
                    if self.verbose:
                        print("Target =", target)
                    self.game.play_card(card_id, target=target)
                    if self.game.is_end():
                        break
                elif inp == 2:
                    attacker_position = random.choice(
                        self.game.available_attackers())
                    if self.verbose:
                        print("Attacker: ", attacker_position)
                        self.game.show_available_attacking_targets(
                            attacker_position)
                    target_position = random.choice(
                        self.game.available_attacking_targets(
                            attacker_position))
                    if self.verbose:
                        print("Attacked target:", target_position)
                    self.game.attack(attacker_position, target_position)
                    if self.game.is_end():
                        break
                elif inp == 3:
                    break
                else:
                    print("Invalid option!")
            if self.game.is_end():
                break
            self.game.end_turn()
        if self.verbose:
            self.game.show_state()
            self.game.end_game()
        self.winner = self.game.get_winner()
Esempio n. 6
0
class PlayMagicCard:
    def __init__(self):
        self.game = MagicCardGame()

    def initialize(self):
        self.game.initialize()

    def start_game(self):
        self.game.show_state()

        while not self.game.is_end():
            self.game.start_turn()
            if self.game.is_end():
                break

            inp = 0
            while inp != 3:
                self.game.show_state()
                self.game.show_available_play_cards()
                self.game.show_available_attackers()
                available_set = (3, )
                if len(self.game.available_play_cards()) != 0:
                    available_set += (1, )
                if len(self.game.available_attackers()) != 0:
                    available_set += (2, )
                inp = "x"
                while inp not in available_set:
                    inp = int(input("Actions: 1.play 2.attack 3.end turn: "))

                if inp == 1:
                    card_id = "x"
                    while card_id not in tuple(
                            self.game.available_play_cards()):
                        card_id = int(input("Choose a card to play: "))
                    if cards[card_id][3] is not None:
                        self.game.show_available_play_card_targets(card_id)
                        target = "x"
                        while target not in self.game.available_play_card_targets(
                                card_id):
                            target = int(input("Choose a target: "))
                    else:
                        target = None
                    self.game.play_card(card_id, target=target)
                    if self.game.is_end():
                        break
                elif inp == 2:
                    attacker_position = "x"
                    while attacker_position not in self.game.available_attackers(
                    ):
                        attacker_position = int(
                            input("Choose an attacker minion: "))
                    self.game.show_available_attacking_targets(
                        attacker_position)
                    target_position = "x"
                    while target_position not in self.game.available_attacking_targets(
                            attacker_position):
                        target_position = int(input("Choose a target: "))
                    self.game.attack(attacker_position, target_position)
                    if self.game.is_end():
                        break
                elif inp == 3:
                    break
                else:
                    print("Invalid option!")
            if self.game.is_end():
                break
            self.game.end_turn()
        self.game.show_state()
        self.game.end_game()
class TrainingDataGenerator:
    def __init__(self, AI="minimax"):
        self.game = None
        self.X = None  # X is the state
        self.Y = None  # Y is the play choice
        self.AI = AI
        self.clf = None

    def initialize(self):
        if self.AI == "sklearn":
            self.clf = svm.SVR(kernel='linear')
            print("fitting sklearn")
            self.clf.fit(training_set_X, training_set_Y)
        self.X = open(
            "C:\\Users\\Zhi Li\\Desktop\\CIS 667 Introduction to AI\\Project\\codes\\gaming part\\20181122 game with coin\\training_data\\training_set_X150.py",
            "w+")
        self.Y = open(
            "C:\\Users\\Zhi Li\\Desktop\\CIS 667 Introduction to AI\\Project\\codes\\gaming part\\20181122 game with coin\\training_data\\training_set_Y150.py",
            "w+")
        self.X.write("X = [\n")
        self.Y.write("Y = [\n")

    def reset_game(self):
        self.game = MagicCardGame()
        self.game.initialize()

    def get_random_choice(self):
        lst = [0] * (Constants.AVAILABLE_CARDS +
                     Constants.PLAYER_MINION_UPPERBOUND * 4 + 3 + 1)
        ##           hand0(134),                    target0(14),  battlefield0(7),battlefield_target0(7)  hero0,h1,h1, end_turn
        new_game_state, random_choice = RandomChoiceGenerator(
            self.game).get_random_play()
        if random_choice[0] == 1:
            lst[random_choice[1] - 1] = 1
            if random_choice[2] is not None:
                if random_choice[2] < 0:
                    if random_choice[2] == Constants.PLAYER_NICKNAME[0]:
                        lst[Constants.AVAILABLE_CARDS +
                            Constants.PLAYER_MINION_UPPERBOUND * 2 + 1 - 1] = 1
                    else:
                        lst[Constants.AVAILABLE_CARDS +
                            Constants.PLAYER_MINION_UPPERBOUND * 2 + 2 - 1] = 1
                elif random_choice[
                        2] < self.game.state.battlefield.card0_length:
                    lst[Constants.AVAILABLE_CARDS + random_choice[2]] = 1
                elif random_choice[2] < len(
                        self.game.state.battlefield.card_states):
                    lst[Constants.AVAILABLE_CARDS +
                        Constants.PLAYER_MINION_UPPERBOUND +
                        random_choice[2]] = 1
                else:
                    raise Exception("Wrong target! target = %s" %
                                    random_choice[2])
        elif random_choice[0] == 2:
            if self.game.get_current_player() == 0:
                lst[Constants.AVAILABLE_CARDS +
                    Constants.PLAYER_MINION_UPPERBOUND * 2 + 2 +
                    random_choice[1]] = 1
                if random_choice[2] < 0:
                    lst[Constants.AVAILABLE_CARDS +
                        Constants.PLAYER_MINION_UPPERBOUND * 4 + 3 - 1] = 1
                else:
                    target = random_choice[
                        2] - self.game.state.battlefield.card0_length
                    lst[Constants.AVAILABLE_CARDS +
                        Constants.PLAYER_MINION_UPPERBOUND * 3 + 2 +
                        target] = 1
            elif self.game.get_current_player() == 1:
                attacker = random_choice[
                    2] - self.game.state.battlefield.card0_length
                lst[Constants.AVAILABLE_CARDS +
                    Constants.PLAYER_MINION_UPPERBOUND * 2 + 2 + attacker] = 1
                if random_choice[2] < 0:
                    lst[Constants.AVAILABLE_CARDS +
                        Constants.PLAYER_MINION_UPPERBOUND * 4 + 3 - 1] = 1
                else:
                    lst[Constants.AVAILABLE_CARDS +
                        Constants.PLAYER_MINION_UPPERBOUND * 3 + 2 +
                        random_choice[2]] = 1
            else:
                raise Exception("Error!")

        elif random_choice[0] == 3:
            lst[-1] = 1
        else:
            raise Exception("Wrong input type! type = %s" % random_choice[0])
        if self.AI == "minimax":
            return lst, RandomSamplingFromState(new_game_state).do_sampling()
        elif self.AI == "sklearn":
            return lst, -1
        else:
            raise Exception("Invalid AI!")

    def play_game(self, verbose=False):
        if verbose:
            self.game.show_state()
        while not self.game.is_end():
            self.game.start_turn()
            if self.game.is_end():
                break

            inp = 0
            while inp != 3:
                ##                input("Enter any key to continue: ")
                if verbose:
                    self.game.show_state()
                    self.game.show_available_play_cards()
                    self.game.show_available_attackers()

                state_lst = list(self.game.get_state_tuple())
                choice_list, win_rate = self.get_random_choice()
                training_X = state_lst + choice_list
                self.X.write(str(training_X))
                self.X.write(",\n")

                if self.AI == "sklearn":
                    win_rate = self.clf.predict([training_X])
                self.Y.write(str(win_rate))
                self.Y.write(",\n")

                available_set = ()
                if len(self.game.available_play_cards()) != 0:
                    available_set += (1, )
                if len(self.game.available_attackers()) != 0:
                    available_set += (2, )
                available_set += (3, )
                inp = available_set[0]
                if verbose:
                    print("Action:", inp)
                if inp == 1:
                    card_id = random.choice(self.game.available_play_cards())
                    if verbose:
                        print("Playing card:", cards[card_id][0])
                    if cards[card_id][3] is not None:
                        if verbose:
                            self.game.show_available_play_card_targets(card_id)
                        target = random.choice(
                            self.game.available_play_card_targets(card_id))
                    else:
                        target = None
                    if verbose:
                        print("Target =", target)
                    self.game.play_card(card_id, target=target)
                    if self.game.is_end():
                        break
                elif inp == 2:
                    attacker_position = random.choice(
                        self.game.available_attackers())
                    if verbose:
                        print("Attacker: ", attacker_position)
                        self.game.show_available_attacking_targets(
                            attacker_position)
                    target_position = random.choice(
                        self.game.available_attacking_targets(
                            attacker_position))
                    if verbose:
                        print("Attacked target:", target_position)
                    self.game.attack(attacker_position, target_position)
                    if self.game.is_end():
                        break
                elif inp == 3:
                    break
                else:
                    print("Invalid option!")
            if self.game.is_end():
                break
            self.game.end_turn()
        if verbose:
            self.game.show_state()
            self.game.end_game()
        print("Winner is player %s!" % self.game.get_winner())

    def end_game(self):
        self.X.write("\n]")
        self.Y.write("\n]")
        self.X.close()
        self.Y.close()