Beispiel #1
0
    def apply_action(self):
        src, tgt = self.source, self.target
        g = Game.getgame()

        src.tags['darknoh_tag'] = src.tags['turn_count']
        sk = self.associated_card
        card = sk.associated_cards[0]
        self.card = card
        migrate_cards([sk], tgt.showncards, unwrap=True)
        self.n = n = len(tgt.cards) + len(tgt.showncards) - tgt.life
        if n <= 0: return True

        cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
        if not cards:
            cl = list(tgt.cards) + list(tgt.showncards)
            try:
                cl.remove(card)
            except:
                pass

            cards = cl[:n]

        g.players.reveal(cards)
        g.process_action(DropCards(src, tgt, cards))

        return True
Beispiel #2
0
    def apply_action(self):
        tgt = self.target
        g = Game.getgame()
        n = 1 + tgt.maxlife - tgt.life
        cards = g.deck.getcards(n)

        tgt.reveal(cards)
        putback, acquire = user_input([tgt], self.inputlet_cls(self, cards), timeout=20)
        for c in acquire:
            c.detach()

        assert not putback or set(putback) == set(g.deck.getcards(len(putback)))

        deck = g.deck.cards
        for i, c in enumerate(putback):
            deck[i] = c

        assert not putback or putback == g.deck.getcards(len(putback))

        if acquire:
            g.process_action(ShowCards(tgt, acquire))
            migrate_cards(acquire, tgt.cards)

        self.acquire = acquire

        return True
Beispiel #3
0
    def fatetell_action(self, ft):
        if ft.succeeded:
            self.card = c = ft.card
            migrate_cards([c], self.target.cards, is_bh=True)
            return True

        return False
Beispiel #4
0
    def apply_action(self):
        src, tgt = self.source, self.target
        g = Game.getgame()

        c = user_input([src], ChoosePeerCardInputlet(self, tgt, ['cards', 'showncards', 'equips']))
        c = c or random_choose_card([tgt.cards, tgt.showncards, tgt.equips])
        g.players.reveal(c)

        g.process_action(DropCards(src, tgt, [c]))

        action = 'draw'
        if tgt.life < tgt.maxlife:
            action = user_input([tgt], ChooseOptionInputlet(self, ('heal', 'draw'))) or 'draw'

        if action == 'heal':
            g.process_action(EirinHeal(src, tgt))
        else:
            g.deck.getcards(3)
            g.deck.cards.rotate(3)
            cl = g.deck.getcards(3)
            g.process_action(ShowCards(tgt, cl))

            drop = [c for c in cl if 'basic' in c.category]
            get = [c for c in cl if c not in drop]

            if get:
                migrate_cards(get, tgt.cards)

            if drop:
                migrate_cards(drop, g.deck.droppedcards)

        ttags(src)['sky_silk'] = True
        return True
Beispiel #5
0
    def apply_action(self):
        src = self.source
        tgt = self.target
        options = (
            Card.SPADE,
            Card.HEART,
            Card.CLUB,
            Card.DIAMOND,
        )

        card = self.associated_card
        detach_cards([card])
        suit = user_input([tgt], ChooseOptionInputlet(self, options))

        src.tags['surprise_tag'] = src.tags['turn_count']
        assert card

        g = Game.getgame()
        g.players.reveal(card.associated_cards)
        migrate_cards([card], tgt.showncards, unwrap=True)

        if card.suit != suit:
            g.process_action(Damage(src, tgt))
            rst = True
        else:
            rst = False

        return rst
Beispiel #6
0
    def fatetell_action(self, ft):
        if ft.succeeded:
            self.card = c = ft.card
            migrate_cards([c], self.target.cards, is_bh=True)
            return True

        return False
Beispiel #7
0
 def apply_action(self):
     src, tgt = self.source, self.target
     c = user_input([src], ChoosePeerCardInputlet(self, tgt, ('cards', 'showncards', 'equips')))
     if not c: return False
     src.reveal(c)
     migrate_cards([c], src.cards)
     return True
