Ejemplo n.º 1
0
    //-----------------------------------------------------------------------------------------------------------------
    //-----------------------------------------------------------------------------------------------------------------
    void ChangeAimPhase(E_AimPhase NewPhase)
    {
        if (Audio != null)
        {
            float coef = 0.0f;

            if ((Audio.isPlaying == true) && (m_AimPhase != E_AimPhase.InProgress))
            {
                coef = 1.0f - Audio.time / Audio.clip.length;
            }

            Audio.Stop();
            Audio.clip = null;
            Audio.loop = false;

            switch (NewPhase)
            {
            case E_AimPhase.Starting:
            {
                if (m_SndSettings.m_AimingStart != null)
                {
                    Audio.clip = m_SndSettings.m_AimingStart;
                    Audio.time = coef * Audio.clip.length;
                }
            }
            break;

            case E_AimPhase.InProgress:
            {
                Audio.clip = m_SndSettings.m_AimingLoop;
                Audio.loop = true;
            }
            break;

            case E_AimPhase.Stopping:
            {
                if (m_SndSettings.m_AimingStop != null)
                {
                    Audio.clip = m_SndSettings.m_AimingStop;
                    Audio.time = coef * Audio.clip.length;
                }
            }
            break;
            }

            Audio.Play();
        }

        m_AimPhase = NewPhase;
    }
Ejemplo n.º 2
0
    //-----------------------------------------------------------------------------------------------------------------
    //-----------------------------------------------------------------------------------------------------------------
    void UpdateAiming(float DeltaTime)
    {
        bool aiming         = false;
        bool dirInTolerance = Mathf.Max(m_HMotor.AbsDiff, m_VMotor.AbsDiff) <= 1.0f * Mathf.Deg2Rad;

        if (dirInTolerance)
        {
            tm = 0.0f;
        }
        else
        {
            tm    += DeltaTime;
            aiming = tm > 0.1f;
        }

        // update aiming direction...

        m_HMotor.Update(DeltaTime);
        m_VMotor.Update(DeltaTime);

        m_AimDir = MathUtils.AnglesToVector(m_PartsSettings.m_Base.forward,
                                            m_PartsSettings.m_Base.up,
                                            m_HMotor.Angle,
                                            m_VMotor.Angle);

        m_PartsSettings.m_Neck.rotation = Quaternion.LookRotation(m_AimDir, m_PartsSettings.m_Base.up);

        // update aiming phase, sounds,...

        E_AimPhase prevPhase = m_AimPhase;

        if (aiming)
        {
            if ((m_AimPhase == E_AimPhase.Idle) || (m_AimPhase == E_AimPhase.Stopping))
            {
                ChangeAimPhase(E_AimPhase.Starting);
            }
        }
        else
        {
            if ((m_AimPhase == E_AimPhase.Starting) || (m_AimPhase == E_AimPhase.InProgress))
            {
                ChangeAimPhase(E_AimPhase.Stopping);
            }
        }

        if (prevPhase == m_AimPhase)
        {
            if ((Audio == null) || (Audio.isPlaying == false))
            {
                if (m_AimPhase == E_AimPhase.Starting)
                {
                    ChangeAimPhase(E_AimPhase.InProgress);
                }
                else if (m_AimPhase == E_AimPhase.Stopping)
                {
                    ChangeAimPhase(E_AimPhase.Idle);
                }
            }
        }

        // set new target direction...

        if (m_Target.m_Agent != null)
        {
            float   angleH = 0.0f;
            float   angleV = 0.0f;
            Vector3 tarDir = Vector3.Normalize(m_Target.m_LastVisiblePos - m_PartsSettings.m_Neck.position);

            MathUtils.VectorToAngles(m_PartsSettings.m_Base.forward,
                                     m_PartsSettings.m_Base.up,
                                     tarDir,
                                     ref angleH,
                                     ref angleV);

            m_HMotor.TargetAngle = angleH;
            m_VMotor.TargetAngle = angleV;
        }
        else if (!OutOfAmmo)
        {
            m_HMotor.TargetAngle = m_InitHAngle;
            m_VMotor.TargetAngle = m_InitVAngle;
        }
    }