Beispiel #1
0
        static void OnFullscreenHotkeyEvent(KeyCode keyCode, EventModifiers modifiers, bool setFullscreen)
        {
            var  character     = DemoCharacter.instance;
            bool completedRoom = false;
            int  currentRoom   = character.enteredRooms.Count;

            switch (currentRoom)
            {
            case 6:
                var focusedWinOps = EditorFullscreenSettings.settings.currentlyFocusedWindow;
                if (setFullscreen && EditorInput.HotkeysMatch(keyCode, modifiers, focusedWinOps.hotkey, focusedWinOps.modifiers))
                {
                    if (lastFullscreenedWindowType == EditorFullscreenState.InspectorWindowType)
                    {
                        completedRoom = true;
                    }
                }
                break;

            case 7:
                var winUnderCursorOps = EditorFullscreenSettings.settings.windowUnderCursor;
                if (setFullscreen && EditorInput.HotkeysMatch(keyCode, modifiers, winUnderCursorOps.hotkey, winUnderCursorOps.modifiers))
                {
                    if (lastFullscreenedWindowType == EditorFullscreenState.ConsoleWindowType)
                    {
                        completedRoom = true;
                    }
                }
                break;
            }
            if (completedRoom)
            {
                character.CompleteRoom(currentRoom);
            }
        }
Beispiel #2
0
        private void DOSliderToNote(int index)
        {
            float finalY = yOffset - (index * indexOffset);

            //selectedSlider.transform.(new Vector3(0f, finalY, 0f), 1f).SetEase(Ease.InOutCubic);
            DOTween.To(SetSelectedSliderPosY, sliderRTrans.anchoredPosition.y, finalY, 0.3f).SetEase(Ease.InOutCubic);

            selectedSlider.GetComponent <Image>().DOColor(EditorInput.GetSelectedColor(), 1f);
        }
    public IInput GetInput()
    {
        IInput inputController = null;

#if UNITY_EDITOR || UNITY_STANDALONE
        inputController = new EditorInput(_swipeThreshHold);
#elif UNITY_ANDROID || UNITY_IOS
        inputController = new TouchInput(_swipeThreshHold);
#endif
        return(inputController);
    }
Beispiel #4
0
 private static void GetInfoForFullscreenOption(EditorFullscreenSettings.FullscreenOption fullscreenOption, out string openAtPos, out string keysDownString)
 {
     if (fullscreenOption.openAtPosition == EditorFullscreenSettings.OpenFullscreenAtPosition.AtSpecifiedPosition)
     {
         openAtPos = "at the position: " + fullscreenOption.position;
     }
     else
     {
         openAtPos = EditorFullscreenSettings.FormatCamelCaseName(fullscreenOption.openAtPosition.ToString()).ToLower().Replace("at ", "at the ");
     }
     keysDownString = EditorInput.GetKeysDownString(fullscreenOption.hotkey, fullscreenOption.modifiers);
 }
Beispiel #5
0
        private void CheckTouch(Touch touch)
        {
            Vector3 v3;

#if UNITY_EDITOR
            var pos = Input.mousePosition;
#else
            var pos = touch.position;
#endif //UNITY_EDITOR

            if (EditorInput.GetState(touch, EditorInput.InputState.Began))
            {
                Dragging           = false;
                _prisonerTransform = null;

                RaycastHit hit;
                var        ray = Camera.main.ScreenPointToRay(pos);

                if (Physics.Raycast(ray, out hit))
                {
                    _prisonerAi = hit.collider.GetComponent <PrisonerAi>();

                    if (_prisonerAi == null)
                    {
                        return;
                    }

                    _prisonerTransform = hit.transform;
                    _prisonerAi.Rigidbody.isKinematic = true;
                    _dist    = hit.transform.position.z - Camera.main.transform.position.z;
                    v3       = new Vector3(pos.x, pos.y, _dist);
                    v3       = Camera.main.ScreenToWorldPoint(v3);
                    _offset  = _prisonerTransform.position - v3;
                    Dragging = true;
                }
            }
            if (Dragging && EditorInput.GetState(touch, EditorInput.InputState.Moving))
            {
                v3 = new Vector3(Input.mousePosition.x, Input.mousePosition.y, _dist);
                v3 = Camera.main.ScreenToWorldPoint(v3);
                if (_prisonerTransform != null)
                {
                    _prisonerTransform.position = v3 + _offset;
                }
            }
            if (Dragging &&
                (EditorInput.GetState(touch, EditorInput.InputState.Ended) ||
                 EditorInput.GetState(touch, EditorInput.InputState.Canceled)))
            {
                Dragging = false;
                _objectPool.SetAllFree();
            }
        }
        IEnumerator PlayAndHideNotification(NRNotification notification)
        {
            float fadeDuration = (float)NRSettings.config.UIFadeDuration;

            //TODO: Set icon to success or fail or info
            switch (notification.type)
            {
            case NRNotifType.Success:

                break;
            }

            //Reset the notif;
            text.SetText(notification.content);
            sliderImg.color  = EditorInput.GetSelectedColor();
            slider.sizeDelta = new Vector2(0, 0);

            //FADE IN
            nImage.DOFade(notifOpacity, fadeDuration / 2f);
            successIcon.DOFade(1f, fadeDuration / 2f);
            text.DOFade(1f, fadeDuration / 2f);
            sliderImg.DOFade(1f, fadeDuration / 2f);


            //Start the slider going
            DOTween.To(SetSliderWidth, 0f, 183.13f, notification.duration).SetEase(Ease.InOutCubic);

            yield return(new WaitForSeconds(notification.duration));

            //FADE OUT
            nImage.DOFade(0, fadeDuration / 2f);
            successIcon.DOFade(0, fadeDuration / 2f);
            text.DOFade(0, fadeDuration / 2f);
            sliderImg.DOFade(0, fadeDuration / 2f);



            yield break;
        }
