备份CatanBuilding瘦身独立工程

Assets/Scripts/EventWashing/Tools/BHitScreen.cs

@@ -0,0 +1,419 @@
+using CW.Common;
+using PaintCore;
+using PaintIn3D;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace game
+{
+    public class BHitScreen : BHitScreenBase
+    {
+        // This stores extra information for each finger unique to this component
+        protected class Link : CwInputManager.Link
+        {
+            public float Age;
+            public bool Down;
+            public int State;
+            public float Distance;
+            public Vector2 ScreenDelta;
+            public Vector2 ScreenOld;
+
+            public List<Vector2> History = new List<Vector2>();
+
+            public void Move(Vector2 screenNew)
+            {
+                if (State == 0)
+                {
+                    ScreenOld = screenNew;
+                    State = 1;
+                }
+                else
+                {
+                    if (TryMove(screenNew) == true || State == 2)
+                    {
+                        State += 1;
+                    }
+                }
+            }
+
+            private bool TryMove(Vector2 screenNew)
+            {
+                var threshold = 2.0f;
+                var distance = Vector2.Distance(ScreenOld, screenNew);
+
+                if (distance >= threshold)
+                {
+                    ScreenOld = Vector2.MoveTowards(ScreenOld, screenNew, distance - threshold * 0.5f);
+
+                    return true;
+                }
+
+                return false;
+            }
+
+            public override void Clear()
+            {
+                Age = 0.0f;
+                Down = false;
+                State = 0;
+                Distance = 0.0f;
+                ScreenDelta = Vector2.zero;
+                ScreenOld = Vector2.zero;
+
+                History.Clear();
+            }
+        }
+
+        public enum FrequencyType
+        {
+            PixelInterval,
+            ScaledPixelInterval,
+            TimeInterval,
+            OnceOnRelease,
+            OnceOnPress,
+            OnceEveryFrame
+        }
+
+        /// <summary>This allows you to control how often the screen is painted.
+        /// PixelInterval = Once every <b>Interval</b> pixels.
+        /// ScaledPixelInterval = Like <b>PixelInterval</b>, but scaled to the screen DPI.
+        /// TimeInterval = Once every <b>Interval</b> seconds.
+        /// OnceOnRelease = When the finger/mouse goes down a preview will be shown, and when it goes up the paint will apply.
+        /// OnceOnPress = When the finger/mouse goes down the paint will apply.
+        /// OnceEveryFrame = Every frame the paint will apply.</summary>
+        public FrequencyType Frequency { set { frequency = value; } get { return frequency; } }
+        [SerializeField] private FrequencyType frequency = FrequencyType.OnceEveryFrame;
+
+        /// <summary>This allows you to set the pixels/seconds between each hit point based on the current <b>Frequency</b> setting.</summary>
+        public float Interval { set { interval = value; } get { return interval; } }
+        [SerializeField] private float interval = 10.0f;
+
+        /// <summary>This allows you to connect the hit points together to form lines.</summary>
+        public CwPointConnector Connector { get { if (connector == null) connector = new CwPointConnector(); return connector; } }
+        [SerializeField] private CwPointConnector connector;
+
+        [System.NonSerialized]
+        private List<Link> links = new List<Link>();
+
+        /// <summary>This component sends hit events to a cached list of components that can receive them. If this list changes then you must manually call this method.</summary>
+        [ContextMenu("Clear Hit Cache")]
+        public void ClearHitCache()
+        {
+            Connector.ClearHitCache();
+        }
+
+        /// <summary>If this GameObject has teleported and you have <b>ConnectHits</b> or <b>HitSpacing</b> enabled, then you can call this to prevent a line being drawn between the previous and current points.</summary>
+        [ContextMenu("Reset Connections")]
+        public void ResetConnections()
+        {
+            connector.ResetConnections();
+        }
+
+        protected virtual void OnEnable()
+        {
+            foreach (var link in links)
+            {
+                link.Clear();
+            }
+
+            Connector.ResetConnections();
+
+            if (ShouldUpgradePointers() == true)
+            {
+                Debug.LogWarning("Upgrading CwHitScreen Controls - To remove this warning you can manually click the \"Upgrade\" button in the inspector of this component while outside of play mode.", gameObject);
+
+                TryUpgradePointers();
+            }
+        }
+
+        protected virtual void Update()
+        {
+            connector.Update();
+        }
+
+        public override void BreakFinger(CwInputManager.Finger finger)
+        {
+            var link = CwInputManager.Link.Find(links, finger);
+
+            if (link != null)
+            {
+                connector.BreakHits(link);
+            }
+        }
+
+        public override void HandleFingerUpdate(CwInputManager.Finger finger, bool down, bool up)
+        {
+            var link = CwInputManager.Link.Find(links, finger);
+            var set = true;
+
+            if (finger.Index < 0) // Preview?
+            {
+                if (CwInputManager.PointOverGui(finger.ScreenPosition, GuiLayers) == true)
+                {
+                    connector.BreakHits(link);
+
+                    return;
+                }
+            }
+            else
+            {
+                if (down == true)
+                {
+                    if (CwInputManager.PointOverGui(finger.ScreenPosition, GuiLayers) == true)
+                    {
+                        connector.BreakHits(link);
+
+                        return;
+                    }
+                }
+                else
+                {
+                    if (link == null)
+                    {
+                        return;
+                    }
+                }
+            }
+
+            if (link == null)
+            {
+                link = CwInputManager.Link.Create(ref links, finger);
+            }
+
+            link.Move(finger.ScreenPosition);
+
+            if (finger.Index < 0) // Preview?
+            {
+                RecordAndPaintAt(link, finger.ScreenPosition, link.ScreenOld, true, 0.0f, link);
+
+                return;
+            }
+
+            if (NeedsDrawAngle == true)
+            {
+                down = link.State == 2;
+                set = link.State >= 2;
+            }
+
+            if (set == true)
+            {
+                switch (frequency)
+                {
+                    case FrequencyType.PixelInterval: PaintSmooth(link, down, interval); break;
+                    case FrequencyType.ScaledPixelInterval: PaintSmooth(link, down, interval / CwInputManager.ScaleFactor); break;
+                    case FrequencyType.TimeInterval: PaintInterval(link, down); break;
+                    case FrequencyType.OnceOnRelease: PaintRelease(link, up); break;
+                    case FrequencyType.OnceOnPress: PaintPress(link, down); break;
+                    case FrequencyType.OnceEveryFrame: PaintEvery(link, down); break;
+                }
+            }
+
+            base.HandleFingerUpdate(finger, down, up);
+        }
+
+        protected override void HandleFingerUp(CwInputManager.Finger finger)
+        {
+            var link = CwInputManager.Link.Find(links, finger);
+
+            if (link != null)
+            {
+                connector.BreakHits(link);
+
+                OnFingerUp(link);
+
+                link.Clear();
+            }
+        }
+
+        private void PaintSmooth(Link link, bool down, float pixelSpacing)
+        {
+            var head = link.Finger.GetSmoothScreenPosition(0.0f);
+
+            if (down == true || link.History.Count == 0)
+            {
+                if (storeStates == true)
+                {
+                    CwStateManager.PotentiallyStoreAllStates();
+                }
+
+                RecordAndPaintAt(link, link.Finger.ScreenPosition, link.ScreenOld, false, link.Finger.Pressure, link);
+            }
+
+            if (pixelSpacing > 0.0f)
+            {
+                var steps = Mathf.Max(1, Mathf.FloorToInt(link.Finger.SmoothScreenPositionDelta));
+                var step = CwHelper.Reciprocal(steps);
+
+                for (var i = 0; i <= steps; i++)
+                {
+                    var next = link.Finger.GetSmoothScreenPosition(Mathf.Clamp01(i * step));
+                    var dist = Vector2.Distance(head, next);
+                    var gaps = Mathf.FloorToInt((link.Distance + dist) / pixelSpacing);
+
+                    for (var j = 0; j < gaps; j++)
+                    {
+                        var remainder = pixelSpacing - link.Distance;
+
+                        head = Vector2.MoveTowards(head, next, remainder);
+
+                        RecordAndPaintAt(link, head, link.History[link.History.Count - 1], false, link.Finger.Pressure, link);
+
+                        dist -= remainder;
+
+                        link.Distance = 0.0f;
+                    }
+
+                    link.Distance += dist;
+                    head = next;
+                }
+            }
+        }
+
+        protected virtual void OnFingerUp(Link link)
+        {
+        }
+
+        private void PaintInterval(Link link, bool down)
+        {
+            if (down == true)
+            {
+                if (storeStates == true)
+                {
+                    CwStateManager.PotentiallyStoreAllStates();
+                }
+
+                link.Age = interval;
+            }
+
+            link.Age += Time.deltaTime;
+
+            if (link.Age >= interval)
+            {
+                if (interval > 0.0f)
+                {
+                    link.Age %= interval;
+                }
+                else
+                {
+                    link.Age = 0.0f;
+                }
+
+                RecordAndPaintAt(link, link.Finger.ScreenPosition, link.ScreenOld, false, link.Finger.Pressure, link);
+            }
+        }
+
+        private void PaintRelease(Link link, bool up)
+        {
+            var preview = true;
+
+            if (up == true)
+            {
+                preview = false;
+
+                if (storeStates == true)
+                {
+                    CwStateManager.PotentiallyStoreAllStates();
+                }
+            }
+
+            RecordAndPaintAt(link, link.Finger.ScreenPosition, link.ScreenOld, preview, link.Finger.Pressure, link);
+        }
+
+        private void PaintPress(Link link, bool down)
+        {
+            if (down == true)
+            {
+                if (storeStates == true)
+                {
+                    CwStateManager.PotentiallyStoreAllStates();
+                }
+
+                RecordAndPaintAt(link, link.Finger.ScreenPosition, link.ScreenOld, false, link.Finger.Pressure, link);
+            }
+        }
+
+        private void PaintEvery(Link link, bool down)
+        {
+            if (down == true)
+            {
+                if (storeStates == true)
+                {
+                    CwStateManager.PotentiallyStoreAllStates();
+                }
+            }
+
+            RecordAndPaintAt(link, link.Finger.ScreenPosition, link.ScreenOld, false, link.Finger.Pressure, link);
+        }
+
+        private void RecordAndPaintAt(Link link, Vector2 screenNew, Vector2 screenOld, bool preview, float pressure, object owner)
+        {
+            link.History.Add(screenNew);
+
+            PaintAt(connector, connector.HitCache, screenNew, screenOld, preview, pressure, owner);
+        }
+    }
+}
+
+#if UNITY_EDITOR
+namespace game
+{
+    using UnityEditor;
+    using TARGET = BHitScreen;
+
+    [CanEditMultipleObjects]
+    [CustomEditor(typeof(TARGET))]
+    public class BHitScreen_Editor : CwHitScreenBase_Editor
+    {
+        protected override void OnInspector()
+        {
+            TARGET tgt; TARGET[] tgts; GetTargets(out tgt, out tgts);
+
+            base.OnInspector();
+
+            Separator();
+
+            DrawBasic();
+
+            Separator();
+
+            DrawAdvancedFoldout();
+
+            Separator();
+
+            var point = tgt.Emit == BHitScreenBase.EmitType.PointsIn3D;
+            var line = tgt.Emit == BHitScreenBase.EmitType.PointsIn3D && tgt.Connector.ConnectHits == true;
+            var triangle = tgt.Emit == BHitScreenBase.EmitType.TrianglesIn3D;
+            var coord = tgt.Emit == BHitScreenBase.EmitType.PointsOnUV;
+
+            tgt.Connector.HitCache.Inspector(tgt.gameObject, point: point, line: line, triangle: triangle, coord: coord);
+        }
+
+        protected override void DrawBasic()
+        {
+            TARGET tgt; TARGET[] tgts; GetTargets(out tgt, out tgts);
+
+            base.DrawBasic();
+
+            Draw("frequency", "This allows you to control how often the screen is painted.\n\nPixelInterval = Once every Interval pixels.\n\nScaledPixelInterval = Once every Interval scaled pixels.\n\nTimeInterval = Once every Interval seconds.\n\nOnceOnRelease = When the finger/mouse goes down a preview will be shown, and when it goes up the paint will apply.\n\nOnceOnPress = When the finger/mouse goes down the paint will apply.\n\nOnceEveryFrame = Every frame the paint will apply.");
+            if (Any(tgts, t => t.Frequency == BHitScreen.FrequencyType.PixelInterval || t.Frequency == BHitScreen.FrequencyType.ScaledPixelInterval || t.Frequency == BHitScreen.FrequencyType.TimeInterval))
+            {
+                BeginIndent();
+                BeginError(Any(tgts, t => t.Interval <= 0.0f));
+                Draw("interval", "This allows you to set the pixels/seconds between each hit point based on the current Frequency setting.");
+                EndError();
+                EndIndent();
+            }
+        }
+
+        protected override void DrawAdvanced()
+        {
+            base.DrawAdvanced();
+
+            Separator();
+
+            CwPointConnector_Editor.Draw();
+        }
+    }
+}
+#endif