Beispiel #1
0
 def create_minion(self, player):
     return Minion(7,
                   7,
                   auras=[
                       Aura(MultiplySpellDamage(2), PlayerSelector()),
                       Aura(MultiplyHealAmount(2), PlayerSelector())
                   ])
Beispiel #2
0
        def create_minion(self, player):
            create_dict = {
                'attack': card_def['attack'],
                'health': card_def['health']
            }
            if "impl" in card_def:
                impl = card_def['impl']
                if 'effects' in impl:
                    create_dict['effects'] = [
                        Effect.from_json(**effect)
                        for effect in impl['effects']
                    ]

                if 'auras' in impl:
                    create_dict['auras'] = [
                        Aura.from_json(**aura) for aura in impl['auras']
                    ]

                if 'buffs' in impl:
                    create_dict['buffs'] = [
                        Buff.from_json(**buff) for buff in impl['buffs']
                    ]

            if 'enrage' in card_def:
                create_dict['enrage'] = [
                    Aura.from_json(**enrage) for enrage in card_def['enrage']
                ]

            if 'deathrattle' in card_def:
                create_dict['deathrattle'] = [
                    Deathrattle.from_json(**deathrattle)
                    for deathrattle in card_def['deathrattle']
                ]

            return Minion(**create_dict)
Beispiel #3
0
 def create_minion(self, player):
     return Minion(7,
                   7,
                   auras=[
                       Aura(SetTo(PLAYER_STATUS.SPELL_DAMAGE_MULTIPLIER, 2),
                            PlayerSelector()),
                       Aura(SetTo(PLAYER_STATUS.HEAL_MULTIPLIER, 2),
                            PlayerSelector())
                   ])
Beispiel #4
0
 def create_minion(self, player):
     return Minion(9,
                   7,
                   auras=[
                       Aura(ChangeHealth(2),
                            MinionSelector(IsType(MINION_TYPE.DEMON))),
                       Aura(ChangeAttack(2),
                            MinionSelector(IsType(MINION_TYPE.DEMON))),
                       Aura(Immune(), HeroSelector())
                   ])
Beispiel #5
0
 def create_minion(self, player):
     return Minion(9,
                   7,
                   auras=[
                       Aura(Add(CHARACTER_STATUS.ATTACK, 2),
                            MinionSelector(IsType(MINION_TYPE.DEMON))),
                       Aura(Add(CHARACTER_STATUS.HEALTH, 2),
                            MinionSelector(IsType(MINION_TYPE.DEMON))),
                       Aura(SetTrue(CHARACTER_STATUS.IMMUNE),
                            HeroSelector())
                   ])
Beispiel #6
0
 def __init__(self):
     super().__init__("Houndmaster",
                      4,
                      CHARACTER_CLASS.HUNTER,
                      CARD_RARITY.FREE,
                      MINION_TYPE.NONE,
                      battlecry=Battlecry(
                          Give([
                              Aura(ChangeHealth(2), SelfSelector()),
                              Aura(ChangeAttack(2), SelfSelector()),
                              Aura(Taunt(), SelfSelector())
                          ]),
                          MinionSelector(MinionIsType(MINION_TYPE.BEAST),
                                         picker=UserPicker())))
Beispiel #7
0
 def __init__(self):
     super().__init__(
         "Anodized Robo Cub",
         2,
         CHARACTER_CLASS.DRUID,
         CARD_RARITY.COMMON,
         minion_type=MINION_TYPE.MECH,
         choices=[
             Choice(AttackMode(),
                    Give([Aura(ChangeAttack(1), SelfSelector())]),
                    SelfSelector()),
             Choice(TankMode(),
                    Give([Aura(ChangeHealth(1), SelfSelector())]),
                    SelfSelector())
         ])
Beispiel #8
0
 def create_minion(self, player):
     return Minion(2,
                   5,
                   auras=[
                       Aura(SetTrue(CHARACTER_STATUS.NO_SPELL_TARGET),
                            MinionSelector(Adjacent()))
                   ])
