protected override void HandleMessage(EntitySnapshotRequest <User> message)
{
IReadOnlyEntityRepository <User> userRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <User>();
var clientManager = ServiceRegistry.GetService <IClientManager>();
IEnumerable <User> currentUsers = userRepository.GetAllEntities();
var userSnapshot = new EntitySnapshot <User>(currentUsers);
clientManager.SendMessageToClient(userSnapshot, message.UserId);
}
protected override void HandleMessage(EntitySnapshot <Conversation> message)
{
var conversationRepository = (ConversationRepository)ServiceRegistry.GetService <RepositoryManager>().GetRepository <Conversation>();
foreach (Conversation conversation in message.Entities)
{
conversationRepository.AddEntity(conversation);
}
OnConversationBootstrapCompleted();
}
protected override void HandleMessage(EntitySnapshot <Participation> message)
{
var participationRepository = (IEntityRepository <Participation>)ServiceRegistry.GetService <RepositoryManager>().GetRepository <Participation>();
foreach (Participation participation in message.Entities)
{
participationRepository.AddEntity(participation);
}
OnParticipationBootstrapCompleted();
}
protected override void HandleMessage(EntitySnapshot <User> message)
{
var userRepository = (UserRepository)ServiceRegistry.GetService <RepositoryManager>().GetRepository <User>();
foreach (User user in message.Entities)
{
userRepository.AddEntity(user);
}
OnUserBootstrapCompleted();
}
protected override void OnEditing(MediaEditorModel model, EntitySnapshot <TypedEntity> entity)
{
//we need to flag if this model is editable based on whether or not it is in the recycle bin
using (var uow = Hive.Create <IContentStore>())
{
var ancestorIds = uow.Repositories.GetAncestorIds(entity.Revision.Item.Id, FixedRelationTypes.DefaultRelationType);
if (ancestorIds.Contains(FixedHiveIds.MediaRecylceBin, new HiveIdComparer(true)))
{
model.IsEditable = false;
}
}
}
/// <summary>
/// Determines whether the revision has a pending publish to be made
/// </summary>
/// <param name="rev">The rev.</param>
/// <returns>
/// <c>true</c> if [is publish pending] [the specified rev]; otherwise, <c>false</c>.
/// </returns>
public static bool IsPublishPending(this EntitySnapshot <TypedEntity> rev)
{
if (rev == null)
{
return(false);
}
var lastPublished = rev.GetLatestDate(FixedStatusTypes.Published);
var lastSaved = rev.GetLatestDate(FixedStatusTypes.Draft);
return(lastSaved > lastPublished);
}
protected override void HandleMessage(EntitySnapshotRequest <Conversation> message)
{
var participationRepository = (ParticipationRepository)ServiceRegistry.GetService <RepositoryManager>().GetRepository <Participation>();
IReadOnlyEntityRepository <Conversation> conversationRepository = ServiceRegistry.GetService <RepositoryManager>().GetRepository <Conversation>();
var clientManager = ServiceRegistry.GetService <IClientManager>();
IEnumerable <int> conversationIds = participationRepository.GetAllConversationIdsByUserId(message.UserId);
List <Conversation> conversations = conversationIds.Select(conversationRepository.FindEntityById).ToList();
var conversationSnapshot = new EntitySnapshot <Conversation>(conversations);
clientManager.SendMessageToClient(conversationSnapshot, message.UserId);
}
/// <summary>
/// Returns the published date if it is published, otherwise returns null
/// </summary>
/// <param name="rev"></param>
/// <returns></returns>
public static DateTimeOffset?PublishedDate(this EntitySnapshot <TypedEntity> rev)
{
if (rev == null)
{
return(null);
}
var lastPublished = rev.GetLatestDate(FixedStatusTypes.Published);
var lastUnpublished = rev.GetLatestDate(FixedStatusTypes.Unpublished);
return(lastPublished > lastUnpublished
? (DateTimeOffset?)lastPublished
: null);
}
protected override void HandleMessage(EntitySnapshotRequest <Participation> message)
{
var participationRepository = (ParticipationRepository)ServiceRegistry.GetService <RepositoryManager>().GetRepository <Participation>();
var clientManager = ServiceRegistry.GetService <IClientManager>();
var userParticipations = new List <Participation>();
foreach (int conversationId in participationRepository.GetAllConversationIdsByUserId(message.UserId))
{
userParticipations.AddRange(participationRepository.GetParticipationsByConversationId(conversationId));
}
var participationSnapshot = new EntitySnapshot <Participation>(userParticipations);
clientManager.SendMessageToClient(participationSnapshot, message.UserId);
}
/// <summary>
/// Removes the entity snapshot refered from the given quadratic coordinates.
/// </summary>
/// <param name="quadCoord">The quadratic coordinates of the entity snapshot to remove.</param>
private void RemoveEntitySnapshot(RCIntVector quadCoord)
{
EntitySnapshot snapshotToRemove = this.entitySnapshots[quadCoord.X, quadCoord.Y];
if (snapshotToRemove == null)
{
return;
}
for (int col = snapshotToRemove.QuadraticPosition.Left; col < snapshotToRemove.QuadraticPosition.Right; col++)
{
for (int row = snapshotToRemove.QuadraticPosition.Top; row < snapshotToRemove.QuadraticPosition.Bottom; row++)
{
this.entitySnapshots[col, row] = null;
}
}
}
internal static EntitySnapshot <T> GetLatestSnapshot <T>(this IEnumerable <IReadonlyProviderRevisionRepository <T> > readonlyRepositories, HiveId hiveId, Uri idRoot, RevisionStatusType revisionStatusType = null)
where T : class, IVersionableEntity
{
EntitySnapshot <T> returnValue = null;
//TODO: Determine which repo is the primary one
//TODO: Ensure population of the incoming queue is sorted by Ordinal
foreach (var reader in readonlyRepositories)
{
returnValue = reader.GetLatestSnapshot <T>(hiveId, revisionStatusType);
if (returnValue != null)
{
break;
}
}
return(GroupSessionHelper.MakeIdsAbsolute(returnValue, idRoot));
}
/// <summary>
/// This creates a "snapshot" of an entity's global positions and rotation. This includes the entity's entire hierarchy.
/// </summary>
private static void CreateSnapshotImpl(this Entity entity, EntitySnapshot root, List <EntitySnapshot> results)
{
if (entity == null || !entity.Valid)
{
return;
}
EntitySnapshot parent = new EntitySnapshot(entity, root);
results.Add(parent);
var children = entity.Children;
foreach (var child in children)
{
CreateSnapshotImpl(child, parent, results);
}
}
/// <summary>
/// Gets the latest date from an EntitySnapshot
/// <paramref name="alias"/>.
/// </summary>
public static DateTimeOffset GetLatestDate <T>(this EntitySnapshot <T> snapshot, string alias)
where T : TypedEntity
{
Mandate.ParameterNotNull(snapshot, "coll");
Mandate.ParameterNotNullOrEmpty(alias, "alias");
//TODO: This is currenty a work around for an issue where NH isn't adding the current item's revision data to the revision list data. SD. 07/11/2011
var latestInItem = snapshot.Revision.MetaData.StatusType.Alias == alias ? snapshot.Revision.MetaData.UtcStatusChanged : DateTimeOffset.MinValue;
var latestInList = snapshot.EntityRevisionStatusList.OrderByDescending(x => x.UtcStatusChanged).FirstOrDefault(x => x.StatusType.Alias == alias);
var latest = latestInList == null
? latestInItem
: latestInItem > latestInList.UtcStatusChanged
? latestInItem
: latestInList.UtcStatusChanged;
return(latest);
}
/// <summary>
/// Adds the given entity snapshot and all of its cutting quadratic tiles into the update lists.
/// </summary>
/// <param name="snapshot">The entity snapshot to add.</param>
/// <param name="snapshotUpdateList">The snapshot update list.</param>
/// <param name="quadTileUpdateList">The quadratic update list.</param>
private void AddEntitySnapshotToUpdate(EntitySnapshot snapshot, RCSet <EntitySnapshot> snapshotUpdateList, RCSet <IQuadTile> quadTileUpdateList)
{
if (snapshot != null && snapshotUpdateList.Add(snapshot))
{
for (int col = snapshot.QuadraticPosition.Left; col < snapshot.QuadraticPosition.Right; col++)
{
for (int row = snapshot.QuadraticPosition.Top; row < snapshot.QuadraticPosition.Bottom; row++)
{
IQuadTile quadTileToUpdate = this.ActiveScenario.Map.GetQuadTile(new RCIntVector(col, row));
if (quadTileToUpdate != null &&
(this.fowCacheMatrix.GetFullFowFlagsAtQuadTile(quadTileToUpdate.MapCoords) != FOWTileFlagsEnum.None ||
this.fowCacheMatrix.GetPartialFowFlagsAtQuadTile(quadTileToUpdate.MapCoords) != FOWTileFlagsEnum.None))
{
quadTileUpdateList.Add(quadTileToUpdate);
}
}
}
}
}
public void ServerUpdateSerializer_Serialization_Empty()
{
byte[] serializedData = new byte[1024];
{
EntityArray entityArray = EntityTests.CreateStandardEntityArray();
EntitySnapshot entitySnapshot = new EntitySnapshot(3, EntityTests.CreateComponentsDefinition());
entitySnapshot.Update(66, entityArray);
OutgoingMessage outgoingMessage = new OutgoingMessage(serializedData);
ServerUpdateSerializer.Serialize(outgoingMessage, null, entitySnapshot, 63, 13);
serializedData = outgoingMessage.ToArray();
}
{
EntitySnapshot entitySnapshot = new EntitySnapshot(3, EntityTests.CreateComponentsDefinition());
ServerUpdateSerializer.Deserialize(new IncomingMessage(serializedData), new EntitySnapshot[0], entitySnapshot, out int latestClientTickAcknowledgedByServer, out int clientCommandingEntityID);
Assert.AreEqual(63, latestClientTickAcknowledgedByServer);
Assert.AreEqual(13, clientCommandingEntityID);
Assert.AreEqual(66, entitySnapshot.ServerFrameTick);
EntityTests.AssertStandardEntityArray(entitySnapshot.EntityArray);
}
}
private static void BlankFace(EntitySnapshot caim, IList <RaidAction> raidActions)
{
var lastAbility = caim.Raid.GetLastAbilityUsed();
if (lastAbility != null)
{
if (lastAbility.Type == Ability.Types.AbilityType.Offensive)
{
caim.GlobalState["blank_face"] = TypedValue.FromString("spades");
if (caim.PositionInFrontline < 4)
{
SpadesPreparation().Cast(caim, raidActions);
}
}
else if (lastAbility.Type == Ability.Types.AbilityType.Healing)
{
caim.GlobalState["blank_face"] = TypedValue.FromString("hearts");
if (caim.PositionInFrontline < 4)
{
HeartsPreparation().Cast(caim, raidActions);
}
}
else if (lastAbility.Type == Ability.Types.AbilityType.Support)
{
caim.GlobalState["blank_face"] = TypedValue.FromString("diamonds");
if (caim.PositionInFrontline < 4)
{
DiamondsPreparation().Cast(caim, raidActions);
}
}
else if (lastAbility.Type == Ability.Types.AbilityType.Defensive)
{
caim.GlobalState["blank_face"] = TypedValue.FromString("clubs");
if (caim.PositionInFrontline < 4)
{
ClubsPreparation().Cast(caim, raidActions);
}
}
}
}
public void ServerUpdateSerializer_DeserializeIfNewer_IsNewer()
{
byte[] serializedData = new byte[1024];
{
EntitySnapshot entitySnapshot = new EntitySnapshot(3, EntityTests.CreateComponentsDefinition());
entitySnapshot.Update(68, entitySnapshot.EntityArray);
OutgoingMessage outgoingMessage = new OutgoingMessage(serializedData);
ServerUpdateSerializer.Serialize(outgoingMessage, null, entitySnapshot, 73, 17);
serializedData = outgoingMessage.ToArray();
}
{
EntityArray entityArray = EntityTests.CreateStandardEntityArray();
EntitySnapshot entitySnapshot = new EntitySnapshot(3, EntityTests.CreateComponentsDefinition());
entitySnapshot.Update(65, entityArray);
Assert.IsTrue(ServerUpdateSerializer.DeserializeIfNewer(new IncomingMessage(serializedData), new EntitySnapshot[0], entitySnapshot, out int latestClientTickAcknowledgedByServer, out int clientCommandingEntityID));
Assert.AreEqual(73, latestClientTickAcknowledgedByServer);
Assert.AreEqual(17, clientCommandingEntityID);
Assert.AreEqual(68, entitySnapshot.ServerFrameTick);
Assert.IsFalse(entitySnapshot.EntityArray.TryGetEntity(0, out _));
Assert.IsFalse(entitySnapshot.EntityArray.TryGetEntity(1, out _));
Assert.IsFalse(entitySnapshot.EntityArray.TryGetEntity(2, out _));
}
}
/// <summary>
/// Calculates the entity snapshot for the given quadratic tile.
/// </summary>
/// <param name="quadCoords">The quadratic coordinates of the tile.</param>
private void CalculateEntitySnapshot(RCIntVector quadCoords)
{
bool isFowRunning = false;
EntitySnapshot entitySnapshot = null;
int greatestExpirationTime = -1;
for (int idx = 0; idx < Player.MAX_PLAYERS; idx++)
{
if (this.runningFows[idx] != null)
{
int expirationTime = this.runningFows[idx].GetExpirationTime(quadCoords);
if (expirationTime > greatestExpirationTime)
{
entitySnapshot = this.runningFows[idx].GetEntitySnapshot(quadCoords);
greatestExpirationTime = expirationTime;
}
isFowRunning = true;
}
}
this.fowCacheMatrix[quadCoords.X, quadCoords.Y].LastEntitySnapshotUpdate = this.scenario.CurrentFrameIndex;
this.fowCacheMatrix[quadCoords.X, quadCoords.Y].EntitySnapshot = isFowRunning ? entitySnapshot : null;
}
public static void FillDiamonds(this EntitySnapshot npc, IList <RaidAction> raidActions)
{
throw new NotImplementedException();
}
private static void ProcessPassiveEffects(EntitySnapshot template)
{
}
public static void StoreSnapshot(ISnapshotStore snapshotStore, EntitySnapshot snapshot)
{
storeSnapshotDelegates[snapshot.GetType()](snapshotStore, snapshot);
}
internal static EntitySnapshot <T> SetProviderAliasOnId <T>(ProviderMetadata providerMetadata, EntitySnapshot <T> entity) where T : class, IVersionableEntity
{
if (entity == null)
{
return(null);
}
SetProviderAliasOnId(providerMetadata, entity.Revision);
return(entity);
}
public void StoreSnapshot(EntitySnapshot snapshot)
{
TSnapshot typedSnapshot = (TSnapshot)snapshot;
StoreSnapshot(typedSnapshot);
}
public static UseAbility UseAbility(this EntitySnapshot hero, int abilityIndex, int targetIndex)
{
throw new NotImplementedException();
}
/// <summary>
/// Continues to update the Fog Of War informations based on the current positions of the owner's entities.
/// </summary>
/// <param name="maxEntities">The maximum number of entities to be processed.</param>
/// <returns>The actual number of processed entities.</returns>
/// <remarks>
/// The already processed entities won't be processed again. Use FogOfWar.RestartUpdate to restart the update procedure.
/// </remarks>
public int ContinueUpdate(int maxEntities)
{
if (maxEntities < 0)
{
throw new ArgumentOutOfRangeException("maxEntities", "maxEntities shall be non-negative!");
}
/// Update every quadratic tiles that are visible by the friendly entities.
int processedEntitiesCount = 0;
using (IEnumerator <Entity> entitiesIterator = this.owner.Entities.GetEnumerator())
{
while (processedEntitiesCount < maxEntities && entitiesIterator.MoveNext())
{
Entity entity = entitiesIterator.Current;
if (!this.processedEntities.Contains(entity.ID.Read()))
{
foreach (RCIntVector visibleQuadCoord in entity.Locator.VisibleQuadCoords)
{
/// Update the expiration time of the quadratic tile.
this.fowExpirationTimes[visibleQuadCoord.X, visibleQuadCoord.Y] =
this.owner.Scenario.CurrentFrameIndex + PARTIAL_FOW_EXPIRATION_TIME;
/// If there was a snapshot at the given quadratic tile -> remove it.
this.RemoveEntitySnapshot(visibleQuadCoord);
/// If there is a non-friendly Entity fixed on the given quadratic tile -> start monitoring.
Entity entityAtQuadTile = this.owner.Scenario.GetFixedEntity <Entity>(visibleQuadCoord);
if (entityAtQuadTile != null && entityAtQuadTile.Owner != this.owner)
{
this.monitoredEntities.Add(entityAtQuadTile.ID.Read());
}
}
this.processedEntities.Add(entity.ID.Read());
processedEntitiesCount++;
}
}
}
/// Check the monitored entities if we still need to monitor them.
List <int> monitoredEntitiesCopy = new List <int>(this.monitoredEntities);
foreach (int monitoredEntityId in monitoredEntitiesCopy)
{
Entity monitoredEntity = this.owner.Scenario.GetElementOnMap <Entity>(monitoredEntityId, MapObjectLayerEnum.GroundObjects);
if (monitoredEntity != null && monitoredEntity.Owner != this.owner && monitoredEntity.MotionControl.Status == MotionControlStatusEnum.Fixed)
{
/// Check if the monitored entity is still visible.
bool isStillVisible = false;
for (int col = monitoredEntity.MapObject.QuadraticPosition.Left; !isStillVisible && col < monitoredEntity.MapObject.QuadraticPosition.Right; col++)
{
for (int row = monitoredEntity.MapObject.QuadraticPosition.Top; row < monitoredEntity.MapObject.QuadraticPosition.Bottom; row++)
{
if (this.GetFogOfWar(new RCIntVector(col, row)) == FOWTypeEnum.None)
{
/// Found at least 1 quadratic tile where the monitored entity is still visible.
isStillVisible = true;
break;
}
}
}
if (!isStillVisible)
{
/// Take a snapshot...
EntitySnapshot snapshot = new EntitySnapshot(monitoredEntity);
for (int col = snapshot.QuadraticPosition.Left; col < snapshot.QuadraticPosition.Right; col++)
{
for (int row = snapshot.QuadraticPosition.Top; row < snapshot.QuadraticPosition.Bottom; row++)
{
this.entitySnapshots[col, row] = snapshot;
}
}
/// ...and stop monitoring.
this.monitoredEntities.Remove(monitoredEntityId);
}
}
else
{
/// The monitored entity is not bound to the quadratic grid or became friendly -> stop monitoring.
this.monitoredEntities.Remove(monitoredEntityId);
}
}
return(processedEntitiesCount);
}
public static void FillDiamonds(this EntitySnapshot npc, IList <RaidAction> raidActions, bool applyToAllRaidParticipants = false)
{
throw new NotImplementedException();
}
/// <summary>
/// Allows inheritors to modify the model before being passed to the view
/// </summary>
/// <param name="model">The model being returned to the view</param>
/// <param name="entity">The entity that the model was created from</param>
protected virtual void OnEditing(TEditorModel model, EntitySnapshot <TypedEntity> entity)
{
}
public void ProcessEffects(EntitySnapshot caster, IList <RaidAction> raidActions)
{
throw new NotImplementedException();
}
private static bool Equals(ResourceEntity entity, EntitySnapshot snapshot)
{
return(string.Equals(entity.ProjectName, snapshot.ProjectName, StringComparison.OrdinalIgnoreCase) &&
string.Equals(entity.UniqueName, snapshot.UniqueName, StringComparison.OrdinalIgnoreCase));
}
public void ProcessEffects(EntitySnapshot caster, int targetPositionInFrontline, IList <RaidAction> raidActions)
{
throw new NotImplementedException();
}
