![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to life.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / life|
Return to life.c CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / life |
1.1 ! root 1: /*** ! 2: * Title: ! 3: * ! 4: * LIFE - An OS/2 Game of Life ! 5: * ! 6: * ! 7: * Author: ! 8: * ! 9: * Brian J. Smith ! 10: * (c) Microsoft Corporation ! 11: * 1987 ! 12: * ! 13: * ! 14: * Description: ! 15: * ! 16: * This is a OS/2 implementation of the game of Life. It is designed ! 17: * to be bound to allow it to operate in both the protect mode of OS/2 ! 18: * and in earlier MS-DOS versions. The program uses a mouse if one ! 19: * is installed, but one is not needed. ! 20: * ! 21: * Keyboard commands: B(lank) - redraw screen ! 22: * G(o) - step through generations until a key or ! 23: * button is hit ! 24: * H(alt) - freeze at current generation ! 25: * Q(uit) - exit program ! 26: * R(ead) - read a game board from the disk ! 27: * S(step) - advance a single generation ! 28: * W(rite) - write the current board to disk ! 29: * D(own-speed) - slow down GOs ! 30: * U(p-speed) - speed up GOs ! 31: * ! 32: */ ! 33: ! 34: ! 35: #include <doscalls.h> /* definitions for DOS calls and */ ! 36: #include <subcalls.h> /* associated data structures */ ! 37: ! 38: /* defines */ ! 39: #define SCR_WID 80 /* screen buffer row width in bytes */ ! 40: #define SIGNATURE 0x5342 /* 1st word of all files from this */ ! 41: ! 42: /* these defines are all coordinates to put various messsages */ ! 43: #define COM_ROW 23 /* alpha row for command line */ ! 44: #define COM_COL 0 /* column for same */ ! 45: #define PROMPT_ROW 24 /* alpha row for prompts */ ! 46: #define PROMPT_COL 0 /* column for same */ ! 47: #define GEN_COL 13 /* column to put generation number on*/ ! 48: #define FILE_COL 37 /* column to put filespec */ ! 49: ! 50: /* misc. defines */ ! 51: #define FONT_ROW 8 /* pixel rows in the font */ ! 52: #define BIT 8 /* number of bits in a byte */ ! 53: #define BYTEINCOLS 8 /* no. of interal columns in a byte */ ! 54: ! 55: /**** all functions in this file ******/ ! 56: int main(); /* setup and master loop for life game*/ ! 57: void blank(); /* blank internal and screen grid*/ ! 58: void go(); /* steps through generations until a key is pressed*/ ! 59: void halt(); /* does nothing */ ! 60: void quit(); /* exit after prompting for certainty*/ ! 61: void diskread(); /* read new grid from disk*/ ! 62: int step(); /* advance one generation on screen and internally*/ ! 63: void diskwrite(); /* write internal grid to disk*/ ! 64: void up(); /* speeds up GO if possible */ ! 65: void down(); /* slows down GO */ ! 66: void beep(); /* beep the speaker for bad commands*/ ! 67: void showingrid(); /* display internal grid on screen*/ ! 68: int getfilespec(); /* get a file name from the user*/ ! 69: void putgen(); /* puts the current generation counter on prompt line*/ ! 70: void fill(); /* fill in a grid cell on the screen and internally*/ ! 71: void remove(); /* clear a grid cell on the screen and internal grids*/ ! 72: int kbdreadeventque(); /* simulates MouReadEventQue with the keyboard*/ ! 73: void xorptr(); /* xors the mouse ptr on the screen*/ ! 74: void gputs(); /* put a character string on the graphics screen*/ ! 75: void gputchar(); /* put a character on the graphics screen*/ ! 76: void anerror(); /* error handler*/ ! 77: char gethit(); /* waits for a key hit or mouse button hit*/ ! 78: void wait4release(); /* wait until mouse buttons are up before returning*/ ! 79: void far pascal exitlife();/* exit program, resetting original screen mode*/ ! 80: ! 81: ! 82: /* global data */ ! 83: /* global variables for the internal and screen grids */ ! 84: int InRow = 45; /* rows & columns of cells w/ default*/ ! 85: int InCol = 80; /* in internal grid. Col must be /8*/ ! 86: int ScrRow = 45; /* rows & column on screen grid */ ! 87: int ScrCol = 79; ! 88: int SizeScrRow = 4; /* pixel rows per screen grid row */ ! 89: int SizeScrCol = 8; /* pixels cols per screen grid column*/ ! 90: char far *InGrid; /* pointer to internal grid, a simple ! 91: * bit map of the space and cells */ ! 92: char far *InGrid2; /* pointer for secondary map used ! 93: * to calculate next generation */ ! 94: ! 95: /* screen related global data */ ! 96: static struct ModeData Highres = {12, 3, 1, 80, 25, 640, 200}; /* 640x200 b/w*/ ! 97: struct ModeData Savemode = {12}; /* place to save old screen mode */ ! 98: unsigned ScrSeg; /* screen buffer segment address */ ! 99: char Cell[]={32,7}; /* blank for clear screen */ ! 100: unsigned OddPage=0x2000; /* offset on Cga of odd row bit plane*/ ! 101: /* should be 0 on non-Cga modes */ ! 102: unsigned Cga=2; /* if using a Cga, screen adresses on ! 103: * must be divided by 2 because of ! 104: * the odd and even row bit planes ! 105: * if using non-Cga mode, should be 1*/ ! 106: /* mouse related global data */ ! 107: unsigned Mouse = 0; /* handle if mouse is present, else */ ! 108: int MouBoundRow = COM_ROW*FONT_ROW+6; /* last row mouse is allowed on */ ! 109: int MouBoundCol = 631; /* last column mouse is allowed on */ ! 110: ! 111: /* misc. global data */ ! 112: char Filespec[79-FILE_COL]; /* file name holder (allows default)*/ ! 113: unsigned Generation; /* current generation count */ ! 114: char Logo[] = " \ ! 115: Microsoft LIFE"; /* logo used to clear prompt line */ ! 116: int Slow=0; /* number of slow-down loops for Go */ ! 117: ! 118: /* Data for commands. Column of command on COM_ROW for printed name, ! 119: * name for printing on command line, flag if not 0 then the command ! 120: * can be executed within a Go command without stopping execution, ! 121: * and the function that does the command. */ ! 122: struct Commands { ! 123: int Col; ! 124: char *Name; ! 125: char GoAble; ! 126: void (*Fun)(); ! 127: } ComLine[] = { 0, "Command:", 0, beep, ! 128: 10, "Blank", 0, blank, ! 129: 16, "Go", 0, go, ! 130: 19, "Halt", 0, halt, ! 131: 24, "Quit", 0, quit, ! 132: 29, "Read", 0, diskread, ! 133: 34, "Step", 0, step, ! 134: 39, "Write", 0, diskwrite, ! 135: 46, "Down-speed", 1, down, ! 136: 57, "Up-speed", 1, 0, ! 137: 67, 0, 0 ! 138: }; ! 139: ! 140: ! 141: /*** main - setup and master loop for life game ! 142: * ! 143: * First this sets the screen mode, gets the address of the screen buffer, ! 144: * sets the ctrl-C handle to a routine to reset the screen mode on exit, ! 145: * and allocates the data structures for the internal representation of ! 146: * the life grid. The main loop of the program continuously reads from ! 147: * the keyboard and the mouse and translates the key or location of the ! 148: * mouse with the ComLine structure into a command to execute. ! 149: */ ! 150: main () { ! 151: struct KeyData kbd; /* return for KBD call */ ! 152: struct PhysBufData get_phys; /* return for GetPhysBufData */ ! 153: unsigned long throwaway; /* for returns I don't use */ ! 154: int i; /* just a counter */ ! 155: unsigned far *ptr; /*used to clear internal grid*/ ! 156: ! 157: /* data for the mouse (or keyboard emulator) */ ! 158: int ptrrow = 86; /* current pointer position */ ! 159: int ptrcol = 316; ! 160: unsigned status = 0x100; /* for MouSetDevStatus */ ! 161: int type=0; /* for no waits on mouse read */ ! 162: struct EventInfo event; /* return for mouse reads */ ! 163: struct PtrLoc loc; /* data for MouSetPtrPos */ ! 164: ! 165: ! 166: /* try to open and initialize mouse. If none installed, Mouse will ! 167: * stay 0 to show keyboard emulation must be used */ ! 168: if (!MOUOPEN (0L, (unsigned far *) &Mouse)) /* get handle */ ! 169: /* mouse is here and well, so initialize it */ ! 170: MOUSETDEVSTATUS ((unsigned far *) &status, Mouse); ! 171: ! 172: /* get current screen mode and save it for restoring on exit */ ! 173: if (VIOGETMODE ((struct ModeData far *) &Savemode, 0)) { ! 174: printf ("Error setting screen mode, exitting\n"); ! 175: DOSEXIT (1, 0); /* exit if error */ ! 176: } ! 177: /* set screen mode to 640x200 b/w (Cga high resolution */ ! 178: if (VIOSETMODE ((struct ModeData far *) &Highres, 0)) { ! 179: printf ("Error setting screen mode, exitting\n"); ! 180: DOSEXIT (1, 0); /* exit if error */ ! 181: } ! 182: ! 183: /* set mouse pointer to middle of screen */ ! 184: if (Mouse) { ! 185: loc.RowPos=ptrrow; ! 186: loc.ColPos=ptrcol; ! 187: MOUSETPTRPOS ((struct PtrLoc far *) &loc, Mouse); ! 188: } ! 189: ! 190: /* get screen buffer segment */ ! 191: get_phys.buf_start=0xb8000L; ! 192: get_phys.buf_length=16*1024L; ! 193: if (VIOGETPHYSBUF ((struct PhysBufData far *) &get_phys, 0)) { ! 194: /* if error here, restore screen and exit */ ! 195: VIOSETMODE ((struct ModeData far *) &Savemode, 0); ! 196: printf ("Error accessing screen memory, exitting\n"); ! 197: DOSEXIT (1, 0); ! 198: } ! 199: ScrSeg = get_phys.selectors[0]; /* store in global */ ! 200: ! 201: /* set ctrl-C to quit() to reset screen at even a break */ ! 202: DOSSETSIGHANDLER (exitlife, &throwaway, (unsigned far *)&throwaway, 2, 1); ! 203: ! 204: /* allocate a segment to hold internal grid representation */ ! 205: if (DOSALLOCSEG (InRow*InCol/BYTEINCOLS, (unsigned far *) &InGrid, 0)) ! 206: /* from here on use anerror() to report errors */ ! 207: anerror ("Error allocating memory", 1); ! 208: (long) InGrid *= 0x10000L; /* move selector to high word*/ ! 209: ! 210: /* allocate a segment to hold second buffer used in stepping */ ! 211: if (DOSALLOCSEG(InRow*InCol/BYTEINCOLS, (unsigned far *) &InGrid2, 0)) ! 212: anerror ("Error allocating memory", 1); ! 213: (long) InGrid2 *= 0x10000L; /* move selector to high word*/ ! 214: ! 215: /* blank internal grid and draw screen */ ! 216: for (i=InRow*InCol/16, ptr=(unsigned far *) InGrid ; i--;) ! 217: *ptr++ = 0; ! 218: showingrid (); ! 219: xorptr (ptrrow, ptrcol); /* show cursor */ ! 220: ! 221: ! 222: /* main input loop, polling mouse and keyboard */ ! 223: while (1) { ! 224: /* try to get mouse event from keyboard or mouse */ ! 225: kbd.char_code=0; /* clear key buffer residue */ ! 226: kbdreadeventque (&event, ptrrow, ptrcol); ! 227: if (Mouse) ! 228: MOUREADEVENTQUE ((struct EventInfo far *) &event, ! 229: (unsigned far *) &type, Mouse); ! 230: ! 231: /* if any mouse-like events, do this */ ! 232: if (event.Mask) { ! 233: xorptr (ptrrow, ptrcol); /* hide cursor */ ! 234: if (event.Mask & 1+2+8) { /* if any motion */ ! 235: /* update position, if off screen grid,ptr=max or min*/ ! 236: ptrrow = event.Row; ! 237: ptrcol = event.Col; ! 238: if (ptrrow > MouBoundRow) ! 239: ptrrow = MouBoundRow; ! 240: if (ptrcol > MouBoundCol) ! 241: ptrcol = MouBoundCol; ! 242: } ! 243: /* if a button was hit */ ! 244: if (event.Mask & (2|4|8|16)) { ! 245: if (ptrrow < COM_ROW*FONT_ROW-SizeScrRow) { /* if on grid */ ! 246: Generation=0; /* reset Gen if */ ! 247: putgen(); /* grid modified*/ ! 248: if (event.Mask & (2 | 4)) /* if left down*/ ! 249: fill (ptrcol/SizeScrCol, ptrrow/SizeScrRow); ! 250: else if (event.Mask & (8 | 16)) /* if right */ ! 251: remove (ptrcol/SizeScrCol, ptrrow/SizeScrRow); ! 252: } ! 253: else { /* on command line*/ ! 254: /* if pointing at command word, execute it, highlighting */ ! 255: for(i=0; ComLine[i].Fun != 0; i++) ! 256: if (ptrcol/BIT >= ComLine[i].Col && ! 257: ptrcol/BIT < ComLine[i+1].Col-1) { ! 258: gputs(ComLine[i].Name,COM_ROW,ComLine[i].Col,0xff); ! 259: wait4release (); /* execute on release*/ ! 260: (*(ComLine[i].Fun))(); ! 261: if (ComLine[i].Fun) /*restore name if not removed*/ ! 262: gputs(ComLine[i].Name,COM_ROW,ComLine[i].Col,0); ! 263: } ! 264: } ! 265: } ! 266: xorptr (ptrrow, ptrcol); /* show cursor */ ! 267: } ! 268: ! 269: /* check keys, no wait */ ! 270: KBDPEEK ((struct KeyData far *) &kbd, 0); ! 271: if (kbd.char_code) { /* get key only if not regular char */ ! 272: KBDCHARIN ((struct KeyData far *) &kbd, 1, 0); /*get command*/ ! 273: xorptr (ptrrow, ptrcol); /* avoid overwrites */ ! 274: /* walk command structure and execute function, highlighting */ ! 275: for(i=0; ComLine[i].Fun != 0; i++) ! 276: if ((kbd.char_code & 0xdf) == *(ComLine[i].Name)) { ! 277: gputs(ComLine[i].Name,COM_ROW,ComLine[i].Col,0xff); ! 278: (*(ComLine[i].Fun))(); ! 279: if (ComLine[i].Fun) /*restore name if not removed*/ ! 280: gputs(ComLine[i].Name,COM_ROW,ComLine[i].Col,0); ! 281: } ! 282: xorptr (ptrrow, ptrcol); /* restore pointer */ ! 283: } ! 284: } ! 285: } ! 286: ! 287: ! 288: /*** blank - blank internal and screen grid ! 289: * ! 290: * Sets the internal grid to all 0's and calls draw_grid() to ! 291: * clear the screen and put up a screen grid. blank() then draws ! 292: * the command line and the program logo. ! 293: * ! 294: * Entry: ScrSeg = current screen segment ! 295: * InGrid points to internal grid defined by InCol and InRow ! 296: * Logo points to program logo that also clears the prompt line ! 297: * ! 298: * Exit: Generation = 0 ! 299: * ! 300: * Calls: gputs(), putgen(), draw_grid [assembler routine] ! 301: */ ! 302: void ! 303: blank (){ ! 304: unsigned far *ptr; ! 305: int i; ! 306: ! 307: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 308: gputs ("Are you sure?", PROMPT_ROW, PROMPT_COL, 0); ! 309: if (gethit () == 'Y') { ! 310: /* if yes, blank screen and internal grid */ ! 311: draw_grid (); /* draw blank grid on screen */ ! 312: for (i=InRow*InCol/16, ptr=(unsigned far *) InGrid ; i--;) ! 313: *ptr++ = 0; /* blank internal grid */ ! 314: for (i=0; ComLine[i].Fun != 0; i++) /* print command line */ ! 315: gputs (ComLine[i].Name, COM_ROW, ComLine[i].Col, 0); ! 316: Generation=0; /* reset generation count */ ! 317: } ! 318: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); /* put on logo */ ! 319: putgen (); /* initial generation message*/ ! 320: } ! 321: ! 322: ! 323: /*** go - steps through generations until a key is pressed ! 324: * ! 325: * Calls step() until a key is hit, which terminates the loop ! 326: * and the key is left on the buffer for main() to process ! 327: * as a command. ! 328: * step()'s return is checked to see if this program has just ! 329: * moved from background to foreground, in which case the ! 330: * the screen will need manual updating with showingrid(). ! 331: * If the D or U keys are hit, down() or up() is executed. ! 332: * ! 333: * Entry: none ! 334: * ! 335: * Exit: None ! 336: * ! 337: * Calls: step(), showingrid() ! 338: */ ! 339: void ! 340: go () { ! 341: struct KeyData kbd; /* return from KBD call */ ! 342: int background=0; /* 0 if forground, 1 backgrd */ ! 343: struct EventInfo event; /* return from mouse read */ ! 344: int type=0; /* for no waits on mouse read*/ ! 345: struct QueInfo num; /* return for GetNumQueEl */ ! 346: unsigned x,y; /* for slowing down loops */ ! 347: ! 348: /* step until key or button is hit, executing GoAble commands */ ! 349: kbd.scan_code=0; ! 350: event.Mask=0; ! 351: while (!kbd.scan_code) { ! 352: if (step ()) ! 353: background=1; ! 354: else if (background==1) { ! 355: background=0; ! 356: showingrid(); ! 357: } ! 358: if (Mouse) { ! 359: /* read all events on que */ ! 360: MOUGETNUMQUEEL ((struct QueInfo far *) &num, Mouse); ! 361: while (num.Events--) { ! 362: MOUREADEVENTQUE ((struct EventInfo far *) &event, ! 363: (unsigned far *) &type, Mouse); ! 364: if (event.Mask & (2|4|8|16)) { /* leave if mouse hit*/ ! 365: wait4release(); ! 366: return; ! 367: } ! 368: } ! 369: } ! 370: ! 371: /* check keys, no wait. Execute if GoAble command */ ! 372: KBDPEEK ((struct KeyData far *) &kbd, 0); ! 373: if (kbd.scan_code) { ! 374: /* walk command structure and execute function, highlighting */ ! 375: for(x=0; ComLine[x].Fun != 0; x++) ! 376: if ((kbd.char_code & 0xdf) == *(ComLine[x].Name) ! 377: && ComLine[x].GoAble) { ! 378: gputs(ComLine[x].Name,COM_ROW,ComLine[x].Col,0xff); ! 379: KBDCHARIN ((struct KeyData far *) &kbd, 1, 0); ! 380: kbd.scan_code=0; ! 381: (*(ComLine[x].Fun))(); ! 382: if (ComLine[x].Fun) /*restore name if not removed*/ ! 383: gputs(ComLine[x].Name,COM_ROW,ComLine[x].Col,0); ! 384: } ! 385: } ! 386: if (Slow) /* slow down if requested */ ! 387: for (x=Slow; x--;) ! 388: for (y=50000; y--;); ! 389: } ! 390: } ! 391: ! 392: ! 393: /*** halt - does nothing ! 394: */ ! 395: void ! 396: halt () { ! 397: int i; ! 398: ! 399: for (i=30000; i--;); /* short pause */ ! 400: } ! 401: ! 402: ! 403: /*** quit - exit after prompting for certainty ! 404: * ! 405: * Entry: None ! 406: * ! 407: * Exit: None ! 408: */ ! 409: void ! 410: quit () { ! 411: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 412: gputs ("Are you sure?", PROMPT_ROW, PROMPT_COL, 0); ! 413: if (gethit () == 'Y') ! 414: exitlife (); /* if yes, do quit routine */ ! 415: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); /* else, continue */ ! 416: putgen(); /* put back gen count*/ ! 417: } ! 418: ! 419: ! 420: /*** diskread - read new grid from disk ! 421: * ! 422: * getfilespec() is called to get a file name from the user which ! 423: * is put in Filespec. ! 424: * Then an internal grid is read from the disk which is in the form: ! 425: * WORD SIGNATURE ; Life file signature ! 426: * WORD rows ! 427: * WORD columns ! 428: * WORD generation ! 429: * (rows*columns/BYTEINCOLS) BYTES of the bit mapped grid ! 430: * ! 431: * InGrid is ReAlloced to the size of the newly read grid and ! 432: * InCol, InRow, and Generation are all set the values contained ! 433: * in the file read. ! 434: * ! 435: * Entry: InGrid points to internal grid defined by InCol and InRow ! 436: * ! 437: * Exit: InGrid is ReAlloced to size of newly read grid. ! 438: * InCol, InRow, and Generation are all set the values ! 439: * contained in the file read. ! 440: * d ! 441: * Calls: getfilespec (); ! 442: */ ! 443: void ! 444: diskread () { ! 445: unsigned handle; /* file handle */ ! 446: unsigned action; /* return for file calls */ ! 447: unsigned signature; /* life file signature word */ ! 448: ! 449: /* get file name into Filespec */ ! 450: if (getfilespec ()) ! 451: return; /* return if user hit ESC */ ! 452: ! 453: /* open file, fail if it doesn't exist */ ! 454: if (DOSOPEN ((char far *) Filespec, (unsigned far *) &handle, ! 455: (unsigned far *) &action, 0L, 0, 0x01, 0x42, 0L)) { ! 456: anerror ("Can't open file", 0); ! 457: Filespec[0]=0; /* clear bad file name */ ! 458: return; ! 459: } ! 460: ! 461: /* read appropriate from file */ ! 462: if (DOSREAD (handle, (char far *) &signature, sizeof (signature), ! 463: (unsigned far *) &action) || action != sizeof (signature)) ! 464: anerror ("Error writing to file", 0); ! 465: ! 466: else if (signature != SIGNATURE) { ! 467: anerror ("Not a life file", 0); ! 468: if (DOSCLOSE (handle)) ! 469: anerror ("Error closing file", 0); ! 470: return; ! 471: } ! 472: else if (DOSREAD (handle, (char far *) &InRow, sizeof (InRow), ! 473: (unsigned far *) &action) || action != sizeof (InRow)) ! 474: anerror ("Error reading from file", 0); ! 475: ! 476: else if (DOSREAD (handle, (char far *) &InCol, sizeof (InCol), ! 477: (unsigned far *) &action) || action != sizeof (InCol)) ! 478: anerror ("Error reading from file", 0); ! 479: ! 480: else if (DOSREAD (handle, (char far *) &Generation, ! 481: sizeof (Generation), (unsigned far *) &action) || ! 482: action != sizeof (Generation)) ! 483: anerror ("Error reading from file", 0); ! 484: ! 485: /* change size of *InGrid to match saved pattern */ ! 486: else if (DOSREALLOCSEG (InRow*InCol/BYTEINCOLS, (unsigned) ! 487: ((long) InGrid/0x10000L))) ! 488: anerror ("Error allocating memory", 0); ! 489: ! 490: else if (DOSREAD (handle, InGrid, InRow*InCol/BYTEINCOLS, ! 491: (unsigned far *) &action) || action != InRow*InCol/BYTEINCOLS) ! 492: anerror ("Error reading from file", 0); ! 493: ! 494: /* show the newly loaded pattern on the screen */ ! 495: showingrid (); ! 496: ! 497: /* close file */ ! 498: if (DOSCLOSE (handle)) ! 499: anerror ("Error closing file", 0); ! 500: } ! 501: ! 502: ! 503: /*** step - advance one generation on screen and internally ! 504: * ! 505: * Uses dostep to advance the current internal and screen grid ! 506: * to the next generation. dostep() returns 1 if the screen ! 507: * was not available and thus no update was made, this allows ! 508: * the program to continue to execute in the background. ! 509: * The return from dostep() is passed back to step()'s caller. ! 510: * ! 511: * Entry: None ! 512: * ! 513: * Exit: Returns 1 if executing in background and there was thus ! 514: * no screen update. ! 515: * Else, returns 0 if in forground ! 516: * Generation is incremented. ! 517: * ! 518: * Calls: putgen(), dostep [assembler routine] ! 519: */ ! 520: int ! 521: step() { ! 522: int rc; /* return code from dostep */ ! 523: ! 524: /* do the stepping using an assembler routine for speed */ ! 525: rc=dostep(InGrid, InGrid2, InRow, InCol); /* do the step */ ! 526: ! 527: Generation++; /* advance the count */ ! 528: putgen(); /* and display gen */ ! 529: return(rc); ! 530: } ! 531: ! 532: ! 533: /*** diskwrite - write internal grid to disk ! 534: * ! 535: * getfilespec() is called to get a file name from the user which ! 536: * is put in Filespec. ! 537: * Then the internal grid is saved to disk in the form: ! 538: * WORD SIGNATURE ; Life file signature ! 539: * WORD rows ! 540: * WORD columns ! 541: * WORD generation ! 542: * (rows*columns/BYTEINCOLS) BYTES of the bit mapped grid ! 543: * ! 544: * Entry: InGrid points to internal grid defined by InCol and InRow ! 545: * ! 546: * Exit: None ! 547: * ! 548: * Calls: getfilespec (); ! 549: */ ! 550: void ! 551: diskwrite () { ! 552: unsigned handle; /* file handle */ ! 553: unsigned action; /* return for file calls */ ! 554: unsigned signature=SIGNATURE; /* life file signature word */ ! 555: ! 556: /* get file name into Filespec */ ! 557: if (getfilespec ()) ! 558: return; /* return if user hit ESC */ ! 559: ! 560: /* open file and truncate or create it if it doesn't exist */ ! 561: if (DOSOPEN ((char far *) Filespec, (unsigned far *) &handle, ! 562: (unsigned far *) &action, 0L, 0, 0x12, 0x42, 0L)) { ! 563: anerror ("Can't open file", 0); ! 564: Filespec[0]=0; /* clear bad file name */ ! 565: return; ! 566: } ! 567: ! 568: /* write appropriate info to file */ ! 569: if (DOSWRITE (handle, (char far *) &signature, sizeof (signature), ! 570: (unsigned far *) &action) || action != sizeof (signature)) ! 571: anerror ("Error writing to file", 0); ! 572: ! 573: else if (DOSWRITE (handle, (char far *) &InRow, sizeof (InRow), ! 574: (unsigned far *) &action) || action != sizeof (InRow)) ! 575: anerror ("Error writing to file", 0); ! 576: ! 577: else if (DOSWRITE (handle, (char far *) &InCol, sizeof (InCol), ! 578: (unsigned far *) &action) || action != sizeof (InCol)) ! 579: anerror ("Error writing to file", 0); ! 580: ! 581: else if (DOSWRITE (handle, (char far *) &Generation, ! 582: sizeof (Generation), (unsigned far *) &action) || ! 583: action != sizeof (Generation)) ! 584: anerror ("Error writing to file", 0); ! 585: ! 586: else if (DOSWRITE (handle, InGrid, InRow*InCol/BYTEINCOLS, ! 587: (unsigned far *) &action) || action != InRow*InCol/BYTEINCOLS) ! 588: anerror ("Error writing to file", 0); ! 589: ! 590: /* close file */ ! 591: if (DOSCLOSE (handle)) ! 592: anerror ("Error closing file", 0); ! 593: } ! 594: ! 595: ! 596: /*** up - speeds up GOs (decrement Slow) ! 597: */ ! 598: void ! 599: up() { ! 600: int i; ! 601: ! 602: if (Slow) ! 603: Slow--; ! 604: if (!Slow) { ! 605: /* if at top speed take out message */ ! 606: for(i=0; *(ComLine[i].Name) != 'U'; i++); ! 607: ComLine[i].Fun=0; ! 608: gputs (" ", COM_ROW, ComLine[i].Col, 0); ! 609: } ! 610: for (i=30000; i--;); /* short pause */ ! 611: } ! 612: ! 613: ! 614: /*** down - slows down GOs (increment Slow) ! 615: */ ! 616: void ! 617: down() { ! 618: int i; ! 619: ! 620: Slow++; ! 621: for (i=30000; i--;); /* short pause */ ! 622: if (Slow){ /* if at top speed, display UP */ ! 623: for(i=0; *(ComLine[i].Name) != 'U'; i++); ! 624: ComLine[i].Fun=up; ! 625: for (i=0; ComLine[i].Fun != 0; i++) /* print command line */ ! 626: gputs (ComLine[i].Name, COM_ROW, ComLine[i].Col, 0); ! 627: } ! 628: } ! 629: ! 630: ! 631: /*** beep - beep the speaker for bad commands ! 632: */ ! 633: void ! 634: beep () { ! 635: DOSBEEP (500, 50); ! 636: } ! 637: ! 638: ! 639: /*** showingrid - display internal grid on screen ! 640: * ! 641: * Clears the screen using the draw_grid routine and then ! 642: * puts the internal grid on the screen using fill() so as to ! 643: * not be resolution dependent. ! 644: * ! 645: * Entry: InGrid points to internal grid defined by InCol and InRow. ! 646: * ScrSeg points to the screen buffer. ! 647: * ScrRow and ScrCol describe the dimensions of the screen grid. ! 648: * Logo points to program logo that also clears the prompt line ! 649: * ! 650: * Exit: None ! 651: * ! 652: * Calls: fill(), putgen(), gputs(), draw_grid [assembler routine] ! 653: */ ! 654: void ! 655: showingrid () { ! 656: int x, y; /* cell coordinates for loop */ ! 657: char retcode; /* for VIOSCRLOCK */ ! 658: ! 659: /* prepare blank screen so we only have to fill in cells that are on */ ! 660: draw_grid (); /* draw blank grid on screen */ ! 661: /* print command line */ ! 662: for (x=0; ComLine[x].Fun != 0; x++) ! 663: gputs (ComLine[x].Name, COM_ROW, ComLine[x].Col, 0); ! 664: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 665: putgen (); ! 666: ! 667: /* loop through the screen sized area of the grid */ ! 668: VIOSCRLOCK (1, (char far *) &retcode, 0); /* get screen access */ ! 669: for (y=ScrRow; y--;) ! 670: for (x=ScrCol; x--;) ! 671: /* if the internal cell is on, turn on the screen one*/ ! 672: if (*(InGrid + (x + y*InCol)/BYTEINCOLS) & (0x80 >> (x&7))) ! 673: fill (x, y); ! 674: VIOSCRUNLOCK (0); ! 675: } ! 676: ! 677: ! 678: /*** getfilespec - get a file name from the user ! 679: * ! 680: * Prompts user for a file name for use with diskread() or diskwrite(). ! 681: * The last file name used is shown on the screen as a default ! 682: * and the user can hit enter (or left mouse button) to specify the ! 683: * default name. If any other key is pressed, this routine takes the ! 684: * input until an enter and returns in Filespec. If ESC is hit any time ! 685: * during typeing, the input will be aborted and the buffer cleared. ! 686: * ! 687: * Entry: Filespec points to default file name ! 688: * Logo points to program logo that also clears the prompt line ! 689: * ! 690: * Exit: Filespec points to new file name ! 691: * returns 0x1b if ESC was hit during entry, else 0 ! 692: * ! 693: * Calls: gputs(), putgen() ! 694: */ ! 695: int ! 696: getfilespec () { ! 697: int c=0; /* index for Filespec[] */ ! 698: struct KeyData kbd; /* return for KBD call */ ! 699: unsigned space=0x0020; /* space character for print */ ! 700: struct EventInfo event; /* return for mouse */ ! 701: int type=0; /* mouse reads w/no wait */ ! 702: ! 703: kbd.scan_code=0; ! 704: event.Mask=0; ! 705: /* put up default file name if one exists */ ! 706: if (Filespec[0]) { ! 707: gputs ("Type file name or enter for default: ", PROMPT_ROW, ! 708: PROMPT_COL,0); ! 709: gputs (Filespec, PROMPT_ROW, FILE_COL, 0); ! 710: /* wait for first key or button to see if they accept default */ ! 711: while (!kbd.scan_code && !(event.Mask & (2|4|8|16))) { ! 712: if (Mouse) ! 713: MOUREADEVENTQUE ((struct EventInfo far *) &event, ! 714: (unsigned far *) &type, Mouse); ! 715: KBDPEEK ((struct KeyData far *) &kbd, 0); ! 716: } ! 717: } ! 718: if (event.Mask & (8 | 16)) { /* if right button hit, same as ESC */ ! 719: kbd.char_code = 0x1b; ! 720: wait4release(); ! 721: } ! 722: if (event.Mask & (2 | 4)) { /* if left button hit, same as \r */ ! 723: wait4release(); ! 724: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 725: putgen(); ! 726: return (0); ! 727: } ! 728: if (kbd.char_code == 0x1b) { /* if ESC, return */ ! 729: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 730: putgen(); ! 731: return (0x1b); /* return escape */ ! 732: } ! 733: ! 734: gputs(Logo, PROMPT_ROW, PROMPT_COL, 0); ! 735: gputs("Type file name, followed by enter: ",PROMPT_ROW,PROMPT_COL,0); ! 736: ! 737: /* read chars and print them until \r */ ! 738: while (!(KBDCHARIN ((struct KeyData far *) &kbd, 0, 0)) && ! 739: kbd.char_code != '\r') { ! 740: if (kbd.char_code == '\b') { /* if backspace, backspace */ ! 741: if (c > 0) { /* prevent underflow*/ ! 742: Filespec[--c]=0; ! 743: /* erase backed-out character*/ ! 744: gputs (&space, PROMPT_ROW, FILE_COL+c,0); ! 745: } ! 746: else /* if overflow, yell */ ! 747: beep(); ! 748: } ! 749: else if (kbd.char_code == 0x1b) { /* if escape was hit */ ! 750: Filespec[0]=0; /* blank name */ ! 751: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 752: putgen(); ! 753: return (0x1b); /* return escape */ ! 754: } ! 755: else if (kbd.char_code <46 || kbd.char_code > 122) ! 756: beep(); /* if not char, beep */ ! 757: else ! 758: if (c < sizeof (Filespec)) { /* prevent overflow */ ! 759: Filespec[c]=kbd.char_code; /* add to string */ ! 760: Filespec[++c]=0; /* null terminal */ ! 761: } ! 762: else /* if overflow, yell */ ! 763: beep(); ! 764: ! 765: gputs (Filespec, PROMPT_ROW, FILE_COL, 0); /* print new name */ ! 766: } ! 767: /* return generation count to screen */ ! 768: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 769: putgen(); ! 770: return (0); ! 771: } ! 772: ! 773: ! 774: /*** putgen - puts the current generation counter on prompt line ! 775: * ! 776: * Entry: Generation = current generation number ! 777: * ! 778: * Exit: None ! 779: * ! 780: * Calls: gputs() ! 781: */ ! 782: void ! 783: putgen () ! 784: { ! 785: char num[8]; /* number string to print */ ! 786: int i, g; ! 787: ! 788: gputs ("Generation: ", PROMPT_ROW, PROMPT_COL,0);/* gen label*/ ! 789: ! 790: if (Generation == 0) ! 791: gputs ("0", PROMPT_ROW,GEN_COL,0);/*if special case need this*/ ! 792: else { /* not 0, do this: */ ! 793: for (g=Generation, i=sizeof(num)-1; i-- >= 0 && g; g/=10) ! 794: num[i]=(g%10)+'0'; /* convert int to string */ ! 795: num[sizeof(num)-1]= 0; /* zero terminated for gputs */ ! 796: gputs (&num[i+1], PROMPT_ROW, GEN_COL,0); /* print number */ ! 797: } ! 798: } ! 799: ! 800: ! 801: /*** fill - fill in a grid cell on the screen and internally ! 802: * ! 803: * fill (x, y) ! 804: * ! 805: * Entry: x = grid horizontal coordinate ! 806: * y = grid vertical coordinate ! 807: * ScrSeg = screen buffer segment ! 808: * VioScrLock is active ! 809: * InGrid points to internal grid defined by InCol and InRow ! 810: * ScrRow and ScrCol define limits of screen grid ! 811: * Currently, must use 79x25 grid drawn by draw_grid() ! 812: * Currently, screen must be in 640x200 b/w mode ! 813: * ! 814: * Exit: None ! 815: */ ! 816: void ! 817: fill (x, y) ! 818: int x,y; ! 819: { ! 820: char far *gridptr; ! 821: ! 822: /* only do if within screen grid limits */ ! 823: if (x < ScrCol && y < ScrRow) { ! 824: /* set gridptr to & in screen buff of cell to fill */ ! 825: (long) gridptr = ScrSeg*0x10000; /* fill in address */ ! 826: (unsigned) gridptr = (x*SizeScrCol/BIT)+(y*SizeScrRow/Cga*SCR_WID); ! 827: /* fill in screen cell */ ! 828: *(gridptr+OddPage)=0x7f; ! 829: *(gridptr+SCR_WID)=0x7f; ! 830: *(gridptr+OddPage+SCR_WID)=0x7f; ! 831: } ! 832: /* fill in internal cell*/ ! 833: /*InGrid= &internal grid of x,y*/ ! 834: gridptr = InGrid + x/BYTEINCOLS + y*InCol/BYTEINCOLS; ! 835: *gridptr = *gridptr | (0x80 >> (x & 7)); /* fill bit */ ! 836: } ! 837: ! 838: ! 839: /*** remove - clear a grid cell on the 79x45 grid screen and internally ! 840: * ! 841: * remove (x, y) ! 842: * ! 843: * Entry: x = grid horizontal coordinate ! 844: * y = grid vertical coordinate ! 845: * ScrSeg = screen buffer segment ! 846: * VioScrLock is active ! 847: * InGrid points to internal grid defined by InCol and InRow ! 848: * ScrRow and ScrCol define limits of screen grid ! 849: * Currently, must use 79x25 grid drawn by draw_grid() ! 850: * Currently, screen must be in 640x200 b/w mode ! 851: * ! 852: * Exit: None ! 853: */ ! 854: void ! 855: remove (x, y) ! 856: int x,y; ! 857: { ! 858: char far *gridptr; ! 859: ! 860: /* only do if within screen grid limits */ ! 861: if (x < ScrCol && y < ScrRow) { ! 862: /* set gridptr to & in screen buff of cell to fill */ ! 863: (long) gridptr = ScrSeg*0x10000; /* fill in address */ ! 864: (unsigned) gridptr = (x*SizeScrCol/BIT)+(y*SizeScrRow/Cga*SCR_WID); ! 865: /* fill in screen cell */ ! 866: *(gridptr+OddPage)=0x80; ! 867: *(gridptr+SCR_WID)=0x80; ! 868: *(gridptr+OddPage+SCR_WID)=0x80; ! 869: } ! 870: ! 871: /* remove internal cell*/ ! 872: /*InGrid= &internal grid of x,y*/ ! 873: gridptr = InGrid + x/BYTEINCOLS + y*InCol/BYTEINCOLS; ! 874: *gridptr = *gridptr & ~((0x80 >> (x & 7))); /* remove bit */ ! 875: } ! 876: ! 877: ! 878: /*** kbdreadeventque - simulates MouReadEventQue with the keyboard ! 879: * ! 880: * F9 key is responded to as left button, F10 key as right. ! 881: * Pointer location is advanced by SizeScrCol or SizeScrRow according ! 882: * to direction of direction key hits. ! 883: * Does not wait for input, instead returns 0 event mask. ! 884: * Does not check MouDevStatus, instead always returns pixel coordinates ! 885: * Event buffer is filled according to MouReadEventQue ! 886: * ! 887: * Entry: event - structure to return data ! 888: * ptrrow - current point row ! 889: * ptrcol - current pointer column ! 890: * ! 891: * Exit: None ! 892: * *event contains any event that may have occurred ! 893: */ ! 894: int ! 895: kbdreadeventque (event, ptrrow, ptrcol) ! 896: struct EventInfo *event; ! 897: int ptrrow, ptrcol; ! 898: { ! 899: struct KeyData kbd; /* return for KBD call */ ! 900: ! 901: kbd.char_code=0; /* clear data struct residue*/ ! 902: kbd.scan_code=0; ! 903: /* peek at key buffer */ ! 904: KBDPEEK ((struct KeyData far *) &kbd, 0); ! 905: ! 906: /* if it is an extended key code, process it */ ! 907: if (kbd.char_code == 0 && kbd.scan_code) { ! 908: KBDCHARIN ((struct KeyData far *) &kbd, 1, 0); /* take char */ ! 909: event->Row=ptrrow; /* initial position */ ! 910: event->Col=ptrcol; ! 911: switch (kbd.scan_code) { /* check second byte of code */ ! 912: case 0x48: /* cursor up */ ! 913: event->Row -= SizeScrRow; ! 914: event->Mask=1; ! 915: break; ! 916: case 0x50: /* cursor down */ ! 917: event->Row += SizeScrRow; ! 918: event->Mask=1; ! 919: break; ! 920: case 0x4b: /* cursor left */ ! 921: event->Col -= SizeScrCol; ! 922: event->Mask=1; ! 923: break; ! 924: case 0x4d: /* cursor right */ ! 925: event->Col += SizeScrCol; ! 926: event->Mask=1; ! 927: break; ! 928: case 0x43: /* left button (F9) */ ! 929: event->Mask=4; ! 930: break; ! 931: case 0x52: /* left button (INS) */ ! 932: event->Mask=4; ! 933: break; ! 934: case 0x44: /* right button (F10) */ ! 935: event->Mask=16; ! 936: break; ! 937: case 0x53: /* right button (DEL) */ ! 938: event->Mask=16; ! 939: break; ! 940: default: /* anything else is no good */ ! 941: event->Mask=0; ! 942: break; ! 943: } ! 944: } ! 945: else ! 946: event->Mask=0; /* if no extended key */ ! 947: } ! 948: ! 949: ! 950: /*** xorptr - xors the mouse ptr on the screen ! 951: * ! 952: * xorptr (ptrrow, ptrcol) ! 953: * ! 954: * Entry: ptrrow = pixel row on screen ! 955: * ptrcol = pixel column on screen ! 956: * ScrSeg = screen buffer segment ! 957: * ! 958: * Exit: None ! 959: */ ! 960: void ! 961: xorptr (ptrrow, ptrcol) ! 962: unsigned ptrrow, ptrcol; ! 963: { ! 964: char far *gridptr; ! 965: unsigned mask=0; /* bit mask for pointer shape*/ ! 966: int x=8; /* count for rows of pointer */ ! 967: char retcode; /* return from VioScrLock */ ! 968: ! 969: /* set gridptr to & in screen buff to xor */ ! 970: ptrrow++; /* 1st move ptr to next row*/ ! 971: (long) gridptr = ScrSeg*0x10000; /* fill in segment address */ ! 972: (unsigned) gridptr = ptrcol/x+(ptrrow/Cga*SCR_WID);/* fill offset*/ ! 973: ! 974: /* fill in screen pointer */ ! 975: VIOSCRLOCK (1, (char far *) &retcode, 0); /* get screen */ ! 976: while (x--) { ! 977: mask = mask >> 1; /* make mask thicker */ ! 978: mask |= 0x8000; /* at bottom */ ! 979: if (ptrrow & 1 && Cga == 2) /* if odd bit plane */ ! 980: gridptr += OddPage; ! 981: /* xor mask to scr, being sure to reverse bytes in word */ ! 982: *(gridptr+1) ^= (char) (mask >> (ptrcol & 7)); ! 983: *(gridptr) ^= (char) ((mask >> (ptrcol & 7)) / 256); ! 984: if (ptrrow & 1 && Cga == 2) /* if odd bit plane */ ! 985: gridptr -= OddPage; /* plane, next row*/ ! 986: ptrrow++; /* next row */ ! 987: if (!(ptrrow & 1) && Cga == 2) /*only advance on odd*/ ! 988: gridptr += SCR_WID; /* row w/o CGA */ ! 989: } ! 990: VIOSCRUNLOCK (0); /* give back screen */ ! 991: } ! 992: ! 993: ! 994: /*** gputs - put a character string on the graphics screen ! 995: * ! 996: * gputs (string, row, col) ! 997: * ! 998: * Draws the passed asciiz string on the screen unless the screen ! 999: * is not available (i.e., if running in background screen group) ! 1000: * in which case this routine does nothing so as to not hold up ! 1001: * the program. ! 1002: * ! 1003: * Entry: string - address of asciiz string to print ! 1004: * row - alpha row to print at ! 1005: * col - alpha col to print at ! 1006: * mask - xor'ed with bytes of character as printed ! 1007: * ! 1008: * Exit: None ! 1009: * ! 1010: * Calls: gputchar() ! 1011: * ! 1012: * Warning: Prints graphics characters for ascii control codes (<32). ! 1013: * Does not wrap-around at line end. ! 1014: */ ! 1015: void ! 1016: gputs (string, row, col, mask) ! 1017: char *string; ! 1018: unsigned col, row; ! 1019: char mask; ! 1020: { ! 1021: static struct VIOFONT fontdata = {14,1,FONT_ROW,8,0L,0};/*for GetFont*/ ! 1022: char c; ! 1023: char retcode; /* for VIOSCRLOCK */ ! 1024: char far *scr_addr; /* address in screen buffer ! 1025: to print at */ ! 1026: ! 1027: /* try lock without waiting for availability */ ! 1028: VIOSCRLOCK (0, (char far *) &retcode, 0); /* get screen access */ ! 1029: ! 1030: /* do display only if screen available now */ ! 1031: if (retcode == 0) { ! 1032: /* get address of font table if haven't yet */ ! 1033: if (!fontdata.font_data) ! 1034: VIOGETFONT ((struct VIOFONT far *) &fontdata, 0); ! 1035: ! 1036: (long) scr_addr = ScrSeg*0x10000; /* fill in segment address*/ ! 1037: (unsigned)scr_addr = col+(row*SCR_WID*(FONT_ROW/Cga));/*offset*/ ! 1038: while ((c=*(string++)) != 0) /* print each char */ ! 1039: gputchar(scr_addr++, fontdata.font_data+c*FONT_ROW,mask); ! 1040: VIOSCRUNLOCK (0); /* give up screen */ ! 1041: } ! 1042: } ! 1043: ! 1044: ! 1045: /*** gputchar - put a character on the graphics screen ! 1046: * ! 1047: * gputchar (scr_addr, font_addr, mask) ! 1048: * ! 1049: * Entry: scr_addr - far address in screen buffer to place character ! 1050: * must be on even Cga bit plane ! 1051: * font_addr - far address in font table bit pattern ! 1052: * mask - xor'ed with each byte put on screen ! 1053: * VIOSCRLOCK is active ! 1054: * ! 1055: * Exit: None ! 1056: */ ! 1057: void ! 1058: gputchar(scr_addr, font_addr, mask) ! 1059: char far *scr_addr; ! 1060: char far *font_addr; ! 1061: char mask; ! 1062: { ! 1063: int i=FONT_ROW; /* count to draw whole character */ ! 1064: ! 1065: while (i--) { ! 1066: if (i & 1 && Cga == 2) /* if odd bit plane */ ! 1067: scr_addr += OddPage-SCR_WID; ! 1068: *scr_addr = (*(font_addr++) ^ mask);/* put byte on even plane*/ ! 1069: if (i & 1 && Cga == 2) /* if odd bit plane */ ! 1070: scr_addr -= OddPage; ! 1071: scr_addr+=SCR_WID; /* move down a line */ ! 1072: } ! 1073: } ! 1074: ! 1075: ! 1076: /*** anerror - error handler ! 1077: * ! 1078: * anerror (message, fatal); ! 1079: * ! 1080: * Prints passed error message and waits for a key hit to allow ! 1081: * user to read it. If fatal flag is 0, the routine then returns, ! 1082: * otherwise the routine restores the original screen mode, clears ! 1083: * the screen, and exits. ! 1084: * ! 1085: * Entry: message - string to print describing error ! 1086: * fatal - flag, if == 0, this procedure prompts for any key hit ! 1087: * then returns. If != 0, error is fatal & program exits. ! 1088: * Logo points to program logo that also clears the prompt line ! 1089: * ! 1090: * Exit: None ! 1091: * ! 1092: * Calls: gputs(), putgen() ! 1093: */ ! 1094: void ! 1095: anerror (message, fatal) ! 1096: char message[]; ! 1097: int fatal; ! 1098: { ! 1099: struct KeyData kbd; /* return for KBD call */ ! 1100: ! 1101: gputs (Logo, PROMPT_ROW, PROMPT_COL,0); ! 1102: gputs (message, PROMPT_ROW, PROMPT_COL, 0);/* print passed message */ ! 1103: ! 1104: if (fatal) { ! 1105: gputs(": Press any key to exit",PROMPT_ROW,strlen(message),0); ! 1106: gethit (); ! 1107: exitlife(); ! 1108: } ! 1109: else { ! 1110: gputs (": Press any key to continue",PROMPT_ROW, ! 1111: strlen(message), 0); ! 1112: gethit (); ! 1113: gputs (Logo, PROMPT_ROW, PROMPT_COL, 0); ! 1114: putgen(); ! 1115: } ! 1116: } ! 1117: ! 1118: ! 1119: /*** gethit - waits for a key hit or mouse button hit ! 1120: * ! 1121: * Entry: None ! 1122: * ! 1123: * Exit: Returns character hit (forced upper case) or 'Y' for left ! 1124: * mouse button and 'N' for right mouse ! 1125: */ ! 1126: char ! 1127: gethit () { ! 1128: struct KeyData kbd; /* for keyboard */ ! 1129: struct EventInfo event; /* for mouse */ ! 1130: int type=0; ! 1131: char rc; /* return code */ ! 1132: ! 1133: /* loop till a hit */ ! 1134: kbd.scan_code=0; ! 1135: event.Mask=0; ! 1136: while (!kbd.scan_code && !(event.Mask & (2|4|8|16))) { ! 1137: if (Mouse) ! 1138: MOUREADEVENTQUE ((struct EventInfo far *) &event, ! 1139: (unsigned far *) &type, Mouse); ! 1140: KBDCHARIN ((struct KeyData far *) &kbd, 1, 0); ! 1141: } ! 1142: if (kbd.scan_code) /* if key, return char */ ! 1143: rc=kbd.char_code & 0xdf; ! 1144: else if (event.Mask & (8 | 16)) { /* if right */ ! 1145: rc='N'; ! 1146: wait4release (); ! 1147: } ! 1148: else if (event.Mask & (2 | 4)) { /* if left down*/ ! 1149: rc='Y'; ! 1150: wait4release (); ! 1151: } ! 1152: return (rc); ! 1153: } ! 1154: ! 1155: ! 1156: /*** wait4release - wait until mouse buttons are up before returning ! 1157: * ! 1158: * Entry: Mouse = mouse handle or 0 if no mouse ! 1159: */ ! 1160: void ! 1161: wait4release () { ! 1162: struct EventInfo event; ! 1163: unsigned type = 0; /* if OS/2, wait for events */ ! 1164: ! 1165: event.Mask=2; /* force 1st read */ ! 1166: if (Mouse) /* loop till no button events */ ! 1167: while ((event.Mask & (2|4|8|16)) || event.Time==0) ! 1168: MOUREADEVENTQUE ((struct EventInfo far *) &event, ! 1169: (unsigned far *) &type, Mouse); ! 1170: } ! 1171: ! 1172: ! 1173: /*** exitlife - exit program, resetting original screen mode ! 1174: * ! 1175: * Called by a Ctrl-C ! 1176: * ! 1177: * Entry: Savemode contains original screen mode info ! 1178: * ! 1179: * Exit: None ! 1180: */ ! 1181: void far pascal ! 1182: exitlife() { ! 1183: VIOSETMODE ((struct ModeData far *) &Savemode, 0); /* restore*/ ! 1184: VIOSCROLLUP (0,0,-1,-1,-1, (char far *) Cell,0); /* cls */ ! 1185: DOSEXIT (1, 0); /* exit all threads */ ! 1186: } ! 1187:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.