def PresetGame(pp, testNr=1): from fireplace import cards cards.db.initialize() for test in range(testNr): class1 = pp.class1 class2 = pp.class2 Dummy1 = DummyAgent("Dummy1", DummyAgent.DummyAI, myClass=class1) Dummy2 = DummyAgent("Dummy2", DummyAgent.DummyAI, myClass=class2) deck1 = random_draft(Dummy1.myClass, []) #random deck wrt its class deck2 = random_draft(Dummy2.myClass, []) #random deck wrt its class player1 = Player(Dummy1.name, deck1, Dummy1.myClass.default_hero) player2 = Player(Dummy2.name, deck2, Dummy2.myClass.default_hero) game = Game(players=(player1, player2)) # Configurations player1._start_hand_size = 3 ## this line must be before 'start()' player2._start_hand_size = 3 ## player1.max_mana = 9 ## this line must be before 'start()' player2.max_mana = 9 ## game.start() player1.hero.max_health = 30 ## this line must be below 'start()' player2.hero.max_health = 30 ## cards_to_mulligan = [] player1.choice.choose(*cards_to_mulligan) player2.choice.choose(*cards_to_mulligan) player1._targetedaction_log = [] player2._targetedaction_log = [] pp(game.current_player).execute(test) pass
def getInitGame(self): """ Returns: startBoard: a representation of the board (ideally this is the form that will be the input to your neural network) """ if self.isolate: self.isolateSet() cards.db.initialize() if self.is_basic: #create quick simple game with open('notbasic.data', 'rb') as f: extra_set = pickle.load(f) p1 = 6 #priest p2 = 7 #rogue deck1 = random_draft(CardClass(p1), exclude=extra_set) deck2 = random_draft(CardClass(p2), exclude=extra_set) else: p1 = random.randint(1, 9) p2 = random.randint(1, 9) deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) self.players[0] = Player("Player1", deck1, CardClass(p1).default_hero) self.players[1] = Player("Player2", deck2, CardClass(p2).default_hero) game = Game(players=self.players) game.start() # Skip mulligan for now for player in game.players: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) game.player_to_start = game.current_player self.game = game return game
def main(): deck1 = random_draft(hero=MAGE) deck2 = random_draft(hero=WARRIOR) player1 = Player(name="Player1") player1.prepare_deck(deck1, MAGE) player2 = Player(name="Player2") player2.prepare_deck(deck2, WARRIOR) game = Game(players=(player1, player2)) game.start() while True: heropower = game.current_player.hero.power # always play the hero power, just for kicks if heropower.is_playable(): if heropower.has_target(): heropower.play(target=random.choice(heropower.targets)) else: heropower.play() # iterate over our hand and play whatever is playable for card in game.current_player.hand: if card.is_playable(): if card.has_target(): card.play(target=random.choice(card.targets)) else: card.play() else: print("Not playing", card) # Randomly attack with whatever can attack for character in game.current_player.characters: if character.can_attack(): character.attack(random.choice(character.targets)) game.end_turn()
def setup_game(): """ initializes a game between two players Returns: game: A game entity representing the start of the game after the mulligan phase """ #choose classes (priest, rogue, shaman, warlock) p1 = random.randint(6, 9) p2 = random.randint(6, 9) #initialize players and randomly draft decks #pdb.set_trace() deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) player1 = Player("Player1", deck1, CardClass(p1).default_hero) player2 = Player("Player2", deck2, CardClass(p2).default_hero) #begin the game game = Game(players=(player1, player2)) game.start() #Skip mulligan for now for player in game.players: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) return game
def initGame(self): cards.db.initialize() if self.is_basic: #create quick simple game with open('notbasic.data', 'rb') as f: extra_set = pickle.load(f) p1 = 6 #priest p2 = 7 #rogue deck1 = random_draft(CardClass(p1), exclude=extra_set) deck2 = random_draft(CardClass(p2), exclude=extra_set) else: p1 = random.randint(1, 9) p2 = random.randint(1, 9) deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) Board.players[0] = Player("Player1", deck1, CardClass(p1).default_hero) Board.players[1] = Player("Player2", deck2, CardClass(p2).default_hero) game = Game(players=self.players) game.start() # Skip mulligan for now for player in game.players: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) # self.start_player = game.current_player game.player_to_start = game.current_player Board.game = game return game
def play_full_game(): deck1 = random_draft(hero=MAGE) deck2 = random_draft(hero=WARRIOR) player1 = Player("Player1", deck1, MAGE) player2 = Player("Player2", deck2, WARRIOR) game = Game(players=(player1, player2)) game.start() for player in game.players: # print("Can mulligan %r" % (player.choice.cards)) mull_count = random.randint(0, len(player.choice.cards)) cards_to_mulligan = random.sample(player.choice.cards, mull_count) player.choice.choose(*cards_to_mulligan) try: while True: player = game.current_player heropower = player.hero.power if heropower.is_usable() and random.random() < 0.1: if heropower.has_target(): heropower.use(target=random.choice(heropower.targets)) else: heropower.use() continue # iterate over our hand and play whatever is playable for card in player.hand: if card.is_playable() and random.random() < 0.5: target = None if card.choose_cards: card = random.choice(card.choose_cards) if card.has_target(): target = random.choice(card.targets) # print("Playing %r on %r" % (card, target)) card.play(target=target) if player.choice: choice = random.choice(player.choice.cards) # print("Choosing card %r" % (choice)) player.choice.choose(choice) continue # Randomly attack with whatever can attack for character in player.characters: if character.can_attack(): character.attack(random.choice(character.targets)) continue game.end_turn() except GameOver: return game # print("Game completed normally in " + str(game.turn) + " turns.") return game
def getInitGame(self): """ Returns: startBoard: a representation of the board (ideally this is the form that will be the input to your neural network) """ if self.isolate: self.isolateSet() cards.db.initialize() if self.is_basic: #create quick simple game # with open('notbasic.data', 'rb') as f: # extra_set = pickle.load(f) extra_set = cards.filter(card_set=[ CardSet.EXPERT1, CardSet.HOF, CardSet.NAXX, CardSet.GVG, CardSet.BRM, CardSet.TGT, CardSet.LOE, CardSet.OG, CardSet. KARA, CardSet.GANGS, CardSet.UNGORO, CardSet.ICECROWN, CardSet. LOOTAPALOOZA, CardSet.GILNEAS, CardSet.BOOMSDAY, CardSet.TROLL ]) # LOOTAPALOOZA = Kobolds and Catacombs # GILNEAS = Witchwood # TROLL = Rasthakan's Rumble # p1 = 6 #priest p1 = 7 #rogue p2 = 7 #rogue # p1 = 4 # mage # p2 = 4 # mage # deck1 = random_draft(CardClass(p1), exclude=extra_set) # deck2 = random_draft(CardClass(p2), exclude=extra_set) deck1 = self.roguebasic_draft( ) # use same shuffled rogue AI basic decks for now deck2 = self.roguebasic_draft() else: p1 = random.randint(1, 9) p2 = random.randint(1, 9) deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) self.players[0] = Player("Player1", deck1, CardClass(p1).default_hero) self.players[1] = Player("Player2", deck2, CardClass(p2).default_hero) game = Game(players=self.players) game.start() # Skip mulligan for now (only mulligan expensive cards) for player in game.players: # if player.name == 'Player1': # cards_to_mulligan = [c for c in player.choice.cards if c.cost > 3] # else: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) # track played card list self.players[0].playedcards = [] self.players[1].playedcards = [] #game.player_to_start = game.current_player # obsolete? self.game = game return game
def play_full_game(): deck1 = random_draft(hero=MAGE) deck2 = random_draft(hero=WARRIOR) player1 = Player(name="Player1") player1.prepare_deck(deck1, MAGE) player2 = Player(name="Player2") player2.prepare_deck(deck2, WARRIOR) game = Game(players=(player1, player2)) game.start() for player in game.players: print("Can mulligan %r" % (player.choice.cards)) mull_count = random.randint(0, len(player.choice.cards)) cards_to_mulligan = random.sample(player.choice.cards, mull_count) player.choice.choose(*cards_to_mulligan) while True: player = game.current_player heropower = player.hero.power if heropower.is_usable() and percent_chance(10): if heropower.has_target(): heropower.use(target=random.choice(heropower.targets)) else: heropower.use() continue # iterate over our hand and play whatever is playable for card in player.hand: if card.is_playable() and percent_chance(50): target = None if card.choose_cards: card = random.choice(card.choose_cards) if card.has_target(): target = random.choice(card.targets) print("Playing %r on %r" % (card, target)) card.play(target=target) continue # Randomly attack with whatever can attack for character in player.characters: if character.can_attack(): character.attack(random.choice(character.targets)) continue if player.choice: choice = random.choice(player.choice.cards) print("Choosing card %r" % (choice)) player.choice.choose(choice) continue game.end_turn()
def init_game(self): """ initializes a game between two players Returns: game: A game entity representing the start of the game after the mulligan phase """ if self.is_basic: #create quick simple game p1 = 6 #priest p2 = 7 #rogue deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) self.players[0] = Player("Player1", deck1, CardClass(p1).default_hero) self.players[1] = Player("Player2", deck2, CardClass(p2).default_hero) self.game = Game(players=self.players) self.game.start() #Skip mulligan for player in self.game.players: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) return self.game else: p1 = random.randint(1, 9) p2 = random.randint(1, 9) #initialize players and randomly draft decks #pdb.set_trace() deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) self.players[0] = Player("Player1", deck1, CardClass(p1).default_hero) self.players[1] = Player("Player2", deck2, CardClass(p2).default_hero) #begin the game self.game = Game(players=self.players) self.game.start() #Skip mulligan for now for player in self.game.players: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) return self.game
def setup_basic_game(): p1 = 6 #priest p2 = 7 #rogue deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) player1 = Player("Player1", deck1, CardClass(p1).default_hero) player2 = Player("Player2", deck2, CardClass(p2).default_hero) game = Game(players=(player1, player2)) game.start() #Skip mulligan for player in game.players: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) return game
def play_game(hero1, hero2): open(log_file, 'w').close() deck1 = random_draft(hero=hero1) deck1[0] = "EX1_160a" player1 = Player(name="Player1") player1.prepare_deck(deck1, hero1) deck2 = random_draft(hero=hero2) deck2[0] = "EX1_160a" player2 = Player(name="Player2") player2.prepare_deck(deck2, hero2) game = Game(players=(player1, player2)) game.start() player1.choice.choose(*[]) player2.choice.choose(*[]) while game.state != State.COMPLETE: try: heropower = game.current_player.hero.power if heropower.is_usable(): if heropower.has_target(): heropower.use(target=random.choice(heropower.targets)) else: heropower.use() for card in game.current_player.hand: if card.is_playable(): target = None if card.choose_cards: card = random.choice(card.choose_cards) if card.has_target(): target = random.choice(card.targets) card.play(target=target) for character in game.current_player.characters: if character.can_attack(): character.attack(random.choice(character.targets)) game.end_turn() except GameOver: pass
def main(): deck1 = random_draft(hero=MAGE) deck2 = random_draft(hero=WARRIOR) player1 = Player(name="Player1") player1.prepare_deck(deck1, MAGE) player2 = Player(name="Player2") player2.prepare_deck(deck2, WARRIOR) game = Game(players=(player1, player2)) game.start() for player in game.players: print("Can mulligan %r" % (player.choice.cards)) mull_count = random.randint(0, len(player.choice.cards)) cards_to_mulligan = random.sample(player.choice.cards, mull_count) player.choice.choose(*cards_to_mulligan) while True: heropower = game.current_player.hero.power # always play the hero power, just for kicks if heropower.is_usable(): if heropower.has_target(): heropower.use(target=random.choice(heropower.targets)) else: heropower.use() # iterate over our hand and play whatever is playable for card in game.current_player.hand: if card.is_playable(): target = None choice = None if card.has_target(): target = random.choice(card.targets) if card.data.choose_cards: choice = random.choice(card.data.choose_cards) card.play(target=target, choose=choice) else: print("Not playing", card) # Randomly attack with whatever can attack for character in game.current_player.characters: if character.can_attack(): character.attack(random.choice(character.targets)) game.end_turn()
def main(): deck1 = random_draft(hero=MAGE) deck2 = random_draft(hero=WARRIOR) player1 = Player(name="Player1") player1.prepare_deck(deck1, MAGE) player2 = Player(name="Player2") player2.prepare_deck(deck2, WARRIOR) game = Game(players=(player1, player2)) game.start() for player in game.players: print("Can mulligan %r" % (player.choice.cards)) mull_count = random.randint(0, len(player.choice.cards)) cards_to_mulligan = random.sample(player.choice.cards, mull_count) player.choice.choose(*cards_to_mulligan) while True: heropower = game.current_player.hero.power # always play the hero power, just for kicks if heropower.is_usable(): if heropower.has_target(): heropower.use(target=random.choice(heropower.targets)) else: heropower.use() # iterate over our hand and play whatever is playable for card in game.current_player.hand: if card.is_playable(): target = None if card.choose_cards: card = random.choice(card.choose_cards) if card.has_target(): target = random.choice(card.targets) print("Playing %r on %r" % (card, target)) card.play(target=target) else: print("Not playing", card) # Randomly attack with whatever can attack for character in game.current_player.characters: if character.can_attack(): character.attack(random.choice(character.targets)) game.end_turn()
def initGame(self): self.init_envi() if self.is_basic: #create quick simple game p1 = 6 #priest p2 = 7 #rogue else: p1 = random.randint(1, 9) p2 = random.randint(1, 9) deck1 = random_draft(CardClass(p1)) deck2 = random_draft(CardClass(p2)) self.players[0] = Player("Player1", deck1, CardClass(p1).default_hero) self.players[1] = Player("Player2", deck2, CardClass(p2).default_hero) game = Game(players=self.players) game.start() #Skip mulligan for now for player in self.game.players: cards_to_mulligan = random.sample(player.choice.cards, 0) player.choice.choose(*cards_to_mulligan) return game
def _draft(hero, exclude): # random_draft() is fairly slow, this caches the drafts if (hero, exclude) not in _draftcache: _draftcache[(hero, exclude)] = random_draft(hero, exclude + BLACKLIST) return _draftcache[(hero, exclude)]
def _draft(hero, exclude): # random_draft() is fairly slow, this caches the drafts if (hero, exclude) not in _draftcache: _draftcache[(hero, exclude)] = random_draft(hero, exclude + BLACKLIST) return _draftcache[(hero, exclude)], hero
def _draft(card_class, exclude): # random_draft() is fairly slow, this caches the drafts if (card_class, exclude) not in _draftcache: _draftcache[(card_class, exclude)] = random_draft(card_class, exclude + BLACKLIST) return _draftcache[(card_class, exclude)], card_class.default_hero
def play_one_game(P1: Agent, P2: Agent, deck1=[], deck2=[], debugLog=True, HEROHPOPTION=30, P1MAXMANA=1, P2MAXMANA=1, P1HAND=3, P2HAND=3): """ エージェント同士で1回対戦する。 実験的に、ヒーローの体力、初期マナ数、初期ハンド枚数をコントロールできます。 play one game by P1 and P2 """ from fireplace.utils import random_draft from fireplace.player import Player import random exclude = [] # you may exclude some cards to construct a deck log.info("New game settings") if len(deck1) == 0: deck1 = random_draft(P1.myClass, exclude) #random deck wrt its class if len(deck2) == 0: deck2 = random_draft(P2.myClass, exclude) #random deck wrt its class player1 = Player(P1.name, deck1, P1.myClass.default_hero) player2 = Player(P2.name, deck2, P2.myClass.default_hero) player1.choiceStrategy = P1.choiceStrategy player2.choiceStrategy = P2.choiceStrategy game = Game(players=(player1, player2)) # Configurations player1._start_hand_size = P1HAND ## this line must be before 'start()' player2._start_hand_size = P2HAND ## player1.max_mana = int( P1MAXMANA) - 1 ## this line must be before 'start()' player2.max_mana = int(P2MAXMANA) - 1 game.start() player1.hero.max_health = int( HEROHPOPTION) ## this line must be below 'start()' player2.hero.max_health = int(HEROHPOPTION) ## #mulligan exchange # Any agent are allowed to give an algorithm to do mulligan exchange. for player in game.players: if player.name == P1.name: if P1.mulliganStrategy == None: mull_count = random.randint(0, len(player.choice.cards)) cards_to_mulligan = random.sample(player.choice.cards, mull_count) else: cards_to_mulligan = P1.mulliganStrategy( P1, player.choice.cards) elif player.name == P2.name: if P2.mulliganStrategy == None: mull_count = random.randint(0, len(player.choice.cards)) cards_to_mulligan = random.sample(player.choice.cards, mull_count) else: cards_to_mulligan = P2.mulliganStrategy( P2, player.choice.cards) player.choice.choose(*cards_to_mulligan) # includes begin_turn() #mulligan exchange end log.info("New game start") while True: #game main loop player = game.current_player start_time = time.time() if player.name == P1.name: #please make each Agent.func has arguments 'self, game, option, gameLog, debugLog' P1.func(P1, game, option=P1.option, gameLog=game.get_log(), debugLog=debugLog) elif player.name == P2.name: #please make each Agent.func has arguments 'self, game, option, gameLog, debugLog' P2.func(P2, game, option=P2.option, gameLog=game.get_log(), debugLog=debugLog) else: Original_random(game) #random player by fireplace #turn end procedure from here if player.choice != None: player.choice = None #somotimes it comes here if game.state != State.COMPLETE: try: game.end_turn() if debugLog: print(">>>>%s>>>>turn change %d[sec]>>>>%s" % (player, time.time() - start_time, player.opponent), end=' ') print("%d : %d" % (player1.hero.health + player1.hero.armor, player2.hero.health + player2.hero.armor)) if game.current_player.choice != None: postAction(game.current_player) except GameOver: #it rarely occurs gameover = 0 #ゲーム終了フラグが立っていたらゲーム終了処理を行う #if game was over if game.state == State.COMPLETE: if debugLog: print(">>>>>>>>>>game end >>>>>>>>" % (), end=' ') print("%d : %d" % (player1.hero.health, player2.hero.health)) if game.current_player.playstate == PlayState.WON: return game.current_player.name if game.current_player.playstate == PlayState.LOST: return game.current_player.opponent.name return 'DRAW' #Maybe impossible to come here.
from random import choice import fireplace.logging from fireplace import cards from fireplace.cards.heroes import * from fireplace.exceptions import GameOver from fireplace.entity import Entity from fireplace.game import Game from fireplace.player import Player from fireplace.utils import random_draft from hearthstone.enums import PlayState cards.db.initialize() fireplace.logging.log.setLevel(logging.WARN) deck1 = random_draft(SHAMAN) deck2 = random_draft(PALADIN) player1 = Player("Player1", deck1, SHAMAN) player2 = Player("Player2", deck2, PALADIN) game = Game(players=(player1, player2)) game.start() for player in game.players: if player.choice: player.choice.choose() begin_time = datetime.datetime.utcnow() N = 100 for i in range(N):
def try_montecarlo_tree_search(_game, _candidates=[], _trialPerTree=50, _numOfTree=10): from fireplace.deck import Deck copyGame = copy.deepcopy(_game) #フルコピーをとる。 myPlayer = copyGame.current_player #呼び出した「自分」 enemy = myPlayer.opponent #呼び出した「相手」 handNum = len(enemy.hand) #相手のハンドの枚数 totalScores = [] if len(_candidates) == 0: #事前にはじいているので、これは起こらない。 return pass if len(_candidates) == 1: #そもそもアクション候補が1つなら、そのアクションを行う。 return _candidates[0] pass for i in range(_numOfTree): #シミュレーション下準備(この下準備は運営側で提供すべき。具体的にはdeepcopyのときに組み込むべき。) #random_sampling exclude = [] # 除外すべきカードは、読み込みを停めている。 d = random_draft(enemy.hero.card_class, exclude) #カードクラスに従ったランダムなデッキ。第1引数はクラス名に変更。 enemy.hand = CardList() #敵のハンドをクリア enemy.deck = Deck() #敵のデッキをクリア for item in d: #敵のデッキを更新 enemy.card(item, zone=Zone.DECK) pass enemy.draw(count=handNum) #敵のハンドを更新 #ゲーム木展開 #あとでcandidatesをpopするからそのまま使うと_candidatesは空説 cand = getCandidates(copyGame, _includeTurnEnd=True) root = Node(copyGame, None, None, cand) #ファイル内クラス for k in range(_trialPerTree): current_node = root while len(current_node.untriedMoves) == 0 and len( current_node.childNodes) != 0: current_node = current_node.selectChild() if len(current_node.untriedMoves) != 0: expanding_action = current_node.choose_expanding_action() current_node = current_node.expandChild(expanding_action) result = current_node.simulate() current_node.backPropagate(result) visitScores = list( map(lambda node: myActionValue(node.move, node.visits), root.childNodes)) totalScores = addActionValues(totalScores, visitScores) print("totalScores") for item in totalScores: print("{action} -->{score}".format(action=item.action, score=item.score)) pass maxScore = max( list(map(lambda actionValue: actionValue.score, totalScores))) retAction = 0 for item in totalScores: if item.score == maxScore: retAction = item.action pass pass print(retAction) for item in _candidates: if item == retAction: retAction = item pass pass #time.sleep(5) return retAction pass
def try_montecarlo_tree_search(_game, _candidates=[], _trialPerTree=10, _numOfTree=10): from fireplace.deck import Deck copyGame = copy.deepcopy(_game) myPlayer = copyGame.current_player enemy = myPlayer.opponent handNum = len(enemy.hand) totalScores = [] if len(_candidates) == 0: return pass if len(_candidates) == 1: return _candidates[0] pass for i in range(_numOfTree): #シミュレーション下準備 #random_sampling d = random_draft(enemy.hero) enemy.hand = CardList() enemy.deck = Deck() for item in d: enemy.card(item, zone=Zone.DECK) pass enemy.draw(count=handNum) #ゲーム木展開 root = Node(copyGame, None, None, _candidates) print(_candidates) for k in range(_trialPerTree): currentNode = root print("----------") print("dig tree...") while len(currentNode.untriedMoves) == 0 and len( currentNode.childNodes) != 0: currentNode = currentNode.selectChild() print(currentNode.move) print("->") pass print("digged!!") print("expand child...") if len(currentNode.untriedMoves) != 0: #まだ探索してない枝がある print("expanding...") expandingAction = currentNode.choose_expanding_action() try: currentNode = currentNode.expandChild(expandingAction) except GameOver: #今gameoverに勝者の情報は入っていないので注意して newChild = Node(None, expandingAction, currentNode, []) if winner == "Maya": newChild.setScore(1) pass else: newChild.setScore(0) currentNode.childNodes.append(newChild) newChild.backPropagate() continue print("done") pass else: currentNode.backPropagate() continue pass print("is it ended?") result = simulate_random_game(currentNode.gameTree) currentNode.backPropagate(result) pass visitScores = list( map(lambda node: myActionValue(node.move, node.visits), root.childNodes)) totalScores = addActionValues(totalScores, visitScores) print("totalScores") for item in totalScores: print(item.action) print("-->{score}".format(score=item.score)) pass maxScore = max( list(map(lambda actionValue: actionValue.score, totalScores))) retAction = 0 for item in totalScores: if item.score == maxScore: retAction = item.action pass pass print(retAction) #time.sleep(5) return retAction pass
def play_one_game(P1: Agent, P2: Agent, deck1=[], deck2=[], HeroHPOption=30, debugLog=True): from fireplace.utils import random_draft from fireplace.player import Player import random #バグが確認されているものを当面除外する exclude = ['CFM_672', 'CFM_621', 'CFM_095', 'LOE_076', 'BT_490'] # 'LOE_076' : Sir Finley Mrrgglton # 'BT_490' : 魔力喰い、ターゲットの扱いにエラーがあるので除外。 if len(deck1) == 0: deck1 = random_draft(P1.myClass, exclude) #ランダムなデッキ if len(deck2) == 0: deck2 = random_draft(P2.myClass, exclude) #ランダムなデッキ player1 = Player(P1.name, deck1, P1.myClass.default_hero) player2 = Player(P2.name, deck2, P2.myClass.default_hero) game = Game(players=(player1, player2)) game.start() for player in game.players: #print("Can mulligan %r" % (player.choice.cards)) mull_count = random.randint(0, len(player.choice.cards)) cards_to_mulligan = random.sample(player.choice.cards, mull_count) player.choice.choose(*cards_to_mulligan) if HeroHPOption != 30: game.player1.hero.max_health = HeroHPOption game.player2.hero.max_health = HeroHPOption while True: from agent_Standard import StandardRandom, HumanInput, Original_random from agent_Maya import Maya_MCTS player = game.current_player #print("%r starts their turn."%player.name); if player.name == "Maya": Maya_MCTS(game) #マヤ氏の作品 elif player.name == "Standard": StandardRandom( game, debugLog=debugLog) #公式のランダムより、もう少しキチンとしたランダムプレーエージェント elif player.name == "Human": HumanInput(game) #人がプレーするときはこれ elif player.name == P1.name: P1.func(game, option=P1.option, debugLog=debugLog) #P1.funcには引数option, debugLogを作ってください elif player.name == P2.name: P2.func(game, option=P2.option, debugLog=debugLog) #P2.funcには引数option, debugLogを作ってください else: Original_random(game) #公式のランダム if player.choice != None: player.choice = None #論理的にはおこらないが、ときどきおこる if game.state != State.COMPLETE: try: game.end_turn() except GameOver: #まれにおこる gameover = 0 if game.state == State.COMPLETE: #ゲーム終了フラグが立っていたら if game.current_player.playstate == PlayState.WON: return game.current_player.name if game.current_player.playstate == PlayState.LOST: return game.current_player.opponent.name return 'DRAW'
def generate_decks(winner_hero=None, winner_deck=None): decks = {} for hero in heroes: decks[hero] = winner_deck if hero == winner_hero else random_draft(hero=hero) return decks