games/atc/update.c

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