1: /*      $NetBSD: update.c,v 1.12 2003/08/07 09:36:55 agc Exp $       */
    2: 
    3: /*-
    4:  * Copyright (c) 1990, 1993
    5:  *      The Regents of the University of California.  All rights reserved.
    6:  *
    7:  * This code is derived from software contributed to Berkeley by
    8:  * Ed James.
    9:  *
   10:  * Redistribution and use in source and binary forms, with or without
   11:  * modification, are permitted provided that the following conditions
   12:  * are met:
   13:  * 1. Redistributions of source code must retain the above copyright
   14:  *    notice, this list of conditions and the following disclaimer.
   15:  * 2. Redistributions in binary form must reproduce the above copyright
   16:  *    notice, this list of conditions and the following disclaimer in the
   17:  *    documentation and/or other materials provided with the distribution.
   18:  * 3. Neither the name of the University nor the names of its contributors
   19:  *    may be used to endorse or promote products derived from this software
   20:  *    without specific prior written permission.
   21:  *
   22:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32:  * SUCH DAMAGE.
   33:  */
   34: 
   35: /*
   36:  * Copyright (c) 1987 by Ed James, UC Berkeley.  All rights reserved.
   37:  *
   38:  * Copy permission is hereby granted provided that this notice is
   39:  * retained on all partial or complete copies.
   40:  *
   41:  * For more info on this and all of my stuff, mail edjames@berkeley.edu.
   42:  */
   43: 
   44: #include <sys/cdefs.h>
   45: #ifndef lint
   46: #if 0
   47: static char sccsid[] = "@(#)update.c    8.1 (Berkeley) 5/31/93";
   48: #else
   49: __RCSID("$NetBSD: update.c,v 1.12 2003/08/07 09:36:55 agc Exp $");
   50: #endif
   51: #endif /* not lint */
   52: 
   53: #include "include.h"
   54: 
   55: void
   56: update(dummy)
   57:         int dummy __attribute__((__unused__));
   58: {
   59:         int    i, dir_diff, unclean;
   60:         PLANE  *pp, *p1, *p2;
   61: 
   62: #ifdef SYSV
   63:         alarm(0);
   64:         signal(SIGALRM, update);
   65: #endif
   66: 
   67:         clck++;
   68: 
   69:         erase_all();
   70: 
   71:         /* put some planes in the air */
   72:         do {
   73:                 unclean = 0;
   74:                 for (pp = ground.head; pp != NULL; pp = pp->next) {
   75:                         if (pp->new_altitude > 0) {
   76:                                 delete(&ground, pp);
   77:                                 append(&air, pp);
   78:                                 unclean = 1;
   79:                                 break;
   80:                         }
   81:                 }
   82:         } while (unclean);
   83: 
   84:         /* do altitude change and basic movement */
   85:         for (pp = air.head; pp != NULL; pp = pp->next) {
   86:                 /* type 0 only move every other turn */
   87:                 if (pp->plane_type == 0 && clck & 1)
   88:                         continue;
   89: 
   90:                 pp->fuel--;
   91:                 if (pp->fuel < 0)
   92:                         loser(pp, "ran out of fuel.");
   93: 
   94:                 pp->altitude += SGN(pp->new_altitude - pp->altitude);
   95: 
   96:                 if (!pp->delayd) {
   97:                         dir_diff = pp->new_dir - pp->dir;
   98:                         /*
   99:                          * Allow for circle commands
  100:                          */
  101:                         if (pp->new_dir >= 0 && pp->new_dir < MAXDIR) {
  102:                                 if (dir_diff > MAXDIR/2)
  103:                                         dir_diff -= MAXDIR;
  104:                                 else if (dir_diff < -(MAXDIR/2))
  105:                                         dir_diff += MAXDIR;
  106:                         }
  107:                         if (dir_diff > 2)
  108:                                 dir_diff = 2;
  109:                         else if (dir_diff < -2)
  110:                                 dir_diff = -2;
  111:                         pp->dir += dir_diff;
  112:                         if (pp->dir >= MAXDIR)
  113:                                 pp->dir -= MAXDIR;
  114:                         else if (pp->dir < 0)
  115:                                 pp->dir += MAXDIR;
  116:                 }
  117:                 pp->xpos += displacement[pp->dir].dx;
  118:                 pp->ypos += displacement[pp->dir].dy;
  119: 
  120:                 if (pp->delayd && pp->xpos == sp->beacon[pp->delayd_no].x &&
  121:                     pp->ypos == sp->beacon[pp->delayd_no].y) {
  122:                         pp->delayd = 0;
  123:                         if (pp->status == S_UNMARKED)
  124:                                 pp->status = S_MARKED;
  125:                 }
  126: 
  127:                 switch (pp->dest_type) {
  128:                 case T_AIRPORT:
  129:                         if (pp->xpos == sp->airport[pp->dest_no].x &&
  130:                             pp->ypos == sp->airport[pp->dest_no].y &&
  131:                             pp->altitude == 0) {
  132:                                 if (pp->dir != sp->airport[pp->dest_no].dir)
  133:                                     loser(pp, "landed in the wrong direction.");
  134:                                 else {
  135:                                     pp->status = S_GONE;
  136:                                     continue;
  137:                                 }
  138:                         }
  139:                         break;
  140:                 case T_EXIT:
  141:                         if (pp->xpos == sp->exit[pp->dest_no].x &&
  142:                             pp->ypos == sp->exit[pp->dest_no].y) {
  143:                              if (pp->altitude != 9)
  144:                                     loser(pp, "exited at the wrong altitude.");
  145:                                 else {
  146:                                     pp->status = S_GONE;
  147:                                     continue;
  148:                                 }
  149:                         }
  150:                         break;
  151:                 default:
  152:                         loser(pp, "has a bizarre destination, get help!");
  153:                 }
  154:                 if (pp->altitude > 9)
  155:                         /* "this is impossible" */
  156:                         loser(pp, "exceded flight ceiling.");
  157:                 if (pp->altitude <= 0) {
  158:                         for (i = 0; i < sp->num_airports; i++)
  159:                                 if (pp->xpos == sp->airport[i].x &&
  160:                                     pp->ypos == sp->airport[i].y) {
  161:                                         if (pp->dest_type == T_AIRPORT)
  162:                                             loser(pp, 
  163:                                                 "landed at the wrong airport.");
  164:                                         else
  165:                                             loser(pp, 
  166:                                                 "landed instead of exited.");
  167:                                 }
  168:                         loser(pp, "crashed on the ground.");
  169:                 }
  170:                 if (pp->xpos < 1 || pp->xpos >= sp->width - 1 ||
  171:                     pp->ypos < 1 || pp->ypos >= sp->height - 1) {
  172:                         for (i = 0; i < sp->num_exits; i++)
  173:                                 if (pp->xpos == sp->exit[i].x &&
  174:                                     pp->ypos == sp->exit[i].y) {
  175:                                         if (pp->dest_type == T_EXIT)
  176:                                             loser(pp, 
  177:                                                 "exited via the wrong exit.");
  178:                                         else
  179:                                             loser(pp, 
  180:                                                 "exited instead of landed.");
  181:                                 }
  182:                         loser(pp, "illegally left the flight arena.");
  183:                 }
  184:         }
  185: 
  186:         /*
  187:          * Traverse the list once, deleting the planes that are gone.
  188:          */
  189:         for (pp = air.head; pp != NULL; pp = p2) {
  190:                 p2 = pp->next;
  191:                 if (pp->status == S_GONE) {
  192:                         safe_planes++;
  193:                         delete(&air, pp);
  194:                 }
  195:         }
  196: 
  197:         draw_all();
  198: 
  199:         for (p1 = air.head; p1 != NULL; p1 = p1->next)
  200:                 for (p2 = p1->next; p2 != NULL; p2 = p2->next)
  201:                         if (too_close(p1, p2, 1)) {
  202:                                 static char buf[80];
  203: 
  204:                                 (void)sprintf(buf, "collided with plane '%c'.",
  205:                                         name(p2));
  206:                                 loser(p1, buf);
  207:                         }
  208:         /*
  209:          * Check every other update.  Actually, only add on even updates.
  210:          * Otherwise, prop jobs show up *on* entrance.  Remember that
  211:          * we don't update props on odd updates.
  212:          */
  213:         if ((rand() % sp->newplane_time) == 0)
  214:                 addplane();
  215: 
  216: #ifdef SYSV
  217:         alarm(sp->update_secs);
  218: #endif
  219: }
  220: 
  221: const char *
  222: command(pp)
  223:         const PLANE    *pp;
  224: {
  225:         static char    buf[50], *bp, *comm_start;
  226: 
  227:         buf[0] = '\0';
  228:         bp = buf;
  229:         (void)sprintf(bp, "%c%d%c%c%d: ", name(pp), pp->altitude, 
  230:                 (pp->fuel < LOWFUEL) ? '*' : ' ',
  231:                 (pp->dest_type == T_AIRPORT) ? 'A' : 'E', pp->dest_no);
  232: 
  233:         comm_start = bp = strchr(buf, '\0');
  234:         if (pp->altitude == 0)
  235:                 (void)sprintf(bp, "Holding @ A%d", pp->orig_no);
  236:         else if (pp->new_dir >= MAXDIR || pp->new_dir < 0)
  237:                 strcpy(bp, "Circle");
  238:         else if (pp->new_dir != pp->dir)
  239:                 (void)sprintf(bp, "%d", dir_deg(pp->new_dir));
  240: 
  241:         bp = strchr(buf, '\0');
  242:         if (pp->delayd)
  243:                 (void)sprintf(bp, " @ B%d", pp->delayd_no);
  244: 
  245:         bp = strchr(buf, '\0');
  246:         if (*comm_start == '\0' && 
  247:             (pp->status == S_UNMARKED || pp->status == S_IGNORED))
  248:                 strcpy(bp, "---------");
  249:         return (buf);
  250: }
  251: 
  252: char
  253: name(p)
  254:         const PLANE    *p;
  255: {
  256:         if (p->plane_type == 0)
  257:                 return ('A' + p->plane_no);
  258:         else
  259:                 return ('a' + p->plane_no);
  260: }
  261: 
  262: int
  263: number(l)
  264:         char l;
  265: {
  266:         if (l < 'a' && l > 'z' && l < 'A' && l > 'Z')
  267:                 return (-1);
  268:         else if (l >= 'a' && l <= 'z')
  269:                 return (l - 'a');
  270:         else 
  271:                 return (l - 'A');
  272: }
  273: 
  274: int
  275: next_plane()
  276: {
  277:         static int     last_plane = -1;
  278:         PLANE          *pp;
  279:         int            found, start_plane = last_plane;
  280: 
  281:         do {
  282:                 found = 0;
  283:                 last_plane++;
  284:                 if (last_plane >= 26)
  285:                         last_plane = 0;
  286:                 for (pp = air.head; pp != NULL; pp = pp->next)
  287:                         if (pp->plane_no == last_plane) {
  288:                                 found++;
  289:                                 break;
  290:                         }
  291:                 if (!found)
  292:                         for (pp = ground.head; pp != NULL; pp = pp->next)
  293:                                 if (pp->plane_no == last_plane) {
  294:                                         found++;
  295:                                         break;
  296:                                 }
  297:         } while (found && last_plane != start_plane);
  298:         if (last_plane == start_plane)
  299:                 return (-1);
  300:         return (last_plane);
  301: }
  302: 
  303: int
  304: addplane()
  305: {
  306:         PLANE  p, *pp, *p1;
  307:         int    i, num_starts, close, rnd, rnd2, pnum;
  308: 
  309:         memset(&p, 0, sizeof (p));
  310: 
  311:         p.status = S_MARKED;
  312:         p.plane_type = random() % 2;
  313: 
  314:         num_starts = sp->num_exits + sp->num_airports;
  315:         rnd = random() % num_starts;
  316: 
  317:         if (rnd < sp->num_exits) {
  318:                 p.dest_type = T_EXIT;
  319:                 p.dest_no = rnd;
  320:         } else {
  321:                 p.dest_type = T_AIRPORT;
  322:                 p.dest_no = rnd - sp->num_exits;
  323:         }
  324: 
  325:         /* loop until we get a plane not near another */
  326:         for (i = 0; i < num_starts; i++) {
  327:                 /* loop till we get a different start point */
  328:                 while ((rnd2 = random() % num_starts) == rnd)
  329:                         ;
  330:                 if (rnd2 < sp->num_exits) {
  331:                         p.orig_type = T_EXIT;
  332:                         p.orig_no = rnd2;
  333:                         p.xpos = sp->exit[rnd2].x;
  334:                         p.ypos = sp->exit[rnd2].y;
  335:                         p.new_dir = p.dir = sp->exit[rnd2].dir;
  336:                         p.altitude = p.new_altitude = 7;
  337:                         close = 0;
  338:                         for (p1 = air.head; p1 != NULL; p1 = p1->next)
  339:                                 if (too_close(p1, &p, 4)) {
  340:                                         close++;
  341:                                         break;
  342:                                 }
  343:                         if (close)
  344:                                 continue;
  345:                 } else {
  346:                         p.orig_type = T_AIRPORT;
  347:                         p.orig_no = rnd2 - sp->num_exits;
  348:                         p.xpos = sp->airport[p.orig_no].x;
  349:                         p.ypos = sp->airport[p.orig_no].y;
  350:                         p.new_dir = p.dir = sp->airport[p.orig_no].dir;
  351:                         p.altitude = p.new_altitude = 0;
  352:                 }
  353:                 p.fuel = sp->width + sp->height;
  354:                 break;
  355:         }
  356:         if (i >= num_starts)
  357:                 return (-1);
  358:         pnum = next_plane();
  359:         if (pnum < 0)
  360:                 return (-1);
  361:         p.plane_no = pnum;
  362: 
  363:         pp = newplane();
  364:         if (pp == NULL)
  365:                 loser(NULL, "Out of memory!");
  366:         memcpy(pp, &p, sizeof (p));
  367: 
  368:         if (pp->orig_type == T_AIRPORT)
  369:                 append(&ground, pp);
  370:         else
  371:                 append(&air, pp);
  372: 
  373:         return (pp->dest_type);
  374: }
  375: 
  376: PLANE   *
  377: findplane(n)
  378:         int    n;
  379: {
  380:         PLANE  *pp;
  381: 
  382:         for (pp = air.head; pp != NULL; pp = pp->next)
  383:                 if (pp->plane_no == n)
  384:                         return (pp);
  385:         for (pp = ground.head; pp != NULL; pp = pp->next)
  386:                 if (pp->plane_no == n)
  387:                         return (pp);
  388:         return (NULL);
  389: }
  390: 
  391: int
  392: too_close(p1, p2, dist)
  393:         const PLANE    *p1, *p2;
  394:         int     dist;
  395: {
  396:         if (ABS(p1->altitude - p2->altitude) <= dist &&
  397:             ABS(p1->xpos - p2->xpos) <= dist && ABS(p1->ypos - p2->ypos) <= dist)
  398:                 return (1);
  399:         else
  400:                 return (0);
  401: }
  402: 
  403: int
  404: dir_deg(d)
  405:         int d;
  406: {
  407:         switch (d) {
  408:         case 0: return (0);
  409:         case 1: return (45);
  410:         case 2: return (90);
  411:         case 3: return (135);
  412:         case 4: return (180);
  413:         case 5: return (225);
  414:         case 6: return (270);
  415:         case 7: return (315);
  416:         default:
  417:                 return (-1);
  418:         }
  419: }