tdecfg.c

C++游戏开发书籍的实例非常适合初学但又又想往游戏开发方面发展的人学习哦

#include <bios.h>
#include <dos.h>
#include <io.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "tdecfg.h"


struct vcfg cfg;                /* video stuff */
FILE *tde_exe;                  /* FILE pointer to tde.exe */

long sort_offset;
long mode_offset;
long color_offset;
long macro_offset;
long keys_offset;
long two_key_offset;
long help_offset;

struct screen cfg_choice[] = {
   {5,25,"1.  Change colors" },
   {7,25,"2.  Redefine keys" },
   {9,25,"3.  Install new help screen" },
  {11,25,"4.  Set default modes" },
  {13,25,"5.  Install permanent macro file" },
  {15,25,"6.  Read in a configuration file" },
  {17,25,"7.  Exit" },
 {20,20,"Please enter choice: " },
  {0,0,NULL}
};


char *greatest_composer_ever = "W. A. Mozart, 1756-1791";


/*
 * Name:    main
 * Date:    October 5, 1991
 * Notes:   Strategy is fairly straight forward -  1) initialize all the
 *          variables  2) show the user a color sample  3) make the changes
 *          permanent if desired.
 */
void main( int argc, char *argv[] )
{
int  rc;
int  c;
char fname[82];
char *buff;

   /*
    * lets get a 8k buffer for our pattern matching machines.
    */
   if ((buff = malloc( 8200 )) == NULL) {
      puts( "\nNot enough memory." );
      exit( 1 );
   }

   puts( "\nEnter tde executable file name (<Enter> = \"tde.exe\")  :" );
   gets( fname );

   if (strlen(fname) == 0)
      strcpy( fname, "tde.exe" );

   if ((rc = access( fname, EXIST )) != 0) {
      puts( "\nFile not found." );
      exit( 1 );
   } else if ((tde_exe = fopen( fname, "r+b" )) == NULL ) {
      puts( "\nCannot open executable file." );
      exit( 2 );
   }
   if ((rc = find_offsets( buff )) == ERROR)
      puts( "\nFatal error finding offsets.\n" );
   free( buff );
   if (rc == ERROR)
      exit( 3 );

   video_config( );
   cls( );
   show_box( 0, 0, cfg_choice, NORMAL );
   for (rc=0; rc != 1;) {
      xygoto( 42, 20 );
      c = getkey( );
      while (c != '1' && c != '2' && c != '3' && c != '4' && c != '5' &&
             c != '6' && c != '7')
         c = getkey( );
      switch (c) {
         case '1' :
            tdecolor( );
            show_box( 0, 0, cfg_choice, NORMAL );
            break;
         case '2' :
            tdekeys( );
            show_box( 0, 0, cfg_choice, NORMAL );
            break;
         case '3' :
            tdehelp( );
            show_box( 0, 0, cfg_choice, NORMAL );
            break;
         case '4' :
            tdemodes( );
            show_box( 0, 0, cfg_choice, NORMAL );
            break;
         case '5' :
            tdemacro( );
            show_box( 0, 0, cfg_choice, NORMAL );
            break;
         case '6' :
            tdecfgfile( );
            show_box( 0, 0, cfg_choice, NORMAL );
            break;
         case '7' :
            rc = 1;
            break;
      }
   }
   fcloseall( );
   puts( " " );
   puts( " " );
}


/***********************  original comments  *************************/
/*
** OFFSETS.C    -       Automatically scan tde.exe for config offsets
**
** Author:  Jim Lee ([e-mail])
**   Date:  5/12/93
** Status:  Released to the public domain
**
**      This little utility takes the drudgery out of updating tdecfg.h
**      every time you re-compile tde.exe.  Just remove the hard-coded
**      offsets in tdecfg.h and replace them with '#include "newoff.h"'.
**      Then run 'offsets tde.exe > newoff.h'.  Now re-compile tdecfg
**      and you're done!
**
*/
/*****************************   end   *******************************/


