]> 4ch.mooo.com Git - 16.git/blob - src/lib/16_in.c
0ac77f15d5cb49a06d6ce0a0e6bdf27cde49666c
[16.git] / 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 ///////////////////////////////////////////////////////////////////////////\r
253 //\r
254 //      INL_GetMouseDelta() - Gets the amount that the mouse has moved from the\r
255 //              mouse driver\r
256 //\r
257 ///////////////////////////////////////////////////////////////////////////\r
258 static void\r
259 INL_GetMouseDelta(int *x,int *y)\r
260 {\r
261         Mouse(MDelta);\r
262         *x = _CX;\r
263         *y = _DX;\r
264 }\r
265 \r
266 ///////////////////////////////////////////////////////////////////////////\r
267 //\r
268 //      INL_GetMouseButtons() - Gets the status of the mouse buttons from the\r
269 //              mouse driver\r
270 //\r
271 ///////////////////////////////////////////////////////////////////////////\r
272 static word\r
273 INL_GetMouseButtons(void)\r
274 {\r
275         word    buttons;\r
276 \r
277         Mouse(MButtons);\r
278         buttons = _BX;\r
279         return(buttons);\r
280 }\r
281 \r
282 ///////////////////////////////////////////////////////////////////////////\r
283 //\r
284 //      IN_GetJoyAbs() - Reads the absolute position of the specified joystick\r
285 //\r
286 ///////////////////////////////////////////////////////////////////////////\r
287 void\r
288 IN_GetJoyAbs(word joy,word *xp,word *yp)\r
289 {\r
290         byte    xb,yb,\r
291                         xs,ys;\r
292         word    x,y;\r
293 \r
294         x = y = 0;\r
295         xs = joy? 2 : 0;                // Find shift value for x axis\r
296         xb = 1 << xs;                   // Use shift value to get x bit mask\r
297         ys = joy? 3 : 1;                // Do the same for y axis\r
298         yb = 1 << ys;\r
299 \r
300 // Read the absolute joystick values\r
301         __asm {\r
302                 pushf                           // Save some registers\r
303                 push    si\r
304                 push    di\r
305                 cli                                     // Make sure an interrupt doesn't screw the timings\r
306 \r
307 \r
308                 mov             dx,0x201\r
309                 in              al,dx\r
310                 out             dx,al           // Clear the resistors\r
311 \r
312                 mov             ah,[xb]         // Get masks into registers\r
313                 mov             ch,[yb]\r
314 \r
315                 xor             si,si           // Clear count registers\r
316                 xor             di,di\r
317                 xor             bh,bh           // Clear high byte of bx for later\r
318 \r
319                 push    bp                      // Don't mess up stack frame\r
320                 mov             bp,MaxJoyValue\r
321 #ifdef __BORLANDC__\r
322         }\r
323 #endif\r
324 loo:\r
325 #ifdef __BORLANDC__\r
326         __asm {\r
327 #endif\r
328                 in              al,dx           // Get bits indicating whether all are finished\r
329 \r
330                 dec             bp                      // Check bounding register\r
331                 jz              done            // We have a silly value - abort\r
332 \r
333                 mov             bl,al           // Duplicate the bits\r
334                 and             bl,ah           // Mask off useless bits (in [xb])\r
335                 add             si,bx           // Possibly increment count register\r
336                 mov             cl,bl           // Save for testing later\r
337 \r
338                 mov             bl,al\r
339                 and             bl,ch           // [yb]\r
340                 add             di,bx\r
341 \r
342                 add             cl,bl\r
343                 jnz             loo             // If both bits were 0, drop out\r
344 #ifdef __BORLANDC__\r
345         }\r
346 #endif\r
347 done:\r
348 #ifdef __BORLANDC__\r
349         __asm {\r
350 #endif\r
351                 pop             bp\r
352 \r
353                 mov             cl,[xs]         // Get the number of bits to shift\r
354                 shr             si,cl           //  and shift the count that many times\r
355 \r
356                 mov             cl,[ys]\r
357                 shr             di,cl\r
358 \r
359                 mov             [x],si          // Store the values into the variables\r
360                 mov             [y],di\r
361 \r
362                 pop             di\r
363                 pop             si\r
364                 popf                            // Restore the registers\r
365         }\r
366 \r
367         *xp = x;\r
368         *yp = y;\r
369 }\r
370 \r
371 ///////////////////////////////////////////////////////////////////////////\r
372 //\r
373 //      INL_GetJoyDelta() - Returns the relative movement of the specified\r
374 //              joystick (from +/-127)\r
375 //\r
376 ///////////////////////////////////////////////////////////////////////////\r
377 void INL_GetJoyDelta(word joy,int *dx,int *dy/*,boolean adaptive*/, global_game_variables_t *gvar)\r
378 {\r
379         word            x,y;\r
380 //00    word TimeCount = *clockw;\r
381         JoystickDef     *def;\r
382 //00static      word    lasttime;\r
383 \r
384         IN_GetJoyAbs(joy,&x,&y);\r
385         def = gvar->in.JoyDefs + joy;\r
386 \r
387         if (x < def->threshMinX)\r
388         {\r
389                 if (x < def->joyMinX)\r
390                         x = def->joyMinX;\r
391 \r
392                 x = -(x - def->threshMinX);\r
393                 x *= def->joyMultXL;\r
394                 x >>= JoyScaleShift;\r
395                 *dx = (x > 127)? -127 : -x;\r
396         }\r
397         else if (x > def->threshMaxX)\r
398         {\r
399                 if (x > def->joyMaxX)\r
400                         x = def->joyMaxX;\r
401 \r
402                 x = x - def->threshMaxX;\r
403                 x *= def->joyMultXH;\r
404                 x >>= JoyScaleShift;\r
405                 *dx = (x > 127)? 127 : x;\r
406         }\r
407         else\r
408                 *dx = 0;\r
409 \r
410         if (y < def->threshMinY)\r
411         {\r
412                 if (y < def->joyMinY)\r
413                         y = def->joyMinY;\r
414 \r
415                 y = -(y - def->threshMinY);\r
416                 y *= def->joyMultYL;\r
417                 y >>= JoyScaleShift;\r
418                 *dy = (y > 127)? -127 : -y;\r
419         }\r
420         else if (y > def->threshMaxY)\r
421         {\r
422                 if (y > def->joyMaxY)\r
423                         y = def->joyMaxY;\r
424 \r
425                 y = y - def->threshMaxY;\r
426                 y *= def->joyMultYH;\r
427                 y >>= JoyScaleShift;\r
428                 *dy = (y > 127)? 127 : y;\r
429         }\r
430         else\r
431                 *dy = 0;\r
432 //      if (adaptive)\r
433 //      {\r
434 //              time = (TimeCount - lasttime) / 2;\r
435 //              if (time)\r
436 //              {\r
437 //                      if (time > 8)\r
438 //                              time = 8;\r
439 //                      *dx *= time;\r
440 //                      *dy *= time;\r
441 //              }\r
442 //      }\r
443 //00    lasttime = TimeCount;\r
444 }\r
445 \r
446 ///////////////////////////////////////////////////////////////////////////\r
447 //\r
448 //      INL_GetJoyButtons() - Returns the button status of the specified\r
449 //              joystick\r
450 //\r
451 ///////////////////////////////////////////////////////////////////////////\r
452 static word\r
453 INL_GetJoyButtons(word joy)\r
454 {\r
455 register        word    result;\r
456 \r
457         result = inportb(0x201);        // Get all the joystick buttons\r
458         result >>= joy? 6 : 4;  // Shift into bits 0-1\r
459         result &= 3;                            // Mask off the useless bits\r
460         result ^= 3;\r
461         return(result);\r
462 }\r
463 \r
464 ///////////////////////////////////////////////////////////////////////////\r
465 //\r
466 //      IN_GetJoyButtonsDB() - Returns the de-bounced button status of the\r
467 //              specified joystick\r
468 //\r
469 ///////////////////////////////////////////////////////////////////////////\r
470 word\r
471 IN_GetJoyButtonsDB(word joy)\r
472 {\r
473 //00    word TimeCount = *clockw;\r
474 //00    word    lasttime;\r
475         word            result1,result2;\r
476 \r
477         do\r
478         {\r
479                 result1 = INL_GetJoyButtons(joy);\r
480 //00            lasttime = TimeCount;\r
481 //00            while(TimeCount == lasttime)\r
482                         //;\r
483                 result2 = INL_GetJoyButtons(joy);\r
484         } while(result1 != result2);\r
485         return(result1);\r
486 }\r
487 \r
488 ///////////////////////////////////////////////////////////////////////////\r
489 //\r
490 //      INL_StartKbd() - Sets up my keyboard stuff for use\r
491 //\r
492 ///////////////////////////////////////////////////////////////////////////\r
493 static void\r
494 INL_StartKbd(void)\r
495 {\r
496         INL_KeyHook = NULL;     // Clear key hook\r
497 \r
498         IN_ClearKeysDown();\r
499 \r
500         OldKeyVect = getvect(KeyInt);//IN_KbdLED();\r
501         setvect(KeyInt,INL_KeyService);\r
502 }\r
503 \r
504 ///////////////////////////////////////////////////////////////////////////\r
505 //\r
506 //      INL_ShutKbd() - Restores keyboard control to the BIOS\r
507 //\r
508 ///////////////////////////////////////////////////////////////////////////\r
509 static void\r
510 INL_ShutKbd(void)\r
511 {\r
512         pokeb(0x40,0x17,peekb(0x40,0x17) & 0xfaf0);     // Clear ctrl/alt/shift flags\r
513 \r
514         setvect(KeyInt,OldKeyVect);\r
515 }\r
516 \r
517 ///////////////////////////////////////////////////////////////////////////\r
518 //\r
519 //      INL_StartMouse() - Detects and sets up the mouse\r
520 //\r
521 ///////////////////////////////////////////////////////////////////////////\r
522 static boolean\r
523 INL_StartMouse(void)\r
524 {\r
525 #if 0\r
526         if (getvect(MouseInt))\r
527         {\r
528                 Mouse(MReset);\r
529                 if (_AX == 0xffff)\r
530                         return(true);\r
531         }\r
532         return(false);\r
533 #else\r
534         byte far *vector;\r
535 \r
536 \r
537         if ((vector=MK_FP(peek(0,0x33*4+2),peek(0,0x33*4)))==NULL)\r
538         return false;\r
539 \r
540         if (*vector == 207)\r
541                 return false;\r
542 \r
543         Mouse(MReset);\r
544         return true;\r
545 #endif\r
546 }\r
547 \r
548 ///////////////////////////////////////////////////////////////////////////\r
549 //\r
550 //      INL_ShutMouse() - Cleans up after the mouse\r
551 //\r
552 ///////////////////////////////////////////////////////////////////////////\r
553 static void\r
554 INL_ShutMouse(void)\r
555 {\r
556 }\r
557 \r
558 //\r
559 //      INL_SetJoyScale() - Sets up scaling values for the specified joystick\r
560 //\r
561 static void\r
562 INL_SetJoyScale(word joy, global_game_variables_t *gvar)\r
563 {\r
564         JoystickDef     *def;\r
565 \r
566         def = &(gvar->in.JoyDefs[joy]);\r
567         def->joyMultXL = JoyScaleMax / (def->threshMinX - def->joyMinX);\r
568         def->joyMultXH = JoyScaleMax / (def->joyMaxX - def->threshMaxX);\r
569         def->joyMultYL = JoyScaleMax / (def->threshMinY - def->joyMinY);\r
570         def->joyMultYH = JoyScaleMax / (def->joyMaxY - def->threshMaxY);\r
571 }\r
572 \r
573 ///////////////////////////////////////////////////////////////////////////\r
574 //\r
575 //      IN_SetupJoy() - Sets up thresholding values and calls INL_SetJoyScale()\r
576 //              to set up scaling values\r
577 //\r
578 ///////////////////////////////////////////////////////////////////////////\r
579 void\r
580 IN_SetupJoy(word joy,word minx,word maxx,word miny,word maxy, global_game_variables_t *gvar)\r
581 {\r
582         word            d,r;\r
583         JoystickDef     *def;\r
584 \r
585         def = &(gvar->in.JoyDefs[joy]);\r
586 \r
587         def->joyMinX = minx;\r
588         def->joyMaxX = maxx;\r
589         r = maxx - minx;\r
590         d = r / 3;\r
591         def->threshMinX = ((r / 2) - d) + minx;\r
592         def->threshMaxX = ((r / 2) + d) + minx;\r
593 \r
594         def->joyMinY = miny;\r
595         def->joyMaxY = maxy;\r
596         r = maxy - miny;\r
597         d = r / 3;\r
598         def->threshMinY = ((r / 2) - d) + miny;\r
599         def->threshMaxY = ((r / 2) + d) + miny;\r
600 \r
601         INL_SetJoyScale(joy, gvar);\r
602 }\r
603 \r
604 ///////////////////////////////////////////////////////////////////////////\r
605 //\r
606 //      INL_StartJoy() - Detects & auto-configures the specified joystick\r
607 //                                      The auto-config assumes the joystick is centered\r
608 //\r
609 ///////////////////////////////////////////////////////////////////////////\r
610 static boolean\r
611 INL_StartJoy(word joy, global_game_variables_t *gvar)\r
612 {\r
613         word            x,y;\r
614 \r
615         IN_GetJoyAbs(joy,&x,&y);\r
616 \r
617         if\r
618         (\r
619                 ((x == 0) || (x > MaxJoyValue - 10))\r
620         ||      ((y == 0) || (y > MaxJoyValue - 10))\r
621         )\r
622                 return(false);\r
623         else\r
624         {\r
625                 IN_SetupJoy(joy,0,x * 2,0,y * 2, gvar);\r
626                 return(true);\r
627         }\r
628 }\r
629 \r
630 ///////////////////////////////////////////////////////////////////////////\r
631 //\r
632 //      INL_ShutJoy() - Cleans up the joystick stuff\r
633 //\r
634 ///////////////////////////////////////////////////////////////////////////\r
635 static void\r
636 INL_ShutJoy(word joy, global_game_variables_t *gvar)\r
637 {\r
638         gvar->in.JoysPresent[joy] = false;\r
639 }\r
640 \r
641 //      Public routines\r
642 \r
643 ///////////////////////////////////////////////////////////////////////////\r
644 //\r
645 //      IN_Startup() - Starts up the Input Mgr\r
646 //\r
647 ///////////////////////////////////////////////////////////////////////////\r
648 void\r
649 IN_Startup(global_game_variables_t *gvar)\r
650 {\r
651         boolean checkjoys,checkmouse;\r
652         word    i;\r
653 \r
654         if (gvar->in.IN_Started)\r
655                 return;\r
656 \r
657         checkjoys = true;\r
658         checkmouse = true;\r
659         for (i = 1;i < _argc;i++)\r
660         {\r
661                 switch (US_CheckParm(_argv[i],ParmStringsIN))\r
662                 {\r
663                 case 0:\r
664                         checkjoys = false;\r
665                         break;\r
666                 case 1:\r
667                         checkmouse = false;\r
668                         break;\r
669                 }\r
670         }\r
671 \r
672         INL_StartKbd();\r
673         gvar->in.MousePresent = checkmouse? INL_StartMouse() : false;\r
674 \r
675         for (i = 0;i < MaxJoys;i++)\r
676                 gvar->in.JoysPresent[i] = checkjoys? INL_StartJoy(i, gvar) : false;\r
677 \r
678         gvar->in.inst = &inst;\r
679 \r
680         gvar->in.IN_Started = true;\r
681 }\r
682 \r
683 ///////////////////////////////////////////////////////////////////////////\r
684 //\r
685 //      IN_Default() - Sets up default conditions for the Input Mgr\r
686 //\r
687 ///////////////////////////////////////////////////////////////////////////\r
688 void\r
689 IN_Default(boolean gotit,player_t *player,ControlType nt, global_game_variables_t *gvar)\r
690 {\r
691         int i;\r
692         if\r
693         (\r
694                 (!gotit)\r
695         ||      ((nt == ctrl_Joystick1) && !gvar->in.JoysPresent[0])\r
696         ||      ((nt == ctrl_Joystick2) && !gvar->in.JoysPresent[1])\r
697         ||      ((nt == ctrl_Mouse) && !gvar->in.MousePresent)\r
698         )\r
699                 nt = ctrl_Keyboard1;\r
700         gvar->in.KbdDefs[0].button0 = 0x1c;\r
701         gvar->in.KbdDefs[0].button1 = 0x38;\r
702         //in.KbdDefs[0].upleft = 0x47;\r
703         gvar->in.KbdDefs[0].up = 0x48;\r
704         //in.KbdDefs[0].upright = 0x49;\r
705         gvar->in.KbdDefs[0].left = 0x4b;\r
706         gvar->in.KbdDefs[0].right = 0x4d;\r
707         //in.KbdDefs[0].downleft = 0x4f;\r
708         gvar->in.KbdDefs[0].down = 0x50;\r
709         //in.KbdDefs[0].downright = 0x51;\r
710         IN_SetControlType(player,nt);\r
711         for(i=0; i>MaxPlayers;i++)\r
712                 player[i].enti.d =2;\r
713 }\r
714 \r
715 ///////////////////////////////////////////////////////////////////////////\r
716 //\r
717 //      IN_Shutdown() - Shuts down the Input Mgr\r
718 //\r
719 ///////////////////////////////////////////////////////////////////////////\r
720 void\r
721 IN_Shutdown(global_game_variables_t *gvar)\r
722 {\r
723         word    i;\r
724 \r
725         if (!gvar->in.IN_Started)\r
726                 return;\r
727 \r
728         INL_ShutMouse();\r
729         for (i = 0;i < MaxJoys;i++)\r
730                 INL_ShutJoy(i, gvar);\r
731         INL_ShutKbd();\r
732 \r
733         gvar->in.IN_Started = false;\r
734 }\r
735 \r
736 ///////////////////////////////////////////////////////////////////////////\r
737 //\r
738 //      IN_SetKeyHook() - Sets the routine that gets called by INL_KeyService()\r
739 //                      everytime a real make/break code gets hit\r
740 //\r
741 ///////////////////////////////////////////////////////////////////////////\r
742 void\r
743 IN_SetKeyHook(void (*hook)())\r
744 {\r
745         INL_KeyHook = hook;\r
746 }\r
747 \r
748 ///////////////////////////////////////////////////////////////////////////\r
749 //\r
750 //      IN_ClearKeysDown() - Clears the keyboard array\r
751 //\r
752 ///////////////////////////////////////////////////////////////////////////\r
753 void\r
754 IN_ClearKeysDown(void)\r
755 {\r
756         //int   i;\r
757 \r
758         inst.LastScan = sc_None;\r
759         inst.LastASCII = key_None;\r
760         memset (inst.Keyboard,0,sizeof(inst.Keyboard));\r
761 }\r
762 \r
763 ///////////////////////////////////////////////////////////////////////////\r
764 //\r
765 //      INL_AdjustCursor() - Internal routine of common code from IN_ReadCursor()\r
766 //\r
767 ///////////////////////////////////////////////////////////////////////////\r
768 static void\r
769 INL_AdjustCursor(CursorInfo *info,word buttons,int dx,int dy)\r
770 {\r
771         if (buttons & (1 << 0))\r
772                 info->button0 = true;\r
773         if (buttons & (1 << 1))\r
774                 info->button1 = true;\r
775 \r
776         info->x += dx;\r
777         info->y += dy;\r
778 }\r
779 \r
780 ///////////////////////////////////////////////////////////////////////////\r
781 //\r
782 //      IN_ReadCursor() - Reads the input devices and fills in the cursor info\r
783 //              struct\r
784 //\r
785 ///////////////////////////////////////////////////////////////////////////\r
786 void\r
787 IN_ReadCursor(CursorInfo *info, global_game_variables_t *gvar)\r
788 {\r
789         word    i,\r
790                         buttons;\r
791         int             dx,dy;\r
792 \r
793         info->x = info->y = 0;\r
794         info->button0 = info->button1 = false;\r
795 \r
796         if (gvar->in.MousePresent)\r
797         {\r
798                 buttons = INL_GetMouseButtons();\r
799                 INL_GetMouseDelta(&dx,&dy);\r
800                 INL_AdjustCursor(info,buttons,dx,dy);\r
801         }\r
802 \r
803         for (i = 0;i < MaxJoys;i++)\r
804         {\r
805                 if (!gvar->in.JoysPresent[i])\r
806                         continue;\r
807 \r
808                 buttons = INL_GetJoyButtons(i);\r
809                 INL_GetJoyDelta(i,&dx,&dy/*,true*/, gvar);\r
810                 dx /= 64;\r
811                 dy /= 64;\r
812                 INL_AdjustCursor(info,buttons,dx,dy);\r
813         }\r
814 }\r
815 \r
816 //if else for gfxtesting and direction\r
817 #define DIRECTIONIFELSE (player->info.dir == 2)\r
818 //#define NDIRECTIONIFELSE      (player->info.dir != 2)\r
819 \r
820 ///////////////////////////////////////////////////////////////////////////\r
821 //\r
822 //      IN_ReadControl() - Reads the device associated with the specified\r
823 //              player and fills in the control info struct\r
824 //\r
825 ///////////////////////////////////////////////////////////////////////////\r
826 void\r
827 IN_ReadControl(player_t *player, global_game_variables_t *gvar)\r
828 {\r
829                         boolean         realdelta;\r
830 #if DEMO0\r
831                         byte            dbyte;\r
832 #endif\r
833                         word            buttons;\r
834                         int                     dx,dy;\r
835                         Motion          mx,my;\r
836                         ControlType     type;\r
837                         sword conpee;\r
838                         byte dir=DirTable[2];\r
839 register        KeyboardDef     *def;\r
840 \r
841         dx = dy = 0;\r
842         mx = my = motion_None;\r
843         buttons = 0;\r
844 \r
845 #if DEMO0\r
846         if (DemoMode == demo_Playback)\r
847         {\r
848                 dbyte = DemoBuffer[DemoOffset + 1];\r
849                 my = (dbyte & 3) - 1;\r
850                 mx = ((dbyte >> 2) & 3) - 1;\r
851                 buttons = (dbyte >> 4) & 3;\r
852 \r
853                 if (!(--DemoBuffer[DemoOffset]))\r
854                 {\r
855                         DemoOffset += 2;\r
856                         if (DemoOffset >= DemoSize)\r
857                                 DemoMode = demo_PlayDone;\r
858                 }\r
859 \r
860                 realdelta = false;\r
861         }\r
862         else if (DemoMode == demo_PlayDone)\r
863                 Quit ("Demo playback exceeded");\r
864         else\r
865         {\r
866 #endif\r
867                 switch (type = player->Controls)\r
868                 {\r
869                 case ctrl_Keyboard:\r
870                         def = &(gvar->in.KbdDefs[type - ctrl_Keyboard]);\r
871 \r
872 /*                      if (Keyboard[def->upleft])\r
873                                 mx = motion_Left,my = motion_Up;\r
874                         else if (Keyboard[def->upright])\r
875                                 mx = motion_Right,my = motion_Up;\r
876                         else if (Keyboard[def->downleft])\r
877                                 mx = motion_Left,my = motion_Down;\r
878                         else if (Keyboard[def->downright])\r
879                                 mx = motion_Right,my = motion_Down;*/\r
880 //TODO: make this into a function that the joystick AND keyboard can use wwww\r
881                         if(DIRECTIONIFELSE)//(player->info.dir == 2)\r
882                         {\r
883                         if(!inst.Keyboard[def->left] && !inst.Keyboard[def->right]){\r
884                                 if((inst.Keyboard[def->up] && !inst.Keyboard[def->down]))\r
885                                         my = motion_Up;\r
886                                 if((inst.Keyboard[def->down] && !inst.Keyboard[def->up]))\r
887                                         my = motion_Down;\r
888                         }else if(!inst.Keyboard[def->up] && !inst.Keyboard[def->down]){\r
889                                 if((inst.Keyboard[def->left] && !inst.Keyboard[def->right]))\r
890                                         mx = motion_Left;\r
891                                 if((inst.Keyboard[def->right] && !inst.Keyboard[def->left]))\r
892                                         mx = motion_Right;\r
893                         }else{  //2 keys pressed\r
894                                         switch (player->pdir)\r
895                                         {\r
896                                                 case 0:\r
897                                                 case 4:\r
898                                                         if((inst.Keyboard[def->left] && !inst.Keyboard[def->right])){ dir = DirTable[1]; }//mx = motion_Left; }\r
899                                                         else if((inst.Keyboard[def->right] && !inst.Keyboard[def->left])){ dir = DirTable[3]; }//mx = motion_Right; }\r
900                                                 break;\r
901                                                 case 1:\r
902                                                 case 3:\r
903                                                         if((inst.Keyboard[def->up] && !inst.Keyboard[def->down])){ dir = DirTable[0]; }//my = motion_Up; }\r
904                                                         else if((inst.Keyboard[def->down] && !inst.Keyboard[def->up])){ dir = DirTable[4]; }//my = motion_Down; }\r
905                                                 break;\r
906                                                 default:\r
907                                                 break;\r
908                                         }\r
909 #ifdef __DEBUG_InputMgr__\r
910                                         //if(dbg_testcontrolnoisy > 0){ printf("dir=%c ", dirchar(dir)); printf("pdir=%c        ", dirchar(player->pdir)); }\r
911 #endif\r
912                                 }\r
913                         }\r
914                         //input from player\r
915                         if (inst.Keyboard[def->button0])\r
916                                 buttons += 1 << 0;\r
917                         if (inst.Keyboard[def->button1])\r
918                                 buttons += 1 << 1;\r
919                         realdelta = false;\r
920                         break;\r
921                 case ctrl_Joystick1:\r
922                 case ctrl_Joystick2:\r
923                         INL_GetJoyDelta(type - ctrl_Joystick,&dx,&dy/*,false*/, gvar);\r
924                         buttons = INL_GetJoyButtons(type - ctrl_Joystick);\r
925                         realdelta = true;\r
926                         break;\r
927                 case ctrl_Mouse:\r
928                         INL_GetMouseDelta(&dx,&dy);\r
929                         buttons = INL_GetMouseButtons();\r
930                         realdelta = true;\r
931                         break;\r
932                 }\r
933 #ifdef DEMO0\r
934         }\r
935 #endif\r
936 \r
937         if (realdelta)\r
938         {\r
939                 mx = (dx < 0)? motion_Left : ((dx > 0)? motion_Right : motion_None);\r
940                 my = (dy < 0)? motion_Up : ((dy > 0)? motion_Down : motion_None);\r
941         }\r
942         else\r
943         {\r
944                 dx = mx * 127;\r
945                 dy = my * 127;\r
946         }\r
947 \r
948         player->info.x = dx;\r
949         player->info.xaxis = mx;\r
950         player->info.y = dy;\r
951         player->info.yaxis = my;\r
952         player->info.button0 = buttons & (1 << 0);\r
953         player->info.button1 = buttons & (1 << 1);\r
954         player->info.button2 = buttons & (1 << 2);\r
955         player->info.button3 = buttons & (1 << 3);\r
956 //      player->info.dir = DirTable[((my + 1) * 3) + (mx + 1)];\r
957         conpee=(((my + 1) * 2) + (mx + 1))-1;\r
958         player->info.dir = DirTable[conpee];\r
959 \r
960         if(DirTable[conpee]!=2) player->pdir=DirTable[conpee];\r
961         if(player->enti.q==1 &&( dir!=2 || (mx!=motion_None || my!=motion_None)))\r
962         {\r
963                 if(dir==2) player->enti.d = player->info.dir;\r
964                 else player->enti.d = DirTable[dir];\r
965         }\r
966 \r
967 #if DEMO0\r
968         if (DemoMode == demo_Record)\r
969         {\r
970                 // Pack the control info into a byte\r
971                 dbyte = (buttons << 4) | ((mx + 1) << 2) | (my + 1);\r
972 \r
973                 if\r
974                 (\r
975                         (DemoBuffer[DemoOffset + 1] == dbyte)\r
976                 &&      (DemoBuffer[DemoOffset] < 255)\r
977                 )\r
978                         (DemoBuffer[DemoOffset])++;\r
979                 else\r
980                 {\r
981                         if (DemoOffset || DemoBuffer[DemoOffset])\r
982                                 DemoOffset += 2;\r
983 \r
984                         if (DemoOffset >= DemoSize)\r
985                                 Quit ("Demo buffer overflow");\r
986 \r
987                         DemoBuffer[DemoOffset] = 1;\r
988                         DemoBuffer[DemoOffset + 1] = dbyte;\r
989                 }\r
990         }\r
991 #endif\r
992 #ifdef __DEBUG_InputMgr__\r
993 if(dbg_joymousedelta)\r
994 {\r
995         {\r
996 static          int                     old_dx,old_dy;\r
997 static          word            old_buttons=0;\r
998                 if(dx!=old_dx || dy!=old_dy) printf("dx,dy      [%d,%d] %d,%d\n", dx, dy, mx, my);\r
999                 if(dx!=old_dx)  old_dx=dx;\r
1000                 if(dy!=old_dy)  old_dy=dy;\r
1001                 if(old_buttons!=buttons)\r
1002                 {\r
1003                         printf("        buttons={%u,%u,%u,%u}\n", player->info.button0, player->info.button1, player->info.button2, player->info.button3);\r
1004                         old_buttons=buttons;\r
1005                 }\r
1006         }\r
1007 }\r
1008 \r
1009 if(dbg_testcontrolnoisy > 0)\r
1010 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
1011 {\r
1012         //printf("b1=%u b2=%u b3=%u b4=%u       ", player->info.button0, player->info.button1, player->info.button2, player->info.button3);\r
1013         //printf("q=%d ", player->enti.q);\r
1014         //printf("cpee=%c ", dirchar(conpee));\r
1015         printf("pdir=%c d=%c dir=%c ", dirchar(player->pdir), dirchar(player->enti.d), dirchar(player->info.dir));\r
1016         /*if(realdelta) */printf("dx=%d dy=%d   mx=%d   my=%d", player->info.x, player->info.y, player->info.xaxis, player->info.yaxis);\r
1017         //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
1018         printf("\n");\r
1019 }\r
1020 #endif\r
1021 }\r
1022 \r
1023 ///////////////////////////////////////////////////////////////////////////\r
1024 //\r
1025 //      IN_SetControlType() - Sets the control type to be used by the specified\r
1026 //              player\r
1027 //\r
1028 ///////////////////////////////////////////////////////////////////////////\r
1029 void\r
1030 IN_SetControlType(player_t *player,ControlType type)\r
1031 {\r
1032         // DEBUG - check that requested type is present?\r
1033         player->Controls = type;\r
1034 }\r
1035 \r
1036 #if DEMO0\r
1037 ///////////////////////////////////////////////////////////////////////////\r
1038 //\r
1039 //      IN_StartDemoRecord() - Starts the demo recording, using a buffer the\r
1040 //              size passed. Returns if the buffer allocation was successful\r
1041 //\r
1042 ///////////////////////////////////////////////////////////////////////////\r
1043 boolean\r
1044 IN_StartDemoRecord(word bufsize)\r
1045 {\r
1046         if (!bufsize)\r
1047                 return(false);\r
1048 \r
1049         MM_GetPtr((memptr *)&DemoBuffer,bufsize);\r
1050         DemoMode = demo_Record;\r
1051         DemoSize = bufsize & ~1;\r
1052         DemoOffset = 0;\r
1053         DemoBuffer[0] = DemoBuffer[1] = 0;\r
1054 \r
1055         return(true);\r
1056 }\r
1057 \r
1058 ///////////////////////////////////////////////////////////////////////////\r
1059 //\r
1060 //      IN_StartDemoPlayback() - Plays back the demo pointed to of the given size\r
1061 //\r
1062 ///////////////////////////////////////////////////////////////////////////\r
1063 void\r
1064 IN_StartDemoPlayback(byte /*__segment*/ *buffer,word bufsize)\r
1065 {\r
1066         DemoBuffer = buffer;\r
1067         DemoMode = demo_Playback;\r
1068         DemoSize = bufsize & ~1;\r
1069         DemoOffset = 0;\r
1070 }\r
1071 \r
1072 ///////////////////////////////////////////////////////////////////////////\r
1073 //\r
1074 //      IN_StopDemo() - Turns off demo mode\r
1075 //\r
1076 ///////////////////////////////////////////////////////////////////////////\r
1077 void\r
1078 IN_StopDemo(void)\r
1079 {\r
1080         if ((DemoMode == demo_Record) && DemoOffset)\r
1081                 DemoOffset += 2;\r
1082 \r
1083         DemoMode = demo_Off;\r
1084 }\r
1085 \r
1086 ///////////////////////////////////////////////////////////////////////////\r
1087 //\r
1088 //      IN_FreeDemoBuffer() - Frees the demo buffer, if it's been allocated\r
1089 //\r
1090 ///////////////////////////////////////////////////////////////////////////\r
1091 void\r
1092 IN_FreeDemoBuffer(void)\r
1093 {\r
1094         if (DemoBuffer)\r
1095                 MM_FreePtr((memptr *)&DemoBuffer);\r
1096 }\r
1097 #endif\r
1098 \r
1099 \r
1100 ///////////////////////////////////////////////////////////////////////////\r
1101 //\r
1102 //      IN_GetScanName() - Returns a string containing the name of the\r
1103 //              specified scan code\r
1104 //\r
1105 ///////////////////////////////////////////////////////////////////////////\r
1106 byte *\r
1107 IN_GetScanName(ScanCode scan)\r
1108 {\r
1109         byte            **p;\r
1110         ScanCode        far *s;\r
1111 \r
1112         for (s = ExtScanCodes,p = ExtScanNames;*s;p++,s++)\r
1113                 if (*s == scan)\r
1114                         return(*p);\r
1115 \r
1116         return(ScanNames[scan]);\r
1117 }\r
1118 \r
1119 ///////////////////////////////////////////////////////////////////////////\r
1120 //\r
1121 //      IN_WaitForKey() - Waits for a scan code, then clears LastScan and\r
1122 //              returns the scan code\r
1123 //\r
1124 ///////////////////////////////////////////////////////////////////////////\r
1125 ScanCode\r
1126 IN_WaitForKey(void)\r
1127 {\r
1128         ScanCode        result;\r
1129 \r
1130         while (!(result = inst.LastScan))\r
1131                 ;\r
1132         inst.LastScan = 0;\r
1133         return(result);\r
1134 }\r
1135 \r
1136 ///////////////////////////////////////////////////////////////////////////\r
1137 //\r
1138 //      IN_WaitForASCII() - Waits for an ASCII char, then clears LastASCII and\r
1139 //              returns the ASCII value\r
1140 //\r
1141 ///////////////////////////////////////////////////////////////////////////\r
1142 char\r
1143 IN_WaitForASCII(void)\r
1144 {\r
1145         char            result;\r
1146 \r
1147         while (!(result = inst.LastASCII))\r
1148                 ;\r
1149         inst.LastASCII = '\0';\r
1150         return(result);\r
1151 }\r
1152 \r
1153 ///////////////////////////////////////////////////////////////////////////\r
1154 //\r
1155 //      IN_Ack() - waits for a button or key press.  If a button is down, upon\r
1156 // calling, it must be released for it to be recognized\r
1157 //\r
1158 ///////////////////////////////////////////////////////////////////////////\r
1159 \r
1160 boolean btnstate[8];\r
1161 \r
1162 void IN_StartAck(global_game_variables_t *gvar)\r
1163 {\r
1164         unsigned        i,buttons;\r
1165 \r
1166 //\r
1167 // get initial state of everything\r
1168 //\r
1169         IN_ClearKeysDown();\r
1170         memset (btnstate,0,sizeof(btnstate));\r
1171 \r
1172         buttons = IN_JoyButtons () << 4;\r
1173         if (gvar->in.MousePresent)\r
1174                 buttons |= IN_MouseButtons (gvar);\r
1175 \r
1176         for (i=0;i<8;i++,buttons>>=1)\r
1177                 if (buttons&1)\r
1178                         btnstate[i] = true;\r
1179 }\r
1180 \r
1181 \r
1182 boolean IN_CheckAck (global_game_variables_t *gvar)\r
1183 {\r
1184         unsigned        i,buttons;\r
1185 \r
1186 //\r
1187 // see if something has been pressed\r
1188 //\r
1189         if(!gvar->in.IN_Started)\r
1190                 getch();\r
1191         else\r
1192         {\r
1193                 if (inst.LastScan)\r
1194                         return true;\r
1195         }\r
1196 \r
1197         buttons = IN_JoyButtons () << 4;\r
1198         if (gvar->in.MousePresent)\r
1199                 buttons |= IN_MouseButtons (gvar);\r
1200 \r
1201         for (i=0;i<8;i++,buttons>>=1)\r
1202                 if ( buttons&1 )\r
1203                 {\r
1204                         if (!btnstate[i])\r
1205                                 return true;\r
1206                 }\r
1207                 else\r
1208                         btnstate[i]=false;\r
1209 \r
1210         return false;\r
1211 }\r
1212 \r
1213 \r
1214 void IN_Ack (global_game_variables_t *gvar)\r
1215 {\r
1216         IN_StartAck (gvar);\r
1217 \r
1218         while (!IN_CheckAck (gvar))\r
1219         ;\r
1220 }\r
1221 \r
1222 ///////////////////////////////////////////////////////////////////////////\r
1223 //\r
1224 //      IN_IsUserInput() - Returns true if a key has been pressed or a button\r
1225 //              is down\r
1226 //\r
1227 ///////////////////////////////////////////////////////////////////////////\r
1228 boolean\r
1229 IN_IsUserInput(global_game_variables_t *gvar)\r
1230 {\r
1231         boolean result;\r
1232         word    i;\r
1233 \r
1234         result = inst.LastScan;\r
1235 \r
1236         if (gvar->in.MousePresent)\r
1237                 if (INL_GetMouseButtons())\r
1238                         result = true;\r
1239 \r
1240         for (i = 0;i < MaxJoys;i++)\r
1241                 if (gvar->in.JoysPresent[i])\r
1242                         if (INL_GetJoyButtons(i))\r
1243                                 result = true;\r
1244 \r
1245         return(result);\r
1246 }\r
1247 \r
1248 ///////////////////////////////////////////////////////////////////////////\r
1249 //\r
1250 //      IN_UserInput() - Waits for the specified delay time (in ticks) or the\r
1251 //              user pressing a key or a mouse button. If the clear flag is set, it\r
1252 //              then either clears the key or waits for the user to let the mouse\r
1253 //              button up.\r
1254 //\r
1255 ///////////////////////////////////////////////////////////////////////////\r
1256 boolean IN_UserInput(word delay, global_game_variables_t *gvar)\r
1257 {\r
1258         word TimeCount = *clockw;\r
1259         word    lasttime;\r
1260 \r
1261         lasttime = TimeCount;\r
1262         IN_StartAck (gvar);\r
1263         do\r
1264         {\r
1265                 if (IN_CheckAck(gvar))\r
1266                         return true;\r
1267         } while (TimeCount - lasttime < delay);\r
1268         return(false);\r
1269 }\r
1270 \r
1271 //===========================================================================\r
1272 \r
1273 /*\r
1274 ===================\r
1275 =\r
1276 = IN_MouseButtons\r
1277 =\r
1278 ===================\r
1279 */\r
1280 \r
1281 byte    IN_MouseButtons (global_game_variables_t *gvar)\r
1282 {\r
1283         if (gvar->in.MousePresent)\r
1284         {\r
1285                 Mouse(MButtons);\r
1286                 return _BX;\r
1287         }\r
1288         else\r
1289                 return 0;\r
1290 }\r
1291 \r
1292 \r
1293 /*\r
1294 ===================\r
1295 =\r
1296 = IN_JoyButtons\r
1297 =\r
1298 ===================\r
1299 */\r
1300 \r
1301 byte    IN_JoyButtons (void)\r
1302 {\r
1303         byte joybits;\r
1304 \r
1305         joybits = inportb(0x201);       // Get all the joystick buttons\r
1306         joybits >>= 4;                          // only the high bits are useful\r
1307         joybits ^= 15;                          // return with 1=pressed\r
1308 \r
1309         return joybits;\r
1310 }\r
1311 \r
1312 boolean IN_KeyDown(byte code)\r
1313 {\r
1314 #ifdef __DEBUG_InputMgr__\r
1315 //      if(inst.Keyboard[code])\r
1316 //              printf("IN_KeyDown(%c): %u\n", code, inst.Keyboard[code]);\r
1317         if(!dbg_nointest)\r
1318 #endif\r
1319         return inst.Keyboard[code];\r
1320 #ifdef __DEBUG_InputMgr__\r
1321         else\r
1322                 if(dbg_nointest && kbhit())\r
1323                         return 1;\r
1324                 else\r
1325                         return 0;\r
1326 #endif\r
1327 }\r
1328 \r
1329 void IN_ClearKey(byte code)\r
1330 {\r
1331         inst.Keyboard[code] = false;\r
1332         if(code == inst.LastScan)\r
1333                 inst.LastScan = sc_None;\r
1334         }\r
1335 \r
1336 boolean IN_qb(byte kee)\r
1337 {\r
1338 #ifdef __DEBUG_InputMgr__\r
1339         if(dbg_testkeyin) if(inst.Keyboard[kee]) printf("IN_qb():       %u\n", inst.Keyboard[kee]);\r
1340 #endif\r
1341         if(inst.Keyboard[kee]==true) return 1;\r
1342         else return 0;\r
1343 }\r
1344 \r
1345 ScanCode IN_GetLastScan()\r
1346 {\r
1347         return inst.LastScan;\r
1348 }\r
1349 \r
1350 ScanCode IN_GetCurCode()\r
1351 {\r
1352         return inst.CurCode;\r
1353 }\r
1354 \r
1355 void IN_KbdLED()\r
1356 {\r
1357         byte far *lock_key;\r
1358 \r
1359         // turn off num-lock via BIOS\r
1360         lock_key = MK_FP(0x040, 0x017); // Pointing to the address of the bios shift state keys\r
1361         *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
1362         OldKeyVect();   // call BIOS keyhandler to change keyboard lights\r
1363 }\r