__seguse.txt added to show _seg usage also OpenVGMFile needs to be ported to 16_snd...

diff --git a/data/meeee5dffbc3496814ead13b3c29d8b99adef.png b/data/meeee.png
similarity index 100%
rename from data/meeee5dffbc3496814ead13b3c29d8b99adef.png
rename to data/meeee.png

diff --git a/data/spri/me.pcx b/data/spri/me.pcx
new file mode 100755 (executable)
index 0000000..6e78ab9
Binary files /dev/null and b/data/spri/me.pcx differ

diff --git a/data/spri/me.sht b/data/spri/me.sht
new file mode 100755 (executable)
index 0000000..b785309
--- /dev/null
+++ b/data/spri/me.sht
@@ -0,0 +1,153 @@
+# MEKYUU.PCX demo sprite sheet compiler script
+# (C) 2016 Jonathan Campbell
+
+# *spritesheet declares the section used by the sprite sheet cutting tool
+#
+# Sprites are declared by name (which becomes the .VRL file) at the + in the form:
+# +NAME@ID
+#
+# Sprite names are meant for temporary use when compiling the sprite sheet into VRLs.
+# At some point a longer name might be provided for use in your code.
+# This will fill the CURRENT WORKING DIRECTORY with .VRL files as directed when you
+# run PCXSSCUT, make sure your makefile does this in a temporary directory when
+# you integrate into your build and that your cleanup commands delete these files,
+# and that your .gitignore does not attempt to commit these files.
+
+# this format is a bit crap, but we'll improve it as needed. be patient.
+
+# begin spritesheet section
+*spritesheet
+
+# ---------------- player, walking, blue shirt with white cross. Frame 2/3 could be used for standing still
+
+# player, forward, frame 1/3
++MEBFCW0@10
+xy=0,0
+wh=24,32
+# player, forward, frame 2/3
++MEBFCW1@11
+xy=24,0
+wh=24,32
+# player, forward, frame 3/3
++MEBFCW2@12
+xy=48,0
+wh=24,32
+
+# player, left, frame 1/3
++MEBLCW0@20
+xy=0,32
+wh=24,32
+# player, left, frame 2/3
++MEBLCW1@21
+xy=24,32
+wh=24,32
+# player, left, frame 3/3
++MEBLCW2@22
+xy=48,32
+wh=24,32
+
+# player, right, frame 1/3
++MEBRCW0@30
+xy=0,64
+wh=24,32
+# player, right, frame 2/3
++MEBRCW1@31
+xy=24,64
+wh=24,32
+# player, right, frame 3/3
++MEBRCW2@32
+xy=48,64
+wh=24,32
+
+# player, away, frame 1/3
++MEBACW0@40
+xy=0,96
+wh=24,32
+# player, away, frame 2/3
++MEBACW1@41
+xy=24,96
+wh=24,32
+# player, away, frame 3/3
++MEBACW2@42
+xy=48,96
+wh=24,32
+
+# begin animation list section. must come after sprite sheet
+*animation
+
+# Me-tan, forward, standing and walking animation cycles
++MEBFCW_STANDING@10
+sprite=MEBFCW1
+
++MEBFCW_WALKING@11
+sprite=MEBFCW0
+delay=3
+-newframe
+sprite=MEBFCW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+-newframe
+sprite=MEBFCW2
+delay=3
+-newframe
+sprite=MEBFCW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+
+# Me-tan, left, standing and walking animation cycles
++MEBLCW_STANDING@20
+sprite=MEBLCW1
+
++MEBLCW_WALKING@21
+sprite=MEBLCW0
+delay=3
+-newframe
+sprite=MEBLCW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+-newframe
+sprite=MEBLCW2
+delay=3
+-newframe
+sprite=MEBLCW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+
+# Me-tan, right, standing and walking animation cycles
++MEBRCW_STANDING@30
+sprite=MEBRCW1
+
++MEBRCW_WALKING@31
+sprite=MEBRCW0
+delay=3
+-newframe
+sprite=MEBRCW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+-newframe
+sprite=MEBRCW2
+delay=3
+-newframe
+sprite=MEBRCW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+
+# Me-tan, away, standing and walking animation cycles
++MEBACW_STANDING@40
+sprite=MEBACW1
+
++MEBACW_WALKING@41
+sprite=MEBACW0
+delay=3
+-newframe
+sprite=MEBACW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+-newframe
+sprite=MEBACW2
+delay=3
+-newframe
+sprite=MEBACW1
+delay=3
+event=@100         # in this example, signal the game engine the frame is one that can immediately transition to "standing"
+

diff --git a/db.exe b/db.exe
index 457a9fa192d31529e39312c63fcfc8b50357625a..587c001b44becfde111c370f0125c27fcbe93cb6 100755 (executable)
Binary files a/db.exe and b/db.exe differ