/*
 * Name:    build_next_table
 * Date:    August 29, 1993
 * Notes:   the algorithm for building the next table is based the description
 *           by KMP in _SIAM J Comp_, page 328.  Hints for a C implementation
 *           are from Dr. Sedgewick's book, page 283.
 */
void build_next_table( char *pattern, char *next )
{
int  j;
int  t;
int  len;

   len = strlen( pattern );
   t = next[0] = -1;
   j = 0;
   while (j < len) {
      while (t >= 0  &&  pattern[j] != pattern[t])
         t = (int)next[t];
      j++;
      t++;
      next[j] =  pattern[j] == pattern[t]  ?  next[t]  :  (char)t;
   }
}


/*
 * Name:    find_offsets
 * Date:    June 5, 1993
 *          August 29, 1993
 * Notes:   to increase the speed, we use a pattern matching machine
 *           for each of the signatures.  on one pass through the file, all 7
 *           signatures will be found.  it's also a little faster if we read
 *           the file in big chunks.  also note that we never have to back-up
 *           or reread the file.
 *
 *          this implementation is pretty much based on the description by
 *           KMP in _SIAM J Comp_, page 326 (middle of the page.)  hints for
 *           a C implementation are from Dr. Sedgewick's book, page 282, 285.
 *
 *   original KMP implementation by:  James H. Thompson, [e-mail]
 */
int  find_offsets( char *buff )
{
long off;
int  m1, m2, m3, m4, m5, m6, m7;
char sig1[8] = { '\x00','\x01','\x02','\x03','\x04','\x05','\x06','\x07' };
char sig2[8] = "$ modes";
char sig3[8] = "$colors";
char sig4[8] = "$macbuf";
char sig5[8] = "$  keys";
char sig6[8] = "$twokey";
char sig7[8] = "$  help";
char sig1_next[8];
char sig2_next[8];
char sig3_next[8];
char sig4_next[8];
char sig5_next[8];
char sig6_next[8];
char sig7_next[8];
unsigned int cnt;
register char *b;

   /* build the _next[] tables */
   build_next_table( sig1, sig1_next );
   build_next_table( sig2, sig2_next );
   build_next_table( sig3, sig3_next );
   build_next_table( sig4, sig4_next );
   build_next_table( sig5, sig5_next );
   build_next_table( sig6, sig6_next );
   build_next_table( sig7, sig7_next );

   /*
    * Let's start the machines 100k into the executable.
    */
   m1 = m2 = m3 = m4 = m5 = m6 = m7 = 0;
   off = 100000L;
   sort_offset = mode_offset    = color_offset = macro_offset = 0L;
   keys_offset = two_key_offset = help_offset  = 0L;
   fseek( tde_exe, off, SEEK_SET );
   while (!feof( tde_exe )) {
      cnt = fread( buff, sizeof(char), 8192, tde_exe );
      b = (char *)buff;
      for (; cnt > 0; off++, cnt--, b++) {

         /*
          * original KMP search implementation by: Jimmy Thompson
          */
         if (m1 < 8) {
            if (sig1[m1] == *b) {
               m1++;
               if (m1 == 8)
                  sort_offset = off - 7L;
            } else {
               while (m1 > 0  &&  *b != sig1[m1])
                  m1 = (int)sig1_next[m1];
               m1++;
            }
         }
         if (m2 < 8) {
            if (sig2[m2] == *b) {
               m2++;
               if (m2 == 8)
                  mode_offset = off - 7L;
            } else {
               while (m2 > 0  &&  *b != sig2[m2])
                  m2 = (int)sig2_next[m2];
               m2++;
            }
         }
         if (m3 < 8) {
            if (sig3[m3] == *b) {
               m3++;
               if (m3 == 8)
                  color_offset = off - 7L;
            } else {
               while (m3 > 0  &&  *b != sig3[m3])
                  m3 = (int)sig3_next[m3];
               m3++;
            }
         }
         if (m4 < 8) {
            if (sig4[m4] == *b) {
               m4++;
               if (m4 == 8)
                  macro_offset = off - 7L;
            } else {
               while (m4 > 0  &&  *b != sig4[m4])
                  m4 = (int)sig4_next[m4];
               m4++;
            }
         }
         if (m5 < 8) {
            if (sig5[m5] == *b) {
               m5++;
               if (m5 == 8)
                  keys_offset = off - 7L;
            } else {
               while (m5 > 0  &&  *b != sig5[m5])
                  m5 = (int)sig5_next[m5];
               m5++;
            }
         }
         if (m6 < 8) {
            if (sig6[m6] == *b) {
               m6++;
               if (m6 == 8)
                  two_key_offset = off - 7L;
            } else {
               while (m6 > 0  &&  *b != sig6[m6])
                  m6 = (int)sig6_next[m6];
               m6++;
            }
         }
         if (m7 < 8) {
            if (sig7[m7] == *b) {
               m7++;
               if (m7 == 8)
                  help_offset = off - 7L;
            } else {
               while (m7 > 0  &&  *b != sig7[m7])
                  m7 = (int)sig7_next[m7];
               m7++;
            }
         }
      }
   }
   m1 = OK;
   if (sort_offset  == 0L || mode_offset == 0L || color_offset   == 0L ||
       macro_offset == 0L || keys_offset == 0L || two_key_offset == 0L ||
       help_offset  == 0L)
      m1 = ERROR;
   return( m1 );
}


