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  * @(#)update.c 8.1 (Berkeley) 5/31/93
  37  * $FreeBSD: src/games/atc/update.c,v 1.6 1999/11/30 03:48:21 billf Exp $
  38  * $DragonFly: src/games/atc/update.c,v 1.3 2006/08/08 15:03:02 pavalos Exp $
  39  */
  40
  41 /*
  42  * Copyright (c) 1987 by Ed James, UC Berkeley.  All rights reserved.
  43  *
  44  * Copy permission is hereby granted provided that this notice is
  45  * retained on all partial or complete copies.
  46  *
  47  * For more info on this and all of my stuff, mail edjames@berkeley.edu.
  48  */
  49
  50 #include "include.h"
  51
  52 static int      next_plane(void);
  53 static int      too_close(const PLANE *, const PLANE *, int);
  54 static int      dir_deg(int);
  55
  56
  57 void
  58 update(void)
  59 {
  60         int     i, dir_diff, mask, unclean;
  61         PLANE   *pp, *p1, *p2;
  62
  63         mask = sigblock(sigmask(SIGINT));
  64
  65         clck++;
  66
  67         erase_all();
  68
  69         /* put some planes in the air */
  70         do {
  71                 unclean = 0;
  72                 for (pp = ground.head; pp != NULL; pp = pp->next) {
  73                         if (pp->new_altitude > 0) {
  74                                 delete(&ground, pp);
  75                                 append(&air, pp);
  76                                 unclean = 1;
  77                                 break;
  78                         }
  79                 }
  80         } while (unclean);
  81
  82         /* do altitude change and basic movement */
  83         for (pp = air.head; pp != NULL; pp = pp->next) {
  84                 /* type 0 only move every other turn */
  85                 if (pp->plane_type == 0 && clck & 1)
  86                         continue;
  87
  88                 pp->fuel--;
  89                 if (pp->fuel < 0)
  90                         loser(pp, "ran out of fuel.");
  91
  92                 pp->altitude += SGN(pp->new_altitude - pp->altitude);
  93
  94                 if (!pp->delayd) {
  95                         dir_diff = pp->new_dir - pp->dir;
  96                         /*
  97                          * Allow for circle commands
  98                          */
  99                         if (pp->new_dir >= 0 && pp->new_dir < MAXDIR) {
 100                                 if (dir_diff > MAXDIR/2)
 101                                         dir_diff -= MAXDIR;
 102                                 else if (dir_diff < -(MAXDIR/2))
 103                                         dir_diff += MAXDIR;
 104                         }
 105                         if (dir_diff > 2)
 106                                 dir_diff = 2;
 107                         else if (dir_diff < -2)
 108                                 dir_diff = -2;
 109                         pp->dir += dir_diff;
 110                         if (pp->dir >= MAXDIR)
 111                                 pp->dir -= MAXDIR;
 112                         else if (pp->dir < 0)
 113                                 pp->dir += MAXDIR;
 114                 }
 115                 pp->xpos += displacement[pp->dir].dx;
 116                 pp->ypos += displacement[pp->dir].dy;
 117
 118                 if (pp->delayd && pp->xpos == sp->beacon[pp->delayd_no].x &&
 119                     pp->ypos == sp->beacon[pp->delayd_no].y) {
 120                         pp->delayd = 0;
 121                         if (pp->status == S_UNMARKED)
 122                                 pp->status = S_MARKED;
 123                 }
 124
 125                 switch (pp->dest_type) {
 126                 case T_AIRPORT:
 127                         if (pp->xpos == sp->airport[pp->dest_no].x &&
 128                             pp->ypos == sp->airport[pp->dest_no].y &&
 129                             pp->altitude == 0) {
 130                                 if (pp->dir != sp->airport[pp->dest_no].dir)
 131                                     loser(pp, "landed in the wrong direction.");
 132                                 else {
 133                                     pp->status = S_GONE;
 134                                     continue;
 135                                 }
 136                         }
 137                         break;
 138                 case T_EXIT:
 139                         if (pp->xpos == sp->exit[pp->dest_no].x &&
 140                             pp->ypos == sp->exit[pp->dest_no].y) {
 141                                 if (pp->altitude != 9)
 142                                     loser(pp, "exited at the wrong altitude.");
 143                                 else {
 144                                     pp->status = S_GONE;
 145                                     continue;
 146                                 }
 147                         }
 148                         break;
 149                 default:
 150                         loser(pp, "has a bizarre destination, get help!");
 151                 }
 152                 if (pp->altitude > 9)
 153                         /* "this is impossible" */
 154                         loser(pp, "exceded flight ceiling.");
 155                 if (pp->altitude <= 0) {
 156                         for (i = 0; i < sp->num_airports; i++)
 157                                 if (pp->xpos == sp->airport[i].x &&
 158                                     pp->ypos == sp->airport[i].y) {
 159                                         if (pp->dest_type == T_AIRPORT)
 160                                             loser(pp,
 161                                                 "landed at the wrong airport.");
 162                                         else
 163                                             loser(pp,
 164                                                 "landed instead of exited.");
 165                                 }
 166                         loser(pp, "crashed on the ground.");
 167                 }
 168                 if (pp->xpos < 1 || pp->xpos >= sp->width - 1 ||
 169                     pp->ypos < 1 || pp->ypos >= sp->height - 1) {
 170                         for (i = 0; i < sp->num_exits; i++)
 171                                 if (pp->xpos == sp->exit[i].x &&
 172                                     pp->ypos == sp->exit[i].y) {
 173                                         if (pp->dest_type == T_EXIT)
 174                                             loser(pp,
 175                                                 "exited via the wrong exit.");
 176                                         else
 177                                             loser(pp,
 178                                                 "exited instead of landed.");
 179                                 }
 180                         loser(pp, "illegally left the flight arena.");
 181                 }
 182         }
 183
 184         /*
 185          * Traverse the list once, deleting the planes that are gone.
 186          */
 187         for (pp = air.head; pp != NULL; pp = p2) {
 188                 p2 = pp->next;
 189                 if (pp->status == S_GONE) {
 190                         safe_planes++;
 191                         delete(&air, pp);
 192                 }
 193         }
 194
 195         draw_all();
 196
 197         for (p1 = air.head; p1 != NULL; p1 = p1->next)
 198                 for (p2 = p1->next; p2 != NULL; p2 = p2->next)
 199                         if (too_close(p1, p2, 1)) {
 200                                 static char     buf[80];
 201
 202                                 (void)sprintf(buf, "collided with plane '%c'.",
 203                                         name(p2));
 204                                 loser(p1, buf);
 205                         }
 206         /*
 207          * Check every other update.  Actually, only add on even updates.
 208          * Otherwise, prop jobs show up *on* entrance.  Remember that
 209          * we don't update props on odd updates.
 210          */
 211         if ((random() % sp->newplane_time) == 0)
 212                 addplane();
 213
 214         sigsetmask(mask);
 215 }
 216
 217 const char *
 218 command(const PLANE *pp)
 219 {
 220         static char     buf[50], *bp, *comm_start;
 221
 222         buf[0] = '\0';
 223         bp = buf;
 224         (void)sprintf(bp, "%c%d%c%c%d: ", name(pp), pp->altitude,
 225                 (pp->fuel < LOWFUEL) ? '*' : ' ',
 226                 (pp->dest_type == T_AIRPORT) ? 'A' : 'E', pp->dest_no);
 227
 228         comm_start = bp = index(buf, '\0');
 229         if (pp->altitude == 0)
 230                 (void)sprintf(bp, "Holding @ A%d", pp->orig_no);
 231         else if (pp->new_dir >= MAXDIR || pp->new_dir < 0)
 232                 strcpy(bp, "Circle");
 233         else if (pp->new_dir != pp->dir)
 234                 (void)sprintf(bp, "%d", dir_deg(pp->new_dir));
 235
 236         bp = index(buf, '\0');
 237         if (pp->delayd)
 238                 (void)sprintf(bp, " @ B%d", pp->delayd_no);
 239
 240         bp = index(buf, '\0');
 241         if (*comm_start == '\0' &&
 242             (pp->status == S_UNMARKED || pp->status == S_IGNORED))
 243                 strcpy(bp, "---------");
 244         return (buf);
 245 }
 246
 247 /* char */
 248 char
 249 name(const PLANE *p)
 250 {
 251         if (p->plane_type == 0)
 252                 return ('A' + p->plane_no);
 253         else
 254                 return ('a' + p->plane_no);
 255 }
 256
 257 char
 258 number(char l)
 259 {
 260         if (l < 'a' && l > 'z' && l < 'A' && l > 'Z')
 261                 return (-1);
 262         else if (l >= 'a' && l <= 'z')
 263                 return (l - 'a');
 264         else
 265                 return (l - 'A');
 266 }
 267
 268 static int
 269 next_plane(void)
 270 {
 271         static int      last_plane = -1;
 272         PLANE           *pp;
 273         int             found, start_plane = last_plane;
 274
 275         do {
 276                 found = 0;
 277                 last_plane++;
 278                 if (last_plane >= 26)
 279                         last_plane = 0;
 280                 for (pp = air.head; pp != NULL; pp = pp->next)
 281                         if (pp->plane_no == last_plane) {
 282                                 found++;
 283                                 break;
 284                         }
 285                 if (!found)
 286                         for (pp = ground.head; pp != NULL; pp = pp->next)
 287                                 if (pp->plane_no == last_plane) {
 288                                         found++;
 289                                         break;
 290                                 }
 291         } while (found && last_plane != start_plane);
 292         if (last_plane == start_plane)
 293                 return (-1);
 294         return (last_plane);
 295 }
 296
 297 int
 298 addplane(void)
 299 {
 300         PLANE   p, *pp, *p1;
 301         int     i, num_starts, is_close, rnd, rnd2, pnum;
 302
 303         bzero(&p, sizeof (p));
 304
 305         p.status = S_MARKED;
 306         p.plane_type = random() % 2;
 307
 308         num_starts = sp->num_exits + sp->num_airports;
 309         rnd = random() % num_starts;
 310
 311         if (rnd < sp->num_exits) {
 312                 p.dest_type = T_EXIT;
 313                 p.dest_no = rnd;
 314         } else {
 315                 p.dest_type = T_AIRPORT;
 316                 p.dest_no = rnd - sp->num_exits;
 317         }
 318
 319         /* loop until we get a plane not near another */
 320         for (i = 0; i < num_starts; i++) {
 321                 /* loop till we get a different start point */
 322                 while ((rnd2 = random() % num_starts) == rnd)
 323                         ;
 324                 if (rnd2 < sp->num_exits) {
 325                         p.orig_type = T_EXIT;
 326                         p.orig_no = rnd2;
 327                         p.xpos = sp->exit[rnd2].x;
 328                         p.ypos = sp->exit[rnd2].y;
 329                         p.new_dir = p.dir = sp->exit[rnd2].dir;
 330                         p.altitude = p.new_altitude = 7;
 331                         is_close = 0;
 332                         for (p1 = air.head; p1 != NULL; p1 = p1->next)
 333                                 if (too_close(p1, &p, 4)) {
 334                                         is_close++;
 335                                         break;
 336                                 }
 337                         if (is_close)
 338                                 continue;
 339                 } else {
 340                         p.orig_type = T_AIRPORT;
 341                         p.orig_no = rnd2 - sp->num_exits;
 342                         p.xpos = sp->airport[p.orig_no].x;
 343                         p.ypos = sp->airport[p.orig_no].y;
 344                         p.new_dir = p.dir = sp->airport[p.orig_no].dir;
 345                         p.altitude = p.new_altitude = 0;
 346                 }
 347                 p.fuel = sp->width + sp->height;
 348                 break;
 349         }
 350         if (i >= num_starts)
 351                 return (-1);
 352         pnum = next_plane();
 353         if (pnum < 0)
 354                 return (-1);
 355         p.plane_no = pnum;
 356
 357         pp = newplane();
 358         bcopy(&p, pp, sizeof (p));
 359
 360         if (pp->orig_type == T_AIRPORT)
 361                 append(&ground, pp);
 362         else
 363                 append(&air, pp);
 364
 365         return (pp->dest_type);
 366 }
 367
 368 PLANE *
 369 findplane(int n)
 370 {
 371         PLANE   *pp;
 372
 373         for (pp = air.head; pp != NULL; pp = pp->next)
 374                 if (pp->plane_no == n)
 375                         return (pp);
 376         for (pp = ground.head; pp != NULL; pp = pp->next)
 377                 if (pp->plane_no == n)
 378                         return (pp);
 379         return (NULL);
 380 }
 381
 382 static int
 383 too_close(const PLANE *p1, const PLANE *p2, int dist)
 384 {
 385         if (ABS(p1->altitude - p2->altitude) <= dist &&
 386             ABS(p1->xpos - p2->xpos) <= dist && ABS(p1->ypos - p2->ypos) <= dist)
 387                 return (1);
 388         else
 389                 return (0);
 390 }
 391
 392 static int
 393 dir_deg(int d)
 394 {
 395         switch (d) {
 396         case 0: return (0);
 397         case 1: return (45);
 398         case 2: return (90);
 399         case 3: return (135);
 400         case 4: return (180);
 401         case 5: return (225);
 402         case 6: return (270);
 403         case 7: return (315);
 404         default:
 405                 return (-1);
 406         }
 407 }