verb.c

minix软件源代码

/*	program VERB.C						*/

#include	"stdio.h"
#include	"advent.h"
#include	"advdec.h"

 /* Initialize default verb messages */
static _CONST int actmsg[56] = {
     0,  24,  29,  0,  33,   0,  33,  38,  38,  42,
    14,  43, 110, 29, 110,  73,  75,  29,  13,  59,
    59, 174, 313, 67,  13, 147, 155, 369, 146, 110,
    13,  13,  24, 25, 110, 262,  14,  29, 271,  14,
    14,  24,  29, 38,  24, 331,  24, 109, 332,   0,
     0, 348, 358,  0, 364,   0};

_PROTOTYPE(static int ck_obj, (void));
_PROTOTYPE(void von, (void));
_PROTOTYPE(void voff, (void));
_PROTOTYPE(void vwave, (void));
_PROTOTYPE(void veat, (void));
_PROTOTYPE(void vthrow, (void));
_PROTOTYPE(void vfind, (void));
_PROTOTYPE(void vfill, (void));
_PROTOTYPE(void vfeed, (void));
_PROTOTYPE(void vbreak, (void));
_PROTOTYPE(void vwake, (void));
_PROTOTYPE(void vdrop, (void));
_PROTOTYPE(void vpour, (void));
_PROTOTYPE(void vput, (void));
_PROTOTYPE(void vread, (void));
_PROTOTYPE(void vinsert, (void));
_PROTOTYPE(void vextract, (void));
_PROTOTYPE(static boolean do_battle, (int *));
_PROTOTYPE(void vhit, (void));
_PROTOTYPE(void vanswer, (void));
_PROTOTYPE(void vblow, (void));
_PROTOTYPE(void vdial, (void));
_PROTOTYPE(void vplay, (void));
_PROTOTYPE(void vpick, (void));
_PROTOTYPE(void vput, (void));
_PROTOTYPE(void vturn, (void));
_PROTOTYPE(void vget, (void));
_PROTOTYPE(void vlook, (void));


/*
  Routine to process a transitive verb
*/
void trverb()
{
    newtravel = FALSE;
    switch (verb) {
    case NOTHING:
    case CALM:
    case WALK:
    case QUIT:
    case SCORE:
    case FOO:
    case SUSPEND:			break;
    case TAKE:		vtake();	break;
    case DROP:		vdrop();	break;
    case SAY:		bug(34);	break;
    case OPEN:		vopen();	break;
    case CLOSE:		vclose();	break;
    case LOCK:		vlock();	break;
    case UNLOCK:	vunlock();	break;
    case ON:		von();		break;
    case OFF:		voff();		break;
    case WAVE:		vwave();	break;
    case KILL:		vkill();	break;
    case POUR:		vpour();	break;
    case EAT:		veat();		break;
    case DRINK:		vdrink();	break;
    case RUB:
	if (object != LAMP)
	    rspeak(76);
	else
	    actspk(RUB);
	break;
    case THROW:
	if (prep == PREPDN)
	    vput();
	else
	    vthrow();
	break;
    case FEED:		vfeed();	break;
    case FIND:
    case INVENTORY:	vfind();	break;
    case FILL:		vfill();	break;
    case BLAST:		ivblast();	break;
    case READ:		vread();	break;
    case BREAK:		vbreak();	break;
    case WAKE:		vwake();	break;
    case REMOVE:	vextract();	break;
    case YANK:		vyank();	break;
    case WEAR:		vwear();	break;
    case HIT:		vhit();		break;
    case ANSWER:	vanswer();	break;
    case BLOW:		vblow();	break;
    case DIAL:		vdial();	break;
    case PLAY:		vplay();	break;
    case PICK:		vpick();	break;
    case PUT:		vput();		break;
    case TURN:		vturn();	break;
    case GET:		vget();		break;
    case INSRT:		vinsert();	break;
    case LOOK:		vlook();	break;
    default:
	printf("This verb is not implemented yet.\n");
    }
    return;
}

/*
  Routine to speak default verb message
*/
void actspk(verb)
int verb;
{
    int i;

    if (verb < 1 || verb > 55)
	bug(39);
    i = actmsg[verb];
    if (i)
	rspeak(i);
    return;
}

