ModulGunController

using UnityEngine;
using System.Collections;

public class ModulGunController : ModulBasys
{
    private ModulGunControllerConfig modulConfig;

    //[SerializeField]
    //Transform gunTransform;

    [Header("Ось вращения")]
    [SerializeField]
    rotateAxis rotationAxis;

    [Header("Обьекты вращения")]
    [Tooltip("Обьект вращения по оси Х")]
    public Transform transformRotationX;
    [Tooltip("Обьект вращения по оси Y")]
    public Transform transformRotationY;

    private float tempAngle = 0;
    private Vector3 gunTarget;
    private float oldRotationY;

    public override UsedEnergy NextUsedEnergy
    {
        get { return currentUsedEnergy; }
        set
        {
            currentUsedEnergy = value;

            switch (value)
            {

                case UsedEnergy.Default:
                    {
                        eRQ_Current = modulConfig.eRQ_Default;
                        break;
                    }

                case UsedEnergy.Armore:
                    {
                        eRQ_Current = modulConfig.eRQ_Armore;
                        break;
                    }

                case UsedEnergy.Speed:
                    {
                        eRQ_Current = modulConfig.eRQ_Speed;
                        break;
                    }

                case UsedEnergy.Weapon:
                    {
                        eRQ_Current = modulConfig.eRQ_Weapon;
                        break;
                    }

                case UsedEnergy.Custom:
                    {
                        eRQ_Current = modulConfig.eRQ_Custom;
                        break;
                    }

                case UsedEnergy.None:
                    {
                        eRQ_Current = 0;
                        break;
                    }
            }
        }
    }

    protected override float EnergyPower
    {
        get { return energyPower; }

        set
        {
            energyPower = Mathf.Clamp(value, 0, modulConfig.maxUsedEnergy);
        }
    }

    //Через данный метод назначаем новый конфиг модулю
    public override void SetNewModul(int value, ModulType type)
    {
        ListModulConfig config = Resources.Load("Config/ModulConfig") as ListModulConfig;
        modulConfig = config.GetGunControllerConfig(type, value);
        InstanceNewModul(modulConfig);
    }

    protected override void InstanceNewModul(ModulBasysConfig modulConfig)
    {
        //Создаем обьект - мешь данного модуля
        if (loadMesh == true)
        {
            if (modulConfig.modulMesh == null)
            {
                Debug.LogError("Dont set mesh in modul config");
                return;
            }

            GameObject tmp = Instantiate(modulConfig.modulMesh);
            tmp.transform.SetParent(thisTransform);
            tmp.transform.localPosition = Vector3.zero;
            tmp.transform.localRotation = Quaternion.identity;

            transformRotationY = tmp.transform;
            transformRotationX = tmp.transform.GetChild(0);
        }
    }

    public override float ReloadEnergy(float reloadEnergy)
    {
        if (EnergyPower < (reloadEnergy / 100) * eRQ_Current)
        {
            EnergyPower = (reloadEnergy / 100) * eRQ_Current;
            return EnergyPower;
        }

        return 0;
    }

    protected override void OnEnable()
    {
        base.OnEnable();

        gunTarget = transform.TransformPoint(Vector3.forward * 500);
    }

    void LateUpdate()
    {
        if (ModulStatus == ModulStatus.On)
        {
            if (rotationAxis == rotateAxis.AxisX || rotationAxis == rotateAxis.AxisXY)
            {
                if (transformRotationX != null)
                {
                    transformRotationX.localEulerAngles = RotationAxisX(transformRotationX);
                }
                else
                {
                    //Debug.LogError("Dont set transformRotationX");
                }
            }

            if (rotationAxis == rotateAxis.AxisY || rotationAxis == rotateAxis.AxisXY)
            {
                if (transformRotationY != null)
                {
                    transformRotationY.localEulerAngles = RotationAxisY(transformRotationY);
                }
                else
                {
                    // Debug.LogError("Dont set transformRotationY");
                }
            }
        }
    }

    private Quaternion GetDirection(Transform tempTransform)
    {
        //вектор, куда нужно вращать башню
        return Quaternion.LookRotation(gunTarget - tempTransform.position);
    }

    float SpeedRotation()
    {
        return (EnergyPower * modulConfig.speedRotateDefault) * Time.deltaTime;
    }

    public override void SetLookDirection(Vector3 pointTarget)
    {
        gunTarget = pointTarget;
    }

    private Vector3 RotationAxisY(Transform rotateTransform)
    {
        rotateTransform.rotation = Quaternion.RotateTowards(rotateTransform.rotation, GetDirection(rotateTransform), SpeedRotation());

        //Debug.DrawLine(gunTarget, rotateTransform.position, Color.yellow);
        //Debug.DrawLine(rotateTransform.position, rotateTransform.TransformPoint(Vector3.forward * 100), Color.blue);

        tempAngle = 0;

        tempAngle = rotateTransform.localEulerAngles.y;

        if (rotateTransform.localEulerAngles.y > 180f)
        {
            //если значение Y больше 180, то используем ограничение между 360 и максимальним ограничением
            tempAngle = Mathf.Clamp(tempAngle, 360f - modulConfig.rangeAngleGun, 360f);
        }
        else
        {
            if (transformRotationY.localEulerAngles.y < 180f)
            {
                //если значение Y меньше 180, то ограничение используем между 0 и минимальным ограничением
                tempAngle = Mathf.Clamp(tempAngle, 0f, modulConfig.rangeAngleGun);
            }
        }

        return new Vector3(0, tempAngle, 0);
    }

    private Vector3 RotationAxisX(Transform rotateTransform)
    {
        rotateTransform.rotation = Quaternion.RotateTowards(rotateTransform.rotation, GetDirection(rotateTransform), SpeedRotation());

        //Debug.DrawLine(gunTarget, rotateTransform.position, Color.yellow);
        //Debug.DrawLine(rotateTransform.position, rotateTransform.TransformPoint(Vector3.forward * 100), Color.blue);

        tempAngle = 0;

        tempAngle = rotateTransform.localEulerAngles.x;

        if (rotateTransform.localEulerAngles.x > 180f)
        {
            tempAngle = Mathf.Clamp(tempAngle, 360f - modulConfig.rangeAngleGun, 360f);
        }
        else
        {
            if (rotateTransform.localEulerAngles.x < 180f)
            {
                tempAngle = Mathf.Clamp(tempAngle, 0f, modulConfig.rangeAngleGun);
            }
        }

        return new Vector3(tempAngle, 0, 0);
    }

    private void Action(Transform rotateTransform)
    {
        if (oldRotationY != Mathf.RoundToInt(rotateTransform.localEulerAngles.y))
        {
            oldRotationY = Mathf.RoundToInt(rotateTransform.localEulerAngles.y);
            ActionModul(EnergyPower);
        }
    }

    //Вызывается из метода включеия данного модуля (SetModulStatus) и вызывает делегат,
    //назначающий данный модуль в класс UI_BotAimController
    protected override void CallDelegate(bool call)
    {
        if (call == true)
        {
            if (botController.GameStatus == GameStatus.PlayerControl)
            {
                //Debug.Log("AddDelegate " + name + "  " + botController.gameStatus.ToString());

                if (EventController.Singleton.d_SetNewModul != null)
                {
                    EventController.Singleton.d_SetNewModul(this);
                }
            }
        }
        else
        {
            //Вызываем делегат, на который подписан класс UI_BotAimController
            if (EventController.Singleton != null && EventController.Singleton.d_ModulClear != null)
            {
                //Debug.Log("ModulClear " + this + " " + botController.name);
                EventController.Singleton.d_ModulClear(this);
            }
        }
    }
}