Return to whnet.c CVS log

Up to [Witchaven II] / src

Annotation of src/whnet.c, revision 1.1

1.1     ! root        1: /***************************************************************************
        !             2:  *   WHNET.C   - Witchaven network module & multiplayer code               *
        !             3:  *                                                                         *
        !             4:  *                                                     - Les Bird 07/12/95 *
        !             5:  ***************************************************************************/
        !             6: 
        !             7: //#define   SERIAL1LIB
        !             8: //#define   DEBUGOUTPUT
        !             9: //#define   MPLAYERCOMPILE
        !            10: 
        !            11: #include "icorp.h"
        !            12: #include "time.h"
        !            13: 
        !            14: #include "hmistd.h"
        !            15: #include "netnow.h"
        !            16: 
        !            17: #ifdef MPLAYERCOMPILE
        !            18: #define __WITCHAVEN__
        !            19: #include "rtq.h"
        !            20: #include "lpc.h"
        !            21: #include "mplib.h"
        !            22: #endif
        !            23: 
        !            24: #ifdef SERIAL1LIB
        !            25: #include "serial.h"
        !            26: #endif
        !            27: 
        !            28: #define   MAXDATASIZE    255
        !            29: #define   MAXTEAMS       4
        !            30: 
        !            31: #define   TEAMFLAG       2232
        !            32: 
        !            33: #define   TEAM1SECTOR    15
        !            34: #define   TEAM2SECTOR    16
        !            35: #define   TEAM3SECTOR    17
        !            36: #define   TEAM4SECTOR    18
        !            37: 
        !            38: #define   TEAM1FLAG      1
        !            39: #define   TEAM2FLAG      2
        !            40: #define   TEAM3FLAG      3
        !            41: #define   TEAM4FLAG      4
        !            42: 
        !            43: #define   TEAM1PAL       0
        !            44: #define   TEAM2PAL       10
        !            45: #define   TEAM3PAL       11
        !            46: #define   TEAM4PAL       12
        !            47: 
        !            48: #ifdef MPLAYERCOMPILE
        !            49: // mplayer net game
        !            50: #define   MPLAYERGAME    4
        !            51: #define     FREEQUEUE            0
        !            52: #define     DOSWORKQUEUE         1
        !            53: #define     WINSENDQUEUE         3
        !            54: #define     DOSPENDINGQUEUE      4
        !            55: 
        !            56: RTQ_NODE *MasterNode;
        !            57: #endif
        !            58: 
        !            59: char netmsg[80],
        !            60:      plrindex[256],
        !            61:      tagindex[MAXPLAYERS],
        !            62:      tempbuf[576];
        !            63: 
        !            64: int  netgame,
        !            65:      netinitialized;
        !            66: 
        !            67: //#pragma pack(1)
        !            68: 
        !            69: struct netnowhdr {
        !            70:      DWORD seq;                    // NETNOW reserved
        !            71:      _NETNOW_NODE_ADDR netadr;
        !            72: };
        !            73: 
        !            74: struct netpck {
        !            75:      char tagno;                   // players random tag number
        !            76:      WORD node;                    // NETNOW node number
        !            77:      char enemytype;               // monster this player chose
        !            78:      char teamno;                  // team this player chose
        !            79:      char weap;                    // weapon being carried
        !            80:      short score;                  // player's score (team or head to head)
        !            81:      long x,
        !            82:           y,
        !            83:           z;                       // x,y,z for this player
        !            84:      short ang;                    // player's angle
        !            85:      short horiz;                  // aiming horizontal
        !            86:      signed char action;           // action being performed
        !            87:      char taghit;                  // player tag that was hit
        !            88:      char guntype;                 // weapon in use
        !            89:      char mapon;                   // map player is on
        !            90:      char gametype;                // game this player has selected
        !            91:      char hasflag;                 // player is carrying a team flag
        !            92: }    netpck[MAXPLAYERS],
        !            93:      othnetpck,
        !            94:      sndnetpck;
        !            95: 
        !            96: struct msgpck {
        !            97:      char team;
        !            98:      char msg[80];
        !            99: };
        !           100: 
        !           101: struct mdmpck {
        !           102:      char hdr[4];
        !           103:      char src;
        !           104:      char dest;
        !           105:      char len;
        !           106:      struct netpck data;
        !           107: }    mdmsndpck,
        !           108:      mdmrcvpck;
        !           109: 
        !           110: #pragma pack()
        !           111: 
        !           112: #ifdef SERIAL1LIB
        !           113: serialData sd;
        !           114: #endif
        !           115: 
        !           116: _NETNOW_NODE_ADDR myadr,
        !           117:      othadr[MAXPLAYERS];
        !           118: 
        !           119: 
        !           120: WORD enemytype,
        !           121:      gametype,
        !           122:      mynode,
        !           123:      playersingame;
        !           124: 
        !           125: BYTE killedby = 0,
        !           126:      myrandomtag = 255;
        !           127: 
        !           128: short comp;
        !           129: 
        !           130: short debugnet,
        !           131:      dropflag,
        !           132:      ihaveflag,
        !           133:      myteam,
        !           134:      teamcolor[MAXTEAMS] = {TEAM1PAL, TEAM2PAL, TEAM3PAL, TEAM4PAL},
        !           135:      teamflagsprite[MAXTEAMS],
        !           136:      teaminplay[MAXPLAYERS],
        !           137:      teamscore[MAXPLAYERS],
        !           138:      xmit = 1;
        !           139: 
        !           140: long bps = 9600L,
        !           141:      netstartx,
        !           142:      netstarty,
        !           143:      netstartz,
        !           144:      netstarts,
        !           145:      numrpcks[MAXPLAYERS],
        !           146:      numspcks[MAXPLAYERS],
        !           147:      teamflagstartx[MAXTEAMS],
        !           148:      teamflagstarty[MAXTEAMS],
        !           149:      teamflagstartz[MAXTEAMS],
        !           150:      totrhdrs,
        !           151:      totrpcks,
        !           152:      totspcks;
        !           153: 
        !           154: int  enempics[] = {
        !           155: //     737,      // kobold
        !           156: //     777,      // devil
        !           157: //     821,      // fat witch
        !           158: //     922,      // goblin
        !           159: //     981,      // minotaur
        !           160: //     1028,     // skull witch
        !           161:      GRONHAL,                      // grondeval halberd
        !           162:      GRONSW,                       // grondeval halberd
        !           163:      GRONMU                        // grondeval halberd
        !           164: };
        !           165: 
        !           166: int  xreps[] = {
        !           167: //     54,       // kobold
        !           168: //     32,       // devil
        !           169: //     32,       // fat witch
        !           170: //     32,       // goblin
        !           171: //     32,       // minotaur
        !           172: //     32,       // skull witch
        !           173:      GRONHALXR,
        !           174:      GRONSWXR,
        !           175:      GRONMUXR
        !           176: };
        !           177: 
        !           178: int  yreps[] = {
        !           179: //     54,       // kobold
        !           180: //     36,       // devil
        !           181: //     32,       // fat witch
        !           182: //     36,       // goblin
        !           183: //     64,       // minotaur
        !           184: //     64,       // skull witch
        !           185:      GRONHALYR,
        !           186:      GRONSWXR,
        !           187:      GRONMUXR
        !           188: };
        !           189: 
        !           190: int  enemheights[] = {
        !           191: //     45,
        !           192: //     50,
        !           193: //     40,
        !           194: //     35,
        !           195: //     40,
        !           196: //     55,
        !           197:      40,
        !           198:      40,
        !           199:      40
        !           200: };
        !           201: 
        !           202: #define   MAXARGS        10
        !           203: 
        !           204: char *argparm[] = {
        !           205:      "MAP",
        !           206:      "CYBERMAXX",
        !           207:      "NET",
        !           208:      "MODEM",
        !           209:      "SERIAL",
        !           210:      "DEBUGNET",
        !           211:      "IGLASSES",
        !           212:      "MPLAYER",
        !           213:      "VFX1",
        !           214:      "LOCAL"
        !           215: };
        !           216: 
        !           217: char *monsternames[] = {
        !           218: //     "Kobold",
        !           219: //     "Devil",
        !           220: //     "Fat Witch",
        !           221: //     "Goblin",
        !           222: //     "Minotaur",
        !           223: //     "Skull Witch",
        !           224:      "Red",
        !           225:      "Blue",
        !           226:      "Purple",
        !           227:      "Brown"
        !           228: };
        !           229: 
        !           230: char *teamcolorstrings[] = {
        !           231:      "RED",
        !           232:      "BLUE",
        !           233:      "PURPLE",
        !           234:      "BROWN"
        !           235: };
        !           236: 
        !           237: #define   NUMGAMES       3
        !           238: 
        !           239: char *gamenames[] = {
        !           240:      "Head to Head",
        !           241:      "Capture the Flag 21",
        !           242:      "Capture the Flag 7"
        !           243: };
        !           244: 
        !           245: char *mapnames[] = {
        !           246:      "War Temple of Abu",
        !           247:      "The Abyssal Pit",
        !           248:      "Maze of Midan",
        !           249:      "Cave of Chaos",
        !           250:      "Lord Verkapherons Castle"
        !           251: };
        !           252: 
        !           253: short mapnumbers[] = {
        !           254:      30, 31, 32, 33, 34
        !           255: };
        !           256: 
        !           257: int  comadr[] = {
        !           258:      0x000, 0x3F8, 0x2F8, 0x3E8, 0x2E8
        !           259: };
        !           260: 
        !           261: extern
        !           262: int  cyberenabled,
        !           263:      mapflag,
        !           264:      mapon;
        !           265: 
        !           266: extern
        !           267: int  playerdie;
        !           268: 
        !           269: extern
        !           270: int  currweapon,
        !           271:      currweaponfired,
        !           272:      escapetomenu,
        !           273:      gameactivated;
        !           274: 
        !           275: void whnetmon(void);
        !           276: 
        !           277: extern
        !           278: int  oldvmode;
        !           279: 
        !           280: extern
        !           281: long selectedgun;
        !           282: 
        !           283: #ifdef DEBUGOUTPUT
        !           284: FILE *dbgfp;
        !           285: #endif
        !           286: 
        !           287: #if 0
        !           288: void (interrupt far * oldGPhandler) ();
        !           289: void (interrupt far * oldPGhandler) ();
        !           290: 
        !           291: #pragma aux gpsetmode=\
        !           292:     "int 10h",     \
        !           293:     parm [eax]     \
        !           294: 
        !           295: void gpsetmode(short);
        !           296: 
        !           297: void interrupt far
        !           298: newGPhandler(union INTPACK r)
        !           299: {
        !           300:      gpsetmode(oldvmode);
        !           301:      _chain_intr(oldGPhandler);
        !           302: }
        !           303: 
        !           304: void interrupt far
        !           305: newPGhandler(union INTPACK r)
        !           306: {
        !           307:      gpsetmode(oldvmode);
        !           308:      _chain_intr(oldPGhandler);
        !           309: }
        !           310: 
        !           311: void far *
        !           312: dpmi_getexception(int no)
        !           313: {
        !           314:      void far *fp;
        !           315:      union REGS regs;
        !           316: 
        !           317:      regs.x.eax = 0x202;
        !           318:      regs.x.ebx = no;
        !           319:      int386(0x31, &regs, &regs);
        !           320:      fp = MK_FP(regs.w.cx, regs.x.edx);
        !           321:      return (fp);
        !           322: }
        !           323: 
        !           324: void
        !           325: dpmi_setexception(int no, void far * func)
        !           326: {
        !           327:      union REGS regs;
        !           328: 
        !           329:      regs.x.eax = 0x203;
        !           330:      regs.x.ebx = no;
        !           331:      regs.x.ecx = FP_SEG(func);
        !           332:      regs.x.edx = FP_OFF(func);
        !           333:      int386(0x31, &regs, &regs);
        !           334: }
        !           335: 
        !           336: void
        !           337: installGPhandler(void)
        !           338: {
        !           339: // fprintf(stdaux, "intstall gphandlet\r\n");
        !           340: 
        !           341:      oldGPhandler = (void interrupt far *) dpmi_getexception(0x0D);
        !           342:      oldPGhandler = (void interrupt far *) dpmi_getexception(0x0E);
        !           343:      dpmi_setexception(0x0D, (void far *) newGPhandler);
        !           344:      dpmi_setexception(0x0E, (void far *) newPGhandler);
        !           345: }
        !           346: #endif
        !           347: 
        !           348: #ifdef DEBUGOUTPUT
        !           349: void
        !           350: debugout(char *fmt,...)
        !           351: {
        !           352:      va_list argptr;
        !           353: 
        !           354:      va_start(argptr, fmt);
        !           355:      vfprintf(dbgfp, fmt, argptr);
        !           356:      va_end(argptr);
        !           357: }
        !           358: #else
        !           359: void
        !           360: debugout(char *fmt,...)
        !           361: {
        !           362:      va_list argptr;
        !           363: 
        !           364:      va_start(argptr, fmt);
        !           365:      vsprintf(netmsg, fmt, argptr);
        !           366:      va_end(argptr);
        !           367: }
        !           368: #endif
        !           369: 
        !           370: extern
        !           371: unsigned vixen;
        !           372: 
        !           373: void
        !           374: netcheckargs(int argc, char *argv[])
        !           375: {
        !           376:      int  i,
        !           377:           j;
        !           378: 
        !           379: // fprintf(stdaux, "netcheckargs\r\n");
        !           380: 
        !           381:      i = 1;
        !           382:      do {
        !           383:           strupr(argv[i]);
        !           384:           for (j = 0; j < MAXARGS; j++) {
        !           385:                if (stricmp(argv[i], argparm[j]) == 0) {
        !           386:                     switch (j) {
        !           387:                     case 0:        // map number
        !           388:                          mapon = atoi(argv[i + 1]);
        !           389:                          mapflag = 1;
        !           390:                          i++;
        !           391:                          break;
        !           392:                     case 1:        // cybermax
        !           393:                          cyberenabled = atoi(argv[i + 1]);
        !           394:                          break;
        !           395:                     case 2:        // network
        !           396:                          netgame = 1;
        !           397:                          break;
        !           398:                     case 3:        // modem
        !           399:                          netgame = 2;
        !           400:                          break;
        !           401:                     case 4:        // direct serial
        !           402:                          netgame = 3;
        !           403:                          break;
        !           404:                     case 5:
        !           405:                          debugnet = 1;
        !           406:                          break;
        !           407:                     case 6:
        !           408:                          iglassenabled = atoi(argv[i + 1]);
        !           409:                          break;
        !           410: #ifdef MPLAYERCOMPILE
        !           411:                     case 7:
        !           412:                          netgame = MPLAYERGAME;
        !           413:                          break;
        !           414: #endif
        !           415:                     case 8:
        !           416:                          vfx1_init();
        !           417:                          break;
        !           418:                     case 9:
        !           419:                          _dos_getdrive((unsigned *)&vixen);
        !           420:                          break;
        !           421:                     }
        !           422:                }
        !           423:           }
        !           424:           i++;
        !           425:      } while (i < argc);
        !           426: }
        !           427: 
        !           428: int
        !           429: netattacking(short p)
        !           430: {
        !           431: // fprintf(stdaux, "netattacking\r\n");
        !           432: 
        !           433:      if (netpck[p].action == KEYFIRE) {
        !           434:           return (1);
        !           435:      }
        !           436:      return (0);
        !           437: }
        !           438: 
        !           439: void
        !           440: netsendpck(struct netpck * p, WORD dnode)
        !           441: {
        !           442:      BOOL rc;
        !           443:      short i;
        !           444:      char *dptr;
        !           445:      struct netnowhdr hdr;
        !           446: 
        !           447: // fprintf(stdaux, "netsendpck\r\n");
        !           448: 
        !           449:      switch (netgame) {
        !           450:      case 1:
        !           451:           memmove(&hdr.netadr, &myadr, sizeof(_NETNOW_NODE_ADDR));
        !           452:           memmove(&othadr[plrindex[myrandomtag]], &myadr,
        !           453:                   sizeof(_NETNOW_NODE_ADDR));
        !           454:           rc = hmiNETNOWSendData((PSTR) & hdr, sizeof(struct netnowhdr),
        !           455:                                  (PSTR) p, sizeof(struct netpck), dnode);
        !           456:           if (rc == _FALSE) {
        !           457:                crash("netsendpck: XMT queue full");
        !           458:           }
        !           459:           break;
        !           460:      case 2:
        !           461:      case 3:
        !           462:           mdmsndpck.hdr[0] = 0x01;
        !           463:           mdmsndpck.hdr[1] = 0x02;
        !           464:           mdmsndpck.hdr[2] = 0x03;
        !           465:           mdmsndpck.hdr[3] = 0x21;
        !           466:           mdmsndpck.src = mynode;
        !           467:           mdmsndpck.dest = dnode;
        !           468:           mdmsndpck.len = sizeof(struct netpck);
        !           469:           dptr = (char *) &mdmsndpck;
        !           470:           memmove(&mdmsndpck.data, p, sizeof(struct netpck));
        !           471: #ifdef SERIAL1LIB
        !           472:           for (i = 0; i < sizeof(struct mdmpck); i++) {
        !           473:                writeSer(&sd, dptr[i]);
        !           474:           }
        !           475: #else
        !           476:           sendpacket(0, dptr, sizeof(struct mdmpck));
        !           477: #endif
        !           478:           break;
        !           479: #ifdef MPLAYERCOMPILE
        !           480:      case MPLAYERGAME:{
        !           481:                RTQ_NODE *n;
        !           482: 
        !           483:                // grab free buffer
        !           484:                while ((n = MGenMoveTo(FREEQUEUE, DOSWORKQUEUE)) == 0) {
        !           485: //                     MGenFlushNodes(WINSENDQUEUE, FREEQUEUE);
        !           486: //                     MGenFlushNodes(DOSPENDINGQUEUE, FREEQUEUE);
        !           487:                     MGenWakeupDll();
        !           488:                     Yield();
        !           489: //                     return;
        !           490:                }
        !           491: 
        !           492:                // here's what we want to send
        !           493:                memcpy(n->rtqDatum, p, sizeof(struct netpck));
        !           494:                n->rtqUpCtr = sizeof(struct netpck);
        !           495: 
        !           496:                // put it into Windows queue
        !           497:                MGenMoveTo(DOSWORKQUEUE, WINSENDQUEUE);
        !           498:                PostWindowsMessage();
        !           499:                Yield();
        !           500:           }
        !           501:           break;
        !           502: #endif
        !           503:      }
        !           504:      numspcks[plrindex[myrandomtag]]++;
        !           505:      totspcks++;
        !           506: }
        !           507: 
        !           508: short
        !           509: netchecktouchflag(struct player * plr)
        !           510: {
        !           511:      short i,
        !           512:           j;
        !           513: 
        !           514: // fprintf(stdaux, "netchecktouchflag\r\n");
        !           515:      if (gametype < 1) {
        !           516:           return (0);
        !           517:      }
        !           518:      if (ihaveflag) {
        !           519:           return (ihaveflag);
        !           520:      }
        !           521:      i = headspritesect[plr->sector];
        !           522:      while (i != -1) {
        !           523:           j = nextspritesect[i];
        !           524:           if (labs(plr->x - sprite[i].x) + labs(plr->y - sprite[i].y) < 512
        !           525:               && labs((plr->z >> 8) - ((sprite[i].z >> 8) - (tilesizy[sprite[i].picnum] >> 1))) <= 40) {
        !           526:                switch (sprite[i].picnum) {
        !           527:                case TEAMFLAG:
        !           528:                     switch (sprite[i].pal) {
        !           529:                     case TEAM1PAL:
        !           530:                          SND_Sound(S_POTION1);
        !           531:                          return (1);
        !           532:                     case TEAM2PAL:
        !           533:                          SND_Sound(S_POTION1);
        !           534:                          return (2);
        !           535:                     case TEAM3PAL:
        !           536:                          SND_Sound(S_POTION1);
        !           537:                          return (3);
        !           538:                     case TEAM4PAL:
        !           539:                          SND_Sound(S_POTION1);
        !           540:                          return (4);
        !           541:                     }
        !           542:                     break;
        !           543:                }
        !           544:           }
        !           545:           i = j;
        !           546:      }
        !           547:      return (0);
        !           548: }
        !           549: 
        !           550: void
        !           551: netmarkflag(short i)
        !           552: {
        !           553: // fprintf(stdaux, "netmarkflag\r\n");
        !           554: 
        !           555:      if (gametype < 1) {
        !           556:           deletesprite(i);
        !           557:           return;
        !           558:      }
        !           559:      switch (sprite[i].pal) {
        !           560:      case TEAM1PAL:
        !           561:           teamflagsprite[0] = i;
        !           562:           teamflagstartx[0] = sprite[i].x;
        !           563:           teamflagstarty[0] = sprite[i].y;
        !           564:           teamflagstartz[0] = sprite[i].z;
        !           565:           break;
        !           566:      case TEAM2PAL:
        !           567:           teamflagsprite[1] = i;
        !           568:           teamflagstartx[1] = sprite[i].x;
        !           569:           teamflagstarty[1] = sprite[i].y;
        !           570:           teamflagstartz[1] = sprite[i].z;
        !           571:           break;
        !           572:      case TEAM3PAL:
        !           573:           teamflagsprite[2] = i;
        !           574:           teamflagstartx[2] = sprite[i].x;
        !           575:           teamflagstarty[2] = sprite[i].y;
        !           576:           teamflagstartz[2] = sprite[i].z;
        !           577:           break;
        !           578:      case TEAM4PAL:
        !           579:           teamflagsprite[3] = i;
        !           580:           teamflagstartx[3] = sprite[i].x;
        !           581:           teamflagstarty[3] = sprite[i].y;
        !           582:           teamflagstartz[3] = sprite[i].z;
        !           583:           break;
        !           584:      }
        !           585:      sprite[i].xrepeat = 24;
        !           586:      sprite[i].yrepeat = 24;
        !           587: }
        !           588: 
        !           589: void
        !           590: moveflag(long x, long y, long z, long teamno)
        !           591: {
        !           592:      short s;
        !           593: 
        !           594: // fprintf(stdaux, "moveflag\r\n");
        !           595: 
        !           596:      if (teamno > 0) {
        !           597:           s = teamflagsprite[teamno - 1];
        !           598:           if (s >= 0) {
        !           599:                setsprite(s, x, y, z + (16 << 8));
        !           600:           }
        !           601:      }
        !           602: }
        !           603: 
        !           604: #define TIMER_RESOLUTION 250
        !           605: 
        !           606: void
        !           607: sendmyinfo(WORD dnode, short forcesend)
        !           608: {
        !           609:      short p;
        !           610:      struct player *plr;
        !           611: 
        !           612:      if (!forcesend) {
        !           613:           static clock_t t;
        !           614:           clock_t n;
        !           615: 
        !           616:           if (t < (n = (clock() + TIMER_RESOLUTION)))
        !           617:                t = n;
        !           618:           else
        !           619:                return;
        !           620:      }
        !           621: 
        !           622:      plr = &player[0];
        !           623:      plr->lvl = 9;
        !           624:      updatesector(plr->x, plr->y, &plr->sector);
        !           625:      ihaveflag = netchecktouchflag(plr);
        !           626:      sndnetpck.tagno = myrandomtag;
        !           627:      sndnetpck.node = mynode;
        !           628:      sndnetpck.enemytype = enemytype;
        !           629:      sndnetpck.x = plr->x;
        !           630:      sndnetpck.y = plr->y;
        !           631:      sndnetpck.z = plr->z;
        !           632:      sndnetpck.ang = plr->ang;
        !           633:      sndnetpck.horiz = plr->horiz;
        !           634:      sndnetpck.mapon = mapon;
        !           635:      sndnetpck.gametype = gametype;
        !           636:      sndnetpck.teamno = myteam;
        !           637:      sndnetpck.weap = currweapon;
        !           638:      sndnetpck.hasflag = ihaveflag;
        !           639:      if (gametype >= 1) {
        !           640:           sndnetpck.score = teamscore[myteam];
        !           641:      }
        !           642:      else {
        !           643:           sndnetpck.score = teamscore[0];
        !           644:      }
        !           645:      if (gametype >= 1) {
        !           646:           teaminplay[myteam] = 1;
        !           647:           captureflagpic();
        !           648:      }
        !           649:      if (playerdie) {
        !           650:           sndnetpck.action = -1;
        !           651:           sndnetpck.taghit = killedby;
        !           652:           killedby = 0;
        !           653:           if (ihaveflag) {
        !           654:                if (teamflagsprite[ihaveflag - 1] >= 0) {
        !           655:                     sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !           656:                }
        !           657:           }
        !           658:           ihaveflag = 0;
        !           659:      }
        !           660:      else if (dropflag) {
        !           661:           dropflag = 0;
        !           662:           sndnetpck.action = -2;
        !           663:           sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !           664:           if (ihaveflag - 1 == myteam) {
        !           665:                netmarkflag(teamflagsprite[ihaveflag - 1]);
        !           666:           }
        !           667:           ihaveflag = 0;
        !           668:      }
        !           669:      else {
        !           670:           if (ihaveflag) {
        !           671:                moveflag(plr->x, plr->y, plr->z, ihaveflag);
        !           672:                if (teamflagsprite[ihaveflag - 1] >= 0) {
        !           673:                     sprite[teamflagsprite[ihaveflag - 1]].cstat |= 32768;
        !           674:                }
        !           675:           }
        !           676:           if (currweaponfired) {
        !           677:                sndnetpck.action = KEYFIRE;
        !           678:           }
        !           679:      }
        !           680:      if (forcesend
        !           681:          || memcmp(&sndnetpck, &netpck[0], sizeof(struct netpck)) != 0) {
        !           682:           memmove(&netpck[0], &sndnetpck, sizeof(struct netpck));
        !           683: #if 0
        !           684:           if (forcesend) {
        !           685:                sprintf(netmsg, "PCKT FORCED");
        !           686:           }
        !           687:           else {
        !           688:                sprintf(netmsg, "PCKT DIFFERENT");
        !           689:           }
        !           690: #endif
        !           691:           switch (netgame) {
        !           692:           case 1:
        !           693:                netsendpck(&sndnetpck, dnode);
        !           694:                break;
        !           695:           case 2:
        !           696:           case 3:
        !           697:                netsendpck(&sndnetpck, 255);
        !           698:                break;
        !           699: #ifdef MPLAYERCOMPILE
        !           700:           case MPLAYERGAME:
        !           701:                netsendpck(&sndnetpck, 255);
        !           702:                break;
        !           703: #endif
        !           704:           }
        !           705:      }
        !           706: #if 0
        !           707:      else {
        !           708:           sprintf(netmsg, "PCKT NOT SENT");
        !           709:      }
        !           710: #endif
        !           711:      if (gametype >= 1 && ihaveflag) {
        !           712:           switch (sector[plr->sector].lotag) {
        !           713:           case TEAM1SECTOR:
        !           714:                switch (ihaveflag) {
        !           715:                case TEAM2FLAG:
        !           716:                case TEAM3FLAG:
        !           717:                case TEAM4FLAG:
        !           718:                     if (teaminplay[ihaveflag - 1]) {
        !           719:                          teamscore[TEAM1FLAG - 1] += 1;
        !           720:                          playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !           721: //                         if (teamscore[ihaveflag-1] > 0) {
        !           722: //                              teamscore[ihaveflag-1]--;
        !           723: //                         }
        !           724:                     }
        !           725:                     dolevelmusic(rand()%10);
        !           726:                     break;
        !           727:                }
        !           728:                dropflagstart(ihaveflag);
        !           729:                captureflagpic();
        !           730:                if (teamflagsprite[ihaveflag - 1] >= 0) {
        !           731:                     sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !           732:                }
        !           733:                ihaveflag = 0;
        !           734:                break;
        !           735:           case TEAM2SECTOR:
        !           736:                switch (ihaveflag) {
        !           737:                case TEAM1FLAG:
        !           738:                case TEAM3FLAG:
        !           739:                case TEAM4FLAG:
        !           740:                     if (teaminplay[ihaveflag - 1]) {
        !           741:                          teamscore[TEAM2FLAG - 1] += 1;
        !           742:                          playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !           743: //                         if (teamscore[ihaveflag-1] > 0) {
        !           744: //                              teamscore[ihaveflag-1]--;
        !           745: //                         }
        !           746:                     }
        !           747:                     dolevelmusic(rand()%10);
        !           748:                     break;
        !           749:                }
        !           750:                dropflagstart(ihaveflag);
        !           751:                captureflagpic();
        !           752:                if (teamflagsprite[ihaveflag - 1] >= 0) {
        !           753:                     sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !           754:                }
        !           755:                ihaveflag = 0;
        !           756:                break;
        !           757:           case TEAM3SECTOR:
        !           758:                switch (ihaveflag) {
        !           759:                case TEAM1FLAG:
        !           760:                case TEAM2FLAG:
        !           761:                case TEAM4FLAG:
        !           762:                     if (teaminplay[ihaveflag - 1]) {
        !           763:                          teamscore[TEAM3FLAG - 1] += 1;
        !           764:                          playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !           765: //                         if (teamscore[ihaveflag-1] > 0) {
        !           766: //                              teamscore[ihaveflag-1]--;
        !           767: //                         }
        !           768:                     }
        !           769:                     dolevelmusic(rand()%10);
        !           770:                     break;
        !           771:                }
        !           772:                dropflagstart(ihaveflag);
        !           773:                captureflagpic();
        !           774:                if (teamflagsprite[ihaveflag - 1] >= 0) {
        !           775:                     sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !           776:                }
        !           777:                ihaveflag = 0;
        !           778:                break;
        !           779:           case TEAM4SECTOR:
        !           780:                switch (ihaveflag) {
        !           781:                case TEAM1FLAG:
        !           782:                case TEAM2FLAG:
        !           783:                case TEAM3FLAG:
        !           784:                     if (teaminplay[ihaveflag - 1]) {
        !           785:                          teamscore[TEAM4FLAG - 1] += 1;
        !           786:                          playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !           787: //                         if (teamscore[ihaveflag-1] > 0) {
        !           788: //                              teamscore[ihaveflag-1]--;
        !           789: //                         }
        !           790:                     }
        !           791:                     dolevelmusic(rand()%10);
        !           792:                     break;
        !           793:                }
        !           794:                dropflagstart(ihaveflag);
        !           795:                captureflagpic();
        !           796:                if (teamflagsprite[ihaveflag - 1] >= 0) {
        !           797:                     sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !           798:                }
        !           799:                ihaveflag = 0;
        !           800:                break;
        !           801:           }
        !           802:      }
        !           803: }
        !           804: 
        !           805: void
        !           806: netjoingame(void)
        !           807: {                                  // announce that we've entered the game
        !           808:      int  i;
        !           809:      FILE *fp;
        !           810: 
        !           811: // fprintf(stdaux, "netjoingame\r\n");
        !           812: #ifdef MPLAYERCOMPILE
        !           813:      if (netgame > 1 && netgame != MPLAYERGAME) {
        !           814: #else
        !           815:      if (netgame > 1) {
        !           816: #endif
        !           817:           for (i = 0; i < 256; i++) {
        !           818:                plrindex[i] = 255;
        !           819:           }
        !           820:           for (i = 0; i < MAXTEAMS; i++) {
        !           821:                teaminplay[i] = 0;
        !           822:                teamscore[i] = 0;
        !           823:           }
        !           824:      }
        !           825:      for (i = 0; i < MAXPLAYERS; i++) {
        !           826:           netpck[i].hasflag = 0;
        !           827:      }
        !           828:      ihaveflag = 0;
        !           829:      switch (netgame) {
        !           830:      case 1:
        !           831:           myrandomtag = myadr.sIPX.bImmediate[5];
        !           832:           mynode = hmiNETNOWGetConsoleNode();
        !           833:           playersingame = hmiNETNOWGetActiveNodes();
        !           834:           plrindex[myrandomtag] = 0;
        !           835:           tagindex[0] = myrandomtag;
        !           836:           for (i = 0; i < _NETNOW_MAX_LISTEN_PACKETS; i++) {
        !           837:                hmiNETNOWPostListen();
        !           838:           }
        !           839:           break;
        !           840:      case 2:
        !           841:      case 3:
        !           842:           mynode = 0;
        !           843:           if (myrandomtag == 255) {
        !           844:                srand(clock());
        !           845:                do {
        !           846:                     myrandomtag = rand() & 255;
        !           847:                } while (myrandomtag == 255);
        !           848:                fp = fopen("tag.dat", "wb");
        !           849:                if (fp != NULL) {
        !           850:                     fwrite(&myrandomtag, sizeof(myrandomtag), 1, fp);
        !           851:                     fclose(fp);
        !           852:                }
        !           853:           }
        !           854:           plrindex[myrandomtag] = 0;
        !           855:           tagindex[0] = myrandomtag;
        !           856:           playersingame = 1;
        !           857:           break;
        !           858: #ifdef MPLAYERCOMPILE
        !           859:      case MPLAYERGAME:
        !           860:           mynode = 0;
        !           861:           myrandomtag = LPCGetMPAddr() - 1;
        !           862:           if (myrandomtag == -1)
        !           863:                crash("MPAddr invalid!");
        !           864:           plrindex[myrandomtag] = 0;
        !           865:           tagindex[0] = myrandomtag;
        !           866:           playersingame = 1;
        !           867:           break;
        !           868: #endif
        !           869:      }
        !           870:      sendmyinfo(_NETNOW_BROADCAST, 1);
        !           871:      SND_Sound(S_DROPFLAG);
        !           872: }
        !           873: 
        !           874: void
        !           875: netsendmove(void)
        !           876: {
        !           877:      short p;
        !           878:      static long sendclock = 0L;
        !           879: 
        !           880: // fprintf(stdaux, "netsendmove\r\n");
        !           881: 
        !           882:      if (netgame == 0) {
        !           883:           return;
        !           884:      }
        !           885:      if (netgame == 1) {
        !           886:           sendmyinfo(_NETNOW_BROADCAST, 0);
        !           887: //          for (p=0 ; p < playersingame ; p++) {
        !           888: //               if (mynode != p || playersingame == 1) {
        !           889: //                    sendmyinfo(p,0);
        !           890: //               }
        !           891: //          }
        !           892:      }
        !           893: #ifdef MPLAYERCOMPILE
        !           894:      else if (netgame == MPLAYERGAME) {
        !           895:           sendmyinfo(_NETNOW_BROADCAST, 0);
        !           896:      }
        !           897: #endif
        !           898:      else if (xmit) {
        !           899:           if (playersingame > 1) {
        !           900:                sendmyinfo(255, 1);
        !           901:           }
        !           902:           else if (totalclock >= sendclock) {
        !           903:                sendclock = totalclock + (CLKIPS * 4);
        !           904:                sendmyinfo(255, 1);
        !           905:           }
        !           906:      }
        !           907:      memset(&sndnetpck, 0, sizeof(struct netpck));
        !           908: }
        !           909: 
        !           910: void
        !           911: netshootgun(short s, char guntype)
        !           912: {
        !           913:      short p;
        !           914: 
        !           915: // fprintf(stdaux, "netshootgun\r\n");
        !           916: 
        !           917:      sndnetpck.guntype = guntype;
        !           918:      if (s != -1) {
        !           919:           for (p = 0; p < playersingame; p++) {
        !           920:                if (player[p].spritenum == s) {
        !           921:                     sndnetpck.taghit = tagindex[p];
        !           922:                     break;
        !           923:                }
        !           924:           }
        !           925:      }
        !           926:      else {
        !           927:           sndnetpck.taghit = myrandomtag;
        !           928:      }
        !           929:      netsendmove();
        !           930: }
        !           931: 
        !           932: void
        !           933: netdamageactor(short s, short o)
        !           934: {
        !           935:      int  val;
        !           936: 
        !           937: // fprintf(stdaux, "netdamageactor\r\n");
        !           938: 
        !           939:      if (player[0].spritenum == s) {
        !           940:           switch (sprite[o].picnum) {
        !           941:           case PLASMA:
        !           942:                val = (krand() & 0x07);
        !           943:                break;
        !           944:           case MONSTERBALL:
        !           945:                val = (krand() & 0x7F);
        !           946:                break;
        !           947:           case BULLET:
        !           948:           case THROWPIKE:
        !           949:                val = (krand() & 0x7F);
        !           950:                break;
        !           951:           }
        !           952:           if (shieldpoints > 0 && selectedgun < 5) {
        !           953:                val >>= 1;
        !           954:                shieldpoints -= val >> 1;
        !           955:           }
        !           956:           healthpic(-(val));
        !           957:           if (player[0].health <= 0) {
        !           958:                killedby = netpck[sprite[o].owner - 4096].tagno;
        !           959:           }
        !           960:      }
        !           961: }
        !           962: 
        !           963: void
        !           964: nethitsprite(short p, char guntype, char taghit)
        !           965: {
        !           966:      short daang,
        !           967:           hitsect,
        !           968:           hitsprite,
        !           969:           hitwall,
        !           970:           i,
        !           971:           j,
        !           972:           k;
        !           973:      long dax,
        !           974:           day,
        !           975:           hitx,
        !           976:           hity,
        !           977:           hitz;
        !           978:      struct player *myplr,
        !           979:          *plr;
        !           980: 
        !           981: // fprintf(stdaux, "nethitsprite\r\n");
        !           982: 
        !           983:      plr = &player[p];
        !           984:      myplr = &player[0];
        !           985: //     sprintf(netmsg,"HIT TAG %d WITH %d",taghit,guntype);
        !           986:      if (guntype == 5) {
        !           987:           daang = plr->ang;
        !           988:           hitscan(plr->x, plr->y, plr->z, plr->sector,
        !           989:                   sintable[(daang + 512) & 2047],
        !           990:                   sintable[daang],
        !           991:                   (100 - plr->horiz) * 2000,
        !           992:                   &hitsect, &hitwall, &hitsprite, &hitx, &hity, &hitz);
        !           993:           if (hitwall >= 0 && hitsprite < 0) {
        !           994:                neartag(hitx, hity, hitz, hitsect, daang,
        !           995:                        &neartagsector, &neartagwall, &neartagsprite,
        !           996:                        &neartaghitdist, 1024);
        !           997:                if (neartagsector < 0) {
        !           998:                     if (sector[neartagsector].lotag == 0) {
        !           999:                          j = insertsprite(hitsect, 0);
        !          1000:                          sprite[j].x = hitx;
        !          1001:                          sprite[j].y = hity;
        !          1002:                          sprite[j].z = hitz + (8 << 8);
        !          1003:                          sprite[j].cstat = 17;    // was16
        !          1004:                          sprite[j].picnum = WALLARROW;
        !          1005:                          sprite[j].shade = 0;
        !          1006:                          sprite[j].pal = 0;
        !          1007:                          sprite[j].xrepeat = 16;
        !          1008:                          sprite[j].yrepeat = 48;
        !          1009:                          sprite[j].ang = ((daang + 2048) - 512 + (rand() & 128 - 64)) & 2047;
        !          1010:                          sprite[j].xvel = 0;
        !          1011:                          sprite[j].yvel = 0;
        !          1012:                          sprite[j].zvel = 0;
        !          1013:                          sprite[j].owner = 4096;
        !          1014:                          sprite[j].lotag = 32;
        !          1015:                          sprite[j].hitag = 0;
        !          1016:                     }
        !          1017:                }
        !          1018:           }
        !          1019:      }
        !          1020:      switch (guntype) {
        !          1021:      case 0:
        !          1022:           playsound_loc(S_SOCK1 + rand() % 4, plr->x, plr->y);
        !          1023:           break;
        !          1024:      case 1:
        !          1025:           if (rand() % 2) {
        !          1026:                playsound_loc(S_GORE1 + rand() % 4, plr->x, plr->y);
        !          1027:           }
        !          1028:           break;
        !          1029:      case 2:
        !          1030:           playsound_loc(S_SWORDCLINK1 + rand() % 4, plr->x, plr->y);
        !          1031:           break;
        !          1032:      case 3:
        !          1033:           playsound_loc(S_SOCK1 + rand() % 4, plr->x, plr->y);
        !          1034:           break;
        !          1035:      case 4:
        !          1036:           playsound_loc(S_SWORD1 + rand() % 6, plr->x, plr->y);
        !          1037:           break;
        !          1038:      case 5:
        !          1039:           playsound_loc(S_SWORD1 + rand() % 2, plr->x, plr->y);
        !          1040:           break;
        !          1041:      case 6:
        !          1042:           playsound_loc(S_SWORD1 + rand() % 6, plr->x, plr->y);
        !          1043:           break;
        !          1044:      case 7:
        !          1045:           playsound_loc(S_PLRWEAPON4, plr->x, plr->y);
        !          1046:           break;
        !          1047:      case 8:
        !          1048:           playsound_loc(S_SWORD1 + rand() % 2, plr->x, plr->y);
        !          1049:           break;
        !          1050:      case 9:
        !          1051:           playsound_loc(S_SWORD1 + rand() % 3, plr->x, plr->y);
        !          1052:           if (rand() % 2) {
        !          1053:                playsound_loc(S_GORE1 + rand() % 4, plr->x, plr->y);
        !          1054:           }
        !          1055:           break;
        !          1056:      }
        !          1057:      if (taghit == myrandomtag) {
        !          1058:           sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !          1059:           ihaveflag = 0;
        !          1060:           switch (guntype) {
        !          1061:           case 0:
        !          1062:                k = (krand() % 5);
        !          1063:                break;
        !          1064:           case 1:
        !          1065:                k = (krand() % 5);
        !          1066:                break;
        !          1067:           case 2:
        !          1068:                k = (krand() % 10);
        !          1069:                break;
        !          1070:           case 3:
        !          1071:                k = (krand() % 20);
        !          1072:                break;
        !          1073:           case 4:
        !          1074:                k = (krand() % 25);
        !          1075:                break;
        !          1076:           case 5:
        !          1077:                k = (krand() % 30);
        !          1078:                break;
        !          1079:           case 6:
        !          1080:                k = (krand() % 30);
        !          1081:                break;
        !          1082:           case 7:
        !          1083:                k = (krand() % 10) + 5;
        !          1084:                break;
        !          1085:           case 8:
        !          1086:                k = (krand() % 20) + 5;
        !          1087:                break;
        !          1088:           case 9:
        !          1089:                k = (krand() % 20) + 5;
        !          1090:                break;
        !          1091:           }
        !          1092:           if (shieldpoints > 0 && selectedgun < 5) {
        !          1093:                k >>= 1;
        !          1094:                shieldpoints -= k >> 1;
        !          1095:           }
        !          1096:           healthpic(-k);
        !          1097:           if (player[0].health <= 0) {
        !          1098:                killedby = netpck[p].tagno;
        !          1099:           }
        !          1100:           if (rand() % 2) {
        !          1101:                painsound(myplr->x, myplr->y);
        !          1102:           }
        !          1103:      }
        !          1104:      else {
        !          1105:           switch (guntype) {
        !          1106:           case 12:
        !          1107:                for (i = 0; i < 10; i++) {
        !          1108:                     j = insertsprite(plr->sector, MISSILE);
        !          1109:                     sprite[j].x = plr->x;
        !          1110:                     sprite[j].y = plr->y;
        !          1111:                     sprite[j].z = plr->z + (8 << 8) + ((krand() & 10) << 8);
        !          1112:                     sprite[j].cstat = 0;
        !          1113:                     sprite[j].picnum = PLASMA;
        !          1114:                     sprite[j].shade = -32;
        !          1115:                     sprite[j].pal = 0;
        !          1116:                     sprite[j].xrepeat = 16;
        !          1117:                     sprite[j].yrepeat = 16;
        !          1118:                     daang = sprite[j].ang = (plr->ang - (i * 5)) + (i * 10);
        !          1119:                     sprite[j].xvel = (sintable[(daang + 512) & 2047] >> 5);
        !          1120:                     sprite[j].yvel = (sintable[daang] >> 5);
        !          1121:                     sprite[j].zvel = ((100 - plr->horiz) << 4);
        !          1122:                     sprite[j].owner = 4096 + p;
        !          1123:                     sprite[j].lotag = 256;
        !          1124:                     sprite[j].hitag = 0;
        !          1125:                     sprite[j].clipdist = 48;
        !          1126:                     dax = sprite[j].xvel;
        !          1127:                     day = sprite[j].yvel;
        !          1128:                     movesprite((short) j, (dax * synctics) << 3, (day * synctics) << 3, 0L,
        !          1129:                                4L << 8, 4L << 8, 0);
        !          1130:                     setsprite(j, sprite[j].x, sprite[j].y, sprite[j].z);
        !          1131:                }
        !          1132:                break;
        !          1133:           case 13:
        !          1134:                j = insertsprite(plr->sector, MISSILE);
        !          1135:                sprite[j].x = plr->x;
        !          1136:                sprite[j].y = plr->y;
        !          1137:                sprite[j].z = plr->z + (8 << 8);
        !          1138:                sprite[j].cstat = 0;// Hitscan does not hit other bullets
        !          1139:                sprite[j].picnum = MONSTERBALL;
        !          1140:                sprite[j].shade = -32;
        !          1141:                sprite[j].pal = 0;
        !          1142:                sprite[j].xrepeat = 64;
        !          1143:                sprite[j].yrepeat = 64;
        !          1144:                daang = sprite[j].ang = plr->ang;
        !          1145:                sprite[j].xvel = (sintable[(daang + 512) & 2047] >> 7);
        !          1146:                sprite[j].yvel = (sintable[daang] >> 7);
        !          1147:                sprite[j].zvel = ((100 - plr->horiz) << 4);
        !          1148:                sprite[j].owner = 4096 + p;
        !          1149:                sprite[j].lotag = 256;
        !          1150:                sprite[j].hitag = 0;
        !          1151:                sprite[j].clipdist = 64;
        !          1152:                dax = sprite[j].xvel;
        !          1153:                day = sprite[j].yvel;
        !          1154:                movesprite((short) j, (dax * synctics) << 3, (day * synctics) << 3, 0L,
        !          1155:                           4L << 8, 4L << 8, 0);
        !          1156:                setsprite(j, sprite[j].x, sprite[j].y, sprite[j].z);
        !          1157:                return;
        !          1158:           case 14:
        !          1159:                j = insertsprite(plr->sector, HEATSEEKER);
        !          1160:                sprite[j].x = plr->x;
        !          1161:                sprite[j].y = plr->y;
        !          1162:                sprite[j].z = plr->z + (8 << 8);
        !          1163:                sprite[j].cstat = 0;// Hitscan does not hit other bullets
        !          1164:                sprite[j].picnum = BULLET;
        !          1165:                sprite[j].shade = -32;
        !          1166:                sprite[j].pal = 0;
        !          1167:                sprite[j].xrepeat = 16;
        !          1168:                sprite[j].yrepeat = 16;
        !          1169:                daang = sprite[j].ang = plr->ang;
        !          1170:                sprite[j].xvel = (sintable[(daang + 512) & 2047] >> 7);
        !          1171:                sprite[j].yvel = (sintable[daang] >> 7);
        !          1172:                sprite[j].zvel = ((100 - plr->horiz) << 4);
        !          1173:                sprite[j].owner = 4096 + p;
        !          1174:                sprite[j].lotag = 1024;
        !          1175:                sprite[j].hitag = 0;
        !          1176:                sprite[j].clipdist = 128;
        !          1177:                dax = sprite[j].xvel;
        !          1178:                day = sprite[j].yvel;
        !          1179:                movesprite((short) j, (dax * synctics) << 3, (day * synctics) << 3, 0L,
        !          1180:                           4L << 8, 4L << 8, 0);
        !          1181:                setsprite(j, sprite[j].x, sprite[j].y, sprite[j].z);
        !          1182:                return;
        !          1183:           case 15:
        !          1184:                j = insertsprite(plr->sector, MISSILE);
        !          1185:                sprite[j].x = plr->x;
        !          1186:                sprite[j].y = plr->y;
        !          1187:                sprite[j].z = plr->z + (16 << 8);
        !          1188:                sprite[j].cstat = 21;
        !          1189:                sprite[j].picnum = THROWPIKE;
        !          1190:                sprite[j].ang = ((plr->ang + 2048 + 96) - 512) & 2047;
        !          1191:                sprite[j].xrepeat = 24;
        !          1192:                sprite[j].yrepeat = 24;
        !          1193:                sprite[j].clipdist = 24;
        !          1194:                sprite[j].extra = plr->ang;
        !          1195:                sprite[j].shade = -15;
        !          1196:                sprite[j].xvel = ((krand() & 256) - 128);
        !          1197:                sprite[j].yvel = ((krand() & 256) - 128);
        !          1198:                sprite[j].zvel = ((100 - plr->horiz) << 4);
        !          1199:                sprite[j].owner = 4096 + p;
        !          1200:                sprite[j].lotag = 1024;
        !          1201:                sprite[j].hitag = 0;
        !          1202:                sprite[j].pal = 0;
        !          1203:                playsound_loc(S_ARROWHIT, sprite[j].x, sprite[j].y);
        !          1204:                dax = sprite[j].xvel;
        !          1205:                day = sprite[j].yvel;
        !          1206:                movesprite((short) j, (dax * synctics) << 3, (day * synctics) << 3, 0L,
        !          1207:                           4L << 8, 4L << 8, 0);
        !          1208:                setsprite(j, sprite[j].x, sprite[j].y, sprite[j].z);
        !          1209:                return;
        !          1210:           }
        !          1211:      }
        !          1212: }
        !          1213: 
        !          1214: void
        !          1215: spawnflag(long x, long y, long z, long teamno)
        !          1216: {
        !          1217:      short s,
        !          1218:           sect;
        !          1219: 
        !          1220: // fprintf(stdaux, "spawnflag\r\n");
        !          1221:      updatesector(x, y, &sect);
        !          1222:      s = insertsprite(sect, 0);
        !          1223:      sprite[s].x = x;
        !          1224:      sprite[s].y = y;
        !          1225:      sprite[s].z = z;
        !          1226:      sprite[s].ang = 0;
        !          1227:      sprite[s].picnum = TEAMFLAG;
        !          1228:      sprite[s].cstat = 1 + 256;
        !          1229:      sprite[s].xrepeat = 32;
        !          1230:      sprite[s].yrepeat = 32;
        !          1231:      sprite[s].pal = teamcolor[teamno];
        !          1232:      teamflagsprite[teamno] = s;
        !          1233: }
        !          1234: 
        !          1235: void
        !          1236: dropflagstart(short teamno)
        !          1237: {
        !          1238:      if (teamno > 0) {
        !          1239:           teamno -= 1;
        !          1240:           if (teamflagsprite[teamno] >= 0) {
        !          1241:                setsprite(teamflagsprite[teamno], teamflagstartx[teamno],
        !          1242:                          teamflagstarty[teamno], teamflagstartz[teamno]);
        !          1243:           }
        !          1244:      }
        !          1245: }
        !          1246: 
        !          1247: void
        !          1248: netdropflag(void)
        !          1249: {
        !          1250: // fprintf(stdaux, "netdropflag\r\n");
        !          1251:      if (ihaveflag) {
        !          1252:           dropflag = 1;
        !          1253:      }
        !          1254: }
        !          1255: 
        !          1256: void
        !          1257: wongamescreen(short p)
        !          1258: {
        !          1259:      int  cnt = 0,
        !          1260:           i,
        !          1261:           n;
        !          1262:      short oth;
        !          1263:      char tmpbuf[32];
        !          1264:      char *dptr;
        !          1265:      PSTR datapck;
        !          1266:      BOOL rc;
        !          1267:      struct netnowhdr gethdr;
        !          1268: 
        !          1269: // fprintf(stdaux, "wongamescreen\r\n");
        !          1270: 
        !          1271:      keystatus[0x1C] = keystatus[0x01] = 0;
        !          1272:      SND_Sound(S_DROPFLAG);
        !          1273:      do {
        !          1274:           if (cnt < 5) {
        !          1275:                cnt++;
        !          1276:                netsendmove();
        !          1277:           }
        !          1278:           rc = _FALSE;
        !          1279:           switch (netgame) {
        !          1280:           case 1:
        !          1281:                rc = hmiNETNOWGetHeader((PSTR) & gethdr, sizeof(struct netnowhdr),
        !          1282:                                        &datapck);
        !          1283:                if (rc == _TRUE) {
        !          1284:                     totrhdrs++;
        !          1285:                }
        !          1286:                break;
        !          1287:           case 2:
        !          1288:           case 3:
        !          1289:                dptr = (char *) &mdmrcvpck;
        !          1290:                if ((i = getpacket(&oth, dptr)) == 0) {
        !          1291:                     break;
        !          1292:                }
        !          1293:                rc = _TRUE;
        !          1294:                break;
        !          1295: #ifdef MPLAYERCOMPILE
        !          1296:           case MPLAYERGAME:{
        !          1297:                     // TODO
        !          1298:                     RTQ_NODE *n;
        !          1299: 
        !          1300:                     while ((n = MGenMoveTo(DOSPENDINGQUEUE, DOSWORKQUEUE)) == 0)
        !          1301:                          Yield();
        !          1302: 
        !          1303:                     memcpy(&othnetpck, n->rtqDatum, sizeof(struct netpck));
        !          1304: // fprintf(stdaux, "received %d\r\n",  sizeof (struct netpck));
        !          1305:                     MGenMoveTo(DOSWORKQUEUE, FREEQUEUE);
        !          1306:                     Yield();
        !          1307:                     rc = _TRUE;
        !          1308:                }
        !          1309:                break;
        !          1310: #endif
        !          1311:           }
        !          1312:           if (rc == _TRUE) {
        !          1313:                memset(&othnetpck, 0, sizeof(struct netpck));
        !          1314:                switch (netgame) {
        !          1315:                case 1:
        !          1316:                     hmiNETNOWGetBlock(datapck, (BYTE *) & othnetpck,
        !          1317:                                       sizeof(struct netpck));
        !          1318:                     break;
        !          1319:                case 2:
        !          1320:                case 3:
        !          1321:                     memmove(&othnetpck, &mdmrcvpck.data, sizeof(struct netpck));
        !          1322:                     break;
        !          1323: #ifdef MPLAYERCOMPILE
        !          1324:                case MPLAYERGAME:
        !          1325:                     // TODO
        !          1326:                     // done above
        !          1327:                     break;
        !          1328: #endif
        !          1329:                }
        !          1330:           }
        !          1331:           switch (p) {
        !          1332:           case TEAM1FLAG - 1:      // red team
        !          1333:                if (svga) {
        !          1334:                     overwritesprite(0, 0, SREDKNIGHTS1, 0, 0, 0);
        !          1335:                     overwritesprite(0, 240, SREDKNIGHTS2, 0, 0, 0);
        !          1336:                }
        !          1337:                else {
        !          1338:                     overwritesprite(0, 0, REDKNIGHTS, 0, 0, 0);
        !          1339:                }
        !          1340:                break;
        !          1341:           case TEAM2FLAG - 1:      // blue team
        !          1342:                if (svga) {
        !          1343:                     overwritesprite(0, 0, SBLUEKNIGHTS1, 0, 0, 0);
        !          1344:                     overwritesprite(0, 240, SBLUEKNIGHTS2, 0, 0, 0);
        !          1345:                }
        !          1346:                else {
        !          1347:                     overwritesprite(0, 0, BLUEKNIGHTS, 0, 0, 0);
        !          1348:                }
        !          1349:                break;
        !          1350:           case TEAM3FLAG - 1:      // purple team
        !          1351:                if (svga) {
        !          1352:                     overwritesprite(0, 0, SPURPLEKNIGHTS1, 0, 0, 0);
        !          1353:                     overwritesprite(0, 240, SPURPLEKNIGHTS2, 0, 0, 0);
        !          1354:                }
        !          1355:                else {
        !          1356:                     overwritesprite(0, 0, PURPLEKNIGHTS, 0, 0, 0);
        !          1357:                }
        !          1358:                break;
        !          1359:           case TEAM4FLAG - 1:      // brown team
        !          1360:                if (svga) {
        !          1361:                     overwritesprite(0, 0, SBROWNKNIGHTS1, 0, 0, 0);
        !          1362:                     overwritesprite(0, 240, SBROWNKNIGHTS2, 0, 0, 0);
        !          1363:                }
        !          1364:                else {
        !          1365:                     overwritesprite(0, 0, BROWNKNIGHTS, 0, 0, 0);
        !          1366:                }
        !          1367:                break;
        !          1368:           }
        !          1369:           for (i = 0, n = 0; i < MAXTEAMS; i++) {
        !          1370:                if (teaminplay[i]) {
        !          1371:                     sprintf(tmpbuf, "%s: %d", teamcolorstrings[i], teamscore[i]);
        !          1372:                     printext256(xdim - (strlen(tmpbuf) * 4),
        !          1373:                                 ydim - (n * 8) - tilesizy[STATUSBAR] - 8, 31, -1, tmpbuf, 1);
        !          1374:                     n++;
        !          1375:                }
        !          1376:           }
        !          1377:           nextpage();
        !          1378:      } while (keystatus[0x1C] == 0 && keystatus[0x01] == 0);
        !          1379:      gameactivated = 0;
        !          1380: }
        !          1381: 
        !          1382: char *
        !          1383: IPXadrstr(_IPX_INTERNET_ADDR * p)
        !          1384: {
        !          1385:      int  i,
        !          1386:           j,
        !          1387:           n;
        !          1388:      unsigned char far *ptr;
        !          1389:      static unsigned char ret[25];
        !          1390: 
        !          1391:      ptr = (char *) p;
        !          1392:      memset(ret, 0, sizeof(ret));
        !          1393:      for (i = j = n = 0; n < 4; i += 2, n++) {
        !          1394:           sprintf(&ret[i], "%02X", ptr[j++]);
        !          1395:      }
        !          1396:      strcat(ret, ":");
        !          1397:      i++;
        !          1398:      for (n = 0; n < 6; i += 2, n++) {
        !          1399:           sprintf(&ret[i], "%02X", ptr[j++]);
        !          1400:      }
        !          1401:      return (ret);
        !          1402: }
        !          1403: 
        !          1404: void
        !          1405: netgetmove(void)
        !          1406: {
        !          1407:      BOOL rc;
        !          1408:      PSTR datapck;
        !          1409:      short etype,
        !          1410:           i,
        !          1411:           p,
        !          1412:           sect,
        !          1413:           s,
        !          1414:           teamno;
        !          1415:      struct player *plr;
        !          1416:      char *dptr;
        !          1417:      struct netnowhdr gethdr;
        !          1418: 
        !          1419: // fprintf(stdaux, "netgetmove\r\n");
        !          1420:      do {
        !          1421:           rc = _FALSE;
        !          1422:           switch (netgame) {
        !          1423:           case 1:
        !          1424:                rc = hmiNETNOWGetHeader((PSTR) & gethdr, sizeof(struct netnowhdr),
        !          1425:                                        &datapck);
        !          1426:                if (rc == _TRUE) {
        !          1427: #ifdef DEBUGOUTPUT
        !          1428:                     debugout("HEDR: %06ld NETADR: %s\n", gethdr.seq,
        !          1429:                              IPXadrstr(&gethdr.netadr.sIPX));
        !          1430: #endif
        !          1431:                     totrhdrs++;
        !          1432:                }
        !          1433:                break;
        !          1434:           case 2:
        !          1435:           case 3:
        !          1436:                dptr = (char *) &mdmrcvpck;
        !          1437: #ifdef SERIAL1LIB
        !          1438:                if (sd.rx.q->count < sizeof(struct mdmpck)) {
        !          1439:                     return;
        !          1440:                }
        !          1441:                for (i = 0; i < 4; i++) {
        !          1442:                     dptr[i] = readSer(&sd);
        !          1443:                }
        !          1444:                if (mdmrcvpck.hdr[0] != 0x01 || mdmrcvpck.hdr[1] != 0x02
        !          1445:                    || mdmrcvpck.hdr[2] != 0x03 || mdmrcvpck.hdr[3] != 0x21) {
        !          1446:                     sprintf(netmsg, "netgetmove: Invalid header (%X,%X,%X,%X)",
        !          1447:                          mdmrcvpck.hdr[0], mdmrcvpck.hdr[1], mdmrcvpck.hdr[2],
        !          1448:                             mdmrcvpck.hdr[3]);
        !          1449:                     crash(netmsg);
        !          1450:                }
        !          1451:                mdmrcvpck.src = readSer(&sd);
        !          1452:                mdmrcvpck.dest = readSer(&sd);
        !          1453:                mdmrcvpck.len = readSer(&sd);
        !          1454:                dptr = (char *) &mdmrcvpck.data;
        !          1455:                for (i = 0; i < sizeof(struct netpck); i++) {
        !          1456:                     dptr[i] = readSer(&sd);
        !          1457:                }
        !          1458: #else
        !          1459:                if ((i = getpacket(&p, dptr)) == 0) {
        !          1460:                     break;
        !          1461:                }
        !          1462: #endif
        !          1463:                rc = _TRUE;
        !          1464:                break;
        !          1465: #ifdef MPLAYERCOMPILE
        !          1466:           case MPLAYERGAME:{
        !          1467:                     // TODO
        !          1468:                     rc = _TRUE;
        !          1469: // fprintf(stdaux, "netgetmove 1\r\n");
        !          1470:                }
        !          1471:                break;
        !          1472: #endif
        !          1473:           }
        !          1474:           if (rc == _TRUE) {
        !          1475:                memset(&othnetpck, 0, sizeof(struct netpck));
        !          1476:                switch (netgame) {
        !          1477:                case 1:
        !          1478:                     hmiNETNOWGetBlock(datapck, (BYTE *) & othnetpck,
        !          1479:                                       sizeof(struct netpck));
        !          1480: #ifdef DEBUGOUTPUT
        !          1481:                     debugout("PCKT: %06ld TAG: %03d P: %02d\n", gethdr.seq,
        !          1482:                              othnetpck.tagno, plrindex[othnetpck.tagno]);
        !          1483: #endif
        !          1484:                     break;
        !          1485:                case 2:
        !          1486:                case 3:
        !          1487:                     memmove(&othnetpck, &mdmrcvpck.data, sizeof(struct netpck));
        !          1488:                     break;
        !          1489: #ifdef MPLAYERCOMPILE
        !          1490:                case MPLAYERGAME:
        !          1491:                     {
        !          1492:                          RTQ_NODE *n;
        !          1493: 
        !          1494: // fprintf(stdaux, "netgetmove 2\r\n");
        !          1495:                          if ((n = MGenMoveTo(DOSPENDINGQUEUE, DOSWORKQUEUE)) != 0) {
        !          1496:                               memcpy(&othnetpck, n->rtqDatum, sizeof(struct netpck));
        !          1497:                               MGenMoveTo(DOSWORKQUEUE, FREEQUEUE);
        !          1498:                               Yield();
        !          1499:                          }
        !          1500:                          else
        !          1501:                               rc = 0;
        !          1502: 
        !          1503:                          break;
        !          1504:                     }
        !          1505: #endif
        !          1506:                }
        !          1507:                if (othnetpck.mapon != mapon) {    // on a different map
        !          1508:                     if (debugnet) {
        !          1509:                          debugout("SKIPPED - NOT ON SAME MAP");
        !          1510:                     }
        !          1511:                     continue;
        !          1512:                }
        !          1513:                if (othnetpck.gametype != gametype) {   // playing a different
        !          1514:                                                        // game
        !          1515:                     if (debugnet) {
        !          1516:                          debugout("SKIPPED - NOT IN SAME GAME");
        !          1517:                     }
        !          1518:                     continue;
        !          1519:                }
        !          1520: #if 0
        !          1521:                if (debugnet) {
        !          1522:                     debugout("PCKT RECV FROM P: %02d TAG: %d",
        !          1523:                              plrindex[othnetpck.tagno], othnetpck.tagno);
        !          1524:                }
        !          1525: #endif
        !          1526:                if (othnetpck.tagno == myrandomtag) {
        !          1527:                     if (debugnet) {
        !          1528:                          debugout("SKIPPED - OWN TAG");
        !          1529:                     }
        !          1530:                     continue;
        !          1531:                }
        !          1532:                p = plrindex[othnetpck.tagno];
        !          1533:                if (p == 255) {     // new player identified
        !          1534:                     switch (netgame) {
        !          1535:                     case 1:
        !          1536:                          hmiNETNOWAddNode(&gethdr.netadr);
        !          1537:                          hmiNETNOWSortNodes();
        !          1538:                          mynode = hmiNETNOWGetConsoleNode();
        !          1539:                          p = plrindex[othnetpck.tagno] = playersingame;
        !          1540:                          tagindex[p] = othnetpck.tagno;
        !          1541:                          playersingame = hmiNETNOWGetActiveNodes();
        !          1542:                          break;
        !          1543:                     case 2:
        !          1544:                     case 3:
        !          1545:                          mynode = 0;
        !          1546:                          p = plrindex[othnetpck.tagno] = playersingame++;
        !          1547:                          tagindex[p] = othnetpck.tagno;
        !          1548:                          break;
        !          1549: #ifdef MPLAYERCOMPILE
        !          1550:                     case MPLAYERGAME:
        !          1551:                          // TODO
        !          1552:                          p = plrindex[othnetpck.tagno] = playersingame++;
        !          1553:                          tagindex[p] = othnetpck.tagno;
        !          1554: // fprintf(stdaux, "*netgetmove: players in game %d, idx %d, my ti0 %d ti1 %d\r\n", playersingame, othnetpck.tagno, tagindex[0], tagindex[1]);
        !          1555: // fprintf(stdaux, "netgetmove: plrindex 0 %d plrindex 1 %d\r\n", plrindex[0], plrindex[1]);
        !          1556:                          break;
        !          1557: #endif
        !          1558:                     }
        !          1559: #ifdef DEBUGOUTPUT
        !          1560:                     debugout("PCKT: %06ld TAG: %03d P: %02d NEWPLAYER\n",
        !          1561:                              gethdr.seq, tagindex[plrindex[othnetpck.tagno]],
        !          1562:                              plrindex[othnetpck.tagno]);
        !          1563:                     sprintf(netmsg, "ADDING TAG %d", othnetpck.tagno);
        !          1564: #endif
        !          1565: // ccw               sendmyinfo(_NETNOW_BROADCAST,1);
        !          1566:                     sendmyinfo(_NETNOW_BROADCAST, 0);
        !          1567:                }
        !          1568:                if (p < 0 || p >= MAXPLAYERS) {
        !          1569: //                                     fprintf(stdaux, "error = player index invalid p = %d\r\n", p);
        !          1570:                     sprintf(netmsg, "netgetmove: player index invalid (p=%d)", p);
        !          1571:                     crash(netmsg);
        !          1572:                }
        !          1573:                if (xmit != 1) {
        !          1574:                     xmit = 1;
        !          1575:                }
        !          1576:                memmove(&netpck[p], &othnetpck, sizeof(struct netpck));
        !          1577:                memmove(&othadr[p], &gethdr.netadr, sizeof(_NETNOW_NODE_ADDR));
        !          1578:                if (netpck[p].action == -2) {
        !          1579:                     i = teamflagsprite[netpck[p].hasflag - 1];
        !          1580:                     if (i >= 0 && ihaveflag == netpck[p].hasflag) {
        !          1581:                          sprite[i].cstat &= ~32768;
        !          1582:                     }
        !          1583:                     if (netpck[p].hasflag - 1 == netpck[p].teamno) {
        !          1584:                          netmarkflag(i);
        !          1585:                     }
        !          1586:                }
        !          1587:                plr = &player[p];
        !          1588:                switch (netpck[p].weap) {
        !          1589:                case 1:
        !          1590:                case 2:
        !          1591:                case 3:
        !          1592:                case 4:
        !          1593:                case 8:
        !          1594:                     etype = 1;
        !          1595:                     break;
        !          1596:                case 5:
        !          1597:                case 6:
        !          1598:                case 7:
        !          1599:                case 9:
        !          1600:                     etype = 0;
        !          1601:                     break;
        !          1602:                default:
        !          1603:                     etype = 2;
        !          1604:                     break;
        !          1605:                }
        !          1606:                if (plr->spritenum <= 0) {
        !          1607: //                    etype=netpck[p].enemytype;
        !          1608:                     updatesector(netpck[p].x, netpck[p].y, &sect);
        !          1609:                     s = insertsprite(sect, 1);
        !          1610:                     sprite[s].x = netpck[p].x;
        !          1611:                     sprite[s].y = netpck[p].y;
        !          1612:                     sprite[s].z = netpck[p].z;
        !          1613:                     sprite[s].ang = netpck[p].ang;
        !          1614:                     sprite[s].picnum = enempics[etype];
        !          1615:                     sprite[s].cstat = 1 + 256;
        !          1616:                     sprite[s].xrepeat = xreps[etype];
        !          1617:                     sprite[s].yrepeat = yreps[etype];
        !          1618:                     sprite[s].owner = MAXSPRITES + p;
        !          1619:                     sprite[s].pal = teamcolor[netpck[p].teamno];
        !          1620:                     plr = &player[p];
        !          1621:                     plr->spritenum = s;
        !          1622:                     plr->x = sprite[s].x;
        !          1623:                     plr->y = sprite[s].y;
        !          1624:                     plr->z = sprite[s].z;
        !          1625:                     plr->ang = sprite[s].ang;
        !          1626:                     plr->height = PLAYERHEIGHT;
        !          1627:                     plr->sector = plr->oldsector = sprite[s].sectnum;
        !          1628:                }
        !          1629:                else {
        !          1630: //                    etype=netpck[p].enemytype;
        !          1631:                     if (gametype >= 1) {
        !          1632:                          teamno = netpck[p].teamno;
        !          1633:                     }
        !          1634:                     else {
        !          1635:                          teamno = plrindex[netpck[p].tagno];
        !          1636:                     }
        !          1637:                     plr->x = netpck[p].x;
        !          1638:                     plr->y = netpck[p].y;
        !          1639:                     plr->z = netpck[p].z;
        !          1640:                     plr->ang = netpck[p].ang;
        !          1641:                     plr->horiz = netpck[p].horiz;
        !          1642:                     if (plr->spritenum <= 0 || plr->spritenum >= MAXSPRITES) {
        !          1643:                          sprintf(netmsg, "netgetmove: player sprite number (%d) invalid",
        !          1644:                                  plr->spritenum);
        !          1645:                          crash(netmsg);
        !          1646:                     }
        !          1647:                     sprite[plr->spritenum].ang = plr->ang;
        !          1648:                     sprite[plr->spritenum].cstat = 1 + 256;
        !          1649:                     sprite[plr->spritenum].xrepeat = xreps[etype];
        !          1650:                     sprite[plr->spritenum].yrepeat = yreps[etype];
        !          1651:                     sprite[plr->spritenum].pal = teamcolor[netpck[p].teamno];
        !          1652:                     setsprite(plr->spritenum, plr->x, plr->y, plr->z + (plr->height << 8));
        !          1653:                     updatesector(plr->x, plr->y, &plr->sector);
        !          1654: //                    plr->sector = sprite[plr->spritenum].sectnum;
        !          1655:                     if (plr->sector < 0 || plr->sector >= numsectors) {
        !          1656:                          sprintf(netmsg, "netgetmove (p=%d): sector number"
        !          1657:                                  "invalid (t=%d s=%d x=%d, y=%d, z=%d)",p,
        !          1658:                                  teamno,plr->sector,
        !          1659:                                  plr->x, plr->y, plr->z);
        !          1660:                          crash(netmsg);
        !          1661:                     }
        !          1662:                     if (gametype >= 1) {
        !          1663:                          if (teamno < 0 || teamno >= MAXTEAMS) {
        !          1664:                               sprintf(netmsg, "netgetmove: invalid team number %d", teamno);
        !          1665:                               crash(netmsg);
        !          1666:                          }
        !          1667:                          if (teaminplay[teamno] == 0) {
        !          1668:                               teaminplay[teamno] = 1;
        !          1669:                               captureflagpic();
        !          1670:                          }
        !          1671:                     }
        !          1672:                     if (teamscore[teamno] < netpck[p].score) {
        !          1673:                          teamscore[teamno] = netpck[p].score;
        !          1674:                          if (gametype >= 1) {
        !          1675:                               captureflagpic();
        !          1676:                          }
        !          1677:                          else {
        !          1678:                               fragspic();
        !          1679:                          }
        !          1680:                     }
        !          1681:                     if (gametype >= 1 && netpck[p].hasflag) {
        !          1682:                          if (netpck[p].hasflag < 1 || netpck[p].hasflag > MAXTEAMS) {
        !          1683:                               sprintf(netmsg, "netgetmove: flag referencing invalid team %d",
        !          1684:                                       netpck[p].hasflag);
        !          1685:                               crash(netmsg);
        !          1686:                          }
        !          1687:                          if (ihaveflag < 0 || ihaveflag > MAXTEAMS) {
        !          1688:                               sprintf(netmsg, "netgetmove: ihaveflag (%d) invalid value",
        !          1689:                                       ihaveflag);
        !          1690:                               crash(netmsg);
        !          1691:                          }
        !          1692:                          if (netpck[p].hasflag == ihaveflag) {
        !          1693:                               if (teamflagsprite[ihaveflag - 1] >= 0) {
        !          1694:                                    playsound_loc(S_LAUGH, netpck[p].x, netpck[p].y);
        !          1695:                                    sprite[teamflagsprite[ihaveflag - 1]].cstat &= ~32768;
        !          1696:                               }
        !          1697:                               ihaveflag = 0;
        !          1698:                          }
        !          1699:                          moveflag(plr->x, plr->y, plr->z, netpck[p].hasflag);
        !          1700:                          switch (sector[plr->sector].lotag) {
        !          1701:                          case TEAM1SECTOR:
        !          1702:                               switch (netpck[p].hasflag) {
        !          1703:                               case TEAM2FLAG:
        !          1704:                               case TEAM3FLAG:
        !          1705:                               case TEAM4FLAG:
        !          1706:                                    if (teaminplay[netpck[p].hasflag - 1]) {
        !          1707:                                         teamscore[TEAM1FLAG - 1] += 1;
        !          1708:                                         playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !          1709: //                                        if (teamscore[netpck[p].hasflag-1] > 0) {
        !          1710: //                                             teamscore[netpck[p].hasflag-1]--;
        !          1711: //                                        }
        !          1712:                                    }
        !          1713:                                    break;
        !          1714:                               }
        !          1715:                               dropflagstart(netpck[p].hasflag);
        !          1716:                               captureflagpic();
        !          1717:                               break;
        !          1718:                          case TEAM2SECTOR:
        !          1719:                               switch (netpck[p].hasflag) {
        !          1720:                               case TEAM1FLAG:
        !          1721:                               case TEAM3FLAG:
        !          1722:                               case TEAM4FLAG:
        !          1723:                                    if (teaminplay[netpck[p].hasflag - 1]) {
        !          1724:                                         teamscore[TEAM2FLAG - 1] += 1;
        !          1725:                                         playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !          1726: //                                        if (teamscore[netpck[p].hasflag-1] > 0) {
        !          1727: //                                             teamscore[netpck[p].hasflag-1]--;
        !          1728: //                                        }
        !          1729:                                    }
        !          1730:                                    break;
        !          1731:                               }
        !          1732:                               dropflagstart(netpck[p].hasflag);
        !          1733:                               captureflagpic();
        !          1734:                               break;
        !          1735:                          case TEAM3SECTOR:
        !          1736:                               switch (netpck[p].hasflag) {
        !          1737:                               case TEAM1FLAG:
        !          1738:                               case TEAM2FLAG:
        !          1739:                               case TEAM4FLAG:
        !          1740:                                    if (teaminplay[netpck[p].hasflag - 1]) {
        !          1741:                                         teamscore[TEAM3FLAG - 1] += 1;
        !          1742:                                         playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !          1743: //                                        if (teamscore[netpck[p].hasflag-1] > 0) {
        !          1744: //                                             teamscore[netpck[p].hasflag-1]--;
        !          1745: //                                        }
        !          1746:                                    }
        !          1747:                                    break;
        !          1748:                               }
        !          1749:                               dropflagstart(netpck[p].hasflag);
        !          1750:                               captureflagpic();
        !          1751:                               break;
        !          1752:                          case TEAM4SECTOR:
        !          1753:                               switch (netpck[p].hasflag) {
        !          1754:                               case TEAM1FLAG:
        !          1755:                               case TEAM2FLAG:
        !          1756:                               case TEAM3FLAG:
        !          1757:                                    if (teaminplay[netpck[p].hasflag - 1]) {
        !          1758:                                         teamscore[TEAM4FLAG - 1] += 1;
        !          1759:                                         playsound_loc(S_DROPFLAG, netpck[p].x, netpck[p].y);
        !          1760: //                                        if (teamscore[netpck[p].hasflag-1] > 0) {
        !          1761: //                                             teamscore[netpck[p].hasflag-1]--;
        !          1762: //                                        }
        !          1763:                                    }
        !          1764:                                    break;
        !          1765:                               }
        !          1766:                               dropflagstart(netpck[p].hasflag);
        !          1767:                               captureflagpic();
        !          1768:                               break;
        !          1769:                          }
        !          1770:                     }
        !          1771:                }
        !          1772:                switch (netpck[p].action) {
        !          1773:                case KEYFIRE:
        !          1774:                     if (sprite[plr->spritenum].statnum != ATTACK) {
        !          1775:                          newstatus(plr->spritenum, ATTACK);
        !          1776:                     }
        !          1777:                     if (netpck[p].guntype != 0) {
        !          1778:                          nethitsprite(p, netpck[p].guntype, netpck[p].taghit);
        !          1779:                          netpck[p].taghit = 0;
        !          1780:                          netpck[p].guntype = 0;
        !          1781:                     }
        !          1782:                     break;
        !          1783:                case -1:
        !          1784:                     if (sprite[plr->spritenum].statnum != DIE) {
        !          1785:                          newstatus(plr->spritenum, DIE);
        !          1786:                          if (netpck[p].taghit == myrandomtag) {
        !          1787:                               if (gametype < 1) {
        !          1788:                                    teamscore[0]++;
        !          1789:                                    fragspic();
        !          1790:                               }
        !          1791:                          }
        !          1792:                          if (playersingame == 2) {
        !          1793:                               xmit = 0;
        !          1794:                          }
        !          1795:                     }
        !          1796:                     break;
        !          1797:                default:
        !          1798:                     sprite[plr->spritenum].picnum = enempics[etype];
        !          1799:                     if (sprite[plr->spritenum].statnum != 1) {
        !          1800:                          changespritestat(plr->spritenum, 1);
        !          1801:                     }
        !          1802:                     break;
        !          1803:                }
        !          1804:                numspcks[p]++;
        !          1805:                totrpcks++;
        !          1806:           }
        !          1807:      } while (rc != _FALSE);
        !          1808:      for (i = 0; i < MAXTEAMS; i++) {
        !          1809:           switch (gametype) {
        !          1810:           case 0:                  // head to head
        !          1811:                break;
        !          1812:           case 1:                  // capture the flag 21
        !          1813:                if (teamscore[i] >= 21) {
        !          1814:                     wongamescreen(i);
        !          1815:                     netpickmonster();
        !          1816:                }
        !          1817:                break;
        !          1818:           case 2:                  // capture the flag 7
        !          1819:                if (teamscore[i] >= 7) {
        !          1820:                     wongamescreen(i);
        !          1821:                     netpickmonster();
        !          1822:                }
        !          1823:                break;
        !          1824:           }
        !          1825:      }
        !          1826: }
        !          1827: 
        !          1828: void
        !          1829: netpickmonster(void)
        !          1830: {
        !          1831:      int  animpic,
        !          1832:           i,
        !          1833:           more = 1,
        !          1834:           numenemchoices,
        !          1835:           numgamechoices,
        !          1836:           nummapchoices,
        !          1837:           pal,
        !          1838:           picking,
        !          1839:           selected,
        !          1840:           step=0;
        !          1841:      long animclock = 0L;
        !          1842:      char tmpbuf[32];
        !          1843:      struct player *plr;
        !          1844: 
        !          1845: // fprintf(stdaux, "netpickmonster\r\n");
        !          1846: 
        !          1847:      animpic = picking = selected = 0;
        !          1848:      keystatus[0x1C] = 0;
        !          1849:      numenemchoices = MAXTEAMS;
        !          1850:      numgamechoices = NUMGAMES;
        !          1851:      nummapchoices = sizeof(mapnumbers) / sizeof(short);
        !          1852:      animclock = totalclock + (CLKIPS >> 3);
        !          1853:      keystatus[0x1C] = keystatus[0x01] = 0;
        !          1854:      do {
        !          1855:           if (svga) {
        !          1856:                rotatesprite(0L << 16, 0L << 16, 65536L, 0, VMAINBLANK,
        !          1857:                             0, 0, 8 + 16, 0L, 0L, xdim - 1L, ydim - 1L);
        !          1858:           }
        !          1859:           else {
        !          1860:                rotatesprite(0L << 16, 0L << 16, 65536L, 0, 1028,
        !          1861:                             0, 0, 8 + 16, 0L, 0L, xdim - 1L, ydim - 1L);
        !          1862:           }
        !          1863:           switch (picking) {
        !          1864:           case 0:
        !          1865:                for (i = 0; i < numenemchoices; i++) {
        !          1866:                     if (i == selected) {
        !          1867:                          rotatesprite(((xdim>>1)-135L)<<16,
        !          1868:                                       (((ydim>>1)-72L)+(i * 19))<<16,
        !          1869:                                       16384L, 0, HELMET + step,
        !          1870:                                       0, 0, 8 + 16,
        !          1871:                                       0L, 0L, xdim-1L, ydim-1L);
        !          1872:                     }
        !          1873:                     pal = 3;
        !          1874:                     strcpy(tmpbuf, monsternames[i]);
        !          1875:                     fancyfont((xdim >> 1) - 100, (ydim >> 1) - 69 + (i * 19),
        !          1876:                               THEFONT, tmpbuf, pal);
        !          1877:                }
        !          1878:                if (totalclock >= animclock) {
        !          1879:                     if (selected == 9) {
        !          1880:                          animpic = (animpic + 1) & 15;
        !          1881:                     }
        !          1882:                     else {
        !          1883:                          animpic = (animpic + 1) & 3;
        !          1884:                     }
        !          1885:                     step = (step + 1) & 7;
        !          1886:                     animclock = totalclock + (CLKIPS >> 3);
        !          1887:                }
        !          1888:                overwritesprite((xdim >> 1) + 35, 10,
        !          1889:                                enempics[0] + animpic,
        !          1890:                                0, 0, teamcolor[selected]);
        !          1891:                if (keystatus[0x1C]) {
        !          1892:                     keystatus[0x1C] = 0;
        !          1893:                     enemytype = selected;
        !          1894:                     myteam = selected;
        !          1895:                     selected = 0;
        !          1896: 
        !          1897: #ifdef MPLAYERCOMPILE
        !          1898:                     // ccw
        !          1899:                     if (netgame != MPLAYERGAME)
        !          1900: #endif
        !          1901:                          picking = 1;
        !          1902: #ifdef MPLAYERCOMPILE
        !          1903:                     else {
        !          1904:                          gametype = 0;  // head to head
        !          1905:                          mapon = mapnumbers[3];   // four castles
        !          1906:                          more = 0; // bail
        !          1907:                     }
        !          1908: #endif
        !          1909:                }
        !          1910:                else if (keystatus[0x01]) {
        !          1911:                     keystatus[0x01] = 0;
        !          1912:                     shutdown();
        !          1913:                }
        !          1914:                break;
        !          1915:           case 1:
        !          1916:                for (i = 0; i < numgamechoices; i++) {
        !          1917:                     if (i == selected) {
        !          1918:                          rotatesprite(((xdim>>1)-135L)<<16,
        !          1919:                                       (((ydim>>1)-72L)+(i * 19))<<16,
        !          1920:                                       16384L, 0, HELMET + step,
        !          1921:                                       0, 0, 8 + 16,
        !          1922:                                       0L, 0L, xdim-1L, ydim-1L);
        !          1923:                     }
        !          1924:                     pal = 3;
        !          1925:                     strcpy(tmpbuf, gamenames[i]);
        !          1926:                     fancyfont((xdim >> 1) - 100, (ydim >> 1) - 69 + (i * 19),
        !          1927:                               THEFONT, tmpbuf, pal);
        !          1928:                }
        !          1929:                if (totalclock >= animclock) {
        !          1930:                     step = (step + 1) & 7;
        !          1931:                     animclock = totalclock + (CLKIPS >> 3);
        !          1932:                }
        !          1933:                if (keystatus[0x1C]) {
        !          1934:                     keystatus[0x1C] = 0;
        !          1935:                     gametype = selected;
        !          1936:                     selected = 0;
        !          1937:                     picking = 2;
        !          1938:                }
        !          1939:                else if (keystatus[0x01]) {
        !          1940:                     keystatus[0x01] = 0;
        !          1941:                     selected = 0;
        !          1942:                     picking = 0;
        !          1943:                }
        !          1944:                break;
        !          1945:           case 2:
        !          1946:                for (i = 0; i < nummapchoices; i++) {
        !          1947:                     if (i == selected) {
        !          1948:                          rotatesprite(((xdim>>1)-152L)<<16,
        !          1949:                                       (((ydim>>1)-72L)+(i * 19))<<16,
        !          1950:                                       16384L, 0, HELMET + step,
        !          1951:                                       0, 0, 8 + 16,
        !          1952:                                       0L, 0L, xdim-1L, ydim-1L);
        !          1953:                     }
        !          1954:                     pal = 3;
        !          1955:                     strcpy(tmpbuf, mapnames[i]);
        !          1956:                     fancyfont((xdim >> 1) - 130, (ydim >> 1) - 69 + (i * 19),
        !          1957:                               THEFONT, tmpbuf, pal);
        !          1958:                }
        !          1959:                if (totalclock >= animclock) {
        !          1960:                     step = (step + 1) & 7;
        !          1961:                     animclock = totalclock + (CLKIPS >> 3);
        !          1962:                }
        !          1963:                if (keystatus[0x1C]) {
        !          1964:                     keystatus[0x1C] = 0;
        !          1965:                     mapon = mapnumbers[selected];
        !          1966:                     more = 0;
        !          1967:                }
        !          1968:                else if (keystatus[0x01]) {
        !          1969:                     keystatus[0x01] = 0;
        !          1970:                     selected = 0;
        !          1971:                     picking = 1;
        !          1972:                }
        !          1973:                break;
        !          1974:           }
        !          1975:           nextpage();
        !          1976:           if (keystatus[keys[KEYBACK]] != 0) {
        !          1977:                keystatus[keys[KEYBACK]] = 0;
        !          1978:                selected++;
        !          1979:                switch (picking) {
        !          1980:                case 0:
        !          1981:                     if (selected >= numenemchoices) {
        !          1982:                          selected = 0;
        !          1983:                     }
        !          1984:                     break;
        !          1985:                case 1:
        !          1986:                     if (selected >= numgamechoices) {
        !          1987:                          selected = 0;
        !          1988:                     }
        !          1989:                     break;
        !          1990:                case 2:
        !          1991:                     if (selected >= nummapchoices) {
        !          1992:                          selected = 0;
        !          1993:                     }
        !          1994:                     break;
        !          1995:                }
        !          1996:           }
        !          1997:           else if (keystatus[keys[KEYFWD]] != 0) {
        !          1998:                keystatus[keys[KEYFWD]] = 0;
        !          1999:                selected--;
        !          2000:                switch (picking) {
        !          2001:                case 0:
        !          2002:                     if (selected < 0) {
        !          2003:                          selected = numenemchoices - 1;
        !          2004:                     }
        !          2005:                     break;
        !          2006:                case 1:
        !          2007:                     if (selected < 0) {
        !          2008:                          selected = numgamechoices - 1;
        !          2009:                     }
        !          2010:                     break;
        !          2011:                case 2:
        !          2012:                     if (selected < 0) {
        !          2013:                          selected = nummapchoices - 1;
        !          2014:                     }
        !          2015:                     break;
        !          2016:                }
        !          2017:           }
        !          2018:      } while (more);
        !          2019:      for (i = 0; i < MAXSECTORS; i++) {
        !          2020:           // memset(&sector[i],0,sizeof(struct sectortype));
        !          2021:           memset(&sector[i], 0, sizeof(sectortype));
        !          2022:      }
        !          2023:      for (i = 0; i < MAXWALLS; i++) {
        !          2024:           // memset(&wall[i],0,sizeof(struct walltype));
        !          2025:           memset(&wall[i], 0, sizeof(walltype));
        !          2026:      }
        !          2027:      for (i = 0; i < MAXSPRITES; i++) {
        !          2028:           // memset(&sprite[i],0,sizeof(struct spritetype));
        !          2029:           memset(&sprite[i], 0, sizeof(spritetype));
        !          2030:      }
        !          2031:      for (i = 0; i < MAXPLAYERS; i++) {
        !          2032:           memset(&player[i], 0, sizeof(struct player));
        !          2033:      }
        !          2034:      for (i = 0; i < MAXPLAYERS; i++) {
        !          2035:           teaminplay[i] = 0;
        !          2036:           teamscore[i] = 0;
        !          2037:      }
        !          2038:      plr = &player[pyrn];
        !          2039:      plr->oldsector = plr->sector;
        !          2040:      plr->horiz = 100;
        !          2041:      plr->zoom = 256;
        !          2042:      if (svga == 1) {
        !          2043:           plr->screensize = 328;
        !          2044:      }
        !          2045:      else {
        !          2046:           plr->screensize = 320;
        !          2047:      }
        !          2048:      plr->dimension = 3;
        !          2049:      plr->height = PLAYERHEIGHT;
        !          2050:      plr->z = sector[plr->sector].floorz - (plr->height << 8);
        !          2051: 
        !          2052:      loadnewlevel(mapon);
        !          2053:      mapflag = 1;
        !          2054:      if (plr->spritenum <= 0) {
        !          2055:           initplayersprite();
        !          2056:      }
        !          2057:      setup3dscreen();
        !          2058:      netjoingame();
        !          2059:      netstartx = player[pyrn].x;
        !          2060:      netstarty = player[pyrn].y;
        !          2061:      netstartz = player[pyrn].z;
        !          2062:      netstarts = player[pyrn].sector;
        !          2063:      gameactivated = 1;
        !          2064:      updatepics();
        !          2065: }
        !          2066: 
        !          2067: #define   NUMSETOPTS          2
        !          2068: 
        !          2069: char *setopts[] = {
        !          2070:      "COM PORT:",
        !          2071:      "BAUD RATE:"
        !          2072: };
        !          2073: 
        !          2074: void
        !          2075: mdmreadsettings(void)
        !          2076: {
        !          2077:      short i,
        !          2078:           n;
        !          2079:      long l;
        !          2080:      char buf[80],
        !          2081:          *ptr;
        !          2082:      FILE *fp;
        !          2083: 
        !          2084: // fprintf(stdaux, "mdmreadsettings\r\n");
        !          2085:      fp = fopen("modem.dat", "r");
        !          2086:      if (fp == NULL) {
        !          2087:           return;
        !          2088:      }
        !          2089:      while (fgets(buf, 80, fp) != NULL) {
        !          2090:           for (i = 0; i < NUMSETOPTS; i++) {
        !          2091:                if ((ptr = strstr(buf, setopts[i])) != NULL) {
        !          2092:                     ptr += strlen(setopts[i]);
        !          2093:                     switch (i) {
        !          2094:                     case 0:        // com port
        !          2095:                          sscanf(ptr, "%d", &n);
        !          2096:                          if (n < 1 || n > 4) {
        !          2097:                               break;
        !          2098:                          }
        !          2099:                          comp = n;
        !          2100:                          break;
        !          2101:                     case 1:        // baud rate
        !          2102:                          sscanf(ptr, "%ld", &l);
        !          2103:                          if (l < 2400L || l > 115200L) {
        !          2104:                               break;
        !          2105:                          }
        !          2106:                          bps = l;
        !          2107:                          break;
        !          2108:                     }
        !          2109:                }
        !          2110:           }
        !          2111:      }
        !          2112:      fclose(fp);
        !          2113: }
        !          2114: 
        !          2115: char comtable[] = {0x00, 0x01, 0x02, 0x03, 0x04};
        !          2116: 
        !          2117: void
        !          2118: initmulti(int numplayers)
        !          2119: {
        !          2120:      int  i,
        !          2121:           stat;
        !          2122:      char option4,
        !          2123:           option5;
        !          2124:      FILE *fp;
        !          2125: 
        !          2126: // fprintf(stdaux, "initmulti\r\n");
        !          2127: //     installGPhandler();
        !          2128:      fp = fopen("tag.dat", "rb");
        !          2129:      if (fp != NULL) {
        !          2130:           fread(&myrandomtag, sizeof(myrandomtag), 1, fp);
        !          2131:           fclose(fp);
        !          2132:      }
        !          2133: #ifdef DEBUGOUTPUT
        !          2134:      dbgfp = fopen("debug.out", "w");
        !          2135: #endif
        !          2136:      if (numplayers > _NETNOW_MAX_NODES) {
        !          2137:           numplayers = _NETNOW_MAX_NODES;
        !          2138:      }
        !          2139:      switch (netgame) {
        !          2140:      case 1:
        !          2141:           if (hmiNETNOWInitSystem(numplayers) != _NETNOW_NO_ERROR) {
        !          2142:                crash("WHNET: IPX/NETBIOS driver not loaded");
        !          2143:           }
        !          2144:           netinitialized = 1;
        !          2145:           if (!hmiNETNOWGetNetworkAddr(&myadr)) {
        !          2146:                crash("WHNET: Cannot identify local address");
        !          2147:           }
        !          2148:           mynode = hmiNETNOWGetConsoleNode();
        !          2149:           stat = 1;
        !          2150:           break;
        !          2151:      case 2:
        !          2152:      case 3:
        !          2153:           mdmsndpck.hdr[0] = 0x03;
        !          2154:           mdmsndpck.hdr[1] = 0x02;
        !          2155:           mdmsndpck.hdr[2] = 0x01;
        !          2156:           mdmsndpck.hdr[3] = 0x21;
        !          2157:           mdmsndpck.len = sizeof(struct netpck);
        !          2158:           mdmreadsettings();
        !          2159: #ifdef SERIAL1LIB
        !          2160:           stat = initSerial(&sd, comp - 1, USE_16550, 256L, 1024L);
        !          2161:           if (stat == SER_OK) {
        !          2162:                netinitialized;
        !          2163:                if (netgame == 2 && getDCD(&sd) == _FALSE) {
        !          2164:                     crash("MODEM connection not established");
        !          2165:                }
        !          2166:                setBPS(&sd, bps);
        !          2167:                stat = 1;
        !          2168:           }
        !          2169:           else {
        !          2170:                crash("COM port unavailable");
        !          2171:           }
        !          2172: #else
        !          2173:           option4 = option5 = 0;
        !          2174:           option4 = comtable[comp];
        !          2175:           switch (bps) {
        !          2176:           case 2400:
        !          2177:                break;
        !          2178:           case 4800:
        !          2179:                option5 |= 0x01;
        !          2180:                break;
        !          2181:           case 14400:
        !          2182:                option5 |= 0x03;
        !          2183:                break;
        !          2184:           case 19200:
        !          2185:                option5 |= 0x04;
        !          2186:                break;
        !          2187:           case 28800:
        !          2188:                option5 |= 0x05;
        !          2189:                break;
        !          2190:           default:
        !          2191:           case 9600:
        !          2192:                option5 |= 0x02;
        !          2193:                break;
        !          2194:           }
        !          2195:           if (comp == 1 || comp == 3) {
        !          2196:                option5 |= 0x20;
        !          2197:           }
        !          2198:           else {
        !          2199:                option5 |= 0x10;
        !          2200:           }
        !          2201:           initmultiplayers(option4, option5);
        !          2202:           netinitialized = 1;
        !          2203: #endif
        !          2204:           break;
        !          2205: #ifdef MPLAYERCOMPILE
        !          2206:      case MPLAYERGAME:{
        !          2207:                unsigned rtqSize;
        !          2208:                char error[80];
        !          2209: 
        !          2210:                MasterNode = MGenGetMasterNode(&rtqSize);
        !          2211:                if (rtqSize != sizeof(RTQ_NODE)) {
        !          2212:                     sprintf(error, "Incompatible version of Mplayer: expected %d"
        !          2213:                             " got %d\n", sizeof(RTQ_NODE), rtqSize);
        !          2214:                     crash(error);
        !          2215:                }
        !          2216:                netinitialized = 1;
        !          2217:                mynode = 0;
        !          2218:                stat = 1;
        !          2219:           }
        !          2220:           break;
        !          2221: #endif
        !          2222:      }
        !          2223:      for (i = 0; i < 256; i++) {
        !          2224:           plrindex[i] = 255;
        !          2225:      }
        !          2226:      for (i = 0; i < MAXTEAMS; i++) {
        !          2227:           teamflagsprite[i] = -1;
        !          2228:      }
        !          2229:      netpickmonster();
        !          2230: }
        !          2231: 
        !          2232: void
        !          2233: dropDTR(void)
        !          2234: {
        !          2235:      outp(comadr[comp] + 4, 0);
        !          2236: }
        !          2237: 
        !          2238: void
        !          2239: netshutdown(void)
        !          2240: {
        !          2241: // fprintf(stdaux, "netshutdown\r\n");
        !          2242:      if (netinitialized) {
        !          2243:           switch (netgame) {
        !          2244:  case 1:
        !          2245:                hmiNETNOWUnInitSystem();
        !          2246:                break;
        !          2247:           case 2:
        !          2248:           case 3:
        !          2249: #ifdef SERIAL1LIB
        !          2250:                setDTR(&sd, 0);
        !          2251:                setRTS(&sd, 0);
        !          2252:                deInitSerial(&sd);
        !          2253: #else
        !          2254:                uninitmultiplayers();
        !          2255:                dropDTR();
        !          2256: #endif
        !          2257:                break;
        !          2258: #ifdef MPLAYERCOMPILE
        !          2259:           case MPLAYERGAME:
        !          2260:                // TODO
        !          2261:                // do nothing for us
        !          2262:                break;
        !          2263: #endif
        !          2264:           }
        !          2265:      }
        !          2266: #ifdef DEBUGOUTPUT
        !          2267:      if (dbgfp != NULL) {
        !          2268:           fclose(dbgfp);
        !          2269:      }
        !          2270: #endif
        !          2271: }
        !          2272: 
        !          2273: void
        !          2274: whnetmon(void)
        !          2275: {
        !          2276:      int  i,
        !          2277:           n;
        !          2278:      long loz;
        !          2279:      char tmpbuf[80];
        !          2280: 
        !          2281: // fprintf(stdaux, "whnetmon\r\n");
        !          2282: 
        !          2283:      if (debugnet) {
        !          2284: //      {
        !          2285:           sprintf(tmpbuf, "P: %02d S: %05d R: %05d HDR: %05d "
        !          2286:                   "N: %02d T:%03d SPR: %04d %s",
        !          2287:              playersingame, totspcks, totrpcks, totrhdrs, mynode, myrandomtag,
        !          2288:                   player[pyrn].spritenum, netmsg);
        !          2289:           memset(netmsg, 0, sizeof(netmsg));
        !          2290:           printext256(0L, 8L, 31, -1, tmpbuf, 1);
        !          2291:           for (i = 0; i < playersingame; i++) {
        !          2292:                n = plrindex[tagindex[i]];
        !          2293:                sprintf(tmpbuf, "P: %02d T: %03d X: %05d Y: %05d Z: %05d "
        !          2294:                        "M: %02d AN: %05d F: %02d SPR: %04d",
        !          2295:                        n, tagindex[i],
        !          2296:                        player[n].x, player[n].y, player[n].z,
        !          2297:                        netpck[n].mapon, player[n].ang, netpck[n].hasflag,
        !          2298:                        player[n].spritenum);
        !          2299:                printext256(0L, 16L + (i * 8), 31, -1, tmpbuf, 1);
        !          2300:           }
        !          2301:           for (i = 0; i < MAXTEAMS; i++) {
        !          2302:                if (teamflagsprite[i] == -1) {
        !          2303:                     continue;
        !          2304:                }
        !          2305:                sprintf(tmpbuf, "F: %03d S: %d X: %05d Y: %05d Z: %05d",
        !          2306:                        i, teamflagsprite[i],
        !          2307:                      sprite[teamflagsprite[i]].x, sprite[teamflagsprite[i]].y,
        !          2308:                        sprite[teamflagsprite[i]].z);
        !          2309:                printext256(0L, 16L + (playersingame * 8) + (i * 8), 31, -1, tmpbuf, 1);
        !          2310:           }
        !          2311:           for (i = 0, n = 0; i < MAXTEAMS; i++) {
        !          2312:                if (teaminplay[i]) {
        !          2313:                     sprintf(tmpbuf, "%s: %d", teamcolorstrings[i], teamscore[i]);
        !          2314:                     printext256(xdim - (strlen(tmpbuf) * 4),
        !          2315:                                 ydim - (n * 8) - tilesizy[STATUSBAR] - 8, 31, -1, tmpbuf, 1);
        !          2316:                     n++;
        !          2317:                }
        !          2318:           }
        !          2319:      }
        !          2320:      if (gametype >= 1) {
        !          2321:           if (svga) {
        !          2322:                overwritesprite(600, 48, THEFLAG, 0, 0x02, teamcolor[myteam]);
        !          2323:           }
        !          2324:           else {
        !          2325:                overwritesprite(xdim - tilesizx[THEFLAG], (ydim - 40), THEFLAG,
        !          2326:                                0, 0x02, teamcolor[myteam]);
        !          2327:           }
        !          2328:           if (ihaveflag) {
        !          2329:                if (svga) {
        !          2330:                     rotatesprite(28L << 16, 48L << 16, 16384L, 0, TEAMFLAG, 0,
        !          2331:                                  teamcolor[ihaveflag - 1], 8 + 16,
        !          2332:                                  0L, 0L, xdim - 1L, ydim - 1L);
        !          2333:                }
        !          2334:                else {
        !          2335:                     rotatesprite(8L << 16, 48L << 16, 16384L, 0, TEAMFLAG, 0,
        !          2336:                                  teamcolor[ihaveflag - 1], 8 + 16,
        !          2337:                                  0L, 0L, xdim - 1L, ydim - 1L);
        !          2338:                }
        !          2339:           }
        !          2340:           for (n = 0; n < MAXTEAMS; n++) {
        !          2341:                i = teamflagsprite[n];
        !          2342:                if (i >= 0) {
        !          2343:                     loz = sector[sprite[i].sectnum].floorz;
        !          2344:                     for (i = 0; i < playersingame; i++) {
        !          2345:                          if (netpck[i].hasflag == n + 1) {
        !          2346:                               break;
        !          2347:                          }
        !          2348:                     }
        !          2349:                     if (i == playersingame) {
        !          2350:                          i = teamflagsprite[n];
        !          2351:                          if (sprite[i].z < loz) {
        !          2352:                               sprite[i].zvel += GRAVITYCONSTANT;
        !          2353:                          }
        !          2354:                          sprite[i].z += sprite[i].zvel;
        !          2355:                          if (sprite[i].z > loz) {
        !          2356:                               sprite[i].zvel = -(sprite[i].zvel >> 2);
        !          2357:                               sprite[i].z = loz;
        !          2358:                          }
        !          2359:                     }
        !          2360:                }
        !          2361:           }
        !          2362:      }
        !          2363:      if (netgame == 2) {
        !          2364:           if ((inp(comadr[comp] + 6) & 0x80) == 0) {
        !          2365:                sprintf(tmpbuf, "NO CONNECTION");
        !          2366:                printext256((xdim >> 1) - (strlen(tmpbuf) << 2), (ydim >> 1), 31, -1, tmpbuf, 1);
        !          2367:           }
        !          2368:      }
        !          2369:      if (escapetomenu) {
        !          2370:           if (keystatus[0x15]) {
        !          2371:                for (i=0 ; i < 5 ; i++) {
        !          2372:                     netkillme();
        !          2373:                }
        !          2374:                shutdown();
        !          2375:           }
        !          2376:           else if (keystatus[0x31]) {
        !          2377:                keystatus[0x31] = 0;
        !          2378:                escapetomenu = 0;
        !          2379:           }
        !          2380:           sprintf(tmpbuf, "QUIT GAME (Y/N)?");
        !          2381:           printext256(0L, 0L, 31, -1, tmpbuf, 0);
        !          2382:      }
        !          2383: }
        !          2384: 
        !          2385: void
        !          2386: netrestartplayer(struct player * plr)
        !          2387: {
        !          2388:      plr->x = netstartx;
        !          2389:      plr->y = netstarty;
        !          2390:      plr->z = netstartz;
        !          2391:      plr->sector = netstarts;
        !          2392: 
        !          2393: // fprintf(stdaux, "netstartplayer %d %d %d %d\r\n", plr->x, plr->y, plr->z, plr->sector);
        !          2394: }
        !          2395: 
        !          2396: void
        !          2397: netkillme(void)
        !          2398: {
        !          2399: // fprintf(stdaux, "netkillme\r\n");
        !          2400:      playerdie = 1;
        !          2401:      netsendmove();
        !          2402: }
        !          2403: 
        !          2404: void
        !          2405: netreviveme(void)
        !          2406: {
        !          2407: // fprintf(stdaux, "netreviveme\r\n");
        !          2408:      playerdie = 0;
        !          2409: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.