UnityEngine.Vector2.Distance(UnityEngine.Vector2, UnityEngine.Vector2)

private void GetSpiral(Vector3 masterposition, Vector3 masterrotation)
    {
        float num = 30f;
        float num2 = 0.5f;
        float num3 = 0.05f + (float)this.spiralcount * 0.03f;
        float num5;
        if (this.spiralcount < 5)
        {
            float num4 = Vector2.Distance(new Vector2(masterposition.x, masterposition.z), new Vector2(baseGT.position.x, baseGT.position.z));
            num5 = num4;
        }
        else
        {
            num5 = 1.2f + (float)(60 - this.spiralcount) * 0.1f;
        }
        num2 -= (float)this.spiralcount * 0.06f;
        float num6 = num5 / num;
        float num7 = num3 / num;
        float num8 = num7 * 2f * 3.14159274f;
        num2 *= 6.28318548f;
        this.spiralNodes = new List<Vector3>();
        int num9 = 1;
        while ((float)num9 <= num)
        {
            float num10 = (float)num9 * num6 * (1f + 0.05f * (float)num9);
            float f = (float)num9 * num8 + num2 + 1.2566371f + masterrotation.y * 0.0173f;
            float x = Mathf.Cos(f) * num10;
            float z = -Mathf.Sin(f) * num10;
            this.spiralNodes.Add(new Vector3(x, 0f, z));
            num9++;
        }
    }

private void ButtonOn(Synapse value) 
    { 
        if (GizmaSynapse != null)
        {
            GizmaSynapse.SetActive(true);
            GizmaSynapse.GetComponent<LineRenderer>().SetPosition(0, value.parentNeuron.position);
            GizmaSynapse.GetComponent<LineRenderer>().SetPosition(1, value.targetNeuron.position);
        }
        EditSynanse = value;
        forceS = "" + value.Force;
        delayS = "" + value.Delay;
        descriptorS = "" + value.descriptor;
        distanse = Vector2.Distance(value.parentNeuron.position, value.targetNeuron.position);
    }

public override void Loop()
        {
            base.Loop();

            string add = $"\nCleaner Role: {Functions.ColorPurple}Active[]\n[]Clean Cooldown: {Functions.ColorPurple}{CleanCooldown}s";

            if (!CheepsAmongUsMod.CheepsAmongUsMod.SettingsAddition.Contains(add) && Enabled)
                CheepsAmongUsMod.CheepsAmongUsMod.SettingsAddition = CheepsAmongUsMod.CheepsAmongUsMod.SettingsAddition.Replace(prevAdd, "") + add;
            else if (CheepsAmongUsMod.CheepsAmongUsMod.SettingsAddition.Contains(prevAdd) && !Enabled)
                CheepsAmongUsMod.CheepsAmongUsMod.SettingsAddition = CheepsAmongUsMod.CheepsAmongUsMod.SettingsAddition.Replace(prevAdd, "");

            prevAdd = add;

            if (AllRolePlayers.Count == 0)
                return;

            var cleaner = AllRolePlayers.First();

            if (PlayerController.LocalPlayer.PlayerData.IsImpostor)
                cleaner.PlayerController.PlayerControl.nameText.Color = cleaner.NameColor;

            if (!cleaner.AmRolePlayer)
                return;

            if (CleanButtonSprite == null)
            {
                CleanButtonSprite = Functions.LoadSpriteFromreplacedemblyResource(replacedembly.GetExecutingreplacedembly(), "CleanerRoleGameMode.replacedets.clean.png"); // Load sprite

                KillSprite = PlayerHudManager.HudManager.KillButton.renderer.sprite;

                PlayerHudManager.HudManager.KillButton.renderer.sprite = CleanButtonSprite;
            }

            if (CleanStopwatch.Elapsed.TotalSeconds < CleanCooldown)
                PlayerHudManager.HudManager.KillButton.SetCoolDown(CleanCooldown - (float)CleanStopwatch.Elapsed.TotalSeconds, CleanCooldown);
            else
                PlayerHudManager.HudManager.KillButton.SetCoolDown(0, CleanCooldown);

            #region ---------- Manage Dead Body Target ----------
            var bodies = UnityEngine.Object.FindObjectsOfType<DeadBody>();

            DeadBody closest = null;

            #region ----- Find closest body -----
            foreach (var body in bodies)
            {
                try
                {
                    var distToObject = Vector2.Distance(body.transform.position, PlayerController.LocalPlayer.GameObject.transform.position);

                    var prevDist = float.MaxValue;

                    if(closest != null)
                        prevDist = Vector2.Distance(closest.transform.position, PlayerController.LocalPlayer.GameObject.transform.position);

                    if (distToObject < prevDist)
                    {
                        closest = body;
                    }
                }
                catch { }
            }
            #endregion

            #region ----- If distance too large, set target to null -----
            if(closest != null)
                if (Vector2.Distance(closest.transform.position, PlayerController.LocalPlayer.GameObject.transform.position) > CleanDistance)
                    closest = null;
            #endregion

            #region ----- Remove outline from previous target -----
            if (Patching.Patch_KillButtonManager_PerformKill.TargetId != byte.MaxValue)
            {
                if(closest == null || Patching.Patch_KillButtonManager_PerformKill.TargetId != closest.ParentId)
                    try
                    {
                        SetOutline(Patching.Patch_KillButtonManager_PerformKill.TargetId, Color.blue, false);
                    } catch { }
            }
            #endregion

            if (closest != null)
                Patching.Patch_KillButtonManager_PerformKill.TargetId = closest.ParentId; // update target
            else
                Patching.Patch_KillButtonManager_PerformKill.TargetId = byte.MaxValue;

            if (closest != null)
            {
                SetOutline(closest.ParentId, Color.blue, true); // set target outline
                PlayerHudManager.HudManager.KillButton.renderer.color = EnabledColor;
                PlayerHudManager.HudManager.KillButton.renderer.material.SetFloat("_Desat", 0f);
            } else
            {
                PlayerHudManager.HudManager.KillButton.renderer.color = DisabledColor;
                PlayerHudManager.HudManager.KillButton.renderer.material.SetFloat("_Desat", 1f);
            }
            #endregion

        }

public static void Start()
        {
            CheepsAmongUsMod._logger.LogInfo("Started DebugMenu");

            HudUpdateEvent.Listener += () =>
            {
                bool openCloseDebug = true;

                for (int i = 0; i < OpenCloseDebug.Length; i++)
                    if (i == OpenCloseDebug.Length - 1)
                        openCloseDebug &= Functions.GetKeyDown(OpenCloseDebug[i]);
                    else
                        openCloseDebug &= Functions.GetKey(OpenCloseDebug[i]);

                if (openCloseDebug)
                {
                    if (IsDebugOpen)
                        CloseDebug();
                    else
                        OpenDebug();
                }

                if (ImpostorSelectorOpen)
                {
                    foreach(var text in SelectImpostorTexts)
                    {
                        try
                        {
                            bool clicked = Functions.GetKeyDown(KeyCode.Mouse0) && Vector2.Distance(text.gameObject.transform.position, Functions.MouseWorldPosition) < Distance;

                            if(text.Text == "Random Impostors")
                            {
                                if (clicked)
                                {
                                    SelectedImpostorIds.Clear();
                                    continue;
                                }

                                if (SelectedImpostorIds.Count == 0)
                                    text.Color = Color.red;
                                else
                                    text.Color = Color.white;
                            }

                            if(text.Text == "Close Menu!" && clicked)
                            {
                                CloseDebug();
                                return;
                            }

                            var pId = PlayerController.FromName(text.Text).PlayerId;

                            if (SelectedImpostorIds.Contains(pId))
                            {
                                text.Color = Color.red;

                                if (clicked)
                                    SelectedImpostorIds.Remove(pId);
                            } else
                            {
                                text.Color = Color.white;

                                if (clicked)
                                    SelectedImpostorIds.Add(pId);
                            }
                        }
                        catch { }
                    }
                }

                if (IsDebugOpen) { 
                    var posText = Texts.Where(x => x.Text.StartsWith("Position: ")).First();

                    var pos = PlayerController.LocalPlayer.GameObject.transform.position;

                    posText.Text = $"Position: {pos.x}, {pos.y}, {pos.z}";

                    if (Functions.GetKeyDown(KeyCode.Mouse0))
                    {
                        foreach (var text in Texts)
                            if (Vector2.Distance(text.gameObject.transform.position, Functions.MouseWorldPosition) < Distance)
                            {
                                switch (text.Text)
                                {
                                    case "Force End Game":
                                        {
                                            CheepsAmongUsMod._logger.LogInfo("Force Ending Game...");

                                            CloseDebug();

                                            MessageWriter messageWriter = AmongUsClient.Instance.StartEndGame();
                                            messageWriter.Write((byte)GameEndReason.ImpostorByKill);
                                            messageWriter.Write(false);
                                            AmongUsClient.Instance.FinishEndGame(messageWriter);
                                            return;
                                        }

                                    case "Disable ShadowQuad":
                                    case "Enable ShadowQuad":
                                        {
                                            var enabled = text.Text != "Disable ShadowQuad";

                                            if (enabled)
                                                text.Text = "Disable ShadowQuad";
                                            else
                                                text.Text = "Enable ShadowQuad";

                                            CheepsAmongUsMod._logger.LogInfo("Setting ShadowQuad to " + enabled);

                                            PlayerHudManager.HudManager.ShadowQuad.gameObject.SetActive(enabled);
                                            break;
                                        }

                                    case "Enable Collision":
                                    case "Disable Collision":
                                        {
                                            var collision = !PlayerController.LocalPlayer.HasCollision;

                                            if (collision)
                                                text.Text = "Disable Collision";
                                            else
                                                text.Text = "Enable Collision";

                                            CheepsAmongUsMod._logger.LogInfo("Setting collision to " + collision);

                                            PlayerController.LocalPlayer.HasCollision = collision;
                                            break;
                                        }

                                    case "Set Impostor":
                                    case "Unset Impostor":
                                        {
                                            var impostor = !PlayerController.LocalPlayer.PlayerData.IsImpostor;

                                            CheepsAmongUsMod._logger.LogInfo("Setting impostor to " + impostor);

                                            if (impostor)
                                                text.Text = "Unset Impostor";
                                            else
                                                text.Text = "Set Impostor";

                                            PlayerController.LocalPlayer.PlayerData.IsImpostor = impostor;

                                            break;
                                        }

                                    case "Enable Cancel End Game":
                                    case "Disable Cancel End Game":
                                        {
                                            CancelDefaultEndGame = !CancelDefaultEndGame;

                                            if (CancelDefaultEndGame)
                                                text.Text = "Disable Cancel End Game";
                                            else
                                                text.Text = "Enable Cancel End Game";

                                            break;
                                        }

                                    case "Select Impostors":
                                        {
                                            CloseDebug();

                                            ImpostorSelectorOpen = true;

                                            var rnd = CreateText(0f, 2.5f, "Random Impostors");
                                            rnd.Color = Color.red;
                                            SelectImpostorTexts.Add(rnd);

                                            SelectImpostorTexts.Add(CreateText(0f, -2.5f, "Close Menu!"));

                                            float currentX = -2.3f;
                                            float currentY = 2f;

                                            foreach (var player in PlayerController.AllPlayerControls) {
                                                SelectImpostorTexts.Add(CreateText(currentX, currentY, player.PlayerData.PlayerName));

                                                currentX += 2.3f;

                                                if (currentX > 2.3f)
                                                {
                                                    currentX = -2.3f;
                                                    currentY -= 0.5f;
                                                }
                                            }

                                            break;
                                        }

                                    case "Set Dead":
                                    case "Set Alive":
                                        {
                                            var dead = !PlayerController.LocalPlayer.PlayerData.IsDead;

                                            CheepsAmongUsMod._logger.LogInfo("Setting dead to " + dead);

                                            if (dead)
                                                text.Text = "Set Alive";
                                            else
                                                text.Text = "Set Dead";

                                            PlayerController.LocalPlayer.PlayerData.IsDead = dead;

                                            break;
                                        }

                                    case "Close Menu":
                                        {
                                            CloseDebug();
                                            return;
                                        }
                                }
                            }
                    }
                }
            };

            LobbyBehaviourStartedEvent.Listener += () =>
            {
                SelectedImpostorIds.Clear();
            };
        }

