def _duplicate_session(sio: ServerApp, session: GameSession, new_title: str):
_verify_has_admin(sio, session.id, None)
current_user = sio.get_current_user()
_add_audit_entry(sio, session, f"Duplicated session as {new_title}")
with database.db.atomic():
new_session: GameSession = GameSession.create(
name=new_title,
password=session.password,
creator=current_user,
layout_description_json=session.layout_description_json,
seed_hash=session.seed_hash,
dev_features=session.dev_features,
)
for preset in session.presets:
assert isinstance(preset, GameSessionPreset)
GameSessionPreset.create(
session=new_session,
row=preset.row,
preset=preset.preset,
)
GameSessionMembership.create(
user=current_user,
session=new_session,
row=None,
admin=True,
connection_state="Offline",
)
GameSessionAudit.create(
session=new_session,
user=current_user,
message=f"Duplicated from {session.name}",
)
def _verify_has_admin(sio: ServerApp,
session_id: int,
admin_user_id: Optional[int],
*,
allow_when_no_admins: bool = False) -> None:
"""
Checks if the logged user can do admin operations to the given session,
:param session_id: The GameSessions id
:param admin_user_id: An user id that is exceptionally authorized for this
:param allow_when_no_admins: This action is authorized for non-admins if there are no admins.
:return:
"""
current_user = sio.get_current_user()
try:
current_membership = GameSessionMembership.get_by_ids(
current_user.id, session_id)
except peewee.DoesNotExist:
raise NotAuthorizedForAction()
if not (current_membership.admin or
(admin_user_id is not None and current_user.id == admin_user_id)):
if allow_when_no_admins and GameSessionMembership.select().where(
GameSessionMembership.session == session_id,
GameSessionMembership.admin == True).count() == 0:
return
raise NotAuthorizedForAction()
def game_session_self_update(sio: ServerApp, session_id: int, inventory: str,
game_connection_state: str):
current_user = sio.get_current_user()
membership = GameSessionMembership.get_by_ids(current_user.id, session_id)
membership.connection_state = f"Online, {game_connection_state}"
membership.inventory = inventory
membership.save()
_emit_session_update(membership.session)
def game_session_request_pickups(sio: ServerApp, session_id: int):
current_user = sio.get_current_user()
your_membership = GameSessionMembership.get_by_ids(current_user.id,
session_id)
session: GameSession = your_membership.session
if session.state == GameSessionState.SETUP:
logger().info(f"Session {session_id}, Row {your_membership.row} "
f"requested pickups, but session is setup.")
return None
if your_membership.is_observer:
logger().info(
f"Session {session_id}, {current_user.name} requested pickups, but is an observer."
)
return None
description = session.layout_description
row_to_member_name = {
member.row: member.effective_name
for member in GameSessionMembership.non_observer_members(session)
}
resource_database = _get_resource_database(description,
your_membership.row)
result = []
actions: List[GameSessionTeamAction] = list(
_query_for_actions(your_membership))
for action in actions:
pickup_target = _get_pickup_target(description, action.provider_row,
action.provider_location_index)
if pickup_target is None:
logging.error(
f"Action {action} has a location index with nothing.")
result.append(None)
else:
name = row_to_member_name.get(action.provider_row,
f"Player {action.provider_row + 1}")
result.append({
"provider_name":
name,
"pickup":
_base64_encode_pickup(pickup_target.pickup, resource_database),
})
logger().info(
f"Session {session_id}, Row {your_membership.row} "
f"requested pickups, returning {len(result)} elements for {resource_database.game_enum.value}."
)
return {
"game": resource_database.game_enum.value,
"pickups": result,
}
def disconnect_game_session(sio: ServerApp, session_id: int):
current_user = sio.get_current_user()
try:
current_membership = GameSessionMembership.get_by_ids(
current_user.id, session_id)
current_membership.connection_state = "Offline"
current_membership.save()
_emit_session_meta_update(current_membership.session)
except peewee.DoesNotExist:
pass
sio.leave_game_session()
def create_game_session(sio: ServerApp, session_name: str):
current_user = sio.get_current_user()
with database.db.atomic():
new_session = GameSession.create(
name=session_name,
password=None,
creator=current_user,
)
GameSessionPreset.create(
session=new_session,
row=0,
preset=json.dumps(PresetManager(None).default_preset.as_json))
membership = GameSessionMembership.create(user=sio.get_current_user(),
session=new_session,
row=0,
admin=True)
sio.join_game_session(membership)
return new_session.create_session_entry()
def game_session_request_update(sio: ServerApp, session_id: int):
current_user = sio.get_current_user()
session: GameSession = GameSession.get_by_id(session_id)
membership = GameSessionMembership.get_by_ids(current_user.id, session_id)
_emit_session_meta_update(session)
if session.layout_description is not None:
_emit_session_actions_update(session)
if not membership.is_observer and session.state != GameSessionState.SETUP:
_emit_game_session_pickups_update(sio, membership)
_emit_session_audit_update(session)
def _download_layout_description(sio: ServerApp, session: GameSession):
try:
# You must be a session member to do get the spoiler
GameSessionMembership.get_by_ids(sio.get_current_user().id, session.id)
except peewee.DoesNotExist:
raise NotAuthorizedForAction()
if session.layout_description_json is None:
raise InvalidAction("Session does not contain a game")
if not session.layout_description.permalink.spoiler:
raise InvalidAction("Session does not contain a spoiler")
return session.layout_description_json
def _update_layout_generation(sio: ServerApp, session: GameSession,
active: bool):
_verify_has_admin(sio, session.id, None)
_verify_in_setup(session)
if active:
if session.generation_in_progress is None:
session.generation_in_progress = sio.get_current_user()
else:
raise InvalidAction(
f"Generation already in progress by {session.generation_in_progress.name}."
)
else:
session.generation_in_progress = None
session.save()
def _change_layout_description(sio: ServerApp, session: GameSession,
description_json: Optional[dict]):
_verify_has_admin(sio, session.id, None)
_verify_in_setup(session)
rows_to_update = []
if description_json is None:
description = None
else:
if session.generation_in_progress != sio.get_current_user():
if session.generation_in_progress is None:
raise InvalidAction(f"Not waiting for a layout.")
else:
raise InvalidAction(
f"Waiting for a layout from {session.generation_in_progress.name}."
)
_verify_no_layout_description(session)
description = LayoutDescription.from_json_dict(description_json)
if description.player_count != session.num_rows:
raise InvalidAction(
f"Description is for a {description.player_count} players,"
f" while the session is for {session.num_rows}.")
for permalink_preset, preset_row in zip(description.all_presets,
session.presets):
preset_row = typing.cast(GameSessionPreset, preset_row)
if _get_preset(json.loads(
preset_row.preset)).get_preset() != permalink_preset:
preset = VersionedPreset.with_preset(permalink_preset)
if preset.game not in session.allowed_games:
raise InvalidAction(f"{preset.game} preset not allowed.")
preset_row.preset = json.dumps(preset.as_json)
rows_to_update.append(preset_row)
with database.db.atomic():
for preset_row in rows_to_update:
preset_row.save()
session.generation_in_progress = None
session.layout_description = description
session.save()
_add_audit_entry(
sio, session, "Removed generated game" if description is None else
f"Set game to {description.shareable_word_hash}")
def _change_layout_description(sio: ServerApp, session: GameSession,
description_json: Optional[dict]):
_verify_has_admin(sio, session.id, None)
_verify_in_setup(session)
rows_to_update = []
if description_json is None:
description = None
else:
if session.generation_in_progress != sio.get_current_user():
if session.generation_in_progress is None:
raise InvalidAction(f"Not waiting for a layout.")
else:
raise InvalidAction(
f"Waiting for a layout from {session.generation_in_progress.name}."
)
_verify_no_layout_description(session)
description = LayoutDescription.from_json_dict(description_json)
permalink = description.permalink
if permalink.player_count != session.num_rows:
raise InvalidAction(
f"Description is for a {permalink.player_count} players,"
f" while the session is for {session.num_rows}.")
for permalink_preset, preset_row in zip(permalink.presets.values(),
session.presets):
preset_row = typing.cast(GameSessionPreset, preset_row)
if _get_preset(json.loads(
preset_row.preset)).get_preset() != permalink_preset:
preset = VersionedPreset.with_preset(permalink_preset)
if preset.game != RandovaniaGame.PRIME2:
raise InvalidAction("Only Prime 2 presets allowed.")
preset_row.preset = json.dumps(preset.as_json)
rows_to_update.append(preset_row)
with database.db.atomic():
for preset_row in rows_to_update:
preset_row.save()
session.generation_in_progress = None
session.layout_description = description
session.save()
def _change_row(sio: ServerApp, session: GameSession, arg: Tuple[int, dict]):
if len(arg) != 2:
raise InvalidAction("Missing arguments.")
row_id, preset_json = arg
_verify_has_admin(sio, session.id, sio.get_current_user().id)
_verify_in_setup(session)
_verify_no_layout_description(session)
preset = _get_preset(preset_json)
try:
with database.db.atomic():
preset_row = GameSessionPreset.get(
GameSessionPreset.session == session,
GameSessionPreset.row == row_id)
preset_row.preset = json.dumps(preset.as_json)
preset_row.save()
except peewee.DoesNotExist:
raise InvalidAction(f"invalid row: {row_id}")
def game_session_collect_locations(sio: ServerApp, session_id: int,
pickup_locations: Tuple[int, ...]):
current_user = sio.get_current_user()
session: GameSession = database.GameSession.get_by_id(session_id)
membership = GameSessionMembership.get_by_ids(current_user.id, session_id)
if session.state != GameSessionState.IN_PROGRESS:
raise InvalidAction(
"Unable to collect locations of sessions that aren't in progress")
if membership.is_observer:
raise InvalidAction("Observers can't collect locations")
description = session.layout_description
receiver_players = set()
for location in pickup_locations:
receiver_player = _collect_location(session, membership, description,
location)
if receiver_player is not None:
receiver_players.add(receiver_player)
if not receiver_players:
return
for receiver_player in receiver_players:
try:
receiver_membership = GameSessionMembership.get_by_session_position(
session, row=receiver_player)
flask_socketio.emit(
"game_has_update", {
"session": session_id,
"row": receiver_player,
},
room=
f"game-session-{receiver_membership.session.id}-{receiver_membership.user.id}"
)
except peewee.DoesNotExist:
pass
_emit_session_update(session)
def join_game_session(sio: ServerApp, session_id: int,
password: Optional[str]):
session = GameSession.get_by_id(session_id)
if session.password is not None:
if password is None or _hash_password(password) != session.password:
raise WrongPassword()
elif password is not None:
raise WrongPassword()
membership = GameSessionMembership.get_or_create(
user=sio.get_current_user(),
session=session,
defaults={
"row": None,
"admin": False
})[0]
_emit_session_update(session)
sio.join_game_session(membership)
return session.create_session_entry()
def _change_row(sio: ServerApp, session: GameSession, arg: Tuple[int, dict]):
if len(arg) != 2:
raise InvalidAction("Missing arguments.")
row_id, preset_json = arg
_verify_has_admin(sio, session.id, sio.get_current_user().id)
_verify_in_setup(session)
_verify_no_layout_description(session)
preset = _get_preset(preset_json)
# if preset.game != RandovaniaGame.PRIME2:
# raise InvalidAction("Only Prime 2 presets allowed.")
try:
with database.db.atomic():
preset_row = GameSessionPreset.get(
GameSessionPreset.session == session,
GameSessionPreset.row == row_id)
preset_row.preset = json.dumps(preset.as_json)
logger().info(f"Session {session.id}: Changing row {row_id}.")
preset_row.save()
except peewee.DoesNotExist:
raise InvalidAction(f"invalid row: {row_id}")
def game_session_collect_locations(sio: ServerApp, session_id: int,
pickup_locations: Tuple[int, ...]):
current_user = sio.get_current_user()
session: GameSession = database.GameSession.get_by_id(session_id)
membership = GameSessionMembership.get_by_ids(current_user.id, session_id)
if session.state != GameSessionState.IN_PROGRESS:
raise InvalidAction(
"Unable to collect locations of sessions that aren't in progress")
if membership.is_observer:
raise InvalidAction("Observers can't collect locations")
logger().info(
f"{_describe_session(session, membership)} found items {pickup_locations}"
)
description = session.layout_description
receiver_players = set()
for location in pickup_locations:
receiver_player = _collect_location(session, membership, description,
location)
if receiver_player is not None:
receiver_players.add(receiver_player)
if not receiver_players:
return
for receiver_player in receiver_players:
try:
receiver_membership = GameSessionMembership.get_by_session_position(
session, row=receiver_player)
_emit_game_session_pickups_update(sio, receiver_membership)
except peewee.DoesNotExist:
pass
_emit_session_actions_update(session)
def game_session_admin_player(sio: ServerApp, session_id: int, user_id: int,
action: str, arg):
_verify_has_admin(sio, session_id, user_id)
action: SessionAdminUserAction = SessionAdminUserAction(action)
session: GameSession = database.GameSession.get_by_id(session_id)
membership = GameSessionMembership.get_by_ids(user_id, session_id)
if action == SessionAdminUserAction.KICK:
_add_audit_entry(
sio, session, f"Kicked {membership.effective_name}"
if membership.user != sio.get_current_user() else "Left session")
membership.delete_instance()
if not list(session.players):
session.delete_instance(recursive=True)
logger().info(
f"{_describe_session(session)}. Kicking user {user_id} and deleting session."
)
else:
logger().info(
f"{_describe_session(session)}. Kicking user {user_id}.")
elif action == SessionAdminUserAction.MOVE:
offset: int = arg
if membership.is_observer is None:
raise InvalidAction("Player is an observer")
new_row = membership.row + offset
if new_row < 0:
raise InvalidAction("New position is negative")
if new_row >= session.num_rows:
raise InvalidAction("New position is beyond num of rows")
team_members = [None] * session.num_rows
for member in GameSessionMembership.non_observer_members(session):
team_members[member.row] = member
while (0 <= new_row <
session.num_rows) and team_members[new_row] is not None:
new_row += offset
if new_row < 0 or new_row >= session.num_rows:
raise InvalidAction("No empty slots found in this direction")
with database.db.atomic():
logger().info(
f"{_describe_session(session)}, User {user_id}. "
f"Performing {action}, new row is {new_row}, from {membership.row}."
)
membership.row = new_row
membership.save()
elif action == SessionAdminUserAction.SWITCH_IS_OBSERVER:
if membership.is_observer:
membership.row = _find_empty_row(session)
else:
membership.row = None
logger().info(
f"{_describe_session(session)}, User {user_id}. Performing {action}, "
f"new row is {membership.row}.")
membership.save()
elif action == SessionAdminUserAction.SWITCH_ADMIN:
# Must be admin for this
_verify_has_admin(sio, session_id, None, allow_when_no_admins=True)
num_admins = GameSessionMembership.select().where(
GameSessionMembership.session == session_id,
GameSessionMembership.admin == True).count()
if membership.admin and num_admins <= 1:
raise InvalidAction("can't demote the only admin")
membership.admin = not membership.admin
_add_audit_entry(
sio, session,
f"Made {membership.effective_name} {'' if membership.admin else 'not '}an admin"
)
logger().info(
f"{_describe_session(session)}, User {user_id}. Performing {action}, "
f"new status is {membership.admin}.")
membership.save()
elif action == SessionAdminUserAction.CREATE_PATCHER_FILE:
player_names = {i: f"Player {i + 1}" for i in range(session.num_rows)}
for member in GameSessionMembership.non_observer_members(session):
player_names[member.row] = member.effective_name
layout_description = session.layout_description
players_config = PlayersConfiguration(
player_index=membership.row,
player_names=player_names,
)
preset = layout_description.get_preset(players_config.player_index)
cosmetic_patches = preset.game.data.layout.cosmetic_patches.from_json(
arg)
_add_audit_entry(sio, session,
f"Made an ISO for row {membership.row + 1}")
data_factory = preset.game.patch_data_factory(layout_description,
players_config,
cosmetic_patches)
try:
return data_factory.create_data()
except Exception as e:
logger().exception("Error when creating patch data")
raise InvalidAction(f"Unable to export game: {e}")
elif action == SessionAdminUserAction.ABANDON:
# FIXME
raise InvalidAction("Abandon is NYI")
_emit_session_meta_update(session)
def _add_audit_entry(sio: ServerApp, session: GameSession, message: str):
GameSessionAudit.create(session=session,
user=sio.get_current_user(),
message=message)
_emit_session_audit_update(session)