def init_cardlist(self):
all_cards = list(get_cards())
def card_to_sql(card):
result = '("{name}", {mana}, {rare}, {char_class})'.format(name=card.name, mana=card.mana,
rare=card.rarity, char_class=card.character_class)
return result
values_str = ', '.join(map(card_to_sql, all_cards))
command = 'insert into Card (name, mana, rare, class) values {0}'.format(values_str)
self.execute(command)
def get_card(self, player, owner):
from hearthbreaker.engine import card_lookup, get_cards
if self.name:
return card_lookup(self.name)
if self.source == CARD_SOURCE.COLLECTION:
card_list = get_cards()
elif self.source == CARD_SOURCE.MY_DECK:
card_list = filter(lambda c: not c.drawn, player.deck.cards)
elif self.source == CARD_SOURCE.MY_HAND:
card_list = player.hand
elif self.source == CARD_SOURCE.OPPONENT_DECK:
card_list = filter(lambda c: not c.drawn, player.opponent.deck.cards)
elif self.source == CARD_SOURCE.OPPONENT_HAND:
card_list = player.opponent.hand
elif self.source == CARD_SOURCE.LIST:
card_list = self.source_list
elif self.source == CARD_SOURCE.LAST_CARD:
return type(player.game.last_card)()
elif self.source == CARD_SOURCE.MINION:
return self.minion.get_targets(owner, owner)[0].card
else:
card_list = []
# TODO Throw an exception in any other case?
def check_condition(condition):
return lambda c: condition.evaluate(player, c)
for condition in self.conditions:
card_list = filter(check_condition(condition), card_list)
card_list = [card for card in card_list]
card_len = len(card_list)
if card_len == 1:
chosen_card = card_list[0]
elif card_len == 0:
return None
else:
chosen_card = player.game.random_choice(card_list)
if self.source == CARD_SOURCE.COLLECTION or self.source == CARD_SOURCE.LIST or self.make_copy:
return chosen_card
elif self.source == CARD_SOURCE.MY_DECK:
chosen_card.drawn = True
player.deck.left -= 1
return chosen_card
elif self.source == CARD_SOURCE.OPPONENT_DECK:
chosen_card.drawn = True
player.opponent.deck.left -= 1
return chosen_card
elif self.source == CARD_SOURCE.MY_HAND:
player.hand.remove(chosen_card)
return chosen_card
elif self.source == CARD_SOURCE.OPPONENT_HAND:
player.opponent.hand.remove(chosen_card)
return chosen_card
def get_card(self, player, owner):
from hearthbreaker.engine import card_lookup, get_cards
if self.name:
return card_lookup(self.name)
if self.source == CARD_SOURCE.COLLECTION:
card_list = get_cards()
elif self.source == CARD_SOURCE.MY_DECK:
card_list = filter(lambda c: not c.drawn, player.deck.cards)
elif self.source == CARD_SOURCE.MY_HAND:
card_list = player.hand
elif self.source == CARD_SOURCE.OPPONENT_DECK:
card_list = filter(lambda c: not c.drawn,
player.opponent.deck.cards)
elif self.source == CARD_SOURCE.OPPONENT_HAND:
card_list = player.opponent.hand
elif self.source == CARD_SOURCE.LIST:
card_list = self.source_list
elif self.source == CARD_SOURCE.LAST_CARD:
return type(player.game.last_card)()
elif self.source == CARD_SOURCE.LAST_DRAWN:
chosen_card = player.hand[-1]
player.hand.remove(chosen_card)
chosen_card.unattach()
return chosen_card
elif self.source == CARD_SOURCE.MINION:
card_list = [
minion.card
for minion in self.minion.get_targets(owner, owner)
]
elif self.source == CARD_SOURCE.MY_SECRETS:
card_list = [secret.card for secret in player.secrets]
elif self.source == CARD_SOURCE.ENEMY_SECRETS:
card_list = [secret for secret in player.opponent.secrets]
else:
card_list = []
# TODO Throw an exception in any other case?
def check_condition(condition):
return lambda c: condition.evaluate(player, c)
for condition in self.conditions:
card_list = filter(check_condition(condition), card_list)
card_list = [card for card in card_list]
card_len = len(card_list)
if card_len == 1:
chosen_card = card_list[0]
elif card_len == 0:
return None
else:
chosen_card = player.game.random_choice(card_list)
if self.source == CARD_SOURCE.COLLECTION or self.source == CARD_SOURCE.LIST or self.make_copy:
return chosen_card
elif self.source == CARD_SOURCE.MY_DECK:
chosen_card.drawn = True
player.deck.left -= 1
return chosen_card
elif self.source == CARD_SOURCE.OPPONENT_DECK:
chosen_card.drawn = True
player.opponent.deck.left -= 1
return chosen_card
elif self.source == CARD_SOURCE.MY_HAND:
player.hand.remove(chosen_card)
chosen_card.unattach()
return chosen_card
elif self.source == CARD_SOURCE.OPPONENT_HAND:
player.opponent.hand.remove(chosen_card)
chosen_card.unattach()
return chosen_card
elif self.source == CARD_SOURCE.MY_SECRETS:
if player is player.game.other_player:
chosen_card.deactivate(player)
player.secrets.remove(chosen_card)
return chosen_card
elif self.source == CARD_SOURCE.ENEMY_SECRETS:
if player.opponent is player.game.other_player:
chosen_card.deactivate(player.opponent)
player.opponent.secrets.remove(chosen_card)
return chosen_card
def get_list(self, target, player, owner):
from hearthbreaker.engine import get_cards
return get_cards()
from hearthbreaker.agents.basic_agents import RandomAgent
from hearthbreaker.cards.heroes import hero_for_class
from hearthbreaker.constants import CHARACTER_CLASS, CARD_RARITY
from hearthbreaker.engine import Game, Deck, card_lookup, get_cards
from hearthbreaker.cards import *
from hearthbreaker.cards.base import MinionCard
import random
import timeit
import json
from hearthsql import *
import pdb
import functools
import collections
all_cards = list(get_cards())
database = HearthDatabase('database.sqlite')
def get_random_class():
return random.randint(1, 9)
@functools.lru_cache(maxsize=None)
def cards_of_class(char_class):
def filter_class(card):
return card.character_class == char_class or card.character_class == CHARACTER_CLASS.ALL
def get_name(card):
return card.name
return list(map(get_name, filter(filter_class, all_cards)))
def deck_valid(deck):
counter = collections.defaultdict(lambda: 0)
for card in deck.deck:
card_ob = card_lookup(card)
def get_card(self, target, player, owner):
from hearthbreaker.engine import card_lookup, get_cards
if self.name:
chosen_card = card_lookup(self.name)
chosen_card.attach(chosen_card, player)
return chosen_card
if self.source == CARD_SOURCE.COLLECTION:
card_list = get_cards()
elif self.source == CARD_SOURCE.MY_DECK:
card_list = filter(lambda c: not c.drawn, player.deck.cards)
elif self.source == CARD_SOURCE.MY_HAND:
card_list = player.hand
elif self.source == CARD_SOURCE.OPPONENT_DECK:
card_list = filter(lambda c: not c.drawn, player.opponent.deck.cards)
elif self.source == CARD_SOURCE.OPPONENT_HAND:
card_list = player.opponent.hand
elif self.source == CARD_SOURCE.LIST:
card_list = self.source_list
elif self.source == CARD_SOURCE.LAST_CARD:
chosen_card = type(player.game.last_card)()
chosen_card.attach(chosen_card, player)
return chosen_card
elif self.source == CARD_SOURCE.LAST_DRAWN:
chosen_card = player.hand[-1]
player.hand.remove(chosen_card)
chosen_card.unattach()
return chosen_card
elif self.source == CARD_SOURCE.MINION:
chosen_card = self.minion.get_targets(owner, owner)[0].card
chosen_card.attach(chosen_card, player)
return chosen_card
elif self.source == CARD_SOURCE.MY_SECRETS:
card_list = [secret.card for secret in player.secrets]
elif self.source == CARD_SOURCE.ENEMY_SECRETS:
card_list = [secret for secret in player.opponent.secrets]
else:
card_list = []
# TODO Throw an exception in any other case?
def check_condition(condition):
return lambda c: condition.evaluate(target, c)
for condition in self.conditions:
card_list = filter(check_condition(condition), card_list)
card_list = [card for card in card_list]
card_len = len(card_list)
if card_len == 1:
chosen_card = card_list[0]
elif card_len == 0:
return None
else:
chosen_card = player.game.random_choice(card_list)
chosen_card.attach(chosen_card, player)
if self.source == CARD_SOURCE.COLLECTION or self.source == CARD_SOURCE.LIST \
or self.source == CARD_SOURCE.MINION or self.make_copy:
return chosen_card
elif self.source == CARD_SOURCE.MY_DECK:
chosen_card.drawn = True
player.deck.left -= 1
return chosen_card
elif self.source == CARD_SOURCE.OPPONENT_DECK:
chosen_card.drawn = True
player.opponent.deck.left -= 1
return chosen_card
elif self.source == CARD_SOURCE.MY_HAND:
player.hand.remove(chosen_card)
chosen_card.unattach()
return chosen_card
elif self.source == CARD_SOURCE.OPPONENT_HAND:
player.opponent.hand.remove(chosen_card)
chosen_card.unattach()
return chosen_card
elif self.source == CARD_SOURCE.MY_SECRETS:
if player is player.game.other_player:
chosen_card.deactivate(player)
player.secrets.remove(chosen_card)
return chosen_card
elif self.source == CARD_SOURCE.ENEMY_SECRETS:
if player.opponent is player.game.other_player:
chosen_card.deactivate(player.opponent)
player.opponent.secrets.remove(chosen_card)
return chosen_card
def get_list(self, target, player, owner):
from hearthbreaker.engine import get_cards
return get_cards()
