internal void ApplyInput(ICalculatorInput calculatorinput)
{
if (!ValidateInput(calculatorinput))
{
return;
}
var input = InputHistory.LastOrDefault();
if (input is CalculatorOperator && calculatorinput is CalculatorOperator)
{
InputHistory.RemoveAt(InputHistory.Count - 1);
InputHistory.Add(calculatorinput);
FireChange("Input");
return;
}
if ((input == null || input is CalculatorOperator) && calculatorinput.Value == ".")
{
InputHistory.Add(InputButtons.FirstOrDefault(b => b.Value == "0"));
InputHistory.Add(calculatorinput);
}
else
{
InputHistory.Add(calculatorinput);
}
CurrentInput = Input.Replace(" ", "").Split(OperatorButtons.Select(b => b.Value).ToArray(), StringSplitOptions.RemoveEmptyEntries).Where(s => !string.IsNullOrEmpty(s)).LastOrDefault();
FireChange("Input");
if (calculatorinput is CalculatorOperator)
{
CurrentOperator = calculatorinput as CalculatorOperator;
Calculate();
}
}
public static bool GetButtonDown(InputButtons button, int index)
{
var gIndex = IntToIndex(index);
bool result = false;
if (gIndex == Index.Any)
{
for (int i = 0; i < 4; i++)
{
if (XInput.GetButtonDown(Buttons[button], i))
{
result = true;
}
}
if (KbInput.GetButtonDown(Buttons[button]))
{
result = true;
}
}
else if (gIndex == Index.Kbm)
{
result = KbInput.GetButtonDown(Buttons[button]);
}
else
{
result = XInput.GetButtonDown(Buttons[button], index);
}
return(result);
}
public Boolean IsDown(InputButtons button)
{
switch (button)
{
case InputButtons.Fire: return(Fire.IsDown);
}
return(false);
}
public Boolean WasPressed(InputButtons button)
{
switch (button)
{
case InputButtons.Fire: return(Fire.WasPressed);
}
return(false);
}
public bool getButtonDown(InputButtons button)
{
bool result;
// default bool value of false is desired if key is missing
buttonValues.TryGetValue(button, out result);
return(result);
}
private void HandleInputManagerCreated(InputButtons sender, InputButtonManager input)
{
if (input.Which.Type == InputButtonType.Keyboard)
{ // Track all created keyboard events...
_keys[_keyCount] = input;
_keyCount++;
}
}
public void ButtonHold(InputButtons button)
{
InputEvent ie;
if (buttonHoldEvents.TryGetValue(button, out ie))
{
ie.Trigger();
}
}
public TileTapEventArgs(TileEventArgs tileEventArgs, InputButtons button, bool doubleClicked, bool pressedDown,
InputButtons allButtons = InputButtons.None)
{
this.TileEventArgs = tileEventArgs;
this.Button = button;
this.DoubleClicked = doubleClicked;
this.PressedDown = pressedDown;
this.AllButtonStates = allButtons;
}
public TileTapEventArgs(TileEventArgs tileEventArgs, InputButtons button, bool doubleClicked, bool pressedDown,
InputButtons allButtons = InputButtons.None)
{
this.TileEventArgs = tileEventArgs;
this.Button = button;
this.DoubleClicked = doubleClicked;
this.PressedDown = pressedDown;
this.AllButtonStates = allButtons;
}
// Constructor
public HumanController(PlayerOnClient nPlayer)
{
player = nPlayer;
if(InGameLobby.instance != null)
lobbyChat = InGameLobby.instance.lobbyChat;
// Input manager
inputManager = InputManager.instance;
buttons = new InputButtons(inputManager);
}
public SdlInput(string controllerMappingFilepath)
{
ControllerMappingFilepath = controllerMappingFilepath;
Timestamp = 0;
Buttons = new InputButtons();
Analog = new InputAnalogue();
Extension = new InputExtension();
// Set "controller byte"
Extension.Unknown1 = 1;
}
protected override void Release()
{
base.Release();
_buttons = null;
_mButtons.Values.ForEach(i =>
{
i.OnStateChanged -= this.HandleInputChanged;
});
_mButtons.Clear();
}
// Constructor
public HumanController(PlayerOnClient nPlayer)
{
player = nPlayer;
if (InGameLobby.instance != null)
{
lobbyChat = InGameLobby.instance.lobbyChat;
}
// Input manager
inputManager = InputManager.instance;
buttons = new InputButtons(inputManager);
}
private void RaiseTileTap(Point tapPoint, InputButtons button, bool pressedDown, bool doubleClicked,
MouseButtonEventArgs e)
{
var allButtons = e != null?this.GetStateOfAllMouseButtons(e) : InputButtons.None;
this.TilePressCommand.ExecuteIfAbleTo(
new TileTapEventArgs(
this.GetTileEventArgsFromBoardPoint(tapPoint),
button,
doubleClicked,
pressedDown,
allButtons));
}
public bool IsButtonDown(InputButtons button)
{
switch (button)
{
case InputButtons.A_1:
return(A_1 == ButtonState.Pressed);
case InputButtons.X_2:
return(X_2 == ButtonState.Pressed);
case InputButtons.B_3:
return(B_3 == ButtonState.Pressed);
case InputButtons.Y_4:
return(Y_4 == ButtonState.Pressed);
case InputButtons.Dpad_UpArrow:
return(Dpad_UpArrow == ButtonState.Pressed);
case InputButtons.Dpad_DownArrow:
return(Dpad_DownArrow == ButtonState.Pressed);
case InputButtons.Dpad_RightArrow:
return(Dpad_RightArrow == ButtonState.Pressed);
case InputButtons.Dpad_LeftArrow:
return(Dpad_LeftArrow == ButtonState.Pressed);
case InputButtons.Select_TAB:
return(Select_TAB == ButtonState.Pressed);
case InputButtons.Start_ESC:
return(Start_ESC == ButtonState.Pressed);
case InputButtons.LeftBumper_Q:
return(LeftBumper_Q == ButtonState.Pressed);
case InputButtons.RightBumper_E:
return(RightBumper_E == ButtonState.Pressed);
case InputButtons.LeftTrigger_Mouse2:
return(LeftTrigger_Mouse2 == ButtonState.Pressed);
case InputButtons.RightTrigger_Mouse1:
return(RightTrigger_Mouse1 == ButtonState.Pressed);
default:
return(false);
}
}
public DxInput(string controllerMappingFilepath)
{
ControllerMappingFilepath = controllerMappingFilepath;
Timestamp = 0;
Buttons = new InputButtons();
Analog = new InputAnalogue();
Extension = new InputExtension();
// Set "controller byte"
Extension.Unknown1 = 1;
// Initialize DirectInput
_directInput = new DirectInput();
}
/// <summary>
/// Send controller input frame
/// </summary>
/// <param name="createdTime">Creation timestamp of input data.</param>
/// <param name="buttons">Input button data.</param>
/// <param name="analogue">Input analog axis data.</param>
/// <param name="extension">Input extension data.</param>
/// <returns></returns>
public async Task SendInputFrame(DateTime createdTime, InputButtons buttons,
InputAnalogue analogue, InputExtension extension)
{
// Convert DateTime to relative timestamp
// e.g. microSeconds since reference timestamp
ulong createdTimestampMicroS = DateTimeHelper.ToTimestampMicroseconds(createdTime, ReferenceTimestamp);
InputFrame frame = new InputFrame(NextFrameId, Timestamp, createdTimestampMicroS,
buttons, analogue, extension);
/*
* await WaitForMessageAsync<InputFrameAck>(
* TimeSpan.FromMilliseconds(10),
* async () => await SendAsync(frame)
* );
*/
await SendAsync(frame);
}
public void EnableButton(InputButtons button, InputButtonActions action)
{
switch (action)
{
case InputButtonActions.Down:
buttonDownEvents.First(b => b.Key == button).Value.Enable();
break;
case InputButtonActions.Hold:
buttonHoldEvents.First(b => b.Key == button).Value.Enable();
break;
case InputButtonActions.Up:
buttonUpEvents.First(b => b.Key == button).Value.Enable();
break;
}
}
public void RegisterButton(InputButtons button, InputButtonActions action, Action callback)
{
switch (action)
{
case InputButtonActions.Down:
buttonDownEvents.Add(button, new InputEvent(callback));
break;
case InputButtonActions.Hold:
buttonHoldEvents.Add(button, new InputEvent(callback));
break;
case InputButtonActions.Up:
buttonUpEvents.Add(button, new InputEvent(callback));
break;
}
}
private void Calculate()
{
var calculation = Input.Replace(" ", "");
var items = calculation.Split(OperatorButtons.Select(o => o.Value).ToArray(), StringSplitOptions.RemoveEmptyEntries);
if (items.Count() < 2)
{
return;
}
List <CalculatorOperator> operators = new List <CalculatorOperator>();
foreach (string s in calculation.Where(o => OperatorButtons.Select(b => b.Value).Contains(o.ToString())).Select(o => o.ToString()))
{
operators.Add(OperatorButtons.FirstOrDefault(o => o.Value == s) as CalculatorOperator);
}
int opindex = 0;
string calcresult = null;
foreach (var item in items)
{
if (calcresult == null)
{
calcresult = item;
continue;
}
var op = operators[opindex];
switch (op.OperatorType)
{
case OperatorTypes.Add:
{
calcresult = (double.Parse(calcresult) + double.Parse(item)).ToString();
} break;
case OperatorTypes.Subtract:
{
calcresult = (double.Parse(calcresult) - double.Parse(item)).ToString();
} break;
case OperatorTypes.Multiply:
{
calcresult = (double.Parse(calcresult) * double.Parse(item)).ToString();
} break;
case OperatorTypes.Divide:
{
calcresult = (double.Parse(calcresult) / double.Parse(item)).ToString();
} break;
}
opindex++;
}
Result = Math.Round(decimal.Parse(calcresult), 2).ToString();
if (CurrentOperator.OperatorType == OperatorTypes.Equals)
{
InputHistory.Clear();
foreach (var c in Result)
{
ApplyInput(InputButtons.FirstOrDefault(i => i.Value.ToString() == c.ToString()));
}
}
FireChange("Input");
}
public bool BtnUp(InputButtons button)
{
return(!newInputState.IsButtonDown(button));
}
public bool BtnClicked(InputButtons button)
{
return(newInputState.IsButtonDown(button) && !oldInputState.IsButtonDown(button));
}
public bool BtnReleased(InputButtons button)
{
return(!newInputState.IsButtonDown(button) && oldInputState.IsButtonDown(button));
}
public static InputButtons ClearFlag(this InputButtons self, InputButtons flag)
{
return(self & ~flag);
}
protected override void Release()
{
base.Release();
_inputButtons = null;
}
public static Boolean HasFlag(this InputButtons self, InputButtons flag)
{
return((self & flag) == flag);
}
public void DisableEvent(InputContexts context, InputButtons button, InputButtonActions action)
{
GetByContext(context).DisableButton(button, action);
}
public void RegisterEvent(InputContexts context, InputButtons button, InputButtonActions action, Action callback)
{
GetByContext(context).RegisterButton(button, action, callback);
}
public bool IsButtonDown(InputButtons button)
{
switch(button)
{
case InputButtons.A_1: return A_1 == ButtonState.Pressed;
case InputButtons.X_2: return X_2 == ButtonState.Pressed;
case InputButtons.B_3: return B_3 == ButtonState.Pressed;
case InputButtons.Y_4: return Y_4 == ButtonState.Pressed;
case InputButtons.Dpad_UpArrow: return Dpad_UpArrow == ButtonState.Pressed;
case InputButtons.Dpad_DownArrow: return Dpad_DownArrow == ButtonState.Pressed;
case InputButtons.Dpad_RightArrow: return Dpad_RightArrow == ButtonState.Pressed;
case InputButtons.Dpad_LeftArrow: return Dpad_LeftArrow == ButtonState.Pressed;
case InputButtons.Select_TAB: return Select_TAB == ButtonState.Pressed;
case InputButtons.Start_ESC: return Start_ESC == ButtonState.Pressed;
case InputButtons.LeftBumper_Q: return LeftBumper_Q == ButtonState.Pressed;
case InputButtons.RightBumper_E: return RightBumper_E == ButtonState.Pressed;
case InputButtons.LeftTrigger_Mouse2: return LeftTrigger_Mouse2 == ButtonState.Pressed;
case InputButtons.RightTrigger_Mouse1: return RightTrigger_Mouse1 == ButtonState.Pressed;
default: return false;
}
}
public bool BtnClicked(InputButtons button)
{
return newInputState.IsButtonDown(button) && !oldInputState.IsButtonDown(button);
}
public bool BtnReleased(InputButtons button)
{
return !newInputState.IsButtonDown(button) && oldInputState.IsButtonDown(button);
}
public static InputButtons SetFlag(this InputButtons self, InputButtons flag)
{
return(self | flag);
}
private void RaiseTileTap(Point tapPoint, InputButtons button, bool pressedDown, bool doubleClicked,
MouseButtonEventArgs e)
{
var allButtons = e != null ? this.GetStateOfAllMouseButtons(e) : InputButtons.None;
this.TilePressCommand.ExecuteIfAbleTo(
new TileTapEventArgs(
this.GetTileEventArgsFromBoardPoint(tapPoint),
button,
doubleClicked,
pressedDown,
allButtons));
}
public bool BtnUp(InputButtons button)
{
return !newInputState.IsButtonDown(button);
}
