コード例 #1
0
    void Update()
    {
        int  energy = CalculateEnergy();
        bool isOn   = energy >= threshold;

        if (isOn && !wasOn)
        {
            AddActivator(null); // make sure sensor is on
            foreach (EntityComponent activator in activatorCounts.Keys)
            {
                AddActivator(activator);
            }
        }
        else if (wasOn && !isOn)
        {
            ClearActivators();
        }
        wasOn = isOn;

        foreach (var input in inputs)
        {
            EntityComponent e = input.entityRef.component;
            if (e == null)
            {
                continue;
            }
            foreach (var newActivator in e.GetNewActivators())
            {
                if (input.negative)
                {
                    DecrInputActivator(newActivator);
                }
                else
                {
                    IncrInputActivator(newActivator);
                }
            }
            foreach (var removedActivator in e.GetRemovedActivators())
            {
                if (input.negative)
                {
                    IncrInputActivator(removedActivator);
                }
                else
                {
                    DecrInputActivator(removedActivator);
                }
            }
        }
    }
コード例 #2
0
    void Update()
    {
        float           time        = Time.time;
        EntityComponent inputEntity = input.component;

        foreach (var keyValue in delayedActivators)
        {
            DelayedActivator delayedA = keyValue.Value;
            if (delayedA.state == ActivatorState.TURNING_ON)
            {
                if (time - delayedA.changeTime >= onTime)
                {
                    delayedA.state = ActivatorState.ON;
                    AddActivator(delayedA.activator);
                }
            }
            else if (delayedA.state == ActivatorState.TURNING_OFF)
            {
                if (time - delayedA.changeTime >= offTime)
                {
                    delayedActivatorsToRemove.Add(keyValue.Key);
                    RemoveActivator(delayedA.activator);
                }
            }
        }
        foreach (EntityComponent e in delayedActivatorsToRemove)
        {
            delayedActivators.Remove(e);
        }
        delayedActivatorsToRemove.Clear();

        if (inputEntity == null)
        {
            return;
        }

        foreach (EntityComponent newActivator in inputEntity.GetNewActivators())
        {
            if (newActivator == null) // null is reserved for the net cycle
            {
                continue;
            }
            AddActivatorDelay(newActivator, newActivator, time);
        }

        foreach (EntityComponent removedActivator in inputEntity.GetRemovedActivators())
        {
            if (removedActivator == null) // null is reserved for the net cycle
            {
                continue;
            }
            RemoveActivatorDelay(removedActivator, removedActivator, time);
        }

        // net cycle
        bool inputIsOn = inputEntity.IsOn();

        if (inputIsOn && !inputWasOn)
        {
            AddActivatorDelay(nullKey, null, time);
        }
        else if (inputWasOn && !inputIsOn)
        {
            RemoveActivatorDelay(nullKey, null, time);
        }
        inputWasOn = inputIsOn;
    }