864 lines
18 KiB
C
864 lines
18 KiB
C
|
/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
|
||
|
|
/* hack.invent.c - version 1.0.3 */
|
||
|
|
|
||
|
|
#include "hack.h"
|
||
|
|
#include <stdio.h>
|
||
|
|
extern struct obj *splitobj();
|
||
|
|
extern struct obj zeroobj;
|
||
|
|
extern char morc;
|
||
|
|
extern char quitchars[];
|
||
|
|
static char *xprname();
|
||
|
|
|
||
|
|
#ifndef NOWORM
|
||
|
|
#include "def.wseg.h"
|
||
|
|
extern struct wseg *wsegs[32];
|
||
|
|
#endif NOWORM
|
||
|
|
|
||
|
|
#define NOINVSYM '#'
|
||
|
|
|
||
|
|
static int lastinvnr = 51; /* 0 ... 51 */
|
||
|
|
static
|
||
|
|
assigninvlet(otmp)
|
||
|
|
register struct obj *otmp;
|
||
|
|
{
|
||
|
|
boolean inuse[52];
|
||
|
|
register int i;
|
||
|
|
register 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)
|
||
|
|
register struct obj *obj;
|
||
|
|
{
|
||
|
|
register 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
useup(obj)
|
||
|
|
register struct obj *obj;
|
||
|
|
{
|
||
|
|
if(obj->quan > 1){
|
||
|
|
obj->quan--;
|
||
|
|
obj->owt = weight(obj);
|
||
|
|
} else {
|
||
|
|
setnotworn(obj);
|
||
|
|
freeinv(obj);
|
||
|
|
obfree(obj, (struct obj *) 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
freeinv(obj)
|
||
|
|
register struct obj *obj;
|
||
|
|
{
|
||
|
|
register 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) */
|
||
|
|
delobj(obj) register struct obj *obj; {
|
||
|
|
freeobj(obj);
|
||
|
|
unpobj(obj);
|
||
|
|
obfree(obj, (struct obj *) 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* unlink obj from chain starting with fobj */
|
||
|
|
freeobj(obj) register struct obj *obj; {
|
||
|
|
register 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! */
|
||
|
|
freegold(gold) register struct gold *gold; {
|
||
|
|
register 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
deltrap(trap)
|
||
|
|
register struct trap *trap;
|
||
|
|
{
|
||
|
|
register 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)
|
||
|
|
register x,y;
|
||
|
|
{
|
||
|
|
register struct monst *mtmp;
|
||
|
|
#ifndef NOWORM
|
||
|
|
register 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)
|
||
|
|
register x,y;
|
||
|
|
{
|
||
|
|
register 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)
|
||
|
|
register n,x,y;
|
||
|
|
{
|
||
|
|
register struct obj *otmp;
|
||
|
|
|
||
|
|
for(otmp = fobj; otmp; otmp = otmp->nobj)
|
||
|
|
if(otmp->ox == x && otmp->oy == y && otmp->otyp == n)
|
||
|
|
return(otmp);
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
carried(obj) register struct obj *obj; {
|
||
|
|
register struct obj *otmp;
|
||
|
|
for(otmp = invent; otmp; otmp = otmp->nobj)
|
||
|
|
if(otmp == obj) return(1);
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
carrying(type)
|
||
|
|
register int type;
|
||
|
|
{
|
||
|
|
register 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; register 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)
|
||
|
|
register x,y;
|
||
|
|
{
|
||
|
|
register 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)
|
||
|
|
register x,y;
|
||
|
|
{
|
||
|
|
register 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)
|
||
|
|
register long q;
|
||
|
|
{
|
||
|
|
register 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)
|
||
|
|
register char *let,*word;
|
||
|
|
{
|
||
|
|
register struct obj *otmp;
|
||
|
|
register char ilet,ilet1,ilet2;
|
||
|
|
char buf[BUFSZ];
|
||
|
|
char lets[BUFSZ];
|
||
|
|
register int foo = 0, foo2;
|
||
|
|
register 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 || index(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]){
|
||
|
|
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(index(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 && !index(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) {
|
||
|
|
register struct obj *obj;
|
||
|
|
obj = splitobj(otmp, (int) cnt);
|
||
|
|
if(otmp == uwep) setuwep(obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return(otmp);
|
||
|
|
}
|
||
|
|
|
||
|
|
ckunpaid(otmp) register struct obj *otmp; {
|
||
|
|
return( otmp->unpaid );
|
||
|
|
}
|
||
|
|
|
||
|
|
/* interactive version of getobj - used for Drop and Identify */
|
||
|
|
/* return the number of times fn was called successfully */
|
||
|
|
ggetobj(word, fn, max)
|
||
|
|
char *word;
|
||
|
|
int (*fn)(), max;
|
||
|
|
{
|
||
|
|
char buf[BUFSZ];
|
||
|
|
register char *ip;
|
||
|
|
register char sym;
|
||
|
|
register int oletct = 0, iletct = 0;
|
||
|
|
register boolean allflag = FALSE;
|
||
|
|
char olets[20], ilets[20];
|
||
|
|
int (*ckfn)() = (int (*)()) 0;
|
||
|
|
xchar allowgold = (u.ugold && !strcmp(word, "drop")) ? 1 : 0; /* BAH */
|
||
|
|
if(!invent && !allowgold){
|
||
|
|
pline("You have nothing to %s.", word);
|
||
|
|
return(0);
|
||
|
|
} else {
|
||
|
|
register struct obj *otmp = invent;
|
||
|
|
register int uflg = 0;
|
||
|
|
|
||
|
|
if(allowgold) ilets[iletct++] = '$';
|
||
|
|
ilets[iletct] = 0;
|
||
|
|
while(otmp) {
|
||
|
|
if(!index(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++){
|
||
|
|
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(index("!%?[()=*/\"0", sym)){
|
||
|
|
if(!index(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.
|
||
|
|
*/
|
||
|
|
askchain(objchn, olets, allflag, fn, ckfn, max)
|
||
|
|
struct obj *objchn;
|
||
|
|
register char *olets;
|
||
|
|
int allflag;
|
||
|
|
int (*fn)(), (*ckfn)();
|
||
|
|
int max;
|
||
|
|
{
|
||
|
|
register struct obj *otmp, *otmp2;
|
||
|
|
register char sym, ilet;
|
||
|
|
register 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 && !index(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);
|
||
|
|
}
|
||
|
|
|
||
|
|
obj_to_let(obj) /* should of course only be called for things in invent */
|
||
|
|
register struct obj *obj;
|
||
|
|
{
|
||
|
|
register struct obj *otmp;
|
||
|
|
register 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
prinv(obj)
|
||
|
|
register struct obj *obj;
|
||
|
|
{
|
||
|
|
pline(xprname(obj, obj_to_let(obj)));
|
||
|
|
}
|
||
|
|
|
||
|
|
static char *
|
||
|
|
xprname(obj,let)
|
||
|
|
register struct obj *obj;
|
||
|
|
register char let;
|
||
|
|
{
|
||
|
|
static char li[BUFSZ];
|
||
|
|
|
||
|
|
(void) sprintf(li, "%c - %s.",
|
||
|
|
flags.invlet_constant ? obj->invlet : let,
|
||
|
|
doname(obj));
|
||
|
|
return(li);
|
||
|
|
}
|
||
|
|
|
||
|
|
ddoinv()
|
||
|
|
{
|
||
|
|
doinv((char *) 0);
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* called with 0 or "": all objects in inventory */
|
||
|
|
/* otherwise: all objects with (serial) letter in lets */
|
||
|
|
doinv(lets)
|
||
|
|
register char *lets;
|
||
|
|
{
|
||
|
|
register struct obj *otmp;
|
||
|
|
register 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 || index(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);
|
||
|
|
}
|
||
|
|
|
||
|
|
dotypeinv () /* free after Robert Viduya */
|
||
|
|
/* Changed to one type only, so he doesnt have to type cr */
|
||
|
|
{
|
||
|
|
char c, ilet;
|
||
|
|
char stuff[BUFSZ];
|
||
|
|
register int stct;
|
||
|
|
register 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 (!index (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(index(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 */
|
||
|
|
dolook() {
|
||
|
|
register struct obj *otmp, *otmp0;
|
||
|
|
register struct gold *gold;
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
|
||
|
|
stackobj(obj) register struct obj *obj; {
|
||
|
|
register 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 */
|
||
|
|
merged(otmp,obj,lose) register struct obj *otmp, *obj; {
|
||
|
|
if(obj->otyp == otmp->otyp &&
|
||
|
|
obj->unpaid == otmp->unpaid &&
|
||
|
|
obj->spe == otmp->spe &&
|
||
|
|
obj->dknown == otmp->dknown &&
|
||
|
|
obj->cursed == otmp->cursed &&
|
||
|
|
(index("%*?!", 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* 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.]
|
||
|
|
*/
|
||
|
|
extern int (*occupation)();
|
||
|
|
extern char *occtxt;
|
||
|
|
static long goldcounted;
|
||
|
|
|
||
|
|
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 */
|
||
|
|
}
|
||
|
|
|
||
|
|
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 --- */
|
||
|
|
|
||
|
|
doprwep(){
|
||
|
|
if(!uwep) pline("You are empty handed.");
|
||
|
|
else prinv(uwep);
|
||
|
|
return(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
doprarm(){
|
||
|
|
if(!uarm && !uarmg && !uarms && !uarmh)
|
||
|
|
pline("You are not wearing any armor.");
|
||
|
|
else {
|
||
|
|
char lets[6];
|
||
|
|
register 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
doprring(){
|
||
|
|
if(!uleft && !uright)
|
||
|
|
pline("You are not wearing any rings.");
|
||
|
|
else {
|
||
|
|
char lets[3];
|
||
|
|
register 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
digit(c) char c; {
|
||
|
|
return(c >= '0' && c <= '9');
|
||
|
|
}
|