def handle(self, evt_type, act):
if evt_type == 'action_after' and isinstance(act, ActionStage):
tgt = act.target
if not tgt.has_skill(LittleLegion):
return act
c, = user_choose_cards(
self, tgt, ('cards', 'showncards', 'equips')) or (None, )
if c is None:
return act
g = Game.getgame()
assert 'equipment' in c.category
category = c.equipment_category
g.process_action(Reforge(tgt, tgt, c))
if tgt.dead:
return act
if category == 'weapon':
g.process_action(LittleLegionAttackAction(tgt, tgt))
elif category == 'shield':
g.process_action(LittleLegionCoverAction(tgt, tgt))
elif category == 'accessories':
g.process_action(LittleLegionHoldAction(tgt, tgt))
elif category in ('redufo', 'greenufo'):
g.process_action(LittleLegionControlAction(tgt, tgt))
return act
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
c, = user_choose_cards(self, tgt,
('cards', 'showncards', 'equips')) or (None, )
c = c or random_choose_card([tgt.cards, tgt.showncards, tgt.equips])
self.card = c
return True
def handle(self, evt_type, act):
if evt_type == 'action_after' and isinstance(act, ActionStage):
tgt = act.target
if not tgt.has_skill(LittleLegion):
return act
c, = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips')) or (None,)
if c is None:
return act
g = Game.getgame()
assert 'equipment' in c.category
category = c.equipment_category
g.process_action(Reforge(tgt, tgt, c))
if tgt.dead:
return act
if category == 'weapon':
g.process_action(LittleLegionAttackAction(tgt, tgt))
elif category == 'shield':
g.process_action(LittleLegionCoverAction(tgt, tgt))
elif category == 'accessories':
g.process_action(LittleLegionHoldAction(tgt, tgt))
elif category in ('redufo', 'greenufo'):
g.process_action(LittleLegionControlAction(tgt, tgt))
return act
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, 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 activate_action(self):
p = self.source
self.cards = cards = user_choose_cards(
self, p, ('cards', 'showncards', 'equips'))
if not cards: return False
p.tags['ran_ei'] = p.tags['turn_count'] + 1
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 handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, ActionStage):
g = Game.getgame()
tgt = act.target
for p in g.players:
if p.dead or not p.has_skill(Devour):
continue
if ttags(p)['devour_used']:
continue
cl = user_choose_cards(self, p,
('cards', 'showncards', 'equips'))
if not cl:
continue
g.process_action(DevourAction(p, tgt, cl[0]))
elif evt_type == 'action_after' and isinstance(act, ActionStage):
tgt = act.target
t = ttags(tgt)['keine_devour']
if not t:
return act
g = Game.getgame()
g.process_action(DevourEffect(t['source'], tgt, t))
return act
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
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):
g = Game.getgame()
tgt = self.target
c = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips'))
c = c[0] if c else random_choose_card(
[tgt.cards, tgt.showncards, tgt.equips])
if not c:
return False
g.process_action(Reforge(tgt, tgt, c))
return True
def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, FatetellStage):
self.target = tgt = act.target
if not tgt.has_skill(Reborn): return act
cards = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips'))
if cards:
g = Game.getgame()
g.process_action(DropCards(tgt, tgt, cards))
g.process_action(RebornAction(tgt))
return act
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):
src, tgt = self.source, self.target
cl = VirtualCard.unwrap([self.associated_card])
assert len(cl) == 1
g = Game.getgame()
ttags(src)['teach_used'] = True
g.process_action(Reforge(src, src, cl[0]))
cl = user_choose_cards(self, src, ('cards', 'showncards', 'equips'))
c = cl[0] if cl else random_choose_card([src.cards, src.showncards, src.equips])
g.process_action(TeachTargetEffect(src, tgt, c))
return True
def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, FatetellStage):
self.target = tgt = act.target
if not tgt.has_skill(Reborn): return act
cards = user_choose_cards(self, tgt,
('cards', 'showncards', 'equips'))
if cards:
g = Game.getgame()
g.process_action(DropCards(tgt, tgt, cards))
g.process_action(RebornAction(tgt))
return act
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 handle(self, p, act):
if p.dead: return act
if not p.has_skill(MiracleMallet): return act
self.number = act.card.number
self.act = act
cards = user_choose_cards(self, p, ('cards', 'showncards', 'equips'))
if cards:
c = cards[0]
Game.getgame().process_action(MiracleMalletAction(p, act.target, act, c))
return act
def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, FatetellStage):
self.target = tgt = act.target
if not tgt.has_skill(Reborn): return act
cards = user_choose_cards(self, tgt,
('cards', 'showncards', 'equips'))
if cards:
g = Game.getgame()
g.process_action(DropCards(tgt, tgt, cards))
if not tgt.dead: # Ensure no ui action_effect_after (str | se) after drop Exinwan causing fall
g.process_action(RebornAction(tgt))
return act
def apply_action(self):
src = self.source
tgt = self.target
cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
g = Game.getgame()
if cards:
self.peer_action = 'drop'
g.process_action(DropCards(src, tgt, cards))
else:
self.peer_action = 'draw'
g.process_action(DrawCards(src, 1))
return True
def apply_action(self):
g = Game.getgame()
tgt = self.target
if tgt.dead:
return False
cards = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips'))
if cards:
g.process_action(DropCards(tgt, tgt, cards))
else:
g.process_action(Damage(None, tgt))
return True
def apply_action(self):
g = Game.getgame()
tgt = self.target
if tgt.dead:
return False
cards = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips'))
if cards:
g.process_action(DropCards(tgt, tgt, cards))
else:
g.process_action(Damage(None, tgt))
return True
def apply_action(self):
src = self.source
tgt = self.target
cards = user_choose_cards(self, tgt, ('cards', 'showncards'))
g = Game.getgame()
if cards:
self.peer_action = 'drop'
g.process_action(DropCards(src, tgt, cards))
else:
self.peer_action = 'draw'
g.process_action(DrawCards(src, 1))
return True
def apply_action(self):
src, tgt = self.source, self.target
ttags(src)['bakadesu'] = True
cl = user_choose_cards(self, tgt, ('cards', 'showncards'))
g = Game.getgame()
if cl:
g.process_action(LaunchCard(tgt, [src], cl[0]))
else:
c = user_input([src], ChoosePeerCardInputlet(self, tgt, ('cards', 'showncards', 'equips')))
c = c or random_choose_card([tgt.cards, tgt.showncards, tgt.equips])
c and g.process_action(CirnoDropCards(src, tgt, [c]))
return True
def apply_action(self):
attacker, victim = self.target_list
src = self.source
g = Game.getgame()
tags = self.source.tags
tags['darkness_tag'] = tags['turn_count']
cards = user_choose_cards(self, attacker, ('cards', 'showncards'))
if cards:
c = cards[0]
g.process_action(LaunchCard(attacker, [victim], c))
else:
g.process_action(Damage(src, attacker, 1))
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):
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 handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, FatetellStage):
g = Game.getgame()
for p in g.players:
if p.dead:
continue
if not p.has_skill(Ciguatera):
continue
cards = user_choose_cards(self, p, ('cards', 'showncards', 'equips'))
if cards:
g.process_action(CiguateraAction(p, act.target, cards))
return act
def apply_action(self):
attacker, victim = self.target_list
src = self.source
g = Game.getgame()
tags = self.source.tags
tags['darkness_tag'] = tags['turn_count']
cards = user_choose_cards(self, attacker, ('cards', 'showncards'))
if cards:
c = cards[0]
g.process_action(LaunchCard(attacker, [victim], c))
else:
g.process_action(Damage(src, attacker, 1))
return True
def apply_action(self):
self.damage.cancelled = True
src, tgt = self.source, self.target
g = Game.getgame()
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 c:
damage = c.resides_in is not tgt.equips
g.process_action(CirnoDropCards(src, tgt, [c]))
if damage:
g.process_action(LifeLost(src, tgt, 1))
return True
def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, FatetellStage):
g = Game.getgame()
for p in g.players:
if p.dead:
continue
if not p.has_skill(Ciguatera):
continue
cards = user_choose_cards(self, p,
('cards', 'showncards', 'equips'))
if cards:
g.process_action(CiguateraAction(p, act.target, cards))
return act
def handle(self, p, act):
if p.dead: return act
if not p.has_skill(Trial): return act
self.act = act
if not user_input([p], ChooseOptionInputlet(self, (False, True))):
return act
cards = user_choose_cards(self, p, ('cards', 'showncards', 'equips'))
if cards:
c = cards[0]
Game.getgame().process_action(TrialAction(p, act.target, act, c))
return act
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 handle(self, p, act):
if p.dead: return act
if not p.has_skill(Trial): return act
self.act = act
if not user_input([p], ChooseOptionInputlet(self, (False, True))):
return act
cards = user_choose_cards(self, p, ('cards', 'showncards', 'equips'))
if cards:
c = cards[0]
Game.getgame().process_action(TrialAction(p, act.target, act, c))
return act
def handle(self, evt_type, act):
if evt_type == 'action_after' and isinstance(act, Damage):
if not act.succeeded: return act
src, tgt = act.source, act.target
if not (src and src.has_skill(AyaRoundfanSkill) and tgt.equips): return act
g = Game.getgame()
pa = g.action_stack[-1]
if not isinstance(pa, basic.BaseAttack): return act
cards = user_choose_cards(self, src, ('cards', 'showncards'))
if not cards: return act
g = Game.getgame()
g.process_action(DropCards(src, src, cards))
g.process_action(AyaRoundfan(src, tgt))
return act
def handle(self, evt_type, act):
if evt_type == 'action_after' and isinstance(act, Damage):
if not act.succeeded: return act
src, tgt = act.source, act.target
if not (src and src.has_skill(AyaRoundfanSkill) and tgt.equips): return act
g = Game.getgame()
pa = g.action_stack[-1]
if not isinstance(pa, basic.BaseAttack): return act
cards = user_choose_cards(self, src, ('cards', 'showncards'))
if not cards: return act
g = Game.getgame()
g.process_action(DropCards(src, src, cards))
g.process_action(AyaRoundfan(src, tgt))
return act
def apply_action(self):
self.damage.cancelled = True
src, tgt = self.source, self.target
g = Game.getgame()
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 c:
damage = c.resides_in is not tgt.equips
g.process_action(CirnoDropCards(src, tgt, [c]))
if damage:
g.process_action(LifeLost(src, tgt, 1))
return True
def apply_action(self):
src, tgt = self.source, self.target
ttags(src)['bakadesu'] = True
cl = user_choose_cards(self, tgt, ('cards', 'showncards'))
g = Game.getgame()
if cl:
g.process_action(LaunchCard(tgt, [src], cl[0]))
else:
c = user_input([src],
ChoosePeerCardInputlet(
self, tgt, ('cards', 'showncards', 'equips')))
c = c or random_choose_card(
[tgt.cards, tgt.showncards, tgt.equips])
c and g.process_action(CirnoDropCards(src, tgt, [c]))
return True
def handle(self, evt_type, act):
if evt_type != 'action_after': return act
if not isinstance(act, LaunchCard): return act
g = Game.getgame()
card = act.card
if not card: return act
if 'basic' not in card.category: return act
if card.color != Card.RED: return act
if card.is_card(VirtualCard):
rawcards = VirtualCard.unwrap([card])
else:
rawcards = [card]
if not all(c.resides_in is None or c.resides_in.type == 'droppedcard'
for c in rawcards):
return act
tgt = act.source
self.target = tgt # for ui
if tgt.dead: return act
for p in g.players:
if p.dead or p is tgt: continue
if not p.has_skill(ImperishableNight): continue
if p is g.current_player: continue
if not user_input([p], ChooseOptionInputlet(self, (False, True))):
continue
cards = user_choose_cards(self, p,
('cards', 'showncards', 'equips'))
if cards:
g.players.reveal(cards)
skill = skill_wrap(p, [ImperishableNight], cards, {})
assert skill_check(skill) # should not fail
g.deck.register_vcard(skill)
rst = g.process_action(LaunchCard(p, [tgt], skill))
assert rst
return act
def handle(self, evt_type, act):
if evt_type != 'action_after': return act
if not isinstance(act, LaunchCard): return act
g = Game.getgame()
card = act.card
if not card: return act
if 'basic' not in card.category: return act
if card.color != Card.RED: return act
if card.is_card(VirtualCard):
rawcards = VirtualCard.unwrap([card])
else:
rawcards = [card]
if not all(
c.resides_in is None or c.resides_in.type == 'droppedcard'
for c in rawcards
): return act
tgt = act.source
self.target = tgt # for ui
if tgt.dead: return act
for p in g.players:
if p.dead or p is tgt: continue
if not p.has_skill(ImperishableNight): continue
if p is g.current_player: continue
if not user_input([p], ChooseOptionInputlet(self, (False, True))):
continue
cards = user_choose_cards(self, p, ('cards', 'showncards', 'equips'))
if cards:
g.players.reveal(cards)
skill = skill_wrap(p, [ImperishableNight], cards, {})
assert skill_check(skill) # should not fail
g.deck.register_vcard(skill)
rst = g.process_action(LaunchCard(p, [tgt], skill))
assert rst
return act
def handle(self, evt_type, act):
if evt_type == 'action_apply' and isinstance(act, PlayerTurn):
actor = act.target
g = Game.getgame()
for p in g.players:
if not p.has_skill(Qiliao): continue
qi = getattr(p, 'meirin_qiliao', None)
if not qi: continue
cl = user_choose_cards(self, actor, ('cards', 'showncards'))
if not cl: continue
g.process_action(DropCards(actor, actor, cl))
if actor.dead: continue
c = user_input([actor], ChooseIndividualCardInputlet(self, qi)) or random_choose_card([qi])
g.players.reveal(c)
g.process_action(DropCards(actor, p, [c]))
return act
def handle(self, evt_type, act):
if evt_type == 'action_apply' and isinstance(act, PlayerTurn):
actor = act.target
g = Game.getgame()
for p in g.players:
if not p.has_skill(Qiliao): continue
qi = getattr(p, 'meirin_qiliao', None)
if not qi: continue
cl = user_choose_cards(self, actor, ('cards', 'showncards'))
if not cl: continue
g.process_action(DropCards(actor, actor, cl))
if actor.dead: continue
c = user_input([actor], ChooseIndividualCardInputlet(
self, qi)) or random_choose_card([qi])
g.players.reveal(c)
g.process_action(DropCards(actor, p, [c]))
return act
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
def handle(self, evt_type, arg):
if evt_type == 'attack_aftergraze':
act, succeed = arg
assert isinstance(act, basic.BaseAttack)
if succeed:
return arg
src = act.source
tgt = act.target
if not src or not src.has_skill(LaevateinSkill):
return arg
g = Game.getgame()
cards = user_choose_cards(self, src, ('cards', 'showncards', 'equips'))
if not cards:
return arg
g.process_action(DropCards(src, src, cards))
g.process_action(Laevatein(src, tgt))
return act, True
return arg
def handle(self, evt_type, arg):
if evt_type == 'attack_aftergraze':
act, succeed = arg
assert isinstance(act, basic.BaseAttack)
if succeed:
return arg
src = act.source
tgt = act.target
if not src or not src.has_skill(LaevateinSkill):
return arg
g = Game.getgame()
cards = user_choose_cards(self, src, ('cards', 'showncards', 'equips'))
if not cards:
return arg
g.process_action(DropCards(src, src, cards))
g.process_action(Laevatein(src, tgt))
return act, True
return arg
def activate_action(self):
p = self.source
self.cards = cards = user_choose_cards(self, p, ('cards', 'showncards', 'equips'))
if not cards: return False
p.tags['ran_ei'] = p.tags['turn_count'] + 1
return True
def apply_action(self):
tgt = self.target
c, = user_choose_cards(self, tgt, ('cards', 'showncards', 'equips')) or (None,)
c = c or random_choose_card([tgt.cards, tgt.showncards, tgt.equips])
self.card = c
return True
