home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 23 / IOPROG_23.ISO / SOFT / RAYCAST.ZIP / KEYBOARD.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-02  |  3.7 KB  |  155 lines
  1. #include "os.h"
  2. #include "keyinfo.h"
  3. #include "keyboard.h"
  4. #include "playint.h"
  5. #include "ray.h"
  6. #include "sprtypes.h"
  7. #include "rayspr.h"
  8.  
  9. int raw_key=0;                  // the global raw keyboard data aquired from the ISR
  10.  
  11. int key_table[MAX_TRACKED_INPUTS-1] = {0,0,0,0,0,0}; // the key state table for the motion keys
  12.  
  13. #ifdef OS_DOS
  14. #include <dos.h>
  15. #include <conio.h>
  16. #include <i86.h>
  17.  
  18. #define INT_CONTROL     0x20         // interrupt control register 
  19. #define KEYBOARD_INT    0x09         // the keyboard interrupt vector 
  20. #define KEY_BUFFER      0x60         // keyboard buffer area 
  21. #define KEY_CONTROL     0x61         // keyboard control register 
  22.  
  23. unsigned short getkey(void);
  24.  
  25. // Routine to read a key directly from the port
  26. #pragma aux getkey = \
  27.    " sti" \
  28.    "in al, 60h" \
  29.    "xor ah,ah" \
  30.    "mov bx, ax" \
  31.    "in al, 61h" \
  32.    "or al, 82h" \
  33.    "out 61h,al" \
  34.    "and al,7fh" \
  35.    "out 61h,al" \
  36.    "mov al,20h" \
  37.    "out 20h,al" \
  38.    modify [ax bx] \
  39.    value [bx];
  40.  
  41. void (_interrupt _far *Old_Key_Isr)(); // holds old keyboard interrupt handler 
  42.  
  43. void _interrupt _far New_Key_Int(void) 
  44. { 
  45. // this function links into the keyboard interrupt and takes over.  it is called 
  46. // when a key is pressed.  Note: how it differs from the one were saw in the 
  47. // chapter on I/O.  It has been modified to take into consideration the demo 
  48. // mode of the system 
  49.  
  50. int temp_key=getkey();
  51. // now for some C to update the arrow state table 
  52.  
  53. // process the key and update the table 
  54. Process_Key(temp_key);
  55.  
  56. } // end New_Key_Int 
  57.  
  58. #endif
  59.  
  60. void Init_Keyboard() {
  61. #ifdef OS_DOS
  62. Old_Key_Isr = _dos_getvect(KEYBOARD_INT); 
  63.  
  64. _dos_setvect(KEYBOARD_INT, New_Key_Int); 
  65. #endif
  66. }
  67.  
  68. void Close_Keyboard() {
  69. #ifdef OS_DOS
  70. _dos_setvect(KEYBOARD_INT, Old_Key_Isr); 
  71. #endif
  72. }
  73.  
  74. void Process_Key(short temp_key) {
  75.  
  76. switch(temp_key)
  77.       { 
  78.       case MAKE_UP:    // pressing up 
  79.            { 
  80.            key_table[INDEX_UP]    = Obj_Type_List[PLAYER_TYPE].stats.base_speed;
  81.            } break; 
  82.  
  83.       case MAKE_DOWN:  // pressing down 
  84.            { 
  85.            key_table[INDEX_DOWN]  = Obj_Type_List[PLAYER_TYPE].stats.base_speed;
  86.            } break; 
  87.  
  88.       case MAKE_RIGHT: // pressing right 
  89.            { 
  90.            key_table[INDEX_RIGHT] = PLAYER_ROT_SPEED;
  91.            } break; 
  92.  
  93.       case MAKE_LEFT:  // pressing left 
  94.            { 
  95.            key_table[INDEX_LEFT]  = PLAYER_ROT_SPEED;
  96.            } break; 
  97.  
  98.       case MAKE_LUP: // look up
  99.            {
  100.            key_table[LOOK_UP]=ANGLE_2;
  101.            } break;
  102.  
  103.       case MAKE_LDOWN: // look down
  104.            {
  105.            key_table[LOOK_DOWN]=ANGLE_2;
  106.            } break;
  107.  
  108.       case MAKE_CNTL: // ctrl key
  109.            {
  110.            key_table[INDEX_GUN]=1;
  111.            }
  112.            break;
  113.  
  114.       case BREAK_UP:    // releasing up 
  115.            { 
  116.            key_table[INDEX_UP]    = 0; 
  117.            } break; 
  118.  
  119.       case BREAK_DOWN:  // releasing down 
  120.            { 
  121.            key_table[INDEX_DOWN]  = 0; 
  122.            } break; 
  123.  
  124.       case BREAK_RIGHT: // releasing right 
  125.            { 
  126.            key_table[INDEX_RIGHT] = 0; 
  127.            } break; 
  128.  
  129.       case BREAK_LEFT:  // releasing left 
  130.            { 
  131.            key_table[INDEX_LEFT]  = 0; 
  132.            } break; 
  133.  
  134.       case BREAK_LUP: // releasing look up
  135.            {
  136.            key_table[LOOK_UP]=0;
  137.            } break;
  138.  
  139.       case BREAK_LDOWN: // releasing look down
  140.            {
  141.            key_table[LOOK_DOWN]=0;
  142.            } break;
  143.  
  144.       case BREAK_CNTL: // releasin control key
  145.            {
  146.            key_table[INDEX_GUN]=0;
  147.            }
  148.            break;
  149.  
  150.       default: raw_key=temp_key; break;
  151.  
  152.  
  153.       } // end switch 
  154. }
  155.