Пример #1
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
Пример #2
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
Пример #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
Пример #4
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
Пример #5
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
Пример #6
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
Пример #7
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
Пример #8
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
Пример #9
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
Пример #10
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
Пример #11
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
Пример #12
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)
Пример #13
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
Пример #14
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
Пример #15
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
Пример #16
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
Пример #17
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
Пример #18
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
Пример #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
Пример #20
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
Пример #21
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
Пример #22
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
Пример #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
Пример #24
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
Пример #25
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
Пример #26
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
Пример #27
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
Пример #28
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
Пример #29
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
Пример #30
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
Пример #31
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
Пример #32
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
Пример #33
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
Пример #34
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
Пример #35
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
Пример #36
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
Пример #37
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
Пример #38
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
Пример #39
0
    def apply_action(self):
        src = self.source
        tgt = 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])
        if not c: return False
        src.reveal(c)
        migrate_cards([c], src.cards)
        src.tags['borrow_tag'] = src.tags['turn_count']

        if user_input([tgt], ChooseOptionInputlet(self, (False, True))):
            g.process_action(LaunchCard(tgt, [src], Daze(tgt), bypass_check=True))

        return True
Пример #40
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
Пример #41
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
Пример #42
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
Пример #43
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
Пример #44
0
    def apply_action(self):
        g = Game.getgame()
        card = self.associated_card
        target = self.target
        equips = target.equips
        g = Game.getgame()

        with MigrateCardsTransaction(self) as trans:
            for oc in equips:
                if oc.equipment_category == card.equipment_category:
                    migrate_cards([oc], g.deck.droppedcards, unwrap=True, trans=trans)
                    break

            migrate_cards([card], target.equips, trans=trans)

        return True
Пример #45
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
Пример #46
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
Пример #47
0
    def apply_action(self):
        pact = ForEach.get_actual_action(self)
        cards = pact.cards
        cards_avail = [c for c in cards if c.detached]
        if not cards_avail: return False
        tgt = self.target

        card = user_input(
            [tgt],
            ChooseIndividualCardInputlet(self, cards_avail),
            trans=pact.trans,
        ) or random_choose_card([cards_avail])

        migrate_cards([card], tgt.cards)

        pact.trans.notify('harvest_choose', card)
        self.card = card
        return True
Пример #48
0
    def apply_action(self):
        pact = ForEach.get_actual_action(self)
        cards = pact.cards
        cards_avail = [c for c in cards if c.detached]
        if not cards_avail: return False
        tgt = self.target

        card = user_input(
            [tgt],
            ChooseIndividualCardInputlet(self, cards_avail),
            trans=pact.trans,
        ) or random_choose_card([cards_avail])

        migrate_cards([card], tgt.cards)

        pact.trans.notify('harvest_choose', card)
        self.card = card
        return True
Пример #49
0
    def apply_action(self):
        ft = self.ftact
        tgt = ft.target

        from .definition import YinYangOrbCard
        for e in tgt.equips:
            if e.is_card(YinYangOrbCard):
                with MigrateCardsTransaction(self) as trans:
                    migrate_cards([ft.card], tgt.cards, unwrap=True, trans=trans, is_bh=True)
                    detach_cards([e], trans=trans)
                    self.card = e
                    ft.set_card(e, self)

                break
        else:
            raise GameError('Player has YinYangOrb skill but no equip!')

        return True
Пример #50
0
    def apply_action(self):
        g = Game.getgame()
        card = self.associated_card
        target = self.target
        equips = target.equips
        g = Game.getgame()

        with MigrateCardsTransaction(self) as trans:
            for oc in equips:
                if oc.equipment_category == card.equipment_category:
                    migrate_cards([oc],
                                  g.deck.droppedcards,
                                  unwrap=True,
                                  trans=trans)
                    break

            migrate_cards([card], target.equips, trans=trans)

        return True
Пример #51
0
    def apply_action(self):
        src = self.source
        tgt = 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])
        if not c: return False
        src.reveal(c)
        migrate_cards([c], src.cards)
        src.tags['borrow_tag'] = src.tags['turn_count']

        if user_input([tgt], ChooseOptionInputlet(self, (False, True))):
            g.process_action(
                LaunchCard(tgt, [src], Daze(tgt), bypass_check=True))

        return True
Пример #52
0
    def apply_action(self):
        src, tgt = self.source, self.target
        g = Game.getgame()
        g.process_action(DrawCards(tgt, 2))

        cl = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips'))
        c = cl[0] if cl else random_choose_card(
            [tgt.cards, tgt.showncards, tgt.equips])

        if not c: return False

        g.players.reveal(c)
        g.process_action(ShowCards(tgt, [c]))
        migrate_cards([c], src.cards)

        if c.suit == Card.HEART:
            g.process_action(DrawCards(src, 1))

        self.card = c

        return True