/// <summary>
/// Returns an axis value.
/// </summary>
/// <param name="name">Name of the axis we want to return</param>
/// <returns></returns>
public float GetAxis(string name)
{
float tmp = 0;
AxisInput _axis = new AxisInput();
if (!PauseMenuControl.Paused)
{
//Like with button inputs, we will first cycle through our available axis inputs.
for (int a = 0; a < axisInputs.Length; a++)
{
if (axisInputs[a].Name == name)
{
_axis = axisInputs[a];
}
}
float TargetInput = _axis.Value;
///For keyboard input axes, we set a target value and add or subtract it depending on if positive/negative inputs are held or released.
if (Input.GetKeyDown(_axis.Positive) || Input.GetKeyUp(_axis.Negative))
{
_axis.TargetValue += 1;
}
if (Input.GetKeyUp(_axis.Positive) || Input.GetKeyDown(_axis.Negative))
{
_axis.TargetValue -= 1;
}
if (!Input.GetKey(_axis.Positive) && !Input.GetKey(_axis.Negative))
{
_axis.TargetValue = 0;
}
tmp = _axis.Value + Input.GetAxisRaw(_axis.GamepadAxis);
tmp = HedgeMath.ClampFloat(tmp, -1, 1);
}
return(tmp);
}
private static void TrackAxis(string axis, bool trackUnityAxisOnly = false)
{
try
{
AxisInput unityAxis = new AxisInput(axis)
{
value = Input.GetAxisRaw(axis)
};
if (!m_trackUnityInput)
{
unityAxis.ResetValue();
}
trackedUnityAxes.Add(unityAxis);
unityAxis.StartTracking();
}
catch
{
if (!trackUnityAxisOnly)
{
AxisInput temporaryAxis = new AxisInput(axis)
{
value = 0f
};
trackedTemporaryAxes.Add(temporaryAxis);
temporaryAxis.StartTracking();
}
}
}
/// <summary>
/// Returns an axis value;
/// </summary>
/// <param name="Index">Array index of the axis we want to return</param>
/// <returns></returns>
public float GetAxis(int Index)
{
float tmp = 0;
AxisInput _axis = axisInputs[Index];
if (!PauseMenuControl.Paused)
{
float TargetInput = _axis.Value;
///For keyboard input axes, we set a target value and add or subtract it depending on if positive/negative inputs are held or released.
if (Input.GetKeyDown(_axis.Positive) || Input.GetKeyUp(_axis.Negative))
{
_axis.TargetValue += 1;
}
if (Input.GetKeyUp(_axis.Positive) || Input.GetKeyDown(_axis.Negative))
{
_axis.TargetValue -= 1;
}
if (!Input.GetKey(_axis.Positive) && !Input.GetKey(_axis.Negative))
{
_axis.TargetValue = 0;
}
tmp = _axis.Value + Input.GetAxisRaw(_axis.GamepadAxis);
tmp = HedgeMath.ClampFloat(tmp, -1, 1);
}
return(tmp);
}
private void InitInput()
{
if (hasInitilized)
{
return;
}
if (CustomKeys == null || CustomAxis == null)
{
return;
}
cInput.usePlayerPrefs = storePlayerPref;
// Initializing Keys
for (int i = 0; i < CustomKeys.Length; i++)
{
KeyInput key = CustomKeys[i];
if (key.action.Length == 0 || key.defPrimary.Length == 0)
{
Debug.LogError("Please define a name or primary key to key: " + i);
}
else
{
cInput.SetKey
(
key.action,
GetStringFromKeys(key.defPrimary),
GetStringFromKeys(key.defSecondary)
);
}
}
// Initializing Axis
for (int i = 0; i < CustomAxis.Length; i++)
{
AxisInput axis = CustomAxis[i];
if (axis.name.Length == 0 || axis.negative.Length == 0 || axis.positive.Length == 0)
{
Debug.LogError("Please define a name, negative key or positive key to axis: " + i);
}
else
{
cInput.SetAxis
(
axis.name,
axis.negative,
axis.positive,
axis.sensitivity,
axis.gravity,
axis.deadzone
);
}
}
hasInitilized = true;
}
public void OnAxisInput(AxisInput input)
{
switch (input.InputName) {
case "MotionX":
HorizontalAxis = input.Value.PowSign(inputPower);
break;
}
}
void StartAxisListen(string axisName)
{
// Init new AxisInput
AxisInput axis = new AxisInput(axisName);
// Add to listener
axisListeners.Add(axis);
}
public Axis(KeyCode[] p, KeyCode[] n)
{
inputs = new AxisInput[p.Length];
for (int i = 0; i < p.Length; i++)
{
inputs[i] = new AxisInput(p[i], n[i]);
}
}
protected override void OnInitialize()
{
bool headless = Screen.DisplayMode == DisplayMode.Decapitated || Screen.DisplayMode == DisplayMode.Headless;
// Initialize input for player 1...
InputManager.AddAxisInputs("PlayerVertical", new [] { Players.One },
AxisInput.FromKeyboard(Keys.S, Keys.W),
AxisInput.FromThumbStick(ThumbSticks.Left, ThumbSticksAxis.Y, 0.1f, true));
InputManager.AddAxisInputs("PlayerHorizontal", new[] { Players.One },
AxisInput.FromKeyboard(Keys.D, Keys.A),
AxisInput.FromThumbStick(ThumbSticks.Left, ThumbSticksAxis.X, 0.1f));
// Initialize input for player 2...
InputManager.AddAxisInputs("PlayerVertical", new[] { Players.Two },
AxisInput.FromKeyboard(Keys.G, Keys.T),
AxisInput.FromThumbStick(ThumbSticks.Left, ThumbSticksAxis.Y, 0.1f, true));
InputManager.AddAxisInputs("PlayerHorizontal", new[] { Players.Two },
AxisInput.FromKeyboard(Keys.H, Keys.F),
AxisInput.FromThumbStick(ThumbSticks.Left, ThumbSticksAxis.X, 0.1f));
// Initialize networking...
NetHelper.AddSpawnable("Player", typeof(NetPlayer));
NetHelper.AddSpawnable("bouncy", typeof(BouncyBall));
Network.OnServerStarted += SpawnStuff;
Network.OnPeerConnected += peer => {
if (Network.IsServer)
{
NetHelper.Instantiate("Player", peer.GetUniqueID(), new Vector2(100, 100));
NetHelper.Instantiate("Player", peer.GetUniqueID(), new Vector2(100, 100));
}
};
//SceneManager.SetCurrentScene("_DEMOS\\menu");
SceneManager.SetCurrentScene("_DEMOS\\networktest");
backToMenu = new BackButton();
// Load the network test level, and start server if in fully-headless mode.
if (headless)
{
SceneManager.SetCurrentScene("_DEMOS\\networktest");
Network.StartServer(919, 920);
}
if (!Screen.IsFullHeadless)
{
Lighting.Ambient = new Color(0.1f, 0.1f, 0.1f);
}
new Cursor(Vector2.Zero, 0f, Vector2.One);
if (!IsEditor)
{
GameObject camera = new InternalCamera(Vector2.Zero, 0f, Vector2.One);
}
}
private void HandleAxes()
{
for (int i = 0; i < axisInputs.Count; i++)
{
AxisInput axis = axisInputs[i];
float value = (axis.state == AxisState.Normal) ? Input.GetAxis(axis.code) : (Input.GetAxisRaw(axis.code));
bool flag = (axis.comparisons.Count > 0);
for (int j = 0; j < axis.comparisons.Count; j++)
{
if (!flag)
{
break;
}
AxisComparison comparison = axis.comparisons[j];
switch (comparison.comparison)
{
case Comparison.Less:
{
flag = flag && (value < comparison.value);
break;
}
case Comparison.LessEqual:
{
flag = flag && (value <= comparison.value);
break;
}
case Comparison.Equal:
{
flag = flag && (value == comparison.value);
break;
}
case Comparison.GreaterEqual:
{
flag = flag && (value >= comparison.value);
break;
}
case Comparison.Greater:
{
flag = flag && (value > comparison.value);
break;
}
}
}
if (flag)
{
axis.onEvent.Invoke(axis.code, value);
}
}
}
private void Start()
{
axisInput = keyBindingManager.continousMovementAxisInput;
axisInput.SubscibeToAxisChange(Move);
player.Stopped += axisInput.Deactivate;
player.Go += axisInput.Activate;
}
private void Start()
{
rotationInput = keyBindingManager.continousRotationAxisInput;
rotationInput.SubscibeToAxisChange(Rotate);
player.Stopped += rotationInput.Deactivate;
player.Go += rotationInput.Activate;
}
private void CheckAxisInput()
{
if (Input.GetAxisRaw("Horizontal") == 0 && Input.GetAxisRaw("Vertical") == 0)
{
AxisUp.Invoke();
return;
}
AxisInput.Invoke(new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical")));
}
private void Awake()
{
Axis = new AxisInput[axisNames.Length];
for (int i = 0; i < Axis.Length; i++)
{
Axis[i] = new AxisInput(axisNames[i]);
Axis[i].IsPressedDown = false;
Axis[i].IsReleased = false;
}
}
public void Populate(StateInput input)
{
grounded = input.grounded;
inClimbArea = input.inClimbArea;
climbTopReached = input.climbTopReached;
horizontal = input.horizontal;
vertical = input.vertical;
jump = input.jump;
climbPosition = input.climbPosition;
}
/// <summary>
/// Registers an axis input to the input manager.
/// </summary>
/// <param name="inputName">Name used for identification.</param>
/// <param name="theAxis">Axis input.</param>
/// <param name="players">Array of players to add the axis input to.</param>
/// <param name="replace">Whether or not to replace an existing input with the same inputName.</param>
/// <returns>An AxisInputSet created from the provided AxisInput.</returns>
public static void AddAxisInput(string inputName, AxisInput theAxis, Players[] players, bool replace = false)
{
if (players == null)
{
players = All;
}
for (int i = 0; i < players.Length; i++)
{
controllers[(int)players[i]].AddAxisInput(inputName, theAxis.DeepCopy(), replace);
}
}
private static void UnregisterAxis(AxisInput input)
{
Axis axisObj;
if (axes.TryGetValue(input.Key, out axisObj))
{
if (axisObj.inputs.Remove(input) && axisObj.inputs.Count == 0)
{
axes.Remove(input.Key);
axesList.Remove(axisObj);
}
}
}
private static bool BindAxis(string gameAxisID, string gameAxisDescr, AxisInput inputAxis)
{
if (gameAxisBindings.ContainsKey(gameAxisID)) //Already bound game axis
{
gameAxisBindings[gameAxisID].BindInputAxis(inputAxis);
return(false);
}
else //New game axis
{
gameAxisBindings.Add(gameAxisID, new GameAxis(inputAxis, gameAxisDescr));
return(true);
}
}
private static void RegisterAxis(AxisInput input)
{
Axis axisObj;
if (!axes.TryGetValue(input.Key, out axisObj))
{
axisObj = new Axis(input.Key);
axes[input.Key] = axisObj;
axesList.Add(axisObj);
// Track corresponding Unity input as well, if exists
TrackAxis(input.Key, true);
}
axisObj.inputs.Add(input);
}
void Update()
{
var input = new PlayerInput();
AxisInput axisInput = input.MainAxis();
MoveSpeed speed = new MoveSpeed(3f);
Vector3 cameraForward = cameraTransformCache.forward;
MoveVector2 moveVector = new MoveVector2(axisInput.value);
Vector3 vector3 = moveVector
.Multi(speed)
.MultiCurrentFrameTime()
.RotateTo(cameraForward)
.SolveThatSlantIsRoot2()
.ToXZOfVector3();
charaPresenter.Move(vector3);
}
/// <summary>
/// Registers multiple axis inputs to the input system, under a shared ID.
/// </summary>
/// <param name="inputName">Name used for identification.</param>
/// <param name="replace">Whether or not to replace existing inputs with the same inputName.</param>
/// <param name="players">Array of players to add the axis inputs to.</param>
/// <param name="axis">One or more axis to be added. All axis inputs will be assigned to the same ID.</param>
/// <returns>An AxisInputSet created from the provided AxisInputs.</returns>
public static void AddAxisInputs(string inputName, bool replace, Players[] players, params AxisInput[] axis)
{
if (players == null)
{
players = All;
}
for (int i = 0; i < players.Length; i++)
{
AxisInput[] copy = new AxisInput[axis.Length];
for (int y = 0; y < axis.Length; y++)
{
copy[y] = axis[y].DeepCopy();
}
controllers[(int)players[i]].AddAxisInput(inputName, replace, copy);
}
}
public static LockstepTestCaseData NewLockstepTestCaseData(float nextSecond = 0.02f, int userId = 1, float vertical = 0, float horizontal = 0, bool jump = false)
{
var inputs = new IInput[(jump ? 2 : 1)];
inputs[0] = new AxisInput()
{
Vertical = (Fix64)vertical, Horizontal = (Fix64)horizontal
};
if (jump)
{
inputs[1] = new KeyInput()
{
KeyCodes = new List <int>()
{
32
}
};
}
return(NewLockstepTestCaseData(nextSecond, userId, inputs));
}
private void UpdateInputs()
{
LockstepUtility.AddInput(new EventInput().WithType(EventCode.HeartBeat));
var axisInput = new AxisInput();
axisInput.Horizontal = (Fix64)Input.GetAxis(InputParameters.Horizontal);
axisInput.Vertical = (Fix64)Input.GetAxis(InputParameters.Vertical);
LockstepUtility.AddInput(axisInput);
var keyInput = new KeyInput()
{
KeyCodes = new List <int>()
};
foreach (var obj in Enum.GetValues(typeof(KeyCode)))
{
if (Input.GetKey((KeyCode)obj))
{
keyInput.KeyCodes.Add((int)obj);
}
}
LockstepUtility.AddInput(keyInput);
var mouseInput = new MouseInput()
{
MouseButtons = new List <int>()
};
for (int i = 0; i < 3; i++)
{
if (Input.GetMouseButton(i))
{
mouseInput.MouseButtons.Add(i);
}
}
mouseInput.ScrollDelta = (FixVector2)Input.mouseScrollDelta;
mouseInput.Position = (FixVector3)Input.mousePosition;
mouseInput.Delta = new FixVector2((Fix64)Input.GetAxis(InputParameters.MouseX), (Fix64)Input.GetAxis(InputParameters.MouseY));
LockstepUtility.AddInput(mouseInput);
}
void LateUpdate()
{
PlayerInput input = new PlayerInput();
AxisInput axisInput = input.SubAxis();
DeltaCameraAngle deltaAngle = new DeltaCameraAngle(axisInput.value)
.Multi(speed)
.MultiCurrentFrameTime()
.Reverse();
CameraAngle currentCameraAngle = prevCameraAngle.Add(deltaAngle);
prevCameraAngle = currentCameraAngle;
Vector3 lookPoint = playerTransformCache.position + Vector3.up * height;
Vector3 localPosition = currentCameraAngle.ToLocalPosition(distance);
Vector3 position = lookPoint + localPosition;
transformCache.position = position;
transformCache.LookAt(playerTransformCache);
}
private void Awake()
{
// Set singleton
if (instance)
{
Destroy(this);
return;
}
instance = this;
horizontalInput = new AxisInput("Horizontal");
verticalInput = new AxisInput("Vertical");
eInput = new ButtonInput("Fire3");
lbInput = new ButtonInput("Fire1");
rbInput = new ButtonInput("Fire2");
oneInput = new ButtonInput("One");
twoInput = new ButtonInput("Two");
threeInput = new ButtonInput("Three");
tabInput = new ButtonInput("Tab");
shiftInput = new ButtonInput("Shift");
}
public override void OnInspectorGUI()
{
this.serializedObject.Update();
AxisInput bridge = (AxisInput)target;
GUI.enabled = false;
EditorGUILayout.PropertyField(script, true, new GUILayoutOption[0]);
GUI.enabled = true;
EditorGUILayout.PropertyField(minCenterHorizontal, new GUIContent("minCenterHorizontal"));
EditorGUILayout.PropertyField(maxCenterHorizontal, new GUIContent("maxCenterHorizontal"));
EditorGUILayout.PropertyField(minCenterVertical, new GUIContent("minCenterVertical"));
EditorGUILayout.PropertyField(maxCenterVertical, new GUIContent("maxCenterVertical"));
EditorGUILayout.PropertyField(invertHorizontal, new GUIContent("invertHorizontal"));
EditorGUILayout.PropertyField(invertVertical, new GUIContent("invertVertical"));
if (Application.isPlaying && bridge.enabled)
{
EditorGUILayout.Vector2Field("Input Axis", bridge.axis);
EditorUtility.SetDirty(target);
}
this.serializedObject.ApplyModifiedProperties();
}
private void Update()
{
if (OnUpdate != null)
{
OnUpdate();
}
for (int i = 0; i < trackedUnityAxes.Count; i++)
{
trackedUnityAxes[i].value = Input.GetAxisRaw(trackedUnityAxes[i].Key);
}
for (int i = 0; i < trackedUnityButtons.Count; i++)
{
trackedUnityButtons[i].value = Input.GetButton(trackedUnityButtons[i].Key);
}
for (int i = 0; i < trackedUnityMouseButtons.Count; i++)
{
trackedUnityMouseButtons[i].value = Input.GetMouseButton(trackedUnityMouseButtons[i].Key);
}
float lerpModifier = AXIS_LERP_MODIFIER * Time.deltaTime;
for (int i = 0; i < axesList.Count; i++)
{
Axis axis = axesList[i];
axis.valueRaw = 0f;
for (int j = axis.inputs.Count - 1; j >= 0; j--)
{
AxisInput input = axis.inputs[j];
if (input.value != 0f)
{
axis.valueRaw = input.value;
break;
}
}
axis.value = Mathf.Lerp(axis.value, axis.valueRaw, lerpModifier);
if (axis.valueRaw == 0f && axis.value != 0f)
{
if (Mathf.Abs(axis.value) < 0.025f)
{
axis.value = 0f;
}
}
}
for (int i = 0; i < buttonsList.Count; i++)
{
Button button = buttonsList[i];
bool isDown = false;
for (int j = button.inputs.Count - 1; j >= 0; j--)
{
ButtonInput input = button.inputs[j];
if (input.value)
{
isDown = true;
break;
}
}
if (isDown)
{
if (button.state == InputState.None || button.state == InputState.Released)
{
button.state = InputState.Pressed;
}
else
{
button.state = InputState.Held;
}
}
else
{
if (button.state == InputState.Pressed || button.state == InputState.Held)
{
button.state = InputState.Released;
}
else
{
button.state = InputState.None;
}
}
}
for (int i = 0; i < mouseButtonsList.Count; i++)
{
MouseButton mouseButton = mouseButtonsList[i];
bool isDown = false;
for (int j = mouseButton.inputs.Count - 1; j >= 0; j--)
{
MouseButtonInput input = mouseButton.inputs[j];
if (input.value)
{
isDown = true;
break;
}
}
if (isDown)
{
if (mouseButton.state == InputState.None || mouseButton.state == InputState.Released)
{
mouseButton.state = InputState.Pressed;
}
else
{
mouseButton.state = InputState.Held;
}
}
else
{
if (mouseButton.state == InputState.Pressed || mouseButton.state == InputState.Held)
{
mouseButton.state = InputState.Released;
}
else
{
mouseButton.state = InputState.None;
}
}
}
for (int i = 0; i < keysList.Count; i++)
{
Key key = keysList[i];
bool isDown = false;
for (int j = key.inputs.Count - 1; j >= 0; j--)
{
KeyInput input = key.inputs[j];
if (input.value)
{
isDown = true;
break;
}
}
if (isDown)
{
if (key.state == InputState.None || key.state == InputState.Released)
{
key.state = InputState.Pressed;
}
else
{
key.state = InputState.Held;
}
}
else
{
if (key.state == InputState.Pressed || key.state == InputState.Held)
{
key.state = InputState.Released;
}
else
{
key.state = InputState.None;
}
}
}
}
public void OnAxisInput(AxisInput input)
{
}
private void Update()
{
if (OnUpdate != null)
{
OnUpdate();
}
if (m_trackUnityInput)
{
for (int i = 0; i < trackedUnityAxes.Count; i++)
{
trackedUnityAxes[i].value = Input.GetAxisRaw(trackedUnityAxes[i].Key);
}
for (int i = 0; i < trackedUnityButtons.Count; i++)
{
trackedUnityButtons[i].value = Input.GetButton(trackedUnityButtons[i].Key);
}
for (int i = 0; i < trackedUnityMouseButtons.Count; i++)
{
trackedUnityMouseButtons[i].value = Input.GetMouseButton(trackedUnityMouseButtons[i].Key);
}
}
float sensitivity = GetAxisSensitivity * (GetAxisTimeScaleDependent ? Time.deltaTime : Time.unscaledDeltaTime);
for (int i = 0; i < axesList.Count; i++)
{
Axis axis = axesList[i];
axis.valueRaw = 0f;
for (int j = axis.inputs.Count - 1; j >= 0; j--)
{
AxisInput input = axis.inputs[j];
if (input.value != 0f)
{
axis.valueRaw = input.value;
break;
}
}
#if GET_AXIS_USE_MOVE_TOWARDS
if (axis.value >= 0)
{
axis.value = Mathf.MoveTowards(axis.valueRaw >= 0 || !GetAxisSnapValue ? axis.value : 0, axis.valueRaw, sensitivity);
}
else
{
axis.value = Mathf.MoveTowards(axis.valueRaw <= 0 || !GetAxisSnapValue ? axis.value : 0, axis.valueRaw, sensitivity);
}
#else
if (axis.value >= 0)
{
axis.value = Mathf.Lerp(axis.valueRaw >= 0 || !GetAxisSnapValue ? axis.value : 0, axis.valueRaw, sensitivity);
}
else
{
axis.value = Mathf.Lerp(axis.valueRaw <= 0 || !GetAxisSnapValue ? axis.value : 0, axis.valueRaw, sensitivity);
}
#endif
if (axis.valueRaw == 0f && axis.value != 0f)
{
if (Mathf.Abs(axis.value) < GetAxisDeadZone)
{
axis.value = 0f;
}
}
}
for (int i = 0; i < buttonsList.Count; i++)
{
Button button = buttonsList[i];
bool isDown = false;
for (int j = button.inputs.Count - 1; j >= 0; j--)
{
ButtonInput input = button.inputs[j];
if (input.value)
{
isDown = true;
break;
}
}
if (isDown)
{
if (button.state == InputState.None || button.state == InputState.Released)
{
button.state = InputState.Pressed;
}
else
{
button.state = InputState.Held;
}
}
else
{
if (button.state == InputState.Pressed || button.state == InputState.Held)
{
button.state = InputState.Released;
}
else
{
button.state = InputState.None;
}
}
}
for (int i = 0; i < mouseButtonsList.Count; i++)
{
MouseButton mouseButton = mouseButtonsList[i];
bool isDown = false;
for (int j = mouseButton.inputs.Count - 1; j >= 0; j--)
{
MouseButtonInput input = mouseButton.inputs[j];
if (input.value)
{
isDown = true;
break;
}
}
if (isDown)
{
if (mouseButton.state == InputState.None || mouseButton.state == InputState.Released)
{
mouseButton.state = InputState.Pressed;
}
else
{
mouseButton.state = InputState.Held;
}
}
else
{
if (mouseButton.state == InputState.Pressed || mouseButton.state == InputState.Held)
{
mouseButton.state = InputState.Released;
}
else
{
mouseButton.state = InputState.None;
}
}
}
for (int i = 0; i < keysList.Count; i++)
{
Key key = keysList[i];
bool isDown = false;
for (int j = key.inputs.Count - 1; j >= 0; j--)
{
KeyInput input = key.inputs[j];
if (input.value)
{
isDown = true;
break;
}
}
if (isDown)
{
if (key.state == InputState.None || key.state == InputState.Released)
{
key.state = InputState.Pressed;
}
else
{
key.state = InputState.Held;
}
}
else
{
if (key.state == InputState.Pressed || key.state == InputState.Held)
{
key.state = InputState.Released;
}
else
{
key.state = InputState.None;
}
}
}
}
public void BindInputAxis(AxisInput inputAxis)
{
inputList.Add(inputAxis);
}
public DirectionalAxisInput(string x, string y)
{
this.x = new AxisInput(x);
this.y = new AxisInput(y);
}
/// <summary>
/// スティック入力に操作を対応付ける。
/// </summary>
/// <param name="abstractKey"></param>
/// <param name="axisIndex"></param>
/// <param name="direction"></param>
public void BindAxis(TControl abstractKey, int axisIndex, AxisDirection direction)
{
binding[abstractKey] = new AxisInput(axisIndex, direction);
}
/// <summary>
/// Called when an axis is moved.
/// </summary>
/// <param name="axis">The axis.</param>
public virtual void OnAxis(AxisInput axis) { }
// Use this for initialization
void Start ()
{
mInput = GetComponent<AxisInput> ();
}
private void UpdateAxisInput(Transform objectPosition, float moveMagnitude, ref AxisInput axisInput)
{
axisInput.magnitude = moveMagnitude * Mathf.Sign(GetVectorComponent(currentPoint.nextPoint.transform.position) - GetVectorComponent(objectPosition.position));
axisInput.buttonPressed = true;
}
// Set the axis input handler
public virtual void SetAxisInput(AxisInput axisInput)
{
_input = axisInput;
}