Beispiel #7
0
        public void UpdateUINoteSelected(EditorTool type)
        {
            Color color        = EditorInput.GetSelectedColor();
            float fadeDuration = (float)NRSettings.config.UIFadeDuration;

            switch (type)
            {
            case EditorTool.Standard:
                DOSliderToNote(0);
                //selectedSlider.GetComponent<Image>().DOFade(1f, fadeDuration);

                srstandard.DOFade(1, fadeDuration);
                srstandard.DOColor(color, fadeDuration);

                srhold.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                srhold.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);
                imgDragSelect.DOFade(fadeAmount, fadeDuration);

                break;

            case EditorTool.Hold:
                DOSliderToNote(1);
                //selectedSlider.GetComponent<Image>().DOFade(1f, fadeDuration);

                srhold.DOFade(1, fadeDuration);
                srhold.DOColor(color, fadeDuration);

                srstandard.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                srstandard.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);
                imgDragSelect.DOFade(fadeAmount, fadeDuration);

                break;

            case EditorTool.Horizontal:
                DOSliderToNote(2);
                //selectedSlider.GetComponent<Image>().DOFade(1f, fadeDuration);

                srhorizontal.DOFade(1, fadeDuration);
                srhorizontal.DOColor(color, fadeDuration);

                srstandard.DOColor(Color.white, fadeDuration);
                srhold.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                srstandard.DOFade(fadeAmount, fadeDuration);
                srhold.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);
                imgDragSelect.DOFade(fadeAmount, fadeDuration);

                break;

            case EditorTool.Vertical:
                DOSliderToNote(3);
                //selectedSlider.GetComponent<Image>().DOFade(1f, fadeDuration);

                srvertical.DOFade(1, fadeDuration);
                srvertical.DOColor(color, fadeDuration);

                srstandard.DOColor(Color.white, fadeDuration);
                srhold.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                srstandard.DOFade(fadeAmount, fadeDuration);
                srhold.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);
                imgDragSelect.DOFade(fadeAmount, fadeDuration);

                break;

            case EditorTool.ChainStart:
                DOSliderToNote(4);
                //selectedSlider.GetComponent<Image>().DOFade(1f, fadeDuration);

                srchainstart.DOFade(1, fadeDuration);
                srchainstart.DOColor(color, fadeDuration);

                srstandard.DOColor(Color.white, fadeDuration);
                srhold.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                srstandard.DOFade(fadeAmount, fadeDuration);
                srhold.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);
                imgDragSelect.DOFade(fadeAmount, fadeDuration);

                break;

            case EditorTool.ChainNode:
                DOSliderToNote(5);
                //selectedSlider.GetComponent<Image>().DOFade(1f, fadeDuration);

                srchainnode.DOFade(1, fadeDuration);
                srchainnode.DOColor(color, fadeDuration);

                srstandard.DOColor(Color.white, fadeDuration);
                srhold.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                srstandard.DOFade(fadeAmount, fadeDuration);
                srhold.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);
                imgDragSelect.DOFade(fadeAmount, fadeDuration);

                break;

            case EditorTool.Melee:

                DOSliderToNote(6);
                //selectedSlider.GetComponent<Image>().DOFade(1f, fadeDuration);


                srmelee.DOFade(1, fadeDuration);
                srmelee.DOColor(color, fadeDuration);

                srstandard.DOColor(Color.white, fadeDuration);
                srhold.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);

                srstandard.DOFade(fadeAmount, fadeDuration);
                srhold.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);
                imgDragSelect.DOFade(fadeAmount, fadeDuration);

                break;


            //The other editor tools that aren't on the sidebar
            case EditorTool.DragSelect:
                //DOSliderToNote(6, Color.white);

                //Fade in the button
                imgDragSelect.DOFade(1f, fadeDuration);


                //Fade out the slider
                selectedSlider.GetComponent <Image>().DOFade(0f, fadeDuration);

                //Reset all note toolbar colors
                srstandard.DOColor(Color.white, fadeDuration);
                srhold.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                //Fade them out
                srstandard.DOFade(fadeAmount, fadeDuration);
                srhold.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgChainBuilder.DOFade(fadeAmount, fadeDuration);



                break;


            case EditorTool.ChainBuilder:
                //DOSliderToNote(6, Color.white);

                //Fade in the button
                imgChainBuilder.DOFade(1f, fadeDuration);


                //Fade out the slider
                selectedSlider.GetComponent <Image>().DOFade(0f, fadeDuration);

                //Reset all note toolbar colors
                srstandard.DOColor(Color.white, fadeDuration);
                srhold.DOColor(Color.white, fadeDuration);
                srhorizontal.DOColor(Color.white, fadeDuration);
                srvertical.DOColor(Color.white, fadeDuration);
                srchainstart.DOColor(Color.white, fadeDuration);
                srchainnode.DOColor(Color.white, fadeDuration);
                srmelee.DOColor(Color.white, fadeDuration);

                //Fade them out
                srstandard.DOFade(fadeAmount, fadeDuration);
                srhold.DOFade(fadeAmount, fadeDuration);
                srhorizontal.DOFade(fadeAmount, fadeDuration);
                srvertical.DOFade(fadeAmount, fadeDuration);
                srchainstart.DOFade(fadeAmount, fadeDuration);
                srchainnode.DOFade(fadeAmount, fadeDuration);
                srmelee.DOFade(fadeAmount, fadeDuration);

                imgDragSelect.DOFade(fadeAmount, fadeDuration);



                break;
            }
        }
