input.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software 
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#ifndef __INPUT_HEADER__
#define __INPUT_HEADER__

#include "utils.h"
#include "defs.h"

namespace hoa_input {

extern GameInput* InputManager;

extern bool INPUT_DEBUG;

/* \brief Handles pausing/unpausing for battle mode (special case)
* \note Placed here so it's visible from QuitMode as well
*/
void TEMP_HandlePause();


namespace private_input {

const int16 JOYAXIS_THRESHOLD = 8192;

class KeyState {
public:
  SDLKey up;
  SDLKey down;
  SDLKey left;
  SDLKey right;
  SDLKey confirm;
  SDLKey cancel;
  SDLKey menu;
  SDLKey swap;
  SDLKey left_select;
  SDLKey right_select;
  SDLKey pause;
}; // class KeyState

class JoystickState {
public:
  SDL_Joystick *js;

  int32 joy_index;



  uint8 confirm;
  uint8 cancel;
  uint8 menu;
  uint8 swap;
  uint8 left_select;
  uint8 right_select;
  uint8 pause;
  uint8 quit;



  int16 x_previous_peak;
  int16 y_previous_peak;



  int16 x_current_peak;
  int16 y_current_peak;

  friend class GameInput;
}; // class JoystickState

} // namespace private_input

class GameInput : public hoa_utils::Singleton<GameInput> {
  friend class hoa_utils::Singleton<GameInput>;

private:
  GameInput();

  private_input::KeyState _key;

  private_input::JoystickState _joystick;


  bool _any_key_press;

  bool _any_key_release;

  bool _up_state;
  bool _down_state;
  bool _left_state;
  bool _right_state;
  bool _confirm_state;
  bool _cancel_state;
  bool _menu_state;
  bool _swap_state;
  bool _left_select_state;
  bool _right_select_state;

  bool _up_press;
  bool _down_press;
  bool _left_press;
  bool _right_press;
  bool _confirm_press;
  bool _cancel_press;
  bool _menu_press;
  bool _swap_press;
  bool _left_select_press;
  bool _right_select_press;

  bool _up_release;
  bool _down_release;
  bool _left_release;
  bool _right_release;
  bool _confirm_release;
  bool _cancel_release;
  bool _menu_release;
  bool _swap_release;
  bool _left_select_release;
  bool _right_select_release;

  bool _joyaxis_x_first;
  bool _joyaxis_y_first;

  void _KeyEventHandler(SDL_KeyboardEvent& key_event);
  void _JoystickEventHandler(SDL_Event& js_event);

  void _SetNewKey(SDLKey & old_key, SDLKey new_key);

  void _SetNewJoyButton(uint8 & old_button, uint8 new_button);
public:
  ~GameInput();

  bool SingletonInitialize ();

  bool RestoreDefaultKeys();

  bool RestoreDefaultJoyButtons();

  bool AnyKeyPress();

  bool AnyKeyRelease();

  void TogglePause();
  void EventHandler();

  bool UpState() 
    { return _up_state; }
  bool DownState() 
    { return _down_state; }
  bool LeftState() 
    { return _left_state; }
  bool RightState() 
    { return _right_state; }
  bool ConfirmState() 
    { return _confirm_state; }
  bool CancelState() 
    { return _cancel_state; }
  bool MenuState() 
    { return _menu_state; }
  bool SwapState() 
    { return _swap_state; }
  bool LeftSelectState() 
    { return _left_select_state; }
  bool RightSelectState() 
    { return _right_select_state; }

  bool UpPress() 
    { return _up_press; }
  bool DownPress() 
    { return _down_press; }
  bool LeftPress() 
    { return _left_press; }
  bool RightPress() 
    { return _right_press; }
  bool ConfirmPress() 
    { return _confirm_press; }
  bool CancelPress() 
    { return _cancel_press; }
  bool MenuPress() 
    { return _menu_press; }
  bool SwapPress() 
    { return _swap_press; }
  bool LeftSelectPress() 
    { return _left_select_press; }
  bool RightSelectPress() 
    { return _right_select_press; }

