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(); }
public void OnEntityRemoved(EntityRemoved message) { foreach (var shipSpawner in Components) { shipSpawner.Targets.Remove(message.Entity); } }
protected virtual void OnEntityRemoved(Entity e) { if (e.UsingPool != null) { e.UsingPool.myPool.ReturnToPool(e, ref e.UsingPool.active); } EntityRemoved?.Invoke(this, e); }
private void ClearEntities() { foreach (var entity in Entities) { EntityRemoved?.Invoke(this, new CharacterArgs(entity.Value)); } Entities.Clear(); }
public override bool Remove(Entity item) { EntityRemoved?.Invoke(this, item); if (item is EntityVisible visible) { drawablesMap.Remove(visible); } return(base.Remove(item)); }
/// <summary> /// Raises the Entity Added event /// </summary> /// <param name="args">The event args</param> protected void OnEntityRemoved(CacheObjectEventArgs args) { var handler = EntityRemoved; if (handler != null) { EntityRemoved.Invoke(this, args); } }
private void RemoveOldEntitiesFromCache() { foreach (var current in Entities) { EntityRemoved?.Invoke(current); current.IsInList = false; } entityCache.Clear(); }
public void OnEntityRemoved(EntityRemoved message) { // If an entity was removed from the system we want to make sure // that no AI is targeting it anymore. Otherwise the id may be // re-used before the AI is updated, leading to bad references. foreach (var ai in Components) { ai.OnEntityInvalidated(message.Entity); } }
public bool RemoveEntity(Character entity) { var success = Entities.TryRemove(entity.Id, out entity); if (success) { EntityRemoved?.Invoke(this, new CharacterArgs(entity)); } return(success); }
protected virtual void OnEntityRemoved(Entity e) { if (e.UsingPool != null && e.PreventReturnToPoolOnDetach == false) { e.UsingPool.myPool.ReturnToPool(e, ref e.UsingPool.active); } EntityRemoved?.Invoke(this, e); }
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 bool RemoveEntity(Character character) { var success = Entities.TryRemove(character.Id, out character); if (success) { EntityRemoved?.Invoke(this, new CharacterArgs(character)); } return(success); }
public void OnEntityRemoved(EntityRemoved message) { // An item was removed, unequip it everywhere. foreach (var slot in Components) { if (slot.Item == message.Entity) { slot.Item = 0; } } }
private void RemoveEntity(IEntity entity) { if (!_entities.Remove(entity)) { return; } entity.WorldChanged -= OnEntityWorldChanged; entity.Removed -= OnEntityRemoved; EntityRemoved?.Invoke(this, new EntityEventArgs(entity)); }
public void OnEntityRemoved(EntityRemoved message) { // Unset owner for all components where the removed entity // was the owner. foreach (var component in Components) { if (component.Value == message.Entity) { component.Value = 0; } } }
/// <summary> /// Destroy the entity with the given ID. Notifies all systems that the entity has been removed. /// </summary> /// <param name="entityId">The ID of the entity to destroy.</param> public void DestroyEntity(uint entityId) { int entityBitmask = GetEntityBitmask(entityId); int componentIndex; for (componentIndex = 0; componentIndex < entityTable.GetLength(ComponentRows); componentIndex++) { entityTable[componentIndex, entityId] = null; } entityInWorld[entityId] = false; EntityRemoved?.Invoke(this, new EntityEventArgs(entityId, entityBitmask)); }
protected void RemoveEntity(RailEntityBase entity) { if (entities.ContainsKey(entity.Id)) { entities.Remove(entity.Id); entity.RoomBase = null; entity.Removed(); // TODO: Pooling entities? HandleRemovedEntity(entity.Id); EntityRemoved?.Invoke(entity); } }
public void Remove(IEntity entity) { if (!Entities.ContainsKey(entity.ID)) { return; } entity = Entities[entity.ID]; entity.ComponentAdded -= ComponentAdded; entity.ComponentRemoved -= ComponentRemoved; Entities.Remove(entity.ID); EntityRemoved?.Invoke(this, new EntityRemovedEventArgs(entity)); }
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(); }
public void RemoveFromMap(Entity entity) { if (m_EntityIdToCoordinate.ContainsKey(entity.Id)) { entity.EntityKilled -= RemoveFromMap; Coordinate current = m_EntityIdToCoordinate[entity.Id]; if (m_CoordinateToMapTile.ContainsKey(current)) { m_CoordinateToMapTile[current].entities.Remove(entity); } m_EntityIdToCoordinate.Remove(entity.Id); EntityRemoved?.Invoke(this, new EntityArgs() { entity = entity, coordinate = current }); } }
private void UpdateEntityCollections() { OnlyValidEntities.Clear(); NotOnlyValidEntities.Clear(); NotValidDict.Clear(); foreach (var e in ValidEntitiesByType) { e.Value.Clear(); } while (keysForDelete.Count > 0) { var key = keysForDelete.Dequeue(); if (entityCache.TryGetValue(key, out var entity)) { EntityRemoved?.Invoke(entity); entityCache.Remove(key); } } foreach (var entity in entityCache) { var entityValue = entity.Value; if (entityValue.IsValid) { OnlyValidEntities.Add(entityValue); ValidEntitiesByType[entityValue.Type].Add(entityValue); } else { NotOnlyValidEntities.Add(entityValue); NotValidDict[entityValue.Id] = entityValue; } } }
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); } } }
public virtual void OnEntityRemoved(T entity) { EntityRemoved?.Invoke(entity); }
protected internal void OnEntityRemoved(EntityEventArgs args) { args.Entity.ComponentAdded -= HandleComponentAdded; args.Entity.ComponentRemoved -= HandleComponentRemoved; EntityRemoved?.Invoke(this, args); }
private void OnEntityRemoved(Entity entity) { EntityRemoved?.Invoke(entity); }
protected virtual void OnEntityRemoved(Entity e) { EntityRemoved?.Invoke(this, e); }
/// <summary> /// Removes a child entity from this container /// </summary> /// <param name="child"></param> internal void RemoveChild(Entity child) { children.Remove(child); EntityRemoved?.Invoke(child); }
public static void RegisterRemovedCallback <T>(this EntityRef <T> entityRef, EntityRemoved <T> funcs) where T : class { entityRef.ParentPool.RegisterRemovedEvent(entityRef, funcs); }
private void OnEntityRemoved(object sender, EntityCollectionChangedEventArgs <TLinkTable> e) { EntityRemoved?.Invoke(this, new EntityCollectionChangedEventArgs <TEntity>(_getEntity(e.Entity))); }
private static void RemoveEdge(long removerEntityId, long entityIdToRemove) { MyEntity holderEntity; MyEntities.TryGetEntityById(removerEntityId, out holderEntity); var holderPlayer = holderEntity != null ? MyAPIGateway.Players.GetPlayerControllingEntity(holderEntity) : null; MyEntity removeEntity = null; MyEntities.TryGetEntityById(entityIdToRemove, out removeEntity); if (removeEntity == 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 && !MyAreaPermissionSystem.Static.HasPermission( holderPlayer.IdentityId, removeEntity.GetPosition(), MyPermissionsConstants.QuickDeconstruct)) { holderPlayer.ShowNotification("You cannot quick deconstruct here", 2000, null, new Vector4(1, 0, 0, 1)); return; } string err; if (!ValidateQuickRemove(holderPlayer, removeEntity, out err)) { MyEventContext.ValidationFailed(); if (!string.IsNullOrEmpty(err)) { holderPlayer.ShowNotification(err, 2000, null, new Vector4(1, 0, 0, 1)); } return; } } #endregion var block = removeEntity?.Get <MyBlockComponent>(); if (block != null) { block.GridData.RemoveBlock(block.Block); } else { removeEntity.Close(); } EntityRemoved?.Invoke(holderEntity, holderPlayer, removeEntity); }