/*
  CARRY TAKE etc.
*/
void vtake()
{
    int msg;

    msg = 0;
    if (object == BIRD && !g.closed && athand(BIRD)
	&& g.place[BIRD] != g.loc) {
	rspeak(407);
	return;
    }
    if (prep == PREPOF) {
	if (object && iobj) {
	    rspeak(confuz());
	    return;
	} else if (!object) {
	    object = iobj;
	    iobj = 0;
	    vdrop();
	    return;
	}
    }
    msg = 24;
    if (object == BOAT)
	msg = 281;
    if (plural(object))
	msg = 297;
    if (holding(object)) {
	rspeak(msg);
	return;
    }
    /* Special case objects and fixed objects */
    msg = ck_obj();
    if (g.fixed[object]) {
	rspeak(msg);
	return;
    }
    if (prep == PREPIN) {
	vinsert();
	return;
    }
    /* Special case for liquids */
    if (object == WATER || object == OIL || object == WINE) {
	if (here(BOTTLE) && here(CASK)) {
	    rspeak(315);
	    return;
	}
	iobj = object;
	if (here(BOTTLE)) {
	    object = BOTTLE;
	    if (holding(BOTTLE))
		vfill();
	    else
		rspeak(312);
	    return;
	} else if (here(CASK)) {
	    object = CASK;
	    if (holding(CASK))
		vfill();
	    else
		rspeak(312);
	    return;
	} else {
	    rspeak(312);
	    return;
	}
    }
    if (object != BEAR && ((burden(0) + burden(object)) > 15)) {
	if (wearng(object)) {
	    g.prop[object] = 0;
	    bitoff(object, WEARBT);
	}
	rspeak(92);
	return;
    }
    if (prep == PREPFR || enclosed(object)) {
	vextract();
	return;
    }
    msg = 343;
    /* Poster: hides wall safe */
    if (object == POSTER && g.place[SAFE] == 0) {
	g.prop[POSTER] = 1;
	msg = 362;
	/* Move safe and wall containing safe into view */
	drop(SAFE, g.loc);
	drop(WALL2, g.loc);
    }
    /* Boat: need the pole to push it */
    if (object == BOAT) {
	if (!toting(POLE) && g.place[POLE] != -BOAT) {
	    rspeak(218);
	    return;
	} else {
	    g.prop[BOAT] = 1;
	    msg = 221;
	}
    }
    /* Special case for bird. */
    if (object == BIRD && g.prop[BIRD] <= 0) {
	if (athand(ROD)) {
	    rspeak(26);
	    return;
	}
	if (!holding(CAGE)) {
	    rspeak(27);
	    return;
	}
	if (!ajar(CAGE)) {
	    rspeak(358);
	    return;
	}
	insert(BIRD, CAGE);
	bitoff(CAGE, OPENBT);
	pspeak(object, -1);
	rspeak(54);
	return;
    }
    /* SWORD If in anvil, need crown & must yank */
    if (object == SWORD && g.prop[SWORD] != 0) {
	if (iobj && iobj != ANVIL) {
	    rspeak(noway());
	    return;
	}
	if (verb != YANK)
	    if (!yes(215, 0, 54))
		return;

	if (!wearng(CROWN)) {
	    g.fixed[SWORD] = -1;
	    g.prop[SWORD] = 3;
	    pspeak(SWORD, 2);
	    return;
	}
    }
    carry(object, g.loc);
    if (object == POLE || object == SKEY || object == SWORD
	 || ((object == CLOAK || object == RING) && !wearng(object)) )
	g.prop[object] = 0;

    if (verb == YANK || object == SWORD)
	msg = 204;
    rspeak(msg);
    return;
}

static int ck_obj()
{
    int msg;

    msg = noway();
    if (object == PLANT && g.prop[PLANT] <= 0)
	msg = 115;
    if (object == BEAR && g.prop[BEAR] == 1)
	msg = 169;
    if (object == CHAIN && g.prop[BEAR] != 0)
	msg = 170;
    if (object == SWORD && g.prop[SWORD] == 5)
	msg = 208;
    if (object == CLOAK && g.prop[CLOAK] == 2)
	msg = 242;
    if (object == AXE && g.prop[AXE] == 2)
	msg = 246;
    if (object == PHONE)
	msg = 251;
    if (object == BEES || object == HIVE)
	msg = 295;
    if (object == STICKS)
	msg = 296;
    return (msg);
}

