xref: /dragonfly/games/hack/hack.invent.c (revision cfd1aba3) 
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 }
965