Annotation of src/corr7men.c, revision 1.1.1.1

1.1       root        1: /***************************************************************************
                      2:  *   CORR7MEN.C - Game menu related functions for Corridor 7
                      3:  *
                      4:  *                                                     04/17/96  Les Bird
                      5:  ***************************************************************************/
                      6: 
                      7: #include "icorp.h"
                      8: #include "keycodes.h"
                      9: #include <ctype.h>
                     10: #include <memcheck.h>
                     11: 
                     12: #define   MAXMENUCHOICES 24
                     13: #define   FRAMETILE      4094
                     14: 
                     15: char scantoasc[128]={
                     16:        0,  0,'1','2','3','4','5','6','7','8','9','0','-','=',  0,  0,
                     17:      'q','w','e','r','t','y','u','i','o','p','[',']',  0,  0,'a','s',
                     18:      'd','f','g','h','j','k','l',';', 39,'`',  0, 92,'z','x','c','v',
                     19:      'b','n','m',',','.','/',  0,'*',  0, 32,  0,  0,  0,  0,  0,  0,
                     20:        0,  0,  0,  0,  0,  0,  0,'7','8','9','-','4','5','6','+','1',
                     21:      '2','3','0','.',  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
                     22:        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
                     23:        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
                     24: };
                     25: 
                     26: char scantoascwithshift[128]={
                     27:        0,  0,'!','@','#','$','%','^','&','*','(',')','_','+',  0,  0,
                     28:      'Q','W','E','R','T','Y','U','I','O','P','{','}',  0,  0,'A','S',
                     29:      'D','F','G','H','J','K','L',':', 34,'~',  0,'|','Z','X','C','V',
                     30:      'B','N','M','<','>','?',  0,'*',  0, 32,  0,  0,  0,  0,  0,  0,
                     31:        0,  0,  0,  0,  0,  0,  0,'7','8','9','-','4','5','6','+','1',
                     32:      '2','3','0','.',  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
                     33:        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
                     34:        0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
                     35: };
                     36: 
                     37: enum {
                     38:      FONT_SMALLFONT,
                     39:      FONT_BIGFONT,
                     40:      FONT_NORMALTEXT,
                     41:      FONT_SMALLTEXT,
                     42:      NUMFONTS
                     43: };
                     44: 
                     45: int  configSoundFlag,
                     46:      inMenuFlag,
                     47:      minline,
                     48:      saveScreenShotFlag,
                     49:      updateStep;
                     50: 
                     51: long fontScale[NUMFONTS]={49152L,65536L,32768L},
                     52:      fontXSize[NUMFONTS]={8L,13L,8L},
                     53:      fontYSize[NUMFONTS]={12L,16L,8L};
                     54: 
                     55: enum {
                     56:      MENUOPTION_NONE,
                     57:      MENUOPTION_BOOLEAN,
                     58:      MENUOPTION_SLIDER,
                     59:      MENUOPTION_BULLET,
                     60:      MENUOPTION_GRAPHIC,
                     61:      MENUOPTION_LEFTJUST,
                     62:      MENUOPTION_RIGHTJUST
                     63: };
                     64: 
                     65: struct menuOption {
                     66:      char active;
                     67:      short type;
                     68:      char *label;
                     69:      long misc1;
                     70:      long misc2;
                     71:      short column;
                     72:      short line;
                     73:      short font;
                     74: };
                     75: 
                     76: unsigned long menuActiveBits;
                     77: 
                     78: int  *menuCur,
                     79:      menuNum,
                     80:      menuOpt;
                     81: 
                     82: struct menuOption *menuArr[32];
                     83: 
                     84: enum {
                     85:      MMENU_NEWMISSION,
                     86:      MMENU_OPTIONS,
                     87:      MMENU_RETRIEVE,
                     88:      MMENU_STORE,
                     89:      MMENU_CREDITS,
                     90:      MMENU_DEMO,
                     91:      MMENU_ORDER,
                     92:      MMENU_QUIT,
                     93:      NUMMENUOPTIONS
                     94: };
                     95: 
                     96: int  curMenu;
                     97: 
                     98: struct menuOption menuNamesArr[NUMMENUOPTIONS]={
                     99:      {1,MENUOPTION_NONE,"NEW MISSION",0,0,0,0,FONT_BIGFONT},
                    100:      {1,MENUOPTION_NONE,"OPTIONS",0,0,0,0,FONT_BIGFONT},
                    101:      {1,MENUOPTION_NONE,"RETRIEVE MISSION",0,0,0,0,FONT_BIGFONT},
                    102:      {0,MENUOPTION_NONE,"STORE MISSION",0,0,0,0,FONT_BIGFONT},
                    103:      {1,MENUOPTION_NONE,"CREDITS",0,0,0,0,FONT_BIGFONT},
                    104:      {1,MENUOPTION_NONE,"BACK TO DEMO",0,0,0,0,FONT_BIGFONT},
                    105:      {1,MENUOPTION_NONE,"HOW TO ORDER",0,0,0,0,FONT_BIGFONT},
                    106:      {1,MENUOPTION_NONE,"QUIT",0,0,0,0,FONT_BIGFONT}
                    107: },*menuNames[NUMMENUOPTIONS];
                    108: 
                    109: struct menuOption menu2NamesArr[NUMMENUOPTIONS]={
                    110:      {1,MENUOPTION_NONE,"NEW MISSION",0,0,0,0,FONT_BIGFONT},
                    111:      {1,MENUOPTION_NONE,"OPTIONS",0,0,0,0,FONT_BIGFONT},
                    112:      {1,MENUOPTION_NONE,"RETRIEVE MISSION",0,0,0,0,FONT_BIGFONT},
                    113:      {1,MENUOPTION_NONE,"STORE MISSION",0,0,0,0,FONT_BIGFONT},
                    114:      {0,MENUOPTION_NONE,"CREDITS",0,0,0,0,FONT_BIGFONT},
                    115:      {1,MENUOPTION_NONE,"RESUME MISSION",0,0,0,0,FONT_BIGFONT},
                    116:      {0,MENUOPTION_NONE,"HOW TO ORDER",0,0,0,0,FONT_BIGFONT},
                    117:      {1,MENUOPTION_NONE,"QUIT",0,0,0,0,FONT_BIGFONT}
                    118: },*menu2Names[NUMMENUOPTIONS];
                    119: 
                    120: enum {
                    121:      EMENU_MISSION1,
                    122:      EMENU_MISSION2,
                    123:      EMENU_MISSION3,
                    124:      NUMMISSIONS
                    125: };
                    126: 
                    127: int  curMission;
                    128: 
                    129: struct menuOption missionNamesArr[NUMMISSIONS]={
                    130:      {1,MENUOPTION_NONE,"MISSION 1",0,0,0,0,FONT_BIGFONT},
                    131:      {1,MENUOPTION_NONE,"MISSION 2",0,0,0,0,FONT_BIGFONT},
                    132:      {1,MENUOPTION_NONE,"MISSION 3",0,0,0,0,FONT_BIGFONT}
                    133: },*missionNames[NUMMISSIONS];
                    134: 
                    135: int  curSkill=1;
                    136: 
                    137: struct menuOption skillNamesArr[NUMSKILLS]={
                    138:      {1,MENUOPTION_NONE,"CORPORAL",0,0,0,0,FONT_BIGFONT},
                    139:      {1,MENUOPTION_NONE,"LIEUTENANT",0,0,0,0,FONT_BIGFONT},
                    140:      {1,MENUOPTION_NONE,"CAPTAIN",0,0,0,0,FONT_BIGFONT},
                    141:      {1,MENUOPTION_NONE,"MAJOR",0,0,0,0,FONT_BIGFONT},
                    142:      {1,MENUOPTION_NONE,"PRESIDENT",0,0,0,0,FONT_BIGFONT}
                    143: },*skillNames[NUMSKILLS];
                    144: 
                    145: int  curActor;
                    146: 
                    147: enum {
                    148:      AMENU_ALLIEDSPACEMARINE,
                    149:      AMENU_ALLIEDFEMALEMARINE,
                    150:      NUMACTORS
                    151: };
                    152: 
                    153: struct menuOption alliedActorNamesArr[NUMACTORS]={
                    154:      {1,MENUOPTION_GRAPHIC,"SPACE MARINE",0,0,0,0,FONT_BIGFONT},
                    155:      {1,MENUOPTION_GRAPHIC,"FEMALE MARINE",0,0,0,0,FONT_BIGFONT}
                    156: },*alliedActorNames[NUMACTORS];
                    157: 
                    158: enum {
                    159:      AMENU_AXISSPACEMARINE,
                    160:      AMENU_AXISFEMALEMARINE,
                    161: };
                    162: 
                    163: struct menuOption axisActorNamesArr[NUMACTORS]={
                    164:      {1,MENUOPTION_GRAPHIC,"SPACE MARINE",0,0,0,0,FONT_BIGFONT},
                    165:      {1,MENUOPTION_GRAPHIC,"FEMALE MARINE",0,0,0,0,FONT_BIGFONT}
                    166: },*axisActorNames[NUMACTORS];
                    167: 
                    168: int  curAlliance;
                    169: 
                    170: enum {
                    171:      AMENU_ALLIED,
                    172:      AMENU_AXIS,
                    173:      NUMALLIANCES
                    174: };
                    175: 
                    176: struct menuOption allianceNamesArr[NUMALLIANCES]={
                    177:      {1,MENUOPTION_NONE,"ALLIED SIDE",0,0,0,0,FONT_BIGFONT},
                    178:      {1,MENUOPTION_NONE,"AXIS SIDE",0,0,0,0,FONT_BIGFONT}
                    179: },*allianceNames[NUMALLIANCES];
                    180: 
                    181: enum {
                    182:      OMENU_GRAPHICS,
                    183:      OMENU_SOUND,
                    184:      OMENU_CONTROLLER,
                    185:      OMENU_EXIT,
                    186:      NUMOPTIONS
                    187: };
                    188: 
                    189: int  curOption;
                    190: 
                    191: struct menuOption optionNamesArr[NUMOPTIONS]={
                    192:      {1,MENUOPTION_NONE,"GRAPHICS OPTIONS",0,0,0,0,FONT_BIGFONT},
                    193:      {1,MENUOPTION_NONE,"SOUND OPTIONS",0,0,0,0,FONT_BIGFONT},
                    194:      {1,MENUOPTION_NONE,"CONTROLLER OPTIONS",0,0,0,0,FONT_BIGFONT},
                    195:      {1,MENUOPTION_NONE,"PREVIOUS MENU",0,0,0,0,FONT_BIGFONT}
                    196: },*optionNames[NUMOPTIONS];
                    197: 
                    198: #define   NUMSAVESPOTS        10
                    199: #define   MAXSAVENAMESIZE     17
                    200: 
                    201: int  curSaveSpot;
                    202: 
                    203: struct menuOption saveGameNamesArr[NUMSAVESPOTS],
                    204:      *saveNames[NUMSAVESPOTS];
                    205: 
                    206: char saveGameName[NUMSAVESPOTS][MAXSAVENAMESIZE];
                    207: 
                    208: enum {
                    209:      GMENU_GORELEVEL,
                    210:      GMENU_AUTOHORIZON,
                    211:      GMENU_AUTOAIM,
                    212:      GMENU_DETAILLEVEL,
                    213:      GMENU_EXIT,
                    214:      NUMGRAPHICOPTIONS
                    215: };
                    216: 
                    217: int  curGraphics;
                    218: 
                    219: struct menuOption graphicNamesArr[NUMGRAPHICOPTIONS]={
                    220:      {1,MENUOPTION_SLIDER,"GORE LEVEL",0,0,0,0,FONT_BIGFONT},
                    221:      {1,MENUOPTION_BOOLEAN,"AUTO HORIZON",0,0,0,0,FONT_BIGFONT},
                    222:      {1,MENUOPTION_BOOLEAN,"AUTO AIM",0,0,0,0,FONT_BIGFONT},
                    223:      {1,MENUOPTION_SLIDER,"DETAIL LEVEL",0,0,0,0,FONT_BIGFONT},
                    224:      {1,MENUOPTION_LEFTJUST,"PREVIOUS MENU",0,0,0,0,FONT_BIGFONT}
                    225: },*graphicNames[NUMGRAPHICOPTIONS];
                    226: 
                    227: enum {
                    228:      SMENU_SOUNDVOL,
                    229:      SMENU_MUSICVOL,
                    230:      SMENU_STEREO,
                    231:      SMENU_EXIT,
                    232:      NUMSOUNDOPTIONS
                    233: };
                    234: 
                    235: int  curSound;
                    236: 
                    237: struct menuOption soundNamesArr[NUMSOUNDOPTIONS]={
                    238:      {1,MENUOPTION_SLIDER,"DIGITAL VOLUME",0,0,0,0,FONT_BIGFONT},
                    239:      {1,MENUOPTION_SLIDER,"MUSIC VOLUME",0,0,0,0,FONT_BIGFONT},
                    240:      {1,MENUOPTION_BOOLEAN,"REVERSE STEREO",0,0,0,0,FONT_BIGFONT},
                    241:      {1,MENUOPTION_LEFTJUST,"PREVIOUS MENU",0,0,0,0,FONT_BIGFONT}
                    242: },*soundNames[NUMSOUNDOPTIONS];
                    243: 
                    244: enum {
                    245:      CMENU_KEYBOARD,
                    246:      CMENU_MOUSE,
                    247:      CMENU_JOYSTICKS,
                    248:      CMENU_VRHEADSETS,
                    249:      CMENU_EXIT,
                    250:      NUMCONTROLLEROPTIONS
                    251: };
                    252: 
                    253: int  curController;
                    254: 
                    255: struct menuOption controllerNamesArr[NUMCONTROLLEROPTIONS]={
                    256:      {1,MENUOPTION_LEFTJUST,"KEYBOARD",0,0,0,0,FONT_BIGFONT},
                    257:      {1,MENUOPTION_LEFTJUST,"MOUSE",0,0,0,0,FONT_BIGFONT},
                    258:      {1,MENUOPTION_LEFTJUST,"JOYSTICKS",0,0,0,0,FONT_BIGFONT},
                    259:      {1,MENUOPTION_LEFTJUST,"VR HEADSETS",0,0,0,0,FONT_BIGFONT},
                    260:      {1,MENUOPTION_LEFTJUST,"PREVIOUS MENU",0,0,0,0,FONT_BIGFONT}
                    261: },*controllerNames[NUMCONTROLLEROPTIONS];
                    262: 
                    263: char actionName[MAXACTIONS][30];
                    264: 
                    265: int  curKeyboard;
                    266: 
                    267: struct menuOption keyboardNamesArr[MAXACTIONS]={
                    268:      {1,MENUOPTION_NONE,&actionName[ACT_FORWARD],0,0,0,0,FONT_NORMALTEXT},
                    269:      {1,MENUOPTION_NONE,&actionName[ACT_BACKWARD],0,0,0,0,FONT_NORMALTEXT},
                    270:      {1,MENUOPTION_NONE,&actionName[ACT_LEFT],0,0,0,0,FONT_NORMALTEXT},
                    271:      {1,MENUOPTION_NONE,&actionName[ACT_RIGHT],0,0,0,0,FONT_NORMALTEXT},
                    272:      {1,MENUOPTION_NONE,&actionName[ACT_RUN],0,0,0,0,FONT_NORMALTEXT},
                    273:      {1,MENUOPTION_NONE,&actionName[ACT_STRAFE],0,0,0,0,FONT_NORMALTEXT},
                    274:      {1,MENUOPTION_NONE,&actionName[ACT_USEWEAP],0,0,0,0,FONT_NORMALTEXT},
                    275:      {1,MENUOPTION_NONE,&actionName[ACT_USEITEM],0,0,0,0,FONT_NORMALTEXT},
                    276:      {1,MENUOPTION_NONE,&actionName[ACT_JUMP],0,0,0,0,FONT_NORMALTEXT},
                    277:      {1,MENUOPTION_NONE,&actionName[ACT_CROUCH],0,0,0,0,FONT_NORMALTEXT},
                    278:      {1,MENUOPTION_NONE,&actionName[ACT_LOOKUP],0,0,0,0,FONT_NORMALTEXT},
                    279:      {1,MENUOPTION_NONE,&actionName[ACT_LOOKDN],0,0,0,0,FONT_NORMALTEXT},
                    280:      {1,MENUOPTION_NONE,&actionName[ACT_CENTER],0,0,0,0,FONT_NORMALTEXT},
                    281:      {1,MENUOPTION_NONE,&actionName[ACT_STRAFEL],0,0,0,0,FONT_NORMALTEXT},
                    282:      {1,MENUOPTION_NONE,&actionName[ACT_STRAFER],0,0,0,0,FONT_NORMALTEXT},
                    283:      {1,MENUOPTION_NONE,&actionName[ACT_MAP],0,0,0,0,FONT_NORMALTEXT},
                    284:      {1,MENUOPTION_NONE,&actionName[ACT_ZOOMIN],0,0,0,0,FONT_NORMALTEXT},
                    285:      {1,MENUOPTION_NONE,&actionName[ACT_ZOOMOUT],0,0,0,0,FONT_NORMALTEXT}
                    286: },*keyboardNames[MAXACTIONS];
                    287: 
                    288: enum {
                    289:      MMENU_ENABLE,
                    290:      MMENU_CONFIGURE,
                    291:      MMENU_MOUSEXSENSE,
                    292:      MMENU_MOUSEYSENSE,
                    293:      MMENU_EXIT,
                    294:      NUMMOUSEOPTIONS
                    295: };
                    296: 
                    297: int  curMouse,
                    298:      curMouseOptions;
                    299: 
                    300: struct menuOption mouseNamesArr[NUMMOUSEOPTIONS]={
                    301:      {1,MENUOPTION_BOOLEAN,"MOUSE ENABLED",0,0,0,0,FONT_BIGFONT},
                    302:      {1,MENUOPTION_LEFTJUST,"CONFIGURE MOUSE",0,0,0,0,FONT_BIGFONT},
                    303:      {1,MENUOPTION_SLIDER,"MOUSE X SENSITIVITY",0,0,0,0,FONT_BIGFONT},
                    304:      {1,MENUOPTION_SLIDER,"MOUSE Y SENSITIVITY",0,0,0,0,FONT_BIGFONT},
                    305:      {1,MENUOPTION_LEFTJUST,"PREVIOUS MENU",0,0,0,0,FONT_BIGFONT}
                    306: },*mouseNames[NUMMOUSEOPTIONS];
                    307: 
                    308: #if 0
                    309: char soundCardName[9][30];
                    310: 
                    311: int  autoDetectFlag,
                    312:      curDMA,
                    313:      curIRQ,
                    314:      curPort,
                    315:      curSoundCard,
                    316:      firstSoundCard,
                    317:      lastSoundCard;
                    318: 
                    319: struct menuOption soundCardArr[9]={
                    320:      {0,MENUOPTION_NONE,&soundCardName[0],0,0,0,0,FONT_SMALLFONT},
                    321:      {0,MENUOPTION_NONE,&soundCardName[1],0,0,0,0,FONT_SMALLFONT},
                    322:      {0,MENUOPTION_NONE,&soundCardName[2],0,0,0,0,FONT_SMALLFONT},
                    323:      {0,MENUOPTION_NONE,&soundCardName[3],0,0,0,0,FONT_SMALLFONT},
                    324:      {0,MENUOPTION_NONE,&soundCardName[4],0,0,0,0,FONT_SMALLFONT},
                    325:      {0,MENUOPTION_NONE,&soundCardName[5],0,0,0,0,FONT_SMALLFONT},
                    326:      {0,MENUOPTION_NONE,&soundCardName[6],0,0,0,0,FONT_SMALLFONT},
                    327:      {0,MENUOPTION_NONE,&soundCardName[7],0,0,0,0,FONT_SMALLFONT},
                    328:      {0,MENUOPTION_NONE,&soundCardName[8],0,0,0,0,FONT_SMALLFONT}
                    329: },*soundCardNames[9];
                    330: #endif
                    331: 
                    332: int  curWeaponEdit;
                    333: 
                    334: #if 0
                    335: extern
                    336: char *sDIGIDeviceName[];
                    337: 
                    338: extern
                    339: W32  wDIGIDeviceID,
                    340:      wMIDIDeviceID,
                    341:      wDIGIIndex,
                    342:      wMIDIIndex;
                    343: 
                    344: extern
                    345: W16  wDIGIPortList[_SETUP_MAX_DEVICES],
                    346:      wDIGIIRQList[_SETUP_MAX_DEVICES],
                    347:      wDIGIDMAList[_SETUP_MAX_DEVICES];
                    348: #endif
                    349: 
                    350: extern
                    351: int  stereoSwapFlag;
                    352: 
                    353: #if 0
                    354: extern
                    355: _SOS_CAPABILITIES sDIGICapabilities;
                    356: #endif
                    357: 
                    358: extern
                    359: _SOS_DIGI_DRIVER sDIGIDriver;
                    360: 
                    361: void
                    362: MEN_stripTrailingBlanks(char *stg)
                    363: {
                    364:      int  j,len;
                    365: 
                    366:      len=strlen(stg);
                    367:      if (len > 0) {
                    368:           j=len-1;
                    369:           while (stg[j] == ' ' && j > 0) {
                    370:                stg[j]=0;
                    371:                j--;
                    372:           }
                    373:           strupr(stg);
                    374:      }
                    375: }
                    376: 
                    377: void
                    378: MEN_initMenus(void)
                    379: {
                    380:      int  i;
                    381: 
                    382:      for (i=0 ; i < NUMMENUOPTIONS ; i++) {
                    383:           menuNames[i]=&menuNamesArr[i];
                    384:           menu2Names[i]=&menu2NamesArr[i];
                    385:      }
                    386:      for (i=0 ; i < NUMALLIANCES ; i++) {
                    387:           allianceNames[i]=&allianceNamesArr[i];
                    388:      }
                    389:      for (i=0 ; i < NUMMISSIONS ; i++) {
                    390:           missionNames[i]=&missionNamesArr[i];
                    391:      }
                    392:      for (i=0 ; i < NUMSKILLS ; i++) {
                    393:           skillNames[i]=&skillNamesArr[i];
                    394:      }
                    395:      for (i=0 ; i < NUMACTORS ; i++) {
                    396:           alliedActorNames[i]=&alliedActorNamesArr[i];
                    397:           axisActorNames[i]=&axisActorNamesArr[i];
                    398:      }
                    399:      for (i=0 ; i < NUMOPTIONS ; i++) {
                    400:           optionNames[i]=&optionNamesArr[i];
                    401:      }
                    402:      for (i=0 ; i < NUMGRAPHICOPTIONS ; i++) {
                    403:           graphicNames[i]=&graphicNamesArr[i];
                    404:      }
                    405:      for (i=0 ; i < NUMCONTROLLEROPTIONS ; i++) {
                    406:           controllerNames[i]=&controllerNamesArr[i];
                    407:      }
                    408:      for (i=0 ; i < MAXACTIONS ; i++) {
                    409:           keyboardNames[i]=&keyboardNamesArr[i];
                    410:      }
                    411:      for (i=0 ; i < NUMMOUSEOPTIONS ; i++) {
                    412:           mouseNames[i]=&mouseNamesArr[i];
                    413:      }
                    414:      for (i=0 ; i < NUMSOUNDOPTIONS ; i++) {
                    415:           soundNames[i]=&soundNamesArr[i];
                    416:      }
                    417: #if 0
                    418:      for (i=0 ; i < 9 ; i++) {
                    419:           soundCardNames[i]=&soundCardArr[i];
                    420:      }
                    421: #endif
                    422: }
                    423: 
                    424: void
                    425: MEN_printext(long x,long y,int shade,char *stg,int font)
                    426: {
                    427:      int  i,len,pic;
                    428: 
                    429:      if (font == FONT_NORMALTEXT || font == FONT_SMALLTEXT) {
                    430:           if (shade != -1) {
                    431:                shade=-1;
                    432:           }
                    433:           else {
                    434:                shade=0;
                    435:           }
                    436:           switch (font) {
                    437:           case FONT_NORMALTEXT:
                    438:                i=0;
                    439:                break;
                    440:           case FONT_SMALLTEXT:
                    441:                i=1;
                    442:                break;
                    443:           }
                    444:           printext256(x,y,REDBASE,-1,stg,i);
                    445:           printext256(x-1,y-1,REDBASE+16,shade,stg,i);
                    446:           return;
                    447:      }
                    448:      len=strlen(stg);
                    449:      for (i=0 ; i < len ; i++) {
                    450:           pic=0;
                    451:           if (isalpha(stg[i])) {
                    452:                pic=graphicLetAPic+(stg[i]-'A');
                    453:           }
                    454:           else if (isdigit(stg[i])) {
                    455:                pic=graphicNum0Pic+(stg[i]-'0');
                    456:           }
                    457:           else {
                    458:                x+=fontXSize[font];
                    459:           }
                    460:           if (pic != 0) {
                    461:                rotatesprite(x<<16,y<<16,fontScale[font],0,pic,shade,0,2+16,
                    462:                             0L,0L,xdim-1L,ydim-1L);
                    463:                x+=fontXSize[font];
                    464:           }
                    465:      }
                    466: }
                    467: 
                    468: void
                    469: MEN_showHeader(char *hdr)
                    470: {
                    471:      rotatesprite(320L<<15,tilesizy[menuTitleBarPic]<<16,65536L,0,
                    472:                   menuTitleBarPic,0,0,2,0L,0L,xdim-1L,ydim-1L);
                    473:      MEN_printext((320L>>1)-((strlen(hdr)*fontXSize[FONT_BIGFONT])>>1),
                    474:                   (tilesizy[menuTitleBarPic]>>1)+2L,-1,hdr,FONT_BIGFONT);
                    475: }
                    476: 
                    477: void
                    478: MEN_displayMenu(int cur,short items,short backpic,char *hdr,
                    479:                 struct menuOption *men[])
                    480: {
                    481:      int  activeItems,i,len=0,shade;
                    482:      long x,y;
                    483:      char *ptr;
                    484: 
                    485:      if (backpic != 0) {
                    486:           if (!ENG_inSetupVideoMode()) {
                    487:                ENG_setupVideo();
                    488:           }
                    489:      }
                    490:      if (playingGameFlag) {
                    491:           if (backpic == 0 && !GAM_inSetupVideoMode()) {
                    492:                GAM_setupVideo(viewSize);
                    493:           }
                    494:           if (saveScreenShotFlag) {
                    495:                MEN_setViewToTile(cur);
                    496:           }
                    497:           GAM_doFrame();
                    498:           if (saveScreenShotFlag) {
                    499:                MEN_setViewBack();
                    500:           }
                    501:      }
                    502:      if (backpic != 0) {
                    503:           rotatesprite(320L<<15,200L<<15,65536L,0,backpic,0,0,2,
                    504:                        0L,0L,xdim-1L,ydim-1L);
                    505:      }
                    506:      MEN_showHeader(hdr);
                    507:      activeItems=0;
                    508:      x=0L;
                    509:      for (i=0 ; i < items ; i++) {
                    510:           if (men[i]->active) {
                    511:                activeItems++;
                    512:                switch (men[i]->type) {
                    513:                case MENUOPTION_SLIDER:
                    514:                     x+=(fontYSize[men[i]->font]*2);
                    515:                     break;
                    516:                default:
                    517:                     x+=fontYSize[men[i]->font];
                    518:                     break;
                    519:                }
                    520:           }
                    521:      }
                    522:      y=(200L>>1)-(x>>1)+10L;
                    523:      minline=y;
                    524:      for (i=0 ; i < items ; i++) {
                    525:           shade=8;
                    526:           if (cur == i) {
                    527:                shade=-1;
                    528:           }
                    529:           if (men[i]->active) {
                    530:                men[i]->line=y;
                    531:                ptr=men[i]->label;
                    532:                switch (men[i]->type) {
                    533:                default:
                    534:                case MENUOPTION_NONE:
                    535:                case MENUOPTION_BULLET:
                    536:                case MENUOPTION_GRAPHIC:
                    537:                     len=strlen(ptr);
                    538:                     x=(320L>>1)-((len*fontXSize[men[i]->font])>>1);
                    539:                     men[i]->column=x;
                    540:                     MEN_printext(x,y,shade,ptr,men[i]->font);
                    541:                     y+=fontYSize[men[i]->font];
                    542:                     break;
                    543:                case MENUOPTION_LEFTJUST:
                    544:                     len=tilesizx[menuTitleBarPic]>>1;
                    545:                     x=(320L>>1)-len+fontXSize[men[i]->font];
                    546:                     men[i]->column=x;
                    547:                     MEN_printext(x,y,shade,ptr,men[i]->font);
                    548:                     y+=fontYSize[men[i]->font];
                    549:                     break;
                    550:                case MENUOPTION_SLIDER:
                    551:                     len=tilesizx[menuTitleBarPic]>>1;
                    552:                     x=(320L>>1)-len+fontXSize[men[i]->font];
                    553:                     men[i]->column=x;
                    554:                     MEN_printext(x,y,shade,ptr,men[i]->font);
                    555:                     y+=fontYSize[men[i]->font];
                    556:                     x=160L-(tilesizx[menuSliderBarPic]>>1);
                    557:                     rotatesprite(x<<16,y<<16,65536L,0,menuSliderBarPic,
                    558:                                  0,0,2+16,0L,0L,xdim-1L,ydim-1L);
                    559:                     x+=(men[i]->misc1*((tilesizx[menuSliderBarPic]-8)/
                    560:                         men[i]->misc2));
                    561:                     rotatesprite((x+3)<<16,(y+1)<<16,65536L,0,menuSliderKnobPic,
                    562:                                  0,0,2+16,0L,0L,xdim-1L,ydim-1L);
                    563:                     y+=fontYSize[men[i]->font];
                    564:                     break;
                    565:                case MENUOPTION_RIGHTJUST:
                    566:                     len=strlen(ptr);
                    567:                     x=320L-(len*fontXSize[men[i]->font]);
                    568:                     x-=fontXSize[men[i]->font];
                    569:                     men[i]->column=x;
                    570:                     MEN_printext(x,y,shade,ptr,men[i]->font);
                    571:                     y+=fontYSize[men[i]->font];
                    572:                     break;
                    573:                case MENUOPTION_BOOLEAN:
                    574:                     len=tilesizx[menuTitleBarPic]>>1;
                    575:                     x=(320L>>1)-len+fontXSize[men[i]->font];
                    576:                     men[i]->column=x;
                    577:                     MEN_printext(x,y,shade,ptr,men[i]->font);
                    578:                     if (men[i]->misc1) {
                    579:                          ptr="ON ";
                    580:                     }
                    581:                     else {
                    582:                          ptr="OFF";
                    583:                     }
                    584:                     x=(320L>>1)+len-(fontXSize[men[i]->font]*strlen(ptr))
                    585:                                     -fontXSize[men[i]->font];
                    586:                     MEN_printext(x,y,shade,ptr,men[i]->font);
                    587:                     y+=fontYSize[men[i]->font];
                    588:                     break;
                    589:                }
                    590:           }
                    591:      }
                    592: }
                    593: 
                    594: int
                    595: MEN_updateMenuTimer(void)
                    596: {
                    597:      static long updateclock;
                    598: 
                    599:      if (totalclock > updateclock) {
                    600:           updateStep++;
                    601:           if (menuMarkerBegPic+updateStep >= menuMarkerEndPic) {
                    602:                updateStep=0L;
                    603:           }
                    604:           updateclock=totalclock+TMR_getSecondFraction(16);
                    605:           return(1);
                    606:      }
                    607:      return(0);
                    608: }
                    609: 
                    610: void
                    611: MEN_showSelectedLine(short n,struct menuOption *men[])
                    612: {
                    613:      short pic=0;
                    614:      long x,x2=0L,y=0L;
                    615: 
                    616:      y=men[n]->line+(tilesizy[menuMarkerBegPic]>>1)
                    617:                    -(tilesizy[menuMarkerBegPic]>>2);
                    618:      switch (men[n]->type) {
                    619:      case MENUOPTION_RIGHTJUST:
                    620:           pic=men[n]->misc1;
                    621:      case MENUOPTION_LEFTJUST:
                    622:      case MENUOPTION_BOOLEAN:
                    623:           x=men[n]->column-(tilesizx[menuMarkerBegPic]>>1);
                    624:           break;
                    625:      default:
                    626:           x=(320L>>1)-(tilesizx[menuTitleBarPic]>>1);
                    627:           x2=(320L>>1)+(tilesizx[menuTitleBarPic]>>1);
                    628:           break;
                    629:      }
                    630:      rotatesprite(x<<16,y<<16,fontScale[men[n]->font],0,
                    631:                   menuMarkerBegPic+updateStep,0,0,2,
                    632:                   0L,0L,xdim-1L,ydim-1L);
                    633:      if (x2 != 0L) {
                    634:           rotatesprite(x2<<16,y<<16,fontScale[men[n]->font],0,
                    635:                        menuMarkerBegPic+updateStep,0,0,2,
                    636:                        0L,0L,xdim-1L,ydim-1L);
                    637:      }
                    638:      if (pic != 0) {
                    639:           x=(320L>>2)+10L;
                    640:           rotatesprite(x<<16,(200L>>1)<<16,men[n]->misc2,512,pic,0,0,2+4+64,
                    641:                        0L,0L,xdim-1L,ydim-1L);
                    642:      }
                    643: }
                    644: 
                    645: int
                    646: MEN_getInput(void)
                    647: {
                    648:      int  k;
                    649:      static int mouseTics;
                    650: 
                    651:      k=KBD_keyPressed();
                    652:      mouseTics+=globalMouseY;
                    653:      if (mouseTics < -200) {
                    654:           k=K_UP;
                    655:           mouseTics=0;
                    656:      }
                    657:      else if (mouseTics > 200) {
                    658:           k=K_DOWN;
                    659:           mouseTics=0;
                    660:      }
                    661:      switch (k&0x7F) {
                    662:      case K_UP:
                    663:           do {
                    664:                menuOpt--;
                    665:                if (menuOpt < 0) {
                    666:                     menuOpt=menuNum-1;
                    667:                }
                    668:           } while ((menuActiveBits&(1L<<menuOpt)) == 0);
                    669:           SND_playMenuChooseSound();
                    670:           break;
                    671:      case K_DOWN:
                    672:           do {
                    673:                menuOpt++;
                    674:                if (menuOpt >= menuNum) {
                    675:                     menuOpt=0;
                    676:                }
                    677:           } while ((menuActiveBits&(1L<<menuOpt)) == 0);
                    678:           SND_playMenuChooseSound();
                    679:           break;
                    680:      case K_RIGHT:
                    681:           switch (menuArr[menuOpt]->type) {
                    682:           case MENUOPTION_SLIDER:
                    683:                if (menuArr[menuOpt]->misc1 < menuArr[menuOpt]->misc2-1) {
                    684:                     menuArr[menuOpt]->misc1++;
                    685:                     SND_playMenuSlideSound();
                    686:                     inMenuFlag=0;
                    687:                }
                    688:                break;
                    689:           }
                    690:           break;
                    691:      case K_LEFT:
                    692:           switch (menuArr[menuOpt]->type) {
                    693:           case MENUOPTION_SLIDER:
                    694:                if (menuArr[menuOpt]->misc1 > 0) {
                    695:                     menuArr[menuOpt]->misc1--;
                    696:                     SND_playMenuSlideSound();
                    697:                     inMenuFlag=0;
                    698:                }
                    699:                break;
                    700:           }
                    701:           break;
                    702:      default:
                    703:           if (k > 0) {
                    704:                if (k == K_SPACE || k == K_ENTER) {
                    705:                     *menuCur=menuOpt;
                    706:                     inMenuFlag=0;
                    707:                     SND_playMenuDoneSound();
                    708:                }
                    709:                else if (k == K_ESC) {
                    710:                     inMenuFlag=-1;
                    711:                     SND_playMenuQuitSound();
                    712:                }
                    713:           }
                    714:           break;
                    715:      }
                    716:      return(k);
                    717: }
                    718: 
                    719: void
                    720: MEN_doMenuFrame(int opt,int num,short pic,char *hdr,struct menuOption *men[])
                    721: {
                    722:      int  update=0;
                    723: 
                    724:      update=MEN_updateMenuTimer();
                    725:      if (update || playingGameFlag) {
                    726:           MEN_displayMenu(opt,num,pic,hdr,men);
                    727:           MEN_showSelectedLine(opt,men);
                    728:           nextpage();
                    729:           GFX_fadeIn(32);
                    730:           update=0;
                    731:      }
                    732: }
                    733: 
                    734: int
                    735: MEN_doMenu(int *cur,int num,short backpic,char *hdr,struct menuOption *men[])
                    736: {
                    737:      int  i,lastMenuOpt=-1;
                    738: 
                    739:      inMenuFlag=1;
                    740:      menuCur=cur;
                    741:      menuOpt=*menuCur;
                    742:      menuNum=num;
                    743:      menuActiveBits=0L;
                    744:      for (i=0 ; i < num ; i++) {
                    745:           menuArr[i]=men[i];
                    746:           if (men[i]->active) {
                    747:                menuActiveBits|=(1L<<i);
                    748:           }
                    749:      }
                    750:      KBD_resetKeys();
                    751:      while (inMenuFlag == 1) {
                    752:           MEN_doMenuFrame(menuOpt,menuNum,backpic,hdr,men);
                    753:           if (!playingGameFlag) {
                    754:                MEN_getInput();
                    755:                GFX_animatePalette();
                    756:           }
                    757:           if (men == saveNames && menuOpt != lastMenuOpt) {
                    758:                MEN_loadScreenShot(menuOpt);
                    759:           }
                    760:           lastMenuOpt=menuOpt;
                    761:      }
                    762:      *menuCur=menuOpt;
                    763:      if (inMenuFlag == -1) {
                    764:           inMenuFlag=0;
                    765:           return(0);
                    766:      }
                    767:      return(1);
                    768: }
                    769: 
                    770: int
                    771: MEN_graphicOptions(void)
                    772: {
                    773:      int  pic=0,
                    774:           r=1;
                    775: 
                    776:      while (r) {
                    777:           pic=menuBackgroundPic;
                    778:           graphicNames[GMENU_AUTOHORIZON]->misc1=horizCheckFlag;
                    779:           graphicNames[GMENU_AUTOAIM]->misc1=WEP_getAutoAimSetting();
                    780:           graphicNames[GMENU_GORELEVEL]->misc1=GAM_getGoreLevel();
                    781:           graphicNames[GMENU_GORELEVEL]->misc2=MAXGORECHOICES;
                    782:           graphicNames[GMENU_DETAILLEVEL]->misc1=GAM_getDetailLevel();
                    783:           graphicNames[GMENU_DETAILLEVEL]->misc2=MAXDETAILLEVEL;
                    784:           r=MEN_doMenu(&curGraphics,NUMGRAPHICOPTIONS,pic,"GRAPHICS OPTIONS",
                    785:                        graphicNames);
                    786:           if (r) {
                    787:                switch (curGraphics) {
                    788:                case GMENU_GORELEVEL:
                    789:                     GAM_setGoreLevel(graphicNames[curGraphics]->misc1);
                    790:                     break;
                    791:                case GMENU_AUTOHORIZON:
                    792:                     horizCheckFlag^=1;
                    793:                     break;
                    794:                case GMENU_AUTOAIM:
                    795:                     WEP_toggleAutoAimSetting();
                    796:                     break;
                    797:                case GMENU_DETAILLEVEL:
                    798:                     GAM_setDetailLevel(graphicNames[curGraphics]->misc1);
                    799:                     GAM_scanDetailSprites();
                    800:                     break;
                    801:                case GMENU_EXIT:
                    802:                     r=0;
                    803:                     break;
                    804:                }
                    805:           }
                    806:      }
                    807:      return(r);
                    808: }
                    809: 
                    810: int
                    811: MEN_soundOptions(void)
                    812: {
                    813:      int  pic=0,
                    814:           r=1;
                    815: 
                    816:      while (r) {
                    817:           pic=menuBackgroundPic;
                    818:           soundNames[SMENU_STEREO]->misc1=stereoSwapFlag;
                    819:           soundNames[SMENU_SOUNDVOL]->misc1=SND_getSoundVolume();
                    820:           soundNames[SMENU_SOUNDVOL]->misc2=16;
                    821: #if 0
                    822:           soundNames[SMENU_MUSICVOL]->misc1=SND_getMusicVolume();
                    823: #endif
                    824:           soundNames[SMENU_MUSICVOL]->misc2=16;
                    825:           r=MEN_doMenu(&curSound,NUMSOUNDOPTIONS,pic,"SOUND OPTIONS",
                    826:                        soundNames);
                    827:           if (r) {
                    828:                switch (curSound) {
                    829:                case SMENU_SOUNDVOL:
                    830:                     SND_setSoundVolume(soundNames[curSound]->misc1);
                    831:                     break;
                    832:                case SMENU_MUSICVOL:
                    833: #if 0
                    834:                     SND_setMusicVolume(soundNames[curSound]->misc1);
                    835: #endif
                    836:                     break;
                    837:                case SMENU_STEREO:
                    838:                     stereoSwapFlag^=1;
                    839:                     if (stereoSwapFlag) {
                    840:                          sDIGIDriver.wDriverFormat|=_DRV_SWAP_CHANNELS;
                    841:                     }
                    842:                     else {
                    843:                          sDIGIDriver.wDriverFormat&=~_DRV_SWAP_CHANNELS;
                    844:                     }
                    845:                     break;
                    846:                case SMENU_EXIT:
                    847:                     r=0;
                    848:                     break;
                    849:                }
                    850:           }
                    851:      }
                    852:      return(r);
                    853: }
                    854: 
                    855: int
                    856: MEN_keyboardConfiguration(void)
                    857: {
                    858:      int  i,
                    859:           pic=0,
                    860:           r;
                    861: 
                    862:      for (i=0 ; i < MAXACTIONS ; i++) {
                    863:           sprintf(actionName[i],"%s %-6s",
                    864:                   controlArray[i].desc,keystrings[keys[i]&0x7F]);
                    865:           keyboardNames[i]->misc1=keys[i];
                    866:      }
                    867:      r=1;
                    868:      while (r) {
                    869:           pic=menuBackgroundPic;
                    870:           r=MEN_doMenu(&curKeyboard,MAXACTIONS,pic,"KEYBOARD CONFIG",
                    871:                        keyboardNames);
                    872:           if (r) {
                    873:                sprintf(actionName[curKeyboard],"%s %-6s",
                    874:                        controlArray[curKeyboard].desc,"");
                    875:                while ((i=KBD_keyPressed()) == 0) {
                    876:                     MEN_doMenuFrame(curKeyboard,MAXACTIONS,pic,
                    877:                                     "PRESS A KEY",keyboardNames);
                    878:                }
                    879:                sprintf(actionName[curKeyboard],"%s %-6s",
                    880:                        controlArray[curKeyboard].desc,keystrings[i&0x7F]);
                    881:                keyboardNames[curKeyboard]->misc1=i;
                    882:           }
                    883:      }
                    884:      for (i=0 ; i < MAXACTIONS ; i++) {
                    885:           keys[i]=keyboardNames[i]->misc1;
                    886:      }
                    887:      return(r);
                    888: }
                    889: 
                    890: //** NOTE: mouseConfiguration uses the keyboard menu arrays
                    891: 
                    892: int
                    893: MEN_mouseConfiguration(void)
                    894: {
                    895:      int  i,j,
                    896:           pic=0,
                    897:           r;
                    898: 
                    899:      for (i=0 ; i < MAXACTIONS ; i++) {
                    900:           keyboardNames[i]->misc1=0;
                    901:           for (j=1 ; j < MAXMOUSEBUTTONS ; j++) {
                    902:                if (configMouse[j] == i) {
                    903:                     sprintf(actionName[i],"%s %s",
                    904:                             controlArray[i].desc,
                    905:                             mouseControlLabel[j]);
                    906:                     keyboardNames[i]->misc1=j;
                    907:                     break;
                    908:                }
                    909:           }
                    910:           if (keyboardNames[i]->misc1 == 0) {
                    911:                sprintf(actionName[i],"%s %13s",controlArray[i].desc,"");
                    912:           }
                    913:      }
                    914:      r=1;
                    915:      while (r) {
                    916:           pic=menuBackgroundPic;
                    917:           r=MEN_doMenu(&curMouse,MAXACTIONS,pic,"MOUSE CONFIG",
                    918:                        keyboardNames);
                    919:           if (r) {
                    920:                sprintf(actionName[curMouse],"%s %13s",
                    921:                        controlArray[curMouse].desc,"");
                    922:                while ((i=KBD_keyPressed()) == 0) {
                    923:                     MEN_doMenuFrame(curMouse,MAXACTIONS,pic,
                    924:                                     "PRESS MOUSE BUTTON",keyboardNames);
                    925:                }
                    926:                if (globalMouseB != 0) {
                    927:                     if ((globalMouseB&0x01) != 0) {
                    928:                          i=1;
                    929:                     }
                    930:                     else if ((globalMouseB&0x02) != 0) {
                    931:                          i=3;
                    932:                     }
                    933:                     else {
                    934:                          i=2;
                    935:                     }
                    936:                     for (j=0 ; j < MAXACTIONS ; j++) {
                    937:                          if (keyboardNames[j]->misc1 == i) {
                    938:                               keyboardNames[j]->misc1=0;
                    939:                               sprintf(actionName[j],"%s %13s",
                    940:                                       controlArray[j].desc,"");
                    941:                               break;
                    942:                          }
                    943:                     }
                    944:                     sprintf(actionName[curMouse],"%s %s",
                    945:                             controlArray[curMouse].desc,
                    946:                             mouseControlLabel[i]);
                    947:                     keyboardNames[curMouse]->misc1=i;
                    948:                }
                    949:           }
                    950:      }
                    951:      for (i=0 ; i < MAXACTIONS ; i++) {
                    952:           j=keyboardNames[i]->misc1;
                    953:           if (j != 0 && j < MAXMOUSEBUTTONS) {
                    954:                configMouse[j]=i;
                    955:           }
                    956:      }
                    957:      return(r);
                    958: }
                    959: 
                    960: int
                    961: MEN_mouseOptions(void)
                    962: {
                    963:      int  pic=0,
                    964:           r=1;
                    965: 
                    966:      mouseNames[MMENU_ENABLE]->misc1=configMouse[0];
                    967:      mouseNames[MMENU_MOUSEXSENSE]->misc1=PLR_getMouseXSense();
                    968:      mouseNames[MMENU_MOUSEXSENSE]->misc2=MAXMOUSESENSE;
                    969:      mouseNames[MMENU_MOUSEYSENSE]->misc1=PLR_getMouseYSense();
                    970:      mouseNames[MMENU_MOUSEYSENSE]->misc2=MAXMOUSESENSE;
                    971:      while (r) {
                    972:           pic=menuBackgroundPic;
                    973:           r=MEN_doMenu(&curMouseOptions,NUMMOUSEOPTIONS,pic,
                    974:                        "MOUSE OPTIONS",mouseNames);
                    975:           if (r) {
                    976:                switch (curMouseOptions) {
                    977:                case MMENU_ENABLE:
                    978:                     mouseNames[curMouseOptions]->misc1^=1;
                    979:                     break;
                    980:                case MMENU_CONFIGURE:
                    981:                     MEN_mouseConfiguration();
                    982:                     break;
                    983:                case MMENU_EXIT:
                    984:                     r=0;
                    985:                     break;
                    986:                }
                    987:           }
                    988:      }
                    989:      configMouse[0]=mouseNames[MMENU_ENABLE]->misc1;
                    990:      PLR_setMouseXSense(mouseNames[MMENU_MOUSEXSENSE]->misc1);
                    991:      PLR_setMouseYSense(mouseNames[MMENU_MOUSEYSENSE]->misc1);
                    992:      return(r);
                    993: }
                    994: 
                    995: int
                    996: MEN_controllerOptions(void)
                    997: {
                    998:      int  pic=0,
                    999:           r=1;
                   1000: 
                   1001:      while (r) {
                   1002:           pic=menuBackgroundPic;
                   1003:           r=MEN_doMenu(&curController,NUMCONTROLLEROPTIONS,pic,
                   1004:                        "CONTROLLER OPTIONS",controllerNames);
                   1005:           if (r) {
                   1006:                switch (curController) {
                   1007:                case CMENU_KEYBOARD:
                   1008:                     MEN_keyboardConfiguration();
                   1009:                     break;
                   1010:                case CMENU_MOUSE:
                   1011:                     MEN_mouseOptions();
                   1012:                     break;
                   1013:                case CMENU_JOYSTICKS:
                   1014: //                    MEN_joystickControllers();
                   1015:                     break;
                   1016:                case CMENU_VRHEADSETS:
                   1017: //                    MEN_vrHeadsetControllers();
                   1018:                     break;
                   1019:                case CMENU_EXIT:
                   1020:                     r=0;
                   1021:                     break;
                   1022:                }
                   1023:           }
                   1024:      }
                   1025:      return(r);
                   1026: }
                   1027: 
                   1028: int
                   1029: MEN_gameOptions(void)              // setup/configure game options
                   1030: {
                   1031:      int  pic=0,
                   1032:           r=1;
                   1033: 
                   1034:      while (r) {
                   1035:           pic=menuBackgroundPic;
                   1036:           r=MEN_doMenu(&curOption,NUMOPTIONS,pic,"GAME OPTIONS",optionNames);
                   1037:           if (r) {
                   1038:                switch (curOption) {
                   1039:                case OMENU_GRAPHICS:
                   1040:                     MEN_graphicOptions();
                   1041:                     break;
                   1042:                case OMENU_SOUND:
                   1043:                     MEN_soundOptions();
                   1044:                     break;
                   1045:                case OMENU_CONTROLLER:
                   1046:                     MEN_controllerOptions();
                   1047:                     break;
                   1048:                case OMENU_EXIT:
                   1049:                     r=0;
                   1050:                     break;
                   1051:                }
                   1052:           }
                   1053:      }
                   1054:      return(r);
                   1055: }
                   1056: 
                   1057: void
                   1058: MEN_saveGameData(void)
                   1059: {
                   1060:      GAM_saveGame(curSaveSpot);
                   1061: }
                   1062: 
                   1063: int
                   1064: MEN_getSaveName(short pic,char *hdr)
                   1065: {
                   1066:      int  c,stat,x;
                   1067:      char backup[MAXSAVENAMESIZE],
                   1068:           locbuf[MAXSAVENAMESIZE],
                   1069:           *ptr;
                   1070: 
                   1071:      strcpy(backup,saveNames[curSaveSpot]->label);
                   1072:      strcpy(locbuf,backup);
                   1073:      ptr=locbuf;
                   1074:      MEN_stripTrailingBlanks(ptr);
                   1075:      if (strcmp(ptr,"EMPTY") == 0) {
                   1076:           memset(ptr,0,MAXSAVENAMESIZE);
                   1077:      }
                   1078:      x=strlen(ptr);
                   1079:      sprintf(saveNames[curSaveSpot]->label,"%-16s",locbuf);
                   1080:      KBD_resetKeys();
                   1081:      inMenuFlag=1;
                   1082:      saveScreenShotFlag=1;
                   1083:      keyfifoplc=keyfifoend;
                   1084:      MEN_getSaveScreenShot(curSaveSpot);
                   1085:      do {
                   1086:           MEN_doMenuFrame(curSaveSpot,NUMSAVESPOTS,pic,hdr,saveNames);
                   1087:           while (keyfifoplc != keyfifoend) {
                   1088:                c=keyfifo[keyfifoplc];
                   1089:                stat=keyfifo[(keyfifoplc+1)&(KEYFIFOSIZ-1)];
                   1090:                if (stat == 1) {
                   1091:                     switch (c) {
                   1092:                     case K_ESC:
                   1093:                          strcpy(saveNames[curSaveSpot]->label,backup);
                   1094:                          saveScreenShotFlag=0;
                   1095:                          inMenuFlag=0;
                   1096:                          return(0);
                   1097:                     case K_BACKSPACE:
                   1098:                          if (x > 0) {
                   1099:                               ptr[x]=0;
                   1100:                               ptr[x-1]=0;
                   1101:                               x--;
                   1102:                          }
                   1103:                          break;
                   1104:                     case K_ENTER:
                   1105:                          saveScreenShotFlag=0;
                   1106:                          inMenuFlag=0;
                   1107:                          return(1);
                   1108:                     default:
                   1109:                          if (scantoasc[c] != 0) {
                   1110:                               ptr[x++]=toupper(scantoasc[c]);
                   1111:                               if (x >= MAXSAVENAMESIZE) {
                   1112:                                    x=MAXSAVENAMESIZE-1;
                   1113:                               }
                   1114:                               ptr[x]=0;
                   1115:                          }
                   1116:                          break;
                   1117:                     }
                   1118:                     sprintf(saveNames[curSaveSpot]->label,"%-16s",locbuf);
                   1119:                }
                   1120:                keyfifoplc=(keyfifoplc+1)&(KEYFIFOSIZ-1);
                   1121:           }
                   1122:      } while (1);
                   1123: }
                   1124: 
                   1125: void
                   1126: MEN_allocFrameTile(void)
                   1127: {
                   1128:      walock[FRAMETILE]=255;
                   1129:      if (waloff[FRAMETILE] == 0) {
                   1130:           allocache(&waloff[FRAMETILE],320L*200L,&walock[FRAMETILE]);
                   1131:      }
                   1132: }
                   1133: 
                   1134: void
                   1135: MEN_freeFrameTile(void)
                   1136: {
                   1137:      walock[FRAMETILE]=1;
                   1138: }
                   1139: 
                   1140: int
                   1141: MEN_saveGameOption(void)
                   1142: {
                   1143:      int  i,pic=0,r=1;
                   1144:      FILE *fp;
                   1145: 
                   1146:      for (i=0 ; i < NUMSAVESPOTS ; i++) {
                   1147:           saveNames[i]=&saveGameNamesArr[i];
                   1148:           saveNames[i]->label=&saveGameName[i];
                   1149:           sprintf(tempbuf,SAVENAMEFMT,i);
                   1150:           if ((fp=fopen(tempbuf,"r+b")) != NULL) {
                   1151:                GAM_fread(saveNames[i]->label,sizeof(char),MAXSAVENAMESIZE,fp);
                   1152:                fclose(fp);
                   1153:           }
                   1154:           else {
                   1155:                sprintf(tempbuf,"%-16s","EMPTY");
                   1156:                strcpy(saveNames[i]->label,tempbuf);
                   1157:           }
                   1158:           saveNames[i]->active=1;
                   1159:           saveNames[i]->type=MENUOPTION_RIGHTJUST;
                   1160:           saveNames[i]->misc1=0;
                   1161:           saveNames[i]->misc2=0;
                   1162:           saveNames[i]->font=FONT_SMALLFONT;
                   1163:      }
                   1164:      MEN_allocFrameTile();
                   1165:      while (r) {
                   1166:           pic=menuBackgroundPic;
                   1167:           r=MEN_doMenu(&curSaveSpot,NUMSAVESPOTS,pic,"SAVE GAME",saveNames);
                   1168:           if (r) {
                   1169:                if (MEN_getSaveName(pic,"SAVE GAME")) {
                   1170:                     MEN_saveGameData();
                   1171:                     MEN_saveScreenShot();
                   1172:                }
                   1173:                r=0;
                   1174:           }
                   1175:      }
                   1176:      MEN_freeFrameTile();
                   1177:      return(r);
                   1178: }
                   1179: 
                   1180: int
                   1181: MEN_getLoadName(void)
                   1182: {
                   1183:      sprintf(tempbuf,"%-16s","EMPTY");
                   1184:      if (strcmp(saveNames[curSaveSpot]->label,tempbuf) != 0) {
                   1185:           return(1);
                   1186:      }
                   1187:      return(0);
                   1188: }
                   1189: 
                   1190: void
                   1191: MEN_loadGameData(void)
                   1192: {
                   1193:      GAM_loadGame(curSaveSpot);
                   1194: }
                   1195: 
                   1196: int
                   1197: MEN_loadGameOption(void)
                   1198: {
                   1199:      int  i,pic=0,r=1;
                   1200:      FILE *fp;
                   1201: 
                   1202:      for (i=0 ; i < NUMSAVESPOTS ; i++) {
                   1203:           saveNames[i]=&saveGameNamesArr[i];
                   1204:           saveNames[i]->label=&saveGameName[i];
                   1205:           sprintf(tempbuf,SAVENAMEFMT,i);
                   1206:           if ((fp=fopen(tempbuf,"r+b")) != NULL) {
                   1207:                GAM_fread(saveNames[i]->label,sizeof(char),MAXSAVENAMESIZE,fp);
                   1208:                fclose(fp);
                   1209:           }
                   1210:           else {
                   1211:                sprintf(tempbuf,"%-16s","EMPTY");
                   1212:                strcpy(saveNames[i]->label,tempbuf);
                   1213:           }
                   1214:           saveNames[i]->active=1;
                   1215:           saveNames[i]->type=MENUOPTION_RIGHTJUST;
                   1216:           saveNames[i]->misc1=0;
                   1217:           saveNames[i]->misc2=0;
                   1218:           saveNames[i]->font=FONT_SMALLFONT;
                   1219:      }
                   1220:      walock[FRAMETILE]=255;
                   1221:      if (waloff[FRAMETILE] == 0) {
                   1222:           allocache(&waloff[FRAMETILE],320L*200L,&walock[FRAMETILE]);
                   1223:      }
                   1224:      pic=menuBackgroundPic;
                   1225:      r=MEN_doMenu(&curSaveSpot,NUMSAVESPOTS,pic,"LOAD GAME",saveNames);
                   1226:      walock[FRAMETILE]=1;
                   1227:      if (r) {
                   1228:           if (MEN_getLoadName()) {
                   1229:                MEN_loadGameData();
                   1230:           }
                   1231:      }
                   1232:      return(r);
                   1233: }
                   1234: 
                   1235: int
                   1236: MEN_areYouSure(void)
                   1237: {
                   1238:      return(1);
                   1239: }
                   1240: 
                   1241: int
                   1242: MEN_mainMenu(void)
                   1243: {
                   1244:      int  pic=0,
                   1245:           r;
                   1246: 
                   1247:      if (playingGameFlag) {
                   1248:           curMenu=MMENU_STORE;
                   1249:      }
                   1250:      else {
                   1251:           curMenu=MMENU_NEWMISSION;
                   1252:      }
                   1253:      while (inGameFlag) {
                   1254:           if (gameType != GAMETYPE_SINGLE || (noWaitFlag && !playingGameFlag)
                   1255:               || newMapLoadedFlag) {
                   1256:                curMenu=MMENU_NEWMISSION;
                   1257:                r=1;
                   1258:           }
                   1259:           else {
                   1260:                if (!playingGameFlag) {
                   1261:                     pic=menuBackgroundPic;
                   1262:                     r=MEN_doMenu(&curMenu,NUMMENUOPTIONS,pic,
                   1263:                                  "CORRIDOR 8 GW MENU",menuNames);
                   1264:                }
                   1265:                else {
                   1266:                     r=MEN_doMenu(&curMenu,NUMMENUOPTIONS,0,
                   1267:                                  "CORRIDOR 8 GW MENU",menu2Names);
                   1268:                }
                   1269:           }
                   1270:           if (r) {
                   1271:                switch (curMenu) {
                   1272:                case MMENU_NEWMISSION:
                   1273:                     if (playingGameFlag) {
                   1274:                          if (MEN_areYouSure()) {
                   1275:                               newGameFlag=1;
                   1276:                               return(0);
                   1277:                          }
                   1278:                     }
                   1279:                     return(1);
                   1280:                case MMENU_OPTIONS:
                   1281:                     MEN_gameOptions();
                   1282:                     break;
                   1283:                case MMENU_RETRIEVE:
                   1284:                     if (playingGameFlag) {
                   1285:                          if (!MEN_areYouSure()) {
                   1286:                               return(1);
                   1287:                          }
                   1288:                     }
                   1289:                     if (MEN_loadGameOption()) {
                   1290:                          loadLevelFlag=1;
                   1291:                          return(1);
                   1292:                     }
                   1293:                     break;
                   1294:                case MMENU_STORE:
                   1295:                     MEN_saveGameOption();
                   1296:                     if (playingGameFlag) {
                   1297:                          GAM_setupVideo(viewSize);
                   1298:                     }
                   1299:                     return(1);
                   1300:                case MMENU_CREDITS:
                   1301:                     GAM_demoGameCredits();
                   1302:                     break;
                   1303:                case MMENU_DEMO:
                   1304:                     if (playingGameFlag) {
                   1305:                          return(1);
                   1306:                     }
                   1307:                     return(0);
                   1308:                case MMENU_ORDER:
                   1309:                     GAM_orderScreen();
                   1310:                     break;
                   1311:                case MMENU_QUIT:
                   1312:                     if (MEN_areYouSure()) {
                   1313:                          inGameFlag=0;
                   1314:                          playingGameFlag=0;
                   1315:                          inMenuFlag=0;
                   1316:                          return(0);
                   1317:                     }
                   1318:                     break;
                   1319:                }
                   1320:           }
                   1321:           else {
                   1322:                if (playingGameFlag) {
                   1323:                     return(1);
                   1324:                }
                   1325:                else {
                   1326:                     return(0);
                   1327:                }
                   1328:           }
                   1329:      }
                   1330:      return(0);
                   1331: }
                   1332: 
                   1333: int
                   1334: MEN_getMission(void)               // get episode to play
                   1335: {
                   1336:      int  pic,
                   1337:           r;
                   1338: 
                   1339:      pic=menuBackgroundPic;
                   1340:      r=MEN_doMenu(&curMission,NUMMISSIONS,pic,"CHOOSE A MISSION",
                   1341:                   missionNames);
                   1342:      return(r);
                   1343: }
                   1344: 
                   1345: int
                   1346: MEN_getSkill(void)                 // get skill level
                   1347: {
                   1348:      int  pic=0,
                   1349:           r;
                   1350: 
                   1351:      pic=menuBackgroundPic;
                   1352:      r=MEN_doMenu(&curSkill,NUMSKILLS,pic,"CHOOSE DIFFICULTY",skillNames);
                   1353:      return(r);
                   1354: }
                   1355: 
                   1356: int
                   1357: MEN_getAlliedActor(void)           // get actor to play
                   1358: {
                   1359:      int  pic=0,
                   1360:           r;
                   1361: 
                   1362:      pic=menuBackgroundPic;
                   1363:      r=MEN_doMenu(&curActor,NUMACTORS,pic,"CHOOSE A CHARACTER",
                   1364:                   alliedActorNames);
                   1365:      return(r);
                   1366: }
                   1367: 
                   1368: int
                   1369: MEN_getAxisActor(void)             // get actor to play
                   1370: {
                   1371:      int  pic=0,
                   1372:           r;
                   1373: 
                   1374:      pic=menuBackgroundPic;
                   1375:      r=MEN_doMenu(&curActor,NUMACTORS,pic,"CHOOSE A CHARACTER",
                   1376:                   axisActorNames);
                   1377:      return(r);
                   1378: }
                   1379: 
                   1380: int
                   1381: MEN_getAlliance(void)              // get actor to play
                   1382: {
                   1383:      int  pic=0,
                   1384:           r;
                   1385: 
                   1386:      pic=menuBackgroundPic;
                   1387:      r=MEN_doMenu(&curAlliance,NUMALLIANCES,pic,"CHOOSE A SIDE",
                   1388:                   allianceNames);
                   1389:      return(r);
                   1390: }
                   1391: 
                   1392: #if 0
                   1393: void
                   1394: MEN_fillSoundCardNames(void)
                   1395: {
                   1396:      int  i,j;
                   1397: 
                   1398:      j=firstSoundCard;
                   1399:      if (j == 0) {
                   1400:           strcpy(soundCardName[0],"AUTO DETECT");
                   1401:      }
                   1402:      else {
                   1403:           strcpy(soundCardName[0],"PREVIOUS MENU");
                   1404:      }
                   1405:      soundCardNames[0]->active=1;
                   1406:      for (i=1 ; i < 8 ; i++) {
                   1407:           if (sDIGIDeviceName[j] != NULL) {
                   1408:                soundCardNames[i]->active=1;
                   1409:                strcpy(soundCardName[i],sDIGIDeviceName[j]);
                   1410:                MEN_stripTrailingBlanks(soundCardName[i]);
                   1411:                j++;
                   1412:           }
                   1413:           else {
                   1414:                soundCardNames[i]->active=0;
                   1415:           }
                   1416:      }
                   1417:      strcpy(soundCardName[8],"MORE OPTIONS");
                   1418:      soundCardNames[8]->active=1;
                   1419:      lastSoundCard=j;
                   1420: }
                   1421: 
                   1422: int
                   1423: MEN_getSoundPort(void)
                   1424: {
                   1425:      int  i,pic,r;
                   1426: 
                   1427:      for (i=0 ; i < 9 ; i++) {
                   1428:           soundCardNames[i]->active=0;
                   1429:      }
                   1430:      i=0;
                   1431:      while ((short)wDIGIPortList[i] != -1 && i < 9) {
                   1432:           if (sDIGIDriver.sHardware.wPort == wDIGIPortList[i]) {
                   1433:                curPort=i;
                   1434:           }
                   1435:           sprintf(soundCardName[i],"PORT %03X",wDIGIPortList[i]);
                   1436:           soundCardNames[i]->active=1;
                   1437:           i++;
                   1438:      }
                   1439:      if (i == 0) {
                   1440:           return(0);
                   1441:      }
                   1442:      if (i == 1) {
                   1443:           return(1);
                   1444:      }
                   1445:      pic=menuBackgroundPic;
                   1446:      r=MEN_doMenu(&curPort,i,pic,"CHOOSE THE PORT",soundCardNames);
                   1447:      if (r) {
                   1448:           sDIGIDriver.sHardware.wPort=wDIGIPortList[curPort];
                   1449:           return(1);
                   1450:      }
                   1451:      return(0);
                   1452: }
                   1453: 
                   1454: int
                   1455: MEN_getSoundIRQ(void)
                   1456: {
                   1457:      int  i,pic,r;
                   1458: 
                   1459:      for (i=0 ; i < 9 ; i++) {
                   1460:           soundCardNames[i]->active=0;
                   1461:      }
                   1462:      i=0;
                   1463:      while ((short)wDIGIIRQList[i] != -1 && i < 9) {
                   1464:           if (sDIGIDriver.sHardware.wIRQ == wDIGIIRQList[i]) {
                   1465:                curIRQ=i;
                   1466:           }
                   1467:           sprintf(soundCardName[i],"IRQ %d",wDIGIIRQList[i]);
                   1468:           soundCardNames[i]->active=1;
                   1469:           i++;
                   1470:      }
                   1471:      if (i == 0) {
                   1472:           sDIGIDriver.sHardware.wIRQ=-1;
                   1473:           return(1);
                   1474:      }
                   1475:      if (i == 1) {
                   1476:           return(1);
                   1477:      }
                   1478:      pic=menuBackgroundPic;
                   1479:      r=MEN_doMenu(&curIRQ,i,pic,"CHOOSE THE SOUND IRQ",soundCardNames);
                   1480:      if (r) {
                   1481:           sDIGIDriver.sHardware.wIRQ=wDIGIIRQList[curIRQ];
                   1482:           return(1);
                   1483:      }
                   1484:      return(0);
                   1485: }
                   1486: 
                   1487: int
                   1488: MEN_getSoundDMA(void)
                   1489: {
                   1490:      int  i,pic,r;
                   1491: 
                   1492:      for (i=0 ; i < 9 ; i++) {
                   1493:           soundCardNames[i]->active=0;
                   1494:      }
                   1495:      i=0;
                   1496:      while ((short)wDIGIDMAList[i] != -1 && i < 9) {
                   1497:           if (sDIGIDriver.sHardware.wDMA == wDIGIDMAList[i]) {
                   1498:                curDMA=i;
                   1499:           }
                   1500:           sprintf(soundCardName[i],"DMA %d",wDIGIDMAList[i]);
                   1501:           soundCardNames[i]->active=1;
                   1502:           i++;
                   1503:      }
                   1504:      if (i == 0) {
                   1505:           sDIGIDriver.sHardware.wDMA=-1;
                   1506:           return(1);
                   1507:      }
                   1508:      if (i == 1) {
                   1509:           return(1);
                   1510:      }
                   1511:      pic=menuBackgroundPic;
                   1512:      r=MEN_doMenu(&curDMA,i,pic,"CHOOSE THE DMA CHANNEL",soundCardNames);
                   1513:      if (r) {
                   1514:           sDIGIDriver.sHardware.wDMA=wDIGIDMAList[curDMA];
                   1515:           return(1);
                   1516:      }
                   1517:      return(0);
                   1518: }
                   1519: 
                   1520: int
                   1521: MEN_getSoundConfig(void)
                   1522: {
                   1523:      int  more=1,
                   1524:           pic=0,
                   1525:           r,
                   1526:           sndState;
                   1527: 
                   1528:      if (SND_digiInitialized()) {
                   1529:           return(1);
                   1530:      }
                   1531:      if (!configSoundFlag && sosEZGetConfig("HMISET.CFG")) {
                   1532:           wDIGIIndex=SND_getDIGIIndex(wDIGIDeviceID);
                   1533:           wMIDIIndex=SND_getMIDIIndex(wMIDIDeviceID);
                   1534:           return(1);
                   1535:      }
                   1536:      pic=menuBackgroundPic;
                   1537:      do {
                   1538:           MEN_fillSoundCardNames();
                   1539:           r=MEN_doMenu(&curSoundCard,9,pic,"CHOOSE A SOUND CARD",
                   1540:                        soundCardNames);
                   1541:           if (r) {
                   1542:                switch (curSoundCard) {
                   1543:                case 0:
                   1544:                     if (firstSoundCard == 0) {
                   1545:                          setupDIGIPerformDetection();
                   1546:                          firstSoundCard=wDIGIIndex/7;
                   1547:                          curSoundCard=((wDIGIIndex+1)&7);
                   1548:                          autoDetectFlag=wDIGIIndex;
                   1549:                          break;
                   1550:                     }
                   1551:                     firstSoundCard-=7;
                   1552:                     break;
                   1553:                case 8:
                   1554:                     if (sDIGIDeviceName[lastSoundCard] == NULL) {
                   1555:                          firstSoundCard=0;
                   1556:                     }
                   1557:                     else {
                   1558:                          firstSoundCard+=7;
                   1559:                     }
                   1560:                     break;
                   1561:                default:
                   1562:                     if (firstSoundCard == 0 && curSoundCard == 1) {
                   1563:                          r=0;
                   1564:                          more=0;
                   1565:                     }
                   1566:                     wDIGIIndex=firstSoundCard+(curSoundCard-1);
                   1567:                     if (!SND_getCapsIndex(wDIGIIndex)) {
                   1568:                          break;
                   1569:                     }
                   1570:                     sndState=0;
                   1571:                     if (wDIGIIndex == autoDetectFlag) {
                   1572:                          more=0;
                   1573:                     }
                   1574:                     while (more && sndState >= 0 && sndState < 3) {
                   1575:                          switch (sndState) {
                   1576:                          case 0:
                   1577:                               if (MEN_getSoundPort()) {
                   1578:                                    sndState++;
                   1579:                               }
                   1580:                               else {
                   1581:                                    sndState--;
                   1582:                               }
                   1583:                               break;
                   1584:                          case 1:
                   1585:                               if (MEN_getSoundIRQ()) {
                   1586:                                    sndState++;
                   1587:                               }
                   1588:                               else {
                   1589:                                    sndState--;
                   1590:                               }
                   1591:                               break;
                   1592:                          case 2:
                   1593:                               if (MEN_getSoundDMA()) {
                   1594:                                    more=0;
                   1595:                               }
                   1596:                               else {
                   1597:                                    sndState--;
                   1598:                               }
                   1599:                               break;
                   1600:                          }
                   1601:                     }
                   1602:                     break;
                   1603:                }
                   1604:           }
                   1605:           else {
                   1606:                more=0;
                   1607:           }
                   1608:      } while (more);
                   1609:      if (r) {
                   1610:           SND_writeConfig();
                   1611:      }
                   1612:      return(r);
                   1613: }
                   1614: #endif
                   1615: 
                   1616: void
                   1617: MEN_loadScreenShot(short spot)
                   1618: {
                   1619:      long imagepos;
                   1620:      void *image;
                   1621:      FILE *fp;
                   1622: 
                   1623:      saveNames[spot]->misc1=0;
                   1624:      saveNames[spot]->misc2=0;
                   1625:      sprintf(tempbuf,SAVENAMEFMT,spot);
                   1626:      if ((fp=fopen(tempbuf,"rb")) == NULL) {
                   1627:           return;
                   1628:      }
                   1629:      if (waloff[FRAMETILE] == 0 || walock[FRAMETILE] != 255) {
                   1630:           fclose(fp);
                   1631:           return;
                   1632:      }
                   1633:      fseek(fp,-sizeof(long),SEEK_END);
                   1634:      fread(&imagepos,sizeof(long),1,fp);
                   1635:      if (imagepos > 0L) {
                   1636:           fseek(fp,imagepos,SEEK_SET);
                   1637:           image=(void *)waloff[FRAMETILE];
                   1638:           GAM_fread(image,sizeof(char),320L*200L,fp);
                   1639:           saveNames[spot]->misc1=FRAMETILE;
                   1640:           saveNames[spot]->misc2=24576L;
                   1641:           tilesizx[FRAMETILE]=200;
                   1642:           tilesizy[FRAMETILE]=320;
                   1643:      }
                   1644:      fclose(fp);
                   1645: }
                   1646: 
                   1647: void
                   1648: MEN_saveScreenShot(void)
                   1649: {
                   1650:      long imagepos;
                   1651:      void *image;
                   1652:      FILE *fp;
                   1653: 
                   1654:      sprintf(tempbuf,SAVENAMEFMT,curSaveSpot);
                   1655:      if ((fp=fopen(tempbuf,"r+b")) == NULL) {
                   1656:           return;
                   1657:      }
                   1658:      imagepos=ftell(fp);
                   1659:      fseek(fp,0L,SEEK_END);
                   1660:      if (waloff[FRAMETILE] != 0 && walock[FRAMETILE] == 255) {
                   1661:           imagepos=ftell(fp);
                   1662:           image=(void *)waloff[FRAMETILE];
                   1663:           GAM_fwrite(image,sizeof(char),320L*200L,fp);
                   1664:      }
                   1665:      fwrite(&imagepos,sizeof(long),1,fp);
                   1666:      fclose(fp);
                   1667: }
                   1668: 
                   1669: void
                   1670: MEN_setViewToTile(short spot)
                   1671: {
                   1672:      setviewtotile(FRAMETILE,200L,320L);
                   1673:      saveNames[spot]->misc1=FRAMETILE;
                   1674:      saveNames[spot]->misc2=24576L;
                   1675: }
                   1676: 
                   1677: void
                   1678: MEN_setViewBack(void)
                   1679: {
                   1680:      setviewback();
                   1681: }
                   1682: 
                   1683: void
                   1684: MEN_getSaveScreenShot(short spot)
                   1685: {
                   1686:      MEN_setViewToTile(spot);
                   1687:      ENG_drawScreen(GAM_getViewSprite(),0L);
                   1688:      MEN_setViewBack();
                   1689: }
                   1690: 
                   1691: void
                   1692: MEN_showWeaponInfo(short weap)
                   1693: {
                   1694:      if (weaponPtr[weap]->registered) {
                   1695:           sprintf(tempbuf,"WEAPON #%d: %s",weap,weaponPtr[weap]->name);
                   1696:      }
                   1697:      else {
                   1698:           sprintf(tempbuf,"WEAPON #%d: (UNREGISTERED)",weap);
                   1699:      }
                   1700:      MEN_printext(16L,16L,0,tempbuf,FONT_SMALLTEXT);
                   1701: }
                   1702: 
                   1703: void
                   1704: MEN_saveGame(FILE *fp)
                   1705: {
                   1706:      GAM_fwrite(&saveGameName[curSaveSpot],sizeof(char),MAXSAVENAMESIZE,fp);
                   1707:      GAM_fwrite(&curMission,sizeof(int),1,fp);
                   1708:      GAM_fwrite(&curSkill,sizeof(int),1,fp);
                   1709:      GAM_fwrite(&curActor,sizeof(int),1,fp);
                   1710:      GAM_fwrite(&curAlliance,sizeof(int),1,fp);
                   1711: }
                   1712: 
                   1713: void
                   1714: MEN_loadGame(FILE *fp)
                   1715: {
                   1716:      GAM_fread(&saveGameName[curSaveSpot],sizeof(char),MAXSAVENAMESIZE,fp);
                   1717:      GAM_fread(&curMission,sizeof(int),1,fp);
                   1718:      GAM_fread(&curSkill,sizeof(int),1,fp);
                   1719:      GAM_fread(&curActor,sizeof(int),1,fp);
                   1720:      GAM_fread(&curAlliance,sizeof(int),1,fp);
                   1721: }
                   1722: 

unix.superglobalmegacorp.com