/*
 * Name:    xygoto
 * Date:    July 21, 1991
 * Notes:   Use the video interrupt to set the cursor.
 */
void xygoto( int col, int row )
{
union REGS inregs, outregs;

   inregs.h.ah = 2;
   inregs.h.bh = 0;
   inregs.h.dh = row;
   inregs.h.dl = col;
   int86( VIDEO_INT, &inregs, &outregs );
}


/*
 * Name:    video_config
 * Date:    July 21, 1991
 * Notes:   See main.c for more info.
 */
void video_config( void )
{
#pragma pack( 1 )    /* Use pragma to force packing on byte boundaries. */

struct LOWMEMVID
{
   char     vidmode;           /* 0x449 */
   unsigned scrwid;            /* 0x44A */
   unsigned scrlen;            /* 0x44C */
   unsigned scroff;            /* 0x44E */
   struct   LOCATE
   {
      unsigned char col;
      unsigned char row;
   } csrpos[8];                /* 0x450 */
   struct   CURSIZE
   {
      unsigned char end;
      unsigned char start;
   } csrsize;                  /* 0x460 */
   char      page;             /* 0x462 */
   unsigned  addr_6845;        /* 0x463 */
   char      crt_mode_set;     /* 0x465 */
   char      crt_palette;      /* 0x466 */
   char      system_stuff[29]; /* 0x467 */
   char      rows;             /* 0x484 */
   unsigned  points;           /* 0x485 */
   char      ega_info;         /* 0x487 */
   char      info_3;           /* 0x488 */
} vid;
struct LOWMEMVID _far *pvid = &vid;

#pragma pack( )    /* revert to previously defined pack pragma. */

union REGS in, out;
unsigned char temp, active_display;

   /* Move system information into uninitialized structure variable. */
   movedata( 0, 0x449, FP_SEG( pvid ), FP_OFF( pvid ), sizeof( vid ) );

   cfg.rescan = FALSE;
   in.x.ax =  0x1a00;
   int86( VIDEO_INT, &in, &out );
   temp = out.h.al;
   active_display = out.h.bl;
   if (temp == 0x1a && (active_display == 7 || active_display == 8))
      cfg.adapter = VGA;
   else {
      in.h.ah =  0x12;
      in.h.bl =  0x10;
      int86( VIDEO_INT, &in, &out );
      if (out.h.bl != 0x10) {         /* EGA */
         if (vid.ega_info & 0x08) {
            if (vid.addr_6845 == 0x3d4)
               cfg.adapter = CGA;
            else
               cfg.adapter = MDA;
         } else
            cfg.adapter = EGA;
      } else if (vid.addr_6845 == 0x3d4)
         cfg.adapter = CGA;
      else
         cfg.adapter = MDA;
   }

   if (cfg.adapter == CGA)
      cfg.rescan = TRUE;

   cfg.mode = vid.vidmode;
   if (vid.addr_6845 == 0x3D4) {