1

     2

#include "Input.hh"

     3

#include "Engine.hh"

     4

#include "Config.hh"

     5

     6

InputKeymapEntry<PlayerInputBit> INPUT_PLAYER_KEYMAP[] = {

     7

    {   INPUT_AIM_UP,       INPUT_FLAG_UNLIMITED,   { -CL_KEY_ENTER,    CL_KEY_UP       } },

     8

    {   INPUT_AIM_DOWN,     INPUT_FLAG_UNLIMITED,   { -CL_KEY_ENTER,    CL_KEY_DOWN     } },

     9

    {   INPUT_MOVE_LEFT,    INPUT_FLAG_UNLIMITED,   { -CL_KEY_ENTER,    CL_KEY_LEFT     } },

    10

    {   INPUT_MOVE_RIGHT,   INPUT_FLAG_UNLIMITED,   { -CL_KEY_ENTER,    CL_KEY_RIGHT    } },

    11

    {   INPUT_JUMP,         INPUT_FLAG_SLOWREPEAT,  { -CL_KEY_ENTER,    CL_KEY_RSHIFT   } },

    12

    {   INPUT_DIG,          INPUT_FLAG_NOREPEAT,    { CL_KEY_LEFT,      CL_KEY_RIGHT    } },

    13

    {   INPUT_SHOOT,        INPUT_FLAG_UNLIMITED,   { CL_KEY_RCONTROL,  0               } },

    14

    {   INPUT_CHANGE_PREV,  INPUT_FLAG_SLOWREPEAT,  { CL_KEY_ENTER,     CL_KEY_LEFT     } },

    15

    {   INPUT_CHANGE_NEXT,  INPUT_FLAG_SLOWREPEAT,  { CL_KEY_ENTER,     CL_KEY_RIGHT    } },

    16

    {   INPUT_ROPE,         INPUT_FLAG_NOREPEAT,    { CL_KEY_ENTER,     CL_KEY_RSHIFT   } },

    17

    {   INPUT_UNROPE,       INPUT_FLAG_SLOWREPEAT,  { -CL_KEY_ENTER,    CL_KEY_RSHIFT   } },

    18

    {   INPUT_ROPE_UP,      INPUT_FLAG_UNLIMITED,   { CL_KEY_ENTER,     CL_KEY_UP       } },

    19

    {   INPUT_ROPE_DOWN,    INPUT_FLAG_UNLIMITED,   { CL_KEY_ENTER,     CL_KEY_DOWN     } },

    20

    {   INPUT_SUICIDE,      INPUT_FLAG_NOREPEAT,    { CL_KEY_LCONTROL,  CL_KEY_K        } },

    21

    {   INPUT_NONE,         0,                      { 0,                0               } }

    22

};

    23

    24

InputKeymapEntry<GuiInputBit> INPUT_GUI_KEYMAP[] = {

    25

    {   GUI_INPUT_QUIT,                 0,                  { CL_KEY_ESCAPE,    0               } },

    26

    {   GUI_INPUT_DISPLAY_WEAPON,       0,                  { CL_KEY_ENTER,     0               } },

    27

    {   GUI_INPUT_DEBUG_PLAYER,         0,                  { CL_KEY_I,         0               } },

    28

    {   GUI_INPUT_TOGGLE_FULLSCREEN,    INPUT_FLAG_NOREPEAT,{ CL_KEY_LCONTROL,  CL_KEY_F        } },

    29

    {   GUI_INPUT_NONE,                 0,                  { 0,                0,              } }

    30

};

    31

    32

/*

    33

 * InputKeyRepeatEntry

    34

 */

    35

template <typename BitEnumType> 

    36

InputKeyRepeatEntry<BitEnumType>::InputKeyRepeatEntry (BitEnumType value, TimeMS expire) : 

    37

    value(value), expire(expire) 

    38

{

    39

    40

}

    41

    42

template <typename BitEnumType> 

    43

bool InputKeyRepeatEntry<BitEnumType>::operator< (const struct InputKeyRepeatEntry &other) {

    44

    return other.expire > expire;

    45

}

    46

    47

template <typename BitEnumType> 

    48

bool InputKeyRepeatEntry<BitEnumType>::updateExpired (TimeMS dt) {

    49

    if (expire == 0)

    50

        return false;

    51

    52

    expire -= dt;

    53

    54

    return (expire <= 0);

    55

}

    56

    57

/*

    58

 * InputKeyRepeatQueue

    59

 */

    60

template <typename BitEnumType> 

    61

InputKeyRepeatQueue<BitEnumType>::InputKeyRepeatQueue (TimeMS expire) :

    62

    expire(expire)

    63

{

    64

    65

}

    66

    67

template <typename BitEnumType> 

    68

void InputKeyRepeatQueue<BitEnumType>::push (BitEnumType bit, bool expire) {

    69

    list.push_back(InputKeyRepeatEntry<BitEnumType>(bit, expire ? this->expire : 0));

    70

}

    71

    72

template <typename BitEnumType> 

    73

void InputKeyRepeatQueue<BitEnumType>::forget (BitEnumType bit) {

    74

    // go through the list, looking for it

    75

    for (list_iterator it = list.begin(); it != list.end(); it++) {

    76

        if (it->value == bit) {

    77

            // found, erase it and return

    78

            list.erase(it);

    79

    80

            return;

    81

        }

    82

    }

    83

}

    84

    85

