unity slider2d分隔式血条加减血效果跟随人物移动 以及相机跟随（详细）

主要是用血条管理处理 简单加了个相机跟随主角移动。血条使用了分隔处理和多层处理的减血效果。如图：

分隔处理参考了其他小伙伴的文字就是重写方法 多层减血效果是直接改了slider脚本。

介绍如下：

       1 血条ui结构。

       2 重写的Myslider脚本，和分隔脚本（当然可以写一起）BloodImage。

       3 血条脚本控制器hudController;

       4 血条管理器HudManger。

       5 相机跟随脚本 caremaFllow。

      6  范围判断减血RangeDetermiantion。

      7 游戏启动管理器Gamemanger。

      8 移动脚本前面发了文章的。

内容开始：

 1 血条ui结构如图：

 

 

细节图：

 

 2 重写的Myslider脚本，和分隔脚本（当然可以写一起）BloodImage。

 

（1）：BloodImage使用：血条图片使用texture;

脚本BloodImage ：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;


public class BloodImage : RawImage
{

    private MySlider _BloodSlider;

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

        //获取血条
        if (_BloodSlider == null)
            _BloodSlider = transform.parent.parent.GetComponent<MySlider>();

        //获取血条的值
        if (_BloodSlider != null)
        {
            //刷新血条的显示
            float value = _BloodSlider.value;
            uvRect = new Rect(0, 0, value, 1);
        }
    }
}

MySlider脚本：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;




namespace UnityEngine.UI
{
    [AddComponentMenu("UI/Slider", 33)]
    [RequireComponent(typeof(RectTransform))]
    public class MySlider : Selectable, IDragHandler, IInitializePotentialDragHandler, ICanvasElement
    {
        public enum Direction
        {
            LeftToRight,
            RightToLeft,
            BottomToTop,
            TopToBottom,
        }
        private float m_ReductionTime = 0f;
        private float delayTime = 0.1f;
        public float ReductionTime { get { return m_ReductionTime; } set { this.value = m_ReductionTime; } }
        [Serializable]
        public class SliderEvent : UnityEvent<float> { }

        [SerializeField]
        private RectTransform m_FillRect;
        public RectTransform fillRect { get { return m_FillRect; } set { if (MySetPropertyUtility.SetClass(ref m_FillRect, value)) { UpdateCachedReferences(); UpdateVisuals(); } } }
        [SerializeField]
        private RectTransform m_ScondFillRect;
        public RectTransform ScondfillRect { get { return m_ScondFillRect; } /*set { if (MySetPropertyUtility.SetClass(ref m_ScondFillRect, value)) {  } }*/ }//SetSecondValue();

        [SerializeField]
        private RectTransform m_HandleRect;
        public RectTransform handleRect { get { return m_HandleRect; } set { if (MySetPropertyUtility.SetClass(ref m_HandleRect, value)) { UpdateCachedReferences(); UpdateVisuals(); } } }

        [Space]

        [SerializeField]
        private Direction m_Direction = Direction.LeftToRight;
        public Direction direction { get { return m_Direction; } set { if (MySetPropertyUtility.SetStruct(ref m_Direction, value)) UpdateVisuals(); } }

        [SerializeField]
        private float m_MinValue = 0;
        public float minValue { get { return m_MinValue; } set { if (MySetPropertyUtility.SetStruct(ref m_MinValue, value)) { Set(m_Value); UpdateVisuals(); } } }

        [SerializeField]
        private float m_MaxValue = 1;
        public float maxValue { get { return m_MaxValue; } set { if (MySetPropertyUtility.SetStruct(ref m_MaxValue, value)) { Set(m_Value); UpdateVisuals(); } } }

        [SerializeField]
        private bool m_WholeNumbers = false;
        public bool wholeNumbers { get { return m_WholeNumbers; } set { if (MySetPropertyUtility.SetStruct(ref m_WholeNumbers, value)) { Set(m_Value); UpdateVisuals(); } } }

        [SerializeField]
        protected float m_Value;
        public virtual float value
        {
            get
            {
                if (wholeNumbers)
                    return Mathf.Round(m_Value);
                return m_Value;
            }
            set
            {
                Set(value);
            }
        }

        public float normalizedValue
        {
            get
            {
                if (Mathf.Approximately(minValue, maxValue))
                    return 0;
                return Mathf.InverseLerp(minValue, maxValue, value);
            }
            set
            {
                this.value = Mathf.Lerp(minValue, maxValue, value);
            }
        }

        [Space]

        // Allow for delegate-based subscriptions for faster events than 'eventReceiver', and allowing for multiple receivers.
        [SerializeField]
        private SliderEvent m_OnValueChanged = new SliderEvent();
        public SliderEvent onValueChanged { get { return m_OnValueChanged; } set { m_OnValueChanged = value; } }

        // Private fields
        private Vector2 targetMin;
        private Vector2 targetMax;
        private Vector2 originMin;
        private Vector2 originMax;
        //last target 
        private Vector2 lastTargetMax;


        private Image m_FillImage;
        private Image m_ScondFillImage;
        private Transform m_FillTransform;
        private RectTransform m_FillContainerRect;
        private Transform m_HandleTransform;
        private RectTransform m_HandleContainerRect;
       

        // The offset from handle position to mouse down position
        private Vector2 m_Offset = Vector2.zero;

        private DrivenRectTransformTracker m_Tracker;

        // Size of each step.
        float stepSize { get { return wholeNumbers ? 1 : (maxValue - minValue) * 0.1f; } }

        //protected Slider()
        //{ }

#if UNITY_EDITOR
        protected override void OnValidate()
        {
            base.OnValidate();

            if (wholeNumbers)
            {
                m_MinValue = Mathf.Round(m_MinValue);
                m_MaxValue = Mathf.Round(m_MaxValue);
            }

            //Onvalidate is called before OnEnabled. We need to make sure not to touch any other objects before OnEnable is run.
            if (IsActive())
            {
                UpdateCachedReferences();
                Set(m_Value, false);
                // Update rects since other things might affect them even if value didn't change.
                UpdateVisuals();
            }

            var prefabType = UnityEditor.PrefabUtility.GetPrefabType(this);
            if (prefabType != UnityEditor.PrefabType.Prefab && !Application.isPlaying)
                CanvasUpdateRegistry.RegisterCanvasElementForLayoutRebuild(this);
        }

#endif // if UNITY_EDITOR

        public virtual void Rebuild(CanvasUpdate executing)
        {
#if UNITY_EDITOR
            if (executing == CanvasUpdate.Prelayout)
                onValueChanged.Invoke(value);
#endif
        }

        public virtual void LayoutComplete()
        { }

        public virtual void GraphicUpdateComplete()
        { }

        protected override void OnEnable()
        {
            base.OnEnable();
            UpdateCachedReferences();
            Set(m_Value, false);
            // Update rects since they need to be initialized correctly.
            UpdateVisuals();
        }

        protected override void OnDisable()
        {
            m_Tracker.Clear();
            b