1139 lines
37 KiB
C#
1139 lines
37 KiB
C#
using Beyond;
|
|
using UnityEngine;
|
|
using UnityEngine.EventSystems;
|
|
//using UnityEngine.InputSystem;
|
|
//#if MOBILE_INPUT
|
|
using UnityStandardAssets.CrossPlatformInput;
|
|
//#endif
|
|
|
|
namespace Invector.vCharacterController
|
|
{
|
|
public class vInput : MonoBehaviour
|
|
{
|
|
public delegate void OnChangeInputType(InputDevice type);
|
|
public event OnChangeInputType onChangeInputType;
|
|
//public GameControls inputActions;
|
|
private static vInput _instance;
|
|
public static vInput instance
|
|
{
|
|
get
|
|
{
|
|
if (_instance == null)
|
|
{
|
|
_instance = GameObject.FindObjectOfType<vInput>();
|
|
if (_instance == null)
|
|
{
|
|
_instance = new GameObject("vInputType").AddComponent<vInput>();
|
|
return _instance;
|
|
}
|
|
}
|
|
return _instance;
|
|
}
|
|
}
|
|
|
|
public vHUDController hud;
|
|
|
|
private void Awake()
|
|
{
|
|
if(_instance != null && _instance != this)
|
|
{
|
|
Destroy(this);
|
|
}
|
|
transform.SetParent(null);
|
|
DontDestroyOnLoad(gameObject);
|
|
|
|
//inputActions = new GameControls();
|
|
} void Start()
|
|
{
|
|
if (hud == null) hud = vHUDController.instance;
|
|
|
|
}
|
|
|
|
private void OnEnable()
|
|
{
|
|
//inputActions.Enable();
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
//inputActions.Disable();
|
|
}
|
|
private InputDevice _inputType = InputDevice.MouseKeyboard;
|
|
[HideInInspector]
|
|
public InputDevice inputDevice
|
|
{
|
|
get { return _inputType; }
|
|
set
|
|
{
|
|
_inputType = value;
|
|
OnChangeInput();
|
|
}
|
|
}
|
|
|
|
void OnGUI()
|
|
{
|
|
switch (inputDevice)
|
|
{
|
|
case InputDevice.MouseKeyboard:
|
|
if (isJoystickInput())
|
|
{
|
|
inputDevice = InputDevice.Joystick;
|
|
|
|
if (hud != null)
|
|
{
|
|
hud.controllerInput = true;
|
|
hud.ShowText("Control scheme changed to Controller", 2f, 0.5f);
|
|
}
|
|
}
|
|
else if (isMobileInput())
|
|
{
|
|
inputDevice = InputDevice.Mobile;
|
|
if (hud != null)
|
|
{
|
|
hud.controllerInput = true;
|
|
hud.ShowText("Control scheme changed to Mobile", 2f, 0.5f);
|
|
}
|
|
}
|
|
break;
|
|
case InputDevice.Joystick:
|
|
if (isMouseKeyboard())
|
|
{
|
|
inputDevice = InputDevice.MouseKeyboard;
|
|
if (hud != null)
|
|
{
|
|
hud.controllerInput = false;
|
|
hud.ShowText("Control scheme changed to Keyboard/Mouse", 2f, 0.5f);
|
|
}
|
|
}
|
|
else if (isMobileInput())
|
|
{
|
|
inputDevice = InputDevice.Mobile;
|
|
if (hud != null)
|
|
{
|
|
hud.controllerInput = true;
|
|
hud.ShowText("Control scheme changed to Mobile", 2f, 0.5f);
|
|
}
|
|
}
|
|
break;
|
|
case InputDevice.Mobile:
|
|
if (isMouseKeyboard())
|
|
{
|
|
inputDevice = InputDevice.MouseKeyboard;
|
|
if (hud != null)
|
|
{
|
|
hud.controllerInput = false;
|
|
hud.ShowText("Control scheme changed to Keyboard/Mouse", 2f, 0.5f);
|
|
}
|
|
}
|
|
else if (isJoystickInput())
|
|
{
|
|
inputDevice = InputDevice.Joystick;
|
|
if (hud != null)
|
|
{
|
|
hud.controllerInput = true;
|
|
hud.ShowText("Control scheme changed to Controller", 2f, 0.5f);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool isMobileInput()
|
|
{
|
|
#if UNITY_EDITOR && UNITY_MOBILE
|
|
if (EventSystem.current.IsPointerOverGameObject() && Input.GetMouseButtonDown(0))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
#elif MOBILE_INPUT
|
|
if (EventSystem.current.IsPointerOverGameObject() || (Input.touches.Length > 0))
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
private bool isMouseKeyboard()
|
|
{
|
|
#if MOBILE_INPUT
|
|
return false;
|
|
#else
|
|
// mouse & keyboard buttons
|
|
if (Event.current.isKey || Event.current.isMouse)
|
|
return true;
|
|
// mouse movement
|
|
if (Input.GetAxis("Mouse X") != 0.0f || Input.GetAxis("Mouse Y") != 0.0f)
|
|
return true;
|
|
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
private bool isJoystickInput()
|
|
{
|
|
// joystick buttons
|
|
if (Input.GetKey(KeyCode.Joystick1Button0) ||
|
|
Input.GetKey(KeyCode.Joystick1Button1) ||
|
|
Input.GetKey(KeyCode.Joystick1Button2) ||
|
|
Input.GetKey(KeyCode.Joystick1Button3) ||
|
|
Input.GetKey(KeyCode.Joystick1Button4) ||
|
|
Input.GetKey(KeyCode.Joystick1Button5) ||
|
|
Input.GetKey(KeyCode.Joystick1Button6) ||
|
|
Input.GetKey(KeyCode.Joystick1Button7) ||
|
|
Input.GetKey(KeyCode.Joystick1Button8) ||
|
|
Input.GetKey(KeyCode.Joystick1Button9) ||
|
|
Input.GetKey(KeyCode.Joystick1Button10) ||
|
|
Input.GetKey(KeyCode.Joystick1Button11) ||
|
|
Input.GetKey(KeyCode.Joystick1Button12) ||
|
|
Input.GetKey(KeyCode.Joystick1Button13) ||
|
|
Input.GetKey(KeyCode.Joystick1Button14) ||
|
|
Input.GetKey(KeyCode.Joystick1Button15) ||
|
|
Input.GetKey(KeyCode.Joystick1Button16) ||
|
|
Input.GetKey(KeyCode.Joystick1Button17) ||
|
|
Input.GetKey(KeyCode.Joystick1Button18) ||
|
|
Input.GetKey(KeyCode.Joystick1Button19))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// joystick axis
|
|
if (Input.GetAxis("LeftAnalogHorizontal") != 0.0f ||
|
|
Input.GetAxis("LeftAnalogVertical") != 0.0f ||
|
|
Input.GetAxis("RightAnalogHorizontal") != 0.0f ||
|
|
Input.GetAxis("RightAnalogVertical") != 0.0f ||
|
|
Input.GetAxis("LT") != 0.0f ||
|
|
Input.GetAxis("RT") != 0.0f ||
|
|
Input.GetAxis("D-Pad Horizontal") != 0.0f ||
|
|
Input.GetAxis("D-Pad Vertical") != 0.0f)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void OnChangeInput()
|
|
{
|
|
if (onChangeInputType != null)
|
|
{
|
|
onChangeInputType(inputDevice);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// INPUT TYPE - check in real time if you are using a joystick, mobile or mouse/keyboard
|
|
/// </summary>
|
|
[HideInInspector]
|
|
public enum InputDevice
|
|
{
|
|
MouseKeyboard,
|
|
Joystick,
|
|
Mobile
|
|
};
|
|
|
|
[System.Serializable]
|
|
public class GenericInput
|
|
{
|
|
//new input
|
|
public enum Axis { None, Horizontal, Vertical }
|
|
|
|
//private InputAction action;
|
|
private bool wasReleasedThisFrame;
|
|
private int wasReleasedFrameCount;
|
|
private bool m_isPressed;
|
|
private Axis m_Axis;
|
|
private bool useNewInput = false;
|
|
private bool binded;
|
|
private string newInput;
|
|
/*
|
|
public bool UseNewInput
|
|
{
|
|
get
|
|
{
|
|
BindButtons();
|
|
return useNewInput;
|
|
}
|
|
set => useNewInput = value;
|
|
}
|
|
*/
|
|
//public GenericInput(InputAction action)
|
|
//{
|
|
// this.action = action;
|
|
// m_Axis = Axis.None;
|
|
// UseNewInput = true;
|
|
// AssignToEvents(action);
|
|
//}
|
|
|
|
//public GenericInput(InputAction action, Axis axis)
|
|
//{
|
|
// this.action = action;
|
|
// m_Axis = axis;
|
|
// UseNewInput = true;
|
|
// AssignToEvents(action);
|
|
//}
|
|
/*
|
|
private void AssignToEvents(InputAction action)
|
|
{
|
|
action.performed += ctx =>
|
|
{
|
|
m_isPressed = true;
|
|
};
|
|
action.canceled += ctx =>
|
|
{
|
|
wasReleasedFrameCount = Time.frameCount;
|
|
wasReleasedThisFrame = true;
|
|
m_isPressed = false;
|
|
};
|
|
}
|
|
*/
|
|
protected InputDevice inputDevice { get { return vInput.instance.inputDevice; } }
|
|
public bool useInput = true;
|
|
[SerializeField]
|
|
private bool isAxisInUse;
|
|
[SerializeField]
|
|
private bool isUnityInput;
|
|
[SerializeField]
|
|
public string keyboard;
|
|
[SerializeField]
|
|
public bool keyboardAxis;
|
|
[SerializeField]
|
|
public string joystick;
|
|
[SerializeField]
|
|
public bool joystickAxis;
|
|
[SerializeField]
|
|
public string mobile;
|
|
[SerializeField]
|
|
public bool mobileAxis;
|
|
|
|
[SerializeField]
|
|
public bool joystickAxisInvert;
|
|
[SerializeField]
|
|
public bool keyboardAxisInvert;
|
|
[SerializeField]
|
|
public bool mobileAxisInvert;
|
|
|
|
public float timeButtonWasPressed;
|
|
public float lastTimeTheButtonWasPressed;
|
|
public bool inButtomTimer;
|
|
private float multTapTimer;
|
|
private int multTapCounter;
|
|
|
|
public bool isAxis
|
|
{
|
|
get
|
|
{
|
|
bool value = false;
|
|
switch (inputDevice)
|
|
{
|
|
case InputDevice.Joystick:
|
|
value = joystickAxis;
|
|
break;
|
|
case InputDevice.MouseKeyboard:
|
|
value = keyboardAxis;
|
|
break;
|
|
case InputDevice.Mobile:
|
|
value = mobileAxis;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
|
|
public bool isAxisInvert
|
|
{
|
|
get
|
|
{
|
|
bool value = false;
|
|
switch (inputDevice)
|
|
{
|
|
case InputDevice.Joystick:
|
|
value = joystickAxisInvert;
|
|
break;
|
|
case InputDevice.MouseKeyboard:
|
|
value = keyboardAxisInvert;
|
|
break;
|
|
case InputDevice.Mobile:
|
|
value = mobileAxisInvert;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialise a new GenericInput
|
|
/// </summary>
|
|
/// <param name="keyboard"></param>
|
|
/// <param name="joystick"></param>
|
|
/// <param name="mobile"></param>
|
|
public GenericInput(string keyboard, string joystick, string mobile, string additionalTag = "")
|
|
{
|
|
this.keyboard = keyboard;
|
|
this.joystick = joystick;
|
|
this.mobile = mobile;
|
|
this.newInput = keyboard + additionalTag;
|
|
}
|
|
/*
|
|
private void BindButtons()
|
|
{
|
|
if (binded)
|
|
{
|
|
return;
|
|
}
|
|
|
|
binded = true;
|
|
bool binding = true;
|
|
m_Axis = Axis.None;
|
|
|
|
switch (newInput)
|
|
{
|
|
case "L":
|
|
action = vInput.instance.inputActions.Player.ActionTrigger;
|
|
break;
|
|
case "Vertical":
|
|
action = vInput.instance.inputActions.Player.Move;
|
|
m_Axis = Axis.Vertical;
|
|
break;
|
|
case "E":
|
|
action = vInput.instance.inputActions.Player.Enter;
|
|
break;
|
|
case "Space":
|
|
action = vInput.instance.inputActions.Player.Exit;
|
|
break;
|
|
case "LeftShift":
|
|
action = vInput.instance.inputActions.Player.FastClimb;
|
|
break;
|
|
case "Q":
|
|
action = vInput.instance.inputActions.Player.SlideDown;
|
|
break;
|
|
case "E1":
|
|
action = vInput.instance.inputActions.Player.ActionTrigger;
|
|
break;
|
|
case "Horizontal":
|
|
action = vInput.instance.inputActions.Player.Move;
|
|
m_Axis = Axis.Horizontal;
|
|
break;
|
|
case "Space1":
|
|
action = vInput.instance.inputActions.Player.Jump;
|
|
m_Axis = Axis.Horizontal;
|
|
break;
|
|
case "Q1":
|
|
action = vInput.instance.inputActions.Player.Roll;
|
|
break;
|
|
case "Tab":
|
|
action = vInput.instance.inputActions.Player.Strafe;
|
|
break;
|
|
case "LeftShift1":
|
|
action = vInput.instance.inputActions.Player.Sprint;
|
|
break;
|
|
case "C":
|
|
action = vInput.instance.inputActions.Player.Crouch;
|
|
break;
|
|
case "Mouse X":
|
|
action = vInput.instance.inputActions.Player.CameraRotate;
|
|
m_Axis = Axis.Horizontal;
|
|
break;
|
|
case "Mouse Y":
|
|
action = vInput.instance.inputActions.Player.CameraRotate;
|
|
m_Axis = Axis.Vertical;
|
|
break;
|
|
case "Mouse ScrollWheel":
|
|
action = vInput.instance.inputActions.Player.CameraZoom;
|
|
m_Axis = Axis.Vertical;
|
|
break;
|
|
case "H":
|
|
action = vInput.instance.inputActions.Player.HideAndDrawWeapons;
|
|
break;
|
|
case "Escape":
|
|
action = vInput.instance.inputActions.Player.CancelInput;
|
|
break;
|
|
case "Alpha 1":
|
|
//[Tooltip("Input to equip on press")]
|
|
action = vInput.instance.inputActions.Player.EquipOnPress;
|
|
break;
|
|
case "I":
|
|
action = vInput.instance.inputActions.Player.OpenInventory;
|
|
break;
|
|
case "Mouse1":
|
|
action = vInput.instance.inputActions.Player.RemoveEquipment;
|
|
break;
|
|
case "Horizontal1":
|
|
action = vInput.instance.inputActions.Player.MoveInventory;
|
|
m_Axis = Axis.Horizontal;
|
|
break;
|
|
case "Vertical1":
|
|
action = vInput.instance.inputActions.Player.MoveInventory;
|
|
m_Axis = Axis.Vertical;
|
|
break;
|
|
case "Return":
|
|
action = vInput.instance.inputActions.Player.SubmitInventory;
|
|
break;
|
|
case "Backspace":
|
|
action = vInput.instance.inputActions.Player.CancelInventory;
|
|
break;
|
|
case "U":
|
|
action = vInput.instance.inputActions.Player.UseItem;
|
|
break;
|
|
case "LeftArrow":
|
|
action = vInput.instance.inputActions.Player.PreviousItem;
|
|
break;
|
|
case "RightArrow":
|
|
action = vInput.instance.inputActions.Player.NextItem;
|
|
break;
|
|
case "Escape1":
|
|
// [Tooltip("Input to press")]
|
|
// class vSimpleInput
|
|
// [Tooltip("This Gameobject will turn off after the input is pressed")]
|
|
// public bool disableThisObjectAfterInput = true;
|
|
action = vInput.instance.inputActions.Player.SimpleInput;
|
|
break;
|
|
case "Mouse0":
|
|
action = vInput.instance.inputActions.Player.AttackWeak;
|
|
break;
|
|
case "Alpha1":
|
|
action = vInput.instance.inputActions.Player.AttackStrong;
|
|
break;
|
|
case "Mouse11":
|
|
action = vInput.instance.inputActions.Player.Defense;
|
|
break;
|
|
case "Tab1":
|
|
action = vInput.instance.inputActions.Player.LockOnTarget;
|
|
break;
|
|
case "X":
|
|
action = vInput.instance.inputActions.Player.NextTarget;
|
|
break;
|
|
case "Z":
|
|
action = vInput.instance.inputActions.Player.PreviousTarget;
|
|
break;
|
|
case "L1":
|
|
action = vInput.instance.inputActions.Player.ActionAnimation;
|
|
break;
|
|
case "Q2":
|
|
action = vInput.instance.inputActions.Player.selectLeftInputInventory;
|
|
break;
|
|
case "E2":
|
|
action = vInput.instance.inputActions.Player.selectRightInputInventory;
|
|
break;
|
|
default:
|
|
Debug.Log("<color=red> Button binding not find for </color>" + keyboard);
|
|
binding = false;
|
|
break;
|
|
}
|
|
|
|
if (binding)
|
|
{
|
|
Debug.Log("<color=green>Button binded for </color>" + keyboard);
|
|
AssignToEvents(action);
|
|
}
|
|
}
|
|
*/
|
|
/// <summary>
|
|
/// Initialise a new GenericInput
|
|
/// </summary>
|
|
/// <param name="keyboard"></param>
|
|
/// <param name="joystick"></param>
|
|
/// <param name="mobile"></param>
|
|
public GenericInput(string keyboard, bool keyboardAxis, string joystick, bool joystickAxis, string mobile, bool mobileAxis)
|
|
{
|
|
this.keyboard = keyboard;
|
|
this.keyboardAxis = keyboardAxis;
|
|
this.joystick = joystick;
|
|
this.joystickAxis = joystickAxis;
|
|
this.mobile = mobile;
|
|
this.mobileAxis = mobileAxis;
|
|
this.newInput = keyboard;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialise a new GenericInput
|
|
/// </summary>
|
|
/// <param name="keyboard"></param>
|
|
/// <param name="joystick"></param>
|
|
/// <param name="mobile"></param>
|
|
public GenericInput(string keyboard, bool keyboardAxis, bool keyboardInvert, string joystick, bool joystickAxis, bool joystickInvert, string mobile, bool mobileAxis, bool mobileInvert)
|
|
{
|
|
this.keyboard = keyboard;
|
|
this.keyboardAxis = keyboardAxis;
|
|
this.keyboardAxisInvert = keyboardInvert;
|
|
this.joystick = joystick;
|
|
this.joystickAxis = joystickAxis;
|
|
this.joystickAxisInvert = joystickInvert;
|
|
this.mobile = mobile;
|
|
this.mobileAxis = mobileAxis;
|
|
this.mobileAxisInvert = mobileInvert;
|
|
this.newInput = keyboard;
|
|
}
|
|
/// <summary>
|
|
/// Button Name
|
|
/// </summary>
|
|
public string buttonName
|
|
{
|
|
get
|
|
{
|
|
if (vInput.instance != null)
|
|
{
|
|
if (vInput.instance.inputDevice == InputDevice.MouseKeyboard) return keyboard.ToString();
|
|
else if (vInput.instance.inputDevice == InputDevice.Joystick) return joystick;
|
|
else return mobile;
|
|
}
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if button is a Key
|
|
/// </summary>
|
|
public bool isKey
|
|
{
|
|
get
|
|
{
|
|
if (vInput.instance != null && !isUnityInput)
|
|
{
|
|
if (System.Enum.IsDefined(typeof(KeyCode), buttonName))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get <see cref="KeyCode"/> value
|
|
/// </summary>
|
|
public KeyCode key
|
|
{
|
|
get
|
|
{
|
|
return (KeyCode)System.Enum.Parse(typeof(KeyCode), buttonName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Button
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool GetButton()
|
|
{
|
|
/*
|
|
if (UseNewInput)
|
|
{
|
|
if (action != null)
|
|
{
|
|
return m_isPressed;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
*/
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (isAxis) return GetAxisButton();
|
|
|
|
// mobile
|
|
if (inputDevice == InputDevice.Mobile)
|
|
{
|
|
#if MOBILE_INPUT
|
|
if (CrossPlatformInputManager.GetButton(this.mobile))
|
|
return true;
|
|
/*
|
|
if (isKey)
|
|
{
|
|
if (Input.GetKey(key))
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (Input.GetButton(this.buttonName))
|
|
return true;
|
|
}
|
|
*/
|
|
#endif
|
|
}
|
|
// keyboard/mouse
|
|
else if (inputDevice == InputDevice.MouseKeyboard)
|
|
{
|
|
if (CrossPlatformInputManager.ButtonExists(this.mobile) && CrossPlatformInputManager.GetButton(this.mobile))
|
|
return true;
|
|
|
|
if (isKey)
|
|
{
|
|
if (Input.GetKey(key))
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (Input.GetButton(this.buttonName))
|
|
return true;
|
|
}
|
|
}
|
|
// joystick
|
|
else if (inputDevice == InputDevice.Joystick)
|
|
{
|
|
if (Input.GetButton(this.buttonName))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get ButtonDown
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool GetButtonDown()
|
|
{
|
|
/*
|
|
if (UseNewInput)
|
|
{
|
|
if (action != null)
|
|
{
|
|
return action.triggered;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
} */
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (isAxis) return GetAxisButtonDown();
|
|
// mobile
|
|
if (inputDevice == InputDevice.Mobile)
|
|
{
|
|
#if MOBILE_INPUT
|
|
if (CrossPlatformInputManager.GetButtonDown(this.buttonName))
|
|
return true;
|
|
#endif
|
|
}
|
|
// keyboard/mouse
|
|
else if (inputDevice == InputDevice.MouseKeyboard)
|
|
{
|
|
if (CrossPlatformInputManager.ButtonExists(this.mobile) && CrossPlatformInputManager.GetButtonDown(this.mobile))
|
|
return true;
|
|
//
|
|
|
|
if (isKey)
|
|
{
|
|
if (Input.GetKeyDown(key))
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (Input.GetButtonDown(this.buttonName))
|
|
return true;
|
|
}
|
|
}
|
|
// joystick
|
|
else if (inputDevice == InputDevice.Joystick)
|
|
{
|
|
if (Input.GetButtonDown(this.buttonName))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Button Up
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool GetButtonUp()
|
|
{
|
|
/*
|
|
if (UseNewInput)
|
|
{
|
|
if (action != null)
|
|
{
|
|
if (wasReleasedThisFrame)
|
|
{
|
|
if (wasReleasedFrameCount < Time.frameCount)
|
|
{
|
|
wasReleasedThisFrame = false;
|
|
}
|
|
}
|
|
return wasReleasedThisFrame;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
*/
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (isAxis) return GetAxisButtonUp();
|
|
|
|
// mobile
|
|
if (inputDevice == InputDevice.Mobile)
|
|
{
|
|
#if MOBILE_INPUT
|
|
if (CrossPlatformInputManager.GetButtonUp(this.buttonName))
|
|
return true;
|
|
#endif
|
|
}
|
|
// keyboard/mouse
|
|
else if (inputDevice == InputDevice.MouseKeyboard)
|
|
{
|
|
if (CrossPlatformInputManager.ButtonExists(this.mobile) && CrossPlatformInputManager.GetButtonUp(this.mobile))
|
|
return true; if (isKey)
|
|
{
|
|
if (Input.GetKeyUp(key))
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (Input.GetButtonUp(this.buttonName))
|
|
return true;
|
|
}
|
|
}
|
|
// joystick
|
|
else if (inputDevice == InputDevice.Joystick)
|
|
{
|
|
if (Input.GetButtonUp(this.buttonName))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Axis
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public float GetAxis()
|
|
{
|
|
/*
|
|
if (UseNewInput)
|
|
{
|
|
if (action != null)
|
|
{
|
|
if (m_Axis == Axis.Horizontal)
|
|
{
|
|
// Debug.Log("action.ReadValue<Vector2>().x: "+ action.ReadValue<Vector2>().x);
|
|
return action.ReadValue<Vector2>().x;
|
|
}
|
|
else if (m_Axis == Axis.Vertical)
|
|
{
|
|
//Debug.Log("action.ReadValue<Vector2>().y: " + action.ReadValue<Vector2>().y);
|
|
return action.ReadValue<Vector2>().y;
|
|
}
|
|
else
|
|
{
|
|
return 0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0f;
|
|
}
|
|
}
|
|
*/
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName) || isKey) return 0;
|
|
|
|
// mobile
|
|
if (inputDevice == InputDevice.Mobile)
|
|
{
|
|
#if MOBILE_INPUT
|
|
/*
|
|
var val = CrossPlatformInputManager.GetAxis(this.buttonName);
|
|
var tmp = Input.GetAxis(this.buttonName);
|
|
return Mathf.Abs(val) > Mathf.Abs(tmp) ? val : tmp;
|
|
*/
|
|
return CrossPlatformInputManager.GetAxis(this.buttonName);
|
|
#endif
|
|
}
|
|
// keyboard/mouse
|
|
else if (inputDevice == InputDevice.MouseKeyboard)
|
|
{
|
|
return Input.GetAxis(this.buttonName);
|
|
}
|
|
// joystick
|
|
else if (inputDevice == InputDevice.Joystick)
|
|
{
|
|
return Input.GetAxis(this.buttonName);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Axis Raw
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public float GetAxisRaw()
|
|
{
|
|
/*
|
|
if (UseNewInput)
|
|
{
|
|
return GetAxis();
|
|
}
|
|
*/
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName) || isKey) return 0;
|
|
|
|
// mobile
|
|
if (inputDevice == InputDevice.Mobile)
|
|
{
|
|
#if MOBILE_INPUT
|
|
return CrossPlatformInputManager.GetAxisRaw(this.buttonName);
|
|
#endif
|
|
}
|
|
// keyboard/mouse
|
|
else if (inputDevice == InputDevice.MouseKeyboard)
|
|
{
|
|
return Input.GetAxisRaw(this.buttonName);
|
|
}
|
|
// joystick
|
|
else if (inputDevice == InputDevice.Joystick)
|
|
{
|
|
return Input.GetAxisRaw(this.buttonName);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Double Button Down Check if button is pressed Within the defined time
|
|
/// </summary>
|
|
/// <param name="inputTime"></param>
|
|
/// <returns></returns>
|
|
public bool GetDoubleButtonDown(float inputTime = 1)
|
|
{
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
|
|
|
|
if (multTapCounter == 0 && GetButtonDown())
|
|
{
|
|
multTapTimer = Time.time;
|
|
multTapCounter = 1;
|
|
return false;
|
|
}
|
|
else if (multTapCounter == 1 && GetButtonDown())
|
|
{
|
|
var time = multTapTimer + inputTime;
|
|
var valid = (Time.time < time);
|
|
multTapTimer = 0;
|
|
multTapCounter = 0;
|
|
return valid;
|
|
}
|
|
else if(multTapCounter == 1 && multTapTimer + inputTime<Time.time)
|
|
{
|
|
multTapTimer = 0;
|
|
multTapCounter = 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Buttom Timer Check if a button is pressed for defined time
|
|
/// </summary>
|
|
/// <param name="inputTime"> time to check button press</param>
|
|
/// <returns></returns>
|
|
public bool GetButtonTimer(float inputTime = 2)
|
|
{
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (GetButtonDown() && !inButtomTimer)
|
|
{
|
|
lastTimeTheButtonWasPressed = Time.time + 0.1f;
|
|
timeButtonWasPressed = Time.time;
|
|
inButtomTimer = true;
|
|
}
|
|
if (inButtomTimer)
|
|
{
|
|
var time = timeButtonWasPressed + inputTime;
|
|
var valid = (time - Time.time <= 0);
|
|
|
|
if (!GetButton() || lastTimeTheButtonWasPressed < Time.time)
|
|
{
|
|
inButtomTimer = false;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
lastTimeTheButtonWasPressed = Time.time + 0.1f;
|
|
}
|
|
if (valid)
|
|
{
|
|
inButtomTimer = false;
|
|
}
|
|
return valid;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Buttom Timer Check if a button is pressed for defined time
|
|
/// </summary>
|
|
/// <param name="inputTime"> time to check button press</param>
|
|
/// <returns></returns>
|
|
public bool GetButtonTimer(ref float currentTimer, float inputTime = 2)
|
|
{
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (GetButtonDown() && !inButtomTimer)
|
|
{
|
|
lastTimeTheButtonWasPressed = Time.time + 0.1f;
|
|
timeButtonWasPressed = Time.time;
|
|
inButtomTimer = true;
|
|
}
|
|
if (inButtomTimer)
|
|
{
|
|
var time = timeButtonWasPressed + inputTime;
|
|
currentTimer = time - Time.time;
|
|
var valid = (time - Time.time <= 0);
|
|
|
|
if (!GetButton() || lastTimeTheButtonWasPressed < Time.time)
|
|
{
|
|
inButtomTimer = false;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
lastTimeTheButtonWasPressed = Time.time + 0.1f;
|
|
}
|
|
if (valid)
|
|
{
|
|
inButtomTimer = false;
|
|
}
|
|
return valid;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Buttom Timer Check if a button is pressed for defined time
|
|
/// </summary>
|
|
/// <param name="inputTime"> time to check button press</param>
|
|
/// <returns></returns>
|
|
public bool GetButtonTimer(ref float currentTimer, ref bool upAfterPressed, float inputTime = 2)
|
|
{
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (GetButtonDown())
|
|
{
|
|
lastTimeTheButtonWasPressed = Time.time + 0.1f;
|
|
timeButtonWasPressed = Time.time;
|
|
inButtomTimer = true;
|
|
}
|
|
if (inButtomTimer)
|
|
{
|
|
var time = timeButtonWasPressed + inputTime;
|
|
currentTimer = (inputTime - (time - Time.time)) / inputTime;
|
|
var valid = (time - Time.time <= 0);
|
|
|
|
if (!GetButton() || lastTimeTheButtonWasPressed < Time.time)
|
|
{
|
|
inButtomTimer = false;
|
|
upAfterPressed = true;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
upAfterPressed = false;
|
|
lastTimeTheButtonWasPressed = Time.time + 0.1f;
|
|
}
|
|
if (valid)
|
|
{
|
|
inButtomTimer = false;
|
|
}
|
|
return valid;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Axis like a button
|
|
/// </summary>
|
|
/// <param name="value">Value to check need to be diferent 0</param>
|
|
/// <returns></returns>
|
|
public bool GetAxisButton(float value = 0.5f)
|
|
{
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (isAxisInvert) value *= -1f;
|
|
if (value > 0)
|
|
{
|
|
return GetAxisRaw() >= value;
|
|
}
|
|
else if (value < 0)
|
|
{
|
|
return GetAxisRaw() <= value;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Axis like a buttonDown
|
|
/// </summary>
|
|
/// <param name="value">Value to check need to be diferent 0</param>
|
|
/// <returns></returns>
|
|
public bool GetAxisButtonDown(float value = 0.5f)
|
|
{
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (isAxisInvert) value *= -1f;
|
|
if (value > 0)
|
|
{
|
|
if (!isAxisInUse && GetAxisRaw() >= value)
|
|
{
|
|
isAxisInUse = true;
|
|
return true;
|
|
}
|
|
else if (isAxisInUse && GetAxisRaw() == 0)
|
|
{
|
|
isAxisInUse = false;
|
|
}
|
|
}
|
|
else if (value < 0)
|
|
{
|
|
if (!isAxisInUse && GetAxisRaw() <= value)
|
|
{
|
|
isAxisInUse = true;
|
|
return true;
|
|
}
|
|
else if (isAxisInUse && GetAxisRaw() == 0)
|
|
{
|
|
isAxisInUse = false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Axis like a buttonUp
|
|
/// Check if Axis is zero after press
|
|
/// <returns></returns>
|
|
public bool GetAxisButtonUp()
|
|
{
|
|
if (string.IsNullOrEmpty(buttonName) || !IsButtonAvailable(this.buttonName)) return false;
|
|
if (isAxisInUse && GetAxisRaw() == 0)
|
|
{
|
|
isAxisInUse = false;
|
|
return true;
|
|
}
|
|
else if (!isAxisInUse && GetAxisRaw() != 0)
|
|
{
|
|
isAxisInUse = true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsButtonAvailable(string btnName)
|
|
{
|
|
/*
|
|
if (UseNewInput)
|
|
{
|
|
if (action != null && action.enabled)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
*/
|
|
if (!useInput) return false;
|
|
try
|
|
{
|
|
if (isKey) return true;
|
|
Input.GetButton(buttonName);
|
|
return true;
|
|
}
|
|
catch (System.Exception exc)
|
|
{
|
|
Debug.LogWarning(" Failure to try access button :" + buttonName + "\n" + exc.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
} |