def _draft_loop(self) -> None:
while not self._terminating.is_set():
try:
booster = self._booster_queue.get(timeout=2)
except Empty:
continue
self._current_booster = booster
self.send_message('booster',
booster=RawStrategy.serialize(
self._current_booster))
while not self._terminating.is_set():
try:
pick = self._pick_queue.get(timeout=2)
except Empty:
continue
if not self.perform_pick(pick):
self.send_error(
'invalid_pick',
pick=pick.serialize(),
)
continue
self._pick_counter += 1
self.send_message(
'pick',
pick=pick.serialize(),
booster=RawStrategy.serialize(self._current_booster),
pick_number=self._pick_counter,
)
DraftPick.objects.create(
seat=self._draft_seat,
pack_number=self._draft.pack_counter,
pick_number=self._current_booster.pick_number,
global_pick_number=self._pick_counter - 1,
pack=self._current_booster,
pick=pick,
)
self._current_booster.pick_number += 1
if self._current_booster.cubeables:
self.passing_to.give_booster(self._current_booster)
else:
self._draft.booster_empty(self._current_booster)
self._current_booster = None
self._draft.broadcast_message(
'booster_amount_update',
drafter=self._drafter.user.pk,
queue_size=self.booster_amount,
)
break
def to_representation(self, value):
if self.context.get('request') and strtobool(
self.context['request'].query_params.get('native', '0')):
if isinstance(value, Cardboard):
return value.name
if isinstance(value, Printing):
return value.id
return RawStrategy.serialize(value)
return self._model_serializer.serialize(value)
def __reduce__(self):
return (self._inflate, (
self.__class__,
self.cubeable.id if isinstance(self.cubeable, Printing) else
RawStrategy.serialize(self.cubeable),
type(self.cubeable),
self.node_parent,
self.values,
self._release_id,
self._get_additional_reduce(),
))
def _handle_add(self) -> None:
cardboard, accepted = SelectCardboardDialog.get_cardboard()
if not accepted:
return
self._lobby_view.lobby_model.set_options(
self._lobby_view.lobby.name,
{
'infinites':
RawStrategy.serialize(self._infinites +
Infinites((cardboard, ))),
},
)
def keyPressEvent(self, key_event: QtGui.QKeyEvent):
pressed_key = key_event.key()
if pressed_key == QtCore.Qt.Key_Delete and self._enabled:
item = self.currentItem()
if item is not None:
self._lobby_view.lobby_model.set_options(
self._lobby_view.lobby.name,
{
'infinites':
RawStrategy.serialize(self._infinites - Infinites(
(Context.db.cardboards[item.data(0)], ))),
},
)
else:
super().keyPressEvent(key_event)
def serialize(self) -> t.Mapping[str, t.Any]:
return {
'drafters': [
UserSerializer(drafter.user).data
for drafter in self._drafters.all
],
'pack_amount':
self._pack_amount,
'draft_format':
self._draft_format,
'pool_specification':
PoolSpecificationSerializer(self._pool_specification).data,
'infinites':
RawStrategy.serialize(self._infinites),
'reverse':
self._reverse,
}
def _on_booster_specification_value_change(self, option: str,
value: t.Any) -> None:
current_options = copy.copy(
self._lobby_view.lobby.game_options['pool_specification'])
current_options[self._current_specification_index][option] = value
if len(current_options) == 1 and current_options[0][
'type'] == CubeBoosterSpecification.__name__ and option == 'release':
Context.cube_api_client.release(value).then(
lambda release: self._lobby_view.lobby_model.set_options(
self._lobby_view.lobby.name,
{'infinites': RawStrategy.serialize(release.infinites)},
))
self._lobby_view.lobby_model.set_options(
self._lobby_view.lobby.name,
{'pool_specification': current_options},
)
class Sealed(Game):
name = 'sealed'
format: str = metaoptions.OptionsOption(options=Format.formats_map.keys(),
default=LimitedSideboard.name)
open_decks: bool = metaoptions.BooleanOption(default=False)
open_pools: bool = metaoptions.BooleanOption(default=False)
pool_specification: PoolSpecificationOptions = PoolSpecificationOption(
{
'CubeBoosterSpecification': {
'release': CubeReleaseOption(),
'size': metaoptions.IntegerOption(min=1, max=360, default=90),
'allow_intersection': metaoptions.BooleanOption(default=False),
'allow_repeat': metaoptions.BooleanOption(default=False),
'scale': metaoptions.BooleanOption(default=False),
},
'ExpansionBoosterSpecification': {
'expansion_code': ExpansionOption(),
},
'AllCardsBoosterSpecification': {
'respect_printings': metaoptions.BooleanOption(default=True),
},
'ChaosBoosterSpecification': {
'same': metaoptions.BooleanOption(default=False),
},
},
default_booster_specification='CubeBoosterSpecification',
)
infinites: t.Mapping[str, t.Any] = CardboardSetOption(
default=RawStrategy.serialize(
CardboardSet((db.cardboards[n] for n in (
'Plains',
'Island',
'Swamp',
'Mountain',
'Forest',
)))))
mirrored = metaoptions.BooleanOption(default=False)
tournament_options = TournamentOptions()
def __init__(
self,
options: t.Mapping[str, t.Any],
players: t.AbstractSet[AbstractUser],
callback: t.Callable[[], None],
):
super().__init__(options, players, callback)
tournament_type, tournament_config, match_type = TournamentOptions.deserialize_options(
self.tournament_options)
with transaction.atomic():
pool_specification = PoolSpecification.from_options(
self.pool_specification)
session = LimitedSession.objects.create(
game_type='sealed',
format=self.format,
open_decks=self.open_decks,
open_pools=self.open_pools,
pool_specification=pool_specification,
infinites=RawStrategy(db).deserialize(Infinites,
self.infinites),
tournament_type=tournament_type,
tournament_config=tournament_config,
match_type=match_type,
)
self._keys = {}
try:
for player, pool in zip(
players,
itertools.repeat(pool_specification.get_pool())
if self.mirrored else pool_specification.get_pools(
len(players))):
self._keys[player] = Pool.objects.create(
user=player,
session=session,
pool=pool,
).id
except GenerateBoosterException as e:
self._keys = {}
raise StartGameException(str(e))
@property
def keys(self) -> t.Mapping[AbstractUser, t.Union[str, int]]:
return self._keys
def start(self) -> None:
self._finished_callback()
def serialize(self) -> t.Mapping[str, t.Any]:
return {
'pool': self._pool,
'infinites': RawStrategy.serialize(self.infinites),
**super().serialize(),
}
class DraftGame(Game):
name = 'draft'
format: str = metaoptions.OptionsOption(
options=Format.formats_map.keys(),
default=LimitedSideboard.name,
)
open_decks: bool = metaoptions.BooleanOption(default=False)
open_pools: bool = metaoptions.BooleanOption(default=False)
reverse: bool = metaoptions.BooleanOption(default=False)
pool_specification: PoolSpecificationOptions = PoolSpecificationOption(
{
'CubeBoosterSpecification': {
'release': CubeReleaseOption(),
'size': metaoptions.IntegerOption(min=1, max=360, default=7),
'allow_intersection': metaoptions.BooleanOption(default=False),
'allow_repeat': metaoptions.BooleanOption(default=False),
'scale': metaoptions.BooleanOption(default=False),
},
'ExpansionBoosterSpecification': {
'expansion_code': ExpansionOption(),
},
'AllCardsBoosterSpecification': {
'respect_printings': metaoptions.BooleanOption(default=True),
},
'ChaosBoosterSpecification': {
'same': metaoptions.BooleanOption(default=False),
},
},
default_booster_specification='CubeBoosterSpecification',
default_amount=11,
)
draft_format: str = metaoptions.OptionsOption(
options={'single_pick', 'burn'}, default='single_pick')
infinites: t.Mapping[str, t.Any] = CardboardSetOption(
default=RawStrategy.serialize(
CardboardSet((db.cardboards[n] for n in (
'Plains',
'Island',
'Swamp',
'Mountain',
'Forest',
)))))
allow_cheating = metaoptions.BooleanOption(default=False)
tournament_options = TournamentOptions()
def __init__(
self,
options: t.Mapping[str, t.Any],
players: t.AbstractSet[AbstractUser],
callback: t.Callable[[], None],
):
super().__init__(options, players, callback)
self._pool_specification = PoolSpecification.from_options(
self.pool_specification)
self._keys = {
user: drafter.key
for user, drafter in DRAFT_COORDINATOR.start_draft(
users=random.sample(list(self._players), len(self._players)),
pool_specification=self._pool_specification,
infinites=RawStrategy(db).deserialize(Infinites,
self.infinites),
draft_format=self.draft_format,
reverse=self.reverse,
finished_callback=self._finished_callback_wrapper,
)
}
def _finished_callback_wrapper(self, draft: Draft):
self._finished_callback()
tournament_type, tournament_config, match_type = TournamentOptions.deserialize_options(
self.tournament_options)
session = LimitedSession.objects.create(
game_type='draft',
format=self.format,
open_decks=self.open_decks,
open_pools=self.open_pools,
pool_specification=self._pool_specification,
infinites=RawStrategy(db).deserialize(Infinites, self.infinites),
allow_cheating=self.allow_cheating,
tournament_type=tournament_type,
tournament_config=tournament_config,
match_type=match_type,
)
draft.draft_session.limited_session = session
draft.draft_session.save(update_fields=('limited_session', ))
if self.reverse:
drafters = list(draft.interfaces.items())
random.shuffle(drafters)
for ((drafter, interface),
(_, next_interface)) in zip(drafters,
drafters[1:] + [drafters[0]]):
pool = Pool.objects.create(
user=drafter.user,
session=session,
pool=next_interface.pool,
)
interface.send_message(
'completed',
pool_id=pool.id,
session_name=session.name,
)
else:
for drafter, interface in draft.interfaces.items():
pool = Pool.objects.create(
user=drafter.user,
session=session,
pool=interface.pool,
)
interface.send_message(
'completed',
pool_id=pool.id,
session_name=session.name,
)
@property
def keys(self) -> t.Mapping[AbstractUser, t.Union[str, int]]:
return self._keys
def start(self) -> None:
pass
def serialize_cardboard_cubeable(
cardboard_cubeable: CardboardCubeable) -> t.Any:
return cardboard_cubeable.name if isinstance(
cardboard_cubeable,
Cardboard) else RawStrategy.serialize(cardboard_cubeable)
def serialize_cubeable(cubeable: Cubeable) -> t.Any:
return cubeable.id if isinstance(
cubeable, Printing) else RawStrategy.serialize(cubeable)
