public bool Add(INetworkingClient client)
{
lock (entities)
{
return(entities.TryAdd(client.Token, client));
}
}
public bool TryGet(string token, out INetworkingClient client)
{
lock (entities)
{
return(entities.TryGetValue(token, out client));
}
}
/// <summary>
/// Checks which keys have changed for the input data snapshot to stay in sync
/// </summary>
/// <param name="networkingClient">The networking client to compare, we need the client not the snapshot to keep reference for possible overflow</param>
/// <returns>the changed keys, returns null when no changes</returns>
public IEnumerable <string> CompareWithClient(INetworkingClient networkingClient)
{
if (Snapshots == null)
{
return(null); // entity snapshot never updated, nothing to do
}
lastClients.Add(networkingClient);
IEnumerable <string> changedKeys;
var clientDataSnapshot = networkingClient.Snapshot;
if (clientDataSnapshot.TryGetSnapshotForEntity(entityId, out var entitySnapshotFromClient)
) // client visited entity before
{
changedKeys = Compare(entitySnapshotFromClient);
entitySnapshotFromClient.Snapshots.Clear();
foreach (var(key, value) in Snapshots)
{
entitySnapshotFromClient.Snapshots[key] = value;
}
}
else // client never visited entity before
{
changedKeys = Snapshots.Keys.ToArray();
clientDataSnapshot.SetSnapshotForEntity(entityId,
new DataSnapshot(new ConcurrentDictionary <string, ulong>(Snapshots)));
}
return(changedKeys);
}
public void UpdateClientPositionOverride(INetworkingClient networkingClient, Vector3?position)
{
ServerEvent serverEvent;
if (position != null)
{
var clientPositionOverrideChangeEvent = new ClientPositionOverrideChangeEvent
{
PositionX = position.Value.X, PositionY = position.Value.Y, PositionZ = position.Value.Z
};
serverEvent = new ServerEvent {
ClientPositionOverrideChange = clientPositionOverrideChangeEvent
};
}
else
{
var clientPositionStopOverrideChangeEvent = new ClientPositionStopOverrideChangeEvent();
serverEvent = new ServerEvent
{
ClientPositionStopOverrideChange = clientPositionStopOverrideChangeEvent
};
}
var bytes = serverEvent.ToByteArray();
lock (networkingClient)
{
if (networkingClient.Exists)
{
networkingClient.WebSocket?.SendAsync(bytes, true);
}
}
}
public DataBlockManager(INetworkingClient client)
{
Client = client;
BlockEventManager = new BlockEventManager(Client);
BlockEventManager.RegisterEvents();
SendBlockQueue = new ConcurrentQueue <IBlockEvent>();
Task.Factory.StartNew(() => Update());
}
public void Process(INetworkingClient client)//currently only support server clients and not regular clients
{
if (NewBlock)
{
client.BlockManager.NewBlock(BlockEventId, BlockLength);
}
else
{
client.BlockManager.AddBlock(Block);
}
}
public Task <bool> Verify(INetworkingClientPool networkingClientPool, ManagedWebSocket webSocket, string token,
out INetworkingClient client)
{
if (!networkingClientPool.TryGet(token, out client))
{
return(Task.FromResult(false));
}
//TODO: check if already has websocket ect. client.WebSocket
webSocket.Extra[ClientExtra] = client;
return(Task.FromResult(true));
}
public void UpdateClientDimension(INetworkingClient networkingClient, int dimension)
{
var clientDimensionChangeEvent = new ClientDimensionChangeEvent {
Dimension = dimension
};
var serverEvent = new ServerEvent {
ClientDimensionChange = clientDimensionChangeEvent
};
var bytes = serverEvent.ToByteArray();
networkingClient.WebSocket.SendAsync(bytes, true);
}
public bool Remove(string token, out INetworkingClient client)
{
idProvider.Free(token);
lock (entities)
{
if (!entities.Remove(token, out client))
{
return(false);
}
}
if (client is IInternalNetworkingClient internalNetworkingClient)
{
lock (internalNetworkingClient)
{
internalNetworkingClient.Exists = false;
}
}
return(true);
}
public Task <bool> Verify(INetworkingClientPool networkingClientPool, ManagedWebSocket managedWebSocket,
string token, out INetworkingClient client)
{
if (networkingClientPool.TryGet(token, out client))
{
//managedWebSocket.Extra.TryAdd("client", client);
/*if (client.WebSocket != managedWebSocket)
* {
* webSocket.CloseWebSocket(client.WebSocket);
* }
*
* client.WebSocket = managedWebSocket;*/
//return Task.FromResult(true);
networkingClientPool.Remove(client);
//TODO: maybe try to reuse clients later when client can send if it was a reconnect or new connection in auth event
}
client = AltNetworking.CreateClient(token);
client.WebSocket = managedWebSocket; //TODO: maybe do that automatically, but we would lost freedom
managedWebSocket.Extra.TryAdd("client", client);
return(Task.FromResult(true));
}
public void Transmit(INetworkingClient client)
{
client.BlockManager.QueueBlockEvent(this);
}
public void Process(INetworkingClient client)
{
}
public RemoteEventManager(INetworkingClient client)
{
Client = client;
RemoteEvents = new List <RemoteEvent>();
}
public UserClient(INetworkingClient client)
{
this.client = client;
}
public void Process(INetworkingClient client)//currently only support server clients and not regular clients
{
}
internal static void SetNetworkingClient(this IPlayer player, INetworkingClient client)
{
player.SetData(ClientKey, client);
}
public ConversationClient(INetworkingClient client)
{
this.client = client;
}
public bool VerifyPosition(INetworkingClient client, INetworkingEntity entity, bool inRange)
{
return(true);
}
public void Transmit(INetworkingClient client)
{
throw new NotImplementedException();
}
public GameEventManager(INetworkingClient client)
{
Client = client;
}
public bool VerifyPosition(INetworkingClient client, INetworkingEntity entity, bool inRange)
{
// Can be extended when more trustful position checking is needed
return(true);
}
public static bool TryGetNetworkingClient(this IPlayer player, out INetworkingClient client)
{
return(player.GetData(ClientKey, out client));
}
public void Transmit(INetworkingClient client)
{
client.SendEvent(this);
}
public void Process(INetworkingClient client)
{
client.SetAuthenticated(true);
}
public void Process(INetworkingClient client)
{
client.RemoteEventManager.TriggerEvent(EventId, FunctionId);
}
public void Transmit(INetworkingClient client)//currently only support server clients and not regular clients
{
}
public void Process(INetworkingClient client)
{
throw new NotImplementedException();
}
public BlockEventManager(INetworkingClient client)
{
Client = client;
BlockEvents = new Dictionary <BlockEventId, Type>();
}
public MessageClient(INetworkingClient client)
{
this.client = client;
}
public void Remove(INetworkingClient client) => Remove(client.Token);
