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