InputHandler class v.2, now controlls mouse-events, joystick-events and keyboard-events, clean code

Author: JOGUI22

InputHandler.cpp

@@ -5,12 +5,24 @@ InputHandler* InputHandler::s_pInstance = 0; //IMPORTANT TO MAKE SINGLETON WORK
 
 InputHandler::InputHandler()
 {
-    //ctor
+    for (int i = 0; i < 3; i++)
+    {
+        m_mouseButtonStates.push_back(false); //incialitze vector of buttons from mouse
+    }
+    m_mousePosition = new Vector2D(0,0);
 }
 
 InputHandler::~InputHandler()
 {
+    // delete anything we created dynamically
+    delete m_keystates;
+    delete m_mousePosition;
 
+    // clear our arrays
+    m_joystickValues.clear();
+    m_joysticks.clear();
+    m_buttonStates.clear();
+    m_mouseButtonStates.clear();
 }
 
 void InputHandler::initialiseJoysticks()
@@ -27,7 +39,17 @@ void InputHandler::initialiseJoysticks()
             SDL_Joystick* joy = SDL_JoystickOpen(i);
             if (SDL_JoystickOpen(i) != NULL) // try to activate the joystick, otherwise show the error
             {
-                m_joysticks.push_back(joy);
+                m_joysticks.push_back(joy); // add to vector of joystick id
+                m_joystickValues.push_back(make_pair(new Vector2D(0,0), new Vector2D(0,0))); //inicialize values for joystick axis
+
+                vector<bool> tempButtons; //buttons of the joystick
+
+                for (int j = 0; j < SDL_JoystickNumButtons(joy); j++)
+                {
+                    tempButtons.push_back(false);
+                }
+
+                m_buttonStates.push_back(tempButtons); //add buttons of the joystick to the vector of buttons of joystickS
             }
             else
             {
@@ -54,7 +76,7 @@ void InputHandler::clean()
 {
     if(m_bJoysticksInitialised)
     {
-        for(int i= 0; i < SDL_NumJoysticks(); i++)
+        for(int i= 0; i < SDL_NumJoysticks(); i++) //clean joysticks opened
         {
             SDL_JoystickClose(m_joysticks[i]);
         }
@@ -66,9 +88,248 @@ void InputHandler::update()
     SDL_Event event;
     while(SDL_PollEvent(&event))
     {
-        if(event.type == SDL_QUIT)
+        switch (event.type)
+        {
+            case SDL_QUIT:
+                TheGame::Instance()->quit();
+                break;
+
+            case SDL_JOYAXISMOTION:
+                onJoystickAxisMove(event);
+                break;
+
+            case SDL_JOYBUTTONDOWN:
+                onJoystickButtonDown(event);
+                break;
+
+            case SDL_JOYBUTTONUP:
+                onJoystickButtonUp(event);
+                break;
+
+            case SDL_MOUSEMOTION:
+                onMouseMove(event);
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+                onMouseButtonDown(event);
+                break;
+
+            case SDL_MOUSEBUTTONUP:
+                onMouseButtonUp(event);
+                break;
+
+            case SDL_KEYDOWN:
+                onKeyDown();
+                break;
+
+            case SDL_KEYUP:
+                onKeyUp();
+                break;
+
+            default:
+                break;
+        }
+    }
+}
+
+void InputHandler::onKeyDown()
+{
+    m_keystates = SDL_GetKeyboardState(0);
+}
+
+void InputHandler::onKeyUp()
+{
+    m_keystates = SDL_GetKeyboardState(0);
+}
+
+void InputHandler::onMouseMove(SDL_Event &event)
+{
+    m_mousePosition->setX(event.motion.x);
+    m_mousePosition->setY(event.motion.y);
+}
+
+void InputHandler::onMouseButtonDown(SDL_Event &event)
+{
+    if(event.button.button == SDL_BUTTON_LEFT)
+    {
+        m_mouseButtonStates[LEFT] = true;
+    }
+
+    if(event.button.button == SDL_BUTTON_MIDDLE)
+    {
+        m_mouseButtonStates[MIDDLE] = true;
+    }
+
+    if(event.button.button == SDL_BUTTON_RIGHT)
+    {
+        m_mouseButtonStates[RIGHT] = true;
+    }
+}
+
+void InputHandler::onMouseButtonUp(SDL_Event &event)
+{
+    if(event.button.button == SDL_BUTTON_LEFT)
+    {
+        m_mouseButtonStates[LEFT] = false;
+    }
+
+    if(event.button.button == SDL_BUTTON_MIDDLE)
+    {
+        m_mouseButtonStates[MIDDLE] = false;
+    }
+
+    if(event.button.button == SDL_BUTTON_RIGHT)
+    {
+        m_mouseButtonStates[RIGHT] = false;
+    }
+}
+
+void InputHandler::onJoystickAxisMove(SDL_Event &event)
+{
+    int whichOne = event.jaxis.which;
+
+    // left stick move left or right
+    if(event.jaxis.axis == 0)
+    {
+        if (event.jaxis.value > m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].first->setX(1);
+        }
+        else if(event.jaxis.value < -m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].first->setX(-1);
+        }
+        else
+        {
+            m_joystickValues[whichOne].first->setX(0);
+        }
+    }
+
+    // left stick move up or down
+    if(event.jaxis.axis == 1)
+    {
+        if (event.jaxis.value > m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].first->setY(1);
+        }
+        else if(event.jaxis.value < -m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].first->setY(-1);
+        }
+        else
+        {
+            m_joystickValues[whichOne].first->setY(0);
+        }
+    }
+
+    // right stick move left or right
+    if(event.jaxis.axis == 3)
+    {
+        if (event.jaxis.value > m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].second->setX(1);
+        }
+        else if(event.jaxis.value < -m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].second->setX(-1);
+        }
+        else
+        {
+            m_joystickValues[whichOne].second->setX(0);
+        }
+    }
+
+    // right stick move up or down
+    if(event.jaxis.axis == 4)
+    {
+        if (event.jaxis.value > m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].second->setY(1);
+        }
+        else if(event.jaxis.value < -m_joystickDeadZone)
+        {
+            m_joystickValues[whichOne].second->setY(-1);
+        }
+        else
+        {
+            m_joystickValues[whichOne].second->setY(0);
+        }
+    }
+}
+
+void InputHandler::onJoystickButtonDown(SDL_Event &event)
+{
+    int whichOne = event.jaxis.which;
+
+    m_buttonStates[whichOne][event.jbutton.button] = true;
+}
+
+void InputHandler::onJoystickButtonUp(SDL_Event &event)
+{
+    int whichOne = event.jaxis.which;
+
+    m_buttonStates[whichOne][event.jbutton.button] = false;
+}
+
+int InputHandler::xvalue(int joy, int stick)
+{
+    if(m_joystickValues.size() > 0)
+    {
+        if (stick == 1)
+        {
+            return m_joystickValues[joy].first->getX();
+        }
+        else if (stick == 2)
+        {
+            return m_joystickValues[joy].second->getX();
+        }
+    }
+    return 0;
+}
+
+int InputHandler::yvalue(int joy, int stick)
+{
+    if(m_joystickValues.size() > 0)
+    {
+        if (stick == 1)
+        {
+            return m_joystickValues[joy].first->getY();
+        }
+        else if (stick == 2)
+        {
+            return m_joystickValues[joy].second->getY();
+        }
+    }
+    return 0;
+}
+
+bool InputHandler::getJoyButtonState(int joy, int buttonNumber)
+{
+    return m_buttonStates[joy][buttonNumber];
+}
+
+bool InputHandler::getMouseButtonState(int buttonNumber)
+{
+    return m_mouseButtonStates[buttonNumber];
+}
+
+Vector2D* InputHandler::getMousePosition()
+{
+    return m_mousePosition;
+}
+
+bool InputHandler::isKeyDown(SDL_Scancode key)
+{
+    if(m_keystates != 0)
+    {
+        if(m_keystates[key] == 1)
+        {
+            return true;
+        }
+        else
         {
-            TheGame::Instance()->quit();
+            return false;
         }
     }
+    return false;
 }

