Problem with Event Keyboard Input

[Chyro]

Hey there.
I'm currently working on a little game project to gather more experience with C++ and SFML.

Now I came across a kinda odd problem while making a visual keyboard for entering a character name.
If I'm using sf::event to check for keypresses ->

(click to show/hide)

if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Right)
   {
   }

It works fine for the arrow keys, to move around the marker to select whatever key on the visual keyboard you want to use. But just below that, when I used the same thing to check if the 'Enter' key got pressed, it didn't work.

(click to show/hide)

if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Enter)
   {
   }

After much trying around and looking for solutions, I noticed that for some reason, it only recognizes that 'Enter' key input when I'm holding alt while pressing Enter. Further trying out showed that this applies to most other keys, it only recognizes letter presses (like "N" or "L") or Spacebar if I'm holding alt at the same time. Yet the arrow keys work fine without holding Alt, with the exact same code.

Also, my current now working solution to it - simply using "sf::Keyboard::isKeyPressed(sf::Keyboard::Enter)", does work without the odd issue of having to hold 'Alt'.

So.. I do have a solution to my problem, but I still want to understand why it is causing that weird behavior when using event to check for the key inputs. While trying to figure it out, at one point I used the following code to check what the pressed key is recognized as by outputting it to the console:

(click to show/hide)

std::cout << "Pressed button: " << event.key.code << "\n";

Oddly, it output the press of 'Enter' as '13'. Pressing alt + 'Enter' returned '58' which should be the correct value for the key.

Does anyone have an idea what could be causing this?
I figured I'll only put the relevant code here, but if you need I can post all of it.

Though I think I pretty much narrowed the issue down to that one question -
What could cause sf::event require 'alt' being held to recognize 'Enter' correctly, while arrow keys are recognized normally and sf::keyboard also recognizes 'Enter' normally?

