public void Update(PlayerButton input, Facing facing, Boolean paused)
{
m_inputbuffer.Add(input, facing);
if (paused == false)
{
foreach (BufferCount count in m_commandcount.Values) count.Tick();
}
foreach (Command command in Commands)
{
if (command.IsValid == false) continue;
if (CommandChecker.Check(command, m_inputbuffer) == true)
{
Int32 time = command.BufferTime;
if (paused == true) ++time;
m_commandcount[command.Name].Set(time);
}
}
m_activecommands.Clear();
foreach (var data in m_commandcount) if (data.Value.IsActive == true) m_activecommands.Add(data.Key);
}
public void Add(PlayerButton input, Facing facing)
{
if (facing == Facing.Left)
{
if (((input & PlayerButton.Left) == PlayerButton.Left) != ((input & PlayerButton.Right) == PlayerButton.Right))
{
input ^= PlayerButton.Left;
input ^= PlayerButton.Right;
}
}
if (((input & PlayerButton.Up) == PlayerButton.Up) && ((input & PlayerButton.Down) == PlayerButton.Down))
{
input &= ~PlayerButton.Up;
input &= ~PlayerButton.Down;
}
if (((input & PlayerButton.Left) == PlayerButton.Left) && ((input & PlayerButton.Right) == PlayerButton.Right))
{
input &= ~PlayerButton.Left;
input &= ~PlayerButton.Right;
}
m_buffer.Add(input);
m_size = m_buffer.Size;
}
public void Add(PlayerButton button, Action<Boolean> callback)
{
if (button == PlayerButton.None) throw new ArgumentOutOfRangeException("button");
if (callback == null) throw new ArgumentNullException("callback");
m_callbackmap[(Int32)button] = callback;
}
public RecordingData(Int32 system, Int32 player1, Int32 player2, Int32 player3, Int32 player4)
{
SystemInput = (SystemButton)system;
Player1Input = (PlayerButton)player1;
Player2Input = (PlayerButton)player2;
Player3Input = (PlayerButton)player3;
Player4Input = (PlayerButton)player4;
}
public override void RecieveInput(PlayerButton button, Boolean pressed)
{
base.RecieveInput(button, pressed);
foreach (Entity entity in Engine.Entities)
{
Helper helper = entity as Helper;
if (helper == null || helper.BasePlayer != this) continue;
helper.RecieveInput(button, pressed);
}
}
public void Call(PlayerButton button, Boolean pressed)
{
if (button == PlayerButton.None) throw new ArgumentOutOfRangeException("button");
if (m_callback != null)
{
m_callback(button, pressed);
}
else
{
Action<Boolean> callback;
if (m_callbackmap.TryGetValue((Int32)button, out callback) == true) callback(pressed);
}
}
public override void RecieveInput(PlayerButton button, Boolean pressed)
{
base.RecieveInput(button, pressed);
foreach (Entity entity in Engine.Entities)
{
Helper helper = entity as Helper;
if (helper == null || helper.BasePlayer != this)
{
continue;
}
helper.RecieveInput(button, pressed);
}
}
private GameObject getTargetCell(PlayerButton playerButton)
{
GameObject tmpCell;
int currentCellId = playerButton.cellNum;
if (cellsWithLeather.Contains(currentCellId + 1) || currentCellId == 0 || currentCellId == 1)
{
tmpCell = cellPath[currentCellId + 2];
}
else
{
tmpCell = cellPath[currentCellId + 1];
}
return(tmpCell);
}
private void TogglePage(int page, bool show)
{
IntVector2 range = pages[page];
for (int i = range.x; i < range.y; i++)
{
PlayerButton btn = buttons[i];
if (show)
{
btn.Show();
}
else
{
btn.Hide();
}
}
}
internal bool ButtonDown(PlayerButton button)
{
switch (button)
{
case PlayerButton.Attack:
return(attackPressed);
case PlayerButton.SpecialAttack:
return(specialAttackPressed);
case PlayerButton.Jump:
return(jumpPressed);
default:
return(false);
}
}
public void SetInput(Input.InputState inputstate)
{
if (inputstate == null)
{
throw new ArgumentNullException("inputstate");
}
foreach (PlayerButton button in Enum.GetValues(typeof(PlayerButton)))
{
PlayerButton b = button;
inputstate[1].Add(b, x => Team1.MainPlayer.RecieveInput(b, x));
inputstate[2].Add(b, x => Team2.MainPlayer.RecieveInput(b, x));
}
inputstate[0].Add(SystemButton.FullLifeAndPower, RestoreLifeAndPower);
inputstate[0].Add(SystemButton.TestCheat, Tester);
}
public void Call(PlayerButton button, bool pressed)
{
if (button == PlayerButton.None)
{
throw new ArgumentOutOfRangeException(nameof(button));
}
if (m_callback != null)
{
m_callback(button, pressed);
}
else
{
Action <bool> callback;
if (m_callbackmap.TryGetValue((int)button, out callback))
{
callback(pressed);
}
}
}
public void Call(PlayerButton button, Boolean pressed)
{
if (button == PlayerButton.None)
{
throw new ArgumentOutOfRangeException("button");
}
if (m_callback != null)
{
m_callback(button, pressed);
}
else
{
Action <Boolean> callback;
if (m_callbackmap.TryGetValue((Int32)button, out callback) == true)
{
callback(pressed);
}
}
}
public ButtonState GetButton(PlayerButton button)
{
string buttonName = button.ToString();
if (Input.GetButtonDown(buttonName))
{
return(ButtonState.Down);
}
if (Input.GetButtonUp(buttonName))
{
return(ButtonState.Up);
}
if (Input.GetButton(buttonName))
{
return(ButtonState.Hold);
}
return(ButtonState.None);
}
public static bool isButtonDown(PlayerButton button)
{
if (game_controllers_locked)
{
return(isButtonDownConfirm(button, current_game_pad));
}
else
{
for (int i = 0; i < game_pad_state.Length; i++)
{
button_pushed = isButtonDownConfirm(button, i);
if (button_pushed)
{
Console.WriteLine("Button was pushed: " + button_pushed);
return(true);
}
}
return(false);
}
}
public void DeleteNPC()
{
if (activeNPC != null)
{
PlayerButton _button = activeNPC.button;
//This (probablly?) creates garbage
activeNPC = null;
foreach (DamageSquare square in dmgSquares)
{
square.ClearSpots();
}
bleedingSquare.ClearSpots();
Destroy(_button.gameObject);
ToggleAreYouSurePanel(false);
}
}
public void Update(PlayerButton input, Facing facing, bool paused)
{
m_inputbuffer.Add(input, facing);
if (paused == false)
{
foreach (var count in m_commandcount.Values)
{
count.Tick();
}
}
foreach (var command in Commands)
{
if (command.IsValid == false)
{
continue;
}
if (CommandChecker.Check(command, m_inputbuffer))
{
var time = command.BufferTime;
if (paused)
{
++time;
}
m_commandcount[command.Name].Set(time);
}
}
m_activecommands.Clear();
foreach (var data in m_commandcount)
{
if (data.Value.IsActive)
{
m_activecommands.Add(data.Key);
}
}
}
public Boolean AreIdentical(Int32 start, Int32 end)
{
if (start < 0 || start >= Size)
{
throw new ArgumentOutOfRangeException("start");
}
if (end < 0 || end >= Size)
{
throw new ArgumentOutOfRangeException("end");
}
PlayerButton match = m_buffer.ReverseGet(start);
for (Int32 i = start + 1; i < end; ++i)
{
if (match != m_buffer.ReverseGet(i))
{
return(false);
}
}
return(true);
}
public IEnumerator SmoothMove(GameObject player, int cellCount)
{
int targetCellNum = player.GetComponent <PlayerButton>().cellNum + 1;
if (targetCellNum < 64)
{
PlayerButton playerButton = player.GetComponent <PlayerButton>();
playerButton.isMoving = true;
GameObject tmpCell = getTargetCell(playerButton);
float currTime = 0;
do
{
player.transform.position = Vector3.Lerp(player.transform.position, tmpCell.transform.position, currTime / playerSpeed);
currTime += Time.deltaTime;
yield return(null);
}while (currTime <= playerSpeed);
player.GetComponent <Transform>().SetParent(tmpCell.transform, true);
playerButton.cellNum = tmpCell.GetComponent <TimeFieldCellScript>().id;
if (cellsWithButtons.Contains(playerButton.cellNum))
{
int numberOfButtons = gameContoller.GetComponent <GameControl>().ActivePlayerGetButtonsFromField();
CreateButtonPopup(numberOfButtons, tmpCell);
}
if (finishCells.Contains(playerButton.cellNum))
{
gameContoller.GetComponent <GameControl>().ActivePlayerRichFinish();
}
if (cellCount > 1)
{
StartCoroutine(SmoothMove(player, cellCount - 1));
}
else
{
StartCoroutine(WaitAndDisableTimeFeild(timeBeforeDisable, player));
}
}
}
public void AddPlayer()
{
PlayerData data = new PlayerData();
players.Add(data);
data.playerName = "Player " + players.Count;
GameObject newButton = GameObject.Instantiate(prefab);
newButton.transform.SetParent(contentPanel);
PlayerButton playerButton = newButton.GetComponent <PlayerButton>();
playerButton.Setup(data, this);
//old stuff
//Player newPlayer = new Player();
//newPlayer.name = "Player " + players.Count;
//GameObject newButton = Instantiate(playerButton);
//newButton.transform.SetParent(removePlayerPanel.transform);
//newButton.GetComponent<Text>().text = newPlayer.name;
//players.Add(newPlayer);
//print(players.Count);
//print(newButton.GetComponent<Player>().name);
}
public void SetInput(Input.InputState inputstate)
{
if (inputstate == null)
{
throw new ArgumentNullException("inputstate");
}
foreach (PlayerButton button in Enum.GetValues(typeof(PlayerButton)))
{
PlayerButton buttonindex = button;
inputstate[1].Add(buttonindex, x => RecieveInput((Int32)buttonindex, 1, x));
inputstate[2].Add(buttonindex, x => RecieveInput((Int32)buttonindex, 2, x));
inputstate[3].Add(buttonindex, x => RecieveInput((Int32)buttonindex, 3, x));
inputstate[4].Add(buttonindex, x => RecieveInput((Int32)buttonindex, 4, x));
}
foreach (SystemButton button in Enum.GetValues(typeof(SystemButton)))
{
SystemButton buttonindex = button;
inputstate[0].Add(buttonindex, x => RecieveInput((Int32)buttonindex, 0, x));
}
}
/// <summary>
/// Remaps/Updates the Keyboard Axis/Button dictionaries with a new key
/// </summary>
/// <param name="buttonKey"></param>
/// <param name="key"></param>
/// <param name="player"></param>
public static void RemapKeyboardButton(PlayerButton button, KeyCode key, IInputPlayer player)
{
string buttonKey = button.ToString();
if (player == null)
{
return;
}
else
{
if (keyboardAxisDictList[player.PlayerIndex + 1].ContainsKey(buttonKey))
{
keyboardAxisDictList[player.PlayerIndex + 1][buttonKey] = key;
}
else if (keyboardButtonDictList[player.PlayerIndex + 1].ContainsKey(buttonKey))
{
keyboardButtonDictList[player.PlayerIndex + 1][buttonKey] = key;
}
else
{
Debug.InputLog("No keyboard dictionary contains the key: " + buttonKey, Debug.LogType.Warning);
}
}
}
public bool IsDown(PlayerButton button)
{
return((current & (InputState)(1u << (int)button)) != 0);
}
Boolean GetButtonState(PlayerButton inputelement, CommandElement commandelement)
{
return(((inputelement & commandelement.MatchHash1) == commandelement.MatchHash1) && ((inputelement & commandelement.MatchHash2) == 0));
}
Boolean GetButtonState(PlayerButton inputelement, CommandElement commandelement)
{
return ((inputelement & commandelement.MatchHash1) == commandelement.MatchHash1) && ((inputelement & commandelement.MatchHash2) == 0);
}
public bool GetButtonUp(PlayerButton button)
{
_state = GamePad.GetState(_index);
if (_scheme.IsGamepad)
{
switch (button)
{
case PlayerButton.A:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButtonUp(GamePad.Button.A, _index));
}
else
{
if (_wasAPressed)
{
if (!_state.Down)
{
_wasAPressed = false;
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
case PlayerButton.B:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButtonUp(GamePad.Button.B, _index));
}
else
{
if (_wasBPressed)
{
if (!_state.Right)
{
_wasBPressed = false;
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
case PlayerButton.X:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButtonUp(GamePad.Button.X, _index));
}
else
{
if (_wasXPressed)
{
if (!_state.Left)
{
_wasXPressed = false;
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
case PlayerButton.Y:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButtonUp(GamePad.Button.Y, _index));
}
else
{
if (_wasYPressed)
{
if (!_state.Up)
{
_wasYPressed = false;
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
default:
throw new ArgumentOutOfRangeException("button", button, null);
}
}
else
{
switch (button)
{
case PlayerButton.A:
return(Input.GetKeyUp(_scheme.ButtonA));
case PlayerButton.B:
return(Input.GetKeyUp(_scheme.ButtonB));
case PlayerButton.X:
return(Input.GetKeyUp(_scheme.ButtonX));
case PlayerButton.Y:
return(Input.GetKeyUp(_scheme.ButtonY));
default:
throw new ArgumentOutOfRangeException("button", button, null);
}
}
}
public virtual void RecieveInput(PlayerButton button, Boolean pressed)
{
if (pressed)
{
m_currentinput |= button;
}
else
{
m_currentinput &= ~button;
}
}
public ButtonState GetButton(PlayerButton button)
{
return(ButtonState.None);
}
/// <summary>
/// Initializes a new instance of this class for a player ButtonMap.
/// </summary>
/// <param name="buttonmap">The index of the ButtonMap.</param>
/// <param name="button">The PlayerButton to reference.</param>
public ButtonWrapper(int buttonmap, PlayerButton button)
{
MapIndex = buttonmap;
ButtonIndex = (int)button;
}
PlayerButton BuildHash2()
{
PlayerButton hash = 0;
switch (Direction)
{
case CommandDirection.B:
hash |= PlayerButton.Up;
hash |= PlayerButton.Down;
hash |= PlayerButton.Right;
break;
case CommandDirection.DB:
hash |= PlayerButton.Up;
hash |= PlayerButton.Right;
break;
case CommandDirection.D:
hash |= PlayerButton.Up;
hash |= PlayerButton.Left;
hash |= PlayerButton.Right;
break;
case CommandDirection.DF:
hash |= PlayerButton.Up;
hash |= PlayerButton.Left;
break;
case CommandDirection.F:
hash |= PlayerButton.Up;
hash |= PlayerButton.Down;
hash |= PlayerButton.Left;
break;
case CommandDirection.UF:
hash |= PlayerButton.Down;
hash |= PlayerButton.Left;
break;
case CommandDirection.U:
hash |= PlayerButton.Left;
hash |= PlayerButton.Down;
hash |= PlayerButton.Right;
break;
case CommandDirection.UB:
hash |= PlayerButton.Down;
hash |= PlayerButton.Right;
break;
case CommandDirection.B4Way:
case CommandDirection.U4Way:
case CommandDirection.F4Way:
case CommandDirection.D4Way:
case CommandDirection.None:
default:
break;
}
return(hash);
}
PlayerButton BuildHash1()
{
PlayerButton hash = 0;
switch (Direction)
{
case CommandDirection.B4Way:
case CommandDirection.B:
hash |= PlayerButton.Left;
break;
case CommandDirection.DB:
hash |= PlayerButton.Down;
hash |= PlayerButton.Left;
break;
case CommandDirection.D4Way:
case CommandDirection.D:
hash |= PlayerButton.Down;
break;
case CommandDirection.DF:
hash |= PlayerButton.Down;
hash |= PlayerButton.Right;
break;
case CommandDirection.F4Way:
case CommandDirection.F:
hash |= PlayerButton.Right;
break;
case CommandDirection.UF:
hash |= PlayerButton.Up;
hash |= PlayerButton.Right;
break;
case CommandDirection.U4Way:
case CommandDirection.U:
hash |= PlayerButton.Up;
break;
case CommandDirection.UB:
hash |= PlayerButton.Up;
hash |= PlayerButton.Left;
break;
case CommandDirection.None:
default:
break;
}
if ((Buttons & CommandButton.A) == CommandButton.A)
{
hash |= PlayerButton.A;
}
if ((Buttons & CommandButton.B) == CommandButton.B)
{
hash |= PlayerButton.B;
}
if ((Buttons & CommandButton.C) == CommandButton.C)
{
hash |= PlayerButton.C;
}
if ((Buttons & CommandButton.X) == CommandButton.X)
{
hash |= PlayerButton.X;
}
if ((Buttons & CommandButton.Y) == CommandButton.Y)
{
hash |= PlayerButton.Y;
}
if ((Buttons & CommandButton.Z) == CommandButton.Z)
{
hash |= PlayerButton.Z;
}
if ((Buttons & CommandButton.Taunt) == CommandButton.Taunt)
{
hash |= PlayerButton.Taunt;
}
return(hash);
}
/// <summary>
/// Initializes a new instance of this class for a player ButtonMap.
/// </summary>
/// <param name="buttonmap">The index of the ButtonMap.</param>
/// <param name="button">The PlayerButton to reference.</param>
public ButtonWrapper(Int32 buttonmap, PlayerButton button)
{
m_buttonmap = buttonmap;
m_button = (Int32)button;
}
private static bool isButtonDownConfirm(PlayerButton button, int control_number)
{
switch (button)
{
case PlayerButton.UpDirection:
if (game_pad_state[control_number].DPad.Up == ButtonState.Pressed || game_pad_state[control_number].ThumbSticks.Left.Y > 0.0 || key_board_state.IsKeyDown(Keys.Up))
{
return(true);
}
break;
case PlayerButton.DownDirection:
if (game_pad_state[control_number].DPad.Down == ButtonState.Pressed || game_pad_state[control_number].ThumbSticks.Left.Y < 0.0 || key_board_state.IsKeyDown(Keys.Down))
{
return(true);
}
break;
case PlayerButton.LeftDirection:
if (game_pad_state[control_number].DPad.Left == ButtonState.Pressed || game_pad_state[control_number].ThumbSticks.Left.X < 0.0 || key_board_state.IsKeyDown(Keys.Left))
{
return(true);
}
break;
case PlayerButton.RightDirection:
if (game_pad_state[control_number].DPad.Right == ButtonState.Pressed || game_pad_state[control_number].ThumbSticks.Left.X > 0.0 || key_board_state.IsKeyDown(Keys.Right))
{
return(true);
}
break;
case PlayerButton.Confirm:
if (game_pad_state[control_number].Buttons.A == ButtonState.Pressed || key_board_state.IsKeyDown(Keys.Enter))
{
return(true);
}
break;
case PlayerButton.Cancel:
if (game_pad_state[control_number].Buttons.B == ButtonState.Pressed || key_board_state.IsKeyDown(Keys.Escape) || key_board_state.IsKeyDown(Keys.Back))
{
return(true);
}
break;
case PlayerButton.UseItem1:
if (game_pad_state[control_number].Triggers.Left > 0.0 || key_board_state.IsKeyDown(Keys.A) || game_pad_state[control_number].Buttons.A == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.UseItem2:
if (game_pad_state[control_number].Triggers.Right > 0.0 || key_board_state.IsKeyDown(Keys.S) || game_pad_state[control_number].Buttons.B == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.SwitchItem1:
if (game_pad_state[control_number].Buttons.LeftShoulder == ButtonState.Pressed || key_board_state.IsKeyDown(Keys.Q) || game_pad_state[control_number].Buttons.X == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.SwitchItem2:
if (game_pad_state[control_number].Buttons.RightShoulder == ButtonState.Pressed || key_board_state.IsKeyDown(Keys.W) || game_pad_state[control_number].Buttons.Y == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.PauseButton:
if (game_pad_state[control_number].Buttons.Start == ButtonState.Pressed || key_board_state.IsKeyDown(Keys.Enter))
{
return(true);
}
break;
case PlayerButton.BackButton:
if (game_pad_state[control_number].Buttons.Back == ButtonState.Pressed || key_board_state.IsKeyDown(Keys.Back))
{
return(true);
}
break;
case PlayerButton.AnyButton:
if (game_pad_state[control_number].Buttons.A == ButtonState.Pressed || game_pad_state[control_number].Buttons.A == ButtonState.Pressed || game_pad_state[control_number].Buttons.B == ButtonState.Pressed || game_pad_state[control_number].Buttons.Y == ButtonState.Pressed || game_pad_state[control_number].Buttons.X == ButtonState.Pressed || game_pad_state[control_number].Buttons.Back == ButtonState.Pressed || game_pad_state[control_number].Buttons.Start == ButtonState.Pressed || game_pad_state[control_number].Buttons.RightShoulder == ButtonState.Pressed || game_pad_state[control_number].Buttons.LeftShoulder == ButtonState.Pressed || game_pad_state[control_number].Buttons.RightStick == ButtonState.Pressed || game_pad_state[control_number].Buttons.LeftStick == ButtonState.Pressed || key_board_state.IsKeyDown(Keys.Enter))
{
return(true);
}
break;
default:
return(false);
}
return(false);
}
public static void SetAction(string actionName, Buttons button, PlayerIndex playerIndex = PlayerIndex.One)
{
buttonDict[actionName] = new PlayerButton {
playerIndex = playerIndex, button = button
};
}
/// <summary>
/// Checks if a button is pressed for a specified Player.
/// </summary>
/// <param name="player">The assigned player index to check.</param>
/// <param name="button">The button to poll.</param>
/// <returns>True if the button for the player's device is pressed.</returns>
public static bool IsPlayerButtonDown(PPG_Player player, PlayerButton button)
{
if (bindings[(int)player] == PlayerPad.Keyboard)
{
switch (button)
{
case PlayerButton.Confirm:
if (keyboardController.IsKeyDown(keyConfig.Confirm))
{
return(true);
}
break;
case PlayerButton.Cancel:
if (keyboardController.IsKeyDown(keyConfig.Cancel))
{
return(true);
}
break;
case PlayerButton.PauseButton:
if (keyboardController.IsKeyDown(keyConfig.PauseButton))
{
return(true);
}
break;
case PlayerButton.BackButton:
if (keyboardController.IsKeyDown(keyConfig.BackButton))
{
return(true);
}
break;
case PlayerButton.UseItem2:
if (keyboardController.IsKeyDown(keyConfig.UseLeftItem))
{
return(true);
}
break;
case PlayerButton.UseItem1:
if (keyboardController.IsKeyDown(keyConfig.UseRightItem))
{
return(true);
}
break;
case PlayerButton.SwitchItem1:
if (keyboardController.IsKeyDown(keyConfig.SwitchItem1))
{
return(true);
}
break;
case PlayerButton.SwitchItem2:
if (keyboardController.IsKeyDown(keyConfig.SwitchItem2))
{
return(true);
}
break;
case PlayerButton.DownDirection:
if (keyboardController.IsKeyDown(keyConfig.DownDirection))
{
return(true);
}
break;
case PlayerButton.UpDirection:
if (keyboardController.IsKeyDown(keyConfig.UpDirection))
{
return(true);
}
break;
case PlayerButton.LeftDirection:
if (keyboardController.IsKeyDown(keyConfig.LeftDirection))
{
return(true);
}
break;
case PlayerButton.RightDirection:
if (keyboardController.IsKeyDown(keyConfig.RightDirection))
{
return(true);
}
break;
}
}
else if ((int)bindings[(int)player] > -1)
{
GamePadState state = xInputControllers[(int)bindings[(int)player]];
switch (button)
{
case PlayerButton.Confirm:
if (state.Buttons.A == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.Cancel:
if (state.Buttons.B == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.PauseButton:
if (state.Buttons.Start == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.BackButton:
if (state.Buttons.Back == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.UseItem2:
if (state.Buttons.A == ButtonState.Pressed || state.Triggers.Left > 0.01f)
{
return(true);
}
break;
case PlayerButton.UseItem1:
if (state.Buttons.B == ButtonState.Pressed || state.Triggers.Right > 0.01f)
{
return(true);
}
break;
case PlayerButton.SwitchItem1:
if (state.Buttons.X == ButtonState.Pressed || state.Buttons.RightShoulder == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.SwitchItem2:
if (state.Buttons.Y == ButtonState.Pressed || state.Buttons.LeftShoulder == ButtonState.Pressed)
{
return(true);
}
break;
case PlayerButton.DownDirection:
if (state.DPad.Down == ButtonState.Pressed || state.ThumbSticks.Left.Y < 0)
{
return(true);
}
break;
case PlayerButton.UpDirection:
if (state.DPad.Up == ButtonState.Pressed || state.ThumbSticks.Left.Y > 0)
{
return(true);
}
break;
case PlayerButton.LeftDirection:
if (state.DPad.Left == ButtonState.Pressed || state.ThumbSticks.Left.X < 0)
{
return(true);
}
break;
case PlayerButton.RightDirection:
if (state.DPad.Right == ButtonState.Pressed || state.ThumbSticks.Left.X > 0)
{
return(true);
}
break;
}
}
return(false);
}
/// <summary>
/// Polls the hardware for any input press. Useful for getting the player's controller index.
/// </summary>
/// <param name="button">The button you would like to poll.</param>
/// <returns>The PlayerPad corresponding with a connected input device that pressed the specified button. Will return PlayerPad.NoPad if no devices are pressing the specified button.</returns>
/// <remarks>If two input devices are pressing the same button simeltaneously, this method will return the device with the higher index. The keyboard's index is considered to be in between 1 and 2.</remarks>
public static PlayerPad IsAnyControllerButtonDown(PlayerButton button)
{
for (int i = 0; i < 4; i++)
{
GamePadState state = xInputControllers[i];
switch (button)
{
case PlayerButton.Confirm:
if (xInputControllers[i].Buttons.A == ButtonState.Pressed)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.Confirm))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.Cancel:
if (xInputControllers[i].Buttons.B == ButtonState.Pressed)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.Cancel))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.PauseButton:
if (xInputControllers[i].Buttons.Start == ButtonState.Pressed)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.PauseButton))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.BackButton:
if (xInputControllers[i].Buttons.Back == ButtonState.Pressed)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.BackButton))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.UseItem2:
if (xInputControllers[i].Buttons.A == ButtonState.Pressed || xInputControllers[i].Triggers.Left > 0.01f)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.UseLeftItem))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.UseItem1:
if (xInputControllers[i].Buttons.B == ButtonState.Pressed || xInputControllers[i].Triggers.Right > 0.01f)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.UseRightItem))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.SwitchItem1:
if (xInputControllers[i].Buttons.X == ButtonState.Pressed || xInputControllers[i].Buttons.RightShoulder == ButtonState.Pressed)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.SwitchItem1))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.SwitchItem2:
if (xInputControllers[i].Buttons.Y == ButtonState.Pressed || xInputControllers[i].Buttons.LeftShoulder == ButtonState.Pressed)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.SwitchItem2))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.DownDirection:
if (xInputControllers[i].DPad.Down == ButtonState.Pressed || xInputControllers[i].ThumbSticks.Left.Y < 0)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.DownDirection))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.UpDirection:
if (xInputControllers[i].DPad.Up == ButtonState.Pressed || xInputControllers[i].ThumbSticks.Left.Y > 0)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.UpDirection))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.LeftDirection:
if (xInputControllers[i].DPad.Left == ButtonState.Pressed || xInputControllers[i].ThumbSticks.Left.X < 0)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.LeftDirection))
{
return(PlayerPad.Keyboard);
}
break;
case PlayerButton.RightDirection:
if (xInputControllers[i].DPad.Right == ButtonState.Pressed || xInputControllers[i].ThumbSticks.Left.X > 0)
{
return(GamePadIndexToPlayerPad((PlayerIndex)i));
}
if (keyboardController.IsKeyDown(keyConfig.RightDirection))
{
return(PlayerPad.Keyboard);
}
break;
}
}
return(PlayerPad.NoPad);
}
public bool IsUp(PlayerButton button)
{
return(!IsDown(button));
}
public bool GetButton(PlayerButton button)
{
_state = GamePad.GetState(_index);
if (_scheme.IsGamepad)
{
switch (button)
{
case PlayerButton.A:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButton(GamePad.Button.A, _index));
}
else
{
return(_state.Down);
}
case PlayerButton.B:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButton(GamePad.Button.B, _index));
}
else
{
return(_state.Right);
}
case PlayerButton.X:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButton(GamePad.Button.X, _index));
}
else
{
return(_state.Left);
}
case PlayerButton.Y:
if (_scheme.IsRightPlayer)
{
return(GamePad.GetButton(GamePad.Button.Y, _index));
}
else
{
return(_state.Up);
}
default:
throw new ArgumentOutOfRangeException("button", button, null);
}
}
else
{
switch (button)
{
case PlayerButton.A:
return(Input.GetKey(_scheme.ButtonA));
case PlayerButton.B:
return(Input.GetKey(_scheme.ButtonB));
case PlayerButton.X:
return(Input.GetKey(_scheme.ButtonX));
case PlayerButton.Y:
return(Input.GetKey(_scheme.ButtonY));
default:
throw new ArgumentOutOfRangeException("button", button, null);
}
}
}
public override void RecieveInput(PlayerButton button, Boolean pressed)
{
if (Data.KeyControl == true)
{
base.RecieveInput(button, pressed);
}
}
public static bool isButtonDown(PlayerButton button)
{
for (int i = 0; i < padStates.Length; i++)
{
if (lockMostRecentPad && i != mostRecentPad)
{
continue;
}
switch (button)
{
case PlayerButton.UpDirection:
if (padStates[i].DPad.Up == ButtonState.Pressed || padStates[i].ThumbSticks.Left.Y > 0.01 || kbdState.IsKeyDown(Keys.Up))
{
return true;
}
break;
case PlayerButton.DownDirection:
if (padStates[i].DPad.Down == ButtonState.Pressed || padStates[i].ThumbSticks.Left.Y < -0.01 || kbdState.IsKeyDown(Keys.Down))
{
return true;
}
break;
case PlayerButton.LeftDirection:
if (padStates[i].DPad.Left == ButtonState.Pressed || padStates[i].ThumbSticks.Left.X < -0.01 || kbdState.IsKeyDown(Keys.Left))
{
return true;
}
break;
case PlayerButton.RightDirection:
if (padStates[i].DPad.Right == ButtonState.Pressed || padStates[i].ThumbSticks.Left.X > 0.01 || kbdState.IsKeyDown(Keys.Right))
{
return true;
}
break;
case PlayerButton.Push:
if (padStates[i].ThumbSticks.Right.Length() > 0.01f)
{
return true;
}
break;
case PlayerButton.Jump:
if (padStates[i].Buttons.RightShoulder == ButtonState.Pressed)
{
return true;
}
break;
case PlayerButton.Confirm:
if (padStates[i].Buttons.A == ButtonState.Pressed || kbdState.IsKeyDown(Keys.Enter))
{
return true;
}
break;
case PlayerButton.Cancel:
if (padStates[i].Buttons.B == ButtonState.Pressed || kbdState.IsKeyDown(Keys.Back))
{
return true;
}
break;
case PlayerButton.StartButton:
if (padStates[i].Buttons.Start == ButtonState.Pressed || kbdState.IsKeyDown(Keys.Escape))
{
return true;
}
break;
case PlayerButton.XButton:
if (padStates[i].Buttons.X == ButtonState.Pressed)
{
return true;
}
break;
case PlayerButton.YButton:
if (padStates[i].Buttons.Y == ButtonState.Pressed)
{
return true;
}
break;
case PlayerButton.LBumper:
if (padStates[i].Buttons.LeftShoulder == ButtonState.Pressed)
{
return true;
}
break;
case PlayerButton.RBumper:
if (padStates[i].Buttons.RightShoulder == ButtonState.Pressed)
{
return true;
}
break;
case PlayerButton.AnyButton:
if (padStates[i].Buttons.A == ButtonState.Pressed || padStates[i].Buttons.B == ButtonState.Pressed || padStates[i].Buttons.X == ButtonState.Pressed || padStates[i].Buttons.Y == ButtonState.Pressed || padStates[i].Buttons.Back == ButtonState.Pressed || padStates[i].Buttons.Start == ButtonState.Pressed || padStates[i].Buttons.RightShoulder == ButtonState.Pressed || padStates[i].Buttons.LeftShoulder == ButtonState.Pressed || padStates[i].Buttons.RightStick == ButtonState.Pressed || padStates[i].Buttons.LeftStick == ButtonState.Pressed)
{
return true;
}
break;
default:
return false;
}
}
return false;
}
private bool GetButtonState(PlayerButton inputelement, CommandElement commandelement)
{
return((inputelement & commandelement.MatchHash1) == commandelement.MatchHash1 && (inputelement & commandelement.MatchHash2) == 0);
}
/// <summary>
/// Add a new input callback for a PlayerButton.
/// </summary>
/// <param name="button">The button associated with the callback.</param>
/// <param name="callback">The callback to be fired.</param>
public void Add(PlayerButton button, Action<Boolean> callback)
{
if (callback == null) throw new ArgumentNullException("callback");
Add((Int32)button, callback);
}