Beispiel #8
0
        public bool HandleInput(EditorInput input)
        {
            switch (input)
            {
                case EditorInput.UpArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Up);
                    return false;
                case EditorInput.DownArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Down);
                    return false;
                case EditorInput.LeftArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Left);
                    return false;
                case EditorInput.RightArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Right);
                    return false;
                case EditorInput.Enter:
                    Buffer.SplitLine(Cursor);
                    Cursor = Cursor.Move(Buffer, MoveDirection.Right);
                    return true;
                case EditorInput.Backspace:
                    if (Cursor.AtFirstColumn(Buffer))
                    {
                        if (!Cursor.AtStart(Buffer))
                        {
                            Cursor = Cursor.Move(Buffer, MoveDirection.Left);
                            Buffer.MergeLine(Cursor.Line + 1);
                            return true;
                        }
                    }
                    else
                    {
                        Buffer.RemoveAt(Cursor, 1);
                        Cursor = Cursor.Move(Buffer, MoveDirection.Left);
                        return true;
                    }
                    return false;
                case EditorInput.Tab:
                    Buffer.InsertAt(Cursor, "    ");
                    Cursor.Column += 4;
                    return true;
                case EditorInput.ShiftTab:
                    return false;
            }

            return false;
        }
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();

        EditorGUILayout.Space(10);
        if (GUILayout.Button("Update Member Data"))
        {
            UpdateMemberNames();
        }
        if (GUILayout.Button("Update Formation Data"))
        {
            UpdateFormationNames();
        }

        if (!editModeEnabled)
        {
            if (GUILayout.Button("Review Formations"))
            {
                CF.ReviewFormations();
                editModeEnabled = true;
            }
            if (CF.mode == CustomFormations.Mode.Random)
            {
                if (GUILayout.Button("Connect to Spawner"))
                {
                    CF.ConnectToSpawner();
                }
            }
            return;
        }
        if (memberNames != null && memberNames.Length != 0)
        {
            GUI.backgroundColor = Color.grey;
            EditorGUILayout.LabelField("Members");
            memberSelected = GUILayout.SelectionGrid(memberSelected, memberNames, CF.memberData.Count);
        }
        else
        {
            EditorGUILayout.LabelField("No Members");
        }
        if (formationNames != null && formationNames.Length != 0)
        {
            EditorGUILayout.LabelField("Formations");
            formationSelected = GUILayout.SelectionGrid(formationSelected, formationNames, 4);
        }
        else
        {
            EditorGUILayout.LabelField("No Formations Added");
        }

        GUI.backgroundColor = Color.white;
        CF.UpdateFormations();

        if (GUILayout.Button("Add Formation"))
        {
            EditorInput input = new EditorInput();
            input.mode   = true;
            input.target = this;
            input.Show();
            input.Focus();
        }
        if (formationNames != null && formationNames.Length != 0 && formationSelected != -1)
        {
            GUILayout.BeginHorizontal();
            if (GUILayout.Button("Rename Formation"))
            {
                EditorInput input = new EditorInput();
                input.mode   = false;
                input.target = this;
                input.Show();
                input.Focus();
            }
            if (CF.openedFormations.Contains(formationSelected))
            {
                if (GUILayout.Button("Save Formation"))
                {
                    CF.SaveFormation(formationSelected);
                }
                if (CF.mode == CustomFormations.Mode.Sequence)
                {
                    if (GUILayout.Button("Add to Sequence"))
                    {
                        CF.AddToSequence(formationSelected);
                    }
                }
            }
            else
            {
                if (GUILayout.Button("Edit Formation"))
                {
                    CF.EditFormation(formationSelected);
                }
            }
            if (GUILayout.Button("Add Member"))
            {
                CF.AddMember(formationSelected, memberSelected);
            }
            GUILayout.EndHorizontal();
        }
        if (GUILayout.Button("Save"))
        {
            CF.Save();
            UpdateFormationNames();
            editModeEnabled = false;
        }
    }
