xref: /netbsd-src/games/adventure/subr.c (revision 1182a44c59cae4d586117d55eca24b4b8b173211)

/*	$NetBSD: subr.c,v 1.14 2021/05/02 12:50:43 rillig Exp $	*/

/*-
 * Copyright (c) 1991, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * The game adventure was originally written in Fortran by Will Crowther
 * and Don Woods.  It was later translated to C and enhanced by Jim
 * Gillogly.  This code is derived from software contributed to Berkeley
 * by Jim Gillogly at The Rand Corporation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)subr.c	8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: subr.c,v 1.14 2021/05/02 12:50:43 rillig Exp $");
#endif
#endif				/* not lint */

/*      Re-coding of advent in C: subroutines from main                 */

#include <stdio.h>
#include <stdlib.h>
#include "hdr.h"
#include "extern.h"

static void badmove(void);
static int bitset(int, int);
static int dropper(void);
static int liq2(int);
static int mback(void);
static int specials(void);
static int trbridge(void);

/*              Statement functions     */
int
toting(int objj)
{
	if (place[objj] == -1)
		return (TRUE);
	else
		return (FALSE);
}

int
here(int objj)
{
	if (place[objj] == loc || toting(objj))
		return (TRUE);
	else
		return (FALSE);
}

int
at(int objj)
{
	if (place[objj] == loc || fixed[objj] == loc)
		return (TRUE);
	else
		return (FALSE);
}

static int
liq2(int pbotl)
{
	return ((1 - pbotl) * water + (pbotl / 2) * (water + oil));
}

int
liq(void)
{
	int     i;
	i = prop[bottle];
	if (i > -1 - i)
		return (liq2(i));
	else
		return (liq2(-1 - i));
}

/* may want to clean this one up a bit */
int
liqloc(int locc)
{
	int     i, j, l;
	i = cond[locc] / 2;
	j = ((i * 2) % 8) - 5;
	l = cond[locc] / 4;
	l = l % 2;
	return (liq2(j * l + 1));
}

static int
bitset(int l, int n)
{
	if (cond[l] & setbit[n])
		return (TRUE);
	return (FALSE);
}

int
forced(int locc)
{
	if (cond[locc] == 2)
		return (TRUE);
	return (FALSE);
}

int
dark(void)
{
	if ((cond[loc] % 2) == 0 && (prop[lamp] == 0 || !here(lamp)))
		return (TRUE);
	return (FALSE);
}

int
pct(int n)
{
	if (ran(100) < n)
		return (TRUE);
	return (FALSE);
}


