Example #1
0
        public void DeleteSelected()
        {
            bool          UpdateRequired = false;
            List <Entity> pendingDelete  = new List <Entity>();

            foreach (Entity entity in GetEntities())
            {
                if (entity.Selected == true)
                {
                    pendingDelete.Add(entity);
                    UpdateRequired = true;
                }
            }

            foreach (Entity entity in pendingDelete)
            {
                OnEntityRemove?.Invoke(this, entity, EventArgs.Empty);

                entity.parent.Children.Remove(entity);
            }

            if (UpdateRequired == true)
            {
                Invalidate();

                OnEntityCountChanged?.Invoke(this, EventArgs.Empty);
            }

            if (entityGrid != null)
            {
                entityGrid.SelectedObject = null;
            }

            SetDestinationNode(root);
        }
Example #2
0
        public void RemoveEntity(Entity entity)
        {
            entity.parent.Children.Remove(entity);

            OnEntityRemove?.Invoke(this, entity, EventArgs.Empty);

            OnEntityCountChanged?.Invoke(this, EventArgs.Empty);
        }
Example #3
0
        /*
         * @brief 實體更新
         * @param id [in] 組件編號
         * @note 限定管理器使用
         */
        public void UpdateEntity(T entity, int id, IComponent oldComponent, IComponent newComponent)
        {
            if (HasEntity(entity) == false)
            {
                return;
            }

            OnEntityRemove?.Invoke(this, entity);
            OnEntityAdd?.Invoke(this, entity);
            OnEntityUpdate?.Invoke(this, entity, id, oldComponent, newComponent);
        }
Example #4
0
        /*
         * @brief 移除實體
         * @param id [in] 組件編號
         */
        private void RemoveEntity(T entity, int id, IComponent component)
        {
            var res = entities.Remove(entity);

            if (res)
            {
                entitiesCache = null;

                OnEntityRemove?.Invoke(this, entity);

                entity.RemoveRef(this);
            }
        }
Example #5
0
        public void DeleteAllEntites()
        {
            foreach (Entity entity in GetEntities())
            {
                OnEntityRemove?.Invoke(this, entity, EventArgs.Empty);
            }

            root.Children.Clear();
            Invalidate();

            OnEntityCountChanged?.Invoke(this, EventArgs.Empty);

            SetDestinationNode(root);
        }
        /// <summary>
        /// Removes a entity from the simulation with a entity id.
        /// </summary>
        /// <param name="key">The entity Id used to determine who is being removed from the simulation.</param>
        /// <param name="reason"></param>
        public void RemoveEntity(string key, EntityRemovalReason?reason = null)
        {
            bool isPlayer = false;

            lock (_lock)
            {
                if (_entitiesIndex.ContainsKey(key))
                {
                    SimulationEntity entity = _entitiesIndex[key];

                    //Remove from chunk
                    World.ChunkIndex[entity.ChunkKey].Entities.Remove(key);

                    //remove from entity index
                    _entitiesIndex.Remove(key);

                    //remove from player index if a player
                    if (_playerEntitiesIndex.ContainsKey(key))
                    {
                        _playerEntitiesIndex.Remove(key);
                        isPlayer = true;
                    }

                    entity.EmitOnSimulationRemoval(this, reason);
//                    EmitRemoveEntity(entity, reason);
                    GameMode?.EmitEntityRemove(this, entity, reason);
                }

                if (_playerEntitiesIndex.Count == 0 && _state == SimulationState.Running)
                {
                    Stop();
                }
            }

            OnEntityRemove?.Invoke(key, isPlayer);
        }