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