Beispiel #8
0
    def apply_action(self):
        tgt, victim = self.target, self.victim
        if tgt.dead: return False

        g = Game.getgame()

        sel = ShipwreckChooseCard(tgt, victim)
        g.process_action(sel)
        c = sel.card

        tgt.reveal(c)
        migrate_cards([c], tgt.cards, unwrap=True)

        n = self.dropn
        if n <= 0:
            g.process_action(ShipwreckBrokenScoop(tgt, victim))
            return True

        g = Game.getgame()
        cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
        if not cards:
            from itertools import chain
            cards = list(chain(tgt.cards, tgt.showncards))[min(-n, 0):]

        g.process_action(ShipwreckEffect(tgt, victim, cards))

        return True
Beispiel #9
0
    def apply_action(self):
        tgt = self.target
        g = Game.getgame()
        n = 1 + tgt.maxlife - tgt.life
        cards = g.deck.getcards(n)

        tgt.reveal(cards)
        putback, acquire = user_input([tgt],
                                      self.inputlet_cls(self, cards),
                                      timeout=20)
        for c in acquire:
            c.detach()

        assert not putback or set(putback) == set(g.deck.getcards(
            len(putback)))

        deck = g.deck.cards
        for i, c in enumerate(putback):
            deck[i] = c

        assert not putback or putback == g.deck.getcards(len(putback))

        if acquire:
            g.process_action(ShowCards(tgt, acquire))
            migrate_cards(acquire, tgt.cards)

        self.acquire = acquire

        return True
Beispiel #10
0
    def apply_action(self):
        tgt = self.target
        c = self.card
        g = Game.getgame()
        tgt.reveal(c)
        migrate_cards([c], tgt.cards, unwrap=True)

        choice = user_input([tgt],
                            ChooseOptionInputlet(self, ('reforge', 'action')))
        if choice == 'reforge':
            g.process_action(TeachTargetReforgeAction(tgt, tgt))
        else:
            act = TeachTargetActionStage(tgt)
            g.process_action(act)
            if act.action_count == 1:
                return False

            c = random_choose_card([tgt.cards, tgt.showncards, tgt.equips])
            if not c:
                return False

            g.players.reveal(c)
            g.process_action(Reforge(tgt, tgt, c))

        return True
Beispiel #11
0
    def apply_action(self):
        tgt, victim = self.target, self.victim
        if tgt.dead: return False

        g = Game.getgame()

        sel = ShipwreckChooseCard(tgt, victim)
        g.process_action(sel)
        c = sel.card

        tgt.reveal(c)
        migrate_cards([c], tgt.cards, unwrap=True)

        n = self.dropn
        if n <= 0:
            g.process_action(ShipwreckBrokenScoop(tgt, victim))
            return True

        g = Game.getgame()
        cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
        if not cards:
            from itertools import chain
            cards = list(chain(tgt.cards, tgt.showncards))[min(-n, 0):]

        g.process_action(ShipwreckEffect(tgt, victim, cards))

        return True
Beispiel #12
0
    def apply_action(self):
        src = self.source
        tgt = self.target
        options = (
            Card.SPADE, Card.HEART,
            Card.CLUB, Card.DIAMOND,
        )

        card = self.associated_card
        detach_cards([card])
        suit = user_input([tgt], ChooseOptionInputlet(self, options))

        src.tags['surprise_tag'] = src.tags['turn_count']
        assert card

        g = Game.getgame()
        g.players.reveal(card.associated_cards)
        migrate_cards([card], tgt.showncards, unwrap=True)

        if card.suit != suit:
            g.process_action(Damage(src, tgt))
            rst = True
        else:
            rst = False

        return rst
Beispiel #13
0
    def apply_action(self):
        tgt = self.target
        src = self.source

        catnames = ('cards', 'showncards', 'equips', 'fatetell')
        cats = [getattr(tgt, i) for i in catnames]
        card = user_input([src], ChoosePeerCardInputlet(self, tgt, catnames))
        card = card or random_choose_card(cats)
        if not card:
            return False

        self.card = card
        src.reveal(card)

        src.tags['spirit_away_tag'] += 1

        cl = getattr(tgt, 'yukari_dimension', None)
        if cl is None:
            cl = CardList(tgt, 'yukari_dimension')
            tgt.yukari_dimension = cl
            tgt.showncardlists.append(cl)

        migrate_cards([card], cl)

        return True
