![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to whnet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Witchaven II] / src|
Return to whnet.c CVS log | Up to [Witchaven II] / src |
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, ®s, ®s);
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, ®s, ®s);
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, §);
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, §);
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(§or[i],0,sizeof(struct sectortype));
2021: memset(§or[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.