  bool UpRelease() 
    { return _up_release; }
  bool DownRelease() 
    { return _down_release; }
  bool LeftRelease() 
    { return _left_release; }
  bool RightRelease() 
    { return _right_release; }
  bool ConfirmRelease() 
    { return _confirm_release; }
  bool CancelRelease() 
    { return _cancel_release; }
  bool MenuRelease() 
    { return _menu_release; }
  bool SwapRelease() 
    { return _swap_release; }
  bool LeftSelectRelease() 
    { return _left_select_release; }
  bool RightSelectRelease() 
    { return _right_select_release; }

  std::string GetUpKeyName() const { return SDL_GetKeyName(_key.up); }
  std::string GetDownKeyName() const { return SDL_GetKeyName(_key.down); }
  std::string GetLeftKeyName() const { return SDL_GetKeyName(_key.left); }
  std::string GetRightKeyName() const { return SDL_GetKeyName(_key.right); }
  std::string GetConfirmKeyName() const { return SDL_GetKeyName(_key.confirm); }
  std::string GetCancelKeyName() const { return SDL_GetKeyName(_key.cancel); }
  std::string GetMenuKeyName() const { return SDL_GetKeyName(_key.menu); }
  std::string GetSwapKeyName() const { return SDL_GetKeyName(_key.swap); }
  std::string GetLeftSelectKeyName() const { return SDL_GetKeyName(_key.left_select); }
  std::string GetRightSelectKeyName() const { return SDL_GetKeyName(_key.right_select); }
  std::string GetPauseKeyName() const { return SDL_GetKeyName(_key.pause); }

  int32 GetConfirmJoy() const { return _joystick.confirm; }
  int32 GetCancelJoy() const { return _joystick.cancel; }
  int32 GetMenuJoy() const { return _joystick.menu; }
  int32 GetSwapJoy() const { return _joystick.swap; }
  int32 GetLeftSelectJoy() const { return _joystick.left_select; }
  int32 GetRightSelectJoy() const { return _joystick.right_select; }
  int32 GetPauseJoy() const { return _joystick.pause; }

  void SetUpKey(const SDLKey & key) { _SetNewKey(_key.up, key); }
  void SetDownKey(const SDLKey & key) { _SetNewKey(_key.down, key); }
  void SetLeftKey(const SDLKey & key) { _SetNewKey(_key.left, key); }
  void SetRightKey(const SDLKey & key) { _SetNewKey(_key.right, key); }
  void SetConfirmKey(const SDLKey & key) { _SetNewKey(_key.confirm, key); }
  void SetCancelKey(const SDLKey & key) { _SetNewKey(_key.cancel, key); }
  void SetMenuKey(const SDLKey & key) { _SetNewKey(_key.menu, key); }
  void SetSwapKey(const SDLKey & key) { _SetNewKey(_key.swap, key); }
  void SetLeftSelectKey(const SDLKey & key) { _SetNewKey(_key.left_select, key); }
  void SetRightSelectKey(const SDLKey & key) { _SetNewKey(_key.right_select, key); }
  void SetPauseKey(const SDLKey & key) { _SetNewKey(_key.pause, key); }

  void SetConfirmJoy(uint8 button) { _SetNewJoyButton(_joystick.confirm, button); }
  void SetCancelJoy(uint8 button) { _SetNewJoyButton(_joystick.cancel, button); }
  void SetMenuJoy(uint8 button) { _SetNewJoyButton(_joystick.menu, button); }
  void SetSwapJoy(uint8 button) { _SetNewJoyButton(_joystick.swap, button); }
  void SetLeftSelectJoy(uint8 button) { _SetNewJoyButton(_joystick.left_select, button); }
  void SetRightSelectJoy(uint8 button) { _SetNewJoyButton(_joystick.right_select, button); }
  void SetPauseJoy(uint8 button) { _SetNewJoyButton(_joystick.pause, button); }

  int32 GetUpKey() const { return _key.up; }
  int32 GetDownKey() const { return _key.down; }
  int32 GetLeftKey() const { return _key.left; }
  int32 GetRightKey() const { return _key.right; }
  int32 GetConfirmKey() const { return _key.confirm; }
  int32 GetCancelKey() const { return _key.cancel; }
  int32 GetMenuKey() const { return _key.menu; }
  int32 GetSwapKey() const { return _key.swap; }
  int32 GetLeftSelectKey() const { return _key.left_select; }
  int32 GetRightSelectKey() const { return _key.right_select; }
  int32 GetPauseKey() const { return _key.pause; }

}; // class GameInput

} // namespace hoa_input

#endif

---