(and no, there's nothing in my code doing anything with the 'alt' key or checking for it)

[eXpl0it3r]

What's your full code?

[Laurent]

I figured I'll only put the relevant code here, but if you need I can post all of it.

A complete and minimal code that reproduces the problem would be much better

[Chyro]

Uh.. okay, full code.
Here we go.
The project is using a state machine, so I guess I'll put in the main code and the code of the state where the issue happens. Probably more than is really needed, but its in convenient spoiler tags so you can just look at the stuff that may be relevant.

.. side note, I'm still quite new to programming (like 2 months or so) so please forgive if there's things in it that are inefficient or should be done in a simpler fashion. Don't mind if anything gets pointed out, as its always good to learn how to do things better. .. I'm just happy when it works the way I intend it to ^^

(click to show/hide)

#include <SFML/Graphics.hpp>
#include "main.h"
#include "GameState.h"
#include "Intro.h"
#include "Intro2.h"
#include "Title.h"
#include "Naming.h"


int stateID = STATE_NULL;
int nextState = STATE_NULL;

GameState *currentState = NULL;


sf::RenderWindow window(sf::VideoMode(windowWidth, windowHeight), "Darklight");

void set_next_state(int newState)
{
   if (nextState != STATE_EXIT)
   {
      nextState = newState;
   }
};

void change_state(bool &isInit)
{
   if (nextState != STATE_NULL)
   {
      if (nextState != STATE_EXIT)
      {
         delete currentState;
      }
      else
      {
         window.close();
      }

      isInit = false;

      switch (nextState)
      {
      case STATE_INTRO:
         currentState = new Intro(window);
         stateID = STATE_INTRO;
         break;

      case STATE_INTRO2:
         currentState = new Intro2(window);
         stateID = STATE_INTRO2;
         break;

      case STATE_TITLE:
         currentState = new Title(window);
         stateID = STATE_TITLE;
         break;

      case STATE_NAMING:
         currentState = new Naming(window);
         stateID = STATE_NAMING;
         break;
      }

      nextState = STATE_NULL;
   }

};

int main()
{
   
   window.setFramerateLimit(120);
   stateID = STATE_NAMING;
   currentState = new Naming(window);
   bool isInit = false;
   bool keyPressed = false;
   

   while (window.isOpen())
   {
      sf::Event event;
      while (window.pollEvent(event))
      {
         if (event.type == sf::Event::Closed)
         {
            window.close();
         }
      }

      if (keyPressed == false)
      {
         if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
         {
            if (stateID == STATE_INTRO || stateID == STATE_TITLE)
            {
               set_next_state(STATE_EXIT);
               keyPressed = true;
            }
            else
            {
               set_next_state(STATE_TITLE);
               keyPressed = true;
            }
         }
      }
      else
      {
         if (event.type == sf::Event::KeyReleased && (event.key.code == sf::Keyboard::Escape))
         {
            keyPressed = false;
         }
      }

      if (isInit == false)
      {
         currentState->initiate(window);
         isInit = true;
      }
      currentState->update(window);
      currentState->handle_events(window, event);
      change_state(isInit);

   }

   return 0;
}

(click to show/hide)

#ifndef main_H
#define main_H
#include <iostream>
#include <SFML/Graphics.hpp>

enum GameStates
{
   STATE_NULL,
   STATE_INTRO,
   STATE_INTRO2,
   STATE_INTRO3,
   STATE_TITLE,
   STATE_NAMING,
   STATE_EXIT,
};

const int windowWidth = 1400;
const int windowHeight = 900;

void set_next_state(int newState);
void change_state(bool &isInit);

#endif

(click to show/hide)

#ifndef GameState_H
#define GameState_H
#include <SFML/Graphics.hpp>


class GameState
{
public:
   virtual void initiate(sf::RenderWindow &window) = 0;
   virtual void update(sf::RenderWindow &window) = 0;
   virtual void handle_events(sf::RenderWindow &window, sf::Event &event) = 0;
   virtual ~GameState() {};
};


#endif

(click to show/hide)

#ifndef Naming_H
#define Naming_H
#include <SFML/Graphics.hpp>
#include "GameState.h"
#include "main.h"


class Naming : public GameState
{
public:
   Naming(sf::RenderWindow &window);
   ~Naming();
   void initiate(sf::RenderWindow &window);
   void update(sf::RenderWindow &window);
   void handle_events(sf::RenderWindow &window, sf::Event &event);


private:
   bool keyPress = false;
   bool borderTop = true;
   bool borderBot = false;
   bool borderLeft = true;
   bool borderRight = false;

   bool caps = true;

   int markerX = 1;
   int markerY = 1;

   sf::Sprite bgSprite;
   sf::Texture bgTex;

   sf::Sprite beamvertSprite;
   sf::Sprite beamhorizSprite;
   sf::Texture beamvertTex;
   sf::Texture beamhorizTex;

   sf::CircleShape orb1CS;
   sf::CircleShape orb2CS;
   sf::CircleShape orbMarkerCS;

   sf::String nameString;
   sf::Text nameText;
   sf::Font font;

   sf::Clock clock;
   sf::Time elapsedTime;
};


#endif

(click to show/hide)

#include "Naming.h"

Naming::Naming(sf::RenderWindow &window)
{


}

Naming::~Naming()
{

}


void Naming::initiate(sf::RenderWindow &window)
{
   bgTex.loadFromFile("content/img/keyboardbig.png");
   bgSprite.setTexture(bgTex);

   beamvertTex.loadFromFile("content/img/kbbeamvert.png");
   beamvertSprite.setTexture(beamvertTex);
   beamvertSprite.setPosition(bgSprite.getPosition().x + 151, bgSprite.getPosition().y +390);

   beamhorizTex.loadFromFile("content/img/kbbeamhoriz.png");
   beamhorizSprite.setTexture(beamhorizTex);
   beamhorizSprite.setPosition(bgSprite.getPosition().x + 54, bgSprite.getPosition().y + 486);

   orb1CS.setFillColor(sf::Color(0, 0, 0));
   orb1CS.setOutlineColor(sf::Color(255, 255, 255));
   orb1CS.setOutlineThickness(2);
   orb1CS.setRadius(10);
   orb1CS.setOrigin(10, 10);
   orb1CS.setPosition(beamvertSprite.getPosition().x +40, beamvertSprite.getPosition().y -20);

   orb2CS.setFillColor(sf::Color(0, 0, 0));
   orb2CS.setOutlineColor(sf::Color(255, 255, 255));
   orb2CS.setOutlineThickness(2);
   orb2CS.setRadius(10);
   orb2CS.setOrigin(10, 10);
   orb2CS.setPosition(beamhorizSprite.getPosition().x -20, beamhorizSprite.getPosition().y +40);

   orbMarkerCS.setFillColor(sf::Color(0, 0, 0));
   orbMarkerCS.setOutlineColor(sf::Color(255, 255, 255));
   orbMarkerCS.setOutlineThickness(2);
   orbMarkerCS.setRadius(37);
   orbMarkerCS.setOrigin(37, 37);
   orbMarkerCS.setPosition(beamvertSprite.getPosition().x + 40, beamhorizSprite.getPosition().y + 40);

   font.loadFromFile("content/fonts/harrington.ttf");
   nameText.setCharacterSize(50);
   nameText.setFont(font);
   nameText.setFillColor(sf::Color(255, 255, 255));
   nameText.setPosition(windowWidth / 2 -200, windowHeight / 2 -200);

   nameString = "Name Goes Here (placeholder)";
}

void Naming::update(sf::RenderWindow &window)
{
   orbMarkerCS.setPosition(beamvertSprite.getPosition().x + 40, beamhorizSprite.getPosition().y + 40);
   orb1CS.setPosition(beamvertSprite.getPosition().x + 40, beamvertSprite.getPosition().y - 20);
   orb2CS.setPosition(beamhorizSprite.getPosition().x - 20, beamhorizSprite.getPosition().y + 40);

   nameText.setString(nameString);

   window.clear(sf::Color(0, 0, 0));
   window.draw(orb1CS);
   window.draw(orb2CS);
   window.draw(beamvertSprite);
   window.draw(beamhorizSprite);
   window.draw(orbMarkerCS);
   window.draw(bgSprite);
   window.draw(nameText);
   window.display();
}

void Naming::handle_events(sf::RenderWindow &window, sf::Event &event)
{
   if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Up && keyPress == false && !borderTop)
   {
      beamhorizSprite.setPosition(beamhorizSprite.getPosition().x, beamhorizSprite.getPosition().y -100);
      beamvertSprite.setPosition(beamvertSprite.getPosition().x - 50, beamvertSprite.getPosition().y);
      markerY--;
      keyPress = true;
   }
   else if (event.type == sf::Event::KeyReleased && event.key.code == sf::Keyboard::Up)
   {
      keyPress = false;
   }

   if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Down && keyPress == false && !borderBot)
   {
      beamhorizSprite.setPosition(beamhorizSprite.getPosition().x, beamhorizSprite.getPosition().y +100);
      beamvertSprite.setPosition(beamvertSprite.getPosition().x + 50, beamvertSprite.getPosition().y);
      markerY++;
      keyPress = true;
   }
   else if (event.type == sf::Event::KeyReleased && event.key.code == sf::Keyboard::Down)
   {
      keyPress = false;
   }

   if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Left && keyPress == false && !borderLeft)
   {
      beamvertSprite.setPosition(beamvertSprite.getPosition().x - 100, beamvertSprite.getPosition().y);
      markerX--;
      keyPress = true;
   }
   else if (event.type == sf::Event::KeyReleased && event.key.code == sf::Keyboard::Left)
   {
      keyPress = false;
   }

   if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Right && keyPress == false && !borderRight)
   {
      beamvertSprite.setPosition(beamvertSprite.getPosition().x + 100, beamvertSprite.getPosition().y);
      markerX++;
      keyPress = true;   
   }
   else if (event.type == sf::Event::KeyReleased && event.key.code == sf::Keyboard::Right)
   {
      keyPress = false;
   }

   if (markerY == 1)
   {
      borderTop = true;
   }
   else
   {
      borderTop = false;
   }

   if (markerY == 3)
   {
      borderBot = true;
   }
   else
   {
      borderBot = false;
   }

   if (markerX == 1)
   {
      borderLeft = true;
   }
   else
   {
      borderLeft = false;
   }

   if ((markerX == 10 && (markerY == 1 ||  markerY == 2)) || (markerX == 8 && markerY == 3))
   {
      borderRight = true;
   }
   else
   {
      borderRight = false;
   }