Beispiel #9
0
 def create_minion(self, player):
     return Minion(0,
                   4,
                   auras=[
                       Aura(Subtract(CARD_STATUS.MANA, 2, minimum=1),
                            CardSelector(condition=IsMinion()))
                   ])
        def create_minion(self, player):
            create_dict = {
                'attack': card_def['attack'],
                'health': card_def['health']
            }
            if 'effects' in card_def:
                create_dict['effects'] = [
                    Effect.from_json(player.game, **effect)
                    for effect in card_def['effects']
                ]

            if 'auras' in card_def:
                create_dict['auras'] = [
                    Aura.from_json(**aura) for aura in card_def['auras']
                ]

            if 'enrage' in card_def:
                create_dict['enrage'] = [
                    Action.from_json(**action) for action in card_def['enrage']
                ]

            if 'deathrattle' in card_def:
                create_dict['deathrattle'] = Deathrattle.from_json(
                    **card_def['deathrattle'])

            return Minion(**create_dict)
Beispiel #11
0
 def create_minion(self, player):
     return Minion(0,
                   3,
                   auras=[
                       Aura(Add(CHARACTER_STATUS.ATTACK, 2),
                            MinionSelector(Adjacent()))
                   ])
Beispiel #12
0
 def create_minion(self, player):
     return Minion(3,
                   2,
                   auras=[
                       Aura(Subtract(CARD_STATUS.MANA, 1),
                            CardSelector(condition=IsSpell()))
                   ])
        def __init__(self):
            init_dict = {
                'name': card_def['name'],
                'mana': card_def['mana'],
                'rarity': CARD_RARITY.from_str(card_def['rarity'])
            }
            if 'character_class' in card_def:
                init_dict['character_class'] = CHARACTER_CLASS.from_str(card_def['character_class'])

            if 'minion_type' in card_def:
                init_dict['minion_type'] = MINION_TYPE.from_str(card_def['minion_type'])

            if 'battlecry' in card_def:
                init_dict['battlecry'] = tuple(Battlecry.from_json(**battlecry) for battlecry in card_def['battlecry'])

            if 'choices' in card_def:
                init_dict['choices'] = [Choice.from_json(**choice) for choice in card_def['choices']]

            if 'combo' in card_def:
                init_dict['combo'] = Battlecry.from_json(**card_def['combo'])

            if 'overload' in card_def:
                init_dict['overload'] = card_def['overload']

            if 'buffs' in card_def:
                init_dict['buffs'] = [Buff.from_json(**buff) for buff in card_def['buffs']]
            if 'auras' in card_def:
                init_dict['auras'] = [Aura.from_json(**aura) for aura in card_def['auras']]
            if 'effects' in card_def:
                init_dict['effects'] = [Effect.from_json(**effect) for effect in card_def['effects']]

            MinionCard.__init__(self, **init_dict)
Beispiel #14
0
        def __init_weapon__(self):
            init_dict = {
                'name': card_def['name'],
                'mana': card_def['mana'],
                'rarity': CARD_RARITY.from_str(card_def['rarity'])
            }
            if 'character_class' in card_def:
                init_dict['character_class'] = CHARACTER_CLASS.from_str(
                    card_def['character_class'])

            if 'battlecry' in card_def:
                init_dict['battlecry'] = Battlecry.from_json(
                    **card_def['battlecry'])

            if 'combo' in card_def:
                init_dict['combo'] = Battlecry.from_json(**card_def['combo'])

            if 'overload' in card_def:
                init_dict['overload'] = card_def['overload']

            if 'buffs' in card_def:
                init_dict['buffs'] = [
                    Buff.from_json(**buff) for buff in card_def['buffs']
                ]
            if 'auras' in card_def:
                init_dict['auras'] = [
                    Aura.from_json(**aura) for aura in card_def['auras']
                ]
            if 'effects' in card_def:
                init_dict['effects'] = [
                    Effect.from_json(**effect)
                    for effect in card_def['effects']
                ]

            WeaponCard.__init__(self, **init_dict)
Beispiel #15
0
 def create_minion(self, player):
     return Minion(1,
                   1,
                   auras=[
                       Aura(Add(CHARACTER_STATUS.ATTACK, 1),
                            MinionSelector(IsType(MINION_TYPE.BEAST)))
                   ])