Beispiel #14
0
    def apply_action(self):
        src, tgt = self.source, self.target
        g = Game.getgame()

        src.tags['darknoh_tag'] = src.tags['turn_count']
        sk = self.associated_card
        card = sk.associated_cards[0]
        self.card = card
        migrate_cards([sk], tgt.showncards, unwrap=True)
        self.n = n = len(tgt.cards) + len(tgt.showncards) - tgt.life
        if n <= 0: return True

        cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
        if not cards:
            cl = list(tgt.cards) + list(tgt.showncards)
            try:
                cl.remove(card)
            except:
                pass

            cards = cl[:n]

        g.players.reveal(cards)
        g.process_action(DropCards(src, tgt, cards))

        return True
Beispiel #15
0
    def apply_action(self):
        src, tgt = self.source, self.target
        cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
        c = cards[0] if cards else random_choose_card([tgt.cards, tgt.showncards])
        src.reveal(c)
        migrate_cards([c], src.cards)

        return True
Beispiel #16
0
 def cleanup(self):
     g = Game.getgame()
     self.trans.end()
     g.emit_event('harvest_finish', self)
     dropped = g.deck.droppedcards
     migrate_cards([c for c in self.cards if c.detached],
                   dropped,
                   is_bh=True)
Beispiel #17
0
    def apply_action(self):
        src, tgt = self.source, self.target
        cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
        c = cards[0] if cards else random_choose_card(
            [tgt.cards, tgt.showncards])
        src.reveal(c)
        migrate_cards([c], src.cards)

        return True
Beispiel #18
0
 def apply_action(self):
     src, tgt = self.source, self.target
     qi = src.meirin_qiliao
     assert qi
     g = Game.getgame()
     tgt.reveal(list(qi))
     migrate_cards(qi, tgt.cards, unwrap=True)
     g.process_action(Heal(src, tgt, 1))
     return True
Beispiel #19
0
 def apply_action(self):
     src, tgt = self.source, self.target
     qi = src.meirin_qiliao
     assert qi
     g = Game.getgame()
     tgt.reveal(list(qi))
     migrate_cards(qi, tgt.cards, unwrap=True)
     g.process_action(Heal(src, tgt, 1))
     return True
Beispiel #20
0
 def apply_action(self):
     tgt = self.target
     assert tgt.cards
     c = random_choose_card([tgt.cards])
     g = Game.getgame()
     g.players.reveal(c)
     tgt.tags['mind_hack_effect-%s' % g.turn_count] = True
     migrate_cards([c], tgt.showncards)
     return True
Beispiel #21
0
    def apply_action(self):
        tgt = self.target

        cards = list(tgt.cards)[:2]
        g = Game.getgame()
        g.players.exclude(tgt).reveal(cards)
        migrate_cards(cards, tgt.showncards)

        return True
Beispiel #22
0
 def apply_action(self):
     src, tgt = self.source, self.target
     c = user_input([src],
                    ChoosePeerCardInputlet(
                        self, tgt, ('cards', 'showncards', 'equips')))
     if not c: return False
     src.reveal(c)
     migrate_cards([c], src.cards)
     return True
Beispiel #23
0
    def apply_action(self):
        tgt = self.target

        cards = list(tgt.cards)[:2]
        g = Game.getgame()
        g.players.exclude(tgt).reveal(cards)
        migrate_cards(cards, tgt.showncards)

        return True
Beispiel #24
0
    def fatetell_action(self, ft):
        if not ft.succeeded:
            return False

        g = Game.getgame()
        tgt, c = self.target, self.hat_card
        g.process_action(spellcard.SinsackDamage(None, tgt, amount=2))
        migrate_cards([c], tgt.cards, unwrap=True)
        return True
Beispiel #25
0
    def fatetell_action(self, ft):
        if not ft.succeeded:
            return False

        g = Game.getgame()
        tgt, c = self.target, self.hat_card
        g.process_action(spellcard.SinsackDamage(None, tgt, amount=2))
        migrate_cards([c], tgt.cards, unwrap=True)
        return True
Beispiel #26
0
    def apply_action(self):
        card = self.associated_card
        action = card.delayed_action
        assert issubclass(action, DelayedSpellCardAction)

        t = self.target
        migrate_cards([card], t.fatetell)

        return True
