Mercurial > ~darius > hgwebdir.cgi > paradise_client

comparison shortcomm.c @ 3:5a977ccbc7a9 default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Empty changelog
author darius
date Sat, 06 Dec 1997 05:41:29 +0000
parents
children
comparison
equal deleted inserted replaced
2:fba0b6e6cdc7 3:5a977ccbc7a9
1 /* $Id: shortcomm.c,v 1.1.1.1 1997/12/06 05:41:30 darius Exp $ */
2
3 /* This file implements all SHORT_PACKETS functions */
4 /* HW 19.07.93 */
5 #ifdef SHORT_PACKETS
6
7 #ifdef HPBSD
8 #include <machine/endian.h>
9 #endif
10
11 #include <stdio.h>
12 #include <sys/types.h>
13 #include <netinet/in.h>
14 #include <sys/socket.h>
15 #include <sys/time.h>
16 #ifdef RS6K
17 #include <sys/select.h>
18 #endif /* RS6K */
19 #include <netdb.h>
20 #include <math.h>
21 #include <errno.h>
22 #include "Wlib.h"
23 #include "defs.h"
24 #include "struct.h"
25 #include "data.h"
26 #include "packets.h"
27 #include "gameconf.h"
28 #ifdef SOUND
29 #include "Slib.h"
30 #endif
31 #include "sound.h"
32
33 #if 1
34
35 char *
36 ship_type(shp)
37 struct ship *shp;
38 {
39 static char ring[4][3];
40 static int ri;
41 char *rval;
42 ring[ri][0] = shp->s_desig[0];
43 ring[ri][1] = shp->s_desig[1];
44 ring[ri][2] = 0;
45 rval = ring[ri];
46 ri++;
47 if (ri >= sizeof(ring) / sizeof(*ring))
48 ri = 0;
49 return rval;
50 }
51 #define TEAM_LETTER(p) ( teaminfo[(p).p_teami].letter )
52 #define TEAM_SHORT(p) ( teaminfo[(p).p_teami].shortname )
53 #define TEAM_LETTERP(pl) ( teaminfo[mask_to_idx((pl).pl_owner)].letter )
54 #define TEAM_SHORTP(pl) ( teaminfo[mask_to_idx((pl).pl_owner)].shortname )
55 #define reviewWin messWin[WREVIEW].window
56 #define MAXTORP ntorps
57 #define MAXPLANETS nplanets
58 #define MAXPLASMA nplasmas
59
60 #else
61
62 #define ship_type(shp) shiptype[(shp).s_type]
63 #define TEAM_LETTER(p) ( teamlet[(p).p_team] )
64 #define TEAM_SHORT(p) ( teamshort[(p).p_team] )
65 #define TEAM_LETTERP(pl) ( teamlet[(pl).pl_owner] )
66 #define TEAM_SHORTP(pl) ( teamshort[(pl).pl_owner] )
67
68 #endif
69
70 /* from here on all SHORT_PACKETS */
71 #include "wtext.h" /* here are all warningdefines */
72
73 /* Here are all warnings that are send with SP_S_WARNING */
74 /* HW 93 */
75
76 /* DaemonMessages */
77 char *daemon_texts[] =
78 {
79 /* Game_Paused() */
80 "Game is paused. CONTINUE to continue.", /* 0 */
81 "Game is no-longer paused!",/* 1 */
82 "Game is paused. Captains CONTINUE to continue.", /* 2 */
83 "Game will continue in 10 seconds", /* 3 */
84 /* send_about_to_start() */
85 "Teams chosen. Game will start in 1 minute.", /* 4 */
86 "----------- Game will start in 1 minute -------------", /* 5 */
87 };
88
89 /* VARITEXTE = warnings with 1 or more arguments argument */
90 char *vari_texts[] =
91 {
92 /* redraw.c */
93 "Engineering: Energizing transporters in %d seconds", /* 0 */
94 "Stand By ... Self Destruct in %d seconds", /* 1 */
95 "Helmsman: Docking manuever completed Captain. All moorings secured at port %d.", /* 2 */
96 /* interface.c from INL server */
97 "Not constructed yet. %d minutes required for completion", /* 3 */
98
99 };
100
101
102
103 char *w_texts[] =
104 {
105 /* socket.c */
106 "Tractor beams haven't been invented yet.", /* 0 */
107 "Weapons's Officer: Cannot tractor while cloaked, sir!", /* 1 */
108 "Weapon's Officer: Vessel is out of range of our tractor beam.", /* 2 */
109
110 /* handleRepressReq */
111 /**************** coup.c ***********************/
112 /* coup() */
113 "You must have one kill to throw a coup", /* 3 */
114 "You must orbit your home planet to throw a coup", /* 4 */
115 "You already own a planet!!!", /* 5 */
116 "You must orbit your home planet to throw a coup", /* 6 */
117 "Too many armies on planet to throw a coup", /* 7 */
118 "Planet not yet ready for a coup", /* 8 */
119 /* getentry.c */
120 /* getentry() */
121 "I cannot allow that. Pick another team", /* 9 */
122 "Please confirm change of teams. Select the new team again.", /* 10 */
123 "That is an illegal ship type. Try again.", /* 11 */
124 "That ship hasn't beed designed yet. Try again.", /* 12 */
125 "Your new starbase is still under construction", /* 13 */
126 "Your team is not capable of defending such an expensive ship!", /* 14 */
127 "Your team's stuggling economy cannot support such an expenditure!", /* 15 */
128 "Your side already has a starbase!", /* 16 */
129 /* plasma.c */
130 /* nplasmatorp(course, type) */
131 "Plasmas haven't been invented yet.", /* 17 */
132 "Weapon's Officer: Captain, this ship is not armed with plasma torpedoes!", /* 18 */
133 "Plasma torpedo launch tube has exceeded the maximum safe temperature!", /* 19 */
134 "Our fire control system limits us to 1 live torpedo at a time captain!", /* 20 */
135 "Our fire control system limits us to 1 live torpedo at a time captain!", /* 21 */
136 "We don't have enough fuel to fire a plasma torpedo!", /* 22 */
137 "We cannot fire while our vessel is undergoing repairs.", /* 23 */
138 "We are unable to fire while in cloak, captain!", /* 24 */
139 /******** torp.c *********/
140 /* ntorp(course, type) */
141 "Torpedo launch tubes have exceeded maximum safe temperature!", /* 25 */
142 "Our computers limit us to having 8 live torpedos at a time captain!", /* 26 */
143 "We don't have enough fuel to fire photon torpedos!", /* 27 */
144 "We cannot fire while our vessel is in repair mode.", /* 28 */
145 "We are unable to fire while in cloak, captain!", /* 29 */
146 "We only have forward mounted cannons.", /* 30 */
147 /* phasers.c */
148 /* phaser(course) */
149 "Weapons Officer: This ship is not armed with phasers, captain!", /* 31 */
150 "Phasers have not recharged", /* 32 */
151 "Not enough fuel for phaser", /* 33 */
152 "Can't fire while repairing", /* 34 */
153 "Weapons overheated", /* 35 */
154 "Cannot fire while cloaked",/* 36 */
155 "Phaser missed!!!", /* 37 */
156 "You destroyed the plasma torpedo!", /* 38 */
157 /* interface.c */
158 /* bomb_planet() */
159 "Must be orbiting to bomb", /* 39 */
160 "Can't bomb your own armies. Have you been reading Catch-22 again?", /* 40 */
161 "Must declare war first (no Pearl Harbor syndrome allowed here).", /* 41 */
162 "Bomb out of T-mode? Please verify your order to bomb.", /* 42 */
163 "Hoser!", /* 43 */
164 /* beam_up() */
165 "Must be orbiting or docked to beam up.", /* 44 */
166 "Those aren't our men.", /* 45 */
167 "Comm Officer: We're not authorized to beam foriegn troops on board!", /* 46 */
168 /* beam_down() */
169 "Must be orbiting or docked to beam down.", /* 47 */
170 "Comm Officer: Starbase refuses permission to beam our troops over.", /* 48 */
171 /* declare_war(mask) */
172 "Pausing ten seconds to re-program battle computers.", /* 49 */
173 /* do_refit(type) */
174 "You must orbit your HOME planet to apply for command reassignment!", /* 50 */
175 "You must orbit your home planet to apply for command reassignment!", /* 51 */
176 "Can only refit to starbase on your home planet.", /* 52 */
177 "You must dock YOUR starbase to apply for command reassignment!", /* 53 */
178 "Must orbit home planet or dock your starbase to apply for command reassignment!", /* 54 */
179 "Central Command refuses to accept a ship in this condition!", /* 55 */
180 "You must beam your armies down before moving to your new ship", /* 56 */
181 "That ship hasn't been designed yet.", /* 57 */
182 "Your side already has a starbase!", /* 58 */
183 "Your team is not capable of defending such an expensive ship", /* 59 */
184 "Your new starbase is still under construction", /* 60 */
185 "Your team's stuggling economy cannot support such an expenditure!", /* 61 */
186 "You are being transported to your new vessel .... ", /* 62 */
187 /* redraw.c */
188 /* auto_features() */
189 "Engineering: Energize. [ SFX: chimes ]", /* 63 */
190 "Wait, you forgot your toothbrush!", /* 64 */
191 "Nothing like turning in a used ship for a new one.", /* 65 */
192 "First officer: Oh no, not you again... we're doomed!", /* 66 */
193 "First officer: Uh, I'd better run diagnostics on the escape pods.", /* 67 */
194 "Shipyard controller: This time, *please* be more careful, okay?", /* 68 */
195 "Weapons officer: Not again! This is absurd...", /* 69 */
196 "Weapons officer: ... the whole ship's computer is down?", /* 70 */
197 "Weapons officer: Just to twiddle a few bits of the ship's memory?", /* 71 */
198 "Weapons officer: Bah! [ bangs fist on inoperative console ]", /* 72 */
199 "First Officer: Easy, big guy... it's just one of those mysterious", /* 73 */
200 "First Officer: laws of the universe, like 'tires on the ether'.", /* 74 */
201 "First Officer: laws of the universe, like 'Klingon bitmaps are ugly'.", /* 75 */
202 "First Officer: laws of the universe, like 'all admirals have scummed'.", /* 76 */
203 "First Officer: laws of the universe, like 'Mucus Pig exists'.", /* 77 */
204 "First Officer: laws of the universe, like 'guests advance 5x faster'.", /* 78 */
205 /* orbit.c */
206 /*orbit() */
207 "Helmsman: Captain, the maximum safe speed for docking or orbiting is warp 2!", /* 79 */
208 "Central Command regulations prohibits you from orbiting foreign planets", /* 80 */
209 "Helmsman: Sensors read no valid targets in range to dock or orbit sir!", /* 81 */
210 /* redraw.c */
211 "No more room on board for armies", /* 82 */
212 "You notice everyone on the bridge is staring at you.", /* 83 */
213 /* startdaemon.c */
214 /* practice_robo() */
215 "Can't send in practice robot with other players in the game.", /* 84 */
216 /* socket.c */
217 /* doRead(asock) */
218 "Self Destruct has been canceled", /* 85 */
219 /* handleMessageReq(packet) */
220 "Be quiet", /* 86 */
221 "You are censured. Message was not sent.", /* 87 */
222 "You are ignoring that player. Message was not sent.", /* 88 */
223 "That player is censured. Message was not sent.", /* 89 */
224 /* handleQuitReq(packet) */
225 "Self destruct initiated", /* 90 */
226 /* handleScan(packet) */
227 "Scanners haven't been invented yet", /* 91 */
228 /* handleUdpReq(packet) */
229 "WARNING: BROKEN mode is enabled", /* 92 */
230 "Server can't do that UDP mode", /* 93 */
231 "Server will send with TCP only", /* 94 */
232 "Server will send with simple UDP", /* 95 */
233 "Request for fat UDP DENIED (set to simple)", /* 96 */
234 "Request for double UDP DENIED (set to simple)", /* 97 */
235 /* forceUpdate() */
236 "Update request DENIED (chill out!)", /* 98 */
237 /* INL redraw.c */
238 "Player lock lost while player dead.", /* 99 */
239 "Can only lock on own team.", /* 100 */
240 "You can only warp to your own team's planets!", /* 101 */
241 "Planet lock lost on change of ownership.", /* 102 */
242 " Weapons officer: Finally! systems are back online!", /* 103 */
243
244 };
245
246 #define NUMWTEXTS (sizeof w_texts / sizeof w_texts[0])
247 #define NUMVARITEXTS ( sizeof vari_texts / sizeof vari_texts[0])
248 #define NUMDAEMONTEXTS ( sizeof daemon_texts / sizeof daemon_texts[0])
249
250
251 void add_whydead();
252
253 extern int vtisize[];
254 extern unsigned char numofbits[];
255 #if 0
256 int Plx[MAX_PLAYER], Ply[MAX_PLAYER], Pgx[MAX_PLAYER], Pgy[MAX_PLAYER];
257 unsigned char Pdir[MAX_PLAYER];
258 #endif
259 int my_x, my_y; /* for rotation we need to keep track of our
260 real coordinates */
261 /* SP_S_WARNING vari texte */
262 char *s_texte[256]; /* Better with a malloc scheme */
263 char no_memory[] =
264 {"Not enough memory for warning string!"};
265
266 #if 0
267 /* For INL Server */
268 char *shiptype[NUM_TYPES] =
269 {"SC", "DD", "CA", "BB", "AS", "SB", "??"};
270 #endif
271 int spwinside = 500; /* WINSIDE from Server */
272 long spgwidth = 100000;
273
274
275 void
276 sendThreshold(v)
277 unsigned short v;
278 {
279 struct threshold_cpacket p;
280
281 p.type = CP_S_THRS;
282 p.thresh = v;
283 sendServerPacket((struct player_spacket *) & p);
284 }
285
286 void
287 handleVTorp(sbuf)
288 unsigned char *sbuf;
289 {
290 unsigned char *which, *data;
291 unsigned char bitset;
292 struct torp *thetorp;
293 int dx, dy;
294 int shiftvar;
295
296 int i;
297 register int shift = 0; /* How many torps are extracted (for shifting
298 ) */
299
300 /* now we must find the data ... :-) */
301 if (sbuf[0] == SP_S_8_TORP) { /* MAX packet */
302 bitset = 0xff;
303 which = &sbuf[1];
304 data = &sbuf[2];
305 } else { /* Normal Packet */
306 bitset = sbuf[1];
307 which = &sbuf[2];
308 data = &sbuf[3];
309 }
310
311 #ifdef CORRUPTED_PACKETS
312 /* we probably should do something clever here - jmn */
313 #endif
314
315 thetorp = &torps[((unsigned char) *which * 8)];
316 for (shift = 0, i = 0; i < 8;
317 #if defined(RS6K) || defined(__SABER__)
318 i++, thetorp++, bitset >>= 1) {
319 #else
320 i++, thetorp++, bitset = ((unsigned char)bitset) >> 1) {
321 #endif
322 if (bitset & 01) {
323 dx = (*data >> shift);
324 data++;
325 shiftvar = (unsigned char) *data; /* to silence gcc */
326 shiftvar <<= (8 - shift);
327 dx |= (shiftvar & 511);
328 shift++;
329 dy = (*data >> shift);
330 data++;
331 shiftvar = (unsigned char) *data; /* to silence gcc */
332 shiftvar <<= (8 - shift);
333 dy |= (shiftvar & 511);
334 shift++;
335 if (shift == 8) {
336 shift = 0;
337 data++;
338 }
339 /* This is necessary because TFREE/TMOVE is now encoded in the bitset */
340 if (thetorp->t_status == TFREE) {
341 thetorp->t_status = TMOVE; /* guess */
342 players[thetorp->t_owner].p_ntorp++;
343 #ifdef UNIX_SOUND
344 play_sound (SND_FIRETORP); /* Fire Torp */
345 #endif
346 } else if (thetorp->t_owner == me->p_no && thetorp->t_status == TEXPLODE) {
347 thetorp->t_status = TMOVE; /* guess */
348 }
349 /* Check if torp is visible */
350 if (dx > spwinside || dy > spwinside) {
351 thetorp->t_x = -100000; /* Not visible */
352 thetorp->t_y = -100000;
353 } else { /* visible */
354 /* thetorp->t_x = me->p_x + ((dx - spwinside / 2) * SCALE);
355 thetorp->t_y = me->p_y + ((dy - spwinside / 2) * SCALE); */
356 thetorp->t_x = my_x + ((dx - spwinside / 2) * SCALE);
357 thetorp->t_y = my_y + ((dy - spwinside / 2) * SCALE);
358 #ifdef ROTATERACE
359 if (rotate) {
360 rotate_coord(&thetorp->t_x, &thetorp->t_y, rotate_deg,
361 spgwidth / 2, spgwidth / 2);
362 }
363 #endif
364 }
365 }
366 /* if */
367 else { /* We got a TFREE */
368 if (thetorp->t_status && thetorp->t_status != TEXPLODE) {
369 players[thetorp->t_owner].p_ntorp--;
370 thetorp->t_status = TFREE; /* That's no guess */
371 }
372 }
373 } /* for */
374 }
375
376 void
377 handleSelfShort(packet)
378 struct youshort_spacket *packet;
379 {
380 me = (ghoststart ? &players[ghost_pno] : &players[packet->pnum]);
381 myship = me->p_ship;
382 mystats = &(me->p_stats);
383 me->p_hostile = packet->hostile;
384 me->p_swar = packet->swar;
385 me->p_armies = packet->armies;
386 me->p_flags = ntohl(packet->flags);
387 me->p_whydead = packet->whydead;
388 me->p_whodead = packet->whodead;
389 #ifdef SOUND
390 S_HandlePFlags();
391 #endif
392 }
393
394 void
395 handleSelfShip(packet)
396 struct youss_spacket *packet;
397 {
398 if (!me)
399 return; /* wait.. */
400
401 me->p_damage = ntohs(packet->damage);
402 me->p_shield = ntohs(packet->shield);
403 me->p_fuel = ntohs(packet->fuel);
404 me->p_etemp = ntohs(packet->etemp);
405 me->p_wtemp = ntohs(packet->wtemp);
406 #ifdef SOUND
407 S_HandlePFlags();
408 #endif
409 }
410
411 void
412 handleVPlayer(sbuf)
413 unsigned char *sbuf;
414 {
415 register int x, y, i, numofplayers, pl_no, save;
416 register struct player *pl;
417 unsigned char newdir; /* needed for uncloak kludge with ROTATERACE */
418 int offset;
419
420 numofplayers = (unsigned char) sbuf[1] & 0x3f;
421
422 if (sbuf[1] & (unsigned char) 128) { /* Short Header + Extended */
423 sbuf += 4;
424 offset = 32; /* more than 32 players? */
425 } else if (sbuf[1] & 64) { /* Short Header */
426 sbuf += 4;
427 offset = 0;
428 } else {
429 struct player_s_spacket *packet = (struct player_s_spacket *) sbuf;
430 pl = &players[me->p_no];
431 pl->p_dir = (unsigned char) packet->dir;
432 #if 0
433 Pdir[me->p_no] = (unsigned char) rosette(pl->p_dir, 16);
434 #endif
435 pl->p_speed = packet->speed;
436 #ifdef FEATURE
437 if (F_dead_warp && (pl->p_speed == 14)) {
438 if (pl->p_status == PALIVE) {
439 pl->p_status = PEXPLODE;
440 pl->p_explode = 0;
441 }
442 } else
443 #endif
444 {
445 pl->p_x = my_x = ntohl(packet->x);
446 pl->p_y = my_y = ntohl(packet->y);
447 #ifdef ROTATERACE
448 if (rotate) {
449 rotate_coord(&pl->p_x, &pl->p_y,
450 rotate_deg, spgwidth / 2, spgwidth / 2);
451 rotate_dir(&pl->p_dir, rotate_deg);
452 }
453 #endif
454 #if 0
455 Plx[me->p_no] = WINSIDE / 2;
456 Ply[me->p_no] = WINSIDE / 2;
457 Pgx[me->p_no] = pl->p_x * WINSIDE / spgwidth;
458 Pgy[me->p_no] = pl->p_y * WINSIDE / spgwidth;
459 #endif
460 }
461 redrawPlayer[me->p_no] = 1;
462 sbuf += 12; /* Now the small packets */
463 offset = 0;
464 }
465 for (i = 0; i < numofplayers; i++) {
466 pl_no = ((unsigned char) *sbuf & 0x1f) + offset;
467 if (pl_no >= nplayers)
468 continue;
469 save = (unsigned char) *sbuf;
470 sbuf++;
471 pl = &players[pl_no];
472 pl->p_speed = (unsigned char) *sbuf & 15; /* SPEED */
473 #if 0
474 Pdir[pl_no] = (unsigned char) *sbuf >> 4; /* DIR */
475 #endif
476 newdir = (unsigned char) *sbuf & 0xf0; /* realDIR */
477
478 #ifdef ROTATERACE
479 if (rotate)
480 rotate_dir(&newdir, rotate_deg);
481 #endif
482 #ifdef FEATURE
483 if (cloakerMaxWarp) {
484 if (pl->p_speed == 15)
485 pl->p_flags |= PFCLOAK;
486 else
487 pl->p_flags &= ~(PFCLOAK);
488 } else
489 #endif
490 {
491 #ifdef CHECK_DROPPED
492 /*
493 this is a mess. Too many exceptions. I don't use it any
494 more. cloakerMaxWarp is much much better, but requires server
495 support.
496 */
497 /*
498 Kludge to fix lost uncloak packets! [3/94] -JR may be a
499 problem with server sending directions after cloakphase is at
500 CLOAK_PHASES-1, since cloakphase is strictly a client variable
501 :(
502 */
503 if (pl->p_flags & PFCLOAK && pl->p_cloakphase >= (CLOAK_PHASES - 1) &&
504 (pl->p_dir & 0xf0 != newdir & 0xf0) && !(pl->p_flags & PFORBIT)) {
505 int i, plocked = 0;
506 for (i = 0; i < nplayers; i++) {
507 if ((phasers[i].ph_status & PHHIT) && (phasers[i].ph_target == pl_no)) {
508 plocked = 1;
509 break;
510 }
511 }
512 if (!plocked)
513 /*
514 if all of the above, the guy is *probably* uncloaked.
515 Ask the server.
516 */
517 sendShortReq(SPK_SALL);
518 }
519 #endif
520 }
521 pl->p_dir = newdir; /* realDIR */
522
523 sbuf++;
524 x = (unsigned char) *sbuf++;
525 y = (unsigned char) *sbuf++; /* The lower 8 Bits are saved */
526
527 /* Now we must preprocess the coordinates */
528 if ((unsigned char) save & 64)
529 x |= 256;
530 if ((unsigned char) save & 128)
531 y |= 256;
532 #ifdef FEATURE
533 /*
534 MAY CHANGE! dead_warp is still an experiment, some servers are
535 also sending illegal co-ords for dead players, so we'll just
536 ignore 'em for now if the guy's dead.
537 */
538 if (F_dead_warp && pl->p_speed == 14) {
539 if (pl->p_status == PALIVE) {
540 pl->p_status = PEXPLODE;
541 pl->p_explode = 0;
542 }
543 redrawPlayer[pl->p_no] = 1;
544 continue;
545 }
546 #endif
547 /* Now test if it's galactic or local coord */
548 if (save & 32) { /* It's galactic */
549 #if 0
550 if (x >= 501 || y >= 501) {
551 pl->p_x = -500 * spgwidth / spwinside;
552 pl->p_y = -500 * spgwidth / spwinside;
553 } else
554 #endif
555 {
556 pl->p_x = x * spgwidth / spwinside;
557 pl->p_y = y * spgwidth / spwinside;
558 }
559 #if 0
560 Pgx[pl_no] = x;
561 Pgy[pl_no] = y;
562 Plx[pl_no] = -1; /* Not visible */
563 Ply[pl_no] = -1;
564 #endif
565 } else { /* Local */
566 pl->p_x = my_x + ((x - spwinside / 2) * SCALE);
567 pl->p_y = my_y + ((y - spwinside / 2) * SCALE);
568 #if 0
569 Plx[pl_no] = x;
570 Ply[pl_no] = y;
571 Pgx[pl_no] = pl->p_x * spwinside / spgwidth;
572 Pgy[pl_no] = pl->p_y * spwinside / spgwidth;
573 #endif
574 }
575 redrawPlayer[pl->p_no] = 1;
576 #ifdef ROTATERACE
577 if (rotate) {
578 rotate_coord(&pl->p_x, &pl->p_y,
579 rotate_deg, spgwidth / 2, spgwidth / 2);
580 }
581 #endif
582 } /* for */
583 }
584
585 void
586 handleSMessage(packet)
587 struct mesg_s_spacket *packet;
588 {
589 char buf[100];
590 char addrbuf[9];
591
592 #if 0
593 if (debug)
594 printf("Length of Message is: %d total Size %d \n", strlen(&packet->mesg), (int) packet->length);
595 #endif
596 if (packet->m_from >= nplayers)
597 packet->m_from = 255;
598
599 if (packet->m_from == 255)
600 strcpy(addrbuf, "GOD->");
601 else {
602 sprintf(addrbuf, " %c%c->", TEAM_LETTER(players[packet->m_from]),
603 shipnos[players[packet->m_from].p_no]);
604 }
605
606 switch (packet->m_flags & (MTEAM | MINDIV | MALL)) {
607 case MALL:
608 sprintf(addrbuf + 5, "ALL");
609 break;
610 case MTEAM:
611 sprintf(addrbuf + 5, TEAM_SHORT(*me));
612 break;
613 case MINDIV:
614 /* I know that it's me -> xxx but i copied it straight ... */
615 sprintf(addrbuf + 5, "%c%c ", TEAM_LETTER(players[packet->m_recpt]),
616 shipnos[packet->m_recpt]);
617 break;
618 default:
619 sprintf(addrbuf + 5, "ALL");
620 break;
621 }
622 sprintf(buf, "%-9s%s", addrbuf, &packet->mesg);
623 dmessage(buf, packet->m_flags, packet->m_from, packet->m_recpt);
624 }
625
626 void
627 handleShortReply(packet)
628 struct shortreply_spacket *packet;
629 {
630 switch (packet->repl) {
631 case SPK_VOFF:
632 recv_short = 0;
633 sprefresh(SPK_VFIELD);
634 break;
635 case SPK_VON:
636 recv_short = 1;
637 sprefresh(SPK_VFIELD);
638
639 spwinside = (CARD16) ntohs(packet->winside);
640 /*
641 bug in server-side SP code, wrong-endian machines confuse a client
642 with normal byte order
643 */
644 if (spwinside == 0xf401)
645 spwinside = 0x01f4;
646
647 if (paradise) {
648 spgwidth = (INT32) ntohl(packet->gwidth);
649 blk_gwidth = spgwidth;
650 blk_windgwidth = (float)spwinside;
651 redrawall = 1;
652
653 /*
654 bug in server-side SP code, wrong-endian machines confuse a
655 client with normal byte order
656 */
657 if (spgwidth == 0xa0860100)
658 spgwidth = 0x000186a0;
659 if (spgwidth == 0x0100)
660 spgwidth = 0x000186a0;
661 }
662 break;
663 case SPK_MOFF:
664 recv_mesg = 0;
665 sprefresh(SPK_MFIELD);
666 W_SetSensitive(reviewWin, 0);
667 break;
668 case SPK_MON:
669 recv_mesg = 1;
670 sprefresh(SPK_MFIELD);
671 W_SetSensitive(reviewWin, 1);
672 break;
673 case SPK_M_KILLS:
674 recv_kmesg = 1;
675 sprefresh(SPK_KFIELD);
676 break;
677 case SPK_M_NOKILLS:
678 recv_kmesg = 0;
679 sprefresh(SPK_KFIELD);
680 break;
681 case SPK_M_WARN:
682 recv_warn = 1;
683 sprefresh(SPK_WFIELD);
684 break;
685 case SPK_M_NOWARN:
686 recv_warn = 0;
687 sprefresh(SPK_WFIELD);
688 break;
689
690 case SPK_THRESHOLD:
691 break;
692 default:
693 fprintf(stderr, "%s: unknown response packet value short-req: %d\n",
694 "netrek", packet->repl);
695 }
696 }
697
698 void
699 handleVTorpInfo(sbuf)
700 unsigned char *sbuf;
701 {
702 unsigned char *bitset, *which, *data, *infobitset, *infodata;
703 struct torp *thetorp;
704 int dx, dy;
705 int shiftvar;
706 char status, war;
707 register int i;
708 register int shift = 0; /* How many torps are extracted (for shifting
709 ) */
710
711 /* now we must find the data ... :-) */
712 bitset = &sbuf[1];
713 which = &sbuf[2];
714 infobitset = &sbuf[3];
715 /* Where is the data ? */
716 data = &sbuf[4];
717 infodata = &sbuf[vtisize[numofbits[(unsigned char) sbuf[1]]]];
718
719 thetorp = &torps[(unsigned char) (*which * 8)];
720
721 for (shift = 0, i = 0; i < 8;
722 #if defined(RS6K) || defined(__SABER__)
723 thetorp++, *bitset >>= 1, *infobitset >>= 1, i++) {
724 #else
725 thetorp++, *bitset = ((unsigned char)*bitset) >> 1, *infobitset = ((unsigned char) *infobitset) >> 1, i++) {
726 #endif
727
728 if (*bitset & 01) {
729 dx = (*data >> shift);
730 data++;
731 shiftvar = (unsigned char) *data; /* to silence gcc */
732 shiftvar <<= (8 - shift);
733 dx |= (shiftvar & 511);
734 shift++;
735 dy = (*data >> shift);
736 data++;
737 shiftvar = (unsigned char) *data; /* to silence gcc */
738 shiftvar <<= (8 - shift);
739 dy |= (shiftvar & 511);
740 shift++;
741 if (shift == 8) {
742 shift = 0;
743 data++;
744 }
745 /* Check for torp with no TorpInfo */
746 if (!(*infobitset & 01)) {
747 if (thetorp->t_status == TFREE) {
748 thetorp->t_status = TMOVE; /* guess */
749 players[thetorp->t_owner].p_ntorp++;
750 } else if (thetorp->t_owner == me->p_no &&
751 thetorp->t_status == TEXPLODE) { /* If TFREE got lost */
752 thetorp->t_status = TMOVE; /* guess */
753 }
754 }
755 /* Check if torp is visible */
756 if (dx > spwinside || dy > spwinside) {
757 thetorp->t_x = -100000; /* Not visible */
758 thetorp->t_y = -100000;
759 } else { /* visible */
760 /* thetorp->t_x = me->p_x + ((dx - spwinside / 2) * SCALE);
761 thetorp->t_y = me->p_y + ((dy - spwinside / 2) * SCALE);
762 */
763 thetorp->t_x = my_x + ((dx - spwinside / 2) *
764 SCALE);
765 thetorp->t_y = my_y + ((dy - spwinside / 2) *
766 SCALE);
767
768 #ifdef ROTATERACE
769 if (rotate) {
770 rotate_coord(&thetorp->t_x, &thetorp->t_y, rotate_deg,
771 spgwidth / 2, spgwidth / 2);
772 }
773 #endif
774 }
775 }
776 /* if */
777 else { /* Got a TFREE ? */
778 if (!(*infobitset & 01)) { /* No other TorpInfo for this Torp */
779 if (thetorp->t_status && thetorp->t_status != TEXPLODE) {
780 players[thetorp->t_owner].p_ntorp--;
781 thetorp->t_status = TFREE; /* That's no guess */
782 }
783 }
784 }
785 /* Now the TorpInfo */
786 if (*infobitset & 01) {
787 war = (unsigned char) *infodata & 15 /* 0x0f */ ;
788 status = ((unsigned char) *infodata & 0xf0) >> 4;
789 infodata++;
790 if (status == TEXPLODE && thetorp->t_status == TFREE) {
791 /* FAT: redundant explosion; don't update p_ntorp */
792 continue;
793 }
794 if (thetorp->t_status == TFREE && status) {
795 players[thetorp->t_owner].p_ntorp++;
796 #ifdef UNIX_SOUND
797 play_sound (SND_FIRETORP); /* Fire Torp */
798 #endif
799 }
800 if (thetorp->t_status && status == TFREE) {
801 players[thetorp->t_owner].p_ntorp--;
802 }
803 thetorp->t_war = war;
804 if (status != thetorp->t_status) {
805 /* FAT: prevent explosion reset */
806 thetorp->t_status = status;
807 if (thetorp->t_status == TEXPLODE) {
808 thetorp->t_fuse = NUMDETFRAMES;
809 }
810 }
811 } /* if */
812 } /* for */
813 }
814
815 void
816 handleVPlanet(sbuf)
817 unsigned char *sbuf;
818 {
819 register int i;
820 register int numofplanets; /* How many Planets are in the packet */
821 struct planet *plan;
822 struct planet_s_spacket *packet = (struct planet_s_spacket *) & sbuf[2];
823 /* FAT: prevent excessive redraw */
824 int redraw = 0;
825
826 numofplanets = (unsigned char) sbuf[1];
827
828 if (numofplanets > MAXPLANETS + 1)
829 return;
830
831 for (i = 0; i < numofplanets; i++, packet++) {
832 if (packet->pnum < 0 || packet->pnum >= MAXPLANETS)
833 continue;
834
835 plan = &planets[packet->pnum];
836 if (plan->pl_owner != packet->owner)
837 redraw = 1;
838 plan->pl_owner = packet->owner;
839
840 if (plan->pl_info != packet->info)
841 redraw = 1;
842
843 plan->pl_info = packet->info;
844 /* Redraw the planet because it was updated by server */
845
846 if (plan->pl_flags != (int) ntohs(packet->flags))
847 redraw = 1;
848 plan->pl_flags = (int) ntohs(packet->flags);
849
850 if (plan->pl_armies != (unsigned char) packet->armies) {
851 /*#ifdef EM*/
852 /*
853 don't redraw when armies change unless it crosses the '4' *
854 army limit. Keeps people from watching for planet 'flicker' *
855 when players are beaming
856 */
857 int planetarmies = (unsigned char) packet->armies;
858 if ((plan->pl_armies < 5 && planetarmies > 4) ||
859 (plan->pl_armies > 4 && planetarmies < 5))
860 /*#endif*/
861 redraw = 1;
862 }
863
864 plan->pl_armies = (unsigned char) packet->armies;
865 if (plan->pl_info == 0) {
866 plan->pl_owner = NOBODY;
867 }
868
869 if (redraw) {
870 plan->pl_flags |= PLREDRAW;
871 pl_update[packet->pnum].plu_update = 1;
872 pl_update[packet->pnum].plu_x = plan->pl_x;
873 pl_update[packet->pnum].plu_y = plan->pl_y;
874
875 }
876 } /* FOR */
877 }
878
879 void
880 sendShortReq(state)
881 char state;
882 {
883 struct shortreq_cpacket shortReq;
884
885 shortReq.type = CP_S_REQ;
886 shortReq.req = state;
887 shortReq.version = SHORTVERSION;
888 switch (state) {
889 case SPK_VON:
890 warning("Sending short packet request");
891 break;
892 case SPK_VOFF:
893 warning("Sending old packet request");
894 break;
895 default:
896 break;
897 }
898 if ((state == SPK_SALL || state == SPK_ALL) && recv_short) {
899 /* Let the client do the work, and not the network :-) */
900
901 register int i;
902 for (i = 0; i < nplayers * MAXTORP; i++)
903 torps[i].t_status = TFREE;
904
905 for (i = 0; i < nplayers * MAXPLASMA; i++)
906 plasmatorps[i].pt_status = PTFREE;
907
908 for (i = 0; i < nplayers; i++) {
909 players[i].p_ntorp = 0;
910 players[i].p_nplasmatorp = 0;
911 phasers[i].ph_status = PHFREE;
912 }
913 if (state == SPK_SALL)
914 warning("Sent request for small update (weapons+planets+kills)");
915 else if (state == SPK_ALL)
916 warning("Sent request for medium update (all except stats)");
917 else
918 warning("Sent some unknown request...");
919 }
920 sendServerPacket((struct shortreq_cpacket *) & shortReq);
921 }
922
923 char *whydeadmess[] =
924 {"", "[quit]", "[photon]", "[phaser]", "[planet]", "[explosion]",
925 "", "", "[ghostbust]", "[genocide]", "", "[plasma]", "[detted photon]", "[chain explosion]",
926 "[TEAM]", "", "[team det]", "[team explosion]"};
927
928
929 void
930 handleSWarning(packet)
931 struct warning_s_spacket *packet;
932 {
933 char buf[80];
934 register struct player *target;
935 register int damage;
936 static int arg3, arg4; /* Here are the arguments for warnings with
937 more than 2 arguments */
938 static int karg3, karg4, karg5 = 0;
939 char killmess[20];
940
941 switch (packet->whichmessage) {
942 case TEXTE: /* damage used as tmp var */
943 damage = (unsigned char) packet->argument;
944 damage |= (unsigned char) packet->argument2 << 8;
945 if (damage >= 0 && damage < NUMWTEXTS)
946 warning(w_texts[damage]);
947 break;
948 case PHASER_HIT_TEXT:
949 target = &players[(unsigned char) packet->argument & 0x3f];
950 damage = (unsigned char) packet->argument2;
951 if ((unsigned char) packet->argument & 64)
952 damage |= 256;
953 if ((unsigned char) packet->argument & 128)
954 damage |= 512;
955 (void) sprintf(buf, "Phaser burst hit %s for %d points", target->p_name, damage);
956 warning(buf);
957 break;
958 case BOMB_INEFFECTIVE:
959 sprintf(buf, "Weapons Officer: Bombing is ineffective. Only %d armies are defending.",
960 (int) packet->argument); /* nifty info feature 2/14/92
961 TMC */
962 warning(buf);
963 break;
964 case BOMB_TEXT:
965 sprintf(buf, "Weapons Officer: Bombarding %s... Sensors read %d armies left.",
966 planets[(unsigned char) packet->argument].pl_name,
967 (unsigned char) packet->argument2);
968 warning(buf);
969 break;
970 case BEAMUP_TEXT:
971 sprintf(buf, "%s: Too few armies to beam up",
972 planets[(unsigned char) packet->argument].pl_name);
973 warning(buf);
974 break;
975 case BEAMUP2_TEXT:
976 sprintf(buf, "Beaming up. (%d/%d)", (unsigned char) packet->argument, (unsigned char) packet->argument2);
977 warning(buf);
978 break;
979 case BEAMUPSTARBASE_TEXT:
980 sprintf(buf, "Starbase %s: Too few armies to beam up",
981 players[packet->argument].p_name);
982 warning(buf);
983 break;
984 case BEAMDOWNSTARBASE_TEXT:
985 sprintf(buf, "No more armies to beam down to Starbase %s.",
986 players[packet->argument].p_name);
987 warning(buf);
988
989 break;
990 case BEAMDOWNPLANET_TEXT:
991 sprintf(buf, "No more armies to beam down to %s.",
992 planets[(unsigned char) packet->argument].pl_name);
993 warning(buf);
994 break;
995 case SBREPORT:
996 sprintf(buf, "Transporter Room: Starbase %s reports all troop bunkers are full!",
997 players[packet->argument].p_name);
998 warning(buf);
999 break;
1000 case ONEARG_TEXT:
1001 if (packet->argument >= 0 && packet->argument < NUMVARITEXTS) {
1002 sprintf(buf, vari_texts[packet->argument], (unsigned char) packet->argument2);
1003 warning(buf);
1004 }
1005 break;
1006 case BEAM_D_PLANET_TEXT:
1007 sprintf(buf, "Beaming down. (%d/%d) %s has %d armies left",
1008 arg3,
1009 arg4,
1010 planets[(unsigned char) packet->argument].pl_name,
1011 packet->argument2);
1012 warning(buf);
1013 break;
1014 case ARGUMENTS:
1015 arg3 = (unsigned char) packet->argument;
1016 arg4 = (unsigned char) packet->argument2;
1017 break;
1018 case BEAM_U_TEXT:
1019 sprintf(buf, "Transfering ground units. (%d/%d) Starbase %s has %d armies left",
1020 (unsigned char) arg3, (unsigned char) arg4, players[packet->argument].p_name, (unsigned char) packet->argument2);
1021 warning(buf);
1022 break;
1023 case LOCKPLANET_TEXT:
1024 sprintf(buf, "Locking onto %s", planets[(unsigned char) packet->argument].pl_name);
1025 warning(buf);
1026 break;
1027 case SBRANK_TEXT:
1028 sprintf(buf, "You need a rank of %s or higher to command a starbase!", ranks[packet->argument].name);
1029 warning(buf);
1030 break;
1031 case SBDOCKREFUSE_TEXT:
1032 sprintf(buf, "Starbase %s refusing us docking permission captain.",
1033 players[packet->argument].p_name);
1034 warning(buf);
1035 break;
1036 case SBDOCKDENIED_TEXT:
1037 sprintf(buf, "Starbase %s: Permission to dock denied, all ports currently occupied.", players[packet->argument].p_name);
1038 warning(buf);
1039 break;
1040 case SBLOCKSTRANGER:
1041 sprintf(buf, "Locking onto %s (%c%c)",
1042 players[packet->argument].p_name,
1043 TEAM_LETTER(players[packet->argument]),
1044 shipnos[players[packet->argument].p_no]);
1045 warning(buf);
1046 break;
1047 case SBLOCKMYTEAM:
1048 sprintf(buf, "Locking onto %s (%c%c) (docking is %s)",
1049 players[packet->argument].p_name,
1050 TEAM_LETTER(players[packet->argument]),
1051 shipnos[players[packet->argument].p_no],
1052 (players[packet->argument].p_flags & PFDOCKOK) ? "enabled" : "disabled");
1053 warning(buf);
1054 break;
1055 case DMKILL:
1056 {
1057 struct mesg_spacket msg;
1058 int killer, victim, armies;
1059 float kills;
1060 victim = (unsigned char) packet->argument & 0x3f;
1061 killer = (unsigned char) packet->argument2 & 0x3f;
1062 /* that's only a temp */
1063 damage = (unsigned char) karg3;
1064 damage |= (karg4 & 127) << 8;
1065 kills = damage / 100.0;
1066 if (kills == 0.0)
1067 strcpy(killmess, "NO CREDIT");
1068 else
1069 sprintf(killmess, "%0.2f", kills);
1070 armies = (((unsigned char) packet->argument >> 6) | ((unsigned char) packet->argument2 & 192) >> 4);
1071 if (karg4 & 128)
1072 armies |= 16;
1073 if (armies == 0) {
1074 (void) sprintf(msg.mesg, "%s%s (%c%c) [%c%c] was kill %s for %s (%c%c) [%c%c]",
1075 (godToAllOnKills ? "GOD->ALL " : ""),
1076 players[victim].p_name,
1077 TEAM_LETTER(players[victim]),
1078 shipnos[victim],
1079 players[victim].p_ship->s_desig[0],
1080 players[victim].p_ship->s_desig[1],
1081 killmess,
1082 players[killer].p_name,
1083 TEAM_LETTER(players[killer]),
1084 shipnos[killer],
1085 players[killer].p_ship->s_desig[0],
1086 players[killer].p_ship->s_desig[1]);
1087 msg.m_flags = MALL | MVALID | MKILL;
1088 } else {
1089 #ifdef SOUND /* was feeling a little silly :-) */
1090 if (killer == me->p_no || alwaysSoundDoosh)
1091 S_PlaySound(S_DOOSH);
1092 #endif
1093 (void) sprintf(msg.mesg, "%s%s (%c%c+%d armies) [%c%c]: kill %s for %s (%c%c) [%c%c]",
1094 (godToAllOnKills ? "GOD->ALL " : ""),
1095 players[victim].p_name,
1096 TEAM_LETTER(players[victim]),
1097 shipnos[victim],
1098 armies,
1099 players[victim].p_ship->s_desig[0],
1100 players[victim].p_ship->s_desig[1],
1101 killmess,
1102 players[killer].p_name,
1103 TEAM_LETTER(players[killer]),
1104 shipnos[killer],
1105 players[killer].p_ship->s_desig[0],
1106 players[killer].p_ship->s_desig[1]);
1107 msg.m_flags = MALL | MVALID | MKILLA;
1108 }
1109 if (why_dead) {
1110 add_whydead(msg.mesg, karg5);
1111 karg5 = 0;
1112 }
1113 msg.type = SP_MESSAGE;
1114 msg.mesg[79] = '\0';
1115 msg.m_recpt = 0;
1116 msg.m_from = 255;
1117 handleMessage(&msg);
1118 }
1119 break;
1120 case KILLARGS:
1121 karg3 = (unsigned char) packet->argument;
1122 karg4 = (unsigned char) packet->argument2;
1123 break;
1124 case KILLARGS2:
1125 karg5 = (unsigned char) packet->argument;
1126 break;
1127 case DMKILLP:
1128 {
1129 struct mesg_spacket msg;
1130 (void) sprintf(msg.mesg, "%s%s (%c%c) [%c%c] killed by %s (%c)",
1131 (godToAllOnKills ? "GOD->ALL " : ""),
1132 players[packet->argument].p_name,
1133 TEAM_LETTER(players[packet->argument]),
1134 shipnos[packet->argument],
1135 players[packet->argument].p_ship->s_desig[0],
1136 players[packet->argument].p_ship->s_desig[1],
1137 planets[(unsigned char) packet->argument2].pl_name,
1138 TEAM_LETTERP(planets[(unsigned char) packet->argument2]));
1139 if (why_dead) {
1140 add_whydead(msg.mesg, karg5);
1141 karg5 = 0;
1142 }
1143 msg.type = SP_MESSAGE;
1144 msg.mesg[79] = '\0';
1145 msg.m_flags = MALL | MVALID | MKILLP;
1146 msg.m_recpt = 0;
1147 msg.m_from = 255;
1148 handleMessage(&msg);
1149 }
1150 break;
1151 case DMBOMB:
1152 {
1153 struct mesg_spacket msg;
1154 char buf1[80];
1155 (void) sprintf(buf, "%-3s->%-3s", planets[(unsigned char) packet->argument2].pl_name, TEAM_SHORTP(planets[(unsigned char) packet->argument2]));
1156 (void) sprintf(buf1, "We are being attacked by %s %c%c who is %d%% damaged.",
1157 players[packet->argument].p_name,
1158 TEAM_LETTER(players[packet->argument]),
1159 shipnos[packet->argument],
1160 arg3);
1161 (void) sprintf(msg.mesg, "%s %s", buf, buf1);
1162 msg.type = SP_MESSAGE;
1163 msg.mesg[79] = '\0';
1164 msg.m_flags = MTEAM | MBOMB | MVALID;
1165 msg.m_recpt = planets[(unsigned char) packet->argument2].pl_owner;
1166 msg.m_from = 255;
1167 handleMessage(&msg);
1168 }
1169 break;
1170 case DMDEST:
1171 {
1172 struct mesg_spacket msg;
1173 char buf1[80];
1174 (void) sprintf(buf, "%s destroyed by %s (%c%c)",
1175 planets[(unsigned char) packet->argument].pl_name,
1176 players[packet->argument2].p_name,
1177 TEAM_LETTER(players[packet->argument2]),
1178 shipnos[(unsigned char) packet->argument2]);
1179 (void) sprintf(buf1, "%-3s->%-3s",
1180 planets[(unsigned char) packet->argument].pl_name, TEAM_SHORTP(planets[(unsigned char) packet->argument]));
1181 (void) sprintf(msg.mesg, "%s %s", buf1, buf);
1182 msg.type = SP_MESSAGE;
1183 msg.mesg[79] = '\0';
1184 msg.m_flags = MTEAM | MDEST | MVALID;
1185 msg.m_recpt = planets[(unsigned char) packet->argument].pl_owner;
1186 msg.m_from = 255;
1187 handleMessage(&msg);
1188 }
1189 break;
1190 case DMTAKE:
1191 {
1192 struct mesg_spacket msg;
1193 char buf1[80];
1194 (void) sprintf(buf, "%s taken over by %s (%c%c)",
1195 planets[(unsigned char) packet->argument].pl_name,
1196 players[packet->argument2].p_name,
1197 TEAM_LETTER(players[packet->argument2]),
1198 shipnos[packet->argument2]);
1199 (void) sprintf(buf1, "%-3s->%-3s",
1200 planets[(unsigned char) packet->argument].pl_name, TEAM_SHORT(players[packet->argument2]));
1201 (void) sprintf(msg.mesg, "%s %s", buf1, buf);
1202 msg.type = SP_MESSAGE;
1203 msg.mesg[79] = '\0';
1204 msg.m_flags = MTEAM | MTAKE | MVALID;
1205 msg.m_recpt = idx_to_mask(players[packet->argument2].p_teami);
1206 msg.m_from = 255;
1207 handleMessage(&msg);
1208 }
1209 break;
1210 case DGHOSTKILL:
1211 {
1212 struct mesg_spacket msg;
1213 ushort damage;
1214 damage = (unsigned char) karg3;
1215 damage |= (unsigned char) (karg4 & 0xff) << 8;
1216 (void) sprintf(msg.mesg, "GOD->ALL %s (%c%c) was kill %0.2f for the GhostBusters",
1217 players[(unsigned char) packet->argument].p_name, TEAM_LETTER(players[(unsigned char) packet->argument]),
1218 shipnos[(unsigned char) packet->argument],
1219 (float) damage / 100.0);
1220 msg.type = SP_MESSAGE;
1221 msg.mesg[79] = '\0';
1222 msg.m_flags = MALL | MVALID;
1223 msg.m_recpt = 0;
1224 msg.m_from = 255;
1225 handleMessage(&msg);
1226 }
1227 break;
1228 /* INL Daemon Mesages */
1229 case INLDMKILLP:
1230 {
1231 struct mesg_spacket msg;
1232 *buf = 0;
1233 if (arg3) { /* Armies */
1234 sprintf(buf, "+%d", arg3);
1235 #ifdef SOUND
1236 if(alwaysSoundDoosh)
1237 S_PlaySound(S_DOOSH);
1238 #endif
1239 }
1240 (void) sprintf(msg.mesg, "%s%s[%s] (%c%c%s) killed by %s (%c)",
1241 (godToAllOnKills ? "GOD->ALL " : ""),
1242 players[(unsigned char) packet->argument].p_name,
1243 ship_type(players[(unsigned char) packet->argument].p_ship),
1244 TEAM_LETTER(players[(unsigned char) packet->argument]),
1245 shipnos[(unsigned char) packet->argument],
1246 buf,
1247 planets[(unsigned char) packet->argument2].pl_name,
1248 TEAM_LETTERP(planets[(unsigned char) packet->argument2]));
1249 if (why_dead) {
1250 add_whydead(msg.mesg, karg5);
1251 karg5 = 0;
1252 }
1253 msg.type = SP_MESSAGE;
1254 msg.mesg[79] = '\0';
1255 msg.m_flags = MALL | MVALID | MKILLP;
1256 msg.m_recpt = 0;
1257 msg.m_from = 255;
1258 handleMessage(&msg);
1259 }
1260 break;
1261 case INLDMKILL:
1262 {
1263 struct mesg_spacket msg;
1264 int killer, victim, armies;
1265 float kills;
1266 victim = (unsigned char) packet->argument & 0x3f;
1267 killer = (unsigned char) packet->argument2 & 0x3f;
1268 /* that's only a temp */
1269 damage = (unsigned char) karg3;
1270 damage |= (karg4 & 127) << 8;
1271 kills = damage / 100.0;
1272 armies = (((unsigned char) packet->argument >> 6) | ((unsigned char) packet->argument2 & 192) >> 4);
1273 if (karg4 & 128)
1274 armies |= 16;
1275 if (armies == 0) {
1276 (void) sprintf(msg.mesg, "%s%s[%s] (%c%c) was kill %0.2f for %s[%s] (%c%c)",
1277 (godToAllOnKills ? "GOD->ALL " : ""),
1278 players[victim].p_name,
1279 ship_type(players[victim].p_ship),
1280 TEAM_LETTER(players[victim]),
1281 shipnos[victim],
1282 kills,
1283 players[killer].p_name,
1284 ship_type(players[killer].p_ship),
1285 TEAM_LETTER(players[killer]),
1286 shipnos[killer]);
1287 msg.m_flags = MALL | MVALID | MKILL;
1288 } else {
1289 #ifdef SOUND
1290 if(killer == me->p_no || alwaysSoundDoosh)
1291 S_PlaySound(S_DOOSH);
1292 #endif
1293 (void) sprintf(msg.mesg, "%s%s[%s] (%c%c+%d armies) was kill %0.2f for %s[%s] (%c%c)",
1294 (godToAllOnKills ? "GOD->ALL " : ""),
1295 players[victim].p_name,
1296 ship_type(players[victim].p_ship),
1297 TEAM_LETTER(players[victim]),
1298 shipnos[victim],
1299 armies,
1300 kills,
1301 players[killer].p_name,
1302 ship_type(players[killer].p_ship),
1303 TEAM_LETTER(players[killer]),
1304 shipnos[killer]);
1305 msg.m_flags = MALL | MVALID | MKILLA;
1306 }
1307 if (why_dead) {
1308 add_whydead(msg.mesg, karg5);
1309 karg5 = 0;
1310 }
1311 msg.type = SP_MESSAGE;
1312 msg.mesg[79] = '\0';
1313 msg.m_recpt = 0;
1314 msg.m_from = 255;
1315 handleMessage(&msg);
1316 }
1317 break;
1318 case INLDRESUME:
1319 {
1320 struct mesg_spacket msg;
1321 sprintf(msg.mesg, " Game will resume in %d seconds", (unsigned char) packet->argument);
1322 msg.m_flags = MALL | MVALID;
1323 msg.type = SP_MESSAGE;
1324 msg.mesg[79] = '\0';
1325 msg.m_recpt = 0;
1326 msg.m_from = 255;
1327 handleMessage(&msg);
1328 }
1329 break;
1330 case INLDTEXTE:
1331 if (packet->argument >= 0 && (unsigned char) packet->argument < NUMDAEMONTEXTS) {
1332 struct mesg_spacket msg;
1333 strcpy(msg.mesg, daemon_texts[(unsigned char) packet->argument]);
1334 msg.m_flags = MALL | MVALID;
1335 msg.type = SP_MESSAGE;
1336 msg.mesg[79] = '\0';
1337 msg.m_recpt = 0;
1338 msg.m_from = 255;
1339 handleMessage(&msg);
1340 }
1341 break;
1342 case STEXTE:
1343 warning(s_texte[(unsigned char) packet->argument]);
1344 break;
1345 case SHORT_WARNING:
1346 {
1347 struct warning_spacket *warn = (struct warning_spacket *) packet;
1348 warning(warn->mesg);
1349 }
1350 break;
1351 case STEXTE_STRING:
1352 {
1353 struct warning_spacket *warn = (struct warning_spacket *) packet;
1354 warning(warn->mesg);
1355 s_texte[(unsigned char) warn->pad2] = (char *) malloc(warn->pad3 - 4);
1356 if (s_texte[(unsigned char) warn->pad2] == NULL) {
1357 s_texte[(unsigned char) warn->pad2] = no_memory;
1358 warning("Could not add warning! (No memory!)");
1359 } else
1360 strcpy(s_texte[(unsigned char) warn->pad2], warn->mesg);
1361 }
1362 break;
1363 default:
1364 warning("Unknown Short Warning!");
1365 break;
1366 }
1367 }
1368
1369 #define MY_SIZEOF(a) (sizeof(a) / sizeof(*(a)))
1370
1371 void
1372 add_whydead(s, m) /* 7/22/93 LAB */
1373 char *s;
1374 int m;
1375 {
1376 char b[256];
1377
1378 if (m < MY_SIZEOF(whydeadmess)) {
1379 sprintf(b, "%-50s %s", s, whydeadmess[m]);
1380 b[79] = '\0';
1381 strcpy(s, b);
1382 }
1383 }
1384
1385 #endif
1386
1387 /* END SHORT_PACKETS */