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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
