Mercurial > hg > early-roguelike

comparison arogue5/pack.c @ 63:0ed67132cf10

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import Advanced Rogue 5.8 from the Roguelike Restoration Project (r1490)
author elwin
date Thu, 09 Aug 2012 22:58:48 +0000
parents
children 56e748983fa8
comparison
equal deleted inserted replaced
62:0ef99244acb8 63:0ed67132cf10
1 /*
2 * Routines to deal with the pack
3 *
4 * Advanced Rogue
5 * Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
6 * All rights reserved.
7 *
8 * Based on "Rogue: Exploring the Dungeons of Doom"
9 * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
10 * All rights reserved.
11 *
12 * See the file LICENSE.TXT for full copyright and licensing information.
13 */
14
15 #include "curses.h"
16 #include <ctype.h>
17 #include "rogue.h"
18
19 char outstring[512]; /* ridiculously long string for use with msg */
20
21 /*
22 * add_pack:
23 * Pick up an object and add it to the pack. If the argument is non-null
24 * use it as the linked_list pointer instead of gettting it off the ground.
25 */
26 bool
27 add_pack(item, silent, packret)
28 register struct linked_list *item, **packret;
29 bool silent;
30 {
31 register struct linked_list *ip, *lp = NULL, *ap;
32 register struct object *obj, *op = NULL;
33 register bool exact, from_floor;
34
35 if (packret != NULL)
36 *packret = NULL;
37
38 if (item == NULL)
39 {
40 from_floor = TRUE;
41 if ((item = find_obj(hero.y, hero.x)) == NULL)
42 return(FALSE);
43 }
44 else
45 from_floor = FALSE;
46 obj = OBJPTR(item);
47 /*
48 * If it is gold, just add its value to rogue's purse and get rid
49 * of it.
50 */
51 if (obj->o_type == GOLD) {
52 register struct linked_list *mitem;
53 register struct thing *tp;
54
55 if (!silent) {
56 if (!terse) addmsg("You found ");
57 msg("%d gold pieces.", obj->o_count);
58 }
59
60 /* First make sure no greedy monster is after this gold.
61 * If so, make the monster run after the rogue instead.
62 */
63 for (mitem = mlist; mitem != NULL; mitem = next(mitem)) {
64 tp = THINGPTR(mitem);
65 if (tp->t_dest == &obj->o_pos) tp->t_dest = &hero;
66 }
67
68 purse += obj->o_count;
69 if (from_floor) {
70 detach(lvl_obj, item);
71 if ((ap = find_obj(hero.y, hero.x)) == NULL)
72 mvaddch(hero.y,hero.x,(roomin(&hero)==NULL ? PASSAGE : FLOOR));
73 else
74 mvaddch(hero.y,hero.x,(OBJPTR(ap))->o_type);
75 }
76 o_discard(item);
77 return(TRUE);
78 }
79
80 /*
81 * see if he can carry any more weight
82 */
83 if (itemweight(obj) + pstats.s_pack > pstats.s_carry) {
84 msg("Too much for you to carry.");
85 return FALSE;
86 }
87 /*
88 * Link it into the pack. Search the pack for a object of similar type
89 * if there isn't one, stuff it at the beginning, if there is, look for one
90 * that is exactly the same and just increment the count if there is.
91 * it that. Food is always put at the beginning for ease of access, but
92 * is not ordered so that you can't tell good food from bad. First check
93 * to see if there is something in thr same group and if there is then
94 * increment the count.
95 */
96 if (obj->o_group)
97 {
98 for (ip = pack; ip != NULL; ip = next(ip))
99 {
100 op = OBJPTR(ip);
101 if (op->o_group == obj->o_group)
102 {
103 /*
104 * Put it in the pack and notify the user
105 */
106 op->o_count += obj->o_count;
107 if (from_floor)
108 {
109 detach(lvl_obj, item);
110 if ((ap = find_obj(hero.y, hero.x)) == NULL)
111 mvaddch(hero.y,hero.x,
112 (roomin(&hero)==NULL ? PASSAGE : FLOOR));
113 else
114 mvaddch(hero.y,hero.x,(OBJPTR(ap))->o_type);
115 }
116 o_discard(item);
117 item = ip;
118 goto picked_up;
119 }
120 }
121 }
122
123 /*
124 * Check for and deal with scare monster scrolls
125 */
126 if (obj->o_type == SCROLL && obj->o_which == S_SCARE)
127 if (obj->o_flags & ISCURSED)
128 {
129 msg("The scroll turns to dust as you pick it up.");
130 detach(lvl_obj, item);
131 if ((ap = find_obj(hero.y, hero.x)) == NULL)
132 mvaddch(hero.y,hero.x,(roomin(&hero)==NULL ? PASSAGE : FLOOR));
133 else
134 mvaddch(hero.y,hero.x,(OBJPTR(ap))->o_type);
135 return(TRUE);
136 }
137
138 /*
139 * Search for an object of the same type
140 */
141 exact = FALSE;
142 for (ip = pack; ip != NULL; ip = next(ip))
143 {
144 op = OBJPTR(ip);
145 if (obj->o_type == op->o_type)
146 break;
147 }
148 if (ip == NULL)
149 {
150 /*
151 * Put it at the end of the pack since it is a new type
152 */
153 for (ip = pack; ip != NULL; ip = next(ip))
154 {
155 op = OBJPTR(ip);
156 if (op->o_type != FOOD)
157 break;
158 lp = ip;
159 }
160 }
161 else
162 {
163 /*
164 * Search for an object which is exactly the same
165 */
166 while (ip != NULL && op->o_type == obj->o_type)
167 {
168 if (op->o_which == obj->o_which)
169 {
170 exact = TRUE;
171 break;
172 }
173 lp = ip;
174 if ((ip = next(ip)) == NULL)
175 break;
176 op = OBJPTR(ip);
177 }
178 }
179 /*
180 * Check if there is room
181 */
182 if (ip == NULL || !exact || !ISMULT(obj->o_type)) {
183 if (inpack == MAXPACK-1) {
184 msg(terse ? "No room." : "You can't carry anything else.");
185 return(FALSE);
186 }
187 }
188 inpack++;
189 if (from_floor)
190 {
191 detach(lvl_obj, item);
192 if ((ap = find_obj(hero.y, hero.x)) == NULL)
193 mvaddch(hero.y,hero.x,(roomin(&hero)==NULL ? PASSAGE : FLOOR));
194 else
195 mvaddch(hero.y,hero.x,(OBJPTR(ap))->o_type);
196 }
197 if (ip == NULL)
198 {
199 /*
200 * Didn't find an exact match, just stick it here
201 */
202 if (pack == NULL)
203 pack = item;
204 else
205 {
206 lp->l_next = item;
207 item->l_prev = lp;
208 item->l_next = NULL;
209 }
210 }
211 else
212 {
213 /*
214 * If we found an exact match. If it is food,
215 * increase the count, otherwise put it with its clones.
216 */
217 if (exact && ISMULT(obj->o_type))
218 {
219 op->o_count += obj->o_count;
220 inpack--; /* adjust for previous addition */
221 o_discard(item);
222 item = ip;
223 goto picked_up;
224 }
225 if ((item->l_prev = prev(ip)) != NULL)
226 item->l_prev->l_next = item;
227 else
228 pack = item;
229 item->l_next = ip;
230 ip->l_prev = item;
231 }
232 picked_up:
233 /*
234 * Notify the user
235 */
236 obj = OBJPTR(item);
237 if (!silent)
238 {
239 if (!terse)
240 addmsg("You now have ");
241 sprintf(outstring,"%s (%c)", inv_name(obj, !terse), pack_char(pack, obj));
242 msg(outstring);
243 }
244
245 /* Relics can do strange things when you pick them up */
246 if (obj->o_type == RELIC) {
247 cur_relic[obj->o_which]++; /* Note that we have it */
248 switch (obj->o_which) {
249 case HEIL_ANKH:
250 msg("The ankh welds itself into your hand.");
251
252 /* A cloak must be worn. */
253 when EMORI_CLOAK:
254 if (cur_armor != NULL || cur_misc[WEAR_CLOAK]) {
255 msg("The cloak insists you remove your current garments.");
256 if (!dropcheck(cur_armor != NULL ? cur_armor
257 : cur_misc[WEAR_CLOAK])) {
258 pstats.s_hpt = -1;
259 msg("The cloak constricts around you.");
260 msg("It draws your life force from you!!! -- More --");
261 wait_for(cw,' ');
262 death(D_RELIC);
263 }
264 }
265
266 /* The amulet must be worn. */
267 when YENDOR_AMULET:
268 if (cur_misc[WEAR_JEWEL]) {
269 msg("You have an urge to remove your current amulet.");
270 if (!dropcheck(cur_misc[WEAR_JEWEL])) {
271 pstats.s_hpt = -1;
272 msg("The Amulet of Yendor begins pulsing.");
273 msg("It fades away.... -- More --");
274 wait_for(cw,' ');
275 death(D_RELIC);
276 }
277 }
278 msg("The amulet welds itself into your chest.");
279
280 /* Weapons will insist on being wielded. */
281 when MUSTY_DAGGER:
282 case HRUGGEK_MSTAR:
283 case YEENOGHU_FLAIL:
284 if (cur_weapon != NULL) {
285 msg("The artifact insists you release your current weapon.");
286 if (!dropcheck(cur_weapon)) {
287 pstats.s_hpt = -1;
288 msg("The artifact forces your weapon into your heart.");
289 msg("It hums with satisfaction. -- More --");
290 wait_for(cw,' ');
291 death(D_RELIC);
292 }
293 }
294 cur_weapon = obj;
295 }
296 }
297
298 updpack(FALSE);
299 if (packret != NULL)
300 *packret = item;
301 return(TRUE);
302 }
303
304 /*
305 * inventory:
306 * list what is in the pack
307 */
308 inventory(list, type)
309 register struct linked_list *list;
310 register int type;
311 {
312 register struct object *obj;
313 register char ch;
314 register int n_objs;
315 register int cnt;
316 char inv_temp[LINELEN];
317
318 cnt = 0;
319 n_objs = 0;
320 for (ch = 'a'; list != NULL; ch++, list = next(list)) {
321 obj = OBJPTR(list);
322 if (!is_type(obj, type))
323 continue;
324 switch (n_objs++) {
325 /*
326 * For the first thing in the inventory, just save the string
327 * in case there is only one.
328 */
329 case 0:
330 sprintf(inv_temp, "%c) %s", ch, inv_name(obj, FALSE));
331 break;
332 /*
333 * If there is more than one, clear the screen, print the
334 * saved message and fall through to ...
335 */
336 case 1:
337 if (slow_invent)
338 msg(inv_temp);
339 else
340 {
341 wclear(hw);
342 waddstr(hw, inv_temp);
343 waddch(hw, '\n');
344 }
345 /*
346 * Print the line for this object
347 */
348 default:
349 if (ch > 'z')
350 ch = 'A';
351 if (slow_invent){
352 sprintf(outstring,"%c) %s", ch, inv_name(obj, FALSE));
353 msg(outstring);
354 }
355 else {
356 if (++cnt >= LINES - 2) { /* if bottom of screen */
357 dbotline(hw, morestr);
358 cnt = 0;
359 wclear(hw);
360 }
361 wprintw(hw, "%c) %s\n", ch, inv_name(obj, FALSE));
362 }
363 }
364 }
365 if (n_objs == 0) {
366 if (terse)
367 msg(type == 0 ? "Empty handed." :
368 "Nothing appropriate");
369 else
370 msg(type == 0 ? "You are empty handed." :
371 "You don't have anything appropriate");
372 return FALSE;
373 }
374 if (n_objs == 1) {
375 msg(inv_temp);
376 return TRUE;
377 }
378 if (!slow_invent)
379 {
380 mvwaddstr(hw, LINES-1, 0, spacemsg);
381 draw(hw);
382 wait_for(hw,' ');
383 clearok(cw, TRUE);
384 touchwin(cw);
385 }
386 return TRUE;
387 }
388
389 /*
390 * pick_up:
391 * Add something to characters pack.
392 */
393 pick_up(ch)
394 char ch;
395 {
396 switch (ch) {
397 default:
398 debug("Where did you pick that up???");
399 case GOLD:
400 case ARMOR:
401 case POTION:
402 case FOOD:
403 case WEAPON:
404 case SCROLL:
405 case MM:
406 case RING:
407 case STICK:
408 case RELIC:
409 while (add_pack(NULL, FALSE, NULL)); /* pick up everything there */
410 break;
411 }
412 }
413
414 /*
415 * picky_inven:
416 * Allow player to inventory a single item
417 */
418 void
419 picky_inven()
420 {
421 register struct linked_list *item;
422 register char ch, mch;
423
424 if (pack == NULL)
425 msg("You aren't carrying anything");
426 else if (next(pack) == NULL)
427 msg("a) %s", inv_name(OBJPTR(pack), FALSE));
428 else
429 {
430 msg(terse ? "Item: " : "Which item do you wish to inventory: ");
431 mpos = 0;
432 if ((mch = readchar()) == ESCAPE)
433 {
434 msg("");
435 return;
436 }
437
438 /* Check for a special character */
439 switch (mch) {
440 case FOOD:
441 case SCROLL:
442 case POTION:
443 case RING:
444 case STICK:
445 case RELIC:
446 case ARMOR:
447 case WEAPON:
448 case MM:
449 msg("");
450 if (get_item(pack, NULL, mch) == NULL) {
451 if (terse) msg("None in pack.");
452 else msg("You have no %c in your pack.", mch);
453 }
454 return;
455 }
456
457 for (ch = 'a', item = pack; item != NULL; item = next(item), ch++)
458 if (ch == mch)
459 {
460 sprintf(outstring, "%c) %s",ch ,inv_name(OBJPTR(item), FALSE));
461 msg(outstring);
462 return;
463 }
464 if (!terse)
465 msg("'%s' not in pack.", unctrl(mch));
466 msg("Range is 'a' to '%c'", --ch);
467 }
468 }
469
470
471 /*
472 * get_item:
473 * pick something out of a pack for a purpose
474 */
475 struct linked_list *
476 get_item(list, purpose, type)
477 reg struct linked_list *list;
478 char *purpose; /* NULL if we should be silent (no prompts) */
479 int type;
480 {
481 reg struct linked_list *item;
482 reg struct object *obj;
483 reg int cnt, ch, och;
484 struct linked_list *saveitem = NULL;
485
486 cnt = 0;
487 if (list == NULL) {
488 msg("You aren't carrying anything.");
489 return NULL;
490 }
491 /* see if we have any of the type requested */
492 for(ch = 'a',item = list ; item != NULL ; item = next(item), ch++) {
493 obj = OBJPTR(item);
494 if (is_type(obj, type)) {
495 cnt++;
496 saveitem = item;
497 }
498 }
499 if (cnt == 0) {
500 if (purpose) msg("Nothing to %s",purpose);
501 after = FALSE;
502 return NULL;
503 }
504 else if (cnt == 1) { /* only found one of 'em */
505 obj = OBJPTR(saveitem);
506 for(;;) {
507 if (purpose) { /* Should we prompt the player? */
508 msg("%s what (* for the item)? ",purpose);
509 ch = tolower(readchar());
510 }
511 else {
512 sprintf(outstring, "%c) %s", pack_char(list, obj), inv_name(obj,FALSE));
513 msg(outstring);
514 }
515
516 if (ch == '*') {
517 mpos = 0;
518 sprintf(outstring, "%c) %s", pack_char(list, obj), inv_name(obj,FALSE));
519 msg(outstring);
520 continue;
521 }
522 if (ch == ESCAPE) {
523 msg("");
524 after = FALSE;
525 return NULL;
526 }
527 for(item = list,och = 'a'; item != NULL; item = next(item),och++) {
528 if (ch == och) break;
529 if (och == 'z') och = 'A' - 1;
530 }
531 if (item == NULL) {
532 msg("Please specify a letter between 'a' and '%c'",
533 och == 'A' ? 'z' : och-1);
534 continue;
535 }
536 if (is_type (OBJPTR(item), type)) {
537 if (purpose) mpos = 0;
538 return item;
539 }
540 else
541 msg ("You can't %s that!", purpose);
542
543 }
544 }
545 for(;;) {
546 if (purpose) {
547 msg("%s what? (* for list): ",purpose);
548 ch = readchar();
549 }
550 else ch = '*';
551
552 mpos = 0;
553 if (ch == ESCAPE) { /* abort if escape hit */
554 after = FALSE;
555 msg(""); /* clear display */
556 return NULL;
557 }
558 if (ch == '*') {
559 wclear(hw);
560 cnt = 0;
561 for(item = list,ch = 'a'; item != NULL ; item = next(item), ch++) {
562 obj = OBJPTR(item);
563 if (!is_type(OBJPTR(item), type))
564 continue;
565 wprintw(hw,"%c) %s\n\r",ch,inv_name(obj,FALSE));
566 if (++cnt >= LINES - 2 && next(item) != NULL) {
567 cnt = 0;
568 dbotline(hw, spacemsg);
569 wclear(hw);
570 }
571 if (ch == 'z') ch = 'A' - 1;
572 }
573 wmove(hw, LINES - 1,0);
574 if (purpose) wprintw(hw,"%s what? ",purpose);
575 else waddstr(hw, spacemsg);
576
577 draw(hw); /* write screen */
578
579 if (purpose) {
580 do {
581 ch = tolower(wgetch(hw));
582 } until (isalpha(ch) || ch == ESCAPE);
583 }
584 else {
585 ch = pack_char(list, OBJPTR(saveitem)); /* Pick a valid item */
586 wait_for(hw,' ');
587 }
588
589 restscr(cw); /* redraw orig screen */
590 if(ch == ESCAPE) {
591 after = FALSE;
592 msg(""); /* clear top line */
593 return NULL; /* all done if abort */
594 }
595 /* ch has item to get from list */
596 }
597 for(item = list,och = 'a'; item != NULL; item = next(item),och++) {
598 if (ch == och) break;
599 if (och == 'z') och = 'A' - 1;
600 }
601 if (item == NULL) {
602 msg("Please specify a letter between 'a' and '%c'",
603 och == 'A' ? 'z' : och-1);
604 continue;
605 }
606 if (is_type(OBJPTR(item), type))
607 return (item);
608 else
609 msg ("You can't %s that!", purpose);
610 }
611 }
612
613 pack_char(list, obj)
614 register struct object *obj;
615 struct linked_list *list;
616 {
617 register struct linked_list *item;
618 register char c;
619
620 c = 'a';
621 for (item = list; item != NULL; item = next(item)) {
622 if (OBJPTR(item) == obj)
623 return c;
624 else {
625 if (c == 'z') c = 'A';
626 else c++;
627 }
628 }
629 return 'z';
630 }
631
632
633 /*
634 * cur_null:
635 * This updates cur_weapon etc for dropping things
636 */
637 cur_null(op)
638 reg struct object *op;
639 {
640 if (op == cur_weapon) cur_weapon = NULL;
641 else if (op == cur_armor) cur_armor = NULL;
642 else if (op == cur_ring[LEFT_1]) cur_ring[LEFT_1] = NULL;
643 else if (op == cur_ring[LEFT_2]) cur_ring[LEFT_2] = NULL;
644 else if (op == cur_ring[LEFT_3]) cur_ring[LEFT_3] = NULL;
645 else if (op == cur_ring[LEFT_4]) cur_ring[LEFT_4] = NULL;
646 else if (op == cur_ring[RIGHT_1]) cur_ring[RIGHT_1] = NULL;
647 else if (op == cur_ring[RIGHT_2]) cur_ring[RIGHT_2] = NULL;
648 else if (op == cur_ring[RIGHT_3]) cur_ring[RIGHT_3] = NULL;
649 else if (op == cur_ring[RIGHT_4]) cur_ring[RIGHT_4] = NULL;
650 else if (op == cur_misc[WEAR_BOOTS]) cur_misc[WEAR_BOOTS] = NULL;
651 else if (op == cur_misc[WEAR_JEWEL]) cur_misc[WEAR_JEWEL] = NULL;
652 else if (op == cur_misc[WEAR_GAUNTLET]) cur_misc[WEAR_GAUNTLET] = NULL;
653 else if (op == cur_misc[WEAR_CLOAK]) cur_misc[WEAR_CLOAK] = NULL;
654 else if (op == cur_misc[WEAR_BRACERS]) cur_misc[WEAR_BRACERS] = NULL;
655 else if (op == cur_misc[WEAR_NECKLACE]) cur_misc[WEAR_NECKLACE] = NULL;
656 }
657
658 /*
659 * idenpack:
660 * Identify all the items in the pack
661 */
662 idenpack()
663 {
664 reg struct linked_list *pc;
665
666 for (pc = pack ; pc != NULL ; pc = next(pc))
667 whatis(pc);
668 }
669
670 is_type (obj, type)
671 register struct object *obj;
672 register int type;
673 {
674 register bool current;
675
676 if (type == obj->o_type)
677 return (TRUE);
678
679 switch (type) {
680 case ALL:
681 return (TRUE);
682 when ZAPPABLE:
683 if (obj->o_type == STICK) return (TRUE);
684 if (obj->o_type == RELIC)
685 switch (obj->o_which) {
686 case MING_STAFF:
687 case ASMO_ROD:
688 case ORCUS_WAND:
689 return (TRUE);
690 }
691 when WEARABLE:
692 case REMOVABLE:
693 current = is_current(obj);
694
695 /*
696 * Don't wear thing we are already wearing or remove things
697 * we aren't wearing.
698 */
699 if (type == WEARABLE && current) return (FALSE);
700 else if (type == REMOVABLE && !current) return (FALSE);
701
702 switch (obj->o_type) {
703 case RELIC:
704 switch (obj->o_which) {
705 case HEIL_ANKH:
706 case EMORI_CLOAK:
707 return (TRUE);
708 }
709 when MM:
710 switch (obj->o_which) {
711 case MM_ELF_BOOTS:
712 case MM_DANCE:
713 case MM_BRACERS:
714 case MM_DISP:
715 case MM_PROTECT:
716 case MM_G_DEXTERITY:
717 case MM_G_OGRE:
718 case MM_JEWEL:
719 case MM_R_POWERLESS:
720 case MM_FUMBLE:
721 case MM_STRANGLE:
722 case MM_ADAPTION:
723 return (TRUE);
724 }
725 when ARMOR:
726 case RING:
727 return (TRUE);
728 }
729 when CALLABLE:
730 switch (obj->o_type) {
731 case RING:
732 case POTION:
733 case STICK:
734 case SCROLL:
735 case MM:
736 return(TRUE);
737 }
738 when WIELDABLE:
739 switch (obj->o_type) {
740 case STICK:
741 case WEAPON:
742 return(TRUE);
743 when RELIC:
744 switch (obj->o_which) {
745 case MUSTY_DAGGER:
746 case HRUGGEK_MSTAR:
747 case YEENOGHU_FLAIL:
748 case MING_STAFF:
749 case ORCUS_WAND:
750 case ASMO_ROD:
751 return(TRUE);
752 }
753 }
754 when IDENTABLE:
755 if (!(obj->o_flags & ISKNOW) && obj->o_type != FOOD)
756 return (TRUE);
757 if (obj->o_type == MM) {
758 switch (obj->o_which) {
759 case MM_JUG:
760 /* Can still identify a jug if we don't know the potion */
761 if (obj->o_ac != JUG_EMPTY && !p_know[obj->o_ac])
762 return (TRUE);
763 }
764 }
765 when USEABLE:
766 if (obj->o_type == MM) {
767 switch(obj->o_which) {
768 case MM_JUG:
769 case MM_BEAKER:
770 case MM_BOOK:
771 case MM_SKILLS:
772 case MM_OPEN:
773 case MM_HUNGER:
774 case MM_DRUMS:
775 case MM_DISAPPEAR:
776 case MM_CHOKE:
777 case MM_KEOGHTOM:
778 return (TRUE);
779 }
780 }
781 else if (obj->o_type == RELIC) {
782 switch (obj->o_which) {
783 case EMORI_CLOAK:
784 case BRIAN_MANDOLIN:
785 case HEIL_ANKH:
786 case YENDOR_AMULET:
787 case GERYON_HORN:
788 return (TRUE);
789 }
790 }
791 when PROTECTABLE:
792 switch (obj->o_type) {
793 case WEAPON:
794 if ((obj->o_flags & ISMETAL) == 0) return (FALSE);
795
796 /* Fall through */
797 case ARMOR:
798 return (TRUE);
799
800 when MM:
801 if (obj->o_which == MM_BRACERS) return (TRUE);
802 }
803 }
804 return(FALSE);
805 }
806
807 del_pack(item)
808 register struct linked_list *item;
809 {
810 register struct object *obj;
811
812 obj = OBJPTR(item);
813 if (obj->o_count > 1) {
814 obj->o_count--;
815 }
816 else {
817 cur_null(obj);
818 detach(pack, item);
819 o_discard(item);
820 inpack--;
821 }
822 }
823
824 /*
825 * carry_obj:
826 * Check to see if a monster is carrying something and, if so, give
827 * it to him.
828 */
829
830 carry_obj(mp, chance)
831 register struct thing *mp;
832 int chance;
833 {
834 reg struct linked_list *item;
835 reg struct object *obj;
836
837 /*
838 * If there is no chance, just return.
839 * Note that this means there must be a "chance" in order for
840 * the creature to carry a relic.
841 */
842 if (chance <= 0) return;
843
844 /*
845 * check for the relic/artifacts
846 * Do the relics first so they end up last in the pack. Attach()
847 * always adds things to the beginning. This way they will be the
848 * last things dropped when the creature is killed. This will ensure
849 * the relic will be on top if there is a stack of item lying on the
850 * floor and so the hero will know where it is if he's trying to
851 * avoid it
852 */
853 if (on(*mp, CARRYDAGGER)) {
854 item = spec_item(RELIC, MUSTY_DAGGER, NULL, NULL);
855 obj = OBJPTR(item);
856 obj->o_pos = mp->t_pos;
857 attach(mp->t_pack, item);
858 }
859
860 if (on(*mp, CARRYCLOAK)) {
861 item = spec_item(RELIC, EMORI_CLOAK, NULL, NULL);
862 obj = OBJPTR(item);
863 obj->o_pos = mp->t_pos;
864 attach(mp->t_pack, item);
865 }
866
867 if (on(*mp, CARRYANKH)) {
868 item = spec_item(RELIC, HEIL_ANKH, NULL, NULL);
869 obj = OBJPTR(item);
870 obj->o_pos = mp->t_pos;
871 attach(mp->t_pack, item);
872 }
873
874 if (on(*mp, CARRYSTAFF)) {
875 item = spec_item(RELIC, MING_STAFF, NULL, NULL);
876 obj = OBJPTR(item);
877 obj->o_pos = mp->t_pos;
878 attach(mp->t_pack, item);
879 }
880
881 if (on(*mp, CARRYWAND)) {
882 item = spec_item(RELIC, ORCUS_WAND, NULL, NULL);
883 obj = OBJPTR(item);
884 obj->o_pos = mp->t_pos;
885 attach(mp->t_pack, item);
886 }
887
888 if (on(*mp, CARRYROD)) {
889 item = spec_item(RELIC, ASMO_ROD, NULL, NULL);
890 obj = OBJPTR(item);
891 obj->o_pos = mp->t_pos;
892 attach(mp->t_pack, item);
893 }
894
895 if (on(*mp, CARRYAMULET)) {
896 item = spec_item(RELIC, YENDOR_AMULET, NULL, NULL);
897 obj = OBJPTR(item);
898 obj->o_pos = mp->t_pos;
899 attach(mp->t_pack, item);
900 }
901
902 if (on(*mp, CARRYMANDOLIN)) {
903 item = spec_item(RELIC, BRIAN_MANDOLIN, NULL, NULL);
904 obj = OBJPTR(item);
905 obj->o_pos = mp->t_pos;
906 attach(mp->t_pack, item);
907 }
908 if (on(*mp, CARRYMSTAR)) {
909 item = spec_item(RELIC, HRUGGEK_MSTAR, NULL, NULL);
910 obj = OBJPTR(item);
911 obj->o_pos = mp->t_pos;
912 attach(mp->t_pack, item);
913 }
914 if (on(*mp, CARRYFLAIL)) {
915 item = spec_item(RELIC, YEENOGHU_FLAIL, NULL, NULL);
916 obj = OBJPTR(item);
917 obj->o_pos = mp->t_pos;
918 attach(mp->t_pack, item);
919 }
920 if (on(*mp, CARRYHORN)) {
921 item = spec_item(RELIC, GERYON_HORN, NULL, NULL);
922 obj = OBJPTR(item);
923 obj->o_pos = mp->t_pos;
924 attach(mp->t_pack, item);
925 }
926 /*
927 * If it carries gold, give it some
928 */
929 if (on(*mp, CARRYGOLD) && rnd(100) < chance) {
930 item = spec_item(GOLD, NULL, NULL, NULL);
931 obj = OBJPTR(item);
932 obj->o_count = GOLDCALC + GOLDCALC;
933 obj->o_pos = mp->t_pos;
934 attach(mp->t_pack, item);
935 }
936
937 /*
938 * If it carries food, give it some
939 */
940 if (on(*mp, CARRYFOOD) && rnd(100) < chance) {
941 item = spec_item(FOOD, NULL, NULL, NULL);
942 obj = OBJPTR(item);
943 obj->o_weight = things[TYP_FOOD].mi_wght;
944 obj->o_pos = mp->t_pos;
945 attach(mp->t_pack, item);
946 }
947
948 /*
949 * If it carries a weapon, give it one
950 */
951 if (on(*mp, CARRYWEAPON) && rnd(100) < chance) {
952 int type, hit, dam;
953
954 /* Get the "bonuses" */
955 hit = rnd(5) - 2;
956 dam = rnd(5) - 2;
957
958 /* Only choose an appropriate type of weapon */
959 switch (rnd(11)) {
960 case 0: type = DAGGER;
961 when 1: type = BATTLEAXE;
962 when 2: type = MACE;
963 when 3: type = SWORD;
964 when 4: type = PIKE;
965 when 5: type = HALBERD;
966 when 6: type = SPETUM;
967 when 7: type = BARDICHE;
968 when 8: type = TRIDENT;
969 when 9: type = BASWORD;
970 otherwise: type = TWOSWORD;
971 }
972
973 /* Create the item */
974 item = spec_item(WEAPON, type, hit, dam);
975 obj = OBJPTR(item);
976 obj->o_pos = mp->t_pos;
977 attach(mp->t_pack, item);
978 }
979
980 /*
981 * If it carries a scroll, give it one
982 */
983 if (on(*mp, CARRYSCROLL) && rnd(100) < chance) {
984 item = new_thing(TYP_SCROLL);
985 obj = OBJPTR(item);
986 obj->o_pos = mp->t_pos;
987
988 /* Can the monster carry this scroll? */
989 if (obj->o_which == S_SCARE && mp->t_stats.s_intel < 16)
990 fall(item, FALSE); /* This would scare us! */
991 else attach(mp->t_pack, item);
992 }
993
994 /*
995 * If it carries a potion, give it one
996 */
997 if (on(*mp, CARRYPOTION) && rnd(100) < chance) {
998 item = new_thing(TYP_POTION);
999 obj = OBJPTR(item);
1000 obj->o_pos = mp->t_pos;
1001 attach(mp->t_pack, item);
1002 }
1003
1004 /*
1005 * If it carries a ring, give it one
1006 */
1007 if (on(*mp, CARRYRING) && rnd(100) < chance) {
1008 item = new_thing(TYP_RING);
1009 obj = OBJPTR(item);
1010 obj->o_pos = mp->t_pos;
1011 attach(mp->t_pack, item);
1012 }
1013
1014 /*
1015 * If it carries a wand or staff, give it one
1016 */
1017 if (on(*mp, CARRYSTICK) && rnd(100) < chance) {
1018 item = new_thing(TYP_STICK);
1019 obj = OBJPTR(item);
1020 obj->o_pos = mp->t_pos;
1021 attach(mp->t_pack, item);
1022 }
1023
1024 /*
1025 * If it carries any miscellaneous magic, give it one
1026 */
1027 if (on(*mp, CARRYMISC) && rnd(100) < chance) {
1028 item = new_thing(TYP_MM);
1029 obj = OBJPTR(item);
1030 obj->o_pos = mp->t_pos;
1031 attach(mp->t_pack, item);
1032 }
1033 }
1034
1035
1036 /*
1037 * grab():
1038 * See what is on the spot where the player is standing. If
1039 * nothing is there, do nothing. If there is one thing, pick it
1040 * up. If there are multiple things, prompt the player for what
1041 * he wants (* means everything).
1042 */
1043
1044 grab(y, x)
1045 register y, x;
1046 {
1047 register struct linked_list *next_item, *item;
1048 register struct object *obj;
1049 register int cnt;
1050 int num_there = 0, ch, och;
1051
1052 /*
1053 * Count how many objects there are and move them to the front
1054 * of the level list.
1055 */
1056 for (item = lvl_obj; item != NULL; item = next_item) {
1057 obj = OBJPTR(item);
1058 next_item = next(item);
1059 if (obj->o_pos.y == y && obj->o_pos.x == x) {
1060 num_there++;
1061 detach(lvl_obj, item); /* Remove it from the list */
1062 attach(lvl_obj, item); /* Place it at the front of the list */
1063 }
1064 }
1065
1066 /* Nothing there. */
1067 if (num_there < 1) msg("Nothing %s", terse ? "there." : "to pick up.");
1068
1069 /* One thing there */
1070 else if (num_there == 1) {
1071 add_pack(FALSE, FALSE, NULL);
1072 return(1);
1073 }
1074
1075 /* Multiple things there */
1076 else {
1077 wclear(hw);
1078 cnt = 0;
1079 for (item = lvl_obj, ch = 'a'; item != NULL && cnt < num_there;
1080 item = next(item), ch++) {
1081 obj = OBJPTR(item);
1082 wprintw(hw,"%c) %s\n\r", ch, inv_name(obj,FALSE));
1083 if (++cnt >= LINES - 2 && next(item) != NULL) {
1084 cnt = 0;
1085 dbotline(hw, spacemsg);
1086 wclear(hw);
1087 }
1088 if (ch == 'z') ch = 'A' - 1;
1089 }
1090 wmove(hw, LINES - 1,0);
1091 wprintw(hw, "Pick up what? (* for all): ");
1092 draw(hw); /* write screen */
1093
1094 for (;;) {
1095 do {
1096 ch = tolower(wgetch(hw));
1097 } until (isalpha(ch) || ch == '*' || ch == ESCAPE);
1098 restscr(cw); /* redraw orig screen */
1099 if (ch == ESCAPE) {
1100 after = FALSE;
1101 msg(""); /* clear top line */
1102 break;
1103 }
1104 if (ch == '*') {
1105 while (add_pack(NULL, TRUE, NULL)); /* pick up everything there */
1106 return(num_there);
1107 }
1108 /* ch has item to get from list */
1109
1110 cnt = 0;
1111 for (item = lvl_obj, och = 'a'; item != NULL && cnt < num_there;
1112 item = next(item), och++, cnt++) {
1113 if (ch == och)
1114 break;
1115 if (och == 'z') och = 'A' - 1;
1116 }
1117 if (item == NULL || cnt >= num_there) {
1118 wmove(hw, LINES - 1, 25);
1119 wprintw(hw, " [between 'a' and '%c']:%c ",
1120 och == 'A' ? 'z' : och-1, '\007');
1121 draw(hw); /* write screen */
1122 continue;
1123 }
1124 else {
1125 detach(lvl_obj, item);
1126 if (add_pack(item, FALSE, NULL)) {
1127 /*
1128 * There should always be at least one item left since we
1129 * handle the one item case up above. But it never hurts
1130 * to make sure we don't have a NULL pointer.
1131 */
1132 if ((item = find_obj(hero.y, hero.x)) == NULL)
1133 mvaddch(y, x, (OBJPTR(item))->o_type);
1134 return(1);
1135 }
1136 else attach(lvl_obj, item); /* Couldn't pick it up! */
1137 break;
1138 }
1139 }
1140 }
1141
1142 return(0);
1143 }