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(); }