Task IMultiplayerClient.UserStateChanged(int userId, MultiplayerUserState state)
{
if (Room == null)
{
return(Task.CompletedTask);
}
Schedule(() =>
{
if (Room == null)
{
return;
}
Room.Users.Single(u => u.UserID == userId).State = state;
if (state != MultiplayerUserState.Playing)
{
PlayingUsers.Remove(userId);
}
RoomChanged?.Invoke();
});
return(Task.CompletedTask);
}
private void updateLocalRoomSettings(MultiplayerRoomSettings settings)
{
if (Room == null)
{
return;
}
Schedule(() =>
{
if (Room == null)
{
return;
}
Debug.Assert(apiRoom != null);
// Update a few properties of the room instantaneously.
Room.Settings = settings;
apiRoom.Name.Value = Room.Settings.Name;
// The playlist update is delayed until an online beatmap lookup (below) succeeds.
// In-order for the client to not display an outdated beatmap, the playlist is forcefully cleared here.
apiRoom.Playlist.Clear();
RoomChanged?.Invoke();
var req = new GetBeatmapSetRequest(settings.BeatmapID, BeatmapSetLookupType.BeatmapId);
req.Success += res => updatePlaylist(settings, res);
api.Queue(req);
});
}
async Task IMultiplayerClient.UserJoined(MultiplayerRoomUser user)
{
if (Room == null)
{
return;
}
await PopulateUser(user);
Schedule(() =>
{
if (Room == null)
{
return;
}
// for sanity, ensure that there can be no duplicate users in the room user list.
if (Room.Users.Any(existing => existing.UserID == user.UserID))
{
return;
}
Room.Users.Add(user);
RoomChanged?.Invoke();
});
}
Task IMultiplayerClient.HostChanged(int userId)
{
if (Room == null)
{
return(Task.CompletedTask);
}
Schedule(() =>
{
if (Room == null)
{
return;
}
Debug.Assert(apiRoom != null);
var user = Room.Users.FirstOrDefault(u => u.UserID == userId);
Room.Host = user;
apiRoom.Host.Value = user?.User;
RoomChanged?.Invoke();
});
return(Task.CompletedTask);
}
private void SetupRoom()
{
_currentRoom = _controller.GetCurrentRoom();
_roomID = _controller._roomID;
RoomChanged?.Invoke(this, EventArgs.Empty);
RenderBackground(_currentRoom);
AddTravelator?.Invoke(this, EventArgs.Empty);
RenderExit(_currentRoom);
}
IEnumerator Start()
{
_controller = GetComponent <RoomController>();
while (!_controller._isReady)
{
yield return(null);
}
RoomChanged?.Invoke(this, EventArgs.Empty);
SetupRoom();
_controller.RoomChanged += Room_Changed;
}
public virtual Task LeaveRoom()
{
if (Room == null)
{
return(Task.CompletedTask);
}
apiRoom = null;
Room = null;
Schedule(() => RoomChanged?.Invoke());
return(Task.CompletedTask);
}
/// <summary>
/// Keep a weather eye on the room number. If it changes, notify
/// subscribers.
/// </summary>
/// <returns></returns>
IEnumerator Start()
{
var lastRoom = _roomID;
while (true)
{
if (lastRoom != _roomID)
{
lastRoom = _roomID;
RoomChanged?.Invoke(this, EventArgs.Empty);
}
yield return(null);
}
}
private void ConnectToRoomButton_Click(object sender, RoutedEventArgs e)
{
if (_control.RoomSelector.SelectedIndex < 0)
{
return;
}
var dialog = new TextInputDialog();
dialog.ShowDialog();
RoomID = _tcpConnection.ConnectToRoom(
_control.RoomSelector.SelectedItem as string,
dialog.PasswordTextBox.Text);
if (RoomID < 0)
{
return;
}
RoomChanged?.Invoke();
}
async Task IMultiplayerClient.UserJoined(MultiplayerRoomUser user)
{
if (Room == null)
{
return;
}
await PopulateUser(user);
Schedule(() =>
{
if (Room == null)
{
return;
}
Room.Users.Add(user);
RoomChanged?.Invoke();
});
}
Task IMultiplayerClient.UserLeft(MultiplayerRoomUser user)
{
if (Room == null)
{
return(Task.CompletedTask);
}
Schedule(() =>
{
if (Room == null)
{
return;
}
Room.Users.Remove(user);
PlayingUsers.Remove(user.UserID);
RoomChanged?.Invoke();
});
return(Task.CompletedTask);
}
Task IMultiplayerClient.RoomStateChanged(MultiplayerRoomState state)
{
if (Room == null)
{
return(Task.CompletedTask);
}
Schedule(() =>
{
if (Room == null)
{
return;
}
Debug.Assert(apiRoom != null);
Room.State = state;
switch (state)
{
case MultiplayerRoomState.Open:
apiRoom.Status.Value = new RoomStatusOpen();
break;
case MultiplayerRoomState.Playing:
apiRoom.Status.Value = new RoomStatusPlaying();
break;
case MultiplayerRoomState.Closed:
apiRoom.Status.Value = new RoomStatusEnded();
break;
}
RoomChanged?.Invoke();
});
return(Task.CompletedTask);
}
public override Result Execute(CommandID id, string command, string?parameters, Player player)
{
if (parameters != null)
{
return(Result.Error(GetTexts(TextID.CommandSyntax).ReplaceInAll("{command}", command)));
}
Direction?direction = CommandToDirection(id);
if (direction == null)
{
return(Result.Error());
}
if (!player.CurrentRoom.Connections.ContainsKey(direction.Value))
{
return(Result.Failure(GetTexts(TextID.CantGoThere)));
}
Room fromRoom = player.CurrentRoom;
Room toRoom = player.CurrentRoom.Connections[direction.Value];
var args = new RoomChangeRequestedEventArgs(fromRoom.ID, toRoom.ID);
RoomChangeRequested?.Invoke(args);
if (args.Cancel)
{
return(Result.Failure());
}
player.CurrentRoom = toRoom;
RoomChanged?.Invoke(args);
CheckPaperRoute(toRoom.ID);
return(Result.Success());
}
public void RaiseRoomChanged(object sender, List <UserRoom> rooms)
{
RoomChanged?.Invoke(sender, rooms);
}
protected virtual void OnRoomChanged(string room) => RoomChanged?.Invoke(this, room);
