src/lib/16_in.c

   1 /* Project 16 Source Code~\r
   2  * Copyright (C) 2012-2017 sparky4 & pngwen & andrius4669 & joncampbell123 & yakui-lover\r
   3  *\r
   4  * This file is part of Project 16.\r
   5  *\r
   6  * Project 16 is free software; you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License as published by\r
   8  * the Free Software Foundation; either version 3 of the License, or\r
   9  * (at your option) any later version.\r
  10  *\r
  11  * Project 16 is distributed in the hope that it will be useful,\r
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14  * GNU General Public License for more details.\r
  15  *\r
  16  * You should have received a copy of the GNU General Public License\r
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>, or\r
  18  * write to the Free Software Foundation, Inc., 51 Franklin Street,\r
  19  * Fifth Floor, Boston, MA 02110-1301 USA.\r
  20  *\r
  21  */\r
  22 //\r
  23 //      ID Engine\r
  24 //      ID_IN.c - Input Manager\r
  25 //      v1.0d1w\r
  26 //      By Jason Blochowiak\r
  27 //      Open Watcom port by sparky4\r
  28 //\r
  29 \r
  30 //\r
  31 //      This module handles dealing with the various input devices\r
  32 //\r
  33 //      Depends on: Memory Mgr (for demo recording), Sound Mgr (for timing stuff),\r
  34 //                              User Mgr (for command line parms)\r
  35 //\r
  36 //      Globals:\r
  37 //              LastScan - The keyboard scan code of the last key pressed\r
  38 //              LastASCII - The ASCII value of the last key pressed\r
  39 //      DEBUG - there are more globals\r
  40 //\r
  41 \r
  42 #include "src/lib/16_in.h"\r
  43 #pragma hdrstop\r
  44 \r
  45 static word far* clockw= (word far*) 0x046C; /* 18.2hz clock */\r
  46 \r
  47 /*\r
  48 =============================================================================\r
  49 \r
  50                                         GLOBAL VARIABLES\r
  51 \r
  52 =============================================================================\r
  53 */\r
  54 /*struct inconfig\r
  55 {\r
  56         boolean         MousePresent;\r
  57         boolean         JoysPresent[MaxJoys];\r
  58         boolean         Keyboard[NumCodes];\r
  59         boolean         Paused;\r
  60         char            LastASCII;\r
  61         ScanCode        LastScan;\r
  62 \r
  63         KeyboardDef     KbdDefs[MaxKbds];\r
  64         JoystickDef     JoyDefs[MaxJoys];\r
  65 } inpu;*/\r
  66 \r
  67 //gvar->in.KbdDefs = {0x1d,0x38,/*0x47,*/0x48,/*0x49,*/0x4b,0x4d,/*0x4f,*/0x50/*,0x51*/};\r
  68 \r
  69 /*\r
  70 =============================================================================\r
  71 \r
  72                                         LOCAL VARIABLES\r
  73 \r
  74 =============================================================================\r
  75 */\r
  76 \r
  77 #ifdef __cplusplus              /* Function must be declared C style */\r
  78 extern "C" {\r
  79 #endif\r
  80 \r
  81 /*static struct instat {\r
  82         boolean         CapsLock;\r
  83         ScanCode        CurCode,LastCode;\r
  84 \r
  85         boolean         Keyboard[NumCodes];\r
  86         boolean         Paused;\r
  87         char            LastASCII;\r
  88         ScanCode        LastScan;\r
  89 } inst;*/\r
  90 \r
  91 //the def stuff is need fix warnings\r
  92 #ifndef INSTDEFED\r
  93 #define INSTDEFED\r
  94 static inst_t inst;\r
  95 #endif\r
  96 \r
  97 static  byte        far ASCIINames[] =          // Unshifted ASCII for scan codes\r
  98                                         {\r
  99 //       0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F\r
 100         0  ,27 ,'1','2','3','4','5','6','7','8','9','0','-','=',8  ,9  ,        // 0\r
 101         'q','w','e','r','t','y','u','i','o','p','[',']',13 ,0  ,'a','s',        // 1\r
 102         'd','f','g','h','j','k','l',';',39 ,'`',0  ,92 ,'z','x','c','v',        // 2\r
 103         'b','n','m',',','.','/',0  ,'*',0  ,' ',0  ,0  ,0  ,0  ,0  ,0  ,        // 3\r
 104         0  ,0  ,0  ,0  ,0  ,0  ,0  ,'7','8','9','-','4','5','6','+','1',        // 4\r
 105         '2','3','0',127,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 5\r
 106         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 6\r
 107         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0           // 7\r
 108                                         },\r
 109                                         far ShiftNames[] =              // Shifted ASCII for scan codes\r
 110                                         {\r
 111 //       0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F\r
 112         0  ,27 ,'!','@','#','$','%','^','&','*','(',')','_','+',8  ,9  ,        // 0\r
 113         'Q','W','E','R','T','Y','U','I','O','P','{','}',13 ,0  ,'A','S',        // 1\r
 114         'D','F','G','H','J','K','L',':',34 ,'~',0  ,'|','Z','X','C','V',        // 2\r
 115         'B','N','M','<','>','?',0  ,'*',0  ,' ',0  ,0  ,0  ,0  ,0  ,0  ,        // 3\r
 116         0  ,0  ,0  ,0  ,0  ,0  ,0  ,'7','8','9','-','4','5','6','+','1',        // 4\r
 117         '2','3','0',127,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 5\r
 118         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 6\r
 119         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0           // 7\r
 120                                         },\r
 121                                         far SpecialNames[] =    // ASCII for 0xe0 prefixed codes\r
 122                                         {\r
 123 //       0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F\r
 124         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 0\r
 125         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,13 ,0  ,0  ,0  ,        // 1\r
 126         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 2\r
 127         0  ,0  ,0  ,0  ,0  ,'/',0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 3\r
 128         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 4\r
 129         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 5\r
 130         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 6\r
 131         0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0           // 7\r
 132                                         },\r
 133                                         *ScanNames[] =          // Scan code names with single chars\r
 134                                         {\r
 135         "?","?","1","2","3","4","5","6","7","8","9","0","-","+","?","?",\r
 136         "Q","W","E","R","T","Y","U","I","O","P","[","]","|","?","A","S",\r
 137         "D","F","G","H","J","K","L",";","\"","?","?","?","Z","X","C","V",\r
 138         "B","N","M",",",".","/","?","?","?","?","?","?","?","?","?","?",\r
 139         "?","?","?","?","?","?","?","?","\xf","?","-","\x15","5","\x11","+","?",\r
 140         "\x13","?","?","?","?","?","?","?","?","?","?","?","?","?","?","?",\r
 141         "?","?","?","?","?","?","?","?","?","?","?","?","?","?","?","?",\r
 142         "?","?","?","?","?","?","?","?","?","?","?","?","?","?","?","?"\r
 143                                         },      // DEBUG - consolidate these\r
 144                                         far ExtScanCodes[] =    // Scan codes with >1 char names\r
 145                                         {\r
 146         1,0xe,0xf,0x1d,0x2a,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,\r
 147         0x3f,0x40,0x41,0x42,0x43,0x44,0x57,0x59,0x46,0x1c,0x36,\r
 148         0x37,0x38,0x47,0x49,0x4f,0x51,0x52,0x53,0x45,0x48,\r
 149         0x50,0x4b,0x4d,0x00\r
 150                                         },\r
 151                                         *ExtScanNames[] =       // Names corresponding to ExtScanCodes\r
 152                                         {\r
 153         "Esc","BkSp","Tab","Ctrl","LShft","Space","CapsLk","F1","F2","F3","F4",\r
 154         "F5","F6","F7","F8","F9","F10","F11","F12","ScrlLk","Enter","RShft",\r
 155         "PrtSc","Alt","Home","PgUp","End","PgDn","Ins","Del","NumLk","Up",\r
 156         "Down","Left","Right",""\r
 157                                         };\r
 158 \r
 159 static  Direction       DirTable[] =            // Quick lookup for total direction\r
 160                                         {\r
 161                                                 /*dir_NorthWest,        */dir_North,/*  dir_NorthEast,*/\r
 162                                                 dir_West,               dir_None,       dir_East,\r
 163                                                 /*dir_SouthWest,        */dir_South/*,  dir_SouthEast*/\r
 164                                         };\r
 165 #ifdef __cplusplus\r
 166 }\r
 167 #endif\r
 168 \r
 169 static  void                    (*INL_KeyHook)(void);\r
 170 static  void interrupt  (*OldKeyVect)(void);\r
 171 static  char                    *ParmStringsIN[] = {"nojoys","nomouse",nil};\r
 172 static  void                    INL_StartKbd(void);\r
 173 \r
 174 //      Internal routines\r
 175 \r
 176 ///////////////////////////////////////////////////////////////////////////\r
 177 //\r
 178 //      INL_KeyService() - Handles a keyboard interrupt (key up/down)\r
 179 //\r
 180 ///////////////////////////////////////////////////////////////////////////\r
 181 /*static */void interrupt\r
 182 INL_KeyService(void)\r
 183 {\r
 184 static  boolean special;\r
 185                 byte    k,c,\r
 186                                 temp;\r
 187 \r
 188         k = inportb(0x60);      // Get the scan code\r
 189 \r
 190         // Tell the XT keyboard controller to clear the key\r
 191         outportb(0x61,(temp = inportb(0x61)) | 0x80);\r
 192         outportb(0x61,temp);\r
 193 \r
 194         if (k == 0xe0)          // Special key prefix\r
 195                 special = true;\r
 196         else if (k == 0xe1)     // Handle Pause key\r
 197                 inst.Paused = true;\r
 198         else\r
 199         {\r
 200                 if (k & 0x80)   // Break code\r
 201                 {\r
 202                         k &= 0x7f;\r
 203 \r
 204 // DEBUG - handle special keys: ctl-alt-delete, print scrn\r
 205 \r
 206                         inst.Keyboard[k] = false;\r
 207                 }\r
 208                 else                    // Make code\r
 209                 {\r
 210                         inst.LastCode = inst.CurCode;\r
 211                         inst.CurCode = inst.LastScan = k;\r
 212                         inst.Keyboard[k] = true;\r
 213 \r
 214                         if (special)\r
 215                                 c = SpecialNames[k];\r
 216                         else\r
 217                         {\r
 218                                 if (k == sc_CapsLock)\r
 219                                 {\r
 220                                         inst.CapsLock ^= true;\r
 221                                         // DEBUG - make caps lock light work\r
 222                                 }\r
 223 \r
 224                                 if (inst.Keyboard[sc_LShift] || inst.Keyboard[sc_RShift])       // If shifted\r
 225                                 {\r
 226                                         c = ShiftNames[k];\r
 227                                         if ((c >= 'A') && (c <= 'Z') && inst.CapsLock)\r
 228                                                 c += 'a' - 'A';\r
 229                                 }\r
 230                                 else\r
 231                                 {\r
 232                                         c = ASCIINames[k];\r
 233                                         if ((c >= 'a') && (c <= 'z') && inst.CapsLock)\r
 234                                                 c -= 'a' - 'A';\r
 235                                 }\r
 236                         }\r
 237                         if (c)\r
 238                                 inst.LastASCII = c;\r
 239                 }\r
 240 \r
 241                 special = false;\r
 242         }\r
 243 \r
 244         if (INL_KeyHook && !special)\r
 245                 INL_KeyHook();\r
 246 #ifdef __DEBUG_InputMgr__\r
 247         if(dbg_testkeyin > 0) printf("%c        %u      [0x%x %u]       %u\n", c, c, k, k, inst.Keyboard[k]);\r
 248 #endif\r
 249         outportb(0x20,0x20);\r
 250 }\r
 251 \r
 252 void INL_Mouse(int x)\r
 253 {\r
 254         union REGS CPURegs;\r
 255         x = CPURegs.x.ax;\r
 256 /*_=_=  __asm {\r
 257                 mov     ax,x\r
 258                 int     MouseInt\r
 259         }*/\r
 260         int86(MouseInt,&CPURegs,&CPURegs);\r
 261 }\r
 262 \r
 263 ///////////////////////////////////////////////////////////////////////////\r
 264 //\r
 265 //      INL_GetMouseDelta() - Gets the amount that the mouse has moved from the\r
 266 //              mouse driver\r
 267 //\r
 268 ///////////////////////////////////////////////////////////////////////////\r
 269 static void\r
 270 INL_GetMouseDelta(int *x,int *y)\r
 271 {\r
 272         union REGS CPURegs;\r
 273         Mouse(MDelta);\r
 274         *x = CPURegs.x.cx;\r
 275         *y = CPURegs.x.dx;\r
 276 #ifdef __DEBUG_InputMgr__\r
 277         if(dbg_joymousedelta)\r
 278         {\r
 279                 printf("mousedelta=[%dx%d]\n", *x, *y);\r
 280         }\r
 281         #endif\r
 282 }\r
 283 \r
 284 ///////////////////////////////////////////////////////////////////////////\r
 285 //\r
 286 //      INL_GetMouseButtons() - Gets the status of the mouse buttons from the\r
 287 //              mouse driver\r
 288 //\r
 289 ///////////////////////////////////////////////////////////////////////////\r
 290 static word\r
 291 INL_GetMouseButtons(void)\r
 292 {\r
 293         union REGS CPURegs;\r
 294         word    buttons;\r
 295 \r
 296         Mouse(MButtons);\r
 297         buttons = CPURegs.x.bx;\r
 298         return(buttons);\r
 299 }\r
 300 \r
 301 ///////////////////////////////////////////////////////////////////////////\r
 302 //\r
 303 //      IN_GetJoyAbs() - Reads the absolute position of the specified joystick\r
 304 //\r
 305 ///////////////////////////////////////////////////////////////////////////\r
 306 void\r
 307 IN_GetJoyAbs(word joy,word *xp,word *yp)\r
 308 {\r
 309         byte    xb,yb,\r
 310                         xs,ys;\r
 311         word    x,y;\r
 312 \r
 313         x = y = 0;\r
 314         xs = joy? 2 : 0;                // Find shift value for x axis\r
 315         xb = 1 << xs;                   // Use shift value to get x bit mask\r
 316         ys = joy? 3 : 1;                // Do the same for y axis\r
 317         yb = 1 << ys;\r
 318 \r
 319 // Read the absolute joystick values\r
 320         __asm {\r
 321                 pushf                           // Save some registers\r
 322                 push    si\r
 323                 push    di\r
 324                 cli                                     // Make sure an interrupt doesn't screw the timings\r
 325 \r
 326 \r
 327                 mov             dx,0x201\r
 328                 in              al,dx\r
 329                 out             dx,al           // Clear the resistors\r
 330 \r
 331                 mov             ah,[xb]         // Get masks into registers\r
 332                 mov             ch,[yb]\r
 333 \r
 334                 xor             si,si           // Clear count registers\r
 335                 xor             di,di\r
 336                 xor             bh,bh           // Clear high byte of bx for later\r
 337 \r
 338                 push    bp                      // Don't mess up stack frame\r
 339                 mov             bp,MaxJoyValue\r
 340 #ifdef __BORLANDC__\r
 341         }\r
 342 #endif\r
 343 loo:\r
 344 #ifdef __BORLANDC__\r
 345         __asm {\r
 346 #endif\r
 347                 in              al,dx           // Get bits indicating whether all are finished\r
 348 \r
 349                 dec             bp                      // Check bounding register\r
 350                 jz              done            // We have a silly value - abort\r
 351 \r
 352                 mov             bl,al           // Duplicate the bits\r
 353                 and             bl,ah           // Mask off useless bits (in [xb])\r
 354                 add             si,bx           // Possibly increment count register\r
 355                 mov             cl,bl           // Save for testing later\r
 356 \r
 357                 mov             bl,al\r
 358                 and             bl,ch           // [yb]\r
 359                 add             di,bx\r
 360 \r
 361                 add             cl,bl\r
 362                 jnz             loo             // If both bits were 0, drop out\r
 363 #ifdef __BORLANDC__\r
 364         }\r
 365 #endif\r
 366 done:\r
 367 #ifdef __BORLANDC__\r
 368         __asm {\r
 369 #endif\r
 370                 pop             bp\r
 371 \r
 372                 mov             cl,[xs]         // Get the number of bits to shift\r
 373                 shr             si,cl           //  and shift the count that many times\r
 374 \r
 375                 mov             cl,[ys]\r
 376                 shr             di,cl\r
 377 \r
 378                 mov             [x],si          // Store the values into the variables\r
 379                 mov             [y],di\r
 380 \r
 381                 pop             di\r
 382                 pop             si\r
 383                 popf                            // Restore the registers\r
 384         }\r
 385 \r
 386         *xp = x;\r
 387         *yp = y;\r
 388 }\r
 389 \r
 390 ///////////////////////////////////////////////////////////////////////////\r
 391 //\r
 392 //      INL_GetJoyDelta() - Returns the relative movement of the specified\r
 393 //              joystick (from +/-127)\r
 394 //\r
 395 ///////////////////////////////////////////////////////////////////////////\r
 396 void INL_GetJoyDelta(word joy,int *dx,int *dy/*,boolean adaptive*/, global_game_variables_t *gvar)\r
 397 {\r
 398         word            x,y;\r
 399         word TimeCount = *clockw;\r
 400         JoystickDef     *def;\r
 401 static  word    lasttime;\r
 402 \r
 403         IN_GetJoyAbs(joy,&x,&y);\r
 404         def = gvar->in.JoyDefs + joy;\r
 405 \r
 406         if (x < def->threshMinX)\r
 407         {\r
 408                 if (x < def->joyMinX)\r
 409                         x = def->joyMinX;\r
 410 \r
 411                 x = -(x - def->threshMinX);\r
 412                 x *= def->joyMultXL;\r
 413                 x >>= JoyScaleShift;\r
 414                 *dx = (x > 127)? -127 : -x;\r
 415         }\r
 416         else if (x > def->threshMaxX)\r
 417         {\r
 418                 if (x > def->joyMaxX)\r
 419                         x = def->joyMaxX;\r
 420 \r
 421                 x = x - def->threshMaxX;\r
 422                 x *= def->joyMultXH;\r
 423                 x >>= JoyScaleShift;\r
 424                 *dx = (x > 127)? 127 : x;\r
 425         }\r
 426         else\r
 427                 *dx = 0;\r
 428 \r
 429         if (y < def->threshMinY)\r
 430         {\r
 431                 if (y < def->joyMinY)\r
 432                         y = def->joyMinY;\r
 433 \r
 434                 y = -(y - def->threshMinY);\r
 435                 y *= def->joyMultYL;\r
 436                 y >>= JoyScaleShift;\r
 437                 *dy = (y > 127)? -127 : -y;\r
 438         }\r
 439         else if (y > def->threshMaxY)\r
 440         {\r
 441                 if (y > def->joyMaxY)\r
 442                         y = def->joyMaxY;\r
 443 \r
 444                 y = y - def->threshMaxY;\r
 445                 y *= def->joyMultYH;\r
 446                 y >>= JoyScaleShift;\r
 447                 *dy = (y > 127)? 127 : y;\r
 448         }\r
 449         else\r
 450                 *dy = 0;\r
 451 //      if (adaptive)\r
 452 //      {\r
 453 //              time = (TimeCount - lasttime) / 2;\r
 454 //              if (time)\r
 455 //              {\r
 456 //                      if (time > 8)\r
 457 //                              time = 8;\r
 458 //                      *dx *= time;\r
 459 //                      *dy *= time;\r
 460 //              }\r
 461 //      }\r
 462         lasttime = TimeCount;\r
 463 }\r
 464 \r
 465 ///////////////////////////////////////////////////////////////////////////\r
 466 //\r
 467 //      INL_GetJoyButtons() - Returns the button status of the specified\r
 468 //              joystick\r
 469 //\r
 470 ///////////////////////////////////////////////////////////////////////////\r
 471 static word\r
 472 INL_GetJoyButtons(word joy)\r
 473 {\r
 474 register        word    result;\r
 475 \r
 476         result = inportb(0x201);        // Get all the joystick buttons\r
 477         result >>= joy? 6 : 4;  // Shift into bits 0-1\r
 478         result &= 3;                            // Mask off the useless bits\r
 479         result ^= 3;\r
 480         return(result);\r
 481 }\r
 482 \r
 483 ///////////////////////////////////////////////////////////////////////////\r
 484 //\r
 485 //      IN_GetJoyButtonsDB() - Returns the de-bounced button status of the\r
 486 //              specified joystick\r
 487 //\r
 488 ///////////////////////////////////////////////////////////////////////////\r
 489 word\r
 490 IN_GetJoyButtonsDB(word joy)\r
 491 {\r
 492         word TimeCount = *clockw;\r
 493         word    lasttime;\r
 494         word            result1,result2;\r
 495 \r
 496         do\r
 497         {\r
 498                 result1 = INL_GetJoyButtons(joy);\r
 499                 lasttime = TimeCount;\r
 500                 while(TimeCount == lasttime)\r
 501                         //;\r
 502                 result2 = INL_GetJoyButtons(joy);\r
 503         } while(result1 != result2);\r
 504         return(result1);\r
 505 }\r
 506 \r
 507 ///////////////////////////////////////////////////////////////////////////\r
 508 //\r
 509 //      INL_StartKbd() - Sets up my keyboard stuff for use\r
 510 //\r
 511 ///////////////////////////////////////////////////////////////////////////\r
 512 static void\r
 513 INL_StartKbd()\r
 514 {\r
 515         INL_KeyHook = NULL;     // Clear key hook\r
 516 \r
 517         IN_ClearKeysDown();\r
 518 \r
 519         OldKeyVect = getvect(KeyInt);//IN_KbdLED();\r
 520         setvect(KeyInt,INL_KeyService);\r
 521 }\r
 522 \r
 523 ///////////////////////////////////////////////////////////////////////////\r
 524 //\r
 525 //      INL_ShutKbd() - Restores keyboard control to the BIOS\r
 526 //\r
 527 ///////////////////////////////////////////////////////////////////////////\r
 528 static void\r
 529 INL_ShutKbd(void)\r
 530 {\r
 531         pokeb(0x40,0x17,peekb(0x40,0x17) & 0xfaf0);     // Clear ctrl/alt/shift flags\r
 532 \r
 533         setvect(KeyInt,OldKeyVect);\r
 534 }\r
 535 \r
 536 ///////////////////////////////////////////////////////////////////////////\r
 537 //\r
 538 //      INL_StartMouse() - Detects and sets up the mouse\r
 539 //\r
 540 ///////////////////////////////////////////////////////////////////////////\r
 541 static boolean\r
 542 INL_StartMouse(void)\r
 543 {\r
 544         union REGS CPURegs;\r
 545         if (getvect(MouseInt))\r
 546         {\r
 547                 Mouse(MReset);\r
 548                 if (/*_AX*/CPURegs.x.ax == 0xffff)\r
 549                         return(true);\r
 550         }\r
 551         return(false);\r
 552 #if 0\r
 553         byte far *vector;\r
 554 \r
 555 \r
 556         if ((vector=MK_FP(peek(0,0x33*4+2),peek(0,0x33*4)))==NULL)\r
 557         return false;\r
 558 \r
 559         if (*vector == 207)\r
 560                 return false;\r
 561 \r
 562         Mouse(MReset);\r
 563         return true;\r
 564 #endif\r
 565 }\r
 566 \r
 567 ///////////////////////////////////////////////////////////////////////////\r
 568 //\r
 569 //      INL_ShutMouse() - Cleans up after the mouse\r
 570 //\r
 571 ///////////////////////////////////////////////////////////////////////////\r
 572 static void\r
 573 INL_ShutMouse(void)\r
 574 {\r
 575 }\r
 576 \r
 577 //\r
 578 //      INL_SetJoyScale() - Sets up scaling values for the specified joystick\r
 579 //\r
 580 static void\r
 581 INL_SetJoyScale(word joy, global_game_variables_t *gvar)\r
 582 {\r
 583         JoystickDef     *def;\r
 584 \r
 585         def = &(gvar->in.JoyDefs[joy]);\r
 586         def->joyMultXL = JoyScaleMax / (def->threshMinX - def->joyMinX);\r
 587         def->joyMultXH = JoyScaleMax / (def->joyMaxX - def->threshMaxX);\r
 588         def->joyMultYL = JoyScaleMax / (def->threshMinY - def->joyMinY);\r
 589         def->joyMultYH = JoyScaleMax / (def->joyMaxY - def->threshMaxY);\r
 590 }\r
 591 \r
 592 ///////////////////////////////////////////////////////////////////////////\r
 593 //\r
 594 //      IN_SetupJoy() - Sets up thresholding values and calls INL_SetJoyScale()\r
 595 //              to set up scaling values\r
 596 //\r
 597 ///////////////////////////////////////////////////////////////////////////\r
 598 void\r
 599 IN_SetupJoy(word joy,word minx,word maxx,word miny,word maxy, global_game_variables_t *gvar)\r
 600 {\r
 601         word            d,r;\r
 602         JoystickDef     *def;\r
 603 \r
 604         def = &(gvar->in.JoyDefs[joy]);\r
 605 \r
 606         def->joyMinX = minx;\r
 607         def->joyMaxX = maxx;\r
 608         r = maxx - minx;\r
 609         d = r / 3;\r
 610         def->threshMinX = ((r / 2) - d) + minx;\r
 611         def->threshMaxX = ((r / 2) + d) + minx;\r
 612 \r
 613         def->joyMinY = miny;\r
 614         def->joyMaxY = maxy;\r
 615         r = maxy - miny;\r
 616         d = r / 3;\r
 617         def->threshMinY = ((r / 2) - d) + miny;\r
 618         def->threshMaxY = ((r / 2) + d) + miny;\r
 619 \r
 620         INL_SetJoyScale(joy, gvar);\r
 621 }\r
 622 \r
 623 ///////////////////////////////////////////////////////////////////////////\r
 624 //\r
 625 //      INL_StartJoy() - Detects & auto-configures the specified joystick\r
 626 //                                      The auto-config assumes the joystick is centered\r
 627 //\r
 628 ///////////////////////////////////////////////////////////////////////////\r
 629 static boolean\r
 630 INL_StartJoy(word joy, global_game_variables_t *gvar)\r
 631 {\r
 632         word            x,y;\r
 633 \r
 634         IN_GetJoyAbs(joy,&x,&y);\r
 635 \r
 636         if\r
 637         (\r
 638                 ((x == 0) || (x > MaxJoyValue - 10))\r
 639         ||      ((y == 0) || (y > MaxJoyValue - 10))\r
 640         )\r
 641                 return(false);\r
 642         else\r
 643         {\r
 644                 IN_SetupJoy(joy,0,x * 2,0,y * 2, gvar);\r
 645                 return(true);\r
 646         }\r
 647 }\r
 648 \r
 649 ///////////////////////////////////////////////////////////////////////////\r
 650 //\r
 651 //      INL_ShutJoy() - Cleans up the joystick stuff\r
 652 //\r
 653 ///////////////////////////////////////////////////////////////////////////\r
 654 static void\r
 655 INL_ShutJoy(word joy, global_game_variables_t *gvar)\r
 656 {\r
 657         gvar->in.JoysPresent[joy] = false;\r
 658 }\r
 659 \r
 660 //      Public routines\r
 661 \r
 662 ///////////////////////////////////////////////////////////////////////////\r
 663 //\r
 664 //      IN_Startup() - Starts up the Input Mgr\r
 665 //\r
 666 ///////////////////////////////////////////////////////////////////////////\r
 667 void\r
 668 IN_Startup(global_game_variables_t *gvar)\r
 669 {\r
 670         boolean checkjoys,checkmouse;\r
 671         word    i;\r
 672 \r
 673         if (gvar->in.IN_Started)\r
 674                 return;\r
 675 \r
 676         checkjoys = true;\r
 677         checkmouse = true;\r
 678         for (i = 1;i < _argc;i++)\r
 679         {\r
 680                 switch (US_CheckParm(_argv[i],ParmStringsIN))\r
 681                 {\r
 682                 case 0:\r
 683                         checkjoys = false;\r
 684                         break;\r
 685                 case 1:\r
 686                         checkmouse = false;\r
 687                         break;\r
 688                 }\r
 689         }\r
 690 \r
 691         INL_StartKbd();\r
 692         gvar->in.MousePresent = checkmouse? INL_StartMouse() : false;\r
 693 \r
 694         for (i = 0;i < MaxJoys;i++)\r
 695                 gvar->in.JoysPresent[i] = checkjoys? INL_StartJoy(i, gvar) : false;\r
 696 \r
 697         gvar->in.inst = &inst;\r
 698 \r
 699         gvar->in.IN_Started = true;\r
 700 \r
 701 }\r
 702 \r
 703 ///////////////////////////////////////////////////////////////////////////\r
 704 //\r
 705 //      IN_Default() - Sets up default conditions for the Input Mgr\r
 706 //\r
 707 ///////////////////////////////////////////////////////////////////////////\r
 708 void\r
 709 IN_Default(boolean gotit,player_t *player,ControlType nt, global_game_variables_t *gvar)\r
 710 {\r
 711         int i;\r
 712         if\r
 713         (\r
 714                 (!gotit)\r
 715         ||      ((nt == ctrl_Joystick1) && !gvar->in.JoysPresent[0])\r
 716         ||      ((nt == ctrl_Joystick2) && !gvar->in.JoysPresent[1])\r
 717         ||      ((nt == ctrl_Mouse) && !gvar->in.MousePresent)\r
 718         )\r
 719                 nt = ctrl_Keyboard1;\r
 720         gvar->in.KbdDefs[0].button0 = 0x1c;\r
 721         gvar->in.KbdDefs[0].button1 = 0x38;\r
 722         //in.KbdDefs[0].upleft = 0x47;\r
 723         gvar->in.KbdDefs[0].up = 0x48;\r
 724         //in.KbdDefs[0].upright = 0x49;\r
 725         gvar->in.KbdDefs[0].left = 0x4b;\r
 726         gvar->in.KbdDefs[0].right = 0x4d;\r
 727         //in.KbdDefs[0].downleft = 0x4f;\r
 728         gvar->in.KbdDefs[0].down = 0x50;\r
 729         //in.KbdDefs[0].downright = 0x51;\r
 730         IN_SetControlType(player,nt);\r
 731         for(i=0; i>MaxPlayers;i++)\r
 732                 player[i].enti.d =2;\r
 733 }\r
 734 \r
 735 ///////////////////////////////////////////////////////////////////////////\r
 736 //\r
 737 //      IN_Shutdown() - Shuts down the Input Mgr\r
 738 //\r
 739 ///////////////////////////////////////////////////////////////////////////\r
 740 void\r
 741 IN_Shutdown(global_game_variables_t *gvar)\r
 742 {\r
 743         word    i;\r
 744 \r
 745         if (!gvar->in.IN_Started)\r
 746                 return;\r
 747 \r
 748         INL_ShutMouse();\r
 749         for (i = 0;i < MaxJoys;i++)\r
 750                 INL_ShutJoy(i, gvar);\r
 751         INL_ShutKbd();\r
 752 \r
 753         gvar->in.IN_Started = false;\r
 754 }\r
 755 \r
 756 ///////////////////////////////////////////////////////////////////////////\r
 757 //\r
 758 //      IN_SetKeyHook() - Sets the routine that gets called by INL_KeyService()\r
 759 //                      everytime a real make/break code gets hit\r
 760 //\r
 761 ///////////////////////////////////////////////////////////////////////////\r
 762 void\r
 763 IN_SetKeyHook(void (*hook)())\r
 764 {\r
 765         INL_KeyHook = hook;\r
 766 }\r
 767 \r
 768 ///////////////////////////////////////////////////////////////////////////\r
 769 //\r
 770 //      IN_ClearKeysDown() - Clears the keyboard array\r
 771 //\r
 772 ///////////////////////////////////////////////////////////////////////////\r
 773 void\r
 774 IN_ClearKeysDown(void)\r
 775 {\r
 776         //int   i;\r
 777 \r
 778         inst.LastScan = sc_None;\r
 779         inst.LastASCII = key_None;\r
 780         memset (inst.Keyboard,0,sizeof(inst.Keyboard));\r
 781 }\r
 782 \r
 783 ///////////////////////////////////////////////////////////////////////////\r
 784 //\r
 785 //      INL_AdjustCursor() - Internal routine of common code from IN_ReadCursor()\r
 786 //\r
 787 ///////////////////////////////////////////////////////////////////////////\r
 788 static void\r
 789 INL_AdjustCursor(CursorInfo *info,word buttons,int dx,int dy)\r
 790 {\r
 791         if (buttons & (1 << 0))\r
 792                 info->button0 = true;\r
 793         if (buttons & (1 << 1))\r
 794                 info->button1 = true;\r
 795 \r
 796         info->x += dx;\r
 797         info->y += dy;\r
 798 }\r
 799 \r
 800 ///////////////////////////////////////////////////////////////////////////\r
 801 //\r
 802 //      IN_ReadCursor() - Reads the input devices and fills in the cursor info\r
 803 //              struct\r
 804 //\r
 805 ///////////////////////////////////////////////////////////////////////////\r
 806 void\r
 807 IN_ReadCursor(CursorInfo *info, global_game_variables_t *gvar)\r
 808 {\r
 809         word    i,\r
 810                         buttons;\r
 811         int             dx,dy;\r
 812 \r
 813         info->x = info->y = 0;\r
 814         info->button0 = info->button1 = false;\r
 815 \r
 816         if (gvar->in.MousePresent)\r
 817         {\r
 818                 buttons = INL_GetMouseButtons();\r
 819                 INL_GetMouseDelta(&dx,&dy);\r
 820                 INL_AdjustCursor(info,buttons,dx,dy);\r
 821         }\r
 822 \r
 823         for (i = 0;i < MaxJoys;i++)\r
 824         {\r
 825                 if (!gvar->in.JoysPresent[i])\r
 826                         continue;\r
 827 \r
 828                 buttons = INL_GetJoyButtons(i);\r
 829                 INL_GetJoyDelta(i,&dx,&dy/*,true*/, gvar);\r
 830                 dx /= 64;\r
 831                 dy /= 64;\r
 832                 INL_AdjustCursor(info,buttons,dx,dy);\r
 833         }\r
 834 }\r
 835 \r
 836 //if else for gfxtesting and direction\r
 837 #define DIRECTIONIFELSE (player->info.dir == 2)\r
 838 //#define NDIRECTIONIFELSE      (player->info.dir != 2)\r
 839 \r
 840 ///////////////////////////////////////////////////////////////////////////\r
 841 //\r
 842 //      IN_ReadControl() - Reads the device associated with the specified\r
 843 //              player and fills in the control info struct\r
 844 //\r
 845 ///////////////////////////////////////////////////////////////////////////\r
 846 void\r
 847 IN_ReadControl(player_t *player, global_game_variables_t *gvar)\r
 848 {\r
 849                         boolean         realdelta;\r
 850 #if DEMO0\r
 851                         byte            dbyte;\r
 852 #endif\r
 853                         word            buttons;\r
 854                         int                     dx,dy;\r
 855                         Motion          mx,my;\r
 856                         ControlType     type;\r
 857                         sword conpee;\r
 858                         byte dir=DirTable[2];\r
 859 register        KeyboardDef     *def;\r
 860 //#ifdef __DEBUG_InputMgr__\r
 861 //static                int                     old_dx,old_dy;\r
 862 //#endif\r
 863 \r
 864         dx = dy = 0;\r
 865         mx = my = motion_None;\r
 866         buttons = 0;\r
 867 \r
 868 #if DEMO0\r
 869         if (DemoMode == demo_Playback)\r
 870         {\r
 871                 dbyte = DemoBuffer[DemoOffset + 1];\r
 872                 my = (dbyte & 3) - 1;\r
 873                 mx = ((dbyte >> 2) & 3) - 1;\r
 874                 buttons = (dbyte >> 4) & 3;\r
 875 \r
 876                 if (!(--DemoBuffer[DemoOffset]))\r
 877                 {\r
 878                         DemoOffset += 2;\r
 879                         if (DemoOffset >= DemoSize)\r
 880                                 DemoMode = demo_PlayDone;\r
 881                 }\r
 882 \r
 883                 realdelta = false;\r
 884         }\r
 885         else if (DemoMode == demo_PlayDone)\r
 886                 Quit ("Demo playback exceeded");\r
 887         else\r
 888         {\r
 889 #endif\r
 890                 switch (type = player->Controls)\r
 891                 {\r
 892                 case ctrl_Keyboard1:\r
 893                 case ctrl_Keyboard2:\r
 894                         def = &(gvar->in.KbdDefs[type - ctrl_Keyboard]);\r
 895 \r
 896 /*                      if (Keyboard[def->upleft])\r
 897                                 mx = motion_Left,my = motion_Up;\r
 898                         else if (Keyboard[def->upright])\r
 899                                 mx = motion_Right,my = motion_Up;\r
 900                         else if (Keyboard[def->downleft])\r
 901                                 mx = motion_Left,my = motion_Down;\r
 902                         else if (Keyboard[def->downright])\r
 903                                 mx = motion_Right,my = motion_Down;*/\r
 904 //TODO: make this into a function that the joystick AND keyboard can use wwww\r
 905                         if(DIRECTIONIFELSE)//(player->info.dir == 2)\r
 906                         {\r
 907                         if(!inst.Keyboard[def->left] && !inst.Keyboard[def->right]){\r
 908                                 if((inst.Keyboard[def->up] && !inst.Keyboard[def->down]))\r
 909                                         my = motion_Up;\r
 910                                 if((inst.Keyboard[def->down] && !inst.Keyboard[def->up]))\r
 911                                         my = motion_Down;\r
 912                         }else if(!inst.Keyboard[def->up] && !inst.Keyboard[def->down]){\r
 913                                 if((inst.Keyboard[def->left] && !inst.Keyboard[def->right]))\r
 914                                         mx = motion_Left;\r
 915                                 if((inst.Keyboard[def->right] && !inst.Keyboard[def->left]))\r
 916                                         mx = motion_Right;\r
 917                         }else{  //2 keys pressed\r
 918                                         switch (player->pdir)\r
 919                                         {\r
 920                                                 case 0:\r
 921                                                 case 4:\r
 922                                                         if((inst.Keyboard[def->left] && !inst.Keyboard[def->right])){ dir = DirTable[1]; }//mx = motion_Left; }\r
 923                                                         else if((inst.Keyboard[def->right] && !inst.Keyboard[def->left])){ dir = DirTable[3]; }//mx = motion_Right; }\r
 924                                                 break;\r
 925                                                 case 1:\r
 926                                                 case 3:\r
 927                                                         if((inst.Keyboard[def->up] && !inst.Keyboard[def->down])){ dir = DirTable[0]; }//my = motion_Up; }\r
 928                                                         else if((inst.Keyboard[def->down] && !inst.Keyboard[def->up])){ dir = DirTable[4]; }//my = motion_Down; }\r
 929                                                 break;\r
 930                                                 default:\r
 931                                                 break;\r
 932                                         }\r
 933 #ifdef __DEBUG_InputMgr__\r
 934                                         //if(dbg_testcontrolnoisy > 0){ printf("dir=%c ", dirchar(dir)); printf("pdir=%c        ", dirchar(player->pdir)); }\r
 935 #endif\r
 936                                 }\r
 937                         }\r
 938                         //input from player\r
 939                         if (inst.Keyboard[def->button0])\r
 940                                 buttons += 1 << 0;\r
 941                         if (inst.Keyboard[def->button1])\r
 942                                 buttons += 1 << 1;\r
 943                         realdelta = false;\r
 944                         break;\r
 945                 case ctrl_Joystick1:\r
 946                 case ctrl_Joystick2:\r
 947                         INL_GetJoyDelta(type - ctrl_Joystick,&dx,&dy/*,false*/, gvar);\r
 948                         buttons = INL_GetJoyButtons(type - ctrl_Joystick);\r
 949                         realdelta = true;\r
 950                         break;\r
 951                 case ctrl_Mouse:\r
 952                         INL_GetMouseDelta(&dx,&dy);\r
 953                         buttons = INL_GetMouseButtons();\r
 954                         realdelta = true;\r
 955                         break;\r
 956                 }\r
 957 #ifdef DEMO0\r
 958         }\r
 959 #endif\r
 960 \r
 961         if (realdelta)\r
 962         {\r
 963                 mx = (dx < 0)? motion_Left : ((dx > 0)? motion_Right : motion_None);\r
 964                 my = (dy < 0)? motion_Up : ((dy > 0)? motion_Down : motion_None);\r
 965         }\r
 966         else\r
 967         {\r
 968                 dx = mx;// * 127;\r
 969                 dy = my;// * 127;\r
 970         }\r
 971 \r
 972         player->info.x = dx;\r
 973         player->info.xaxis = mx;\r
 974         player->info.y = dy;\r
 975         player->info.yaxis = my;\r
 976         player->info.button0 = buttons & (1 << 0);\r
 977         player->info.button1 = buttons & (1 << 1);\r
 978         player->info.button2 = buttons & (1 << 2);\r
 979         player->info.button3 = buttons & (1 << 3);\r
 980 //      player->info.dir = DirTable[((my + 1) * 3) + (mx + 1)];\r
 981         conpee=(((my + 1) * 2) + (mx + 1))-1;\r
 982         player->info.dir = DirTable[conpee];\r
 983 \r
 984         if(DirTable[conpee]!=2) player->pdir=DirTable[conpee];\r
 985         if(player->enti.q==1 &&( dir!=2 || (mx!=motion_None || my!=motion_None)))\r
 986         {\r
 987                 if(dir==2) player->enti.d = player->info.dir;\r
 988                 else player->enti.d = DirTable[dir];\r
 989         }\r
 990 \r
 991 #if DEMO0\r
 992         if (DemoMode == demo_Record)\r
 993         {\r
 994                 // Pack the control info into a byte\r
 995                 dbyte = (buttons << 4) | ((mx + 1) << 2) | (my + 1);\r
 996 \r
 997                 if\r
 998                 (\r
 999                         (DemoBuffer[DemoOffset + 1] == dbyte)\r
1000                 &&      (DemoBuffer[DemoOffset] < 255)\r
1001                 )\r
1002                         (DemoBuffer[DemoOffset])++;\r
1003                 else\r
1004                 {\r
1005                         if (DemoOffset || DemoBuffer[DemoOffset])\r
1006                                 DemoOffset += 2;\r
1007 \r
1008                         if (DemoOffset >= DemoSize)\r
1009                                 Quit ("Demo buffer overflow");\r
1010 \r
1011                         DemoBuffer[DemoOffset] = 1;\r
1012                         DemoBuffer[DemoOffset + 1] = dbyte;\r
1013                 }\r
1014         }\r
1015 #endif\r
1016 #ifdef __DEBUG_InputMgr__\r
1017 /*if(dbg_joymousedelta)\r
1018 {\r
1019         if(dx!=old_dx || dy!=old_dy) printf("dx,dy      [%d,%d] %d,%d\n", dx, dy, mx, my);\r
1020         if(dx!=old_dx)  old_dx=dx;\r
1021         if(dy!=old_dy)  old_dy=dy;\r
1022 }*/\r
1023 \r
1024 if(dbg_testcontrolnoisy > 0)\r
1025 if(player->info.dir!=2/*(inst.Keyboard[def->up] || inst.Keyboard[def->down] || inst.Keyboard[def->left] || inst.Keyboard[def->right])*/ || player->enti.q>1)\r
1026 {\r
1027         //printf("b1=%u b2=%u b3=%u b4=%u       ", player->info.button0, player->info.button1, player->info.button2, player->info.button3);\r
1028         //printf("q=%d ", player->enti.q);\r
1029         //printf("cpee=%c ", dirchar(conpee));\r
1030         printf("pdir=%c d=%c dir=%c ", dirchar(player->pdir), dirchar(player->enti.d), dirchar(player->info.dir));\r
1031         /*if(realdelta) */printf("dx=%d dy=%d   mx=%d   my=%d", player->info.x, player->info.y, player->info.xaxis, player->info.yaxis);\r
1032         //else if(!realdelta) printf("%c%d %c%d %c%d %c%d", dirchar(0), inst.Keyboard[def->up], dirchar(4), inst.Keyboard[def->down], dirchar(1), inst.Keyboard[def->left], dirchar(3), inst.Keyboard[def->right]);\r
1033         printf("\n");\r
1034 }\r
1035 #endif\r
1036 }\r
1037 \r
1038 ///////////////////////////////////////////////////////////////////////////\r
1039 //\r
1040 //      IN_SetControlType() - Sets the control type to be used by the specified\r
1041 //              player\r
1042 //\r
1043 ///////////////////////////////////////////////////////////////////////////\r
1044 void\r
1045 IN_SetControlType(player_t *player,ControlType type)\r
1046 {\r
1047         // DEBUG - check that requested type is present?\r
1048         player->Controls = type;\r
1049 }\r
1050 \r
1051 #if DEMO0\r
1052 ///////////////////////////////////////////////////////////////////////////\r
1053 //\r
1054 //      IN_StartDemoRecord() - Starts the demo recording, using a buffer the\r
1055 //              size passed. Returns if the buffer allocation was successful\r
1056 //\r
1057 ///////////////////////////////////////////////////////////////////////////\r
1058 boolean\r
1059 IN_StartDemoRecord(word bufsize)\r
1060 {\r
1061         if (!bufsize)\r
1062                 return(false);\r
1063 \r
1064         MM_GetPtr((memptr *)&DemoBuffer,bufsize);\r
1065         DemoMode = demo_Record;\r
1066         DemoSize = bufsize & ~1;\r
1067         DemoOffset = 0;\r
1068         DemoBuffer[0] = DemoBuffer[1] = 0;\r
1069 \r
1070         return(true);\r
1071 }\r
1072 \r
1073 ///////////////////////////////////////////////////////////////////////////\r
1074 //\r
1075 //      IN_StartDemoPlayback() - Plays back the demo pointed to of the given size\r
1076 //\r
1077 ///////////////////////////////////////////////////////////////////////////\r
1078 void\r
1079 IN_StartDemoPlayback(byte /*__segment*/ *buffer,word bufsize)\r
1080 {\r
1081         DemoBuffer = buffer;\r
1082         DemoMode = demo_Playback;\r
1083         DemoSize = bufsize & ~1;\r
1084         DemoOffset = 0;\r
1085 }\r
1086 \r
1087 ///////////////////////////////////////////////////////////////////////////\r
1088 //\r
1089 //      IN_StopDemo() - Turns off demo mode\r
1090 //\r
1091 ///////////////////////////////////////////////////////////////////////////\r
1092 void\r
1093 IN_StopDemo(void)\r
1094 {\r
1095         if ((DemoMode == demo_Record) && DemoOffset)\r
1096                 DemoOffset += 2;\r
1097 \r
1098         DemoMode = demo_Off;\r
1099 }\r
1100 \r
1101 ///////////////////////////////////////////////////////////////////////////\r
1102 //\r
1103 //      IN_FreeDemoBuffer() - Frees the demo buffer, if it's been allocated\r
1104 //\r
1105 ///////////////////////////////////////////////////////////////////////////\r
1106 void\r
1107 IN_FreeDemoBuffer(void)\r
1108 {\r
1109         if (DemoBuffer)\r
1110                 MM_FreePtr((memptr *)&DemoBuffer);\r
1111 }\r
1112 #endif\r
1113 \r
1114 \r
1115 ///////////////////////////////////////////////////////////////////////////\r
1116 //\r
1117 //      IN_GetScanName() - Returns a string containing the name of the\r
1118 //              specified scan code\r
1119 //\r
1120 ///////////////////////////////////////////////////////////////////////////\r
1121 byte *\r
1122 IN_GetScanName(ScanCode scan)\r
1123 {\r
1124         byte            **p;\r
1125         ScanCode        far *s;\r
1126 \r
1127         for (s = ExtScanCodes,p = ExtScanNames;*s;p++,s++)\r
1128                 if (*s == scan)\r
1129                         return(*p);\r
1130 \r
1131         return(ScanNames[scan]);\r
1132 }\r
1133 \r
1134 ///////////////////////////////////////////////////////////////////////////\r
1135 //\r
1136 //      IN_WaitForKey() - Waits for a scan code, then clears LastScan and\r
1137 //              returns the scan code\r
1138 //\r
1139 ///////////////////////////////////////////////////////////////////////////\r
1140 ScanCode\r
1141 IN_WaitForKey(void)\r
1142 {\r
1143         ScanCode        result;\r
1144 \r
1145         while (!(result = inst.LastScan))\r
1146                 ;\r
1147         inst.LastScan = 0;\r
1148         return(result);\r
1149 }\r
1150 \r
1151 ///////////////////////////////////////////////////////////////////////////\r
1152 //\r
1153 //      IN_WaitForASCII() - Waits for an ASCII char, then clears LastASCII and\r
1154 //              returns the ASCII value\r
1155 //\r
1156 ///////////////////////////////////////////////////////////////////////////\r
1157 char\r
1158 IN_WaitForASCII(void)\r
1159 {\r
1160         char            result;\r
1161 \r
1162         while (!(result = inst.LastASCII))\r
1163                 ;\r
1164         inst.LastASCII = '\0';\r
1165         return(result);\r
1166 }\r
1167 \r
1168 ///////////////////////////////////////////////////////////////////////////\r
1169 //\r
1170 //      IN_Ack() - waits for a button or key press.  If a button is down, upon\r
1171 // calling, it must be released for it to be recognized\r
1172 //\r
1173 ///////////////////////////////////////////////////////////////////////////\r
1174 \r
1175 boolean btnstate[8];\r
1176 \r
1177 void IN_StartAck(global_game_variables_t *gvar)\r
1178 {\r
1179         unsigned        i,buttons;\r
1180 \r
1181 //\r
1182 // get initial state of everything\r
1183 //\r
1184         IN_ClearKeysDown();\r
1185         memset (btnstate,0,sizeof(btnstate));\r
1186 \r
1187         buttons = IN_JoyButtons () << 4;\r
1188         if (gvar->in.MousePresent)\r
1189                 buttons |= IN_MouseButtons (gvar);\r
1190 \r
1191         for (i=0;i<8;i++,buttons>>=1)\r
1192                 if (buttons&1)\r
1193                         btnstate[i] = true;\r
1194 }\r
1195 \r
1196 \r
1197 boolean IN_CheckAck (global_game_variables_t *gvar)\r
1198 {\r
1199         unsigned        i,buttons;\r
1200 \r
1201 //\r
1202 // see if something has been pressed\r
1203 //\r
1204         if(!gvar->in.IN_Started)\r
1205                 getch();\r
1206         else\r
1207         {\r
1208                 if (inst.LastScan)\r
1209                         return true;\r
1210         }\r
1211 \r
1212         buttons = IN_JoyButtons () << 4;\r
1213         if (gvar->in.MousePresent)\r
1214                 buttons |= IN_MouseButtons (gvar);\r
1215 \r
1216         for (i=0;i<8;i++,buttons>>=1)\r
1217                 if ( buttons&1 )\r
1218                 {\r
1219                         if (!btnstate[i])\r
1220                                 return true;\r
1221                 }\r
1222                 else\r
1223                         btnstate[i]=false;\r
1224 \r
1225         return false;\r
1226 }\r
1227 \r
1228 \r
1229 void IN_Ack (global_game_variables_t *gvar)\r
1230 {\r
1231         IN_StartAck (gvar);\r
1232 \r
1233         while (!IN_CheckAck (gvar))\r
1234         ;\r
1235 }\r
1236 \r
1237 ///////////////////////////////////////////////////////////////////////////\r
1238 //\r
1239 //      IN_IsUserInput() - Returns true if a key has been pressed or a button\r
1240 //              is down\r
1241 //\r
1242 ///////////////////////////////////////////////////////////////////////////\r
1243 boolean\r
1244 IN_IsUserInput(global_game_variables_t *gvar)\r
1245 {\r
1246         boolean result;\r
1247         word    i;\r
1248 \r
1249         result = inst.LastScan;\r
1250 \r
1251         if (gvar->in.MousePresent)\r
1252                 if (INL_GetMouseButtons())\r
1253                         result = true;\r
1254 \r
1255         for (i = 0;i < MaxJoys;i++)\r
1256                 if (gvar->in.JoysPresent[i])\r
1257                         if (INL_GetJoyButtons(i))\r
1258                                 result = true;\r
1259 \r
1260         return(result);\r
1261 }\r
1262 \r
1263 ///////////////////////////////////////////////////////////////////////////\r
1264 //\r
1265 //      IN_UserInput() - Waits for the specified delay time (in ticks) or the\r
1266 //              user pressing a key or a mouse button. If the clear flag is set, it\r
1267 //              then either clears the key or waits for the user to let the mouse\r
1268 //              button up.\r
1269 //\r
1270 ///////////////////////////////////////////////////////////////////////////\r
1271 boolean IN_UserInput(word delay, global_game_variables_t *gvar)\r
1272 {\r
1273         word TimeCount = *clockw;\r
1274         word    lasttime;\r
1275 \r
1276         lasttime = TimeCount;\r
1277         IN_StartAck (gvar);\r
1278         do\r
1279         {\r
1280                 if (IN_CheckAck(gvar))\r
1281                         return true;\r
1282         } while (TimeCount - lasttime < delay);\r
1283         return(false);\r
1284 }\r
1285 \r
1286 //===========================================================================\r
1287 \r
1288 /*\r
1289 ===================\r
1290 =\r
1291 = IN_MouseButtons\r
1292 =\r
1293 ===================\r
1294 */\r
1295 \r
1296 byte    IN_MouseButtons (global_game_variables_t *gvar)\r
1297 {\r
1298         union REGS CPURegs;\r
1299         if (gvar->in.MousePresent)\r
1300         {\r
1301                 Mouse(MButtons);\r
1302                 return CPURegs.x.bx;\r
1303         }\r
1304         else\r
1305                 return 0;\r
1306 }\r
1307 \r
1308 \r
1309 /*\r
1310 ===================\r
1311 =\r
1312 = IN_JoyButtons\r
1313 =\r
1314 ===================\r
1315 */\r
1316 \r
1317 byte    IN_JoyButtons (void)\r
1318 {\r
1319         byte joybits;\r
1320 \r
1321         joybits = inportb(0x201);       // Get all the joystick buttons\r
1322         joybits >>= 4;                          // only the high bits are useful\r
1323         joybits ^= 15;                          // return with 1=pressed\r
1324 \r
1325         return joybits;\r
1326 }\r
1327 \r
1328 boolean IN_KeyDown(byte code)\r
1329 {\r
1330 #ifdef __DEBUG_InputMgr__\r
1331 //      if(inst.Keyboard[code])\r
1332 //              printf("IN_KeyDown(%c): %u\n", code, inst.Keyboard[code]);\r
1333         if(!dbg_nointest)\r
1334 #endif\r
1335         return inst.Keyboard[code];\r
1336 #ifdef __DEBUG_InputMgr__\r
1337         else\r
1338                 if(dbg_nointest && kbhit())\r
1339                         return 1;\r
1340                 else\r
1341                         return 0;\r
1342 #endif\r
1343 }\r
1344 \r
1345 void IN_ClearKey(byte code)\r
1346 {\r
1347         inst.Keyboard[code] = false;\r
1348         if(code == inst.LastScan)\r
1349                 inst.LastScan = sc_None;\r
1350         }\r
1351 \r
1352 boolean IN_qb(byte kee)\r
1353 {\r
1354 #ifdef __DEBUG_InputMgr__\r
1355         if(dbg_testkeyin) if(inst.Keyboard[kee]) printf("IN_qb():       %u\n", inst.Keyboard[kee]);\r
1356 #endif\r
1357         if(inst.Keyboard[kee]==true) return 1;\r
1358         else return 0;\r
1359 }\r
1360 \r
1361 ScanCode IN_GetLastScan()\r
1362 {\r
1363         return inst.LastScan;\r
1364 }\r
1365 \r
1366 ScanCode IN_GetCurCode()\r
1367 {\r
1368         return inst.CurCode;\r
1369 }\r
1370 \r
1371 void IN_KbdLED()\r
1372 {\r
1373         byte far *lock_key;\r
1374 \r
1375         // turn off num-lock via BIOS\r
1376         lock_key = MK_FP(0x040, 0x017); // Pointing to the address of the bios shift state keys\r
1377         *lock_key&=(~(16 | 32 | 64)); // toggle off the locks by changing the values of the 4th, 5th, and 6th bits of the address byte of 0040:0017\r
1378         OldKeyVect();   // call BIOS keyhandler to change keyboard lights\r
1379 }\r