Beispiel #27
0
    def apply_action(self):
        g = Game.getgame()
        target = self.target

        cards = g.deck.getcards(self.amount)

        target.reveal(cards)
        migrate_cards(cards, target.showncards)
        self.cards = cards
        return True
Beispiel #28
0
    def apply_action(self):
        tgt = self.target
        cl = getattr(tgt, 'momiji_sentry_cl', None)
        if cl is None:
            cl = CardList(tgt, 'momiji_sentry_cl')
            tgt.momiji_sentry_cl = cl
            tgt.showncardlists.append(cl)

        migrate_cards(self.cards, cl)
        return True
Beispiel #29
0
    def apply_action(self):
        tgt = self.target
        cl = getattr(tgt, 'momiji_sentry_cl', None)
        if cl is None:
            cl = CardList(tgt, 'momiji_sentry_cl')
            tgt.momiji_sentry_cl = cl
            tgt.showncardlists.append(cl)

        migrate_cards(self.cards, cl)
        return True
Beispiel #30
0
    def apply_action(self):
        g = Game.getgame()
        target = self.target

        cards = g.deck.getcards(self.amount)

        target.reveal(cards)
        migrate_cards(cards, target.showncards)
        self.cards = cards
        return True
Beispiel #31
0
    def apply_action(self):
        src, tgt = self.source, self.target
        lists = [tgt.cards, tgt.showncards, tgt.equips]
        with MigrateCardsTransaction(self) as trans:
            for cl in lists:
                if not cl: continue
                cl = list(cl)
                src.reveal(cl)
                migrate_cards(cl, src.cards, unwrap=True, trans=trans)

        return True
Beispiel #32
0
    def apply_action(self):
        g = Game.getgame()
        c = self.card
        ft = self.ft
        g.players.exclude(self.source).reveal(c)
        with MigrateCardsTransaction(self) as trans:
            migrate_cards([ft.card], g.deck.droppedcards, unwrap=True, trans=trans, is_bh=True)
            detach_cards([c], trans=trans)
            self.ft.set_card(c, self)

        return True
Beispiel #33
0
    def apply_action(self):
        src, tgt = self.source, self.target
        lists = [tgt.cards, tgt.showncards, tgt.equips]
        with MigrateCardsTransaction(self) as trans:
            for cl in lists:
                if not cl: continue
                cl = list(cl)
                src.reveal(cl)
                migrate_cards(cl, src.cards, unwrap=True, trans=trans)

        return True
Beispiel #34
0
    def apply_action(self):
        src, tgt = self.source, self.target
        cards = user_choose_cards(self, src, ('cards', 'showncards', 'equips'))
        c = cards[0] if cards else random_choose_card([src.cards, src.showncards, src.equips])
        if not c:
            return False

        tgt.reveal(c)
        migrate_cards([c], tgt.cards)

        return True
Beispiel #35
0
    def apply_action(self):
        tgt = self.target
        g = Game.getgame()

        with MigrateCardsTransaction(self) as trans:
            g.players.reveal(list(tgt.cards))
            migrate_cards(tgt.cards, g.deck.droppedcards, trans=trans)
            cards = g.deck.getcards(4)
            tgt.reveal(cards)
            migrate_cards(cards, tgt.cards, trans=trans)

        return True
Beispiel #36
0
    def apply_action(self):
        g = Game.getgame()
        c = self.card
        ft = self.ft
        src = self.source
        g.players.exclude(src).reveal(c)
        with MigrateCardsTransaction(self) as trans:
            migrate_cards([ft.card], src.cards, unwrap=True, trans=trans, is_bh=True)
            detach_cards([c], trans=trans)
            self.ft.set_card(c, self)

        return True
Beispiel #37
0
    def apply_action(self):
        tgt = self.target
        g = Game.getgame()

        with MigrateCardsTransaction(self) as trans:
            g.players.reveal(list(tgt.cards))
            migrate_cards(tgt.cards, g.deck.droppedcards, trans=trans)
            cards = g.deck.getcards(4)
            tgt.reveal(cards)
            migrate_cards(cards, tgt.cards, trans=trans)

        return True