Beispiel #10
0
        public bool HandleInput(EditorInput input)
        {
            switch (input)
            {
                case EditorInput.UpArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Up);
                    return false;
                case EditorInput.DownArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Down);
                    return false;
                case EditorInput.LeftArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Left);
                    return false;
                case EditorInput.RightArrow:
                    Cursor = Cursor.Move(Buffer, MoveDirection.Right);
                    return false;
                case EditorInput.Enter:
                    Buffer.SplitLine(Cursor);
                    Cursor = Cursor.Move(Buffer, MoveDirection.Right);
                    return true;
                case EditorInput.Backspace:
                    if (Cursor.AtFirstColumn(Buffer))
                    {
                        if (!Cursor.AtStart(Buffer))
                        {
                            Cursor = Cursor.Move(Buffer, MoveDirection.Left);
                            Buffer.MergeLine(Cursor.Line + 1);
                            return true;
                        }
                    }
                    else
                    {
                        Buffer.RemoveAt(Cursor, 1);
                        Cursor = Cursor.Move(Buffer, MoveDirection.Left);
                        return true;
                    }
                    return false;
                case EditorInput.Delete:
                    if (!Cursor.AtLastColumn(Buffer))
                    {
                        var newCursor = new Cursor(Cursor.Line, Cursor.Column + 1);
                        Buffer.RemoveAt(newCursor, 1);
                        return true;
                    }
                    else
                    {
                        if (!Cursor.AtLastLine(Buffer))
                        {
                            Buffer.MergeLine(Cursor.Line + 1);
                            return true;
                        }
                    }
                    return false;
                case EditorInput.Tab:
                    Buffer.InsertAt(Cursor, "    ");
                    Cursor.Column += 4;
                    return true;
                case EditorInput.ShiftTab:
                    return false;
                case EditorInput.Home:
                    Cursor.Column = 0;
                    return false;
                case EditorInput.ControlHome:
                    Cursor.Line = 0;
                    Cursor.Column = 0;
                    return false;
                case EditorInput.End:
                    Cursor.Column = Buffer.Lines[Cursor.Line].Data.Length;
                    return false;
                case EditorInput.ControlEnd:
                    Cursor.Line = Buffer.Lines.Count - 1;
                    Cursor.Column = Buffer.Lines[Cursor.Line].Data.Length;
                    return false;
                case EditorInput.PageUp:
                    int newLine = Cursor.Line - (Height - 1);
                    if (newLine < 0)
                        Cursor.Line = 0;
                    else
                        Cursor.Line = newLine;

                    this.StartLine = Cursor.Line;

                    if (Cursor.Column > Buffer.Lines[Cursor.Line].Data.Length)
                        Cursor.Column = Buffer.Lines[Cursor.Line].Data.Length;
                    return true;
                case EditorInput.ControlPageUp:
                    Cursor.Line = StartLine;
                    Cursor.Column = StartColumn;
                    return false;
                case EditorInput.PageDown:
                    newLine = Cursor.Line + (Height - 1);
                    if (newLine > Buffer.Lines.Count)
                        Cursor.Line = Buffer.Lines.Count - 1;
                    else
                        Cursor.Line = newLine;

                    this.StartLine = Cursor.Line;

                    if (Cursor.Column > Buffer.Lines[Cursor.Line].Data.Length)
                        Cursor.Column = Buffer.Lines[Cursor.Line].Data.Length;
                    return true;
                case EditorInput.ControlPageDown:
                    Cursor.Line = Math.Min(StartLine + Height - 2, Buffer.Lines.Count - 1);
                    Cursor.Column = Math.Min(StartColumn + Width - GetGutterWidth() - 1, Buffer.Lines[Cursor.Line].Data.Length);
                    return false;
                case EditorInput.ControlUpArrow:
                    if (StartLine > 0)
                        StartLine -= 1;
                    return true;
                case EditorInput.ControlDownArrow:
                    if (StartLine < Buffer.Lines.Count)
                        StartLine += 1;
                    return true;
            }

            return false;
        }
