public void UpdateEntityData(INetworkingEntity entity, string key, MValue value)
{
lock (entity.StreamedInClients)
{
if (entity.StreamedInClients.Count <= 0)
{
return;
}
var entityDataChangeEvent = new EntityDataChangeEvent {
Id = entity.Id, Key = key, Value = value
};
var serverEvent = new ServerEvent {
DataChange = entityDataChangeEvent
};
var bytes = serverEvent.ToByteArray();
foreach (var streamedInClient in entity.StreamedInClients)
{
lock (streamedInClient)
{
if (streamedInClient.Exists)
{
streamedInClient.WebSocket?.SendAsync(bytes, true);
}
}
}
}
}
public void CreateEntity(INetworkingEntity networkingEntity)
{
if (networkingEntity.StreamingType == StreamingType.EntityStreaming)
{
return;
}
byte[] bytes;
if (networkingEntity.StreamingType == StreamingType.DataStreaming)
{
// Remove data before sending it over the wire
var entityWithoutData = networkingEntity.StreamedEntity.Clone();
entityWithoutData.Data.Clear();
var entityCreateEvent = new EntityCreateEvent {
Entity = entityWithoutData
};
var serverEvent = new ServerEvent {
Create = entityCreateEvent
};
bytes = serverEvent.ToByteArray();
}
else
{
var entityCreateEvent = new EntityCreateEvent {
Entity = networkingEntity.StreamedEntity
};
var serverEvent = new ServerEvent {
Create = entityCreateEvent
};
bytes = serverEvent.ToByteArray();
}
AltNetworking.Module.ClientPool.SendToAll(bytes);
}
public void UpdateEntityPosition(Entity.Entity entity, Position position)
{
var entityPositionChangeEvent = new EntityPositionChangeEvent {
Id = entity.Id, Position = position
};
var serverEvent = new ServerEvent {
PositionChange = entityPositionChangeEvent
};
var bytes = serverEvent.ToByteArray();
AltNetworking.Module.ClientPool.SendToAll(bytes);
}
public void UpdateEntityRange(Entity.Entity entity, float range)
{
var entityRangeChangeEvent = new EntityRangeChangeEvent {
Id = entity.Id, Range = range
};
var serverEvent = new ServerEvent {
RangeChange = entityRangeChangeEvent
};
var bytes = serverEvent.ToByteArray();
AltNetworking.Module.ClientPool.SendToAll(bytes);
}
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 async Task RemoveEntity(INetworkingEntity networkingEntity)
{
if (networkingEntity.StreamingType == StreamingType.EntityStreaming)
{
return;
}
var entityDeleteEvent = new EntityDeleteEvent {
Id = networkingEntity.StreamedEntity.Id
};
var serverEvent = new ServerEvent {
Delete = entityDeleteEvent
};
var bytes = serverEvent.ToByteArray();
await AltNetworking.Module.ClientPool.SendToAllTask(bytes);
}
public void OnMessage(ManagedWebSocket managedWebSocket, WebSocketReceiveResult result, byte[] data)
{
Task.Run(async() =>
{
var clientEvent = ClientEvent.Parser.ParseFrom(data);
if (clientEvent == null)
{
return;
}
var authEvent = clientEvent.Auth;
var streamIn = clientEvent.StreamIn;
var streamOut = clientEvent.StreamOut;
if (authEvent != null)
{
var token = authEvent.Token;
if (token == null)
{
return;
}
var verified = await authenticationProvider.Verify(networkingClientPool, managedWebSocket, token,
out var client);
if (!verified)
{
return;
}
client.OnConnect(managedWebSocket);
var sendEvent = new ServerEvent();
var currSendEvent = new EntitySendEvent();
lock (AltNetworking.Module.EntityPool.Entities)
{
foreach (var entity in AltNetworking.Module.EntityPool.Entities)
{
if (entity.Value.StreamingType == StreamingType.DataStreaming)
{
var streamedEntity = entity.Value.StreamedEntity.Clone();
streamedEntity.Data.Clear();
currSendEvent.Entities.Add(streamedEntity);
}
else
{
currSendEvent.Entities.Add(entity.Value.StreamedEntity);
}
}
}
sendEvent.Send = currSendEvent;
await managedWebSocket.SendAsync(sendEvent.ToByteArray(), true);
}
else if (streamIn != null)
{
var client = authenticationProvider.GetClient(managedWebSocket);
if (client == null)
{
return;
}
var entityId = streamIn.EntityId;
if (AltNetworking.Module.EntityPool.TryGet(entityId, out var entity))
{
if (!authenticationProvider.VerifyPosition(client, entity, true))
{
return;
}
EntityStreamInHandler?.Invoke(entity, client);
entity.ClientStreamedIn(client);
var changedKeys = entity.Snapshot.CompareWithClient(client);
if (changedKeys != null)
{
var multipleDataChangeEvent = new EntityMultipleDataChangeEvent {
Id = entityId
};
foreach (var changedKey in changedKeys)
{
if (entity.StreamedEntity.Data.TryGetValue(changedKey, out var mValue))
{
multipleDataChangeEvent.Data[changedKey] = mValue;
}
else // data got deleted probably
{
multipleDataChangeEvent.Data[changedKey] = new MValue {
NullValue = false
};
}
}
var serverEvent = new ServerEvent {
MultipleDataChange = multipleDataChangeEvent
};
await managedWebSocket.SendAsync(serverEvent.ToByteArray(), true);
}
}
}
else if (streamOut != null)
{
var client = authenticationProvider.GetClient(managedWebSocket);
if (client == null)
{
return;
}
var entityId = streamOut.EntityId;
if (AltNetworking.Module.EntityPool.TryGet(entityId, out var entity))
{
if (!authenticationProvider.VerifyPosition(client, entity, false))
{
return;
}
if (entity.ClientStreamedOut(client))
{
EntityStreamOutHandler?.Invoke(entity, client);
}
}
}
});
}
