def __from_json__(cls, pd, game, agent):
deck = Deck.__from__to_json__(pd["deck"],
hero_from_name(pd["hero"]["name"]))
player = Player("whatever", deck, agent, game)
hero = Hero.__from_json__(pd["hero"], player)
player.hero = hero
hero.player = player
if hero.weapon:
hero.weapon.player = player
player.mana = pd["mana"]
player.max_mana = pd["max_mana"]
player.name = pd['name']
player.hand = []
for card_def in pd['hand']:
card = card_lookup(card_def['name'])
card.__from_json__(card, **card_def)
card.attach(card, player)
player.hand.append(card)
player.graveyard = set()
for card_name in pd["graveyard"]:
player.graveyard.add(card_name)
player.secrets = []
for secret_name in pd["secrets"]:
secret = card_lookup(secret_name)
secret.player = player
player.secrets.append(secret)
i = 0
player.minions = []
for md in pd["minions"]:
minion = Minion.__from_json__(md, player, game)
minion.index = i
player.minions.append(minion)
i += 1
return player
def __from_json__(cls, pd, game, agent):
deck = Deck.__from__to_json__(pd["deck"],
hearthbreaker.constants.CHARACTER_CLASS.from_str(pd["hero"]["character"]))
player = Player("whatever", deck, agent, game)
hero = Hero.__from_json__(pd["hero"], player)
player.hero = hero
hero.player = player
if hero.weapon:
hero.weapon.player = player
player.mana = pd["mana"]
player.max_mana = pd["max_mana"]
player.name = pd['name']
player.hand = [card_lookup(name) for name in pd["hand"]]
player.graveyard = set()
for card_name in pd["graveyard"]:
player.graveyard.add(card_name)
player.secrets = []
for secret_name in pd["secrets"]:
secret = card_lookup(secret_name)
secret.player = player
player.secrets.append(secret)
i = 0
player.minions = []
for md in pd["minions"]:
minion = Minion.__from_json__(md, player, game)
minion.index = i
player.minions.append(minion)
i += 1
return player
def __init__(self, name, deck, agent, game):
super().__init__()
self.game = game
self.hero = Hero(deck.character_class, self)
self.name = name
self.mana = 0
self.max_mana = 0
self.deck = deck
self.spell_damage = 0
self.minions = []
self.graveyard = set()
self.hand = []
self.object_auras = []
self.player_auras = []
self.fatigue = 0
self.agent = agent
self.effects = []
self.secrets = []
self.spell_multiplier = 1
self.heal_multiplier = 1
self.heal_does_damage = 0
self.double_deathrattle = 0
self.mana_filters = []
self.overload = 0
self.opponent = None
self.cards_played = 0
self.dead_this_turn = []
def __from_json__(cls, pd, game, agent):
deck = Deck.__from__to_json__(pd["deck"], hero_from_name(pd["hero"]["name"]))
player = Player("whatever", deck, agent, game)
hero = Hero.__from_json__(pd["hero"], player)
player.hero = hero
hero.player = player
if pd["weapon"]:
player.weapon = Weapon.__from_json__(pd["weapon"], player)
player.weapon.player = player
player.mana = pd["mana"]
player.max_mana = pd["max_mana"]
player.upcoming_overload = pd["upcoming_overload"]
player.current_overload = pd["current_overload"]
player.name = pd["name"]
player.hand = []
for card_def in pd["hand"]:
card = card_lookup(card_def["name"])
card.__from_json__(card, **card_def)
card.attach(card, player)
player.hand.append(card)
player.graveyard = pd["graveyard"]
player.secrets = []
for secret_name in pd["secrets"]:
secret = card_lookup(secret_name)
secret.player = player
player.secrets.append(secret)
i = 0
player.minions = []
for md in pd["minions"]:
minion = Minion.__from_json__(md, player, game)
minion.index = i
player.minions.append(minion)
i += 1
return player
def create_hero(self, player):
return Hero(self.health, self.character_class, self.power(), player)
def create_hero(self, player):
h = Hero(self.health, self.character_class, self.power(), player)
# h.card = self
h.name = self.name
return h
class Player(Bindable):
def __init__(self, name, deck, agent, game):
super().__init__()
self.game = game
self.hero = Hero(deck.character_class, self)
self.name = name
self.mana = 0
self.max_mana = 0
self.deck = deck
self.spell_damage = 0
self.minions = []
self.graveyard = set()
self.hand = []
self.object_auras = []
self.player_auras = []
self.fatigue = 0
self.agent = agent
self.effects = []
self.secrets = []
self.spell_multiplier = 1
self.heal_multiplier = 1
self.heal_does_damage = 0
self.double_deathrattle = 0
self.mana_filters = []
self.overload = 0
self.opponent = None
self.cards_played = 0
self.dead_this_turn = []
def __str__(self): # pragma: no cover
return "Player: " + self.name
def copy(self, new_game):
copied_player = Player(self.name, self.deck.copy(), self.agent, new_game)
copied_player.hero = self.hero.copy(copied_player, new_game)
copied_player.graveyard = copy.copy(self.graveyard)
copied_player.minions = [minion.copy(copied_player, new_game) for minion in self.minions]
copied_player.hand = [type(card)() for card in self.hand]
copied_player.spell_damage = self.spell_damage
copied_player.mana = self.mana
copied_player.max_mana = self.max_mana
copied_player.overload = self.overload
copied_player.dead_this_turn = copy.copy(self.dead_this_turn)
for effect in self.effects:
effect = copy.copy(effect)
copied_player.add_effect(effect)
copied_player.secrets = []
for secret in self.secrets:
new_secret = type(secret)()
new_secret.player = copied_player
copied_player.secrets.append(new_secret)
for aura in filter(lambda a: isinstance(a, AuraUntil), self.player_auras):
aura = copy.deepcopy(aura)
aura.owner = copied_player.hero
copied_player.add_aura(aura)
for aura in filter(lambda a: isinstance(a, AuraUntil), self.object_auras):
aura = copy.deepcopy(aura)
aura.owner = copied_player.hero
copied_player.add_aura(aura)
copied_player.effect_count = dict()
return copied_player
def draw(self):
if self.can_draw():
card = self.deck.draw(self.game)
self.trigger("card_drawn", card)
if len(self.hand) < 10:
self.hand.append(card)
else:
self.trigger("card_destroyed", card)
else:
self.fatigue += 1
self.hero.trigger("fatigue_damage", self.fatigue)
self.hero.damage(self.fatigue, None)
self.hero.activate_delayed()
def can_draw(self):
return self.deck.can_draw()
def effective_spell_damage(self, base_damage):
return (base_damage + self.spell_damage) * self.spell_multiplier
def effective_heal_power(self, base_heal):
if self.heal_does_damage:
return -(base_heal + self.spell_damage) * self.spell_multiplier
else:
return base_heal * self.heal_multiplier
def put_back(self, card):
self.hand.remove(card)
self.deck.put_back(card)
self.trigger("card_put_back", card)
def discard(self):
if len(self.hand) > 0:
targets = self.hand
target = self.game.random_choice(targets)
self.hand.remove(target)
self.trigger("card_discarded", target)
def add_effect(self, effect):
def remove_effect(*args):
effect.unapply()
self.effects.remove(effect)
effect.event.unbind(self.hero, remove_effect)
self.effects.append(effect)
effect.set_owner(self.hero)
effect.apply()
effect.event.bind(self.hero, remove_effect)
def add_aura(self, aura):
if isinstance(aura.selector, hearthbreaker.tags.selector.MinionSelector):
self.object_auras.append(aura)
else:
self.player_auras.append(aura)
if not aura.owner:
aura.set_owner(self.hero)
aura.apply()
def remove_aura(self, aura):
if isinstance(aura.selector, hearthbreaker.tags.selector.MinionSelector):
self.object_auras = [au for au in filter(lambda a: not a.eq(aura), self.object_auras)]
else:
self.player_auras = [au for au in filter(lambda a: not a.eq(aura), self.player_auras)]
aura.unapply()
def choose_target(self, targets):
return self.agent.choose_target(targets)
def is_valid(self):
return True
def __to_json__(self):
auras = copy.copy(self.player_auras)
auras.extend(self.object_auras)
return {
'hero': self.hero,
'deck': self.deck,
'graveyard': [card for card in self.graveyard],
'hand': [card.name for card in self.hand],
'secrets': [secret.name for secret in self.secrets],
'effects': self.effects,
'auras': [aura for aura in filter(lambda a: isinstance(a, AuraUntil), auras)],
'minions': self.minions,
'mana': self.mana,
'max_mana': self.max_mana,
'name': self.name,
}
@classmethod
def __from_json__(cls, pd, game, agent):
deck = Deck.__from__to_json__(pd["deck"],
hearthbreaker.constants.CHARACTER_CLASS.from_str(pd["hero"]["character"]))
player = Player("whatever", deck, agent, game)
hero = Hero.__from_json__(pd["hero"], player)
player.hero = hero
hero.player = player
if hero.weapon:
hero.weapon.player = player
player.mana = pd["mana"]
player.max_mana = pd["max_mana"]
player.name = pd['name']
player.hand = [card_lookup(name) for name in pd["hand"]]
player.graveyard = set()
for card_name in pd["graveyard"]:
player.graveyard.add(card_name)
player.secrets = []
for secret_name in pd["secrets"]:
secret = card_lookup(secret_name)
secret.player = player
player.secrets.append(secret)
i = 0
player.minions = []
for md in pd["minions"]:
minion = Minion.__from_json__(md, player, game)
minion.index = i
player.minions.append(minion)
i += 1
return player