int
fdwarf(void)
{				/* 71 */
	int     i, j;
	struct travlist *kk;

	if (newloc != loc && !forced(loc) && !bitset(loc, 3)) {
		for (i = 1; i <= 5; i++) {
			if (odloc[i] != newloc || !dseen[i])
				continue;
			newloc = loc;
			rspeak(2);
			break;
		}
	}
	loc = newloc;		/* 74 */
	if (loc == 0 || forced(loc) || bitset(newloc, 3))
		return (2000);
	if (dflag == 0) {
		if (loc >= 15)
			dflag = 1;
		return (2000);
	}
	if (dflag == 1) {	/* 6000 */
		if (loc < 15 || pct(95))
			return (2000);
		dflag = 2;
		for (i = 1; i <= 2; i++) {
			j = 1 + ran(5);
			if (pct(50) && saved == -1)
				dloc[j] = 0;	/* 6001 */
		}
		for (i = 1; i <= 5; i++) {
			if (dloc[i] == loc)
				dloc[i] = daltloc;
			odloc[i] = dloc[i];	/* 6002 */
		}
		rspeak(3);
		drop(axe, loc);
		return (2000);
	}
	dtotal = attack = stick = 0;	/* 6010 */
	for (i = 1; i <= 6; i++) {	/* loop to 6030 */
		if (dloc[i] == 0)
			continue;
		j = 1;
		for (kk = travel[dloc[i]]; kk != 0; kk = kk->next) {
			newloc = kk->tloc;
			if (newloc > 300 || newloc < 15 || newloc == odloc[i]
			    || (j > 1 && newloc == tk[j - 1]) || j >= 20
			    || newloc == dloc[i] || forced(newloc)
			    || (i == 6 && bitset(newloc, 3))
			    || kk->conditions == 100)
				continue;
			tk[j++] = newloc;
		}
		tk[j] = odloc[i];	/* 6016 */
		if (j >= 2)
			j--;
		j = 1 + ran(j);
		odloc[i] = dloc[i];
		dloc[i] = tk[j];
		dseen[i] = (dseen[i] && loc >= 15) ||
		    (dloc[i] == loc || odloc[i] == loc);
		if (!dseen[i])
			continue;	/* i.e. goto 6030 */
		dloc[i] = loc;
		if (i == 6) {	/* pirate's spotted him */
			if (loc == chloc || prop[chest] >= 0)
				continue;
			k = 0;
			for (j = 50; j <= maxtrs; j++) { /* loop to 6020 */
				if (j == pyramid && (loc == plac[pyramid]
					|| loc == plac[emerald]))
					goto l6020;
				if (toting(j))
					goto l6022;
		l6020:		if (here(j))
					k = 1;
			}	/* 6020 */
			if (tally == tally2 + 1 && k == 0 && place[chest] == 0
			    && here(lamp) && prop[lamp] == 1)
				goto l6025;
			if (odloc[6] != dloc[6] && pct(20))
				rspeak(127);
			continue;	/* to 6030 */
	l6022:		rspeak(128);
			if (place[message] == 0)
				move(chest, chloc);
			move(message, chloc2);
			for (j = 50; j <= maxtrs; j++) { /* loop to 6023 */
				if (j == pyramid && (loc == plac[pyramid]
					|| loc == plac[emerald]))
					continue;
				if (at(j) && fixed[j] == 0)
					carry(j, loc);
				if (toting(j))
					drop(j, chloc);
			}
	l6024:		dloc[6] = odloc[6] = chloc;
			dseen[6] = FALSE;
			continue;
	l6025:		rspeak(186);
			move(chest, chloc);
			move(message, chloc2);
			goto l6024;
		}
		dtotal++;	/* 6027 */
		if (odloc[i] != dloc[i])
			continue;
		attack++;
		if (knfloc >= 0)
			knfloc = loc;
		if (ran(1000) < 95 * (dflag - 2))
			stick++;
	}			/* 6030 */
	if (dtotal == 0)
		return (2000);
	if (dtotal != 1) {
		printf("There are %d threatening little dwarves ", dtotal);
		printf("in the room with you.\n");
	} else
		rspeak(4);
	if (attack == 0)
		return (2000);
	if (dflag == 2)
		dflag = 3;
	if (saved != -1)
		dflag = 20;
	if (attack != 1) {
		printf("%d of them throw knives at you!\n", attack);
		k = 6;
l82:		if (stick <= 1) {	/* 82 */
			rspeak(k + stick);
			if (stick == 0)
				return (2000);
		} else
			printf("%d of them get you!\n", stick);	/* 83 */
		oldloc2 = loc;
		return (99);
	}
	rspeak(5);
	k = 52;
	goto l82;
}


/* label 8              */
int
march(void)
{
	int     ll1, ll2;

	if ((tkk = travel[newloc = loc]) == 0)
		bug(26);
	if (k == null)
		return (2);
	if (k == cave) {	/* 40                   */
		if (loc < 8)
			rspeak(57);
		if (loc >= 8)
			rspeak(58);
		return (2);
	}
	if (k == look) {	/* 30                   */
		if (detail++ < 3)
			rspeak(15);
		wasdark = FALSE;
		abb[loc] = 0;
		return (2);
	}
	if (k == back) {	/* 20                   */
		switch (mback()) {
		case 2:
			return (2);
		case 9:
			goto l9;
		default:
			bug(100);
		}
	}
	oldloc2 = oldloc;
	oldloc = loc;
l9:
	for (; tkk != 0; tkk = tkk->next)
		if (tkk->tverb == 1 || tkk->tverb == k)
			break;
	if (tkk == 0) {
		badmove();
		return (2);
	}
l11:	ll1 = tkk->conditions;	/* 11                   */
	ll2 = tkk->tloc;
	newloc = ll1;		/* newloc=conditions    */
	k = newloc % 100;	/* k used for prob      */
	if (newloc <= 300) {
		if (newloc <= 100) {	/* 13                   */
			if (newloc != 0 && !pct(newloc))
				goto l12;	/* 14   */
	l16:		newloc = ll2;	/* newloc=location      */
			if (newloc <= 300)
				return (2);
			if (newloc <= 500)
				switch (specials()) {	/* to 30000           */
				case 2:
					return (2);
				case 12:
					goto l12;
				case 99:
					return (99);
				default:
					bug(101);
				}
			rspeak(newloc - 500);
			newloc = loc;
			return (2);
		}
		if (toting(k) || (newloc > 200 && at(k)))
			goto l16;
		goto l12;
	}
	if (prop[k] != (newloc / 100) - 3)
		goto l16;	/* newloc still conditions */
l12:				/* alternative to probability move      */
	for (; tkk != 0; tkk = tkk->next)
		if (tkk->tloc != ll2 || tkk->conditions != ll1)
			break;
	if (tkk == 0)
		bug(25);
	goto l11;
}

