hack/hack.invent.c

   1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   2 /* hack.invent.c - version 1.0.3 */
   3
   4 #include        "hack.h"
   5 #include        <stdio.h>
   6 extern struct obj *splitobj();
   7 extern struct obj zeroobj;
   8 extern char morc;
   9 extern char quitchars[];
  10 char *xprname();
  11
  12 #ifndef NOWORM
  13 #include        "def.wseg.h"
  14 extern struct wseg *wsegs[32];
  15 #endif NOWORM
  16
  17 #define NOINVSYM        '#'
  18
  19 static int lastinvnr = 51;      /* 0 ... 51 */
  20 static
  21 assigninvlet(otmp)
  22 register struct obj *otmp;
  23 {
  24         boolean inuse[52];
  25         register int i;
  26         register struct obj *obj;
  27
  28         for(i = 0; i < 52; i++) inuse[i] = FALSE;
  29         for(obj = invent; obj; obj = obj->nobj) if(obj != otmp) {
  30                 i = obj->invlet;
  31                 if('a' <= i && i <= 'z') inuse[i - 'a'] = TRUE; else
  32                 if('A' <= i && i <= 'Z') inuse[i - 'A' + 26] = TRUE;
  33                 if(i == otmp->invlet) otmp->invlet = 0;
  34         }
  35         if((i = otmp->invlet) &&
  36             (('a' <= i && i <= 'z') || ('A' <= i && i <= 'Z')))
  37                 return;
  38         for(i = lastinvnr+1; i != lastinvnr; i++) {
  39                 if(i == 52) { i = -1; continue; }
  40                 if(!inuse[i]) break;
  41         }
  42         otmp->invlet = (inuse[i] ? NOINVSYM :
  43                         (i < 26) ? ('a'+i) : ('A'+i-26));
  44         lastinvnr = i;
  45 }
  46
  47 struct obj *
  48 addinv(obj)
  49 register struct obj *obj;
  50 {
  51         register struct obj *otmp;
  52
  53         /* merge or attach to end of chain */
  54         if(!invent) {
  55                 invent = obj;
  56                 otmp = 0;
  57         } else
  58         for(otmp = invent; /* otmp */; otmp = otmp->nobj) {
  59                 if(merged(otmp, obj, 0))
  60                         return(otmp);
  61                 if(!otmp->nobj) {
  62                         otmp->nobj = obj;
  63                         break;
  64                 }
  65         }
  66         obj->nobj = 0;
  67
  68         if(flags.invlet_constant) {
  69                 assigninvlet(obj);
  70                 /*
  71                  * The ordering of the chain is nowhere significant
  72                  * so in case you prefer some other order than the
  73                  * historical one, change the code below.
  74                  */
  75                 if(otmp) {      /* find proper place in chain */
  76                         otmp->nobj = 0;
  77                         if((invent->invlet ^ 040) > (obj->invlet ^ 040)) {
  78                                 obj->nobj = invent;
  79                                 invent = obj;
  80                         } else
  81                         for(otmp = invent; ; otmp = otmp->nobj) {
  82                             if(!otmp->nobj ||
  83                                 (otmp->nobj->invlet ^ 040) > (obj->invlet ^ 040)){
  84                                 obj->nobj = otmp->nobj;
  85                                 otmp->nobj = obj;
  86                                 break;
  87                             }
  88                         }
  89                 }
  90         }
  91
  92         return(obj);
  93 }
  94
  95 useup(obj)
  96 register struct obj *obj;
  97 {
  98         if(obj->quan > 1){
  99                 obj->quan--;
 100                 obj->owt = weight(obj);
 101         } else {
 102                 setnotworn(obj);
 103                 freeinv(obj);
 104                 obfree(obj, (struct obj *) 0);
 105         }
 106 }
 107
 108 freeinv(obj)
 109 register struct obj *obj;
 110 {
 111         register struct obj *otmp;
 112
 113         if(obj == invent)
 114                 invent = invent->nobj;
 115         else {
 116                 for(otmp = invent; otmp->nobj != obj; otmp = otmp->nobj)
 117                         if(!otmp->nobj) panic("freeinv");
 118                 otmp->nobj = obj->nobj;
 119         }
 120 }
 121
 122 /* destroy object in fobj chain (if unpaid, it remains on the bill) */
 123 delobj(obj) register struct obj *obj; {
 124         freeobj(obj);
 125         unpobj(obj);
 126         obfree(obj, (struct obj *) 0);
 127 }
 128
 129 /* unlink obj from chain starting with fobj */
 130 freeobj(obj) register struct obj *obj; {
 131         register struct obj *otmp;
 132
 133         if(obj == fobj) fobj = fobj->nobj;
 134         else {
 135                 for(otmp = fobj; otmp->nobj != obj; otmp = otmp->nobj)
 136                         if(!otmp) panic("error in freeobj");
 137                 otmp->nobj = obj->nobj;
 138         }
 139 }
 140
 141 /* Note: freegold throws away its argument! */
 142 freegold(gold) register struct gold *gold; {
 143         register struct gold *gtmp;
 144
 145         if(gold == fgold) fgold = gold->ngold;
 146         else {
 147                 for(gtmp = fgold; gtmp->ngold != gold; gtmp = gtmp->ngold)
 148                         if(!gtmp) panic("error in freegold");
 149                 gtmp->ngold = gold->ngold;
 150         }
 151         free((char *) gold);
 152 }
 153
 154 deltrap(trap)
 155 register struct trap *trap;
 156 {
 157         register struct trap *ttmp;
 158
 159         if(trap == ftrap)
 160                 ftrap = ftrap->ntrap;
 161         else {
 162                 for(ttmp = ftrap; ttmp->ntrap != trap; ttmp = ttmp->ntrap) ;
 163                 ttmp->ntrap = trap->ntrap;
 164         }
 165         free((char *) trap);
 166 }
 167
 168 struct wseg *m_atseg;
 169
 170 struct monst *
 171 m_at(x,y)
 172 register x,y;
 173 {
 174         register struct monst *mtmp;
 175 #ifndef NOWORM
 176         register struct wseg *wtmp;
 177 #endif NOWORM
 178
 179         m_atseg = 0;
 180         for(mtmp = fmon; mtmp; mtmp = mtmp->nmon){
 181                 if(mtmp->mx == x && mtmp->my == y)
 182                         return(mtmp);
 183 #ifndef NOWORM
 184                 if(mtmp->wormno){
 185                     for(wtmp = wsegs[mtmp->wormno]; wtmp; wtmp = wtmp->nseg)
 186                     if(wtmp->wx == x && wtmp->wy == y){
 187                         m_atseg = wtmp;
 188                         return(mtmp);
 189                     }
 190                 }
 191 #endif NOWORM
 192         }
 193         return(0);
 194 }
 195
 196 struct obj *
 197 o_at(x,y)
 198 register x,y;
 199 {
 200         register struct obj *otmp;
 201
 202         for(otmp = fobj; otmp; otmp = otmp->nobj)
 203                 if(otmp->ox == x && otmp->oy == y) return(otmp);
 204         return(0);
 205 }
 206
 207 struct obj *
 208 sobj_at(n,x,y)
 209 register n,x,y;
 210 {
 211         register struct obj *otmp;
 212
 213         for(otmp = fobj; otmp; otmp = otmp->nobj)
 214                 if(otmp->ox == x && otmp->oy == y && otmp->otyp == n)
 215                         return(otmp);
 216         return(0);
 217 }
 218
 219 carried(obj) register struct obj *obj; {
 220 register struct obj *otmp;
 221         for(otmp = invent; otmp; otmp = otmp->nobj)
 222                 if(otmp == obj) return(1);
 223         return(0);
 224 }
 225
 226 carrying(type)
 227 register int type;
 228 {
 229         register struct obj *otmp;
 230
 231         for(otmp = invent; otmp; otmp = otmp->nobj)
 232                 if(otmp->otyp == type)
 233                         return(TRUE);
 234         return(FALSE);
 235 }
 236
 237 struct obj *
 238 o_on(id, objchn) unsigned int id; register struct obj *objchn; {
 239         while(objchn) {
 240                 if(objchn->o_id == id) return(objchn);
 241                 objchn = objchn->nobj;
 242         }
 243         return((struct obj *) 0);
 244 }
 245
 246 struct trap *
 247 t_at(x,y)
 248 register x,y;
 249 {
 250         register struct trap *trap = ftrap;
 251         while(trap) {
 252                 if(trap->tx == x && trap->ty == y) return(trap);
 253                 trap = trap->ntrap;
 254         }
 255         return(0);
 256 }
 257
 258 struct gold *
 259 g_at(x,y)
 260 register x,y;
 261 {
 262         register struct gold *gold = fgold;
 263         while(gold) {
 264                 if(gold->gx == x && gold->gy == y) return(gold);
 265                 gold = gold->ngold;
 266         }
 267         return(0);
 268 }
 269
 270 /* make dummy object structure containing gold - for temporary use only */
 271 struct obj *
 272 mkgoldobj(q)
 273 register long q;
 274 {
 275         register struct obj *otmp;
 276
 277         otmp = newobj(0);
 278         /* should set o_id etc. but otmp will be freed soon */
 279         otmp->olet = '$';
 280         u.ugold -= q;
 281         OGOLD(otmp) = q;
 282         flags.botl = 1;
 283         return(otmp);
 284 }
 285
 286 /*
 287  * getobj returns:
 288  *      struct obj *xxx:        object to do something with.
 289  *      (struct obj *) 0        error return: no object.
 290  *      &zeroobj                explicitly no object (as in w-).
 291  */
 292 struct obj *
 293 getobj(let,word)
 294 register char *let,*word;
 295 {
 296         register struct obj *otmp;
 297         register char ilet,ilet1,ilet2;
 298         char buf[BUFSZ];
 299         char lets[BUFSZ];
 300         register int foo = 0, foo2;
 301         register char *bp = buf;
 302         xchar allowcnt = 0;     /* 0, 1 or 2 */
 303         boolean allowgold = FALSE;
 304         boolean allowall = FALSE;
 305         boolean allownone = FALSE;
 306         xchar foox = 0;
 307         long cnt;
 308
 309         if(*let == '0') let++, allowcnt = 1;
 310         if(*let == '$') let++, allowgold = TRUE;
 311         if(*let == '#') let++, allowall = TRUE;
 312         if(*let == '-') let++, allownone = TRUE;
 313         if(allownone) *bp++ = '-';
 314         if(allowgold) *bp++ = '$';
 315         if(bp > buf && bp[-1] == '-') *bp++ = ' ';
 316
 317         ilet = 'a';
 318         for(otmp = invent; otmp; otmp = otmp->nobj){
 319             if(!*let || index(let, otmp->olet)) {
 320                 bp[foo++] = flags.invlet_constant ? otmp->invlet : ilet;
 321
 322                 /* ugly check: remove inappropriate things */
 323                 if((!strcmp(word, "take off") &&
 324                     !(otmp->owornmask & (W_ARMOR - W_ARM2)))
 325                 || (!strcmp(word, "wear") &&
 326                     (otmp->owornmask & (W_ARMOR | W_RING)))
 327                 || (!strcmp(word, "wield") &&
 328                     (otmp->owornmask & W_WEP))) {
 329                         foo--;
 330                         foox++;
 331                 }
 332             }
 333             if(ilet == 'z') ilet = 'A'; else ilet++;
 334         }
 335         bp[foo] = 0;
 336         if(foo == 0 && bp > buf && bp[-1] == ' ') *--bp = 0;
 337         (void) strcpy(lets, bp);        /* necessary since we destroy buf */
 338         if(foo > 5) {                   /* compactify string */
 339                 foo = foo2 = 1;
 340                 ilet2 = bp[0];
 341                 ilet1 = bp[1];
 342                 while(ilet = bp[++foo2] = bp[++foo]){
 343                         if(ilet == ilet1+1){
 344                                 if(ilet1 == ilet2+1)
 345                                         bp[foo2 - 1] = ilet1 = '-';
 346                                 else if(ilet2 == '-') {
 347                                         bp[--foo2] = ++ilet1;
 348                                         continue;
 349                                 }
 350                         }
 351                         ilet2 = ilet1;
 352                         ilet1 = ilet;
 353                 }
 354         }
 355         if(!foo && !allowall && !allowgold && !allownone) {
 356                 pline("You don't have anything %sto %s.",
 357                         foox ? "else " : "", word);
 358                 return(0);
 359         }
 360         for(;;) {
 361                 if(!buf[0])
 362                         pline("What do you want to %s [*]? ", word);
 363                 else
 364                         pline("What do you want to %s [%s or ?*]? ",
 365                                 word, buf);
 366
 367                 cnt = 0;
 368                 ilet = readchar();
 369                 while(digit(ilet) && allowcnt) {
 370                         if (cnt < 100000000)
 371                             cnt = 10*cnt + (ilet - '0');
 372                         else
 373                             cnt = 999999999;
 374                         allowcnt = 2;   /* signal presence of cnt */
 375                         ilet = readchar();
 376                 }
 377                 if(digit(ilet)) {
 378                         pline("No count allowed with this command.");
 379                         continue;
 380                 }
 381                 if(index(quitchars,ilet))
 382                         return((struct obj *)0);
 383                 if(ilet == '-') {
 384                         return(allownone ? &zeroobj : (struct obj *) 0);
 385                 }
 386                 if(ilet == '$') {
 387                         if(!allowgold){
 388                                 pline("You cannot %s gold.", word);
 389                                 continue;
 390                         }
 391                         if(!(allowcnt == 2 && cnt < u.ugold))
 392                                 cnt = u.ugold;
 393                         return(mkgoldobj(cnt));
 394                 }
 395                 if(ilet == '?') {
 396                         doinv(lets);
 397                         if(!(ilet = morc)) continue;
 398                         /* he typed a letter (not a space) to more() */
 399                 } else if(ilet == '*') {
 400                         doinv((char *) 0);
 401                         if(!(ilet = morc)) continue;
 402                         /* ... */
 403                 }
 404                 if(flags.invlet_constant) {
 405                         for(otmp = invent; otmp; otmp = otmp->nobj)
 406                                 if(otmp->invlet == ilet) break;
 407                 } else {
 408                         if(ilet >= 'A' && ilet <= 'Z') ilet += 'z'-'A'+1;
 409                         ilet -= 'a';
 410                         for(otmp = invent; otmp && ilet;
 411                                         ilet--, otmp = otmp->nobj) ;
 412                 }
 413                 if(!otmp) {
 414                         pline("You don't have that object.");
 415                         continue;
 416                 }
 417                 if(cnt < 0 || otmp->quan < cnt) {
 418                         pline("You don't have that many! [You have %u]"
 419                         , otmp->quan);
 420                         continue;
 421                 }
 422                 break;
 423         }
 424         if(!allowall && let && !index(let,otmp->olet)) {
 425                 pline("That is a silly thing to %s.",word);
 426                 return(0);
 427         }
 428         if(allowcnt == 2) {     /* cnt given */
 429                 if(cnt == 0) return(0);
 430                 if(cnt != otmp->quan) {
 431                         register struct obj *obj;
 432                         obj = splitobj(otmp, (int) cnt);
 433                         if(otmp == uwep) setuwep(obj);
 434                 }
 435         }
 436         return(otmp);
 437 }
 438
 439 ckunpaid(otmp) register struct obj *otmp; {
 440         return( otmp->unpaid );
 441 }
 442
 443 /* interactive version of getobj - used for Drop and Identify */
 444 /* return the number of times fn was called successfully */
 445 ggetobj(word, fn, max)
 446 char *word;
 447 int (*fn)(),  max;
 448 {
 449 char buf[BUFSZ];
 450 register char *ip;
 451 register char sym;
 452 register int oletct = 0, iletct = 0;
 453 register boolean allflag = FALSE;
 454 char olets[20], ilets[20];
 455 int (*ckfn)() = (int (*)()) 0;
 456 xchar allowgold = (u.ugold && !strcmp(word, "drop")) ? 1 : 0;   /* BAH */
 457         if(!invent && !allowgold){
 458                 pline("You have nothing to %s.", word);
 459                 return(0);
 460         } else {
 461                 register struct obj *otmp = invent;
 462                 register int uflg = 0;
 463
 464                 if(allowgold) ilets[iletct++] = '$';
 465                 ilets[iletct] = 0;
 466                 while(otmp) {
 467                         if(!index(ilets, otmp->olet)){
 468                                 ilets[iletct++] = otmp->olet;
 469                                 ilets[iletct] = 0;
 470                         }
 471                         if(otmp->unpaid) uflg = 1;
 472                         otmp = otmp->nobj;
 473                 }
 474                 ilets[iletct++] = ' ';
 475                 if(uflg) ilets[iletct++] = 'u';
 476                 if(invent) ilets[iletct++] = 'a';
 477                 ilets[iletct] = 0;
 478         }
 479         pline("What kinds of thing do you want to %s? [%s] ",
 480                 word, ilets);
 481         getlin(buf);
 482         if(buf[0] == '\033') {
 483                 clrlin();
 484                 return(0);
 485         }
 486         ip = buf;
 487         olets[0] = 0;
 488         while(sym = *ip++){
 489                 if(sym == ' ') continue;
 490                 if(sym == '$') {
 491                         if(allowgold == 1)
 492                                 (*fn)(mkgoldobj(u.ugold));
 493                         else if(!u.ugold)
 494                                 pline("You have no gold.");
 495                         allowgold = 2;
 496                 } else
 497                 if(sym == 'a' || sym == 'A') allflag = TRUE; else
 498                 if(sym == 'u' || sym == 'U') ckfn = ckunpaid; else
 499                 if(index("!%?[()=*/\"0", sym)){
 500                         if(!index(olets, sym)){
 501                                 olets[oletct++] = sym;
 502                                 olets[oletct] = 0;
 503                         }
 504                 }
 505                 else pline("You don't have any %c's.", sym);
 506         }
 507         if(allowgold == 2 && !oletct)
 508                 return(1);      /* he dropped gold (or at least tried to) */
 509         else
 510                 return(askchain(invent, olets, allflag, fn, ckfn, max));
 511 }
 512
 513 /*
 514  * Walk through the chain starting at objchn and ask for all objects
 515  * with olet in olets (if nonNULL) and satisfying ckfn (if nonNULL)
 516  * whether the action in question (i.e., fn) has to be performed.
 517  * If allflag then no questions are asked. Max gives the max nr of
 518  * objects to be treated. Return the number of objects treated.
 519  */
 520 askchain(objchn, olets, allflag, fn, ckfn, max)
 521 struct obj *objchn;
 522 register char *olets;
 523 int allflag;
 524 int (*fn)(), (*ckfn)();
 525 int max;
 526 {
 527 register struct obj *otmp, *otmp2;
 528 register char sym, ilet;
 529 register int cnt = 0;
 530         ilet = 'a'-1;
 531         for(otmp = objchn; otmp; otmp = otmp2){
 532                 if(ilet == 'z') ilet = 'A'; else ilet++;
 533                 otmp2 = otmp->nobj;
 534                 if(olets && *olets && !index(olets, otmp->olet)) continue;
 535                 if(ckfn && !(*ckfn)(otmp)) continue;
 536                 if(!allflag) {
 537                         pline(xprname(otmp, ilet));
 538                         addtopl(" [nyaq]? ");
 539                         sym = readchar();
 540                 }
 541                 else    sym = 'y';
 542
 543                 switch(sym){
 544                 case 'a':
 545                         allflag = 1;
 546                 case 'y':
 547                         cnt += (*fn)(otmp);
 548                         if(--max == 0) goto ret;
 549                 case 'n':
 550                 default:
 551                         break;
 552                 case 'q':
 553                         goto ret;
 554                 }
 555         }
 556         pline(cnt ? "That was all." : "No applicable objects.");
 557 ret:
 558         return(cnt);
 559 }
 560
 561 obj_to_let(obj) /* should of course only be called for things in invent */
 562 register struct obj *obj;
 563 {
 564         register struct obj *otmp;
 565         register char ilet;
 566
 567         if(flags.invlet_constant)
 568                 return(obj->invlet);
 569         ilet = 'a';
 570         for(otmp = invent; otmp && otmp != obj; otmp = otmp->nobj)
 571                 if(++ilet > 'z') ilet = 'A';
 572         return(otmp ? ilet : NOINVSYM);
 573 }
 574
 575 prinv(obj)
 576 register struct obj *obj;
 577 {
 578         pline(xprname(obj, obj_to_let(obj)));
 579 }
 580
 581 static char *
 582 xprname(obj,let)
 583 register struct obj *obj;
 584 register char let;
 585 {
 586         static char li[BUFSZ];
 587
 588         (void) sprintf(li, "%c - %s.",
 589                 flags.invlet_constant ? obj->invlet : let,
 590                 doname(obj));
 591         return(li);
 592 }
 593
 594 ddoinv()
 595 {
 596         doinv((char *) 0);
 597         return(0);
 598 }
 599
 600 /* called with 0 or "": all objects in inventory */
 601 /* otherwise: all objects with (serial) letter in lets */
 602 doinv(lets)
 603 register char *lets;
 604 {
 605         register struct obj *otmp;
 606         register char ilet;
 607         int ct = 0;
 608         char any[BUFSZ];
 609
 610         morc = 0;               /* just to be sure */
 611
 612         if(!invent){
 613                 pline("Not carrying anything.");
 614                 return;
 615         }
 616
 617         cornline(0, (char *) 0);
 618         ilet = 'a';
 619         for(otmp = invent; otmp; otmp = otmp->nobj) {
 620             if(flags.invlet_constant) ilet = otmp->invlet;
 621             if(!lets || !*lets || index(lets, ilet)) {
 622                     cornline(1, xprname(otmp, ilet));
 623                     any[ct++] = ilet;
 624             }
 625             if(!flags.invlet_constant) if(++ilet > 'z') ilet = 'A';
 626         }
 627         any[ct] = 0;
 628         cornline(2, any);
 629 }
 630
 631 dotypeinv ()                            /* free after Robert Viduya */
 632 /* Changed to one type only, so he doesnt have to type cr */
 633 {
 634     char c, ilet;
 635     char stuff[BUFSZ];
 636     register int stct;
 637     register struct obj *otmp;
 638     boolean billx = inshop() && doinvbill(0);
 639     boolean unpd = FALSE;
 640
 641         if (!invent && !u.ugold && !billx) {
 642             pline ("You aren't carrying anything.");
 643             return(0);
 644         }
 645
 646         stct = 0;
 647         if(u.ugold) stuff[stct++] = '$';
 648         stuff[stct] = 0;
 649         for(otmp = invent; otmp; otmp = otmp->nobj) {
 650             if (!index (stuff, otmp->olet)) {
 651                 stuff[stct++] = otmp->olet;
 652                 stuff[stct] = 0;
 653             }
 654             if(otmp->unpaid)
 655                 unpd = TRUE;
 656         }
 657         if(unpd) stuff[stct++] = 'u';
 658         if(billx) stuff[stct++] = 'x';
 659         stuff[stct] = 0;
 660
 661         if(stct > 1) {
 662             pline ("What type of object [%s] do you want an inventory of? ",
 663                 stuff);
 664             c = readchar();
 665             if(index(quitchars,c)) return(0);
 666         } else
 667             c = stuff[0];
 668
 669         if(c == '$')
 670             return(doprgold());
 671
 672         if(c == 'x' || c == 'X') {
 673             if(billx)
 674                 (void) doinvbill(1);
 675             else
 676                 pline("No used-up objects on the shopping bill.");
 677             return(0);
 678         }
 679
 680         if((c == 'u' || c == 'U') && !unpd) {
 681                 pline("You are not carrying any unpaid objects.");
 682                 return(0);
 683         }
 684
 685         stct = 0;
 686         ilet = 'a';
 687         for (otmp = invent; otmp; otmp = otmp -> nobj) {
 688             if(flags.invlet_constant) ilet = otmp->invlet;
 689             if (c == otmp -> olet || (c == 'u' && otmp -> unpaid))
 690                 stuff[stct++] = ilet;
 691             if(!flags.invlet_constant) if(++ilet > 'z') ilet = 'A';
 692         }
 693         stuff[stct] = '\0';
 694         if(stct == 0)
 695                 pline("You have no such objects.");
 696         else
 697                 doinv (stuff);
 698
 699         return(0);
 700 }
 701
 702 /* look at what is here */
 703 dolook() {
 704     register struct obj *otmp, *otmp0;
 705     register struct gold *gold;
 706     char *verb = Blind ? "feel" : "see";
 707     int ct = 0;
 708
 709     if(!u.uswallow) {
 710         if(Blind) {
 711             pline("You try to feel what is lying here on the floor.");
 712             if(Levitation) {                            /* ab@unido */
 713                 pline("You cannot reach the floor!");
 714                 return(1);
 715             }
 716         }
 717         otmp0 = o_at(u.ux, u.uy);
 718         gold = g_at(u.ux, u.uy);
 719     }
 720
 721     if(u.uswallow || (!otmp0 && !gold)) {
 722         pline("You %s no objects here.", verb);
 723         return(!!Blind);
 724     }
 725
 726     cornline(0, "Things that are here:");
 727     for(otmp = otmp0; otmp; otmp = otmp->nobj) {
 728         if(otmp->ox == u.ux && otmp->oy == u.uy) {
 729             ct++;
 730             cornline(1, doname(otmp));
 731             if(Blind && otmp->otyp == DEAD_COCKATRICE && !uarmg) {
 732                 pline("Touching the dead cockatrice is a fatal mistake ...");
 733                 pline("You die ...");
 734                 killer = "dead cockatrice";
 735                 done("died");
 736             }
 737         }
 738     }
 739
 740     if(gold) {
 741         char gbuf[30];
 742
 743         (void) sprintf(gbuf, "%ld gold piece%s",
 744                 gold->amount, plur(gold->amount));
 745         if(!ct++)
 746             pline("You %s here %s.", verb, gbuf);
 747         else
 748             cornline(1, gbuf);
 749     }
 750
 751     if(ct == 1 && !gold) {
 752         pline("You %s here %s.", verb, doname(otmp0));
 753         cornline(3, (char *) 0);
 754     }
 755     if(ct > 1)
 756         cornline(2, (char *) 0);
 757     return(!!Blind);
 758 }
 759
 760 stackobj(obj) register struct obj *obj; {
 761 register struct obj *otmp = fobj;
 762         for(otmp = fobj; otmp; otmp = otmp->nobj) if(otmp != obj)
 763         if(otmp->ox == obj->ox && otmp->oy == obj->oy &&
 764                 merged(obj,otmp,1))
 765                         return;
 766 }
 767
 768 /* merge obj with otmp and delete obj if types agree */
 769 merged(otmp,obj,lose) register struct obj *otmp, *obj; {
 770         if(obj->otyp == otmp->otyp &&
 771           obj->unpaid == otmp->unpaid &&
 772           obj->spe == otmp->spe &&
 773           obj->dknown == otmp->dknown &&
 774           obj->cursed == otmp->cursed &&
 775           (index("%*?!", obj->olet) ||
 776             (obj->known == otmp->known &&
 777                 (obj->olet == WEAPON_SYM && obj->otyp < BOOMERANG)))) {
 778                 otmp->quan += obj->quan;
 779                 otmp->owt += obj->owt;
 780                 if(lose) freeobj(obj);
 781                 obfree(obj,otmp);       /* free(obj), bill->otmp */
 782                 return(1);
 783         } else  return(0);
 784 }
 785
 786 /*
 787  * Gold is no longer displayed; in fact, when you have a lot of money,
 788  * it may take a while before you have counted it all.
 789  * [Bug: d$ and pickup still tell you how much it was.]
 790  */
 791 extern int (*occupation)();
 792 extern char *occtxt;
 793 static long goldcounted;
 794
 795 countgold(){
 796         if((goldcounted += 100*(u.ulevel + 1)) >= u.ugold) {
 797                 long eps = 0;
 798                 if(!rn2(2)) eps = rnd((int) (u.ugold/100 + 1));
 799                 pline("You probably have about %ld gold pieces.",
 800                         u.ugold + eps);
 801                 return(0);      /* done */
 802         }
 803         return(1);              /* continue */
 804 }
 805
 806 doprgold(){
 807         if(!u.ugold)
 808                 pline("You do not carry any gold.");
 809         else if(u.ugold <= 500)
 810                 pline("You are carrying %ld gold pieces.", u.ugold);
 811         else {
 812                 pline("You sit down in order to count your gold pieces.");
 813                 goldcounted = 500;
 814                 occupation = countgold;
 815                 occtxt = "counting your gold";
 816         }
 817         return(1);
 818 }
 819
 820 /* --- end of gold counting section --- */
 821
 822 doprwep(){
 823         if(!uwep) pline("You are empty handed.");
 824         else prinv(uwep);
 825         return(0);
 826 }
 827
 828 doprarm(){
 829         if(!uarm && !uarmg && !uarms && !uarmh)
 830                 pline("You are not wearing any armor.");
 831         else {
 832                 char lets[6];
 833                 register int ct = 0;
 834
 835                 if(uarm) lets[ct++] = obj_to_let(uarm);
 836                 if(uarm2) lets[ct++] = obj_to_let(uarm2);
 837                 if(uarmh) lets[ct++] = obj_to_let(uarmh);
 838                 if(uarms) lets[ct++] = obj_to_let(uarms);
 839                 if(uarmg) lets[ct++] = obj_to_let(uarmg);
 840                 lets[ct] = 0;
 841                 doinv(lets);
 842         }
 843         return(0);
 844 }
 845
 846 doprring(){
 847         if(!uleft && !uright)
 848                 pline("You are not wearing any rings.");
 849         else {
 850                 char lets[3];
 851                 register int ct = 0;
 852
 853                 if(uleft) lets[ct++] = obj_to_let(uleft);
 854                 if(uright) lets[ct++] = obj_to_let(uright);
 855                 lets[ct] = 0;
 856                 doinv(lets);
 857         }
 858         return(0);
 859 }
 860
 861 digit(c) char c; {
 862         return(c >= '0' && c <= '9');
 863 }