Beispiel #16
0
 def create_minion(self, player):
     return Minion(3,
                   5,
                   auras=[
                       Aura(SetTrue(PLAYER_STATUS.HEAL_AS_DAMAGE),
                            PlayerSelector())
                   ])
        def __init_weapon__(self):
            init_dict = {
                'name': card_def['name'],
                'mana': card_def['mana'],
                'rarity': CARD_RARITY.from_str(card_def['rarity'])
            }
            if 'character_class' in card_def:
                init_dict['character_class'] = CHARACTER_CLASS.from_str(card_def['character_class'])

            if 'battlecry' in card_def:
                init_dict['battlecry'] = Battlecry.from_json(**card_def['battlecry'])

            if 'combo' in card_def:
                init_dict['combo'] = Battlecry.from_json(**card_def['combo'])

            if 'overload' in card_def:
                init_dict['overload'] = card_def['overload']

            if 'buffs' in card_def:
                init_dict['buffs'] = [Buff.from_json(**buff) for buff in card_def['buffs']]
            if 'auras' in card_def:
                init_dict['auras'] = [Aura.from_json(**aura) for aura in card_def['auras']]
            if 'effects' in card_def:
                init_dict['effects'] = [Effect.from_json(**effect) for effect in card_def['effects']]

            WeaponCard.__init__(self, **init_dict)
Beispiel #18
0
 def create_minion(self, player):
     return Minion(1,
                   1,
                   auras=[
                       Aura(ChangeAttack(1),
                            MinionSelector(IsType(MINION_TYPE.BEAST)))
                   ])
Beispiel #19
0
 def create_minion(self, player):
     return Minion(0,
                   4,
                   auras=[
                       Aura(ManaChange(-2, 1, minimum=1),
                            CardSelector(condition=IsMinion()))
                   ])
Beispiel #20
0
        def create_weapon(self, player):
            create_dict = {
                'attack_power': card_def['attack'],
                'durability': card_def['durability']
            }
            if "impl" in card_def:
                impl = card_def['impl']
                if 'effects' in impl:
                    create_dict['effects'] = [
                        Effect.from_json(**effect)
                        for effect in impl['effects']
                    ]

                if 'auras' in impl:
                    create_dict['auras'] = [
                        Aura.from_json(**aura) for aura in impl['auras']
                    ]

                if 'buffs' in impl:
                    create_dict['buffs'] = [
                        Buff.from_json(**buff) for buff in impl['buffs']
                    ]

            if 'deathrattle' in card_def:
                create_dict['deathrattle'] = Deathrattle.from_json(
                    **card_def['deathrattle'])

            return Weapon(**create_dict)
Beispiel #21
0
 def __init__(self):
     super().__init__("Cenarius",
                      9,
                      CHARACTER_CLASS.DRUID,
                      CARD_RARITY.LEGENDARY,
                      choices=[
                          Choice(
                              IncreaseStats(),
                              Give([
                                  Aura(ChangeAttack(2), SelfSelector()),
                                  Aura(ChangeHealth(2), SelfSelector()),
                                  Aura(Taunt(), SelfSelector())
                              ]), MinionSelector()),
                          Choice(SummonTreants(), Summon(Treant(), 2),
                                 PlayerSelector())
                      ])
Beispiel #22
0
 def create_minion(self, player):
     return Minion(2,
                   3,
                   auras=[
                       Aura(SetTrue(PLAYER_STATUS.POWER_TARGETS_MINIONS),
                            HeroSelector())
                   ])
Beispiel #23
0
    def use(self, player, game):
        super().use(player, game)

        self.target.change_attack(2)
        self.target.increase_health(4)
        self.target.add_aura(
            Aura(Add(PLAYER_STATUS.SPELL_DAMAGE, 1), PlayerSelector()))
Beispiel #24
0
 def __from_json__(self, auras):
     self.auras = []
     for aura in auras:
         if "until" in aura:
             self.auras.append(AuraUntil.from_json(**aura))
         else:
             self.auras.append(Aura.from_json(**aura))
     return self
Beispiel #25
0
 def create_minion(self, player):
     return Minion(2,
                   5,
                   charge=True,
                   auras=[
                       Aura(Charge(),
                            MinionSelector(MinionIsType(MINION_TYPE.BEAST)))
                   ])
Beispiel #26
0
 def use(self, player, game):
     super().use(player, game)
     for minion in player.minions:
         if not minion.stealth:
             aura = Aura(Stealth(), SelfSelector())
             minion.add_aura(aura)
             minion.add_effect(
                 Effect(TurnStarted(), Take(aura), SelfSelector()))
Beispiel #27
0
 def __from_json__(self, auras):
     self.auras = []
     for aura in auras:
         if "until" in aura:
             self.auras.append(AuraUntil.from_json(**aura))
         else:
             self.auras.append(Aura.from_json(**aura))
     return self
