protected ControllerSpotlightInputController()
{
method = (ControllerMethod)Enum.Parse(typeof(ControllerMethod), Plugin.Settings.GeneralSettingsIniFile.ReadString("Controller", "Method", nameof(ControllerMethod.LeftStick)), true);
modifierButton = Plugin.Settings.GeneralSettingsIniFile.ReadEnum <ControllerButtons>("Controller", "Modifier", ControllerButtons.LeftShoulder);
toggleButton = Plugin.Settings.GeneralSettingsIniFile.ReadEnum <ControllerButtons>("Controller", "Toggle", ControllerButtons.X);
}
public static void LoadConfig()
{
InitializationFile settings = initialiseFile(Global.Application.ConfigPath + "SilencerKI.ini");
Logger.DebugLog("General Config Loading Started.");
Global.Application.DebugLogging = (settings.ReadBoolean("General", "DebugLogging", false));
KeysConverter KeyCV = new KeysConverter();
string AttachKey, AttachKeyModifier, AttachSilencerController, AttachSilencerControllerModifier;
AttachKey = settings.ReadString("Keybinds", "AttachSilencer", "F10");
AttachKeyModifier = settings.ReadString("Keybinds", "AttachSilencerModifier", "LShiftKey");
AttachSilencerController = settings.ReadString("Keybinds", "AttachSilencerController", "DPadRight");
AttachSilencerControllerModifier = settings.ReadString("Keybinds", "AttachSilencerControllerModifier", "LShiftKey");
Global.Controls.AttachSilencer = (Keys)KeyCV.ConvertFromString(AttachKey);
Global.Controls.AttachSilencerModifier = (Keys)KeyCV.ConvertFromString(AttachKeyModifier);
TypeConverter typeConverter = TypeDescriptor.GetConverter(Global.Controls.AttachSilencerController);
ControllerButtons CVController = (ControllerButtons)typeConverter.ConvertFromString(AttachSilencerController);
ControllerButtons CVControllerModifier = (ControllerButtons)typeConverter.ConvertFromString(AttachSilencerControllerModifier);
Global.Controls.AttachSilencerController = CVController;
Global.Controls.AttachSilencerControllerModifier = CVControllerModifier;
Logger.DebugLog("General Config Loading Finished.");
}
public static bool Pressed(ControllerButtons cb, PlayerIndex pi)
{
bool current = (bool)typeof(ControllerState).GetProperty(cb.ToString()).GetValue(CurrentControllerState[(int)pi]);
bool previous = (bool)typeof(ControllerState).GetProperty(cb.ToString()).GetValue(PreviousControllerState[(int)pi]);
return(current && !previous);
}
private static void SetupUserGeneralSettings()
{
KeysConverter kc = new KeysConverter();
PlayAnimations = GeneralIni.ReadBoolean("GeneralConfig", "PlayAnimations", true);
PlayRadioButtonSounds = GeneralIni.ReadBoolean("GeneralConfig", "PlayRadioButtonSounds", true);
PoliceSmartRadio.PlayerName = GeneralIni.ReadString("GeneralConfig", "PlayerName", "NoNameSet");
ResetRadioWhenOpening = GeneralIni.ReadBoolean("GeneralConfig", "ResetToPageOneOnOpen", false);
AlwaysDisplayButtons = GeneralIni.ReadBoolean("GeneralConfig", "AlwaysDisplayButtons", false);
ToggleRadioKey = (Keys)kc.ConvertFromString(KeyboardIni.ReadString("KeyboardConfig", "ToggleRadioKey", "C"));
ToggleRadioModifierKey = (Keys)kc.ConvertFromString(KeyboardIni.ReadString("KeyboardConfig", "ToggleRadioModifierKey", "None"));
NextButtonKey = (Keys)kc.ConvertFromString(KeyboardIni.ReadString("KeyboardConfig", "NextButtonKey", "G"));
PreviousButtonKey = (Keys)kc.ConvertFromString(KeyboardIni.ReadString("KeyboardConfig", "PreviousButtonKey", "T"));
SelectButtonKey = (Keys)kc.ConvertFromString(KeyboardIni.ReadString("KeyboardConfig", "SelectButtonKey", "Z"));
NextPageKey = (Keys)kc.ConvertFromString(KeyboardIni.ReadString("KeyboardConfig", "NextPageKey", "Right"));
PreviousPageKey = (Keys)kc.ConvertFromString(KeyboardIni.ReadString("KeyboardConfig", "PreviousPageKey", "Left"));
ToggleRadioButton = ControllerIni.ReadEnum <ControllerButtons>("ControllerConfig", "ToggleRadioButton", ControllerButtons.DPadLeft);
ToggleRadioModifierButton = ControllerIni.ReadEnum <ControllerButtons>("ControllerConfig", "ToggleRadioModifierButton", ControllerButtons.None);
NextButtonButton = ControllerIni.ReadEnum <ControllerButtons>("ControllerConfig", "NextButtonButton", ControllerButtons.DPadDown);
PreviousButtonButton = ControllerIni.ReadEnum <ControllerButtons>("ControllerConfig", "PreviousButtonButton", ControllerButtons.DPadUp);
SelectButtonButton = ControllerIni.ReadEnum <ControllerButtons>("ControllerConfig", "SelectButtonButton", ControllerButtons.X);
NextPageButton = ControllerIni.ReadEnum <ControllerButtons>("ControllerConfig", "NextPageButton", ControllerButtons.None);
PreviousPageButton = ControllerIni.ReadEnum <ControllerButtons>("ControllerConfig", "PreviousPageButton", ControllerButtons.None);
}
public void Update(short lX, short lY, short rX, short rY, ControllerButtons buttons)
{
// Axes
iReport.LeftThumbX = lX;
iReport.LeftThumbY = lY;
iReport.RightThumbX = rX;
iReport.RightThumbY = rY;
// Face buttons
iReport.SetButtonState(Xbox360Buttons.Y, (buttons & ControllerButtons.BTN_Button1) != 0);
iReport.SetButtonState(Xbox360Buttons.B, (buttons & ControllerButtons.BTN_Button2) != 0);
iReport.SetButtonState(Xbox360Buttons.A, (buttons & ControllerButtons.BTN_Button3) != 0);
iReport.SetButtonState(Xbox360Buttons.X, (buttons & ControllerButtons.BTN_Button4) != 0);
// POV buttons
iReport.SetButtonState(Xbox360Buttons.Up, (buttons & ControllerButtons.BTN_POV_Up) != 0);
iReport.SetButtonState(Xbox360Buttons.Down, (buttons & ControllerButtons.BTN_POV_Down) != 0);
iReport.SetButtonState(Xbox360Buttons.Left, (buttons & ControllerButtons.BTN_POV_Left) != 0);
iReport.SetButtonState(Xbox360Buttons.Right, (buttons & ControllerButtons.BTN_POV_Right) != 0);
// L buttons
iReport.SetButtonState(Xbox360Buttons.LeftShoulder, (buttons & ControllerButtons.BTN_L1) != 0);
iReport.LeftTrigger = ((buttons & ControllerButtons.BTN_L2) == ControllerButtons.BTN_L2) ? byte.MaxValue : byte.MinValue;
iReport.SetButtonState(Xbox360Buttons.LeftThumb, (buttons & ControllerButtons.BTN_L3) != 0);
// R buttons
iReport.SetButtonState(Xbox360Buttons.RightShoulder, (buttons & ControllerButtons.BTN_R1) != 0);
iReport.RightTrigger = ((buttons & ControllerButtons.BTN_R2) == ControllerButtons.BTN_R2) ? byte.MaxValue : byte.MinValue;
iReport.SetButtonState(Xbox360Buttons.RightThumb, (buttons & ControllerButtons.BTN_R3) != 0);
// Start/Select
iReport.SetButtonState(Xbox360Buttons.Start, (buttons & ControllerButtons.BTN_Start) != 0);
iReport.SetButtonState(Xbox360Buttons.Back, (buttons & ControllerButtons.BTN_Select) != 0);
ctrl.SendReport(iReport);
}
public Control(Keys key, Keys modifierKey, ControllerButtons button, ControllerButtons modifierButton)
{
Key = key;
ModifierKey = modifierKey;
Button = button;
ModifierButton = modifierButton;
}
// Get a new button from ControllerButtons Enum
private ControllerButtons GetNewButton()
{
Array values = Enum.GetValues(typeof(ControllerButtons));
m_PreviousButton = (ControllerButtons)values.GetValue((int)Random.Range(0, values.Length));
OnButtonChange.Invoke(m_PreviousButton);
return(m_PreviousButton);
}
public ControlsSerializeAdapter(
TEnum action,
Keys key, Keys modifier, ControllerButtons ctrlButton)
{
Action = action;
Key = key;
Modifier = modifier;
ControllerBtn = ctrlButton;
}
public void ChangeText(ControllerButtons button)
{
if (!isFirst)
{
m_animator.SetTrigger("Close");
}
else isFirst = false;
m_animator.SetTrigger(button.ToString().ToUpper());
}
public void SetButton(ControllerButtons button, bool pressed)
{
if (pressed)
{
_currentButtonState |= (byte)button;
}
else
{
_currentButtonState &= (byte)~button;
}
}
public static bool GetButtonUp(ControllerButtons button)
{
if ((int)button < 9)
{
return(Input.GetButtonUp(Buttons[(int)button]));
}
else
{
return(Input.GetAxis(Buttons[(int)button]) < 1e-3f);
}
}
//============================================================================================
// detects is a button is down on any controller, e.g. for a single player game that has
// several controllers attached, this lets you treat them all as the same controller
//============================================================================================
public bool isPressed(ControllerButtons b)
{
for (int i = 0; i < mActivePadCount; i++) //iterate through attached controllers and output data
{
if (isPressed(i, b))
{
return(true);
}
}
return(false);
}
//============================================================================================
//detects if a button is down, this is just a helper function to make code cleaner, pulls data from the absracted controller
//============================================================================================
public bool isDown(int id, ControllerButtons b)
{
switch (b)
{
case ControllerButtons.LAS_BUTTON:
return(mPadData[id].leftAsDown);
case ControllerButtons.RAS_BUTTON:
return(mPadData[id].rightAsDown);
case ControllerButtons.BUTX:
return(mPadData[id].butX);
case ControllerButtons.BUTY:
return(mPadData[id].butY);
case ControllerButtons.BUTA:
return(mPadData[id].butA);
case ControllerButtons.BUTB:
return(mPadData[id].butB);
case ControllerButtons.UP:
return(mPadData[id].up);
case ControllerButtons.DOWN:
return(mPadData[id].down);
case ControllerButtons.LEFT:
return(mPadData[id].left);
case ControllerButtons.RIGHT:
return(mPadData[id].right);
case ControllerButtons.LEFTTOP:
return(mPadData[id].leftTop);
case ControllerButtons.RIGHTTOP:
return(mPadData[id].rightTop);
case ControllerButtons.START:
return(mPadData[id].start);
case ControllerButtons.HOME:
return(mPadData[id].home);
case ControllerButtons.BACK:
return(mPadData[id].back);
default:
break;
}
return(false);
}
public static bool ButtonReleased(Players Player, ControllerButtons button)
{
if (Input.GetButtonUp(Player.ToString() + "-Controller" + button.ToString()))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Initializes an Unbalance controller.
/// </summary>
internal Ps2Controller(ControllerButtons buttons, byte[] buttonBytes, byte[] brake, byte[] power)
{
ControllerName = string.Empty;
IsConnected = false;
RequiresCalibration = false;
BrakeNotches = brake.Length / 2 - 2;
PowerNotches = power.Length / 2 - 1;
brakeBytes = brake;
powerBytes = power;
Buttons = buttons;
buttonMask = buttonBytes;
}
public void ChangeText(ControllerButtons button)
{
if (!isFirst)
{
m_animator.SetTrigger("Close");
}
else
{
isFirst = false;
}
m_animator.SetTrigger(button.ToString().ToUpper());
}
/// <summary>
/// Initializes an Unbalance controller.
/// </summary>
internal UnbalanceController(ControllerButtons buttons, int[] buttonIndices, bool combo, byte[] brake, byte[] power)
{
ControllerName = string.Empty;
IsConnected = false;
RequiresCalibration = false;
BrakeNotches = brake.Length / 2 - 2;
PowerNotches = power.Length / 2 - 1;
brakeBytes = brake;
powerBytes = power;
Buttons = buttons;
buttonIndex = buttonIndices;
comboDpad = combo;
}
private void OnPadClicked(object sender, ClickedEventArgs clickedEventArgs)
{
var pressedButton = GetModeForPadPosition(clickedEventArgs.padX, clickedEventArgs.padY);
if (pressedButton == CurrentlyPressedButton)
{
return;
}
if (UIButtonClickedEvent != null)
{
UIButtonClickedEvent(this, pressedButton);
}
CurrentlyPressedButton = pressedButton;
}
public string GetMappedButton(ControllerButtons btn, ControllerButtons modifier)
{
if (btn == ControllerButtons.None)
{
return(null);
}
foreach (KeyValuePair <string, Control> mapping in this)
{
if (mapping.Value.Button == btn && mapping.Value.ModifierButton == modifier)
{
return(mapping.Key);
}
}
return(null);
}
public static void LoadConfig()
{
InitializationFile settings = initialiseFile(Global.Application.ConfigPath + "PassengerKI.ini");
Logger.DebugLog("General Config Loading Started.");
Global.Application.DebugLogging = (settings.ReadBoolean("General", "DebugLogging", false));
KeysConverter KeyCV = new KeysConverter();
string EnterPassenger, EnterPassengerModifier, EnterPassengerController, EnterPassengerControllerModifier, DriveToMarker, DriveToMarkerModifier, DriveToMarkerController, DriveToMarkerControllerModifier;
// Fetch settings from file / set default values
EnterPassenger = settings.ReadString("Keybinds", "EnterPassenger", "E");
EnterPassengerModifier = settings.ReadString("Keybinds", "EnterPassengerModifier", "None");
EnterPassengerController = settings.ReadString("Keybinds", "EnterPassengerController", "Y");
EnterPassengerControllerModifier = settings.ReadString("Keybinds", "EnterPassengerControllerModifier", "DPadDown");
DriveToMarker = settings.ReadString("Keybinds", "DriveToMarker", "Space");
DriveToMarkerModifier = settings.ReadString("Keybinds", "DriveToMarkerModifier", "None");
DriveToMarkerController = settings.ReadString("Keybinds", "DriveToMarkerController", "X");
DriveToMarkerControllerModifier = settings.ReadString("Keybinds", "DriveToMarkerControllerModifier", "DPadLeft");
// Assign Keyboard Buttons to Global Variable
Global.Controls.EnterPassenger = (Keys)KeyCV.ConvertFromString(EnterPassenger);
Global.Controls.EnterPassengerModifier = (Keys)KeyCV.ConvertFromString(EnterPassengerModifier);
Global.Controls.DriveToMarker = (Keys)KeyCV.ConvertFromString(DriveToMarker);
Global.Controls.DriveToMarkerModifier = (Keys)KeyCV.ConvertFromString(DriveToMarkerModifier);
// Convert Controller Buttons to the right format
TypeConverter typeConverter = TypeDescriptor.GetConverter(Global.Controls.EnterPassengerController); // get type of variable
ControllerButtons EPController = (ControllerButtons)typeConverter.ConvertFromString(EnterPassengerController);
ControllerButtons EPControllerModifier = (ControllerButtons)typeConverter.ConvertFromString(EnterPassengerControllerModifier);
ControllerButtons DMController = (ControllerButtons)typeConverter.ConvertFromString(DriveToMarkerController);
ControllerButtons DMControllerModifier = (ControllerButtons)typeConverter.ConvertFromString(DriveToMarkerControllerModifier);
// Assign Controller Buttons to Global Variable
Global.Controls.EnterPassengerController = EPController;
Global.Controls.EnterPassengerControllerModifier = EPControllerModifier;
Global.Controls.DriveToMarkerController = DMController;
Global.Controls.DriveToMarkerControllerModifier = DMControllerModifier;
Logger.DebugLog("General Config Loading Finished.");
}
public ControllerButtons UpdateStickButtons(
JoystickPosition leftStick,
JoystickPosition rightStick)
{
ControllerButtons result = 0;
if (rightStick.Dx < 0)
{
result |= ControllerButtons.RStickLeft;
}
if (rightStick.Dx > 0)
{
result |= ControllerButtons.RStickRight;
}
if (rightStick.Dy < 0)
{
result |= ControllerButtons.RStickDown;
}
if (rightStick.Dy > 0)
{
result |= ControllerButtons.RStickUp;
}
if (leftStick.Dx < 0)
{
result |= ControllerButtons.LStickLeft;
}
if (leftStick.Dx > 0)
{
result |= ControllerButtons.LStickRight;
}
if (leftStick.Dy < 0)
{
result |= ControllerButtons.LStickDown;
}
if (leftStick.Dy > 0)
{
result |= ControllerButtons.LStickUp;
}
return(result);
}
//Helper method that executes the Pressed or Released event for a button on the UI thread.
private void ExecuteButtonChangedEvent(ControllerButtons button, bool isPressed)
{
ButtonEventArgs eventArgs = new ButtonEventArgs()
{
AffectedButton = button
};
if (isPressed && ButtonPressed != null)
{
ApplicationDispatcher.Invoke(delegate { ButtonPressed(this, eventArgs); });
}
else if (!isPressed && ButtonReleased != null)
{
ApplicationDispatcher.Invoke(delegate { ButtonReleased(this, eventArgs); });
}
}
public static Vector2 ThumbstickPosition(ControllerButtons cb, int index)
{
if (index > 3 || index < 0)
{
throw new Exception();
}
switch (cb)
{
case ControllerButtons.LeftStick:
return(CurrentControllerState[index].LeftStick);
case ControllerButtons.RightStick:
return(CurrentControllerState[index].RightStick);
default:
throw new Exception();
}
}
/// <summary>
/// Gets the list of connected controllers
/// </summary>
/// <returns>The list of controllers handled by this class.</returns>
internal static Dictionary <Guid, Controller> GetControllers()
{
for (int i = 0; i < 10; i++)
{
Guid guid = Joystick.GetGuid(i);
string id = GetControllerID(guid);
string name = Joystick.GetName(i);
if (!cachedControllers.ContainsKey(guid))
{
// ZKNS-001
if (id == "0f0d:00c1")
{
ControllerButtons buttons = ControllerButtons.Select | ControllerButtons.Start | ControllerButtons.A | ControllerButtons.B | ControllerButtons.C | ControllerButtons.D | ControllerButtons.LDoor | ControllerButtons.RDoor | ControllerButtons.DPad;
int[] buttonIndices = { 8, 9, 0, 1, 2, 3, 4, 5 };
byte[] brakeBytes = { 0x7F, 0x81, 0x64, 0x66, 0x56, 0x58, 0x48, 0x4A, 0x3B, 0x3D, 0x2D, 0x2F, 0x1F, 0x21, 0x12, 0x14, 0x04, 0x06, 0x0, 0x1 };
byte[] powerBytes = { 0x7F, 0x81, 0x9E, 0xA0, 0xB6, 0xB8, 0xCD, 0xCF, 0xE5, 0xE7, 0xFE, 0xFF };
ZuikiController newcontroller = new ZuikiController(buttons, buttonIndices, brakeBytes, powerBytes)
{
Guid = guid,
Id = id,
joystickIndex = i,
ControllerName = name,
IsConnected = true
};
cachedControllers.Add(guid, newcontroller);
}
}
else
{
// Cached controller, update it
((ZuikiController)cachedControllers[guid]).joystickIndex = i;
// HACK: IsConnected is broken, we check the capabilities instead to know if the controller is connected or not
cachedControllers[guid].IsConnected = Joystick.GetCapabilities(i).ButtonCount > 0;
}
}
return(cachedControllers);
}
public static bool IsJustPressed(this Control control)
{
if (NativeFunction.CallByName <int>("UPDATE_ONSCREEN_KEYBOARD") == 0)
{
return(false);
}
if (Settings.UseController && IsUsingController)
{
bool modifierButtonPressed = Settings.ModifierButton == ControllerButtons.None ? true : Game.IsControllerButtonDownRightNow(Settings.ModifierButton);
ControllerButtons bttn = GetControllerButton(control);
return(modifierButtonPressed && (bttn == ControllerButtons.None ? false : Game.IsControllerButtonDown(bttn)));
}
else if (Settings.UseKeyboard)
{
bool modifierKeyPressed = Settings.ModifierKey == Keys.None ? true : Game.IsKeyDownRightNow(Settings.ModifierKey);
Keys key = GetKey(control);
return(modifierKeyPressed && (key == Keys.None ? false : Game.IsKeyDown(key)));
}
return(false);
}
private static GameControl?ButtonToScriptControl(ControllerButtons button)
{
switch (button)
{
case ControllerButtons.DPadUp: return(GameControl.ScriptPadUp);
case ControllerButtons.DPadDown: return(GameControl.ScriptPadDown);
case ControllerButtons.DPadLeft: return(GameControl.ScriptPadLeft);
case ControllerButtons.DPadRight: return(GameControl.ScriptPadRight);
case ControllerButtons.Start: return(null);
case ControllerButtons.Back: return(null);
case ControllerButtons.LeftThumb: return(GameControl.ScriptLT);
case ControllerButtons.RightThumb: return(GameControl.ScriptRT);
case ControllerButtons.LeftShoulder: return(GameControl.ScriptLB);
case ControllerButtons.RightShoulder: return(GameControl.ScriptRB);
case ControllerButtons.A: return(GameControl.ScriptRDown);
case ControllerButtons.B: return(GameControl.ScriptRRight);
case ControllerButtons.X: return(GameControl.ScriptRLeft);
case ControllerButtons.Y: return(GameControl.ScriptRUp);
default: return(null);
}
;
}
//============================================================================================
//detects a momementary button press (e.g debounced), helper pulls data from the abstracted controller data.
//============================================================================================
public bool isPressed(int id, ControllerButtons b)
{
bool curr, old;
switch (b)
{
case ControllerButtons.LAS_BUTTON:
curr = mPadData[id].leftAsDown;
old = !mPadDataOld[id].leftAsDown;
return(curr && old);
case ControllerButtons.RAS_BUTTON:
curr = mPadData[id].rightAsDown;
old = !mPadDataOld[id].rightAsDown;
return(curr && old);
case ControllerButtons.BUTX:
curr = mPadData[id].butX;
old = !mPadDataOld[id].butX;
return(curr && old);
case ControllerButtons.BUTY:
curr = mPadData[id].butY;
old = !mPadDataOld[id].butY;
return(curr && old);
case ControllerButtons.BUTA:
curr = mPadData[id].butA;
old = !mPadDataOld[id].butA;
return(curr && old);
case ControllerButtons.BUTB:
curr = mPadData[id].butB;
old = !mPadDataOld[id].butB;
return(curr && old);
case ControllerButtons.UP:
curr = mPadData[id].up;
old = !mPadDataOld[id].up;
return((curr && old)?true:false);
case ControllerButtons.DOWN:
curr = mPadData[id].down;
old = !mPadDataOld[id].down;
return(curr && old);
case ControllerButtons.LEFT:
curr = mPadData[id].left;
old = !mPadDataOld[id].left;
return((curr && old)?true:false);
case ControllerButtons.RIGHT:
curr = mPadData[id].right;
old = !mPadDataOld[id].right;
return(curr && old);
case ControllerButtons.LEFTTOP:
curr = mPadData[id].leftTop;
old = !mPadDataOld[id].leftTop;
return(curr && old);
case ControllerButtons.RIGHTTOP:
curr = mPadData[id].rightTop;
old = !mPadDataOld[id].rightTop;
return(curr && old);
case ControllerButtons.PAUSE:
curr = mPadData[id].pause;
old = !mPadDataOld[id].pause;
return(curr && old);
default:
break;
}
return(false);
}
// Get a new button from ControllerButtons Enum
private ControllerButtons GetNewButton()
{
Array values = Enum.GetValues(typeof(ControllerButtons));
m_PreviousButton = (ControllerButtons)values.GetValue((int)Random.Range(0, values.Length));
OnButtonChange.Invoke(m_PreviousButton);
return m_PreviousButton;
}
public static bool Held(Keys key, ControllerButtons cb, PlayerIndex pi = PlayerIndex.One)
{
return(Held(key) || Held(cb, pi));
}
public static bool Released(Keys key, ControllerButtons cb, PlayerIndex pi = PlayerIndex.One)
{
return(Released(key) || Released(cb, pi));
}
private void timer_Tick(object sender, EventArgs e)
{
int X, Y;
leftTriggerB = XInput.Controllers[controllerBox].State.Gamepad.LeftTrigger > 100;
joystick.SetAxis(XInput.Controllers[controllerBox].State.Gamepad.LeftTrigger * 128, id, HID_USAGES.HID_USAGE_SL0);
rightTriggerB = XInput.Controllers[controllerBox].State.Gamepad.RightTrigger > 100;
joystick.SetAxis(XInput.Controllers[controllerBox].State.Gamepad.RightTrigger * 128, id, HID_USAGES.HID_USAGE_SL1);
leftX = XInput.Controllers[controllerBox].State.Gamepad.ThumbLeftX / (32767 / 11);
joystick.SetAxis(XInput.Controllers[controllerBox].State.Gamepad.ThumbLeftX / 2 + 16384, id, HID_USAGES.HID_USAGE_X);
leftY = XInput.Controllers[controllerBox].State.Gamepad.ThumbLeftY / (32767 / 11);
joystick.SetAxis(XInput.Controllers[controllerBox].State.Gamepad.ThumbLeftY / 2 + 16384, id, HID_USAGES.HID_USAGE_Y);
if (Math.Abs(leftX) > 1 || Math.Abs(leftY) > 1)
{
X = XInput.Controllers[controllerBox].State.Gamepad.ThumbLeftX / (32767 / 20);
Y = 0 - XInput.Controllers[controllerBox].State.Gamepad.ThumbLeftY / (32767 / 20);
string stuff = X.ToString();
mouse_event(MOUSEEVENTF_MOVE, (uint)X, (uint)Y, 0, 0);
//MessageBox.Show(stuff, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
rightX = XInput.Controllers[controllerBox].State.Gamepad.ThumbRightX / (32767 / 11);
joystick.SetAxis(XInput.Controllers[controllerBox].State.Gamepad.ThumbRightX / 2 + 16384, id, HID_USAGES.HID_USAGE_RX);
rightY = XInput.Controllers[controllerBox].State.Gamepad.ThumbRightY / (32767 / 11);
joystick.SetAxis(XInput.Controllers[controllerBox].State.Gamepad.ThumbRightY / 2 + 16384, id, HID_USAGES.HID_USAGE_RY);
rightStick.Text = rightX + ";" + rightY;
ControllerButtons buttons = XInput.Controllers[controllerBox].State.Gamepad.Buttons;
//************ A
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.A)) joystick.SetBtn(true, id, 1);
else joystick.SetBtn(false, id, 1);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.A))
{
if (!LMouse_button_state)
{
X = Cursor.Position.X;
Y = Cursor.Position.Y;
LMouse_button_state = true;
mouse_event(MOUSEEVENTF_LEFTDOWN, (uint)X, (uint)Y, 0, 0);
}
}
else
{
if (LMouse_button_state)
{
X = Cursor.Position.X;
Y = Cursor.Position.Y;
LMouse_button_state = false;
mouse_event(MOUSEEVENTF_LEFTUP, (uint)X, (uint)Y, 0, 0);
}
}
//****************** B
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.B)) joystick.SetBtn(true, id, 2);
else joystick.SetBtn(false, id, 2);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.B))
{
if (!RMouse_button_state)
{
X = Cursor.Position.X;
Y = Cursor.Position.Y;
RMouse_button_state = true;
mouse_event(MOUSEEVENTF_RIGHTDOWN, (uint)X, (uint)Y, 0, 0);
}
}
else
{
if (RMouse_button_state)
{
X = Cursor.Position.X;
Y = Cursor.Position.Y;
RMouse_button_state = false;
mouse_event(MOUSEEVENTF_RIGHTUP, (uint)X, (uint)Y, 0, 0);
}
}
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.X)) joystick.SetBtn(true, id, 3);
else joystick.SetBtn(false, id, 3);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Y)) joystick.SetBtn(true, id, 4);
else joystick.SetBtn(false, id, 4);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Y))
{
if (!YMouse_button_state)
{
YMouse_button_state = true;
keybd_event(0x5B, 0, 0, 0);
}
}
else
{
if (YMouse_button_state)
{
YMouse_button_state = false;
keybd_event(0x5B, 0, 0, 0x02);
}
}
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.ShoulderLeft)) joystick.SetBtn(true, id, 5);
else joystick.SetBtn(false, id, 5);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.ShoulderRight)) joystick.SetBtn(true, id, 6);
else joystick.SetBtn(false, id, 6);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Back)) joystick.SetBtn(true, id, 7);
else joystick.SetBtn(false, id, 7);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Start)) joystick.SetBtn(true, id, 8);
else joystick.SetBtn(false, id, 8);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.ThumbLeft)) joystick.SetBtn(true, id, 9);
else joystick.SetBtn(false, id, 9);
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.ThumbRight)) joystick.SetBtn(true, id, 10);
else joystick.SetBtn(false, id, 10);
int pov = -1;
if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Up) && XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Right)) pov = 4500;
else if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Right) && XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Down)) pov = 13500;
else if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Down) && XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Left)) pov = 22500;
else if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Left) && XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Up)) pov = 31500;
else if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Up)) pov = 0;
else if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Right)) pov = 9000;
else if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Down)) pov = 18000;
else if (XInput.Controllers[controllerBox].IsButtonPressed(ControllerButtons.Left)) pov = 27000;
joystick.SetContPov(pov, id, 1);
this.pictureBox1.Refresh();
this.pictureBox2.Refresh();
lastButtonsPressed = buttons;
}
public static bool Pressed(Keys key, MouseControl button, ControllerButtons cb, PlayerIndex pi = PlayerIndex.One)
{
return(Pressed(key) || Pressed(button) || Pressed(cb, pi));
}
public bool IsButtonPressed(ControllerButtons buttonsToCheck)
{
PollStateInternal();
return (this.state.Gamepad.Buttons & buttonsToCheck) != 0;
}
public static bool Released(ControllerButtons cb, PlayerIndex pi)
{
bool current = (bool)typeof(ControllerState).GetProperty(cb.ToString()).GetValue(CurrentControllerState[(int)pi], null);
return(current);
}
public static ButtonData State(ControllerButtons Button, int iPlayerIndex)
{
return State(Button, iPlayerIndex, false);
}
public static ButtonData State(ControllerButtons Button, int iPlayerIndex, bool Prev)
{
ButtonData Data = new ButtonData();
if (iPlayerIndex == -1 || iPlayerIndex == -2)
{
if (!Prev)
{
Data.Dir *= 0;
for (int i = 0; i < 4; i++)
//if (Generic.PlayerExists[i] || iPlayerIndex == -2)
{
ButtonData data = State(Button, i);
Data.Down = Data.Down || data.Down;
Data.Pressed = Data.Pressed || data.Pressed;
//Data.Down = Data.Down || State(Button, i).Down;
if (Math.Abs(data.Dir.X) > Math.Abs(Data.Dir.X)) Data.Dir.X = data.Dir.X;
if (Math.Abs(data.Dir.Y) > Math.Abs(Data.Dir.Y)) Data.Dir.Y = data.Dir.Y;
}
}
else
{
for (int i = 0; i < 4; i++)
//if (Generic.PlayerExists[i] || iPlayerIndex == -2)
{
ButtonData data = State(Button, i, true);
Data.Down = Data.Down || data.Down;
Data.Pressed = Data.Pressed || data.Pressed;
//Data.Down = Data.Down || State(Button, i, true).Down;
}
}
return Data;
}
#if WINDOWS
Keys key = Keys.None;
//if (iPlayerIndex == 0 || Generic.PlayerExists[iPlayerIndex])
{
#if PC_VERSION
if (Button == ControllerButtons.Start) key = Keys.Escape;
if (Button == ControllerButtons.B) key = Keys.Escape;
if (Button == ControllerButtons.X) key = Keys.C;
if (Button == ControllerButtons.Y) key = Keys.V;
if (Button == ControllerButtons.RT) key = Keys.OemPeriod;
if (Button == ControllerButtons.LT) key = Keys.OemComma;
#else
if (Button == ControllerButtons.Start) key = Keys.S;
if (Button == ControllerButtons.A) key = Keys.Z;
if (Button == ControllerButtons.B) key = Keys.X;
if (Button == ControllerButtons.X) key = Keys.C;
if (Button == ControllerButtons.Y) key = Keys.V;
if (Button == ControllerButtons.RT) key = Keys.OemPeriod;
if (Button == ControllerButtons.LT) key = Keys.OemComma;
#endif
}
KeyboardState keyboard;
if (Prev)
keyboard = Tools.PrevKeyboardState;
else
keyboard = Tools.keybState;
#endif
//#else
GamePadState Pad;
if (Prev) Pad = Tools.PrevpadState[iPlayerIndex];
else Pad = Tools.padState[iPlayerIndex];
switch (Button)
{
case ControllerButtons.Start: Data.Down = (Pad.Buttons.Start == ButtonState.Pressed); break;
case ControllerButtons.A: Data.Down = (Pad.Buttons.A == ButtonState.Pressed); break;
case ControllerButtons.B: Data.Down = (Pad.Buttons.B == ButtonState.Pressed); break;
case ControllerButtons.X: Data.Down = (Pad.Buttons.X == ButtonState.Pressed); break;
case ControllerButtons.Y: Data.Down = (Pad.Buttons.Y == ButtonState.Pressed); break;
case ControllerButtons.LJButton: Data.Down = (Pad.Buttons.LeftStick == ButtonState.Pressed); break;
case ControllerButtons.RJButton: Data.Down = (Pad.Buttons.RightStick == ButtonState.Pressed); break;
case ControllerButtons.LS: Data.Down = (Pad.Buttons.LeftShoulder == ButtonState.Pressed); break;
case ControllerButtons.RS: Data.Down = (Pad.Buttons.RightShoulder == ButtonState.Pressed); break;
case ControllerButtons.LT:
{
Data.Down = (Pad.Triggers.Left > .5f);
Data.Squeeze = Pad.Triggers.Left;
break;
}
case ControllerButtons.RT:
{
Data.Down = (Pad.Triggers.Right > .5f);
Data.Squeeze = Pad.Triggers.Right;
break;
}
case ControllerButtons.LJ: Data.Dir = Pad.ThumbSticks.Left; break;
case ControllerButtons.RJ: Data.Dir = Pad.ThumbSticks.Right; break;
case ControllerButtons.DPad:
{
Data.Dir = Vector2.Zero;
if (Pad.DPad.Right == ButtonState.Pressed) Data.Dir = new Vector2(1, 0);
if (Pad.DPad.Up == ButtonState.Pressed) Data.Dir = new Vector2(0, 1);
if (Pad.DPad.Left == ButtonState.Pressed) Data.Dir = new Vector2(-1, 0);
if (Pad.DPad.Down == ButtonState.Pressed) Data.Dir = new Vector2(0, -1);
}
break;
}
//#endif
#if WINDOWS
#if PC_VERSION
if (Button == ControllerButtons.A)
{
if (Prev)
Data.Down = Tools.CurMouseState.LeftButton == ButtonState.Pressed;
else
Data.Down = Tools.PrevMouseState.LeftButton == ButtonState.Pressed;
}
else
Data.Down = keyboard.IsKeyDown(key);
key = Keys.Escape;
if (Button == ControllerButtons.A) key = Keys.Z;
if (Button == ControllerButtons.B) key = Keys.X;
if (key != Keys.Escape)
Data.Down = Data.Down || keyboard.IsKeyDown(key);
if (Button == ControllerButtons.A)
Data.Down = Data.Down || keyboard.IsKeyDown(Keys.Enter);
#else
Data.Down |= keyboard.IsKeyDown(key);
#endif
if (Button == ControllerButtons.LJ)
{
Vector2 KeyboardDir = Vector2.Zero;
if (keyboard.IsKeyDown(Keys.Left)) KeyboardDir = new Vector2(-1, 0);
if (keyboard.IsKeyDown(Keys.Right)) KeyboardDir = new Vector2(1, 0);
if (keyboard.IsKeyDown(Keys.Up)) KeyboardDir = new Vector2(0, 1);
if (keyboard.IsKeyDown(Keys.Down)) KeyboardDir = new Vector2(0, -1);
if (KeyboardDir.LengthSquared() > Data.Dir.LengthSquared())
Data.Dir = KeyboardDir;
}
#endif
// Pressed == true if the previous state was not pressed but the current is
if (Data.Down && !Prev && !State(Button, iPlayerIndex, true).Down)
Data.Pressed = true;
return Data;
}
//============================================================================================
//detects if a button is down, this is just a helper function to make code cleaner, pulls data from the absracted controller
//============================================================================================
public bool isDown(int id,ControllerButtons b)
{
switch(b)
{
case ControllerButtons.LAS_BUTTON:
return(mPadData[id].leftAsDown);
case ControllerButtons.RAS_BUTTON:
return(mPadData[id].rightAsDown);
case ControllerButtons.BUTX:
return(mPadData[id].butX);
case ControllerButtons.BUTY:
return(mPadData[id].butY);
case ControllerButtons.BUTA:
return(mPadData[id].butA);
case ControllerButtons.BUTB:
return(mPadData[id].butB);
case ControllerButtons.UP:
return(mPadData[id].up);
case ControllerButtons.DOWN:
return(mPadData[id].down);
case ControllerButtons.LEFT:
return(mPadData[id].left);
case ControllerButtons.RIGHT:
return(mPadData[id].right);
case ControllerButtons.LEFTTOP:
return(mPadData[id].leftTop);
case ControllerButtons.RIGHTTOP:
return(mPadData[id].rightTop);
case ControllerButtons.PAUSE:
return(mPadData[id].pause);
default:
break;
}
return false;
}
//============================================================================================
//detects a momementary button press (e.g debounced), helper pulls data from the abstracted controller data.
//============================================================================================
public bool isPressed(int id,ControllerButtons b)
{
bool curr,old;
switch(b)
{
case ControllerButtons.LAS_BUTTON:
curr = mPadData[id].leftAsDown;
old = !mPadDataOld[id].leftAsDown;
return(curr&&old);
case ControllerButtons.RAS_BUTTON:
curr = mPadData[id].rightAsDown;
old = !mPadDataOld[id].rightAsDown;
return(curr&&old);
case ControllerButtons.BUTX:
curr = mPadData[id].butX;
old = !mPadDataOld[id].butX;
return(curr&&old);
case ControllerButtons.BUTY:
curr = mPadData[id].butY;
old = !mPadDataOld[id].butY;
return(curr&&old);
case ControllerButtons.BUTA:
curr = mPadData[id].butA;
old = !mPadDataOld[id].butA;
return(curr&&old);
case ControllerButtons.BUTB:
curr = mPadData[id].butB;
old = !mPadDataOld[id].butB;
return(curr&&old);
case ControllerButtons.UP:
curr = mPadData[id].up;
old = !mPadDataOld[id].up;
return((curr&&old)?true:false);
case ControllerButtons.DOWN:
curr = mPadData[id].down;
old = !mPadDataOld[id].down;
return(curr&&old);
case ControllerButtons.LEFT:
curr = mPadData[id].left;
old = !mPadDataOld[id].left;
return((curr&&old)?true:false);
case ControllerButtons.RIGHT:
curr = mPadData[id].right;
old = !mPadDataOld[id].right;
return(curr&&old);
case ControllerButtons.LEFTTOP:
curr = mPadData[id].leftTop;
old = !mPadDataOld[id].leftTop;
return(curr&&old);
case ControllerButtons.RIGHTTOP:
curr = mPadData[id].rightTop;
old = !mPadDataOld[id].rightTop;
return(curr&&old);
case ControllerButtons.PAUSE:
curr = mPadData[id].pause;
old = !mPadDataOld[id].pause;
return(curr&&old);
default:
break;
}
return false;
}
//============================================================================================
// detects is a button is down on any controller, e.g. for a single player game that has
// several controllers attached, this lets you treat them all as the same controller
//============================================================================================
public bool isPressed(ControllerButtons b)
{
for(int i=0; i<mActivePadCount; i++) //iterate through attached controllers and output data
{
if(isPressed(i,b))
return true;
}
return false;
}
