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