/* Here I used the following line instead, which had the explained odd behavior of requiring Alt to be held for Enter to be recognized:
if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Enter && keyPress == false)
*/

   if (sf::Keyboard::isKeyPressed(sf::Keyboard::Enter) && keyPress == false)
   {
      if (caps)
      {
         if (markerX == 1 && markerY == 1)
         {
            nameString += "Q";
            nameText.setString(nameString);      
         }
      }
      keyPress = true;
   }
   else if (event.type == sf::Event::KeyReleased && event.key.code == 58)
   {
      keyPress = false;
   }
   

   // And the lil bit of code I used to help figure out what the issue is. Timer to not have the console spammed full.
   elapsedTime = clock.getElapsedTime();
   if (elapsedTime.asSeconds() >= 3)
   {
      std::cout << "Button is pressed: " << event.key.code << "\n";
      clock.restart();
   }
   
}

(click to show/hide)

Oh yeah, looking at it again reminded me of something else.
While checking the keypressed with event doesn't recognize the normal 'Enter' as 'Enter' (enum index 58 of sf::keyboard), the keyreleased does correctly recognize it.
So it's exclusively keypressed that (for some reason) needs alt to be held for 'Enter' to be recognized.

[eXpl0it3r]

As suspected, you're checking the event variable outside of the event loop. You need to poll all the events and check the event variable inside the event loop, otherwise you only get stale or even invalid data.

