986 lines
20 KiB
C
986 lines
20 KiB
C
/* $NetBSD: hack.invent.c,v 1.7 2001/03/25 20:44:00 jsm Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: hack.invent.c,v 1.7 2001/03/25 20:44:00 jsm Exp $");
|
|
#endif /* not lint */
|
|
|
|
#include <stdlib.h>
|
|
#include "hack.h"
|
|
#include "extern.h"
|
|
|
|
#ifndef NOWORM
|
|
#include "def.wseg.h"
|
|
#endif /* NOWORM */
|
|
|
|
#define NOINVSYM '#'
|
|
|
|
static int lastinvnr = 51; /* 0 ... 51 */
|
|
|
|
static void assigninvlet __P((struct obj *));
|
|
static char *xprname __P((struct obj *, char));
|
|
|
|
static void
|
|
assigninvlet(otmp)
|
|
struct obj *otmp;
|
|
{
|
|
boolean inuse[52];
|
|
int i;
|
|
struct obj *obj;
|
|
|
|
for (i = 0; i < 52; i++)
|
|
inuse[i] = FALSE;
|
|
for (obj = invent; obj; obj = obj->nobj)
|
|
if (obj != otmp) {
|
|
i = obj->invlet;
|
|
if ('a' <= i && i <= 'z')
|
|
inuse[i - 'a'] = TRUE;
|
|
else if ('A' <= i && i <= 'Z')
|
|
inuse[i - 'A' + 26] = TRUE;
|
|
if (i == otmp->invlet)
|
|
otmp->invlet = 0;
|
|
}
|
|
if ((i = otmp->invlet) &&
|
|
(('a' <= i && i <= 'z') || ('A' <= i && i <= 'Z')))
|
|
return;
|
|
for (i = lastinvnr + 1; i != lastinvnr; i++) {
|
|
if (i == 52) {
|
|
i = -1;
|
|
continue;
|
|
}
|
|
if (!inuse[i])
|
|
break;
|
|
}
|
|
otmp->invlet = (inuse[i] ? NOINVSYM :
|
|
(i < 26) ? ('a' + i) : ('A' + i - 26));
|
|
lastinvnr = i;
|
|
}
|
|
|
|
struct obj *
|
|
addinv(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct obj *otmp;
|
|
|
|
/* merge or attach to end of chain */
|
|
if (!invent) {
|
|
invent = obj;
|
|
otmp = 0;
|
|
} else
|
|
for (otmp = invent; /* otmp */ ; otmp = otmp->nobj) {
|
|
if (merged(otmp, obj, 0))
|
|
return (otmp);
|
|
if (!otmp->nobj) {
|
|
otmp->nobj = obj;
|
|
break;
|
|
}
|
|
}
|
|
obj->nobj = 0;
|
|
|
|
if (flags.invlet_constant) {
|
|
assigninvlet(obj);
|
|
/*
|
|
* The ordering of the chain is nowhere significant
|
|
* so in case you prefer some other order than the
|
|
* historical one, change the code below.
|
|
*/
|
|
if (otmp) { /* find proper place in chain */
|
|
otmp->nobj = 0;
|
|
if ((invent->invlet ^ 040) > (obj->invlet ^ 040)) {
|
|
obj->nobj = invent;
|
|
invent = obj;
|
|
} else
|
|
for (otmp = invent;; otmp = otmp->nobj) {
|
|
if (!otmp->nobj ||
|
|
(otmp->nobj->invlet ^ 040) > (obj->invlet ^ 040)) {
|
|
obj->nobj = otmp->nobj;
|
|
otmp->nobj = obj;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (obj);
|
|
}
|
|
|
|
void
|
|
useup(obj)
|
|
struct obj *obj;
|
|
{
|
|
if (obj->quan > 1) {
|
|
obj->quan--;
|
|
obj->owt = weight(obj);
|
|
} else {
|
|
setnotworn(obj);
|
|
freeinv(obj);
|
|
obfree(obj, (struct obj *) 0);
|
|
}
|
|
}
|
|
|
|
void
|
|
freeinv(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct obj *otmp;
|
|
|
|
if (obj == invent)
|
|
invent = invent->nobj;
|
|
else {
|
|
for (otmp = invent; otmp->nobj != obj; otmp = otmp->nobj)
|
|
if (!otmp->nobj)
|
|
panic("freeinv");
|
|
otmp->nobj = obj->nobj;
|
|
}
|
|
}
|
|
|
|
/* destroy object in fobj chain (if unpaid, it remains on the bill) */
|
|
void
|
|
delobj(obj)
|
|
struct obj *obj;
|
|
{
|
|
freeobj(obj);
|
|
unpobj(obj);
|
|
obfree(obj, (struct obj *) 0);
|
|
}
|
|
|
|
/* unlink obj from chain starting with fobj */
|
|
void
|
|
freeobj(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct obj *otmp;
|
|
|
|
if (obj == fobj)
|
|
fobj = fobj->nobj;
|
|
else {
|
|
for (otmp = fobj; otmp->nobj != obj; otmp = otmp->nobj)
|
|
if (!otmp)
|
|
panic("error in freeobj");
|
|
otmp->nobj = obj->nobj;
|
|
}
|
|
}
|
|
|
|
/* Note: freegold throws away its argument! */
|
|
void
|
|
freegold(gold)
|
|
struct gold *gold;
|
|
{
|
|
struct gold *gtmp;
|
|
|
|
if (gold == fgold)
|
|
fgold = gold->ngold;
|
|
else {
|
|
for (gtmp = fgold; gtmp->ngold != gold; gtmp = gtmp->ngold)
|
|
if (!gtmp)
|
|
panic("error in freegold");
|
|
gtmp->ngold = gold->ngold;
|
|
}
|
|
free((char *) gold);
|
|
}
|
|
|
|
void
|
|
deltrap(trap)
|
|
struct trap *trap;
|
|
{
|
|
struct trap *ttmp;
|
|
|
|
if (trap == ftrap)
|
|
ftrap = ftrap->ntrap;
|
|
else {
|
|
for (ttmp = ftrap; ttmp->ntrap != trap; ttmp = ttmp->ntrap);
|
|
ttmp->ntrap = trap->ntrap;
|
|
}
|
|
free((char *) trap);
|
|
}
|
|
|
|
struct wseg *m_atseg;
|
|
|
|
struct monst *
|
|
m_at(x, y)
|
|
int x, y;
|
|
{
|
|
struct monst *mtmp;
|
|
#ifndef NOWORM
|
|
struct wseg *wtmp;
|
|
#endif /* NOWORM */
|
|
|
|
m_atseg = 0;
|
|
for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) {
|
|
if (mtmp->mx == x && mtmp->my == y)
|
|
return (mtmp);
|
|
#ifndef NOWORM
|
|
if (mtmp->wormno) {
|
|
for (wtmp = wsegs[mtmp->wormno]; wtmp; wtmp = wtmp->nseg)
|
|
if (wtmp->wx == x && wtmp->wy == y) {
|
|
m_atseg = wtmp;
|
|
return (mtmp);
|
|
}
|
|
}
|
|
#endif /* NOWORM */
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
struct obj *
|
|
o_at(x, y)
|
|
int x, y;
|
|
{
|
|
struct obj *otmp;
|
|
|
|
for (otmp = fobj; otmp; otmp = otmp->nobj)
|
|
if (otmp->ox == x && otmp->oy == y)
|
|
return (otmp);
|
|
return (0);
|
|
}
|
|
|
|
struct obj *
|
|
sobj_at(n, x, y)
|
|
int n, x, y;
|
|
{
|
|
struct obj *otmp;
|
|
|
|
for (otmp = fobj; otmp; otmp = otmp->nobj)
|
|
if (otmp->ox == x && otmp->oy == y && otmp->otyp == n)
|
|
return (otmp);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
carried(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct obj *otmp;
|
|
for (otmp = invent; otmp; otmp = otmp->nobj)
|
|
if (otmp == obj)
|
|
return (1);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
carrying(type)
|
|
int type;
|
|
{
|
|
struct obj *otmp;
|
|
|
|
for (otmp = invent; otmp; otmp = otmp->nobj)
|
|
if (otmp->otyp == type)
|
|
return (TRUE);
|
|
return (FALSE);
|
|
}
|
|
|
|
struct obj *
|
|
o_on(id, objchn)
|
|
unsigned int id;
|
|
struct obj *objchn;
|
|
{
|
|
while (objchn) {
|
|
if (objchn->o_id == id)
|
|
return (objchn);
|
|
objchn = objchn->nobj;
|
|
}
|
|
return ((struct obj *) 0);
|
|
}
|
|
|
|
struct trap *
|
|
t_at(x, y)
|
|
int x, y;
|
|
{
|
|
struct trap *trap = ftrap;
|
|
while (trap) {
|
|
if (trap->tx == x && trap->ty == y)
|
|
return (trap);
|
|
trap = trap->ntrap;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
struct gold *
|
|
g_at(x, y)
|
|
int x, y;
|
|
{
|
|
struct gold *gold = fgold;
|
|
while (gold) {
|
|
if (gold->gx == x && gold->gy == y)
|
|
return (gold);
|
|
gold = gold->ngold;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/* make dummy object structure containing gold - for temporary use only */
|
|
struct obj *
|
|
mkgoldobj(q)
|
|
long q;
|
|
{
|
|
struct obj *otmp;
|
|
|
|
otmp = newobj(0);
|
|
/* should set o_id etc. but otmp will be freed soon */
|
|
otmp->olet = '$';
|
|
u.ugold -= q;
|
|
OGOLD(otmp) = q;
|
|
flags.botl = 1;
|
|
return (otmp);
|
|
}
|
|
|
|
/*
|
|
* getobj returns:
|
|
* struct obj *xxx: object to do something with.
|
|
* (struct obj *) 0 error return: no object.
|
|
* &zeroobj explicitly no object (as in w-).
|
|
*/
|
|
struct obj *
|
|
getobj(let, word)
|
|
const char *let, *word;
|
|
{
|
|
struct obj *otmp;
|
|
char ilet, ilet1, ilet2;
|
|
char buf[BUFSZ];
|
|
char lets[BUFSZ];
|
|
int foo = 0, foo2;
|
|
char *bp = buf;
|
|
xchar allowcnt = 0; /* 0, 1 or 2 */
|
|
boolean allowgold = FALSE;
|
|
boolean allowall = FALSE;
|
|
boolean allownone = FALSE;
|
|
xchar foox = 0;
|
|
long cnt;
|
|
|
|
if (*let == '0')
|
|
let++, allowcnt = 1;
|
|
if (*let == '$')
|
|
let++, allowgold = TRUE;
|
|
if (*let == '#')
|
|
let++, allowall = TRUE;
|
|
if (*let == '-')
|
|
let++, allownone = TRUE;
|
|
if (allownone)
|
|
*bp++ = '-';
|
|
if (allowgold)
|
|
*bp++ = '$';
|
|
if (bp > buf && bp[-1] == '-')
|
|
*bp++ = ' ';
|
|
|
|
ilet = 'a';
|
|
for (otmp = invent; otmp; otmp = otmp->nobj) {
|
|
if (!*let || strchr(let, otmp->olet)) {
|
|
bp[foo++] = flags.invlet_constant ? otmp->invlet : ilet;
|
|
|
|
/* ugly check: remove inappropriate things */
|
|
if ((!strcmp(word, "take off") &&
|
|
!(otmp->owornmask & (W_ARMOR - W_ARM2)))
|
|
|| (!strcmp(word, "wear") &&
|
|
(otmp->owornmask & (W_ARMOR | W_RING)))
|
|
|| (!strcmp(word, "wield") &&
|
|
(otmp->owornmask & W_WEP))) {
|
|
foo--;
|
|
foox++;
|
|
}
|
|
}
|
|
if (ilet == 'z')
|
|
ilet = 'A';
|
|
else
|
|
ilet++;
|
|
}
|
|
bp[foo] = 0;
|
|
if (foo == 0 && bp > buf && bp[-1] == ' ')
|
|
*--bp = 0;
|
|
(void) strcpy(lets, bp);/* necessary since we destroy buf */
|
|
if (foo > 5) { /* compactify string */
|
|
foo = foo2 = 1;
|
|
ilet2 = bp[0];
|
|
ilet1 = bp[1];
|
|
while ((ilet = bp[++foo2] = bp[++foo]) != '\0') {
|
|
if (ilet == ilet1 + 1) {
|
|
if (ilet1 == ilet2 + 1)
|
|
bp[foo2 - 1] = ilet1 = '-';
|
|
else if (ilet2 == '-') {
|
|
bp[--foo2] = ++ilet1;
|
|
continue;
|
|
}
|
|
}
|
|
ilet2 = ilet1;
|
|
ilet1 = ilet;
|
|
}
|
|
}
|
|
if (!foo && !allowall && !allowgold && !allownone) {
|
|
pline("You don't have anything %sto %s.",
|
|
foox ? "else " : "", word);
|
|
return (0);
|
|
}
|
|
for (;;) {
|
|
if (!buf[0])
|
|
pline("What do you want to %s [*]? ", word);
|
|
else
|
|
pline("What do you want to %s [%s or ?*]? ",
|
|
word, buf);
|
|
|
|
cnt = 0;
|
|
ilet = readchar();
|
|
while (digit(ilet) && allowcnt) {
|
|
if (cnt < 100000000)
|
|
cnt = 10 * cnt + (ilet - '0');
|
|
else
|
|
cnt = 999999999;
|
|
allowcnt = 2; /* signal presence of cnt */
|
|
ilet = readchar();
|
|
}
|
|
if (digit(ilet)) {
|
|
pline("No count allowed with this command.");
|
|
continue;
|
|
}
|
|
if (strchr(quitchars, ilet))
|
|
return ((struct obj *) 0);
|
|
if (ilet == '-') {
|
|
return (allownone ? &zeroobj : (struct obj *) 0);
|
|
}
|
|
if (ilet == '$') {
|
|
if (!allowgold) {
|
|
pline("You cannot %s gold.", word);
|
|
continue;
|
|
}
|
|
if (!(allowcnt == 2 && cnt < u.ugold))
|
|
cnt = u.ugold;
|
|
return (mkgoldobj(cnt));
|
|
}
|
|
if (ilet == '?') {
|
|
doinv(lets);
|
|
if (!(ilet = morc))
|
|
continue;
|
|
/* he typed a letter (not a space) to more() */
|
|
} else if (ilet == '*') {
|
|
doinv((char *) 0);
|
|
if (!(ilet = morc))
|
|
continue;
|
|
/* ... */
|
|
}
|
|
if (flags.invlet_constant) {
|
|
for (otmp = invent; otmp; otmp = otmp->nobj)
|
|
if (otmp->invlet == ilet)
|
|
break;
|
|
} else {
|
|
if (ilet >= 'A' && ilet <= 'Z')
|
|
ilet += 'z' - 'A' + 1;
|
|
ilet -= 'a';
|
|
for (otmp = invent; otmp && ilet;
|
|
ilet--, otmp = otmp->nobj);
|
|
}
|
|
if (!otmp) {
|
|
pline("You don't have that object.");
|
|
continue;
|
|
}
|
|
if (cnt < 0 || otmp->quan < cnt) {
|
|
pline("You don't have that many! [You have %u]"
|
|
,otmp->quan);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!allowall && let && !strchr(let, otmp->olet)) {
|
|
pline("That is a silly thing to %s.", word);
|
|
return (0);
|
|
}
|
|
if (allowcnt == 2) { /* cnt given */
|
|
if (cnt == 0)
|
|
return (0);
|
|
if (cnt != otmp->quan) {
|
|
struct obj *obj;
|
|
obj = splitobj(otmp, (int) cnt);
|
|
if (otmp == uwep)
|
|
setuwep(obj);
|
|
}
|
|
}
|
|
return (otmp);
|
|
}
|
|
|
|
int
|
|
ckunpaid(otmp)
|
|
struct obj *otmp;
|
|
{
|
|
return (otmp->unpaid);
|
|
}
|
|
|
|
/* interactive version of getobj - used for Drop and Identify */
|
|
/* return the number of times fn was called successfully */
|
|
int
|
|
ggetobj(word, fn, max)
|
|
const char *word;
|
|
int (*fn) __P((struct obj *));
|
|
int max;
|
|
{
|
|
char buf[BUFSZ];
|
|
char *ip;
|
|
char sym;
|
|
int oletct = 0, iletct = 0;
|
|
boolean allflag = FALSE;
|
|
char olets[20], ilets[20];
|
|
int (*ckfn) __P((struct obj *)) =
|
|
(int (*) __P((struct obj *))) 0;
|
|
xchar allowgold = (u.ugold && !strcmp(word, "drop")) ? 1 : 0; /* BAH */
|
|
if (!invent && !allowgold) {
|
|
pline("You have nothing to %s.", word);
|
|
return (0);
|
|
} else {
|
|
struct obj *otmp = invent;
|
|
int uflg = 0;
|
|
|
|
if (allowgold)
|
|
ilets[iletct++] = '$';
|
|
ilets[iletct] = 0;
|
|
while (otmp) {
|
|
if (!strchr(ilets, otmp->olet)) {
|
|
ilets[iletct++] = otmp->olet;
|
|
ilets[iletct] = 0;
|
|
}
|
|
if (otmp->unpaid)
|
|
uflg = 1;
|
|
otmp = otmp->nobj;
|
|
}
|
|
ilets[iletct++] = ' ';
|
|
if (uflg)
|
|
ilets[iletct++] = 'u';
|
|
if (invent)
|
|
ilets[iletct++] = 'a';
|
|
ilets[iletct] = 0;
|
|
}
|
|
pline("What kinds of thing do you want to %s? [%s] ",
|
|
word, ilets);
|
|
getlin(buf);
|
|
if (buf[0] == '\033') {
|
|
clrlin();
|
|
return (0);
|
|
}
|
|
ip = buf;
|
|
olets[0] = 0;
|
|
while ((sym = *ip++) != '\0') {
|
|
if (sym == ' ')
|
|
continue;
|
|
if (sym == '$') {
|
|
if (allowgold == 1)
|
|
(*fn) (mkgoldobj(u.ugold));
|
|
else if (!u.ugold)
|
|
pline("You have no gold.");
|
|
allowgold = 2;
|
|
} else if (sym == 'a' || sym == 'A')
|
|
allflag = TRUE;
|
|
else if (sym == 'u' || sym == 'U')
|
|
ckfn = ckunpaid;
|
|
else if (strchr("!%?[()=*/\"0", sym)) {
|
|
if (!strchr(olets, sym)) {
|
|
olets[oletct++] = sym;
|
|
olets[oletct] = 0;
|
|
}
|
|
} else
|
|
pline("You don't have any %c's.", sym);
|
|
}
|
|
if (allowgold == 2 && !oletct)
|
|
return (1); /* he dropped gold (or at least tried to) */
|
|
else
|
|
return (askchain(invent, olets, allflag, fn, ckfn, max));
|
|
}
|
|
|
|
/*
|
|
* Walk through the chain starting at objchn and ask for all objects
|
|
* with olet in olets (if nonNULL) and satisfying ckfn (if nonNULL)
|
|
* whether the action in question (i.e., fn) has to be performed.
|
|
* If allflag then no questions are asked. Max gives the max nr of
|
|
* objects to be treated. Return the number of objects treated.
|
|
*/
|
|
int
|
|
askchain(objchn, olets, allflag, fn, ckfn, max)
|
|
struct obj *objchn;
|
|
char *olets;
|
|
int allflag;
|
|
int (*fn) __P((struct obj *));
|
|
int (*ckfn) __P((struct obj *));
|
|
int max;
|
|
{
|
|
struct obj *otmp, *otmp2;
|
|
char sym, ilet;
|
|
int cnt = 0;
|
|
ilet = 'a' - 1;
|
|
for (otmp = objchn; otmp; otmp = otmp2) {
|
|
if (ilet == 'z')
|
|
ilet = 'A';
|
|
else
|
|
ilet++;
|
|
otmp2 = otmp->nobj;
|
|
if (olets && *olets && !strchr(olets, otmp->olet))
|
|
continue;
|
|
if (ckfn && !(*ckfn) (otmp))
|
|
continue;
|
|
if (!allflag) {
|
|
pline(xprname(otmp, ilet));
|
|
addtopl(" [nyaq]? ");
|
|
sym = readchar();
|
|
} else
|
|
sym = 'y';
|
|
|
|
switch (sym) {
|
|
case 'a':
|
|
allflag = 1;
|
|
case 'y':
|
|
cnt += (*fn) (otmp);
|
|
if (--max == 0)
|
|
goto ret;
|
|
case 'n':
|
|
default:
|
|
break;
|
|
case 'q':
|
|
goto ret;
|
|
}
|
|
}
|
|
pline(cnt ? "That was all." : "No applicable objects.");
|
|
ret:
|
|
return (cnt);
|
|
}
|
|
|
|
char
|
|
obj_to_let(obj) /* should of course only be called for things
|
|
* in invent */
|
|
struct obj *obj;
|
|
{
|
|
struct obj *otmp;
|
|
char ilet;
|
|
|
|
if (flags.invlet_constant)
|
|
return (obj->invlet);
|
|
ilet = 'a';
|
|
for (otmp = invent; otmp && otmp != obj; otmp = otmp->nobj)
|
|
if (++ilet > 'z')
|
|
ilet = 'A';
|
|
return (otmp ? ilet : NOINVSYM);
|
|
}
|
|
|
|
void
|
|
prinv(obj)
|
|
struct obj *obj;
|
|
{
|
|
pline(xprname(obj, obj_to_let(obj)));
|
|
}
|
|
|
|
static char *
|
|
xprname(obj, let)
|
|
struct obj *obj;
|
|
char let;
|
|
{
|
|
static char li[BUFSZ];
|
|
|
|
(void) sprintf(li, "%c - %s.",
|
|
flags.invlet_constant ? obj->invlet : let,
|
|
doname(obj));
|
|
return (li);
|
|
}
|
|
|
|
int
|
|
ddoinv()
|
|
{
|
|
doinv((char *) 0);
|
|
return (0);
|
|
}
|
|
|
|
/* called with 0 or "": all objects in inventory */
|
|
/* otherwise: all objects with (serial) letter in lets */
|
|
void
|
|
doinv(lets)
|
|
char *lets;
|
|
{
|
|
struct obj *otmp;
|
|
char ilet;
|
|
int ct = 0;
|
|
char any[BUFSZ];
|
|
|
|
morc = 0; /* just to be sure */
|
|
|
|
if (!invent) {
|
|
pline("Not carrying anything.");
|
|
return;
|
|
}
|
|
cornline(0, (char *) 0);
|
|
ilet = 'a';
|
|
for (otmp = invent; otmp; otmp = otmp->nobj) {
|
|
if (flags.invlet_constant)
|
|
ilet = otmp->invlet;
|
|
if (!lets || !*lets || strchr(lets, ilet)) {
|
|
cornline(1, xprname(otmp, ilet));
|
|
any[ct++] = ilet;
|
|
}
|
|
if (!flags.invlet_constant)
|
|
if (++ilet > 'z')
|
|
ilet = 'A';
|
|
}
|
|
any[ct] = 0;
|
|
cornline(2, any);
|
|
}
|
|
|
|
int
|
|
dotypeinv()
|
|
{ /* free after Robert Viduya */
|
|
/* Changed to one type only, so he doesnt have to type cr */
|
|
char c, ilet;
|
|
char stuff[BUFSZ];
|
|
int stct;
|
|
struct obj *otmp;
|
|
boolean billx = inshop() && doinvbill(0);
|
|
boolean unpd = FALSE;
|
|
|
|
if (!invent && !u.ugold && !billx) {
|
|
pline("You aren't carrying anything.");
|
|
return (0);
|
|
}
|
|
stct = 0;
|
|
if (u.ugold)
|
|
stuff[stct++] = '$';
|
|
stuff[stct] = 0;
|
|
for (otmp = invent; otmp; otmp = otmp->nobj) {
|
|
if (!strchr(stuff, otmp->olet)) {
|
|
stuff[stct++] = otmp->olet;
|
|
stuff[stct] = 0;
|
|
}
|
|
if (otmp->unpaid)
|
|
unpd = TRUE;
|
|
}
|
|
if (unpd)
|
|
stuff[stct++] = 'u';
|
|
if (billx)
|
|
stuff[stct++] = 'x';
|
|
stuff[stct] = 0;
|
|
|
|
if (stct > 1) {
|
|
pline("What type of object [%s] do you want an inventory of? ",
|
|
stuff);
|
|
c = readchar();
|
|
if (strchr(quitchars, c))
|
|
return (0);
|
|
} else
|
|
c = stuff[0];
|
|
|
|
if (c == '$')
|
|
return (doprgold());
|
|
|
|
if (c == 'x' || c == 'X') {
|
|
if (billx)
|
|
(void) doinvbill(1);
|
|
else
|
|
pline("No used-up objects on the shopping bill.");
|
|
return (0);
|
|
}
|
|
if ((c == 'u' || c == 'U') && !unpd) {
|
|
pline("You are not carrying any unpaid objects.");
|
|
return (0);
|
|
}
|
|
stct = 0;
|
|
ilet = 'a';
|
|
for (otmp = invent; otmp; otmp = otmp->nobj) {
|
|
if (flags.invlet_constant)
|
|
ilet = otmp->invlet;
|
|
if (c == otmp->olet || (c == 'u' && otmp->unpaid))
|
|
stuff[stct++] = ilet;
|
|
if (!flags.invlet_constant)
|
|
if (++ilet > 'z')
|
|
ilet = 'A';
|
|
}
|
|
stuff[stct] = '\0';
|
|
if (stct == 0)
|
|
pline("You have no such objects.");
|
|
else
|
|
doinv(stuff);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/* look at what is here */
|
|
int
|
|
dolook()
|
|
{
|
|
struct obj *otmp = NULL, *otmp0 = NULL;
|
|
struct gold *gold = NULL;
|
|
const char *verb = Blind ? "feel" : "see";
|
|
int ct = 0;
|
|
|
|
if (!u.uswallow) {
|
|
if (Blind) {
|
|
pline("You try to feel what is lying here on the floor.");
|
|
if (Levitation) { /* ab@unido */
|
|
pline("You cannot reach the floor!");
|
|
return (1);
|
|
}
|
|
}
|
|
otmp0 = o_at(u.ux, u.uy);
|
|
gold = g_at(u.ux, u.uy);
|
|
}
|
|
if (u.uswallow || (!otmp0 && !gold)) {
|
|
pline("You %s no objects here.", verb);
|
|
return (!!Blind);
|
|
}
|
|
cornline(0, "Things that are here:");
|
|
for (otmp = otmp0; otmp; otmp = otmp->nobj) {
|
|
if (otmp->ox == u.ux && otmp->oy == u.uy) {
|
|
ct++;
|
|
cornline(1, doname(otmp));
|
|
if (Blind && otmp->otyp == DEAD_COCKATRICE && !uarmg) {
|
|
pline("Touching the dead cockatrice is a fatal mistake ...");
|
|
pline("You die ...");
|
|
killer = "dead cockatrice";
|
|
done("died");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (gold) {
|
|
char gbuf[30];
|
|
|
|
(void) sprintf(gbuf, "%ld gold piece%s",
|
|
gold->amount, plur(gold->amount));
|
|
if (!ct++)
|
|
pline("You %s here %s.", verb, gbuf);
|
|
else
|
|
cornline(1, gbuf);
|
|
}
|
|
if (ct == 1 && !gold) {
|
|
pline("You %s here %s.", verb, doname(otmp0));
|
|
cornline(3, (char *) 0);
|
|
}
|
|
if (ct > 1)
|
|
cornline(2, (char *) 0);
|
|
return (!!Blind);
|
|
}
|
|
|
|
void
|
|
stackobj(obj)
|
|
struct obj *obj;
|
|
{
|
|
struct obj *otmp = fobj;
|
|
for (otmp = fobj; otmp; otmp = otmp->nobj)
|
|
if (otmp != obj)
|
|
if (otmp->ox == obj->ox && otmp->oy == obj->oy &&
|
|
merged(obj, otmp, 1))
|
|
return;
|
|
}
|
|
|
|
/* merge obj with otmp and delete obj if types agree */
|
|
int
|
|
merged(otmp, obj, lose)
|
|
struct obj *otmp, *obj;
|
|
int lose;
|
|
{
|
|
if (obj->otyp == otmp->otyp &&
|
|
obj->unpaid == otmp->unpaid &&
|
|
obj->spe == otmp->spe &&
|
|
obj->dknown == otmp->dknown &&
|
|
obj->cursed == otmp->cursed &&
|
|
(strchr("%*?!", obj->olet) ||
|
|
(obj->known == otmp->known &&
|
|
(obj->olet == WEAPON_SYM && obj->otyp < BOOMERANG)))) {
|
|
otmp->quan += obj->quan;
|
|
otmp->owt += obj->owt;
|
|
if (lose)
|
|
freeobj(obj);
|
|
obfree(obj, otmp); /* free(obj), bill->otmp */
|
|
return (1);
|
|
} else
|
|
return (0);
|
|
}
|
|
|
|
static long goldcounted;
|
|
/*
|
|
* Gold is no longer displayed; in fact, when you have a lot of money,
|
|
* it may take a while before you have counted it all.
|
|
* [Bug: d$ and pickup still tell you how much it was.]
|
|
*/
|
|
int
|
|
countgold()
|
|
{
|
|
if ((goldcounted += 100 * (u.ulevel + 1)) >= u.ugold) {
|
|
long eps = 0;
|
|
if (!rn2(2))
|
|
eps = rnd((int) (u.ugold / 100 + 1));
|
|
pline("You probably have about %ld gold pieces.",
|
|
u.ugold + eps);
|
|
return (0); /* done */
|
|
}
|
|
return (1); /* continue */
|
|
}
|
|
|
|
int
|
|
doprgold()
|
|
{
|
|
if (!u.ugold)
|
|
pline("You do not carry any gold.");
|
|
else if (u.ugold <= 500)
|
|
pline("You are carrying %ld gold pieces.", u.ugold);
|
|
else {
|
|
pline("You sit down in order to count your gold pieces.");
|
|
goldcounted = 500;
|
|
occupation = countgold;
|
|
occtxt = "counting your gold";
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
/* --- end of gold counting section --- */
|
|
int
|
|
doprwep()
|
|
{
|
|
if (!uwep)
|
|
pline("You are empty handed.");
|
|
else
|
|
prinv(uwep);
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
doprarm()
|
|
{
|
|
if (!uarm && !uarmg && !uarms && !uarmh)
|
|
pline("You are not wearing any armor.");
|
|
else {
|
|
char lets[6];
|
|
int ct = 0;
|
|
|
|
if (uarm)
|
|
lets[ct++] = obj_to_let(uarm);
|
|
if (uarm2)
|
|
lets[ct++] = obj_to_let(uarm2);
|
|
if (uarmh)
|
|
lets[ct++] = obj_to_let(uarmh);
|
|
if (uarms)
|
|
lets[ct++] = obj_to_let(uarms);
|
|
if (uarmg)
|
|
lets[ct++] = obj_to_let(uarmg);
|
|
lets[ct] = 0;
|
|
doinv(lets);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
doprring()
|
|
{
|
|
if (!uleft && !uright)
|
|
pline("You are not wearing any rings.");
|
|
else {
|
|
char lets[3];
|
|
int ct = 0;
|
|
|
|
if (uleft)
|
|
lets[ct++] = obj_to_let(uleft);
|
|
if (uright)
|
|
lets[ct++] = obj_to_let(uright);
|
|
lets[ct] = 0;
|
|
doinv(lets);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
digit(c)
|
|
char c;
|
|
{
|
|
return (c >= '0' && c <= '9');
|
|
}
|