win_sys.c

来自「经典的老游戏digger的源代码.提起digger相信很多人会回忆起曾经为了它挑」· C语言 代码 · 共 1,185 行 · 第 1/3 页

/* Digger Remastered
   Copyright (c) Andrew Jenner 1998-2004 */

#define INITGUID
#include "def.h"
#include <stdio.h>
#include <stdlib.h>
#include "win_dig.h"
#include <windowsx.h>
#include "resource.h"
#include "scores.h"
#include <commctrl.h>
#include "win_vid.h"
#include "win_snd.h"
#include "win_cfg.h"
#include "main.h"
#include "ini.h"
#include "hardware.h"
#include "sprite.h"
#include "record.h"
#include "scores.h"

extern void finish(void);
extern int keycodes[17][5];
extern void redefkeyb(bool allf);
extern void parsecmd(int argc,char *argv[]);

extern bool joyflag;

/* these are used by the menu/dialogue boxes */
extern Sint4 nplayers,diggers,curplayer,startlev;
extern bool start;
extern void shownplayers(void);
extern bool gauntlet;
extern int gtime;
extern bool soundflag,musicflag;
extern bool pausef;
extern Uint5 ftime;
extern bool timeout;
extern Uint4 size;
extern bool soundlevdoneflag;
extern bool escape;
extern Sint4 frame;
extern bool started;

HINSTANCE hDirectDrawInstance=NULL;
HINSTANCE hDirectSoundInstance=NULL;
HRESULT (WINAPI *lpDirectSoundCreate)(LPGUID, LPDIRECTSOUND *, LPUNKNOWN);
HRESULT (WINAPI *lpDirectDrawCreate)(GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter );
bool check_for_direct_x=TRUE;

// This will store a copy of the original level data so that the user can return to using the original set of level, after loading one of the DLF files
Sint3 orig_leveldat[8][MHEIGHT][MWIDTH];
Uint4 orig_bonusscore;

// This will store a copy of the 'current' level data so that the current level data is not lost when a DRF is played
Sint3 backup_leveldat[8][MHEIGHT][MWIDTH];
Uint4 backup_bonusscore;
char backup_levfname[FILENAME_BUFFER_SIZE];
bool backup_levfflag;

char drf_filename[FILENAME_BUFFER_SIZE]="";
int use_direct_input=0;

bool suspend_game=FALSE;
HWND hWnd;
SIZE window_size;
HINSTANCE g_hInstance;
bool reset_main_menu_screen=FALSE;
bool use_performance_counter;
_int64 performance_frequency;
int kb_buffer=0;
int command_buffer=0;

HWND cur_dialog_box=(HWND) NULL;
char* params[10];
int param_count;
bool main_function_started=FALSE;   /* has main() been called yet? */
bool shutting_down=FALSE;
HMENU hMenu;
char digger_dir[256];

LRESULT CALLBACK gauntlet_settings_dialog_proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK sound_settings_dialog_proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK help_about_dialog_proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK levels_dialog_proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

/* time routines */
void olddelay(Sint4 t) { };
Sint5 getkips(void) { return 0; };
void inittimer(void){ };
Uint5 gethrt(void)
{
  return (Uint5) ((DWORD) GetTickCount() * 1193l);
//  return (Uint5) ((DWORD) GetTickCount());
};

Sint5 getlrt(void)
{
  return gethrt();
};

Sint4 getkey(void)  // returns the Virtual Key Code of the last key pressed
{
  Sint4 temp_buffer;
  do
  {
    if (kb_buffer)
    {
      temp_buffer=kb_buffer;
      kb_buffer=0;
      return temp_buffer;
    }
    else
      do_windows_events();
  } while (TRUE);

};

Sint4 getcommand(void)   // similar to getkey() but the value returned has already been translated from the keycode to the function/command that the key is mapped to
{
  Sint4 temp_buffer;

  temp_buffer=command_buffer;
  command_buffer=0;
  return temp_buffer;
};
bool kbhit(void)
{
  return (kb_buffer!=0);
};
bool cmdhit(void)
{
  return (command_buffer);
}

void initkeyb(void) {};
void restorekeyb(void) {};