public override void Loop()
        {
            base.Loop();

            GameModeSettingsAddition = $"\nRandom Start Location: {Functions.ColorPurple}{(RandomStartLocation ? "On" : "Off")}";

            if (!IsInGame)
                return;

            #region ----- Display new task text -----
            string ToDisplay = "----- [ff7b00ff]Battle Royale[] -----\n" +
                                "Be the last man standing!\n" +
                                "\n" +
                                $"Players left: { PlayerController.AllPlayerControls.Where(x => !x.PlayerData.IsDead).Count() }/{ MaxPlayerCount }";

            PlayerHudManager.TaskText = ToDisplay + "\n--------------------"; // Current text
            #endregion

            #region ----- Display Kill Button -----
            PlayerHudManager.HudManager.KillButton.gameObject.SetActive(!PlayerController.LocalPlayer.PlayerData.IsDead); // Activate Kill Button
            PlayerHudManager.HudManager.KillButton.isActive = !PlayerController.LocalPlayer.PlayerData.IsDead; // Activate Kill Button

            PlayerHudManager.HudManager.KillButton.transform.position = PlayerHudManager.HudManager.UseButton.transform.position;   // Move the Kill Button

            PlayerHudManager.HudManager.ReportButton.enabled = false;    // Disable report button
            PlayerHudManager.HudManager.ReportButton.gameObject.SetActive(false);    // Disable report button
            PlayerHudManager.HudManager.ReportButton.renderer.color = new Color(1, 1, 1, 0);    // Hide report button

            PlayerHudManager.HudManager.UseButton.enabled = false;    // Disable use button
            PlayerHudManager.HudManager.UseButton.gameObject.SetActive(false);    // Disable use button
            PlayerHudManager.HudManager.UseButton.UseButton.color = new Color(1, 1, 1, 0);    // Hide use button

            #region --- Update Cooldown ---
            if (GameOptions.KillCooldown - (Functions.GetUnixTime() - LastKilled) <= 0)
                LastKilled = 0;

            if (LastKilled != 0)
                PlayerHudManager.HudManager.KillButton.SetCoolDown(GameOptions.KillCooldown - (Functions.GetUnixTime() - LastKilled), GameOptions.KillCooldown);
            else
                PlayerHudManager.HudManager.KillButton.SetCoolDown(0, GameOptions.KillCooldown);
            #endregion

            #region ----- End Game If Required -----
            if (PlayerController.AllPlayerControls.Where(x => !x.PlayerData.IsDead).Count() == 1 && Started)
            {
                Started = false;

                if (!CheepsAmongUsMod.CheepsAmongUsMod.IsDecidingClient)
                    return;

                Task.Run(async () =>
                {
                    await Task.Delay(2500);
                    Patching.PatchFinishEndGame.CanEndGame = true;
                    ShipStatusClreplaced.PLBGOMIEONF(GameEndReason.ImpostorByKill, false);
                });

                var winner = PlayerController.AllPlayerControls.Where(x => !x.PlayerData.IsDead).First();

                winner.PlayerData.IsImpostor = true;

                RolePlayer MyRole = new RolePlayer(PlayerController.LocalPlayer, "Default");

                MyRole.RoleOutro.UseRoleOutro = true;

                MyRole.RoleOutro.UseRoleOutro = true;

                if (winner.IsLocalPlayer)
                {
                    MyRole.RoleOutro.WinText = "Victory Royale";
                    MyRole.RoleOutro.WinTextColor = new Color(255 / 255f, 174 / 255f, 0 / 255f);
                    MyRole.RoleOutro.BackgroundColor = new Color(1f, 0.8f, 0f);
                }
                else
                {
                    MyRole.RoleOutro.WinText = winner.PlayerData.PlayerName;
                    MyRole.RoleOutro.WinTextColor = new Color(255 / 255f, 174 / 255f, 0 / 255f);
                    MyRole.RoleOutro.BackgroundColor = new Color(1f, 0f, 0f);
                }

                RpcManager.SendRpc(BattleRoyale.BattleRoyalRpc, new byte[] { (byte)BattleRoyale.CustomRpcCalls.SetWinner, winner.PlayerId });
            }
            #endregion

            if (!Started)
                return;

            #region ----- Get Closest Player -----
            IEnumerable<PlayerController> AvailablePlayers = PlayerController.AllPlayerControls.Where(x => !x.PlayerData.IsDead && !x.IsLocalPlayer);

            PlayerController closest = AvailablePlayers.ToList()[0];

            foreach (var player in AvailablePlayers)
            {
                float DistOld = Vector2.Distance(closest.Position, PlayerController.LocalPlayer.Position);
                float DistNew = Vector2.Distance(player.Position, PlayerController.LocalPlayer.Position);

                if (DistNew < DistOld)
                    closest = player;
            }
            #endregion

            #region --- Update Target ---
            if (Vector2.Distance(closest.Position, PlayerController.LocalPlayer.Position) <= KillDistance)
            {
                PlayerHudManager.HudManager.KillButton.SetTarget(closest.PlayerControl);
                PlayerHudManager.HudManager.KillButton.CurrentTarget = closest.PlayerControl;
                Patching.PatchPerformKill.Target = closest;
            }
            else
            {
                Patching.PatchPerformKill.Target = null;
            }
            #endregion
            #endregion
        }

public float GetScreenDistance(Vector2 point)
		{
			return Vector2.Distance(ScreenPosition, point);
		}

public float GetLastScreenDistance(Vector2 point)
		{
			return Vector2.Distance(LastScreenPosition, point);
		}

public float GetStartScreenDistance(Vector2 point)
		{
			return Vector2.Distance(StartScreenPosition, point);
		}

public override void OnPointerUp(PointerEventData eventData)
    {
        if (isStatic)
        {
            base.OnPointerUp(eventData);
            return;
        }
        
        var d = Vector2.Distance(pressPosition, eventData.position);
        if (d > 0.005f * Context.ReferenceWidth)
        {
            IsPointerDown = false;
        }

        base.OnPointerUp(eventData);
        if (loadedCover) cover.DOFade(0.15f, 0.2f).SetEase(Ease.OutCubic);
        // cover.rectTransform.DOScale(1.0f, 0.2f).SetEase(Ease.OutCubic);
    }

public override void OnPointerUp(PointerEventData eventData)
    {
        if (!navigateToLastScreen || !navigateToHomeScreenWhenLongPress)
        {
            base.OnPointerUp(eventData);
            return;
        }
        
        var d = Vector2.Distance(pressPosition, eventData.position);
        if (d > 0.005f * Context.ReferenceWidth || ignoreNextPointerUp)
        {
            ignoreNextPointerUp = false;
            IsPointerDown = false;
        }

        actionToken?.Cancel();
        base.OnPointerUp(eventData);
    }

public override void OnPointerUp(PointerEventData eventData)
    {
        if (isStatic)
        {
            base.OnPointerUp(eventData);
            return;
        }
        
        var d = Vector2.Distance(pressPosition, eventData.position);
        if (d > 0.005f * Context.ReferenceWidth || ignoreNextPointerUp)
        {
            ignoreNextPointerUp = false;
            IsPointerDown = false;
        }

        actionToken?.Cancel();
        base.OnPointerUp(eventData);
        if (loadedCover) cover.DOFade(0.7f, 0.2f).SetEase(Ease.OutCubic);
        // cover.rectTransform.DOScale(1.0f, 0.2f).SetEase(Ease.OutCubic);
    }

