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