public void Update()
{
if (doInitDelay)
{
initialDelay--;
}
if (initialDelay <= 0)
{
doInitDelay = false;
currentCommand = new NullCommand();
keyboardState = Keyboard.GetState();
foreach (Keys key in keyboardState.GetPressedKeys())
{
if (commandLibrary.ContainsKey(key))
{
currentCommand = commandLibrary[key];
currentCommand.Execute();
break;
}
}
if (keyboardState.GetPressedKeys().Length == 0)
{
player.Idle();
}
}
}
public void SetKeyboardState(KeyboardState ob)
{
if(ob.GetPressedKeys().Length>0)
switch (ob.GetPressedKeys()[0])
{
case Keys.W:
direction = GameObjects.Sprites.Direction.Up;
action = GameObjects.Sprites.Action.Walking;
break;
case Keys.A:
direction = GameObjects.Sprites.Direction.Left;
action = GameObjects.Sprites.Action.Walking;
break;
case Keys.S:
direction = GameObjects.Sprites.Direction.Down;
action = GameObjects.Sprites.Action.Walking;
break;
case Keys.D:
direction = GameObjects.Sprites.Direction.Right;
action = GameObjects.Sprites.Action.Walking;
break;
default:
action = GameObjects.Sprites.Action.Standing;
break;
}
if (!ob.GetPressedKeys().Contains(Keys.W) &&
!ob.GetPressedKeys().Contains(Keys.A) &&
!ob.GetPressedKeys().Contains(Keys.S) &&
!ob.GetPressedKeys().Contains(Keys.D))
{
action = GameObjects.Sprites.Action.Standing;
}
}
public void Update(KeyboardState Tastenstatus, ref string Text)
{
if (SchreibModus == true)
{
Lastposition = Text.Length;
if (Tastenstatus.IsKeyDown(Keys.LeftShift))
{
Großschreiben = true;
if (Tastendruck == true && Tastenstatus.GetPressedKeys().Length == 1)
{
Tastendruck = false;
}
}
else
{
Großschreiben = false;
if (Tastendruck == true && Tastenstatus.GetPressedKeys().Length == 0)
{
Tastendruck = false;
}
}
if (Tastenstatus.IsKeyDown(Keys.Back) && Lastposition > 0 && Tastendruck == false)
{
Text = Text.Remove(Lastposition - 1, 1);
Tastendruck = true;
}
if (Lastposition <= MaxAnzahlZeichen)
{
Keys[] currentlyPressed = Tastenstatus.GetPressedKeys();
List<string> allowedChars = new List<string>(AllowedChars);
foreach (Keys key in currentlyPressed)
{
Buchstabe = key.ToString();
if (Buchstabe.Length == 2)
{
Buchstabe = Buchstabe.Remove(0, 1);
}
if (allowedChars.Contains(Buchstabe.ToLower()) && Tastendruck == false)
{
Tastendruck = true;
if (Großschreiben == true)
{
Text += Buchstabe.ToUpper();
}
else
{
Text += Buchstabe.ToLower();
}
}
}
}
}
}
public override void HandleInput(GameTime time)
{
//throw new NotImplementedException();
newState = Keyboard.GetState();
Keys[] newDown = newState.GetPressedKeys();
Keys[] oldDown = oldState.GetPressedKeys();
foreach(Keys k in oldDown)
{
if(!newDown.Contains(k))
{
if(k == Keys.Back)
{
if (text.Length > 0) text = text.Substring(0, text.Length - 1);
}
else if(k == Keys.Space)
{
text += " ";
}
else
{
text += k.ToString();
}
}
}
oldState = newState;
}
public static void UpdateInput()
{
oldKeyboardState = currentKeyboardState;
currentKeyboardState = Keyboard.GetState();
Keys[] pressedKeys;
pressedKeys = currentKeyboardState.GetPressedKeys();
foreach (Keys key in pressedKeys)
{
if( oldKeyboardState.IsKeyUp(key) )
{
if (key == Keys.Back) // overflows
{
if (textString.Length > 0)
textString = textString.Remove(textString.Length - 1, 1);
}
else if (key == Keys.Space)
textString = textString.Insert(textString.Length, " ");
else if (key == Keys.Enter)
{
Command = textString;
InputParser.Update();
textString = String.Empty;
}
else
textString += key.ToString();
}
}
}
public void Update(GameTime time)
{
oldState = currentState;
currentState = Microsoft.Xna.Framework.Input.Keyboard.GetState();
shiftDown = currentState.IsKeyDown(Keys.LeftShift) || currentState.IsKeyDown(Keys.RightShift);
currentlyPressed = currentState.GetPressedKeys();
previouslyPressed = oldState.GetPressedKeys();
if (currentlyPressed.Length != previouslyPressed.Length)
{
keyHoldTimer = 0.0f;
keyHeld = false;
lastKeyHeld = FindLastKeyPressed();
}
if (!keyHeld && currentlyPressed.Length > 0)
{
keyHoldTimer += (float)time.ElapsedGameTime.TotalMilliseconds;
if (keyHoldTimer > keyHoldWait)
{
keyHeld = true;
}
}
}
public List<char> ReturnDigitORNumberKeyAsChar(KeyboardState keyboardstate, KeyboardState oldKeyboardstate)
{
List<char> chars = new List<char>();
char c;
bool shift = false;
if (keyboardstate.IsKeyDown(Keys.LeftShift) || keyboardstate.IsKeyDown(Keys.RightShift))
shift = true;
foreach (Keys a in keyboardstate.GetPressedKeys())
{
if (oldKeyboardstate.IsKeyUp(a) && a != Keys.RightShift && a != Keys.LeftShift)
{
int i = a.GetHashCode();
c = (char)i;
if (Char.IsLetterOrDigit(c))
if (shift)
chars.Add(c);
else
chars.Add(Convert.ToChar(c.ToString().ToLower()));
}
}
return chars;
}
public static void Initialize()
{
previousState = currentState = Keyboard.GetState();
previousKeySet = new HashSet<Keys>(currentState.GetPressedKeys());
keyListeners = new HashSet<KeyListener>();
}
public void Update(KeyboardState state)
{
Keys[] pressed = state.GetPressedKeys();
List<Keys> toRemove = new List<Keys>();
List<Keys> toRelease = new List<Keys>();
foreach (KeyValuePair<Keys, AdvancedKeyState> key in States) {
if (!pressed.Contains(key.Key)) {
if (key.Value == AdvancedKeyState.Pressed ||
key.Value == AdvancedKeyState.Down) {
toRelease.Add(key.Key);
} else if (key.Value == AdvancedKeyState.Released) {
toRemove.Add(key.Key);
}
}
}
foreach (var release in toRelease) {
States[release] = AdvancedKeyState.Released;
FireEvent(release);
}
foreach (var remove in toRemove)
States.Remove(remove);
foreach (var key in pressed) {
if (!States.ContainsKey(key) ||
States[key] == AdvancedKeyState.Released) {
States[key] = AdvancedKeyState.Pressed;
FireEvent(key);
} else if (States[key] == AdvancedKeyState.Pressed) {
States[key] = AdvancedKeyState.Down;
}
}
}
public static string TypeText(KeyboardState oldState, KeyboardState newState, string text, int maxchars, string def)
{
Keys[] oldKeys = oldState.GetPressedKeys();
Keys[] newKeys = newState.GetPressedKeys();
foreach (Keys key in oldKeys)
{
if (!newKeys.Contains(key))
{
if (key == Keys.Back)
{
if (text.Length > 0)
text = text.Remove(text.Length - 1);
}
else if (text.Length <= maxchars)
{
if (key == Keys.Space)
{
text += "_";
}
else if (key.ToString().Length == 1)
{
if (text == def)
text = "";
text += key.ToString();
}
}
}
}
return text;
}
public static void getState()
{
oldTeclado = teclado;
oldMouse = mouse;
teclado = Keyboard.GetState();
mouse = Mouse.GetState();
Keys[] keys = teclado.GetPressedKeys();
foreach (Keys keyPressed in keys)
{
if (!keysPressed.Contains(keyPressed))
{
keysPressed.Add(keyPressed);
}
}
foreach (Keys keyPressed in keysPressed)
{
if (teclado.IsKeyUp(keyPressed))
{
keysPressed.Remove(keyPressed);
break;
}
}
}
public void Update(GameTime gameTime, KeyboardState keyState)
{
if (IsAtive)
{
#region Change of direction
if (keyState.GetPressedKeys().Contains(KeyLeft))
{
this.Direction += DirectionSpeed * (float)gameTime.ElapsedGameTime.TotalMilliseconds;
}
if (keyState.GetPressedKeys().Contains(KeyRight))
{
this.Direction -= DirectionSpeed * (float)gameTime.ElapsedGameTime.TotalMilliseconds;
}
#endregion
Vector2 newPosition = ActualPosition + new Vector2((float)Math.Sin(Direction) * Speed * (float)gameTime.ElapsedGameTime.TotalMilliseconds, (float)Math.Cos(Direction) * Speed * (float)gameTime.ElapsedGameTime.TotalMilliseconds);
float Distance = Vector2.Distance(newPosition, Positions[Positions.Count - 1]);
if (SpaceParts <= 0)
{
for (int i = (int)(Distance / PartsDistance); i > 0; i--)
{
Vector2 newPart = Positions[Positions.Count - 1] + new Vector2((float)Math.Sin(Direction) * PartsDistance, (float)Math.Cos(Direction) * PartsDistance);
Positions.Add(newPart);
}
}
else
{
SpaceParts--;
if (SpaceParts == 0)
{
Positions.Add(ActualPosition);
}
}
ActualPosition = newPosition;
#region Spaces
SpaceTime -= gameTime.ElapsedGameTime.TotalMilliseconds;
if (SpaceTime <= 0)
{
SpaceParts = SpacePartsMax;
SpaceTime = 2000 + Nahoda.Next(0, 3000);
}
#endregion
}
}
private static void DevInput(MouseState mouse, KeyboardState keyboard)
{
if (keyboard.GetPressedKeys().Contains(Keys.Space))
{
Camera.Position.X = 0;
Camera.Position.Z = 0;
}
}
private void CalculateKeyDownMessages(KeyboardState newKeyState)
{
var keys = newKeyState.GetPressedKeys().Where(key => !_oldKeyState.IsKeyDown(key));
foreach (var key in keys)
{
_messageManager.QueueMessage(new KeyDownMessage(key));
}
}
public override void Update(GameTime gameTime)
{
keyOldState = keyNewState;
keyNewState = Keyboard.GetState();
if ((Game.IsActive && (keyNewState.GetPressedKeys().Length > 0 || keyOldState.GetPressedKeys().Length > 0) && KeyEvent != null))
KeyEvent(keyNewState, keyOldState);
}
public void Update()
{
//Update the previous states
m_PreviousState = m_CurrentState;
m_PrevKeysPressed = m_PreviousState.GetPressedKeys();
m_CurrentState = Keyboard.GetState();
m_KeysPressed = m_CurrentState.GetPressedKeys();
}
public void Initialize()
{
m_CurrentState = new KeyboardState();
m_PreviousState = new KeyboardState();
m_CurrentState = Keyboard.GetState();
m_PreviousState = Keyboard.GetState();
m_KeysPressed = m_CurrentState.GetPressedKeys();
m_PrevKeysPressed = m_PreviousState.GetPressedKeys();
}
protected override void Update(GameTime delta, KeyboardState keyboard, MouseState mouse, RenderEngine renderEngine)
{
if (keyboard.GetPressedKeys().Length != 0)
{
if (keyboard.IsKeyDown(Keys.Escape)) NextGameState = null;
else Fade();
}
if (opacity.A != 255) Fade();
}
public static void Update()
{
LastState = CurrentState;
CurrentState = Keyboard.GetState();
Pressed = CurrentState.GetPressedKeys().Where(k => LastState.IsKeyUp(k)).ToList();
Released = LastState.GetPressedKeys().Where(k => CurrentState.IsKeyUp(k)).ToList();
}
/// <summary>
/// Update the KeyboardManager, calling the appropriate events.
/// </summary>
internal static void Update()
{
_currentState = Keyboard.GetState();
//Key down
if (KeyDown != null)
{
foreach (Keys k in _currentState.GetPressedKeys())
{
if (_lastState.IsKeyUp(k))
{
KeyDown(null, new SingleKeyEventArgs(k));
}
}
}
//Key up
if (KeyUp != null)
{
foreach (Keys k in _lastState.GetPressedKeys())
{
if (_currentState.IsKeyUp(k))
{
KeyUp(null, new SingleKeyEventArgs(k));
}
}
}
//Key press
if (KeyPressed != null)
{
foreach (Keys s in _currentState.GetPressedKeys())
{
if (!_knownDownKeys.Contains(s))
{
_knownDownKeys.Add(s);
}
}
List<Keys> rm = new List<Keys>();
foreach (Keys k in _knownDownKeys)
{
if (_currentState.IsKeyUp(k))
{
KeyPressed(null, new SingleKeyEventArgs(k));
rm.Add(k);
}
}
foreach (Keys rk in rm)
{
_knownDownKeys.Remove(rk);
}
}
_lastState = _currentState;
}
public void HandleKeyboardInput(KeyboardState keyboardState)
{
// Summon monster hotkey
if (keyboardState.GetPressedKeys().Contains(Keys.S) && !previousKeyboardState.GetPressedKeys().Contains(Keys.S))
{
UI.getInstance().OpenSummonDialog();
}
if (keyboardState.GetPressedKeys().Contains(Keys.Enter) && !previousKeyboardState.GetPressedKeys().Contains(Keys.Enter))
{
foreach (Button button in UI.getInstance().playerActionDialog.buttonCollection)
{
if (typeof(PassTurnButton) == button.GetType())
button.ClickHandler();
}
}
previousKeyboardState = keyboardState;
}
public void update()
{
previousState = currentState;
currentState = Keyboard.GetState();
Keys[] previousKeys = previousState.GetPressedKeys();
Keys[] currentKeys = currentState.GetPressedKeys();
_keyDowns = currentKeys.Except(previousKeys).ToArray();
}
public override void HandleInput(KeyboardState newKeyboardState, MouseState newMouseState, Game1 parent)
{
if (_timer < 0)
if (newKeyboardState.GetPressedKeys().Length > 0 || _player.State != MediaState.Playing)
{
_player.Stop();
parent.SwitchScene(_next);
}
_windowSize = new Rectangle(0, 0, parent.Window.ClientBounds.Width, parent.Window.ClientBounds.Height);
}
MouseState originalMouseState; //represents the mouse at program stard
#endregion Fields
#region Constructors
public InputManager(Game game)
: base(game)
{
// TODO: Construct any child components here
originalKBState = Keyboard.GetState(); //get the keyboard state at program start
originalKeys = originalKBState.GetPressedKeys(); //find the pressed keys at program start
originalMouseState = Mouse.GetState(); //initialize the mouse state
}
public override void Update(GameObject gameObject, GameTime gameTime)
{
newK = Keyboard.GetState();
foreach (Keys k in newK.GetPressedKeys())
{
eventHandler.QueueEvent(new InputEvent(k, gameObject.ID));
}
oldK = newK;
}
KeyboardState prevKState; //Previous Keyboard State
#endregion Fields
#region Methods
public void CatchKeys(int PlayerID)
{
if (capturedKeys.Count == 1)
capturedKeys.Remove(Keys.Enter);
prevKState = curKState;
curKState = Keyboard.GetState();
Keys[] keys = curKState.GetPressedKeys();
foreach (Keys k in keys)
if (curKState.IsKeyDown(k) && !prevKState.IsKeyDown(k))
capturedKeys.Add(k);
}
public void HandleKeyboard(KeyboardState state)
{
if (!IsAlive)
return;
Keys[] pressed = state.GetPressedKeys();
foreach (Keys k in pressed)
{
switch (k)
{
case Keys.Space:
Jump();
break;
case Keys.D:
case Keys.Right:
if (_states.First() != PlayerState.Jump)
{
PushState(PlayerState.Walk);
Direction = DirectionEnum.Right;
_force.X = 2000;
}
else
{
Direction = DirectionEnum.Right;
_force.X += 50;
}
break;
case Keys.A:
case Keys.Left:
if (_states.First() != PlayerState.Jump)
{
PushState(PlayerState.Walk);
Direction = DirectionEnum.Left;
_force.X = -2000;
}
else
{
_force.X -= 50;
Direction = DirectionEnum.Left;
}
break;
}
}
if (_states.First() == PlayerState.Walk && (state.IsKeyUp(Keys.A) && state.IsKeyUp(Keys.D)))
{
PopState();
_force.X = 0;
}
}
/// <summary>
/// Update the KeyboardManager, calling the appropriate events.
/// </summary>
internal static void Update()
{
_currentState = Keyboard.GetState();
//Key down
if (KeyDown != null)
{
foreach (Keys k in _currentState.GetPressedKeys())
{
if (_lastState.IsKeyUp(k))
{
KeyDown(null, new SingleKeyEventArgs(k));
}
}
}
//Key up
if (KeyUp != null)
{
foreach (Keys k in _lastState.GetPressedKeys())
{
if (_currentState.IsKeyUp(k))
{
KeyUp(null, new SingleKeyEventArgs(k));
}
}
}
//Key press
if (KeyPressed != null)
{
foreach (Keys s in _currentState.GetPressedKeys())
{
if (!_knownDownKeys.Contains(s))
{
_knownDownKeys.Add(s);
}
}
for (int i = 0; i < _knownDownKeys.Count; i++ )
{
if (_currentState.IsKeyUp(_knownDownKeys[i]))
{
KeyPressed(null, new SingleKeyEventArgs(_knownDownKeys[i]));
_knownDownKeys.RemoveAt(i);
i--;
}
}
}
_lastState = _currentState;
}
public override void Update(GameTime gameTime)
{
clavier = Keyboard.GetState();
videoPlayer.Play(myVideoFile);
if (gameTime.TotalGameTime.TotalSeconds > myVideoFile.Duration.Seconds + 0.5f || clavier.GetPressedKeys().Length > 0)
{
videoPlayer.Stop();
Gestion_Ecran.Goto_Ecran("Menu Principal");
this.Shutdown();
}
base.Update(gameTime);
}
public MMGKeyboard()
{
secretKeyboard = this;
pressed = new List<Keys>();
released = new List<Keys>();
timer = new Dictionary<Keys, float>();
names = new Dictionary<string, Keys>();
keyboard = Keyboard.GetState();
previous = current = keyboard.GetPressedKeys();
}
