def apply_action(self):
g = Game.getgame()
tgt = self.target
while True:
dc = DrawCards(tgt, 1)
g.process_action(dc)
c, = dc.cards
self.card = c
g.process_action(ShowCards(tgt, [c]))
with InputTransaction('ActionStageAction', [tgt]) as trans:
p, rst = ask_for_action(self, [tgt], ('cards', 'showncards'),
g.players, trans)
if p is not tgt:
g.process_action(WindWalkSkipAction(tgt, tgt))
break
cl, tl = rst
g.players.reveal(cl)
c, = cl
g.process_action(WindWalkLaunch(p, tl, c))
return True
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 apply_action(self):
src = self.source
g = Game.getgame()
g.process_action(DrawCards(src, 1))
turn = PlayerTurn.get_current(src)
try:
turn.pending_stages.remove(DropCardStage)
except Exception:
pass
return True
def apply_action(self):
src, tgt = self.source, self.target
ttags(src)['dismantle'] = True
g = Game.getgame()
c = user_input([src], ChoosePeerCardInputlet(self, tgt, ('equips', )))
c = c or random_choose_card([tgt.equips])
if not c: return False
g.process_action(Reforge(src, tgt, c))
g.process_action(DrawCards(tgt, 1))
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 = self.source
tgt = self.target
draw = DrawCards(src, self.amount)
g = Game.getgame()
g.process_action(draw)
g.process_action(ShowCards(src, draw.cards))
if [c for c in draw.cards if c.suit != Card.CLUB]: # any non-club
tgt.tags['melancholy_tag'] = g.turn_count
self.effective = True
else:
self.effective = False
return True
def apply_action(self):
tgt = self.target
g = Game.getgame()
g.process_action(DrawCards(tgt, 1))
ttags(tgt)['miracle_times'] += 1
if ttags(tgt)['miracle_times'] == 3:
candidates = [p for p in g.players if not p.dead and p.life < p.maxlife]
if candidates:
beneficiery, = user_choose_players(self, tgt, candidates) or (None,)
if beneficiery:
g.process_action(MiracleHeal(tgt, beneficiery))
return True
def handle(self, evt_type, act):
if evt_type != 'action_before': return act
if not isinstance(act, DeadDropCards): return act
g = Game.getgame()
tgt = act.target
for f in g.forces:
if tgt in f:
break
else:
assert False, 'WTF?!'
other = BatchList(f).exclude(tgt)[0]
if other.dead: return act
if user_input([other],
ChooseOptionInputlet(self,
('inherit', 'draw'))) == 'inherit':
g.process_action(HeritageAction(other, tgt))
else:
g.process_action(DrawCards(other, 2))
return act
def handle(self, evt_type, act):
if evt_type == 'action_apply' and isinstance(act, PlayerDeath):
g = Game.getgame()
T = Identity.TYPE
tgt = act.target
dead = lambda p: p.dead or p is tgt
# curtain's win
survivors = [p for p in g.players if not dead(p)]
if len(survivors) == 1:
pl = g.players
pl.reveal([p.identity for p in g.players])
if survivors[0].identity.type == T.CURTAIN:
g.winners = survivors[:]
g.game_end()
deads = defaultdict(list)
for p in g.players:
if dead(p):
deads[p.identity.type].append(p)
def winner(*identities):
pl = g.players
pl.reveal([p.identity for p in g.players])
g.winners = [p for p in pl if p.identity.type in identities]
g.game_end()
def no(identity):
return len(deads[identity]) == g.identities.count(identity)
# attackers' & curtain's win
if len(deads[T.BOSS]):
if g.double_curtain:
winner(T.ATTACKER)
else:
if no(T.ATTACKER):
winner(T.CURTAIN)
else:
winner(T.ATTACKER)
# boss & accomplices' win
if no(T.ATTACKER) and no(T.CURTAIN):
winner(T.BOSS, T.ACCOMPLICE)
# all survivors dropped
if all([p.dropped for p in survivors]):
pl = g.players
pl.reveal([p.identity for p in pl])
g.winners = []
g.game_end()
elif evt_type == 'action_after' and isinstance(act, PlayerDeath):
T = Identity.TYPE
g = Game.getgame()
tgt = act.target
src = act.source
if src:
if tgt.identity.type == T.ATTACKER:
g.process_action(DrawCards(src, 3))
elif tgt.identity.type == T.ACCOMPLICE:
if src.identity.type == T.BOSS:
g.players.exclude(src).reveal(list(src.cards))
cards = []
cards.extend(src.cards)
cards.extend(src.showncards)
cards.extend(src.equips)
cards and g.process_action(DropCards(src, src, cards))
return act
def apply_action(self):
g = Game.getgame()
from cards import Deck
g.deck = Deck()
g.ehclasses = list(action_eventhandlers) + g.game_ehs.values()
H, M, A = Identity.TYPE.HAKUREI, Identity.TYPE.MORIYA, Identity.TYPE.ADMIN
idlist = [A, H, H, M, M]
del H, M, A
pl = g.players[1:]
seed = sync_primitive(g.random.getrandbits(32), g.players)
random.Random(seed).shuffle(pl)
g.players[1:] = pl
g.emit_event('reseat', None)
for p, identity in zip(g.players, idlist):
p.identity = Identity()
p.identity.type = identity
g.process_action(RevealIdentity(p, g.players))
force_hakurei = BatchList(g.players[1:3])
force_moriya = BatchList(g.players[3:5])
g.forces = BatchList([force_hakurei, force_moriya])
from . import characters
g.switch_character(g.players[0], CharChoice(characters.koakuma.Koakuma))
g.koakuma = koakuma = g.players[0]
koakuma.tags['books'] = g.total_books
koakuma.maxlife += 4
koakuma.life += 4
# choose girls -->
chars = characters.get_characters('book')
try:
chars.remove(characters.koakuma.Koakuma)
except:
pass
g.random.shuffle(chars)
testing = list(settings.TESTING_CHARACTERS)
testing = filter_out(chars, lambda c: c.__name__ in testing)
chars = g.random.sample(chars, 24)
if Game.SERVER_SIDE:
choices = [CharChoice(cls) for cls in chars[-20:]]
else:
choices = [CharChoice(None) for _ in xrange(20)]
del chars[-20:]
for p in g.players[1:]:
c = choices[-4:]
del choices[-4:]
akari = CharChoice(characters.akari.Akari)
akari.real_cls = chars.pop()
c.append(akari)
c.extend([CharChoice(cls) for cls in testing])
p.choices = c
p.reveal(c)
pl = g.players[1:]
mapping = {p: p.choices for p in pl}
with InputTransaction('ChooseGirl', pl, mapping=mapping) as trans:
ilet = ChooseGirlInputlet(g, mapping)
ilet.with_post_process(lambda p, rst: trans.notify('girl_chosen', (p, rst)) or rst)
rst = user_input(pl, ilet, timeout=30, type='all', trans=trans)
for p in pl:
c = rst[p] or p.choices[0]
g.switch_character(p, c)
g.emit_event('game_begin', g)
for p in g.players:
g.process_action(DistributeCards(p, amount=4))
pl = g.players
for i, idx in enumerate(cycle(range(len(pl)))):
if i >= 6000: break
p = pl[idx]
if p.dead:
g.process_action(PlayerRevive(p, p, 2))
g.process_action(DrawCards(p, 2))
continue
g.emit_event('player_turn', p)
try:
g.process_action(PlayerTurn(p))
except InterruptActionFlow:
pass
def apply_action(self):
g = Game.getgame()
g.process_action(DrawCards(self.target, amount=2))
return True
def apply_action(self):
g = Game.getgame()
tgt = self.target
g.process_action(DrawCards(tgt, 1))
return True
def apply_action(self):
return Game.getgame().process_action(DrawCards(self.target, 1))
def apply_action(self):
g = Game.getgame()
params = self.params
from cards import Deck
g.deck = Deck()
g.ehclasses = []
if params['random_seat']:
seed = get_seed_for(g.players)
random.Random(seed).shuffle(g.players)
g.emit_event('reseat', None)
for i, p in enumerate(g.players):
p.identity = Identity()
p.identity.type = (Identity.TYPE.HAKUREI,
Identity.TYPE.MORIYA)[i % 2]
g.forces = forces = BatchList([BatchList(), BatchList()])
for i, p in enumerate(g.players):
f = i % 2
p.force = f
forces[f].append(p)
pl = g.players
for p in pl:
g.process_action(RevealIdentity(p, pl))
# choose girls -->
from . import characters
chars = characters.get_characters('3v3')
seed = get_seed_for(g.players)
random.Random(seed).shuffle(chars)
# ANCHOR(test)
testing = list(settings.TESTING_CHARACTERS)
testing = filter_out(chars, lambda c: c.__name__ in testing)
chars.extend(testing)
choices = [CharChoice(cls) for cls in chars[-16:]]
del chars[-12:]
for c in choices[:4]:
c.char_cls = characters.akari.Akari
if Game.SERVER_SIDE:
for c, cls in zip(choices[:4],
g.random.sample(chars,
4)): # yes, must random.sample
c.real_cls = cls
# ----- roll ------
roll = range(len(g.players))
g.random.shuffle(roll)
pl = g.players
roll = sync_primitive(roll, pl)
roll = [pl[i] for i in roll]
g.emit_event('game_roll', roll)
first = roll[0]
g.emit_event('game_roll_result', first)
# ----
first_index = g.players.index(first)
order_list = (0, 5, 3, 4, 2, 1)
n = len(order_list)
order = [g.players[(first_index + i) % n] for i in order_list]
# akaris = {} # DO NOT USE DICT! THEY ARE UNORDERED!
akaris = []
mapping = {p: choices for p in g.players}
with InputTransaction('ChooseGirl', g.players,
mapping=mapping) as trans:
for p in order:
c = user_input([p],
ChooseGirlInputlet(g, mapping),
timeout=30,
trans=trans)
c = c or [_c for _c in choices if not _c.chosen][0]
c.chosen = p
if issubclass(c.char_cls, characters.akari.Akari):
akaris.append((p, c))
else:
g.set_character(p, c.char_cls)
trans.notify('girl_chosen', (p, c))
# reveal akaris
if akaris:
for p, c in akaris:
c.char_cls = c.real_cls
g.players.reveal([i[1] for i in akaris])
for p, c in akaris:
g.set_character(p, c.char_cls)
# -------
for p in g.players:
log.info(
u'>> Player: %s:%s %s',
p.__class__.__name__,
Identity.TYPE.rlookup(p.identity.type),
p.account.username,
)
# -------
first = g.players[first_index]
g.emit_event('game_begin', g)
for p in g.players:
g.process_action(DrawCards(p, amount=3 if p is first else 4))
pl = g.players.rotate_to(first)
for i, p in enumerate(cycle(pl)):
if i >= 6000: break
if not p.dead:
g.emit_event('player_turn', p)
try:
g.process_action(PlayerTurn(p))
except InterruptActionFlow:
pass
return True