Beispiel #28
0
 def create_minion(self, player):
     return Minion(2,
                   5,
                   charge=True,
                   auras=[
                       Aura(SetTrue(CHARACTER_STATUS.CHARGE),
                            MinionSelector(IsType(MINION_TYPE.BEAST)))
                   ])
Beispiel #29
0
    def __init__(self):

        super().__init__("Ancient of War",
                         7,
                         CHARACTER_CLASS.DRUID,
                         CARD_RARITY.EPIC,
                         choices=[
                             Choice(
                                 Health(),
                                 Give([
                                     Aura(ChangeHealth(5), SelfSelector()),
                                     Aura(Taunt(), SelfSelector())
                                 ]), SelfSelector()),
                             Choice(
                                 Attack(),
                                 Give([Aura(ChangeAttack(5), SelfSelector())]),
                                 SelfSelector()),
                         ])
Beispiel #30
0
    def __init__(self, auras):

        if isinstance(auras, Action):
            from hearthbreaker.tags.selector import SelfSelector
            self.auras = [Aura(auras, SelfSelector())]
        elif isinstance(auras, list):
            self.auras = auras
        else:
            self.auras = [auras]
Beispiel #31
0
    def __from_json__(self, auras=None, effects=None):
        if effects:  # To allow for give to work with effects as well, we check at load time
            effects = [Effect.from_json(**effect) for effect in effects]
            return GiveEffect(effects)

        self.auras = []
        for aura in auras:
            if "until" in aura:
                self.auras.append(AuraUntil.from_json(**aura))
            else:
                self.auras.append(Aura.from_json(**aura))
        return self
Beispiel #32
0
    def __from_json__(self, auras=None, effects=None):
        if effects:  # To allow for give to work with effects as well, we check at load time
            effects = [Effect.from_json(**effect) for effect in effects]
            return GiveEffect(effects)

        self.auras = []
        for aura in auras:
            if "until" in aura:
                self.auras.append(AuraUntil.from_json(**aura))
            else:
                self.auras.append(Aura.from_json(**aura))
        return self
        def create_minion(self, player):
            create_dict = {
                'attack': card_def['attack'],
                'health': card_def['health']
            }
            if "impl" in card_def:
                impl = card_def['impl']
                if 'effects' in impl:
                    create_dict['effects'] = [Effect.from_json(**effect) for effect in impl['effects']]

                if 'auras' in impl:
                    create_dict['auras'] = [Aura.from_json(**aura) for aura in impl['auras']]

                if 'buffs' in impl:
                    create_dict['buffs'] = [Buff.from_json(**buff) for buff in impl['buffs']]

            if 'enrage' in card_def:
                create_dict['enrage'] = [Aura.from_json(**enrage) for enrage in card_def['enrage']]

            if 'deathrattle' in card_def:
                create_dict['deathrattle'] = [Deathrattle.from_json(**deathrattle)
                                              for deathrattle in card_def['deathrattle']]

            return Minion(**create_dict)
Beispiel #34
0
 def __from_json__(minion, effects=None, auras=None, buffs=None, **kwargs):
     if effects:
         minion.effects = [Effect.from_json(**effect) for effect in effects]
     else:
         minion.effects = []
     if auras:
         minion.auras = [AuraUntil.from_json(**aura) if 'until' in aura else Aura.from_json(**aura)
                         for aura in auras]
     else:
         minion.auras = []
     if buffs:
         minion.buffs = [BuffUntil.from_json(**buff) if 'until' in buff else Buff.from_json(**buff)
                         for buff in buffs]
     else:
         minion.buffs = []
Beispiel #35
0
        def __init__(self):
            init_dict = {
                'name': card_def['name'],
                'mana': card_def['mana'],
                'rarity': CARD_RARITY.from_str(card_def['rarity'])
            }
            if 'character_class' in card_def:
                init_dict['character_class'] = CHARACTER_CLASS.from_str(
                    card_def['character_class'])

            if 'minion_type' in card_def:
                init_dict['minion_type'] = MINION_TYPE.from_str(
                    card_def['minion_type'])

            if 'battlecry' in card_def:
                init_dict['battlecry'] = tuple(
                    Battlecry.from_json(**battlecry)
                    for battlecry in card_def['battlecry'])

            if 'choices' in card_def:
                init_dict['choices'] = [
                    Choice.from_json(**choice)
                    for choice in card_def['choices']
                ]

            if 'combo' in card_def:
                init_dict['combo'] = Battlecry.from_json(**card_def['combo'])

            if 'overload' in card_def:
                init_dict['overload'] = card_def['overload']

            if 'buffs' in card_def:
                init_dict['buffs'] = [
                    Buff.from_json(**buff) for buff in card_def['buffs']
                ]
            if 'auras' in card_def:
                init_dict['auras'] = [
                    Aura.from_json(**aura) for aura in card_def['auras']
                ]
            if 'effects' in card_def:
                init_dict['effects'] = [
                    Effect.from_json(**effect)
                    for effect in card_def['effects']
                ]

            MinionCard.__init__(self, **init_dict)