/*
  DROP etc.
*/
void vdrop()
{
    int msg;

    /* Check for dynamite */
    if (holding(ROD2) && object == ROD && !holding(ROD))
	object = ROD2;
    if (plural(object))
	msg = 105;
    else
	msg = 29;

    if (object == liq(BOTTLE))
	object = BOTTLE;
    else if (object == liq(CASK))
	object = CASK;

    if (!toting(object)) {
	rspeak(msg);
	return;
    }
    if (prep == PREPIN) {
	vinsert();
	return;
    }
    /* Snake and bird */
    if (object == BIRD && here(SNAKE)) {
	rspeak(30);
	if (g.closed) {
	    dwarfend();
	    return;
	}
	extract(BIRD);
	destroy(SNAKE);
	/* Set snake prop for use by travel options */
	g.prop[SNAKE] = 1;
	drop(BIRD, g.loc);
	return;
    }
    msg = 344;
    if (verb == LEAVE)
	msg = 353;
    if (verb == THROW)
	msg = 352;
    if (verb == TAKE)
	msg = 54;
    if (object == POLE && holding(BOAT)) {
	rspeak(280);
	return;
    }
    /* Coins and vending machine */
    if (object == COINS && here(VEND)) {
	destroy(COINS);
	drop(BATTERIES, g.loc);
	pspeak(BATTERIES, 0);
	return;
    }
    /* Bird and dragon (ouch!!) */
    if (object == BIRD && at(DRAGON) && g.prop[DRAGON] == 0) {
	rspeak(154);
	extract(BIRD);
	destroy(BIRD);
	if (g.place[SNAKE] == plac[SNAKE])
	    g.tally2++;
	return;
    }
    /* Bear and troll */
    if (object == BEAR && at(TROLL)) {
	msg = 163;
	destroy(TROLL);
	destroy(TROLL + MAXOBJ);
	move(TROLL2, plac[TROLL]);
	move((TROLL2 + MAXOBJ), fixd[TROLL]);
	juggle(CHASM);
	g.prop[TROLL] = 2;
    }
    /* Vase */
    else if (object == VASE) {
	if (g.loc == plac[PILLOW])
	    msg = 54;
	else {
	    g.prop[VASE] = at(PILLOW) ? 0 : 2;
	    pspeak(VASE, g.prop[VASE] + 1);
	    if (g.prop[VASE] != 0)
		g.fixed[VASE] = -1;
	}
    } else {
	if (worn(object) || object == POLE || object == BOAT)
	    g.prop[object] = 0;
	if (worn(object))
	    bitoff(object, WEARBT);
	if (object == POLE)
	    g.prop[BOAT] = 0;
    }

    if (enclosed(object))
	extract(object);
    drop(object, g.loc);
    rspeak(msg);
    return;
}

/*
  OPEN. special stuff for opening clam/oyster.
  The following can be opened without a key:
  clam/oyster, door, pdoor, bottle, cask, cage
*/
void vopen()
{
    int msg, oyclam;

    if (!hinged(object))
	msg = noway();
    else if (object == PDOOR && g.prop[PDOOR] == 1)
	msg = 253;
    else if (ajar(object))
	msg = 336;
    else if (locks(object) || iobj == KEYS || iobj == SKEY) {
	vunlock();
	return;
    } else if (locked(object))
	if (object == DOOR)
	    msg = 111;
	else
	    msg = 337;
    else if (object == CLAM || object == OYSTER) {
	oyclam = (object == OYSTER ? 1 : 0);
	msg = oyclam + holding(object) ? 120 : 124;
	if (!athand(TRIDENT))
	    msg = 122 + oyclam;
	if (iobj != 0 && iobj != TRIDENT)
	    msg = 376 + oyclam;

	if (msg == 124) {
	    destroy(CLAM);
	    drop(OYSTER, g.loc);
	    drop(PEARL, 105);
	}
    } else {
	msg = 54;
	biton(object, OPENBT);
    }
    rspeak(msg);
    return;
}

/*
   close, shut
   the following can be closed without keys:
   door, pdoor, bottle, cask, cage
*/
void vclose()
{
    if (!hinged(object))
	rspeak(noway());
    else if (!ajar(object))
	rspeak(338);
    else if (locks(object))
	vlock();
    else {
	rspeak(54);
	bitoff(object, OPENBT);
    }
}

/*
  Lamp ON.
*/
void von()
{
    if (!athand(LAMP))
	actspk(verb);
    else if (g.limit < 0)
	rspeak(184);
    else if (g.prop[LAMP] == 1)
	rspeak(321);
    else {
	g.prop[LAMP] = 1;
	if (g.loc == 200)
	    rspeak(108);
	else
	    rspeak(39);
	if (g.wzdark) {
	    g.wzdark = 0;
	    describe();
	    descitem();
	}
    }
    return;
}

/*
  Lamp OFF.
*/
void voff()
{
    if (!athand(LAMP))
	actspk(verb);
    else if (g.prop[LAMP] == 0)
	rspeak(322);
    else {
	g.prop[LAMP] = 0;
	rspeak(40);
	if (dark())
	    rspeak(16);
    }
    return;
}

