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