Annotation of src/corr7plr.cc, revision 1.1.1.1

1.1       root        1: /***************************************************************************
                      2:  *   CORR7PLR.C - Player related functions for Corridor 7
                      3:  *
                      4:  *                                                     02/29/96  Les Bird
                      5:  ***************************************************************************/
                      6: 
                      7: #include "icorp.h"
                      8: #include <memcheck.h>
                      9: 
                     10: #define   VELSPEED       768
                     11: #define   TURNSPEED      128
                     12: #define   MAXMOUSEXVEL   1536
                     13: #define   MAXMOUSEYVEL   1536
                     14: 
                     15: #define   DIEMESSAGE     "PRESS SPACEBAR TO CONTINUE"
                     16: 
                     17: char keys[MAXKEYS],
                     18:      okeys[256];
                     19: 
                     20: int  currentView,
                     21:      gammaCorrection,
                     22:      localViewSize,
                     23:      mouseEnabled=1,
                     24:      mouseXSens=8,
                     25:      mouseYSens=8,
                     26:      viewWeapon;
                     27: 
                     28: int  doMainMenuFlag,
                     29:      horizCheckFlag=1,
                     30:      singleStepFlag;
                     31: 
                     32: int  playerHealth=1000,
                     33:      playerMaxHealth;
                     34: 
                     35: int  stfspeed=6;
                     36: 
                     37: unsigned
                     38: long playerInventory[MAXPLAYERS];
                     39: 
                     40: long trnvel,locavel,
                     41:      fwdvel,locfvel,
                     42:      stfvel,locsvel;
                     43: 
                     44: long omoves[MAXPLAYERS];
                     45: 
                     46: short horizCheckSprite=-1,
                     47:      horizSlopeGoal[MAXSPRITES];
                     48: 
                     49: short savemap;
                     50: 
                     51: struct player plr[MAXPLAYERS],
                     52:      *player[MAXPLAYERS];
                     53: 
                     54: extern
                     55: int  dumpDebugInfoFlag,
                     56:      showFrameRateFlag;
                     57: 
                     58: void
                     59: PLR_init(void)
                     60: {
                     61:      int  i;
                     62: 
                     63:      for (i=0 ; i < MAXPLAYERS ; i++) {
                     64:           player[i]=&plr[i];
                     65:      }
                     66: }
                     67: 
                     68: void
                     69: PLR_unInit(void)
                     70: {
                     71: }
                     72: 
                     73: void
                     74: PLR_initMouse(void)
                     75: {
                     76:      mouseEnabled=configMouse[MOUSE_ENABLE];
                     77:      if (mouseEnabled || editorEnabledFlag) {
                     78:           initmouse();
                     79:      }
                     80: }
                     81: 
                     82: int
                     83: PLR_getMouseXSense(void)
                     84: {
                     85:      return(mouseXSens);
                     86: }
                     87: 
                     88: void
                     89: PLR_setMouseXSense(int n)
                     90: {
                     91:      mouseXSens=n;
                     92: }
                     93: 
                     94: int
                     95: PLR_getMouseYSense(void)
                     96: {
                     97:      return(mouseYSens);
                     98: }
                     99: 
                    100: void
                    101: PLR_setMouseYSense(int n)
                    102: {
                    103:      mouseYSens=n;
                    104: }
                    105: 
                    106: int
                    107: PLR_isPlayer(short s)
                    108: {
                    109:      if (spritePtr[s]->statnum == STAT_PLAYER) {
                    110:           return(1);
                    111:      }
                    112:      return(0);
                    113: }
                    114: 
                    115: short
                    116: PLR_getPlayerNumber(short s)
                    117: {
                    118:      return(spritePtr[s]->owner&4095);
                    119: }
                    120: 
                    121: short
                    122: PLR_getPlayerSprite(short p)
                    123: {
                    124:      return(player[p]->spriteNum);
                    125: }
                    126: 
                    127: void
                    128: PLR_setMyWeapon(short gun)
                    129: {
                    130:      currentWeapon[PLR_getPlayerSprite(myconnectindex)]=gun;
                    131: }
                    132: 
                    133: short
                    134: PLR_getMyWeapon(void)
                    135: {
                    136:      return(currentWeapon[PLR_getPlayerSprite(myconnectindex)]);
                    137: }
                    138: 
                    139: void
                    140: PLR_setViewWeapon(short gun)
                    141: {
                    142:      viewWeapon=gun;
                    143: }
                    144: 
                    145: short
                    146: PLR_getViewWeapon(void)
                    147: {
                    148:      return(viewWeapon);
                    149: }
                    150: 
                    151: void
                    152: PLR_addInventoryItem(short s,short i)
                    153: {
                    154:      short p;
                    155: 
                    156:      if (PLR_isPlayer(s)) {
                    157:           p=PLR_getPlayerNumber(s);
                    158:           if (p >= 0 && p < MAXPLAYERS) {
                    159:                playerInventory[p]|=(1<<i);
                    160:           }
                    161:      }
                    162: }
                    163: 
                    164: void
                    165: PLR_removeInventoryItem(short s,short i)
                    166: {
                    167:      short p;
                    168: 
                    169:      if (PLR_isPlayer(s)) {
                    170:           p=PLR_getPlayerNumber(s);
                    171:           if (p >= 0 && p < MAXPLAYERS) {
                    172:                playerInventory[p]&=~(1<<i);
                    173:           }
                    174:      }
                    175: }
                    176: 
                    177: int
                    178: PLR_hasInventoryItem(short s,short i)
                    179: {
                    180:      short p;
                    181: 
                    182:      if (PLR_isPlayer(s)) {
                    183:           p=PLR_getPlayerNumber(s);
                    184:           if (p >= 0 && p < MAXPLAYERS) {
                    185:                if ((playerInventory[p]&(1<<i)) != 0) {
                    186:                     return(1);
                    187:                }
                    188:           }
                    189:      }
                    190:      return(0);
                    191: }
                    192: 
                    193: void
                    194: PLR_updateStatusHealth(void)
                    195: {
                    196:      short i,len=0,pic,s;
                    197:      long x,y;
                    198:      char locbuf[5];
                    199: 
                    200:      if (qsetmode != 200L) {
                    201:           return;
                    202:      }
                    203:      s=GAM_getViewSprite();
                    204:      sprintf(locbuf,"%d",ACT_getHealth(s)/10);
                    205:      for (i=0 ; i < strlen(locbuf) ; i++) {
                    206:           len+=tilesizx[graphicBigNum0Pic+locbuf[i]-'0'];
                    207:      }
                    208:      x=(xdim>>1)-80L-(len>>1);
                    209:      y=ydim-20L;
                    210:      for (i=0 ; i < strlen(locbuf) ; i++) {
                    211:           pic=graphicBigNum0Pic+locbuf[i]-'0';
                    212:           rotatesprite(x<<16,y<<16,65536L,0,pic,0,0,8+128,0L,0L,xdim-1L,ydim-1L);
                    213:           x+=tilesizx[pic];
                    214:      }
                    215: }
                    216: 
                    217: void
                    218: PLR_updateStatusAmmo(void)
                    219: {
                    220:      short i,len=0,pic,s;
                    221:      long x,y;
                    222:      char locbuf[5];
                    223: 
                    224:      if (qsetmode != 200L) {
                    225:           return;
                    226:      }
                    227:      s=GAM_getViewSprite();
                    228:      sprintf(locbuf,"%d",WEP_getAmmo(s,WEP_getSpriteAmmoType(s)));
                    229:      for (i=0 ; i < strlen(locbuf) ; i++) {
                    230:           len+=tilesizx[graphicBigNum0Pic+locbuf[i]-'0'];
                    231:      }
                    232:      x=(xdim>>1)-130L-(len>>1);
                    233:      y=ydim-20L;
                    234:      for (i=0 ; i < strlen(locbuf) ; i++) {
                    235:           pic=graphicBigNum0Pic+locbuf[i]-'0';
                    236:           rotatesprite(x<<16,y<<16,65536L,0,pic,0,0,8+128,0L,0L,xdim-1L,ydim-1L);
                    237:           x+=tilesizx[pic];
                    238:      }
                    239: }
                    240: 
                    241: void
                    242: PLR_updateStatusAliens(void)
                    243: {
                    244:      short i,len=0,pic;
                    245:      long x,y;
                    246:      char locbuf[5];
                    247: 
                    248:      if (qsetmode != 200L) {
                    249:           return;
                    250:      }
                    251:      sprintf(locbuf,"%d",GAM_getAliensLeft());
                    252:      for (i=0 ; i < strlen(locbuf) ; i++) {
                    253:           len+=tilesizx[graphicBigNum0Pic+locbuf[i]-'0'];
                    254:      }
                    255:      x=(xdim>>1)-30L-(len>>1);
                    256:      y=ydim-20L;
                    257:      for (i=0 ; i < strlen(locbuf) ; i++) {
                    258:           pic=graphicBigNum0Pic+locbuf[i]-'0';
                    259:           rotatesprite(x<<16,y<<16,65536L,0,pic,0,0,8+128,0L,0L,xdim-1L,ydim-1L);
                    260:           x+=tilesizx[pic];
                    261:      }
                    262: }
                    263: 
                    264: void
                    265: PLR_updateStatusBar(void)
                    266: {
                    267:      if (currentView >= 0 && WEP_getMissileView() == -1) {
                    268:           PLR_updateStatusHealth();
                    269:           PLR_updateStatusAmmo();
                    270:           PLR_updateStatusAliens();
                    271:      }
                    272: }
                    273: 
                    274: void
                    275: PLR_checkStatusBar(void)
                    276: {
                    277:      short aliens,ammo,health,s,update=0;
                    278:      static int oldHealth,oldAmmo,oldAliens;
                    279: 
                    280:      s=GAM_getViewSprite();
                    281:      if ((health=ACT_getHealth(s)) != oldHealth) {
                    282:           update=1;
                    283:      }
                    284:      if ((ammo=WEP_getAmmo(s,WEP_getSpriteAmmoType(s))) != oldAmmo) {
                    285:           update=1;
                    286:      }
                    287:      if ((aliens=GAM_getAliensLeft()) != oldAliens) {
                    288:           update=1;
                    289:      }
                    290:      if (update) {
                    291:           oldHealth=health;
                    292:           oldAmmo=ammo;
                    293:           oldAliens=aliens;
                    294:           GAM_updateStatusBar();
                    295:      }
                    296: }
                    297: 
                    298: int
                    299: PLR_getKillScore(short s)
                    300: {
                    301:      return(1);
                    302: }
                    303: 
                    304: void
                    305: PLR_adjScore(short s)
                    306: {
                    307:      short k,p;
                    308: 
                    309:      k=ACT_getKiller(s);
                    310:      p=PLR_getPlayerNumber(k);
                    311:      switch (gameMode) {
                    312:      case GAMEMODE_DEATHMATCH:
                    313:           if (PLR_isPlayer(s)) {
                    314:                if (s != PLR_getPlayerSprite(myconnectindex)) {
                    315:                     if (k >= 0) {
                    316:                          if (p >= 0 && p < MAXPLAYERS) {
                    317:                               player[p]->score+=PLR_getKillScore(s);
                    318:                          }
                    319:                          if (k == PLR_getPlayerSprite(myconnectindex)) {
                    320:                               GAM_adjAliensLeft(1);
                    321:                          }
                    322:                     }
                    323:                }
                    324:           }
                    325:           break;
                    326:      default:
                    327:           if (ACT_isActor(s)) {
                    328:                if (k >= 0) {
                    329:                     if (p >= 0 && p < MAXPLAYERS) {
                    330:                          player[p]->score+=PLR_getKillScore(s);
                    331:                     }
                    332:                }
                    333:                GAM_adjAliensLeft(-1);
                    334:           }
                    335:           break;
                    336:      }
                    337: }
                    338: 
                    339: void
                    340: PLR_initPlayers(void)
                    341: {
                    342:      int  i;
                    343: 
                    344:      for (i=0 ; i < MAXPLAYERS ; i++) {
                    345:           player[i]->spriteNum=-1;
                    346:      }
                    347:      currentView=0;
                    348: }
                    349: 
                    350: void
                    351: PLR_initPlayer(int p)
                    352: {
                    353:      player[p]->viewMode=3;
                    354:      player[p]->zoom=768L;
                    355:      player[p]->viewSize=localViewSize;
                    356:      if (p == currentView) {
                    357:           GFX_initPlayerShifts();
                    358:      }
                    359: }
                    360: 
                    361: void
                    362: PLR_initPlayerSprite(int p)
                    363: {
                    364:      int  i,j;
                    365:      long goalz;
                    366: 
                    367:      if (gameMode == GAMEMODE_DEATHMATCH) {
                    368:           if (numStartSpots == 0) {
                    369:                j=ENG_insertsprite(starts,STAT_PLAYER);
                    370:                spritePtr[j]->x=startx;
                    371:                spritePtr[j]->y=starty;
                    372:                spritePtr[j]->z=startz;
                    373:                spritePtr[j]->sectnum=starts;
                    374:                spritePtr[j]->ang=starta;
                    375:           }
                    376:           else {
                    377:                i=krand()%numStartSpots;
                    378:                j=ENG_insertsprite(startSpotDeathMatch[i].sectnum,STAT_PLAYER);
                    379:                spritePtr[j]->x=startSpotDeathMatch[i].x;
                    380:                spritePtr[j]->y=startSpotDeathMatch[i].y;
                    381:                spritePtr[j]->z=startSpotDeathMatch[i].z;
                    382:                spritePtr[j]->sectnum=startSpotDeathMatch[i].sectnum;
                    383:                spritePtr[j]->ang=startSpotDeathMatch[i].ang;
                    384:           }
                    385:      }
                    386:      else {
                    387:           if (p == connecthead || numStartSpots == 0) {
                    388:                j=ENG_insertsprite(starts,STAT_PLAYER);
                    389:                spritePtr[j]->x=startx;
                    390:                spritePtr[j]->y=starty;
                    391:                spritePtr[j]->z=startz;
                    392:                spritePtr[j]->sectnum=starts;
                    393:                spritePtr[j]->ang=starta;
                    394:           }
                    395:           else {
                    396:                i=krand()%numStartSpots;
                    397:                j=ENG_insertsprite(startSpot[i].sectnum,STAT_PLAYER);
                    398:                spritePtr[j]->x=startSpot[i].x;
                    399:                spritePtr[j]->y=startSpot[i].y;
                    400:                spritePtr[j]->z=startSpot[i].z;
                    401:                spritePtr[j]->sectnum=startSpot[i].sectnum;
                    402:                spritePtr[j]->ang=startSpot[i].ang;
                    403:           }
                    404:      }
                    405:      player[p]->spriteNum=j;
                    406:      spritePtr[j]->cstat=0;
                    407:      spritePtr[j]->picnum=enemyPic[curActor];
                    408:      spritePtr[j]->pal=p;
                    409:      spritePtr[j]->xrepeat=defaultPlayerWidth;
                    410:      spritePtr[j]->yrepeat=defaultPlayerHeight;
                    411:      spritePtr[j]->clipdist=spritePtr[j]->xrepeat;
                    412:      spritePtr[j]->owner=MAXSPRITES+p;
                    413:      getzrange(spritePtr[j]->x,spritePtr[j]->y,spritePtr[j]->z,
                    414:                spritePtr[j]->sectnum,&globhiz,&globhihit,
                    415:                &globloz,&globlohit,spritePtr[j]->clipdist<<1,0);
                    416:      spritePtr[j]->cstat|=(SPRC_BLOCKING|SPRC_BLOCKINGH);
                    417:      goalz=globloz;
                    418:      spritePtr[j]->z=goalz;
                    419:      GAM_onGround(j,1);
                    420:      ACT_setActorPic(j,spritePtr[j]->picnum);
                    421:      ACT_setHealth(j,playerHealth);
                    422:      spriteHoriz[j]=100;
                    423:      ACT_setKiller(j,-1);
                    424:      diez[p]=0L;
                    425:      if (p == myconnectindex) {
                    426:           show2dsprite[j>>3]|=(1<<(j&7));
                    427:      }
                    428:      currentWeapon[j]=GUN_1;
                    429:      fireFrame[j]=0;
                    430:      WEP_defaultAmmo(j);
                    431: }
                    432: 
                    433: void
                    434: PLR_initPlayerSprites(int nPlayers)
                    435: {
                    436:      int  i;
                    437: 
                    438:      if (ENG_editorGameMode()) {
                    439:           for (i=0 ; i < MAXPLAYERS ; i++) {
                    440:                connectpoint2[i]=-1;
                    441:           }
                    442:           currentView=connecthead;
                    443:           myconnectindex=connecthead;
                    444:           numplayers=1;
                    445:      }
                    446:      for (i=0 ; i < nPlayers ; i++) {
                    447:           PLR_initPlayer(i);
                    448:           PLR_initPlayerSprite(i);
                    449:      }
                    450: }
                    451: 
                    452: void
                    453: PLR_useCheck(short snum,long x,long y,long z,short sector,short ang)
                    454: {
                    455:      short nearsector,nearwall,nearsprite;
                    456:      long neardist;
                    457: 
                    458:      neartag(x,y,z,sector,ang,&nearsector,&nearwall,&nearsprite,&neardist,
                    459:              1024L,1);
                    460:      if (nearsprite != -1) {       // using a sprite
                    461:           EFF_operateSprite(nearsprite);
                    462:      }
                    463:      if (nearwall != -1) {         // using a wall
                    464:           EFF_operateWall(nearwall);
                    465:      }
                    466:      if (!EFF_operatableSector(nearsector)) {
                    467:           if (EFF_operatableSector(sector)) {
                    468:                nearsector=sector;
                    469:           }
                    470:      }
                    471:      if (nearsector != -1 && sectorPtr[nearsector]->hitag == 0) {
                    472:           EFF_operateSector(nearsector);
                    473:      }
                    474: }
                    475: 
                    476: void
                    477: PLR_dieAnim(short p)
                    478: {
                    479:      short clipheight,playerHeight,snum;
                    480:      long z;
                    481: 
                    482:      snum=PLR_getPlayerSprite(p);
                    483:      playerHeight=ACT_getActorViewHeight(spritePtr[snum]);
                    484:      clipheight=ACT_getActorClipHeight(spritePtr[snum]);
                    485:      z=globloz-playerHeight+diez[p];
                    486:      if (z < globloz-clipheight) {
                    487:           diez[p]+=(TICWAITPERFRAME<<8);
                    488:      }
                    489:      else {
                    490:           z=playerHeight-clipheight;
                    491:      }
                    492: }
                    493: 
                    494: void
                    495: PLR_movePlayer(short p)
                    496: {
                    497:      short ang,
                    498:           clipdist,clipheight,
                    499:           horizCheckSect,
                    500:           playerHeight,
                    501:           resetPlayerFlag,
                    502:           s,sect,
                    503:           zAdj;
                    504:      long horizCheckX,horizCheckY,horizCheckZ,x,xvect,y,yvect,z;
                    505:      struct moveFIFO *movePtr;
                    506:      spritetype *spr;
                    507:      sectortype *sectPtr;
                    508: 
                    509:      s=PLR_getPlayerSprite(p);
                    510:      spr=spritePtr[s];
                    511:      clipdist=ACT_getActorClipDist(spr);
                    512:      clipheight=ACT_getActorClipHeight(spr);
                    513:      playerHeight=ACT_getActorViewHeight(spr);
                    514:      zAdj=playerHeight;
                    515:      ang=spr->ang;
                    516:      x=spr->x;
                    517:      y=spr->y;
                    518:      z=spr->z-playerHeight;
                    519:      sect=spr->sectnum;
                    520:      movePtr=&moveFIFOBuf[p][moveFIFObeg];
                    521:      currentWeapon[s]=movePtr->weapon;
                    522:      if (forceVel[s] != 0 || movePtr->fvel != 0L || movePtr->svel != 0L) {
                    523:           xvect=0L;
                    524:           yvect=0L;
                    525:           if (forceVel[s] != 0) {
                    526:                xvect=mulscale2((long)forceVel[s],
                    527:                                (long)sintable[(forceAng[s]+512)&2047]);
                    528:                yvect=mulscale2((long)forceVel[s],
                    529:                                (long)sintable[forceAng[s]]);
                    530:                forceVel[s]=kmax(forceVel[s]-(TICWAITPERFRAME<<2),0);
                    531:           }
                    532:           if (movePtr->fvel != 0L) {
                    533:                xvect+=mulscale3(movePtr->fvel,(long)sintable[(ang+512)&2047]);
                    534:                yvect+=mulscale3(movePtr->fvel,(long)sintable[ang]);
                    535:           }
                    536:           if (movePtr->svel != 0L) {
                    537:                xvect+=mulscale3(movePtr->svel,(long)sintable[ang]);
                    538:                yvect+=mulscale3(movePtr->svel,(long)sintable[(ang+1536)&2047]);
                    539:           }
                    540:           clipmove(&x,&y,&z,&sect,xvect,yvect,clipdist,clipheight,clipheight,0);
                    541:      }
                    542:      if (movePtr->avel != 0) {
                    543:           ang+=((movePtr->avel*TICWAITPERFRAME)>>4);
                    544:           ang&=2047;
                    545:      }
                    546:      spr->cstat&=~SPRC_BLOCKING;
                    547:      if (pushmove(&x,&y,&z,&sect,clipdist,clipheight,clipheight,0) < 0) {
                    548:           if (!ACT_isDead(s)) {
                    549:                ACT_killPlayer(s);
                    550:           }
                    551:      }
                    552:      getzrange(x,y,z,sect,&globhiz,&globhihit,&globloz,&globlohit,clipdist,0);
                    553:      sectPtr=sectorPtr[sect];
                    554:      if ((sectPtr->floorstat&0x02) != 0 || (sectPtr->ceilingstat&0x02) != 0) {
                    555:           getzsofslope(sect,x,y,&globhiz,&globloz);
                    556:      }
                    557:      horizSlopeGoal[s]=0;
                    558:      if (horizCheckFlag && GAM_isOnGround(s)) {
                    559:           if ((sectPtr->floorstat&0x02) != 0) {   // on a slope
                    560:                horizCheckX=x+((long)sintable[(ang+512)&2047]>>4);
                    561:                horizCheckY=y+((long)sintable[ang]>>4);
                    562:                updatesector(horizCheckX,horizCheckY,&horizCheckSect);
                    563:                if (horizCheckSect != -1) {
                    564:                     horizCheckZ=getflorzofslope(horizCheckSect,
                    565:                                                 horizCheckX,
                    566:                                                 horizCheckY);
                    567:                     horizSlopeGoal[s]=kmin((spr->z-horizCheckZ)>>7,200);
                    568:                     if (horizCheckSprite != -1) {
                    569:                          setsprite(horizCheckSprite,horizCheckX,
                    570:                                    horizCheckY,horizCheckZ);
                    571:                          spritePtr[horizCheckSprite]->ang=ang;
                    572:                     }
                    573:                }
                    574:           }
                    575:      }
                    576:      if (horizSlopeAdj[s] < horizSlopeGoal[s]) {
                    577:           horizSlopeAdj[s]=kmin(horizSlopeAdj[s]+(TICWAITPERFRAME<<1),
                    578:                                 horizSlopeGoal[s]);
                    579:      }
                    580:      else if (horizSlopeAdj[s] > horizSlopeGoal[s]) {
                    581:           horizSlopeAdj[s]=kmax(horizSlopeAdj[s]-(TICWAITPERFRAME<<1),
                    582:                                 horizSlopeGoal[s]);
                    583:      }
                    584:      if (ACT_isDead(s)) {
                    585:           zAdj=0;
                    586:           spr->zvel=0;
                    587:           PLR_dieAnim(p);
                    588:           goto playerdeadlabel;
                    589:      }
                    590:      spr->cstat|=SPRC_BLOCKING;
                    591:      ACT_inSector(s,sect);
                    592:      if (sect != spr->sectnum) {
                    593:           ACT_newSector(s,&spr->sectnum,&sect,&ang,&x,&y,&z);
                    594:      }
                    595:      if ((globlohit&0x4000) == 0x4000) {     // on a sector
                    596:           if ((globlohit&(MAXSECTORS-1)) != sect) {
                    597:                if (EFF_isBonusSector(globlohit&(MAXSECTORS-1))) {
                    598:                     ACT_getBonusSectorItem(s,globlohit&(MAXSECTORS-1));
                    599:                }
                    600:           }
                    601:      }
                    602:      if ((globlohit&0xC000) == 0xC000) {     // on a sprite
                    603:           EFF_onSprite(s,globlohit&(MAXSPRITES-1),&ang,&sect,&x,&y,&z);
                    604:      }
                    605:      if ((movePtr->moves&MOVES_LOOKUP) != 0) {
                    606:           spriteHoriz[s]=kmax(spriteHoriz[s]-(TICWAITPERFRAME<<1),0);
                    607:      }
                    608:      if ((movePtr->moves&MOVES_LOOKDN) != 0) {
                    609:           spriteHoriz[s]=kmin(spriteHoriz[s]+(TICWAITPERFRAME<<1),200);
                    610:      }
                    611:      if ((movePtr->moves&MOVES_AUTOCENTER) != 0) {
                    612:           plr->autocenter=1;
                    613:      }
                    614:      if (plr->autocenter != 0) {
                    615:           if (spriteHoriz[s] < 100) {
                    616:                spriteHoriz[s]=kmin(spriteHoriz[s]+(TICWAITPERFRAME<<1),100);
                    617:           }
                    618:           else if (spriteHoriz[s] > 100) {
                    619:                spriteHoriz[s]=kmax(spriteHoriz[s]-(TICWAITPERFRAME<<1),100);
                    620:           }
                    621:           else {
                    622:                plr->autocenter=0;
                    623:           }
                    624:      }
                    625:      if ((movePtr->moves&MOVES_SHOOT) != 0) {
                    626:           WEP_weaponActivated(s);
                    627:      }
                    628:      else {
                    629:           firingWeapon[s]=0;
                    630:      }
                    631:      if (GAM_isOnGround(s)) {
                    632:           if ((movePtr->moves&MOVES_JUMP) != 0) {
                    633:                spr->zvel-=jumpVelocity;
                    634:           }
                    635: #if 0
                    636:           else if ((movePtr->moves&MOVES_CROUCH) != 0) {
                    637:                zAdj>>=1;
                    638:           }
                    639: #endif
                    640:      }
                    641: playerdeadlabel:
                    642:      resetPlayerFlag=0;
                    643:      if ((movePtr->moves&MOVES_USE) != 0 && (omoves[p]&MOVES_USE) == 0) {
                    644:           if (ACT_isDead(s)) {
                    645:                switch (gameType) {
                    646:                case GAMETYPE_SINGLE:
                    647:                     playingGameFlag=0;
                    648:                     loadLevelFlag=1;
                    649:                     break;
                    650:                default:
                    651:                     resetPlayerFlag=1;
                    652:                     break;
                    653:                }
                    654:           }
                    655:           else {
                    656:                PLR_useCheck(s,x,y,z,sect,ang);
                    657:           }
                    658:      }
                    659: //** do game physics
                    660:      GAM_doPhysics(s,&z,&spr->zvel,zAdj,playerHeight,clipheight);
                    661: //**
                    662:      setsprite(s,x,y,z+playerHeight);
                    663:      spr->ang=ang;
                    664:      if (ACT_isDead(s)) {
                    665:           if (resetPlayerFlag) {
                    666:                GAM_setupVideo(viewSize);
                    667:                PLR_initPlayer(p);
                    668:                PLR_initPlayerSprite(p);
                    669:           }
                    670:      }
                    671:      else {
                    672:           if (sect < 0 || sect >= numsectors) {
                    673:                ACT_killPlayer(s);
                    674:           }
                    675:      }
                    676:      omoves[p]=movePtr->moves;
                    677: }
                    678: 
                    679: void
                    680: PLR_doActors(void)
                    681: {
                    682:      int  p;
                    683: 
                    684:      for (p=connecthead ; p >= 0 ; p=connectpoint2[p]) {
                    685:           PLR_movePlayer(p);
                    686:           WEP_spriteFireWeapon(PLR_getPlayerSprite(p));
                    687:      }
                    688: }
                    689: 
                    690: int
                    691: PLR_oneTimeKey(int keynum)
                    692: {
                    693:      if (tkeys[keynum] != 0 && okeys[keynum] == 0) {
                    694:           return(1);
                    695:      }
                    696:      return(0);
                    697: }
                    698: 
                    699: void
                    700: PLR_getMouse(short *x,short *y,short *b)
                    701: {
                    702:      if (mouseEnabled) {
                    703:           getmousevalues(x,y,b);
                    704:      }
                    705:      else {
                    706:           *x=0;
                    707:           *y=0;
                    708:           *b=0;
                    709:      }
                    710: }
                    711: 
                    712: void
                    713: PLR_getInput(void)
                    714: {
                    715:      int  i,j,moving,running,strafing,turning;
                    716:      short mb=0,mx=0,my=0,snum;
                    717:      long mavel,mfvel,msvel,maxvel;
                    718:      spritetype *spr;
                    719:      struct player *plr;
                    720: 
                    721:      plr=player[myconnectindex];
                    722: //** copy current key states
                    723:      KBD_copyKeys();
                    724: //** do menu input if on main menu while playing game
                    725:      if (inMenuFlag) {
                    726:           MEN_getInput();
                    727:           goto menuskip;
                    728:      }
                    729:      snum=plr->spriteNum;
                    730:      spr=spritePtr[snum];
                    731: //** hard coded keys (local console)
                    732:      if (tkeys[K_ESC] != 0) {
                    733:           if (playingGameFlag) {
                    734:                if (qsetmode == 200L) {
                    735:                     doMainMenuFlag=1;
                    736:                }
                    737:           }
                    738:      }
                    739:      if (PLR_oneTimeKey(K_F1)) {        // HELP screen
                    740:           GAM_helpScreen();
                    741:      }
                    742:      else if (PLR_oneTimeKey(K_F2)) {   // SAVE game
                    743:           noEnemiesFlag=1;
                    744:           MEN_saveGameOption();
                    745:           noEnemiesFlag=0;
                    746:           GAM_setupVideo(viewSize);
                    747:      }
                    748:      else if (PLR_oneTimeKey(K_F3)) {   // LOAD game
                    749:           noEnemiesFlag=1;
                    750:           if (MEN_loadGameOption()) {
                    751:                loadLevelFlag=1;
                    752:           }
                    753:           noEnemiesFlag=0;
                    754:           GAM_setupVideo(viewSize);
                    755:      }
                    756:      else if (PLR_oneTimeKey(K_F4)) {   // sound options (volume)
                    757:           noEnemiesFlag=1;
                    758:           MEN_soundOptions();
                    759:           noEnemiesFlag=0;
                    760:           GAM_setupVideo(viewSize);
                    761:      }
                    762:      else if (PLR_oneTimeKey(K_F5)) {   // graphics options (detail)
                    763:           noEnemiesFlag=1;
                    764:           MEN_graphicOptions();
                    765:           noEnemiesFlag=0;
                    766:           GAM_setupVideo(viewSize);
                    767:      }
                    768:      else if (PLR_oneTimeKey(K_F6)) {   // QUICKSAVE game
                    769:           noEnemiesFlag=1;
                    770:           MEN_allocFrameTile();
                    771:           if (MEN_getSaveName(menuBackgroundPic,"QUICK SAVE")) {
                    772:                MEN_saveGameData();
                    773:                MEN_saveScreenShot();
                    774:           }
                    775:           MEN_freeFrameTile();
                    776:           noEnemiesFlag=0;
                    777:           GAM_setupVideo(viewSize);
                    778:      }
                    779:      else if (PLR_oneTimeKey(K_F7)) {   // END game
                    780:           noEnemiesFlag=1;
                    781:           if (MEN_areYouSure()) {
                    782:                playingGameFlag=0;
                    783:                inMenuFlag=0;
                    784:           }
                    785:           noEnemiesFlag=0;
                    786:           GAM_setupVideo(viewSize);
                    787:      }
                    788:      else if (PLR_oneTimeKey(K_F8)) {   // repeat messages
                    789:      }
                    790:      else if (PLR_oneTimeKey(K_F9)) {   // QUICKLOAD game
                    791:           noEnemiesFlag=1;
                    792:           if (MEN_getLoadName()) {
                    793:                MEN_loadGameData();
                    794:           }
                    795:           noEnemiesFlag=0;
                    796:           GAM_setupVideo(viewSize);
                    797:      }
                    798:      if (tkeys[K_LEFTALT] != 0) {       // special ALT-key combinations
                    799:           if (PLR_oneTimeKey(K_D)) {
                    800:                debugModeFlag^=1;
                    801:           }
                    802:           else if (PLR_oneTimeKey(K_F)) {
                    803:                showFrameRateFlag^=1;
                    804:           }
                    805:           else if (PLR_oneTimeKey(K_G)) {
                    806:                plr->gridSize=(plr->gridSize+1)%6;
                    807:           }
                    808:           else if (PLR_oneTimeKey(K_5)) {
                    809:                noEnemiesFlag^=1;
                    810:                EFF_displayMessage("ENEMIES %s",noEnemiesFlag ? "DISABLED" :
                    811:                                                                "ENABLED");
                    812:           }
                    813:           else if (PLR_oneTimeKey(K_6)) {
                    814:                if (horizCheckSprite == -1) {
                    815:                     horizCheckSprite=ENG_insertsprite(spr->sectnum,STAT_NONE);
                    816:                     spritePtr[horizCheckSprite]->x=spr->x;
                    817:                     spritePtr[horizCheckSprite]->y=spr->y;
                    818:                     spritePtr[horizCheckSprite]->z=spr->z;
                    819:                     spritePtr[horizCheckSprite]->cstat=spr->cstat;
                    820:                     spritePtr[horizCheckSprite]->picnum=spr->picnum;
                    821:                     spritePtr[horizCheckSprite]->shade=spr->shade;
                    822:                     spritePtr[horizCheckSprite]->pal=spr->pal;
                    823:                     spritePtr[horizCheckSprite]->clipdist=spr->clipdist;
                    824:                     spritePtr[horizCheckSprite]->xrepeat=16;
                    825:                     spritePtr[horizCheckSprite]->yrepeat=16;
                    826:                     spritePtr[horizCheckSprite]->ang=spr->ang;
                    827:                     EFF_displayMessage("HORIZ DEBUG ON");
                    828:                }
                    829:                else {
                    830:                     ENG_deletesprite(horizCheckSprite);
                    831:                     horizCheckSprite=-1;
                    832:                     EFF_displayMessage("HORIZ DEBUG OFF");
                    833:                }
                    834:           }
                    835:           else if (PLR_oneTimeKey(K_0)) {
                    836:                if (!dumpDebugInfoFlag) {
                    837:                     if (dbgfp != NULL) {
                    838:                          fclose(dbgfp);
                    839:                          EFF_displayMessage("DEBUG FILE CLOSED");
                    840:                     }
                    841:                     else {
                    842:                          sprintf(tempbuf,"DEBUG.%03d",myconnectindex);
                    843:                          dbgfp=fopen(tempbuf,"w");
                    844:                          EFF_displayMessage("FILE %s OPENED",tempbuf);
                    845:                     }
                    846:                }
                    847:           }
                    848:           else if (PLR_oneTimeKey(K_P)) {
                    849:                GFX_redShift(256);
                    850:                GFX_greenShift(512);
                    851:                GFX_blueShift(768);
                    852:                EFF_displayMessage("PALETTE SHIFT TEST");
                    853:           }
                    854:           else if (PLR_oneTimeKey(K_S)) {
                    855:                sprintf(tempbuf,"SAVE%04d.MAP",savemap++);
                    856:                saveboard(tempbuf,&spr->x,&spr->y,&spr->z,&spr->ang,
                    857:                          &spr->sectnum);
                    858:           }
                    859:           else if (PLR_oneTimeKey(K_1)) {        // add player
                    860:                if (numplayers < MAXPLAYERS) {
                    861:                     j=connecthead;
                    862:                     i=connectpoint2[j];
                    863:                     while (i != -1) {
                    864:                          j=i;
                    865:                          i=connectpoint2[j];
                    866:                     }
                    867:                     i=connectpoint2[j]=numplayers++;
                    868:                     PLR_initPlayer(i);
                    869:                     PLR_initPlayerSprite(i);
                    870:                }
                    871:           }
                    872:           else if (PLR_oneTimeKey(K_2)) {        // switch view
                    873:                currentView=connectpoint2[currentView];
                    874:                if (currentView == -1) {
                    875:                     currentView=connecthead;
                    876:                }
                    877:                i=currentWeapon[PLR_getPlayerSprite(currentView)];
                    878:                PLR_setViewWeapon(i);
                    879:           }
                    880:           else if (PLR_oneTimeKey(K_3)) {        // switch control
                    881:                myconnectindex=connectpoint2[myconnectindex];
                    882:                if (myconnectindex == -1) {
                    883:                     myconnectindex=connecthead;
                    884:                }
                    885:           }
                    886:           else if (PLR_oneTimeKey(K_4)) {        // missile camera
                    887:                if (WEP_getMissileView() >= 0) {
                    888:                     WEP_setMissileView(-1);
                    889:                }
                    890:                else {
                    891:                     WEP_setMissileView(WEP_findMissileView(snum));
                    892:                     if (WEP_getMissileView() >= 0) {
                    893:                          EFF_displayMessage("MISSILE VIEW");
                    894:                     }
                    895:                     else {
                    896:                          EFF_displayMessage("MISSILE VIEW FAILED");
                    897:                     }
                    898:                }
                    899:           }
                    900:           else if (PLR_oneTimeKey(K_9)) {         // single step mode
                    901:                singleStepFlag^=1;
                    902:                EFF_displayMessage("SINGLE STEP MODE %s",singleStepFlag ?
                    903:                                   "ENABLED" : "DISABLED");
                    904:           }
                    905:      }
                    906:      if (tkeys[K_F10] != 0) {      // F10 = quick exit
                    907:           inGameFlag=0;
                    908:           playingGameFlag=0;
                    909:           inMenuFlag=0;
                    910:      }
                    911: menuskip:
                    912:      if (PLR_oneTimeKey(K_F11)) {
                    913:           if (tkeys[K_LEFTALT] != 0) {
                    914:                visibility-=64;
                    915:                if (visibility < 0) {
                    916:                     visibility=512;
                    917:                }
                    918:                EFF_displayMessage("VISIBILITY: %d",visibility);
                    919:           }
                    920:           else {
                    921:                gammaCorrection++;
                    922:                if (gammaCorrection > 8) {
                    923:                     gammaCorrection=0;
                    924:                }
                    925:                setbrightness(gammaCorrection,(char *)&palette[0]);
                    926:                EFF_displayMessage("GAMMA CORRECTION: %d",gammaCorrection);
                    927:           }
                    928:      }
                    929:      if (PLR_oneTimeKey(K_F12)) {
                    930:           screencapture("captxxxx.pcx",0);
                    931:      }
                    932: //** programmable keys
                    933:      if (playingGameFlag) {
                    934:           mavel=0;                 // mouse velocities
                    935:           mfvel=0;
                    936:           msvel=0;
                    937:           moving=0;
                    938:           running=0;
                    939:           strafing=0;
                    940:           turning=0;
                    941:           maxvel=VELSPEED;
                    942:           plr->moves=0L;
                    943:           if (inMenuFlag) {
                    944:                goto menuskip2;
                    945:           }
                    946: //** read controller buttons
                    947:           if (!ACT_isDead(snum)) {
                    948:                if (mouseEnabled) {
                    949:                     PLR_getMouse(&mx,&my,&mb);
                    950:                     if ((mb&1) != 0) {  // left mouse button
                    951:                          tkeys[keys[configMouse[MOUSE_LEFTBUTTON]]]=1;
                    952:                     }
                    953:                     if ((mb&2) != 0) {  // right mouse button
                    954:                          tkeys[keys[configMouse[MOUSE_RIGHTBUTTON]]]=1;
                    955:                     }
                    956:                     if ((mb&4) != 0) {  // middle mouse button
                    957:                          tkeys[keys[configMouse[MOUSE_MIDDLEBUTTON]]]=1;
                    958:                     }
                    959:                }
                    960:                if (tkeys[keys[KEYRUN]] != 0) {
                    961:                     maxvel<<=1;
                    962:                     running=1;
                    963:                }
                    964:                if (tkeys[keys[KEYSTRAFE]] != 0) {
                    965:                     strafing=1;
                    966:                }
                    967: //** apply force to motion & rotation
                    968:                if (tkeys[keys[KEYFWD]] != 0) {
                    969:                     if (fwdvel < 0L) {
                    970:                          fwdvel=0L;
                    971:                     }
                    972:                     fwdvel=min(fwdvel+(TICWAITPERFRAME<<6),maxvel-1);
                    973:                     moving=1;
                    974:                }
                    975:                else if (tkeys[keys[KEYBACK]] != 0) {
                    976:                     if (fwdvel > 0L) {
                    977:                          fwdvel=0L;
                    978:                     }
                    979:                     fwdvel=max(fwdvel-(TICWAITPERFRAME<<6),-maxvel);
                    980:                     moving=1;
                    981:                }
                    982:                if (tkeys[keys[KEYLEFT]] != 0) {
                    983:                     if (strafing) {
                    984:                          if (stfvel < 0L) {
                    985:                               stfvel=0L;
                    986:                          }
                    987:                          stfvel=min(stfvel+(TICWAITPERFRAME<<stfspeed),
                    988:                                     maxvel-1);
                    989:                          strafing=2;
                    990:                     }
                    991:                     else {
                    992:                          if (trnvel > 0L) {
                    993:                               trnvel=0L;
                    994:                          }
                    995:                          trnvel=max(trnvel-(TICWAITPERFRAME<<4),-TURNSPEED);
                    996:                          turning=1;
                    997:                     }
                    998:                }
                    999:                else if (tkeys[keys[KEYRIGHT]] != 0) {
                   1000:                     if (strafing) {
                   1001:                          if (stfvel > 0L) {
                   1002:                               stfvel=0L;
                   1003:                          }
                   1004:                          stfvel=max(stfvel-(TICWAITPERFRAME<<stfspeed),
                   1005:                                     -maxvel);
                   1006:                          strafing=2;
                   1007:                     }
                   1008:                     else {
                   1009:                          if (trnvel < 0L) {
                   1010:                               trnvel=0L;
                   1011:                          }
                   1012:                          trnvel=min(trnvel+(TICWAITPERFRAME<<4),TURNSPEED-1);
                   1013:                          turning=1;
                   1014:                     }
                   1015:                }
                   1016:                if (tkeys[keys[KEYSTFL]] != 0) {
                   1017:                     if (stfvel < 0L) {
                   1018:                          stfvel=0L;
                   1019:                     }
                   1020:                     stfvel=min(stfvel+(TICWAITPERFRAME<<stfspeed),
                   1021:                                maxvel-1);
                   1022:                     strafing=2;
                   1023:                }
                   1024:                else if (tkeys[keys[KEYSTFR]] != 0) {
                   1025:                     if (stfvel > 0L) {
                   1026:                          stfvel=0L;
                   1027:                     }
                   1028:                     stfvel=max(stfvel-(TICWAITPERFRAME<<stfspeed),
                   1029:                                -maxvel);
                   1030:                     strafing=2;
                   1031:                }
                   1032:           }
                   1033: //** look up and look down code
                   1034:           if (tkeys[keys[KEYLKUP]] != 0) {
                   1035:                plr->autocenter=0;
                   1036:                plr->moves|=MOVES_LOOKUP;
                   1037:           }
                   1038:           if (tkeys[keys[KEYLKDN]] != 0) {
                   1039:                plr->autocenter=0;
                   1040:                plr->moves|=MOVES_LOOKDN;
                   1041:           }
                   1042:           if (tkeys[keys[KEYCNTR]] != 0) {
                   1043:                plr->moves|=MOVES_AUTOCENTER;
                   1044:           }
                   1045: //** fire weapon code
                   1046:           if (!ACT_isDead(snum) && !inMenuFlag) {
                   1047:                for (i=0 ; i < MAXWEAPONS ; i++) {
                   1048:                     if (tkeys[K_1+i] != 0) {
                   1049:                          if (i != currentWeapon[snum]) {
                   1050:                               WEP_changeWeapon(i);
                   1051:                          }
                   1052:                          break;
                   1053:                     }
                   1054:                }
                   1055:                if (tkeys[keys[KEYFIRE]] != 0 && WEP_changingWeapon() == 0) {
                   1056:                     plr->moves|=MOVES_SHOOT;
                   1057:                }
                   1058: //** jump & crouch code
                   1059:                if (PLR_oneTimeKey(keys[KEYJUMP])) {
                   1060:                     if (GAM_isOnGround(snum)) {
                   1061:                          plr->moves|=MOVES_JUMP;
                   1062:                     }
                   1063:                }
                   1064:                if (tkeys[keys[KEYCROUCH]] != 0) {
                   1065:                     plr->moves|=MOVES_CROUCH;
                   1066:                }
                   1067:           }
                   1068: //** switch to map mode & zoom in/zoom out code
                   1069:           if (PLR_oneTimeKey(keys[KEYMAP])) {
                   1070:                plr->viewMode++;
                   1071:                if (plr->viewMode > 3) {
                   1072:                     plr->viewMode=0;
                   1073:                }
                   1074:           }
                   1075:           if (plr->viewMode != 3) {
                   1076:                if (tkeys[keys[KEYZOOMO]] != 0) {
                   1077:                     if (plr->zoom > 48L) {
                   1078:                          plr->zoom-=(plr->zoom>>4);
                   1079:                     }
                   1080:                }
                   1081:                else if (tkeys[keys[KEYZOOMI]] != 0) {
                   1082:                     if (plr->zoom < 4096L) {
                   1083:                          plr->zoom+=(plr->zoom>>4);
                   1084:                     }
                   1085:                }
                   1086:           }
                   1087:           else if (plr->viewMode == 3) {
                   1088:                if (PLR_oneTimeKey(keys[KEYZOOMO])) {
                   1089:                     if (plr->viewSize > xdim) {
                   1090:                          plr->viewSize=xdim;
                   1091:                     }
                   1092:                     else {
                   1093:                          plr->viewSize-=8;
                   1094:                     }
                   1095:                     if (plr->viewSize < 64) {
                   1096:                          plr->viewSize=64;
                   1097:                     }
                   1098:                     localViewSize=plr->viewSize;
                   1099:                }
                   1100:                else if (PLR_oneTimeKey(keys[KEYZOOMI])) {
                   1101:                     plr->viewSize+=8;
                   1102:                     if (plr->viewSize > xdim) {
                   1103:                          plr->viewSize=xdim+1;
                   1104:                     }
                   1105:                     localViewSize=plr->viewSize;
                   1106:                }
                   1107:           }
                   1108: //** operate sectors/sprites code
                   1109:           if (PLR_oneTimeKey(keys[KEYUSE])) {
                   1110:                plr->moves|=MOVES_USE;
                   1111:           }
                   1112: //** apply mouse velocities
                   1113:           if (mouseEnabled) {
                   1114:                if (my != 0) {
                   1115:                     mfvel=min(max(-(my*mouseYSens),-MAXMOUSEYVEL),
                   1116:                              MAXMOUSEYVEL-1);
                   1117:                }
                   1118:                if (mx != 0) {
                   1119:                     if (strafing == 1) {
                   1120:                          msvel=min(max(-(mx*mouseXSens),-MAXMOUSEXVEL),
                   1121:                                   MAXMOUSEXVEL-1);
                   1122:                     }
                   1123:                     else {
                   1124:                          mavel=min(max((mx*mouseXSens)>>2,-MAXMOUSEXVEL),
                   1125:                                   MAXMOUSEXVEL-1);
                   1126:                     }
                   1127:                }
                   1128:           }
                   1129: //** apply physics to motion & rotation
                   1130: menuskip2:
                   1131:           if (!moving) {
                   1132:                if (fwdvel < -VELSPEED) {
                   1133:                     fwdvel=-VELSPEED;
                   1134:                }
                   1135:                else if (fwdvel > VELSPEED) {
                   1136:                     fwdvel=VELSPEED;
                   1137:                }
                   1138:                if (fwdvel < 0) {
                   1139:                     fwdvel=min(fwdvel+(TICWAITPERFRAME<<5),0);
                   1140:                }
                   1141:                else if (fwdvel > 0) {
                   1142:                     fwdvel=max(fwdvel-(TICWAITPERFRAME<<5),0);
                   1143:                }
                   1144:           }
                   1145:           if (strafing != 2) {
                   1146:                if (stfvel < 0) {
                   1147:                     stfvel=min(stfvel+(TICWAITPERFRAME<<6),0);
                   1148:                }
                   1149:                else if (stfvel > 0) {
                   1150:                     stfvel=max(stfvel-(TICWAITPERFRAME<<6),0);
                   1151:                }
                   1152:           }
                   1153:           if (!turning) {
                   1154:                if (trnvel < 0) {
                   1155:                     trnvel=min(trnvel+(TICWAITPERFRAME<<4),0);
                   1156:                }
                   1157:                else if (trnvel > 0) {
                   1158:                     trnvel=max(trnvel-(TICWAITPERFRAME<<4),0);
                   1159:                }
                   1160:           }
                   1161:           locavel=trnvel+mavel;
                   1162:           locfvel=fwdvel+mfvel;
                   1163:           locsvel=stfvel+msvel;
                   1164:      }
                   1165:      memmove(okeys,tkeys,sizeof(okeys));
                   1166: }
                   1167: 
                   1168: void
                   1169: PLR_doStatusCode(void)
                   1170: {
                   1171: }
                   1172: 
                   1173: void
                   1174: PLR_checkStatus(void)
                   1175: {
                   1176:      long x;
                   1177: 
                   1178:      if (ACT_isDead(GAM_getViewSprite())) {
                   1179:           if (qsetmode == 200L) {
                   1180:                x=(xdim>>1)-(strlen(DIEMESSAGE)<<2);
                   1181:                printext256(x,8L,P256COLOR,-1,DIEMESSAGE,0);
                   1182:           }
                   1183:      }
                   1184: }
                   1185: 
                   1186: void
                   1187: PLR_saveGame(FILE *fp)
                   1188: {
                   1189:      short i,s;
                   1190: 
                   1191:      GAM_fwrite(&currentView,sizeof(int),1,fp);
                   1192:      GAM_fwrite(plr,sizeof(struct player),MAXPLAYERS,fp);
                   1193:      for (i=connecthead ; i >= 0 ; i=connectpoint2[i]) {
                   1194:           s=PLR_getPlayerSprite(i);
                   1195:           GAM_fwrite(&ammo[s],sizeof(short),MAXWEAPONTYPES,fp);
                   1196:           GAM_fwrite(&attackers[s],sizeof(char),1,fp);
                   1197:           GAM_fwrite(&fireFrame[s],sizeof(char),1,fp);
                   1198:           GAM_fwrite(&firingWeapon[s],sizeof(char),1,fp);
                   1199:           GAM_fwrite(&spriteHoriz[s],sizeof(short),1,fp);
                   1200:           GAM_fwrite(&forceAng[s],sizeof(short),1,fp);
                   1201:           GAM_fwrite(&forceVel[s],sizeof(short),1,fp);
                   1202:      }
                   1203:      GAM_fwrite(&playerHealth,sizeof(int),1,fp);
                   1204:      GAM_fwrite(&playerMaxHealth,sizeof(int),1,fp);
                   1205:      GAM_fwrite(&trnvel,sizeof(long),1,fp);
                   1206:      GAM_fwrite(&locavel,sizeof(long),1,fp);
                   1207:      GAM_fwrite(&fwdvel,sizeof(long),1,fp);
                   1208:      GAM_fwrite(&locfvel,sizeof(long),1,fp);
                   1209:      GAM_fwrite(&stfvel,sizeof(long),1,fp);
                   1210:      GAM_fwrite(&locsvel,sizeof(long),1,fp);
                   1211: }
                   1212: 
                   1213: void
                   1214: PLR_loadGame(FILE *fp)
                   1215: {
                   1216:      short i,s;
                   1217: 
                   1218:      GAM_fread(&currentView,sizeof(int),1,fp);
                   1219:      GAM_fread(plr,sizeof(struct player),MAXPLAYERS,fp);
                   1220:      for (i=connecthead ; i >= 0 ; i=connectpoint2[i]) {
                   1221:           s=PLR_getPlayerSprite(i);
                   1222:           GAM_fread(&ammo[s],sizeof(short),MAXWEAPONTYPES,fp);
                   1223:           GAM_fread(&attackers[s],sizeof(char),1,fp);
                   1224:           GAM_fread(&fireFrame[s],sizeof(char),1,fp);
                   1225:           GAM_fread(&firingWeapon[s],sizeof(char),1,fp);
                   1226:           GAM_fread(&spriteHoriz[s],sizeof(short),1,fp);
                   1227:           GAM_fread(&forceAng[s],sizeof(short),1,fp);
                   1228:           GAM_fread(&forceVel[s],sizeof(short),1,fp);
                   1229:      }
                   1230:      GAM_fread(&playerHealth,sizeof(int),1,fp);
                   1231:      GAM_fread(&playerMaxHealth,sizeof(int),1,fp);
                   1232:      GAM_fread(&trnvel,sizeof(long),1,fp);
                   1233:      GAM_fread(&locavel,sizeof(long),1,fp);
                   1234:      GAM_fread(&fwdvel,sizeof(long),1,fp);
                   1235:      GAM_fread(&locfvel,sizeof(long),1,fp);
                   1236:      GAM_fread(&stfvel,sizeof(long),1,fp);
                   1237:      GAM_fread(&locsvel,sizeof(long),1,fp);
                   1238: }
                   1239: 
                   1240: //** debug code follows
                   1241: 
                   1242: void
                   1243: PLR_debug(void)
                   1244: {
                   1245:      int  p,s;
                   1246:      spritetype *spr;
                   1247: 
                   1248:      for (p=connecthead ; p >= 0 ; p=connectpoint2[p]) {
                   1249:           s=PLR_getPlayerSprite(p);
                   1250:           spr=spritePtr[s];
                   1251:           debugOut(windowx1,windowy1,"P=%d X=%06d Y=%06d Z=%06d A=%04d H=%d "
                   1252:                    "AM=%d G=%d HOR=%d",p,spr->x,spr->y,spr->z,spr->ang,
                   1253:                    ACT_getHealth(s),WEP_getAmmo(s,WEP_getSpriteAmmoType(s)),
                   1254:                    GAM_isOnGround(s),spriteHoriz[s]);
                   1255:           debugOut(windowx1,windowy1,"CDIST=%d CHEIGHT=%d PHEIGHT=%d",
                   1256:                    ACT_getActorClipDist(spr),ACT_getActorClipHeight(spr),
                   1257:                    ACT_getActorViewHeight(spr));
                   1258:      }
                   1259:      debugOut(windowx1,windowy1,"LOZ=%06ld HIZ=%06ld LOHIT=%06ld HIHIT=%06ld",
                   1260:               globloz,globhiz,globlohit,globhihit);
                   1261: }
                   1262: 

unix.superglobalmegacorp.com