/* 20                   */
static int
mback(void)
{
	struct travlist *tk2, *j;
	int     ll;
	if (forced(k = oldloc))
		k = oldloc2;	/* k=location           */
	oldloc2 = oldloc;
	oldloc = loc;
	tk2 = 0;
	if (k == loc) {
		rspeak(91);
		return (2);
	}
	for (; tkk != 0; tkk = tkk->next) {	/* 21                   */
		ll = tkk->tloc;
		if (ll == k) {
			k = tkk->tverb;	/* k back to verb       */
			tkk = travel[loc];
			return (9);
		}
		if (ll <= 300) {
			j = travel[loc];
			if (forced(ll) && k == j->tloc)
				tk2 = tkk;
		}
	}
	tkk = tk2;		/* 23                   */
	if (tkk != 0) {
		k = tkk->tverb;
		tkk = travel[loc];
		return (9);
	}
	rspeak(140);
	return (2);
}

/* 30000                */
static int
specials(void)
{
	switch (newloc -= 300) {
		case 1:		/* 30100                */
		newloc = 99 + 100 - loc;
		if (holding == 0 || (holding == 1 && toting(emerald)))
			return (2);
		newloc = loc;
		rspeak(117);
		return (2);
	case 2:		/* 30200                */
		drop(emerald, loc);
		return (12);
	case 3:		/* to 30300             */
		return (trbridge());
	default:
		bug(29);
	}
}

/* 30300                */
static int
trbridge(void)
{
	if (prop[troll] == 1) {
		pspeak(troll, 1);
		prop[troll] = 0;
		move(troll2, 0);
		move(troll2 + 100, 0);
		move(troll, plac[troll]);
		move(troll + 100, fixd[troll]);
		juggle(chasm);
		newloc = loc;
		return (2);
	}
	newloc = plac[troll] + fixd[troll] - loc;	/* 30310    */
	if (prop[troll] == 0)
		prop[troll] = 1;
	if (!toting(bear))
		return (2);
	rspeak(162);
	prop[chasm] = 1;
	prop[troll] = 2;
	drop(bear, newloc);
	fixed[bear] = -1;
	prop[bear] = 3;
	if (prop[spices] < 0)
		tally2++;
	oldloc2 = newloc;
	return (99);
}

/* 20                   */
static void
badmove(void)
{
	spk = 12;
	if (k >= 43 && k <= 50)
		spk = 9;
	if (k == 29 || k == 30)
		spk = 9;
	if (k == 7 || k == 36 || k == 37)
		spk = 10;
	if (k == 11 || k == 19)
		spk = 11;
	if (verb == find || verb == invent)
		spk = 59;
	if (k == 62 || k == 65)
		spk = 42;
	if (k == 17)
		spk = 80;
	rspeak(spk);
}

void
bug(int n)
{
	printf("Please tell jim@rand.org that fatal bug %d happened.\n", n);
	exit(1);
}

/* 2600 &c              */
void
checkhints(void)
{
	int     hint;
	for (hint = 4; hint <= hintmax; hint++) {
		if (hinted[hint])
			continue;
		if (!bitset(loc, hint))
			hintlc[hint] = -1;
		hintlc[hint]++;
		if (hintlc[hint] < hints[hint][1])
			continue;
		switch (hint) {
		case 4:	/* 40400 */
			if (prop[grate] == 0 && !here(keys))
				goto l40010;
			goto l40020;
		case 5:	/* 40500 */
			if (here(bird) && toting(rod) && obj == bird)
				goto l40010;
			continue;	/* i.e. goto l40030 */
		case 6:	/* 40600 */
			if (here(snake) && !here(bird))
				goto l40010;
			goto l40020;
		case 7:	/* 40700 */
			if (atloc[loc] == 0 && atloc[oldloc] == 0
			    && atloc[oldloc2] == 0 && holding > 1)
				goto l40010;
			goto l40020;
		case 8:	/* 40800 */
			if (prop[emerald] != -1 && prop[pyramid] == -1)
				goto l40010;
			goto l40020;
		case 9:
			goto l40010;	/* 40900 */
		default:
			bug(27);
		}
l40010:	hintlc[hint] = 0;
		if (!yes(hints[hint][3], 0, 54))
			continue;
		printf("I am prepared to give you a hint, but it will ");
		printf("cost you %d points.\n", hints[hint][2]);
		hinted[hint] = yes(175, hints[hint][4], 54);
l40020:	hintlc[hint] = 0;
	}
}