InputHandler.h

@@ -4,8 +4,16 @@
 #include "SDL2/SDL.h"
 #include <iostream>
 #include <vector>
+#include "Vector2D.h"
 
 using namespace std;
+
+enum mouse_buttons
+{
+    LEFT = 0,
+    MIDDLE = 1,
+    RIGHT = 2
+};
 
 class InputHandler
 {
@@ -26,20 +34,55 @@ class InputHandler
 
         void initialiseJoysticks(); //pre: -- //post: initialise joystick handling
         bool joysticksInitialised(); //pre: -- //post: return if joysticks are initialised
-
+
+        int xvalue(int joy, int stick); //pre: joy is the joystick ID, stick 1 is left, stick 2 is right //post: return x value
+        int yvalue(int joy, int stick); //pre: joy is the joystick ID, stick 1 is left, stick 2 is right //post: return y value
+
+        //GET METHODS
+        bool getJoyButtonState(int joy, int buttonNumber); //get the state of the buttonNumber from joy.
+        bool getMouseButtonState(int buttonNumber); //get the state of the buttonNumber from mouse
+        Vector2D* getMousePosition(); //get the actual Vector2D coords of the mouse in the window
+        bool isKeyDown(SDL_Scancode key); //check if a keyboard key is down
+
     private:
 
         //Atribute members
         vector<SDL_Joystick* > m_joysticks; //all the connected joysticks
         bool m_bJoysticksInitialised; //are joystick initialisated?
+        vector<pair<Vector2D*, Vector2D* > > m_joystickValues; //values of axis joystic
+        vector< vector<bool> > m_buttonStates; //matrix with buttons input
+        vector<bool> m_mouseButtonStates; //vector with the state of mouse buttons
+        Vector2D* m_mousePosition; //vector with the actual position in the window of the cursor(mouse)
+        const Uint8* m_keystates;
+
+        //SINGLETON
+        static InputHandler* s_pInstance; //the own instance
+
+        //Constants
+        const int m_joystickDeadZone = 10000; //Value has to change accordingly to the controller type
+
 
         //Private methods
         InputHandler(); //SINGLETON private constructor
         ~InputHandler(); //SINGLETON private destructor
 
-        //SINGLETON
-        static InputHandler* s_pInstance; //the own instance
-};
+        //Private functions to handle different event types
+
+        //handle keyboard events
+        void onKeyDown();
+        void onKeyUp();
+
+        //handle mpuse events
+        void onMouseMove(SDL_Event& event);
+        void onMouseButtonDown(SDL_Event& event);
+        void onMouseButtonUp(SDL_Event& event);
+
+        //handle joysticks events
+        void onJoystickAxisMove(SDL_Event& event);
+        void onJoystickButtonDown(SDL_Event& event);
+        void onJoystickButtonUp(SDL_Event& event);
+
+        };
 
 typedef InputHandler TheInputHandler; //only one singleton in all the program