/* method to generate the controls packet sent to the Central Program */
private String gamepad_packet_generator(GamepadReading input, long packetNumber)
{
String packetMeta = "CNTR|" + packetNumber.ToString() + "|" + input.Timestamp + "|";
String packetEnd = "END|";
String buttonString;
String[] parsedButtons = null;
String returnString = "";
buttonString = input.Buttons.ToString();
parsedButtons = buttonString.Split(new char[] { ',' });
foreach (String s in parsedButtons)
{
returnString += s.Trim() + "|";
}
if (input.RightTrigger >= 0.0)
{
returnString += getRightTrigger(input, parsedButtons, "RightTrigger,");
}
if (input.LeftTrigger >= 0.0)
{
returnString += getLeftTrigger(input, parsedButtons, "LeftTrigger,");
}
returnString += getServos(input.RightThumbstickX, input.RightThumbstickY);
returnString += getRStick("LeftThumbstickX", input.LeftThumbstickX);
returnString += getRStick("LeftThumbstickY", input.LeftThumbstickY);
return(packetMeta + returnString + packetEnd);
}
public CarMoveCommand(GamepadReading gamepadReading)
{
var deadzone = 0.25;
var leftThumbstickX = gamepadReading.LeftThumbstickX;
if ((leftThumbstickX > 0 && leftThumbstickX <= deadzone) ||
(leftThumbstickX < 0 && leftThumbstickX >= (deadzone * -1)))
{
leftThumbstickX = 0.0;
}
var rightTrigger = gamepadReading.RightTrigger <= deadzone ? 0.0 : gamepadReading.RightTrigger;
var leftTrigger = gamepadReading.LeftTrigger <= deadzone ? 0.0 : gamepadReading.LeftTrigger;
var rightLeftTrigger = (rightTrigger > 0.0) && (leftTrigger > 0.0);
if (!rightLeftTrigger &&
rightTrigger > 0.0)
{
Speed = rightTrigger;
ForwardBackward = true;
}
else if (!rightLeftTrigger &&
leftTrigger > 0.0)
{
Speed = leftTrigger;
ForwardBackward = false;
}
else
{
Speed = 0.0;
ForwardBackward = true;
}
RightLeft = leftThumbstickX;
if (RightLeft <= -0.985)
{
LeftCircle = true;
}
else if (RightLeft >= 0.985)
{
RightCircle = true;
}
if (RightLeft != 0.0 && Speed == 0.0)
{
if (RightLeft < 0)
{
LeftCircle = true;
Speed = 1;
}
else if (RightLeft > 0)
{
RightCircle = true;
Speed = 1;
}
}
}
/// <summary>
/// Reads gamepad input.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void GamePad_Tick(object sender, Object e)
{
reading = mainGamepad.GetCurrentReading();
if (currentGameState == GameState.InGame)
{
if (reading.Buttons == GamepadButtons.DPadUp && Snake[0].Direction != MovementDirection.Down)
{
Snake[0].Direction = MovementDirection.Up;
}
else if (reading.Buttons == GamepadButtons.DPadDown && Snake[0].Direction != MovementDirection.Up)
{
Snake[0].Direction = MovementDirection.Down;
}
else if (reading.Buttons == GamepadButtons.DPadLeft && Snake[0].Direction != MovementDirection.Right)
{
Snake[0].Direction = MovementDirection.Left;
}
else if (reading.Buttons == GamepadButtons.DPadRight && Snake[0].Direction != MovementDirection.Left)
{
Snake[0].Direction = MovementDirection.Right;
}
}
if (reading.Buttons == GamepadButtons.Menu)
{
currentGameState = (currentGameState == GameState.Paused) ? GameState.InGame : GameState.Paused;
}
}
/// <summary>
/// Querries all current input states.
/// </summary>
public IEnumerable <InputStateBase> GetInputStates()
{
for (int loop = 0; loop < MAX_GAMEPAD_COUNT; loop++)
{
Gamepad actGamepad = m_gamepads[loop];
bool isConnected = actGamepad != null;
// Handle connected state
if (!isConnected)
{
m_states[loop].NotifyConnected(false);
continue;
}
m_states[loop].NotifyConnected(true);
GamepadReading gpReading = actGamepad.GetCurrentReading();
m_states[loop].NotifyState(new GamepadReportedState()
{
Buttons = (GamepadButton)gpReading.Buttons,
LeftThumbstickX = (float)gpReading.LeftThumbstickX,
LeftThumbstickY = (float)gpReading.LeftThumbstickY,
LeftTrigger = (float)gpReading.LeftTrigger,
RightThumbstickX = (float)gpReading.RightThumbstickX,
RightThumbstickY = (float)gpReading.RightThumbstickY,
RightTrigger = (float)gpReading.RightTrigger
});
}
// Now return all input states
for (int loop = 0; loop < m_states.Length; loop++)
{
yield return(m_states[loop]);
}
}
public void ReadGamePadInput()
{
if (gamepad != null)
{
GamepadReading reading = gamepad.GetCurrentReading();
if (reading.Buttons != GamepadButtons.None)
{
if (buttonMapping.ContainsKey(reading.Buttons))
{
OnUserInputReceived(buttonMapping[reading.Buttons]);
}
}
else
{
// Use 0.4 so the stick don't have to be exactly to right or left, but is more forgiving
if (reading.RightThumbstickX < -0.6)
{
OnUserInputReceived(UserInput.MoveLeft);
}
else if (reading.RightThumbstickX > 0.6)
{
OnUserInputReceived(UserInput.MoveRight);
}
else if (reading.RightThumbstickY > 0.6)
{
OnUserInputReceived(UserInput.MoveUp);
}
else if (reading.RightThumbstickY < -0.6)
{
OnUserInputReceived(UserInput.MoveDown);
}
}
}
}
public CarControlCommand(GamepadReading gamepadReading)
{
var directionControlUpDownStepMaxSpeed = 6;
var deadzone = 0.25;
var leftThumbstickY = gamepadReading.LeftThumbstickY;
if ((leftThumbstickY > 0 && leftThumbstickY <= deadzone) ||
(leftThumbstickY < 0 && leftThumbstickY >= (deadzone * -1)))
{
leftThumbstickY = 0.0;
}
var directionControlUpDown = leftThumbstickY;
if (directionControlUpDown > 0)
{
DirectionControlUp = true;
}
else if (directionControlUpDown < 0)
{
DirectionControlDown = true;
}
DirectionControlUpDownStepSpeed = (ushort)Math.Round(Math.Abs(directionControlUpDown) * directionControlUpDownStepMaxSpeed, 1);
}
public void GamepadTimerEvent(object sender, object e)
{
if (myGamepads.Count() > PlayerNum - 1 && myGamepads.Count() > 0)
{
Gamepad gamepad = myGamepads[PlayerNum - 1];
GamepadReading reading = gamepad.GetCurrentReading();
textBlockButtons.Text = reading.Buttons.ToString();
if (!gp_lastreading.Equals(reading))
{
if ((reading.Buttons == GamepadButtons.A) && (gp_lastreading.Buttons != GamepadButtons.A))
{
ButtonAnswerClick(buttonA, null);
}
if ((reading.Buttons == GamepadButtons.B) && (gp_lastreading.Buttons != GamepadButtons.B))
{
ButtonAnswerClick(buttonB, null);
}
if ((reading.Buttons == GamepadButtons.X) && (gp_lastreading.Buttons != GamepadButtons.X))
{
ButtonAnswerClick(buttonX, null);
}
if ((reading.Buttons == GamepadButtons.Y) && (gp_lastreading.Buttons != GamepadButtons.Y))
{
ButtonAnswerClick(buttonY, null);
}
gp_lastreading = reading;
}
}
}
/// <summary>
/// Prints the gamepad readings to the UI
/// </summary>
/// <param name="reading">The reading.</param>
private void WriteGamepadReadings(GamepadReading reading)
{
var propertyStringBuilder = new StringBuilder();
var valueStringBuilder = new StringBuilder();
valueStringBuilder.AppendLine(this.gamepad.CurrentSlotId.ToString());
propertyStringBuilder.AppendLine(string.Format("Slot:"));
valueStringBuilder.AppendLine(reading.Buttons.ToString());
propertyStringBuilder.AppendLine("Buttons:");
valueStringBuilder.AppendLine(reading.LeftTrigger.ToString());
propertyStringBuilder.AppendLine("LeftTrigger:");
valueStringBuilder.AppendLine(reading.RightTrigger.ToString());
propertyStringBuilder.AppendLine("RightTrigger:");
valueStringBuilder.AppendLine(reading.LeftThumbstickX.ToString());
propertyStringBuilder.AppendLine("LeftThumbstickX:");
valueStringBuilder.AppendLine(reading.LeftThumbstickY.ToString());
propertyStringBuilder.AppendLine("LeftThumbstickY:");
valueStringBuilder.AppendLine(reading.RightThumbstickX.ToString());
propertyStringBuilder.AppendLine("RightThumbstickX:");
valueStringBuilder.AppendLine(reading.RightThumbstickY.ToString());
propertyStringBuilder.AppendLine("RightThumbstickY:");
var task = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { measurementId.Text = propertyStringBuilder.ToString(); }).AsTask();
var task2 = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { measurementValue.Text = valueStringBuilder.ToString(); }).AsTask();
Task.WaitAll(task, task2);
}
/* Method for dealing with button actions of connected controller */
private async void gamepad_Controls()
{
Gamepad.GamepadAdded += gamepad_Added;
Gamepad.GamepadRemoved += gamepad_Removed;
long cntrCounter = 0;
while (true)
{
await Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, () =>
{
if (gamepad == null)
{
return;
}
String inputString;
GamepadReading input = gamepad.GetCurrentReading();
if (input.Equals(gamepadDelta))
{
return;
}
inputString = gamepad_packet_generator(input, cntrCounter);
writer.MeasureString(inputString);
writer.WriteString(inputString);
gamepadDelta = input;
});
try
{
await writer.StoreAsync();
}
catch (Exception exception)
{
switch (SocketError.GetStatus(exception.HResult))
{
case SocketErrorStatus.HostNotFound:
socket = null;
writer = null;
centralprogramStatusTextBlock.Text = "MULE Controls Status: Disconnected";
return;
default:
socket = null;
writer = null;
centralprogramStatusTextBlock.Text = "MULE Controls Status: Disconnected";
return;
}
}
await Task.Delay(TimeSpan.FromMilliseconds(100));
cntrCounter++;
}
}
// Update is called once per frame
void Update()
{
if (controller != null)
{
//oldButton = reading;
reading = controller.GetCurrentReading();
}
}
// Update is called once per frame
void Update()
{
if (!IsStarted)
{
return;
}
// Yボタン入力でフラグを管理
bool sideChange = false;
#if WINDOWS_UWP
reading =
ControlEventGetter.Instance.reading;
if (reading.Buttons.HasFlag(GamepadButtons.Y))
{
sideChange = true;
}
#else
if (Input.GetButtonDown("Attack_SideChange"))
{
sideChange = true;
}
#endif
if (sideChange)
{
isSideUnder = !isSideUnder;
}
// プレイヤー位置を取得、その場に実態生成
Vector3 playerPos = player.transform.position;
GameObject instPillar = Instantiate(pillar);
// スケールY値に変数の値を加算
instPillar.transform.localScale =
new Vector3(instPillar.transform.localScale.x,
pillarHeightParamt,
instPillar.transform.localScale.z);
// ポジション変更のための変数用意
float pillarPos = (pillarHeightParamt / 2);
if (isSideUnder)
{
// 下方向ならポジションをマイナスするため*=-1
pillarPos *= -1;
}
// 変数を加算した値にポジション変更
instPillar.transform.position = new Vector3(playerPos.x, playerPos.y + pillarPos, playerPos.z);
// どの方向に出されたかを子オブジェクトに持たせる
instPillar.transform.GetComponent <Pillar>().SetSideUnderFlag(isSideUnder);
// 親オブジェクトにthisオブジェクトを登録
instPillar.transform.SetParent(this.gameObject.transform);
// 死に時間設定
instPillar.GetComponent <KTB.AutoDestroy>().SetDestroyLimit(everyPillarLifeLimit);
// カメラの方向に向きを合わせるを向かせる
if (camera == null)
{
return;
}
instPillar.transform.eulerAngles += new Vector3(0, camera.transform.eulerAngles.y, 0);
// カメラの参照をPillarに！ by KTB
//instPillar.GetComponent<Pillar>().Camera = OpeningSceneManager.GetComponent<gami.OpeningCameraMover>().mainCamera;
}
/// <summary>
/// Prints the gamepad readings to the UI
/// </summary>
/// <param name="reading">The reading.</param>
private void WriteGamepadReadings(GamepadReading reading)
{
var propertyStringBuilder = new StringBuilder();
var valueStringBuilder = new StringBuilder();
valueStringBuilder.AppendLine(this.gamepad.CurrentSlotId.ToString());
propertyStringBuilder.AppendLine(string.Format("Slot:"));
valueStringBuilder.AppendLine(reading.Buttons.ToString());
propertyStringBuilder.AppendLine("Buttons:");
valueStringBuilder.AppendLine(reading.LeftTrigger.ToString());
propertyStringBuilder.AppendLine("LeftTrigger:");
valueStringBuilder.AppendLine(reading.RightTrigger.ToString());
propertyStringBuilder.AppendLine("RightTrigger:");
valueStringBuilder.AppendLine(reading.LeftThumbstickX.ToString());
propertyStringBuilder.AppendLine("LeftThumbstickX:");
valueStringBuilder.AppendLine(reading.LeftThumbstickY.ToString());
propertyStringBuilder.AppendLine("LeftThumbstickY:");
valueStringBuilder.AppendLine(reading.RightThumbstickX.ToString());
propertyStringBuilder.AppendLine("RightThumbstickX:");
valueStringBuilder.AppendLine(reading.RightThumbstickY.ToString());
propertyStringBuilder.AppendLine("RightThumbstickY:");
// Config values
EliteGamepadConfiguration config = this.gamepad.gamepad.GetConfiguration(this.gamepad.CurrentSlotId);
valueStringBuilder.AppendLine(config.LeftTrigger.Min.ToString());
propertyStringBuilder.AppendLine("LeftTriggerMin:");
valueStringBuilder.AppendLine(config.LeftTrigger.Max.ToString());
propertyStringBuilder.AppendLine("LeftTriggerMax:");
valueStringBuilder.AppendLine(config.RightTrigger.Min.ToString());
propertyStringBuilder.AppendLine("RightTriggerMin:");
valueStringBuilder.AppendLine(config.RightTrigger.Max.ToString());
propertyStringBuilder.AppendLine("RightTriggerMax:");
double value = normalizeTriggerValue(reading.LeftTrigger, config.LeftTrigger.Min / 10, config.LeftTrigger.Max / 10);
valueStringBuilder.AppendLine(value.ToString());
propertyStringBuilder.AppendLine("VibrationValueLeft");
value = normalizeTriggerValue(reading.RightTrigger, config.RightTrigger.Min / 10, config.RightTrigger.Max / 10);
valueStringBuilder.AppendLine(value.ToString());
propertyStringBuilder.AppendLine("VibrationValueRight");
var task = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { measurementId.Text = propertyStringBuilder.ToString(); }).AsTask();
var task2 = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { measurementValue.Text = valueStringBuilder.ToString(); }).AsTask();
Task.WaitAll(task, task2);
}
private void LeeMando()
{
if (myGamepads.Count != 0)
{
mainGamepad = myGamepads[0];
prereading = reading;
reading = mainGamepad.GetCurrentReading();
}
}
public bool GetState(TBXInputButton button, GamepadReading gamepadState)
{
switch (button)
{
case TBXInputButton.ButtonA:
return(GamepadButtons.A == (gamepadState.Buttons & GamepadButtons.A));
case TBXInputButton.ButtonB:
return(GamepadButtons.B == (gamepadState.Buttons & GamepadButtons.B));
case TBXInputButton.ButtonX:
return(GamepadButtons.X == (gamepadState.Buttons & GamepadButtons.X));
case TBXInputButton.ButtonY:
return(GamepadButtons.Y == (gamepadState.Buttons & GamepadButtons.Y));
case TBXInputButton.LeftStick:
return(GamepadButtons.LeftThumbstick == (gamepadState.Buttons & GamepadButtons.LeftThumbstick));
case TBXInputButton.RightStick:
return(GamepadButtons.RightThumbstick == (gamepadState.Buttons & GamepadButtons.RightThumbstick));
case TBXInputButton.DpadUp:
return(GamepadButtons.DPadUp == (gamepadState.Buttons & GamepadButtons.DPadUp));
case TBXInputButton.DpadRight:
return(GamepadButtons.DPadRight == (gamepadState.Buttons & GamepadButtons.DPadRight));
case TBXInputButton.DpadDown:
return(GamepadButtons.DPadDown == (gamepadState.Buttons & GamepadButtons.DPadDown));
case TBXInputButton.DpadLeft:
return(GamepadButtons.DPadLeft == (gamepadState.Buttons & GamepadButtons.DPadLeft));
case TBXInputButton.Back:
return(GamepadButtons.View == (gamepadState.Buttons & GamepadButtons.View));
case TBXInputButton.Start:
return(GamepadButtons.Menu == (gamepadState.Buttons & GamepadButtons.Menu));
case TBXInputButton.RightBumper:
return(GamepadButtons.RightShoulder == (gamepadState.Buttons & GamepadButtons.RightShoulder));
case TBXInputButton.LeftBumper:
return(GamepadButtons.LeftShoulder == (gamepadState.Buttons & GamepadButtons.LeftShoulder));
case TBXInputButton.LeftTrigger:
return(gamepadState.LeftTrigger > 0);
case TBXInputButton.RightTrigger:
return(gamepadState.RightTrigger > 0);
default:
TBLogging.LogWarning("Could not find requested Windows Input type.");
return(false);
}
}
public GamepadButtonDownResult UpdateGamepadButtonState(GamepadReading gamepadReading, List <GamepadButtons> gamepadButtonsPreventClickable)
{
var clickable = true;
if (gamepadButtonsPreventClickable != null)
{
foreach (var button in gamepadButtonsPreventClickable)
{
clickable = (gamepadReading.Buttons & _gamepadButtonOne) == _gamepadButtonOne;
if (!clickable)
{
break;
}
}
}
var gamepadButtonDownResult = new GamepadButtonDownResult();
var buttonDown = false;
if (!_gamepadButtonTwo.HasValue)
{
buttonDown = (gamepadReading.Buttons & _gamepadButtonOne) == _gamepadButtonOne;
}
else
{
buttonDown = (gamepadReading.Buttons & (_gamepadButtonOne | _gamepadButtonTwo.Value)) == (_gamepadButtonOne | _gamepadButtonTwo.Value);
}
gamepadButtonDownResult.ButtonDown = buttonDown;
if (!buttonDown && _buttonDownCalled)
{
_buttonDownCalled = false;
}
if (buttonDown &&
!_buttonDownCalled &&
!_buttonDownCalledTime.HasValue &&
clickable)
{
_buttonDownCalledTime = DateTime.Now;
}
else if (_buttonDownCalledTime.HasValue &&
DateTime.Now >= _buttonDownCalledTime.Value.Add(_buttonDownTime) &&
!_buttonDownCalled)
{
gamepadButtonDownResult.ButtonClicked = true;
_buttonDownCalled = true;
_buttonDownCalledTime = null;
}
return(gamepadButtonDownResult);
}
private String getLeftTrigger(GamepadReading input, String[] parsedButtons, String label)
{
foreach (String s in parsedButtons)
{
if (s.Trim().Equals("LeftShoulder"))
{
return("");
}
}
return(label + input.LeftTrigger.ToString() + "|");
}
private async void gamepad_Added(object sender, Gamepad e)
{
gamepad = e;
gamepadDelta = e.GetCurrentReading();
await Dispatcher.RunAsync(
CoreDispatcherPriority.Normal, () =>
{
controllerStatusTextBlock.Text = "XBOX Controller Status: Connected";
});
}
private async Task GetPadInput()
{
GamepadReading pad = Gamepad.Gamepads.FirstOrDefault().GetCurrentReading();
right = pad.RightTrigger;
left = pad.LeftTrigger;
buttonPressed = pad.Buttons.ToString();
await Task.Delay(50);
}
public bool GetFireGamepad()
{
readyGamePad();
if (Gamepad.Gamepads.Count > 0)
{
GamepadReading reading = Gamepad.Gamepads[0].GetCurrentReading();
return(reading.Buttons == GamepadButtons.A);
}
return(manager.joyPad.FirePressed);
}
private string GetStateLog(GamepadReading reading)
{
var stateLog = $"Left Joystick: {reading.LeftThumbstickX.ToString()}, {reading.LeftThumbstickY}\n";
stateLog += $"Right Joystick: {reading.RightThumbstickX}, {reading.RightThumbstickY}\n";
stateLog += $"Left Trigger: {reading.LeftTrigger}\n";
stateLog += $"Right Trigger: {reading.RightTrigger}\n";
stateLog += $"Buttons: {reading.Buttons}";
return(stateLog);
}
private void GetControllers()
{
lock (this)
{
if (DriveController != null || ArmController != null)
{
return;
}
while (Gamepad.Gamepads.Count < 1)
{
;
}
Task.Delay(100).Wait();
Gamepad g1 = Gamepad.Gamepads[0];
if (Gamepad.Gamepads.Count > 1)
{
Gamepad g2 = Gamepad.Gamepads[1];
while (true)
{
GamepadReading r1 = g1.GetCurrentReading();
GamepadReading r2 = g2.GetCurrentReading();
Debug.WriteLine($"{r1.Buttons}, {r2.Buttons}");
if (r1.Buttons != 0)
{
ArmController = g2;
DriveController = g1;
break;
}
else if (r2.Buttons != 0)
{
ArmController = g1;
DriveController = g2;
break;
}
}
}
else
{
ArmController = g1;
for (int i = 0; i < 200; i++)
{
if (g1.GetCurrentReading().Buttons != 0)
{
ArmController = null;
DriveController = g1;
break;
}
Task.Delay(10).Wait();
}
}
}
}
private void DoArm()
{
if (ArmController != null)
{
GamepadReading reading = ArmController.GetCurrentReading();
if (reading.LeftThumbstickX == 0 &&
reading.LeftThumbstickY == 0 &&
reading.RightThumbstickX == 0 &&
reading.RightThumbstickY == 0)
{
return;
}
double fArmUpper = ((-reading.RightThumbstickY + 1) / 2) * 500 + 70;
if (fArmUpper > 255)
{
fArmUpper = 255;
}
double fArmLower = ((-reading.RightThumbstickX + 1) / 2) * 650 - 70;
if (fArmLower > 255)
{
fArmLower = 255;
}
double fPan = ((reading.LeftThumbstickY + 1) / 2) * 400;
if (fPan > 255)
{
fPan = 255;
}
double fPitch = ((reading.LeftThumbstickX + 1) / 2) * 400 + 15;
if (fPitch > 255)
{
fPitch = 255;
}
byte ArmUpper = (byte)fArmUpper;
byte ArmLower = (byte)fArmLower;
byte Pan = (byte)fPan;
byte Pitch = (byte)fPitch;
//Debug.WriteLine($"{actuator}");
//Debug.WriteLine($"{Pan}");
//Debug.WriteLine($"{reading.LeftThumbstickX}, {reading.LeftThumbstickY}, {reading.RightThumbstickX}, {reading.RightThumbstickY}, {reading.RightTrigger}, {reading.LeftTrigger}");
packet[(int)PacketIndex.ArmLower] = ArmLower;
packet[(int)PacketIndex.ArmUpper] = ArmUpper;
packet[(int)PacketIndex.ClawPan] = Pan;
packet[(int)PacketIndex.ClawPitch] = Pitch;
//Debug.WriteLine($"{ArmLower} {ArmUpper}");
//Debug.WriteLine($"{Pitch}");
}
else
{
// Do nothing to arm
}
}
private void LeeMando()
{
//No hay GamePads en la lista, no añade ninguno
if (myGamepads.Count != 0)
{
//Selecciona el principal como el primero de la lista
mainGamepad = myGamepads[0];
prereading = reading;
//Prerading es el reading anterior. Al principio es NULL
reading = mainGamepad.GetCurrentReading();
}
}
private static bool GetGamepadButtonState(GamepadReading reading, InputTypes button)
{
if (!LibretroGamepadToWindowsGamepadButtonMapping.ContainsKey(button))
{
return(false);
}
var nativeButton = LibretroGamepadToWindowsGamepadButtonMapping[button];
var output = (reading.Buttons & nativeButton) == nativeButton;
return(output);
}
/// <summary>
/// Whether gamepad processing should be skipped due to the current and previous reading being the same.
/// </summary>
/// <param name="reading">The reading.</param>
/// <returns>True if the reading is new and should be processed; otherwise, false.</returns>
private bool ShouldSkipGamepadProcessing(GamepadReading reading)
{
var newTimestamp = reading.Timestamp;
if (this.lastTimestamp == reading.Timestamp)
{
return(true);
}
this.lastTimestamp = newTimestamp;
return(false);
}
private async Task GetTCodeFromGamepadreading()
{
await Task.Run(() =>
{
while (IsRunning)
{
if (_selectedGamePad == null)
{
Dispose();
return;
}
_tcodeFactory.Init();
GamepadReading reading = _selectedGamePad.GetCurrentReading();
var axisValues = new HashSet<ChannelValueModel>();
_tcodeFactory.Calculate(GamepadAxisNames.LeftXAxis, CalculateDeadZone(reading.LeftThumbstickX), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.LeftYAxis, CalculateDeadZone(reading.LeftThumbstickY), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.RightXAxis, CalculateDeadZone(reading.RightThumbstickX), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.RightYAxis, CalculateDeadZone(reading.RightThumbstickY), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.RightTrigger, reading.RightTrigger, axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.LeftTrigger, reading.LeftTrigger, axisValues);
// Binary inputs
_tcodeFactory.Calculate(GamepadAxisNames.A, GamepadButtons.A == (reading.Buttons & GamepadButtons.A), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.B, GamepadButtons.B == (reading.Buttons & GamepadButtons.B), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.X, GamepadButtons.X == (reading.Buttons & GamepadButtons.X), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.Y, GamepadButtons.Y == (reading.Buttons & GamepadButtons.Y), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.RightBumper, GamepadButtons.RightShoulder == (reading.Buttons & GamepadButtons.RightShoulder), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.LeftBumper, GamepadButtons.LeftShoulder == (reading.Buttons & GamepadButtons.LeftShoulder), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.Start, GamepadButtons.View == (reading.Buttons & GamepadButtons.View), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.Select, GamepadButtons.Menu == (reading.Buttons & GamepadButtons.Menu), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.DPadUp, GamepadButtons.DPadUp == (reading.Buttons & GamepadButtons.DPadUp), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.DPadDown, GamepadButtons.DPadDown == (reading.Buttons & GamepadButtons.DPadDown), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.DPadLeft, GamepadButtons.DPadLeft == (reading.Buttons & GamepadButtons.DPadLeft), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.DPadRight, GamepadButtons.DPadRight == (reading.Buttons & GamepadButtons.DPadRight), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.RightAxisButton, GamepadButtons.RightThumbstick == (reading.Buttons & GamepadButtons.RightThumbstick), axisValues);
_tcodeFactory.Calculate(GamepadAxisNames.LeftAxisButton, GamepadButtons.LeftThumbstick == (reading.Buttons & GamepadButtons.LeftThumbstick), axisValues);
EventHandler<DataReceivedEventArgs> handler = DataRecieved;
if (handler != null)
{
var eventArgs = new DataReceivedEventArgs();
if (_device.GetType() == typeof(TcpHandler) || _device.GetType() == typeof(UdpHandler))
{
eventArgs.GamepadData = axisValues;
}
else
{
eventArgs.Data = _tcodeFactory.FormatTCode(axisValues);
}
handler(this, eventArgs);
}
}
});
}
private string GamePadReadingToString(GamepadReading reading)
{
return(string.Format("LeftStickX={0}\n" +
"LeftstickY={1}\n" +
"LeftTrigger={2}\n" +
"RightStickX={3}\n" +
"RightStickY={4}\n" +
"RightTrigger={5}\n" +
"Buttons={6}\n\n",
reading.LeftThumbstickX, reading.LeftThumbstickY, reading.LeftTrigger,
reading.RightThumbstickX, reading.RightThumbstickY, reading.RightTrigger,
reading.Buttons));
}
void Update()
{
#if WINDOWS_UWP
oldButton = reading;
reading = ControlEventGetter.Instance.reading;
#endif
//Debug.Log("circleRadius : " + Mathf.Sqrt((this.transform.position.x-mainCamera.transform.position.x)* (this.transform.position.x - mainCamera.transform.position.x)+ (this.transform.position.z - mainCamera.transform.position.z)* (this.transform.position.z - mainCamera.transform.position.z)));
ControllerEvent();
AccelAction();
// 移動
TransformPos();
//mainCamera.transform.LookAt(this.transform);
}
private void LeeMando()
{
if (myGamepads.Count != 0)
{
mainGamepad = myGamepads[0];
prereading = reading;
reading = mainGamepad.GetCurrentReading();
//Muestra en IU
GamePadLog.Text = "Botones: " + reading.Buttons.ToString() + "\n"
+ " @@@ " + reading.RightThumbstickX.ToString()
+ " , " + reading.LeftThumbstickX.ToString();
}
}
void Update()
{
#if WINDOWS_UWP
oldButton = reading;
reading = ControlEventGetter.Instance.reading;
#endif
if (!IsAutoPilot)
{
ControllerEvent();
GearAutoAccelAction();
// 今現在向いている方向に進む
this.transform.Translate(new Vector3(0, 0, speed));
}
}
void HandleInputReportRecieved(HidDevice sender, HidInputReportReceivedEventArgs args)
=> _currentReading = args.Report.ToGamepadReading();
/// <summary>
/// Whether gamepad processing should be skipped due to the current and previous reading being the same.
/// </summary>
/// <param name="reading">The reading.</param>
/// <returns>True if the reading is new and should be processed; otherwise, false.</returns>
private bool ShouldSkipGamepadProcessing(GamepadReading reading)
{
var newTimestamp = reading.Timestamp;
if (this.lastTimestamp == reading.Timestamp)
{
return true;
}
this.lastTimestamp = newTimestamp;
return false;
}
/// <summary>
/// Processes the gamepad readings for sending the assigned key.
/// </summary>
/// <param name="reading">The reading.</param>
private void ProcessGamepadReadings(GamepadReading reading)
{
var values = (GamepadButtons[])Enum.GetValues(typeof(GamepadButtons));
var tasks = new HashSet<Task>();
foreach (var value in values.Where(v => (reading.Buttons & v) != 0))
{
VirtualKey key;
if (this.assignedButtons.TryGetValue(value, out key) && !this.buttonsDown.Contains(value))
{
this.buttonsDown.Add(value);
this.SendKeyDown(key);
}
switch (reading.Buttons & value)
{
case GamepadButtons.Aux1:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux1_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x10, 0x7C, 0x10)); }).AsTask());
break;
case GamepadButtons.Aux2:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux2_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x10, 0x7C, 0x10)); }).AsTask());
break;
case GamepadButtons.Aux3:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux3_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x10, 0x7C, 0x10)); }).AsTask());
break;
case GamepadButtons.Aux4:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux4_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x10, 0x7C, 0x10)); }).AsTask());
break;
default:
break;
}
}
foreach (var value in values.Where(v => (reading.Buttons & v) == 0))
{
if (this.buttonsDown.Contains(value))
{
VirtualKey key;
if (this.assignedButtons.TryGetValue(value, out key))
{
this.buttonsDown.Add(value);
this.SendKeyUp(key);
}
this.buttonsDown.Remove(value);
}
if (this.buttonsDown.Contains(value))
{
this.buttonsDown.Remove(value);
}
switch (value)
{
case GamepadButtons.Aux1:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux1_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x3A, 0x3A, 0x3A)); }).AsTask());
break;
case GamepadButtons.Aux2:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux2_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x3A, 0x3A, 0x3A)); }).AsTask());
break;
case GamepadButtons.Aux3:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux3_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x3A, 0x3A, 0x3A)); }).AsTask());
break;
case GamepadButtons.Aux4:
tasks.Add(Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { aux4_identifier.BorderBrush = new SolidColorBrush(Color.FromArgb(0xFF, 0x3A, 0x3A, 0x3A)); }).AsTask());
break;
default:
break;
}
}
// Wait for UI to update
Task.WaitAll(tasks.ToArray<Task>());
}
/// <summary>
/// Prints the gamepad readings to the UI
/// </summary>
/// <param name="reading">The reading.</param>
private void WriteGamepadReadings(GamepadReading reading)
{
var propertyStringBuilder = new StringBuilder();
var valueStringBuilder = new StringBuilder();
valueStringBuilder.AppendLine(this.gamepad.CurrentSlotId.ToString());
propertyStringBuilder.AppendLine(string.Format("Slot:"));
valueStringBuilder.AppendLine(reading.Buttons.ToString());
propertyStringBuilder.AppendLine("Buttons:");
valueStringBuilder.AppendLine(reading.LeftTrigger.ToString());
propertyStringBuilder.AppendLine("LeftTrigger:");
valueStringBuilder.AppendLine(reading.RightTrigger.ToString());
propertyStringBuilder.AppendLine("RightTrigger:");
valueStringBuilder.AppendLine(reading.LeftThumbstickX.ToString());
propertyStringBuilder.AppendLine("LeftThumbstickX:");
valueStringBuilder.AppendLine(reading.LeftThumbstickY.ToString());
propertyStringBuilder.AppendLine("LeftThumbstickY:");
valueStringBuilder.AppendLine(reading.RightThumbstickX.ToString());
propertyStringBuilder.AppendLine("RightThumbstickX:");
valueStringBuilder.AppendLine(reading.RightThumbstickY.ToString());
propertyStringBuilder.AppendLine("RightThumbstickY:");
var task = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { measurementId.Text = propertyStringBuilder.ToString(); }).AsTask();
var task2 = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { measurementValue.Text = valueStringBuilder.ToString(); }).AsTask();
Task.WaitAll(task, task2);
}
