![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / games / atc|
Return to atc.c CVS log | Up to [Research Unix] / researchv10no / games / atc |
1.1 root 1: /* atc: simulate an air traffic controller at work */
2:
3: #define NRAND 1
4: #define die nrand
5:
6: #include <stdio.h>
7: #include <sys/ttyio.h>
8: #include <sys/param.h>
9: #include <sys/timeb.h>
10: #include <ctype.h>
11: #include <signal.h>
12: #include <pwd.h>
13: #include "ahdr.h"
14:
15: #define SYNTAX "Usage: atc [-s=<seed>] [-a=<airspace>] [-t=<time>]\n"
16:
17: /* size of terminal capability buffer */
18: #define TCSIZE 1024
19:
20: int cmdx; /* command located using same cursor positioning as screen */
21: int cmdy; /* usually will be at 24 lines down */
22:
23: char screen[MAXWIDTH][MAXHEIGHT]; /* contents of screen when no planes */
24:
25: char *flowfile = 0; /* no default flow patterns */
26: char *airfile = AIRFILE;
27: char *airspace = {"Apple1"}; /* default airspace is as on Apple */
28: char *protofile = 0; /* no default protocol file */
29: FILE *proto; /* stays open all the time if protocol */
30: char *moviefile = 0; /* if in movie mode, here's the file */
31: FILE *movie; /* and the file descriptor */
32: int nextmovie; /* next time for a moviefile command */
33: char *mcommand; /* next movie command */
34: int width,height; /* these values set in the airspace file */
35: char *bigname = 0; /* megastatistics file */
36: FILE *bigstatsfile; /* megastatistics stream */
37:
38: struct flow fpath[MAXPATHS];
39: int maxflow;
40: int npaths;
41:
42: int nentry = 0; /* number of entries into the board */
43: struct pstruct entry[EMAX];
44:
45: int nairport = 0;
46: struct pstruct airport[AMAX];
47:
48: int nnavaid = 0;
49: struct pstruct navaid[NMAX];
50:
51: int nplanes = PMAX;
52: struct astruct plane[PMAX];
53:
54: int initseed,seed,game_time,initgame_time,last_update;
55: time_t start_time; /* real time in seconds that game started */
56:
57: time_t get_time();
58: struct passwd *getpwuid();
59: FILE *popen();
60:
61: #define BUFSIZE 80 /* buffer for message */
62:
63: int remain;
64:
65: int bound = 0; /* number of boundary errors */
66: int system = 0; /* system errors */
67: int crash = 0; /* crashed - out of fuel */
68: int fuel = 0; /* out of fuel on runway - tow truck */
69: int goaround = 0; /* missed an approach */
70: int icmds = 0; /* number of cmds issued (including deferred) */
71: int cmds = 0; /* number of cmds actually executed */
72:
73: int fuelused = 0;
74:
75: int inaptot=0,outaptot=0; /* denominators for random entries/exits */
76: int inawtot=0,outawtot=0; /* for airports and airways */
77:
78: char tcbuf[TCSIZE];
79: char cmbuf[100]; /* buffer for cursor motion strings */
80: char clbuf[100]; /* clear screen sequence */
81:
82: int rubout = 0;
83:
84: catchint(n)
85: int n;
86: {
87: rubout = 1;
88: signal (n, catchint);
89: }
90:
91: struct sgttyb tty_setting;
92: short tty_flags;
93:
94: main(argc,argv)
95: int argc;
96: char **argv;
97: { register char *arg;
98:
99: char *ttype;
100: char *getenv();
101:
102: ttype = getenv("TERM");
103: if (ttype == NULL || *ttype == '\0' || tgetent (tcbuf, ttype) <= 0) {
104: fprintf (stderr, "cannot determine terminal type\n");
105: exit (1);
106: }
107:
108: /* get cursor motion and clear screen code into cmbuf and clbuf */
109: {
110: char *p;
111: p = cmbuf;
112: tgetstr ("cm", &p);
113: p = clbuf;
114: tgetstr ("cl", &p);
115: }
116:
117: ioctl(0, TIOCGETP, &tty_setting);
118: tty_flags = tty_setting.sg_flags;
119: seed = 0;
120: for (arg = *++argv; --argc; arg = *++argv) /* read args 1 at a time */
121: { if (arg[0] == '-')
122: switch(arg[1])
123: { case 's':
124: if (arg[2] != '=') err(SYNTAX);
125: seed = atoi(&arg[3]);
126: break;
127: case 'S':
128: if (arg[2] != '=') err(SYNTAX);
129: bigname = &arg[3];
130: break;
131: case 'a':
132: if (arg[2] != '=') err(SYNTAX);
133: airspace = &arg[3];
134: break;
135: case 'u':
136: if (arg[2] != '=') err(SYNTAX);
137: airfile = &arg[3];
138: break;
139: case 't':
140: if (arg[2] != '=') err(SYNTAX);
141: initgame_time = game_time = 59 + 60 * atoi(&arg[3]);
142: break;
143: case 'f':
144: if (arg[2] != '=') err(SYNTAX);
145: flowfile = &arg[3];
146: break;
147: case 'p': /* run a protocol */
148: if (arg[2] != '=') err(SYNTAX);
149: protofile = &arg[3];
150: break;
151: case 'm': /* movie mode */
152: if (arg[2] != '=') err(SYNTAX);
153: moviefile = &arg[3];
154: break;
155: default :
156: err("Bad arg: %s\n",arg);
157: }
158: }
159: init(); /* set up flight plans, initialize screen */
160: while (command()); /* get commands from user */
161: done(1);
162: exit(0);
163: }
164:
165: #define CMDSIZE 40
166:
167: int inter; /* non-zero if an alarm went off */
168: intp() /* process interrupt from alarm */
169: { inter++;
170: }
171:
172:
173: command()
174: { time_t now;
175: char cmd[CMDSIZE];
176: char *c,utype,*d;
177: int i,j;
178:
179: for (utype = i = *(c=cmd) = 0; utype != RETURN; )
180: {
181: if (moviefile) game_time--; /* 1 sec at a time? */
182: else
183: { now = get_time();
184: game_time = initgame_time - (now - start_time);
185: }
186: if (remain == 0) return(0);
187: if (game_time < 0)
188: { report(OUTOFTIME,0,0);
189: return(0);
190: }
191: if (i == 0) /* preserve partial command */
192: { cursor(cmdx,cmdy);
193: printf("<%.2d> COMMAND: ",game_time/60);
194: }
195: if (last_update - game_time >= UPDATE)
196: { update();
197: if (c != cmd) {BEEP;} /* cmd may be obsolete */
198: }
199: while (moviefile && game_time <= nextmovie)
200: { if (bigname) pcmd(bigstatsfile,mcommand);
201: if (protofile) pcmd(proto,mcommand);
202: i = parse(mcommand);
203: if (!i) return i;
204: getmcmd();
205: }
206: if (moviefile) continue; /* no longer accept inputs */
207: cursor(cmdx+7,cmdy);
208: for (j=0; j<i; j++) putchar(cmd[j]);
209: signal(SIGALRM,intp);/* catch the alarm if it goes off */
210: inter = 0; /* set to >0 if the alarm goes off */
211: if (rubout) return 0; /* user really wants to quit */
212: alarm(TIMEOUT); /* read for TIMEOUT sec unless he types */
213: utype = getchar() & 0177;
214: alarm(0);
215: if (inter > 0) continue; /* didn't type anything */
216: delmsg(cmdx,cmdy-1); /* erase previous echo if he types */
217: cursor(cmdx+7,cmdy);
218: if (i != 2 || (*(c-1) != '*' && *(c-1) != ':'))
219: if (*cmd != '!' || i == 0) /* don't shift CDL filename */
220: if (*cmd != '@'|| i == 0) /* don't shift location descrip */
221: if (utype >= 'a' && utype <= 'z')
222: utype = utype - 'a' + 'A';
223: if (utype == INSMODE) utype = RETURN;
224: if ((*c++ = utype) != RETURN)
225: { if (++i >= CMDSIZE) c--;
226: else
227: switch(utype) /* echo something reasonable */
228: {
229: #ifdef ANNARBOR
230: case MIPAGE:/* check cursor controls */
231: putchar(*--c = 'N');
232: putchar(*++c = 'W');
233: c++; i++;
234: break;
235: case HOME:
236: putchar(*--c = 'N');
237: c++;
238: break;
239: case PLPAGE:
240: putchar(*--c = 'N');
241: putchar(*++c = 'E');
242: c++; i++;
243: break;
244: case MISRCH:
245: putchar(*--c = 'W');
246: c++;
247: break;
248: case UPARROW:
249: putchar(*--c = '0');
250: c++;
251: break;
252: case PLSRCH:
253: putchar(*--c = 'E');
254: c++;
255: break;
256: case LEFTARROW:
257: putchar(*--c = 'S');
258: putchar(*++c = 'W');
259: c++; i++;
260: break;
261: case DOWNARROW:
262: putchar(*--c = 'S');
263: c++;
264: break;
265: case RIGHTARROW:
266: putchar(*--c = 'S');
267: putchar(*++c = 'E');
268: c++; i++;
269: break;
270: case ':': /* like a * */
271: putchar('*');
272: break;
273: #endif
274: case BS:
275: if (i<=0) break;
276: if (i==1) { i = 0; break; }
277: putchar(BS);
278: c--; c--; i--; i--;
279: break;
280: default: putchar(utype); break;
281: }
282: }
283: }
284: *c = 0;
285: if (bigname) pcmd(bigstatsfile,cmd);
286: if (protofile) pcmd(proto,cmd);
287: return(parse(cmd));
288: }
289:
290: pcmd(file,cmd) /* protocol a command */
291: FILE *file;
292: char *cmd;
293: { register char *s;
294:
295: if (file == proto)
296: fprintf(file,"%5d: ",game_time);
297: else fprintf(file,"%5d: ",initgame_time - game_time);
298: for (s = cmd; *s && *s != RETURN; s++) fputc(*s,file);
299: fputc('\n',file);
300: }
301:
302: parse(cmd) /* command is terminated by RETURN */
303: register char *cmd;
304: { time_t now;
305: register int i;
306: register struct astruct *pl;
307: char dest;
308: char *fullcmd;
309: char ubuf[10];
310:
311: fullcmd = cmd;
312: switch(*cmd) /* parse 1 letter at a time */
313: { case ' ': /* time advance */
314: sprintf (ubuf, "%d", UPDATE);
315: echo("%s\" - ROGER",ubuf);
316: now = get_time();
317: start_time = last_update - UPDATE - 1 - initgame_time + now;
318: break;
319: case '$':
320: return(0);
321: case '!': /* read a file of clearance directive lists */
322: readcdl(++cmd);
323: break;
324: case '@': /* get a monitoring command */
325: getmon(++cmd);
326: break;
327: default: /* should be airplane id */
328: /* ASSUMPTION HERE: aircraft are A-Z */
329: if (*cmd < 'A' || *cmd > 'Z')
330: { echo("%s - UNABLE",fullcmd);
331: BEEP;
332: break;
333: }
334: for (pl = &plane[i=0]; i < nplanes; i++,pl++)
335: if (pl->a_id == *cmd) break;
336: if (i == nplanes)
337: { echo("%s - NOT ACTIVE",fullcmd);
338: BEEP;
339: break;
340: }
341:
342: if (cmd[1] == '?') /* o.k. to cancel plans */
343: { if (pl->a_active != ACTIVE &&
344: pl->a_active != WAITING)
345: { echo("%s - NOT ACTIVE",fullcmd);
346: BEEP;
347: break;
348: }
349: }
350: else if (cmd[1] == RETURN) /* info request only */
351: { if (pl->a_active != ACTIVE &&
352: pl->a_active != APPROACHING &&
353: pl->a_active != WAITING)
354: { echo("%s - NOT ACTIVE",fullcmd);
355: BEEP;
356: break;
357: }
358: }
359: else
360: { if (pl->a_active != ACTIVE && pl->a_active != WAITING)
361: { echo("%s - NOT ACTIVE",fullcmd);
362: BEEP;
363: break;
364: }
365: if (pl->a_active==ACTIVE && pl->a_nextz == 0 && cmd[1]!=RETURN)
366: { echo("%s - LANDING",fullcmd);
367: BEEP;
368: break;
369: }
370: }
371: switch(*++cmd) /* parse second char */
372: { case RETURN: /* info request */
373: strip(pl,cmdy+1,VERBOSE);
374: break;
375: case 'A': /* change altitude */
376: if (*++cmd < '0' || *cmd > '5')
377: { echo("%s - UNABLE",fullcmd);
378: BEEP;
379: }
380: else
381: { pl->a_nextz = *cmd - '0';
382: echo("%s - ROGER",fullcmd);
383: cmds++;
384: icmds++;
385: }
386: break;
387: case 'H': /* hold at beacon */
388: pl->a_hold = 1;
389: pl->a_clear = 0;
390: echo("%s - ROGER",fullcmd);
391: cmds++;
392: icmds++;
393: break;
394: case 'L': /* left turn */
395: rdturn(pl,'L',++cmd,fullcmd);
396: break;
397: case 'R': /* right turn */
398: rdturn(pl,'R',++cmd,fullcmd);
399: break;
400: case 'T': /* shortest turn */
401: rdturn(pl,'T',++cmd,fullcmd);
402: break;
403: case '*': /* clearance at navaid */
404: case ':':
405: dest = *++cmd;
406: for (i=0; i<nentry; i++) /* vector to entry? */
407: if (dest == entry[i].p_sym) break;
408: if (pl->a_hold == 1) pl->a_hold = 0;
409: if (i<nentry)
410: { echo("%s - ROGER",fullcmd);
411: pl->a_clear = dest;
412: cmds++;
413: icmds++;
414: break;
415: }
416: for (i=0; i<nairport; i++)
417: if (dest == airport[i].p_sym) break;
418: if (i<nairport)
419: { echo("%s - ROGER",fullcmd);
420: pl->a_clear = dest;
421: cmds++;
422: icmds++;
423: break;
424: }
425: echo("%s - UNABLE",fullcmd);
426: BEEP;
427: break;
428: case '?': /* delete delayed commands */
429: ddelay(pl);
430: echo("%s - ROGER",fullcmd);
431: cmds++;
432: icmds++;
433: break;
434: default: /* airport id? - maybe cursor motions? */
435: echo("%s - UNABLE",fullcmd);
436: BEEP;
437: break;
438: }
439: }
440: return(1);
441: }
442:
443: getmon(cmd) /* get monitor command from command line */
444: register char *cmd;
445: { int x,y;
446: register char *start;
447:
448: start = cmd;
449: if (getloc(cmd,&x,&y) == 0) /* where did you say? */
450: { echo("%s - BAD LOC SPEC",cmd);
451: BEEP;
452: return;
453: }
454: while (*cmd) /* pick up each command that happens here */
455: { while (*cmd && *cmd != ',') cmd++;
456: if (*cmd == 0) return; /* read last command */
457: putlist(start,x,y,++cmd); /* put the next command on a list */
458: }
459: }
460:
461: ddelay(pl) /* delete any delayed commands from this plane's list */
462: struct astruct *pl;
463: { struct list *l,*next;
464:
465: if (pl->a_plan == 0) return;
466: for (l = pl->a_plan; l; l = next)
467: { next = l->l_next;
468: free(l);
469: }
470: pl->a_plan = 0;
471: }
472:
473: putlist(start,x,y,cmd) /* put some commands on the list for a plane */
474: char *start;
475: int x,y;
476: char *cmd;
477: { register struct list *l;
478: register struct astruct *p;
479: register char *c,*d;
480: int i;
481:
482: d = cmd;
483: for (i = 0; cmd[i] != ',' && cmd[i] != 0 && cmd[i] != RETURN; i++)
484: if (i != 2 || (cmd[i-1] != '*' && cmd[i-1] != ':'))
485: if (cmd[i] >= 'a' && cmd[i] <= 'z') cmd[i] += 'A' - 'a';
486: for (p = &plane[i = 0]; i < nplanes; i++,p++)
487: if (p->a_id == *cmd) break;
488: if (i == nplanes)
489: { echo("BAD PLANE SPEC: %s",cmd);
490: BEEP;
491: return;
492: }
493: l = p->a_plan; /* go to the CDL for this plane */
494: if (p->a_plan == 0)
495: l = p->a_plan = (struct list *) malloc(sizeof (struct list));
496: else
497: { for (l = p->a_plan; l->l_next != 0; l = l->l_next); /* eol */
498: l->l_next = (struct list *) malloc(sizeof (struct list));
499: l = l->l_next;
500: }
501: l->l_next = 0;
502: l->l_x = x;
503: l->l_y = y;
504: c = l->l_cmd;
505: while (*cmd != ',' && *cmd != 0 && *cmd != RETURN)
506: *c++ = *cmd++;
507: *c++ = RETURN;
508: *c = 0;
509: for (c = d; *c; c++) if (*c == RETURN) *c = 0; /* return damages dspla*/
510: echo("%s - WILCO",d);
511: icmds++;
512: /* copy the verbatim direction used by the guy */
513: for (c = start, d = l->l_loc; *c != ','; *d++ = *c++);
514: *d = 0;
515: }
516:
517:
518: getloc(cmd,px,py) /* get location description from a monitor command */
519: char *cmd;
520: int *px,*py;
521: { register char l,*m; /* location */
522: register int i;
523: register struct pstruct *p;
524: int dx,dy;
525: char buf[300];
526:
527: l = *(m = cmd);
528: p = 0;
529: for (i = 0; i < nentry; i++)
530: if (entry[i].p_sym == l) p = &entry[i];
531: for (i = 0; i < nairport; i++)
532: if (airport[i].p_sym == l) p = &airport[i];
533: for (i = 0; i < nnavaid; i++)
534: if (navaid[i].p_sym == l) p = &navaid[i];
535: if (p == 0) return 0;
536: *px = p->p_x;
537: *py = p->p_y;
538: m++;
539: while (*m != ',') /* read through the other directions */
540: { dx = dy = 0;
541: switch(*m) /* NSEW */
542: { case 'n': dy = -1; break;
543: case 's': dy = 1; break;
544: case 'e': dx = 1; break;
545: case 'w': dx = -1; break;
546: default:
547: sprintf(buf,"Got %c instead of n,s,e,w",*m);
548: msg(cmdx,cmdy+3,buf);
549: return 0;
550: }
551: if (*++m == 'w') { dx = -1; m++;} /* NW or SW */
552: else if (*m == 'e') { dx = 1; m++;} /* NE or SE */
553: if (*m < '0' || *m > '9')
554: { sprintf(buf,"Got %c instead of digit",*m);
555: msg(cmdx,cmdy+3,buf);
556: return 0;
557: }
558: for (i = 0; *m >= '0' && *m <= '9'; m++)
559: i = 10 * i + *m - '0';
560: *px += i * dx;
561: *py += i * dy;
562: }
563: return 1;
564: }
565:
566: readcdl(fname) /* fname points at CDL filename, \r-terminated */
567: char *fname;
568: { FILE *cdlfile;
569: char *p;
570:
571: while (*fname == ' ') fname++; /* skip initial blanks */
572: for (p = fname; *p && *p != RETURN; p++); /* remove newline */
573: *p = 0;
574: if ((cdlfile = fopen(fname,"r")) == NULL)
575: { echo("Cannot open %s",fname);
576: return;
577: }
578: echo("Reading CDL file...",0);
579: fclose(cdlfile);
580: }
581:
582:
583: rdturn(pl,dir,cmd,fullcmd)
584: struct astruct *pl;
585: char dir;
586: char *cmd,*fullcmd;
587: { int i,ok,newx,newy,turncount;
588:
589: if (pl->a_nextz == 0)
590: { echo("%s - WRONG WAY",fullcmd);
591: BEEP;
592: return;
593: }
594: ok = 1; /* check whether this is a legal command */
595: newx = newy = 0;
596: for (i=0; i<2; i++) /* look at next 2 chars */
597: switch(cmd[i])
598: { case RETURN:
599: if (i == 0)
600: { echo("%s - WHICH WAY?",fullcmd);
601: BEEP;
602: return;
603: }
604: break;
605: case '0':
606: if (i == 1) /* can't be second char */
607: { ok = 0;
608: break;
609: }
610: pl->a_dxnew = 0;
611: pl->a_dynew = 0;
612: pl->a_turn = 0;
613: pl->a_clear = 0;
614: pl->a_hold = 0;
615: echo("%s - ROGER",fullcmd);
616: cmds++;
617: icmds++;
618: return;
619: case 'N':
620: newy = -1;
621: break;
622: case 'S':
623: newy = 1;
624: break;
625: case 'E':
626: newx = 1;
627: break;
628: case 'W':
629: newx = -1;
630: break;
631: default: /* numbers (e.g.) no longer acceptable */
632: ok = 0;
633: break;
634: }
635: if (ok)
636: { echo("%s - ROGER",fullcmd);
637: cmds++;
638: icmds++;
639: pl->a_turn = dir; /* will replace 'T' with 'L' or 'R' */
640: pl->a_dxnew = newx; pl->a_dynew = newy;
641: pl->a_hold = pl->a_clear = 0;
642: if (dir == 'T')
643: { newx = pl->a_dx; /* start with this direction */
644: newy = pl->a_dy; /* and turn until done */
645: for (turncount = 1; turncount < 9; turncount++)
646: if (turn(&newx,&newy,'L',pl->a_dxnew,pl->a_dynew))
647: break;
648: if (turncount <= 4) pl->a_turn = 'L';
649: else pl->a_turn = 'R';
650: }
651: }
652: else
653: { echo("%s - UNABLE",fullcmd);
654: BEEP;
655: }
656: }
657:
658: echo(format,cmd)
659: char *format,*cmd;
660: { char *c;
661: char mbuf[BUFSIZE];
662:
663: for (c=cmd; *c; c++) if (*c == RETURN) *c = 0;
664: sprintf(mbuf,format,cmd);
665: msg(cmdx,cmdy-1,mbuf);
666: }
667:
668: int parity = 0; /* props move every other update */
669:
670: update()
671: { parity = 1 - parity;
672: last_update -= UPDATE; /* must average out to every UPDATE secs */
673: moveplanes();
674: printplans();
675: if (bigname) activity();
676: }
677:
678: activity() /* number of active planes to megastats file */
679: { register int i,active,waiting,approaching,planned;
680: struct astruct *p;
681:
682: for (i=active=waiting=approaching=planned=0; i < nplanes; i++)
683: { p = &plane[i];
684: switch(p->a_active)
685: { case ACTIVE:
686: active++;
687: break;
688: case WAITING:
689: waiting++;
690: break;
691: case APPROACHING:
692: approaching++;
693: break;
694: }
695: if (p->a_plan && p->a_active != DONE) planned++;
696: }
697: fprintf(bigstatsfile,"%5d: %d active, %d approaching, %d waiting. ",
698: initgame_time - game_time, active,approaching,waiting);
699: fprintf(bigstatsfile,"%d planned.\n",planned);
700: for (i = 0; i < nplanes; i++)
701: { int a;
702:
703: p = &plane[i];
704: a = p->a_active;
705: if (a == ACTIVE || a == APPROACHING || a == WAITING)
706: { p->a_load += active;
707: p->a_ticks++;
708: p->a_planned += planned;
709: }
710: if (a == APPROACHING || a == WAITING)
711: { p->a_aprev += active;
712: p->a_prev++;
713: p->a_pprev += planned;
714: p->a_pplanned = (p->a_plan? YES : NO);
715: }
716: }
717: }
718:
719: moveplanes()
720: { register struct astruct *pl;
721: register int i,j;
722: register int nextx,nexty;
723: int ax,ay,oldx,oldy;
724: struct pstruct *dst;
725:
726: for (pl = &plane[i = 0]; i < PMAX; i++, pl++)
727: { if (parity && pl->a_type == PROP)
728: { pl->a_lastz = pl->a_z;
729: if (pl->a_active == LANDING) pl->a_active = DONE;
730: continue;
731: }
732: switch(pl->a_active)
733: { case INACTIVE:
734: if (initgame_time - game_time + FPTHRESH>= pl->a_stime
735: && !pl->a_sair)
736: pl->a_active = APPROACHING;
737:
738: case APPROACHING:
739: if (initgame_time - game_time>= pl->a_stime)
740: { pl->a_active = ACTIVE;
741: if (pl->a_sair) pl->a_active = WAITING;
742: nextx = pl->a_x;
743: nexty = pl->a_y;
744: }
745: break;
746:
747: case LANDING: /* to allow for conflicts */
748: pl->a_active = DONE;
749: break;
750:
751: case ACTIVE:
752: pl->a_dist++; /* increment distance traveled */
753: nextx = pl->a_x + pl->a_dx;
754: nexty = pl->a_y + pl->a_dy;
755: if (nextx < 0 || nexty < 0 ||
756: nextx >= width || nexty >= height)
757: { leavescreen(pl);
758: break;
759: }
760:
761: /* turning? */
762: if (pl->a_turn) /* turn 1 tick in right direction */
763: if (turn(&pl->a_dx,&pl->a_dy,
764: pl->a_turn,pl->a_dxnew,pl->a_dynew))
765: pl->a_turn = pl->a_dxnew = pl->a_dynew = 0;
766:
767:
768: if (pl->a_dair) /* landing? */
769: { dst = &airport[pl->a_dest];
770: ax = dst->p_x;
771: ay = dst->p_y;
772: if (ax == nextx && ay == nexty)
773: if (pl->a_z == 0 &&
774: pl->a_dx == dst->p_dx &&
775: pl->a_dy == dst->p_dy)
776: { pl->a_active = LANDING; /* landed */
777: erase(pl->a_x,pl->a_y);
778: pl->a_x = nextx;
779: pl->a_y = nexty;
780: remain--;
781: }
782: else if (pl->a_nextz == 0) /* flyby */
783: { pl->a_nextz = 1; /* down too late*/
784: goaround++;
785: report(GOAROUND,pl);
786: }
787: }
788:
789: /* changing altitude? */
790: if (pl->a_z > pl->a_nextz)
791: pl->a_lastz = pl->a_z--;
792: else if (pl->a_z < pl->a_nextz)
793: pl->a_lastz = pl->a_z++;
794: else pl->a_lastz = pl->a_z;
795:
796: /* out of fuel? */
797: if (--pl->a_fuel <= 0)
798: { crash++;
799: report(CRASH,pl);
800: pl->a_active = DONE;
801: remain--;
802: erase(pl->a_x,pl->a_y);
803: }
804: if (pl->a_type == JET) fuelused += 5;
805: else fuelused += 1;
806: break;
807:
808: case WAITING: /* waiting for takeoff */
809: if (--pl->a_fuel <= 0) /* out of fuel on ground? */
810: { fuel++;
811: if (bigname) freport(pl);
812: report(FUEL,pl);
813: pl->a_active = DONE;
814: remain--;
815: }
816: if (pl->a_nextz != 0)
817: { pl->a_z++; /* take off */
818: pl->a_active = ACTIVE;
819: pl->a_dist++;
820: }
821: nextx = pl->a_x + pl->a_dx;
822: nexty = pl->a_y + pl->a_dy;
823:
824: /* turning? */
825: if (pl->a_turn) /* turn 1 tick in right direction */
826: if (turn(&pl->a_dx,&pl->a_dy,
827: pl->a_turn,pl->a_dxnew,pl->a_dynew))
828: pl->a_turn = pl->a_dxnew = pl->a_dynew = 0;
829:
830: if (pl->a_type == JET) fuelused += 5;
831: else fuelused += 1;
832: break;
833:
834: case DONE: /* off the screen */
835: break;
836: }
837: if (pl->a_active != ACTIVE) continue;
838: oldx = pl->a_x;
839: oldy = pl->a_y;
840: pl->a_x = nextx;
841: pl->a_y = nexty;
842: cursor(nextx,nexty);
843: printf("%c%c",pl->a_id,(pl->a_z>9? '^' : pl->a_z+'0'));
844: erase(oldx,oldy);
845: if (pl->a_hold || pl->a_clear)
846: for (j = 0; j < nnavaid; j++) /* at a navaid? */
847: if (screen[nextx][nexty] == navaid[j].p_sym)
848: { donavaid(pl); /* right navaid? */
849: break;
850: }
851: }
852: conflict();
853: delays(); /* execute any applicable delayed commands */
854: }
855:
856: freport(pl) /* report to big stats file about tow truck */
857: struct astruct *pl;
858: {
859: fprintf(bigstatsfile,"%5d: %c out of fuel on runway.\n",
860: initgame_time - game_time,pl->a_id);
861: }
862:
863: delays() /* execute any applicable delayed actions */
864: { register struct astruct *p;
865: register int i;
866: register struct list *l,*last;
867:
868: /* for each plane, if it is active and if it has a command pending,
869: * and if it is at the right place for the command, then execute it.
870: */
871: for (i = 0; i < PMAX; i++)
872: { p = &plane[i];
873: if (p->a_active != ACTIVE) continue;
874: if (p->a_plan == 0) continue;
875: last = 0;
876: for (l = p->a_plan; l; )
877: { if (p->a_x != l->l_x || p->a_y != l->l_y)
878: {
879: last = l;
880: l = l->l_next;
881: }
882: else /* it matched */
883: {
884: parse(l->l_cmd); /* execute the command */
885:
886: /* now delete the command from the list */
887: if (last == 0) /* it was the first one */
888: { p->a_plan = l->l_next;
889: free(l);
890: l = p->a_plan;
891: /* last stays at 0 */
892: }
893: else
894: { last->l_next = l->l_next;
895: free(l);
896: l = last->l_next;
897: /* last stays where it was */
898: }
899: }
900: }
901: }
902: }
903:
904: donavaid(pl) /* take appropriate action at navaid */
905: struct astruct *pl; /* the plane has either been vectored or told to hold */
906: { register struct pstruct *d;
907: register int i;
908:
909: if (pl->a_hold)
910: { pl->a_hold = 2; /* will be holding now */
911: pl->a_turn = 'L'; /* and turning continuously to the left */
912: pl->a_dxnew = pl->a_dx; /* until it reaches this heading agn*/
913: pl->a_dynew = pl->a_dy;
914: }
915: if (pl->a_clear)
916: { pl->a_turn = pl->a_dxnew = pl->a_dynew = pl->a_hold = 0;
917: /* see what we're vectoring to */
918: for (d = &entry[i=0]; i < nentry; i++,d++)
919: if (d->p_sym == pl->a_clear) break;
920: if (i != nentry) /* yes, it was a navaid */
921: { pl->a_dx = -d->p_dx; /* opposite of entry heading*/
922: pl->a_dy = -d->p_dy;
923: pl->a_clear = 0;
924: return;
925: }
926: for (d = &airport[i=0]; i < nairport; i++,d++)
927: if (d->p_sym == pl->a_clear) break;
928: if (i == nairport) return; /* program bug - cleared to ?? */
929: pl->a_dx = d->p_dx; /* assume landing heading for airport */
930: pl->a_dy = d->p_dy;
931: pl->a_clear = 0;
932:
933: if (pl->a_hold == 1)
934: pl->a_hold = pl->a_dxnew = pl->a_dynew = 0;
935: else if (pl->a_hold == 0)
936: pl->a_dxnew = pl->a_dynew = 0;
937: return;
938: }
939: }
940:
941: turn(newx,newy,direc,dx,dy) /* messy - enumeration of all cases */
942: int *newx,*newy; /* returned values of new heading */
943: char direc;
944: int dx,dy;
945: { int x,y;
946:
947: x = *newx;
948: y = *newy;
949: switch(direc)
950: { case 'L': /* cases would be more efficient, but this is clearer*/
951: if (x== -1 && y== -1) {*newx= -1; *newy= 0; break;}
952: if (x== -1 && y== 0) {*newx= -1; *newy= 1; break;}
953: if (x== -1 && y== 1) {*newx= 0; *newy= 1; break;}
954: if (x== 0 && y== -1) {*newx= -1; *newy= -1; break;}
955: if (x== 0 && y== 1) {*newx= 1; *newy= 1; break;}
956: if (x== 1 && y== -1) {*newx= 0; *newy= -1; break;}
957: if (x== 1 && y== 0) {*newx= 1; *newy= -1; break;}
958: if (x== 1 && y== 1) {*newx= 1; *newy= 0; break;}
959: break;
960: case 'R':
961: if (x== -1 && y== -1) {*newx= 0; *newy= -1; break;}
962: if (x== -1 && y== 0) {*newx= -1; *newy= -1; break;}
963: if (x== -1 && y== 1) {*newx= -1; *newy= 0; break;}
964: if (x== 0 && y== -1) {*newx= 1; *newy= -1; break;}
965: if (x== 0 && y== 1) {*newx= -1; *newy= 1; break;}
966: if (x== 1 && y== -1) {*newx= 1; *newy= 0; break;}
967: if (x== 1 && y== 0) {*newx= 1; *newy= 1; break;}
968: if (x== 1 && y== 1) {*newx= 0; *newy= 1; break;}
969: break;
970: }
971: if (*newx == dx && *newy == dy) return(1); /* finished turn */
972: else return(0);
973: }
974:
975:
976: report(error,plane1,plane2)
977: int error;
978: struct astruct *plane1,*plane2;
979: { char mbuf[BUFSIZE];
980: int i;
981:
982: putchar(BELL);
983: switch(error)
984: { case FUEL:
985: sprintf(mbuf,"Tow truck called for %c (%c)",
986: plane1->a_id,airport[plane1->a_start].p_sym);
987: break;
988: case CRASH:
989: sprintf(mbuf,"PLANE %c OUT OF GAS",plane1->a_id);
990: break;
991: case BOUND:
992: sprintf(mbuf,"Boundary error - %c",plane1->a_id);
993: break;
994: case SYSTEM:
995: sprintf(mbuf,"%c AND %c: SYSTEM ERROR",
996: plane1->a_id, plane2->a_id);
997: break;
998: case GOAROUND:
999: sprintf(mbuf,"%c missed approach",plane1->a_id);
1000: break;
1001: case OUTOFTIME:
1002: sprintf(mbuf,"Out of time: %d remain",remain);
1003: break;
1004: }
1005: msg(cmdx,cmdy+2,mbuf);
1006: }
1007:
1008:
1009:
1010: leavescreen(pl)
1011: struct astruct *pl;
1012: { struct pstruct *e;
1013:
1014: pl->a_active = DONE;
1015: pl->a_dist++;
1016: erase(pl->a_x,pl->a_y);
1017: remain--;
1018: e = &entry[pl->a_dest];
1019: if (pl->a_z == 5 && !pl->a_dair && /* leaving at non-airport, 5K' */
1020: screen[pl->a_x][pl->a_y] == e->p_sym && /* right exit */
1021: pl->a_dx == -e->p_dx && pl->a_dy == -e->p_dy && /* right direc */
1022: pl->a_turn == 0) /* and not turning */
1023: return(0);
1024: bound++;
1025: if (bigname)
1026: { fprintf(bigstatsfile,"%5d: Boundary error - plane %c ",
1027: initgame_time - game_time,pl->a_id);
1028: fprintf(bigstatsfile,"left at %d000' ",pl->a_z);
1029: if (pl->a_nextz > pl->a_z)
1030: fprintf(bigstatsfile,"climbing to %d000'",pl->a_nextz);
1031: if (pl->a_nextz < pl->a_z)
1032: fprintf(bigstatsfile,"descending to %d000'",pl->a_nextz);
1033: fprintf(bigstatsfile,
1034: "\n\tPosition: (%d,%d) Bearing: ",pl->a_x,pl->a_y);
1035: if (pl->a_dy < 0) fprintf(bigstatsfile,"N");
1036: else if (pl->a_dy > 0) fprintf(bigstatsfile,"S");
1037: if (pl->a_dx > 0) fprintf(bigstatsfile,"E");
1038: else if (pl->a_dx < 0) fprintf(bigstatsfile,"W");
1039: if (pl->a_turn)
1040: { fprintf(bigstatsfile," turning %c to ",pl->a_turn);
1041: if (pl->a_dynew < 0) fprintf(bigstatsfile,"N");
1042: else if (pl->a_dynew > 0) fprintf(bigstatsfile,"S");
1043: if (pl->a_dxnew > 0) fprintf(bigstatsfile,"E");
1044: else if (pl->a_dxnew < 0) fprintf(bigstatsfile,"W");
1045: }
1046: fprintf(bigstatsfile,".\n");
1047: }
1048: report(BOUND,pl);
1049: return(0);
1050: }
1051:
1052: conflict() /* check each pair of planes for problems */
1053: { register struct astruct *q,*p;
1054: register int i,j,k;
1055: register int miss;
1056:
1057: for (p = &plane[k=1]; k < nplanes; k++,p++)
1058: { if (p->a_active != ACTIVE && p->a_active != LANDING) continue;
1059: for (q = &plane[i=0]; i < k; i++,q++)
1060: { if (q->a_active != ACTIVE) continue;
1061: if (q->a_z != p->a_z && q->a_z != p->a_lastz &&
1062: q->a_lastz != p->a_z && q->a_lastz != p->a_lastz)
1063: continue;
1064: miss = abs(q->a_x - p->a_x);
1065: j = abs(q->a_y - p->a_y);
1066: if (j>miss) miss=j;
1067: if (miss < 3) /* too close - system error */
1068: { system++;
1069: if (bigname) bigsyserr(p,q);
1070: report(SYSTEM,p,q);
1071: break;
1072: }
1073: }
1074: }
1075: }
1076:
1077: bigsyserr(p,q) /* spew sys err info into the big stats file */
1078: struct astruct *p,*q;
1079: {
1080: fprintf(bigstatsfile,
1081: "%5d: System error between %c (%d,%d,%d000) and %c (%d,%d,%d000)\n",
1082: initgame_time - game_time,p->a_id,p->a_x,p->a_y,p->a_z,
1083: q->a_id,q->a_x,q->a_y,q->a_z);
1084: }
1085:
1086: erase(x,y)
1087: int x,y;
1088: { register struct astruct *p;
1089: register int i;
1090:
1091: if (x<0 || y < 0) return;
1092: if (x>=width || y>=height) return;
1093: cursor(x,y);
1094: printf("%c ",screen[x][y]);
1095: for (p = &plane[i=0]; i < nplanes; i++,p++)
1096: if (p->a_active == ACTIVE && x == p->a_x && y == p->a_y)
1097: { cursor(x,y);
1098: printf("%c%c",p->a_id,(p->a_z>9?'^':p->a_z+'0'));
1099: }
1100: }
1101:
1102:
1103: int msglen[MAXHEIGHT]; /* length of message string on this row */
1104:
1105: init()
1106: { int i,j;
1107: char c,mbuf[BUFSIZE];
1108: int pcompare();
1109: FILE *statfile;
1110: struct passwd *pw;
1111: time_t now;
1112: char *p,*ct;
1113: extern char *ctime();
1114: int nearlies;
1115:
1116: if ((statfile = fopen(STATSFILE,"a")) != NULL)
1117: { pw = getpwuid(getuid());
1118: now = get_time();
1119: ct = ctime(&now);
1120: for (p= &ct[4]; p <= &ct[16]; p++) fputc(*p,statfile);
1121: fprintf(statfile,"%8s\n",pw->pw_name);
1122: fclose(statfile);
1123: }
1124:
1125: /* go into raw mode, no echo */
1126: if (!moviefile)
1127: { ioctl(0, TIOCGETP, &tty_setting);
1128: tty_flags = tty_setting.sg_flags;
1129: #ifdef CBREAK
1130: tty_setting.sg_flags |= CBREAK;
1131: tty_setting.sg_flags &= ~CRMOD;
1132: #else
1133: tty_setting.sg_flags |= RAW;
1134: #endif
1135: tty_setting.sg_flags &= ~ECHO;
1136: ioctl(0, TIOCSETP, &tty_setting);
1137: if (signal (SIGINT, SIG_IGN) != SIG_IGN)
1138: signal (SIGINT, catchint);
1139: if (signal (SIGQUIT, SIG_IGN) != SIG_IGN)
1140: signal (SIGQUIT, catchint);
1141: }
1142:
1143: for (i = 0; i < MAXHEIGHT; i++)
1144: msglen[i] = 0;
1145:
1146: for (i=0; i<MAXWIDTH; i++) for (j=0; j<MAXHEIGHT; j++)
1147: screen[i][j] = '.';
1148:
1149: if (moviefile)
1150: { if ((movie = fopen(moviefile,"r")) == NULL)
1151: err("Cannot open %s for reading.\n",moviefile);
1152: minit(); /* initialize from movie file */
1153: }
1154:
1155: if (seed == 0) seed = get_time();
1156: initseed = seed;
1157: #ifdef vax
1158: srand(seed);
1159: #else
1160: srandom(seed); /* initialize random number generator */
1161: #endif
1162:
1163: clearscreen();
1164: readspace();
1165:
1166:
1167: cmdx = width; /* start command just to right of display */
1168: cmdy = height-4; /* and a ways from the bottom */
1169: display(); /* initial display */
1170: for (i=0; i<nairport; i++)
1171: { sprintf(mbuf,"%c : %c%c",
1172: screen[airport[i].p_x][airport[i].p_y],
1173: (j = airport[i].p_dy) == 1 ? 'S' : j == -1 ? 'N' : ' ',
1174: (j = airport[i].p_dx) == 1 ? 'E' : j == -1 ? 'W' : ' ');
1175: msg(cmdx,cmdy-2-i,mbuf);
1176: }
1177:
1178: cdltop.c_next = 0; /* initially no clearance directive lists */
1179: cdltop.c_list = 0;
1180:
1181: while (game_time < 16*60 || game_time > 99*60+59) /*get time from user */
1182: { char buf[100];
1183: char *p;
1184: cursor(cmdx,cmdy);
1185: printf("< >");
1186: cursor(cmdx,cmdy);
1187:
1188: /* move the cursor one space to the right */
1189: p = buf;
1190: tgetstr ("nd", &p);
1191: fwrite (buf, sizeof (*buf), p-buf, stdout);
1192:
1193: game_time = getdigit()*10; /* get the time as 2 digits */
1194: game_time += getdigit();
1195: initgame_time = game_time = game_time*60+59;
1196: }
1197:
1198: if (protofile) /* keeping a protocol of the whole game */
1199: { if ((proto = fopen(protofile,"w")) == NULL)
1200: err("Cannot open %s for writing.\n",protofile);
1201: protostats(proto);
1202: }
1203:
1204: if (bigname) /* megastatistics requested */
1205: { if ((bigstatsfile = fopen(bigname,"w")) == NULL)
1206: err("Cannot open %s for writing.\n",bigname);
1207: protostats(bigstatsfile);
1208: if (protofile)
1209: fprintf(bigstatsfile,"Protocol from %s\n",protofile);
1210: }
1211:
1212: last_update = initgame_time+UPDATE; /* force early update */
1213: if (moviefile) last_update += OFFSET;
1214:
1215: for (i=nearlies=0; i<nplanes; i++) /* construct 26 flight plans */
1216: { plane[i].a_id = 'A'+i;
1217: flightplan(&plane[i],0);
1218: if (plane[i].a_stime < FPTHRESH) nearlies++;
1219: }
1220: for (i=nearlies; i < NEARLY; i++) /* ensure 2 or so planes in 1st minute */
1221: flightplan(&plane[die(nplanes)],1);
1222: qsort(plane,nplanes,sizeof (struct astruct),pcompare);
1223: remain = nplanes;
1224: if (bigname)
1225: for (i = 0; i < nplanes; i++)
1226: strip(&plane[i],-1,TERSE);
1227:
1228: for (i=0; i<nairport; i++) /* erase the approaches */
1229: delmsg(cmdx,cmdy-2-i);
1230: start_time = get_time();
1231: }
1232:
1233: protostats(proto) /* bunch of statistics for protocols and stuff */
1234: FILE *proto;
1235: { char wd[100]; /* result of a "pwd" command */
1236: FILE *pwd;
1237: char *s,*t,*u;
1238: int c;
1239:
1240: if ((pwd = popen("pwd","r")) == NULL)
1241: err("Cannot open a pipe to pwd.\n");
1242: for (s = wd; (c = getc(pwd)) != EOF;)
1243: if (c != '\n') *s++ = c;
1244: t = s; /* here's where to put the filename */
1245: *s = 0;
1246: fclose(pwd);
1247: if (*airfile != '/') /* relative airspace file */
1248: { s = t;
1249: *s++ = '/';
1250: for (u = airfile; *s++ = *u++; );
1251: fprintf(proto,"Airspace file: %s\n",wd);
1252: }
1253: else fprintf(proto,"Airspace file: %s\n",airfile);
1254: fprintf(proto,"Airspace: %s\n",airspace);
1255: if (flowfile)
1256: { if (*flowfile != '/') /* relative flowfile */
1257: { s = t;
1258: *s++ = '/';
1259: for (u = flowfile; *s++ = *u++; );
1260: fprintf(proto,"Flow file: %s\n",wd);
1261: }
1262: else fprintf(proto,"Flow file: %s\n",flowfile);
1263: }
1264: else fprintf(proto,"Flow file: \n");
1265: fprintf(proto,"Seed: %d\n",seed);
1266: fprintf(proto,"Time: %d seconds\n",game_time);
1267: }
1268:
1269: minit() /* initialize the game from a protocol file */
1270: { /* the file is open on stream "movie" */
1271: char buffer[80];
1272: static char airfilebuf[80];
1273: static char airbuf[80];
1274: static char flowbuf[80];
1275: char *s,*t;
1276:
1277: if (fgets(buffer,80,movie) == 0) /* airspace file line */
1278: err("Unexpected EOF on movie file.\n");
1279: for (s = buffer; *s != ':' && *s; s++); /* scan to colon */
1280: if (*s == 0) err("Bad airspace file line.\n");
1281: s++; s++; /* skip colon and space */
1282: for (t = airfilebuf; (*t++ = *s++) != '\n';); /* copy airspace file */
1283: *--t = 0;
1284: airfile = airfilebuf; /* and dummy the pointer */
1285: if (fgets(buffer,80,movie) == 0) /* airspace line */
1286: err("Unexpected EOF on movie file.\n");
1287: for (s = buffer; *s != ':' && *s; s++); /* scan to colon */
1288: if (*s == 0) err("Bad airspace line.\n");
1289: s++; s++; /* skip colon and space */
1290: for (t = airbuf; (*t++ = *s++) != '\n';); /* copy airspace name */
1291: *--t = 0;
1292: airspace = airbuf; /* and dummy the pointer */
1293: if (fgets(buffer,80,movie) == 0) /* flowfile line */
1294: err("Unexpected EOF on movie file.\n");
1295: for (s = buffer; *s != ':' && *s; s++); /* scan to colon */
1296: if (*s == 0) err("Bad flowfile line.\n");
1297: s++; s++; /* skip colon and space */
1298: if (*s == '\n') flowfile = 0;
1299: else
1300: { for (t = flowbuf; (*t++ = *s++) != '\n';); /* copy flowfile */
1301: *--t = 0;
1302: flowfile = flowbuf; /* and dummy the pointer */
1303: }
1304: if (fgets(buffer,80,movie) == 0) /* seed */
1305: err("Unexpected EOF on movie file.\n");
1306: for (s = buffer; *s != ':' && *s; s++); /* scan to colon */
1307: if (*s == 0) err("Bad seed line.\n");
1308: s++; s++; /* skip colon and space */
1309: seed = atoi(s);
1310: if (fgets(buffer,80,movie) == 0) /* time line */
1311: err("Unexpected EOF on movie file.\n");
1312: for (s = buffer; *s != ':' && *s; s++); /* scan to colon */
1313: if (*s == 0) err("Bad time line.\n");
1314: s++; s++; /* skip colon and space */
1315: initgame_time = game_time = atoi(s);
1316: getmcmd(); /* get the first command from movie mode */
1317: }
1318:
1319: getmcmd() /* read a command and store time and command */
1320: { static char buff[80];
1321: char *s;
1322:
1323: if (fgets(buff,80,movie) == 0)
1324: { mcommand = "";
1325: nextmovie = -20;
1326: fclose(movie);
1327: return;
1328: }
1329: for (s = buff; *s == ' '; s++); /* skip initial blanks */
1330: nextmovie = atoi(s);
1331: while (*s++ != ' '); /* skip to the command */
1332: mcommand = s; /* and save it in a global */
1333: for (; *s; s++) if (*s == '\n') *s = RETURN;
1334: }
1335:
1336: pcompare(p1,p2) /* compare start times for sorting the plane list */
1337: struct astruct *p1,*p2;
1338: { if ((p1)->a_stime < (p2)->a_stime) return(-1);
1339: else if ((p1)->a_stime == (p2)->a_stime) return(0);
1340: else return(1);
1341: }
1342:
1343:
1344: printplans() /* flight plans for active and near-active planes */
1345: { register int ctr; /* can only keep cmdy-2 planes on the screen */
1346: register struct astruct *p;
1347: register int i;
1348:
1349: for (i = ctr = 0, p = &plane[0]; i < nplanes && ctr < cmdy - 2; i++,p++)
1350: if (p->a_active == APPROACHING || p->a_active == WAITING)
1351: strip(p,ctr++,TERSE);
1352: delmsg(cmdx,ctr++); /* blank line between approaching and active*/
1353: for (p = &plane[i=0]; i < nplanes && ctr < cmdy - 2; i++,p++)
1354: if (p->a_active == ACTIVE)
1355: strip(p,ctr++,TERSE);
1356: while (ctr < cmdy - 2) delmsg(cmdx,ctr++); /* delete any msg on line*/
1357: }
1358:
1359: strip(p,y,outstyle) /* display flight strip for this plane on cmd row y */
1360: register struct astruct *p;
1361: int y,outstyle;
1362: { char mbuf[80]; /* plan message to appear */
1363: int pfuel;
1364: struct list *l;
1365: char *s;
1366:
1367: if (p->a_active == WAITING) sprintf(mbuf," ");
1368: else if (p->a_active == APPROACHING)
1369: sprintf(mbuf,"%d ",
1370: (p->a_stime - initgame_time + game_time + 14) / 15);
1371: else mbuf[0] = 0;
1372: sprintf(&mbuf[strlen(mbuf)],"%c%c %c->%c ",
1373: p->a_id,
1374: (p->a_type? 'j': 'p'),
1375: screen[p->a_x][p->a_y],
1376: (p->a_dair? airport[p->a_dest].p_sym :
1377: entry[p->a_dest].p_sym));
1378: sprintf(&mbuf[strlen(mbuf)],"%d%c%c ",
1379: p->a_z,
1380: (p->a_nextz > p->a_z ? '^' :
1381: p->a_nextz < p->a_z ? 'v' : ' '),
1382: (p->a_nextz != p->a_z ? p->a_nextz + '0' : ' '));
1383: if (p->a_dy>0) sprintf(&mbuf[strlen(mbuf)],"S");
1384: else if (p->a_dy<0) sprintf(&mbuf[strlen(mbuf)],"N");
1385: if (p->a_dx>0) sprintf(&mbuf[strlen(mbuf)],"E");
1386: else if (p->a_dx<0) sprintf(&mbuf[strlen(mbuf)],"W");
1387: if (p->a_dy == 0) sprintf(&mbuf[strlen(mbuf)]," ");
1388: switch(p->a_hold)
1389: { case 2: sprintf(&mbuf[strlen(mbuf)]," h "); break;
1390: case 1: sprintf(&mbuf[strlen(mbuf)]," * "); break;
1391: case 0: sprintf(&mbuf[strlen(mbuf)]," %c ",p->a_turn-'A'+'a');
1392: break;
1393: }
1394: if (p->a_clear)
1395: sprintf(&mbuf[strlen(mbuf)],"* %c",p->a_clear);
1396: if (p->a_dynew>0) sprintf(&mbuf[strlen(mbuf)],"S");
1397: else if (p->a_dynew<0) sprintf(&mbuf[strlen(mbuf)],"N");
1398: if (p->a_dxnew>0) sprintf(&mbuf[strlen(mbuf)],"E");
1399: else if (p->a_dxnew<0) sprintf(&mbuf[strlen(mbuf)],"W");
1400: if (p->a_dynew == 0) sprintf(&mbuf[strlen(mbuf)]," ");
1401: pfuel = (p->a_type == JET? p->a_fuel/4 : p->a_fuel/2);
1402: sprintf(&mbuf[strlen(mbuf)]," %c",pfuel>=10?'+':pfuel+'0');
1403: if (p->a_plan)
1404: sprintf(&mbuf[strlen(mbuf)]," P");
1405: if (y < 0) /* flight strip to file, not screen */
1406: { if (bigname)
1407: { int st;
1408:
1409: st = p->a_stime;
1410: if (p->a_type == JET)
1411: { st = st / 15;
1412: st = st * 15;
1413: }
1414: else
1415: { st = (st + 45) / 30;
1416: st = (st * 30) - 15;
1417: }
1418: if (st < FIRST_TIME) st = FIRST_TIME;
1419: fprintf(bigstatsfile,"%5d: ",st);
1420: fprintf(bigstatsfile,"%s\n",mbuf);
1421: }
1422: }
1423: else
1424: { msg(cmdx,y,mbuf); /* display the string */
1425: if (outstyle == VERBOSE && p->a_plan)
1426: { for (l = p->a_plan; l; l = l->l_next)
1427: { sprintf(mbuf,"%s %s",l->l_loc,l->l_cmd);
1428: for (s = mbuf; *s; s++) if (*s == RETURN) *s = 0;
1429: msg(cmdx,++y,mbuf);
1430: }
1431: }
1432: while (++y < MAXHEIGHT && msglen[y]) msg(cmdx,y,"");/* clr old plans*/
1433: }
1434: }
1435:
1436: msg(x,y,string) /* put up a message at cursor position x,y */
1437: int x,y;
1438: char *string;
1439: { int i,l;
1440:
1441: cursor(x,y);
1442: printf("%s",string);
1443: l = strlen(string);
1444: for (i=l; i<msglen[y]; i++) putchar(' ');
1445: msglen[y] = l;
1446: }
1447:
1448: delmsg(x,y) /* delete any message starting at cursor posn x,y */
1449: int x,y;
1450: { int i;
1451:
1452: if (msglen[y] <= 0) return;
1453: cursor(x,y);
1454: for (i=0; i<msglen[y]; i++) putchar(' ');
1455: msglen[y] = 0;
1456: }
1457:
1458:
1459: flightplan(p,early)
1460: struct astruct *p;
1461: int early; /* 1 if this plane should be rescheduled for early arrival */
1462: { int i,r,cum;
1463: struct astruct *q;
1464: struct pstruct *loc;
1465:
1466: p->a_type = die(2);
1467: /* starting time: no planes in last 15 minutes; pretend interval
1468: * extends negatively from 0 by FUDGE seconds to make it more likely
1469: * that there will be planes available soon. On the other hand, no
1470: * plane can come on for the first FIRST_TIME seconds.
1471: */
1472: p->a_stime = die(FUDGE + game_time - 15*60) - FUDGE;
1473: if (early) p->a_stime = die(FPTHRESH);
1474: if (p->a_stime <FIRST_TIME) p->a_stime = FIRST_TIME;
1475: if (flowfile) /* flows have been specified */
1476: { r = die(maxflow);
1477: for (i = cum = 0; i < npaths; i++)
1478: { cum += fpath[i].f_freq;
1479: if (cum >= r) break;
1480: }
1481: if (i >= npaths) i = 0; /* shouldn't ever do this */
1482: p->a_sair = fpath[i].f_fair;
1483: p->a_dair = fpath[i].f_tair;
1484: p->a_hold = (p->a_dair && !p->a_sair? 1 : 0);
1485: p->a_start = fpath[i].f_from;
1486: p->a_dest = fpath[i].f_to;
1487:
1488: if (p->a_sair) loc = &airport[p->a_start];
1489: else loc = &entry[p->a_start];
1490: }
1491: else
1492: { p->a_sair = (die(inaptot+inawtot) <= inaptot? 1 : 0);
1493: p->a_dair = (die(outaptot+outawtot) <= outaptot? 1 : 0);
1494:
1495: p->a_hold = (p->a_dair? 1 : 0);
1496: if (p->a_sair)
1497: { p->a_start =pick(die(inaptot),&airport[0],nairport,1);
1498: loc = &airport[p->a_start];
1499: p->a_hold = 0;
1500: if (p->a_dair) p->a_dest = pick(die(inaptot),
1501: &airport[0],nairport,0);
1502: else p->a_dest = pick(die(inawtot),
1503: &entry[0],nentry,0);
1504: }
1505: else
1506: { p->a_start = pick(die(inawtot),&entry[0],nentry,0);
1507: loc = &entry[p->a_start];
1508: if (p->a_dair) p->a_dest = pick(die(inaptot),
1509: &airport[0],nairport,0);
1510: else do p->a_dest = pick(die(inawtot),
1511: &entry[0],nentry,0);
1512: while (p->a_dest == p->a_start);
1513: }
1514: }
1515: p->a_active = INACTIVE;
1516: p->a_z = (p->a_sair? 0 : 6);
1517: if (!p->a_sair) /* separate planes by 1000' altitude */
1518: for (q = &plane[0]; q != &plane[PMAX]; q++)
1519: { if (q == p && !early) break;
1520: if (q == p) continue;
1521: if (p->a_start == q->a_start)
1522: if (abs(q->a_stime - p->a_stime) < SAFETY)
1523: if (q->a_z >= p->a_z)
1524: p->a_z = q->a_z + 1;
1525: }
1526: if (flowfile && p->a_z < NALT)
1527: { p->a_opt = fpath[i].f_dist[p->a_z];
1528: p->a_cmds = fpath[i].f_cmds;
1529: }
1530: p->a_prev = p->a_pprev = p->a_aprev = 0;
1531: p->a_x = loc->p_x;
1532: p->a_y = loc->p_y;
1533: p->a_dx = loc->p_dx;
1534: p->a_dy = loc->p_dy;
1535: p->a_dxnew = p->a_dynew = 0;
1536: p->a_lastz = p->a_nextz = p->a_z;
1537: p->a_turn = 0;
1538: p->a_fuel = (p->a_type == JET ? JETFUEL : PROPFUEL);
1539: p->a_clear = 0; /* not cleared for any approach */
1540: p->a_plan = 0; /* no monitor points on the flight plan */
1541: p->a_load = p->a_ticks = p->a_planned = p->a_dist = 0;
1542: }
1543:
1544: pick(draw,point,num,in)
1545: int draw;
1546: struct pstruct *point;
1547: int num,in;
1548: { register int i,cum;
1549:
1550: for (i = cum = 0; i<num; i++,point++)
1551: { if (in) cum += point->p_inprop;
1552: else cum += point->p_outprop;
1553: if (cum >= draw) return(i);
1554: }
1555: return(0); /* should never get here */
1556: }
1557:
1558: #if !NRAND
1559: die(n) /* throw an n-sided die (sides 0 thru n-1) */
1560: int n;
1561: { int r;
1562:
1563: #ifdef vax
1564: r = rand() >> 10; /* rightmost bits are not very random */
1565: #else
1566: r = random(); /* rightmost bits are not very random */
1567: #endif
1568: return(r % n); /* enough resolution to make this o.k. */
1569: }
1570: #endif
1571:
1572: getdigit() /* keep reading chars from terminal until get a digit */
1573: { int c; /* returns digit - '0' */
1574:
1575: do {
1576: if (rubout) return 9;
1577: c = getchar() & 0177;
1578: } while (c < '0' || c > '9');
1579: putchar(c);
1580: return(c-'0');
1581: }
1582:
1583: time_t
1584: get_time() /* returns time in seconds since 1970 */
1585: {
1586: time_t t;
1587:
1588: time(&t);
1589: return(t); /* seconds since 1970 */
1590: }
1591:
1592:
1593: display() /* put up initial screen */
1594: { int i,j;
1595:
1596: for (j=0; j<height; j++)
1597: { cursor(0,j); /* general enough to extend to graphics */
1598: for (i=0; i<width; i++)
1599: { putchar(screen[i][j]);
1600: putchar(' ');
1601: }
1602: }
1603: }
1604:
1605:
1606: cursor(x,y) /* move to location x,y on WIDTHxHEIGHT screen */
1607: char x,y; /* this is in terms of screen, i.e. with x's 2 chars wide */
1608: {
1609: poscur(2*x,y);
1610: }
1611:
1612:
1613: poscur(x,y) /* position cursor at this absolute location on screen */
1614: char x,y;
1615: {
1616: char *tgoto();
1617: printf ("%s", tgoto (cmbuf, x, y));
1618: }
1619:
1620:
1621: clearscreen()
1622: {
1623: printf ("%s", clbuf);
1624: }
1625:
1626: char *
1627: plural(n) /* returns "s" unless n=1 */
1628: int n;
1629: { static char s[2] = "s";
1630:
1631: if (n != 1) return(s);
1632: else return("");
1633: }
1634:
1635: done(flag) /* clean up */
1636: int flag;
1637: { FILE *statfile;
1638: struct passwd *pw;
1639: time_t now;
1640: char *c,*ct;
1641: extern char *ctime();
1642:
1643: if (!moviefile)
1644: { tty_setting.sg_flags = tty_flags;/* put terminal back the way it was*/
1645: ioctl(0, TIOCSETP, &tty_setting);
1646: }
1647: if (flag) cursor(LEFT,height+1);
1648:
1649: if ((statfile = fopen(STATSFILE,"a")) != NULL)
1650: { pw = getpwuid(getuid());
1651: now = get_time();
1652: ct = ctime(&now);
1653: for (c= &ct[4]; c <= &ct[16]; c++) fputc(*c,statfile);
1654: if (!flag) fprintf(statfile,"%8s: aborted\n",pw->pw_name);
1655: else
1656: { fprintf(statfile,"%8s: %2d %3d %2d %2d %3d %5d %3d %2d",
1657: pw->pw_name,crash,system,fuel,bound,goaround,
1658: fuelused,cmds,remain);
1659: fprintf(statfile,". %d %2d %s\n",
1660: initseed,initgame_time/60,airspace);
1661: fclose(statfile);
1662: }
1663: }
1664: if (!flag) return;
1665: ttystats(stdout);
1666: if (bigname)
1667: { int i;
1668: float load,ticks,plans,route,d,stripped;
1669:
1670: for (i = 0; i < nplanes; i++)
1671: { load = plane[i].a_load;
1672: ticks = plane[i].a_ticks;
1673: plans = plane[i].a_planned;
1674: route = plane[i].a_opt;
1675: stripped = plane[i].a_prev;
1676: d = plane[i].a_dist;
1677: fprintf(bigstatsfile,
1678: "%c: %2d tks, %2d/%2d=%1.2f, %d, %.2f a/tk, %.2f p/tk, %.2f a/ptk, %.2f p/ptk, %c, %s\n",
1679: plane[i].a_id,plane[i].a_ticks,
1680: plane[i].a_dist,
1681: plane[i].a_opt,
1682: d/route,
1683: plane[i].a_cmds,
1684: load/ticks,
1685: plans/ticks,
1686: plane[i].a_aprev/stripped,
1687: plane[i].a_pprev/stripped,
1688: plane[i].a_sair? 'W' : 'A',
1689: plane[i].a_pplanned? "+P" : "-P"
1690: );
1691: }
1692: }
1693: if (bigname) ttystats(bigstatsfile);
1694: if (protofile) fclose(proto);
1695: if (bigname) fclose(bigstatsfile);
1696: }
1697:
1698: ttystats(file)
1699: FILE *file;
1700: { char *eol;
1701:
1702: if (file == bigstatsfile) eol = "\n";
1703: else {
1704: clearscreen();
1705: eol = "\n\r";
1706: }
1707: if (crash) fprintf(file,"%d plane%s out of fuel, crashed%s",
1708: crash,plural(crash),eol);
1709: if (system) fprintf(file,"%d system error%s%s",
1710: system,plural(system),eol);
1711: if (fuel) fprintf(file,"%d tow truck%s called%s",
1712: fuel,plural(fuel),eol);
1713: if (bound) fprintf(file,"%d boundary error%s%s",
1714: bound,plural(bound),eol);
1715: if (goaround) fprintf(file,"%d go-around%s%s",
1716: goaround,plural(goaround),eol);
1717: if (crash+system+fuel+bound+remain == 0)
1718: { fprintf(file,"GREAT JOB!! Have you considered a career in ATC?\n");
1719: fprintf(file,"Now try %d minutes...\n",initgame_time/60-5);
1720: }
1721: fprintf(file,"Fuel used: %d\n",fuelused);
1722: fprintf(file,"Commands issued (including deferred): %d\n",icmds);
1723: fprintf(file,"Commands executed: %d\n",cmds);
1724: fprintf(file,"Airspace: %s; seed: %d; time=%d; %d remaining.%s",
1725: airspace,initseed,initgame_time/60,remain,eol);
1726: if (file == bigstatsfile) fprintf(file,"\f");
1727: }
1728:
1729: err(msg,arg1,arg2)
1730: char *msg;
1731: { fprintf(stderr,msg,arg1,arg2);
1732: done(0);
1733: exit(1);
1734: }
1735:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.