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