xref: /dragonfly/games/adventure/io.c (revision c89a6c1b) 
1 /*-
2  * Copyright (c) 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * The game adventure was originally written in Fortran by Will Crowther
6  * and Don Woods.  It was later translated to C and enhanced by Jim
7  * Gillogly.  This code is derived from software contributed to Berkeley
8  * by Jim Gillogly at The Rand Corporation.
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  * @(#)io.c	8.1 (Berkeley) 5/31/93
35  * $FreeBSD: src/games/adventure/io.c,v 1.8.2.1 2001/03/05 11:43:11 kris Exp $
36  * $DragonFly: src/games/adventure/io.c,v 1.3 2007/04/18 18:32:12 swildner Exp $
37  */
38 
39 /* Re-coding of advent in C: file i/o and user i/o */
40 
41 #include "hdr.h"
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <err.h>
46 
47 static int next(void);
48 static void rdesc(int);
49 static void rdflt(void);
50 static void rhints(void);
51 static void rliq(void);
52 static void rlocs(void);
53 static int rnum(void);
54 static void rtrav(void);
55 static void rvoc(void);
56 #ifdef DEBUG
57 static void twrite(int);
58 #endif
59 
60 /* Get command from user. No prompt, usually. */
61 void
62 getin(char **wrd1, char **wrd2)
63 {
64 	char *s;
65 	static char wd1buf[MAXSTR], wd2buf[MAXSTR];
66 	int first, numch;
67 
68 	*wrd1 = wd1buf;			/* return ptr to internal string */
69 	*wrd2 = wd2buf;
70 	wd2buf[0] = 0;			/* in case it isn't set here */
71 	for (s = wd1buf, first = 1, numch = 0;;) {
72 		if ((*s = getchar()) >= 'A' && *s <= 'Z')
73 			*s = *s - ('A' - 'a');	/* convert to upper case */
74 		switch (*s) {		/* start reading from user */
75 		case '\n':
76 			*s = 0;
77 			return;
78 		case ' ':
79 			if (s == wd1buf || s == wd2buf)	/* initial blank */
80 				continue;
81 			*s = 0;
82 			if (first) {	/* finished 1st wd; start 2nd */
83 				first = numch = 0;
84 				s = wd2buf;
85 				break;
86 			} else {	/* finished 2nd word */
87 				FLUSHLINE;
88 				*s = 0;
89 				return;
90 			}
91 		case EOF:
92 			printf("user closed input stream, quitting...\n");
93 			exit(0);
94 		default:
95 			if (++numch >= MAXSTR) {	/* string too long */
96 				printf("Give me a break!!\n");
97 				wd1buf[0] = wd2buf[0] = 0;
98 				FLUSHLINE;
99 				return;
100 			}
101 			s++;
102 		}
103 	}
104 }
105 
106 /* confirm with rspeak */
107 int
108 yes(int x, int y, int z)
109 {
110 	int result;
111 	int ch;
112 
113 	result = FALSE;
114 	for (;;) {
115 		rspeak(x);	/* tell him what we want */
116 		if ((ch = getchar()) == 'y')
117 			result = TRUE;
118 		else if (ch == 'n')
119 			result = FALSE;
120 		else if (ch == EOF) {
121 			printf("user closed input stream, quitting...\n");
122 			exit(0);
123 		}
124 		FLUSHLINE;
125 		if (ch == 'y' || ch == 'n')
126 			break;
127 		printf("Please answer the question.\n");
128 	}
129 	if (result == TRUE)
130 		rspeak(y);
131 	if (result == FALSE)
132 		rspeak(z);
133 	return (result);
134 }
135 
136 /* confirm with mspeak */
137 int
138 yesm(int x, int y, int z)
139 {
140 	int result;
141 	int ch;
142 
143 	result = FALSE;
144 	for (;;) {
145 		mspeak(x);	/* tell him what we want */
146 		if ((ch = getchar()) == 'y')
147 			result = TRUE;
148 		else if (ch == 'n')
149 			result = FALSE;
150 		else if (ch == EOF) {
151 			printf("user closed input stream, quitting...\n");
152 			exit(0);
153 		}
154 		FLUSHLINE;
155 		if (ch == 'y' || ch == 'n')
156 			break;
157 		printf("Please answer the question.\n");
158 	}
159 	if (result == TRUE)
160 		mspeak(y);
161 	if (result == FALSE)
162 		mspeak(z);
163 	return (result);
164 }
165 
166 /* FILE *inbuf, *outbuf; */
167 
168 char *inptr;				/* Pointer into virtual disk */
169 
170 int outsw = 0;				/* putting stuff to data file? */
171 
172 const char iotape[] = "Ax3F'\003tt$8h\315qer*h\017nGKrX\207:!l";
173 const char *tape = iotape;		/* pointer to encryption tape */
174 
175 /* next virtual char, bump adr */
176 static int
177 next(void)
178 {
179 	int ch;
180 
181 	ch = (*inptr ^ random()) & 0xFF; /* Decrypt input data */
182 	if (outsw) {			/* putting data in tmp file */
183 		if (*tape == 0)
184 			tape = iotape;	/* rewind encryption tape */
185 		*inptr = ch ^ *tape++;	/* re-encrypt and replace value */
186 	}
187 	inptr++;
188 	return (ch);
189 }
190 
191 char breakch;				/* tell which char ended rnum */
192 
193 /* "read" data from virtual file */
194 void
195 rdata(void)
196 {
197 	int sect;
198 	char ch;
199 
200 	inptr = data_file;		/* Pointer to virtual data file */
201 	srandom(SEED);			/* which is lightly encrypted. */
202 
203 	clsses = 1;
204 	for (;;) {			/* read data sections */
205 		sect = next() - '0';	/* 1st digit of section number */
206 #ifdef VERBOSE
207 		printf("Section %c", sect + '0');
208 #endif
209 		if ((ch = next()) != LF) {	/* is there a second digit? */
210 			FLUSHLF;
211 #ifdef VERBOSE
212 			putchar(ch);
213 #endif
214 			sect = 10 * sect + ch - '0';
215 		}
216 #ifdef VERBOSE
217 		putchar('\n');
218 #endif
219 		switch (sect) {
220 		case 0:		/* finished reading database */
221 			return;
222 		case 1:		/* long form descriptions */
223 			rdesc(1);
224 			break;
225 		case 2:		/* short form descriptions */
226 			rdesc(2);
227 			break;
228 		case 3:		/* travel table */
229 			rtrav();
230 			break;
231 		case 4:		/* vocabulary */
232 			rvoc();
233 			break;
234 		case 5:		/* object descriptions */
235 			rdesc(5);
236 			break;
237 		case 6:		/* arbitrary messages */
238 			rdesc(6);
239 			break;
240 		case 7:		/* object locations */
241 			rlocs();
242 			break;
243 		case 8:		/* action defaults */
244 			rdflt();
245 			break;
246 		case 9:		/* liquid assets */
247 			rliq();
248 			break;
249 		case 10:	/* class messages */
250 			rdesc(10);
251 			break;
252 		case 11:	/* hints */
253 			rhints();
254 			break;
255 		case 12:	/* magic messages */
256 			rdesc(12);
257 			break;
258 		default:
259 			printf("Invalid data section number: %d\n", sect);
260 			for (;;)
261 				putchar(next());
262 		}
263 		if (breakch != LF)	/* routines return after "-1" */
264 			FLUSHLF;
265 	}
266 }
267 
268 char nbf[12];
269 
270 /* read initial location num */
271 static int
272 rnum(void)
273 {
274 	char *s;
275 
276 	tape = iotape;		/* restart encryption tape */
277 	for (s = nbf, *s = 0;; s++)
278 		if ((*s = next()) == TAB || *s == '\n' || *s == LF)
279 			break;
280 	breakch = *s;		/* save char for rtrav() */
281 	*s = 0;			/* got the number as ascii */
282 	if (nbf[0] == '-')	/* end of data */
283 		return (-1);
284 	return (atoi(nbf));	/* convert it to integer */
285 }
286 
287 char *seekhere;
288 
289 /* read description-format msgs */
290 static void
291 rdesc(int sect)
292 {
293 	int locc;
294 	char *seekstart, *maystart;
295 
296 	seekhere = inptr;		/* Where are we in virtual file? */
297 	outsw = 1;			/* these msgs go into tmp file */
298 	for (oldloc = -1, seekstart = seekhere;;) {
299 		maystart = inptr;	/* maybe starting new entry */
300 		if ((locc = rnum()) != oldloc && oldloc >= 0 /* finished msg */
301 		    /* unless sect 5 */
302 		    && !(sect == 5 && (locc == 0 || locc >= 100))) {
303 			switch (sect) {	/* now put it into right table */
304 			case 1:		/* long descriptions */
305 				ltext[oldloc].seekadr = seekhere;
306 				ltext[oldloc].txtlen = maystart - seekstart;
307 				break;
308 			case 2:		/* short descriptions */
309 				stext[oldloc].seekadr = seekhere;
310 				stext[oldloc].txtlen = maystart - seekstart;
311 				break;
312 			case 5:		/* object descriptions */
313 				ptext[oldloc].seekadr = seekhere;
314 				ptext[oldloc].txtlen = maystart - seekstart;
315 				break;
316 			case 6:		/* random messages */
317 				if (oldloc > RTXSIZ)
318 					errx(1, "Too many random msgs");
319 				rtext[oldloc].seekadr = seekhere;
320 				rtext[oldloc].txtlen = maystart - seekstart;
321 				break;
322 			case 10:	/* class messages */
323 				ctext[clsses].seekadr = seekhere;
324 				ctext[clsses].txtlen = maystart - seekstart;
325 				cval[clsses++] = oldloc;
326 				break;
327 			case 12:	/* magic messages */
328 				if (oldloc > MAGSIZ)
329 					errx(1, "Too many magic msgs");
330 				mtext[oldloc].seekadr = seekhere;
331 				mtext[oldloc].txtlen = maystart - seekstart;
332 				break;
333 			default:
334 				errx(1, "rdesc called with bad section");
335 			}
336 			seekhere += maystart - seekstart;
337 		}
338 		if (locc < 0) {
339 			outsw = 0;	/* turn off output */
340 			seekhere += 3;	/* -1<delimiter> */
341 			return;
342 		}
343 		if (sect != 5 || (locc > 0 && locc < 100)) {
344 			if (oldloc != locc)	/* starting a new message */
345 				seekstart = maystart;
346 			oldloc = locc;
347 		}
348 		FLUSHLF;		/* scan the line */
349 	}
350 }
351 
352 /* read travel table */
353 static void
354 rtrav(void)
355 {
356 	int locc;
357 	struct travlist *t;
358 	char *s;
359 	char buf[12];
360 	int len, m, n, entries;
361 
362 	entries = 0;
363 	t = NULL;
364 	for (oldloc = -1;;) {		/* get another line */
365 		/* end of entry */
366 		if ((locc = rnum()) != oldloc && oldloc >= 0) {
367 			t->next = 0;	/* terminate the old entry */
368 #if DEBUG
369 			printf("%d:%d entries\n", oldloc, entries);
370 			twrite(oldloc);
371 #endif
372 		}
373 		if (locc == -1)
374 			return;
375 		if (locc != oldloc) {	/* getting a new entry */
376 			t = travel[locc] = malloc(sizeof(*t));
377 			if (t == NULL)
378 				errx(1, "Out of memory!");
379 			/* printf("New travel list for %d\n", locc); */
380 			entries = 0;
381 			oldloc = locc;
382 		}
383 		for (s = buf;; s++)		/* get the newloc number /ASCII */
384 			if ((*s = next()) == TAB || *s == LF)
385 				break;
386 		*s = 0;
387 		len = strlen(buf);	/* quad long number handling */
388 		/* printf("Newloc: %s (%d chars)\n", buf, len); */
389 		if (len < 4) {		/* no "m" conditions */
390 			m = 0;
391 			n = atoi(buf);	/* newloc mod 1000 = newloc */
392 		} else {		/* a long integer */
393 			n = atoi(buf + len - 3);
394 			buf[len - 3] = 0;	/* terminate newloc/1000 */
395 			m = atoi(buf);
396 		}
397 		while (breakch != LF) {	/* only do one line at a time */
398 			if (entries++) {
399 				t = t->next = malloc(sizeof(*t));
400 				if (t == NULL)
401 					errx(1, "Out of memory!");
402 			}
403 			t->tverb = rnum();	/* get verb from the file */
404 			t->tloc = n;		/* table entry mod 1000 */
405 			t->conditions = m;	/* table entry / 1000 */
406 			/* printf("entry %d for %d\n", entries, locc); */
407 		}
408 	}
409 }
410 
411 #ifdef DEBUG
412 
413 /* travel options from this loc */
414 static void
415 twrite(int loq)
416 {
417 	struct travlist *t;
418 
419 	printf("If");
420 	speak(&ltext[loq]);
421 	printf("then\n");
422 	for (t = travel[loq]; t != 0; t = t->next) {
423 		printf("verb %d takes you to ", t->tverb);
424 		if (t->tloc <= 300)
425 			speak(&ltext[t->tloc]);
426 		else if (t->tloc <= 500)
427 			printf("special code %d\n", t->tloc - 300);
428 		else
429 			rspeak(t->tloc - 500);
430 		printf("under conditions %d\n", t->conditions);
431 	}
432 }
433 #endif /* DEBUG */
434 
435 /* read the vocabulary */
436 static void
437 rvoc(void)
438 {
439 	char *s;
440 	int rv_index;
441 	char buf[6];
442 
443 	for (;;) {
444 		rv_index = rnum();
445 		if (rv_index < 0)
446 			break;
447 		for (s = buf, *s = 0;; s++)	/* get the word */
448 			if ((*s = next()) == TAB || *s == '\n' || *s == LF
449 			    || *s == ' ')
450 				break;
451 		/* terminate word with newline, LF, tab, blank */
452 		if (*s != '\n' && *s != LF)
453 			FLUSHLF;		/* can be comments */
454 		*s = 0;
455 		/* printf("\"%s\"=%d\n", buf, rv_index); */
456 		vocab(buf, -2, rv_index);
457 	}
458 }
459 
460 /* initial object locations */
461 static void
462 rlocs(void)
463 {
464 	for (;;) {
465 		if ((obj = rnum()) < 0)
466 			break;
467 		plac[obj] = rnum();	/* initial loc for this obj */
468 		if (breakch == TAB)	/* there's another entry */
469 			fixd[obj] = rnum();
470 		else
471 			fixd[obj] = 0;
472 	}
473 }
474 
475 /* default verb messages */
476 static void
477 rdflt(void)
478 {
479 	for (;;) {
480 		if ((verb = rnum()) < 0)
481 			break;
482 		actspk[verb] = rnum();
483 	}
484 }
485 
486 /* liquid assets &c: cond bits */
487 static void
488 rliq(void)
489 {
490 	int bitnum;
491 
492 	for (;;) {			/* read new bit list */
493 		if ((bitnum = rnum()) < 0)
494 			break;
495 		for (;;) {		/* read locs for bits */
496 			cond[rnum()] |= setbit[bitnum];
497 			if (breakch == LF)
498 				break;
499 		}
500 	}
501 }
502 
503 static void
504 rhints(void)
505 {
506 	int hintnum, i;
507 
508 	hntmax = 0;
509 	for (;;) {
510 		if ((hintnum = rnum()) < 0)
511 			break;
512 		for (i = 1; i < 5; i++)
513 			hints[hintnum][i] = rnum();
514 		if (hintnum > hntmax)
515 			hntmax = hintnum;
516 	}
517 }
518 
519 void
520 rspeak(int msg)
521 {
522 	if (msg != 0)
523 		speak(&rtext[msg]);
524 }
525 
526 void
527 mspeak(int msg)
528 {
529 	if (msg != 0)
530 		speak(&mtext[msg]);
531 }
532 
533 /* read, decrypt, and print a message (not ptext) */
534 /* msg is a pointer to seek address and length of mess */
535 void
536 speak(const struct text *msg)
537 {
538 	char *s, nonfirst;
539 
540 	s = msg->seekadr;
541 	nonfirst = 0;
542 	while (s - msg->seekadr < msg->txtlen) { /* read a line at a time */
543 		tape = iotape;			 /* restart decryption tape */
544 		while ((*s++ ^ *tape++) != TAB); /* read past loc num */
545 		/* assume tape is longer than location number */
546 		/* plus the lookahead put together */
547 		if ((*s ^ *tape) == '>' &&
548 		    (*(s + 1) ^ *(tape + 1)) == '$' &&
549 		    (*(s + 2) ^ *(tape + 2)) == '<')
550 			break;
551 		if (blklin && !nonfirst++)
552 			putchar('\n');
553 		do {
554 			if (*tape == 0)
555 				tape = iotape;	/* rewind decryp tape */
556 			putchar(*s ^ *tape);
557 		} while ((*s++ ^ *tape++) != LF); /* better end with LF */
558 	}
559 }
560 
561 /* read, decrypt and print a ptext message */
562 /* msg is the number of all the p msgs for this place */
563 /* assumes object 1 doesn't have prop 1, obj 2 no prop 2, etc. */
564 void
565 pspeak(int m, int skip)
566 {
567 	char *s, nonfirst;
568 	char *numst, ps_save;
569 	struct text *msg;
570 	char *tbuf;
571 
572 	msg = &ptext[m];
573 	if ((tbuf = malloc(msg->txtlen + 1)) == 0)
574 		errx(1, "Out of memory!");
575 	memcpy(tbuf, msg->seekadr, (unsigned)msg->txtlen + 1); /* Room to null */
576 	s = tbuf;
577 
578 	nonfirst = 0;
579 	while (s - tbuf < msg->txtlen) {	/* read line at a time */
580 		tape = iotape;			/* restart decryption tape */
581 		for (numst = s; (*s ^= *tape++) != TAB; s++) /* get number */
582 		  ; /* nothing */
583 
584 		ps_save = *s;	/* Temporarily trash the string (cringe) */
585 		*s++ = 0;	/* decrypting number within the string */
586 
587 		if (atoi(numst) != 100 * skip && skip >= 0) {
588 			while ((*s++ ^ *tape++) != LF)	/* flush the line */
589 				if (*tape == 0)
590 					tape = iotape;
591 			continue;
592 		}
593 		if ((*s ^ *tape) == '>' && (*(s + 1) ^ *(tape + 1)) == '$' &&
594 		    (*(s + 2) ^ *(tape + 2)) == '<')
595 			break;
596 		if (blklin && !nonfirst++)
597 			putchar('\n');
598 		do {
599 			if (*tape == 0)
600 				tape = iotape;
601 			putchar(*s ^ *tape);
602 		} while ((*s++ ^ *tape++) != LF);	/* better end with LF */
603 		if (skip < 0)
604 			break;
605 	}
606 	free(tbuf);
607 }
608