public void DrawNoodle(Gradient gradient, NoodlePath path, NoodleStroke stroke, float thickness, List<Vector2> gridPoints) {
            // convert grid points to window points
            for (int i = 0; i < gridPoints.Count; ++i)
                gridPoints[i] = GridToWindowPosition(gridPoints[i]);

            Color originalHandlesColor = Handles.color;
            Handles.color = gradient.Evaluate(0f);
            int length = gridPoints.Count;
            switch (path) {
                case NoodlePath.Curvy:
                    Vector2 outputTangent = Vector2.right;
                    for (int i = 0; i < length - 1; i++) {
                        Vector2 inputTangent;
                        // Cached most variables that repeat themselves here to avoid so many indexer calls :p
                        Vector2 point_a = gridPoints[i];
                        Vector2 point_b = gridPoints[i + 1];
                        float dist_ab = Vector2.Distance(point_a, point_b);
                        if (i == 0) outputTangent = zoom * dist_ab * 0.01f * Vector2.right;
                        if (i < length - 2) {
                            Vector2 point_c = gridPoints[i + 2];
                            Vector2 ab = (point_b - point_a).normalized;
                            Vector2 cb = (point_b - point_c).normalized;
                            Vector2 ac = (point_c - point_a).normalized;
                            Vector2 p = (ab + cb) * 0.5f;
                            float tangentLength = (dist_ab + Vector2.Distance(point_b, point_c)) * 0.005f * zoom;
                            float side = ((ac.x * (point_b.y - point_a.y)) - (ac.y * (point_b.x - point_a.x)));

                            p = tangentLength * Mathf.Sign(side) * new Vector2(-p.y, p.x);
                            inputTangent = p;
                        } else {
                            inputTangent = zoom * dist_ab * 0.01f * Vector2.left;
                        }

                        // Calculates the tangents for the bezier's curves.
                        float zoomCoef = 50 / zoom;
                        Vector2 tangent_a = point_a + outputTangent * zoomCoef;
                        Vector2 tangent_b = point_b + inputTangent * zoomCoef;
                        // Hover effect.
                        int division = Mathf.RoundToInt(.2f * dist_ab) + 3;
                        // Coloring and bezier drawing.
                        int draw = 0;
                        Vector2 bezierPrevious = point_a;
                        for (int j = 1; j <= division; ++j) {
                            if (stroke == NoodleStroke.Dashed) {
                                draw++;
                                if (draw >= 2) draw = -2;
                                if (draw < 0) continue;
                                if (draw == 0) bezierPrevious = CalculateBezierPoint(point_a, tangent_a, tangent_b, point_b, (j - 1f) / (float) division);
                            }
                            if (i == length - 2)
                                Handles.color = gradient.Evaluate((j + 1f) / division);
                            Vector2 bezierNext = CalculateBezierPoint(point_a, tangent_a, tangent_b, point_b, j / (float) division);
                            DrawAAPolyLineNonAlloc(thickness, bezierPrevious, bezierNext);
                            bezierPrevious = bezierNext;
                        }
                        outputTangent = -inputTangent;
                    }
                    break;
                case NoodlePath.Straight:
                    for (int i = 0; i < length - 1; i++) {
                        Vector2 point_a = gridPoints[i];
                        Vector2 point_b = gridPoints[i + 1];
                        // Draws the line with the coloring.
                        Vector2 prev_point = point_a;
                        // Approximately one segment per 5 pixels
                        int segments = (int) Vector2.Distance(point_a, point_b) / 5;
                        segments = Math.Max(segments, 1);

                        int draw = 0;
                        for (int j = 0; j <= segments; j++) {
                            draw++;
                            float t = j / (float) segments;
                            Vector2 lerp = Vector2.Lerp(point_a, point_b, t);
                            if (draw > 0) {
                                if (i == length - 2) Handles.color = gradient.Evaluate(t);
                                DrawAAPolyLineNonAlloc(thickness, prev_point, lerp);
                            }
                            prev_point = lerp;
                            if (stroke == NoodleStroke.Dashed && draw >= 2) draw = -2;
                        }
                    }
                    break;
                case NoodlePath.Angled:
                    for (int i = 0; i < length - 1; i++) {
                        if (i == length - 1) continue; // Skip last index
                        if (gridPoints[i].x <= gridPoints[i + 1].x - (50 / zoom)) {
                            float midpoint = (gridPoints[i].x + gridPoints[i + 1].x) * 0.5f;
                            Vector2 start_1 = gridPoints[i];
                            Vector2 end_1 = gridPoints[i + 1];
                            start_1.x = midpoint;
                            end_1.x = midpoint;
                            if (i == length - 2) {
                                DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1);
                                Handles.color = gradient.Evaluate(0.5f);
                                DrawAAPolyLineNonAlloc(thickness, start_1, end_1);
                                Handles.color = gradient.Evaluate(1f);
                                DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]);
                            } else {
                                DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1);
                                DrawAAPolyLineNonAlloc(thickness, start_1, end_1);
                                DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]);
                            }
                        } else {
                            float midpoint = (gridPoints[i].y + gridPoints[i + 1].y) * 0.5f;
                            Vector2 start_1 = gridPoints[i];
                            Vector2 end_1 = gridPoints[i + 1];
                            start_1.x += 25 / zoom;
                            end_1.x -= 25 / zoom;
                            Vector2 start_2 = start_1;
                            Vector2 end_2 = end_1;
                            start_2.y = midpoint;
                            end_2.y = midpoint;
                            if (i == length - 2) {
                                DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1);
                                Handles.color = gradient.Evaluate(0.25f);
                                DrawAAPolyLineNonAlloc(thickness, start_1, start_2);
                                Handles.color = gradient.Evaluate(0.5f);
                                DrawAAPolyLineNonAlloc(thickness, start_2, end_2);
                                Handles.color = gradient.Evaluate(0.75f);
                                DrawAAPolyLineNonAlloc(thickness, end_2, end_1);
                                Handles.color = gradient.Evaluate(1f);
                                DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]);
                            } else {
                                DrawAAPolyLineNonAlloc(thickness, gridPoints[i], start_1);
                                DrawAAPolyLineNonAlloc(thickness, start_1, start_2);
                                DrawAAPolyLineNonAlloc(thickness, start_2, end_2);
                                DrawAAPolyLineNonAlloc(thickness, end_2, end_1);
                                DrawAAPolyLineNonAlloc(thickness, end_1, gridPoints[i + 1]);
                            }
                        }
                    }
                    break;
                case NoodlePath.ShaderLab:
                    Vector2 start = gridPoints[0];
                    Vector2 end = gridPoints[length - 1];
                    //Modify first and last point in array so we can loop trough them nicely.
                    gridPoints[0] = gridPoints[0] + Vector2.right * (20 / zoom);
                    gridPoints[length - 1] = gridPoints[length - 1] + Vector2.left * (20 / zoom);
                    //Draw first vertical lines going out from nodes
                    Handles.color = gradient.Evaluate(0f);
                    DrawAAPolyLineNonAlloc(thickness, start, gridPoints[0]);
                    Handles.color = gradient.Evaluate(1f);
                    DrawAAPolyLineNonAlloc(thickness, end, gridPoints[length - 1]);
                    for (int i = 0; i < length - 1; i++) {
                        Vector2 point_a = gridPoints[i];
                        Vector2 point_b = gridPoints[i + 1];
                        // Draws the line with the coloring.
                        Vector2 prev_point = point_a;
                        // Approximately one segment per 5 pixels
                        int segments = (int) Vector2.Distance(point_a, point_b) / 5;
                        segments = Math.Max(segments, 1);

                        int draw = 0;
                        for (int j = 0; j <= segments; j++) {
                            draw++;
                            float t = j / (float) segments;
                            Vector2 lerp = Vector2.Lerp(point_a, point_b, t);
                            if (draw > 0) {
                                if (i == length - 2) Handles.color = gradient.Evaluate(t);
                                DrawAAPolyLineNonAlloc(thickness, prev_point, lerp);
                            }
                            prev_point = lerp;
                            if (stroke == NoodleStroke.Dashed && draw >= 2) draw = -2;
                        }
                    }
                    gridPoints[0] = start;
                    gridPoints[length - 1] = end;
                    break;
            }
            Handles.color = originalHandlesColor;
        }

public void SetPosition(Vector2 start, Vector2 end) {
			if (!rectTransform) rectTransform = (RectTransform) transform;
			transform.position = (start + end) * 0.5f;

			float r = Mathf.Atan2(start.y - end.y, start.x - end.x) * Mathf.Rad2Deg;
			transform.rotation = Quaternion.Euler(0, 0, r);
			rectTransform.sizeDelta = new Vector2(Vector2.Distance(start, end), rectTransform.sizeDelta.y);
		}

public float GetDistance() {

		float distanceTravelled = Vector2.Distance (new Vector2 (startPosition.x, 0),
			                          new Vector2 (this.transform.position.x, 0));

		return distanceTravelled;

	}