void clear_nplayerlines()
{
  outtext("          ",180,25,3);
  outtext("            ",170,39,3);
}

void refresh_menu_items()
{
  /* set checkmarks, etc. */
  HMENU cur_menu;

  cur_menu=GetMenu(hWnd);
  CheckMenuItem(cur_menu, ID_GAME_PLAYERS_ONE, MF_BYCOMMAND | (diggers>1||nplayers>1 ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_GAME_PLAYERS_TWO, MF_BYCOMMAND | (diggers>1||nplayers!=2 ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_GAME_PLAYERS_TWOSIMULTANEOUS, MF_BYCOMMAND | (diggers!=2 ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_GAME_MODE_NORMAL, MF_BYCOMMAND | (gauntlet ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_GAME_MODE_GAUNTLET, MF_BYCOMMAND | (!gauntlet ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_SOUND_SOUNDS_PLAY, MF_BYCOMMAND | (!soundflag ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_SOUND_MUSIC_PLAY, MF_BYCOMMAND | (!musicflag ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_CONFIGURATION_GRAPHICS_ASYNCHRONOUS, MF_BYCOMMAND | (!use_async_screen_updates ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_CONFIGURATION_SPEED_DEFAULT, MF_BYCOMMAND | (ftime!=80000l ? MF_UNCHECKED : MF_CHECKED));
  CheckMenuItem(cur_menu, ID_VIEW_FULLSCREEN, MF_BYCOMMAND | (g_bWindowed ? MF_UNCHECKED : MF_CHECKED));
  EnableMenuItem(cur_menu, ID_VIEW_FULLSCREEN, MF_BYCOMMAND | (use_direct_draw /*==6*/ ? MF_ENABLED : MF_GRAYED));
  CheckMenuItem(cur_menu, ID_VIEW_VGAGRAPHICS, MF_BYCOMMAND | (video_mode==VIDEO_MODE_VGA_16 ? MF_CHECKED : MF_UNCHECKED));
  CheckMenuItem(cur_menu, ID_VIEW_CGAGRAPHICS, MF_BYCOMMAND | (video_mode==VIDEO_MODE_CGA ? MF_CHECKED : MF_UNCHECKED));
  EnableMenuItem(cur_menu, ID_RECORDING_SAVE, MF_BYCOMMAND | (gotgame && drfvalid) ? MF_ENABLED : MF_GRAYED);
  EnableMenuItem(cur_menu, ID_RECORDING_INSTANTREPLAY, MF_BYCOMMAND | (gotgame && drfvalid) ? MF_ENABLED : MF_GRAYED);
}

void show_game_menu()
{
 /* Display the menu which should be displayed when a game is in progress */
  HMENU main_menu;
  HMENU cur_menu;

  main_menu = GetMenu(hWnd);
  EnableMenuItem(main_menu, ID_GAME_ABORT, MF_BYCOMMAND | MF_ENABLED);
  EnableMenuItem(main_menu, ID_GAME_PAUSE, MF_BYCOMMAND | MF_ENABLED);
  EnableMenuItem(main_menu, ID_GAME_START, MF_BYCOMMAND | MF_GRAYED);
  EnableMenuItem(main_menu, ID_VIEW_VGAGRAPHICS, MF_BYCOMMAND | MF_GRAYED);
  EnableMenuItem(main_menu, ID_VIEW_CGAGRAPHICS, MF_BYCOMMAND | MF_GRAYED);
  EnableMenuItem(main_menu, ID_CONFIGURATION_CONTROLS_KEYBOARD_REDEFINEKEYS, MF_BYCOMMAND | MF_GRAYED);
  EnableMenuItem(main_menu, ID_CONFIGURATION_CONTROLS_KEYBOARD_REDEFINEALLKEYS, MF_BYCOMMAND | MF_GRAYED);
  cur_menu = GetSubMenu(main_menu, 0);
  EnableMenuItem(cur_menu, 5, MF_BYPOSITION | MF_GRAYED); // MODE>
  EnableMenuItem(cur_menu, 6, MF_BYPOSITION | MF_GRAYED); // PLAYERS>
  EnableMenuItem(cur_menu, 7, MF_BYPOSITION | MF_GRAYED); // LEVELS...
  EnableMenuItem(cur_menu, 9, MF_BYPOSITION | MF_GRAYED); // Recording>
}

void show_main_menu()
{
  /* Display menu for title/high score screen */
  HMENU main_menu;
  HMENU cur_menu;

  main_menu=GetMenu(hWnd);
  EnableMenuItem(main_menu, ID_GAME_ABORT, MF_BYCOMMAND | MF_GRAYED);
  EnableMenuItem(main_menu, ID_GAME_PAUSE, MF_BYCOMMAND | MF_GRAYED);
  EnableMenuItem(main_menu, ID_GAME_START, MF_BYCOMMAND | MF_ENABLED);
  EnableMenuItem(main_menu, ID_VIEW_VGAGRAPHICS, MF_BYCOMMAND | MF_ENABLED);
  EnableMenuItem(main_menu, ID_VIEW_CGAGRAPHICS, MF_BYCOMMAND | MF_ENABLED);
  EnableMenuItem(main_menu, ID_RECORDING_PLAY, MF_BYCOMMAND | MF_ENABLED);
  EnableMenuItem(main_menu, ID_CONFIGURATION_CONTROLS_KEYBOARD_REDEFINEKEYS, MF_BYCOMMAND | MF_ENABLED);
  EnableMenuItem(main_menu, ID_CONFIGURATION_CONTROLS_KEYBOARD_REDEFINEALLKEYS, MF_BYCOMMAND | MF_ENABLED);
  cur_menu=GetSubMenu(main_menu,0);
  EnableMenuItem(cur_menu, 5, MF_BYPOSITION | MF_ENABLED); // MODE>
  EnableMenuItem(cur_menu, 6, MF_BYPOSITION | MF_ENABLED); // PLAYERS>
  EnableMenuItem(cur_menu, 7, MF_BYPOSITION | MF_ENABLED); // LEVEL...
  EnableMenuItem(cur_menu, 9, MF_BYPOSITION | MF_ENABLED); // Recordings>
  cur_menu=GetSubMenu(main_menu, 1);
}

void refresh_screen_info()
{
  /* called whenever the user switches the number of players or the game type */
  loadscores();
  showtable();
  clear_nplayerlines();
  shownplayers();
}

LRESULT CALLBACK WndProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  HRESULT hRet;
  BYTE clear_keyboard_state[256];

  switch(message)
  {
  case WM_KEYDOWN:
    //if (wParam!=VK_SHIFT && wParam!=VK_CONTROL)
    //{
      kb_buffer=wParam;
    //}
    if (wParam==VK_MENU && !g_bWindowed)
      SetMenu(hWnd,hMenu);
    return 0;

  case WM_SYSKEYDOWN:
    switch (wParam)
    {
/*
    case VK_RETURN:
      if (use_direct_draw)
        toggle_screen_mode();
      return 0;
*/
    case VK_MENU:
      if (!g_bWindowed)
        SetMenu(hWnd,hMenu);
    }
    break;

  case WM_SYSKEYUP:
    switch (wParam)
    {
    case VK_F10:
      kb_buffer=VK_F10;
      return 0;
    }
    break;

  /************************************/
  /* menu commands                    */
  /************************************/
  case WM_COMMAND:
    switch (LOWORD(wParam))
    {
    case VK_F10:
      kb_buffer=VK_F10;
    case ID_GAME_EXIT:
      SendMessage(hWnd, WM_CLOSE, 0, 0L);
      break;
    case ID_VIEW_FULLSCREEN:
      toggle_screen_mode();
      break;
    case ID_GAME_PLAYERS_ONE:
      nplayers=1;
      diggers=1;
      refresh_screen_info();
      break;
    case ID_GAME_PLAYERS_TWO:
      nplayers=2;
      diggers=1;
      gauntlet=FALSE;
      refresh_screen_info();
      break;
    case ID_GAME_PLAYERS_TWOSIMULTANEOUS:
      nplayers=1;
      diggers=2;
      refresh_screen_info();
      break;
    case ID_GAME_MODE_NORMAL:
      gauntlet=FALSE;
      timeout=FALSE;  /* must do this in case the previous game was a guantlet game */
      refresh_screen_info();
      break;
    case ID_GAME_MODE_GAUNTLET:
      gauntlet=TRUE;
      nplayers=1;
      if (!gtime)
        gtime=120;
      refresh_screen_info();
      if (do_dialog_box(g_hInstance,
                    MAKEINTRESOURCE(IDD_DIALOG_GAUNTLET_SETTINGS),
                    hWnd, (DLGPROC) gauntlet_settings_dialog_proc))
        WriteINIInt(INI_GAME_SETTINGS, "GauntletTime", gtime, ININAME);
      break;
    case ID_GAME_LEVEL:
      if (do_dialog_box(g_hInstance,
                    MAKEINTRESOURCE(IDD_DIALOG_LEVELS),
                    hWnd, (DLGPROC) levels_dialog_proc))
      {
        startlev=startlev;
      }
      break;
    case ID_GAME_START:
      start=TRUE;
      break;
    case ID_GAME_ABORT:
      kb_buffer=0;
      escape=TRUE;
      break;
    case ID_GAME_PAUSE:
      if (!pausef)
        pausef=TRUE;
      else
        kb_buffer=1;  // any key will cause game to continue
      //kb_buffer=keycodes[16][0];
      break;
    case ID_SOUND_SOUNDS_PLAY:
      soundflag=!soundflag;
      soundlevdoneflag=FALSE;
      break;
    case ID_SOUND_MUSIC_PLAY:
      musicflag=!musicflag;
      break;
    case ID_CONFIGURATION_SPEED_DEFAULT:
      ftime=80000l;
      break;
    case ID_SPEED_FASTER:
      if (ftime>10000l)
        ftime-=10000l;
      break;
    case ID_SPEED_SLOWER:
      ftime+=10000l;
      break;
    case ID_SOUND_SETTINGS:
      if (do_dialog_box(g_hInstance,
                    MAKEINTRESOURCE(IDD_DIALOG_SOUND_SETTINGS),
                    hWnd, (DLGPROC) sound_settings_dialog_proc))
      {
        WriteINIBool(INI_SOUND_SETTINGS, "SoundOn", soundflag, ININAME);
        WriteINIInt(INI_SOUND_SETTINGS, "SoundVolume", get_sound_volume(), ININAME);
      }
      break;
    case ID_HELP_ABOUTDIGGER:
      do_dialog_box(g_hInstance, MAKEINTRESOURCE(IDD_DIALOG_ABOUT), hWnd,
                    (DLGPROC) help_about_dialog_proc);
      break;
    case ID_CONFIGURATION_GRAPHICS_ASYNCHRONOUS:
      use_async_screen_updates=!use_async_screen_updates;
      break;
    case ID_CONFIGURATION_CONTROLS_KEYBOARD_REDEFINEKEYS:
        gclear();
        redefkeyb(FALSE);
        reset_main_menu_screen=TRUE;
        break;
    case ID_CONFIGURATION_CONTROLS_KEYBOARD_REDEFINEALLKEYS:
        gclear();
        redefkeyb(TRUE);
        reset_main_menu_screen=TRUE;
      break;
    case ID_CONFIGURATION_SHOWSETTINGSDIALOG:
      if (started)
        pausef=TRUE;
      create_config_window();
      break;
    case ID_VIEW_VGAGRAPHICS:
      change_graphics_routines(VIDEO_MODE_VGA_16);
      break;

    case ID_VIEW_CGAGRAPHICS:
      change_graphics_routines(VIDEO_MODE_CGA);
      break;
    case ID_RECORDING_PLAY:
      if (get_open_save_filename(OPEN, "Open Recorded Game","Digger Record Files (*.drf)\0*.DRF\0All Files (*.*)\0*.*\0","DRF", drf_filename))
      {
        // make a copy of the current level info, so that it can be restored after the DLF playback is finished
        memcpy(backup_leveldat,leveldat,8*MHEIGHT*MWIDTH);
        strcpy(backup_levfname,levfname);
        backup_bonusscore=bonusscore;
        backup_levfflag=levfflag;

        started=FALSE;