input.cpp

   1
   2 #include "nx.h"
   3 #include "input.fdh"
   4
   5 uint8_t mappings[SDLK_LAST];
   6
   7 bool inputs[INPUT_COUNT];
   8 bool lastinputs[INPUT_COUNT];
   9 int last_sdl_key;
  10
  11 bool input_init(void)
  12 {
  13         memset(inputs, 0, sizeof(inputs));
  14         memset(lastinputs, 0, sizeof(lastinputs));
  15         memset(mappings, 0xff, sizeof(mappings));
  16
  17         // default mappings
  18         #ifdef __SDLSHIM__
  19         {
  20                 mappings[SDLK_LEFT] = LEFTKEY;
  21                 mappings[SDLK_RIGHT] = RIGHTKEY;
  22                 mappings[SDLK_UP] = UPKEY;
  23                 mappings[SDLK_DOWN] = DOWNKEY;
  24
  25                 mappings[SDLK_BTN3] = JUMPKEY;
  26                 mappings[SDLK_BTN4] = FIREKEY;
  27
  28                 mappings[SDLK_BTN1] = INVENTORYKEY;
  29                 mappings[SDLK_BTN2] = MAPSYSTEMKEY;
  30
  31                 mappings[SDLK_JOGDIAL_UP] = PREVWPNKEY;
  32                 mappings[SDLK_JOGDIAL_DOWN] = NEXTWPNKEY;
  33         }
  34         #else
  35         {
  36                 mappings[SDLK_LEFT] = LEFTKEY;
  37                 mappings[SDLK_RIGHT] = RIGHTKEY;
  38                 mappings[SDLK_UP] = UPKEY;
  39                 mappings[SDLK_DOWN] = DOWNKEY;
  40                 mappings[SDLK_z] = JUMPKEY;
  41                 mappings[SDLK_x] = FIREKEY;
  42                 mappings[SDLK_a] = PREVWPNKEY;
  43                 mappings[SDLK_s] = NEXTWPNKEY;
  44                 mappings[SDLK_q] = INVENTORYKEY;
  45                 mappings[SDLK_w] = MAPSYSTEMKEY;
  46
  47                 mappings[SDLK_ESCAPE] = ESCKEY;
  48
  49                 mappings[SDLK_F1] = F1KEY;
  50                 mappings[SDLK_F2] = F2KEY;
  51                 mappings[SDLK_F3] = F3KEY;
  52                 mappings[SDLK_F4] = F4KEY;
  53                 mappings[SDLK_F5] = F5KEY;
  54                 mappings[SDLK_F6] = F6KEY;
  55                 mappings[SDLK_F7] = F7KEY;
  56                 mappings[SDLK_F8] = F8KEY;
  57                 mappings[SDLK_F9] = F9KEY;
  58                 mappings[SDLK_F10] = F10KEY;
  59                 mappings[SDLK_F11] = F11KEY;
  60                 mappings[SDLK_F12] = F12KEY;
  61
  62                 mappings[SDLK_SPACE] = FREEZE_FRAME_KEY;
  63                 mappings[SDLK_c] = FRAME_ADVANCE_KEY;
  64                 mappings[SDLK_v] = DEBUG_FLY_KEY;
  65         }
  66         #endif
  67
  68         return 0;
  69 }
  70
  71
  72 // set the SDL key that triggers an input
  73 void input_remap(int keyindex, int sdl_key)
  74 {
  75         stat("input_remap(%d => %d)", keyindex, sdl_key);
  76         int old_mapping = input_get_mapping(keyindex);
  77         if (old_mapping != -1)
  78                 mappings[old_mapping] = 0xff;
  79
  80         mappings[sdl_key] = keyindex;
  81 }
  82
  83 // get which SDL key triggers a given input
  84 int input_get_mapping(int keyindex)
  85 {
  86 int i;
  87
  88         for(i=0;i<=SDLK_LAST;i++)
  89         {
  90                 if (mappings[i] == keyindex)
  91                         return i;
  92         }
  93
  94         return -1;
  95 }
  96
  97 const char *input_get_name(int index)
  98 {
  99 static const char *input_names[] =
 100 {
 101         "left", "right", "up", "down",
 102         "jump", "fire", "pervious wpn", "next wpn",
 103         "inventory", "map",
 104         "escape",
 105         "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12",
 106         "freeze frame", "frame advance", "debug fly"
 107 };
 108
 109         if (index < 0 || index >= INPUT_COUNT)
 110                 return "invalid";
 111
 112         return input_names[index];
 113 }
 114
 115 void input_set_mappings(int *array)
 116 {
 117         memset(mappings, 0xff, sizeof(mappings));
 118         for(int i=0;i<INPUT_COUNT;i++)
 119                 mappings[array[i]] = i;
 120 }
 121
 122 /*
 123 void c------------------------------() {}
 124 */
 125
 126 void input_poll(void)
 127 {
 128 SDL_Event evt;
 129 int ino, key;
 130
 131         while(SDL_PollEvent(&evt))
 132         {
 133                 switch(evt.type)
 134                 {
 135                         case SDL_KEYDOWN:
 136                         case SDL_KEYUP:
 137                         {
 138                                 key = evt.key.keysym.sym;
 139
 140                                 #ifndef __SDLSHIM__
 141                                 static uint8_t shiftstates = 0;
 142                                 extern bool freezeframe;
 143
 144                                 if (console.IsVisible() && !IsNonConsoleKey(key))
 145                                 {
 146                                         if (key == SDLK_LSHIFT)
 147                                         {
 148                                                 if (evt.type == SDL_KEYDOWN)
 149                                                         shiftstates |= LEFTMASK;
 150                                                 else
 151                                                         shiftstates &= ~LEFTMASK;
 152                                         }
 153                                         else if (key == SDLK_RSHIFT)
 154                                         {
 155                                                 if (evt.type == SDL_KEYDOWN)
 156                                                         shiftstates |= RIGHTMASK;
 157                                                 else
 158                                                         shiftstates &= ~RIGHTMASK;
 159                                         }
 160                                         else
 161                                         {
 162                                                 int ch = key;
 163                                                 if (shiftstates != 0)
 164                                                 {
 165                                                         ch = toupper(ch);
 166                                                         if (ch == '.') ch = '>';
 167                                                         if (ch == '-') ch = '_';
 168                                                         if (ch == '/') ch = '?';
 169                                                         if (ch == '1') ch = '!';
 170                                                 }
 171
 172                                                 if (evt.type == SDL_KEYDOWN)
 173                                                         console.HandleKey(ch);
 174                                                 else
 175                                                         console.HandleKeyRelease(ch);
 176                                         }
 177                                 }
 178                                 else
 179                                 #endif  // __SDLSHIM__
 180                                 {
 181                                         ino = mappings[key];
 182                                         if (ino != 0xff)
 183                                                 inputs[ino] = (evt.type == SDL_KEYDOWN);
 184
 185                                         if (evt.type == SDL_KEYDOWN)
 186                                         {
 187                                                 if (Replay::IsPlaying() && ino <= LASTCONTROLKEY)
 188                                                 {
 189                                                         stat("user interrupt - stopping playback of replay");
 190                                                         Replay::end_playback();
 191                                                         memset(inputs, 0, sizeof(inputs));
 192                                                         inputs[ino] = true;
 193                                                 }
 194
 195                                                 #ifndef __SDLSHIM__
 196                                                 if (key == '`')         // bring up console
 197                                                 {
 198                                                         if (!freezeframe)
 199                                                         {
 200                                                                 sound(SND_SWITCH_WEAPON);
 201                                                                 console.SetVisible(true);
 202                                                         }
 203                                                 }
 204                                                 else
 205                                                 #endif
 206                                                 {
 207                                                         last_sdl_key = key;
 208                                                 }
 209                                         }
 210                                 }
 211                         }
 212                         break;
 213
 214                         case SDL_QUIT:
 215                         {
 216                                 inputs[ESCKEY] = true;
 217                                 game.running = false;
 218                         }
 219                         break;
 220                 }
 221         }
 222 }
 223
 224 // keys that we don't want to send to the console
 225 // even if the console is up.
 226 static int IsNonConsoleKey(int key)
 227 {
 228 static const int nosend[] = { SDLK_LEFT, SDLK_RIGHT, 0 };
 229
 230         for(int i=0;nosend[i];i++)
 231                 if (key == nosend[i])
 232                         return true;
 233
 234         return false;
 235 }
 236
 237
 238 void input_close(void)
 239 {
 240
 241 }
 242
 243 /*
 244 void c------------------------------() {}
 245 */
 246
 247 static const int buttons[] = { JUMPKEY, FIREKEY, 0 };
 248
 249 bool buttondown(void)
 250 {
 251         for(int i=0;buttons[i];i++)
 252         {
 253                 if (inputs[buttons[i]])
 254                         return 1;
 255         }
 256
 257         return 0;
 258 }
 259
 260 bool buttonjustpushed(void)
 261 {
 262         for(int i=0;buttons[i];i++)
 263         {
 264                 if (inputs[buttons[i]] && !lastinputs[buttons[i]])
 265                         return 1;
 266         }
 267
 268         return 0;
 269 }
 270
 271 bool justpushed(int k)
 272 {
 273         return (inputs[k] && !lastinputs[k]);
 274 }
 275
 276
 277
 278
 279