void Update()
    {
        float minDist = 99999;
        Vector2 AimTarget = Vector2.zero;
        try
        {
            foreach (GameObject go in badguys)
            {
                Transform[] allChildren = go.transform.GetComponentsInChildren<Transform>();
                foreach (Transform child in allChildren)
                {
                    if (child.name == bone) //NPC_Spine1 "NPC_Neck"
                    {
                        var replaced = Camera.main.WorldToScreenPoint(child.transform.position);
                        if (replaced.z > -8)
                        {
                            float dist = System.Math.Abs(Vector2.Distance(new Vector2(replaced.x, Screen.height - replaced.y), new Vector2((Screen.width / 2), (Screen.height / 2))));
                            if (dist < 300) //in fov
                            {
                                if (dist < minDist)
                                {
                                    minDist = dist;
                                    AimTarget = new Vector2(replaced.x, Screen.height - replaced.y);
                                }
                            }
                        }
                    }
                }
            }
            if(AimTarget != Vector2.zero)
            {
                double DistX = AimTarget.x - Screen.width / 2.0f;
                double DistY = AimTarget.y - Screen.height / 2.0f;

                //aimsmooth
                DistX /= smooth;
                DistY /= smooth;

                //if aimkey is pressed
                if(!menu)
                if (Input.GetKey(aimkey)) mouse_event(0x0001, (int)DistX, (int)DistY, 0, 0);
            }
        }
         catch { }

        /////////MENU HOTKEY////////////
        if (Input.GetKeyDown(KeyCode.Insert)) menu = !menu;

        ////////////////ENEMY LIST UPDATE/////////
        try
        {
            if (one <= two)
            {
                one = one - 1;
                if (one == two - 1)
                {
                    foreach (GameObject go in GameObject.FindObjectsOfType(typeof(GameObject)))
                    {
                        if (go.name.Contains(nameToAdd))
                        {
                            var distance = Vector3.Distance(Camera.main.transform.position, go.transform.position);
                            if (distance > 2)
                            {
                                if (!badguys.Contains(go))
                                {
                                    var rend = go.GetComponentInChildren<Renderer>();
                                    if (rend.material.name.Contains("S") || rend.material.name.Contains("B")) //"p0/Bumped Specular Mask" "p0/Reflective/Bumped Specular Mask W"
                                    {
                                        badguys.Add(go);
                                        if (wallhack)
                                        {
                                            var rend2 = go.GetComponentsInChildren<Renderer>();
                                            chams.Add(go);
                                            foreach (Renderer renderer in rend2)
                                            {
                                                DefaultShader = renderer.material.shader;
                                                renderer.material.shader = Shader.Find("Hidden/Internal-GUITexture");
                                            }
                                        }
                                    }
                                    else if (distance > 12) badguys.Add(go);
                                    else GameObject.Destroy(go);
                                }
                            }
                        }
                    }
                }
            }
            if (one <= 0)
            {
                badguys.Clear();
                if (wallhack)
                {
                    try
                    {
                        foreach (GameObject gameObj in chams)
                        {
                            if (gameObj != null)
                            {
                                var rend = gameObj.GetComponentsInChildren<Renderer>();
                                foreach (Renderer renderer in rend) renderer.material.shader = DefaultShader;
                            }
                        }
                    }
                    catch { }
                }
                one = two;
            }
        }
        catch { }
    }

Vector3 GetInput(Rect bounds, Vector3 hsv, float radius)
        {
            var e = Event.current;
            var id = GUIUtility.GetControlID(k_ThumbHash, FocusType.Preplacedive, bounds);

            var mousePos = e.mousePosition;
            var relativePos = mousePos - new Vector2(bounds.x, bounds.y);

            if (e.type == EventType.MouseDown && GUIUtility.hotControl == 0 && bounds.Contains(mousePos))
            {
                if (e.button == 0)
                {
                    var center = new Vector2(bounds.x + radius, bounds.y + radius);
                    float dist = Vector2.Distance(center, mousePos);

                    if (dist <= radius)
                    {
                        e.Use();
                        GetWheelHueSaturation(relativePos.x, relativePos.y, radius, out hsv.x, out hsv.y);
                        GUIUtility.hotControl = id;
                        GUI.changed = true;
                    }
                }
                else if (e.button == 1)
                {
                    e.Use();
                    GUI.changed = true;
                    m_ResetState = true;
                }
            }
            else if (e.type == EventType.MouseDrag && e.button == 0 && GUIUtility.hotControl == id)
            {
                e.Use();
                GUI.changed = true;
                GetWheelHueSaturation(relativePos.x, relativePos.y, radius, out hsv.x, out hsv.y);
            }
            else if (e.rawType == EventType.MouseUp && e.button == 0 && GUIUtility.hotControl == id)
            {
                e.Use();
                GUIUtility.hotControl = 0;
            }

            return hsv;
        }

protected override void InitData()
		{
			Target.rectTransform.GetWorldCorners(_corners);
			//获取最终高亮区域半径
			mRadius = Vector2.Distance(World2CanvasPos(mCanvas, _corners[0]), World2CanvasPos(mCanvas, _corners[3])) / 2f;
			//计算圆心
			float x = _corners[0].x + (_corners[3].x - _corners[0].x) / 2f;
			float y = _corners[0].y + (_corners[1].y - _corners[0].y) / 2f;
			Vector3 centerWorld = new Vector3(x, y, 0);
			Vector2 center = World2CanvasPos(mCanvas, centerWorld);
			//Apply 设置数据到shader中
			Vector4 centerMat = new Vector4(center.x, center.y, 0, 0);
			mMaterial.SetVector("_Center", centerMat);
			//计算当前高亮显示区域半径
			RectTransform canvasRectTransform = mCanvas.transform as RectTransform;
			canvasRectTransform.GetWorldCorners(_corners);
			foreach (Vector3 corner in _corners)
			{
				mCurrentRadius = Mathf.Max(Vector3.Distance(World2CanvasPos(mCanvas, corner), corner), mCurrentRadius);
			}
			float initRadius = ShowAnim ? mCurrentRadius : mRadius;
			mMaterial.SetFloat("_Slider", initRadius);
		}

protected override void InitData()
		{
			//获取高亮区域四个顶点的世界坐标
			Target.rectTransform.GetWorldCorners(_corners);
			//计算高亮显示区域咋画布中的范围
			mTargetOffsetX = Vector2.Distance(World2CanvasPos(mCanvas, _corners[0]), World2CanvasPos(mCanvas, _corners[3])) / 2f;
			mTargetOffsetY = Vector2.Distance(World2CanvasPos(mCanvas, _corners[0]), World2CanvasPos(mCanvas, _corners[1])) / 2f;
			//计算高亮显示区域的中心
			float x = _corners[0].x + ((_corners[3].x - _corners[0].x) / 2f);
			float y = _corners[0].y + ((_corners[1].y - _corners[0].y) / 2f);
			Vector3 centerWorld = new Vector3(x,y,0);
			Vector2 center = World2CanvasPos(mCanvas, centerWorld);
			//设置遮罩材料中中心变量
			Vector4 centerMat = new Vector4(center.x,center.y,0,0);
			mMaterial.SetVector("_Center",centerMat);
			//计算当前偏移的初始值
			RectTransform canvasRectTransform = (mCanvas.transform as RectTransform);
			if (canvasRectTransform != null)
			{
				//获取画布区域的四个顶点
				canvasRectTransform.GetWorldCorners(_corners);
				//求偏移初始值
				for (int i = 0; i < _corners.Length; i++)
				{
					if (i % 2 == 0)
						mCurrentOffsetX = Mathf.Max(Vector3.Distance(World2CanvasPos(mCanvas, _corners[i]), center), mCurrentOffsetX);
					else
						mCurrentOffsetY = Mathf.Max(Vector3.Distance(World2CanvasPos(mCanvas, _corners[i]), center), mCurrentOffsetY);
				}
			}
			//设置遮罩材质中当前偏移的变量
			float initX = ShowAnim ? mCurrentOffsetX : mTargetOffsetX;
			float initY = ShowAnim ? mCurrentOffsetY : mTargetOffsetY;
			mMaterial.SetFloat("_SliderX",initX);
			mMaterial.SetFloat("_SliderY",initY);
		}

static public float GetScreenDistance (Vector3 worldPos, Vector2 mousePos)
	{
		Vector2 screenPos = HandleUtility.WorldToGUIPoint(worldPos);
		return Vector2.Distance(mousePos, screenPos);
	}

private static float GetBisectorBisectorOffset(Plan.Vertex vertex, Vector2 intersection)
		{
			float toIntersection = Vector2.Distance(vertex.position, intersection);
			return GetBisectorBisectorOffset(vertex, toIntersection);
		}

private static bool BisectorSegment(Plan.Vertex vertex, Vector2 segmentA, Vector2 segmentB, out float offset)
		{
			IntersectionRaySegment2 intersection;
			if (Intersect.RaySegment(vertex.position, vertex.bisector, segmentA, segmentB, out intersection))
			{
				if (intersection.type == IntersectionType.Point)
				{
					Vector2 segmentDirection = (segmentB - segmentA).normalized;
					float toIntersection = Vector2.Distance(vertex.position, intersection.pointA);
					float intersectionAngle = Vector2.Angle(vertex.bisector, segmentDirection);
					float intersectionSin = Mathf.Sin(intersectionAngle*Mathf.Deg2Rad);
					float bisectorSin = Geometry.GetAngleBisectorSin(vertex.angle);
					offset = toIntersection/(1/intersectionSin + 1/bisectorSin);
					return true;
				}

				// BEGIN: Modified by Microsoft Corporation for generic logging purposes.
				API.MREAPI.Logger.LogError(string.Format("Invalid bisector intersection\ntype: {0}\npointA: {1} pointB: {2}\nray: {3} segmentA:{4} segmentB:{5}",
					intersection.type, intersection.pointA, intersection.pointB, vertex.bisector, segmentA, segmentB));
				// END: Modified by Microsoft Corporation for generic logging purposes.

				offset = 0;
				return false;
			}
			offset = 0;
			return false;
		}

public static float PointSegment(Vector2 point, Vector2 segmentA, Vector2 segmentB)
		{
			return Vector2.Distance(point, Closest.PointSegment(point, segmentA, segmentB));
		}