Beispiel #38
0
 def apply_action(self):
     g = Game.getgame()
     tgt = self.target
     place = user_input([tgt], ChooseOptionInputlet(self, ('top', 'bottom')))
     sk = self.card
     assert sk.is_card(LunaString)
     c = sk.associated_cards[0]
     sk.associated_cards[:] = []
     sk.cost_detached = True
     self.place = place  # for ui
     migrate_cards([c], g.deck.cards, unwrap=True, front=(place == 'top'))
     return True
Beispiel #39
0
    def apply_action(self):
        src, tgt = self.source, self.target
        cards = user_choose_cards(self, src, ('cards', 'showncards', 'equips'))
        c = cards[0] if cards else random_choose_card(
            [src.cards, src.showncards, src.equips])
        if not c:
            return False

        tgt.reveal(c)
        migrate_cards([c], tgt.cards)

        return True
Beispiel #40
0
    def apply_action(self):
        g = Game.getgame()
        src, tgt = self.source, self.target
        cards = self.cards

        tgt.reveal(cards)
        migrate_cards(cards, tgt.cards)

        self.life_lost = life_lost = len(tgt.cards) + len(tgt.showncards) > tgt.life
        life_lost and g.process_action(LifeLost(src, tgt, 1))

        return True
Beispiel #41
0
    def apply_action(self):
        tgt = self.target

        lc = self.launch_action
        if lc and isinstance(lc.card, PhysicalCard):
            mock = EchoPlaceholderCard(tgt, lc.card)
            # HACK: should impl in LaunchCard
            lc.card = mock
            lc.card_action.associated_card = mock

        migrate_cards([self.card], tgt.cards, unwrap=True, is_bh=True)

        return True
Beispiel #42
0
    def apply_action(self):
        g = Game.getgame()
        src, tgt = self.source, self.target
        cards = self.cards

        tgt.reveal(cards)
        migrate_cards(cards, tgt.cards)

        self.life_lost = life_lost = len(tgt.cards) + len(
            tgt.showncards) > tgt.life
        life_lost and g.process_action(LifeLost(src, tgt, 1))

        return True
Beispiel #43
0
    def apply_action(self):
        tgt = self.target
        lc = self.action
        assert isinstance(lc, ActionStageLaunchCard)

        cl = getattr(tgt, 'momiji_sentry_cl', None)
        if cl is None:
            cl = CardList(tgt, 'momiji_sentry_cl')
            tgt.momiji_sentry_cl = cl
            tgt.showncardlists.append(cl)

        migrate_cards([lc.card], cl, unwrap=True)
        lc.cancelled = True
        return True
Beispiel #44
0
 def apply_action(self):
     cl = self.associated_card.associated_cards
     src = self.source
     tgt = self.target
     l = src.tags.get('daiyousei_spnum', 0)
     n = len(cl)
     if l < 3 <= l + n:
         g = Game.getgame()
         g.process_action(Heal(src, src))
     src.tags['daiyousei_spnum'] = l + n
     tgt.reveal(cl)
     migrate_cards([self.associated_card], tgt.cards, unwrap=True)
     self.cards = cl
     return True
Beispiel #45
0
 def fatetell_postprocess(self):
     g = Game.getgame()
     tgt = self.target
     if not self.cancelled and self.succeeded:
         g.process_action(DropCards(None, tgt, [self.associated_card]))
     else:
         pl = g.players
         stop = pl.index(tgt)
         next = stop - len(pl) + 1
         while next < stop:
             if not pl[next].dead:
                 migrate_cards([self.associated_card], pl[next].fatetell)
                 return
             next += 1
Beispiel #46
0
 def apply_action(self):
     cl = self.associated_card.associated_cards
     src = self.source
     tgt = self.target
     l = src.tags.get('daiyousei_spnum', 0)
     n = len(cl)
     if l < 3 <= l + n:
         g = Game.getgame()
         g.process_action(Heal(src, src))
     src.tags['daiyousei_spnum'] = l + n
     tgt.reveal(cl)
     migrate_cards([self.associated_card], tgt.cards, unwrap=True)
     self.cards = cl
     return True
Beispiel #47
0
    def apply_action(self):
        tgt = self.target
        lc = self.action
        assert isinstance(lc, ActionStageLaunchCard)

        cl = getattr(tgt, 'momiji_sentry_cl', None)
        if cl is None:
            cl = CardList(tgt, 'momiji_sentry_cl')
            tgt.momiji_sentry_cl = cl
            tgt.showncardlists.append(cl)

        migrate_cards([lc.card], cl, unwrap=True)
        lc.cancelled = True
        return True
