コード例 #1
0
 public TransmissibleType BeginDrain(OnTransmissibleComplete callback)
 {
     if (m_state == State.Full)
     {
         m_state    = State.Draining;
         m_callback = callback;
         return(m_type);
     }
     return(null);
 }
コード例 #2
0
 public bool BeginInfuse(TransmissibleType type, OnTransmissibleComplete callback)
 {
     if (m_state == State.Empty)
     {
         this.type  = type;
         m_state    = State.Infusing;
         m_callback = callback;
         return(true);
     }
     return(false);
 }
コード例 #3
0
 public void MakeEmpty()
 {
     m_state    = State.Empty;
     m_callback = null;
     m_progress = 0.0f;
 }
コード例 #4
0
    // Update is called once per frame
    protected override void Update()
    {
        base.Update();

        // Update appearance
        foreach (var r in m_renderers)
        {
            r.material.SetFloat("_Progress", m_progress);
            if (m_type.animateUVs != Vector2.zero)
            {
                Vector2 offset = r.material.GetTextureOffset("_MainTex");
                offset += m_type.animateUVs * Time.deltaTime;
                r.material.SetTextureOffset("_MainTex", offset);
            }
        }

        float drainDelta = 1.0f / m_type.timeToDrain * Time.deltaTime;

        switch (m_state)
        {
        case State.Infusing:
            m_progress = Mathf.Clamp01(m_progress + drainDelta);
            if (m_progress == 1.0f)
            {
                m_callback(this);
                m_callback = null;
                m_state    = State.Full;
                if (onFilled != null)
                {
                    onFilled.Invoke();
                }
            }
            break;

        case State.Draining:
            m_progress = Mathf.Clamp01(m_progress - drainDelta);
            if (m_progress == 0.0f)
            {
                m_callback(this);
                m_callback = null;
                m_state    = State.Empty;
            }
            break;

        case State.InfuseCancelled:
            m_progress = Mathf.Clamp01(m_progress - drainDelta * 2.0f);
            if (m_progress == 0.0f)
            {
                m_state = State.Empty;
            }
            break;

        case State.DrainCancelled:
            m_progress = Mathf.Clamp01(m_progress + drainDelta * 2.0f);
            if (m_progress == 1.0f)
            {
                m_state = State.Full;
            }
            break;
        }

        // Inert properties
        if (m_progress < 1.0f)
        {
            foreach (var c in m_colliders)
            {
                c.isTrigger = true;
            }

            if (m_rigidbody)
            {
                m_rigidbody.isKinematic = true;
            }
        }
        else if (m_progress == 1.0f)
        {
            foreach (var c in m_colliders)
            {
                c.isTrigger = m_type.hasCollisions == false || m_type.bouyancy > 0;
            }

            if (m_rigidbody)
            {
                m_rigidbody.isKinematic = !m_type.hasRigidbody;
                //m_rigidbody.SetDensity(m_type.density);
            }
        }

        if (m_type.transmitPower && m_progress == 1)
        {
            m_providesPower = true;
        }
        else if (m_type.generatePower && m_progress == 1)
        {
            m_providesPower      = true;
            m_internalPowerLevel = 1;
        }
        else
        {
            m_providesPower      = false;
            m_internalPowerLevel = 0;
        }
    }