private async Task Fetch()
{
if (HasLastFetchFinished() == false)
{
return;
}
var associationsTask = this.StateManager.GetStateAsync <Dictionary <ActorId, AssociateChunkMetaData> >("associations");
var playersTask = this.StateManager.GetStateAsync <Dictionary <ActorId, MinecraftVersion> >("observers");
var initPlayersTask = this.StateManager.GetStateAsync <Dictionary <ActorId, MinecraftVersion> >("initializeObservers");
await Task.WhenAll(associationsTask, playersTask, initPlayersTask);
var associations = associationsTask.Result;
var players = playersTask.Result;
var initPlayers = initPlayersTask.Result;
CalculateDistribution(1000, 4096);
ActorId[] actorIds = null;
if (players.Count != 0)
{
actorIds = new ActorId[players.Count];
players.Keys.CopyTo(actorIds, 0);
}
foreach (var pair in associations)
{
var association = pair.Value;
//if no tracking pieces, then recreate... this handle the re-hydrate of the actor
if (_tracking.ContainsKey(pair.Key) == false)
{
var trackingData = new TrackingChunkMetaData()
{
fidelity = association.fidelity
};
_tracking.Add(pair.Key, trackingData);
}
var tracking = _tracking[pair.Key];
var task = tracking.updateTask;
if (task != null)
{
var response = task.Result;
tracking.playerVersion = response.lastPlayersVersion;
tracking.blockVersion = response.lastBlockVersion;
}
if ((association.needInitObservers.Count > 0) || (actorIds.Length > 0))
{
var informActor = ActorProxy.Create <InformActor>(pair.Value.informActorId, this.ServiceUri);
tracking.updateTask = informActor.InformOfChange(actorIds, association, tracking);
}
association.needInitObservers.Clear();
//need to save
}
//convert over...
foreach (var pair in initPlayers)
{
players.Add(pair.Key, pair.Value);
}
initPlayers.Clear();
//now save everyting
var taskSetInit = this.StateManager.SetStateAsync("initializeObservers", initPlayers);
var taskSetObserver = this.StateManager.SetStateAsync("observers", players);
var taskSetAssociation = this.StateManager.SetStateAsync("associations", associations);
await Task.WhenAll(taskSetInit, taskSetObserver, taskSetAssociation);
return;
}
public async Task <InformOfChunkChangeResponse> InformOfChange(ActorId[] observer, AssociateChunkMetaData associate, TrackingChunkMetaData tracking)
{
var maxVersion = MinecraftVersion.GetNext();
//Get the data associated with request
var blockPerChunkActor = ActorProxy.Create <BlocksPerChunkActor>(associate.blocksPerChunkActorId, this.ServiceUri);
var playerPerChunkActor = ActorProxy.Create <PlayersPerChunkActor>(associate.playersPerChunkActorId, this.ServiceUri);
var taskPlayerData = playerPerChunkActor.GetAsync();
var taskBlockData = blockPerChunkActor.GetAsync();
await Task.WhenAll(taskPlayerData, taskBlockData);
var blockData = taskBlockData.Result;
var playerData = taskPlayerData.Result;
//gather new changes from the last delta of changes with the max requested being filled out
GatherChangesAndUpdateObservers(observer, tracking.blockVersion, maxVersion, tracking.maxBlocks,
tracking.playerVersion, maxVersion, tracking.maxPlayers,
out int nBlocksLeft, out int nPlayersLeft, out MinecraftVersion lastBlockUsedVersion, out MinecraftVersion lastPlayerUsedVersion,
blockData, playerData);
//information needed to calculate the ask for next request
var response = new InformOfChunkChangeResponse()
{
actorID = this.Id,
availableBlocks = nBlocksLeft,
availablePlayers = nPlayersLeft,
lastPlayersVersion = lastPlayerUsedVersion,
lastBlockVersion = lastBlockUsedVersion
};
//bring all new observers up to the same place as everyone else, but this might not be everything
if (associate.needInitObservers.Count > 0)
{
GatherChangesAndUpdateObservers(associate.needInitObservers.ToArray(), MinecraftVersion.minValue, response.lastBlockVersion, int.MaxValue,
MinecraftVersion.minValue, response.lastPlayersVersion, int.MaxValue,
out nBlocksLeft, out nPlayersLeft, out lastBlockUsedVersion, out lastPlayerUsedVersion,
blockData, playerData);
}
return(response);
}
