|
3
|
1 /* $Id: dmessage.c,v 1.1.1.1 1997/12/06 05:41:29 darius Exp $ */
|
|
|
2
|
|
|
3 /*
|
|
|
4 * dmessage.c
|
|
|
5 *
|
|
|
6 * for the client of a socket based protocol.
|
|
|
7 * code for message window scrollback added by Bill Dyess 12/7/93
|
|
|
8 */
|
|
|
9 #include "copyright.h"
|
|
|
10
|
|
|
11 #include <stdio.h>
|
|
|
12 #include <math.h>
|
|
|
13 #include <string.h>
|
|
|
14 #include <ctype.h>
|
|
|
15 #ifdef __STDC__
|
|
|
16 #include <stdlib.h>
|
|
|
17 #endif
|
|
|
18 #include "Wlib.h"
|
|
|
19 #include "defs.h"
|
|
|
20 #include "struct.h"
|
|
|
21 #include "data.h"
|
|
|
22 #include "proto.h"
|
|
|
23 #ifdef SOUND
|
|
|
24 #include "Slib.h"
|
|
|
25 #endif
|
|
|
26
|
|
|
27 #define MESSAGESIZE 20
|
|
|
28 #define YOFF 0
|
|
|
29
|
|
|
30 struct messageData {
|
|
|
31 char *message;
|
|
|
32 unsigned char flags, from, to;
|
|
|
33 };
|
|
|
34
|
|
|
35 struct messageNode {
|
|
|
36 struct messageData *line;
|
|
|
37 struct messageNode *next, *prev;
|
|
|
38 };
|
|
|
39
|
|
|
40 /* Prototypes */
|
|
|
41 int instr P((char *string1, char *string2));
|
|
|
42 void CheckFeatures P((char *m));
|
|
|
43 void print_message
|
|
|
44 P((char *message, unsigned int flags, unsigned int from,
|
|
|
45 unsigned int to, struct messageData * data,
|
|
|
46 W_Window winmask, int backwards));
|
|
|
47 void evalFlags P((int type, char *flagList));
|
|
|
48
|
|
|
49 void initMessageWindows()
|
|
|
50 {
|
|
|
51 int i;
|
|
|
52 char *s;
|
|
|
53
|
|
|
54 messWin[WALL].window = W_MakeScrollingWindow("review_all", WINSIDE + BORDER,
|
|
|
55 YOFF + WINSIDE + 3 * BORDER + 2 * MESSAGESIZE, 80, 10, 0, "xterm", BORDER);
|
|
|
56 messWin[WTEAM].window = W_MakeScrollingWindow("review_team", WINSIDE + BORDER,
|
|
|
57 YOFF + WINSIDE + 4 * BORDER + 2 * MESSAGESIZE + 10 * W_Textheight + 8,
|
|
|
58 80, 5, 0, "xterm", BORDER);
|
|
|
59 messWin[WINDIV].window = W_MakeScrollingWindow("review_your", WINSIDE + BORDER,
|
|
|
60 YOFF + WINSIDE + 5 * BORDER + 2 * MESSAGESIZE + 15 * W_Textheight + 16,
|
|
|
61 80, 4, 0, "xterm", BORDER);
|
|
|
62 messWin[WKILL].window = W_MakeScrollingWindow("review_kill", WINSIDE + BORDER,
|
|
|
63 YOFF + WINSIDE + 6 * BORDER + 2 * MESSAGESIZE + 19 * W_Textheight + 24,
|
|
|
64 80, 6, 0, "xterm", BORDER);
|
|
|
65 messWin[WPHASER].window = W_MakeScrollingWindow("review_phaser", WINSIDE +
|
|
|
66 BORDER, YOFF + WINSIDE + 7 * BORDER + 2 * MESSAGESIZE + 24 * W_Textheight
|
|
|
67 + 32, 80, 3, 0, "xterm", BORDER);
|
|
|
68 messWin[WREVIEW].window = W_MakeScrollingWindow("review", WINSIDE + BORDER,
|
|
|
69 YOFF + WINSIDE + 3 * BORDER + 2 * MESSAGESIZE,
|
|
|
70 80, 20, 0, "xterm", BORDER);
|
|
|
71
|
|
|
72 /*
|
|
|
73 initialize the 'allow' flags. Any window can display any message.
|
|
|
74 [BDyess]
|
|
|
75 */
|
|
|
76 s = stringDefault("review_all.allow", "MA");
|
|
|
77 evalFlags(WALL, s);
|
|
|
78 s = stringDefault("review_team.allow", "T");
|
|
|
79 evalFlags(WTEAM, s);
|
|
|
80 s = stringDefault("review_your.allow", "I");
|
|
|
81 evalFlags(WINDIV, s);
|
|
|
82 s = stringDefault("review_kill.allow", "K");
|
|
|
83 evalFlags(WKILL, s);
|
|
|
84 s = stringDefault("review_phaser.allow", "P");
|
|
|
85 evalFlags(WPHASER, s);
|
|
|
86 s = stringDefault("review.allow", "MATIKP");
|
|
|
87 evalFlags(WREVIEW, s);
|
|
|
88
|
|
|
89 for (i = 0; i < WNUM; i++) {
|
|
|
90 messWin[i].head = messWin[i].curHead = NULL;
|
|
|
91 }
|
|
|
92 }
|
|
|
93
|
|
|
94 void
|
|
|
95 evalFlags(type, flagList)
|
|
|
96 int type;
|
|
|
97 char *flagList;
|
|
|
98 {
|
|
|
99 char *orig=flagList;
|
|
|
100
|
|
|
101 messWin[type].flags = 0;
|
|
|
102 while (*flagList) {
|
|
|
103 switch (toupper(*flagList)) {
|
|
|
104 case 'A':
|
|
|
105 messWin[type].flags |= WA_ALL;
|
|
|
106 break;
|
|
|
107 case 'T':
|
|
|
108 messWin[type].flags |= WA_TEAM;
|
|
|
109 break;
|
|
|
110 case 'I':
|
|
|
111 messWin[type].flags |= WA_INDIV;
|
|
|
112 break;
|
|
|
113 case 'K':
|
|
|
114 messWin[type].flags |= WA_KILL;
|
|
|
115 break;
|
|
|
116 case 'P':
|
|
|
117 messWin[type].flags |= WA_PHASER;
|
|
|
118 break;
|
|
|
119 case 'M':
|
|
|
120 messWin[type].flags |= WA_MACRO;
|
|
|
121 break;
|
|
|
122 default:
|
|
|
123 printf("Invalid allow flag '%c' in allow list, ignoring\n",
|
|
|
124 *flagList);
|
|
|
125 break;
|
|
|
126 }
|
|
|
127 flagList++;
|
|
|
128 }
|
|
|
129 free(orig);
|
|
|
130 }
|
|
|
131
|
|
|
132 void
|
|
|
133 messageWinEvent(evt)
|
|
|
134 W_Event *evt;
|
|
|
135 /* handles the mouse and keyboard events that happen in one of the message
|
|
|
136 windows. For key events, if the event is within the team or all window then
|
|
|
137 it will automatically start the message for you, with destination to the
|
|
|
138 player's team or ALL, respectively. If it's a button event, it will scroll
|
|
|
139 the message window back, forward, or to start (left, right, and middle
|
|
|
140 button respectively). It beeps if there is no messages to scroll (ie at
|
|
|
141 the top or bottom already). [BDyess] 12/07/93 */
|
|
|
142 {
|
|
|
143 struct messageNode **headpntr, *runner, *newcpntr;
|
|
|
144 struct messageData *j;
|
|
|
145 int windowHeight;
|
|
|
146 register int i;
|
|
|
147 W_Window window = evt->Window;
|
|
|
148 int key = evt->key;
|
|
|
149 int scroll=0;
|
|
|
150
|
|
|
151 if (!W_IsMapped(window))
|
|
|
152 return;
|
|
|
153
|
|
|
154 if (evt->type == W_EV_KEY) {
|
|
|
155 if (key == ('e' + 128)) { /* erase window [BDyess] */
|
|
|
156 W_ClearWindow(window);
|
|
|
157 } else if(key == ('p'+128)) {
|
|
|
158 scroll = -1;
|
|
|
159 } else if(key == ('n'+128)) {
|
|
|
160 scroll = 1;
|
|
|
161 } else if (window == messWin[WALL].window) {
|
|
|
162 smessage_ahead('A', key);
|
|
|
163 } else if (window == messWin[WTEAM].window) {
|
|
|
164 smessage_ahead('T', key);
|
|
|
165 } else {
|
|
|
166 smessage(key);
|
|
|
167 }
|
|
|
168 if(!scroll)
|
|
|
169 return;
|
|
|
170 }
|
|
|
171 headpntr = NULL;
|
|
|
172 for (i = 0; i < WNUM; i++) {
|
|
|
173 if (window == messWin[i].window) {
|
|
|
174 headpntr = &messWin[i].curHead;
|
|
|
175 break;
|
|
|
176 }
|
|
|
177 }
|
|
|
178
|
|
|
179 runner = *headpntr;
|
|
|
180 if (runner == NULL) {
|
|
|
181 if(scrollBeep)
|
|
|
182 W_Beep();
|
|
|
183 return;
|
|
|
184 }
|
|
|
185 windowHeight = W_WindowHeight(window);
|
|
|
186
|
|
|
187 if(scroll==-1) {
|
|
|
188 for (i = 0; (i < windowHeight) && runner; i++, runner = runner->next)
|
|
|
189 ;
|
|
|
190 if (runner == NULL) {
|
|
|
191 if (scrollBeep)
|
|
|
192 W_Beep();
|
|
|
193 return;
|
|
|
194 }
|
|
|
195 j=runner->line;
|
|
|
196 print_message(j->message, j->flags, j->from, j->to, NULL, window, 1);
|
|
|
197 *headpntr = (*headpntr)->next;
|
|
|
198 return;
|
|
|
199 } else if(scroll==1) {
|
|
|
200 if(runner->prev == NULL) {
|
|
|
201 if (scrollBeep)
|
|
|
202 W_Beep();
|
|
|
203 return;
|
|
|
204 }
|
|
|
205 j=runner->prev->line;
|
|
|
206 print_message(j->message, j->flags, j->from, j->to, NULL, window, 0);
|
|
|
207 *headpntr = (*headpntr)->prev;
|
|
|
208 return;
|
|
|
209 }
|
|
|
210 switch (key) {
|
|
|
211 case W_LBUTTON:
|
|
|
212 for (i = 0; (i < windowHeight-1) && runner->next; i++, runner = runner->next)
|
|
|
213 ;
|
|
|
214 newcpntr=runner;
|
|
|
215
|
|
|
216 if (runner->next == NULL) {
|
|
|
217 if (scrollBeep)
|
|
|
218 W_Beep();
|
|
|
219 break;
|
|
|
220 }
|
|
|
221 runner=runner->next;
|
|
|
222 for (i = 0; (i < windowHeight-1) && runner; i++, runner = runner->next) {
|
|
|
223 j=runner->line;
|
|
|
224 print_message(j->message, j->flags, j->from, j->to, NULL, window, 1);
|
|
|
225 }
|
|
|
226 if(i<windowHeight-1) {
|
|
|
227 for(;i<windowHeight-1;i++)
|
|
|
228 W_WriteText(window,0,-1,0,"",0,0);
|
|
|
229 }
|
|
|
230 *headpntr=newcpntr;
|
|
|
231 break;
|
|
|
232 case W_RBUTTON:
|
|
|
233 if (runner->prev == NULL) {
|
|
|
234 if (scrollBeep)
|
|
|
235 W_Beep();
|
|
|
236 break;
|
|
|
237 }
|
|
|
238 for (i = 0; (i < windowHeight-1) && runner->prev; i++, runner = runner->prev) {
|
|
|
239 j=runner->prev->line;
|
|
|
240 print_message(j->message, j->flags, j->from, j->to, NULL, window, 0);
|
|
|
241 }
|
|
|
242 *headpntr = runner;
|
|
|
243 break;
|
|
|
244 case W_MBUTTON:
|
|
|
245 if (runner->prev == NULL) {
|
|
|
246 if (scrollBeep)
|
|
|
247 W_Beep();
|
|
|
248 break;
|
|
|
249 }
|
|
|
250 W_ClearWindow(window);
|
|
|
251 while (runner->prev)
|
|
|
252 runner = runner->prev;
|
|
|
253 *headpntr = runner;
|
|
|
254 for (i = 0; i < windowHeight && runner->next; i++, runner = runner->next);
|
|
|
255 while (runner) {
|
|
|
256 j = runner->line;
|
|
|
257 print_message(j->message, j->flags, j->from, j->to, NULL, window, 0);
|
|
|
258 runner = runner->prev;
|
|
|
259 }
|
|
|
260 break;
|
|
|
261 }
|
|
|
262 }
|
|
|
263
|
|
|
264 void
|
|
|
265 rsvp_borg_call(message, from)
|
|
|
266 char *message;
|
|
|
267 int from;
|
|
|
268 {
|
|
|
269 #if 0
|
|
|
270 int len, pos;
|
|
|
271 len = strlen(message);
|
|
|
272 pos = len - 5;
|
|
|
273 if (strncmp(message + pos, " ", 5) == 0)
|
|
|
274 #else
|
|
|
275 char *chk;
|
|
|
276
|
|
|
277 if (strlen(message) < 15)
|
|
|
278 return;
|
|
|
279 for (chk = message + 10; *chk && *chk == ' '; chk++)
|
|
|
280 /* empty body */ ;
|
|
|
281 if (*chk)
|
|
|
282 return;
|
|
|
283 #endif
|
|
|
284 {
|
|
|
285 char buf[120];
|
|
|
286
|
|
|
287 sprintf(buf, "Paradise Client %s (%s)", CLIENTVERS,
|
|
|
288 #ifdef __osf__
|
|
|
289 "DEC OSF/1"
|
|
|
290 #else
|
|
|
291 #ifdef NeXT
|
|
|
292 "NeXT"
|
|
|
293 #else
|
|
|
294 #ifdef ultrix
|
|
|
295 "DEC Ultrix"
|
|
|
296 #else
|
|
|
297 #if defined(sparc) && defined(SVR4)
|
|
|
298 "Solaris"
|
|
|
299 #else
|
|
|
300 #ifdef sparc
|
|
|
301 "SUN4/Sparc"
|
|
|
302 #else
|
|
|
303 #ifdef sun
|
|
|
304 "SUN3"
|
|
|
305 #else
|
|
|
306 #ifdef sequent
|
|
|
307 "sequent"
|
|
|
308 #else
|
|
|
309 #ifdef hpux
|
|
|
310 "hpux"
|
|
|
311 #else
|
|
|
312 #ifdef AIX
|
|
|
313 "AIX"
|
|
|
314 #else
|
|
|
315 #ifdef vax
|
|
|
316 "vax"
|
|
|
317 #else
|
|
|
318 #ifdef sgi
|
|
|
319 "sgi/IRIX"
|
|
|
320 #else
|
|
|
321 #ifdef apollo
|
|
|
322 "apollo"
|
|
|
323 #else
|
|
|
324 #ifdef RS6K
|
|
|
325 "RS6K"
|
|
|
326 #else
|
|
|
327 #ifdef linux
|
|
|
328 "Linux"
|
|
|
329 #else
|
|
|
330 #ifdef __NetBSD__
|
|
|
331 "NetBSD"
|
|
|
332 #else
|
|
|
333 #ifdef __FreeBSD__
|
|
|
334 "FreeBSD"
|
|
|
335 #else
|
|
|
336 #ifdef AMIGA
|
|
|
337 "Amiga"
|
|
|
338 #else
|
|
|
339 "generic"
|
|
|
340 #endif /* Amiga */
|
|
|
341 #endif /* linux */
|
|
|
342 #endif /* RS6K */
|
|
|
343 #endif /* apollo */
|
|
|
344 #endif /* sgi */
|
|
|
345 #endif /* vax */
|
|
|
346 #endif /* AIX */
|
|
|
347 #endif /* hpux */
|
|
|
348 #endif /* sequent */
|
|
|
349 #endif /* sun */
|
|
|
350 #endif /* sparc */
|
|
|
351 #endif /* solaris */
|
|
|
352 #endif /* ultrix */
|
|
|
353 #endif /* NeXT */
|
|
|
354 #endif /* __osf__ */
|
|
|
355 #endif /* FreeBSD */
|
|
|
356 #endif /* NetBSD */
|
|
|
357 );
|
|
|
358 if (from == 255) {
|
|
|
359 sendMessage(buf, MGOD, 0);
|
|
|
360 } else
|
|
|
361 sendMessage(buf, MINDIV, from);
|
|
|
362 }
|
|
|
363 }
|
|
|
364
|
|
|
365 void
|
|
|
366 logit(message)
|
|
|
367 char *message;
|
|
|
368 /* logs the given message if the 'logmess' variable is set to one. It send the
|
|
|
369 message to stdout by default, or to a file if one is defined. [BDyess] */
|
|
|
370 {
|
|
|
371 if (!logmess)
|
|
|
372 return;
|
|
|
373 if (logfilehandle && logFile) {
|
|
|
374 fprintf(logfilehandle, "%s\n", message);
|
|
|
375 fflush(logfilehandle);
|
|
|
376 } else {
|
|
|
377 printf("%s\n", message);
|
|
|
378 }
|
|
|
379 }
|
|
|
380
|
|
|
381 void
|
|
|
382 writeMessage(data, message, color, len, winmask, type, backwards)
|
|
|
383 struct messageData *data;
|
|
|
384 char *message;
|
|
|
385 W_Color color;
|
|
|
386 int len;
|
|
|
387 W_Window winmask;
|
|
|
388 int type;
|
|
|
389 int backwards;
|
|
|
390 {
|
|
|
391 struct messageNode *newhead;
|
|
|
392 struct messageWin *j;
|
|
|
393
|
|
|
394 if (data != NULL) {
|
|
|
395 #ifdef SPEECH /* was AMIGA... ya never know ;-) */
|
|
|
396 if (((S_SpeakYour && type & WA_INDIV) ||
|
|
|
397 (S_SpeakTeam && type & WA_TEAM) ||
|
|
|
398 (S_SpeakAll && type & WA_ALL) ||
|
|
|
399 (S_SpeakKill && type & WA_KILL)) &&
|
|
|
400 ((strncmp(message,"GOD->",5) != 0) || S_SpeakGod) &&
|
|
|
401 ((data->from != me->p_no) || S_SpeakSelf)) {
|
|
|
402 S_SpeakString(message, len);
|
|
|
403 }
|
|
|
404 #endif /* SPEECH */
|
|
|
405 #ifdef SOUND
|
|
|
406 if ((type & WA_INDIV) && data->from != me->p_no) {
|
|
|
407 S_PlaySound(S_WHISTLE);
|
|
|
408 }
|
|
|
409 #endif
|
|
|
410 for (j = &messWin[0]; j < &messWin[WNUM]; j++) {
|
|
|
411 if (!(j->flags & type))
|
|
|
412 continue;
|
|
|
413 newhead = (struct messageNode *) malloc(sizeof(struct messageNode));
|
|
|
414 newhead->next = j->head;
|
|
|
415 if (newhead->next)
|
|
|
416 newhead->next->prev = newhead;
|
|
|
417 newhead->prev = NULL;
|
|
|
418 newhead->line = data;
|
|
|
419 if (j->head == j->curHead) {
|
|
|
420 /* we aren't currently scrolled back [BDyess] */
|
|
|
421 W_WriteText(j->window, 0, 0, color, message, len, 0);
|
|
|
422 j->curHead = newhead;
|
|
|
423 }
|
|
|
424 j->head = newhead;
|
|
|
425 }
|
|
|
426 } else { /* we're drawing a new page */
|
|
|
427 for (j = &messWin[0]; j < &messWin[WNUM]; j++) {
|
|
|
428 if (!(j->flags & type))
|
|
|
429 continue;
|
|
|
430 if (j->window != winmask)
|
|
|
431 continue;
|
|
|
432 W_WriteText(j->window, 0, (backwards ? -1 : 0), color, message, len, 0);
|
|
|
433 }
|
|
|
434 }
|
|
|
435 }
|
|
|
436
|
|
|
437 void
|
|
|
438 print_message(message, flags, from, to, data, winmask, backwards)
|
|
|
439 char *message;
|
|
|
440 unsigned int flags, from, to;
|
|
|
441 struct messageData *data;
|
|
|
442 W_Window winmask;
|
|
|
443 int backwards;
|
|
|
444 /* this function determines the color that the given message should be and
|
|
|
445 then passes it to writeMessage, where the data structure for the scroll
|
|
|
446 back code is created and also where the winmask test is done. The winmask
|
|
|
447 determines what window the message is written to, useful when calling this
|
|
|
448 routine from the scrollback routines. If winmask == NULL it doesn't
|
|
|
449 limit printing at all, eg team messages will go to the team window and to
|
|
|
450 the total review window. [BDyess] 12/07/93 */
|
|
|
451 {
|
|
|
452 register int len;
|
|
|
453 W_Color color;
|
|
|
454 W_Window targwin;
|
|
|
455
|
|
|
456 #define take MTEAM + MTAKE + MVALID
|
|
|
457 #define destroy MTEAM + MDEST + MVALID
|
|
|
458 #define kill MALL + MKILL + MVALID
|
|
|
459 #define killp MALL + MKILLP + MVALID
|
|
|
460 #define killa MALL + MKILLA + MVALID
|
|
|
461 #define bomb MTEAM + MBOMB + MVALID
|
|
|
462 #define team MTEAM + MVALID
|
|
|
463 #define conq MALL + MCONQ + MVALID
|
|
|
464
|
|
|
465 len = strlen(message);
|
|
|
466 if (from == 254) { /* client passing info around */
|
|
|
467 switch (showPhaser) {
|
|
|
468 case 0:
|
|
|
469 break;
|
|
|
470 case 1:
|
|
|
471 writeMessage(data, message, textColor, len, winmask, WA_KILL | WA_REVIEW, backwards);
|
|
|
472 break;
|
|
|
473 case 2:
|
|
|
474 writeMessage(data, message, textColor, len, winmask, WA_REVIEW | WA_PHASER, backwards);
|
|
|
475 break;
|
|
|
476 case 3:
|
|
|
477 writeMessage(data, message, textColor, len, winmask, WA_REVIEW, backwards);
|
|
|
478 break;
|
|
|
479 }
|
|
|
480 return;
|
|
|
481 }
|
|
|
482 if (from == 255) {
|
|
|
483 if (flags == MCONFIG + MINDIV + MVALID) {
|
|
|
484 /* printf("Going to checkfeatures\n");*/
|
|
|
485 CheckFeatures(message);
|
|
|
486 return;
|
|
|
487 }
|
|
|
488 /* From God */
|
|
|
489 color = textColor;
|
|
|
490 } else {
|
|
|
491 /* kludge to fix the occasional incorrect color message */
|
|
|
492 if (*message == ' ' && from != me->p_no) {
|
|
|
493 /* XXX fix to handle funky teams */
|
|
|
494 switch (*(message + 1)) {
|
|
|
495 case 'F':
|
|
|
496 color = W_Yellow;
|
|
|
497 break;
|
|
|
498 case 'R':
|
|
|
499 color = W_Red;
|
|
|
500 break;
|
|
|
501 case 'K':
|
|
|
502 color = W_Green;
|
|
|
503 break;
|
|
|
504 case 'O':
|
|
|
505 color = W_Cyan;
|
|
|
506 break;
|
|
|
507 case 'I':
|
|
|
508 color = W_Grey;
|
|
|
509 break;
|
|
|
510 default:
|
|
|
511 color = playerColor(&(players[from]));
|
|
|
512 }
|
|
|
513 } else
|
|
|
514 color = playerColor(&(players[from]));
|
|
|
515 }
|
|
|
516
|
|
|
517 /* added/modified to fit with the scrollback feature 1/94 -JR */
|
|
|
518 if (!paradise && niftyNewMessages) {
|
|
|
519 if (flags == conq) {
|
|
|
520 /* output conquer stuff to stdout in addition to message window */
|
|
|
521 fprintf(stdout, "%s\n", message);
|
|
|
522 if (instr(message, "kill")) {
|
|
|
523 fprintf(stdout, "NOTE: The server here does not properly set message flags\n");
|
|
|
524 fprintf(stdout, "You should probably pester the server god to update....\n");
|
|
|
525 }
|
|
|
526 }
|
|
|
527 if ((flags == team) || (flags == take) || (flags == destroy)) {
|
|
|
528 writeMessage(data, message, color, len, winmask, WA_TEAM | WA_REVIEW, backwards);
|
|
|
529 targwin = messWin[WTEAM].window;
|
|
|
530 } else if ((flags == kill) || (flags == killp) || (flags == killa) || (flags == bomb)) {
|
|
|
531 writeMessage(data, message, color, len, winmask,
|
|
|
532 WA_KILL | (reportKills ? WA_REVIEW : 0), backwards);
|
|
|
533 targwin = messWin[WKILL].window;
|
|
|
534 } else if (flags & MINDIV) {
|
|
|
535 writeMessage(data, message, color, len, winmask, (WA_INDIV | WA_REVIEW), backwards);
|
|
|
536 targwin = messWin[WINDIV].window;
|
|
|
537 } else if (flags == (MMACRO | MALL)) {
|
|
|
538 writeMessage(data, message, color, len, winmask, (WA_MACRO | WA_REVIEW), backwards);
|
|
|
539 targwin = messWin[WALL].window;
|
|
|
540 } else {
|
|
|
541 /*
|
|
|
542 if we don't know where the message belongs by this time, stick
|
|
|
543 it in the all board...
|
|
|
544 */
|
|
|
545 writeMessage(data, message, color, len, winmask, (WA_ALL | WA_REVIEW), backwards);
|
|
|
546 targwin = messWin[WALL].window;
|
|
|
547 }
|
|
|
548 } else {
|
|
|
549
|
|
|
550 /*
|
|
|
551 Kludge stuff for report kills...
|
|
|
552 */
|
|
|
553 if ((strncmp(message, "GOD->ALL", 8) == 0 &&
|
|
|
554 (instr(message, "was kill") ||
|
|
|
555 instr(message, "killed by"))) ||
|
|
|
556 instr(message, "burned to a crisp by") ||
|
|
|
557 instr(message, "shot down by") ||
|
|
|
558 (*message != ' ' && instr(message, "We are being attacked"))) {
|
|
|
559 writeMessage(data, message, color, len, winmask,
|
|
|
560 WA_KILL | (reportKills ? WA_REVIEW : 0), backwards);
|
|
|
561 return;
|
|
|
562 }
|
|
|
563 /*
|
|
|
564 note: messages are kept track of even if the associated window is
|
|
|
565 not mapped. This allows the window to be later mapped and have
|
|
|
566 all the past messages. [BDyess]
|
|
|
567 */
|
|
|
568 if (flags & MTEAM) {
|
|
|
569 writeMessage(data, message, color, len, winmask, WA_TEAM | WA_REVIEW, backwards);
|
|
|
570 targwin = messWin[WTEAM].window;
|
|
|
571 } else if (flags & MINDIV) {
|
|
|
572 writeMessage(data, message, color, len, winmask, WA_INDIV | WA_REVIEW, backwards);
|
|
|
573 targwin = messWin[WINDIV].window;
|
|
|
574 } else if (flags == (MMACRO | MALL)) {
|
|
|
575 writeMessage(data, message, color, len, winmask, WA_MACRO | WA_REVIEW, backwards);
|
|
|
576 targwin = messWin[WALL].window;
|
|
|
577 } else {
|
|
|
578 writeMessage(data, message, color, len, winmask, WA_ALL | WA_REVIEW, backwards);
|
|
|
579 targwin = messWin[WALL].window;
|
|
|
580 }
|
|
|
581 }
|
|
|
582 /*
|
|
|
583 send warnings to warning or message window, if player doesn't have
|
|
|
584 messag es mapped
|
|
|
585 */
|
|
|
586 if ((use_msgw && (targwin == messWin[WINDIV].window || targwin == messWin[WTEAM].window)) ||
|
|
|
587 (!W_IsMapped(targwin) && !W_IsMapped(messWin[WREVIEW].window))) {
|
|
|
588 if (!messpend && messagew) { /* don't collide with messages being
|
|
|
589 written! */
|
|
|
590 W_ClearWindow(messagew);
|
|
|
591 W_WriteText(messagew, 5, 5, color, message, len, W_RegularFont);
|
|
|
592 } else
|
|
|
593 warning(message);
|
|
|
594 }
|
|
|
595 }
|
|
|
596
|
|
|
597 void
|
|
|
598 dmessage(message, flags, from, to)
|
|
|
599 char *message;
|
|
|
600 unsigned int flags, from, to;
|
|
|
601 /* prints the given message by going though several subroutines. Here, it first
|
|
|
602 creates the data structure that holds the message info and logs the message,
|
|
|
603 then sends it on it's subroutine path to print it to the correct window(s).
|
|
|
604 This is a good place to handle any special-functions that occur due to
|
|
|
605 incoming messages. The data structure for the scroll back is like this:
|
|
|
606 each window has a head pointer that points to the top of its message
|
|
|
607 list. Each list only contains the messages that go to it's window. The
|
|
|
608 lists have pointers to the message itself, so that only one copy of the
|
|
|
609 message exists even if it is displayed on several windows. Each list also
|
|
|
610 has a current head pointer that points to the record that is at the bottom
|
|
|
611 of that current window. If the current head pointer and the head pointer
|
|
|
612 are different, then the window must be scrolled back. In such a case, new
|
|
|
613 messages are still received but not printed. [BDyess] 12/07/93 */
|
|
|
614 {
|
|
|
615 struct messageData *data;
|
|
|
616 struct distress dist;
|
|
|
617 int len;
|
|
|
618
|
|
|
619 #ifdef RC_DISTRESS
|
|
|
620 /* aha! A new type distress/macro call came in. parse it appropriately */
|
|
|
621 if (F_gen_distress && (flags == (MTEAM | MDISTR | MVALID))) {
|
|
|
622 HandleGenDistr(message, from, to, &dist);
|
|
|
623 len = makedistress(&dist, message, distmacro[dist.distype].macro);
|
|
|
624 #ifdef BEEPLITE
|
|
|
625 if (UseLite)
|
|
|
626 rcdlite(&dist);
|
|
|
627 #endif
|
|
|
628 if (len <= 0)
|
|
|
629 return;
|
|
|
630 flags ^= MDISTR;
|
|
|
631 }
|
|
|
632 #endif
|
|
|
633 /*
|
|
|
634 add create message data struct. Used for message scrollback
|
|
|
635 capability. [BDyess]
|
|
|
636 */
|
|
|
637 data = (struct messageData *) malloc(sizeof(struct messageData));
|
|
|
638 data->message = (char *) strdup(message);
|
|
|
639 data->flags = flags;
|
|
|
640 data->from = from;
|
|
|
641 data->to = to;
|
|
|
642 /*
|
|
|
643 keep track of how many queued messages there are for use with the
|
|
|
644 infoIcon [BDyess]
|
|
|
645 */
|
|
|
646 if (infoIcon) {
|
|
|
647 if (to == me->p_no && flags & MINDIV) { /* personal message */
|
|
|
648 me_messages++;
|
|
|
649 } else if (flags & MTEAM) { /* team message */
|
|
|
650 team_messages++;
|
|
|
651 } else { /* message for all */
|
|
|
652 all_messages++;
|
|
|
653 }
|
|
|
654 if (iconified)
|
|
|
655 drawIcon();
|
|
|
656 }
|
|
|
657 logit(message);
|
|
|
658
|
|
|
659 /*
|
|
|
660 fix for upgrade bug. Forced UDP would resend numbers, (thinking them
|
|
|
661 speed changes) screwing up upgrading on those twinkish sturgeon
|
|
|
662 servers. [BDyess]
|
|
|
663 */
|
|
|
664 if (strncmp(message, "UPG->", 5) == 0)
|
|
|
665 upgrading = 1;
|
|
|
666 if (upgrading && !(me->p_flags & PFORBIT))
|
|
|
667 upgrading = 0;
|
|
|
668
|
|
|
669 if ((from != me->p_no) || pigSelf)
|
|
|
670 rsvp_borg_call(message, from);
|
|
|
671
|
|
|
672 /* beep when a personal message is sent while iconified [BDyess] */
|
|
|
673 if (to == me->p_no && (flags & MINDIV) && iconified) {
|
|
|
674 W_Beep();
|
|
|
675 }
|
|
|
676 if (from == 255 &&
|
|
|
677 strcmp(message, "Tractor beam aborted warp engagement") == 0) {
|
|
|
678 me->p_flags &= ~PFWARPPREP;
|
|
|
679 }
|
|
|
680 print_message(message, flags, from, to, data, NULL, 0);
|
|
|
681 }
|
|
|
682
|
|
|
683
|
|
|
684 int
|
|
|
685 instr(string1, string2)
|
|
|
686 char *string1, *string2;
|
|
|
687 {
|
|
|
688 char *s;
|
|
|
689 int length;
|
|
|
690
|
|
|
691 length = strlen(string2);
|
|
|
692 for (s = string1; *s != 0; s++) {
|
|
|
693 if (*s == *string2 && strncmp(s, string2, length) == 0)
|
|
|
694 return (1);
|
|
|
695 }
|
|
|
696 return (0);
|
|
|
697 }
|
|
|
698
|
|
|
699 void
|
|
|
700 CheckFeatures(m)
|
|
|
701 char *m;
|
|
|
702 /* I don't know if this works correctly or not. It is ripped from BRM and has
|
|
|
703 been modified a bit to fit. Right now it doesn't do anything. [BDyess] */
|
|
|
704 {
|
|
|
705 char buf[BUFSIZ];
|
|
|
706 char *pek = &m[10];
|
|
|
707
|
|
|
708 if ((int) strlen(m) < 11)
|
|
|
709 return;
|
|
|
710
|
|
|
711 while ((*pek == ' ') && (*pek != '\0'))
|
|
|
712 pek++;
|
|
|
713
|
|
|
714 strcpy(buf, "Paradise Client: ");
|
|
|
715
|
|
|
716 if (!strcmp(pek, "NO_VIEW_BOX")) {
|
|
|
717 allowViewBox = 0;
|
|
|
718 strcat(buf, pek);
|
|
|
719 }
|
|
|
720 #ifdef CONTINUOUS_MOUSE
|
|
|
721 if (!strcmp(pek, "NO_CONTINUOUS_MOUSE")) {
|
|
|
722 allowContinuousMouse = 0;
|
|
|
723 strcat(buf, pek);
|
|
|
724 }
|
|
|
725 #endif /* CONTINUOUS_MOUSE */
|
|
|
726 if (!strcmp(pek, "NO_SHOW_ALL_TRACTORS")) {
|
|
|
727 allowShowAllTractorPressor = 0;
|
|
|
728 strcat(buf, pek);
|
|
|
729 }
|
|
|
730 if (!strcmp(pek, "HIDE_PLAYERLIST_ON_ENTRY")) {
|
|
|
731 allowPlayerlist = 0;
|
|
|
732 strcat(buf, pek);
|
|
|
733 }
|
|
|
734 if (!strcmp(pek, "NO_NEWMACRO")) {
|
|
|
735 /* UseNewMacro = 0;*/
|
|
|
736 strcat(buf, pek);
|
|
|
737 }
|
|
|
738 if (!strcmp(pek, "NO_SMARTMACRO")) {
|
|
|
739 /* UseSmartMacro = 0;*/
|
|
|
740 strcat(buf, pek);
|
|
|
741 }
|
|
|
742 if (!strcmp(pek, "WHY_DEAD")) {
|
|
|
743 why_dead = 1;
|
|
|
744 strcat(buf, pek);
|
|
|
745 }
|
|
|
746 if (!strcmp(pek, "RC_DISTRESS")) {
|
|
|
747 /* gen_distress = 1;*/
|
|
|
748 /* distmacro = dist_prefered;*/
|
|
|
749 strcat(buf, pek);
|
|
|
750 }
|
|
|
751 /* what the hell is this? - jmn */
|
|
|
752 if (!strncmp(pek, "INFO", 4)) {
|
|
|
753 strcat(buf, pek);
|
|
|
754 }
|
|
|
755 if (strlen(buf) == strlen("Paradise Client: ")) {
|
|
|
756 strcat(buf, "UNKNOWN FEATURE: ");
|
|
|
757 strcat(buf, pek);
|
|
|
758 }
|
|
|
759 buf[79] = '\0';
|
|
|
760
|
|
|
761 printf("%s\n", buf);
|
|
|
762
|
|
|
763 W_WriteText(messWin[WREVIEW].window, 0, 0, W_White, buf, strlen(buf), 0);
|
|
|
764 W_WriteText(messWin[WALL].window, 0, 0, W_White, buf, strlen(buf), 0);
|
|
|
765 }
|
|
|
766
|
|
|
767 void
|
|
|
768 sendVersion()
|
|
|
769 {
|
|
|
770 static int version_sent = 0;
|
|
|
771 char buf[80];
|
|
|
772
|
|
|
773 if (!version_sent) {
|
|
|
774 version_sent = 1;
|
|
|
775 sprintf(buf, "@%s", CLIENTVERS);
|
|
|
776 pmessage(buf, me->p_no, MINDIV | MCONFIG);
|
|
|
777 }
|
|
|
778 }
|
