private void Input_OnKey(SInputEvent e)
{
// Commands which are only allowed when game is currently running and not paused.
if (State != GameState.Paused)
{
// Fire primary player weapon.
if ((e.KeyPressed(EKeyId.eKI_Space) || e.KeyPressed(EKeyId.eKI_XI_A)) && _player.Exists)
{
_player.Fire();
}
}
if ((State != GameState.Finished) && (e.KeyPressed(EKeyId.eKI_Escape) || e.KeyPressed(EKeyId.eKI_XI_Start)))
{
if (_gameOverTime == DateTime.MinValue)
{
State = State == GameState.Paused ? GameState.Running : GameState.Paused;
if (State == GameState.Paused)
{
Hud.CurrentHud.ShowGamePauseDialog();
}
else
{
Hud.CurrentHud.HideGamePauseDialog();
}
}
}
}
void OnKey(SInputEvent e)
{
if (e.KeyPressed(EKeyId.eKI_Escape) && !Engine.IsSandbox)
{
Engine.Console.ExecuteString("quit");
}
}
public static bool KeyDown(this SInputEvent e, EKeyId k)
{
bool isDown = false;
KeyDownLog.TryGetValue(k, out isDown);
return(isDown);
}
/// <summary>
/// Called by Canvas. Do not call directly.
/// </summary>
public void OnKey(SInputEvent e)
{
if (Items.Count > 0)
{
if (e.KeyPressed(EKeyId.eKI_Down))
{
_idx = Math.Min(Items.Count - 1, _idx + 1);
}
if (e.KeyPressed(EKeyId.eKI_Up))
{
_idx = Math.Max(0, _idx - 1);
}
}
else
{
_idx = -1;
}
if (e.keyName.key.Length == 1)
{
var key = e.keyName.key.ToUpper();
var chosen = Items.FirstOrDefault(x => x.ToString().ToUpper().StartsWith(key));
if (chosen != null)
{
_idx = Items.IndexOf(chosen);
}
}
SelectedItem = _idx < 0 ? null : Items [_idx];
}
public void InvokeOnKey(SInputEvent e)
{
if (_OnKey != null)
{
_OnKey.Invoke(this, new object[] { e });
}
}
/// <summary>
/// Called by Canvas. Do not call directly.
/// </summary>
public override void OnKey(SInputEvent e)
{
if (e.KeyPressed(EKeyId.eKI_Space))
{
IsChecked = !IsChecked;
}
}
private void Input_OnKey(SInputEvent arg)
{
if (arg.KeyPressed(EKeyId.eKI_Space))
{
Spawn();
}
}
public override void OnInputKey(SInputEvent arg)
{
if (_raycaster == null)
{
return;
}
if (arg.keyId == EKeyId.eKI_A)
{
_raycaster.Position += Vec3.Left * MoveSpeed * FrameTime.Delta;
}
if (arg.keyId == EKeyId.eKI_D)
{
_raycaster.Position += Vec3.Right * MoveSpeed * FrameTime.Delta;
}
if (arg.keyId == EKeyId.eKI_Space && arg.state == EInputState.eIS_Pressed)
{
if (_raycaster.RayOut != null && _raycaster.RayOut.Intersected)
{
var ball = EntityFramework.Spawn <Ball>();
ball.Scale = Vec3.One * 2f;
ball.Position = _raycaster.RayOut.Point + Vec3.Up * ball.Scale.y / 2f;
}
}
}
public override void OnInputKey(SInputEvent arg)
{
if (_earthquake == null)
{
return;
}
if (arg.KeyDown(EKeyId.eKI_W))
{
_earthquake.Position += Vec3.Right * 4f * FrameTime.Delta;
}
if (arg.KeyDown(EKeyId.eKI_S))
{
_earthquake.Position += -Vec3.Right * 4f * FrameTime.Delta;
}
if (arg.KeyDown(EKeyId.eKI_A))
{
if (_earthquake.MinAmplitude > 0.5f)
{
_earthquake.MinAmplitude -= 0.5f;
_earthquake.MaxAmplitude -= 0.5f;
}
}
if (arg.KeyDown(EKeyId.eKI_D))
{
_earthquake.MinAmplitude += 0.5f;
_earthquake.MaxAmplitude += 0.5f;
}
if (arg.KeyDown(EKeyId.eKI_Q))
{
_earthquake.Radius -= 0.1f;
_earthquake.Radius = MathExtensions.Clamp(_earthquake.Radius, 0.25f, _earthquake.Radius);
}
if (arg.KeyDown(EKeyId.eKI_E))
{
_earthquake.Radius += 0.1f;
}
if (arg.KeyPressed(EKeyId.eKI_R))
{
_earthquake.RandomOffset += 1f;
}
if (arg.KeyPressed(EKeyId.eKI_F))
{
_earthquake.RandomOffset -= 1f;
_earthquake.RandomOffset = MathExtensions.Clamp(_earthquake.RandomOffset, 0f, _earthquake.RandomOffset);
}
if (arg.KeyPressed(EKeyId.eKI_V))
{
_earthquake.Visualize = !_earthquake.Visualize;
}
}
private void Input_OnKey(SInputEvent arg)
{
_currentHandler?.OnInputKey(arg);
if (arg.KeyPressed(_uiToggleKey))
{
_currentHandler.ToggleUI();
}
}
public override void OnKey(SInputEvent e)
{
if (e.KeyPressed(EKeyId.eKI_Space) || e.KeyPressed(EKeyId.eKI_Enter) || e.KeyPressed(EKeyId.eKI_XI_A))
{
if (OnPressed != null)
{
OnPressed();
}
}
}
private void OnKey(SInputEvent arg)
{
if (_highscorePage.Active)
{
if (arg.deviceType == EInputDeviceType.eIDT_Gamepad && arg.state == EInputState.eIS_Pressed && arg.keyId == EKeyId.eKI_XI_B)
{
SetInactive();
SetupMainMenuPerspective(true);
}
}
}
private void Input_OnKey(SInputEvent arg)
{
if (arg.KeyPressed(EKeyId.eKI_Tab) && _levelManager.Maps.Count != 0)
{
_levelManager.LoadNextLevel();
}
if (arg.KeyPressed(EKeyId.eKI_Escape))
{
Env.Console.ExecuteString("quit");
}
}
internal InputEvent(SInputEvent nativeEvent)
{
DeviceIndex = nativeEvent.deviceIndex;
DeviceType = (InputDeviceType)nativeEvent.deviceType;
DeviceUniqueId = nativeEvent.deviceUniqueID;
KeyId = (KeyId)nativeEvent.keyId;
KeyName = nativeEvent.keyName.key;
InputModifiers = (InputModifierFlags)nativeEvent.modifiers;
State = (InputState)nativeEvent.state;
Value = nativeEvent.value;
Symbol = nativeEvent.pSymbol;
}
void OnKey(SInputEvent e)
{
if (e.KeyPressed(EKeyId.eKI_Escape) && !Engine.IsSandbox)
{
Engine.Console.ExecuteString("quit");
}
// Show/Hide FPS Label on F5.
if (e.KeyPressed(EKeyId.eKI_F5))
{
_fpsText.Active = !_fpsText.Active;
}
}
void OnKey(SInputEvent e)
{
if (e.KeyPressed(EKeyId.eKI_Escape) && !Env.IsSandbox)
{
Shutdown();
}
// Show/Hide FPS Label on F5.
if (e.KeyPressed(EKeyId.eKI_F5))
{
_fpsText.Active = !_fpsText.Active;
}
}
void OnKey(SInputEvent e)
{
if (e.KeyPressed(EKeyId.eKI_E))
{
CreateBall();
}
if (e.KeyPressed(EKeyId.eKI_V))
{
AddImpulse();
}
if (e.KeyPressed(EKeyId.eKI_T))
{
balls.ToList().ForEach(x => x.Destroy());
balls.Clear();
}
}
/// <summary>
/// Called by framework. Do not call directly.
/// </summary>
public void OnKey(SInputEvent e)
{
if (!Active)
{
return;
}
if ((e.KeyPressed(EKeyId.eKI_Tab) && Input.ShiftDown) || e.KeyPressed(EKeyId.eKI_XI_DPadUp) || e.KeyPressed(EKeyId.eKI_XI_DPadLeft))
{
FocusPreviousComponent();
}
else if (e.KeyPressed(EKeyId.eKI_Tab) || e.KeyPressed(EKeyId.eKI_XI_DPadDown) || e.KeyPressed(EKeyId.eKI_XI_DPadRight))
{
FocusNextComponent();
}
else if (CurrentFocus != null)
{
CurrentFocus.InvokeOnKey(e);
}
}
public virtual void OnKey(SInputEvent e)
{
}
/// <summary>
/// Called by CryEngine. Do not call directly.
/// </summary>
public override bool OnInputEvent(SInputEvent e)
{
if (e.deviceType == EInputDeviceType.eIDT_Keyboard)
{
switch (e.state)
{
case EInputState.eIS_Down:
SInputEventExtensions.KeyDownLog[e.keyId] = true;
break;
case EInputState.eIS_Released:
SInputEventExtensions.KeyDownLog[e.keyId] = false;
break;
}
if (e.KeyDown(EKeyId.eKI_LShift))
{
_lShiftDown = true;
}
if (e.KeyUp(EKeyId.eKI_LShift))
{
_lShiftDown = false;
}
if (e.KeyDown(EKeyId.eKI_RShift))
{
_rShiftDown = true;
}
if (e.KeyUp(EKeyId.eKI_RShift))
{
_rShiftDown = false;
}
// Preprocess keyName to contain valid Chars
if (e.keyId == EKeyId.eKI_Space)
{
e.keyName.key = " ";
}
if (e.keyName.key.Length == 1)
{
if (ShiftDown)
{
e.keyName.key = e.keyName.key.ToUpper();
}
if (ShiftDown && Char.IsDigit(e.keyName.key[0]))
{
e.keyName.key = "=!\"§$%&/()".Substring(e.keyName.key[0] - '0', 1);
}
}
else
{
string res;
e.keyName.key = _charByDescription.TryGetValue(e.keyName.key, out res) ? res : string.Empty;
}
if (OnKey != null)
{
OnKey(e);
}
}
else if (e.deviceType == EInputDeviceType.eIDT_Gamepad || e.deviceType == EInputDeviceType.eIDT_Mouse)
{
// Set keyName.key = string.Empty to avoid showing up gamepad
// presses controller keys in text input forms
e.keyName.key = string.Empty;
switch (e.state)
{
case EInputState.eIS_Down:
SInputEventExtensions.KeyDownLog[e.keyId] = true;
break;
case EInputState.eIS_Released:
SInputEventExtensions.KeyDownLog[e.keyId] = false;
break;
case EInputState.eIS_Changed:
SInputEventExtensions.KeyInputValueLog[e.keyId] = e.value;
break;
}
if (OnKey != null)
{
OnKey(e);
}
}
else if (e.deviceType == EInputDeviceType.eIDT_EyeTracker)
{
if (e.keyId == EKeyId.eKI_EyeTracker_X)
{
var axis = GetAxis("EyeTracker");
_axisByName["EyeTracker"] = new Vector2(e.value, axis != null ? axis.y : 0);
}
if (e.keyId == EKeyId.eKI_EyeTracker_Y)
{
var axis = GetAxis("EyeTracker");
_axisByName["EyeTracker"] = new Vector2(axis != null ? axis.x : 0, e.value);
}
}
return(false);
}
public static bool KeyUp(this SInputEvent e, EKeyId k)
{
return(e.keyId == k && e.state == EInputState.eIS_Released);
}
/// <summary>
/// Called by CryEngine. Do not call directly.
/// </summary>
public override bool OnInputEvent(SInputEvent e)
{
if (e.deviceType == EInputDeviceType.eIDT_Keyboard)
{
if (e.state == EInputState.eIS_Down)
{
SInputEventExtentions.KeyDownLog [e.keyId] = true;
}
if (e.state == EInputState.eIS_Released)
{
SInputEventExtentions.KeyDownLog [e.keyId] = false;
}
if (e.KeyDown(EKeyId.eKI_LShift))
{
_lShiftDown = true;
}
if (e.KeyUp(EKeyId.eKI_LShift))
{
_lShiftDown = false;
}
if (e.KeyDown(EKeyId.eKI_RShift))
{
_rShiftDown = true;
}
if (e.KeyUp(EKeyId.eKI_RShift))
{
_rShiftDown = false;
}
// Preprocess keyName to contain valid Chars
if (e.keyId == EKeyId.eKI_Space)
{
e.keyName.key = " ";
}
if (e.keyName.key.Length == 1)
{
if (ShiftDown)
{
e.keyName.key = e.keyName.key.ToUpper();
}
if (ShiftDown && Char.IsDigit(e.keyName.key[0]))
{
e.keyName.key = "=!\"§$%&/()".Substring(e.keyName.key[0] - '0', 1);
}
}
else
{
string res;
e.keyName.key = _charByDescription.TryGetValue(e.keyName.key, out res) ? res : string.Empty;
}
if (OnKey != null)
{
OnKey(e);
}
}
else if (e.deviceType == EInputDeviceType.eIDT_Gamepad)
{
// Set keyName.key = string.Empty to avoid showing up gamepad
// presses controller keys in text input forms
e.keyName.key = string.Empty;
if (e.state == EInputState.eIS_Down)
{
SInputEventExtentions.KeyDownLog [e.keyId] = true;
}
if (e.state == EInputState.eIS_Released)
{
SInputEventExtentions.KeyDownLog [e.keyId] = false;
}
if (e.state == EInputState.eIS_Changed)
{
SInputEventExtentions.KeyInputValueLog [e.keyId] = e.value;
}
if (OnKey != null)
{
OnKey(e);
}
}
return(false);
}
public override bool OnInputEvent(SInputEvent arg0)
{
OnInputReceived?.Invoke(arg0);
return(false);
}
private static void OnInput(SInputEvent nativeEvent)
{
var managedEvent = new InputEvent(nativeEvent);
if (managedEvent.DeviceType == InputDeviceType.Keyboard)
{
switch (managedEvent.State)
{
case InputState.Down:
SetKeyStateDown(managedEvent.KeyId, true);
break;
case InputState.Released:
SetKeyStateDown(managedEvent.KeyId, false);
break;
}
if (KeyDown(KeyId.LShift))
{
_lShiftDown = true;
}
if (KeyUp(KeyId.LShift))
{
_lShiftDown = false;
}
if (KeyDown(KeyId.RShift))
{
_rShiftDown = true;
}
if (KeyUp(KeyId.RShift))
{
_rShiftDown = false;
}
// Preprocess keyName to contain valid Chars
if (managedEvent.KeyId == KeyId.Space)
{
managedEvent.KeyName = " ";
}
if (managedEvent.KeyName.Length == 1)
{
if (ShiftDown)
{
managedEvent.KeyName = managedEvent.KeyName.ToUpper();
}
if (ShiftDown && char.IsDigit(managedEvent.KeyName[0]))
{
managedEvent.KeyName = "=!\"§$%&/()".Substring(managedEvent.KeyName[0] - '0', 1);
}
}
else
{
string res;
managedEvent.KeyName = _charByDescription.TryGetValue(managedEvent.KeyName, out res) ? res : string.Empty;
}
OnKey?.Invoke(managedEvent);
}
else if (managedEvent.DeviceType == InputDeviceType.Gamepad || managedEvent.DeviceType == InputDeviceType.Mouse)
{
// Set keyName.key = string.Empty to avoid showing up gamepad
// presses controller keys in text input forms
managedEvent.KeyName = string.Empty;
switch (managedEvent.State)
{
case InputState.Down:
SetKeyStateDown(managedEvent.KeyId, true);
break;
case InputState.Released:
SetKeyStateDown(managedEvent.KeyId, false);
break;
case InputState.Changed:
SetKeyStateValue(managedEvent.KeyId, managedEvent.Value);
break;
}
if (OnKey != null)
{
OnKey(managedEvent);
}
}
else if (managedEvent.DeviceType == InputDeviceType.EyeTracker)
{
if (managedEvent.KeyId == KeyId.EyeTracker_X)
{
var axis = GetAxis("EyeTracker");
_axisByName["EyeTracker"] = new Vector2(managedEvent.Value, axis != null ? axis.y : 0);
}
if (managedEvent.KeyId == KeyId.EyeTracker_Y)
{
var axis = GetAxis("EyeTracker");
_axisByName["EyeTracker"] = new Vector2(axis != null ? axis.x : 0, managedEvent.Value);
}
}
}
// For analog inputs
public static bool KeyChanged(this SInputEvent e, EKeyId k)
{
return(e.keyId == k && e.state == EInputState.eIS_Changed);
}
public virtual void OnInputKey(SInputEvent arg)
{
}
/// <summary>
/// Called by Canvas. Do not call directly.
/// </summary>
public override void OnKey(SInputEvent e)
{
if (!_submitDesired)
{
if (e.KeyPressed(EKeyId.eKI_Enter))
{
SetCursor(true);
_submitDesired = true;
}
return;
}
if (e.KeyPressed(EKeyId.eKI_Escape))
{
_text.Content = _contentBackup;
PositionContent(true);
SetCursor(false);
_submitDesired = false;
}
else if (e.KeyPressed(EKeyId.eKI_Home))
{
_cursorIndex = 0;
SetCursor(true);
PositionContent();
}
else if (e.KeyPressed(EKeyId.eKI_End))
{
_cursorIndex = _text.Content.Length;
SetCursor(true);
PositionContent();
}
else if (e.KeyPressed(EKeyId.eKI_Delete))
{
if (_cursorIndex < _text.Content.Length)
{
_text.Content = _text.Content.Substring(0, _cursorIndex) + _text.Content.Substring(_cursorIndex + 1);
}
SetCursor(true);
}
else if (e.KeyPressed(EKeyId.eKI_Enter) || e.KeyPressed(EKeyId.eKI_XI_A))
{
if (TrySubmit())
{
SetCursor(false);
_contentBackup = _text.Content;
}
}
else if (e.KeyPressed(EKeyId.eKI_Backspace))
{
if (_cursorIndex > 0)
{
_text.Content = _text.Content.Substring(0, _cursorIndex - 1) + _text.Content.Substring(_cursorIndex);
SetCursor(true);
_cursorIndex--;
}
PositionContent(true);
}
else if (e.KeyPressed(EKeyId.eKI_Left))
{
_cursorIndex = Math.Max(0, _cursorIndex - 1);
SetCursor(true);
PositionContent();
}
else if (e.KeyPressed(EKeyId.eKI_Right))
{
_cursorIndex = Math.Min(_text.Content.Length, _cursorIndex + 1);
SetCursor(true);
PositionContent();
}
else if (e.state == EInputState.eIS_Pressed)
{
_text.Content = _text.Content.Insert(_cursorIndex, e.keyName.key);
_cursorIndex += e.keyName.key.Length;
SetCursor(true);
PositionContent(true);
}
}
public void InvokeOnKey(SInputEvent e)
{
OnKey(e);
}
