public void CreateRoom(Room room, Action <Room> onSuccess = null, Action <string> onError = null)
{
room.Host.Value = api.LocalUser.Value;
var req = new CreateRoomRequest(room);
req.Success += result =>
{
joinedRoom = room;
update(room, result);
addRoom(room);
RoomsUpdated?.Invoke();
onSuccess?.Invoke(room);
};
req.Failure += exception =>
{
if (req.Result != null)
{
onError?.Invoke(req.Result.Error);
}
else
{
Logger.Log($"Failed to create the room: {exception}", level: LogLevel.Important);
}
};
api.Queue(req);
}
private void onRoomsReceived(List <Room> received)
{
if (received == null)
{
ClearRooms();
return;
}
// Remove past matches
foreach (var r in rooms.ToList())
{
if (received.All(e => e.RoomID.Value != r.RoomID.Value))
{
rooms.Remove(r);
}
}
for (int i = 0; i < received.Count; i++)
{
var room = received[i];
Debug.Assert(room.RoomID.Value != null);
if (ignoredRooms.Contains(room.RoomID.Value.Value))
{
continue;
}
room.Position.Value = i;
try
{
update(room, room);
addRoom(room);
}
catch (Exception ex)
{
Logger.Error(ex, $"Failed to update room: {room.Name.Value}.");
ignoredRooms.Add(room.RoomID.Value.Value);
rooms.Remove(room);
}
}
RoomsUpdated?.Invoke();
initialRoomsReceived.Value = true;
}
protected override Task Poll()
{
if (!api.IsLoggedIn)
{
return(base.Poll());
}
var tcs = new TaskCompletionSource <bool>();
pollReq?.Cancel();
pollReq = new GetRoomsRequest(currentFilter.PrimaryFilter);
pollReq.Success += result =>
{
// Remove past matches
foreach (var r in rooms.ToList())
{
if (result.All(e => e.RoomID.Value != r.RoomID.Value))
{
rooms.Remove(r);
}
}
for (int i = 0; i < result.Count; i++)
{
var r = result[i];
r.Position = i;
update(r, r);
addRoom(r);
}
RoomsUpdated?.Invoke();
tcs.SetResult(true);
};
pollReq.Failure += _ => tcs.SetResult(false);
api.Queue(pollReq);
return(tcs.Task);
}
public virtual void CreateRoom(Room room, Action <Room> onSuccess = null, Action <string> onError = null)
{
room.Host.Value = api.LocalUser.Value;
var req = new CreateRoomRequest(room);
req.Success += result =>
{
joinedRoom.Value = room;
update(room, result);
addRoom(room);
RoomsUpdated?.Invoke();
onSuccess?.Invoke(room);
};
req.Failure += exception =>
{
onError?.Invoke(req.Result?.Error ?? exception.Message);
};
api.Queue(req);
}
/// <summary>
/// Read and prosess data from stream
/// </summary>
private void ClientStreamReadData()
{
try
{
using (Stream stream = _server.GetStream())
{
BinaryReader streamReader = new BinaryReader(stream);
while (true)
{
PacketType packetType = (PacketType)streamReader.ReadInt32();
switch (packetType)
{
case PacketType.Negotiation:
NegotiationPacket negotiationPacket = new NegotiationPacket(stream);
negotiationPacket.Receive();
Login = negotiationPacket.Login;
_loginEvents[0].Set();
_registerEvents[0].Set();
lock (_rooms)
{
Room mainRoom = new Room(Room.MainRoomId, Room.MainRoomName, new HashSet <string>());
_rooms.Add(Room.MainRoomId, mainRoom);
}
_context.Post(p => NegotiationCompleted?.Invoke(this, EventArgs.Empty), null);
break;
case PacketType.SimpleMessage:
SimpleMessagePacket simpleMessagePacket = new SimpleMessagePacket(stream);
simpleMessagePacket.Receive();
OnSimpleMessageReceived(simpleMessagePacket);
break;
case PacketType.Error:
ErrorPacket errorPacket = new ErrorPacket(stream);
errorPacket.Receive();
_context.Post(p => ErrorOccurred?.Invoke(this, new ErrorOccurredEventHandlerArgs(errorPacket.ErrorMessage, errorPacket.ErrorType)), null);
break;
case PacketType.UserConnect:
UserConnectPacket userConnectPacket = new UserConnectPacket(stream);
userConnectPacket.Receive();
lock (_users)
{
_users[userConnectPacket.UserLogin] = userConnectPacket.UserInfo;
}
_context.Post(p => UserConnected?.Invoke(this, new UserConnectedEventHandlerArgs(userConnectPacket.UserLogin, userConnectPacket.UserInfo)), null);
break;
case PacketType.UserDisconnect:
UserDisconnectPacket userDisconnectPacket = new UserDisconnectPacket(stream);
userDisconnectPacket.Receive();
lock (_users)
{
_users.Remove(userDisconnectPacket.UserLogin);
}
_context.Post(p => UserDisconnected?.Invoke(this, new UserDisconnectedEventHandlerArgs(userDisconnectPacket.UserLogin)), null);
break;
case PacketType.CreateNewRoom:
CreateNewRoomPacket createNewRoomPacket = new CreateNewRoomPacket(stream);
createNewRoomPacket.Receive();
lock (_rooms)
{
_rooms.Add(createNewRoomPacket.Room.Id, createNewRoomPacket.Room);
}
_context.Post(p => NewRoomCreated?.Invoke(this, new NewRoomCreatedEventHandlerArgs(createNewRoomPacket.Room)), null);
break;
case PacketType.AddUserToRoom:
AddUsersToRoomPacket addUsersToRoomPacket = new AddUsersToRoomPacket(stream);
addUsersToRoomPacket.Receive();
lock (_rooms)
{
foreach (string user in addUsersToRoomPacket.Users)
{
_rooms[addUsersToRoomPacket.RoomId].Members.Add(user);
}
}
_context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null);
break;
case PacketType.RemoveUserFromRoom:
RemoveUserFromRoomPacket removeUserFromRoomPacket = new RemoveUserFromRoomPacket(stream);
removeUserFromRoomPacket.Receive();
lock (_rooms)
{
Room room;
if (_rooms.TryGetValue(removeUserFromRoomPacket.RoomId, out room))
{
room.Members.Remove(removeUserFromRoomPacket.User);
}
}
_context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null);
break;
}
}
}
}
catch (Exception)
{
_server.Close();
_server.Client.Dispose();
}
}
private void notifyRoomsUpdated()
{
Scheduler.AddOnce(invokeRoomsUpdated);
void invokeRoomsUpdated() => RoomsUpdated?.Invoke();
}
private void notifyRoomsUpdated() => Scheduler.AddOnce(() => RoomsUpdated?.Invoke());
public void RemoveRoom(Room room)
{
Rooms.Remove(room);
RoomsUpdated?.Invoke();
}
public void AddRoom(Room room)
{
Rooms.Add(room);
RoomsUpdated?.Invoke();
}
