2020-12-19 00:14:50 +08:00
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
#nullable enable
2021-03-01 16:24:54 +08:00
using System ;
2021-02-01 16:54:56 +08:00
using System.Collections.Generic ;
2020-12-19 00:14:50 +08:00
using System.Diagnostics ;
using System.Linq ;
2022-03-17 18:26:42 +08:00
using System.Threading ;
2020-12-19 00:14:50 +08:00
using System.Threading.Tasks ;
using osu.Framework.Allocation ;
using osu.Framework.Bindables ;
2022-03-24 14:51:30 +08:00
using osu.Framework.Development ;
2022-01-03 16:02:15 +08:00
using osu.Framework.Extensions ;
2020-12-19 00:14:50 +08:00
using osu.Game.Online.API ;
2020-12-25 12:38:11 +08:00
using osu.Game.Online.Multiplayer ;
2022-03-17 18:26:42 +08:00
using osu.Game.Online.Multiplayer.Countdown ;
2021-08-02 16:06:01 +08:00
using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus ;
2021-01-03 09:32:50 +08:00
using osu.Game.Online.Rooms ;
2021-02-01 16:54:56 +08:00
using osu.Game.Rulesets.Mods ;
2021-11-04 17:02:44 +08:00
using APIUser = osu . Game . Online . API . Requests . Responses . APIUser ;
2020-12-19 00:14:50 +08:00
2020-12-25 12:38:11 +08:00
namespace osu.Game.Tests.Visual.Multiplayer
2020-12-19 00:14:50 +08:00
{
2021-06-25 17:02:53 +08:00
/// <summary>
/// A <see cref="MultiplayerClient"/> for use in multiplayer test scenes. Should generally not be used by itself outside of a <see cref="MultiplayerTestScene"/>.
/// </summary>
2021-05-20 14:39:45 +08:00
public class TestMultiplayerClient : MultiplayerClient
2020-12-19 00:14:50 +08:00
{
2020-12-19 00:16:00 +08:00
public override IBindable < bool > IsConnected = > isConnected ;
private readonly Bindable < bool > isConnected = new Bindable < bool > ( true ) ;
2020-12-19 00:14:50 +08:00
2022-04-01 17:31:17 +08:00
/// <summary>
/// The local client's <see cref="Room"/>. This is not always equivalent to the server-side room.
/// </summary>
2021-07-19 19:19:23 +08:00
public new Room ? APIRoom = > base . APIRoom ;
2022-04-01 17:31:17 +08:00
2021-04-22 22:22:44 +08:00
public Action < MultiplayerRoom > ? RoomSetupAction ;
2021-12-20 12:10:13 +08:00
public bool RoomJoined { get ; private set ; }
2020-12-19 00:14:50 +08:00
[Resolved]
private IAPIProvider api { get ; set ; } = null ! ;
2021-10-27 15:10:22 +08:00
private readonly TestMultiplayerRoomManager roomManager ;
2021-11-22 10:26:41 +08:00
/// <summary>
/// Guaranteed up-to-date playlist.
/// </summary>
2021-12-03 15:48:54 +08:00
private readonly List < MultiplayerPlaylistItem > serverSidePlaylist = new List < MultiplayerPlaylistItem > ( ) ;
2021-11-22 10:26:41 +08:00
2022-04-01 17:31:17 +08:00
/// <summary>
/// Guaranteed up-to-date API room.
/// </summary>
private Room ? serverSideAPIRoom ;
2021-11-22 10:26:41 +08:00
private MultiplayerPlaylistItem ? currentItem = > Room ? . Playlist [ currentIndex ] ;
2021-11-16 13:37:29 +08:00
private int currentIndex ;
2021-12-03 15:48:54 +08:00
private long lastPlaylistItemId ;
2021-10-27 15:10:22 +08:00
public TestMultiplayerClient ( TestMultiplayerRoomManager roomManager )
2021-03-03 18:40:19 +08:00
{
this . roomManager = roomManager ;
}
2020-12-19 00:16:00 +08:00
public void Connect ( ) = > isConnected . Value = true ;
public void Disconnect ( ) = > isConnected . Value = false ;
2021-11-04 17:02:44 +08:00
public MultiplayerRoomUser AddUser ( APIUser user , bool markAsPlaying = false )
2021-08-09 18:18:13 +08:00
{
var roomUser = new MultiplayerRoomUser ( user . Id ) { User = user } ;
2021-10-14 23:10:39 +08:00
addUser ( roomUser ) ;
2021-08-09 18:18:13 +08:00
if ( markAsPlaying )
PlayingUserIds . Add ( user . Id ) ;
return roomUser ;
}
2020-12-19 00:14:50 +08:00
2021-11-02 15:51:27 +08:00
public void TestAddUnresolvedUser ( ) = > addUser ( new MultiplayerRoomUser ( TestUserLookupCache . UNRESOLVED_USER_ID ) ) ;
2021-10-14 23:10:39 +08:00
private void addUser ( MultiplayerRoomUser user )
{
2022-01-03 16:02:15 +08:00
( ( IMultiplayerClient ) this ) . UserJoined ( user ) . WaitSafely ( ) ;
2021-10-14 23:10:39 +08:00
2021-10-14 23:20:45 +08:00
// We want the user to be immediately available for testing, so force a scheduler update to run the update-bound continuation.
2021-10-14 23:10:39 +08:00
Scheduler . Update ( ) ;
2021-11-11 15:39:59 +08:00
switch ( Room ? . MatchState )
{
case TeamVersusRoomState teamVersus :
Debug . Assert ( Room ! = null ) ;
// simulate the server's automatic assignment of users to teams on join.
// the "best" team is the one with the least users on it.
int bestTeam = teamVersus . Teams
. Select ( team = > ( teamID : team . ID , userCount : Room . Users . Count ( u = > ( u . MatchState as TeamVersusUserState ) ? . TeamID = = team . ID ) ) )
. OrderBy ( pair = > pair . userCount )
. First ( ) . teamID ;
2022-01-03 16:02:15 +08:00
( ( IMultiplayerClient ) this ) . MatchUserStateChanged ( user . UserID , new TeamVersusUserState { TeamID = bestTeam } ) . WaitSafely ( ) ;
2021-11-11 15:39:59 +08:00
break ;
}
2021-10-14 23:10:39 +08:00
}
2020-12-28 13:56:53 +08:00
2021-11-04 17:02:44 +08:00
public void RemoveUser ( APIUser user )
2020-12-19 00:14:50 +08:00
{
Debug . Assert ( Room ! = null ) ;
2020-12-24 04:00:47 +08:00
( ( IMultiplayerClient ) this ) . UserLeft ( new MultiplayerRoomUser ( user . Id ) ) ;
2020-12-19 00:14:50 +08:00
Schedule ( ( ) = >
{
if ( Room . Users . Any ( ) )
TransferHost ( Room . Users . First ( ) . UserID ) ;
} ) ;
}
2021-04-07 15:35:36 +08:00
public void ChangeRoomState ( MultiplayerRoomState newState )
{
Debug . Assert ( Room ! = null ) ;
( ( IMultiplayerClient ) this ) . RoomStateChanged ( newState ) ;
}
2020-12-19 00:14:50 +08:00
public void ChangeUserState ( int userId , MultiplayerUserState newState )
{
Debug . Assert ( Room ! = null ) ;
2022-03-17 18:26:42 +08:00
2020-12-19 00:14:50 +08:00
( ( IMultiplayerClient ) this ) . UserStateChanged ( userId , newState ) ;
2022-03-24 19:16:43 +08:00
updateRoomStateIfRequired ( ) ;
}
private void updateRoomStateIfRequired ( )
{
Debug . Assert ( Room ! = null ) ;
2022-03-24 19:19:05 +08:00
Debug . Assert ( APIRoom ! = null ) ;
2020-12-19 00:14:50 +08:00
Schedule ( ( ) = >
{
2021-10-22 20:16:10 +08:00
switch ( Room . State )
2020-12-19 00:14:50 +08:00
{
2022-03-17 18:26:42 +08:00
case MultiplayerRoomState . Open :
// If there are no remaining ready users or the host is not ready, stop any existing countdown.
// Todo: This doesn't yet support non-match-start countdowns.
2022-03-25 14:41:01 +08:00
if ( Room . Settings . AutoStartEnabled )
2022-03-24 19:19:05 +08:00
{
bool shouldHaveCountdown = ! APIRoom . Playlist . GetCurrentItem ( ) ! . Expired & & Room . Users . Any ( u = > u . State = = MultiplayerUserState . Ready ) ;
2022-03-25 16:04:45 +08:00
if ( shouldHaveCountdown & & Room . Countdown = = null )
startCountdown ( new MatchStartCountdown { TimeRemaining = Room . Settings . AutoStartDuration } , StartMatch ) ;
2022-03-24 19:19:05 +08:00
}
2022-03-17 18:26:42 +08:00
break ;
2021-10-22 20:16:10 +08:00
case MultiplayerRoomState . WaitingForLoad :
2020-12-19 00:14:50 +08:00
if ( Room . Users . All ( u = > u . State ! = MultiplayerUserState . WaitingForLoad ) )
{
2021-12-14 10:35:56 +08:00
var loadedUsers = Room . Users . Where ( u = > u . State = = MultiplayerUserState . Loaded ) . ToArray ( ) ;
if ( loadedUsers . Length = = 0 )
{
// all users have bailed from the load sequence. cancel the game start.
ChangeRoomState ( MultiplayerRoomState . Open ) ;
return ;
}
2020-12-19 00:14:50 +08:00
foreach ( var u in Room . Users . Where ( u = > u . State = = MultiplayerUserState . Loaded ) )
ChangeUserState ( u . UserID , MultiplayerUserState . Playing ) ;
( ( IMultiplayerClient ) this ) . MatchStarted ( ) ;
2021-10-22 20:16:10 +08:00
ChangeRoomState ( MultiplayerRoomState . Playing ) ;
2020-12-19 00:14:50 +08:00
}
break ;
2021-10-22 20:16:10 +08:00
case MultiplayerRoomState . Playing :
2020-12-19 00:14:50 +08:00
if ( Room . Users . All ( u = > u . State ! = MultiplayerUserState . Playing ) )
{
foreach ( var u in Room . Users . Where ( u = > u . State = = MultiplayerUserState . FinishedPlay ) )
ChangeUserState ( u . UserID , MultiplayerUserState . Results ) ;
2021-12-14 10:35:56 +08:00
ChangeRoomState ( MultiplayerRoomState . Open ) ;
2020-12-19 00:14:50 +08:00
( ( IMultiplayerClient ) this ) . ResultsReady ( ) ;
2021-10-22 21:07:41 +08:00
2022-01-03 16:02:15 +08:00
FinishCurrentItem ( ) . WaitSafely ( ) ;
2020-12-19 00:14:50 +08:00
}
break ;
}
} ) ;
}
2021-01-03 09:32:50 +08:00
public void ChangeUserBeatmapAvailability ( int userId , BeatmapAvailability newBeatmapAvailability )
{
Debug . Assert ( Room ! = null ) ;
( ( IMultiplayerClient ) this ) . UserBeatmapAvailabilityChanged ( userId , newBeatmapAvailability ) ;
}
2021-11-13 00:42:51 +08:00
protected override async Task < MultiplayerRoom > JoinRoom ( long roomId , string? password = null )
2020-12-19 00:14:50 +08:00
{
2022-04-01 17:31:17 +08:00
serverSideAPIRoom = roomManager . ServerSideRooms . Single ( r = > r . RoomID . Value = = roomId ) ;
2020-12-19 00:14:50 +08:00
2022-04-01 17:31:17 +08:00
if ( password ! = serverSideAPIRoom . Password . Value )
2021-07-19 19:01:44 +08:00
throw new InvalidOperationException ( "Invalid password." ) ;
2021-11-22 10:18:21 +08:00
serverSidePlaylist . Clear ( ) ;
2022-04-01 17:31:17 +08:00
serverSidePlaylist . AddRange ( serverSideAPIRoom . Playlist . Select ( item = > new MultiplayerPlaylistItem ( item ) ) ) ;
2021-12-03 15:48:54 +08:00
lastPlaylistItemId = serverSidePlaylist . Max ( item = > item . ID ) ;
2021-11-22 10:18:21 +08:00
2021-04-22 22:22:44 +08:00
var localUser = new MultiplayerRoomUser ( api . LocalUser . Value . Id )
2021-03-01 16:24:32 +08:00
{
User = api . LocalUser . Value
} ;
2020-12-19 00:14:50 +08:00
2021-03-01 16:24:32 +08:00
var room = new MultiplayerRoom ( roomId )
{
Settings =
{
2022-04-01 17:31:17 +08:00
Name = serverSideAPIRoom . Name . Value ,
MatchType = serverSideAPIRoom . Type . Value ,
2021-10-22 19:14:04 +08:00
Password = password ,
2022-04-01 17:31:17 +08:00
QueueMode = serverSideAPIRoom . QueueMode . Value ,
AutoStartDuration = serverSideAPIRoom . AutoStartDuration . Value
2021-03-01 16:24:32 +08:00
} ,
2021-11-22 10:18:21 +08:00
Playlist = serverSidePlaylist . ToList ( ) ,
2021-04-22 22:22:44 +08:00
Users = { localUser } ,
Host = localUser
2021-03-01 16:24:32 +08:00
} ;
2020-12-19 00:14:50 +08:00
2021-12-02 21:32:41 +08:00
await updatePlaylistOrder ( room ) . ConfigureAwait ( false ) ;
2021-11-16 13:37:29 +08:00
await updateCurrentItem ( room , false ) . ConfigureAwait ( false ) ;
2021-04-22 22:22:44 +08:00
RoomSetupAction ? . Invoke ( room ) ;
RoomSetupAction = null ;
2021-11-13 00:42:51 +08:00
return room ;
2020-12-19 00:14:50 +08:00
}
2021-08-03 16:08:19 +08:00
protected override void OnRoomJoined ( )
{
2021-11-13 01:32:20 +08:00
Debug . Assert ( APIRoom ! = null ) ;
2021-08-03 16:08:19 +08:00
Debug . Assert ( Room ! = null ) ;
// emulate the server sending this after the join room. scheduler required to make sure the join room event is fired first (in Join).
2022-01-03 16:02:15 +08:00
changeMatchType ( Room . Settings . MatchType ) . WaitSafely ( ) ;
2021-12-20 12:10:13 +08:00
RoomJoined = true ;
2021-08-03 16:08:19 +08:00
}
2021-12-20 12:10:13 +08:00
protected override Task LeaveRoomInternal ( )
{
RoomJoined = false ;
return Task . CompletedTask ;
}
2021-01-25 19:41:51 +08:00
2020-12-19 00:14:50 +08:00
public override Task TransferHost ( int userId ) = > ( ( IMultiplayerClient ) this ) . HostChanged ( userId ) ;
2021-08-11 16:20:41 +08:00
public override Task KickUser ( int userId )
{
Debug . Assert ( Room ! = null ) ;
2021-08-14 13:08:29 +08:00
return ( ( IMultiplayerClient ) this ) . UserKicked ( Room . Users . Single ( u = > u . UserID = = userId ) ) ;
2021-08-11 16:20:41 +08:00
}
2020-12-19 00:14:50 +08:00
public override async Task ChangeSettings ( MultiplayerRoomSettings settings )
{
Debug . Assert ( Room ! = null ) ;
2021-10-22 21:07:41 +08:00
Debug . Assert ( APIRoom ! = null ) ;
2021-11-13 00:42:51 +08:00
Debug . Assert ( currentItem ! = null ) ;
2021-10-22 21:07:41 +08:00
2021-11-11 22:39:15 +08:00
// Server is authoritative for the time being.
settings . PlaylistItemId = Room . Settings . PlaylistItemId ;
2020-12-19 00:14:50 +08:00
2021-11-13 00:42:51 +08:00
await changeQueueMode ( settings . QueueMode ) . ConfigureAwait ( false ) ;
await ( ( IMultiplayerClient ) this ) . SettingsChanged ( settings ) . ConfigureAwait ( false ) ;
foreach ( var user in Room . Users . Where ( u = > u . State = = MultiplayerUserState . Ready ) )
ChangeUserState ( user . UserID , MultiplayerUserState . Idle ) ;
await changeMatchType ( settings . MatchType ) . ConfigureAwait ( false ) ;
2022-03-24 19:16:43 +08:00
updateRoomStateIfRequired ( ) ;
2020-12-19 00:14:50 +08:00
}
public override Task ChangeState ( MultiplayerUserState newState )
{
2021-12-14 10:30:42 +08:00
Debug . Assert ( Room ! = null ) ;
if ( newState = = MultiplayerUserState . Idle & & LocalUser ? . State = = MultiplayerUserState . WaitingForLoad )
return Task . CompletedTask ;
2020-12-19 00:14:50 +08:00
ChangeUserState ( api . LocalUser . Value . Id , newState ) ;
return Task . CompletedTask ;
}
2021-01-03 09:32:50 +08:00
public override Task ChangeBeatmapAvailability ( BeatmapAvailability newBeatmapAvailability )
{
ChangeUserBeatmapAvailability ( api . LocalUser . Value . Id , newBeatmapAvailability ) ;
return Task . CompletedTask ;
}
2021-02-01 16:57:32 +08:00
public void ChangeUserMods ( int userId , IEnumerable < Mod > newMods )
= > ChangeUserMods ( userId , newMods . Select ( m = > new APIMod ( m ) ) . ToList ( ) ) ;
2021-02-01 16:54:56 +08:00
2021-02-01 16:57:32 +08:00
public void ChangeUserMods ( int userId , IEnumerable < APIMod > newMods )
2021-02-01 16:54:56 +08:00
{
Debug . Assert ( Room ! = null ) ;
2021-02-01 16:57:32 +08:00
( ( IMultiplayerClient ) this ) . UserModsChanged ( userId , newMods . ToList ( ) ) ;
2021-02-01 16:54:56 +08:00
}
2021-02-01 16:57:32 +08:00
public override Task ChangeUserMods ( IEnumerable < APIMod > newMods )
2021-02-01 16:54:56 +08:00
{
2021-02-01 16:57:32 +08:00
ChangeUserMods ( api . LocalUser . Value . Id , newMods ) ;
2021-02-01 16:54:56 +08:00
return Task . CompletedTask ;
}
2022-03-24 14:21:46 +08:00
private CancellationTokenSource ? countdownSkipSource ;
2022-03-17 18:26:42 +08:00
private CancellationTokenSource ? countdownStopSource ;
private Task countdownTask = Task . CompletedTask ;
2022-03-24 14:21:46 +08:00
/// <summary>
/// Skips to the end of the currently-running countdown, if one is running,
/// and runs the callback (e.g. to start the match) as soon as possible unless the countdown has been cancelled.
/// </summary>
public void SkipToEndOfCountdown ( ) = > countdownSkipSource ? . Cancel ( ) ;
2022-03-17 18:26:42 +08:00
2021-08-02 16:06:01 +08:00
public override async Task SendMatchRequest ( MatchUserRequest request )
{
Debug . Assert ( Room ! = null ) ;
Debug . Assert ( LocalUser ! = null ) ;
switch ( request )
{
2022-03-18 20:05:19 +08:00
case StartMatchCountdownRequest matchCountdownRequest :
2022-03-24 19:09:32 +08:00
startCountdown ( new MatchStartCountdown { TimeRemaining = matchCountdownRequest . Duration } , StartMatch ) ;
2022-03-17 18:26:42 +08:00
break ;
case StopCountdownRequest _ :
2022-03-24 19:13:58 +08:00
stopCountdown ( ) ;
2022-03-17 18:26:42 +08:00
break ;
2021-08-02 16:06:01 +08:00
case ChangeTeamRequest changeTeam :
TeamVersusRoomState roomState = ( TeamVersusRoomState ) Room . MatchState ! ;
TeamVersusUserState userState = ( TeamVersusUserState ) LocalUser . MatchState ! ;
var targetTeam = roomState . Teams . FirstOrDefault ( t = > t . ID = = changeTeam . TeamID ) ;
if ( targetTeam ! = null )
{
userState . TeamID = targetTeam . ID ;
await ( ( IMultiplayerClient ) this ) . MatchUserStateChanged ( LocalUser . UserID , userState ) . ConfigureAwait ( false ) ;
}
break ;
}
}
2021-07-21 18:13:56 +08:00
2022-03-24 19:09:32 +08:00
private void startCountdown ( MultiplayerCountdown countdown , Func < Task > continuation )
{
Debug . Assert ( Room ! = null ) ;
Debug . Assert ( ThreadSafety . IsUpdateThread ) ;
2022-03-24 19:13:58 +08:00
stopCountdown ( ) ;
2022-03-24 19:09:32 +08:00
// Note that this will leak CTSs, however this is a test method and we haven't noticed foregoing disposal of non-linked CTSs to be detrimental.
// If necessary, this can be moved into the final schedule below, and the class-level fields be nulled out accordingly.
var stopSource = countdownStopSource = new CancellationTokenSource ( ) ;
var skipSource = countdownSkipSource = new CancellationTokenSource ( ) ;
Task lastCountdownTask = countdownTask ;
countdownTask = start ( ) ;
async Task start ( )
{
await lastCountdownTask ;
Schedule ( ( ) = >
{
if ( stopSource . IsCancellationRequested )
return ;
Room . Countdown = countdown ;
MatchEvent ( new CountdownChangedEvent { Countdown = countdown } ) ;
} ) ;
try
{
using ( var cancellationSource = CancellationTokenSource . CreateLinkedTokenSource ( stopSource . Token , skipSource . Token ) )
await Task . Delay ( countdown . TimeRemaining , cancellationSource . Token ) . ConfigureAwait ( false ) ;
}
catch ( OperationCanceledException )
{
// Clients need to be notified of cancellations in the following code.
}
Schedule ( ( ) = >
{
if ( Room . Countdown ! = countdown )
return ;
Room . Countdown = null ;
MatchEvent ( new CountdownChangedEvent { Countdown = null } ) ;
if ( stopSource . IsCancellationRequested )
return ;
continuation ( ) . WaitSafely ( ) ;
} ) ;
}
}
2022-03-24 19:13:58 +08:00
private void stopCountdown ( ) = > countdownStopSource ? . Cancel ( ) ;
2022-03-24 14:07:01 +08:00
public override Task StartMatch ( )
2020-12-19 00:14:50 +08:00
{
Debug . Assert ( Room ! = null ) ;
2021-04-07 19:46:30 +08:00
ChangeRoomState ( MultiplayerRoomState . WaitingForLoad ) ;
2020-12-19 00:14:50 +08:00
foreach ( var user in Room . Users . Where ( u = > u . State = = MultiplayerUserState . Ready ) )
ChangeUserState ( user . UserID , MultiplayerUserState . WaitingForLoad ) ;
2022-03-24 14:07:01 +08:00
return ( ( IMultiplayerClient ) this ) . LoadRequested ( ) ;
2020-12-19 00:14:50 +08:00
}
2021-03-01 16:24:54 +08:00
2021-12-14 15:52:57 +08:00
public override Task AbortGameplay ( )
2021-12-14 10:30:42 +08:00
{
Debug . Assert ( Room ! = null ) ;
Debug . Assert ( LocalUser ! = null ) ;
ChangeUserState ( LocalUser . UserID , MultiplayerUserState . Idle ) ;
return Task . CompletedTask ;
}
2021-11-25 21:17:18 +08:00
public async Task AddUserPlaylistItem ( int userId , MultiplayerPlaylistItem item )
2021-10-22 15:48:28 +08:00
{
Debug . Assert ( Room ! = null ) ;
Debug . Assert ( APIRoom ! = null ) ;
2021-11-13 00:42:51 +08:00
Debug . Assert ( currentItem ! = null ) ;
2021-11-16 13:53:10 +08:00
if ( Room . Settings . QueueMode = = QueueMode . HostOnly & & Room . Host ? . UserID ! = LocalUser ? . UserID )
2021-11-13 00:42:51 +08:00
throw new InvalidOperationException ( "Local user is not the room host." ) ;
2021-10-22 15:48:28 +08:00
2021-12-02 21:32:41 +08:00
item . OwnerID = userId ;
2021-12-10 13:44:35 +08:00
await addItem ( item ) . ConfigureAwait ( false ) ;
await updateCurrentItem ( Room ) . ConfigureAwait ( false ) ;
2022-03-24 19:16:43 +08:00
updateRoomStateIfRequired ( ) ;
2021-12-10 13:44:35 +08:00
}
2021-11-16 13:37:29 +08:00
2021-12-10 13:44:35 +08:00
public override Task AddPlaylistItem ( MultiplayerPlaylistItem item ) = > AddUserPlaylistItem ( api . LocalUser . Value . OnlineID , item ) ;
2021-11-13 00:42:51 +08:00
2021-12-10 13:44:35 +08:00
public async Task EditUserPlaylistItem ( int userId , MultiplayerPlaylistItem item )
{
Debug . Assert ( Room ! = null ) ;
Debug . Assert ( APIRoom ! = null ) ;
Debug . Assert ( currentItem ! = null ) ;
2021-10-22 15:48:28 +08:00
2021-12-10 13:44:35 +08:00
item . OwnerID = userId ;
2021-11-16 13:37:29 +08:00
2021-12-10 13:44:35 +08:00
var existingItem = serverSidePlaylist . SingleOrDefault ( i = > i . ID = = item . ID ) ;
2021-12-10 00:03:36 +08:00
2021-12-10 13:44:35 +08:00
if ( existingItem = = null )
throw new InvalidOperationException ( "Attempted to change an item that doesn't exist." ) ;
if ( existingItem . OwnerID ! = userId & & Room . Host ? . UserID ! = LocalUser ? . UserID )
throw new InvalidOperationException ( "Attempted to change an item which is not owned by the user." ) ;
if ( existingItem . Expired )
throw new InvalidOperationException ( "Attempted to change an item which has already been played." ) ;
// Ensure the playlist order doesn't change.
item . PlaylistOrder = existingItem . PlaylistOrder ;
serverSidePlaylist [ serverSidePlaylist . IndexOf ( existingItem ) ] = item ;
await ( ( IMultiplayerClient ) this ) . PlaylistItemChanged ( item ) . ConfigureAwait ( false ) ;
2021-10-22 15:48:28 +08:00
}
2021-12-10 13:44:35 +08:00
public override Task EditPlaylistItem ( MultiplayerPlaylistItem item ) = > EditUserPlaylistItem ( api . LocalUser . Value . OnlineID , item ) ;
2021-11-25 21:17:18 +08:00
2021-12-09 01:12:33 +08:00
public async Task RemoveUserPlaylistItem ( int userId , long playlistItemId )
{
Debug . Assert ( Room ! = null ) ;
Debug . Assert ( APIRoom ! = null ) ;
2022-04-01 17:31:17 +08:00
Debug . Assert ( serverSideAPIRoom ! = null ) ;
2021-12-09 01:12:33 +08:00
var item = serverSidePlaylist . Find ( i = > i . ID = = playlistItemId ) ;
if ( item = = null )
throw new InvalidOperationException ( "Item does not exist in the room." ) ;
if ( item = = currentItem )
throw new InvalidOperationException ( "The room's current item cannot be removed." ) ;
if ( item . OwnerID ! = userId )
throw new InvalidOperationException ( "Attempted to remove an item which is not owned by the user." ) ;
2021-12-09 03:12:24 +08:00
if ( item . Expired )
2021-12-09 03:18:53 +08:00
throw new InvalidOperationException ( "Attempted to remove an item which has already been played." ) ;
2021-12-09 03:12:24 +08:00
2021-12-09 01:12:33 +08:00
serverSidePlaylist . Remove ( item ) ;
2022-04-01 17:31:17 +08:00
serverSideAPIRoom . Playlist . RemoveAll ( i = > i . ID = = item . ID ) ;
2021-12-09 01:12:33 +08:00
await ( ( IMultiplayerClient ) this ) . PlaylistItemRemoved ( playlistItemId ) . ConfigureAwait ( false ) ;
await updateCurrentItem ( Room ) . ConfigureAwait ( false ) ;
2022-03-24 19:16:43 +08:00
updateRoomStateIfRequired ( ) ;
2021-12-09 01:12:33 +08:00
}
public override Task RemovePlaylistItem ( long playlistItemId ) = > RemoveUserPlaylistItem ( api . LocalUser . Value . OnlineID , playlistItemId ) ;
2021-08-03 16:08:19 +08:00
private async Task changeMatchType ( MatchType type )
{
Debug . Assert ( Room ! = null ) ;
switch ( type )
{
case MatchType . HeadToHead :
await ( ( IMultiplayerClient ) this ) . MatchRoomStateChanged ( null ) . ConfigureAwait ( false ) ;
foreach ( var user in Room . Users )
await ( ( IMultiplayerClient ) this ) . MatchUserStateChanged ( user . UserID , null ) . ConfigureAwait ( false ) ;
break ;
case MatchType . TeamVersus :
await ( ( IMultiplayerClient ) this ) . MatchRoomStateChanged ( TeamVersusRoomState . CreateDefault ( ) ) . ConfigureAwait ( false ) ;
foreach ( var user in Room . Users )
await ( ( IMultiplayerClient ) this ) . MatchUserStateChanged ( user . UserID , new TeamVersusUserState ( ) ) . ConfigureAwait ( false ) ;
break ;
}
}
2021-10-22 21:07:41 +08:00
2021-11-16 13:53:10 +08:00
private async Task changeQueueMode ( QueueMode newMode )
2021-10-22 21:07:41 +08:00
{
2021-11-16 13:37:29 +08:00
Debug . Assert ( Room ! = null ) ;
2021-10-22 21:07:41 +08:00
Debug . Assert ( APIRoom ! = null ) ;
2021-11-13 00:42:51 +08:00
Debug . Assert ( currentItem ! = null ) ;
2021-10-22 21:07:41 +08:00
2021-11-22 10:10:08 +08:00
// When changing to host-only mode, ensure that at least one non-expired playlist item exists by duplicating the current item.
2021-11-22 10:18:21 +08:00
if ( newMode = = QueueMode . HostOnly & & serverSidePlaylist . All ( item = > item . Expired ) )
2021-11-22 10:10:08 +08:00
await duplicateCurrentItem ( ) . ConfigureAwait ( false ) ;
2021-10-22 21:07:41 +08:00
2021-12-02 21:32:41 +08:00
await updatePlaylistOrder ( Room ) . ConfigureAwait ( false ) ;
2021-11-16 13:37:29 +08:00
await updateCurrentItem ( Room ) . ConfigureAwait ( false ) ;
2021-10-22 21:07:41 +08:00
}
2021-12-01 17:44:46 +08:00
public async Task FinishCurrentItem ( )
2021-10-22 21:07:41 +08:00
{
Debug . Assert ( Room ! = null ) ;
Debug . Assert ( APIRoom ! = null ) ;
2021-11-13 00:42:51 +08:00
Debug . Assert ( currentItem ! = null ) ;
2021-10-22 21:07:41 +08:00
// Expire the current playlist item.
2021-11-13 02:34:45 +08:00
currentItem . Expired = true ;
2021-12-03 19:05:25 +08:00
currentItem . PlayedAt = DateTimeOffset . Now ;
2021-12-03 15:48:54 +08:00
2021-11-13 02:34:45 +08:00
await ( ( IMultiplayerClient ) this ) . PlaylistItemChanged ( currentItem ) . ConfigureAwait ( false ) ;
2021-12-03 15:48:54 +08:00
await updatePlaylistOrder ( Room ) . ConfigureAwait ( false ) ;
2021-10-22 21:07:41 +08:00
// In host-only mode, a duplicate playlist item will be used for the next round.
2021-12-03 15:48:54 +08:00
if ( Room . Settings . QueueMode = = QueueMode . HostOnly & & serverSidePlaylist . All ( item = > item . Expired ) )
2021-11-13 00:42:51 +08:00
await duplicateCurrentItem ( ) . ConfigureAwait ( false ) ;
2021-11-16 13:37:29 +08:00
await updateCurrentItem ( Room ) . ConfigureAwait ( false ) ;
2021-10-22 21:07:41 +08:00
}
2021-11-13 00:42:51 +08:00
private async Task duplicateCurrentItem ( )
2021-10-22 21:07:41 +08:00
{
2021-11-13 00:42:51 +08:00
Debug . Assert ( currentItem ! = null ) ;
2021-12-02 21:32:41 +08:00
await addItem ( new MultiplayerPlaylistItem
2021-11-13 00:42:51 +08:00
{
BeatmapID = currentItem . BeatmapID ,
2021-11-13 02:34:45 +08:00
BeatmapChecksum = currentItem . BeatmapChecksum ,
2021-11-13 00:42:51 +08:00
RulesetID = currentItem . RulesetID ,
2021-11-13 02:34:45 +08:00
RequiredMods = currentItem . RequiredMods ,
AllowedMods = currentItem . AllowedMods
2021-12-02 21:32:41 +08:00
} ) . ConfigureAwait ( false ) ;
}
2021-10-22 21:07:41 +08:00
2021-12-02 21:32:41 +08:00
private async Task addItem ( MultiplayerPlaylistItem item )
{
Debug . Assert ( Room ! = null ) ;
2022-04-01 17:31:17 +08:00
Debug . Assert ( serverSideAPIRoom ! = null ) ;
2021-12-02 21:32:41 +08:00
2021-12-03 15:48:54 +08:00
item . ID = + + lastPlaylistItemId ;
2021-12-06 14:09:06 +08:00
serverSidePlaylist . Add ( item ) ;
2022-04-01 17:31:17 +08:00
serverSideAPIRoom . Playlist . Add ( new PlaylistItem ( item ) ) ;
2021-12-02 21:32:41 +08:00
await ( ( IMultiplayerClient ) this ) . PlaylistItemAdded ( item ) . ConfigureAwait ( false ) ;
2021-12-06 14:09:06 +08:00
await updatePlaylistOrder ( Room ) . ConfigureAwait ( false ) ;
2021-11-13 00:42:51 +08:00
}
2021-12-09 03:18:53 +08:00
private IEnumerable < MultiplayerPlaylistItem > upcomingItems = > serverSidePlaylist . Where ( i = > ! i . Expired ) . OrderBy ( i = > i . PlaylistOrder ) ;
2021-11-16 13:37:29 +08:00
private async Task updateCurrentItem ( MultiplayerRoom room , bool notify = true )
2021-11-13 00:42:51 +08:00
{
2021-12-04 21:34:37 +08:00
// Pick the next non-expired playlist item by playlist order, or default to the most-recently-expired item.
2021-12-09 03:18:53 +08:00
MultiplayerPlaylistItem nextItem = upcomingItems . FirstOrDefault ( ) ? ? serverSidePlaylist . OrderByDescending ( i = > i . PlayedAt ) . First ( ) ;
2021-12-03 19:05:25 +08:00
2021-12-02 21:32:41 +08:00
currentIndex = serverSidePlaylist . IndexOf ( nextItem ) ;
long lastItem = room . Settings . PlaylistItemId ;
room . Settings . PlaylistItemId = nextItem . ID ;
if ( notify & & nextItem . ID ! = lastItem )
await ( ( IMultiplayerClient ) this ) . SettingsChanged ( room . Settings ) . ConfigureAwait ( false ) ;
}
private async Task updatePlaylistOrder ( MultiplayerRoom room )
{
2022-04-01 17:31:17 +08:00
Debug . Assert ( serverSideAPIRoom ! = null ) ;
2021-12-03 15:48:54 +08:00
List < MultiplayerPlaylistItem > orderedActiveItems ;
2021-11-13 00:42:51 +08:00
2021-11-16 13:37:29 +08:00
switch ( room . Settings . QueueMode )
2021-10-22 21:07:41 +08:00
{
2021-11-10 20:27:20 +08:00
default :
2021-12-04 21:34:37 +08:00
orderedActiveItems = serverSidePlaylist . Where ( item = > ! item . Expired ) . OrderBy ( item = > item . ID ) . ToList ( ) ;
2021-10-22 21:07:41 +08:00
break ;
2021-11-19 17:42:34 +08:00
case QueueMode . AllPlayersRoundRobin :
2021-12-06 23:01:07 +08:00
var itemsByPriority = new List < ( MultiplayerPlaylistItem item , int priority ) > ( ) ;
2021-12-03 15:48:54 +08:00
2021-12-06 23:01:07 +08:00
// Assign a priority for items from each user, starting from 0 and increasing in order which the user added the items.
2021-12-23 18:14:09 +08:00
foreach ( var group in serverSidePlaylist . Where ( item = > ! item . Expired ) . OrderBy ( item = > item . ID ) . GroupBy ( item = > item . OwnerID ) )
2021-12-02 21:32:41 +08:00
{
2021-12-06 23:01:07 +08:00
int priority = 0 ;
itemsByPriority . AddRange ( group . Select ( item = > ( item , priority + + ) ) ) ;
2021-12-02 21:32:41 +08:00
}
2021-12-06 23:01:07 +08:00
orderedActiveItems = itemsByPriority
// Order by each user's priority.
. OrderBy ( i = > i . priority )
// Many users will have the same priority of items, so attempt to break the tie by maintaining previous ordering.
// Suppose there are two users: User1 and User2. User1 adds two items, and then User2 adds a third. If the previous order is not maintained,
// then after playing the first item by User1, their second item will become priority=0 and jump to the front of the queue (because it was added first).
. ThenBy ( i = > i . item . PlaylistOrder )
// If there are still ties (normally shouldn't happen), break ties by making items added earlier go first.
// This could happen if e.g. the item orders get reset.
. ThenBy ( i = > i . item . ID )
. Select ( i = > i . item )
. ToList ( ) ;
2021-12-02 21:32:41 +08:00
break ;
2021-10-22 21:07:41 +08:00
}
2021-12-03 15:48:54 +08:00
for ( int i = 0 ; i < orderedActiveItems . Count ; i + + )
2021-12-02 21:32:41 +08:00
{
2021-12-03 19:05:25 +08:00
var item = orderedActiveItems [ i ] ;
if ( item . PlaylistOrder = = i )
continue ;
2021-11-13 00:42:51 +08:00
2021-12-03 19:05:25 +08:00
item . PlaylistOrder = ( ushort ) i ;
2021-11-16 13:37:29 +08:00
2021-12-03 15:48:54 +08:00
await ( ( IMultiplayerClient ) this ) . PlaylistItemChanged ( item ) . ConfigureAwait ( false ) ;
2021-12-02 21:32:41 +08:00
}
2022-04-01 17:31:17 +08:00
// Also ensure that the API room's playlist is correct.
foreach ( var item in serverSideAPIRoom . Playlist )
item . PlaylistOrder = serverSidePlaylist . Single ( i = > i . ID = = item . ID ) . PlaylistOrder ;
2021-10-22 21:07:41 +08:00
}
2020-12-19 00:14:50 +08:00
}
}