/* 9030                 */
int
trsay(void)
{
	int     i;
	if (*wd2 != 0)
		copystr(wd2, wd1);
	i = vocab(wd1, -1, 0);
	if (i == 62 || i == 65 || i == 71 || i == 2025) {
		*wd2 = 0;
		obj = 0;
		return (2630);
	}
	printf("\nOkay, \"%s\".\n", wd2);
	return (2012);
}

/* 9010                 */
int
trtake(void)
{
	if (toting(obj))
		return (2011);	/* 9010 */
	spk = 25;
	if (obj == plant && prop[plant] <= 0)
		spk = 115;
	if (obj == bear && prop[bear] == 1)
		spk = 169;
	if (obj == chain && prop[bear] != 0)
		spk = 170;
	if (fixed[obj] != 0)
		return (2011);
	if (obj == water || obj == oil) {
		if (here(bottle) && liq() == obj) {
			obj = bottle;
			goto l9017;
		}
		obj = bottle;
		if (toting(bottle) && prop[bottle] == 1)
			return (9220);
		if (prop[bottle] != 1)
			spk = 105;
		if (!toting(bottle))
			spk = 104;
		return (2011);
	}
l9017:	if (holding >= 7) {
		rspeak(92);
		return (2012);
	}
	if (obj == bird) {
		if (prop[bird] != 0)
			goto l9014;
		if (toting(rod)) {
			rspeak(26);
			return (2012);
		}
		if (!toting(cage)) {	/* 9013 */
			rspeak(27);
			return (2012);
		}
		prop[bird] = 1;	/* 9015 */
	}
l9014:	if ((obj == bird || obj == cage) && prop[bird] != 0)
		carry(bird + cage - obj, loc);
	carry(obj, loc);
	k = liq();
	if (obj == bottle && k != 0)
		place[k] = -1;
	return (2009);
}

/* 9021                 */
static int
dropper(void)
{
	k = liq();
	if (k == obj)
		obj = bottle;
	if (obj == bottle && k != 0)
		place[k] = 0;
	if (obj == cage && prop[bird] != 0)
		drop(bird, loc);
	if (obj == bird)
		prop[bird] = 0;
	drop(obj, loc);
	return (2012);
}

/* 9020                 */
int
trdrop(void)
{
	if (toting(rod2) && obj == rod && !toting(rod))
		obj = rod2;
	if (!toting(obj))
		return (2011);
	if (obj == bird && here(snake)) {
		rspeak(30);
		if (closed)
			return (19000);
		destroy(snake);
		prop[snake] = 1;
		return (dropper());
	}
	if (obj == coins && here(vend)) {	/* 9024                 */
		destroy(coins);
		drop(batter, loc);
		pspeak(batter, 0);
		return (2012);
	}
	if (obj == bird && at(dragon) && prop[dragon] == 0) {	/* 9025 */
		rspeak(154);
		destroy(bird);
		prop[bird] = 0;
		if (place[snake] == plac[snake])
			tally2--;
		return (2012);
	}
	if (obj == bear && at(troll)) {	/* 9026                 */
		rspeak(163);
		move(troll, 0);
		move(troll + 100, 0);
		move(troll2, plac[troll]);
		move(troll2 + 100, fixd[troll]);
		juggle(chasm);
		prop[troll] = 2;
		return (dropper());
	}
	if (obj != vase || loc == plac[pillow]) { /* 9027       */
		rspeak(54);
		return (dropper());
	}
	prop[vase] = 2;		/* 9028                 */
	if (at(pillow))
		prop[vase] = 0;
	pspeak(vase, prop[vase] + 1);
	if (prop[vase] != 0)
		fixed[vase] = -1;
	return (dropper());
}

