games/hack/hack.invent.c

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