public void Handle(EntityAdded <Case> notification)
{
var createdCase = notification.Entity;
var isOrganizationCase = createdCase.Organization != null;
var subscriptionName = isOrganizationCase ? Constants.Subscriptions.OrganizationCaseCreated : Constants.Subscriptions.UserCaseCreated;
var subscribers = _preferencesQuery.GetSubscriptionPreferenceDetails(subscriptionName);
foreach (var recipient in subscribers)
{
if (recipient.IsEmailRequested)
{
_singleEntityService.Save(new EmailNotification()
{
ToAddress = recipient.EmailAddress,
Content = $"New case created: {createdCase.Id}",
Subject = $"New case created: {createdCase.Id}"
});
}
if (recipient.IsSmsRequested)
{
_singleEntityService.Save(new SmsNotification()
{
ToPhoneNumber = recipient.PhoneNumber,
Content = $"New case created: {createdCase.Id}",
});
}
}
}
public Guid NewEntity(IEntityLogic logic, Guid controllerSim, float updatePeriod = 100)
{
if (Role == InstanceRole.OWNER)
{
var id = Guid.NewGuid();
var entityAdded = new EntityAdded()
{
EntityId = id,
UpdatePeriod = updatePeriod,
CreationInfo = logic.GetCreationInfo(),
InitialSnapshot = logic.TakeSnapshot(),
ControllerSimId = controllerSim,
AuthoritySimId = Id
};
_addedEntites.Add(entityAdded);
var entity = CreateLocalEntity(logic, entityAdded);
AddRemoteEntites(entity, entityAdded);
return(id);
}
else
{
throw new Exception("Can only create entities on OWNER instance");
}
}
public void Add(Entity item, bool isMain)
{
Items.Add(item);
if (item is EntityLiving living)
{
// AI を初期化する
living.MainAi?.OnInit();
foreach (var ai in living.CollisionAIs)
{
ai.OnInit();
}
}
if (item is EntityVisible visible)
{
// IDrawable のマッピングを行う
drawablesMap[visible] = visible.OnSpawn();
visible.OnUpdate(visible.Location, drawablesMap[visible]);
}
if (isMain)
{
MainEntity = item;
}
EntityAdded?.Invoke(this, item);
}
public override void Update(GameTime gameTime)
{
foreach (var entityId in _addedEntities)
{
_entityToComponentBits[entityId] = _componentManager.CreateComponentBits(entityId);
ActiveCount++;
EntityAdded?.Invoke(entityId);
}
foreach (var entityId in _changedEntities)
{
_entityToComponentBits[entityId] = _componentManager.CreateComponentBits(entityId);
EntityChanged?.Invoke(entityId);
}
foreach (var entityId in _removedEntities)
{
// we must notify subscribers before removing it from the pool
// otherwise an entity system could still be using the entity when the same id is obtained.
EntityRemoved?.Invoke(entityId);
var entity = _entityBag[entityId];
_entityBag[entityId] = null;
_componentManager.Destroy(entityId);
_entityToComponentBits[entityId] = default(BitVector32);
ActiveCount--;
_entityPool.Free(entity);
}
_addedEntities.Clear();
_removedEntities.Clear();
_changedEntities.Clear();
}
private void ProcessEntityAdded(EntityAdded added)
{
var logic = _interface.CreateEntity(this, added.CreationInfo);
var entity = CreateLocalEntity(logic, added);
AddRemoteEntites(entity, added);
}
private LocalEntity CreateLocalEntity(IEntityLogic logic, EntityAdded added)
{
var entity = new LocalEntity(added.EntityId, logic, this, GetRoleForSim(Id, added), added.UpdatePeriod);
_entities[entity.Id] = entity;
logic.ApplySnapshot(added.InitialSnapshot);
return(entity);
}
/// <summary>
/// Adds a component to the entity with the given ID. Note that an entity can only hold one unique component of every component type. Notifies all systems that the entity has changed.
/// </summary>
/// <param name="entityId">The ID of the entity to add the component to.</param>
/// <param name="component">The component to add to the entity.</param>
public void AddComponent(uint entityId, IComponent component)
{
entityTable[componentIndices[component.GetType()], entityId] = component;
if (entityInWorld[entityId])
{
EntityAdded?.Invoke(this, new EntityEventArgs(entityId, GetEntityBitmask(entityId)));
}
}
public void RefreshState()
{
if (gameController.Area.CurrentArea == null /*|| !EntitiesStack.CanRead */ || entityCollectSettingsContainer.NeedUpdate || !Player.IsValid)
{
return;
}
// var entities = EntitiesStack.Read();
while (Simple.Count > 0)
{
var entity = Simple.Pop();
if (entity == null)
{
DebugWindow.LogError($"{nameof(EntityListWrapper)}.{nameof(RefreshState)} entity is null. (Very strange).");
continue;
}
var entityId = entity.Id;
if (entityCache.TryGetValue(entityId, out _))
{
continue;
}
if (entityId >= Int32.MaxValue && !_settings.ParseServerEntities)
{
continue;
}
if (/*!entity.IsValid ||*/ entity.Type == EntityType.Error)
{
continue;
}
/*if (entity.Type == EntityType.Monster && (entity.GetComponent<Life>() == null ||
* entity.GetComponent<ObjectMagicProperties>() == null))
* {
* entity.IsValid = false;
* continue;
* }*/
if (entity.League == LeagueType.Legion)
{
if (entity.Stats == null)
{
continue;
}
}
EntityAddedAny?.Invoke(entity);
if ((int)entity.Type >= 100)
{
EntityAdded?.Invoke(entity);
}
entityCache[entityId] = entity;
}
UpdateEntityCollections();
entityCollectSettingsContainer.NeedUpdate = true;
}
public void Add(IEntity entity)
{
Entities[entity.ID] = entity;
entity.ComponentAdded += ComponentAdded;
entity.ComponentRemoved += ComponentRemoved;
EntityAdded?.Invoke(this, new EntityChangedEventArgs(entity));
}
/// <summary>
/// Raises the Entity Added event
/// </summary>
/// <param name="args">The event args</param>
protected void OnEntityAdded(CacheObjectEventArgs args)
{
var handler = EntityAdded;
if (handler != null)
{
EntityAdded.Invoke(this, args);
}
}
public EntityTest(
EntityId id,
string name,
Guid correlationId)
{
var @event = new EntityAdded(correlationId, id, name);
ApplyEvent(@event);
}
public bool AddEntity(Character character)
{
var success = Entities.TryAdd(character.Id, character);
if (success)
{
EntityAdded?.Invoke(this, new CharacterArgs(character));
}
return(success);
}
public bool AddEntity(Character entity)
{
var success = Entities.TryAdd(entity.Id, entity);
if (success)
{
EntityAdded?.Invoke(this, new CharacterArgs(entity));
}
return(success);
}
public Model()
{
_graph = new ModelGraph();
_graph.VertexAdded += i => EntityAdded?.Invoke(i);
_graph.VertexRemoved += i => EntityRemoved?.Invoke(i);
_graph.EdgeAdded += i => RelationshipAdded?.Invoke(i);
_graph.EdgeRemoved += i => RelationshipRemoved?.Invoke(i);
_graph.Cleared += (i, j) => ModelCleared?.Invoke();
}
public void RefreshState()
{
UpdatePlayer();
if (player.IsAlive && player.IsValid && player.HasComponent <Poe.Components.Stats>())
{
UpdatePlayerStats();
}
if (gameController.Area.CurrentArea == null)
{
return;
}
Dictionary <uint, Entity> newEntities = gameController.Game.IngameState.Data.EntityList.EntitiesAsDictionary;
var newCache = new Dictionary <uint, EntityWrapper>();
foreach (var keyEntity in newEntities)
{
if (!keyEntity.Value.IsValid)
{
continue;
}
var entityID = keyEntity.Key;
string uniqueEntityName = keyEntity.Value.Path + entityID;
if (ignoredEntities.Contains(uniqueEntityName))
{
continue;
}
if (entityCache.ContainsKey(entityID) && entityCache[entityID].IsValid)
{
newCache.Add(entityID, entityCache[entityID]);
entityCache[entityID].IsInList = true;
entityCache.Remove(entityID);
continue;
}
var entity = new EntityWrapper(gameController, keyEntity.Value);
EntityAddedAny(entity);
if (entity.Path.StartsWith("Metadata/Effects") || ((entityID & 0x80000000L) != 0L) ||
entity.Path.StartsWith("Metadata/Monsters/Daemon"))
{
ignoredEntities.Add(uniqueEntityName);
continue;
}
EntityAdded?.Invoke(entity);
newCache.Add(entityID, entity);
}
RemoveOldEntitiesFromCache();
entityCache = newCache;
}
/// <summary>
/// Add entity to collection
/// </summary>
/// <param name="entity">document to add</param>
/// <param name="token">cancellation token async support</param>
/// <returns></returns>
public virtual async Task Add(T entity, CancellationToken token = default(CancellationToken))
{
await Collection.InsertOneAsync(entity, new InsertOneOptions()
{
BypassDocumentValidation = true
}, token);
EntityAdded?.Invoke(this, new EntityEventArgs <T, TKey> {
Entity = entity
});
}
/// <summary>
/// Adds a entity to the scene.
/// </summary>
/// <param name="entity">The entity.</param>
public void Add(Entity entity)
{
if (entity == null)
{
return;
}
entity.Scene = scene;
entities.Add(entity.Id, entity);
entity.Initialize();
EntityAdded?.Invoke(this, new EntityEventArgs(entity));
}
public void RefreshState()
{
if (gameController.Area.CurrentArea == null)
{
return;
}
if (entityCollectSettingsContainer.NeedUpdate)
{
return;
}
if (Player == null || !Player.IsValid)
{
return;
}
while (Simple.Count > 0)
{
var entity = Simple.Pop();
if (entity == null)
{
DebugWindow.LogError($"{nameof(EntityListWrapper)}.{nameof(RefreshState)} entity is null. (Very strange).");
continue;
}
var entityId = entity.Id;
if (entityCache.TryGetValue(entityId, out _))
{
continue;
}
if (entityId >= int.MaxValue && !_settings.ParseServerEntities)
{
continue;
}
if (entity.Type == EntityType.Error)
{
continue;
}
EntityAddedAny?.Invoke(entity);
if ((int)entity.Type >= 100)
{
EntityAdded?.Invoke(entity);
}
entityCache[entityId] = entity;
}
UpdateEntityCollections();
entityCollectSettingsContainer.NeedUpdate = true;
}
public void RefreshState()
{
int address = gameController.Game.IngameState.Data.LocalPlayer.Address;
if ((Player == null) || (Player.Address != address))
{
Player = new EntityWrapper(gameController, address);
}
if (gameController.Area.CurrentArea == null)
{
return;
}
Dictionary <int, Entity> newEntities = gameController.Game.IngameState.Data.EntityList.EntitiesAsDictionary;
var newCache = new Dictionary <int, EntityWrapper>();
foreach (var keyEntity in newEntities)
{
if (!keyEntity.Value.IsValid)
{
continue;
}
int entityAddress = keyEntity.Key;
string uniqueEntityName = keyEntity.Value.Path + entityAddress;
if (ignoredEntities.Contains(uniqueEntityName))
{
continue;
}
if (entityCache.ContainsKey(entityAddress) && entityCache[entityAddress].IsValid)
{
newCache.Add(entityAddress, entityCache[entityAddress]);
entityCache[entityAddress].IsInList = true;
entityCache.Remove(entityAddress);
continue;
}
var entity = new EntityWrapper(gameController, keyEntity.Value);
if ((entity.Path.StartsWith("Metadata/Effects") || ((entityAddress & 0x80000000L) != 0L)) || entity.Path.StartsWith("Metadata/Monsters/Daemon"))
{
ignoredEntities.Add(uniqueEntityName);
continue;
}
EntityAdded?.Invoke(entity);
newCache.Add(entityAddress, entity);
}
RemoveOldEntitiesFromCache();
entityCache = newCache;
}
public void AddToMap(Coordinate coordinate, Entity entity)
{
MapTile mapTile = m_CoordinateToMapTile[coordinate];
mapTile.entities.Add(entity);
m_EntityIdToCoordinate[entity.Id] = coordinate;
entity.EntityKilled += RemoveFromMap;
EntityAdded?.Invoke(this, new EntityArgs()
{
entity = entity,
coordinate = coordinate
});
}
private void AddRemoteEntites(LocalEntity entity, EntityAdded added)
{
if (Role == InstanceRole.OWNER)
{
foreach (var client in _clientSims)
{
var remote = new RemoteEntity(entity.Id, GetRoleForSim(client.Id, added), client);
entity.NetworkEntityAdded(remote);
}
}
else
{
var remote = new RemoteEntity(entity.Id, GetRoleForSim(_ownerSim.Id, added), _ownerSim);
entity.NetworkEntityAdded(remote);
}
}
private void PostSaveChanges()
{
foreach (var databaseEntityAddedEventArgs in addedEntites)
{
EntityAdded?.Invoke(this, databaseEntityAddedEventArgs);
}
foreach (var databaseEntityModifiedEventArgs in modifiedEntites)
{
EntityModified?.Invoke(this, databaseEntityModifiedEventArgs);
}
foreach (var databaseEntityRemovedEventArgs in removedEntites)
{
EntityRemoved?.Invoke(this, databaseEntityRemovedEventArgs);
}
addedEntites.Clear();
modifiedEntites.Clear();
removedEntites.Clear();
}
private EntityRole GetRoleForSim(Guid simId, EntityAdded added)
{
var role = EntityRole.EMPTY;
if (simId == added.ControllerSimId)
{
role |= EntityRole.CONTROLLER;
}
if (simId == added.AuthoritySimId)
{
role |= EntityRole.AUTHORITY;
}
if (!(simId == added.ControllerSimId || simId == added.AuthoritySimId))
{
role |= EntityRole.OBSERVER;
}
return(role);
}
public override void Update(GameTime gameTime)
{
foreach (var entity in _addedEntities)
{
_entities[entity.Id] = entity;
entity.Initialize(_world);
ActiveCount++;
EntityAdded?.Invoke(entity);
}
foreach (var entity in _removedEntities)
{
if (_entities.ContainsKey(entity.Id))
{
_entities[entity.Id] = null;
_entities.Remove(entity.Id);
ActiveCount--;
EntityRemoved?.Invoke(entity);
}
}
_addedEntities.Clear();
_removedEntities.Clear();
foreach (var entity in _entities)
{
if (!entity.Value.IsExpired)
{
entity.Value.Update(gameTime);
}
else
{
_removedEntities.Add(entity.Value);
}
}
}
private void OnEntityAdded(Entity entity)
{
EntityAdded?.Invoke(entity);
}
protected virtual void OnEntityAdded(Entity e)
{
EntityAdded?.Invoke(this, e);
}
/// <summary>
/// Adds a child entity to this container
/// </summary>
/// <param name="child"></param>
internal void AddChild(Entity child)
{
children.Add(child);
EntityAdded?.Invoke(child);
}
/// <summary>
/// Marks an entity as added to the world, and invokjes the EntityAdded event, notifying all systems
/// of the new entity.
/// </summary>
/// <param name="entityId">The ID of the added entity</param>
public void AddEntityToWorld(uint entityId)
{
entityInWorld[entityId] = true;
EntityAdded?.Invoke(this, new EntityEventArgs(entityId, GetEntityBitmask(entityId)));
}
private static void PlaceEdge(EdgePlacerConfig cfg, Vector3D[] segments)
{
MyEntity holderEntity;
MyEntities.TryGetEntityById(cfg.EntityPlacing, out holderEntity);
var holderPlayer = holderEntity != null?MyAPIGateway.Players.GetPlayerControllingEntity(holderEntity) : null;
var def = DefinitionFor(cfg.Placed);
if (def == null)
{
MyEventContext.ValidationFailed();
return;
}
#region Validation
if (!MyEventContext.Current.IsLocallyInvoked)
{
if (holderEntity == null || holderPlayer == null ||
MyEventContext.Current.Sender.Value != holderPlayer.SteamUserId)
{
MyEventContext.ValidationFailed();
return;
}
if (MyAreaPermissionSystem.Static != null)
{
foreach (var pos in segments)
{
if (MyAreaPermissionSystem.Static.HasPermission(holderPlayer.IdentityId, pos,
MyPermissionsConstants.Build))
{
continue;
}
holderPlayer.ShowNotification("You cannot build here", 2000, null, new Vector4(1, 0, 0, 1));
MyEventContext.ValidationFailed();
return;
}
}
var validPlacedType = false;
foreach (var item in holderEntity.GetInventory(MyCharacterConstants.MainInventory).Items)
{
if (item == null)
{
continue;
}
var itemDef =
MyDefinitionManager.Get <MyInventoryItemDefinition>(item.DefinitionId) as MyHandItemDefinition;
if (itemDef == null)
{
continue;
}
foreach (var behaviorDef in itemDef.Behaviors)
{
var placeDef = behaviorDef as EdgePlacerBehaviorDefinition;
if (placeDef == null || placeDef.Placed != cfg.Placed)
{
continue;
}
validPlacedType = true;
break;
}
if (validPlacedType)
{
break;
}
}
if (!validPlacedType)
{
MyEventContext.ValidationFailed();
MySession.Static.Log.Warning(
$"{holderPlayer} tried to place {cfg.Placed}, but has no item that can place it");
return;
}
var layer = MySession.Static.Components.Get <BendyController>().GetOrCreateLayer(def.Layer);
var annotated = AnnotateNodes(layer, segments);
var tmp = new List <string>();
if (!ValidatePath(def, layer, annotated, tmp))
{
holderPlayer.ShowNotification(string.Join("\n", tmp));
MyEventContext.ValidationFailed();
return;
}
}
#endregion
var graph = MySession.Static.Components.Get <BendyController>().GetOrCreateLayer(def.Layer);
for (var i = 1; i < segments.Length; i++)
{
var nextNode = graph.GetOrCreateNode(segments[i - 1]);
var prevNode = graph.GetOrCreateNode(segments[i]);
if (graph.GetEdge(prevNode, nextNode) != null)
{
continue;
}
var obContainer = new MyObjectBuilder_ComponentContainer();
var worldMatrix = MatrixD.CreateWorld((prevNode.Position + nextNode.Position) / 2,
Vector3D.Normalize(nextNode.Position - prevNode.Position),
Vector3D.Normalize(nextNode.Up + prevNode.Up));
var worldMatrixInv = MatrixD.Invert(worldMatrix);
((ICollection <MyObjectBuilder_EntityComponent>)obContainer.Components).Add(
new MyObjectBuilder_BendyComponent()
{
Overrides = new[]
{
new MyObjectBuilder_BendyComponent.NodePose
{
Index = 0,
Position = (Vector3)Vector3D.Transform(prevNode.Position, worldMatrixInv),
Up = (Vector3)Vector3D.Transform(prevNode.Up, worldMatrixInv)
},
new MyObjectBuilder_BendyComponent.NodePose
{
Index = 1,
Position = (Vector3)Vector3D.Transform(nextNode.Position, worldMatrixInv),
Up = (Vector3)Vector3D.Transform(nextNode.Up, worldMatrixInv)
}
}
});
var entOb = new MyObjectBuilder_EntityBase()
{
EntityDefinitionId = (MyDefinitionId)cfg.Placed,
PersistentFlags = MyPersistentEntityFlags2.InScene,
PositionAndOrientation = new MyPositionAndOrientation(worldMatrix),
SubtypeName = cfg.Placed.SubtypeId,
ComponentContainer = obContainer
};
var entity = MyAPIGateway.Entities.CreateFromObjectBuilderAndAdd(entOb);
if (holderPlayer != null && holderPlayer.IsCreative())
{
entity.Components.Get <ConstructableComponent>()?.InstallFromCreative();
ConstructableComponentDefinition.CcComponent test;
int test2;
entity.Components.Get <ConstructableComponent>()
?.IncreaseIntegrity(1e9f, out test, out test2);
}
entity.Components.Get <BendyPhysicsComponent>()?.DestroyEnvItems();
EntityAdded?.Invoke(holderEntity, holderPlayer, entity);
}
}
private void OnEntityAdded(object sender, EntityCollectionChangedEventArgs <TLinkTable> e)
{
EntityAdded?.Invoke(this, new EntityCollectionChangedEventArgs <TEntity>(_getEntity(e.Entity)));
}