1 /* $NetBSD: update.c,v 1.28 2021/05/02 12:50:43 rillig 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.28 2021/05/02 12:50:43 rillig 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
update(int dummy __unused)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
loser(const PLANE * p,const char * s)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 *
command(const PLANE * pp)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
name(const PLANE * p)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
number(int l)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
next_plane(void)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
addplane(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 *
findplane(int n)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
too_close(const PLANE * p1,const PLANE * p2,int dist)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
dir_deg(int d)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 }
458