864 lines
32 KiB
Python
864 lines
32 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from datetime import UTC, datetime, timedelta
|
|
from typing import override
|
|
|
|
from app.database import Room
|
|
from app.database.beatmap import Beatmap
|
|
from app.database.playlists import Playlist
|
|
from app.dependencies.database import engine
|
|
from app.exception import InvokeException
|
|
from app.log import logger
|
|
from app.models.mods import APIMod
|
|
from app.models.multiplayer_hub import (
|
|
BeatmapAvailability,
|
|
ForceGameplayStartCountdown,
|
|
GameplayAbortReason,
|
|
MatchRequest,
|
|
MatchServerEvent,
|
|
MultiplayerClientState,
|
|
MultiplayerRoom,
|
|
MultiplayerRoomSettings,
|
|
MultiplayerRoomUser,
|
|
PlaylistItem,
|
|
ServerMultiplayerRoom,
|
|
StartMatchCountdownRequest,
|
|
StopCountdownRequest,
|
|
)
|
|
from app.models.room import (
|
|
DownloadState,
|
|
MatchType,
|
|
MultiplayerRoomState,
|
|
MultiplayerUserState,
|
|
RoomCategory,
|
|
RoomStatus,
|
|
)
|
|
from app.models.score import GameMode
|
|
|
|
from .hub import Client, Hub
|
|
|
|
from sqlalchemy import update
|
|
from sqlmodel import col, select
|
|
from sqlmodel.ext.asyncio.session import AsyncSession
|
|
|
|
GAMEPLAY_LOAD_TIMEOUT = 30
|
|
|
|
|
|
class MultiplayerHub(Hub[MultiplayerClientState]):
|
|
@override
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.rooms: dict[int, ServerMultiplayerRoom] = {}
|
|
|
|
@staticmethod
|
|
def group_id(room: int) -> str:
|
|
return f"room:{room}"
|
|
|
|
@override
|
|
def create_state(self, client: Client) -> MultiplayerClientState:
|
|
return MultiplayerClientState(
|
|
connection_id=client.connection_id,
|
|
connection_token=client.connection_token,
|
|
)
|
|
|
|
async def CreateRoom(self, client: Client, room: MultiplayerRoom):
|
|
logger.info(f"[MultiplayerHub] {client.user_id} creating room")
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id != 0:
|
|
raise InvokeException("You are already in a room")
|
|
async with AsyncSession(engine) as session:
|
|
async with session:
|
|
db_room = Room(
|
|
name=room.settings.name,
|
|
category=RoomCategory.NORMAL,
|
|
type=room.settings.match_type,
|
|
queue_mode=room.settings.queue_mode,
|
|
auto_skip=room.settings.auto_skip,
|
|
auto_start_duration=int(
|
|
room.settings.auto_start_duration.total_seconds()
|
|
),
|
|
host_id=client.user_id,
|
|
status=RoomStatus.IDLE,
|
|
)
|
|
session.add(db_room)
|
|
await session.commit()
|
|
await session.refresh(db_room)
|
|
item = room.playlist[0]
|
|
item.owner_id = client.user_id
|
|
room.room_id = db_room.id
|
|
starts_at = db_room.starts_at
|
|
await Playlist.add_to_db(item, db_room.id, session)
|
|
server_room = ServerMultiplayerRoom(
|
|
room=room,
|
|
category=RoomCategory.NORMAL,
|
|
start_at=starts_at,
|
|
hub=self,
|
|
)
|
|
self.rooms[room.room_id] = server_room
|
|
await server_room.set_handler()
|
|
return await self.JoinRoomWithPassword(
|
|
client, room.room_id, room.settings.password
|
|
)
|
|
|
|
async def JoinRoom(self, client: Client, room_id: int):
|
|
return self.JoinRoomWithPassword(client, room_id, "")
|
|
|
|
async def JoinRoomWithPassword(self, client: Client, room_id: int, password: str):
|
|
logger.info(f"[MultiplayerHub] {client.user_id} joining room {room_id}")
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id != 0:
|
|
raise InvokeException("You are already in a room")
|
|
user = MultiplayerRoomUser(user_id=client.user_id)
|
|
if room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[room_id]
|
|
room = server_room.room
|
|
for u in room.users:
|
|
if u.user_id == client.user_id:
|
|
raise InvokeException("You are already in this room")
|
|
if room.settings.password != password:
|
|
raise InvokeException("Incorrect password")
|
|
if room.host is None:
|
|
# from CreateRoom
|
|
room.host = user
|
|
store.room_id = room_id
|
|
await self.broadcast_group_call(self.group_id(room_id), "UserJoined", user)
|
|
room.users.append(user)
|
|
self.add_to_group(client, self.group_id(room_id))
|
|
await server_room.match_type_handler.handle_join(user)
|
|
return room
|
|
|
|
async def ChangeBeatmapAvailability(
|
|
self, client: Client, beatmap_availability: BeatmapAvailability
|
|
):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
availability = user.availability
|
|
if (
|
|
availability.state == beatmap_availability.state
|
|
and availability.progress == beatmap_availability.progress
|
|
):
|
|
return
|
|
user.availability = beatmap_availability
|
|
await self.broadcast_group_call(
|
|
self.group_id(store.room_id),
|
|
"UserBeatmapAvailabilityChanged",
|
|
user.user_id,
|
|
(beatmap_availability),
|
|
)
|
|
|
|
async def AddPlaylistItem(self, client: Client, item: PlaylistItem):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
await server_room.queue.add_item(
|
|
item,
|
|
user,
|
|
)
|
|
|
|
async def EditPlaylistItem(self, client: Client, item: PlaylistItem):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
await server_room.queue.edit_item(
|
|
item,
|
|
user,
|
|
)
|
|
|
|
async def RemovePlaylistItem(self, client: Client, item_id: int):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
await server_room.queue.remove_item(
|
|
item_id,
|
|
user,
|
|
)
|
|
|
|
async def setting_changed(self, room: ServerMultiplayerRoom, beatmap_changed: bool):
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"SettingsChanged",
|
|
(room.room.settings),
|
|
)
|
|
|
|
async def playlist_added(self, room: ServerMultiplayerRoom, item: PlaylistItem):
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"PlaylistItemAdded",
|
|
(item),
|
|
)
|
|
|
|
async def playlist_removed(self, room: ServerMultiplayerRoom, item_id: int):
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"PlaylistItemRemoved",
|
|
item_id,
|
|
)
|
|
|
|
async def playlist_changed(
|
|
self, room: ServerMultiplayerRoom, item: PlaylistItem, beatmap_changed: bool
|
|
):
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"PlaylistItemChanged",
|
|
(item),
|
|
)
|
|
|
|
async def ChangeUserStyle(
|
|
self, client: Client, beatmap_id: int | None, ruleset_id: int | None
|
|
):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
await self.change_user_style(
|
|
beatmap_id,
|
|
ruleset_id,
|
|
server_room,
|
|
user,
|
|
)
|
|
|
|
async def validate_styles(self, room: ServerMultiplayerRoom):
|
|
if not room.queue.current_item.freestyle:
|
|
for user in room.room.users:
|
|
await self.change_user_style(
|
|
None,
|
|
None,
|
|
room,
|
|
user,
|
|
)
|
|
async with AsyncSession(engine) as session:
|
|
beatmap = await session.get(Beatmap, room.queue.current_item.beatmap_id)
|
|
if beatmap is None:
|
|
raise InvokeException("Beatmap not found")
|
|
beatmap_ids = (
|
|
await session.exec(
|
|
select(Beatmap.id, Beatmap.mode).where(
|
|
Beatmap.beatmapset_id == beatmap.beatmapset_id,
|
|
)
|
|
)
|
|
).all()
|
|
for user in room.room.users:
|
|
beatmap_id = user.beatmap_id
|
|
ruleset_id = user.ruleset_id
|
|
user_beatmap = next(
|
|
(b for b in beatmap_ids if b[0] == beatmap_id),
|
|
None,
|
|
)
|
|
if beatmap_id is not None and user_beatmap is None:
|
|
beatmap_id = None
|
|
beatmap_ruleset = user_beatmap[1] if user_beatmap else beatmap.mode
|
|
if (
|
|
ruleset_id is not None
|
|
and beatmap_ruleset != GameMode.OSU
|
|
and ruleset_id != beatmap_ruleset
|
|
):
|
|
ruleset_id = None
|
|
await self.change_user_style(
|
|
beatmap_id,
|
|
ruleset_id,
|
|
room,
|
|
user,
|
|
)
|
|
|
|
for user in room.room.users:
|
|
is_valid, valid_mods = room.queue.current_item.validate_user_mods(
|
|
user, user.mods
|
|
)
|
|
if not is_valid:
|
|
await self.change_user_mods(valid_mods, room, user)
|
|
|
|
async def change_user_style(
|
|
self,
|
|
beatmap_id: int | None,
|
|
ruleset_id: int | None,
|
|
room: ServerMultiplayerRoom,
|
|
user: MultiplayerRoomUser,
|
|
):
|
|
if user.beatmap_id == beatmap_id and user.ruleset_id == ruleset_id:
|
|
return
|
|
|
|
if beatmap_id is not None or ruleset_id is not None:
|
|
if not room.queue.current_item.freestyle:
|
|
raise InvokeException("Current item does not allow free user styles.")
|
|
|
|
async with AsyncSession(engine) as session:
|
|
item_beatmap = await session.get(
|
|
Beatmap, room.queue.current_item.beatmap_id
|
|
)
|
|
if item_beatmap is None:
|
|
raise InvokeException("Item beatmap not found")
|
|
|
|
user_beatmap = (
|
|
item_beatmap
|
|
if beatmap_id is None
|
|
else await session.get(Beatmap, beatmap_id)
|
|
)
|
|
|
|
if user_beatmap is None:
|
|
raise InvokeException("Invalid beatmap selected.")
|
|
|
|
if user_beatmap.beatmapset_id != item_beatmap.beatmapset_id:
|
|
raise InvokeException(
|
|
"Selected beatmap is not from the same beatmap set."
|
|
)
|
|
|
|
if (
|
|
ruleset_id is not None
|
|
and user_beatmap.mode != GameMode.OSU
|
|
and ruleset_id != user_beatmap.mode
|
|
):
|
|
raise InvokeException(
|
|
"Selected ruleset is not supported for the given beatmap."
|
|
)
|
|
|
|
user.beatmap_id = beatmap_id
|
|
user.ruleset_id = ruleset_id
|
|
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"UserStyleChanged",
|
|
user.user_id,
|
|
beatmap_id,
|
|
ruleset_id,
|
|
)
|
|
|
|
async def ChangeUserMods(self, client: Client, new_mods: list[APIMod]):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
await self.change_user_mods(new_mods, server_room, user)
|
|
|
|
async def change_user_mods(
|
|
self,
|
|
new_mods: list[APIMod],
|
|
room: ServerMultiplayerRoom,
|
|
user: MultiplayerRoomUser,
|
|
):
|
|
is_valid, valid_mods = room.queue.current_item.validate_user_mods(
|
|
user, new_mods
|
|
)
|
|
if not is_valid:
|
|
incompatible_mods = [
|
|
mod["acronym"] for mod in new_mods if mod not in valid_mods
|
|
]
|
|
raise InvokeException(
|
|
f"Incompatible mods were selected: {','.join(incompatible_mods)}"
|
|
)
|
|
|
|
if user.mods == valid_mods:
|
|
return
|
|
|
|
user.mods = valid_mods
|
|
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"UserModsChanged",
|
|
user.user_id,
|
|
valid_mods,
|
|
)
|
|
|
|
async def validate_user_stare(
|
|
self,
|
|
room: ServerMultiplayerRoom,
|
|
old: MultiplayerUserState,
|
|
new: MultiplayerUserState,
|
|
):
|
|
match new:
|
|
case MultiplayerUserState.IDLE:
|
|
if old.is_playing:
|
|
raise InvokeException(
|
|
"Cannot return to idle without aborting gameplay."
|
|
)
|
|
case MultiplayerUserState.READY:
|
|
if old != MultiplayerUserState.IDLE:
|
|
raise InvokeException(f"Cannot change state from {old} to {new}")
|
|
if room.queue.current_item.expired:
|
|
raise InvokeException(
|
|
"Cannot ready up while all items have been played."
|
|
)
|
|
case MultiplayerUserState.WAITING_FOR_LOAD:
|
|
raise InvokeException("Cannot change state from {old} to {new}")
|
|
case MultiplayerUserState.LOADED:
|
|
if old != MultiplayerUserState.WAITING_FOR_LOAD:
|
|
raise InvokeException(f"Cannot change state from {old} to {new}")
|
|
case MultiplayerUserState.READY_FOR_GAMEPLAY:
|
|
if old != MultiplayerUserState.LOADED:
|
|
raise InvokeException(f"Cannot change state from {old} to {new}")
|
|
case MultiplayerUserState.PLAYING:
|
|
raise InvokeException("State is managed by the server.")
|
|
case MultiplayerUserState.FINISHED_PLAY:
|
|
if old != MultiplayerUserState.PLAYING:
|
|
raise InvokeException(f"Cannot change state from {old} to {new}")
|
|
case MultiplayerUserState.RESULTS:
|
|
raise InvokeException("Cannot change state from {old} to {new}")
|
|
case MultiplayerUserState.SPECTATING:
|
|
if old not in (MultiplayerUserState.IDLE, MultiplayerUserState.READY):
|
|
raise InvokeException(f"Cannot change state from {old} to {new}")
|
|
|
|
async def ChangeState(self, client: Client, state: MultiplayerUserState):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
if user.state == state:
|
|
return
|
|
match state:
|
|
case MultiplayerUserState.IDLE:
|
|
if user.state.is_playing:
|
|
return
|
|
case MultiplayerUserState.LOADED | MultiplayerUserState.READY_FOR_GAMEPLAY:
|
|
if not user.state.is_playing:
|
|
return
|
|
await self.validate_user_stare(
|
|
server_room,
|
|
user.state,
|
|
state,
|
|
)
|
|
await self.change_user_state(server_room, user, state)
|
|
if state == MultiplayerUserState.SPECTATING and (
|
|
room.state == MultiplayerRoomState.PLAYING
|
|
or room.state == MultiplayerRoomState.WAITING_FOR_LOAD
|
|
):
|
|
await self.call_noblock(client, "LoadRequested")
|
|
await self.update_room_state(server_room)
|
|
|
|
async def change_user_state(
|
|
self,
|
|
room: ServerMultiplayerRoom,
|
|
user: MultiplayerRoomUser,
|
|
state: MultiplayerUserState,
|
|
):
|
|
user.state = state
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"UserStateChanged",
|
|
user.user_id,
|
|
user.state,
|
|
)
|
|
|
|
async def update_room_state(self, room: ServerMultiplayerRoom):
|
|
match room.room.state:
|
|
case MultiplayerRoomState.WAITING_FOR_LOAD:
|
|
played_count = len(
|
|
[True for user in room.room.users if user.state.is_playing]
|
|
)
|
|
ready_count = len(
|
|
[
|
|
True
|
|
for user in room.room.users
|
|
if user.state == MultiplayerUserState.READY_FOR_GAMEPLAY
|
|
]
|
|
)
|
|
if played_count == ready_count:
|
|
await self.start_gameplay(room)
|
|
case MultiplayerRoomState.PLAYING:
|
|
if all(
|
|
u.state != MultiplayerUserState.PLAYING for u in room.room.users
|
|
):
|
|
for u in filter(
|
|
lambda u: u.state == MultiplayerUserState.FINISHED_PLAY,
|
|
room.room.users,
|
|
):
|
|
await self.change_user_state(
|
|
room, u, MultiplayerUserState.RESULTS
|
|
)
|
|
await self.change_room_state(room, MultiplayerRoomState.OPEN)
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"ResultsReady",
|
|
)
|
|
await room.queue.finish_current_item()
|
|
|
|
async def change_room_state(
|
|
self, room: ServerMultiplayerRoom, state: MultiplayerRoomState
|
|
):
|
|
room.room.state = state
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"RoomStateChanged",
|
|
state,
|
|
)
|
|
|
|
async def StartMatch(self, client: Client):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
if room.host is None or room.host.user_id != client.user_id:
|
|
raise InvokeException("You are not the host of this room")
|
|
if any(u.state != MultiplayerUserState.READY for u in room.users):
|
|
raise InvokeException("Not all users are ready")
|
|
|
|
await self.start_match(server_room)
|
|
|
|
async def start_match(self, room: ServerMultiplayerRoom):
|
|
if room.room.state != MultiplayerRoomState.OPEN:
|
|
raise InvokeException("Can't start match when already in a running state.")
|
|
if room.queue.current_item.expired:
|
|
raise InvokeException("Current playlist item is expired")
|
|
ready_users = [
|
|
u
|
|
for u in room.room.users
|
|
if u.availability.state == DownloadState.LOCALLY_AVAILABLE
|
|
and (
|
|
u.state == MultiplayerUserState.READY
|
|
or u.state == MultiplayerUserState.IDLE
|
|
)
|
|
]
|
|
await asyncio.gather(
|
|
*[
|
|
self.change_user_state(room, u, MultiplayerUserState.WAITING_FOR_LOAD)
|
|
for u in ready_users
|
|
]
|
|
)
|
|
await self.change_room_state(
|
|
room,
|
|
MultiplayerRoomState.WAITING_FOR_LOAD,
|
|
)
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"LoadRequested",
|
|
)
|
|
await room.start_countdown(
|
|
ForceGameplayStartCountdown(
|
|
remaining=timedelta(seconds=GAMEPLAY_LOAD_TIMEOUT)
|
|
),
|
|
self.start_gameplay,
|
|
)
|
|
|
|
async def start_gameplay(self, room: ServerMultiplayerRoom):
|
|
if room.room.state != MultiplayerRoomState.WAITING_FOR_LOAD:
|
|
raise InvokeException("Room is not ready for gameplay")
|
|
if room.queue.current_item.expired:
|
|
raise InvokeException("Current playlist item is expired")
|
|
playing = False
|
|
for user in room.room.users:
|
|
client = self.get_client_by_id(str(user.user_id))
|
|
if client is None:
|
|
continue
|
|
|
|
if user.state in (
|
|
MultiplayerUserState.READY_FOR_GAMEPLAY,
|
|
MultiplayerUserState.LOADED,
|
|
):
|
|
playing = True
|
|
await self.change_user_state(room, user, MultiplayerUserState.PLAYING)
|
|
await self.call_noblock(client, "GameplayStarted")
|
|
elif user.state == MultiplayerUserState.WAITING_FOR_LOAD:
|
|
await self.change_user_state(room, user, MultiplayerUserState.IDLE)
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"GameplayAborted",
|
|
GameplayAbortReason.LOAD_TOOK_TOO_LONG,
|
|
)
|
|
await self.change_room_state(
|
|
room,
|
|
(MultiplayerRoomState.PLAYING if playing else MultiplayerRoomState.OPEN),
|
|
)
|
|
|
|
async def send_match_event(
|
|
self, room: ServerMultiplayerRoom, event: MatchServerEvent
|
|
):
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"MatchEvent",
|
|
event,
|
|
)
|
|
|
|
async def make_user_leave(
|
|
self,
|
|
client: Client,
|
|
room: ServerMultiplayerRoom,
|
|
user: MultiplayerRoomUser,
|
|
kicked: bool = False,
|
|
):
|
|
self.remove_from_group(client, self.group_id(room.room.room_id))
|
|
room.room.users.remove(user)
|
|
|
|
if len(room.room.users) == 0:
|
|
await self.end_room(room)
|
|
await self.update_room_state(room)
|
|
if room.room.host and room.room.host.user_id == user.user_id:
|
|
next_host = room.room.users[0]
|
|
await self.set_host(room, next_host)
|
|
|
|
if kicked:
|
|
await self.call_noblock(client, "UserKicked", user)
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id), "UserKicked", user
|
|
)
|
|
else:
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id), "UserLeft", user
|
|
)
|
|
|
|
target_store = self.state.get(user.user_id)
|
|
if target_store:
|
|
target_store.room_id = 0
|
|
|
|
async def end_room(self, room: ServerMultiplayerRoom):
|
|
assert room.room.host
|
|
async with AsyncSession(engine) as session:
|
|
await session.execute(
|
|
update(Room)
|
|
.where(col(Room.id) == room.room.room_id)
|
|
.values(
|
|
name=room.room.settings.name,
|
|
ended_at=datetime.now(UTC),
|
|
type=room.room.settings.match_type,
|
|
queue_mode=room.room.settings.queue_mode,
|
|
auto_skip=room.room.settings.auto_skip,
|
|
auto_start_duration=int(
|
|
room.room.settings.auto_start_duration.total_seconds()
|
|
),
|
|
host_id=room.room.host.user_id,
|
|
)
|
|
)
|
|
del self.rooms[room.room.room_id]
|
|
|
|
async def LeaveRoom(self, client: Client):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
return
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
await self.make_user_leave(client, server_room, user)
|
|
|
|
async def KickUser(self, client: Client, user_id: int):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
|
|
if room.host is None or room.host.user_id != client.user_id:
|
|
raise InvokeException("You are not the host of this room")
|
|
|
|
user = next((u for u in room.users if u.user_id == user_id), None)
|
|
if user is None:
|
|
raise InvokeException("User not found in this room")
|
|
|
|
target_client = self.get_client_by_id(str(user.user_id))
|
|
if target_client is None:
|
|
return
|
|
await self.make_user_leave(target_client, server_room, user, kicked=True)
|
|
|
|
async def set_host(self, room: ServerMultiplayerRoom, user: MultiplayerRoomUser):
|
|
room.room.host = user
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"HostChanged",
|
|
user.user_id,
|
|
)
|
|
|
|
async def TransferHost(self, client: Client, user_id: int):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
|
|
if room.host is None or room.host.user_id != client.user_id:
|
|
raise InvokeException("You are not the host of this room")
|
|
|
|
new_host = next((u for u in room.users if u.user_id == user_id), None)
|
|
if new_host is None:
|
|
raise InvokeException("User not found in this room")
|
|
await self.set_host(server_room, new_host)
|
|
|
|
async def AbortGameplay(self, client: Client):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
if not user.state.is_playing:
|
|
raise InvokeException("Cannot abort gameplay while not in a gameplay state")
|
|
|
|
await self.change_user_state(
|
|
server_room,
|
|
user,
|
|
MultiplayerUserState.IDLE,
|
|
)
|
|
await self.update_room_state(server_room)
|
|
|
|
async def AbortMatch(self, client: Client):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
|
|
if room.host is None or room.host.user_id != client.user_id:
|
|
raise InvokeException("You are not the host of this room")
|
|
|
|
if (
|
|
room.state != MultiplayerRoomState.PLAYING
|
|
or room.state == MultiplayerRoomState.WAITING_FOR_LOAD
|
|
):
|
|
raise InvokeException("Room is not in a playable state")
|
|
|
|
await asyncio.gather(
|
|
*[
|
|
self.change_user_state(server_room, u, MultiplayerUserState.IDLE)
|
|
for u in room.users
|
|
if u.state.is_playing
|
|
]
|
|
)
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room_id),
|
|
"GameplayAborted",
|
|
GameplayAbortReason.HOST_ABORTED,
|
|
)
|
|
await self.update_room_state(server_room)
|
|
|
|
async def change_user_match_state(
|
|
self, room: ServerMultiplayerRoom, user: MultiplayerRoomUser
|
|
):
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"MatchUserStateChanged",
|
|
user.user_id,
|
|
user.match_state,
|
|
)
|
|
|
|
async def change_room_match_state(self, room: ServerMultiplayerRoom):
|
|
await self.broadcast_group_call(
|
|
self.group_id(room.room.room_id),
|
|
"MatchRoomStateChanged",
|
|
room.room.match_state,
|
|
)
|
|
|
|
async def ChangeSettings(self, client: Client, settings: MultiplayerRoomSettings):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
|
|
if room.host is None or room.host.user_id != client.user_id:
|
|
raise InvokeException("You are not the host of this room")
|
|
|
|
if room.state != MultiplayerRoomState.OPEN:
|
|
raise InvokeException("Cannot change settings while playing")
|
|
|
|
if settings.match_type == MatchType.PLAYLISTS:
|
|
raise InvokeException("Invalid match type selected")
|
|
|
|
previous_settings = room.settings
|
|
room.settings = settings
|
|
|
|
if previous_settings.match_type != settings.match_type:
|
|
await server_room.set_handler()
|
|
if previous_settings.queue_mode != settings.queue_mode:
|
|
await server_room.queue.update_queue_mode()
|
|
|
|
await self.setting_changed(server_room, beatmap_changed=False)
|
|
await self.update_room_state(server_room)
|
|
|
|
async def SendMatchRequest(self, client: Client, request: MatchRequest):
|
|
store = self.get_or_create_state(client)
|
|
if store.room_id == 0:
|
|
raise InvokeException("You are not in a room")
|
|
if store.room_id not in self.rooms:
|
|
raise InvokeException("Room does not exist")
|
|
server_room = self.rooms[store.room_id]
|
|
room = server_room.room
|
|
user = next((u for u in room.users if u.user_id == client.user_id), None)
|
|
if user is None:
|
|
raise InvokeException("You are not in this room")
|
|
|
|
if isinstance(request, StartMatchCountdownRequest):
|
|
# TODO: countdown
|
|
...
|
|
elif isinstance(request, StopCountdownRequest):
|
|
...
|
|
else:
|
|
await server_room.match_type_handler.handle_request(user, request)
|