private static float PointSegment(Vector2 point, Vector2 segmentA, Vector2 segmentB, Vector2 segmentDirection, float segmentLength)
		{
			float pointProjection = Vector2.Dot(segmentDirection, point - segmentA);
			if (pointProjection < -Geometry.Epsilon)
			{
				return Vector2.Distance(point, segmentA);
			}
			if (pointProjection > segmentLength + Geometry.Epsilon)
			{
				return Vector2.Distance(point, segmentB);
			}
			return Vector2.Distance(point, segmentA + segmentDirection*pointProjection);
		}

public static float RaySegment(Vector2 rayOrigin, Vector2 rayDirection, Vector2 segmentA, Vector2 segmentB)
		{
			Vector2 segmentAToOrigin = rayOrigin - segmentA;
			Vector2 segmentDirection = segmentB - segmentA;
			float denominator = VectorE.PerpDot(rayDirection, segmentDirection);
			float perpDotA = VectorE.PerpDot(rayDirection, segmentAToOrigin);
			// Normalized direction gives more stable results 
			float perpDotB = VectorE.PerpDot(segmentDirection.normalized, segmentAToOrigin);

			if (Mathf.Abs(denominator) < Geometry.Epsilon)
			{
				// Parallel
				float segmentAProjection = -Vector2.Dot(rayDirection, segmentAToOrigin);
				Vector2 originToSegmentB = segmentB - rayOrigin;
				float segmentBProjection = Vector2.Dot(rayDirection, originToSegmentB);
				if (Mathf.Abs(perpDotA) > Geometry.Epsilon || Mathf.Abs(perpDotB) > Geometry.Epsilon)
				{
					// Not collinear
					if (segmentAProjection > -Geometry.Epsilon)
					{
						float distanceSqr = segmentAToOrigin.sqrMagnitude - segmentAProjection*segmentAProjection;
						// distanceSqr can be negative
						return distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr);
					}
					if (segmentBProjection > -Geometry.Epsilon)
					{
						float distanceSqr = originToSegmentB.sqrMagnitude - segmentBProjection*segmentBProjection;
						// distanceSqr can be negative
						return distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr);
					}

					if (segmentAProjection > segmentBProjection)
					{
						return Vector2.Distance(rayOrigin, segmentA);
					}
					return Vector2.Distance(rayOrigin, segmentB);
				}
				// Collinear
				if (segmentAProjection > -Geometry.Epsilon || segmentBProjection > -Geometry.Epsilon)
				{
					// Point or segment intersection
					return 0;
				}
				// No intersection
				return segmentAProjection > segmentBProjection ? -segmentAProjection : -segmentBProjection;
			}

			// Not parallel
			float rayDistance = perpDotB/denominator;
			float segmentDistance = perpDotA/denominator;
			if (rayDistance < -Geometry.Epsilon ||
				segmentDistance < -Geometry.Epsilon || segmentDistance > 1 + Geometry.Epsilon)
			{
				// No intersection
				bool codirected = Vector2.Dot(rayDirection, segmentDirection) > 0;
				Vector2 segmentBToOrigin;
				if (!codirected)
				{
					PTUtils.Swap(ref segmentA, ref segmentB);
					segmentDirection = -segmentDirection;
					segmentBToOrigin = segmentAToOrigin;
					segmentAToOrigin = rayOrigin - segmentA;
					segmentDistance = 1 - segmentDistance;
				}
				else
				{
					segmentBToOrigin = rayOrigin - segmentB;
				}

				float segmentAProjection = -Vector2.Dot(rayDirection, segmentAToOrigin);
				float segmentBProjection = -Vector2.Dot(rayDirection, segmentBToOrigin);
				bool segmentAOnRay = segmentAProjection > -Geometry.Epsilon;
				bool segmentBOnRay = segmentBProjection > -Geometry.Epsilon;
				if (segmentAOnRay && segmentBOnRay)
				{
					if (segmentDistance < 0)
					{
						Vector2 rayPoint = rayOrigin + rayDirection*segmentAProjection;
						Vector2 segmentPoint = segmentA;
						return Vector2.Distance(rayPoint, segmentPoint);
					}
					else
					{
						Vector2 rayPoint = rayOrigin + rayDirection*segmentBProjection;
						Vector2 segmentPoint = segmentB;
						return Vector2.Distance(rayPoint, segmentPoint);
					}
				}
				else if (!segmentAOnRay && segmentBOnRay)
				{
					if (segmentDistance < 0)
					{
						Vector2 rayPoint = rayOrigin;
						Vector2 segmentPoint = segmentA;
						return Vector2.Distance(rayPoint, segmentPoint);
					}
					else if (segmentDistance > 1 + Geometry.Epsilon)
					{
						Vector2 rayPoint = rayOrigin + rayDirection*segmentBProjection;
						Vector2 segmentPoint = segmentB;
						return Vector2.Distance(rayPoint, segmentPoint);
					}
					else
					{
						Vector2 rayPoint = rayOrigin;
						float originProjection = Vector2.Dot(segmentDirection, segmentAToOrigin);
						Vector2 segmentPoint = segmentA + segmentDirection*originProjection/segmentDirection.sqrMagnitude;
						return Vector2.Distance(rayPoint, segmentPoint);
					}
				}
				else
				{
					// Not on ray
					Vector2 rayPoint = rayOrigin;
					float originProjection = Vector2.Dot(segmentDirection, segmentAToOrigin);
					float sqrSegmentLength = segmentDirection.sqrMagnitude;
					if (originProjection < 0)
					{
						return Vector2.Distance(rayPoint, segmentA);
					}
					else if (originProjection > sqrSegmentLength)
					{
						return Vector2.Distance(rayPoint, segmentB);
					}
					else
					{
						Vector2 segmentPoint = segmentA + segmentDirection*originProjection/sqrSegmentLength;
						return Vector2.Distance(rayPoint, segmentPoint);
					}
				}
			}
			// Point intersection
			return 0;
		}

