atc/update.c

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