kg: comparison src/Input.hh

equal deleted inserted replaced

-:7e0cfc5f0944
+:440763821484
 #ifndef INPUT_HH
 #define INPUT_HH
-#include <stdint.h>
+#include "Timer.hh"
+#include "Types.hh"
 #include <ClanLib/Display/input_device.h>
 #include <ClanLib/Display/keys.h>
+#include <queue>
 // const TimeMS INPUT_INTERVAL_MS = 20;
+/**
+* Flags to control input behaviour
+*/
+enum InputFlagBits {
+/** Default */
+INPUT_FLAG_REPEAT   = 0x0000,
+INPUT_FLAG_NOREPEAT = 0x0001,
+};
 /**
 * The bits used in the PlayerInput bitmask, each represents a separate action handled by LocalPlayer::handleInput.
 *
 * @see LocalPlayer::handleInput
 /**
 * The bits used in the GuiInput bitmask, each represents something handled locally by Graphics.
 */
 enum GuiInputBit {
+GUI_INPUT_NONE              = 0x0000,
 GUI_INPUT_QUIT              = 0x0001,
 GUI_INPUT_DISPLAY_WEAPON    = 0x0002,
 GUI_INPUT_DEBUG_PLAYER      = 0x0004,
 };
 /**
+* Bitmask of InputFlagBits
+*/
+typedef uint8_t InputFlags;
+/**
 * Bitmask of PlayerInputBits
 *
 * @see PlayerInputBit
 */
 typedef uint16_t PlayerInput;
 * @see GuiInputBit
 */
 typedef uint16_t GuiInput;
 /**
-* Keymap definition used in Input.cc
+* Keymap definition struct
 */
-template <typename BitEnumType> struct InputKeymapEntry;
+template <typename BitEnumType> struct InputKeymapEntry {
+/**
+* The input bit to set if present
+*/
+BitEnumType input;
+/**
+* Flags to use
+*
+* @see InputFlagBits
+*/
+InputFlags flags;
+/**
+* Up to two keycodes to check
+*/
+int keycodes[2];
+};
+/**
+* A InputKeyRepeatQueue entry, this contains the input bit value itself, and then the remaining expire time
+*/
+template <typename BitEnumType> struct InputKeyRepeatEntry {
+BitEnumType value;
+TimeMS expire;
+public:
+InputKeyRepeatEntry (BitEnumType value, TimeMS expire);
+/**
+* Since priority_queue always gives the greatest item, the one with the longest expire is the least item
+*/
+bool operator< (const struct InputKeyRepeatEntry &other);
+/**
+* Decrements expire, returning true if it has now expired, false otherwise
+*/
+bool updateExpired (TimeMS dt);
+};
+/**
+* A InputKeyRepeatQueue maintains a list of InputKeyRepeatEntry's, lets you add new input values, find old ones,
+* and update the list
+*/
+template <typename BitEnumType> class InputKeyRepeatQueue {
+private:
+TimeMS expire;
+typedef InputKeyRepeatEntry<BitEnumType> entry_type;
+std::list<entry_type> list;
+typedef typename std::list<entry_type>::iterator list_iterator;
+public:
+/**
+* Constructs this queue to contain entries with the given expiry time
+*/
+InputKeyRepeatQueue (TimeMS expire);
+/**
+* Push a new input bit onto the queue
+*/
+void push (BitEnumType bit);
+/**
+* Checks if the given input is in the queue
+*/
+bool find (BitEnumType bit);
+/**
+* Updates the list, removing expired items
+*/
+void update (TimeMS dt);
+};
+/**
+* An InputHandler uses an InputKeymapEntry to maintain a BitMaskType of current inputs
+*/
+template <typename BitEnumType, typename BitMaskType> class InputHandler {
+private:
+/**
+* The keyboard that we read input from
+*/
+CL_InputDevice &keyboard;
+/**
+* The keymap that we use
+*/
+InputKeymapEntry<BitEnumType> *keymap;
+/**
+* The current bitmask value
+*/
+BitMaskType value;
+/**
+* How long the bitmask was held...
+*/
+TimeMS dt;
+/**
+* The KeyRepeatQueue
+*/
+InputKeyRepeatQueue<BitEnumType> queue;
+public:
+/**
+* Constructs the InputHandler using the given keyboard, keymap and key-repeat expire time
+*/
+InputHandler (CL_InputDevice &keyboard, InputKeymapEntry<BitEnumType> *keymap, TimeMS keyrepeat_expire);
+private:
+/**
+* Returns true if the keycode is valid, false if not.
+*
+* A positive keycode requires that the keycode be active, a negative keycode that the keycode be inactive,
+* and a zero keycode always returns true.
+*
+* @param keycode A positive keycode to check that it's set, negative keycode to check that it's not set, or zero
+* @returns bool true if positive+set/negavtive+notset/zero, false otherwise
+*/
+bool checkKeycode (int keycode);
+public:
+/**
+* Updates the keyrepeat queue
+*/
+void update (TimeMS dt);
+/**
+* Reads the current input mask value and length into mask and dt, and reset ours to zero
+*
+* @param mask our BitMaskType value is returned using this
+* @param dt how long the input was held for
+*/
+void readValue (BitMaskType &mask, TimeMS &dt);
+};
 /**
 * Handles reading input from a keyboard and mapping it to PlayerInput/GuiInput bitmasks
 */
 class Input {
 protected:
+/**
+* The keyboard device that we use
+*/
 CL_InputDevice &keyboard;
-public:
+/**
+* Our update timer
+*/
+Timer update_timer;
+CL_SlotContainer slots;
+/**
+* Our PlayerInput
+*/
+InputHandler<PlayerInputBit, PlayerInput> player;
+/**
+* Our GuiInput
+*/
+InputHandler<GuiInputBit, GuiInput> gui;
+public:
+/**
+* Build the input handler using the given keyboard and the default keymaps
+*/
 Input (CL_InputDevice &keyboard);
-private:
+public:
-bool checkKeycode (int keycode);
+/**
-template <typename BitEnumType, typename BitMaskType> BitMaskType buildMask (InputKeymapEntry<BitEnumType> *keymap);
+* Reads the current PlayerInput value via mask, and the length of the input via dt
+*/
-public:
+void readPlayerInput (PlayerInput &mask, TimeMS &dt);
-/*
-* Reads the keyboard to determine current state of the Player/Gui input
+/**
-*/
+* Reads the current GuiInput mask and returns it
-PlayerInput readPlayerInput (void);
+*/
 GuiInput readGuiInput (void);
 };
 #endif

changeset 311	440763821484
parent 300	417183866f35
child 319	9f6a838d58c4