atc/update.c

   1 /*      $NetBSD: update.c,v 1.27 2015/06/25 05:33:02 dholland 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.27 2015/06/25 05:33:02 dholland Exp $");
  50 #endif
  51 #endif /* not lint */
  52
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <ctype.h>
  57
  58 #include "def.h"
  59 #include "struct.h"
  60 #include "extern.h"
  61 #include "tunable.h"
  62
  63 static int next_plane(void);
  64 static int too_close(const PLANE *p1, const PLANE *p2, int);
  65 static int dir_deg(int);
  66
  67 /* ARGSUSED */
  68 void
  69 update(int dummy __unused)
  70 {
  71         int dir_diff, unclean;
  72         unsigned i;
  73         PLANE   *pp, *p1, *p2;
  74
  75 #ifdef SYSV
  76         alarm(0);
  77         signal(SIGALRM, update);
  78 #endif
  79
  80         clck++;
  81
  82         erase_all();
  83
  84         /* put some planes in the air */
  85         do {
  86                 unclean = 0;
  87                 for (pp = ground.head; pp != NULL; pp = pp->next) {
  88                         if (pp->new_altitude > 0) {
  89                                 delete(&ground, pp);
  90                                 append(&air, pp);
  91                                 unclean = 1;
  92                                 break;
  93                         }
  94                 }
  95         } while (unclean);
  96
  97         /* do altitude change and basic movement */
  98         for (pp = air.head; pp != NULL; pp = pp->next) {
  99                 /* type 0 only move every other turn */
 100                 if (pp->plane_type == 0 && clck & 1)
 101                         continue;
 102
 103                 pp->fuel--;
 104                 if (pp->fuel < 0)
 105                         loser(pp, "ran out of fuel.");
 106
 107                 pp->altitude += SGN(pp->new_altitude - pp->altitude);
 108
 109                 if (!pp->delayd) {
 110                         dir_diff = pp->new_dir - pp->dir;
 111                         /*
 112                          * Allow for circle commands
 113                          */
 114                         if (pp->new_dir >= 0 && pp->new_dir < MAXDIR) {
 115                                 if (dir_diff > MAXDIR/2)
 116                                         dir_diff -= MAXDIR;
 117                                 else if (dir_diff < -(MAXDIR/2))
 118                                         dir_diff += MAXDIR;
 119                         }
 120                         if (dir_diff > 2)
 121                                 dir_diff = 2;
 122                         else if (dir_diff < -2)
 123                                 dir_diff = -2;
 124                         pp->dir += dir_diff;
 125                         if (pp->dir >= MAXDIR)
 126                                 pp->dir -= MAXDIR;
 127                         else if (pp->dir < 0)
 128                                 pp->dir += MAXDIR;
 129                 }
 130                 pp->xpos += displacement[pp->dir].dx;
 131                 pp->ypos += displacement[pp->dir].dy;
 132
 133                 if (pp->delayd && pp->xpos == sp->beacon[pp->delayd_no].x &&
 134                     pp->ypos == sp->beacon[pp->delayd_no].y) {
 135                         pp->delayd = false;
 136                         if (pp->status == S_UNMARKED)
 137                                 pp->status = S_MARKED;
 138                 }
 139
 140                 switch (pp->dest_type) {
 141                 case T_AIRPORT:
 142                         if (pp->xpos == sp->airport[pp->dest_no].x &&
 143                             pp->ypos == sp->airport[pp->dest_no].y &&
 144                             pp->altitude == 0) {
 145                                 if (pp->dir != sp->airport[pp->dest_no].dir)
 146                                     loser(pp, "landed in the wrong direction.");
 147                                 else {
 148                                     pp->status = S_GONE;
 149                                     continue;
 150                                 }
 151                         }
 152                         break;
 153                 case T_EXIT:
 154                         if (pp->xpos == sp->exit[pp->dest_no].x &&
 155                             pp->ypos == sp->exit[pp->dest_no].y) {
 156                                 if (pp->altitude != 9)
 157                                     loser(pp, "exited at the wrong altitude.");
 158                                 else {
 159                                     pp->status = S_GONE;
 160                                     continue;
 161                                 }
 162                         }
 163                         break;
 164                 default:
 165                         loser(pp, "has a bizarre destination, get help!");
 166                 }
 167                 if (pp->altitude > 9)
 168                         /* "this is impossible" */
 169                         loser(pp, "exceeded flight ceiling.");
 170                 if (pp->altitude <= 0) {
 171                         for (i = 0; i < sp->num_airports; i++)
 172                                 if (pp->xpos == sp->airport[i].x &&
 173                                     pp->ypos == sp->airport[i].y) {
 174                                         if (pp->dest_type == T_AIRPORT)
 175                                             loser(pp,
 176                                                 "landed at the wrong airport.");
 177                                         else
 178                                             loser(pp,
 179                                                 "landed instead of exited.");
 180                                 }
 181                         loser(pp, "crashed on the ground.");
 182                 }
 183                 if (pp->xpos < 1 || pp->xpos >= sp->width - 1 ||
 184                     pp->ypos < 1 || pp->ypos >= sp->height - 1) {
 185                         for (i = 0; i < sp->num_exits; i++)
 186                                 if (pp->xpos == sp->exit[i].x &&
 187                                     pp->ypos == sp->exit[i].y) {
 188                                         if (pp->dest_type == T_EXIT)
 189                                             loser(pp,
 190                                                 "exited via the wrong exit.");
 191                                         else
 192                                             loser(pp,
 193                                                 "exited instead of landed.");
 194                                 }
 195                         loser(pp, "illegally left the flight arena.");
 196                 }
 197         }
 198
 199         /*
 200          * Traverse the list once, deleting the planes that are gone.
 201          */
 202         for (pp = air.head; pp != NULL; pp = p2) {
 203                 p2 = pp->next;
 204                 if (pp->status == S_GONE) {
 205                         safe_planes++;
 206                         delete(&air, pp);
 207                 }
 208         }
 209
 210         draw_all();
 211
 212         for (p1 = air.head; p1 != NULL; p1 = p1->next)
 213                 for (p2 = p1->next; p2 != NULL; p2 = p2->next)
 214                         if (too_close(p1, p2, 1)) {
 215                                 static char     buf[80];
 216
 217                                 (void)snprintf(buf, sizeof(buf),
 218                                         "collided with plane '%c'.",
 219                                         name(p2));
 220                                 loser(p1, buf);
 221                         }
 222         /*
 223          * Check every other update.  Actually, only add on even updates.
 224          * Otherwise, prop jobs show up *on* entrance.  Remember that
 225          * we don't update props on odd updates.
 226          */
 227         if ((rand() % sp->newplane_time) == 0)
 228                 addplane();
 229
 230 #ifdef SYSV
 231         alarm(sp->update_secs);
 232 #endif
 233 }
 234
 235 void
 236 loser(const PLANE *p, const char *s)
 237 {
 238         int                     c;
 239 #ifdef BSD
 240         struct itimerval        itv;
 241 #endif
 242
 243         /* disable timer */
 244 #ifdef BSD
 245         itv.it_value.tv_sec = 0;
 246         itv.it_value.tv_usec = 0;
 247         (void)setitimer(ITIMER_REAL, &itv, NULL);
 248 #endif
 249 #ifdef SYSV
 250         alarm(0);
 251 #endif
 252
 253         losermsg(p, s);
 254         while ((c = getAChar()) != EOF && c != ' ')
 255                 ;
 256         shutdown_gr();
 257         (void)log_score(0);
 258         exit(0);
 259 }
 260
 261 const char *
 262 command(const PLANE *pp)
 263 {
 264         static char     buf[50], *bp, *comm_start;
 265         size_t bpsize;
 266
 267         buf[0] = '\0';
 268         bp = buf;
 269         bpsize = sizeof(buf);
 270         (void)snprintf(bp, bpsize, "%c%d%c%c%u: ", name(pp), pp->altitude,
 271                 (pp->fuel < LOWFUEL) ? '*' : ' ',
 272                 (pp->dest_type == T_AIRPORT) ? 'A' : 'E', pp->dest_no);
 273
 274         comm_start = bp = strchr(buf, '\0');
 275         bpsize = buf + sizeof(buf) - bp;
 276         if (pp->altitude == 0)
 277                 (void)snprintf(bp, bpsize, "Holding @ A%u", pp->orig_no);
 278         else if (pp->new_dir >= MAXDIR || pp->new_dir < 0)
 279                 (void)snprintf(bp, bpsize, "Circle");
 280         else if (pp->new_dir != pp->dir)
 281                 (void)snprintf(bp, bpsize, "%d", dir_deg(pp->new_dir));
 282
 283         bp = strchr(buf, '\0');
 284         bpsize = buf + sizeof(buf) - bp;
 285         if (pp->delayd)
 286                 (void)snprintf(bp, bpsize, " @ B%u", pp->delayd_no);
 287
 288         bp = strchr(buf, '\0');
 289         bpsize = buf + sizeof(buf) - bp;
 290         if (*comm_start == '\0' &&
 291             (pp->status == S_UNMARKED || pp->status == S_IGNORED))
 292                 (void)snprintf(bp, bpsize, "---------");
 293         return (buf);
 294 }
 295
 296 char
 297 name(const PLANE *p)
 298 {
 299         if (p->plane_type == 0)
 300                 return ('A' + p->plane_no);
 301         else
 302                 return ('a' + p->plane_no);
 303 }
 304
 305 int
 306 number(int l)
 307 {
 308         if (islower((unsigned char)l))
 309                 return (l - 'a');
 310         else if (isupper((unsigned char)l))
 311                 return (l - 'A');
 312         else
 313                 return (-1);
 314 }
 315
 316 static int
 317 next_plane(void)
 318 {
 319         static int      last_plane = -1;
 320         PLANE           *pp;
 321         int             found, start_plane = last_plane;
 322
 323         do {
 324                 found = 0;
 325                 last_plane++;
 326                 if (last_plane >= 26)
 327                         last_plane = 0;
 328                 for (pp = air.head; pp != NULL; pp = pp->next)
 329                         if (pp->plane_no == last_plane) {
 330                                 found++;
 331                                 break;
 332                         }
 333                 if (!found)
 334                         for (pp = ground.head; pp != NULL; pp = pp->next)
 335                                 if (pp->plane_no == last_plane) {
 336                                         found++;
 337                                         break;
 338                                 }
 339         } while (found && last_plane != start_plane);
 340         if (found)
 341                 return (-1);
 342         return (last_plane);
 343 }
 344
 345 void
 346 addplane(void)
 347 {
 348         PLANE   p, *pp, *p1;
 349         int     isclose, pnum;
 350         unsigned num_starts, rnd, rnd2, i;
 351
 352         (void)memset(&p, 0, sizeof (p));
 353
 354         p.status = S_MARKED;
 355         p.plane_type = random() % 2;
 356
 357         num_starts = sp->num_exits + sp->num_airports;
 358         rnd = random() % num_starts;
 359
 360         if (rnd < sp->num_exits) {
 361                 p.dest_type = T_EXIT;
 362                 p.dest_no = rnd;
 363         } else {
 364                 p.dest_type = T_AIRPORT;
 365                 p.dest_no = rnd - sp->num_exits;
 366         }
 367
 368         /* loop until we get a plane not near another */
 369         for (i = 0; i < num_starts; i++) {
 370                 /* loop till we get a different start point */
 371                 while ((rnd2 = random() % num_starts) == rnd)
 372                         ;
 373                 if (rnd2 < sp->num_exits) {
 374                         p.orig_type = T_EXIT;
 375                         p.orig_no = rnd2;
 376                         p.xpos = sp->exit[rnd2].x;
 377                         p.ypos = sp->exit[rnd2].y;
 378                         p.new_dir = p.dir = sp->exit[rnd2].dir;
 379                         p.altitude = p.new_altitude = 7;
 380                         isclose = 0;
 381                         for (p1 = air.head; p1 != NULL; p1 = p1->next)
 382                                 if (too_close(p1, &p, 4)) {
 383                                         isclose++;
 384                                         break;
 385                                 }
 386                         if (isclose)
 387                                 continue;
 388                 } else {
 389                         p.orig_type = T_AIRPORT;
 390                         p.orig_no = rnd2 - sp->num_exits;
 391                         p.xpos = sp->airport[p.orig_no].x;
 392                         p.ypos = sp->airport[p.orig_no].y;
 393                         p.new_dir = p.dir = sp->airport[p.orig_no].dir;
 394                         p.altitude = p.new_altitude = 0;
 395                 }
 396                 p.fuel = sp->width + sp->height;
 397                 break;
 398         }
 399         if (i >= num_starts)
 400                 return;
 401         pnum = next_plane();
 402         if (pnum < 0)
 403                 return;
 404         p.plane_no = pnum;
 405
 406         pp = newplane();
 407         if (pp == NULL)
 408                 loser(NULL, "Out of memory!");
 409         (void)memcpy(pp, &p, sizeof (p));
 410
 411         if (pp->orig_type == T_AIRPORT)
 412                 append(&ground, pp);
 413         else
 414                 append(&air, pp);
 415 }
 416
 417 PLANE *
 418 findplane(int n)
 419 {
 420         PLANE   *pp;
 421
 422         for (pp = air.head; pp != NULL; pp = pp->next)
 423                 if (pp->plane_no == n)
 424                         return (pp);
 425         for (pp = ground.head; pp != NULL; pp = pp->next)
 426                 if (pp->plane_no == n)
 427                         return (pp);
 428         return (NULL);
 429 }
 430
 431 static int
 432 too_close(const PLANE *p1, const PLANE *p2, int dist)
 433 {
 434         if (ABS(p1->altitude - p2->altitude) <= dist &&
 435             ABS(p1->xpos - p2->xpos) <= dist &&
 436             ABS(p1->ypos - p2->ypos) <= dist)
 437                 return (1);
 438         else
 439                 return (0);
 440 }
 441
 442 static int
 443 dir_deg(int d)
 444 {
 445         switch (d) {
 446         case 0: return (0);
 447         case 1: return (45);
 448         case 2: return (90);
 449         case 3: return (135);
 450         case 4: return (180);
 451         case 5: return (225);
 452         case 6: return (270);
 453         case 7: return (315);
 454         default:
 455                 return (-1);
 456         }
 457 }