Beispiel #48
0
    def apply_action(self):
        g = Game.getgame()
        card = self.card
        tgt = self.target
        g = Game.getgame()

        weapons = [e for e in tgt.equips if e.equipment_category == 'weapon']
        if len(weapons) > 1:
            e = user_input([tgt], ChooseIndividualCardInputlet(self, weapons))
            e = e or random_choose_card([weapons])
            g.process_action(DropCards(tgt, tgt, [e]))

        migrate_cards([card], tgt.equips)

        return True
Beispiel #49
0
    def apply_action(self):
        src = self.source
        tgt = self.target

        cards = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips'))
        g = Game.getgame()
        if cards:
            self.peer_action = 'card'
            g.players.exclude(tgt).reveal(cards)
            migrate_cards(cards, src.cards)
        else:
            self.peer_action = 'life'
            g.process_action(LifeLost(src, tgt, 1))

        return True
Beispiel #50
0
    def apply_action(self):
        g = Game.getgame()
        card = self.card
        tgt = self.target
        g = Game.getgame()

        weapons = [e for e in tgt.equips if e.equipment_category == 'weapon']
        if len(weapons) > 1:
            e = user_input([tgt], ChooseIndividualCardInputlet(self, weapons))
            e = e or random_choose_card([weapons])
            g.process_action(DropCards(tgt, tgt, [e]))

        migrate_cards([card], tgt.equips)

        return True
Beispiel #51
0
    def apply_action(self):
        src = self.source
        tgt = self.target

        cards = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips'))
        g = Game.getgame()
        if cards:
            self.peer_action = 'card'
            g.players.exclude(tgt).reveal(cards)
            migrate_cards(cards, src.cards)
        else:
            self.peer_action = 'life'
            g.process_action(LifeLost(src, tgt, 1))

        return True
Beispiel #52
0
    def apply_action(self):
        g = Game.getgame()
        for p in g.players:
            cl = getattr(p, 'yukari_dimension', None)
            cl and migrate_cards(cl, p.cards, unwrap=True)

        return True
Beispiel #53
0
    def apply_action(self):
        src = self.source
        tgt = self.target

        catnames = ('cards', 'showncards', 'equips', 'fatetell')
        cats = [getattr(tgt, i) for i in catnames]
        card = user_input([src], ChoosePeerCardInputlet(self, tgt, catnames))
        if not card:
            card = random_choose_card(cats)
            if not card:
                return False

        self.card = card
        src.reveal(card)
        migrate_cards([card], src.cards, unwrap=True)
        return True
Beispiel #54
0
    def apply_action(self):
        t = self.target
        src = self.source
        g = Game.getgame()

        catnames = ('cards', 'showncards', 'equips')
        cats = [getattr(t, i) for i in catnames]
        cards = user_choose_cards(self, t, catnames)
        if not cards:
            cards = [random_choose_card(cats)]

        if cards:
            g.players.exclude(t).reveal(cards)
            migrate_cards(cards, src.showncards)

        return True
Beispiel #55
0
    def apply_action(self):
        tl = self.target_list
        assert len(tl) == 2
        src = self.source

        attacker, victim = tl
        cards = user_choose_cards(self, attacker, ['cards', 'showncards'])
        g = Game.getgame()

        if cards:
            g.players.reveal(cards)
            g.process_action(LaunchCard(attacker, [victim], cards[0]))
        else:
            l = [e for e in attacker.equips if e.equipment_category == 'weapon']
            migrate_cards(l, src.cards)
        return True
Beispiel #56
0
    def apply_action(self):
        tgt = self.target
        ttags(tgt)['qiliao'] = True
        g = Game.getgame()

        cl = getattr(tgt, 'meirin_qiliao', None)
        if cl is None:
            cl = CardList(tgt, 'meirin_qiliao')
            tgt.meirin_qiliao = cl
            tgt.showncardlists.append(cl)

        migrate_cards([self.associated_card], cl, unwrap=True)

        g.deck.shuffle(cl)

        return True