See the events tutorial for the correct approach.

[Chyro]

Correct me if I'm wrong, but I think it is inside the event loop?
If you check main.cpp, it's actually that loop that is running everything. On the line
  'currentState->handle_events(window, event);' (marked it with red in the spoiler above)
Is where the code with the issue is being called, with currentState being 'Naming', and that's inside the event loop. I'm passing the sf::event into the function so that it can be used and affected by the different game states while still being the same (one and only) event created in the main loop.

I mean.. if it got stale and invalid data, then the arrow-keys also wouldn't be recognized, no? But they are fully and correctly recognized, with the same code. And it does recognize other keys like Enter, Space, and letters - but only if alt is held while pressing them. Also, in another state (the title menu) that also gets the 'event' passed to it and uses it for checking key presses, the arrow keys as well as Enter + Space inputs get correctly recognized. If I used it wrongly, would stale/invalid data really cause this many keys to be recognized correctly? (not trying to pointlessly argue, but trying to understand why it works fine for the arrow keys and in another state, but not for other keys)

.. I did read the tutorial page about Events multiple times, and I admit I still don't 100% understand it. Am generally learning and trying to understand things through appying them, by trial and error and logic. I do read the theory, but often struggle to understand it until I try out the examples in different scenarios, see how it works, when it doesnt, and then figure out why it doesn't.

(as a side note, normally the program runs through the states starting with INTRO -> INTRO2 -> TITLE -> NAMING, but for testing / debugging I made it start with NAMING. Each of the other states is checking the event from main.cpp for a pressed Enter to progress (title menu also using arrows to navigate), and in each of them it works fine)

[Arcade]

eXpl0it3r was referring to this loop

sf::Event event;
while (window.pollEvent(event))
{
   if (event.type == sf::Event::Closed)
   {
      window.close();
   }
}
 

You should be handling all of your events in here, not just sf::Event::Closed. Think about what would happen if multiple events came in at the same time (for example, keyboard press and mouse move). You will be looping through them and throwing all but the last one away. Only the last event will make it beyond this code.

Also think about what would happen if you didn't have any events come in since the last frame. event will be left uninitialized, but you are passing it along to your states anyway with whatever random data it contains.

I haven't gone through all of your code to see if this is directly causing your problems or not, but it would be worth fixing this.

---

Also

std::cout << "Pressed button: " << event.key.code << "\n";
 

Why not put this directly in the above event loop to see if you're ever receiving the Enter key event (don't forget to check type==sf::Event::KeyPressed first).

[eXpl0it3r]

Basically what Arcade said.

Also a general rule of thumb, just because something "works" doesn't mean it's correct, especially when other things are not working.

while(window.isOpen())
{
    // ...
}

That's your main/game loop. As long as the window is open do X.

while(window.pollEvent(event)
{
    // ...
}

That's your event loop. As long as there are new events, write them into the event variable and do X.
Only within that loop, should you process events.

[Chyro]

Alright, thanks for the advice.
After a second look I realized that it was in the 'window open' loop, but not inside the poll.event loop.
So I moved the event handler function into the event loop (also the global check for 'Escape' to close the window or go back to title menu, depending on state). And now it works fine.

.. at first I just moved all the main functions into the loop, but realized that makes everything pause as long as there's no event (was kinda funny, the animations and progression always paused unless I kept moving the mouse) but then moved the parts not relevant to events back out ^^

Now everything works as intended, thanks!