public static float SegmentSegment(Vector2 segment1A, Vector2 segment1B, Vector2 segment2A, Vector2 segment2B)
		{
			Vector2 from2ATo1A = segment1A - segment2A;
			Vector2 direction1 = segment1B - segment1A;
			Vector2 direction2 = segment2B - segment2A;
			float segment1Length = direction1.magnitude;
			float segment2Length = direction2.magnitude;

			bool segment1IsAPoint = segment1Length < Geometry.Epsilon;
			bool segment2IsAPoint = segment2Length < Geometry.Epsilon;
			if (segment1IsAPoint && segment2IsAPoint)
			{
				return Vector2.Distance(segment1A, segment2A);
			}
			if (segment1IsAPoint)
			{
				direction2.Normalize();
				return PointSegment(segment1A, segment2A, segment2B, direction2, segment2Length);
			}
			if (segment2IsAPoint)
			{
				direction1.Normalize();
				return PointSegment(segment2A, segment1A, segment1B, direction1, segment1Length);
			}

			direction1.Normalize();
			direction2.Normalize();
			float denominator = VectorE.PerpDot(direction1, direction2);
			float perpDot1 = VectorE.PerpDot(direction1, from2ATo1A);
			float perpDot2 = VectorE.PerpDot(direction2, from2ATo1A);

			if (Mathf.Abs(denominator) < Geometry.Epsilon)
			{
				// Parallel
				if (Mathf.Abs(perpDot1) > Geometry.Epsilon || Mathf.Abs(perpDot2) > Geometry.Epsilon)
				{
					// Not collinear
					float segment2AProjection = -Vector2.Dot(direction1, from2ATo1A);
					if (segment2AProjection > -Geometry.Epsilon &&
						segment2AProjection < segment1Length + Geometry.Epsilon)
					{
						float distanceSqr = from2ATo1A.sqrMagnitude - segment2AProjection*segment2AProjection;
						// distanceSqr can be negative
						return distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr);
					}

					Vector2 from1ATo2B = segment2B - segment1A;
					float segment2BProjection = Vector2.Dot(direction1, from1ATo2B);
					if (segment2BProjection > -Geometry.Epsilon &&
						segment2BProjection < segment1Length + Geometry.Epsilon)
					{
						float distanceSqr = from1ATo2B.sqrMagnitude - segment2BProjection*segment2BProjection;
						// distanceSqr can be negative
						return distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr);
					}

					if (segment2AProjection < 0 && segment2BProjection < 0)
					{
						if (segment2AProjection > segment2BProjection)
						{
							return Vector2.Distance(segment1A, segment2A);
						}
						return Vector2.Distance(segment1A, segment2B);
					}
					if (segment2AProjection > 0 && segment2BProjection > 0)
					{
						if (segment2AProjection < segment2BProjection)
						{
							return Vector2.Distance(segment1B, segment2A);
						}
						return Vector2.Distance(segment1B, segment2B);
					}
					float segment1AProjection = Vector2.Dot(direction2, from2ATo1A);
					Vector2 segment2Point = segment2A + direction2*segment1AProjection;
					return Vector2.Distance(segment1A, segment2Point);
				}
				// Collinear

				bool codirected = Vector2.Dot(direction1, direction2) > 0;
				if (codirected)
				{
					// Codirected
					float segment2AProjection = -Vector2.Dot(direction1, from2ATo1A);
					if (segment2AProjection > -Geometry.Epsilon)
					{
						// 1A------1B
						//     2A------2B
						return SegmentSegmentCollinear(segment1A, segment1B, segment2A);
					}
					else
					{
						//     1A------1B
						// 2A------2B
						return SegmentSegmentCollinear(segment2A, segment2B, segment1A);
					}
				}
				else
				{
					// Contradirected
					float segment2BProjection = Vector2.Dot(direction1, segment2B - segment1A);
					if (segment2BProjection > -Geometry.Epsilon)
					{
						// 1A------1B
						//     2B------2A
						return SegmentSegmentCollinear(segment1A, segment1B, segment2B);
					}
					else
					{
						//     1A------1B
						// 2B------2A
						return SegmentSegmentCollinear(segment2B, segment2A, segment1A);
					}
				}
			}

			// Not parallel
			float distance1 = perpDot2/denominator;
			float distance2 = perpDot1/denominator;
			if (distance1 < -Geometry.Epsilon || distance1 > segment1Length + Geometry.Epsilon ||
				distance2 < -Geometry.Epsilon || distance2 > segment2Length + Geometry.Epsilon)
			{
				// No intersection
				bool codirected = Vector2.Dot(direction1, direction2) > 0;
				Vector2 from1ATo2B;
				if (!codirected)
				{
					PTUtils.Swap(ref segment2A, ref segment2B);
					direction2 = -direction2;
					from1ATo2B = -from2ATo1A;
					from2ATo1A = segment1A - segment2A;
					distance2 = segment2Length - distance2;
				}
				else
				{
					from1ATo2B = segment2B - segment1A;
				}
				Vector2 segment1Point;
				Vector2 segment2Point;

				float segment2AProjection = -Vector2.Dot(direction1, from2ATo1A);
				float segment2BProjection = Vector2.Dot(direction1, from1ATo2B);

				bool segment2AIsAfter1A = segment2AProjection > -Geometry.Epsilon;
				bool segment2BIsBefore1B = segment2BProjection < segment1Length + Geometry.Epsilon;
				bool segment2AOnSegment1 = segment2AIsAfter1A && segment2AProjection < segment1Length + Geometry.Epsilon;
				bool segment2BOnSegment1 = segment2BProjection > -Geometry.Epsilon && segment2BIsBefore1B;
				if (segment2AOnSegment1 && segment2BOnSegment1)
				{
					if (distance2 < -Geometry.Epsilon)
					{
						segment1Point = segment1A + direction1*segment2AProjection;
						segment2Point = segment2A;
					}
					else
					{
						segment1Point = segment1A + direction1*segment2BProjection;
						segment2Point = segment2B;
					}
				}
				else if (!segment2AOnSegment1 && !segment2BOnSegment1)
				{
					if (!segment2AIsAfter1A && !segment2BIsBefore1B)
					{
						segment1Point = distance1 < -Geometry.Epsilon ? segment1A : segment1B;
					}
					else
					{
						// Not on segment
						segment1Point = segment2AIsAfter1A ? segment1B : segment1A;
					}
					float segment1PointProjection = Vector2.Dot(direction2, segment1Point - segment2A);
					segment1PointProjection = Mathf.Clamp(segment1PointProjection, 0, segment2Length);
					segment2Point = segment2A + direction2*segment1PointProjection;
				}
				else if (segment2AOnSegment1)
				{
					if (distance2 < -Geometry.Epsilon)
					{
						segment1Point = segment1A + direction1*segment2AProjection;
						segment2Point = segment2A;
					}
					else
					{
						segment1Point = segment1B;
						float segment1PointProjection = Vector2.Dot(direction2, segment1Point - segment2A);
						segment1PointProjection = Mathf.Clamp(segment1PointProjection, 0, segment2Length);
						segment2Point = segment2A + direction2*segment1PointProjection;
					}
				}
				else
				{
					if (distance2 > segment2Length + Geometry.Epsilon)
					{
						segment1Point = segment1A + direction1*segment2BProjection;
						segment2Point = segment2B;
					}
					else
					{
						segment1Point = segment1A;
						float segment1PointProjection = Vector2.Dot(direction2, segment1Point - segment2A);
						segment1PointProjection = Mathf.Clamp(segment1PointProjection, 0, segment2Length);
						segment2Point = segment2A + direction2*segment1PointProjection;
					}
				}
				return Vector2.Distance(segment1Point, segment2Point);
			}

			// Point intersection
			return 0;
		}

public static float PointLine(Vector2 point, Line2 line)
		{
			return Vector2.Distance(point, Closest.PointLine(point, line));
		}

public static float LineRay(Vector2 lineOrigin, Vector2 lineDirection, Vector2 rayOrigin, Vector2 rayDirection)
		{
			Vector2 rayOriginToLineOrigin = lineOrigin - rayOrigin;
			float denominator = VectorE.PerpDot(lineDirection, rayDirection);
			float perpDotA = VectorE.PerpDot(lineDirection, rayOriginToLineOrigin);

			if (Mathf.Abs(denominator) < Geometry.Epsilon)
			{
				// Parallel
				float perpDotB = VectorE.PerpDot(rayDirection, rayOriginToLineOrigin);
				if (Mathf.Abs(perpDotA) > Geometry.Epsilon || Mathf.Abs(perpDotB) > Geometry.Epsilon)
				{
					// Not collinear
					float rayOriginProjection = Vector2.Dot(lineDirection, rayOriginToLineOrigin);
					float distanceSqr = rayOriginToLineOrigin.sqrMagnitude - rayOriginProjection*rayOriginProjection;
					// distanceSqr can be negative
					return distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr);
				}
				// Collinear
				return 0;
			}

			// Not parallel
			float rayDistance = perpDotA/denominator;
			if (rayDistance < -Geometry.Epsilon)
			{
				// No intersection
				float rayOriginProjection = Vector2.Dot(lineDirection, rayOriginToLineOrigin);
				Vector2 linePoint = lineOrigin - lineDirection*rayOriginProjection;
				return Vector2.Distance(linePoint, rayOrigin);
			}
			// Point intersection
			return 0;
		}

public static float LineSegment(Vector2 lineOrigin, Vector2 lineDirection, Vector2 segmentA, Vector2 segmentB)
		{
			Vector2 segmentAToOrigin = lineOrigin - segmentA;
			Vector2 segmentDirection = segmentB - segmentA;
			float denominator = VectorE.PerpDot(lineDirection, segmentDirection);
			float perpDotA = VectorE.PerpDot(lineDirection, segmentAToOrigin);

			if (Mathf.Abs(denominator) < Geometry.Epsilon)
			{
				// Parallel
				// Normalized direction gives more stable results 
				float perpDotB = VectorE.PerpDot(segmentDirection.normalized, segmentAToOrigin);
				if (Mathf.Abs(perpDotA) > Geometry.Epsilon || Mathf.Abs(perpDotB) > Geometry.Epsilon)
				{
					// Not collinear
					float segmentAProjection = Vector2.Dot(lineDirection, segmentAToOrigin);
					float distanceSqr = segmentAToOrigin.sqrMagnitude - segmentAProjection*segmentAProjection;
					// distanceSqr can be negative
					return distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr);
				}
				// Collinear
				return 0;
			}

			// Not parallel
			float segmentDistance = perpDotA/denominator;
			if (segmentDistance < -Geometry.Epsilon || segmentDistance > 1 + Geometry.Epsilon)
			{
				// No intersection
				Vector2 segmentPoint = segmentA + segmentDirection*Mathf.Clamp01(segmentDistance);
				float segmentPointProjection = Vector2.Dot(lineDirection, segmentPoint - lineOrigin);
				Vector2 linePoint = lineOrigin + lineDirection*segmentPointProjection;
				return Vector2.Distance(linePoint, segmentPoint);
			}
			// Point intersection
			return 0;
		}

public static float RayRay(Vector2 originA, Vector2 directionA, Vector2 originB, Vector2 directionB)
		{
			Vector2 originBToA = originA - originB;
			float denominator = VectorE.PerpDot(directionA, directionB);
			float perpDotA = VectorE.PerpDot(directionA, originBToA);
			float perpDotB = VectorE.PerpDot(directionB, originBToA);

			bool codirected = Vector2.Dot(directionA, directionB) > 0;
			if (Mathf.Abs(denominator) < Geometry.Epsilon)
			{
				// Parallel
				float originBProjection = -Vector2.Dot(directionA, originBToA);
				if (Mathf.Abs(perpDotA) > Geometry.Epsilon || Mathf.Abs(perpDotB) > Geometry.Epsilon)
				{
					// Not collinear
					if (!codirected && originBProjection < Geometry.Epsilon)
					{
						return Vector2.Distance(originA, originB);
					}
					float distanceSqr = originBToA.sqrMagnitude - originBProjection*originBProjection;
					// distanceSqr can be negative
					return distanceSqr <= 0 ? 0 : Mathf.Sqrt(distanceSqr);
				}
				// Collinear

				if (codirected)
				{
					// Ray intersection
					return 0;
				}
				else
				{
					if (originBProjection < Geometry.Epsilon)
					{
						// No intersection
						return Vector2.Distance(originA, originB);
					}
					else
					{
						// Segment intersection
						return 0;
					}
				}
			}

			// Not parallel
			float distanceA = perpDotB/denominator;
			float distanceB = perpDotA/denominator;
			if (distanceA < -Geometry.Epsilon || distanceB < -Geometry.Epsilon)
			{
				// No intersection
				if (codirected)
				{
					float originAProjection = Vector2.Dot(directionB, originBToA);
					if (originAProjection > -Geometry.Epsilon)
					{
						Vector2 rayPointA = originA;
						Vector2 rayPointB = originB + directionB*originAProjection;
						return Vector2.Distance(rayPointA, rayPointB);
					}
					float originBProjection = -Vector2.Dot(directionA, originBToA);
					if (originBProjection > -Geometry.Epsilon)
					{
						Vector2 rayPointA = originA + directionA*originBProjection;
						Vector2 rayPointB = originB;
						return Vector2.Distance(rayPointA, rayPointB);
					}
					return Vector2.Distance(originA, originB);
				}
				else
				{
					if (distanceA > -Geometry.Epsilon)
					{
						float originBProjection = -Vector2.Dot(directionA, originBToA);
						if (originBProjection > -Geometry.Epsilon)
						{
							Vector2 rayPointA = originA + directionA*originBProjection;
							Vector2 rayPointB = originB;
							return Vector2.Distance(rayPointA, rayPointB);
						}
					}
					else if (distanceB > -Geometry.Epsilon)
					{
						float originAProjection = Vector2.Dot(directionB, originBToA);
						if (originAProjection > -Geometry.Epsilon)
						{
							Vector2 rayPointA = originA;
							Vector2 rayPointB = originB + directionB*originAProjection;
							return Vector2.Distance(rayPointA, rayPointB);
						}
					}
					return Vector2.Distance(originA, originB);
				}
			}
			// Point intersection
			return 0;
		}

