xref: /openbsd-src/games/adventure/subr.c (revision 400fe323ee96ae4b484bcc7107522798bf1372c9)
1*400fe323Smestre /*	$OpenBSD: subr.c,v 1.11 2016/03/08 10:48:39 mestre Exp $	*/
2df930be7Sderaadt /*	$NetBSD: subr.c,v 1.2 1995/03/21 12:05:11 cgd Exp $	*/
3df930be7Sderaadt 
4df930be7Sderaadt /*-
5df930be7Sderaadt  * Copyright (c) 1991, 1993
6df930be7Sderaadt  *	The Regents of the University of California.  All rights reserved.
7df930be7Sderaadt  *
8df930be7Sderaadt  * The game adventure was originally written in Fortran by Will Crowther
9df930be7Sderaadt  * and Don Woods.  It was later translated to C and enhanced by Jim
10df930be7Sderaadt  * Gillogly.  This code is derived from software contributed to Berkeley
11df930be7Sderaadt  * by Jim Gillogly at The Rand Corporation.
12df930be7Sderaadt  *
13df930be7Sderaadt  * Redistribution and use in source and binary forms, with or without
14df930be7Sderaadt  * modification, are permitted provided that the following conditions
15df930be7Sderaadt  * are met:
16df930be7Sderaadt  * 1. Redistributions of source code must retain the above copyright
17df930be7Sderaadt  *    notice, this list of conditions and the following disclaimer.
18df930be7Sderaadt  * 2. Redistributions in binary form must reproduce the above copyright
19df930be7Sderaadt  *    notice, this list of conditions and the following disclaimer in the
20df930be7Sderaadt  *    documentation and/or other materials provided with the distribution.
217a09557bSmillert  * 3. Neither the name of the University nor the names of its contributors
22df930be7Sderaadt  *    may be used to endorse or promote products derived from this software
23df930be7Sderaadt  *    without specific prior written permission.
24df930be7Sderaadt  *
25df930be7Sderaadt  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26df930be7Sderaadt  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27df930be7Sderaadt  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28df930be7Sderaadt  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29df930be7Sderaadt  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30df930be7Sderaadt  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31df930be7Sderaadt  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32df930be7Sderaadt  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33df930be7Sderaadt  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34df930be7Sderaadt  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35df930be7Sderaadt  * SUCH DAMAGE.
36df930be7Sderaadt  */
37df930be7Sderaadt 
38df930be7Sderaadt /*	Re-coding of advent in C: subroutines from main			*/
39df930be7Sderaadt 
40bda940d3Spjanzen #include <stdio.h>
4170ef01f6Sdavid #include <stdlib.h>
42*400fe323Smestre 
43bda940d3Spjanzen #include "extern.h"
44*400fe323Smestre #include "hdr.h"
45df930be7Sderaadt 
46df930be7Sderaadt /*		Statement functions	*/
47bda940d3Spjanzen int
toting(int objj)48a5ca3416Sderaadt toting(int objj)
49bda940d3Spjanzen {
50bda940d3Spjanzen 	if (place[objj] == -1)
51bda940d3Spjanzen 		return (TRUE);
52bda940d3Spjanzen 	return (FALSE);
53df930be7Sderaadt }
54df930be7Sderaadt 
55bda940d3Spjanzen int
here(int objj)56a5ca3416Sderaadt here(int objj)
57bda940d3Spjanzen {
58bda940d3Spjanzen 	if (place[objj] == loc || toting(objj))
59bda940d3Spjanzen 		return (TRUE);
60bda940d3Spjanzen 	return (FALSE);
61df930be7Sderaadt }
62df930be7Sderaadt 
63bda940d3Spjanzen int
at(int objj)64a5ca3416Sderaadt at(int objj)
65bda940d3Spjanzen {
66bda940d3Spjanzen 	if (place[objj] == loc || fixed[objj] == loc)
67bda940d3Spjanzen 		return (TRUE);
68bda940d3Spjanzen 	else
69bda940d3Spjanzen 		return (FALSE);
70df930be7Sderaadt }
71df930be7Sderaadt 
72bda940d3Spjanzen int
liq2(int pbotl)73a5ca3416Sderaadt liq2(int pbotl)
74bda940d3Spjanzen {
75bda940d3Spjanzen 	return ((1 - pbotl) * water + (pbotl / 2) * (water + oil));
76df930be7Sderaadt }
77df930be7Sderaadt 
78bda940d3Spjanzen int
liq(void)79a5ca3416Sderaadt liq(void)
80bda940d3Spjanzen {
81bda940d3Spjanzen 	int     i;
82bda940d3Spjanzen 
83df930be7Sderaadt 	i = prop[bottle];
84bda940d3Spjanzen 	if (i > -1 - i)
85bda940d3Spjanzen 		return (liq2(i));
86bda940d3Spjanzen 	return (liq2(-1 - i));
87df930be7Sderaadt }
88df930be7Sderaadt 
89bda940d3Spjanzen int
liqloc(int locc)90a5ca3416Sderaadt liqloc(int locc)	/* may want to clean this one up a bit */
91bda940d3Spjanzen {
92bda940d3Spjanzen 	int     i, j, l;
93bda940d3Spjanzen 
94df930be7Sderaadt 	i = cond[locc] / 2;
95df930be7Sderaadt 	j = ((i * 2) % 8) - 5;
96df930be7Sderaadt 	l = cond[locc] / 4;
97df930be7Sderaadt 	l = l % 2;
98df930be7Sderaadt 	return (liq2(j * l + 1));
99df930be7Sderaadt }
100df930be7Sderaadt 
101bda940d3Spjanzen int
bitset(int l,int n)102a5ca3416Sderaadt bitset(int l, int n)
103bda940d3Spjanzen {
104bda940d3Spjanzen 	if (cond[l] & setbit[n])
105df930be7Sderaadt 		return (TRUE);
106df930be7Sderaadt 	return (FALSE);
107df930be7Sderaadt }
108df930be7Sderaadt 
109bda940d3Spjanzen int
forced(int locc)110a5ca3416Sderaadt forced(int locc)
111bda940d3Spjanzen {
112bda940d3Spjanzen 	if (cond[locc] == 2)
113bda940d3Spjanzen 		return (TRUE);
114bda940d3Spjanzen 	return (FALSE);
115bda940d3Spjanzen }
116bda940d3Spjanzen 
117bda940d3Spjanzen int
dark(void)118a5ca3416Sderaadt dark(void)
119bda940d3Spjanzen {
120bda940d3Spjanzen 	if ((cond[loc] % 2) == 0 && (prop[lamp] == 0 || !here(lamp)))
121bda940d3Spjanzen 		return (TRUE);
122bda940d3Spjanzen 	return (FALSE);
123bda940d3Spjanzen }
124bda940d3Spjanzen 
125bda940d3Spjanzen int
pct(int n)126a5ca3416Sderaadt pct(int n)
127bda940d3Spjanzen {
128bda940d3Spjanzen 	if (ran(100) < n)
129bda940d3Spjanzen 		return (TRUE);
130df930be7Sderaadt 	return (FALSE);
131df930be7Sderaadt }
132df930be7Sderaadt 
133df930be7Sderaadt 
134bda940d3Spjanzen int
fdwarf(void)135a5ca3416Sderaadt fdwarf(void)	/* 71 */
136bda940d3Spjanzen {
137bda940d3Spjanzen 	int     i, j;
138bda940d3Spjanzen 	struct travlist *kk;
139df930be7Sderaadt 
140bda940d3Spjanzen 	if (newloc != loc && !forced(loc) && !bitset(loc, 3)) {
141bda940d3Spjanzen 		for (i = 1; i <= 5; i++) {
142bda940d3Spjanzen 			if (odloc[i] != newloc || !dseen[i])
143bda940d3Spjanzen 				continue;
144df930be7Sderaadt 			newloc = loc;
145df930be7Sderaadt 			rspeak(2);
146df930be7Sderaadt 			break;
147df930be7Sderaadt 		}
148df930be7Sderaadt 	}
149df930be7Sderaadt 	loc = newloc;			/* 74 */
150bda940d3Spjanzen 	if (loc == 0 || forced(loc) || bitset(newloc, 3))
151bda940d3Spjanzen 		return (2000);
152bda940d3Spjanzen 	if (dflag == 0) {
153bda940d3Spjanzen 		if (loc >= 15)
154bda940d3Spjanzen 			dflag = 1;
155df930be7Sderaadt 		return (2000);
156df930be7Sderaadt 	}
157bda940d3Spjanzen 	if (dflag == 1)	{	/* 6000 */
158bda940d3Spjanzen 		if (loc < 15 || pct(95))
159bda940d3Spjanzen 			return (2000);
160df930be7Sderaadt 		dflag = 2;
161bda940d3Spjanzen 		for (i = 1; i <= 2; i++) {
162bda940d3Spjanzen 			j = 1 + ran(5);
163bda940d3Spjanzen 			if (pct(50) && saved == -1)
164bda940d3Spjanzen 				dloc[j] = 0;	/* 6001 */
165df930be7Sderaadt 		}
166bda940d3Spjanzen 		for (i = 1; i <= 5; i++) {
167bda940d3Spjanzen 			if (dloc[i] == loc)
168bda940d3Spjanzen 				dloc[i] = daltlc;
169df930be7Sderaadt 			odloc[i] = dloc[i];	/* 6002 */
170df930be7Sderaadt 		}
171df930be7Sderaadt 		rspeak(3);
172df930be7Sderaadt 		drop(axe, loc);
173df930be7Sderaadt 		return (2000);
174df930be7Sderaadt 	}
175df930be7Sderaadt 	dtotal = attack = stick = 0;		/* 6010 */
176bda940d3Spjanzen 	for (i = 1; i <= 6; i++) {		/* loop to 6030 */
177bda940d3Spjanzen 		if (dloc[i] == 0)
178bda940d3Spjanzen 			continue;
179df930be7Sderaadt 		j = 1;
180bda940d3Spjanzen 		for (kk = travel[dloc[i]]; kk != 0; kk = kk->next) {
181bda940d3Spjanzen 			newloc = kk->tloc;
182df930be7Sderaadt 			if (newloc > 300 || newloc < 15 || newloc == odloc[i]
183df930be7Sderaadt 			    || (j > 1 && newloc == tk[j-1]) || j >= 20
184df930be7Sderaadt 			    || newloc == dloc[i] || forced(newloc)
185df930be7Sderaadt 			    || (i == 6 && bitset(newloc, 3))
186bda940d3Spjanzen 			    || kk->conditions == 100)
187bda940d3Spjanzen 				continue;
188df930be7Sderaadt 			tk[j++] = newloc;
189df930be7Sderaadt 		}
190df930be7Sderaadt 		tk[j] = odloc[i];		/* 6016 */
191bda940d3Spjanzen 		if (j >= 2)
192bda940d3Spjanzen 			j--;
193df930be7Sderaadt 		j = 1 + ran(j);
194df930be7Sderaadt 		odloc[i] = dloc[i];
195df930be7Sderaadt 		dloc[i] = tk[j];
196df930be7Sderaadt 		dseen[i] = (dseen[i] && loc >= 15) || (dloc[i] == loc || odloc[i] == loc);
197bda940d3Spjanzen 		if (!dseen[i])
198bda940d3Spjanzen 			continue;	/* i.e. goto 6030 */
199df930be7Sderaadt 		dloc[i] = loc;
200bda940d3Spjanzen 		if (i == 6) {		/* pirate's spotted him */
201bda940d3Spjanzen 			if (loc == chloc || prop[chest] >= 0)
202bda940d3Spjanzen 				continue;
203df930be7Sderaadt 			k = 0;
204bda940d3Spjanzen 			for (j = 50; j <= maxtrs; j++) {	/* loop to 6020 */
205bda940d3Spjanzen 				if (j == pyram && (loc == plac[pyram]
206bda940d3Spjanzen 				    || loc == plac[emrald]))
207bda940d3Spjanzen 					goto l6020;
208bda940d3Spjanzen 				if (toting(j))
209bda940d3Spjanzen 					goto l6022;
210bda940d3Spjanzen l6020:				if (here(j))
211bda940d3Spjanzen 					k = 1;
212df930be7Sderaadt 			}				/* 6020 */
213df930be7Sderaadt 			if (tally == tally2 + 1 && k == 0 && place[chest] == 0
214bda940d3Spjanzen 			     && here(lamp) && prop[lamp] == 1)
215bda940d3Spjanzen 				goto l6025;
216df930be7Sderaadt 			if (odloc[6] != dloc[6] && pct(20))
217df930be7Sderaadt 				rspeak(127);
218df930be7Sderaadt 			continue;	/* to 6030 */
219df930be7Sderaadt l6022:		rspeak(128);
220bda940d3Spjanzen 			if (place[messag] == 0)
221bda940d3Spjanzen 				move(chest, chloc);
222df930be7Sderaadt 			move(messag, chloc2);
223bda940d3Spjanzen 			for (j = 50; j <= maxtrs; j++) { /* loop to 6023 */
224bda940d3Spjanzen 				if (j == pyram && (loc == plac[pyram]
225bda940d3Spjanzen 				    || loc == plac[emrald]))
226bda940d3Spjanzen 					continue;
227bda940d3Spjanzen 				if (at(j) && fixed[j] == 0)
228bda940d3Spjanzen 					carry(j, loc);
229bda940d3Spjanzen 				if (toting(j))
230bda940d3Spjanzen 					drop(j, chloc);
231df930be7Sderaadt 			}
232df930be7Sderaadt l6024:			dloc[6] = odloc[6] = chloc;
233df930be7Sderaadt 			dseen[6] = FALSE;
234df930be7Sderaadt 			continue;
235df930be7Sderaadt l6025:			rspeak(186);
236df930be7Sderaadt 			move(chest, chloc);
237df930be7Sderaadt 			move(messag, chloc2);
238df930be7Sderaadt 			goto l6024;
239df930be7Sderaadt 		}
240df930be7Sderaadt 		dtotal++;			/* 6027 */
241bda940d3Spjanzen 		if (odloc[i] != dloc[i])
242bda940d3Spjanzen 			continue;
243df930be7Sderaadt 		attack++;
244bda940d3Spjanzen 		if (knfloc >= 0)
245bda940d3Spjanzen 			knfloc = loc;
246bda940d3Spjanzen 		if (ran(1000) < 95 * (dflag - 2))
247bda940d3Spjanzen 			stick++;
248df930be7Sderaadt 	}					/* 6030 */
249bda940d3Spjanzen 	if (dtotal == 0)
250bda940d3Spjanzen 		return (2000);
251bda940d3Spjanzen 	if (dtotal != 1) {
252bda940d3Spjanzen 		printf("There are %d threatening little dwarves ", dtotal);
253df930be7Sderaadt 		printf("in the room with you.\n");
254df930be7Sderaadt 	}
255df930be7Sderaadt 	else
256bda940d3Spjanzen 		rspeak(4);
257bda940d3Spjanzen 	if (attack == 0)
258bda940d3Spjanzen 		return (2000);
259bda940d3Spjanzen 	if (dflag == 2)
260bda940d3Spjanzen 		dflag = 3;
261bda940d3Spjanzen 	if (saved != -1)
262bda940d3Spjanzen 		dflag = 20;
263bda940d3Spjanzen 	if (attack != 1) {
264bda940d3Spjanzen 		printf("%d of them throw knives at you!\n", attack);
265bda940d3Spjanzen 		k = 6;
266bda940d3Spjanzen l82:		if (stick <= 1)	{		/* 82 */
267bda940d3Spjanzen 			rspeak(k + stick);
268bda940d3Spjanzen 			if (stick == 0)
269bda940d3Spjanzen 				return (2000);
270bda940d3Spjanzen 		} else
271df930be7Sderaadt 			printf("%d of them get you!\n", stick);	/* 83 */
272df930be7Sderaadt 		oldlc2 = loc;
273df930be7Sderaadt 		return (99);
274df930be7Sderaadt 	}
275df930be7Sderaadt 	rspeak(5);
276df930be7Sderaadt 	k = 52;
277df930be7Sderaadt 	goto l82;
278df930be7Sderaadt }
279df930be7Sderaadt 
280df930be7Sderaadt 
281bda940d3Spjanzen int
march(void)282a5ca3416Sderaadt march(void)			/* label 8	*/
283bda940d3Spjanzen {
284bda940d3Spjanzen 	int     ll1, ll2;
285df930be7Sderaadt 
286bda940d3Spjanzen 	if ((tkk = travel[newloc = loc]) == 0)
287bda940d3Spjanzen 		bug(26);
288bda940d3Spjanzen 	if (k == null)
289bda940d3Spjanzen 		return (2);
290bda940d3Spjanzen 	if (k == cave) {			/* 40			*/
291bda940d3Spjanzen 		if (loc < 8)
292bda940d3Spjanzen 			rspeak(57);
293bda940d3Spjanzen 		if (loc >= 8)
294bda940d3Spjanzen 			rspeak(58);
295df930be7Sderaadt 		return (2);
296df930be7Sderaadt 	}
297bda940d3Spjanzen 	if (k == look) {			/* 30			*/
298bda940d3Spjanzen 		if (detail++ < 3)
299bda940d3Spjanzen 			rspeak(15);
300df930be7Sderaadt 		wzdark = FALSE;
301df930be7Sderaadt 		abb[loc] = 0;
302df930be7Sderaadt 		return (2);
303df930be7Sderaadt 	}
304bda940d3Spjanzen 	if (k == back) {			/* 20			*/
305bda940d3Spjanzen 		switch(mback()) {
306bda940d3Spjanzen 		case 2: return (2);
307df930be7Sderaadt 		case 9: goto l9;
308df930be7Sderaadt 		default: bug(100);
309df930be7Sderaadt 		}
310df930be7Sderaadt 	}
311df930be7Sderaadt 	oldlc2 = oldloc;
312df930be7Sderaadt 	oldloc = loc;
313df930be7Sderaadt l9:
314df930be7Sderaadt 	for (; tkk != 0; tkk = tkk->next)
315bda940d3Spjanzen 		if (tkk->tverb == 1 || tkk->tverb == k)
316bda940d3Spjanzen 			break;
317bda940d3Spjanzen 	if (tkk == 0) {
318bda940d3Spjanzen 		badmove();
319df930be7Sderaadt 		return (2);
320df930be7Sderaadt 	}
321df930be7Sderaadt l11:	ll1 = tkk->conditions;			/* 11			*/
322df930be7Sderaadt 	ll2 = tkk->tloc;
323df930be7Sderaadt 	newloc = ll1;				/* newloc = conditions	*/
324df930be7Sderaadt 	k = newloc % 100;			/* k used for prob	*/
325bda940d3Spjanzen 	if (newloc <= 300) {
326bda940d3Spjanzen 		if (newloc <= 100) {		/* 13			*/
327bda940d3Spjanzen 			if (newloc != 0 && !pct(newloc))
328bda940d3Spjanzen 				goto l12;	/* 14			*/
329df930be7Sderaadt l16:			newloc = ll2;		/* newloc = location	*/
330bda940d3Spjanzen 			if (newloc <= 300)
331bda940d3Spjanzen 				return (2);
332df930be7Sderaadt 			if (newloc <= 500)
333bda940d3Spjanzen 				switch (specials()) { /* to 30000		*/
334bda940d3Spjanzen 				case 2: return (2);
335df930be7Sderaadt 				case 12: goto l12;
336df930be7Sderaadt 				case 99: return (99);
337df930be7Sderaadt 				default: bug(101);
338df930be7Sderaadt 				}
339df930be7Sderaadt 			rspeak(newloc - 500);
340df930be7Sderaadt 			newloc = loc;
341df930be7Sderaadt 			return (2);
342df930be7Sderaadt 		}
343bda940d3Spjanzen 		if (toting(k) || (newloc > 200 && at(k)))
344bda940d3Spjanzen 			goto l16;
345df930be7Sderaadt 		goto l12;
346df930be7Sderaadt 	}
347bda940d3Spjanzen 	if (prop[k] != (newloc / 100) - 3)
348bda940d3Spjanzen 		goto l16;	/* newloc still conditions	*/
349df930be7Sderaadt l12:	/* alternative to probability move	*/
350df930be7Sderaadt 	for (; tkk != 0; tkk = tkk->next)
351bda940d3Spjanzen 		if (tkk->tloc != ll2 || tkk->conditions != ll1)
352bda940d3Spjanzen 			break;
353bda940d3Spjanzen 	if (tkk == 0)
354bda940d3Spjanzen 		bug(25);
355df930be7Sderaadt 	goto l11;
356df930be7Sderaadt }
357df930be7Sderaadt 
358df930be7Sderaadt 
359bda940d3Spjanzen int
mback(void)360a5ca3416Sderaadt mback(void)			/* 20			*/
361bda940d3Spjanzen {
362bda940d3Spjanzen 	struct travlist *tk2,*j;
363bda940d3Spjanzen 	int     ll;
364bda940d3Spjanzen 
365bda940d3Spjanzen 	if (forced(k = oldloc))
366bda940d3Spjanzen 		k = oldlc2;	/* k = location		*/
367df930be7Sderaadt 	oldlc2 = oldloc;
368df930be7Sderaadt 	oldloc = loc;
369df930be7Sderaadt 	tk2 = 0;
370bda940d3Spjanzen 	if (k == loc) {
371bda940d3Spjanzen 		rspeak(91);
372df930be7Sderaadt 		return (2);
373df930be7Sderaadt 	}
374bda940d3Spjanzen 	for (; tkk != 0; tkk = tkk->next) {	/* 21			*/
375bda940d3Spjanzen 		ll = tkk->tloc;
376bda940d3Spjanzen 		if (ll == k) {
377bda940d3Spjanzen 			k = tkk->tverb;		/* k back to verb	*/
378df930be7Sderaadt 			tkk = travel[loc];
379df930be7Sderaadt 			return (9);
380df930be7Sderaadt 		}
381bda940d3Spjanzen 		if (ll <= 300) {
382bda940d3Spjanzen 			j = travel[loc];
383bda940d3Spjanzen 			if (forced(ll) && k == j->tloc)
384bda940d3Spjanzen 				tk2 = tkk;
385df930be7Sderaadt 		}
386df930be7Sderaadt 	}
387df930be7Sderaadt 	tkk = tk2;				/* 23			*/
388bda940d3Spjanzen 	if (tkk != 0) {
389bda940d3Spjanzen 		k = tkk->tverb;
390df930be7Sderaadt 		tkk = travel[loc];
391df930be7Sderaadt 		return (9);
392df930be7Sderaadt 	}
393df930be7Sderaadt 	rspeak(140);
394df930be7Sderaadt 	return (2);
395df930be7Sderaadt }
396df930be7Sderaadt 
397df930be7Sderaadt 
398bda940d3Spjanzen int
specials(void)399a5ca3416Sderaadt specials(void)			/* 30000		*/
400bda940d3Spjanzen {
401bda940d3Spjanzen 	switch(newloc -= 300) {
402bda940d3Spjanzen 	case 1:			/* 30100		*/
403df930be7Sderaadt 		newloc = 99 + 100 - loc;
404bda940d3Spjanzen 		if (holdng == 0 || (holdng == 1 && toting(emrald)))
405bda940d3Spjanzen 			return (2);
406df930be7Sderaadt 		newloc = loc;
407df930be7Sderaadt 		rspeak(117);
408df930be7Sderaadt 		return (2);
409df930be7Sderaadt 	case 2:			/* 30200		*/
410df930be7Sderaadt 		drop(emrald, loc);
411df930be7Sderaadt 		return (12);
412df930be7Sderaadt 	case 3:			/* to 30300		*/
413df930be7Sderaadt 		return (trbridge());
414bda940d3Spjanzen 	default:
415bda940d3Spjanzen 		bug(29);
416df930be7Sderaadt 	}
417df930be7Sderaadt }
418df930be7Sderaadt 
419df930be7Sderaadt 
420bda940d3Spjanzen int
trbridge(void)421a5ca3416Sderaadt trbridge(void)			/* 30300		*/
422bda940d3Spjanzen {
423bda940d3Spjanzen 	if (prop[troll] == 1) {
424bda940d3Spjanzen 		pspeak(troll, 1);
425df930be7Sderaadt 		prop[troll] = 0;
426df930be7Sderaadt 		move(troll2, 0);
427df930be7Sderaadt 		move(troll2 + 100, 0);
428df930be7Sderaadt 		move(troll, plac[troll]);
429df930be7Sderaadt 		move(troll + 100, fixd[troll]);
430df930be7Sderaadt 		juggle(chasm);
431df930be7Sderaadt 		newloc = loc;
432df930be7Sderaadt 		return (2);
433df930be7Sderaadt 	}
434df930be7Sderaadt 	newloc = plac[troll] + fixd[troll] - loc;	/* 30310		*/
435bda940d3Spjanzen 	if (prop[troll] == 0)
436bda940d3Spjanzen 		prop[troll] = 1;
437bda940d3Spjanzen 	if (!toting(bear))
438bda940d3Spjanzen 		return (2);
439df930be7Sderaadt 	rspeak(162);
440df930be7Sderaadt 	prop[chasm] = 1;
441df930be7Sderaadt 	prop[troll] = 2;
442df930be7Sderaadt 	drop(bear, newloc);
443df930be7Sderaadt 	fixed[bear] = -1;
444df930be7Sderaadt 	prop[bear] = 3;
445bda940d3Spjanzen 	if (prop[spices] < 0)
446bda940d3Spjanzen 		tally2++;
447df930be7Sderaadt 	oldlc2 = newloc;
448df930be7Sderaadt 	return (99);
449df930be7Sderaadt }
450df930be7Sderaadt 
451df930be7Sderaadt 
4522deb5d9fSpjanzen void
badmove(void)453a5ca3416Sderaadt badmove(void)					/* 20			*/
454bda940d3Spjanzen {
455bda940d3Spjanzen 	spk = 12;
456bda940d3Spjanzen 	if (k >= 43 && k <= 50)
457bda940d3Spjanzen 		spk = 9;
458bda940d3Spjanzen 	if (k == 29 || k == 30)
459bda940d3Spjanzen 		spk = 9;
460bda940d3Spjanzen 	if (k == 7 || k == 36 || k == 37)
461bda940d3Spjanzen 		spk = 10;
462bda940d3Spjanzen 	if (k == 11 || k == 19)
463bda940d3Spjanzen 		spk = 11;
464bda940d3Spjanzen 	if (verb == find || verb == invent)
465bda940d3Spjanzen 		spk = 59;
466bda940d3Spjanzen 	if (k == 62 || k == 65)
467bda940d3Spjanzen 		spk = 42;
468bda940d3Spjanzen 	if (k == 17)
469bda940d3Spjanzen 		spk = 80;
470df930be7Sderaadt 	rspeak(spk);
471df930be7Sderaadt }
472df930be7Sderaadt 
4732deb5d9fSpjanzen void
bug(int n)474a5ca3416Sderaadt bug(int n)
475bda940d3Spjanzen {
476bda940d3Spjanzen /*	printf("Please tell jim@rand.org that fatal bug %d happened.\n",n); */
477bda940d3Spjanzen 	fprintf(stderr,
478bda940d3Spjanzen 	    "Please use sendbug to report that bug %d happened in adventure.\n", n);
479bda940d3Spjanzen 	exit(n);
480df930be7Sderaadt }
481df930be7Sderaadt 
482df930be7Sderaadt 
483bda940d3Spjanzen void
checkhints(void)484a5ca3416Sderaadt checkhints(void)				/* 2600 &c		*/
485bda940d3Spjanzen {
486bda940d3Spjanzen 	int     hint;
487bda940d3Spjanzen 
488bda940d3Spjanzen 	for (hint = 4; hint <= hntmax; hint++) {
489bda940d3Spjanzen 		if (hinted[hint])
490bda940d3Spjanzen 			continue;
491bda940d3Spjanzen 		if (!bitset(loc, hint))
492bda940d3Spjanzen 			hintlc[hint] = -1;
493df930be7Sderaadt 		hintlc[hint]++;
494bda940d3Spjanzen 		if (hintlc[hint] < hints[hint][1])
495bda940d3Spjanzen 			continue;
496bda940d3Spjanzen 		switch (hint) {
497bda940d3Spjanzen 		case 4:		/* 40400 */
498bda940d3Spjanzen 			if (prop[grate] == 0 && !here(keys))
499bda940d3Spjanzen 				goto l40010;
500df930be7Sderaadt 			goto l40020;
501df930be7Sderaadt 		case 5:		/* 40500 */
502bda940d3Spjanzen 			if (here(bird) && toting(rod) && obj == bird)
503bda940d3Spjanzen 				goto l40010;
504df930be7Sderaadt 			continue;      /* i.e. goto l40030 */
505df930be7Sderaadt 		case 6:		/* 40600 */
506bda940d3Spjanzen 			if (here(snake) && !here(bird))
507bda940d3Spjanzen 				goto l40010;
508df930be7Sderaadt 			goto l40020;
509df930be7Sderaadt 		case 7:		/* 40700 */
510df930be7Sderaadt 			if (atloc[loc] == 0 && atloc[oldloc] == 0
511bda940d3Spjanzen 			    && atloc[oldlc2] == 0 && holdng > 1)
512bda940d3Spjanzen 				goto l40010;
513df930be7Sderaadt 			goto l40020;
514df930be7Sderaadt 		case 8:		/* 40800 */
515bda940d3Spjanzen 			if (prop[emrald] !=  -1 && prop[pyram] == -1)
516bda940d3Spjanzen 				goto l40010;
517df930be7Sderaadt 			goto l40020;
518df930be7Sderaadt 		case 9:
519df930be7Sderaadt 			goto l40010;	/* 40900 */
520bda940d3Spjanzen 		default:
521bda940d3Spjanzen 			bug(27);
522df930be7Sderaadt 		}
523df930be7Sderaadt l40010:		hintlc[hint] = 0;
524bda940d3Spjanzen 		if (!yes(hints[hint][3], 0, 54))
525bda940d3Spjanzen 			continue;
526df930be7Sderaadt 		printf("I am prepared to give you a hint, but it will ");
527df930be7Sderaadt 		printf("cost you %d points.\n", hints[hint][2]);
528df930be7Sderaadt 		hinted[hint] = yes(175, hints[hint][4], 54);
529df930be7Sderaadt l40020:		hintlc[hint] = 0;
530df930be7Sderaadt 	}
531df930be7Sderaadt }
532df930be7Sderaadt 
533df930be7Sderaadt 
534bda940d3Spjanzen int
trsay(void)535a5ca3416Sderaadt trsay(void)			/* 9030			*/
536bda940d3Spjanzen {
537bda940d3Spjanzen 	int i;
538bda940d3Spjanzen 
5398a190032Smillert 	if (wd2[0] != 0)
5408a190032Smillert 		strlcpy(wd1, wd2, sizeof(wd1));
541bda940d3Spjanzen 	i = vocab(wd1, -1, 0);
542bda940d3Spjanzen 	if (i == 62 || i == 65 || i == 71 || i == 2025) {
5438a190032Smillert 		wd2[0] = 0;
544df930be7Sderaadt 		obj = 0;
545df930be7Sderaadt 		return (2630);
546df930be7Sderaadt 	}
547df930be7Sderaadt 	printf("\nOkay, \"%s\".\n", wd2);
548df930be7Sderaadt 	return (2012);
549df930be7Sderaadt }
550df930be7Sderaadt 
551df930be7Sderaadt 
552bda940d3Spjanzen int
trtake(void)553a5ca3416Sderaadt trtake(void)			/* 9010			*/
554bda940d3Spjanzen {
555bda940d3Spjanzen 	if (toting(obj))
556bda940d3Spjanzen 		return (2011);	/* 9010 */
557df930be7Sderaadt 	spk = 25;
558bda940d3Spjanzen 	if (obj == plant && prop[plant] <= 0)
559bda940d3Spjanzen 		spk = 115;
560bda940d3Spjanzen 	if (obj == bear && prop[bear] == 1)
561bda940d3Spjanzen 		spk = 169;
562bda940d3Spjanzen 	if (obj == chain && prop[bear] != 0)
563bda940d3Spjanzen 		spk = 170;
564bda940d3Spjanzen 	if (fixed[obj] != 0)
565bda940d3Spjanzen 		return (2011);
566bda940d3Spjanzen 	if (obj == water || obj == oil) {
567bda940d3Spjanzen 		if (here(bottle) && liq() == obj) {
568bda940d3Spjanzen 			obj = bottle;
569df930be7Sderaadt 			goto l9017;
570df930be7Sderaadt 		}
571df930be7Sderaadt 		obj = bottle;
572df930be7Sderaadt 		if (toting(bottle) && prop[bottle] == 1)
573df930be7Sderaadt 			return (9220);
574bda940d3Spjanzen 		if (prop[bottle] != 1)
575bda940d3Spjanzen 			spk = 105;
576bda940d3Spjanzen 		if (!toting(bottle))
577bda940d3Spjanzen 			spk = 104;
578df930be7Sderaadt 		return (2011);
579df930be7Sderaadt 	}
580bda940d3Spjanzen l9017:	if (holdng >= 7) {
581bda940d3Spjanzen 		rspeak(92);
582df930be7Sderaadt 		return (2012);
583df930be7Sderaadt 	}
584bda940d3Spjanzen 	if (obj == bird) {
585bda940d3Spjanzen 		if (prop[bird] != 0)
586bda940d3Spjanzen 			goto l9014;
587bda940d3Spjanzen 		if (toting(rod)) {
588bda940d3Spjanzen 			rspeak(26);
589df930be7Sderaadt 			return (2012);
590df930be7Sderaadt 		}
591bda940d3Spjanzen 		if (!toting(cage)) {	/* 9013 */
592bda940d3Spjanzen 			rspeak(27);
593df930be7Sderaadt 			return (2012);
594df930be7Sderaadt 		}
595df930be7Sderaadt 		prop[bird] = 1;		/* 9015 */
596df930be7Sderaadt 	}
597df930be7Sderaadt l9014:	if ((obj == bird || obj == cage) && prop[bird] != 0)
598df930be7Sderaadt 		carry(bird + cage - obj, loc);
599df930be7Sderaadt 	carry(obj, loc);
600bda940d3Spjanzen 	k = liq();
601bda940d3Spjanzen 	if (obj == bottle && k != 0)
602bda940d3Spjanzen 		place[k] = -1;
603df930be7Sderaadt 	return (2009);
604df930be7Sderaadt }
605df930be7Sderaadt 
606df930be7Sderaadt 
607bda940d3Spjanzen int
dropper(void)608a5ca3416Sderaadt dropper(void)			/* 9021			*/
609bda940d3Spjanzen {
610bda940d3Spjanzen 	k = liq();
611bda940d3Spjanzen 	if (k == obj)
612bda940d3Spjanzen 		obj = bottle;
613bda940d3Spjanzen 	if (obj == bottle && k != 0)
614bda940d3Spjanzen 		place[k] = 0;
615bda940d3Spjanzen 	if (obj == cage && prop[bird] != 0)
616bda940d3Spjanzen 		drop(bird, loc);
617bda940d3Spjanzen 	if (obj == bird)
618bda940d3Spjanzen 		prop[bird] = 0;
619df930be7Sderaadt 	drop(obj, loc);
620df930be7Sderaadt 	return (2012);
621df930be7Sderaadt }
622df930be7Sderaadt 
623bda940d3Spjanzen int
trdrop(void)624a5ca3416Sderaadt trdrop(void)			/* 9020			*/
625df930be7Sderaadt {
626bda940d3Spjanzen 	if (toting(rod2) && obj == rod && !toting(rod))
627bda940d3Spjanzen 		obj = rod2;
628bda940d3Spjanzen 	if (!toting(obj))
629bda940d3Spjanzen 		return (2011);
630bda940d3Spjanzen 	if (obj == bird && here(snake)) {
631bda940d3Spjanzen 		rspeak(30);
632bda940d3Spjanzen 		if (closed)
633bda940d3Spjanzen 			return (19000);
634df930be7Sderaadt 		dstroy(snake);
635df930be7Sderaadt 		prop[snake] = 1;
636df930be7Sderaadt 		return (dropper());
637df930be7Sderaadt 	}
638bda940d3Spjanzen 	if (obj == coins && here(vend))	{	/* 9024			*/
639bda940d3Spjanzen 		dstroy(coins);
640df930be7Sderaadt 		drop(batter, loc);
641df930be7Sderaadt 		pspeak(batter, 0);
642df930be7Sderaadt 		return (2012);
643df930be7Sderaadt 	}
644bda940d3Spjanzen 	if (obj == bird && at(dragon) && prop[dragon] == 0) {	/* 9025	*/
645bda940d3Spjanzen 		rspeak(154);
646df930be7Sderaadt 		dstroy(bird);
647df930be7Sderaadt 		prop[bird] = 0;
648bda940d3Spjanzen 		if (place[snake] == plac[snake])
649bda940d3Spjanzen 			tally2--;
650df930be7Sderaadt 		return (2012);
651df930be7Sderaadt 	}
652bda940d3Spjanzen 	if (obj == bear && at(troll)) {		/* 9026		*/
653bda940d3Spjanzen 		rspeak(163);
654df930be7Sderaadt 		move(troll, 0);
655df930be7Sderaadt 		move(troll + 100, 0);
656df930be7Sderaadt 		move(troll2, plac[troll]);
657df930be7Sderaadt 		move(troll2 + 100, fixd[troll]);
658df930be7Sderaadt 		juggle(chasm);
659df930be7Sderaadt 		prop[troll] = 2;
660df930be7Sderaadt 		return (dropper());
661df930be7Sderaadt 	}
662bda940d3Spjanzen 	if (obj != vase || loc == plac[pillow]) {	/* 9027	*/
663bda940d3Spjanzen 		rspeak(54);
664df930be7Sderaadt 		return (dropper());
665df930be7Sderaadt 	}
666df930be7Sderaadt 	prop[vase] = 2;				/* 9028		*/
667bda940d3Spjanzen 	if (at(pillow))
668bda940d3Spjanzen 		prop[vase] = 0;
669df930be7Sderaadt 	pspeak(vase, prop[vase] + 1);
670bda940d3Spjanzen 	if (prop[vase] != 0)
671bda940d3Spjanzen 		fixed[vase] = -1;
672df930be7Sderaadt 	return (dropper());
673df930be7Sderaadt }
674df930be7Sderaadt 
675df930be7Sderaadt 
676bda940d3Spjanzen int
tropen(void)677a5ca3416Sderaadt tropen(void)					/* 9040			*/
678bda940d3Spjanzen {
679bda940d3Spjanzen 	if (obj == clam || obj == oyster) {
680bda940d3Spjanzen 		k = 0;				/* 9046			*/
681bda940d3Spjanzen 		if (obj == oyster)
682bda940d3Spjanzen 			k = 1;
683df930be7Sderaadt 		spk = 124 + k;
684bda940d3Spjanzen 		if (toting(obj))
685bda940d3Spjanzen 			spk = 120 + k;
686bda940d3Spjanzen 		if (!toting(tridnt))
687bda940d3Spjanzen 			spk = 122 + k;
688bda940d3Spjanzen 		if (verb == lock)
689bda940d3Spjanzen 			spk = 61;
690bda940d3Spjanzen 		if (spk != 124)
691bda940d3Spjanzen 			return (2011);
692df930be7Sderaadt 		dstroy(clam);
693df930be7Sderaadt 		drop(oyster, loc);
694df930be7Sderaadt 		drop(pearl, 105);
695df930be7Sderaadt 		return (2011);
696df930be7Sderaadt 	}
697bda940d3Spjanzen 	if (obj == door)
698bda940d3Spjanzen 		spk = 111;
699bda940d3Spjanzen 	if (obj == door && prop[door] == 1)
700bda940d3Spjanzen 		spk = 54;
701bda940d3Spjanzen 	if (obj == cage)
702bda940d3Spjanzen 		spk = 32;
703bda940d3Spjanzen 	if (obj == keys)
704bda940d3Spjanzen 		spk = 55;
705bda940d3Spjanzen 	if (obj == grate || obj == chain)
706bda940d3Spjanzen 		spk = 31;
707bda940d3Spjanzen 	if (spk != 31||!here(keys))
708bda940d3Spjanzen 		return (2011);
709bda940d3Spjanzen 	if (obj == chain) {
710bda940d3Spjanzen 		if (verb == lock) {
711bda940d3Spjanzen 			spk = 172;		/* 9049: lock		*/
712bda940d3Spjanzen 			if (prop[chain] != 0)
713bda940d3Spjanzen 				spk = 34;
714bda940d3Spjanzen 			if (loc != plac[chain])
715bda940d3Spjanzen 				spk = 173;
716bda940d3Spjanzen 			if (spk != 172)
717bda940d3Spjanzen 				return (2011);
718df930be7Sderaadt 			prop[chain] = 2;
719bda940d3Spjanzen 			if (toting(chain))
720bda940d3Spjanzen 				drop(chain, loc);
721df930be7Sderaadt 			fixed[chain] = -1;
722df930be7Sderaadt 			return (2011);
723df930be7Sderaadt 		}
724df930be7Sderaadt 		spk = 171;
725bda940d3Spjanzen 		if (prop[bear] == 0)
726bda940d3Spjanzen 			spk = 41;
727bda940d3Spjanzen 		if (prop[chain] == 0)
728bda940d3Spjanzen 			spk = 37;
729bda940d3Spjanzen 		if (spk != 171)
730bda940d3Spjanzen 			return (2011);
731df930be7Sderaadt 		prop[chain] = 0;
732df930be7Sderaadt 		fixed[chain] = 0;
733bda940d3Spjanzen 		if (prop[bear] != 3)
734bda940d3Spjanzen 			prop[bear] = 2;
735df930be7Sderaadt 		fixed[bear] = 2 - prop[bear];
736df930be7Sderaadt 		return (2011);
737df930be7Sderaadt 	}
738bda940d3Spjanzen 	if (closng) {
739bda940d3Spjanzen 		k = 130;
740bda940d3Spjanzen 		if (!panic)
741bda940d3Spjanzen 			clock2 = 15;
742df930be7Sderaadt 		panic = TRUE;
743df930be7Sderaadt 		return (2010);
744df930be7Sderaadt 	}
745df930be7Sderaadt 	k = 34 + prop[grate];			/* 9043			*/
746df930be7Sderaadt 	prop[grate] = 1;
747bda940d3Spjanzen 	if (verb == lock)
748bda940d3Spjanzen 		prop[grate] = 0;
749df930be7Sderaadt 	k = k + 2 * prop[grate];
750df930be7Sderaadt 	return (2010);
751df930be7Sderaadt }
752df930be7Sderaadt 
753df930be7Sderaadt 
754bda940d3Spjanzen int
trkill(void)755a5ca3416Sderaadt trkill(void)				/* 9120				*/
756bda940d3Spjanzen {
757bda940d3Spjanzen 	int i;
758bda940d3Spjanzen 
759df930be7Sderaadt 	for (i = 1; i <= 5; i++)
760bda940d3Spjanzen 		if (dloc[i] == loc && dflag >= 2)
761bda940d3Spjanzen 			break;
762bda940d3Spjanzen 	if (i == 6)
763bda940d3Spjanzen 		i = 0;
764bda940d3Spjanzen 	if (obj == 0) {			/* 9122				*/
765bda940d3Spjanzen 		if (i != 0)
766bda940d3Spjanzen 			obj = dwarf;
767bda940d3Spjanzen 		if (here(snake))
768bda940d3Spjanzen 			obj = obj * 100 + snake;
769bda940d3Spjanzen 		if (at(dragon) && prop[dragon] == 0)
770bda940d3Spjanzen 			obj = obj * 100 + dragon;
771bda940d3Spjanzen 		if (at(troll))
772bda940d3Spjanzen 			obj = obj * 100 + troll;
773bda940d3Spjanzen 		if (here(bear) && prop[bear] == 0)
774bda940d3Spjanzen 			obj = obj * 100 + bear;
775bda940d3Spjanzen 		if (obj > 100)
776bda940d3Spjanzen 			return (8000);
777bda940d3Spjanzen 		if (obj == 0) {
778bda940d3Spjanzen 			if (here(bird) && verb != throw)
779bda940d3Spjanzen 				obj = bird;
780bda940d3Spjanzen 			if (here(clam) || here(oyster))
781bda940d3Spjanzen 				obj = 100 * obj + clam;
782bda940d3Spjanzen 			if (obj > 100)
783bda940d3Spjanzen 				return (8000);
784df930be7Sderaadt 		}
785df930be7Sderaadt 	}
786bda940d3Spjanzen 	if (obj == bird) {		/* 9124				*/
787bda940d3Spjanzen 		spk = 137;
788bda940d3Spjanzen 		if (closed)
789bda940d3Spjanzen 			return (2011);
790df930be7Sderaadt 		dstroy(bird);
791df930be7Sderaadt 		prop[bird] = 0;
792bda940d3Spjanzen 		if (place[snake] == plac[snake])
793bda940d3Spjanzen 			tally2++;
794df930be7Sderaadt 		spk = 45;
795df930be7Sderaadt 	}
796bda940d3Spjanzen 	if (obj == 0)
797bda940d3Spjanzen 		spk = 44;		/* 9125				*/
798bda940d3Spjanzen 	if (obj == clam || obj == oyster)
799bda940d3Spjanzen 		spk = 150;
800bda940d3Spjanzen 	if (obj == snake)
801bda940d3Spjanzen 		spk = 46;
802bda940d3Spjanzen 	if (obj == dwarf)
803bda940d3Spjanzen 		spk = 49;
804bda940d3Spjanzen 	if (obj == dwarf && closed)
805bda940d3Spjanzen 		return (19000);
806bda940d3Spjanzen 	if (obj == dragon)
807bda940d3Spjanzen 		spk = 147;
808bda940d3Spjanzen 	if (obj == troll)
809bda940d3Spjanzen 		spk = 157;
810bda940d3Spjanzen 	if (obj == bear)
811bda940d3Spjanzen 		spk = 165 + (prop[bear] + 1) / 2;
812bda940d3Spjanzen 	if (obj != dragon || prop[dragon] != 0)
813bda940d3Spjanzen 		return (2011);
814df930be7Sderaadt 	rspeak(49);
815df930be7Sderaadt 	verb = 0;
816df930be7Sderaadt 	obj = 0;
8178a190032Smillert 	getin(wd1, sizeof(wd1), wd2, sizeof(wd2));
818bda940d3Spjanzen 	if (!weq(wd1, "y") && !weq(wd1, "yes"))
819bda940d3Spjanzen 		return (2608);
820df930be7Sderaadt 	pspeak(dragon, 1);
821df930be7Sderaadt 	prop[dragon] = 2;
822df930be7Sderaadt 	prop[rug] = 0;
823df930be7Sderaadt 	k = (plac[dragon] + fixd[dragon]) / 2;
824df930be7Sderaadt 	move(dragon + 100, -1);
825df930be7Sderaadt 	move(rug + 100, 0);
826df930be7Sderaadt 	move(dragon, k);
827df930be7Sderaadt 	move(rug, k);
828df930be7Sderaadt 	for (obj = 1; obj <= 100; obj++)
829df930be7Sderaadt 		if (place[obj] == plac[dragon] || place[obj] == fixd[dragon])
830df930be7Sderaadt 			move(obj, k);
831df930be7Sderaadt 	loc = k;
832df930be7Sderaadt 	k = null;
833df930be7Sderaadt 	return (8);
834df930be7Sderaadt }
835df930be7Sderaadt 
836df930be7Sderaadt 
837bda940d3Spjanzen int
trtoss(void)838a5ca3416Sderaadt trtoss(void)				/* 9170: throw			*/
839bda940d3Spjanzen {
840bda940d3Spjanzen 	int i;
841bda940d3Spjanzen 
842bda940d3Spjanzen 	if (toting(rod2) && obj == rod && !toting(rod))
843bda940d3Spjanzen 		obj = rod2;
844bda940d3Spjanzen 	if (!toting(obj))
845bda940d3Spjanzen 		return (2011);
846bda940d3Spjanzen 	if (obj >= 50 && obj <= maxtrs && at(troll)) {
847bda940d3Spjanzen 		spk = 159;			/* 9178			*/
848df930be7Sderaadt 		drop(obj, 0);
849df930be7Sderaadt 		move(troll, 0);
850df930be7Sderaadt 		move(troll + 100, 0);
851df930be7Sderaadt 		drop(troll2, plac[troll]);
852df930be7Sderaadt 		drop(troll2 + 100, fixd[troll]);
853df930be7Sderaadt 		juggle(chasm);
854df930be7Sderaadt 		return (2011);
855df930be7Sderaadt 	}
856bda940d3Spjanzen 	if (obj == food && here(bear)) {
857bda940d3Spjanzen 		obj = bear;			/* 9177			*/
858df930be7Sderaadt 		return (9210);
859df930be7Sderaadt 	}
860bda940d3Spjanzen 	if (obj != axe)
861bda940d3Spjanzen 		return (9020);
862bda940d3Spjanzen 	for (i = 1; i <= 5; i++) {
863bda940d3Spjanzen 		if (dloc[i] == loc) {
864bda940d3Spjanzen 			spk = 48;		/* 9172			*/
865bda940d3Spjanzen 			if (ran(3) == 0 || saved != -1) {
866bda940d3Spjanzen l9175:
867bda940d3Spjanzen 				rspeak(spk);
868df930be7Sderaadt 				drop(axe, loc);
869df930be7Sderaadt 				k = null;
870df930be7Sderaadt 				return (8);
871df930be7Sderaadt 			}
872df930be7Sderaadt 			dseen[i] = FALSE;
873df930be7Sderaadt 			dloc[i] = 0;
874df930be7Sderaadt 			spk = 47;
875df930be7Sderaadt 			dkill++;
876bda940d3Spjanzen 			if (dkill == 1)
877bda940d3Spjanzen 				spk = 149;
878df930be7Sderaadt 			goto l9175;
879df930be7Sderaadt 		}
880df930be7Sderaadt 	}
881df930be7Sderaadt 	spk = 152;
882df930be7Sderaadt 	if (at(dragon) && prop[dragon] == 0)
883df930be7Sderaadt 		goto l9175;
884df930be7Sderaadt 	spk = 158;
885bda940d3Spjanzen 	if (at(troll))
886bda940d3Spjanzen 		goto l9175;
887bda940d3Spjanzen 	if (here(bear) && prop[bear] == 0) {
888bda940d3Spjanzen 		spk = 164;
889df930be7Sderaadt 		drop(axe, loc);
890df930be7Sderaadt 		fixed[axe] = -1;
891df930be7Sderaadt 		prop[axe] = 1;
892df930be7Sderaadt 		juggle(bear);
893df930be7Sderaadt 		return (2011);
894df930be7Sderaadt 	}
895df930be7Sderaadt 	obj = 0;
896df930be7Sderaadt 	return (9120);
897df930be7Sderaadt }
898df930be7Sderaadt 
899df930be7Sderaadt 
900bda940d3Spjanzen int
trfeed(void)901a5ca3416Sderaadt trfeed(void)					/* 9210			*/
902bda940d3Spjanzen {
903bda940d3Spjanzen 	if (obj == bird) {
904bda940d3Spjanzen 		spk = 100;
905df930be7Sderaadt 		return (2011);
906df930be7Sderaadt 	}
907bda940d3Spjanzen 	if (obj == snake || obj == dragon || obj == troll) {
908bda940d3Spjanzen 		spk = 102;
909bda940d3Spjanzen 		if (obj == dragon && prop[dragon] != 0)
910bda940d3Spjanzen 			spk = 110;
911bda940d3Spjanzen 		if (obj == troll)
912bda940d3Spjanzen 			spk = 182;
913bda940d3Spjanzen 		if (obj != snake || closed || !here(bird))
914bda940d3Spjanzen 			return (2011);
915df930be7Sderaadt 		spk = 101;
916df930be7Sderaadt 		dstroy(bird);
917df930be7Sderaadt 		prop[bird] = 0;
918df930be7Sderaadt 		tally2++;
919df930be7Sderaadt 		return (2011);
920df930be7Sderaadt 	}
921bda940d3Spjanzen 	if (obj == dwarf) {
922bda940d3Spjanzen 		if (!here(food))
923bda940d3Spjanzen 			return (2011);
924df930be7Sderaadt 		spk = 103;
925df930be7Sderaadt 		dflag++;
926df930be7Sderaadt 		return (2011);
927df930be7Sderaadt 	}
928bda940d3Spjanzen 	if (obj == bear) {
929bda940d3Spjanzen 		if (prop[bear] == 0)
930bda940d3Spjanzen 			spk = 102;
931bda940d3Spjanzen 		if (prop[bear] == 3)
932bda940d3Spjanzen 			spk = 110;
933bda940d3Spjanzen 		if (!here(food))
934bda940d3Spjanzen 			return (2011);
935df930be7Sderaadt 		dstroy(food);
936df930be7Sderaadt 		prop[bear] = 1;
937df930be7Sderaadt 		fixed[axe] = 0;
938df930be7Sderaadt 		prop[axe] = 0;
939df930be7Sderaadt 		spk = 168;
940df930be7Sderaadt 		return (2011);
941df930be7Sderaadt 	}
942df930be7Sderaadt 	spk = 14;
943df930be7Sderaadt 	return (2011);
944df930be7Sderaadt }
945df930be7Sderaadt 
946df930be7Sderaadt 
947bda940d3Spjanzen int
trfill(void)948a5ca3416Sderaadt trfill(void)					/* 9220 */
949bda940d3Spjanzen {
950bda940d3Spjanzen 	if (obj == vase) {
951bda940d3Spjanzen 		spk = 29;
952bda940d3Spjanzen 		if (liqloc(loc) == 0)
953bda940d3Spjanzen 			spk = 144;
954bda940d3Spjanzen 		if (liqloc(loc) == 0 || !toting(vase))
955bda940d3Spjanzen 			return (2011);
956df930be7Sderaadt 		rspeak(145);
957df930be7Sderaadt 		prop[vase] = 2;
958df930be7Sderaadt 		fixed[vase] = -1;
959df930be7Sderaadt 		return (9020);		/* advent/10 goes to 9024 */
960df930be7Sderaadt 	}
961bda940d3Spjanzen 	if (obj != 0 && obj != bottle)
962bda940d3Spjanzen 		return (2011);
963bda940d3Spjanzen 	if (obj == 0 && !here(bottle))
964bda940d3Spjanzen 		return (8000);
965df930be7Sderaadt 	spk = 107;
966bda940d3Spjanzen 	if (liqloc(loc) == 0)
967bda940d3Spjanzen 		spk = 106;
968bda940d3Spjanzen 	if (liq() != 0)
969bda940d3Spjanzen 		spk = 105;
970bda940d3Spjanzen 	if (spk != 107)
971bda940d3Spjanzen 		return (2011);
972df930be7Sderaadt 	prop[bottle] = ((cond[loc] % 4) / 2) * 2;
973bda940d3Spjanzen 	k = liq();
974bda940d3Spjanzen 	if (toting(bottle))
975bda940d3Spjanzen 		place[k] = -1;
976bda940d3Spjanzen 	if (k == oil)
977bda940d3Spjanzen 		spk = 108;
978df930be7Sderaadt 	return (2011);
979df930be7Sderaadt }
980df930be7Sderaadt 
981df930be7Sderaadt 
9822deb5d9fSpjanzen void
closing(void)983a5ca3416Sderaadt closing(void)				/* 10000 */
984bda940d3Spjanzen {
985bda940d3Spjanzen 	int i;
986df930be7Sderaadt 
987df930be7Sderaadt 	prop[grate] = prop[fissur] = 0;
988bda940d3Spjanzen 	for (i = 1; i <= 6; i++) {
989bda940d3Spjanzen 		dseen[i] = FALSE;
990df930be7Sderaadt 		dloc[i] = 0;
991df930be7Sderaadt 	}
992df930be7Sderaadt 	move(troll, 0);
993df930be7Sderaadt 	move(troll + 100, 0);
994df930be7Sderaadt 	move(troll2, plac[troll]);
995df930be7Sderaadt 	move(troll2 + 100, fixd[troll]);
996df930be7Sderaadt 	juggle(chasm);
997bda940d3Spjanzen 	if (prop[bear] != 3)
998bda940d3Spjanzen 		dstroy(bear);
999df930be7Sderaadt 	prop[chain] = 0;
1000df930be7Sderaadt 	fixed[chain] = 0;
1001df930be7Sderaadt 	prop[axe] = 0;
1002df930be7Sderaadt 	fixed[axe] = 0;
1003df930be7Sderaadt 	rspeak(129);
1004df930be7Sderaadt 	clock1 = -1;
1005df930be7Sderaadt 	closng = TRUE;
1006df930be7Sderaadt }
1007df930be7Sderaadt 
1008df930be7Sderaadt 
10092deb5d9fSpjanzen void
caveclose(void)1010a5ca3416Sderaadt caveclose(void)				/* 11000 */
1011bda940d3Spjanzen {
1012bda940d3Spjanzen 	int i;
1013bda940d3Spjanzen 
1014df930be7Sderaadt 	prop[bottle] = put(bottle, 115, 1);
1015df930be7Sderaadt 	prop[plant] = put(plant, 115, 0);
1016df930be7Sderaadt 	prop[oyster] = put(oyster, 115, 0);
1017df930be7Sderaadt 	prop[lamp] = put(lamp, 115, 0);
1018df930be7Sderaadt 	prop[rod] = put(rod, 115, 0);
1019df930be7Sderaadt 	prop[dwarf] = put(dwarf, 115, 0);
1020df930be7Sderaadt 	loc = 115;
1021df930be7Sderaadt 	oldloc = 115;
1022df930be7Sderaadt 	newloc = 115;
1023df930be7Sderaadt 
1024df930be7Sderaadt 	put(grate, 116, 0);
1025df930be7Sderaadt 	prop[snake] = put(snake, 116, 1);
1026df930be7Sderaadt 	prop[bird] = put(bird, 116, 1);
1027df930be7Sderaadt 	prop[cage] = put(cage, 116, 0);
1028df930be7Sderaadt 	prop[rod2] = put(rod2, 116, 0);
1029df930be7Sderaadt 	prop[pillow] = put(pillow, 116, 0);
1030df930be7Sderaadt 
1031df930be7Sderaadt 	prop[mirror] = put(mirror, 115, 0);
1032df930be7Sderaadt 	fixed[mirror] = 116;
1033df930be7Sderaadt 
1034df930be7Sderaadt 	for (i = 1; i <= 100; i++)
1035bda940d3Spjanzen 		if (toting(i))
1036bda940d3Spjanzen 			dstroy(i);
1037df930be7Sderaadt 	rspeak(132);
1038df930be7Sderaadt 	closed = TRUE;
1039df930be7Sderaadt }
1040