/* 9040                 */
int
tropen(void)
{
	if (obj == clam || obj == oyster) {
		k = 0;		/* 9046                 */
		if (obj == oyster)
			k = 1;
		spk = 124 + k;
		if (toting(obj))
			spk = 120 + k;
		if (!toting(trident))
			spk = 122 + k;
		if (verb == lock)
			spk = 61;
		if (spk != 124)
			return (2011);
		destroy(clam);
		drop(oyster, loc);
		drop(pearl, 105);
		return (2011);
	}
	if (obj == door)
		spk = 111;
	if (obj == door && prop[door] == 1)
		spk = 54;
	if (obj == cage)
		spk = 32;
	if (obj == keys)
		spk = 55;
	if (obj == grate || obj == chain)
		spk = 31;
	if (spk != 31 || !here(keys))
		return (2011);
	if (obj == chain) {
		if (verb == lock) {
			spk = 172;	/* 9049: lock           */
			if (prop[chain] != 0)
				spk = 34;
			if (loc != plac[chain])
				spk = 173;
			if (spk != 172)
				return (2011);
			prop[chain] = 2;
			if (toting(chain))
				drop(chain, loc);
			fixed[chain] = -1;
			return (2011);
		}
		spk = 171;
		if (prop[bear] == 0)
			spk = 41;
		if (prop[chain] == 0)
			spk = 37;
		if (spk != 171)
			return (2011);
		prop[chain] = 0;
		fixed[chain] = 0;
		if (prop[bear] != 3)
			prop[bear] = 2;
		fixed[bear] = 2 - prop[bear];
		return (2011);
	}
	if (isclosing) {
		k = 130;
		if (!panic)
			clock2 = 15;
		panic = TRUE;
		return (2010);
	}
	k = 34 + prop[grate];	/* 9043                 */
	prop[grate] = 1;
	if (verb == lock)
		prop[grate] = 0;
	k = k + 2 * prop[grate];
	return (2010);
}

/* 9120                         */
int
trkill(void)
{
	int     i;
	for (i = 1; i <= 5; i++)
		if (dloc[i] == loc && dflag >= 2)
			break;
	if (i == 6)
		i = 0;
	if (obj == 0) {		/* 9122                         */
		if (i != 0)
			obj = dwarf;
		if (here(snake))
			obj = obj * 100 + snake;
		if (at(dragon) && prop[dragon] == 0)
			obj = obj * 100 + dragon;
		if (at(troll))
			obj = obj * 100 + troll;
		if (here(bear) && prop[bear] == 0)
			obj = obj * 100 + bear;
		if (obj > 100)
			return (8000);
		if (obj == 0) {
			if (here(bird) && verb != throw)
				obj = bird;
			if (here(clam) || here(oyster))
				obj = 100 * obj + clam;
			if (obj > 100)
				return (8000);
		}
	}
	if (obj == bird) {	/* 9124                         */
		spk = 137;
		if (closed)
			return (2011);
		destroy(bird);
		prop[bird] = 0;
		if (place[snake] == plac[snake])
			tally2++;
		spk = 45;
	}
	if (obj == 0)
		spk = 44;	/* 9125                         */
	if (obj == clam || obj == oyster)
		spk = 150;
	if (obj == snake)
		spk = 46;
	if (obj == dwarf)
		spk = 49;
	if (obj == dwarf && closed)
		return (19000);
	if (obj == dragon)
		spk = 147;
	if (obj == troll)
		spk = 157;
	if (obj == bear)
		spk = 165 + (prop[bear] + 1) / 2;
	if (obj != dragon || prop[dragon] != 0)
		return (2011);
	rspeak(49);
	verb = 0;
	obj = 0;
	getin(&wd1, &wd2);
	if (!weq(wd1, "y") && !weq(wd1, "yes"))
		return (2608);
	pspeak(dragon, 1);
	prop[dragon] = 2;
	prop[rug] = 0;
	k = (plac[dragon] + fixd[dragon]) / 2;
	move(dragon + 100, -1);
	move(rug + 100, 0);
	move(dragon, k);
	move(rug, k);
	for (obj = 1; obj <= 100; obj++)
		if (place[obj] == plac[dragon] || place[obj] == fixd[dragon])
			move(obj, k);
	loc = k;
	k = null;
	return (8);
}