Beispiel #36
0
 def __from_json__(md, player, game):
     from hearthbreaker.engine import card_lookup
     minion = Minion(md['attack'], md['max_health'])
     GameObject.__from_json__(minion, **md)
     minion.health = md['max_health'] - md['damage']
     minion.exhausted = md['exhausted']
     minion.attacks_performed = not md['attacks_performed']
     minion.born = md['sequence_id']
     if 'enrage' in md:
         minion.enrage = [Aura.from_json(**enrage) for enrage in md['enrage']]
     minion.deathrattle = []
     for rattle in md['deathrattles']:
         minion.deathrattle.append(Deathrattle.from_json(**rattle))
     minion.card = card_lookup(md["name"])
     minion.game = game
     minion.player = player
     return minion
        def create_minion(self, player):
            create_dict = {
                'attack': card_def['attack'],
                'health': card_def['health']
            }
            if 'effects' in card_def:
                create_dict['effects'] = [Effect.from_json(player.game, **effect) for effect in card_def['effects']]

            if 'auras' in card_def:
                create_dict['auras'] = [Aura.from_json(**aura) for aura in card_def['auras']]

            if 'enrage' in card_def:
                create_dict['enrage'] = [Action.from_json(**action) for action in card_def['enrage']]

            if 'deathrattle' in card_def:
                create_dict['deathrattle'] = Deathrattle.from_json(**card_def['deathrattle'])

            return Minion(**create_dict)
        def create_weapon(self, player):
            create_dict = {
                'attack_power': card_def['attack'],
                'durability': card_def['durability']
            }
            if 'effects' in card_def:
                create_dict['effects'] = [Effect.from_json(**effect) for effect in card_def['effects']]

            if 'auras' in card_def:
                create_dict['auras'] = [Aura.from_json(**aura) for aura in card_def['auras']]

            if 'buffs' in card_def:
                create_dict['buffs'] = [Buff.from_json(**buff) for buff in card_def['buffs']]

            if 'deathrattle' in card_def:
                create_dict['deathrattle'] = Deathrattle.from_json(**card_def['deathrattle'])

            return Weapon(**create_dict)
Beispiel #39
0
 def __from_json__(md, player, game):
     from hearthbreaker.engine import card_lookup
     minion = Minion(md['attack'], md['max_health'])
     GameObject.__from_json__(minion, **md)
     minion.health = md['max_health'] - md['damage']
     minion.exhausted = md['exhausted']
     minion.attacks_performed = not md['attacks_performed']
     minion.born = md['sequence_id']
     if 'enrage' in md:
         minion.enrage = [
             Aura.from_json(**enrage) for enrage in md['enrage']
         ]
     minion.deathrattle = []
     for rattle in md['deathrattles']:
         minion.deathrattle.append(Deathrattle.from_json(**rattle))
     minion.card = card_lookup(md["name"])
     minion.game = game
     minion.player = player
     return minion
        def create_minion(self, player):
            create_dict = {
                'attack': card_def['attack'],
                'health': card_def['health']
            }
            if 'effects' in card_def:
                create_dict['effects'] = [Effect.from_json(**effect) for effect in card_def['effects']]

            if 'auras' in card_def:
                create_dict['auras'] = [Aura.from_json(**aura) for aura in card_def['auras']]

            if 'buffs' in card_def:
                create_dict['buffs'] = [Buff.from_json(**buff) for buff in card_def['buffs']]

            if 'enrage' in card_def:
                create_dict['enrage'] = Enrage.from_json(**card_def['enrage'])

            if 'deathrattle' in card_def:
                create_dict['deathrattle'] = Deathrattle.from_json(**card_def['deathrattle'])

            return Minion(**create_dict)
Beispiel #41
0
 def __from_json__(self, aura):
     self.aura = Aura.from_json(**aura)
     return self