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_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 _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 _create_client_side_session(sio: ServerApp, user: Optional[User]) -> dict:
"""
:param user: If the session's user was already retrieved, pass it along to avoid an extra query.
:return:
"""
session = sio.get_session()
encrypted_session = sio.fernet_encrypt.encrypt(
json.dumps(session).encode("utf-8"))
if user is None:
user = User.get_by_id(session["user-id"])
elif user.id != session["user-id"]:
raise RuntimeError(f"Provided user does not match the session's user")
logger().info(
f"Client at {sio.current_client_ip()} is user {user.name} ({user.id})."
)
return {
"user":
user.as_json,
"sessions": [
membership.session.create_list_entry()
for membership in GameSessionMembership.select().where(
GameSessionMembership.user == user)
],
"encoded_session_b85":
base64.b85encode(encrypted_session),
}
def restore_user_session(sio: ServerApp, encrypted_session: bytes,
session_id: Optional[int]):
try:
decrypted_session: bytes = sio.fernet_encrypt.decrypt(
encrypted_session)
session = json.loads(decrypted_session.decode("utf-8"))
if "discord-access-token" in session:
user, result = _create_session_with_discord_token(
sio, session["discord-access-token"])
else:
user = User.get_by_id(session["user-id"])
sio.save_session(session)
result = _create_client_side_session(sio, user)
if session_id is not None:
sio.join_game_session(
GameSessionMembership.get_by_ids(user.id, session_id))
return result
except UserNotAuthorized:
raise
except (KeyError, peewee.DoesNotExist, json.JSONDecodeError,
InvalidTokenError) as e:
# InvalidTokenError: discord token expired and couldn't renew
logger().info("Client at %s was unable to restore session: (%s) %s",
sio.current_client_ip(), str(type(e)), str(e))
raise InvalidSession()
except Exception:
logger().exception("Error decoding user session")
raise InvalidSession()
def restore_user_session(sio: ServerApp, encrypted_session: bytes,
session_id: Optional[int]):
try:
decrypted_session: bytes = sio.fernet_encrypt.decrypt(
encrypted_session)
session = json.loads(decrypted_session.decode("utf-8"))
user = User.get_by_id(session["user-id"])
if "discord-access-token" in session:
# TODO: test if the discord access token is still valid
flask.session["DISCORD_OAUTH2_TOKEN"] = session[
"discord-access-token"]
sio.get_server().save_session(flask.request.sid, session)
if session_id is not None:
sio.join_game_session(
GameSessionMembership.get_by_ids(user.id, session_id))
return _create_client_side_session(sio, user)
except (KeyError, peewee.DoesNotExist, json.JSONDecodeError):
raise InvalidSession()
except Exception:
logger().exception("Error decoding user session")
raise InvalidSession()
def _find_empty_row(session: GameSession) -> int:
possible_rows = set(range(session.num_rows))
for member in GameSessionMembership.non_observer_members(session):
possible_rows.remove(member.row)
for empty_row in sorted(possible_rows):
return empty_row
raise InvalidAction("Session is full")
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 _delete_row(sio: ServerApp, session: GameSession, row_id: int):
_verify_has_admin(sio, session.id, None)
_verify_in_setup(session)
_verify_no_layout_description(session)
if session.num_rows < 2:
raise InvalidAction("Can't delete row when there's only one")
if row_id != session.num_rows - 1:
raise InvalidAction(f"Can only delete the last row")
with database.db.atomic():
GameSessionPreset.delete().where(
GameSessionPreset.session == session,
GameSessionPreset.row == row_id).execute()
GameSessionMembership.update(row=None).where(
GameSessionMembership.session == session.id,
GameSessionMembership.row == row_id,
).execute()
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 _find_empty_row(session: GameSession) -> int:
empty_row = 0
for possible_slot in GameSessionMembership.non_observer_members(session):
if empty_row != possible_slot.row:
break
else:
empty_row += 1
if empty_row >= session.num_rows:
raise InvalidAction("Session is full")
return empty_row
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 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 _emit_game_session_pickups_update(sio: ServerApp,
membership: GameSessionMembership):
session: GameSession = membership.session
if session.state == GameSessionState.SETUP:
raise RuntimeError("Unable to emit pickups during SETUP")
if membership.is_observer:
raise RuntimeError("Unable to emit pickups for observers")
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, membership.row)
result = []
actions: List[GameSessionTeamAction] = list(_query_for_actions(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"{_describe_session(session, membership)} "
f"notifying {resource_database.game_enum.value} of {len(result)} pickups."
)
data = {
"game": resource_database.game_enum.value,
"pickups": result,
}
flask_socketio.emit("game_session_pickups_update",
data,
room=f"game-session-{session.id}-{membership.user.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 _start_session(sio: ServerApp, session: GameSession):
_verify_has_admin(sio, session.id, None)
_verify_in_setup(session)
if session.layout_description_json is None:
raise InvalidAction("Unable to start session, no game is available.")
num_players = GameSessionMembership.select().where(
GameSessionMembership.session == session,
GameSessionMembership.row != None).count()
expected_players = session.num_rows
if num_players != expected_players:
raise InvalidAction(
f"Unable to start session, there are {num_players} but expected {expected_players} "
f"({session.num_rows} x {session.num_teams}).")
session.state = GameSessionState.IN_PROGRESS
session.save()
def report_user_disconnected(sio: ServerApp, user_id: int, log):
memberships: List[GameSessionMembership] = list(
GameSessionMembership.select().where(
GameSessionMembership.user == user_id))
log.info(
f"User {user_id} is disconnected, disconnecting from sessions: {memberships}"
)
sessions_to_update = []
for membership in memberships:
if membership.connection_state != "Offline":
membership.connection_state = "Offline"
sessions_to_update.append(membership.session)
membership.save()
for session in sessions_to_update:
_emit_session_meta_update(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 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 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 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:
membership.delete_instance()
if not list(session.players):
session.delete_instance(recursive=True)
logger().info(
f"Session {session_id}. Kicking user {user_id} and deleting session."
)
else:
logger().info(f"Session {session_id}. 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"Session {session_id}, 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"Session {session_id}, User {user_id}. Performing {action}, 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
logger().info(
f"Session {session_id}, User {user_id}. Performing {action}, new status is {membership.admin}."
)
membership.save()
elif action == SessionAdminUserAction.CREATE_PATCHER_FILE:
cosmetic_patches = CosmeticPatches.from_json_dict(arg)
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
players_config = PlayersConfiguration(
player_index=membership.row,
player_names=player_names,
)
return patcher_file.create_patcher_file(session.layout_description,
players_config,
cosmetic_patches)
elif action == SessionAdminUserAction.ABANDON:
# FIXME
raise InvalidAction("Abandon is NYI")
_emit_session_update(session)