Beispiel #11
0
 private void Awake()
 {
     this.controls = new EditorInput();
     this.controls.Editor.SetCallbacks(this);
 }
 public bool HandleInput(EditorInput input)
 {
     switch (input)
     {
         case EditorInput.Backspace:
             if (cursor.Column == 0)
                 return true;
             buffer.RemoveAt(cursor, 1);
             cursor.Column--;
             return true;
         case EditorInput.DownArrow:
         case EditorInput.End:
             cursor.Column = buffer.Lines[0].Data.Length;
             return false;
         // IMO, the cursor should go to the first column, not the first non-whitespace 
         case EditorInput.UpArrow:
         case EditorInput.Home:
             cursor.Column = 0;
             return true;
         case EditorInput.LeftArrow:
             cursor.Column = Math.Max(0, cursor.Column - 1);
             return false;
         case EditorInput.RightArrow:
             cursor.Column = Math.Min(Width - 2, cursor.Column + 1);
             return false;
         case EditorInput.Enter:
             {
                 if (CommandRecieved != null)
                     CommandRecieved(this, new CommandArgs(buffer.Lines[0].Data));
            
                 Hide();
                 Clear();
                 return true;
             }
         default:
             return false;
     }
 }
Beispiel #13
0
    void ProcessMouseInput()
    {
        EditorInput     input    = EditorInput.instance;
        SimulationPanel simPanel = SimulationPanel.instance;

        if (FloatingSelection.instance.HasFloatingComponent())
        {
            if (input.singleClick)
            {
                FloatingSelection.instance.PlaceFloatingComponent();
            }
        }
        else
        {
            if (input.singleClick)
            {
                if (!Input.GetKey(KeyCode.LeftShift))
                {
                    SelectedObjects.instance.ClearSelection();
                }
                foreach (var selectable in simPanel.GetActiveSelectables())
                {
                    if (selectable.RequestedSelect())
                    {
                        SelectedObjects.instance.SelectObject(selectable);
                        break;
                    }
                }
            }
            if (input.doubleClick)
            {
                foreach (var configurable in simPanel.GetActiveConfigurables())
                {
                    if (configurable.RequestedConfig())
                    {
                        SelectedObjects.instance.ClearSelection();
                        configurable.OpenConfigWindow();
                        break;
                    }
                }
            }
            if (input.mouseDragStart)
            {
                foreach (var draggable in simPanel.GetActiveDraggables())
                {
                    if (draggable.RequestedDrag())
                    {
                        draggable.StartDragging();
                        currentDraggable = draggable;
                        break;
                    }
                }
                if (currentDraggable == null)
                {
                    BoxSelection.instance.StartSelecting();
                }
            }
            if (input.mouseDragEnd)
            {
                if (currentDraggable != null)
                {
                    currentDraggable.StopDragging();
                    currentDraggable = null;
                }
                else
                {
                    BoxSelection.instance.StopSelecting();
                }
            }
        }
    }