public static float PointLine(Vector2 point, Vector2 lineOrigin, Vector2 lineDirection)
		{
			return Vector2.Distance(point, Closest.PointLine(point, lineOrigin, lineDirection));
		}

public static float PointRay(Vector2 point, Ray2D ray)
		{
			return Vector2.Distance(point, Closest.PointRay(point, ray));
		}

public static float PointRay(Vector2 point, Vector2 rayOrigin, Vector2 rayDirection)
		{
			return Vector2.Distance(point, Closest.PointRay(point, rayOrigin, rayDirection));
		}

private static bool BisectorBisector(Plan.Vertex vertexA, Plan.Vertex vertexB, out float offset)
		{
			IntersectionRayRay2 intersection;
			if (Intersect.RayRay(vertexA.position, vertexA.bisector, vertexB.position, vertexB.bisector, out intersection))
			{
				if (intersection.type == IntersectionType.Point)
				{
					float offsetA = GetBisectorBisectorOffset(vertexA, intersection.pointA);
					float offsetB = GetBisectorBisectorOffset(vertexB, intersection.pointA);
					offset = Mathf.Min(offsetA, offsetB);
					return true;
				}
				if (intersection.type == IntersectionType.Segment)
				{
					float toIntersection = Vector2.Distance(vertexA.position, vertexB.position);
					float offsetA = GetBisectorBisectorOffset(vertexA, toIntersection)/2;
					float offsetB = GetBisectorBisectorOffset(vertexB, toIntersection)/2;
					offset = Mathf.Min(offsetA, offsetB);
					return true;
				}

				// BEGIN: Modified by Microsoft Corporation for generic logging purposes.
				API.MREAPI.Logger.LogError(string.Format("Invalid bisector intersection\ntype: {0}\npointA: {1} pointB: {2}\nbisectorA: {3} bisectorB:{4}",
					intersection.type, intersection.pointA, intersection.pointB, vertexA.bisector, vertexB.bisector));
				// END: Modified by Microsoft Corporation for generic logging purposes.

				offset = 0;
				return false;
			}
			offset = 0;
			return false;
		}

public static float PointSegment(Vector2 point, Segment2 segment)
		{
			return Vector2.Distance(point, Closest.PointSegment(point, segment));
		}

public static float CircleCircle(Vector2 centerA, float radiusA, Vector2 centerB, float radiusB)
		{
			return Vector2.Distance(centerA, centerB) - radiusA - radiusB;
		}

protected virtual float EvaluateLength()
        {
            if (args.angular == 0)
            {
                return radian;
            }

            var halfPI = Mathf.PI * 0.5f;
            var angularAbs = Mathf.Abs(args.angular);
            var piece = Vector2.Distance(Vector2.zero, new Vector2(halfPI / angularAbs, args.amplitude));
            var pieces = piece * angularAbs;
            var segments = Mathf.RoundToInt(radian / halfPI);
            return pieces * segments;
        }

public float GetDistance() {
		float traveledDistance = Vector2.Distance(new Vector2(startingPosition.x, 0),
		                                          new Vector2(this.transform.position.x, 0));
		return traveledDistance;	                                                                               
	}

private void MoveToDestination(float timeSeconds)
    {
        var maxDistance = timeSeconds * this.movementVelocity;
        var currentPosition = this.RootTransform.position.AddY(-this.SpriteOffsetY);
        var remainingDistance = Vector2.Distance(this.CentralPosition, this.warehouseDestination.CentralPosition);
        if (maxDistance > Math.Abs(remainingDistance))
        {
            this.ArriveDestination();
            return;
        }
        this.RootTransform.position = Vector2.MoveTowards(this.CentralPosition, this.warehouseDestination.CentralPosition, maxDistance)
            .AddY(this.SpriteOffsetY);
    }

public void ScaleMaterial()
        {
            lR = GetComponent<LineRenderer>();
            rend = GetComponent<Renderer>();
            rend.material.mainTextureScale =
                new Vector2(Vector2.Distance(lR.GetPosition(0), lR.GetPosition(lR.positionCount - 1)) / lR.widthMultiplier,
                    1);
        }

private void Update()
        {
            rend.material.mainTextureScale =
                new Vector2(Vector2.Distance(lR.GetPosition(0), lR.GetPosition(lR.positionCount - 1)) / lR.widthMultiplier,
                    1);
        }

