Пример #1
0
 protected virtual void ReleaseItem(object state)
 {
     if (state != null)
     {
         WeakReference reference = state as WeakReference;
         if (reference != null)
         {
             if (reference.IsAlive)
             {
                 IReleasable target = reference.Target as IReleasable;
                 if (target != null)
                 {
                     target.Release();
                 }
             }
             reference = null;
         }
     }
 }
Пример #2
0
        public void RemoveComponent <TComponent>(Entity <TEntity> entity, ComponentID <TEntity, TComponent> id) where TComponent : class
        {
            _threadAffinity.Validate();
            Assert.Debug(IsValid(entity), $"Invalid entity: Index: {entity.Index} CreationID: {entity.CreationIDCheck}");

            Assert.Debug((ushort)id.ComponentIndex < _maxComponentsPerEntity, "Component index out of range");

            int entityIndex    = entity.Index;
            int componentIndex = id.ComponentIndex;
            int offset         = entityIndex * _maxComponentsPerEntity + componentIndex;

            object      component           = _components[offset];
            IReleasable releasableComponent = component as IReleasable;

            if (releasableComponent != null)
            {
                releasableComponent.Release();
            }

            _components[offset] = null;

            componentFlags[entityIndex][componentIndex] = false;
        }
        public override bool Tick()
        {
            switch (State)
            {
            case RobotLoadTruckTask.TaskState.Init:
                _targetEntity.SetPathfindingTarget(_item.Position, _targetEntity.GetPathfindingGraph());
                _state = TaskState.MoveToItem;
                break;

            case RobotLoadTruckTask.TaskState.MoveToItem:
                if (!_targetEntity.IsAtDestination())
                {
                    break;
                }
                _state = TaskState.PickupCargo;
                break;

            case RobotLoadTruckTask.TaskState.PickupCargo:
                if (!_targetEntity.TryAddCargo(_item))
                {
                    break;
                }
                _state = TaskState.MoveToQueue;
                _targetEntity.SetPathfindingTarget(Constants.RobotEnterTruck, _targetEntity.GetPathfindingGraph());
                break;

            case RobotLoadTruckTask.TaskState.MoveToQueue:
                if (_targetEntity.IsAtDestination())
                {
                    _state = TaskState.AwaitTruckAvailable;
                }
                break;

            case RobotLoadTruckTask.TaskState.AwaitTruckAvailable:
                if (_truck.IsOccupied)
                {
                    break;
                }
                _lock = _truck.Occupy(_targetEntity);
                _targetEntity.SetTarget(_destination.PositionAbsolute);
                _state = TaskState.DropOffDestination;
                break;

            case RobotLoadTruckTask.TaskState.DropOffDestination:
                if (!_targetEntity.IsAtDestination())
                {
                    break;
                }
                _destination.SetCargo(_targetEntity.CargoSlots[0].ReleaseCargo());
                _targetEntity.SetTarget(Constants.RobotExitTruck);
                _state = TaskState.LeaveTruck;
                break;

            case RobotLoadTruckTask.TaskState.LeaveTruck:
                if (!_targetEntity.IsAtDestination())
                {
                    break;
                }

                _targetEntity.SetPathfindingTarget(_targetEntity.IdlePos, _targetEntity.GetPathfindingGraph());
                _lock.Release();
                _state           = TaskState.Finished;
                this._isFinished = true;
                break;

            case RobotLoadTruckTask.TaskState.Finished:
                break;
            }
            return(base.Tick());
        }