|
4
|
1 /*--------------------------------------------------------------------------
|
|
|
2 NETREK II -- Paradise
|
|
|
3
|
|
|
4 Permission to use, copy, modify, and distribute this software and its
|
|
|
5 documentation, or any derivative works thereof, for any NON-COMMERCIAL
|
|
|
6 purpose and without fee is hereby granted, provided that this copyright
|
|
|
7 notice appear in all copies. No representations are made about the
|
|
|
8 suitability of this software for any purpose. This software is provided
|
|
|
9 "as is" without express or implied warranty.
|
|
|
10
|
|
|
11 Xtrek Copyright 1986 Chris Guthrie
|
|
|
12 Netrek (Xtrek II) Copyright 1989 Kevin P. Smith
|
|
|
13 Scott Silvey
|
|
|
14 Paradise II (Netrek II) Copyright 1993 Larry Denys
|
|
|
15 Kurt Olsen
|
|
|
16 Brandon Gillespie
|
|
|
17 --------------------------------------------------------------------------*/
|
|
|
18
|
|
|
19 /* was control_mess.c, but changed to message.c for a smaller filename (BG) */
|
|
|
20
|
|
|
21 /*
|
|
|
22 * Ugh, this code is in the middle of a rewrite.
|
|
|
23 *
|
|
|
24 * It used to use a tokenizer with a global dictionary to split the input into
|
|
|
25 * words. The tokenizer accepted abbreviations as long as these were unique.
|
|
|
26 * However, adding a new word to the dictionary would often cause old
|
|
|
27 * abbreviations to be invalidated.
|
|
|
28 *
|
|
|
29 * I wrote a new parser that was called as each token needed to be extracted.
|
|
|
30 * This used a dictionary that was local to each submenu. This localizes
|
|
|
31 * changes to the menu structure so that effects of adding new commands are
|
|
|
32 * minimized.
|
|
|
33 *
|
|
|
34 * Some of the file is converted to use this, but not all. Eventually the
|
|
|
35 * entire module will use the context-sensitive tokenizer.
|
|
|
36 *
|
|
|
37 */
|
|
|
38
|
|
|
39
|
|
|
40 #include "config.h"
|
|
|
41 #include <stdio.h>
|
|
|
42 #include <string.h>
|
|
|
43 #include <signal.h>
|
|
|
44 #include <ctype.h>
|
|
|
45 #include <fcntl.h>
|
|
|
46
|
|
|
47 #include "defs.h"
|
|
|
48 #include "data.h"
|
|
|
49 #include "struct.h"
|
|
|
50 #include "shmem.h"
|
|
|
51
|
|
|
52 enum token_names_e
|
|
|
53 {
|
|
|
54 HELPTOK = 128,
|
|
|
55 CONTROLTOK,
|
|
|
56 VERSIONTOK,
|
|
|
57 QUEUETOK,
|
|
|
58 LEAGUETOK,
|
|
|
59 PARAMTOK,
|
|
|
60 INFOTOK,
|
|
|
61 OBSERVETOK,
|
|
|
62 CLUECHECKTOK,
|
|
|
63
|
|
|
64 NUKEGAMETOK,
|
|
|
65 FREESLOTTOK,
|
|
|
66 ROBOTTOK,
|
|
|
67 TOURNTOK,
|
|
|
68 NEWGALAXY,
|
|
|
69 SHIPTIMERTOK,
|
|
|
70
|
|
|
71 REFITTOK,
|
|
|
72 PLAYERTOK,
|
|
|
73 EJECTTOK,
|
|
|
74 DIETOK,
|
|
|
75 ARMIESTOK,
|
|
|
76 PLASMATOK,
|
|
|
77 MISSILETOK,
|
|
|
78 PLANETTOK,
|
|
|
79 RANKTOK,
|
|
|
80 MOVETOK,
|
|
|
81
|
|
|
82 PASSWDTOK,
|
|
|
83 RATINGSTOK,
|
|
|
84
|
|
|
85 TIMETOK,
|
|
|
86 CAPTAINTOK,
|
|
|
87 RESTARTTOK,
|
|
|
88 STARTTOK,
|
|
|
89 PASSTOK,
|
|
|
90 TIMEOUTTOK,
|
|
|
91 TEAMNAMETOK,
|
|
|
92 AWAYTOK,
|
|
|
93 HOMETOK,
|
|
|
94 PAUSETOK,
|
|
|
95 CONTINUETOK,
|
|
|
96 MAXPLAYERTOK,
|
|
|
97
|
|
|
98 TEAMTOK,
|
|
|
99
|
|
|
100 INDTOK, /* these need to be adjacent and in order */
|
|
|
101 FEDTOK, /* these need to be adjacent and in order */
|
|
|
102 ROMTOK, /* these need to be adjacent and in order */
|
|
|
103 KLITOK, /* these need to be adjacent and in order */
|
|
|
104 ORITOK, /* these need to be adjacent and in order */
|
|
|
105
|
|
|
106 SHIPTOK,
|
|
|
107
|
|
|
108 SCOUTTOK, /* these need to be adjacent and in order */
|
|
|
109 DESTROYERTOK, /* these need to be adjacent and in order */
|
|
|
110 CRUISERTOK, /* these need to be adjacent and in order */
|
|
|
111 BATTLESHIPTOK, /* these need to be adjacent and in order */
|
|
|
112 ASSAULTTOK, /* these need to be adjacent and in order */
|
|
|
113 STARBASETOK, /* these need to be adjacent and in order */
|
|
|
114 ATTTOK, /* these need to be adjacent and in order */
|
|
|
115 JUMPSHIPTOK, /* these need to be adjacent and in order */
|
|
|
116 FRIGATETOK, /* these need to be adjacent and in order */
|
|
|
117 WARBASETOK, /* these need to be adjacent and in order */
|
|
|
118 LIGHTCRUISERTOK,
|
|
|
119 CARRIERTOK,
|
|
|
120 UTILITYTOK,
|
|
|
121 PATROLTOK,
|
|
|
122
|
|
|
123 PLUSTOK,
|
|
|
124 MINUSTOK,
|
|
|
125 ROYALTOK,
|
|
|
126 QUIETTOK,
|
|
|
127 KILLSTOK,
|
|
|
128 HOSETOK,
|
|
|
129 SUPERTOK,
|
|
|
130 ALLOWTOK, /* control allow [teams] */
|
|
|
131
|
|
|
132 ERRORTOK = 255
|
|
|
133 };
|
|
|
134
|
|
|
135 #ifdef GOD_CONTROLS
|
|
|
136 static int god_silent = 0;
|
|
|
137 #endif
|
|
|
138
|
|
|
139 /* static char *con_shipnos = "0123456789abcdefghijklmnopqrstuvwxyz"; */
|
|
|
140
|
|
|
141 extern int pmessage2();
|
|
|
142 extern int pmessage();
|
|
|
143 #ifndef linux
|
|
|
144 extern int atoi();
|
|
|
145 #endif /* linux */
|
|
|
146 extern int detourneyqueue();
|
|
|
147 extern void compute_ratings();
|
|
|
148
|
|
|
149 static void respond();
|
|
|
150
|
|
|
151 #if 0
|
|
|
152 static enum token_names_e tokstring[128]; /* list of tokens */
|
|
|
153 static char *thestrings[128]; /* list of corresponding strings */
|
|
|
154 static char *therest[128]; /* list of pointers to the original text
|
|
|
155 * starting with token i */
|
|
|
156 static int sizetokstring;
|
|
|
157
|
|
|
158 struct token
|
|
|
159 {
|
|
|
160 char string[32];
|
|
|
161 int token;
|
|
|
162 };
|
|
|
163
|
|
|
164
|
|
|
165
|
|
|
166 struct token tstrings[] = {
|
|
|
167 {"0", 0}, {"1", 1}, {"2", 2}, {"3", 3},
|
|
|
168 {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7},
|
|
|
169 {"8", 8}, {"9", 9}, {"a", 10}, {"b", 11},
|
|
|
170 {"c", 12}, {"d", 13}, {"e", 14}, {"f", 15},
|
|
|
171 {"g", 16}, {"h", 17}, {"i", 18}, {"j", 19},
|
|
|
172 {"k", 20}, {"l", 21}, {"m", 22}, {"n", 23},
|
|
|
173 {"o", 24}, {"p", 25}, {"q", 26}, {"r", 27},
|
|
|
174 {"s", 28}, {"t", 29}, {"u", 30}, {"v", 31},
|
|
|
175 {"w", 32}, {"x", 33}, {"y", 34}, {"z", 35},
|
|
|
176 {"help", HELPTOK},
|
|
|
177 {"control", CONTROLTOK},
|
|
|
178 {"con", CONTROLTOK}, /* popular abbrev */
|
|
|
179 {"version", VERSIONTOK},
|
|
|
180 {"tq", QUEUETOK}, /* popular abbrev */
|
|
|
181 {"queue", QUEUETOK},
|
|
|
182 {"league", LEAGUETOK},
|
|
|
183 {"params", PARAMTOK},
|
|
|
184 {"observe", OBSERVETOK},
|
|
|
185 {"info", INFOTOK},
|
|
|
186 {"cluecheck", CLUECHECKTOK},
|
|
|
187
|
|
|
188 {"shiptimers", SHIPTIMERTOK},
|
|
|
189
|
|
|
190 {"refit", REFITTOK},
|
|
|
191 {"player", PLAYERTOK},
|
|
|
192 {"pl", PLAYERTOK}, /* popular abbrev */
|
|
|
193 {"planet", PLANETTOK},
|
|
|
194 {"eject", EJECTTOK},
|
|
|
195 {"die", DIETOK},
|
|
|
196 {"rank", RANKTOK},
|
|
|
197 {"royalty", ROYALTOK},
|
|
|
198 {"move", MOVETOK},
|
|
|
199 {"armies", ARMIESTOK},
|
|
|
200 {"plasma", PLASMATOK},
|
|
|
201 {"missile", MISSILETOK},
|
|
|
202 {"team", TEAMTOK},
|
|
|
203 {"ship", SHIPTOK},
|
|
|
204 {"quiet", QUIETTOK},
|
|
|
205 {"kills", KILLSTOK},
|
|
|
206 {"hose", HOSETOK},
|
|
|
207 {"super", SUPERTOK},
|
|
|
208 {"allow", ALLOWTOK},
|
|
|
209 {"+", PLUSTOK},
|
|
|
210 {"-", MINUSTOK},
|
|
|
211
|
|
|
212 {"robot", ROBOTTOK},
|
|
|
213 {"nukegame", NUKEGAMETOK},
|
|
|
214 {"freeslot", FREESLOTTOK},
|
|
|
215 {"tourn", TOURNTOK},
|
|
|
216 {"galaxy", NEWGALAXY},
|
|
|
217
|
|
|
218 /* player commands */
|
|
|
219 {"password", PASSWDTOK},
|
|
|
220 {"ratings", RATINGSTOK},
|
|
|
221
|
|
|
222 /* league commands */
|
|
|
223 {"time", TIMETOK},
|
|
|
224 {"captain", CAPTAINTOK},
|
|
|
225 {"restart", RESTARTTOK},
|
|
|
226 {"start", STARTTOK},
|
|
|
227 {"pass", PASSTOK},
|
|
|
228 {"timeout", TIMEOUTTOK},
|
|
|
229 {"teamname", TEAMNAMETOK},
|
|
|
230 {"away", AWAYTOK},
|
|
|
231 {"home", HOMETOK},
|
|
|
232 {"pause", PAUSETOK},
|
|
|
233 {"continue", CONTINUETOK},
|
|
|
234 {"maxplayers", MAXPLAYERTOK},
|
|
|
235
|
|
|
236 {"independent", INDTOK},
|
|
|
237 {"federation", FEDTOK}, {"romulan", ROMTOK},
|
|
|
238 {"klingon", KLITOK}, {"orion", ORITOK},
|
|
|
239
|
|
|
240 {"sc", SCOUTTOK}, {"dd", DESTROYERTOK},
|
|
|
241 {"ca", CRUISERTOK}, {"bb", BATTLESHIPTOK},
|
|
|
242 {"as", ASSAULTTOK}, {"sb", STARBASETOK},
|
|
|
243 {"at", ATTTOK}, {"js", JUMPSHIPTOK},
|
|
|
244 {"fr", FRIGATETOK}, {"wb", WARBASETOK},
|
|
|
245 {"cl", LIGHTCRUISERTOK}, {"cv", CARRIERTOK},
|
|
|
246 {"ut", UTILITYTOK}, {"pt", PATROLTOK},
|
|
|
247
|
|
|
248 {"", ERRORTOK} /* I'm last. Keep it that way. */
|
|
|
249 };
|
|
|
250
|
|
|
251 static void
|
|
|
252 dotokenize(input)
|
|
|
253 char *input;
|
|
|
254 {
|
|
|
255 char *temp0, *temp1;
|
|
|
256 int done = 0;
|
|
|
257 static char internal[120];
|
|
|
258
|
|
|
259 sizetokstring = 0;
|
|
|
260
|
|
|
261 /* Convert string to lowercase. */
|
|
|
262
|
|
|
263 temp0 = strcpy(internal, input);
|
|
|
264 while (*temp0 != '\0')
|
|
|
265 {
|
|
|
266 if (isupper(*temp0))
|
|
|
267 *temp0 = tolower(*temp0);
|
|
|
268 temp0++;
|
|
|
269 }
|
|
|
270
|
|
|
271
|
|
|
272 temp0 = internal;
|
|
|
273
|
|
|
274 while (done == 0)
|
|
|
275 {
|
|
|
276 struct token *tptr;
|
|
|
277 int wordlen;
|
|
|
278 int potentialtok, ambiguous;
|
|
|
279
|
|
|
280 /* Eat leading spaces. */
|
|
|
281
|
|
|
282 while (*temp0 == ' ')
|
|
|
283 temp0++;
|
|
|
284
|
|
|
285 /* Find the next word and chop the rest of the string away. */
|
|
|
286
|
|
|
287 temp1 = temp0;
|
|
|
288 therest[sizetokstring] = input + (temp1 - internal);
|
|
|
289 while (*temp1 != '\0' && *temp1 != ' ')
|
|
|
290 temp1++;
|
|
|
291 if (*temp1 != '\0')
|
|
|
292 *temp1++ = '\0';
|
|
|
293 wordlen = strlen(temp0);
|
|
|
294
|
|
|
295 /* Go find out what they've typed. */
|
|
|
296
|
|
|
297 tptr = tstrings;
|
|
|
298 potentialtok = ERRORTOK;
|
|
|
299 ambiguous = 0;
|
|
|
300 while (tptr->token != ERRORTOK)
|
|
|
301 {
|
|
|
302 if (0 == strncmp(temp0, tptr->string, wordlen))
|
|
|
303 {
|
|
|
304 if (strlen(tptr->string) == wordlen)
|
|
|
305 {
|
|
|
306 ambiguous = 0;
|
|
|
307 potentialtok = tptr->token;
|
|
|
308 break; /* exact match */
|
|
|
309 }
|
|
|
310 if (potentialtok != ERRORTOK)
|
|
|
311 {
|
|
|
312 ambiguous = 1; /* this isn't the only match */
|
|
|
313 }
|
|
|
314 potentialtok = tptr->token;
|
|
|
315 }
|
|
|
316 tptr++;
|
|
|
317 }
|
|
|
318
|
|
|
319 thestrings[sizetokstring] = temp0;
|
|
|
320 tokstring[sizetokstring++] = ambiguous ? ERRORTOK : potentialtok;
|
|
|
321 temp0 = temp1;
|
|
|
322
|
|
|
323 /* If *temp0 == 0 then we're done. */
|
|
|
324
|
|
|
325 if (*temp0 == '\0')
|
|
|
326 done = 1;
|
|
|
327 }
|
|
|
328 thestrings[sizetokstring] = 0;
|
|
|
329 }
|
|
|
330 #endif
|
|
|
331
|
|
|
332 /**********************************************************************/
|
|
|
333
|
|
|
334 /* New parsing method. */
|
|
|
335
|
|
|
336 struct control_cmd
|
|
|
337 {
|
|
|
338 char *literal; /* the command they should type */
|
|
|
339 enum token_names_e tok; /* what the parser should return */
|
|
|
340 char *doc; /* documentation to print for a help command */
|
|
|
341 };
|
|
|
342
|
|
|
343 /*
|
|
|
344 * Scans the string cmd for the first whitespace delimited string. Tries to
|
|
|
345 * match this string in a case-insensitive manner against the list in legals.
|
|
|
346 * Returns the appropriate token. Alters the char* pointed to by after to be
|
|
|
347 * the beginning of the next whitespace-delimited string.
|
|
|
348 *
|
|
|
349 * cmd: unmodified legals: unmodified after: MODIFIED
|
|
|
350 *
|
|
|
351 */
|
|
|
352
|
|
|
353 enum token_names_e
|
|
|
354 next_token(cmd, legals, after)
|
|
|
355 char *cmd;
|
|
|
356 struct control_cmd *legals;
|
|
|
357 char **after;
|
|
|
358 {
|
|
|
359 char buf[80]; /* space for the token */
|
|
|
360 char *s;
|
|
|
361 int i;
|
|
|
362 int ambiguous = 0;
|
|
|
363 enum token_names_e potentialtok = ERRORTOK;
|
|
|
364
|
|
|
365 while (*cmd && isspace(*cmd))
|
|
|
366 cmd++;
|
|
|
367
|
|
|
368 if (!*cmd)
|
|
|
369 return ERRORTOK;
|
|
|
370
|
|
|
371 for (s = buf; *cmd && !isspace(*cmd); s++, cmd++)
|
|
|
372 *s = *cmd;
|
|
|
373 *s = 0;
|
|
|
374
|
|
|
375 while (*cmd && isspace(*cmd))
|
|
|
376 cmd++;
|
|
|
377
|
|
|
378 if (after)
|
|
|
379 *after = cmd; /* so they can find the next token */
|
|
|
380
|
|
|
381 for (i = 0; legals[i].literal; i++)
|
|
|
382 {
|
|
|
383 int wordlen = strlen(buf);
|
|
|
384 if (0 == strncasecmp(buf, legals[i].literal, wordlen))
|
|
|
385 {
|
|
|
386 if (strlen(legals[i].literal) == wordlen)
|
|
|
387 {
|
|
|
388 ambiguous = 0;
|
|
|
389 potentialtok = legals[i].tok;
|
|
|
390 break; /* exact match */
|
|
|
391 }
|
|
|
392 if (potentialtok != ERRORTOK)
|
|
|
393 {
|
|
|
394 ambiguous = 1; /* this isn't the only match */
|
|
|
395 return ERRORTOK;
|
|
|
396 }
|
|
|
397 potentialtok = legals[i].tok;
|
|
|
398 }
|
|
|
399 }
|
|
|
400
|
|
|
401 return potentialtok;
|
|
|
402 }
|
|
|
403
|
|
|
404 int
|
|
|
405 match_token(cmd, token, after)
|
|
|
406 char *cmd;
|
|
|
407 char *token;
|
|
|
408 char **after;
|
|
|
409 {
|
|
|
410 struct control_cmd legals[2];
|
|
|
411 legals[0].literal = token;
|
|
|
412 legals[0].tok = HELPTOK; /* pick any token but ERRORTOK */
|
|
|
413 legals[1].literal = 0;
|
|
|
414 return HELPTOK == next_token(cmd, legals, after);
|
|
|
415 }
|
|
|
416
|
|
|
417 /*
|
|
|
418 * Get a player slot number. Returns -1 on failure, slot number on success.
|
|
|
419 * Slot number is guaranteed to be <MAXPLAYER.
|
|
|
420 */
|
|
|
421
|
|
|
422 int
|
|
|
423 get_slotnum(cmd, after)
|
|
|
424 char *cmd;
|
|
|
425 char **after;
|
|
|
426 {
|
|
|
427 int rval;
|
|
|
428 while (*cmd && isspace(*cmd))
|
|
|
429 cmd++;
|
|
|
430
|
|
|
431 if (!*cmd)
|
|
|
432 return -1; /* no token */
|
|
|
433
|
|
|
434 if (cmd[1] && !isspace(cmd[1]))
|
|
|
435 return -1; /* token too long */
|
|
|
436
|
|
|
437 if (*cmd >= '0' && *cmd <= '9')
|
|
|
438 rval = *cmd - '0';
|
|
|
439 else if (*cmd >= 'a' && *cmd <= 'z')
|
|
|
440 rval = *cmd - 'a' + 10;
|
|
|
441 else if (*cmd >= 'A' && *cmd <= 'Z')
|
|
|
442 rval = *cmd - 'A' + 10;
|
|
|
443 else
|
|
|
444 return -1;
|
|
|
445
|
|
|
446 if (rval >= MAXPLAYER)
|
|
|
447 return -1; /* there aren't that many players */
|
|
|
448
|
|
|
449 if (after)
|
|
|
450 {
|
|
|
451 /* scan to next token */
|
|
|
452 cmd++;
|
|
|
453 while (*cmd && isspace(*cmd))
|
|
|
454 cmd++;
|
|
|
455 *after = cmd;
|
|
|
456 }
|
|
|
457
|
|
|
458 return rval;
|
|
|
459 }
|
|
|
460
|
|
|
461 void
|
|
|
462 bad_slotnum(msg)
|
|
|
463 char *msg;
|
|
|
464 {
|
|
|
465 char buf[256];
|
|
|
466 sprintf(buf, "`%s' requires player slot number", msg);
|
|
|
467 respond(buf, 1);
|
|
|
468 }
|
|
|
469
|
|
|
470
|
|
|
471 /*
|
|
|
472 * Get a single token. Returns 0 on failure, 1 on success. Token is returned
|
|
|
473 * in dst.
|
|
|
474 */
|
|
|
475
|
|
|
476 int
|
|
|
477 get_one_token(cmd, dst, dstsize, after)
|
|
|
478 char *cmd;
|
|
|
479 char *dst; /* destination */
|
|
|
480 int dstsize;
|
|
|
481 char **after;
|
|
|
482 {
|
|
|
483 while (*cmd && isspace(*cmd))
|
|
|
484 cmd++;
|
|
|
485
|
|
|
486 if (!*cmd)
|
|
|
487 return 0; /* no token */
|
|
|
488
|
|
|
489 while (dstsize > 1 && *cmd && !isspace(*cmd))
|
|
|
490 {
|
|
|
491 *(dst++) = *(cmd++);
|
|
|
492 dstsize--;
|
|
|
493 }
|
|
|
494 *dst = 0;
|
|
|
495
|
|
|
496 if (after)
|
|
|
497 {
|
|
|
498 /* scan to next token */
|
|
|
499 while (*cmd && isspace(*cmd))
|
|
|
500 cmd++;
|
|
|
501 *after = cmd;
|
|
|
502 }
|
|
|
503
|
|
|
504 return 1;
|
|
|
505 }
|
|
|
506
|
|
|
507 /*
|
|
|
508 * Get an integer Integer is returned in dst. Returns 0 on failure without
|
|
|
509 * modifying dst.
|
|
|
510 */
|
|
|
511
|
|
|
512 int
|
|
|
513 get_int(cmd, dst, after)
|
|
|
514 char *cmd;
|
|
|
515 int *dst;
|
|
|
516 char **after;
|
|
|
517 {
|
|
|
518 int rval, offset;
|
|
|
519
|
|
|
520 if (1 != sscanf(cmd, " %i%n", &rval, &offset))
|
|
|
521 return 0;
|
|
|
522
|
|
|
523 cmd += offset;
|
|
|
524 if (*cmd && !isspace(*cmd))
|
|
|
525 return 0; /* token wasn't all digits */
|
|
|
526
|
|
|
527 *dst = rval;
|
|
|
528
|
|
|
529 if (after)
|
|
|
530 {
|
|
|
531 /* scan to next token */
|
|
|
532 while (*cmd && isspace(*cmd))
|
|
|
533 cmd++;
|
|
|
534 *after = cmd;
|
|
|
535 }
|
|
|
536
|
|
|
537 return 1;
|
|
|
538 }
|
|
|
539
|
|
|
540 /*
|
|
|
541 * Get a double Double is returned in dst. Returns 0 on failure without
|
|
|
542 * modifying dst.
|
|
|
543 */
|
|
|
544
|
|
|
545 int
|
|
|
546 get_double(cmd, dst, after)
|
|
|
547 char *cmd;
|
|
|
548 double *dst;
|
|
|
549 char **after;
|
|
|
550 {
|
|
|
551 double rval;
|
|
|
552 int offset;
|
|
|
553
|
|
|
554 if (1 != sscanf(cmd, " %lg%n", &rval, &offset))
|
|
|
555 return 0;
|
|
|
556
|
|
|
557 cmd += offset;
|
|
|
558 if (*cmd && !isspace(*cmd))
|
|
|
559 return 0; /* token wasn't all digits */
|
|
|
560
|
|
|
561 *dst = rval;
|
|
|
562
|
|
|
563 if (after)
|
|
|
564 {
|
|
|
565 /* scan to next token */
|
|
|
566 while (*cmd && isspace(*cmd))
|
|
|
567 cmd++;
|
|
|
568 *after = cmd;
|
|
|
569 }
|
|
|
570
|
|
|
571 return 1;
|
|
|
572 }
|
|
|
573
|
|
|
574 int
|
|
|
575 get_teamid(cmd, team, after)
|
|
|
576 char *cmd;
|
|
|
577 int *team;
|
|
|
578 char **after;
|
|
|
579 {
|
|
|
580 int i, j;
|
|
|
581
|
|
|
582 while (*cmd && isspace(*cmd))
|
|
|
583 {
|
|
|
584 cmd++;
|
|
|
585 }
|
|
|
586 if (cmd[3] && !isspace(cmd[3]))
|
|
|
587 return 0; /* too long */
|
|
|
588
|
|
|
589 *team = NOBODY;
|
|
|
590
|
|
|
591 for (i = -1; i < NUMTEAM; i++)
|
|
|
592 {
|
|
|
593 j = idx_to_mask(i);
|
|
|
594 if (0 == strncasecmp(cmd, teams[j].shortname, 3))
|
|
|
595 {
|
|
|
596 *team = i;
|
|
|
597 cmd += 3;
|
|
|
598 break;
|
|
|
599 }
|
|
|
600 }
|
|
|
601
|
|
|
602 if (after)
|
|
|
603 {
|
|
|
604 /* scan to next token */
|
|
|
605 while (*cmd && isspace(*cmd))
|
|
|
606 cmd++;
|
|
|
607 *after = cmd;
|
|
|
608 }
|
|
|
609
|
|
|
610 return i < NUMTEAM;
|
|
|
611 }
|
|
|
612
|
|
|
613 int
|
|
|
614 get_shipid(cmd, shipn, after)
|
|
|
615 char *cmd;
|
|
|
616 int *shipn;
|
|
|
617 char **after;
|
|
|
618 {
|
|
|
619 int i;
|
|
|
620
|
|
|
621 while (*cmd && isspace(*cmd))
|
|
|
622 {
|
|
|
623 cmd++;
|
|
|
624 }
|
|
|
625 *shipn = -1;
|
|
|
626
|
|
|
627 for (i = 0; i < NUM_TYPES; i++)
|
|
|
628 {
|
|
|
629 struct ship *ship = &shipvals[i];
|
|
|
630 int len;
|
|
|
631 len = strlen(ship->s_name);
|
|
|
632 if (0 == strncasecmp(cmd, ship->s_name, len) &&
|
|
|
633 (cmd[len] == 0 || isspace(cmd[len])))
|
|
|
634 {
|
|
|
635 *shipn = i;
|
|
|
636 cmd += len;
|
|
|
637 break;
|
|
|
638 }
|
|
|
639 else if (tolower(cmd[0]) == tolower(ship->s_desig1) &&
|
|
|
640 tolower(cmd[1]) == tolower(ship->s_desig2) &&
|
|
|
641 (cmd[2] == 0 || isspace(cmd[2])))
|
|
|
642 {
|
|
|
643 *shipn = i;
|
|
|
644 cmd += 2;
|
|
|
645 break;
|
|
|
646 }
|
|
|
647 }
|
|
|
648
|
|
|
649 if (after)
|
|
|
650 {
|
|
|
651 /* scan to next token */
|
|
|
652 while (*cmd && isspace(*cmd))
|
|
|
653 cmd++;
|
|
|
654 *after = cmd;
|
|
|
655 }
|
|
|
656
|
|
|
657 return i < NUM_TYPES;
|
|
|
658 }
|
|
|
659
|
|
|
660 /* writes a comma-separated list of help strings into the message window */
|
|
|
661
|
|
|
662 void
|
|
|
663 respond_with_help_string(legals)
|
|
|
664 struct control_cmd *legals;
|
|
|
665 {
|
|
|
666 int i;
|
|
|
667 char buf[65]; /* leave space for the message prefix */
|
|
|
668
|
|
|
669 strcpy(buf, "Available commands: ");
|
|
|
670 for (i = 0; legals[i].literal; i++)
|
|
|
671 {
|
|
|
672 if (!(legals[i].doc && legals[i].doc[0]))
|
|
|
673 continue;
|
|
|
674 if (strlen(buf) + 3 + strlen(legals[i].doc) > sizeof(buf))
|
|
|
675 {
|
|
|
676 respond(buf, 0);
|
|
|
677 strcpy(buf, " ");
|
|
|
678 if (!buf[0])
|
|
|
679 { /* one of the help strings was just too long */
|
|
|
680 respond("ACK! programmer error: help string too long", 0);
|
|
|
681 return;
|
|
|
682 }
|
|
|
683 i--; /* retry */
|
|
|
684 continue;
|
|
|
685 }
|
|
|
686 strcat(buf, legals[i].doc);
|
|
|
687 if (legals[i + 1].literal)
|
|
|
688 strcat(buf, ", ");
|
|
|
689 }
|
|
|
690 if (buf[0])
|
|
|
691 respond(buf, 0);
|
|
|
692 }
|
|
|
693
|
|
|
694 /**********************************************************************/
|
|
|
695
|
|
|
696 static void
|
|
|
697 respond(msg, type)
|
|
|
698 char *msg;
|
|
|
699 int type;
|
|
|
700 {
|
|
|
701 if (type == 1)
|
|
|
702 warning(msg);
|
|
|
703 else
|
|
|
704 pmessage2(msg, me->p_no, MINDIV, MCONTROL, 255);
|
|
|
705 }
|
|
|
706
|
|
|
707 #ifdef GOD_CONTROLS
|
|
|
708
|
|
|
709 /*
|
|
|
710 * Here we handle the controls on players. If you add something, make sure
|
|
|
711 * you place it in the help. Thanks, have a nice day.
|
|
|
712 */
|
|
|
713
|
|
|
714 static int
|
|
|
715 parse_control_player(cmd)
|
|
|
716 char *cmd;
|
|
|
717 {
|
|
|
718 char buf[120];
|
|
|
719 int pnum;
|
|
|
720 struct player *victim;
|
|
|
721 int godliness = me->p_stats.st_royal - GODLIKE + 1;
|
|
|
722 char *arg;
|
|
|
723 static struct control_cmd available_cmds[] = {
|
|
|
724 {"help", HELPTOK, 0},
|
|
|
725 {"die", DIETOK, "die"},
|
|
|
726 {"eject", EJECTTOK, "eject"},
|
|
|
727 {"armies", ARMIESTOK, "armies [%d=5]"},
|
|
|
728 {"plasma", PLASMATOK, "plasma [%d]"},
|
|
|
729 {"missiles", MISSILETOK, "missiles [%d=max]"},
|
|
|
730 {"team", TEAMTOK, "team <teamstr>"},
|
|
|
731 {"ship", SHIPTOK, "ship <shiptype>"},
|
|
|
732 {"rank", RANKTOK, "rank (+|-|%d)"},
|
|
|
733 {"royal", ROYALTOK, "royal (+|-|%d)"},
|
|
|
734 {"kills", KILLSTOK, "kills (+|-|%d)"},
|
|
|
735 {"hose", HOSETOK, "hose"},
|
|
|
736 {"move", MOVETOK, "move %d %d"},
|
|
|
737 {0}
|
|
|
738 };
|
|
|
739
|
|
|
740 pnum = get_slotnum(cmd, &cmd);
|
|
|
741 if (pnum < 0)
|
|
|
742 {
|
|
|
743 bad_slotnum("control player");
|
|
|
744 return 0;
|
|
|
745 }
|
|
|
746 victim = &players[pnum];
|
|
|
747
|
|
|
748 if (victim->p_status == PFREE)
|
|
|
749 {
|
|
|
750 respond("Slot is not alive.", 1);
|
|
|
751 return 1;
|
|
|
752 }
|
|
|
753
|
|
|
754 /*
|
|
|
755 * These would probably work better as pointers to functions instead of a
|
|
|
756 * giant switch, but what the hell, I'm lazy. Maybe I'll change it later.
|
|
|
757 */
|
|
|
758
|
|
|
759 switch (next_token(cmd, available_cmds, &arg))
|
|
|
760 {
|
|
|
761 case DIETOK:
|
|
|
762 victim->p_ship.s_type = STARBASE;
|
|
|
763 victim->p_whydead = KPROVIDENCE;
|
|
|
764 victim->p_explode = 10;
|
|
|
765 victim->p_status = PEXPLODE;
|
|
|
766 victim->p_whodead = 0;
|
|
|
767 if (!god_silent)
|
|
|
768 {
|
|
|
769 sprintf(buf, "%s (%2s) was utterly obliterated by %s (%2s).",
|
|
|
770 victim->p_name, twoletters(victim),
|
|
|
771 me->p_name, twoletters(me));
|
|
|
772 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
773 }
|
|
|
774 return 1;
|
|
|
775
|
|
|
776 case EJECTTOK:
|
|
|
777 victim->p_ship.s_type = STARBASE;
|
|
|
778 victim->p_whydead = KQUIT;
|
|
|
779 victim->p_explode = 10;
|
|
|
780 victim->p_status = PEXPLODE;
|
|
|
781 victim->p_whodead = 0;
|
|
|
782 if (!god_silent)
|
|
|
783 {
|
|
|
784 sprintf(buf,
|
|
|
785 "%s (%2s) has been ejected from the game by %s (%2s).",
|
|
|
786 victim->p_name, twoletters(victim),
|
|
|
787 me->p_name, twoletters(me));
|
|
|
788 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
789 }
|
|
|
790 return 1;
|
|
|
791
|
|
|
792 case ARMIESTOK:
|
|
|
793 {
|
|
|
794 int armies = 5;
|
|
|
795 if (*arg && !get_int(arg, &armies, (char **) 0))
|
|
|
796 {
|
|
|
797 respond("optional arg to `control player <slotnum> armies` must be integer", 0);
|
|
|
798 return 0;
|
|
|
799 }
|
|
|
800 victim->p_armies += armies;
|
|
|
801 if (!god_silent)
|
|
|
802 {
|
|
|
803 sprintf(buf, "%s (%2s) has been given %d armies by %s (%2s).",
|
|
|
804 victim->p_name, twoletters(victim), armies,
|
|
|
805 me->p_name, twoletters(me));
|
|
|
806 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
807 }
|
|
|
808 return 1;
|
|
|
809 }
|
|
|
810
|
|
|
811 case PLASMATOK:
|
|
|
812 {
|
|
|
813 int yes = 1;
|
|
|
814 if (*arg && !get_int(arg, &yes, (char **) 0))
|
|
|
815 {
|
|
|
816 respond("optional arg to `control player <slotnum> plasma` must be integer", 0);
|
|
|
817 return 0;
|
|
|
818 }
|
|
|
819
|
|
|
820 if (yes)
|
|
|
821 victim->p_ship.s_nflags |= SFNPLASMAARMED;
|
|
|
822 else
|
|
|
823 victim->p_ship.s_nflags &= ~SFNPLASMAARMED;
|
|
|
824
|
|
|
825 if (!god_silent)
|
|
|
826 {
|
|
|
827 sprintf(buf, "%s (%2s) has been %s plasma torps by %s (%2s).",
|
|
|
828 victim->p_name, twoletters(victim),
|
|
|
829 yes ? "given" : "denied",
|
|
|
830 me->p_name, twoletters(me));
|
|
|
831 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
832 }
|
|
|
833 return 1;
|
|
|
834 }
|
|
|
835
|
|
|
836 case MISSILETOK:
|
|
|
837 {
|
|
|
838 int yes = shipvals[victim->p_ship.s_type].s_missilestored;
|
|
|
839
|
|
|
840 if (*arg && !get_int(arg, &yes, (char **) 0))
|
|
|
841 {
|
|
|
842 respond("optional arg to `control player <slotnum> missile` must be integer", 0);
|
|
|
843 return 0;
|
|
|
844 }
|
|
|
845
|
|
|
846 if (yes)
|
|
|
847 {
|
|
|
848 victim->p_ship.s_nflags |= SFNHASMISSILE;
|
|
|
849 victim->p_ship.s_missilestored = yes;
|
|
|
850 }
|
|
|
851 else
|
|
|
852 {
|
|
|
853 victim->p_ship.s_nflags &= ~SFNHASMISSILE;
|
|
|
854 }
|
|
|
855
|
|
|
856 if (!god_silent)
|
|
|
857 {
|
|
|
858 sprintf(buf, "%s (%2s) has been %s %d missiles by %s (%2s).",
|
|
|
859 victim->p_name, twoletters(victim),
|
|
|
860 yes ? "given" : "denied",
|
|
|
861 yes, me->p_name, twoletters(me));
|
|
|
862 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
863 }
|
|
|
864 return 1;
|
|
|
865 }
|
|
|
866
|
|
|
867 case TEAMTOK:
|
|
|
868 {
|
|
|
869 int team;
|
|
|
870
|
|
|
871 if (!get_teamid(arg, &team, (char **) 0))
|
|
|
872 {
|
|
|
873 respond("available teams: FED ORI ROM KLI IND", 0);
|
|
|
874 return 0;
|
|
|
875 }
|
|
|
876 team = idx_to_mask(team);
|
|
|
877
|
|
|
878 victim->p_hostile |= victim->p_team;
|
|
|
879 victim->p_team = team;
|
|
|
880 victim->p_hostile &= ~team;
|
|
|
881 victim->p_swar &= ~team;
|
|
|
882 sprintf(buf, "%s (%2s) has been changed to a %s by %s (%2s).",
|
|
|
883 victim->p_name, twoletters(victim), teams[team].nickname,
|
|
|
884 me->p_name, twoletters(me));
|
|
|
885 if (!god_silent)
|
|
|
886 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
887 return 1;
|
|
|
888 }
|
|
|
889
|
|
|
890 case SHIPTOK:
|
|
|
891 {
|
|
|
892 int ship;
|
|
|
893 if (!get_shipid(arg, &ship, (char **) 0))
|
|
|
894 {
|
|
|
895 respond("available ships: SC DD CA AS BB SB AT JS FR WB CL CV SUPER", 0);
|
|
|
896 return 0;
|
|
|
897 }
|
|
|
898 #if 0
|
|
|
899 if (tokstring[4] == SUPERTOK)
|
|
|
900 {
|
|
|
901 victim->p_ship.s_maxshield = 750;
|
|
|
902 victim->p_shield = 750;
|
|
|
903 victim->p_ship.s_maxdamage = 750;
|
|
|
904 victim->p_ship.s_maxegntemp = 5000;
|
|
|
905 sprintf(buf, "%s (%2s) has been supercharged by %s (%2s).",
|
|
|
906 victim->p_name, twoletters(victim),
|
|
|
907 me->p_name, twoletters(me));
|
|
|
908 if (!god_silent)
|
|
|
909 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
910 return 1;
|
|
|
911 }
|
|
|
912 #endif
|
|
|
913 /* If others are docked, then kick them off */
|
|
|
914 if (allows_docking(victim->p_ship))
|
|
|
915 {
|
|
|
916 int i;
|
|
|
917 for (i = 0; i < victim->p_ship.s_numports; i++)
|
|
|
918 {
|
|
|
919 base_undock(victim, i);
|
|
|
920 }
|
|
|
921 }
|
|
|
922 get_ship_for_player(victim, ship);
|
|
|
923 switch_special_weapon();
|
|
|
924 victim->p_flags &= ~PFENG;
|
|
|
925 sprintf(buf, "%s (%2s) has been changed to a %c%c by %s (%2s).",
|
|
|
926 victim->p_name, twoletters(victim),
|
|
|
927 victim->p_ship.s_desig1, victim->p_ship.s_desig2,
|
|
|
928 me->p_name, twoletters(me));
|
|
|
929 if (!god_silent)
|
|
|
930 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
931 return 1;
|
|
|
932 }
|
|
|
933
|
|
|
934 case RANKTOK:
|
|
|
935 {
|
|
|
936 int rank = victim->p_stats.st_rank;
|
|
|
937
|
|
|
938 if (match_token(arg, "+", (char **) 0))
|
|
|
939 rank++;
|
|
|
940 else if (match_token(arg, "-", (char **) 0))
|
|
|
941 rank--;
|
|
|
942 else if (!get_int(arg, &rank, (char **) 0))
|
|
|
943 {
|
|
|
944 respond("Try: control player %d rank [%d]+-", 0);
|
|
|
945 return 0;
|
|
|
946 }
|
|
|
947
|
|
|
948 if (rank < 0)
|
|
|
949 rank = 0;
|
|
|
950 if (rank >= NUMRANKS)
|
|
|
951 rank = NUMRANKS - 1;
|
|
|
952
|
|
|
953 victim->p_stats.st_rank = rank;
|
|
|
954 sprintf(buf, "%s (%2s) has been given a rank of %s by %s (%2s).",
|
|
|
955 victim->p_name, twoletters(victim),
|
|
|
956 ranks[victim->p_stats.st_rank].name,
|
|
|
957 me->p_name, twoletters(me));
|
|
|
958 if (!god_silent)
|
|
|
959 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
960 return 1;
|
|
|
961 }
|
|
|
962
|
|
|
963 case ROYALTOK:
|
|
|
964 {
|
|
|
965 int rank = victim->p_stats.st_royal;
|
|
|
966
|
|
|
967 if (match_token(arg, "+", (char **) 0))
|
|
|
968 rank++;
|
|
|
969 else if (match_token(arg, "-", (char **) 0))
|
|
|
970 rank--;
|
|
|
971 else if (!get_int(arg, &rank, (char **) 0))
|
|
|
972 {
|
|
|
973 respond("Try: control player %d royal [%d]+-", 0);
|
|
|
974 return 0;
|
|
|
975 }
|
|
|
976
|
|
|
977 if (rank < 0)
|
|
|
978 rank = 0;
|
|
|
979 if (rank >= NUMROYALRANKS)
|
|
|
980 rank = NUMROYALRANKS - 1;
|
|
|
981
|
|
|
982 if (rank >= GODLIKE && godliness < 2)
|
|
|
983 {
|
|
|
984 respond("You aren't powerful enough to grant godlike royalty.",
|
|
|
985 1);
|
|
|
986 return 1;
|
|
|
987 }
|
|
|
988 victim->p_stats.st_royal = rank;
|
|
|
989 sprintf(buf, "%s (%2s) has been given a rank of %s by %s (%2s).",
|
|
|
990 victim->p_name, twoletters(victim),
|
|
|
991 royal[victim->p_stats.st_royal].name,
|
|
|
992 me->p_name, twoletters(me));
|
|
|
993 if (!god_silent)
|
|
|
994 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
995 return 1;
|
|
|
996 }
|
|
|
997
|
|
|
998 case KILLSTOK:
|
|
|
999 {
|
|
|
1000 double kills = victim->p_kills;
|
|
|
1001
|
|
|
1002 if (match_token(arg, "+", (char **) 0))
|
|
|
1003 kills += 1;
|
|
|
1004 else if (match_token(arg, "-", (char **) 0))
|
|
|
1005 {
|
|
|
1006 kills -= 1;
|
|
|
1007 if (kills < 0)
|
|
|
1008 kills = 0;
|
|
|
1009 }
|
|
|
1010 else if (!get_double(arg, &kills, (char **) 0))
|
|
|
1011 {
|
|
|
1012 respond("Try: control player %d kills [%f]+-", 0);
|
|
|
1013 return 0;
|
|
|
1014 }
|
|
|
1015
|
|
|
1016 victim->p_kills = kills;
|
|
|
1017 sprintf(buf, "%s (%2s) has been given %f kills by %s (%2s).",
|
|
|
1018 victim->p_name, twoletters(victim),
|
|
|
1019 kills, me->p_name, twoletters(me));
|
|
|
1020 if (!god_silent)
|
|
|
1021 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
1022 return 1;
|
|
|
1023 }
|
|
|
1024
|
|
|
1025 case HOSETOK:
|
|
|
1026 victim->p_shield = 0;
|
|
|
1027 victim->p_damage = victim->p_ship.s_maxdamage / 2;
|
|
|
1028 sprintf(buf, "%s (%2s) has been hosed by %s (%2s).",
|
|
|
1029 victim->p_name, twoletters(victim),
|
|
|
1030 me->p_name, twoletters(me));
|
|
|
1031 if (!god_silent)
|
|
|
1032 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
1033 return 1;
|
|
|
1034
|
|
|
1035 case MOVETOK:
|
|
|
1036 {
|
|
|
1037 int x, y;
|
|
|
1038 char *s;
|
|
|
1039 if (!(get_int(arg, &x, &s) && get_int(s, &y, (char **) 0)))
|
|
|
1040 {
|
|
|
1041 respond("Try: control player %d move %d %d", 0);
|
|
|
1042 return 0;
|
|
|
1043 }
|
|
|
1044
|
|
|
1045 if (x <= 0 || y <= 0 || x >= 200000 || y >= 200000)
|
|
|
1046 {
|
|
|
1047 respond("You want to move him where?", 0);
|
|
|
1048 return 0;
|
|
|
1049 }
|
|
|
1050 victim->p_x = x;
|
|
|
1051 victim->p_y = y;
|
|
|
1052 sprintf(buf, "%s (%2s) has been moved to %d %d by %s (%2s).",
|
|
|
1053 victim->p_name, twoletters(victim),
|
|
|
1054 x, y,
|
|
|
1055 me->p_name, twoletters(me));
|
|
|
1056 if (!god_silent)
|
|
|
1057 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
1058 return 1;
|
|
|
1059 }
|
|
|
1060
|
|
|
1061 case HELPTOK: /* fall through */
|
|
|
1062 default:
|
|
|
1063 #if 1
|
|
|
1064 respond_with_help_string(available_cmds);
|
|
|
1065 #else
|
|
|
1066 respond("player controls: die, eject, armies [%d], plasma [%d],", 0);
|
|
|
1067 respond("player controls: missile [%d], team [team], ship [ship],", 0);
|
|
|
1068 respond("player controls: rank [%d]+-, royal [%d]+-, kills [%d]+-", 0);
|
|
|
1069 respond("player controls: hose, move %d %d", 0);
|
|
|
1070 #endif
|
|
|
1071 return 0;
|
|
|
1072 }
|
|
|
1073 }
|
|
|
1074
|
|
|
1075 static int
|
|
|
1076 parse_control(str)
|
|
|
1077 char *str;
|
|
|
1078 {
|
|
|
1079 char buf[120];
|
|
|
1080 struct player *victim;
|
|
|
1081 int i;
|
|
|
1082 int godliness = me->p_stats.st_royal - GODLIKE + 1;
|
|
|
1083
|
|
|
1084 static struct control_cmd available_cmds[] = {
|
|
|
1085 {"help", HELPTOK, 0},
|
|
|
1086 {"freeslot", FREESLOTTOK, "freeslot %p"},
|
|
|
1087 {"player", PLAYERTOK, "player ..."},
|
|
|
1088 {"robot", ROBOTTOK, "robot [args]"},
|
|
|
1089 {"quiet", QUIETTOK, "quiet"},
|
|
|
1090 {"nukegame", NUKEGAMETOK, "nukegame"},
|
|
|
1091 {"restart", RESTARTTOK, "restart"},
|
|
|
1092 {"galaxy", NEWGALAXY, "galaxy"},
|
|
|
1093 {"shiptimer", SHIPTIMERTOK, "shiptimer (teamstr|shipstr)*"},
|
|
|
1094 {"allow", ALLOWTOK, "allow [teams]"},
|
|
|
1095 {0}
|
|
|
1096 };
|
|
|
1097 char *nexttoken;
|
|
|
1098
|
|
|
1099 if (godliness <= 0)
|
|
|
1100 {
|
|
|
1101 #if 0
|
|
|
1102 respond("Those commands are only available to server gods");
|
|
|
1103 #endif
|
|
|
1104 return 0; /* "fail" silently. Don't advertise divine
|
|
|
1105 * powers to peasants. */
|
|
|
1106 }
|
|
|
1107
|
|
|
1108
|
|
|
1109 switch (next_token(str, available_cmds, &nexttoken))
|
|
|
1110 {
|
|
|
1111 case FREESLOTTOK:
|
|
|
1112 {
|
|
|
1113 int slot = get_slotnum(nexttoken, (char **) 0);
|
|
|
1114 if (slot < 0)
|
|
|
1115 {
|
|
|
1116 respond("\"control freeslot\" requires slot number.", 0);
|
|
|
1117 return 1;
|
|
|
1118 }
|
|
|
1119 victim = &players[slot];
|
|
|
1120 if (victim->p_ntspid)
|
|
|
1121 kill(victim->p_ntspid, SIGHUP);
|
|
|
1122
|
|
|
1123 victim->p_status = PFREE;
|
|
|
1124 victim->p_ntspid = 0;
|
|
|
1125
|
|
|
1126 if (!god_silent)
|
|
|
1127 {
|
|
|
1128 sprintf(buf, "Player slot %s has been freed by %s (%2s).",
|
|
|
1129 nexttoken, me->p_name, twoletters(me));
|
|
|
1130 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
1131 }
|
|
|
1132 }
|
|
|
1133 return 1;
|
|
|
1134
|
|
|
1135 case ALLOWTOK:
|
|
|
1136 {
|
|
|
1137 int newlock = 0;
|
|
|
1138 int team;
|
|
|
1139 char *s;
|
|
|
1140 if (0 == *nexttoken)
|
|
|
1141 {
|
|
|
1142 newlock = ALLTEAM;
|
|
|
1143 }
|
|
|
1144 else
|
|
|
1145 {
|
|
|
1146 for (s = nexttoken; get_teamid(s, &team, &s);)
|
|
|
1147 {
|
|
|
1148 newlock |= idx_to_mask(team);
|
|
|
1149 }
|
|
|
1150 if (*s)
|
|
|
1151 {
|
|
|
1152 respond("Usage: control allow [fed] [rom] [kli] [ori]", 0);
|
|
|
1153 return 1;
|
|
|
1154 }
|
|
|
1155 }
|
|
|
1156
|
|
|
1157 status2->nontteamlock = newlock;
|
|
|
1158 strcpy(buf, "Allowed teams now set to:");
|
|
|
1159 if (status2->nontteamlock == ALLTEAM)
|
|
|
1160 {
|
|
|
1161 strcat(buf, " <all teams>");
|
|
|
1162 }
|
|
|
1163 else
|
|
|
1164 {
|
|
|
1165 if (status2->nontteamlock & FED)
|
|
|
1166 strcat(buf, " fed");
|
|
|
1167 if (status2->nontteamlock & ROM)
|
|
|
1168 strcat(buf, " rom");
|
|
|
1169 if (status2->nontteamlock & KLI)
|
|
|
1170 strcat(buf, " kli");
|
|
|
1171 if (status2->nontteamlock & ORI)
|
|
|
1172 strcat(buf, " ori");
|
|
|
1173 }
|
|
|
1174 respond(buf, 0);
|
|
|
1175 }
|
|
|
1176 return 1;
|
|
|
1177 case PLAYERTOK:
|
|
|
1178 return parse_control_player(nexttoken);
|
|
|
1179
|
|
|
1180 case ROBOTTOK:
|
|
|
1181 {
|
|
|
1182 int pid;
|
|
|
1183 char *s;
|
|
|
1184
|
|
|
1185 pid = fork();
|
|
|
1186 if (pid == 0)
|
|
|
1187 {
|
|
|
1188 char *argv[40];
|
|
|
1189 argv[0] = build_path(ROBOT);
|
|
|
1190
|
|
|
1191 s = nexttoken;
|
|
|
1192 for (i = 1; 1; i++)
|
|
|
1193 {
|
|
|
1194 int size = 80;
|
|
|
1195 argv[i] = malloc(size);
|
|
|
1196 if (!get_one_token(s, argv[i], size, &s))
|
|
|
1197 break;
|
|
|
1198 realloc(argv[i], strlen(argv[i]) + 1);
|
|
|
1199 }
|
|
|
1200 free(argv[i]);
|
|
|
1201 argv[i] = 0;
|
|
|
1202
|
|
|
1203 execvp(argv[0], argv);
|
|
|
1204 fprintf(stderr, "Ack! Unable to exec %s\n", argv[0]);
|
|
|
1205 exit(1);
|
|
|
1206 }
|
|
|
1207 else if (pid < 0)
|
|
|
1208 {
|
|
|
1209 respond("Unable to fork robot", 0);
|
|
|
1210 }
|
|
|
1211 else
|
|
|
1212 {
|
|
|
1213 sprintf(buf, "Robot forked (pid %d) with arguments %s",
|
|
|
1214 pid, nexttoken);
|
|
|
1215 respond(buf, 1);
|
|
|
1216 }
|
|
|
1217 }
|
|
|
1218 return 1;
|
|
|
1219
|
|
|
1220 case QUIETTOK:
|
|
|
1221 if (godliness < 2)
|
|
|
1222 {
|
|
|
1223 respond("No sneaking allowed", 0);
|
|
|
1224 return 1;
|
|
|
1225 }
|
|
|
1226 sprintf(buf, "Switching to %s mode.", god_silent ? "loud" : "quiet");
|
|
|
1227 respond(buf, 0);
|
|
|
1228 god_silent = !god_silent;
|
|
|
1229 return 1;
|
|
|
1230 case NUKEGAMETOK:
|
|
|
1231 warning("Nuking game. Have a nice day.");
|
|
|
1232 if (!god_silent)
|
|
|
1233 {
|
|
|
1234 sprintf(buf, "The game has been nuked by %s (%2s).",
|
|
|
1235 me->p_name, twoletters(me));
|
|
|
1236 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
1237 }
|
|
|
1238 kill(status->nukegame, 15);
|
|
|
1239 return 1;
|
|
|
1240 case RESTARTTOK:
|
|
|
1241 warning("Attempting daemon restart.");
|
|
|
1242 startdaemon(
|
|
|
1243 #ifdef LEAGUE_SUPPORT
|
|
|
1244 status2->league
|
|
|
1245 #else
|
|
|
1246 0
|
|
|
1247 #endif
|
|
|
1248 ,1);
|
|
|
1249 return 1;
|
|
|
1250 case NEWGALAXY:
|
|
|
1251 explode_everyone(KPROVIDENCE, 0);
|
|
|
1252 if (!god_silent)
|
|
|
1253 {
|
|
|
1254 sprintf(buf, "The galaxy has been reset by %s (%2s).",
|
|
|
1255 me->p_name, twoletters(me));
|
|
|
1256 pmessage(buf, 0, MALL, MCONTROL);
|
|
|
1257 }
|
|
|
1258 status2->newgalaxy = 1;
|
|
|
1259 warning("Creating new galaxy");
|
|
|
1260 return 1;
|
|
|
1261 case SHIPTIMERTOK:
|
|
|
1262 {
|
|
|
1263 int teammask = 0;
|
|
|
1264 int shipmask = 0;
|
|
|
1265 int i, j;
|
|
|
1266 char *s = nexttoken;
|
|
|
1267 while (1)
|
|
|
1268 {
|
|
|
1269 if (get_shipid(s, &j, &s))
|
|
|
1270 shipmask |= 1 << j;
|
|
|
1271 else if (get_teamid(s, &j, &s))
|
|
|
1272 teammask |= idx_to_mask(j);
|
|
|
1273 else if (*s)
|
|
|
1274 {
|
|
|
1275 respond("Usage:", 0);
|
|
|
1276 respond("control shiptimers (fed|rom|kli|ori)* (sc|dd|ca|bb|as|sb|at|js|fr|wb)*", 0);
|
|
|
1277 respond(" resets the ship timers.", 0);
|
|
|
1278 return 0;
|
|
|
1279 }
|
|
|
1280 else
|
|
|
1281 break;
|
|
|
1282 }
|
|
|
1283 for (i = 0; i < NUMTEAM; i++)
|
|
|
1284 {
|
|
|
1285 int teammask = idx_to_mask(i);
|
|
|
1286 if (teammask && !(teammask & (1 << i)))
|
|
|
1287 continue;
|
|
|
1288
|
|
|
1289 for (j = 0; j < NUM_TYPES; j++)
|
|
|
1290 {
|
|
|
1291 if (shipmask && !(shipmask & (1 << j)))
|
|
|
1292 continue;
|
|
|
1293
|
|
|
1294 if (teams[teammask].s_turns[j])
|
|
|
1295 {
|
|
|
1296 sprintf(buf, "%s %s reset", teams[teammask].name, shipvals[j].s_name);
|
|
|
1297 respond(buf, 0);
|
|
|
1298 teams[teammask].s_turns[j] = 0;
|
|
|
1299 }
|
|
|
1300 }
|
|
|
1301 }
|
|
|
1302 }
|
|
|
1303 return 1;
|
|
|
1304 case HELPTOK: /* fall through */
|
|
|
1305 default:
|
|
|
1306 #if 1
|
|
|
1307 respond_with_help_string(available_cmds);
|
|
|
1308 #else
|
|
|
1309 respond("Available controls: player, quiet, nukegame, freeslot,", 0);
|
|
|
1310 respond(" galaxy, restart, shiptimer", 0);
|
|
|
1311 #endif
|
|
|
1312 return 0;
|
|
|
1313 }
|
|
|
1314 }
|
|
|
1315 #endif
|
|
|
1316
|
|
|
1317 /*
|
|
|
1318 */
|
|
|
1319
|
|
|
1320 static int
|
|
|
1321 parse_info(cmd)
|
|
|
1322 char *cmd;
|
|
|
1323 {
|
|
|
1324 char buf[120];
|
|
|
1325 char *nexttoken;
|
|
|
1326
|
|
|
1327 static struct control_cmd available_cmds[] = {
|
|
|
1328 {"help", HELPTOK, 0},
|
|
|
1329 {"shiptimer", SHIPTIMERTOK, "shiptimer (teamstr|shipstr)*"},
|
|
|
1330 {0}
|
|
|
1331 };
|
|
|
1332
|
|
|
1333 switch (next_token(cmd, available_cmds, &nexttoken))
|
|
|
1334 {
|
|
|
1335 case SHIPTIMERTOK:
|
|
|
1336 {
|
|
|
1337 int race = 0;
|
|
|
1338 int i, j;
|
|
|
1339 int anydead = 0;
|
|
|
1340 #if 0
|
|
|
1341 if (me->p_stats.st_royal < 2)
|
|
|
1342 race = me->p_team;
|
|
|
1343 #endif
|
|
|
1344 for (i = 0; i < NUMTEAM; i++)
|
|
|
1345 {
|
|
|
1346 int teammask = idx_to_mask(i);
|
|
|
1347 if (race && !(race & (1 << i)))
|
|
|
1348 continue;
|
|
|
1349 for (j = 0; j < NUM_TYPES; j++)
|
|
|
1350 {
|
|
|
1351 if (teams[teammask].s_turns[j])
|
|
|
1352 {
|
|
|
1353 sprintf(buf, "%s %s: %d minutes", teams[teammask].name,
|
|
|
1354 shipvals[j].s_name, teams[teammask].s_turns[j]);
|
|
|
1355 anydead = 1;
|
|
|
1356 respond(buf, 0);
|
|
|
1357 }
|
|
|
1358 }
|
|
|
1359 }
|
|
|
1360 if (!anydead)
|
|
|
1361 respond("All ships are available", 0);
|
|
|
1362 }
|
|
|
1363 return 1;
|
|
|
1364 case HELPTOK:
|
|
|
1365 default:
|
|
|
1366 respond("Available subcommands: shiptimer", 0);
|
|
|
1367 return 1;
|
|
|
1368 }
|
|
|
1369 }
|
|
|
1370
|
|
|
1371 #define crypt(a, b) (a)
|
|
|
1372
|
|
|
1373 static int
|
|
|
1374 parse_player(cmd)
|
|
|
1375 char *cmd;
|
|
|
1376 {
|
|
|
1377 static int passver = 0;
|
|
|
1378 char buf[80];
|
|
|
1379 #if 0
|
|
|
1380 static char newpass[16];
|
|
|
1381 #endif
|
|
|
1382 char *nexttoken;
|
|
|
1383
|
|
|
1384 static struct control_cmd available_cmds[] = {
|
|
|
1385 {"help", HELPTOK, 0},
|
|
|
1386 {"password", PASSWDTOK, "password %s"},
|
|
|
1387 {"passwd", PASSWDTOK, 0},
|
|
|
1388 {"ratings", RATINGSTOK, "ratings"},
|
|
|
1389 {"rank", RANKTOK, "rank"},
|
|
|
1390 {0}
|
|
|
1391 };
|
|
|
1392
|
|
|
1393 if (0 == *cmd)
|
|
|
1394 {
|
|
|
1395 if (passver)
|
|
|
1396 respond("Password change cancelled.", 0);
|
|
|
1397
|
|
|
1398 passver = 0;
|
|
|
1399 return 1;
|
|
|
1400 }
|
|
|
1401
|
|
|
1402 switch (next_token(cmd, available_cmds, &nexttoken))
|
|
|
1403 {
|
|
|
1404 case PASSWDTOK:
|
|
|
1405 {
|
|
|
1406 static char newpass[16];
|
|
|
1407 if (me->p_pos < 0)
|
|
|
1408 { /* guest login */
|
|
|
1409 respond("You don't have a password!", 0);
|
|
|
1410 }
|
|
|
1411 else if (*nexttoken == 0)
|
|
|
1412 {
|
|
|
1413 respond("\"player password\" requires new password as argument.", 0);
|
|
|
1414 respond(" example: \"player password lh4ern\"", 0);
|
|
|
1415 }
|
|
|
1416 else if (!passver)
|
|
|
1417 {
|
|
|
1418 strcpy(newpass, crypt(nexttoken, me->p_name));
|
|
|
1419 respond("Repeat \"player password\" command to verify new password.", 0);
|
|
|
1420 respond(" or send \"player\" (no arguments) to cancel.", 0);
|
|
|
1421 passver = 1;
|
|
|
1422 }
|
|
|
1423 else
|
|
|
1424 {
|
|
|
1425 char *paths;
|
|
|
1426 int fd;
|
|
|
1427 if (!strcmp(newpass, crypt(nexttoken, me->p_name)))
|
|
|
1428 {
|
|
|
1429
|
|
|
1430 /* perhaps it'd be better to put this part in */
|
|
|
1431 /* a different place */
|
|
|
1432 paths = build_path(PLAYERFILE);
|
|
|
1433 fd = open(paths, O_WRONLY, 0644);
|
|
|
1434 if (fd >= 0)
|
|
|
1435 {
|
|
|
1436 lseek(fd, 16 + me->p_pos * sizeof(struct statentry), 0);
|
|
|
1437 write(fd, newpass, 16);
|
|
|
1438 close(fd);
|
|
|
1439 respond("Password changed.", 0);
|
|
|
1440 }
|
|
|
1441 else
|
|
|
1442 {
|
|
|
1443 respond("open() of playerfile failed, password not changed.", 0);
|
|
|
1444 }
|
|
|
1445 }
|
|
|
1446 else
|
|
|
1447 respond("Passwords did not match, password unchanged.", 0);
|
|
|
1448 passver = 0;
|
|
|
1449 }
|
|
|
1450 }
|
|
|
1451 return 1;
|
|
|
1452 case RATINGSTOK: /* print your ratings */
|
|
|
1453 {
|
|
|
1454 struct rating r;
|
|
|
1455 compute_ratings(me, &r);
|
|
|
1456
|
|
|
1457 sprintf(buf, "Bomb:%5.2f Plnts:%5.2f Rsrcs:%5.2f Dshs:%5.2f Offns:%5.2f", r.bombrat, r.planetrat, r.resrat, r.dooshrat, r.offrat);
|
|
|
1458 respond(buf, 0);
|
|
|
1459
|
|
|
1460 sprintf(buf, " JS:%5.2f SB:%5.2f WB:%5.2f Ratio:%5.2f", r.jsrat, r.sbrat, r.wbrat, r.ratio);
|
|
|
1461 respond(buf, 0);
|
|
|
1462
|
|
|
1463 sprintf(buf, "Overall Ratings: Battle:%5.2f Strat:%5.2f Spec. Ship:%5.2f", r.battle, r.strategy, r.special);
|
|
|
1464 respond(buf, 0);
|
|
|
1465 }
|
|
|
1466 return 1;
|
|
|
1467
|
|
|
1468 case RANKTOK: /* print the requirements for the next rank */
|
|
|
1469 {
|
|
|
1470 int rank;
|
|
|
1471 rank = me->p_stats.st_rank;
|
|
|
1472 strcpy(buf, "Your current rank is ");
|
|
|
1473 strcat(buf, ranks[rank].name);
|
|
|
1474 respond(buf, 0);
|
|
|
1475 if (rank == NUMRANKS - 1)
|
|
|
1476 return 1;
|
|
|
1477
|
|
|
1478 sprintf(buf, "To make the next rank (%s) you need:",
|
|
|
1479 ranks[rank + 1].name);
|
|
|
1480 respond(buf, 0);
|
|
|
1481
|
|
|
1482 sprintf(buf, " Genocides: %d DI: %.2f Battle: %.2f",
|
|
|
1483 ranks[rank + 1].genocides, ranks[rank + 1].di,
|
|
|
1484 ranks[rank + 1].battle);
|
|
|
1485 respond(buf, 0);
|
|
|
1486
|
|
|
1487 sprintf(buf, " Strategy: %.2f Spec. Ships: %.2f",
|
|
|
1488 ranks[rank + 1].strategy, ranks[rank + 1].specship);
|
|
|
1489 respond(buf, 0);
|
|
|
1490 }
|
|
|
1491 return 1;
|
|
|
1492
|
|
|
1493 case HELPTOK:
|
|
|
1494 default:
|
|
|
1495 respond_with_help_string(available_cmds);
|
|
|
1496 return 1;
|
|
|
1497 }
|
|
|
1498 }
|
|
|
1499
|
|
|
1500 /*
|
|
|
1501 */
|
|
|
1502
|
|
|
1503 #ifdef LEAGUE_SUPPORT
|
|
|
1504
|
|
|
1505 static void
|
|
|
1506 umpire_speak(msg)
|
|
|
1507 char *msg;
|
|
|
1508 {
|
|
|
1509 pmessage(msg, -1, MALL, UMPIRE);
|
|
|
1510 }
|
|
|
1511
|
|
|
1512 static void
|
|
|
1513 talk_about_team(team, type)
|
|
|
1514 struct league_team *team;
|
|
|
1515 char *type;
|
|
|
1516 {
|
|
|
1517 char buf[120];
|
|
|
1518 struct player *captain;
|
|
|
1519
|
|
|
1520 if (team->captain >= 0)
|
|
|
1521 captain = &players[team->captain];
|
|
|
1522 else
|
|
|
1523 captain = 0;
|
|
|
1524
|
|
|
1525 sprintf(buf, "The %s team is named `%s'.", type, team->name);
|
|
|
1526 respond(buf, 0);
|
|
|
1527
|
|
|
1528 if (captain)
|
|
|
1529 sprintf(buf, " %s (%s) is their captain.", captain->p_name,
|
|
|
1530 twoletters(captain));
|
|
|
1531 else
|
|
|
1532 strcpy(buf, " They have not chosen a captain yet.");
|
|
|
1533 respond(buf, 0);
|
|
|
1534
|
|
|
1535 if (team->index >= 0)
|
|
|
1536 {
|
|
|
1537 sprintf(buf, " They have chosen the %s",
|
|
|
1538 teams[idx_to_mask(team->index)].name);
|
|
|
1539 }
|
|
|
1540 else
|
|
|
1541 {
|
|
|
1542 strcpy(buf, " They have not chosen an empire yet.");
|
|
|
1543 }
|
|
|
1544 respond(buf, 0);
|
|
|
1545 }
|
|
|
1546
|
|
|
1547 static int
|
|
|
1548 team_really_ready(team)
|
|
|
1549 struct league_team *team;
|
|
|
1550 {
|
|
|
1551 if (team->index < 0)
|
|
|
1552 {
|
|
|
1553 respond("You haven't chosen an empire", 1);
|
|
|
1554 return 0;
|
|
|
1555 }
|
|
|
1556 if (team->name[0] == 0)
|
|
|
1557 {
|
|
|
1558 respond("You haven't chosen a name", 1);
|
|
|
1559 return 0;
|
|
|
1560 }
|
|
|
1561 return 1;
|
|
|
1562 }
|
|
|
1563
|
|
|
1564 void
|
|
|
1565 trydefect(victim, dest, destname, from, fromname, actor)
|
|
|
1566 struct player *victim;
|
|
|
1567 enum HomeAway dest;
|
|
|
1568 char *destname;
|
|
|
1569 enum HomeAway from;
|
|
|
1570 char *fromname;
|
|
|
1571 struct player *actor;
|
|
|
1572 {
|
|
|
1573 char buf[120];
|
|
|
1574 struct league_team *fromteam =
|
|
|
1575 (from == AWAY) ? &status2->away : &status2->home;
|
|
|
1576
|
|
|
1577 if (victim->p_status == PFREE)
|
|
|
1578 {
|
|
|
1579 respond("Uh, he's not in the game.", 1);
|
|
|
1580 return;
|
|
|
1581 }
|
|
|
1582
|
|
|
1583 if (victim->p_homeaway == dest)
|
|
|
1584 {
|
|
|
1585 sprintf(buf, "%s already belong to the %s team",
|
|
|
1586 actor == victim ? "You" : "They", destname);
|
|
|
1587 respond(buf, 1);
|
|
|
1588 return;
|
|
|
1589 }
|
|
|
1590 if (actor->p_homeaway != from)
|
|
|
1591 {
|
|
|
1592 sprintf(buf, "You don't belong to the %s team. You can't kick him off.",
|
|
|
1593 fromname);
|
|
|
1594 respond(buf, 1);
|
|
|
1595 return;
|
|
|
1596 }
|
|
|
1597 if (fromteam->captain == actor->p_no)
|
|
|
1598 {
|
|
|
1599 if (victim == actor)
|
|
|
1600 {
|
|
|
1601 if (status2->league > 1 || status2->home.ready || status2->away.ready)
|
|
|
1602 {
|
|
|
1603 respond("You can't defect in the middle of the game. You're the captain!", 1);
|
|
|
1604 return;
|
|
|
1605 }
|
|
|
1606 sprintf(buf, "%s (%s), the captain of the %s team, has defected!",
|
|
|
1607 victim->p_name, twoletters(victim), fromname);
|
|
|
1608 umpire_speak(buf);
|
|
|
1609 }
|
|
|
1610 else
|
|
|
1611 {
|
|
|
1612 sprintf(buf, "%s (%s) has kicked %s (%s) off his team.",
|
|
|
1613 actor->p_name, twoletters(actor),
|
|
|
1614 victim->p_name, twoletters(victim));
|
|
|
1615 umpire_speak(buf);
|
|
|
1616 }
|
|
|
1617 }
|
|
|
1618 else
|
|
|
1619 {
|
|
|
1620 if (victim == actor)
|
|
|
1621 {
|
|
|
1622 if (status2->league > 1 || status2->home.ready || status2->away.ready)
|
|
|
1623 {
|
|
|
1624 respond("Only the captain can kick you off now.", 1);
|
|
|
1625 return;
|
|
|
1626 }
|
|
|
1627 sprintf(buf, "%s (%s) has defected to the %s team!",
|
|
|
1628 victim->p_name, twoletters(victim),
|
|
|
1629 destname);
|
|
|
1630 umpire_speak(buf);
|
|
|
1631 }
|
|
|
1632 else
|
|
|
1633 {
|
|
|
1634 respond("Only the captain can kick other people off the team.", 1);
|
|
|
1635 return;
|
|
|
1636 }
|
|
|
1637 }
|
|
|
1638 victim->p_homeaway = dest;
|
|
|
1639 victim->p_status = PEXPLODE;
|
|
|
1640 victim->p_whydead = KPROVIDENCE;
|
|
|
1641 victim->p_explode = 1;
|
|
|
1642 }
|
|
|
1643
|
|
|
1644 static int
|
|
|
1645 parse_league(subcommand)
|
|
|
1646 char *subcommand;
|
|
|
1647 {
|
|
|
1648 struct league_team *myteam, *otherteam;
|
|
|
1649 char *teamtype;
|
|
|
1650 char buf[120];
|
|
|
1651 int i;
|
|
|
1652 int iscaptain;
|
|
|
1653 char *nexttoken;
|
|
|
1654 static char captain_only[] = "That command is reserved for team captains.";
|
|
|
1655 static struct control_cmd available_cmds[] = {
|
|
|
1656 {"help", HELPTOK, 0},
|
|
|
1657 {"captain", CAPTAINTOK, "captain [%d]"},
|
|
|
1658 {"time", TIMETOK, "time [%d %d]"},
|
|
|
1659 {"pass", PASSTOK, "pass"},
|
|
|
1660 {"start", STARTTOK, "start [%d]"},
|
|
|
1661 {"restart", RESTARTTOK, "restart [%d]"},
|
|
|
1662 #if 0
|
|
|
1663 {"timeout", TIMEOUTTOK, "timeout [%d]"},
|
|
|
1664 #endif
|
|
|
1665 {"teamname", TEAMNAMETOK, "teamname %s"},
|
|
|
1666 {"information", INFOTOK, "information"},
|
|
|
1667 #if 0
|
|
|
1668 /* damn, these should be initialized from the current race list */
|
|
|
1669 {"federation", FEDTOK, "fed"},
|
|
|
1670 {"romulan", ROMTOK, "rom"},
|
|
|
1671 {"klingon", KLITOK, "kli"},
|
|
|
1672 {"orion", ORITOK, "ori"},
|
|
|
1673 #endif
|
|
|
1674
|
|
|
1675 {"away", AWAYTOK, "away [%d]"},
|
|
|
1676 {"home", HOMETOK, "home [%d]"},
|
|
|
1677 {"newgalaxy", NEWGALAXY, "newgalaxy [%d]"},
|
|
|
1678 {"pause", PAUSETOK, "pause"},
|
|
|
1679 {"continue", CONTINUETOK, "continue"},
|
|
|
1680 {"maxplayer", MAXPLAYERTOK, "maxplayer [%d]"},
|
|
|
1681 {"freeslot", FREESLOTTOK, "freeslot %d"},
|
|
|
1682 {0}
|
|
|
1683 };
|
|
|
1684
|
|
|
1685 switch (me->p_homeaway)
|
|
|
1686 {
|
|
|
1687 case HOME:
|
|
|
1688 myteam = &status2->home;
|
|
|
1689 otherteam = &status2->away;
|
|
|
1690 teamtype = "home";
|
|
|
1691 break;
|
|
|
1692 case AWAY:
|
|
|
1693 myteam = &status2->away;
|
|
|
1694 otherteam = &status2->home;
|
|
|
1695 teamtype = "away";
|
|
|
1696 break;
|
|
|
1697 default:
|
|
|
1698 respond("WHOA! internal error. You aren't on a team!", 0);
|
|
|
1699 respond("I'm afraid I'm going to have to kill you", 0);
|
|
|
1700 me->p_status = PEXPLODE;
|
|
|
1701 me->p_explode = 1;
|
|
|
1702 return 0;
|
|
|
1703 }
|
|
|
1704
|
|
|
1705 iscaptain = (myteam->captain == me->p_no);
|
|
|
1706
|
|
|
1707 /********************/
|
|
|
1708
|
|
|
1709 if (get_teamid(subcommand, &i, (char **) 0))
|
|
|
1710 {
|
|
|
1711 if (!iscaptain)
|
|
|
1712 {
|
|
|
1713 respond(captain_only, 1);
|
|
|
1714 return 1;
|
|
|
1715 }
|
|
|
1716 if (status2->league != 1)
|
|
|
1717 {
|
|
|
1718 respond("The game has started. You can't change your mind now.", 1);
|
|
|
1719 return 1;
|
|
|
1720 }
|
|
|
1721 if ((myteam->ready || otherteam->ready) && myteam->index >= 0)
|
|
|
1722 {
|
|
|
1723 respond("One of the teams is ready. You can't change your mind now.", 1);
|
|
|
1724 return 1;
|
|
|
1725 }
|
|
|
1726 if (otherteam->index >= 0)
|
|
|
1727 {
|
|
|
1728 if (i == otherteam->index)
|
|
|
1729 {
|
|
|
1730 respond("The other team has already chosen that empire", 1);
|
|
|
1731 return 1;
|
|
|
1732 }
|
|
|
1733 }
|
|
|
1734 else
|
|
|
1735 {
|
|
|
1736 if (me->p_homeaway == HOME)
|
|
|
1737 {
|
|
|
1738 if (!status2->awaypassed)
|
|
|
1739 {
|
|
|
1740 respond("Away team gets first choice of empire.", 1);
|
|
|
1741 return 1;
|
|
|
1742 }
|
|
|
1743 }
|
|
|
1744 else /* away */ if (myteam->index >= 0 && 0 == status2->awaypassed)
|
|
|
1745 {
|
|
|
1746 respond("Give the other team a chance to choose a side, will ya?", 1);
|
|
|
1747 return 1;
|
|
|
1748 }
|
|
|
1749 else if (status2->awaypassed == 1)
|
|
|
1750 {
|
|
|
1751 respond("You passed the choice of empire. You have to wait for their choice.", 1);
|
|
|
1752 return 1;
|
|
|
1753 }
|
|
|
1754 }
|
|
|
1755
|
|
|
1756 if (i == myteam->index)
|
|
|
1757 {
|
|
|
1758 respond("That already IS your empire.", 1);
|
|
|
1759 return 1;
|
|
|
1760 }
|
|
|
1761 if (i < 0)
|
|
|
1762 {
|
|
|
1763 #if 0
|
|
|
1764 sprintf(buf, "The %s team no longer wishes the %s for their empire.",
|
|
|
1765 teamtype, teams[idx_to_mask(myteam->index)].name);
|
|
|
1766 #else
|
|
|
1767 respond("You can't change your mind without a reset. Ask for one", 1);
|
|
|
1768 return 1;
|
|
|
1769 #endif
|
|
|
1770 }
|
|
|
1771 else
|
|
|
1772 sprintf(buf, "The %s team has chosen the %s for their empire.",
|
|
|
1773 teamtype, teams[idx_to_mask(i)].name);
|
|
|
1774 umpire_speak(buf);
|
|
|
1775
|
|
|
1776 myteam->index = i;
|
|
|
1777
|
|
|
1778 return 1;
|
|
|
1779 }
|
|
|
1780 else
|
|
|
1781 switch (next_token(subcommand, available_cmds, &nexttoken))
|
|
|
1782 {
|
|
|
1783 default:
|
|
|
1784 case HELPTOK: /********************/
|
|
|
1785 if (iscaptain)
|
|
|
1786 {
|
|
|
1787 respond_with_help_string(available_cmds);
|
|
|
1788 }
|
|
|
1789 else
|
|
|
1790 {
|
|
|
1791 respond("Available commands: captain [ %d ], time, information, maxplayer.", 0);
|
|
|
1792 }
|
|
|
1793 return 1;
|
|
|
1794
|
|
|
1795 case CAPTAINTOK: /********************/
|
|
|
1796 {
|
|
|
1797 int j;
|
|
|
1798 i = !get_int(nexttoken, &j, (char **) 0) || j;
|
|
|
1799 }
|
|
|
1800 if (i)
|
|
|
1801 {
|
|
|
1802 if (myteam->captain < 0 ||
|
|
|
1803 players[myteam->captain].p_status != PALIVE ||
|
|
|
1804 players[myteam->captain].p_team != me->p_team)
|
|
|
1805 {
|
|
|
1806 if (myteam->captain >= 0)
|
|
|
1807 {
|
|
|
1808 /*
|
|
|
1809 * safety valve in case the person is ghostbusted or on another
|
|
|
1810 * team
|
|
|
1811 */
|
|
|
1812 sprintf(buf, "%s has been overthrown as captain of the %s team",
|
|
|
1813 players[myteam->captain].p_name, teamtype);
|
|
|
1814 umpire_speak(buf);
|
|
|
1815 }
|
|
|
1816 respond("OK. *POOF* you're a captain!", 1);
|
|
|
1817 sprintf(buf, "%s (%s) is now fearless leader of the %s team!",
|
|
|
1818 me->p_name, twoletters(me), teamtype);
|
|
|
1819 umpire_speak(buf);
|
|
|
1820 myteam->captain = me->p_no;
|
|
|
1821 }
|
|
|
1822 else if (iscaptain)
|
|
|
1823 {
|
|
|
1824 respond("Listen, silly. You already are captain. No point in rubbing it in", 1);
|
|
|
1825 }
|
|
|
1826 else
|
|
|
1827 {
|
|
|
1828 /* if myteam->captain were <0, we wouldn't get here */
|
|
|
1829 struct player *capn = &players[myteam->captain];
|
|
|
1830 sprintf(buf, "Sorry, %s (%s) is already captain of your team.",
|
|
|
1831 capn->p_name, twoletters(capn));
|
|
|
1832 respond(buf, 1);
|
|
|
1833 }
|
|
|
1834 }
|
|
|
1835 else
|
|
|
1836 {
|
|
|
1837 if (iscaptain)
|
|
|
1838 {
|
|
|
1839 respond("Wimp. We didn't want you for captain anyway.", 1);
|
|
|
1840 sprintf(buf, "%s (%s) has chickened out.",
|
|
|
1841 me->p_name, twoletters(me));
|
|
|
1842 umpire_speak(buf);
|
|
|
1843 sprintf(buf, "Who now will lead the %s team?", teamtype);
|
|
|
1844 umpire_speak(buf);
|
|
|
1845 myteam->captain = -1;
|
|
|
1846 }
|
|
|
1847 else
|
|
|
1848 {
|
|
|
1849 respond("You can't quit being a captain. You weren't one in the first place.", 1);
|
|
|
1850 }
|
|
|
1851 }
|
|
|
1852 return 1;
|
|
|
1853
|
|
|
1854 case TIMETOK: /********************/
|
|
|
1855 if (0 == *nexttoken)
|
|
|
1856 {
|
|
|
1857 switch (status2->league)
|
|
|
1858 {
|
|
|
1859 case 2:
|
|
|
1860 sprintf(buf, "%d seconds left in pre-tourney warm-up.",
|
|
|
1861 status2->leagueticksleft / SECONDS(1));
|
|
|
1862 break;
|
|
|
1863 case 3:
|
|
|
1864 sprintf(buf, "%d minutes left in regulation play.",
|
|
|
1865 status2->leagueticksleft / MINUTES(1));
|
|
|
1866 break;
|
|
|
1867 case 4:
|
|
|
1868 sprintf(buf, "%d minutes left in overtime.",
|
|
|
1869 status2->leagueticksleft / MINUTES(1));
|
|
|
1870 break;
|
|
|
1871 default:
|
|
|
1872 sprintf(buf, "game is configured for %d minutes (%d overtime).",
|
|
|
1873 configvals->regulation_minutes, configvals->overtime_minutes);
|
|
|
1874 break;
|
|
|
1875 }
|
|
|
1876 respond(buf, 0);
|
|
|
1877 return 1;
|
|
|
1878 }
|
|
|
1879 else if (!iscaptain)
|
|
|
1880 {
|
|
|
1881 respond(captain_only, 1);
|
|
|
1882 return 1;
|
|
|
1883 }
|
|
|
1884 else if (status2->league != 1)
|
|
|
1885 {
|
|
|
1886 respond("You can only adjust the time parameters during the configuration phase", 1);
|
|
|
1887 return 1;
|
|
|
1888 }
|
|
|
1889 else if (otherteam->ready)
|
|
|
1890 {
|
|
|
1891 respond("The other team is ready to start. You can't change the game params NOW.", 1);
|
|
|
1892 return 1;
|
|
|
1893 }
|
|
|
1894 else if (!get_int(nexttoken, &myteam->desired.regulation, &nexttoken)
|
|
|
1895 || !get_int(nexttoken, &myteam->desired.overtime, (char **) 0))
|
|
|
1896 {
|
|
|
1897 respond("Usage: time [ %d %d ]", 1);
|
|
|
1898 return 1;
|
|
|
1899 }
|
|
|
1900
|
|
|
1901 if (status2->home.desired.regulation == status2->away.desired.regulation
|
|
|
1902 && status2->home.desired.overtime == status2->away.desired.overtime)
|
|
|
1903 {
|
|
|
1904 configvals->regulation_minutes = status2->home.desired.regulation;
|
|
|
1905 configvals->overtime_minutes = status2->home.desired.overtime;
|
|
|
1906 sprintf(buf, "The captains have agreed to a %d minute game (%d overtime).", configvals->regulation_minutes, configvals->overtime_minutes);
|
|
|
1907 umpire_speak(buf);
|
|
|
1908 }
|
|
|
1909 else
|
|
|
1910 {
|
|
|
1911 sprintf(buf, "The %s team wishes a game of %d minutes (%d overtime)",
|
|
|
1912 teamtype, myteam->desired.regulation, myteam->desired.overtime);
|
|
|
1913 umpire_speak(buf);
|
|
|
1914 }
|
|
|
1915
|
|
|
1916 return 1;
|
|
|
1917
|
|
|
1918 case PASSTOK: /********************/
|
|
|
1919 if (status2->league != 1)
|
|
|
1920 {
|
|
|
1921 respond("The time for that is long past.", 1);
|
|
|
1922 return 1;
|
|
|
1923 }
|
|
|
1924 if (!iscaptain)
|
|
|
1925 {
|
|
|
1926 respond(captain_only, 1);
|
|
|
1927 return 1;
|
|
|
1928 }
|
|
|
1929 if (me->p_homeaway == AWAY && status2->awaypassed)
|
|
|
1930 {
|
|
|
1931 respond("You already passed the choice of empire.", 1);
|
|
|
1932 return 1;
|
|
|
1933 }
|
|
|
1934 else if (me->p_homeaway == HOME && status2->awaypassed == 0)
|
|
|
1935 {
|
|
|
1936 respond("You can't possibly pass the choice of empire. You don't HAVE it!", 1);
|
|
|
1937 return 1;
|
|
|
1938 }
|
|
|
1939 else if (status2->awaypassed > 1)
|
|
|
1940 {
|
|
|
1941 respond("You both passed already, so get on with it. (indecisive wishy-washy cretins)", 1);
|
|
|
1942 return 1;
|
|
|
1943 }
|
|
|
1944 status2->awaypassed++;
|
|
|
1945
|
|
|
1946 sprintf(buf, "The %s team has passed the choice of empire", teamtype);
|
|
|
1947 umpire_speak(buf);
|
|
|
1948
|
|
|
1949 if (status2->awaypassed > 1)
|
|
|
1950 {
|
|
|
1951 umpire_speak("Computer choosing randomly for both teams");
|
|
|
1952 if (status2->home.index < 0)
|
|
|
1953 {
|
|
|
1954 status2->home.index = lrand48() % ((status2->away.index < 0) ? 4 : 3);
|
|
|
1955 if (status2->away.index >= 0 &&
|
|
|
1956 status2->home.index >= status2->away.index)
|
|
|
1957 status2->home.index++;
|
|
|
1958 }
|
|
|
1959 if (status2->away.index < 0)
|
|
|
1960 {
|
|
|
1961 status2->away.index = lrand48() % 3;
|
|
|
1962 if (status2->away.index >= status2->home.index)
|
|
|
1963 status2->away.index++;
|
|
|
1964 }
|
|
|
1965 }
|
|
|
1966 return 1;
|
|
|
1967
|
|
|
1968 case STARTTOK: /********************/
|
|
|
1969 if (status2->league != 1)
|
|
|
1970 {
|
|
|
1971 respond("The game has already started.", 1);
|
|
|
1972 return 1;
|
|
|
1973 }
|
|
|
1974 if (!iscaptain)
|
|
|
1975 {
|
|
|
1976 respond(captain_only, 1);
|
|
|
1977 return 1;
|
|
|
1978 }
|
|
|
1979 if (get_int(nexttoken, &myteam->ready, (char **) 0) && !myteam->ready)
|
|
|
1980 {
|
|
|
1981 sprintf(buf, "The %s team is not ready.", teamtype);
|
|
|
1982 umpire_speak(buf);
|
|
|
1983 return 0;
|
|
|
1984 }
|
|
|
1985 myteam->ready = 1;
|
|
|
1986 if (!team_really_ready(myteam))
|
|
|
1987 {
|
|
|
1988 respond("Your team is not really ready. You need a name and an empire.", 0);
|
|
|
1989 myteam->ready = 0;
|
|
|
1990 return 0;
|
|
|
1991 }
|
|
|
1992
|
|
|
1993 if (otherteam->ready && !team_really_ready(otherteam))
|
|
|
1994 {
|
|
|
1995 otherteam->ready = 0;
|
|
|
1996 sprintf(buf, "The %s team was ready but the other wasn't.", teamtype);
|
|
|
1997 }
|
|
|
1998 else
|
|
|
1999 {
|
|
|
2000 sprintf(buf, "The %s team is ready to start now.", teamtype);
|
|
|
2001 }
|
|
|
2002 umpire_speak(buf);
|
|
|
2003
|
|
|
2004
|
|
|
2005 if (otherteam->ready)
|
|
|
2006 {
|
|
|
2007 /* shit! we're good to go! */
|
|
|
2008
|
|
|
2009 umpire_speak("Both sides are ready. Let the carnage begin!");
|
|
|
2010 umpire_speak("Everybody dies. T-mode starts in 1 minute.");
|
|
|
2011 status2->league = 2;
|
|
|
2012 status2->leagueticksleft = 60 * TICKSPERSEC;
|
|
|
2013
|
|
|
2014 /* version */
|
|
|
2015
|
|
|
2016 explode_everyone(KTOURNSTART, 0);
|
|
|
2017 }
|
|
|
2018 return 1;
|
|
|
2019
|
|
|
2020 case RESTARTTOK: /********************/
|
|
|
2021 if (status2->league != 1)
|
|
|
2022 {
|
|
|
2023 respond("The game has started. You can't change your mind now.", 1);
|
|
|
2024 return 1;
|
|
|
2025 }
|
|
|
2026
|
|
|
2027 if (!iscaptain)
|
|
|
2028 {
|
|
|
2029 respond(captain_only, 1);
|
|
|
2030 return 1;
|
|
|
2031 }
|
|
|
2032
|
|
|
2033 myteam->desired.restart = !get_int(nexttoken, &i, (char **) 0) || i;
|
|
|
2034
|
|
|
2035 sprintf(buf, myteam->desired.restart ?
|
|
|
2036 "%s (%s) would like to restart team selection." :
|
|
|
2037 "%s (%s) is satisfied with the teams.",
|
|
|
2038 me->p_name, twoletters(me));
|
|
|
2039 umpire_speak(buf);
|
|
|
2040
|
|
|
2041 if (status2->home.desired.restart && status2->away.desired.restart)
|
|
|
2042 {
|
|
|
2043 umpire_speak("Both captains have agreed to restart team selection.");
|
|
|
2044
|
|
|
2045 status2->awaypassed = 0;
|
|
|
2046 status2->home.index = status2->away.index = -1;
|
|
|
2047
|
|
|
2048 status2->home.ready = status2->away.ready = 0;
|
|
|
2049
|
|
|
2050 status2->home.desired.restart = status2->away.desired.restart = 0;
|
|
|
2051 }
|
|
|
2052
|
|
|
2053 return 1;
|
|
|
2054
|
|
|
2055 case TIMEOUTTOK:
|
|
|
2056 respond("NYI", 0);
|
|
|
2057 return 1;
|
|
|
2058
|
|
|
2059 case TEAMNAMETOK: /********************/
|
|
|
2060 if (status2->league != 1)
|
|
|
2061 {
|
|
|
2062 respond("The game has started. You can't change your mind now.", 1);
|
|
|
2063 return 1;
|
|
|
2064 }
|
|
|
2065 if (!iscaptain)
|
|
|
2066 {
|
|
|
2067 respond(captain_only, 1);
|
|
|
2068 return 1;
|
|
|
2069 }
|
|
|
2070 if (0 == *nexttoken)
|
|
|
2071 {
|
|
|
2072 respond("What do you want to call your team?\n", 1);
|
|
|
2073 return 1;
|
|
|
2074 }
|
|
|
2075 strncpy(myteam->name, nexttoken, sizeof(myteam->name));
|
|
|
2076 myteam->name[sizeof(myteam->name) - 1] = 0;
|
|
|
2077
|
|
|
2078 sprintf(buf, "Henceforth let the %s team be known as `%s'!",
|
|
|
2079 teamtype, myteam->name);
|
|
|
2080 umpire_speak(buf);
|
|
|
2081
|
|
|
2082 return 1;
|
|
|
2083
|
|
|
2084 case INFOTOK: /********************/
|
|
|
2085 sprintf(buf, "The game will last for %d minutes (%d overtime)",
|
|
|
2086 configvals->regulation_minutes,
|
|
|
2087 configvals->overtime_minutes);
|
|
|
2088 respond(buf, 0);
|
|
|
2089 sprintf(buf, "Teams are limited to %d players on the field at once",
|
|
|
2090 configvals->playersperteam);
|
|
|
2091 respond(buf, 0);
|
|
|
2092 sprintf(buf, "You are on the %s team.", teamtype);
|
|
|
2093 respond(buf, 0);
|
|
|
2094 talk_about_team(&status2->home, "home");
|
|
|
2095 talk_about_team(&status2->away, "away");
|
|
|
2096
|
|
|
2097 if (status2->awaypassed > 1)
|
|
|
2098 umpire_speak("Both teams passed empire choice. Computer assigned.");
|
|
|
2099 else if (status2->awaypassed)
|
|
|
2100 umpire_speak("Away has passed empire choice to the Home team");
|
|
|
2101 else
|
|
|
2102 umpire_speak("Away chooses empire first");
|
|
|
2103
|
|
|
2104 return 1;
|
|
|
2105
|
|
|
2106
|
|
|
2107 case AWAYTOK: /********************/
|
|
|
2108 {
|
|
|
2109 struct player *victim;
|
|
|
2110 if (!*nexttoken)
|
|
|
2111 victim = me;
|
|
|
2112 else
|
|
|
2113 {
|
|
|
2114 int idx = get_slotnum(nexttoken, (char **) 0);
|
|
|
2115 if (idx < 0)
|
|
|
2116 {
|
|
|
2117 respond("`league away' requires a valid slot number", 0);
|
|
|
2118 return 1;
|
|
|
2119 }
|
|
|
2120 else
|
|
|
2121 {
|
|
|
2122 victim = &players[idx];
|
|
|
2123 }
|
|
|
2124 }
|
|
|
2125 trydefect(victim, AWAY, "away", HOME, "home", me);
|
|
|
2126 }
|
|
|
2127 return 1;
|
|
|
2128
|
|
|
2129 case HOMETOK: /********************/
|
|
|
2130 {
|
|
|
2131 struct player *victim;
|
|
|
2132 if (!*nexttoken)
|
|
|
2133 victim = me;
|
|
|
2134 else
|
|
|
2135 {
|
|
|
2136 int idx = get_slotnum(nexttoken, (char **) 0);
|
|
|
2137 if (idx < 0)
|
|
|
2138 {
|
|
|
2139 respond("`league away' requires a valid slot number", 0);
|
|
|
2140 return 1;
|
|
|
2141 }
|
|
|
2142 else
|
|
|
2143 {
|
|
|
2144 victim = &players[idx];
|
|
|
2145 }
|
|
|
2146 }
|
|
|
2147 trydefect(victim, HOME, "home", AWAY, "away", me);
|
|
|
2148 }
|
|
|
2149
|
|
|
2150 return 1;
|
|
|
2151 case NEWGALAXY: /********************/
|
|
|
2152
|
|
|
2153 if (status2->league != 1)
|
|
|
2154 {
|
|
|
2155 respond("The game has started. You can't change your mind now.", 1);
|
|
|
2156 return 1;
|
|
|
2157 }
|
|
|
2158
|
|
|
2159 if (myteam->ready || otherteam->ready)
|
|
|
2160 {
|
|
|
2161 respond("You can't reset the galaxy now. We're almost ready!", 1);
|
|
|
2162 return 1;
|
|
|
2163 }
|
|
|
2164 if (!iscaptain)
|
|
|
2165 {
|
|
|
2166 respond(captain_only, 1);
|
|
|
2167 return 1;
|
|
|
2168 }
|
|
|
2169
|
|
|
2170 {
|
|
|
2171 int j;
|
|
|
2172 myteam->desired.galaxyreset =
|
|
|
2173 !get_int(nexttoken, &j, (char **) 0) || j;
|
|
|
2174 }
|
|
|
2175
|
|
|
2176 if (myteam->desired.galaxyreset)
|
|
|
2177 {
|
|
|
2178 sprintf(buf, "%s (%s) is dissatisfied with the galaxy",
|
|
|
2179 me->p_name, twoletters(me));
|
|
|
2180 }
|
|
|
2181 else
|
|
|
2182 {
|
|
|
2183 sprintf(buf, "%s (%s) thinks the galaxy is just fine, thank you.",
|
|
|
2184 me->p_name, twoletters(me));
|
|
|
2185 }
|
|
|
2186 umpire_speak(buf);
|
|
|
2187
|
|
|
2188 if (status2->home.desired.galaxyreset &&
|
|
|
2189 status2->away.desired.galaxyreset)
|
|
|
2190 {
|
|
|
2191 umpire_speak("Both captains have agreed that the galaxy sucks.");
|
|
|
2192 status2->newgalaxy = 1;
|
|
|
2193 warning("Creating new galaxy");
|
|
|
2194
|
|
|
2195 status2->home.desired.galaxyreset = status2->away.desired.galaxyreset = 0;
|
|
|
2196
|
|
|
2197 status2->awaypassed = 0;
|
|
|
2198 status2->home.index = status2->away.index = -1;
|
|
|
2199 status2->home.ready = status2->away.ready = 0;
|
|
|
2200 status2->home.desired.restart = status2->away.desired.restart = 0;
|
|
|
2201 }
|
|
|
2202
|
|
|
2203 return 1;
|
|
|
2204
|
|
|
2205 case PAUSETOK: /********************/
|
|
|
2206 if (!iscaptain)
|
|
|
2207 {
|
|
|
2208 respond(captain_only, 1);
|
|
|
2209 return 1;
|
|
|
2210 }
|
|
|
2211
|
|
|
2212 myteam->desirepause = 1;
|
|
|
2213
|
|
|
2214 if (status2->home.desirepause && status2->away.desirepause)
|
|
|
2215 {
|
|
|
2216 /* well, it's unanimous! */
|
|
|
2217 status2->paused = SECONDS(10);
|
|
|
2218 umpire_speak("The game has been paused");
|
|
|
2219 }
|
|
|
2220 else
|
|
|
2221 {
|
|
|
2222 sprintf(buf, "The %s team wishes to PAUSE the game.", teamtype);
|
|
|
2223 umpire_speak(buf);
|
|
|
2224 }
|
|
|
2225
|
|
|
2226 status2->pausemsgfuse = 0;
|
|
|
2227
|
|
|
2228 return 1;
|
|
|
2229
|
|
|
2230 case CONTINUETOK: /********************/
|
|
|
2231 if (!iscaptain)
|
|
|
2232 {
|
|
|
2233 respond(captain_only, 1);
|
|
|
2234 return 0;
|
|
|
2235 }
|
|
|
2236
|
|
|
2237 myteam->desirepause = 0;
|
|
|
2238
|
|
|
2239 sprintf(buf, "The %s team wishes to CONTINUE.", teamtype);
|
|
|
2240 umpire_speak(buf);
|
|
|
2241
|
|
|
2242 status2->pausemsgfuse = 0;
|
|
|
2243
|
|
|
2244 return 1;
|
|
|
2245
|
|
|
2246 case MAXPLAYERTOK:
|
|
|
2247 {
|
|
|
2248 int mp;
|
|
|
2249 if (!get_int(nexttoken, &mp, (char **) 0))
|
|
|
2250 {
|
|
|
2251 sprintf(buf, "The game is currently configured for a maximum of %d players on each", configvals->playersperteam);
|
|
|
2252 respond(buf, 0);
|
|
|
2253 respond("team.", 0);
|
|
|
2254 if (configvals->playersperteam != myteam->desired.maxplayers)
|
|
|
2255 {
|
|
|
2256 sprintf(buf, "You, however, want it to be %d.",
|
|
|
2257 myteam->desired.maxplayers);
|
|
|
2258 respond(buf, 0);
|
|
|
2259 }
|
|
|
2260 }
|
|
|
2261 else
|
|
|
2262 {
|
|
|
2263 if (!iscaptain)
|
|
|
2264 {
|
|
|
2265 respond(captain_only, 1);
|
|
|
2266 return 1;
|
|
|
2267 }
|
|
|
2268
|
|
|
2269 if (mp < 1)
|
|
|
2270 {
|
|
|
2271 respond("That's a stupid value for players-per-team.", 1);
|
|
|
2272 return 1;
|
|
|
2273 }
|
|
|
2274
|
|
|
2275 myteam->desired.maxplayers = mp;
|
|
|
2276 if (status2->away.desired.maxplayers
|
|
|
2277 == status2->home.desired.maxplayers)
|
|
|
2278 {
|
|
|
2279 configvals->playersperteam = mp;
|
|
|
2280 sprintf(buf, "Captains have agreed to limit players per team to %d", mp);
|
|
|
2281 umpire_speak(buf);
|
|
|
2282 }
|
|
|
2283 else
|
|
|
2284 {
|
|
|
2285 sprintf(buf, "The %s team would like to limit the number of ",
|
|
|
2286 teamtype);
|
|
|
2287 umpire_speak(buf);
|
|
|
2288 sprintf(buf, "players per team to %d", mp);
|
|
|
2289 umpire_speak(buf);
|
|
|
2290 }
|
|
|
2291 }
|
|
|
2292 }
|
|
|
2293 return 1;
|
|
|
2294 case FREESLOTTOK:
|
|
|
2295 {
|
|
|
2296 int slotnum;
|
|
|
2297 struct player *victim;
|
|
|
2298 slotnum = get_slotnum(nexttoken, (char **) 0);
|
|
|
2299 if (slotnum < 0)
|
|
|
2300 {
|
|
|
2301 respond("freeslot requires slot number", 1);
|
|
|
2302 return 0;
|
|
|
2303 }
|
|
|
2304
|
|
|
2305 victim = &players[slotnum];
|
|
|
2306 if (victim->p_ntspid)
|
|
|
2307 kill(victim->p_ntspid, SIGHUP);
|
|
|
2308
|
|
|
2309 victim->p_status = PFREE;
|
|
|
2310 victim->p_ntspid = 0;
|
|
|
2311
|
|
|
2312 sprintf(buf, "Player slot %s has been freed by %s (%2s).",
|
|
|
2313 nexttoken, me->p_name, twoletters(me));
|
|
|
2314 umpire_speak(buf);
|
|
|
2315 }
|
|
|
2316 return 1;
|
|
|
2317 }
|
|
|
2318 }
|
|
|
2319 #endif
|
|
|
2320 /*
|
|
|
2321 */
|
|
|
2322
|
|
|
2323
|
|
|
2324
|
|
|
2325 /*
|
|
|
2326 * Parse command messages.
|
|
|
2327 */
|
|
|
2328
|
|
|
2329 int
|
|
|
2330 parse_command_mess(str, who)
|
|
|
2331 char *str;
|
|
|
2332 unsigned char who;
|
|
|
2333 {
|
|
|
2334 char buf[120];
|
|
|
2335 char *nexttoken;
|
|
|
2336 int godlike = me->p_stats.st_royal - GODLIKE + 1;
|
|
|
2337
|
|
|
2338 static struct control_cmd available_cmds[] = {
|
|
|
2339 {"help", HELPTOK, 0},
|
|
|
2340 {"control", CONTROLTOK, "control ..."},
|
|
|
2341 {"league", LEAGUETOK, "league ..."},
|
|
|
2342 {"version", VERSIONTOK, "version"},
|
|
|
2343 {"player", PLAYERTOK, "player ..."},
|
|
|
2344 {"queue", QUEUETOK, "queue"}, {"tq", QUEUETOK, 0},
|
|
|
2345 {"information", INFOTOK, "information ..."},
|
|
|
2346 {"observe", OBSERVETOK, "observe"},
|
|
|
2347 {"parameters", PARAMTOK, "parameters"}, {"params", PARAMTOK, 0},
|
|
|
2348 {"cluecheck", CLUECHECKTOK, "cluecheck [%s]"},
|
|
|
2349 {0}
|
|
|
2350 };
|
|
|
2351
|
|
|
2352 if (godlike < 0)
|
|
|
2353 godlike = 0;
|
|
|
2354
|
|
|
2355
|
|
|
2356
|
|
|
2357 #if 0
|
|
|
2358 /* so we won't damage the original string */
|
|
|
2359 strcpy(buf, str);
|
|
|
2360
|
|
|
2361 dotokenize(buf);
|
|
|
2362
|
|
|
2363 if (sizetokstring == 0) /* nothing? ok, then let them send it :) */
|
|
|
2364 return 0;
|
|
|
2365 #endif
|
|
|
2366
|
|
|
2367 switch (next_token(str, available_cmds, &nexttoken))
|
|
|
2368 {
|
|
|
2369 case HELPTOK:
|
|
|
2370 sprintf(buf, "Available commands: %s%s%s",
|
|
|
2371 godlike ? "control ..., " : "",
|
|
|
2372 #ifdef LEAGUE_SUPPORT
|
|
|
2373 status2->league ? "league ..., " :
|
|
|
2374 #endif
|
|
|
2375 "",
|
|
|
2376 "version, player ..., queue,");
|
|
|
2377 respond(buf, 0);
|
|
|
2378 respond(" information ..., observe [%d], parameters, cluecheck [%s], help", 0);
|
|
|
2379 return 1;
|
|
|
2380 case CONTROLTOK:
|
|
|
2381 #ifdef GOD_CONTROLS
|
|
|
2382 #ifdef LEAGUE_SUPPORT
|
|
|
2383 if (status2->league)
|
|
|
2384 {
|
|
|
2385 respond("God controls are disabled during league play.", 1);
|
|
|
2386 }
|
|
|
2387 else
|
|
|
2388 #endif
|
|
|
2389 return parse_control(nexttoken);
|
|
|
2390 #else
|
|
|
2391 respond("This ntserv is not compiled with god controls.", 1);
|
|
|
2392 return 1;
|
|
|
2393 #endif
|
|
|
2394
|
|
|
2395 case VERSIONTOK:
|
|
|
2396 sprintf(buf, "NetrekII (Paradise), %s", PARAVERS);
|
|
|
2397 respond(buf, 0);
|
|
|
2398 return 1;
|
|
|
2399
|
|
|
2400 case PLAYERTOK:
|
|
|
2401 return parse_player(nexttoken);
|
|
|
2402
|
|
|
2403 case QUEUETOK:
|
|
|
2404 if (me->p_status == PTQUEUE)
|
|
|
2405 {
|
|
|
2406 detourneyqueue();
|
|
|
2407 }
|
|
|
2408 else if (status->tourn)
|
|
|
2409 respond("Dude, what are you waiting for!? It's T-mode. GO FIGHT!", 1);
|
|
|
2410 else if (!(me->p_flags & PFGREEN))
|
|
|
2411 respond("Can not enter the tourney queue while at alert", 1);
|
|
|
2412 #ifndef AEDILE
|
|
|
2413 else if (me->p_damage != 0 || me->p_shield < me->p_ship.s_maxshield)
|
|
|
2414 respond("Can not enter the tourney queue while damaged", 1);
|
|
|
2415 #endif
|
|
|
2416 else if (me->p_armies > 0)
|
|
|
2417 respond("Can not take armies into the tourney queue", 1);
|
|
|
2418 else
|
|
|
2419 {
|
|
|
2420 /*
|
|
|
2421 * well, stick them on the queue. They will be awoken when T mode
|
|
|
2422 * arrives
|
|
|
2423 */
|
|
|
2424
|
|
|
2425 evaporate(me);
|
|
|
2426
|
|
|
2427 /* need code to blab about this */
|
|
|
2428 me->p_status = PTQUEUE;
|
|
|
2429 sprintf(buf, "%s has entered the tournament queue to wait for T-mode", me->p_name);
|
|
|
2430 pmessage(buf, -1, MALL, "GOD->ALL");
|
|
|
2431 }
|
|
|
2432 return 1;
|
|
|
2433
|
|
|
2434 case LEAGUETOK:
|
|
|
2435 #ifdef LEAGUE_SUPPORT
|
|
|
2436 if (status2->league)
|
|
|
2437 {
|
|
|
2438 return parse_league(nexttoken);
|
|
|
2439 }
|
|
|
2440 else
|
|
|
2441 {
|
|
|
2442 respond("League commands are disabled during non-league play.", 1);
|
|
|
2443 return 1;
|
|
|
2444 }
|
|
|
2445 #else
|
|
|
2446 respond("Server is not compiled with league support.", 1);
|
|
|
2447 respond("Edit config.h, recompile, install, and nuke the game.", 1);
|
|
|
2448 return 1;
|
|
|
2449 #endif
|
|
|
2450
|
|
|
2451 case INFOTOK:
|
|
|
2452 return parse_info(nexttoken);
|
|
|
2453
|
|
|
2454 case OBSERVETOK:
|
|
|
2455 {
|
|
|
2456 int i;
|
|
|
2457 i = !get_int(nexttoken, &i, (char **) 0) || i;
|
|
|
2458
|
|
|
2459 if (i)
|
|
|
2460 {
|
|
|
2461 if (me->p_observer && me->p_status == POBSERVE)
|
|
|
2462 {
|
|
|
2463 respond("You are already an observer.", 1);
|
|
|
2464 }
|
|
|
2465 else
|
|
|
2466 {
|
|
|
2467 if (!(me->p_flags & PFGREEN))
|
|
|
2468 respond("Can not become an observer while at alert", 1);
|
|
|
2469 else if (me->p_damage != 0 || me->p_shield < me->p_ship.s_maxshield)
|
|
|
2470 respond("Can not become an observer while damaged", 1);
|
|
|
2471 else if (me->p_armies > 0)
|
|
|
2472 respond("Can not become an observer while carrying armies", 1);
|
|
|
2473 else
|
|
|
2474 {
|
|
|
2475 evaporate(me);
|
|
|
2476 me->p_status = POBSERVE;
|
|
|
2477 }
|
|
|
2478 me->p_observer = 1;
|
|
|
2479 }
|
|
|
2480 }
|
|
|
2481 else
|
|
|
2482 {
|
|
|
2483 if (me->p_observer && me->p_status == POBSERVE)
|
|
|
2484 {
|
|
|
2485 me->p_observer = 0;
|
|
|
2486 #if 1
|
|
|
2487 #ifdef LEAGUE_SUPPORT
|
|
|
2488 if (!(status2->league && status->tourn))
|
|
|
2489 #endif
|
|
|
2490 evaporate(me);
|
|
|
2491 #else
|
|
|
2492 respond("You may now self-destruct and reenter the game as a player", 0);
|
|
|
2493 respond("(assuming there's room for you).", 0);
|
|
|
2494 #endif
|
|
|
2495 }
|
|
|
2496 }
|
|
|
2497 }
|
|
|
2498 return 1;
|
|
|
2499
|
|
|
2500 case PARAMTOK:
|
|
|
2501 warning("Transmitting new game parameters");
|
|
|
2502 updateGameparams();
|
|
|
2503 return 1;
|
|
|
2504 case CLUECHECKTOK:
|
|
|
2505 #if defined(CLUECHECK1) || defined(CLUECHECK2)
|
|
|
2506 return accept_cluecheck(nexttoken);
|
|
|
2507 #else
|
|
|
2508 return 0;
|
|
|
2509 #endif
|
|
|
2510 default:
|
|
|
2511 return 0;
|
|
|
2512 }
|
|
|
2513 }
|
