public void UpdateCachedBody(WorldBody worldBody, uint time)
{
if (worldBody == null || !worldBody.Exists)
{
return;
}
if (!Bodies.TryGetValue(worldBody.ID, out BucketBody bucket))
{
bucket = new BucketBody()
{
Stale = false
};
Bodies.Add(worldBody.ID, bucket);
}
bucket.Stale = false;
bucket.ReadBody(worldBody, time);
if (worldBody.Group != null)
{
if (!Groups.TryGetValue(worldBody.Group.ID, out BucketGroup group))
{
group = new BucketGroup();
Groups.Add(worldBody.Group.ID, group);
group.Stale = true;
}
if (group.Stale)
{
group.Stale = false;
group.ReadGroup(worldBody.Group, time);
}
}
}
internal async Task <Stream> SendAsync(WebSocketRequest request, BucketGroup group, int bucketId, ulong objId)
{
request.CancelToken = _cancelToken;
var bucket = GetBucket(group, bucketId, objId);
return(await bucket.SendAsync(request).ConfigureAwait(false));
}
private void UpdateLocalGroups(IEnumerable <Group> groups)
{
foreach (var bucket in Groups.Values)
{
bucket.Stale = true;
}
foreach (var obj in groups)
{
BucketGroup bucket = null;
if (Groups.ContainsKey(obj.ID))
{
Groups[obj.ID].Stale = false;
}
else
{
bucket = new BucketGroup
{
GroupUpdated = obj,
Stale = false
};
Groups.Add(obj.ID, bucket);
}
}
}
private void CreateBucketGroup(int sub_tick_count, float seconds_per_sub_tick, UpdateRate update_rate, List <BucketGroup> sub_group)
{
BucketGroup item = new BucketGroup(sub_tick_count, seconds_per_sub_tick, update_rate);
bucketGroups.Add(item);
sub_group.Add(item);
}
private void UpdateLocalBodies(IEnumerable <Body> bodies)
{
foreach (var bucket in Groups.Values)
{
bucket.Stale = true;
}
foreach (var bucket in Bodies.Values)
{
bucket.Stale = true;
}
foreach (var obj in bodies)
{
if (Bodies.ContainsKey(obj.ID))
{
Bodies[obj.ID].Stale = false;
Bodies[obj.ID].BodyUpdated = obj;
}
else
{
var bucket = new BucketBody
{
BodyUpdated = obj,
Stale = false
};
Bodies.Add(obj.ID, bucket);
}
if (obj.Group != null)
{
if (Groups.ContainsKey(obj.Group.ID))
{
Groups[obj.Group.ID].Stale = false;
}
else
{
var bucket = new BucketGroup
{
GroupUpdated = obj.Group,
Stale = false
};
Groups.Add(obj.Group.ID, bucket);
}
}
}
}
private RequestQueueBucket GetBucket(BucketGroup group, int bucketId, ulong objId)
{
switch (group)
{
case BucketGroup.Global:
return(GetGlobalBucket((GlobalBucket)bucketId));
case BucketGroup.Guild:
return(GetGuildBucket((GuildBucket)bucketId, objId));
case BucketGroup.Channel:
return(GetChannelBucket((ChannelBucket)bucketId, objId));
default:
throw new ArgumentException($"Unknown bucket group: {group}", nameof(group));
}
}
//Core
private async Task SendGatewayInternalAsync(GatewayOpCode opCode, object payload,
BucketGroup group, int bucketId, ulong guildId, RequestOptions options)
{
CheckState();
//TODO: Add ETF
byte[] bytes = null;
payload = new WebSocketMessage {
Operation = (int)opCode, Payload = payload
};
if (payload != null)
{
bytes = Encoding.UTF8.GetBytes(SerializeJson(payload));
}
await RequestQueue.SendAsync(new WebSocketRequest(_gatewayClient, bytes, true, options), group, bucketId, guildId).ConfigureAwait(false);
await _sentGatewayMessageEvent.InvokeAsync(opCode).ConfigureAwait(false);
}
private async Task <TResponse> SendRpcAsyncInternal <TResponse>(string cmd, object payload, BucketGroup group, int bucketId, ulong guildId,
Optional <string> evt, bool ignoreState, RequestOptions options)
where TResponse : class
{
if (!ignoreState)
{
CheckState();
}
byte[] bytes = null;
var guid = Guid.NewGuid();
payload = new API.Rpc.RpcMessage {
Cmd = cmd, Event = evt, Args = payload, Nonce = guid
};
if (payload != null)
{
var json = SerializeJson(payload);
bytes = Encoding.UTF8.GetBytes(json);
}
var requestTracker = new RpcRequest <TResponse>(options);
_requests[guid] = requestTracker;
await _requestQueue.SendAsync(new WebSocketRequest(_webSocketClient, bytes, true, options), group, bucketId, guildId).ConfigureAwait(false);
await _sentRpcMessageEvent.InvokeAsync(cmd).ConfigureAwait(false);
return(await requestTracker.Promise.Task.ConfigureAwait(false));
}