private void TwoFinger(){
	
		float timeSinceStartAction=0;
		bool move=false;
		Vector2 position = Vector2.zero;
		Vector2 deltaPosition = Vector2.zero;
		float fingerDistance = 0;
			
		// A touch starts
		if ( complexCurrentGesture==GestureType.None){
			twoFinger0 = GetTwoFinger(-1);
			twoFinger1 = GetTwoFinger(twoFinger0);
			
			startTimeAction = Time.realtimeSinceStartup;
			complexCurrentGesture=GestureType.Tap;
			
			fingers[twoFinger0].complexStartPosition = fingers[twoFinger0].position;
			fingers[twoFinger1].complexStartPosition = fingers[twoFinger1].position;
			
			fingers[twoFinger0].oldPosition = fingers[twoFinger0].position;
			fingers[twoFinger1].oldPosition = fingers[twoFinger1].position;
			
		
			oldFingerDistance = Mathf.Abs( Vector2.Distance(fingers[twoFinger0].position, fingers[twoFinger1].position));
			startPosition2Finger = new Vector2((fingers[twoFinger0].position.x+fingers[twoFinger1].position.x)/2, (fingers[twoFinger0].position.y+fingers[twoFinger1].position.y)/2);
			deltaPosition = Vector2.zero;
			
			// do we touch a pickable gameobject ?
			if (autoSelect){
				pickObject2Finger = GetPickeGameObject(fingers[twoFinger0].complexStartPosition);
				if (pickObject2Finger!= GetPickeGameObject(fingers[twoFinger1].complexStartPosition)){
					pickObject2Finger =null;
				}
			}
			
			// we notify the touch
			CreateGesture2Finger(EventName.On_TouchStart2Fingers,startPosition2Finger,startPosition2Finger,deltaPosition,timeSinceStartAction, SwipeType.None,0,Vector2.zero,0,0,oldFingerDistance);				
		}
		
			
		// Calculates the time since the beginning of the action.
		timeSinceStartAction =  Time.realtimeSinceStartup -startTimeAction;
		
		// Position & deltaPosition
		position = new  Vector2((fingers[twoFinger0].position.x+fingers[twoFinger1].position.x)/2, (fingers[twoFinger0].position.y+fingers[twoFinger1].position.y)/2);
		deltaPosition = position - oldStartPosition2Finger;
		fingerDistance = Mathf.Abs(Vector2.Distance(fingers[twoFinger0].position, fingers[twoFinger1].position));
		
		// Cancel
		if (fingers[twoFinger0].phase == TouchPhase.Canceled ||fingers[twoFinger1].phase == TouchPhase.Canceled){
			complexCurrentGesture = GestureType.Cancel;
		}
		
		// Let's go
		if (fingers[twoFinger0].phase != TouchPhase.Ended && fingers[twoFinger1].phase != TouchPhase.Ended && complexCurrentGesture != GestureType.Cancel ){
			
			// Are we stationary ?
			if (complexCurrentGesture == GestureType.Tap && timeSinceStartAction >= longTapTime && FingerInTolerance(fingers[twoFinger0]) && FingerInTolerance(fingers[twoFinger1])){	
				complexCurrentGesture = GestureType.LongTap;				
				// we notify the beginning of a longtouch
				CreateGesture2Finger(EventName.On_LongTapStart2Fingers,startPosition2Finger,position,deltaPosition,timeSinceStartAction, SwipeType.None,0,Vector2.zero,0,0,fingerDistance);				
			}	
			
			// Let's move us ?
			//if (FingerInTolerance(fingers[twoFinger0])==false ||FingerInTolerance(fingers[twoFinger1])==false){
				move=true;
			//}
	 		
			// we move
			if (move){
						
				float dot = Vector2.Dot(fingers[twoFinger0].deltaPosition.normalized, fingers[twoFinger1].deltaPosition.normalized);
																																															
				// Pinch
				if (enablePinch && fingerDistance != oldFingerDistance ){
					// Pinch
					if (Mathf.Abs( fingerDistance-oldFingerDistance)>=minPinchLength){
						complexCurrentGesture = GestureType.Pinch;				
					}
					
					// update pinch
					if (complexCurrentGesture == GestureType.Pinch){	
						//complexCurrentGesture = GestureType.Acquisition;				
						if (fingerDistance<oldFingerDistance){
							
							// Send end message
							if (oldGesture != GestureType.Pinch){
								CreateStateEnd2Fingers(oldGesture,startPosition2Finger,position,deltaPosition,timeSinceStartAction,false,fingerDistance); 
								startTimeAction = Time.realtimeSinceStartup;
							}
							
							// Send pinch
							CreateGesture2Finger(EventName.On_PinchIn,startPosition2Finger,position,deltaPosition,timeSinceStartAction, GetSwipe(fingers[twoFinger0].complexStartPosition,fingers[twoFinger0].position),0,Vector2.zero,0,Mathf.Abs(fingerDistance-oldFingerDistance),fingerDistance);
							complexCurrentGesture = GestureType.Pinch;
	
						}
						else if (fingerDistance>oldFingerDistance){
							// Send end message
							if (oldGesture != GestureType.Pinch){
								CreateStateEnd2Fingers(oldGesture,startPosition2Finger,position,deltaPosition,timeSinceStartAction,false,fingerDistance);
								startTimeAction = Time.realtimeSinceStartup;
							}
							
							// Send pinch
							CreateGesture2Finger(EventName.On_PinchOut,startPosition2Finger,position,deltaPosition,timeSinceStartAction, GetSwipe(fingers[twoFinger0].complexStartPosition,fingers[twoFinger0].position),0,Vector2.zero,0,Mathf.Abs(fingerDistance-oldFingerDistance),fingerDistance);
							complexCurrentGesture = GestureType.Pinch;
						}	
					}
				}
					
				// Twist
				if (enableTwist){
	
					if (Mathf.Abs(TwistAngle())>minTwistAngle){
					
						// Send end message
						if (complexCurrentGesture != GestureType.Twist){
							CreateStateEnd2Fingers(complexCurrentGesture,startPosition2Finger,position,deltaPosition,timeSinceStartAction,false,fingerDistance);
							startTimeAction = Time.realtimeSinceStartup;
						}
						complexCurrentGesture = GestureType.Twist;
					}
							
					// Update Twist
					if (complexCurrentGesture == GestureType.Twist){
						CreateGesture2Finger(EventName.On_Twist,startPosition2Finger,position,deltaPosition,timeSinceStartAction, SwipeType.None,0,Vector2.zero,TwistAngle(),0,fingerDistance);
					}
	
					fingers[twoFinger0].oldPosition = fingers[twoFinger0].position;
					fingers[twoFinger1].oldPosition = fingers[twoFinger1].position;
				}
		
				// Drag
				if (dot>0 ){
					if (pickObject2Finger && !twoFingerDragStart){
						// Send end message
						if (complexCurrentGesture != GestureType.Tap){
							CreateStateEnd2Fingers(complexCurrentGesture,startPosition2Finger,position,deltaPosition,timeSinceStartAction,false,fingerDistance);
							startTimeAction = Time.realtimeSinceStartup;
						}
						//
						CreateGesture2Finger(EventName.On_DragStart2Fingers,startPosition2Finger,position,deltaPosition,timeSinceStartAction, SwipeType.None,0,Vector2.zero,0,0,fingerDistance);	
						twoFingerDragStart = true; 
					}
					else if (!pickObject2Finger && !twoFingerSwipeStart ) {
						// Send end message
						if (complexCurrentGesture!= GestureType.Tap){
							CreateStateEnd2Fingers(complexCurrentGesture,startPosition2Finger,position,deltaPosition,timeSinceStartAction,false,fingerDistance);
							startTimeAction = Time.realtimeSinceStartup;
						}
						//
						
						CreateGesture2Finger(EventName.On_SwipeStart2Fingers,startPosition2Finger,position,deltaPosition,timeSinceStartAction, SwipeType.None,0,Vector2.zero,0,0,fingerDistance);
						twoFingerSwipeStart=true;
					}
				} 
				else{
					if (dot<0){
						twoFingerDragStart=false; 
						twoFingerSwipeStart=false;
					}
				}
			
				//
				if (twoFingerDragStart){
					CreateGesture2Finger(EventName.On_Drag2Fingers,startPosition2Finger,position,deltaPosition,timeSinceStartAction, GetSwipe(oldStartPosition2Finger,position),0,deltaPosition,0,0,fingerDistance);
				}
				
				if (twoFingerSwipeStart){
					CreateGesture2Finger(EventName.On_Swipe2Fingers,startPosition2Finger,position,deltaPosition,timeSinceStartAction, GetSwipe(oldStartPosition2Finger,position),0,deltaPosition,0,0,fingerDistance);
				}
								
			}
			else{
				// Long tap update
		 		if (complexCurrentGesture == GestureType.LongTap){
					CreateGesture2Finger(EventName.On_LongTap2Fingers,startPosition2Finger,position,deltaPosition,timeSinceStartAction, SwipeType.None,0,Vector2.zero,0,0,fingerDistance);
				}
			}
	
			CreateGesture2Finger(EventName.On_TouchDown2Fingers,startPosition2Finger,position,deltaPosition,timeSinceStartAction, GetSwipe(oldStartPosition2Finger,position),0,deltaPosition,0,0,fingerDistance);
		
			
			oldFingerDistance = fingerDistance;
			oldStartPosition2Finger = position;
			oldGesture = complexCurrentGesture;
		}
		else{			
			CreateStateEnd2Fingers(complexCurrentGesture,startPosition2Finger,position,deltaPosition,timeSinceStartAction,true,fingerDistance);
			complexCurrentGesture = GestureType.None;
			pickObject2Finger=null;
			twoFingerSwipeStart = false;
			twoFingerDragStart = false;
		}	
	}

private void HandleEvent(Rect r, Event e){

      Vector2 position = e.mousePosition;

      switch(e.type){

        case EventType.MouseDown:

          if(r.Contains(position)){

            if(e.clickCount == 2){

              spectrum.selection = spectrum.points.Count;
              spectrum.points.Add(MapMouseEvent(r, position));
              Undo.SetCurrentGroupName("Point Added");
              GUI.changed = true;

            } else{

              int selection = spectrum.selection;
              float minDistance = float.MaxValue;

              for(int i = 0; i < spectrum.points.Count; i++){

                float distance = Vector2.Distance(MapPointPosition(r, spectrum.points[i]), position);

                if(distance < minDistance){

                  selection = i;
                  minDistance = distance;

                }

              }

              if(selection != spectrum.selection){

                spectrum.selection = selection;
                Undo.SetCurrentGroupName("Point Selected");
                GUI.changed = true;

              }

            }

            focus = spectrum.GetHashCode();
            dragInitiated = true;

          } else{

            isDragging = false;
            focus = 0;

          }

          e.Use();

          break;

        case EventType.MouseDrag:

          if(dragInitiated){

            dragInitiated = false;
            isDragging = true;

          }

          if(isDragging && spectrum.selection < spectrum.points.Count){

            spectrum.points[spectrum.selection] = MapMouseEvent(r, position);
            e.Use();

          }

          break;

        case EventType.Ignore:
        case EventType.MouseUp:

          dragInitiated = false;

          if(isDragging){

            isDragging = false;
            Undo.SetCurrentGroupName("Point Moved");
            GUI.changed = true;
            e.Use();

          }

          break;

        case EventType.KeyDown:

          switch(e.keyCode){

            case KeyCode.Delete:
            case KeyCode.Backspace:

              if(spectrum.selection < spectrum.points.Count){

                RemovePointAt(spectrum.selection);
                e.Use();

              }

              break;

          }

          break;

      }

    }

public static bool Prefix(Vent __instance, ref float __result, [HarmonyArgument(0)] GameDataPlayerInfo pc, [HarmonyArgument(1)] out bool creplacede, [HarmonyArgument(2)] out bool couldUse)
		{
			float num = float.MaxValue;
			PlayerControl @object = pc.LAOEJKHLKAI;
			couldUse = (pc.DAPKNDBLKIA || pc.JKOMCOJCAID == PlayerControlPatch.Sweeper.PlayerId) && !pc.DLPCKPBIJOE && (@object.GEBLLBHGHLD || @object.inVent);
			creplacede = couldUse;
			if (creplacede)
			{
				num = Vector2.Distance(@object.GetTruePosition(), __instance.transform.position);
				creplacede &= num <= __instance.ILPBJHPGNBJ;
			}
			__result = num;
			return false;
		}

public static bool Prefix(Vent __instance, ref float __result, [HarmonyArgument(0)] GameDataPlayerInfo pc, [HarmonyArgument(1)] out bool creplacede, [HarmonyArgument(2)] out bool couldUse)
		{
			float num = float.MaxValue;
			PlayerControl @object = pc.LAOEJKHLKAI;
			couldUse = (pc.DAPKNDBLKIA || pc.JKOMCOJCAID == PlayerControlPatch.Sweeper.PlayerId) && !pc.DLPCKPBIJOE && (@object.GEBLLBHGHLD || @object.inVent);
			creplacede = couldUse;
			if (creplacede)
            {
				num = Vector2.Distance(@object.GetTruePosition(), __instance.transform.position);
				creplacede &= num <= __instance.ILPBJHPGNBJ;
            }
			__result = num;
			return false;
		}

public override TaskStatus OnUpdate()
        {
            storeResult.Value = Vector2.Distance(firstVector2.Value, secondVector2.Value);
            return TaskStatus.Success;
        }

public static float DistanceToLine(Vector2 a, Vector2 b, Vector2 point){
			// Return minimum distance between line segment vw and point p
			float l2 = Vector2.SqrMagnitude(a - b);  // i.e. |w-v|^2 -  avoid a sqrt
			if (l2 == 0.0)
				return Vector2.Distance(point, a);   // v == w case
			// Consider the line extending the segment, parameterized as v + t (w - v).
			// We find projection of point p onto the line. 
			// It falls where t = [(p-v) . (w-v)] / |w-v|^2
			float t = Vector2.Dot(point - a, b - a) / l2;
			if (t < 0.0)
				return Vector2.Distance(point, a);       // Beyond the 'v' end of the segment
			else if (t > 1.0)
				return Vector2.Distance(point, b);  // Beyond the 'w' end of the segment
			Vector2 projection = a + t * (b - a);  // Projection falls on the segment
			return Vector2.Distance(point, projection);
		}