/* 9170: throw                  */
int
trtoss(void)
{
	int     i;
	if (toting(rod2) && obj == rod && !toting(rod))
		obj = rod2;
	if (!toting(obj))
		return (2011);
	if (obj >= 50 && obj <= maxtrs && at(troll)) {
		spk = 159;	/* 9178                 */
		drop(obj, 0);
		move(troll, 0);
		move(troll + 100, 0);
		drop(troll2, plac[troll]);
		drop(troll2 + 100, fixd[troll]);
		juggle(chasm);
		return (2011);
	}
	if (obj == food && here(bear)) {
		obj = bear;	/* 9177                 */
		return (9210);
	}
	if (obj != axe)
		return (9020);
	for (i = 1; i <= 5; i++) {
		if (dloc[i] == loc) {
			spk = 48;	/* 9172                 */
			if (ran(3) == 0 || saved != -1)
	l9175:		{
				rspeak(spk);
				drop(axe, loc);
				k = null;
				return (8);
			}
			dseen[i] = FALSE;
			dloc[i] = 0;
			spk = 47;
			dkill++;
			if (dkill == 1)
				spk = 149;
			goto l9175;
		}
	}
	spk = 152;
	if (at(dragon) && prop[dragon] == 0)
		goto l9175;
	spk = 158;
	if (at(troll))
		goto l9175;
	if (here(bear) && prop[bear] == 0) {
		spk = 164;
		drop(axe, loc);
		fixed[axe] = -1;
		prop[axe] = 1;
		juggle(bear);
		return (2011);
	}
	obj = 0;
	return (9120);
}

/* 9210                 */
int
trfeed(void)
{
	if (obj == bird) {
		spk = 100;
		return (2011);
	}
	if (obj == snake || obj == dragon || obj == troll) {
		spk = 102;
		if (obj == dragon && prop[dragon] != 0)
			spk = 110;
		if (obj == troll)
			spk = 182;
		if (obj != snake || closed || !here(bird))
			return (2011);
		spk = 101;
		destroy(bird);
		prop[bird] = 0;
		tally2++;
		return (2011);
	}
	if (obj == dwarf) {
		if (!here(food))
			return (2011);
		spk = 103;
		dflag++;
		return (2011);
	}
	if (obj == bear) {
		if (prop[bear] == 0)
			spk = 102;
		if (prop[bear] == 3)
			spk = 110;
		if (!here(food))
			return (2011);
		destroy(food);
		prop[bear] = 1;
		fixed[axe] = 0;
		prop[axe] = 0;
		spk = 168;
		return (2011);
	}
	spk = 14;
	return (2011);
}

/* 9220 */
int
trfill(void)
{
	if (obj == vase) {
		spk = 29;
		if (liqloc(loc) == 0)
			spk = 144;
		if (liqloc(loc) == 0 || !toting(vase))
			return (2011);
		rspeak(145);
		prop[vase] = 2;
		fixed[vase] = -1;
		return (9020);	/* advent/10 goes to 9024 */
	}
	if (obj != 0 && obj != bottle)
		return (2011);
	if (obj == 0 && !here(bottle))
		return (8000);
	spk = 107;
	if (liqloc(loc) == 0)
		spk = 106;
	if (liq() != 0)
		spk = 105;
	if (spk != 107)
		return (2011);
	prop[bottle] = ((cond[loc] % 4) / 2) * 2;
	k = liq();
	if (toting(bottle))
		place[k] = -1;
	if (k == oil)
		spk = 108;
	return (2011);
}

/* 10000 */
void
closing(void)
{
	int     i;

	prop[grate] = prop[fissure] = 0;
	for (i = 1; i <= 6; i++) {
		dseen[i] = FALSE;
		dloc[i] = 0;
	}
	move(troll, 0);
	move(troll + 100, 0);
	move(troll2, plac[troll]);
	move(troll2 + 100, fixd[troll]);
	juggle(chasm);
	if (prop[bear] != 3)
		destroy(bear);
	prop[chain] = 0;
	fixed[chain] = 0;
	prop[axe] = 0;
	fixed[axe] = 0;
	rspeak(129);
	clock1 = -1;
	isclosing = TRUE;
}

/* 11000 */
void
caveclose(void)
{
	int     i;
	prop[bottle] = put(bottle, 115, 1);
	prop[plant] = put(plant, 115, 0);
	prop[oyster] = put(oyster, 115, 0);
	prop[lamp] = put(lamp, 115, 0);
	prop[rod] = put(rod, 115, 0);
	prop[dwarf] = put(dwarf, 115, 0);
	loc = 115;
	oldloc = 115;
	newloc = 115;

	put(grate, 116, 0);
	prop[snake] = put(snake, 116, 1);
	prop[bird] = put(bird, 116, 1);
	prop[cage] = put(cage, 116, 0);
	prop[rod2] = put(rod2, 116, 0);
	prop[pillow] = put(pillow, 116, 0);

	prop[mirror] = put(mirror, 115, 0);
	fixed[mirror] = 116;

	for (i = 1; i <= 100; i++)
		if (toting(i))
			destroy(i);
	rspeak(132);
	closed = TRUE;
}