private static bool ComputeState(HardwareInput hardwareInput, HardwareAction hardwareAction)
{
var hardwareInputVariant = hardwareAction.HardwareInputVariant;
switch (hardwareInputVariant.CurrentVariant)
{
case HardwareInputVariant.Variant.Keyboard:
return(hardwareInput.KeyboardInput[hardwareInputVariant.AsKeyboard()]);
case HardwareInputVariant.Variant.Mouse:
switch (hardwareInputVariant.AsMouse())
{
case HardwareInputVariant.MouseVariant.LeftButton:
return(hardwareInput.MouseInput.LeftButton);
case HardwareInputVariant.MouseVariant.MiddleButton:
return(hardwareInput.MouseInput.MiddleButton);
case HardwareInputVariant.MouseVariant.RightButton:
return(hardwareInput.MouseInput.RightButton);
case HardwareInputVariant.MouseVariant.XButton1:
return(hardwareInput.MouseInput.XButton1);
case HardwareInputVariant.MouseVariant.XButton2:
return(hardwareInput.MouseInput.XButton2);
default:
throw new ArgumentOutOfRangeException();
}
default:
throw new ArgumentOutOfRangeException();
}
}
private static void ProcessCursor(Point axis)
{
var axisInput = new Vector2(axis.X, axis.Y);
if (axisInput.Magnitude > Settings.Default.CursorDeadzone)
{
axisInput = Vector2.Normalize(axisInput) *
((axisInput.Magnitude - Settings.Default.CursorDeadzone) /
(127 - Settings.Default.CursorDeadzone));
var curve = 0.05 * Settings.Default.CursorCurve;
var xSpeed = (axisInput.X < 0 ? -axisInput.X : axisInput.X) * Settings.Default.CursorSpeed;
var ySpeed = (axisInput.Y < 0 ? -axisInput.Y : axisInput.Y) * Settings.Default.CursorSpeed;
var xMath = Math.Pow(curve * xSpeed, 2) + curve * xSpeed;
var yMath = Math.Pow(curve * ySpeed, 2) + curve * ySpeed;
var mouseMovement = new Vector2(xMath, yMath);
if (axis.X < 0)
{
mouseMovement.X = -mouseMovement.X;
}
if (axis.Y < 0)
{
mouseMovement.Y = -mouseMovement.Y;
}
HardwareInput.MoveMouse((int)mouseMovement.X, (int)mouseMovement.Y);
}
}
private static double ComputeState(HardwareInput hardwareInput, HardwareAxis hardwareAxis)
{
var hardwareInputVariant = hardwareAxis.HardwareInputVariant;
switch (hardwareInputVariant.CurrentVariant)
{
case HardwareInputVariant.Variant.Keyboard:
return(BoolToDouble(hardwareInput.KeyboardInput[hardwareInputVariant.AsKeyboard()]));
case HardwareInputVariant.Variant.Mouse:
switch (hardwareInputVariant.AsMouse())
{
case HardwareInputVariant.MouseVariant.AxisX:
return(hardwareInput.MouseInput.PositionDelta.X);
case HardwareInputVariant.MouseVariant.AxisY:
return(-hardwareInput.MouseInput.PositionDelta.Y);
default:
throw new ArgumentOutOfRangeException();
}
default:
throw new ArgumentOutOfRangeException();
}
}
void OnLeftKeyStarted(HardwareInput sender)
{
if (!_atLeftBoundary)
{
_rigidbody.AddForce(Vector3.left * driftSpeed);
}
}
void OnRightKeyStarted(HardwareInput sender)
{
if (!_atRightBoundary)
{
_rigidbody.AddForce(Vector3.right * driftSpeed);
}
}
public Input(KeyboardInput keyboardInput)
{
Mouse = default;
Hardware = default;
Type = InputType.Keyboard;
Keyboard = keyboardInput;
}
/// <summary>
/// Converts a 32bit Input to a 64bit Input
/// </summary>
/// <param name="input"></param>
public Input64(Input input)
{
type = input.type;
mi = input.mi;
ki = input.ki;
hi = input.hi;
}
public static void SendKeyUp(Key key, bool forceDirect = false)
{
if ((Properties.Settings.Default.InputDirectKeyboard || forceDirect) && _process != null)
{
// Send direct key messages to WoW window
PostMessage(new HandleRef(null, _process.MainWindowHandle), WM_KEYUP,
(IntPtr)KeyInterop.VirtualKeyFromKey(key), IntPtr.Zero);
}
else
{
// Simulate hardware inputs
HardwareInput.SendKey(key, false);
}
}
private static void ProcessCursor(Point axis)
{
var axisInput = new Vector2(axis.X, axis.Y);
if (axisInput.Magnitude > Settings.Default.CursorDeadzone)
{
axisInput = Vector2.Normalize(axisInput) *
((axisInput.Magnitude - Settings.Default.CursorDeadzone) /
(127 - Settings.Default.CursorDeadzone));
var curve = 0.05 * Settings.Default.CursorCurve;
var xSpeed = (axisInput.X < 0 ? -axisInput.X : axisInput.X) * Settings.Default.CursorSpeed;
var ySpeed = (axisInput.Y < 0 ? -axisInput.Y : axisInput.Y) * Settings.Default.CursorSpeed;
var xMath = Math.Pow(curve * xSpeed, 2) + curve * xSpeed;
var yMath = Math.Pow(curve * ySpeed, 2) + curve * ySpeed;
//xMath *= MemoryManager.ReadAoeState() ? 0.5 : 1;
//yMath *= MemoryManager.ReadAoeState() ? 0.5 : 1;
var mouseMovement = new Vector2(xMath, yMath);
if (axis.X < 0)
{
mouseMovement.X = -mouseMovement.X;
}
if (axis.Y < 0)
{
mouseMovement.Y = -mouseMovement.Y;
}
if (Settings.Default.InputHardwareMouse)
{
HardwareInput.MoveMouse((int)mouseMovement.X, (int)mouseMovement.Y);
}
else
{
var m = Cursor.Position;
m.X += (int)mouseMovement.X;
m.Y += (int)mouseMovement.Y;
Cursor.Position = m;
}
}
}
/// <summary>
/// Initialize this module.
/// </summary>
public override void Initialize()
{
base.Initialize();
HardwareInput = Host.Platform.GetInput(Host.Window);
HardwareInput.Initialize();
HardwareInput.JoypadConnection += (obj, e) =>
{
if (!InputStates.ContainsKey(e.Joypad))
{
InputStates.Add(e.Joypad, new InputState());
}
if (e.Connected)
{
Joypads.Add(new VirtualJoypad(InputStates?[e.Joypad], e.Joypad.Index, e.Joypad.Name));
}
else
{
Joypads.RemoveAt(Joypads.FindIndex(x => x.Index == e.Joypad.Index));
}
JoypadConnection?.Invoke(obj, e);
};
InputStates.Add(HardwareKeyboard, new InputState());
InputStates.Add(HardwareMouse, new InputState());
HardwareKeyboard.OnTypeWithMods += HardwareKeyboard_OnTypeWithMods;
HardwareKeyboard.OnKeyEvent += HardwareKeyboard_OnKeyEvent;
HardwareKeyboard.OnType += HardwareKeyboard_OnType;
HardwareMouse.OnButtonEvent += HardwareMouse_OnButtonEvent;
HardwareMouse.OnScroll += HardwareMouse_OnScroll;
HardwareMouse.OnMove += HardwareMouse_OnMove;
foreach (var j in HardwareJoypads)
{
Joypads.Add(new VirtualJoypad(null, j.Index, j.Name));
}
}
public HardwarePacket()
{
this.input = new HardwareInput();
}
private void MoveCameraLeft(HardwareInput input)
{
MoveCameraInDirection(CameraDirection.Left);
}
public static void SendMouseUp(MouseButton button, bool forceDirect = false)
{
HardwareInput.SendClick(button, false);
}
private void MoveCameraRight(HardwareInput input)
{
MoveCameraInDirection(CameraDirection.Right);
}
private void StartKick(HardwareInput input)
{
_photonView.RPC("HandleStartKick", RpcTarget.AllViaServer);
}
public static Input Hardware(HardwareInput input)
{
return(new Input {
Type = INPUT_HARDWARE, Hi = input
});
}
/// <summary>
/// Update the state of this element.
/// </summary>
/// <param name="clock">Game clock.</param>
public override void Update(IFrameBasedClock clock)
{
base.Update(clock);
HardwareInput.Update(clock);
InputStates[HardwareKeyboard].Time = clock.CurrentTime;
InputStates[HardwareMouse].Time = clock.CurrentTime;
// - Remove unused joypads
var removed = InputStates.Keys.Where(x => x is IJoypad).Except(HardwareJoypads);
foreach (IJoypad pad in removed)
{
InputStates.Remove(pad);
}
// - Update joypad states
foreach (IJoypad pad in HardwareJoypads)
{
if (!InputStates.ContainsKey(pad))
{
InputStates.Add(pad, new InputState());
}
for (uint i = 0; i < pad.Buttons.Count(); ++i)
{
if (pad.Buttons[i] != InputStates[pad].GetKeyState(i))
{
InputStates[pad].Events.Enqueue(new InputEvent <JoypadKeyEventArgs>
{
Name = "OnButtonPress",
Info = new JoypadKeyEventArgs
{
Key = (int)i,
Action = pad.Buttons[i]
}
});
}
InputStates[pad].SetKeyState(i, pad.Buttons[i]);
}
for (uint i = 0; i < pad.Axes.Count(); ++i)
{
if (pad.Axes[i] != InputStates[pad].GetPositionState(i))
{
InputStates[pad].Events.Enqueue(new InputEvent <JoypadAxeEventArgs>
{
Name = "OnAxeMovement",
Info = new JoypadAxeEventArgs
{
Axe = (int)i,
Value = pad.Axes[i]
}
});
}
InputStates[pad].SetPositionState(i, (float)pad.Axes[i]);
}
InputStates[pad].Time = clock.CurrentTime;
}
Mouse.UpdateCurrentState(InputStates?[HardwareMouse]);
Keyboard.UpdateCurrentState(InputStates?[HardwareKeyboard]);
Mouse.Update(clock);
Keyboard.Update(clock);
foreach (var j in Joypads)
{
j.UpdateCurrentState(InputStates?[HardwareJoypads.Where(x => x.Index == j.Index).FirstOrDefault()]);
j.Update(clock);
}
// - Update binding
CurrentBinding?.Update(clock);
}
public HardwarePacket(HardwareInput input)
{
this.input = input;
}
