Python game_objects.Minion类代码示例

    def create_minion(self, player):
        def did_damage(amount, target):
            target.freeze()

        minion = Minion(3, 6)
        minion.bind("did_damage", did_damage)
        return minion

    def create_minion(self, player):
        minion = Minion(2, 2)
        for combo in range(0, player.cards_played):
            minion.increase_health(2)
            minion.change_attack(2)

        return minion

    def create_minion(self, player):

        class Moonfire(Card):
            def __init__(self):
                super().__init__("Moonfire", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.SPECIAL)

        class Dispel(Card):
            def __init__(self):
                super().__init__("Dispel", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.SPECIAL)

        moonfire = Moonfire()
        dispell = Dispel()
        option = player.agent.choose_option(moonfire, dispell)
        minion = Minion(2, 4)
        if option == moonfire:
            action = deal_two_damage
            targets = hearthbreaker.targeting.find_battlecry_target(player.game, lambda m: not m.stealth)
        else:
            action = silence
            targets = hearthbreaker.targeting.find_minion_battlecry_target(player.game, lambda m: not m.stealth)

        if targets is not None:
            self.target = player.agent.choose_target(targets)

        # here we have to set these things up to mimic a battlecry, although it is not a battlecry
        minion.card = self
        action(minion)

        return minion

            def create_minion(self, player):
                def add_effect(m, index):
                    m.add_aura(1, 0, [player], lambda mini: mini is not minion)

                minion = Minion(2, 4, MINION_TYPE.BEAST)
                minion.bind("added_to_board", add_effect)
                return minion

    def create_minion(self, player):
        def draw_card():
            player.draw()

        minion = Minion(1, 3)
        player.game.bind("minion_healed", draw_card)
        minion.bind_once("silenced", lambda: player.game.unbind("minion_healed", draw_card))
        return minion

    def create_minion(self, player):
        def draw_card():
            player.draw()

        minion = Minion(0, 3)
        player.bind("turn_ended", draw_card)
        minion.bind_once("silenced", lambda: player.unbind("turn_ended", draw_card))
        return minion

    def create_minion(self, player):
        def gain_one_attack(m):
            minion.change_attack(1)

        minion = Minion(2, 4)
        player.game.bind("minion_damaged", gain_one_attack)
        minion.bind_once("silenced", lambda: player.game.unbind("minion_damaged", gain_one_attack))
        return minion

    def create_minion(self, player):
        class Filter:
            def __init__(self):
                self.amount = 2
                self.filter = lambda c: isinstance(c, MinionCard)
                self.min = 1

        mana_filter = Filter()
        minion = Minion(0, 4)
        minion.bind_once("silenced", lambda: player.mana_filters.remove(mana_filter))
        player.mana_filters.append(mana_filter)
        return minion

    def create_minion(self, player):
        def silence():
            player.heal_does_damage = False

            # If another Auchenai Soulpriest is alive and not silenced, keep
            # heal_does_damage as True
            for m in player.minions:
                if m.card.name == "Auchenai Soulpriest" and not m.silenced and m is not minion:
                    player.heal_does_damage = True

        minion = Minion(3, 5)
        minion.bind_once("silenced", silence)
        player.heal_does_damage = True
        return minion

    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 __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 create_minion(self, player):

        # These are basically placeholders to give the agent something to
        # choose
        class Health(Card):
            def __init__(self):
                super().__init__("+5 Health and Taunt", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.SPECIAL)

        class Attack(Card):
            def __init__(self):
                super().__init__("+5 Attack", 0, CHARACTER_CLASS.DRUID, CARD_RARITY.SPECIAL)

        health = Health()
        attack = Attack()
        option = player.agent.choose_option(health, attack)
        minion = Minion(5, 5)
        if option is health:
            minion.increase_health(5)
            minion._effects_to_add.append(Taunt())
        else:
            minion.change_attack(5)

        return minion

    def create_minion(self, player):
        def poisonous(amount, target):
            if type(target) is Minion:
                target.die(self)

        minion = Minion(1, 1, stealth=True)
        minion.bind("did_damage", poisonous)
        minion.bind_once("silenced", lambda: minion.unbind("did_damage", poisonous))
        return minion

 def create_minion(self, player):
     res = Minion(self.base_attack, self.health, taunt=self.taunt)
     res.name = self.name
     return res