diff --git a/src/lib/16_in_.c b/src/lib/16_in_.c
new file mode 100755 (executable)
index 0000000..8ae2a32
--- /dev/null
+++ b/src/lib/16_in_.c
@@ -0,0 +1,1321 @@
+/* Catacomb Apocalypse Source Code\r
+ * Copyright (C) 1993-2014 Flat Rock Software\r
+ *\r
+ * This program is free software; you can redistribute it and/or modify\r
+ * it under the terms of the GNU General Public License as published by\r
+ * the Free Software Foundation; either version 2 of the License, or\r
+ * (at your option) any later version.\r
+ *\r
+ * This program is distributed in the hope that it will be useful,\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
+ * GNU General Public License for more details.\r
+ *\r
+ * You should have received a copy of the GNU General Public License along\r
+ * with this program; if not, write to the Free Software Foundation, Inc.,\r
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
+ */\r
+\r
+//\r
+//     ID Engine\r
+//     ID_IN.c - Input Manager\r
+//     v1.0d1w\r
+//     By Jason Blochowiak\r
+//     Open Watcom port by sparky4\r
+//\r
+\r
+//\r
+//     This module handles dealing with the various input devices\r
+//\r
+//     Depends on: Memory Mgr (for demo recording), Sound Mgr (for timing stuff),\r
+//                             User Mgr (for command line parms)\r
+//\r
+//     Globals:\r
+//             LastScan - The keyboard scan code of the last key pressed\r
+//             LastASCII - The ASCII value of the last key pressed\r
+//     DEBUG - there are more globals\r
+//\r
+\r
+#include "src/lib/16_in.h"\r
+#pragma        hdrstop\r
+\r
+/*\r
+=============================================================================\r
+\r
+                                       GLOBAL VARIABLES\r
+\r
+=============================================================================\r
+*/\r
+// moved to 16_tdef.h\r
+\r
+/*\r
+=============================================================================\r
+\r
+                                       LOCAL VARIABLES\r
+\r
+=============================================================================\r
+*/\r
+\r
+#ifdef __cplusplus             /* Function must be declared C style */\r
+extern "C" {\r
+#endif\r
+\r
+static byte        far ASCIINames[] =          // Unshifted ASCII for scan codes\r
+                                       {\r
+//      0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F\r
+       0  ,27 ,'1','2','3','4','5','6','7','8','9','0','-','=',8  ,9  ,        // 0\r
+       'q','w','e','r','t','y','u','i','o','p','[',']',13 ,0  ,'a','s',        // 1\r
+       'd','f','g','h','j','k','l',';',39 ,'`',0  ,92 ,'z','x','c','v',        // 2\r
+       'b','n','m',',','.','/',0  ,'*',0  ,' ',0  ,0  ,0  ,0  ,0  ,0  ,        // 3\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,'7','8','9','-','4','5','6','+','1',        // 4\r
+       '2','3','0',127,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 5\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 6\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0           // 7\r
+                                       },\r
+                                       far ShiftNames[] =              // Shifted ASCII for scan codes\r
+                                       {\r
+//      0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F\r
+       0  ,27 ,'!','@','#','$','%','^','&','*','(',')','_','+',8  ,9  ,        // 0\r
+       'Q','W','E','R','T','Y','U','I','O','P','{','}',13 ,0  ,'A','S',        // 1\r
+       'D','F','G','H','J','K','L',':',34 ,'~',0  ,'|','Z','X','C','V',        // 2\r
+       'B','N','M','<','>','?',0  ,'*',0  ,' ',0  ,0  ,0  ,0  ,0  ,0  ,        // 3\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,'7','8','9','-','4','5','6','+','1',        // 4\r
+       '2','3','0',127,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 5\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 6\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0           // 7\r
+                                       },\r
+                                       far SpecialNames[] =    // ASCII for 0xe0 prefixed codes\r
+                                       {\r
+//      0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 0\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,13 ,0  ,0  ,0  ,        // 1\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 2\r
+       0  ,0  ,0  ,0  ,0  ,'/',0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 3\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 4\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 5\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,        // 6\r
+       0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0           // 7\r
+                                       },\r
+\r
+\r
+                                       *ScanNames[] =          // Scan code names with single chars\r
+                                       {\r
+       "?","?","1","2","3","4","5","6","7","8","9","0","-","+","?","?",\r
+       "Q","W","E","R","T","Y","U","I","O","P","[","]","|","?","A","S",\r
+       "D","F","G","H","J","K","L",";","\"","?","?","?","Z","X","C","V",\r
+       "B","N","M",",",".","/","?","?","?","?","?","?","?","?","?","?",\r
+       "?","?","?","?","?","?","?","?","\xf","?","-","\x15","5","\x11","+","?",\r
+       "\x13","?","?","?","?","?","?","?","?","?","?","?","?","?","?","?",\r
+       "?","?","?","?","?","?","?","?","?","?","?","?","?","?","?","?",\r
+       "?","?","?","?","?","?","?","?","?","?","?","?","?","?","?","?"\r
+                                       },      // DEBUG - consolidate these\r
+\r
+\r
+                                       far ExtScanCodes[] =    // Scan codes with >1 char names\r
+                                       {\r
+       1,0xe,0xf,0x1d,0x2a,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,\r
+       0x3f,0x40,0x41,0x42,0x43,0x44,0x57,0x59,0x46,0x1c,0x36,\r
+       0x37,0x38,0x47,0x49,0x4f,0x51,0x52,0x53,0x45,0x48,\r
+       0x50,0x4b,0x4d,0x00\r
+                                       },\r
+                                       *ExtScanNames[] =       // Names corresponding to ExtScanCodes\r
+                                       {\r
+       "Esc","BkSp","Tab","Ctrl","LShft","Space","CapsLk","F1","F2","F3","F4",\r
+       "F5","F6","F7","F8","F9","F10","F11","F12","ScrlLk","Enter","RShft",\r
+       "PrtSc","Alt","Home","PgUp","End","PgDn","Ins","Del","NumLk","Up",\r
+       "Down","Left","Right",""\r
+                                       };\r
+\r
+static Direction       DirTable[] =            // Quick lookup for total direction\r
+                                       {\r
+                                               //dir_Nortinest,\r
+                                               dir_North,\r
+                                               dir_West,\r
+                                               dir_None,\r
+                                               dir_East,\r
+                                               dir_South\r
+                                               //dir_NorthEast,\r
+                                               //dir_Soutinest,\r
+                                               //,dir_SouthEast\r
+                                       };\r
+\r
+static void                    (*INL_KeyHook)(void);\r
+static void interrupt  (*OldKeyVect)(void);\r
+\r
+static char                    *ParmStringsIN[] = {"nojoys","nomouse",nil};\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+//     Internal routines\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_KeyService() - Handles a keyboard interrupt (key up/down)\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void interrupt\r
+INL_KeyService()\r
+{\r
+static boolean special;\r
+               byte    k,c;\r
+               register byte temp;\r
+\r
+       k = inp(0x60);  // Get the scan code\r
+\r
+       // Tell the XT keyboard controller to clear the key\r
+       outp(0x61,(temp = inp(0x61)) | 0x80);\r
+       outp(0x61,temp);\r
+\r
+       if (k == 0xe0)          // Special key prefix\r
+               special = true;\r
+       else if (k == 0xe1)     // Handle Pause key\r
+               inpu.Paused = true;\r
+       else\r
+       {\r
+               if (k & 0x80)   // Break code\r
+               {\r
+                       k &= 0x7f;\r
+\r
+// DEBUG - handle special keys: ctl-alt-delete, print scrn\r
+\r
+                       inpu.Keyboard[k] = false;\r
+               }\r
+               else                    // Make code\r
+               {\r
+                       inst.LastCode = inst.CurCode;\r
+                       inst.CurCode = inpu.LastScan = k;\r
+                       inpu.Keyboard[k] = true;\r
+\r
+                       if (special)\r
+                               c = SpecialNames[k];\r
+                       else\r
+                       {\r
+                               if (k == sc_CapsLock)\r
+                               {\r
+                                       inst.CapsLock ^= true;\r
+                                       // DEBUG - make caps lock light work\r
+                               }\r
+\r
+                               if (inpu.Keyboard[sc_LShift] || inpu.Keyboard[sc_RShift])       // If shifted\r
+                               {\r
+                                       c = ShiftNames[k];\r
+                                       if ((c >= 'A') && (c <= 'Z') && inst.CapsLock)\r
+                                               c += 'a' - 'A';\r
+                               }\r
+                               else\r
+                               {\r
+                                       c = ASCIINames[k];\r
+                                       if ((c >= 'a') && (c <= 'z') && inst.CapsLock)\r
+                                               c -= 'a' - 'A';\r
+                               }\r
+                       }\r
+                       if (c)\r
+                               inpu.LastASCII = c;\r
+               }\r
+\r
+               special = false;\r
+       }\r
+\r
+       if (INL_KeyHook && !special)\r
+               INL_KeyHook();\r
+#ifdef __DEBUG_InputMgr__\r
+       if(dbg_testkeyin > 0) printf("%c        %u      [0x%x %u]       %u\n", c, c, k, k, inpu.Keyboard[k]);\r
+#endif\r
+       outp(0x20,0x20);\r
+}\r
+\r
+void\r
+Mouse(int x)\r
+{\r
+       //union REGS CPURegs;\r
+       //x = CPURegs.x.ax;\r
+       __asm {\r
+               mov     ax,x\r
+               int     MouseInt\r
+       }\r
+       //int86(MouseInt,&CPURegs,&CPURegs);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_GetMouseDelta() - Gets the amount that the mouse has moved from the\r
+//             mouse driver\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static void\r
+INL_GetMouseDelta(int *x,int *y)\r
+{\r
+       union REGS CPURegs;\r
+       Mouse(MDelta);\r
+       *x = CPURegs.x.cx;\r
+       *y = CPURegs.x.dx;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_GetMouseButtons() - Gets the status of the mouse buttons from the\r
+//             mouse driver\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static word\r
+INL_GetMouseButtons(void)\r
+{\r
+       union REGS CPURegs;\r
+       word    buttons;\r
+\r
+       Mouse(MButtons);\r
+       buttons = CPURegs.x.bx;\r
+       return(buttons);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_GetJoyAbs() - Reads the absolute position of the specified joystick\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_GetJoyAbs(word joy,word *xp,word *yp)\r
+{\r
+       byte    xb,yb,\r
+                       xs,ys;\r
+       word    x,y;\r
+\r
+       x = y = 0;\r
+       xs = joy? 2 : 0;                // Find shift value for x axis\r
+       xb = 1 << xs;                   // Use shift value to get x bit mask\r
+       ys = joy? 3 : 1;                // Do the same for y axis\r
+       yb = 1 << ys;\r
+\r
+// Read the absolute joystick values\r
+       __asm {\r
+               pushf                           // Save some registers\r
+               push    si\r
+               push    di\r
+               cli                                     // Make sure an interrupt doesn't screw the timings\r
+\r
+\r
+               mov             dx,0x201\r
+               in              al,dx\r
+               out             dx,al           // Clear the resistors\r
+\r
+               mov             ah,[xb]         // Get masks into registers\r
+               mov             ch,[yb]\r
+\r
+               xor             si,si           // Clear count registers\r
+               xor             di,di\r
+               xor             bh,bh           // Clear high byte of bx for later\r
+\r
+               push    bp                      // Don't mess up stack frame\r
+               mov             bp,MaxJoyValue\r
+#ifdef __BORLANDC__\r
+       }\r
+#endif\r
+loo:\r
+#ifdef __BORLANDC__\r
+       __asm {\r
+#endif\r
+               in              al,dx           // Get bits indicating whether all are finished\r
+\r
+               dec             bp                      // Check bounding register\r
+               jz              done            // We have a silly value - abort\r
+\r
+               mov             bl,al           // Duplicate the bits\r
+               and             bl,ah           // Mask off useless bits (in [xb])\r
+               add             si,bx           // Possibly increment count register\r
+               mov             cl,bl           // Save for testing later\r
+\r
+               mov             bl,al\r
+               and             bl,ch           // [yb]\r
+               add             di,bx\r
+\r
+               add             cl,bl\r
+               jnz             loo             // If both bits were 0, drop out\r
+#ifdef __BORLANDC__\r
+       }\r
+#endif\r
+done:\r
+#ifdef __BORLANDC__\r
+       __asm {\r
+#endif\r
+               pop             bp\r
+\r
+               mov             cl,[xs]         // Get the number of bits to shift\r
+               shr             si,cl           //  and shift the count that many times\r
+\r
+               mov             cl,[ys]\r
+               shr             di,cl\r
+\r
+               mov             [x],si          // Store the values into the variables\r
+               mov             [y],di\r
+\r
+               pop             di\r
+               pop             si\r
+               popf                            // Restore the registers\r
+       }\r
+\r
+       *xp = x;\r
+       *yp = y;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_GetJoyDelta() - Returns the relative movement of the specified\r
+//             joystick (from +/-127, scaled adaptively)\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static void\r
+INL_GetJoyDelta(word joy,int *dx,int *dy,boolean adaptive)\r
+{\r
+       word            x,y;\r
+       word    time;\r
+       word TimeCount = *clockw;\r
+       JoystickDef     *def;\r
+static word    lasttime;\r
+\r
+       IN_GetJoyAbs(joy,&x,&y);\r
+       def = inpu.JoyDefs + joy;\r
+\r
+       if (x < def->threshMinX)\r
+       {\r
+               if (x < def->joyMinX)\r
+                       x = def->joyMinX;\r
+\r
+               x = -(x - def->threshMinX);\r
+               x *= def->joyMultXL;\r
+               x >>= JoyScaleShift;\r
+               *dx = (x > 127)? -127 : -x;\r
+       }\r
+       else if (x > def->threshMaxX)\r
+       {\r
+               if (x > def->joyMaxX)\r
+                       x = def->joyMaxX;\r
+\r
+               x = x - def->threshMaxX;\r
+               x *= def->joyMultXH;\r
+               x >>= JoyScaleShift;\r
+               *dx = (x > 127)? 127 : x;\r
+       }\r
+       else\r
+               *dx = 0;\r
+\r
+       if (y < def->threshMinY)\r
+       {\r
+               if (y < def->joyMinY)\r
+                       y = def->joyMinY;\r
+\r
+               y = -(y - def->threshMinY);\r
+               y *= def->joyMultYL;\r
+               y >>= JoyScaleShift;\r
+               *dy = (y > 127)? -127 : -y;\r
+       }\r
+       else if (y > def->threshMaxY)\r
+       {\r
+               if (y > def->joyMaxY)\r
+                       y = def->joyMaxY;\r
+\r
+               y = y - def->threshMaxY;\r
+               y *= def->joyMultYH;\r
+               y >>= JoyScaleShift;\r
+               *dy = (y > 127)? 127 : y;\r
+       }\r
+       else\r
+               *dy = 0;\r
+\r
+       if (adaptive)\r
+       {\r
+               time = (TimeCount - lasttime) / 2;\r
+               if (time)\r
+               {\r
+                       if (time > 8)\r
+                               time = 8;\r
+                       *dx *= time;\r
+                       *dy *= time;\r
+               }\r
+       }\r
+       lasttime = TimeCount;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_GetJoyButtons() - Returns the button status of the specified\r
+//             joystick\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static word\r
+INL_GetJoyButtons(word joy)\r
+{\r
+register       word    result;\r
+\r
+       result = inp(0x201);    // Get all the joystick buttons\r
+       result >>= joy? 6 : 4;  // Shift into bits 0-1\r
+       result &= 3;                            // Mask off the useless bits\r
+       result ^= 3;\r
+       return(result);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_GetJoyButtonsDB() - Returns the de-bounced button status of the\r
+//             specified joystick\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+word\r
+IN_GetJoyButtonsDB(word joy)\r
+{\r
+       word TimeCount = *clockw;\r
+       word    lasttime;\r
+       word            result1,result2;\r
+\r
+       do\r
+       {\r
+               result1 = INL_GetJoyButtons(joy);\r
+               lasttime = TimeCount;\r
+               while(TimeCount == lasttime)\r
+               result2 = INL_GetJoyButtons(joy);\r
+       } while(result1 != result2);\r
+       return(result1);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_StartKbd() - Sets up my keyboard stuff for use\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static void\r
+INL_StartKbd()\r
+{\r
+       byte far *lock_key;\r
+       INL_KeyHook = 0;        // Clear key hook\r
+\r
+       IN_ClearKeysDown();\r
+\r
+       OldKeyVect = _dos_getvect(KeyInt);\r
+\r
+       // turn off num-lock via BIOS\r
+       lock_key = MK_FP(0x040, 0x017); // Pointing to the address of the bios shift state keys\r
+       *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
+       OldKeyVect();   // call BIOS keyhandler to change keyboard lights\r
+       _dos_setvect(KeyInt,INL_KeyService);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_ShutKbd() - Restores keyboard control to the BIOS\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static void\r
+INL_ShutKbd(void)\r
+{\r
+       pokeb(0x40,0x17,peekb(0x40,0x17) & 0xfaf0);     // Clear ctrl/alt/shift flags\r
+\r
+       _dos_setvect(KeyInt,OldKeyVect);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_StartMouse() - Detects and sets up the mouse\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static boolean\r
+INL_StartMouse(void)\r
+{\r
+       union REGS CPURegs;\r
+       if(_dos_getvect(MouseInt))\r
+       {\r
+               Mouse(MReset);\r
+               if(CPURegs.x.ax == 0xffff)\r
+                       return(true);\r
+       }\r
+       return(false);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_ShutMouse() - Cleans up after the mouse\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static void\r
+INL_ShutMouse(void)\r
+{\r
+}\r
+\r
+//\r
+//     INL_SetJoyScale() - Sets up scaling values for the specified joystick\r
+//\r
+static void\r
+INL_SetJoyScale(word joy)\r
+{\r
+       JoystickDef     *def;\r
+\r
+       def = &(inpu.JoyDefs[joy]);\r
+       def->joyMultXL = JoyScaleMax / (def->threshMinX - def->joyMinX);\r
+       def->joyMultXH = JoyScaleMax / (def->joyMaxX - def->threshMaxX);\r
+       def->joyMultYL = JoyScaleMax / (def->threshMinY - def->joyMinY);\r
+       def->joyMultYH = JoyScaleMax / (def->joyMaxY - def->threshMaxY);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_SetupJoy() - Sets up thresholding values and calls INL_SetJoyScale()\r
+//             to set up scaling values\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_SetupJoy(word joy,word minx,word maxx,word miny,word maxy)\r
+{\r
+       word            d,r;\r
+       JoystickDef     *def;\r
+\r
+       def = &(inpu.JoyDefs[joy]);\r
+\r
+       def->joyMinX = minx;\r
+       def->joyMaxX = maxx;\r
+       r = maxx - minx;\r
+       d = r / 3;\r
+       def->threshMinX = ((r / 2) - d) + minx;\r
+       def->threshMaxX = ((r / 2) + d) + minx;\r
+\r
+       def->joyMinY = miny;\r
+       def->joyMaxY = maxy;\r
+       r = maxy - miny;\r
+       d = r / 3;\r
+       def->threshMinY = ((r / 2) - d) + miny;\r
+       def->threshMaxY = ((r / 2) + d) + miny;\r
+\r
+       INL_SetJoyScale(joy);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_StartJoy() - Detects & auto-configures the specified joystick\r
+//                                     The auto-config assumes the joystick is centered\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static boolean\r
+INL_StartJoy(word joy)\r
+{\r
+       word            x,y;\r
+\r
+       IN_GetJoyAbs(joy,&x,&y);\r
+\r
+       if\r
+       (\r
+               ((x == 0) || (x > MaxJoyValue - 10))\r
+       ||      ((y == 0) || (y > MaxJoyValue - 10))\r
+       )\r
+               return(false);\r
+       else\r
+       {\r
+               IN_SetupJoy(joy,0,x * 2,0,y * 2);\r
+               return(true);\r
+       }\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_ShutJoy() - Cleans up the joystick stuff\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static void\r
+INL_ShutJoy(word joy)\r
+{\r
+       inpu.JoysPresent[joy] = false;\r
+}\r
+\r
+//     Public routines\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_Startup() - Starts up the Input Mgr\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_Startup()\r
+{\r
+       boolean checkjoys,checkmouse;\r
+       word    i;\r
+\r
+       if (inst.IN_Started)\r
+               return;\r
+\r
+       checkjoys = true;\r
+       checkmouse = true;\r
+       for (i = 1;i < _argc;i++)\r
+       {\r
+               switch (US_CheckParm(_argv[i],ParmStringsIN))\r
+               {\r
+               case 0:\r
+                       checkjoys = false;\r
+                       break;\r
+               case 1:\r
+                       checkmouse = false;\r
+                       break;\r
+               }\r
+       }\r
+\r
+       INL_StartKbd();\r
+       inpu.MousePresent = checkmouse? INL_StartMouse() : false;\r
+\r
+       for (i = 0;i < MaxJoys;i++)\r
+               inpu.JoysPresent[i] = checkjoys? INL_StartJoy(i) : false;\r
+\r
+       {{0x1d,0x38,0x47,0x48,0x49,0x4b,0x4d,0x4f,0x50,0x51}};\r
+       inst.IN_Started = true;\r
+\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_Default() - Sets up default conditions for the Input Mgr\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_Default(boolean gotit,player_t *player,ControlType nt)\r
+{\r
+       int i;\r
+       if\r
+       (\r
+               (!gotit)\r
+       ||      ((nt == ctrl_Joystick1) && !inpu.JoysPresent[0])\r
+       ||      ((nt == ctrl_Joystick2) && !inpu.JoysPresent[1])\r
+       ||      ((nt == ctrl_Mouse) && !inpu.MousePresent)\r
+       )\r
+               nt = ctrl_Keyboard1;\r
+       inpu.KbdDefs[0].button0 = 0x1c;\r
+       inpu.KbdDefs[0].button1 = 0x38;\r
+       //in.KbdDefs[0].upleft = 0x47;\r
+       inpu.KbdDefs[0].up = 0x48;\r
+       //in.KbdDefs[0].upright = 0x49;\r
+       inpu.KbdDefs[0].left = 0x4b;\r
+       inpu.KbdDefs[0].right = 0x4d;\r
+       //in.KbdDefs[0].downleft = 0x4f;\r
+       inpu.KbdDefs[0].down = 0x50;\r
+       //in.KbdDefs[0].downright = 0x51;\r
+       IN_SetControlType(0,player,nt);\r
+       for(i=0; i>MaxPlayers;i++)\r
+               player[i].enti.d =2;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_Shutdown() - Shuts down the Input Mgr\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_Shutdown()\r
+{\r
+       word    i;\r
+\r
+       if (!inst.IN_Started)\r
+               return;\r
+\r
+       INL_ShutMouse();\r
+       for (i = 0;i < MaxJoys;i++)\r
+               INL_ShutJoy(i);\r
+       INL_ShutKbd();\r
+\r
+       inst.IN_Started = false;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_SetKeyHook() - Sets the routine that gets called by INL_KeyService()\r
+//                     everytime a real make/break code gets hit\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_SetKeyHook(void (*hook)())\r
+{\r
+       INL_KeyHook = hook;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_ClearKeyDown() - Clears the keyboard array\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_ClearKeysDown()\r
+{\r
+       //int   i;\r
+\r
+       inpu.LastScan = sc_None;\r
+       inpu.LastASCII = key_None;\r
+       memset (inpu.Keyboard,0,sizeof(inpu.Keyboard));\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     INL_AdjustCursor() - Internal routine of common code from IN_ReadCursor()\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+static void\r
+INL_AdjustCursor(CursorInfo *info,word buttons,int dx,int dy)\r
+{\r
+       if (buttons & (1 << 0))\r
+               info->button0 = true;\r
+       if (buttons & (1 << 1))\r
+               info->button1 = true;\r
+\r
+       info->x += dx;\r
+       info->y += dy;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_ReadCursor() - Reads the input devices and fills in the cursor info\r
+//             struct\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_ReadCursor(CursorInfo *info)\r
+{\r
+       word    i,\r
+                       buttons;\r
+       int             dx,dy;\r
+\r
+       info->x = info->y = 0;\r
+       info->button0 = info->button1 = false;\r
+\r
+       if (inpu.MousePresent)\r
+       {\r
+               buttons = INL_GetMouseButtons();\r
+               INL_GetMouseDelta(&dx,&dy);\r
+               INL_AdjustCursor(info,buttons,dx,dy);\r
+       }\r
+\r
+       for (i = 0;i < MaxJoys;i++)\r
+       {\r
+               if (!inpu.JoysPresent[i])\r
+                       continue;\r
+\r
+               buttons = INL_GetJoyButtons(i);\r
+               INL_GetJoyDelta(i,&dx,&dy,true);\r
+               dx /= 64;\r
+               dy /= 64;\r
+               INL_AdjustCursor(info,buttons,dx,dy);\r
+       }\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_ReadControl() - Reads the device associated with the specified\r
+//             player and fills in the control info struct\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void near\r
+IN_ReadControl(word pn, player_t *player)\r
+{\r
+                       boolean         realdelta;\r
+#if DEMO0\r
+                       byte            dbyte;\r
+#endif\r
+                       word            buttons;\r
+                       int                     dx,dy;\r
+                       Motion          mx,my;\r
+                       ControlType     type;\r
+                       sword conpee;\r
+                       byte dir=DirTable[2];\r
+register       KeyboardDef     *def;\r
+\r
+       dx = dy = 0;\r
+       mx = my = motion_None;\r
+       buttons = 0;\r
+\r
+#if DEMO0\r
+       if (DemoMode == demo_Playback)\r
+       {\r
+               dbyte = DemoBuffer[DemoOffset + 1];\r
+               my = (dbyte & 3) - 1;\r
+               mx = ((dbyte >> 2) & 3) - 1;\r
+               buttons = (dbyte >> 4) & 3;\r
+\r
+               if (!(--DemoBuffer[DemoOffset]))\r
+               {\r
+                       DemoOffset += 2;\r
+                       if (DemoOffset >= DemoSize)\r
+                               DemoMode = demo_PlayDone;\r
+               }\r
+\r
+               realdelta = false;\r
+       }\r
+       else if (DemoMode == demo_PlayDone)\r
+               Quit ("Demo playback exceeded");\r
+       else\r
+       {\r
+#endif\r
+               switch (type = player[pn].Controls)\r
+               {\r
+               case ctrl_Keyboard1:\r
+               case ctrl_Keyboard2:\r
+                       def = &(inpu.KbdDefs[type - ctrl_Keyboard]);\r
+\r
+/*                     if (Keyboard[def->upleft])\r
+                               mx = motion_Left,my = motion_Up;\r
+                       else if (Keyboard[def->upright])\r
+                               mx = motion_Right,my = motion_Up;\r
+                       else if (Keyboard[def->downleft])\r
+                               mx = motion_Left,my = motion_Down;\r
+                       else if (Keyboard[def->downright])\r
+                               mx = motion_Right,my = motion_Down;*/\r
+//TODO: make this into a function that the joystick AND keyboard can use wwww\r
+                       if(DIRECTIONIFELSE)//(player[pn].info.dir == 2)\r
+                       {\r
+                       if(!inpu.Keyboard[def->left] && !inpu.Keyboard[def->right]){\r
+                               if((inpu.Keyboard[def->up] && !inpu.Keyboard[def->down]))\r
+                                       my = motion_Up;\r
+                               if((inpu.Keyboard[def->down] && !inpu.Keyboard[def->up]))\r
+                                       my = motion_Down;\r
+                       }else if(!inpu.Keyboard[def->up] && !inpu.Keyboard[def->down]){\r
+                               if((inpu.Keyboard[def->left] && !inpu.Keyboard[def->right]))\r
+                                       mx = motion_Left;\r
+                               if((inpu.Keyboard[def->right] && !inpu.Keyboard[def->left]))\r
+                                       mx = motion_Right;\r
+                       }else{  //2 keys pressed\r
+                                       switch (player[pn].pdir)\r
+                                       {\r
+                                               case 0:\r
+                                               case 4:\r
+                                                       if((inpu.Keyboard[def->left] && !inpu.Keyboard[def->right])){ dir = DirTable[1]; }//mx = motion_Left; }\r
+                                                       else if((inpu.Keyboard[def->right] && !inpu.Keyboard[def->left])){ dir = DirTable[3]; }//mx = motion_Right; }\r
+                                               break;\r
+                                               case 1:\r
+                                               case 3:\r
+                                                       if((inpu.Keyboard[def->up] && !inpu.Keyboard[def->down])){ dir = DirTable[0]; }//my = motion_Up; }\r
+                                                       else if((inpu.Keyboard[def->down] && !inpu.Keyboard[def->up])){ dir = DirTable[4]; }//my = motion_Down; }\r
+                                               break;\r
+                                               default:\r
+                                               break;\r
+                                       }\r
+#ifdef __DEBUG_InputMgr__\r
+                                       //if(dbg_testcontrolnoisy > 0){ printf("dir=%c ", dirchar(dir)); printf("pdir=%c        ", dirchar(player[pn].pdir)); }\r
+#endif\r
+                               }\r
+                       }\r
+                       //input from player\r
+                       if (inpu.Keyboard[def->button0])\r
+                               buttons += 1 << 0;\r
+                       if (inpu.Keyboard[def->button1])\r
+                               buttons += 1 << 1;\r
+                       realdelta = false;\r
+                       break;\r
+               case ctrl_Joystick1:\r
+               case ctrl_Joystick2:\r
+                       INL_GetJoyDelta(type - ctrl_Joystick,&dx,&dy,false);\r
+                       buttons = INL_GetJoyButtons(type - ctrl_Joystick);\r
+                       realdelta = true;\r
+                       break;\r
+               case ctrl_Mouse:\r
+                       INL_GetMouseDelta(&dx,&dy);\r
+                       buttons = INL_GetMouseButtons();\r
+                       realdelta = true;\r
+                       break;\r
+               }\r
+#ifdef DEMO0\r
+       }\r
+#endif\r
+\r
+       if (realdelta)\r
+       {\r
+               mx = (dx < 0)? motion_Left : ((dx > 0)? motion_Right : motion_None);\r
+               my = (dy < 0)? motion_Up : ((dy > 0)? motion_Down : motion_None);\r
+       }\r
+       else\r
+       {\r
+               dx = mx;// * 127;\r
+               dy = my;// * 127;\r
+       }\r
+\r
+       player[pn].info.x = dx;\r
+       player[pn].info.xaxis = mx;\r
+       player[pn].info.y = dy;\r
+       player[pn].info.yaxis = my;\r
+       player[pn].info.button0 = buttons & (1 << 0);\r
+       player[pn].info.button1 = buttons & (1 << 1);\r
+       player[pn].info.button2 = buttons & (1 << 2);\r
+       player[pn].info.button3 = buttons & (1 << 3);\r
+//     player[pn].info.dir = DirTable[((my + 1) * 3) + (mx + 1)];\r
+       conpee=(((my + 1) * 2) + (mx + 1))-1;\r
+       player[pn].info.dir = DirTable[conpee];\r
+\r
+       if(DirTable[conpee]!=2) player[pn].pdir=DirTable[conpee];\r
+       if(player[pn].enti.q==1 &&( dir!=2 || (mx!=motion_None || my!=motion_None)))\r
+       {\r
+               if(dir==2) player[pn].enti.d = player[pn].info.dir;\r
+               else player[pn].enti.d = DirTable[dir];\r
+       }\r
+\r
+#if DEMO0\r
+       if (DemoMode == demo_Record)\r
+       {\r
+               // Pack the control info into a byte\r
+               dbyte = (buttons << 4) | ((mx + 1) << 2) | (my + 1);\r
+\r
+               if\r
+               (\r
+                       (DemoBuffer[DemoOffset + 1] == dbyte)\r
+               &&      (DemoBuffer[DemoOffset] < 255)\r
+               )\r
+                       (DemoBuffer[DemoOffset])++;\r
+               else\r
+               {\r
+                       if (DemoOffset || DemoBuffer[DemoOffset])\r
+                               DemoOffset += 2;\r
+\r
+                       if (DemoOffset >= DemoSize)\r
+                               Quit ("Demo buffer overflow");\r
+\r
+                       DemoBuffer[DemoOffset] = 1;\r
+                       DemoBuffer[DemoOffset + 1] = dbyte;\r
+               }\r
+       }\r
+#endif\r
+#ifdef __DEBUG_InputMgr__\r
+if(dbg_testcontrolnoisy > 0)\r
+if(player[pn].info.dir!=2/*(inpu.Keyboard[def->up] || inpu.Keyboard[def->down] || inpu.Keyboard[def->left] || inpu.Keyboard[def->right])*/ || player[pn].enti.q>1)\r
+{\r
+       //printf("b1=%u b2=%u b3=%u b4=%u       ", player[pn].info.button0, player[pn].info.button1, player[pn].info.button2, player[pn].info.button3);\r
+       //printf("q=%d ", player[pn].enti.q);\r
+       //printf("cpee=%c ", dirchar(conpee));\r
+       printf("pdir=%c d=%c dir=%c ", dirchar(player[pn].pdir), dirchar(player[pn].enti.d), dirchar(player[pn].info.dir));\r
+       /*if(realdelta) */printf("dx=%d dy=%d   mx=%d   my=%d", player[pn].info.x, player[pn].info.y, player[pn].info.xaxis, player[pn].info.yaxis);\r
+       //else if(!realdelta) printf("%c%d %c%d %c%d %c%d", dirchar(0), inpu.Keyboard[def->up], dirchar(4), inpu.Keyboard[def->down], dirchar(1), inpu.Keyboard[def->left], dirchar(3), inpu.Keyboard[def->right]);\r
+       printf("\n");\r
+}\r
+#endif\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_SetControlType() - Sets the control type to be used by the specified\r
+//             player\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_SetControlType(word pn,player_t *player,ControlType type)\r
+{\r
+       // DEBUG - check that requested type is present?\r
+       player[pn].Controls = type;\r
+}\r
+\r
+#if DEMO0\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_StartDemoRecord() - Starts the demo recording, using a buffer the\r
+//             size passed. Returns if the buffer allocation was successful\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+boolean\r
+IN_StartDemoRecord(word bufsize)\r
+{\r
+       if (!bufsize)\r
+               return(false);\r
+\r
+       MM_GetPtr((memptr *)&DemoBuffer,bufsize);\r
+       DemoMode = demo_Record;\r
+       DemoSize = bufsize & ~1;\r
+       DemoOffset = 0;\r
+       DemoBuffer[0] = DemoBuffer[1] = 0;\r
+\r
+       return(true);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_StartDemoPlayback() - Plays back the demo pointed to of the given size\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_StartDemoPlayback(byte /*__segment*/ *buffer,word bufsize)\r
+{\r
+       DemoBuffer = buffer;\r
+       DemoMode = demo_Playback;\r
+       DemoSize = bufsize & ~1;\r
+       DemoOffset = 0;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_StopDemo() - Turns off demo mode\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_StopDemo(void)\r
+{\r
+       if ((DemoMode == demo_Record) && DemoOffset)\r
+               DemoOffset += 2;\r
+\r
+       DemoMode = demo_Off;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_FreeDemoBuffer() - Frees the demo buffer, if it's been allocated\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_FreeDemoBuffer(void)\r
+{\r
+       if (DemoBuffer)\r
+               MM_FreePtr((memptr *)&DemoBuffer);\r
+}\r
+#endif\r
+\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_GetScanName() - Returns a string containing the name of the\r
+//             specified scan code\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+byte *\r
+IN_GetScanName(ScanCode scan)\r
+{\r
+       byte            **p;\r
+       ScanCode        far *s;\r
+\r
+       for (s = ExtScanCodes,p = ExtScanNames;*s;p++,s++)\r
+               if (*s == scan)\r
+                       return(*p);\r
+\r
+       return(ScanNames[scan]);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_WaitForKey() - Waits for a scan code, then clears LastScan and\r
+//             returns the scan code\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+ScanCode\r
+IN_WaitForKey()\r
+{\r
+       ScanCode        result;\r
+\r
+       while (!(result = inpu.LastScan))\r
+               ;\r
+       inpu.LastScan = 0;\r
+       return(result);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_WaitForASCII() - Waits for an ASCII char, then clears LastASCII and\r
+//             returns the ASCII value\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+char\r
+IN_WaitForASCII()\r
+{\r
+       char            result;\r
+\r
+       while (!(result = inpu.LastASCII))\r
+               ;\r
+       inpu.LastASCII = '\0';\r
+       return(result);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_AckBack() - Waits for either an ASCII keypress or a button press\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_AckBack()\r
+{\r
+       word    i;\r
+\r
+       while (!inpu.LastScan)\r
+       {\r
+               if (inpu.MousePresent)\r
+               {\r
+                       if (INL_GetMouseButtons())\r
+                       {\r
+                               while (INL_GetMouseButtons())\r
+                                       ;\r
+                               return;\r
+                       }\r
+               }\r
+\r
+               for (i = 0;i < MaxJoys;i++)\r
+               {\r
+                       if (inpu.JoysPresent[i])\r
+                       {\r
+                               if (IN_GetJoyButtonsDB(i))\r
+                               {\r
+                                       while (IN_GetJoyButtonsDB(i))\r
+                                               ;\r
+                                       return;\r
+                               }\r
+                       }\r
+               }\r
+       }\r
+\r
+       IN_ClearKey(inpu.LastScan);\r
+       inpu.LastScan = sc_None;\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_Ack() - Clears user input & then calls IN_AckBack()\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+void\r
+IN_Ack()\r
+{\r
+       word    i;\r
+\r
+       if (!inst.IN_Started)\r
+               return;\r
+\r
+       IN_ClearKey(inpu.LastScan);\r
+       inpu.LastScan = sc_None;\r
+\r
+       if (inpu.MousePresent)\r
+               while (INL_GetMouseButtons())\r
+                                       ;\r
+       for (i = 0;i < MaxJoys;i++)\r
+               if (inpu.JoysPresent[i])\r
+                       while (IN_GetJoyButtonsDB(i))\r
+                               ;\r
+\r
+       IN_AckBack();\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_IsUserInput() - Returns true if a key has been pressed or a button\r
+//             is down\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+boolean\r
+IN_IsUserInput()\r
+{\r
+       boolean result;\r
+       word    i;\r
+\r
+       result = inpu.LastScan;\r
+\r
+       if (inpu.MousePresent)\r
+               if (INL_GetMouseButtons())\r
+                       result = true;\r
+\r
+       for (i = 0;i < MaxJoys;i++)\r
+               if (inpu.JoysPresent[i])\r
+                       if (INL_GetJoyButtons(i))\r
+                               result = true;\r
+\r
+       return(result);\r
+}\r
+\r
+///////////////////////////////////////////////////////////////////////////\r
+//\r
+//     IN_UserInput() - Waits for the specified delay time (in ticks) or the\r
+//             user pressing a key or a mouse button. If the clear flag is set, it\r
+//             then either clears the key or waits for the user to let the mouse\r
+//             button up.\r
+//\r
+///////////////////////////////////////////////////////////////////////////\r
+boolean\r
+IN_UserInput(dword delay,boolean clear)\r
+{\r
+       word TimeCount = *clockw;\r
+       word    lasttime;\r
+\r
+       lasttime = TimeCount;\r
+       do\r
+       {\r
+               if (IN_IsUserInput())\r
+               {\r
+                       if (clear)\r
+                               IN_AckBack();\r
+                       return(true);\r
+               }\r
+       } while (TimeCount - lasttime < delay);\r
+       return(false);\r
+}\r
+\r
+//===========================================================================\r
+\r
+/*\r
+===================\r
+=\r
+= IN_MouseButtons\r
+=\r
+===================\r
+*/\r
+\r
+byte   IN_MouseButtons (void)\r
+{\r
+       union REGS CPURegs;\r
+       if (inpu.MousePresent)\r
+       {\r
+               Mouse(MButtons);\r
+               return CPURegs.x.bx;\r
+       }\r
+       else\r
+               return 0;\r
+}\r
+\r
+\r
+/*\r
+===================\r
+=\r
+= IN_JoyButtons\r
+=\r
+===================\r
+*/\r
+\r
+byte   IN_JoyButtons (void)\r
+{\r
+       byte joybits;\r
+\r
+       joybits = inp(0x201);   // Get all the joystick buttons\r
+       joybits >>= 4;                          // only the high bits are useful\r
+       joybits ^= 15;                          // return with 1=pressed\r
+\r
+       return joybits;\r
+}\r
+\r
+boolean IN_KeyDown(byte code)\r
+{\r
+#ifdef __DEBUG_InputMgr__\r
+       if(!dbg_nointest)\r
+#endif\r
+       return inpu.Keyboard[code];\r
+#ifdef __DEBUG_InputMgr__\r
+       else\r
+               if(dbg_nointest && kbhit())\r
+                       return 1;\r
+               else\r
+                       return 0;\r
+#endif\r
+}\r
+\r
+void IN_ClearKey(byte code)\r
+{\r
+       inpu.Keyboard[code] = false;\r
+       if(code == inpu.LastScan)\r
+               inpu.LastScan = sc_None;\r
+       }\r
+\r
+boolean IN_qb(byte kee)\r
+{\r
+#ifdef __DEBUG_InputMgr__\r
+       if(dbg_testkeyin) printf("%u\n", inpu.Keyboard[kee]);\r
+#endif\r
+       if(inpu.Keyboard[kee]==true) return 1;\r
+       else return 0;\r
+}\r
+\r
+ScanCode IN_GetLastScan()\r
+{\r
+       return inpu.LastScan;\r
+}\r
+\r
+ScanCode IN_GetCurCode()\r
+{\r
+       return inst.CurCode;\r
+}\r

diff --git a/src/lib/16_in_.h b/src/lib/16_in_.h
new file mode 100755 (executable)
index 0000000..39519c2
--- /dev/null
+++ b/src/lib/16_in_.h
@@ -0,0 +1,308 @@
+/* Catacomb Apocalypse Source Code\r
+ * Copyright (C) 1993-2014 Flat Rock Software\r
+ *\r
+ * This program is free software; you can redistribute it and/or modify\r
+ * it under the terms of the GNU General Public License as published by\r
+ * the Free Software Foundation; either version 2 of the License, or\r
+ * (at your option) any later version.\r
+ *\r
+ * This program is distributed in the hope that it will be useful,\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
+ * GNU General Public License for more details.\r
+ *\r
+ * You should have received a copy of the GNU General Public License along\r
+ * with this program; if not, write to the Free Software Foundation, Inc.,\r
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
+ */\r
+\r
+//\r
+//     ID Engine\r
+//     ID_IN.h - Header file for Input Manager\r
+//     v1.0d1w\r
+//     By Jason Blochowiak\r
+//     Open Watcom port by sparky4\r
+//\r
+\r
+#ifndef        __16_IN__\r
+#define        __16_IN__\r
+\r
+#include <string.h>\r
+#include "src/lib/16_head.h"\r
+#include "src/lib/16_timer.h"\r
+#ifdef __WATCOMC__     //borland C BCEXMM.EXE\r
+#include "src/lib/16_dbg.h"\r
+#include "src/lib/16_spri.h"\r
+#include "src/lib/16_enti.h"\r
+//#include "src/lib/bitmap.h"  //old format\r
+#endif\r
+\r
+//if else for gfxtesting and direction\r
+//player[pn].d == 2 ||\r
+//player[pn].d != 2 ||\r
+#define DIRECTIONIFELSE        (player[pn].info.dir == 2)\r
+//#define NDIRECTIONIFELSE     (player[pn].info.dir != 2)\r
+\r
+#define        KeyInt  9       // The keyboard ISR number\r
+\r
+// Stuff for the joystick\r
+#define        JoyScaleMax             32768\r
+#define        JoyScaleShift   8\r
+#define        MaxJoyValue             5000\r
+\r
+//#define      MaxPlayers              2//future plans for multiple playable charaters and being able to alternate\r
+#define        MaxKbds         2\r
+#define        MaxJoys         2\r
+#define        MaxPads         2\r
+#define        NumCodes        128\r
+\r
+//typedef      byte            ScanCode;\r
+#define        sc_None                 0\r
+#define        sc_Bad                  0xff\r
+#define        sc_Return               0x1c\r
+#define        sc_Enter                sc_Return\r
+#define        sc_Escape               0x01\r
+#define        sc_Space                0x39\r
+#define        sc_BackSpace    0x0e\r
+#define        sc_Tab                  0x0f\r
+#define        sc_Alt                  0x38\r
+#define        sc_Control              0x1d\r
+#define        sc_CapsLock             0x3a\r
+#define        sc_LShift               0x2a\r
+#define        sc_RShift               0x36\r
+#define        sc_UpArrow              0x48\r
+#define        sc_DownArrow    0x50\r
+#define        sc_LeftArrow    0x4b\r
+#define        sc_RightArrow   0x4d\r
+#define        sc_Insert               0x52\r
+#define        sc_Delete               0x53\r
+#define        sc_Home                 0x47\r
+#define        sc_End                  0x4f\r
+#define        sc_PgUp                 0x49\r
+#define        sc_PgDn                 0x51\r
+#define        sc_F1                   0x3b\r
+#define        sc_F2                   0x3c\r
+#define        sc_F3                   0x3d\r
+#define        sc_F4                   0x3e\r
+#define        sc_F5                   0x3f\r
+#define        sc_F6                   0x40\r
+#define        sc_F7                   0x41\r
+#define        sc_F8                   0x42\r
+#define        sc_F9                   0x43\r
+#define        sc_F10                  0x44\r
+#define        sc_F11                  0x57\r
+#define        sc_F12                  0x59\r
+\r
+#define        sc_1                    0x02\r
+#define        sc_2                    0x03\r
+#define        sc_3                    0x04\r
+#define        sc_4                    0x05\r
+#define        sc_5                    0x06\r
+#define        sc_6                    0x07\r
+#define        sc_7                    0x08\r
+#define        sc_8                    0x09\r
+#define        sc_9                    0x0a\r
+#define        sc_0                    0x0b\r
+\r
+#define        sc_A                    0x1e\r
+#define        sc_B                    0x30\r
+#define        sc_C                    0x2e\r
+#define        sc_D                    0x20\r
+#define        sc_E                    0x12\r
+#define        sc_F                    0x21\r
+#define        sc_G                    0x22\r
+#define        sc_H                    0x23\r
+#define        sc_I                    0x17\r
+#define        sc_J                    0x24\r
+#define        sc_K                    0x25\r
+#define        sc_L                    0x26\r
+#define        sc_M                    0x32\r
+#define        sc_N                    0x31\r
+#define        sc_O                    0x18\r
+#define        sc_P                    0x19\r
+#define        sc_Q                    0x10\r
+#define        sc_R                    0x13\r
+#define        sc_S                    0x1f\r
+#define        sc_T                    0x14\r
+#define        sc_U                    0x16\r
+#define        sc_V                    0x2f\r
+#define        sc_W                    0x11\r
+#define        sc_X                    0x2d\r
+#define        sc_Y                    0x15\r
+#define        sc_Z                    0x2c\r
+\r
+#define        key_None                0\r
+#define        key_Return              0x0d\r
+#define        key_Enter               key_Return\r
+#define        key_Escape              0x1b\r
+#define        key_Space               0x20\r
+#define        key_BackSpace   0x08\r
+#define        key_Tab                 0x09\r
+#define        key_Delete              0x7f\r
+\r
+#define        key_LSuper                      0x5b\r
+#define        key_RSuper                      0x5c\r
+#define        key_Menu                        0x5d\r
+\r
+//     Stuff for the mouse\r
+#define        MReset          0\r
+#define        MButtons        3\r
+#define        MDelta          11\r
+\r
+#define        MouseInt        0x33\r
+#ifdef DEMO0\r
+typedef        enum            {\r
+                                               demo_Off,demo_Record,demo_Playback,demo_PlayDone\r
+                                       } Demo;\r
+#endif\r
+//moved to 16_tdef.h\r
+/*typedef      enum            {\r
+                                               //ctrl_None,                            // MDM (GAMERS EDGE) - added\r
+                                               ctrl_Keyboard,\r
+                                                       ctrl_Keyboard1 = ctrl_Keyboard,ctrl_Keyboard2,\r
+                                               ctrl_Joystick,\r
+                                                       ctrl_Joystick1 = ctrl_Joystick,ctrl_Joystick2,\r
+                                               ctrl_Mouse,\r
+                                       } ControlType;\r
+typedef        enum            {\r
+                                               motion_Left = -1,motion_Up = -1,\r
+                                               motion_None = 0,\r
+                                               motion_Right = 1,motion_Down = 1\r
+                                       } Motion;\r
+typedef        enum            {\r
+                                               dir_North,//dir_NorthEast,\r
+                                               dir_West,//dir_Nortinest,\r
+                                               dir_None,\r
+                                               dir_East,//,dir_SouthEast,\r
+                                               dir_South,//dir_Soutinest,\r
+                                       } Direction;\r
+typedef        struct          {\r
+                                               boolean near    button0,button1,button2,button3;\r
+                                               int     near            x,y;\r
+                                               Motion  near    xaxis,yaxis;\r
+                                               Direction near  dir;\r
+                                       } CursorInfo;\r
+\r
+typedef        struct          {\r
+                                               ScanCode near   button0,button1,\r
+                                                                       //upleft,\r
+                                                                       up,\r
+                                                                       down,\r
+                                                                       left,\r
+                                                                       right\r
+                                                                       //upright,\r
+                                                                       //downleft,\r
+                                                                       //,downright\r
+                                                                       ;\r
+                                       } KeyboardDef;\r
+typedef        struct          {\r
+                                               word    near    joyMinX,joyMinY,\r
+                                                                       threshMinX,threshMinY,\r
+                                                                       threshMaxX,threshMaxY,\r
+                                                                       joyMaxX,joyMaxY,\r
+                                                                       joyMultXL,joyMultYL,\r
+                                                                       joyMultXH,joyMultYH;\r
+                                       } JoystickDef;\r
+\r
+typedef        struct\r
+{\r
+       int x; //player exact position on the viewable map\r
+       int y; //player exact position on the viewable map\r
+       int tx; //player tile position on the viewable map\r
+       int ty; //player tile position on the viewable map\r
+       int triggerx; //player's trigger box tile position on the viewable map\r
+       int triggery; //player's trigger box tile position on the viewable map\r
+       int sheetsetx; //NOT USED YET! player sprite sheet set on the image x\r
+       int sheetsety; //NOT USED YET! player sprite sheet set on the image y\r
+       byte d;         //direction to render sprite!! wwww\r
+       byte q;         //loop variable for anumation and locking the playing to compleate the animation cycle to prevent issues with misalignment www\r
+       byte near pdir; //previous direction~\r
+       word speed;             //player speed!\r
+       word spt;               //speed per tile\r
+#ifdef __WATCOMC__\r
+       struct sprite   *spri;  //supposively the sprite sheet data\r
+       memptr          gr;\r
+       entity_t                *ent;\r
+#endif\r
+       bitmap_t        *data;          //supposively the sprite sheet data//old format\r
+       bitmap_t        bmp;\r
+       sword hp; //hitpoints of the player\r
+       int persist_aniframe;    // gonna be increased to 1 before being used, so 0 is ok for default\r
+       CursorInfo      info;\r
+       ControlType     Controls;\r
+//newer vars\r
+       int dx, dy, delta;      //TODO: what is this? ^^\r
+} player_t;*/\r
+\r
+/*\r
+=============================================================================\r
+\r
+                                       GLOBAL VARIABLES\r
+\r
+=============================================================================\r
+*/\r
+/*extern struct inconfig\r
+{\r
+       boolean                 MousePresent;\r
+       boolean                 JoysPresent[MaxJoys];\r
+       boolean         Keyboard[NumCodes];\r
+       boolean         Paused;\r
+       char            LastASCII;\r
+       ScanCode        LastScan;\r
+\r
+       KeyboardDef     KbdDefs[MaxKbds];\r
+       JoystickDef     JoyDefs[MaxJoys];\r
+} inpu;*/\r
+\r
+#ifdef DEMO0\r
+               static Demo             DemoMode = demo_Off;\r
+               static byte /*_seg*/    *DemoBuffer;\r
+               static word             DemoOffset,DemoSize;\r
+#endif\r
+\r
+//     Internal routines\r
+extern void interrupt INL_KeyService();\r
+extern void Mouse(int x);\r
+//static void INL_GetMouseDelta(int *x,int *y);\r
+//static word INL_GetMouseButtons(void);\r
+extern void IN_GetJoyAbs(word joy,word *xp,word *yp);\r
+//static void INL_GetJoyDelta(word joy,int *dx,int *dy,boolean adaptive);\r
+//static word INL_GetJoyButtons(word joy);\r
+extern word IN_GetJoyButtonsDB(word joy);\r
+//static void INL_StartKbd(void);\r
+//static void INL_ShutKbd(void);\r
+//static boolean INL_StartMouse(void);\r
+//static void INL_ShutMouse(void);\r
+//static void INL_SetJoyScale(word joy);\r
+extern void IN_SetupJoy(word joy,word minx,word maxx,word miny,word maxy);\r
+//static boolean INL_StartJoy(word joy);\r
+//static void INL_ShutJoy(word joy);\r
+extern void IN_Startup();\r
+extern void IN_Default(boolean gotit,player_t *player,ControlType nt);\r
+extern void IN_Shutdown();\r
+extern void IN_SetKeyHook(void (*hook)());\r
+extern void IN_ClearKeysDown();\r
+//static void INL_AdjustCursor(CursorInfo *info,word buttons,int dx,int dy);\r
+extern void IN_ReadCursor(CursorInfo *info);\r
+extern void near IN_ReadControl(word pn, player_t *player);\r
+extern void IN_SetControlType(word pn,player_t *player,ControlType type);\r
+#if DEMO0\r
+extern boolean IN_StartDemoRecord(word bufsize);\r
+extern void IN_StartDemoPlayback(byte /*__segment*/ *buffer,word bufsize);\r
+extern void IN_StopDemo(void);\r
+extern void IN_FreeDemoBuffer(void);\r
+#endif\r
+extern byte *IN_GetScanName(ScanCode scan);\r
+extern ScanCode IN_WaitForKey();\r
+extern char IN_WaitForASCII();\r
+extern void IN_AckBack();\r
+extern void IN_Ack();\r
+extern boolean IN_IsUserInput();\r
+extern boolean IN_UserInput(dword delay,boolean clear);\r
+extern boolean IN_KeyDown(byte code);\r
+extern void IN_ClearKey(byte code);\r
+extern boolean IN_qb(byte kee);\r
+extern ScanCode IN_GetLastScan();\r
+extern ScanCode IN_GetCurCode();\r
+\r
+#endif\r

diff --git a/src/lib/16_tdef.h b/src/lib/16_tdef.h
index f0f39876f6d4dd84f69e46ebdab13c3aba451115..9cb36102b122a2087b8a9b1be0b1129995c4edae 100755 (executable)
--- a/src/lib/16_tdef.h
+++ b/src/lib/16_tdef.h
@@ -189,7 +189,29 @@ typedef struct {
 \r
 //from 16_in\r
 //==========================================================================\r
-#define        MaxPlayers              2//future plans for multiple playable charaters and being able to alternate\r
+#define        KeyInt          9       // The keyboard ISR number\r
+\r
+//\r
+// mouse constants\r
+//\r
+#define        MReset          0\r
+#define        MButtons        3\r
+#define        MDelta          11\r
+\r
+#define        MouseInt        0x33\r
+//#define      Mouse(x)        _AX = x,geninterrupt(MouseInt)\r
+\r
+//\r
+// joystick constants\r
+//\r
+#define        JoyScaleMax             32768\r
+#define        JoyScaleShift   8\r
+#define        MaxJoyValue             5000\r
+\r
+#define        MaxPlayers      4\r
+#define        MaxKbds         2\r
+#define        MaxJoys         2\r
+#define        NumCodes        128\r
 \r
 typedef        byte            ScanCode;\r
 \r
@@ -241,6 +263,33 @@ typedef    struct          {
                                                                        joyMultXH,joyMultYH;\r
                                        } JoystickDef;\r
 \r
+typedef struct// instat\r
+{\r
+       boolean         IN_Started;\r
+       boolean         CapsLock;\r
+       ScanCode        CurCode,LastCode;\r
+} in_status_t;\r
+\r
+typedef struct// inconfig\r
+{\r
+       in_status_t instat;\r
+//\r
+// configuration variables\r
+//\r
+       boolean         Keyboard[NumCodes],\r
+                                       JoysPresent[MaxJoys],\r
+                                       MousePresent,\r
+                                       JoyPadPresent;\r
+\r
+//     Global variables\r
+       boolean         Paused;\r
+       char            LastASCII;\r
+       ScanCode        LastScan;\r
+\r
+       KeyboardDef     KbdDefs[MaxKbds];\r
+       JoystickDef     JoyDefs[MaxJoys];\r
+} in_info_t;\r
+\r
 //==========================================================================\r
 \r
 typedef        struct\r
@@ -571,7 +620,9 @@ typedef struct
        loghandle_t     handle; //handles for file logging\r
        kurokku_t       kurokku;        //clock struct\r
        mminfo_t        mm; mminfotype  mmi;    // mm stuff\r
+//++++ in_info_t       in;             // 16_in info\r
        player_t        player[MaxPlayers];     // player vars\r
+//==== word far*       clockw;         /* 18.2hz clock */\r
 } global_game_variables_t;\r
 \r
 #ifdef __WATCOMC__\r

diff --git a/src/lib/16_timer.c b/src/lib/16_timer.c
index a9dba5d5d26eeeb58792e1bf0bfdc8ecffe0d7ea..affe67380054ec537f28d002fc3a064eea60caba 100755 (executable)
--- a/src/lib/16_timer.c
+++ b/src/lib/16_timer.c
@@ -22,14 +22,14 @@
 \r
 #include "src/lib/16_timer.h"\r
 \r
-static word far* clockw= (word far*) 0x046C; /* 18.2hz clock */\r
+//static word far* clockw= (word far*) 0x046C; /* 18.2hz clock */\r
 \r
 clock_t start_timer(global_game_variables_t *gv)\r
 {\r
        gv->kurokku.t = clock();\r
        gv->kurokku.tiku = 0; gv->video.sfip = 0;\r
-       gv->kurokku.clock_start = *clockw;\r
-       gv->kurokku.clock = clockw;\r
+       gv->kurokku.clock_start = 0x046C; /* 18.2hz clock */\r
+       gv->kurokku.clock = (word far*) 0x046C; /* 18.2hz clock */\r
        gv->kurokku.wcpu = WCPU_detectcpu();\r
 \r
        //turn this off if XT\r

diff --git a/wcpu.exe b/wcpu.exe
index 6a5fae4e3fd918f9bbf60ed7c83cc5b9a7215290..75555b8f4ac5243f4dd7f320d6194fee1db70d66 100755 (executable)
Binary files a/wcpu.exe and b/wcpu.exe differ

diff --git a/xxdiff.sh b/xxdiff.sh
index ab2c737758a6cfad27682f726b3bb27bbb4d3f7d..c47a98dbba1c1bbd2f2f297413a386828c71996d 100755 (executable)
--- a/xxdiff.sh
+++ b/xxdiff.sh
@@ -1,2 +1,2 @@
 #!/bin/bash
-xxdiff -wB "$1" "$2"
+screen xxdiff -wB "$1" "$2"