def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, SpellCardAction):
if act.cancelled: return act # some other thing have done the job
if act.non_responsive:
return act
g = Game.getgame()
has_reject = False
while g.SERVER_SIDE:
from ..characters.baseclasses import Character
from ..characters.reimu import SpiritualAttack
for p in g.players:
if isinstance(p,
Character) and p.has_skill(SpiritualAttack):
has_reject = True
break
if has_reject: break
from .definition import RejectCard
for c in flatten([[p.cards, p.showncards] for p in g.players]):
if isinstance(c, RejectCard):
has_reject = True
break
break
has_reject = sync_primitive(has_reject, g.players)
if not has_reject: return act
self.target_act = act
pl = BatchList(p for p in g.players if not p.dead)
with InputTransaction('AskForRejectAction', pl) as trans:
p, rst = ask_for_action(self, pl, ('cards', 'showncards'), [],
trans)
if not p: return act
cards, _ = rst
assert cards and self.cond(cards)
g.process_action(
LaunchCard(p, [act.target], cards[0], Reject(p, act)))
return act
def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, SpellCardAction):
if act.cancelled: return act # some other thing have done the job
if act.non_responsive:
return act
g = Game.getgame()
has_reject = False
while g.SERVER_SIDE:
from ..characters.baseclasses import Character
from ..characters.reimu import SpiritualAttack
for p in g.players:
if isinstance(p, Character) and p.has_skill(SpiritualAttack):
has_reject = True
break
if has_reject: break
from .definition import RejectCard
for c in flatten([[p.cards, p.showncards] for p in g.players]):
if isinstance(c, RejectCard):
has_reject = True
break
break
has_reject = sync_primitive(has_reject, g.players)
if not has_reject: return act
self.target_act = act
pl = BatchList(p for p in g.players if not p.dead)
with InputTransaction('AskForRejectAction', pl) as trans:
p, rst = ask_for_action(self, pl, ('cards', 'showncards'), [], trans)
if not p: return act
cards, _ = rst
assert cards and self.cond(cards)
g.process_action(LaunchCard(p, [act.target], cards[0], Reject(p, act)))
return act
def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, SpellCardAction):
if act.cancelled: return act # some other thing have done the job
if isinstance(act, NonResponsiveInstantSpellCardAction):
return act
g = Game.getgame()
has_reject = False
while g.SERVER_SIDE:
from ..characters.reimu import Reimu
for p in g.players:
if isinstance(p, Reimu):
has_reject = True
break
if has_reject: break
from .definition import RejectCard
for c in flatten([[p.cards, p.showncards] for p in g.players]):
if isinstance(c, RejectCard):
has_reject = True
break
break
has_reject = sync_primitive(has_reject, g.players)
if not has_reject: return act
self.target_act = act # for ui
pl = BatchList(p for p in g.players if not p.dead)
p, rst = ask_for_action(self, pl, ['cards', 'showncards'], [])
if not p: return act
cards, _ = rst
assert cards and self.cond(cards)
g.process_action(LaunchReject(p, act, cards[0]))
return act
def handle(self, evt_type, act):
if evt_type == 'action_before' and isinstance(act, SpellCardAction):
if act.cancelled: return act # some other thing have done the job
if isinstance(act, NonResponsiveInstantSpellCardAction):
return act
g = Game.getgame()
has_reject = False
while g.SERVER_SIDE:
from ..characters.reimu import Reimu
for p in g.players:
if isinstance(p, Reimu):
has_reject = True
break
if has_reject: break
from .definition import RejectCard
for c in flatten([[p.cards, p.showncards] for p in g.players]):
if isinstance(c, RejectCard):
has_reject = True
break
break
has_reject = sync_primitive(has_reject, g.players)
if not has_reject: return act
self.target_act = act # for ui
pl = BatchList(p for p in g.players if not p.dead)
p, rst = ask_for_action(self, pl, ['cards', 'showncards'], [])
if not p: return act
cards, _ = rst
assert cards and self.cond(cards)
g.process_action(LaunchReject(p, act, cards[0]))
return act
def game_start(g):
# game started, init state
from cards import Deck
g.deck = Deck()
g.ehclasses = []
for i, p in enumerate(g.players):
p.identity = Identity()
p.identity.type = (Identity.TYPE.HAKUREI, Identity.TYPE.MORIYA)[i % 2]
# choose girls -->
from characters import characters as chars
from characters.akari import Akari
_chars = g.random.sample(chars, 10)
if Game.SERVER_SIDE:
choice = [CharChoice(cls) for cls in _chars[-10:]]
for c in g.random.sample(choice, 4):
c.real_cls = c.char_cls
c.char_cls = Akari
elif Game.CLIENT_SIDE:
choice = [CharChoice(None) for i in xrange(10)]
# -----------
g.players.reveal(choice)
# 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]
second = roll[1]
g.emit_event('game_roll_result', first)
# ----
# akaris = {} # DO NOT USE DICT! THEY ARE UNORDERED!
akaris = []
A, B = first, second
order = [A, B, B, A, A, B, B, A, A, B]
A.choices = []
B.choices = []
choice_mapping = {A: choice, B: choice}
del A, B
with InputTransaction('ChooseGirl', g.players, mapping=choice_mapping) as trans:
for p in order:
c = user_input([p], ChooseGirlInputlet(g, choice_mapping), 10, 'single', trans)
if not c:
# first non-chosen char
for c in choice:
if not c.chosen:
c.chosen = p
break
if issubclass(c.char_cls, Akari):
akaris.append((p, c))
c.chosen = p
p.choices.append(c)
trans.notify('girl_chosen', c)
# reveal akaris for themselves
for p, c in akaris:
c.char_cls = c.real_cls
p.reveal(c)
for p in g.players:
seed = get_seed_for(p)
random.Random(seed).shuffle(p.choices)
mapping = {first: first.choices, second: second.choices}
rst = user_input(g.players, KOFSortInputlet(g, mapping), timeout=30, type='all')
for p in g.players:
perm = p.choices
perm = [ # weird snap for debug
perm[i]
for i in
rst[p]
[:3]
]
p.characters = [c.char_cls for c in perm]
del p.choices
first = g.next_character(first)
second = g.next_character(second)
order = [0, 1] if first is g.players[0] else [1, 0]
try:
pl = g.players
for p in pl:
g.process_action(RevealIdentity(p, pl))
g.emit_event('game_begin', g)
for p in pl:
g.process_action(DrawCards(p, amount=3 if p is first else 4))
for i, idx in enumerate(cycle(order)):
p = g.players[idx]
if i >= 6000: break
if p.dead:
assert p.characters # if not holds true, DeathHandler should end game.
KOFCharacterSwitchHandler.do_switch()
assert not p.dead
try:
g.emit_event('player_turn', p)
g.process_action(PlayerTurn(p))
except InterruptActionFlow:
pass
except GameEnded:
pass
def apply_action(self):
g = Game.getgame()
from . import cards
g.pick_history = []
g.deck = cards.Deck(cards.kof_card_definition)
g.ehclasses = []
g.current_player = None
for i, p in enumerate(g.players):
p.identity = Identity()
p.identity.type = (Identity.TYPE.HAKUREI, Identity.TYPE.MORIYA)[i % 2]
# choose girls -->
from characters import get_characters
chars = get_characters("kof")
testing = list(settings.TESTING_CHARACTERS)
testing = filter_out(chars, lambda c: c.__name__ in testing)
_chars = g.random.sample(chars, 10)
_chars.extend(testing)
from characters.akari import Akari
if Game.SERVER_SIDE:
choice = [CharChoice(cls) for cls in _chars[-10:]]
for c in g.random.sample(choice, 4):
c.real_cls = c.char_cls
c.char_cls = Akari
elif Game.CLIENT_SIDE:
choice = [CharChoice(None) for i in xrange(10)]
# -----------
g.players.reveal(choice)
# 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]
second = roll[1]
g.emit_event("game_roll_result", first)
# ----
# akaris = {} # DO NOT USE DICT! THEY ARE UNORDERED!
akaris = []
A, B = first, second
order = [A, B, B, A, A, B, B, A, A, B]
A.choices = []
B.choices = []
A.remaining = [2]
B.remaining = [2]
choice_mapping = {A: choice, B: choice}
del A, B
with InputTransaction("ChooseGirl", g.players, mapping=choice_mapping) as trans:
for p in order:
c = user_input([p], ChooseGirlInputlet(g, choice_mapping), 10, "single", trans)
if not c:
# first non-chosen char
for c in choice:
if not c.chosen:
c.chosen = p
break
if issubclass(c.char_cls, Akari):
akaris.append((p, c))
c.chosen = p
p.choices.append(c)
trans.notify("girl_chosen", (p, c))
# reveal akaris for themselves
for p, c in akaris:
c.char_cls = c.real_cls
p.reveal(c)
for c in choice:
del c.chosen
list_shuffle(first.choices, first)
list_shuffle(second.choices, second)
mapping = {first: first.choices, second: second.choices}
with InputTransaction("ChooseGirl", g.players, 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, type="all", trans=trans)
def s(p):
c = rst[p] or p.choices[0]
p = g.next_character(p, c)
p.choices.remove(c)
return p
first, second = s(first), s(second)
order = [1, 0] if first is g.players[0] else [0, 1]
pl = g.players
for p in pl:
g.process_action(RevealIdentity(p, pl))
g.emit_event("game_begin", g)
for p in pl:
g.process_action(DistributeCards(p, amount=4 if p is first else 3))
for i in order:
g.emit_event("character_debut", (None, g.players[i]))
for i, idx in enumerate(cycle(order)):
p = g.players[idx]
if i >= 6000:
break
if p.dead:
KOFCharacterSwitchHandler.do_switch_dead()
p = g.players[idx] # player changed
assert not p.dead
try:
g.emit_event("player_turn", p)
g.process_action(PlayerTurn(p))
except InterruptActionFlow:
pass
def apply_action(self):
g = Game.getgame()
from . import cards
g.pick_history = []
g.deck = cards.Deck(cards.kof_card_definition)
g.ehclasses = []
g.current_player = None
for i, p in enumerate(g.players):
p.identity = Identity()
p.identity.type = (Identity.TYPE.HAKUREI,
Identity.TYPE.MORIYA)[i % 2]
# choose girls -->
from characters import get_characters
chars = get_characters('kof')
testing = list(settings.TESTING_CHARACTERS)
testing = filter_out(chars, lambda c: c.__name__ in testing)
_chars = g.random.sample(chars, 10)
_chars.extend(testing)
from characters.akari import Akari
if Game.SERVER_SIDE:
choice = [CharChoice(cls) for cls in _chars[-10:]]
for c in g.random.sample(choice, 4):
c.real_cls = c.char_cls
c.char_cls = Akari
elif Game.CLIENT_SIDE:
choice = [CharChoice(None) for i in xrange(10)]
# -----------
g.players.reveal(choice)
# 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]
second = roll[1]
g.emit_event('game_roll_result', first)
# ----
# akaris = {} # DO NOT USE DICT! THEY ARE UNORDERED!
akaris = []
A, B = first, second
order = [A, B, B, A, A, B, B, A, A, B]
A.choices = []
B.choices = []
A.remaining = [2]
B.remaining = [2]
choice_mapping = {A: choice, B: choice}
del A, B
with InputTransaction('ChooseGirl', g.players,
mapping=choice_mapping) as trans:
for p in order:
c = user_input([p], ChooseGirlInputlet(g, choice_mapping), 10,
'single', trans)
if not c:
# first non-chosen char
for c in choice:
if not c.chosen:
c.chosen = p
break
if issubclass(c.char_cls, Akari):
akaris.append((p, c))
c.chosen = p
p.choices.append(c)
trans.notify('girl_chosen', (p, c))
# reveal akaris for themselves
for p, c in akaris:
c.char_cls = c.real_cls
p.reveal(c)
for c in choice:
del c.chosen
list_shuffle(first.choices, first)
list_shuffle(second.choices, second)
mapping = {first: first.choices, second: second.choices}
with InputTransaction('ChooseGirl', g.players,
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, type='all', trans=trans)
def s(p):
c = rst[p] or p.choices[0]
p = g.next_character(p, c)
p.choices.remove(c)
return p
first, second = s(first), s(second)
order = [1, 0] if first is g.players[0] else [0, 1]
pl = g.players
for p in pl:
g.process_action(RevealIdentity(p, pl))
g.emit_event('game_begin', g)
for p in pl:
g.process_action(DistributeCards(p, amount=4 if p is first else 3))
for i in order:
g.emit_event('character_debut', (None, g.players[i]))
for i, idx in enumerate(cycle(order)):
p = g.players[idx]
if i >= 6000: break
if p.dead:
KOFCharacterSwitchHandler.do_switch_dead()
p = g.players[idx] # player changed
assert not p.dead
try:
g.emit_event('player_turn', p)
g.process_action(PlayerTurn(p))
except InterruptActionFlow:
pass
def game_start(g):
# game started, init state
from cards import Deck
g.deck = Deck()
g.ehclasses = []
for i, p in enumerate(g.players):
p.identity = Identity()
p.identity.type = (Identity.TYPE.HAKUREI,
Identity.TYPE.MORIYA)[i % 2]
# choose girls -->
from characters import characters as chars
from characters.akari import Akari
_chars = g.random.sample(chars, 10)
if Game.SERVER_SIDE:
choice = [CharChoice(cls) for cls in _chars[-10:]]
for c in g.random.sample(choice, 4):
c.real_cls = c.char_cls
c.char_cls = Akari
elif Game.CLIENT_SIDE:
choice = [CharChoice(None) for i in xrange(10)]
# -----------
g.players.reveal(choice)
# 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]
second = roll[1]
g.emit_event('game_roll_result', first)
# ----
# akaris = {} # DO NOT USE DICT! THEY ARE UNORDERED!
akaris = []
A, B = first, second
order = [A, B, B, A, A, B, B, A, A, B]
A.choices = []
B.choices = []
choice_mapping = {A: choice, B: choice}
del A, B
with InputTransaction('ChooseGirl', g.players,
mapping=choice_mapping) as trans:
for p in order:
c = user_input([p], ChooseGirlInputlet(g, choice_mapping), 10,
'single', trans)
if not c:
# first non-chosen char
for c in choice:
if not c.chosen:
c.chosen = p
break
if issubclass(c.char_cls, Akari):
akaris.append((p, c))
c.chosen = p
p.choices.append(c)
trans.notify('girl_chosen', c)
# reveal akaris for themselves
for p, c in akaris:
c.char_cls = c.real_cls
p.reveal(c)
for p in g.players:
seed = get_seed_for(p)
random.Random(seed).shuffle(p.choices)
mapping = {first: first.choices, second: second.choices}
rst = user_input(g.players,
KOFSortInputlet(g, mapping),
timeout=30,
type='all')
for p in g.players:
perm = p.choices
perm = [ # weird snap for debug
perm[i] for i in rst[p][:3]
]
p.characters = [c.char_cls for c in perm]
del p.choices
first = g.next_character(first)
second = g.next_character(second)
order = [0, 1] if first is g.players[0] else [1, 0]
try:
pl = g.players
for p in pl:
g.process_action(RevealIdentity(p, pl))
g.emit_event('game_begin', g)
for p in pl:
g.process_action(DrawCards(p, amount=3 if p is first else 4))
for i, idx in enumerate(cycle(order)):
p = g.players[idx]
if i >= 6000: break
if p.dead:
assert p.characters # if not holds true, DeathHandler should end game.
KOFCharacterSwitchHandler.do_switch()
assert not p.dead
try:
g.emit_event('player_turn', p)
g.process_action(PlayerTurn(p))
except InterruptActionFlow:
pass
except GameEnded:
pass