开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
GAMERUN.CPP
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：16k
源码类别：

游戏

开发平台：

Visual C++

GAMERUN.CPP：源码内容
  1. #include <mem.h>
  2. #include <string.h>
  3. #include <stdarg.h>
  4. #include <fstream.h>
  5. #include "utils.h"
  6. #ifdef OS_DOS
  7. #include "mouse.h"
  8. #include <dos.h>
  9. #endif
  10. #include "ray.h"
  11. #include "scrcntl.h"
  12. #include "palette.h"
  13. #include "screen.h"
  14. #include "globals.h"
  15. #include "resnames.h"
  16. #include "waves.h"
  17. #include "voxinter.h"
  18. #include "scrcap.h"
  19. #include "shading.h"
  20. #include "skipping.h"
  21. #include "sound.h"
  22. #include "sprinter.h"
  23. #include "playint.h"
  24. #include "keyinfo.h"
  25. #include "raywidth.h"
  26. #include "loadwor.h"
  27. #include "keyboard.h"
  28. #include "raybuff.h"
  29. #include "timer.h"
  30. #include "gentree.h"
  31. #include "dosfuncs.h"
  32. #include "winfuncs.h"
  33. #include "scrconf.h"
  34. #include "quit.h"
  35. #include "rgobject.h"
  36. #include "ground.h"
  37. #include "closers.h"
  38. #include "visuals.h"
  39. #include "scrmes.h"
  40. #include <stdio.h>
  42. #define _PROGRAMMER_VERSION_
  44. #define UPDATE_SPEED 36.5
  46. #define MAX_ARG_LENGTH 20
  47. #define NORM_ARG 1
  48. #define FILE_ARG 2
  49. #define WTEX_ARG 3
  50. #define FTEX_ARG 4
  52. #define PLAYER_START_X (1925<<SHIFT)
  53. #define PLAYER_START_Y (550<<SHIFT)
  54. #define PLAYER_START_ANGLE ANGLE_180
  55. #define PLAYER_START_Z 8
  57. #ifdef OS_DOS
  58. #define VGA_WIDTH 320
  59. #define VGA_HEIGHT 200
  60. #define SVGA_WIDTH 640
  61. #define SVGA_HEIGHT 480
  62. #endif
  64. #define HURT_TIME 10
  65. #define STANDARD_PAL 0
  66. #define HURT_PAL 1
  68. extern "C" int _argc;
  69. extern "C" char ** _argv;
  71. typedef BOOL dimension_control_type;
  72. #define VERT_CONTROL TRUE
  73. #define HORIZ_CONTROL FALSE
  75. const char DEF_WORLD [F_NAME_LENGTH]="nraymap.dat";
  76. const char FILE_CMD [MAX_ARG_LENGTH]="-file";
  77. const char WTEX_CMD [MAX_ARG_LENGTH]="-wtex";
  78. const char FTEX_CMD [MAX_ARG_LENGTH]="-ftex";
  79. const char NO_SHADE_CMD [MAX_ARG_LENGTH]="-noshade";
  80. const char WAVE_CMD [MAX_ARG_LENGTH]="-wave";
  81. const char DEF_CAPTURE_F_NAME[F_NAME_LENGTH]="scrcap.pcx";
  82. const char END_PICT_NAME[F_NAME_LENGTH]="end.pcx";
  83. const char SKIP_CMD [MAX_ARG_LENGTH]="-fastvox";
  85. BOOL do_waves;
  87. BOOL is_super_vga;
  88.  
  89. ULONG frame_num=0;
  91. void Analyze_Args();
  93. void World_Update(long cur_update_num);
  95. void Setup_Combined_Input();        
  97. void Start_Palette();
  99. extern int raw_key;                  // the global raw keyboard data aquired from the ISR
  100.  
  101. extern int key_table[MAX_TRACKED_INPUTS-1]; // the key state table for the motion keys
  103. void Clear_Input();
  105. #ifdef OS_DOS
  106. void GetMouseInput(); // Routine to set the mouse statement flags
  107. #endif
  109. int mouse_table[MAX_TRACKED_INPUTS-1] = {0,0,0,0,0,0}; // same state table thing but for the mouse
  111. short combined_table[MAX_TRACKED_INPUTS]= {0,0,0,0,0,0,0}; // combination of mouse+keyboard
  113. #ifdef OS_DOS
  114. BOOL hasmouse=FALSE; // Boolean for whether the comp. has a mouse
  115. #endif
  117. dimension_control_type dim_control;
  119. BOOL done;
  121. void startup();
  122. void shutdown();
  124. void Global_Initialize() {
  125. Screen_Message("Initializing Hardware!");
  126. startup(); // Setup hardware stuff, etc.
  127. Screen_Message("Initializign Renderer!");
  128. initRay(); // Setup raycaster
  129. Screen_Message("Loading data!");
  130. Analyze_Args();           
  131. }
  133. extern "C" Shutdown() {
  134. #ifdef OS_DOS
  135. Dos_Close();
  136. #endif
  138. #ifdef OS_WINDOWS
  139. Win_Close();
  140. #endif
  141. }
  143. extern "C" void Error(char * error) {
  144. Shutdown();
  145. printf(error);
  146. printf("n");
  147. exit(1);
  148. }
  150. void Global_Close() {
  151. closeRay(); // Shut down the raycaster
  152. shutdown(); // Clear up memory and reset hardware
  153. }
  155. void Analyze_Args()
  156. {
  157. LONG arg_type;
  158. LONG cur_arg_num;
  159. PCHAR cur_argument;
  161. arg_type=NORM_ARG;
  162. cur_arg_num=1;
  163. do_waves=FALSE;
  165. Set_Player_Input_Buffer(combined_table);
  166. F_Scan_Load((PCHAR)DEF_WORLD);
  167. Set_Shading(SHADING_ON);
  168. Set_Skipping(SKIPPING_OFF);
  169. // go through arguments looking for user specifications
  171. while (cur_arg_num<_argc) {
  173. cur_argument=_argv[cur_arg_num];
  175. // what type of argument is this 
  176. switch (arg_type) {
  178. // normal:
  179. case NORM_ARG:
  181. // is the user specifying a world file name?
  182. if (!strnicmp(cur_argument, FILE_CMD, MAX_ARG_LENGTH))
  183. arg_type=FILE_ARG;
  185. if (!strnicmp(cur_argument, WTEX_CMD, MAX_ARG_LENGTH))
  186. arg_type=WTEX_ARG;
  188. if (!strnicmp(cur_argument, FTEX_CMD, MAX_ARG_LENGTH))
  189. arg_type=FTEX_ARG;
  191. if (!strnicmp(cur_argument, WAVE_CMD, MAX_ARG_LENGTH))
  192. do_waves=TRUE;
  194. if (!strnicmp(cur_argument, NO_SHADE_CMD, MAX_ARG_LENGTH))
  195. Set_Shading(SHADING_OFF);
  197. if (!strnicmp(cur_argument, SKIP_CMD, MAX_ARG_LENGTH))
  198. Set_Skipping(SKIPPING_ON);
  200. break;
  202. // file name:
  203. case FILE_ARG:
  205. Load_World(cur_argument);
  206. arg_type=NORM_ARG;
  207. break;
  209. //wall texture file name
  210. case WTEX_ARG:
  212. F_Spec_Load(1, cur_argument, (PCHAR)WTEX_RES);
  213. arg_type=NORM_ARG;
  214. break;
  216. //floor texture file name
  217. case FTEX_ARG:
  219. F_Spec_Load(1, cur_argument, (PCHAR)FTEX_RES);
  220. arg_type=NORM_ARG;
  221. break;
  223. default:
  224. break;
  226. }
  228. cur_arg_num++;
  229. }  
  231. the_player=Create_Object(PLAYER_START_X, PLAYER_START_Y, PLAYER_START_Z,
  232. PLAYER_START_ANGLE, PLAYER_TYPE, NULL, 3);
  233. Gen_Tree();
  234. Setup_Anim_Tex();
  235. }     
  237. UCHAR paldata[5][768];
  238. void Start_Palette() {
  239. Init_Palette();
  240. fstream fp;
  241. fp.open("standard.pal",ios::binary | ios::in | ios::out);
  242. fp.seekg(0L,ios::beg);
  243. fp.read(paldata[0],768);
  244. fp.close();
  245. fp.open("red.pal", ios::binary | ios::in | ios::out);
  246. fp.seekg(0L,ios::beg);
  247. fp.read(paldata[1],768);
  248. fp.close();
  249. Load_Palette(paldata[0], 0, 256);
  250. }
  252. void Show_Palette(short pal_handle) {
  253. Load_Palette(paldata[pal_handle], 0, 256);
  254. Activate_Palette(TRUE);
  255. }
  257. void startup()      
  258. {
  259. Init_Timer();
  260. Start_Palette();
  262. #ifdef OS_DOS
  263. if (initmouse()) { // Setup mouse
  264. hasmouse=TRUE;
  265. hidemouse();
  266. } else hasmouse=FALSE;
  267. #endif
  269. Init_Sound(); 
  270. Init_Keyboard();
  271. }
  273. void shutdown()
  274. {
  275. Close_Keyboard();
  276. Close_Timer();
  277. Close_Sound();
  278. End_Graphics();
  279. Close_Palette();
  280. }
  282. angle_type cur_vert_angle, last_vert_angle;
  283. long beg_update_num;
  285. void Do_Intro() {
  287. Play_Sound(Load_Sound("yo.wav"));
  289. long abs_z;
  290. RCastGobject picts(4);
  291. long start_update_num;
  293. picts.assigninfile("3.pcx");
  294. picts.load(0);
  295. picts.assigninfile("2.pcx");
  296. picts.load(1);
  297. picts.assigninfile("1.pcx");
  298. picts.load(2);
  299. picts.assigninfile("go.pcx");
  300. picts.load(3);
  302. for (short cur_pict=0; cur_pict<4; cur_pict++) {
  304.   cur_vert_angle=Get_Player_Vert_Angle(the_player);
  305.   if (cur_vert_angle!=last_vert_angle) {
  306.   Set_View_Angle(cur_vert_angle);
  307.   last_vert_angle=cur_vert_angle;
  308.   }
  309.   if (the_player->cur_sec->flags & VOXEL_SECTOR) {
  310. abs_z=the_player->z+Get_Voxel_Alt((PUCHAR)the_player->cur_sec->extra_data,
  311.  the_player->x, the_player->y)+the_player->type->eye_height;
  312. } else {
  313.   abs_z=the_player->z+the_player->cur_sec->floor_height+the_player->type->eye_height;
  314.   }
  315.   Render_Screen(the_player->x, the_player->y, abs_z, the_player->angle);
  316.   picts.transparent_show(buff, Get_Phys_Screen_Width(), 0,0, cur_pict);
  317. #ifdef OS_WINDOWS
  318.   Win_Copy_Buff();
  319. #endif
  320. #ifdef OS_DOS
  321.   Dos_Copy_Buff();
  322. #endif
  323.   // wait a bit
  324.   start_update_num=Get_Update_Num();
  325.   while ((start_update_num+36)>Get_Update_Num()); /* endwhile */
  326. }
  327. Start_Music();
  328. }
  330. void Post_Quit(ULONG game_result) {
  331. long abs_z;
  332. RCastGobject end_scrn;
  333.   Stop_Music();
  334. if (game_result==WINNING_GAME) {
  335.   Play_Sound(Load_Sound("king.wav"));
  336.   end_scrn.assigninfile((PCHAR)END_PICT_NAME);
  337.   end_scrn.load();
  338.   cur_vert_angle=Get_Player_Vert_Angle(the_player);
  339.   if (cur_vert_angle!=last_vert_angle) {
  340.   Set_View_Angle(cur_vert_angle);
  341.   last_vert_angle=cur_vert_angle;
  342.   }
  343.   if (the_player->cur_sec->flags & VOXEL_SECTOR) {
  344. abs_z=the_player->z+Get_Voxel_Alt((PUCHAR)the_player->cur_sec->extra_data,
  345.  the_player->x, the_player->y)+the_player->type->eye_height;
  346. } else {
  347.   abs_z=the_player->z+the_player->cur_sec->floor_height+the_player->type->eye_height;
  348.   }
  349.   Render_Screen(the_player->x, the_player->y, abs_z, the_player->angle);
  350.   end_scrn.transparent_show(buff, Get_Phys_Screen_Width(), 0,0);
  351. #ifdef OS_WINDOWS
  352.   Win_Copy_Buff();
  353. #endif
  354. #ifdef OS_DOS
  355.   Dos_Copy_Buff();
  356. #endif
  357.   raw_key=0;
  358.   long start_update_num;
  359.   start_update_num=Get_Update_Num();
  360.   while ( ((start_update_num+200)>Get_Update_Num()) && (!raw_key) );
  361.  }
  362. if (game_result==DIED_GAME) {
  363. setgmode(0x3);
  364. cout << "Just because you're paranoid, doesn't mean they're not out to get you.n";
  365. delay(5000);
  366. }
  367. done=TRUE;
  368. }
  370. void Do_Shot(PCHAR graphic_filename, PCHAR sound_filename, long time, BOOL back) {
  371. Suspend_Time();
  372. RCastGobject scrn;
  373. scrn.assigninfile(graphic_filename);
  374. scrn.load();
  376. if (back) {
  377. cur_vert_angle=Get_Player_Vert_Angle(the_player);
  378. if (cur_vert_angle!=last_vert_angle) {
  379. Set_View_Angle(cur_vert_angle);
  380. last_vert_angle=cur_vert_angle;
  381. }
  382. Render_Screen(the_player->x, the_player->y, the_player->z+the_player->type->eye_height+
  383. Ground_Height(the_player), the_player->angle);
  384. } else clearBuff();
  386. scrn.transparent_show(buff, Get_Phys_Screen_Width(), 0, 0);
  387. #ifdef OS_WINDOWS
  388. Win_Copy_Buff();
  389. #endif
  390. #ifdef OS_DOS
  391. Dos_Copy_Buff();
  392. #endif
  393. Play_Sound(Load_Sound(sound_filename));
  394. Reset_Timer();
  395. while (Get_Update_Num()<time);
  396. Resume_Time();
  397. }
  399. void Init_Main_Cycle() {
  400. Reset_Timer();
  401. Do_Intro();
  402. Reset_Timer();
  403. #ifdef OS_DOS
  404. if (hasmouse)
  405.   GetMouseInput();
  406. #endif
  407. Clear_Input();
  408. beg_update_num=0;
  409. cur_vert_angle=last_vert_angle=0;
  410. dim_control=VERT_CONTROL;
  411. raw_key=0;
  412. #ifdef OS_DOS
  413. done=FALSE;
  414. #endif
  415. }
  417. BOOL Main_Cycle_Done() {
  418. return done;
  419. }
  421. void Do_Main_Cycle()
  422. {
  423. long abs_z;
  424. long cur_update, end_update_num;
  426.   cur_vert_angle=Get_Player_Vert_Angle(the_player);
  427.   if (cur_vert_angle!=last_vert_angle) {
  428.   Set_View_Angle(cur_vert_angle);
  429.   last_vert_angle=cur_vert_angle;
  430.   }
  431.   if (the_player->cur_sec->flags & VOXEL_SECTOR) {
  432. abs_z=the_player->z+Get_Voxel_Alt((PUCHAR)the_player->cur_sec->extra_data,
  433.  the_player->x, the_player->y)+the_player->type->eye_height;
  434. } else {
  435.   abs_z=the_player->z+the_player->cur_sec->floor_height+the_player->type->eye_height;
  436.   }
  437.   Render_Screen(the_player->x, the_player->y, abs_z, the_player->angle);
  438. #ifdef OS_WINDOWS
  439.   Win_Copy_Buff();
  440. #endif
  441. #ifdef OS_DOS
  442.   Dos_Copy_Buff();
  443. #endif
  444.   frame_num++; 
  446.   end_update_num=Get_Update_Num();
  447.   for (cur_update=beg_update_num; cur_update<end_update_num; cur_update++) {
  448.   World_Update(cur_update);
  449.   }
  450.   beg_update_num=end_update_num;
  452.   // Check other keys that are unrelated to world updates
  454.   switch (raw_key) {
  455.   case ESC_KEY:
  456.  #ifdef OS_DOS
  457.   done=TRUE;
  458. #endif
  459. #ifdef OS_WINDOWS
  460.   PostQuitMessage(0);
  461. #endif
  462.   // end if user is exiting
  463.   break;
  464. #ifdef _PROGRAMMER_VERSION_
  465.   case PLUS_KEY:
  466.   // user pressed "+" key, so increase window size
  467.   if (GetRenderMode()!=MODE_2D) {
  468.   #ifdef OS_DOS
  469.   if (dim_control==VERT_CONTROL)
  470.   setWindowDimensions(WINDOW_HEIGHT+10);
  471.   else if (dim_control==HORIZ_CONTROL)
  472.   Set_Window_Width(WINDOW_WIDTH+10);
  473.   #endif
  474.   } else Map_Scale_Increase();
  475.   break;
  476.   case MINUS_KEY:
  477.   // user pressed "-" key, so decrease window size
  478.   if (GetRenderMode()!=MODE_2D) {
  479.   #ifdef OS_DOS
  480.   if (dim_control==VERT_CONTROL)
  481.   setWindowDimensions(WINDOW_HEIGHT-10);
  482.   else if (dim_control==HORIZ_CONTROL)
  483.   Set_Window_Width(WINDOW_WIDTH-10);
  484.   #endif
  485.   } else Map_Scale_Decrease();
  486.   break;
  487.   case RIGHT_BRACKET:
  488.   // user pressed "]" key, so increase window FOV
  489.  if (dim_control==VERT_CONTROL)
  490.  setWindowFOV(VERTICAL_VIEW_RANGE+ANGLE_5);
  491.  else if (dim_control==HORIZ_CONTROL)
  492.  Set_Horiz_FOV(HORIZ_VIEW_RANGE+ANGLE_5);
  493.  break;
  494.   case LEFT_BRACKET:
  495.  // user pressed "[" key, so decrease window FOV
  496.  if (dim_control==VERT_CONTROL)
  497.  setWindowFOV(VERTICAL_VIEW_RANGE-ANGLE_5);
  498.  else if (dim_control==HORIZ_CONTROL)
  499.  Set_Horiz_FOV(HORIZ_VIEW_RANGE-ANGLE_5);
  500.  break;
  501.  case PGUP_KEY:
  502.  // user wants to make vox terrain seem farther away
  503.  V_Dist_Scale_Inc();
  504.  break;
  505.  case PGDN_KEY:
  506.  // user wants to make vox terrain seem closer
  507.  V_Dist_Scale_Dec();
  508.  break;
  509. #endif
  510. #ifdef OS_DOS
  511.  case F1_KEY:
  512.  // user is changing screen resolution
  513.  if (is_super_vga)
  514.  Change_Screen(VGA_WIDTH, VGA_HEIGHT);
  515.  else Change_Screen(SVGA_WIDTH, SVGA_HEIGHT);
  516.  is_super_vga=(!is_super_vga);
  517.  Update_Palette();
  518.  break;
  519. #endif
  520. #ifdef _PROGRAMMER_VERSION_
  521.  case F2_KEY:
  522.  // user wants to adjust the other dimension of screen
  523.  if (dim_control==VERT_CONTROL)
  524.  dim_control=HORIZ_CONTROL;
  525.  else if (dim_control==HORIZ_CONTROL)
  526.  dim_control=VERT_CONTROL;
  527.  raw_key=0;
  528.  break;
  529. #endif
  530.  case S_KEY:
  531.  // user wants to capture screen
  532.  Screen_Capture((PCHAR)DEF_CAPTURE_F_NAME);
  533.  break;
  534.   case TAB_KEY:
  535.   SwitchRenderMode();
  536.   raw_key=0;
  537.   break;
  538.   default:
  539.  break;
  540.   } /* endswitch */
  541. }
  543. long time_at_hurt;
  544. BOOL is_hurt;
  546. void Init_Visuals() {
  547. time_at_hurt=0;
  548. is_hurt=FALSE;
  549. }
  551. void Visuals_Message(ULONG message, pdata extra_data) {
  552. switch (message) {
  553.   case HURT_MESSAGE:
  554.   Show_Palette(HURT_PAL);
  555.   time_at_hurt=Get_Update_Num();
  556.   is_hurt=TRUE;
  557.   break;
  558.   case VIS_DIE_MSG:
  559.   Do_Shot("dscreen.pcx", "aaah.wav", 90, TRUE);
  560.   the_player->x=PLAYER_START_X;
  561.   the_player->y=PLAYER_START_Y;
  562.   the_player->z=PLAYER_START_Z;
  563.   the_player->stats.current_health=the_player->type->stats.total_health;
  564.   the_player->angle=PLAYER_START_ANGLE;
  565.   default:
  566.   break;
  567. }
  568. }
  570. void Visuals_Update(long cur_update_num) {
  571. if (is_hurt) {
  572.   if (cur_update_num>time_at_hurt+HURT_TIME) {
  573.  is_hurt=FALSE;
  574.  time_at_hurt=0;
  575.  Show_Palette(STANDARD_PAL);
  576.   }
  577. }
  578. }
  580. void World_Update(long cur_update_num) {
  582. #ifdef OS_DOS
  583. if (hasmouse)
  584. GetMouseInput();
  585. #endif
  587. if (do_waves) {
  588. Do_Waves();
  589. } /* endif */
  591. Animate_Textures(cur_update_num);
  592. Setup_Combined_Input();
  593. Update_Objects(cur_update_num);
  594. Visuals_Update(cur_update_num);
  595. }
  597. void GetMouseInput()
  598. {
  599. #ifdef OS_DOS
  600. short x,y; // x,y positions of the mouse relative to last check
  601. mbrel(x,y); // Get them's positions;
  602. if (x<0) { // mouse to left
  603. mouse_table[INDEX_LEFT]=-x;
  604. } else {
  605. if (x>0) { // mouse to right
  606. mouse_table[INDEX_RIGHT]=x;
  607. } else {  // no mouse movement on x
  608. mouse_table[INDEX_LEFT]=0; mouse_table[INDEX_RIGHT]=0;
  609. } /* endif */
  610. } /* endif */
  611. // Note: on the y axis, direction is reversed i.e. a mouse movement up generates a y<0
  612.  
  613. // mouse has different function in fly mode
  614. if (!Is_Flying(the_player)) {
  615. if (y<0) { // mouse is higher than last position
  616. if (y<-the_player->type->stats.base_speed)
  617. y=-the_player->type->stats.base_speed;
  619. mouse_table[INDEX_UP]=-y;
  620. } else {
  621. if (y>0) { // mouse is lower than last position
  622. if (y>the_player->type->stats.base_speed)
  623. y=the_player->type->stats.base_speed;
  624. mouse_table[INDEX_DOWN]=y;
  625. } else { // no mouse movement on y
  626. mouse_table[INDEX_DOWN]=0; mouse_table[INDEX_UP]=0;
  627. } /* endif */
  628. } /* endif */
  629. if (mbpos(x,y)) { // Check for button press
  630. mouse_table[INDEX_GUN]=1;
  631. } else {
  632. mouse_table[INDEX_GUN]=0;
  633. }
  634. } else {
  635. if (y<0) {
  636. mouse_table[LOOK_UP]=-y;
  637. } else {
  638. if (y>0) {
  639. mouse_table[LOOK_DOWN]=y;
  640. } else {
  641. mouse_table[LOOK_UP]=0; mouse_table[LOOK_DOWN]=0;
  642. } /* endif */
  643. } /* endif */
  644. long mb_press=mbpos(x,y);
  645. if (mb_press & ML_BUTTON) {
  646. mouse_table[INDEX_UP]=the_player->type->stats.base_speed;
  647. } else {
  648. if (mb_press & MR_BUTTON) {
  649. mouse_table[INDEX_DOWN]=the_player->type->stats.base_speed;
  650. } else {
  651. mouse_table[INDEX_UP]=0; mouse_table[INDEX_DOWN]=0;
  652. } /* endif */
  653. } /* endif */
  654. } /* endif */
  655. #endif
  656. }
  658. void Setup_Combined_Input()
  659. {
  660. for (short i=0; i<(MAX_TRACKED_INPUTS-1); i++) {
  661. if (key_table[i]>mouse_table[i]) {
  662. combined_table[i]=(short)key_table[i];
  663. } else {
  664. combined_table[i]=(short)mouse_table[i];
  665. } /* endif */
  666. } /* endfor */
  667. combined_table[MAX_TRACKED_INPUTS-1]=raw_key;
  668. }
  670. void Clear_Input() {
  671. for (short i=0; i<(MAX_TRACKED_INPUTS-1); i++) {
  672. key_table[i]=0;
  673. mouse_table[i]=0;
  674. combined_table[i]=0;
  675. }
  676. raw_key=0;
  677. combined_table[MAX_TRACKED_INPUTS-1]=0;
  678. }
  680. void Screen_Message(PCHAR message) {
  681.   printf(message);
  682.   printf("n");
  683. }