/*
  WAVE. no effect unless waving rod at fissure.
*/
void vwave()
{
    if (!holding(object) &&
	(object != ROD || !holding(ROD2)))
	rspeak(29);
    else if (object != ROD || !at(FISSURE) ||
	     !holding(object) || g.closing)
	actspk(verb);
    else if (iobj != 0 && iobj != FISSURE)
	actspk(verb);
    else {
	g.prop[FISSURE] = 1 - g.prop[FISSURE];
	pspeak(FISSURE, 2 - g.prop[FISSURE]);
	if (g.chase == 0 || g.prop[FISSURE] != 0)
	    return;
	if ((g.loc == 17 && g.oldloc != 27)
	    || (g.loc == 27 && g.oldloc != 17))
	    return;
	/* Demise of the Wumpus.  Champ must have just crossed bridge */
	rspeak(244);
	g.chase = 0;
	drop(RING, 209);
	g.prop[WUMPUS] = 6;
	move(WUMPUS, 209);
	biton(WUMPUS, DEADBT);
	if (g.place[AXE] != plac[WUMPUS])
	    return;
	g.fixed[AXE] = 0;
	g.prop[AXE] = 0;

    }
    return;
}

/*
  ATTACK, KILL etc.
*/
void vkill()
{
    int msg, i, k;
    boolean survival;

    survival = TRUE;
    switch (object) {
    case BIRD:
	if (g.closed)
	    msg = 137;
	else {
	    destroy(BIRD);
	    g.prop[BIRD] = 0;
	    if (g.place[SNAKE] == plac[SNAKE])
		g.tally2++;
	    msg = 45;
	}
	break;
    case DWARF:
	if (g.closed) {
	    dwarfend();
	    return;
	}
	survival = do_battle(&msg);
	break;
    case 0:
	msg = 44;
	break;
    case CLAM:
    case OYSTER:
	msg = 150;
	break;
    case DOG:
	if (g.prop[DOG] == 1)
	    msg = 291;
	else if (iobj == AXE) {
	    object = AXE;
	    iobj = DOG;
	    vthrow();
	    return;
	} else
	    msg = 110;
	break;
    case SNAKE:
	msg = 46;
	break;
    case TROLL:
	if (iobj == AXE)
	    msg = 158;
	else
	    msg = 110;
	break;
    case BEAR:
	msg = 165 + (g.prop[BEAR] + 1) / 2;
	break;
    case WUMPUS:
	if (g.prop[WUMPUS] == 6)
	    msg = 167;
	else if (iobj == AXE) {
	    object = AXE;
	    iobj = WUMPUS;
	    vthrow();
	    return;
	} else
	    msg = 110;
	break;
    case GNOME:
	msg = 320;
	break;
    case DRAGON:
	if (g.prop[DRAGON] != 0) {
	    msg = 167;
	    break;
	}
	if (!yes(49, 0, 0))
	    break;
	pspeak(DRAGON, 1);
	biton(DRAGON, DEADBT);
	g.prop[DRAGON] = 2;
	g.prop[RUG] = 0;
	k = (plac[DRAGON] + fixd[DRAGON]) / 2;
	move((DRAGON + MAXOBJ), -1);
	move((RUG + MAXOBJ), 0);
	move(DRAGON, k);
	move(RUG, k);
	for (i = 1; i < MAXOBJ; i++)
	    if (g.place[i] == plac[DRAGON]
		|| g.place[i] == fixd[DRAGON]
		|| holding(i))
		move(i, k);
	g.loc = k;
	g.newloc = k;
	return;
    default:
	actspk(verb);
	return;
    }
    rspeak(msg);
    if (!survival) {
	g.oldloc2 = g.loc;
	death();
    }
    return;
}

static boolean do_battle(msg_ptr)
int *msg_ptr;
{
    boolean survival;
    int temp;

    survival = TRUE;
    if (iobj == 0)
	*msg_ptr = 49;
    else if (iobj != AXE && iobj != SWORD) {
	*msg_ptr = 355;
	survival = FALSE;
    } else if (pct(25)) {
	temp = iobj;
	iobj = object;
	object = temp;
	vthrow();
	return (TRUE);
    } else if (pct(25)) {
	*msg_ptr = 355;
	survival = FALSE;
    } else if (pct(36))
	*msg_ptr = 354;
    else {
	rspeak(356);
	if (pct(61))
	    *msg_ptr = 52;
	else {
	    *msg_ptr = 53;
	    survival = FALSE;
	}
    }
    return (survival);
}

/*
  POUR
*/
void vpour()
{
    int msg;

    if (object == BOTTLE || object == CASK) {
	iobj = object;
	object = liq(iobj);
	if (object == 0) {
	    rspeak(316);
	    return;
	}
    } else {
	if (object < WATER || object > (WINE + 1)) {
	    rspeak(78);
	    return;
	}
    }