public InputAction(GamePadButton myButton, bool myNewPressOnly,int myPlayer)
 {
     gamePadButton = myButton;
     newPressOnly = myNewPressOnly;
     inputType = InputType.gamepad;
     playerIndex = myPlayer;
 }

        /// <summary>
        /// Renders out field with honeypot security check enabled
        /// </summary>
        /// <param name="helper">HtmlHelper which will be extended</param>
        /// <param name="name">Name of field. Should match model field of string type</param>
        /// <param name="value">Value of the field</param>
        /// <param name="css">CSS class to be applied to input field</param>
        /// <returns>Returns render out MvcHtmlString for displaying on the View</returns>
        public static MvcHtmlString HoneyPotField(this HtmlHelper helper, string name, object value, string inputCss = null, InputType fieldType=InputType.Text,string honeypotCss = null, InputType honeypotType=InputType.Hidden)
        {
            StringBuilder sbControlHtml = new StringBuilder();
            using (StringWriter stringWriter = new StringWriter())
            {
                using (HtmlTextWriter htmlWriter = new HtmlTextWriter(stringWriter))
                {
                    HtmlInputText hashedField = new HtmlInputText(fieldType.ToString().ToLower());
                    string hashedName = GetHashedPropertyName(name);
                    hashedField.Value = value != null ? value.ToString() : string.Empty;
                    hashedField.ID = hashedName;
                    hashedField.Name = hashedName;
                    if (!string.IsNullOrWhiteSpace(inputCss))
                    {
                        hashedField.Attributes["class"] = inputCss;
                    }
                    hashedField.RenderControl(htmlWriter);


                    HtmlInputText hiddenField = new HtmlInputText(honeypotType.ToString().ToLower());
                    hiddenField.Value = string.Empty;
                    hiddenField.ID = name;
                    hiddenField.Name = name;
                    if (!string.IsNullOrWhiteSpace(honeypotCss))
                    {
                        hiddenField.Attributes["class"] = honeypotCss;
                    }
                    hiddenField.RenderControl(htmlWriter);
                    sbControlHtml.Append(stringWriter.ToString());
                }
            }
            return new MvcHtmlString(sbControlHtml.ToString());
        }

        public static string RenderFormGroupSelectElement(HtmlHelper html, SelectElementModel inputModel,
			LabelModel labelModel, InputType inputType)
        {
            HtmlString input = null;

            if (inputType == InputType.DropDownList)
                input = RenderSelectElement(html, inputModel, InputType.DropDownList);

            if (inputType == InputType.ListBox)
                input = RenderSelectElement(html, inputModel, InputType.ListBox);

            var label = RenderLabel(html, labelModel ?? new LabelModel
            {
                htmlFieldName = inputModel.htmlFieldName,
                metadata = inputModel.metadata,
                htmlAttributes = new {@class = "control-label"}.ToDictionary()
            });

            var fieldIsValid = true;

            if (inputModel != null)
                fieldIsValid = html.ViewData.ModelState.IsValidField(inputModel.htmlFieldName);

            return new FormGroup(input, label, FormGroupType.TextBoxLike, fieldIsValid).ToHtmlString();
        }

 public override void HandleInput(InputType input)
 {
     if (input == InputType.Confirm && ButtonClicked != null)
     {
         ButtonClicked.Invoke();
     }
 }

 public HtmlInput(InputType type, string name, string value)
     : base("input")
 {
     SetAttribut("type", type.ToString());
     SetAttribut("name", name);
     SetAttribut("value", value);
 }

	public void dot(){
		m_dotPressed = true;
		m_activeNum += 0.0f;
		m_view.updateDisplay(m_activeNum);

		m_lastInput = InputType.number;
	}

        public string GenerateHtml(InputType inputType, string label, string name, string value = null,
            List<string> options = null)
        {
            string result = inputList[inputType].GenerateHtml(label, name, value, options);

            return result;
        }

    /// <summary>
    /// Calculates whether input is swipe or not.
    /// </summary>
    private void swipeCalculator()
    {
        if (Input.touchCount > 0)
        {
            Touch t = Input.GetTouch(0);

            switch(t.phase)
            {
                case TouchPhase.Began:
                    {
                        startPos = t.position;
                        break;
                    }
                case TouchPhase.Ended:
                    {
                        endPos = t.position;
                        Vector2 lengthOfSwipe = endPos - startPos;
                        if(lengthOfSwipe.magnitude > 90)
                        {
                            touchInput = InputType.SWIPE;
                        }
                        else
                        {
                            touchInput = InputType.TOUCH;
                        }
                        break;
                    }
            }
        }

    }

        public InputConfig(int index)
        {
            Name = "Input #" + (index + 1).ToString("N0");

            PhantomPower = false;
            Type = InputType.Line;
        }

 public GameButton(Buttons buttonCode)
 {
     this.keyCode = Keys.None;
     this.mouseCode = MouseButtons.None;
     this.buttonCode = buttonCode;
     this.inputType = InputType.Button;
 }

        public InputResult OnInput(InputType inputType, MouseEventArgs beginArgs, MouseEventArgs endArgs, object args)
        {
            foreach (DrawComponent drawComponent in _drawComponents)
            {
                if (drawComponent is IInputEnabled && Utils.IsInputStartInBounds(drawComponent, beginArgs))
                {
                    InputResult result = (drawComponent as IInputEnabled).OnInput(inputType, beginArgs, endArgs, args);

                    if (result == InputResult.Consumed)
                    {
                        FocusOn((drawComponent as IInputEnabled));
                        return InputResult.Consumed;
                    }

                }
            }

            // try to consume the gesture by myself
            if (inputType == InputType.Drag)
            {
                if ((args as DragDirection? ?? DragDirection.Left) == DragDirection.Down)
                    SetContentOffset(endArgs.Y - beginArgs.Y);

                if ((args as DragDirection? ?? DragDirection.Left) == DragDirection.Up)
                    SetContentOffset(endArgs.Y - beginArgs.Y);

                return InputResult.Consumed;
            }

            return InputResult.Bubble;
        }

    /// <summary>
    /// 绘制窗口
    /// </summary>
    public override void DrawWindow()
    {
        // 绘制标题
        base.DrawWindow();

        // 绘制选择类型
        inputType = (InputType) EditorGUILayout.EnumPopup("Input type : " , inputType);

        if(inputType == InputType.Number)
        {
            // 绘制Value
            inputValue = EditorGUILayout.TextField("Value", inputValue);
        }
        else if(inputType == InputType.Randomization)
        {
            // 绘制范围
            randomFrom = EditorGUILayout.TextField("From", randomFrom);
            randomTo = EditorGUILayout.TextField("To", randomTo);

            // 随机值
            if(GUILayout.Button("Calculate Random"))
            {
                calculateRandom();
            }
        }
    }

 public virtual void Initialise(string fieldTitle, string fieldType, int fieldId, int moduleId,
                                string controlHelpText, string defaultValue, bool required, string validationRule,
                                string validationMsg, string editStyle, string inputSettings,
                                string outputSettings, bool normalizeFlag, bool multipleValuesFlag,
                                bool inputFilterTags, bool inputFilterScript, InputType inputSettingsListType,
                                ModuleInstanceContext moduleContext, DataTable fieldSettingsTable,
                                IFormEvents formEvents)
 {
     FieldTitle = fieldTitle;
     FieldType = fieldType;
     FieldId = fieldId;
     ModuleId = moduleId;
     HelpText = controlHelpText;
     DefaultValue = defaultValue;
     Required = required;
     ValidationRule = validationRule;
     _customValidationMessage = validationMsg;
     InputSettings = inputSettings;
     OutputSettings = outputSettings;
     Style = editStyle;
     NormalizeFlag = normalizeFlag;
     MultipleValuesFlag = multipleValuesFlag;
     FilterScript = inputFilterScript;
     FilterTags = inputFilterTags;
     ListInputType = inputSettingsListType;
     ModuleContext = moduleContext;
     FieldSettingsTable = fieldSettingsTable;
     FormEvents = formEvents;
 }

 private void OnInput(InputType input)
 {
     if (IsSelected)
     {
         HandleInput(input);
     }
 }

        public void HandleInput(InputType key, InputState state)
        {
            if (_currentGame == null)
                return;

            if (state == InputState.Released)
            {
                if (key == InputType.Next)
                {
                    StartNextGame();
                    return;
                }

                if (key == InputType.Pause)
                {
                    TogglePause(true);
                    return;
                }
            }

            if (state == InputState.Pressed)
                _currentGame.KeyPressed(key);

            if (state == InputState.Released)
                _currentGame.KeyReleased(key);
        }

 public StringInputController(InputType inputType)
 {
     _lastPressedKeys = new List<Keys>();
     MaxInputCharacters = 256;
     CurrentText = string.Empty;
     SetInputType(inputType);
 }

 internal static UIKeyboardType GetKeyboardType(InputType inputType) {
     switch (inputType) {
         case InputType.Email  : return UIKeyboardType.EmailAddress;
         case InputType.Number : return UIKeyboardType.NumberPad;
         default               : return UIKeyboardType.Default;
     }
 }

 // Update is called once per frame
 void Update()
 {
     
     swipeCalculator();
     switch (touchInput)
     {
         case InputType.IDLE:
             {
                 print("Listening for touch");
                 break;
             }
         case InputType.TOUCH:
             {
                 print("You touched");
                 break;
             }
         case InputType.SWIPE:
             {
                 print("You swiped");
                 Vector3 rayCastDirection = getRayCastDirection(endPos - startPos);
                 movePlayerToLocation(rayCastDirection);
                 break;
             }
     }
     touchInput = InputType.IDLE;
 }

        public InputManager(InputType type, PlayerIndex player)
        {
            this.inputType = type;
              this.playerIndex = player;

              // Populate Dictionary Entries
              inputToKeys = new Dictionary<Inputs, Keys>();
              inputToKeys.Add(Inputs.A, Keys.A);
              inputToKeys.Add(Inputs.B, Keys.S);
              inputToKeys.Add(Inputs.Back, Keys.Escape);
              inputToKeys.Add(Inputs.Up, Keys.Up);
              inputToKeys.Add(Inputs.Down, Keys.Down);
              inputToKeys.Add(Inputs.Left, Keys.Left);
              inputToKeys.Add(Inputs.Right, Keys.Right);
              inputToKeys.Add(Inputs.Start, Keys.Enter);
              inputToKeys.Add(Inputs.X, Keys.Z);
              inputToKeys.Add(Inputs.Y, Keys.X);

              inputToButtons = new Dictionary<Inputs, Buttons>();
              inputToButtons.Add(Inputs.A, Buttons.A);
              inputToButtons.Add(Inputs.B, Buttons.B);
              inputToButtons.Add(Inputs.Back, Buttons.Back);
              inputToButtons.Add(Inputs.Up, Buttons.DPadUp);
              inputToButtons.Add(Inputs.Down, Buttons.DPadDown);
              inputToButtons.Add(Inputs.Left, Buttons.DPadLeft);
              inputToButtons.Add(Inputs.Right, Buttons.DPadRight);
              inputToButtons.Add(Inputs.Start, Buttons.Start);
              inputToButtons.Add(Inputs.X, Buttons.X);
              inputToButtons.Add(Inputs.Y, Buttons.Y);

              inputToMouse = new Dictionary<Inputs, MouseButton>();
              inputToMouse.Add(Inputs.A, MouseButton.Left);
              inputToMouse.Add(Inputs.B, MouseButton.Right);
              inputToMouse.Add(Inputs.X, MouseButton.Middle);
        }

        public GUIPlayer(
            Simulator simulator,
            Dictionary<TurretType, bool> availableTurrets,
            Dictionary<string, LevelDescriptor> levelsDescriptors,
            Color color,
            string representation,
            InputType inputType)
        {
            Simulator = simulator;

            SelectedCelestialBodyAnimation = new SelectedCelestialBodyAnimation(Simulator);

            Cursor = new SpaceshipCursor(Simulator.Scene, Vector3.Zero, 2, VisualPriorities.Default.PlayerCursor, color, representation, true);
            Crosshair = new Cursor(Simulator.Scene, Vector3.Zero, 2, VisualPriorities.Default.PlayerCursor, "crosshairRailGun", false);
            TurretMenu = new TurretMenu(Simulator, VisualPriorities.Default.TurretMenu, color, inputType);
            CelestialBodyMenu = new CelestialBodyMenu(Simulator, VisualPriorities.Default.CelestialBodyMenu, color, inputType);

            FinalSolutionPreview = new FinalSolutionPreview(Simulator);

            CelestialBodyMenu.AvailableTurrets = availableTurrets;
            CelestialBodyMenu.Initialize();

            WorldMenu = new WorldMenu(Simulator, VisualPriorities.Default.CelestialBodyMenu, levelsDescriptors, color);
            NewGameMenu = new NewGameMenu(Simulator, VisualPriorities.Default.CelestialBodyMenu, color);

            PowerUpInputMode = false;
            PowerUpFinalSolution = false;
        }