template <typename BitEnumType> 

    86

bool InputKeyRepeatQueue<BitEnumType>::find (BitEnumType bit) {

    87

    for (list_iterator it = list.begin(); it != list.end(); it++) {

    88

        if (it->value == bit)

    89

            return true;

    90

    }

    91

    92

    return false;

    93

}

    94

    95

template <typename BitEnumType> 

    96

void InputKeyRepeatQueue<BitEnumType>::update (TimeMS dt) {

    97

    list_iterator it = list.begin();

    98

    99

    // go through each entry, updateExpired and remove if expired

   100

    while (it != list.end()) {

   101

        if (it->updateExpired(dt))

   102

            it = list.erase(it);

   103

        else

   104

            it++;

   105

    }

   106

}

   107

   108

/*

   109

 * InputHandler

   110

 */

   111

template <typename BitEnumType, typename BitMaskType> 

   112

InputHandler<BitEnumType, BitMaskType>::InputHandler (CL_InputDevice &keyboard, InputKeymapEntry<BitEnumType> *keymap, TimeMS keyrepeat_expire) :

   113

    keyboard(keyboard), 

   114

    keymap(keymap), 

   115

    value(0), 

   116

    prev_value(0),

   117

    dt(0),

   118

    queue(keyrepeat_expire)

   119

{

   120

   121

}

   122

   123

template <typename BitEnumType, typename BitMaskType> 

   124

bool InputHandler<BitEnumType, BitMaskType>::checkKeycode (int keycode) {

   125

    if (keycode > 0)

   126

        return keyboard.get_keycode(keycode);

   127

   128

    else if (keycode < 0)

   129

        return !keyboard.get_keycode(-keycode);

   130

   131

    else // == 0

   132

        return true;

   133

}

   134

   135

template <typename BitEnumType, typename BitMaskType> 

   136

void InputHandler<BitEnumType, BitMaskType>::readValue (BitMaskType &mask, TimeMS &dt) {

   137

    // copy to args

   138

    mask = this->value;

   139

    dt = this->dt;

   140

   141

    this->value = 0;

   142

    this->dt = 0;

   143

}

   144

   145

template <typename BitEnumType, typename BitMaskType> 

   146

void InputHandler<BitEnumType, BitMaskType>::update (TimeMS dt) {

   147

    // all bits that are held down, even those ignored

   148

    BitMaskType raw_value = 0;

   149

   150

    // update the key-repeat queue

   151

    queue.update(dt);

   152

   153

    // then go through the keymap

   154

    for (InputKeymapEntry<BitEnumType> *e = keymap; e->input != 0; e++) {

   155

        // check if we've got the correct keycodes

   156

        if (checkKeycode(e->keycodes[0]) && checkKeycode(e->keycodes[1])) {

   157

            // set raw_value

   158

            raw_value |= e->input;

   159

   160

            if (e->flags & INPUT_FLAG_SLOWREPEAT) {

   161

                // repeat, but slowly

   162

                if (!(prev_value & e->input)) {

   163

                    // we've released the key earlier, move it to the back of the queue

   164

                    queue.forget(e->input);

   165

                    queue.push(e->input);

   166

   167

                } else if (queue.find(e->input)) {

   168

                    // it's still in the queue, so ignore, but set it in ignore_value

   169

                    continue;

   170

   171

                } else {

   172

                    // ok, but add it to the queue

   173

                    queue.push(e->input);

   174

                }

   175

   176

            } else if (e->flags & INPUT_FLAG_NOREPEAT) {

   177

                // do not repeat at all

   178

                if (prev_value & e->input) {

   179

                    // ignore repeats

   180

                    continue;

   181

                }

   182

            }

   183

   184

            // set bit in masks

   185

            this->value |= e->input;

   186

        }

   187

    }

   188

   189

    // update prev_value, also adding ignored values

   190

    prev_value = raw_value;

   191

   192

    // then increment our dt

   193

    this->dt += dt;

   194

}

   195

   196

/**

   197

 * Input

   198

 */

   199

Input::Input (CL_InputDevice &keyboard) :

   200

    keyboard(keyboard),

   201

    update_timer(INPUT_POLL_INTERVAL),

   202

    player(keyboard, INPUT_PLAYER_KEYMAP, INPUT_REPEAT_DELAY),

   203

    gui(keyboard, INPUT_GUI_KEYMAP, INPUT_REPEAT_DELAY)

   204

{

   205

    // connect timer 

   206

    slots.connect(update_timer.sig_tick(), &player, &InputHandler<PlayerInputBit, PlayerInput>::update);

   207

    slots.connect(update_timer.sig_tick(), &gui, &InputHandler<GuiInputBit, GuiInput>::update);

   208

   209

    // enable timer

   210

    update_timer.start();

   211

}

   212

   213

void Input::readPlayerInput (PlayerInput &mask, TimeMS &dt) {

   214

    player.readValue(mask, dt);

   215

}

   216

   217

GuiInput Input::readGuiInput (void) {

   218

    GuiInput mask;

   219

    TimeMS dt;

   220

   221

    gui.readValue(mask, dt);

   222

   223

    return mask;

   224

}

   225