![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pack.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / arogue5|
Return to pack.c CVS log | Up to [contributed] / early-roguelike / arogue5 |
1.1 rubenllo 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: bool is_type (struct object *obj, int type);
22:
23: /*
24: * add_pack:
25: * Pick up an object and add it to the pack. If the argument is non-null
26: * use it as the linked_list pointer instead of gettting it off the ground.
27: */
28: bool
29: add_pack(struct linked_list *item, bool silent, struct linked_list **packret)
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: bool
309: inventory(struct linked_list *list, int type)
310: {
311: register struct object *obj;
312: register char ch;
313: register int n_objs;
314: register int cnt;
315: char inv_temp[LINELEN];
316:
317: cnt = 0;
318: n_objs = 0;
319: for (ch = 'a'; list != NULL; ch++, list = next(list)) {
320: obj = OBJPTR(list);
321: if (!is_type(obj, type))
322: continue;
323: switch (n_objs++) {
324: /*
325: * For the first thing in the inventory, just save the string
326: * in case there is only one.
327: */
328: case 0:
329: sprintf(inv_temp, "%c) %s", ch, inv_name(obj, FALSE));
330: break;
331: /*
332: * If there is more than one, clear the screen, print the
333: * saved message and fall through to ...
334: */
335: case 1:
336: if (slow_invent)
337: msg(inv_temp);
338: else
339: {
340: wclear(hw);
341: waddstr(hw, inv_temp);
342: waddch(hw, '\n');
343: }
344: /*
345: * Print the line for this object
346: */
347: default:
348: if (ch > 'z')
349: ch = 'A';
350: if (slow_invent){
351: sprintf(outstring,"%c) %s", ch, inv_name(obj, FALSE));
352: msg(outstring);
353: }
354: else {
355: if (++cnt >= LINES - 2) { /* if bottom of screen */
356: dbotline(hw, morestr);
357: cnt = 0;
358: wclear(hw);
359: }
360: wprintw(hw, "%c) %s\n", ch, inv_name(obj, FALSE));
361: }
362: }
363: }
364: if (n_objs == 0) {
365: if (terse)
366: msg(type == 0 ? "Empty handed." :
367: "Nothing appropriate");
368: else
369: msg(type == 0 ? "You are empty handed." :
370: "You don't have anything appropriate");
371: return FALSE;
372: }
373: if (n_objs == 1) {
374: msg(inv_temp);
375: return TRUE;
376: }
377: if (!slow_invent)
378: {
379: mvwaddstr(hw, LINES-1, 0, spacemsg);
380: draw(hw);
381: wait_for(hw,' ');
382: clearok(cw, TRUE);
383: touchwin(cw);
384: }
385: return TRUE;
386: }
387:
388: /*
389: * pick_up:
390: * Add something to characters pack.
391: */
392: void
393: pick_up(char ch)
394: {
395: switch (ch) {
396: default:
397: debug("Where did you pick that up???");
398: case GOLD:
399: case ARMOR:
400: case POTION:
401: case FOOD:
402: case WEAPON:
403: case SCROLL:
404: case MM:
405: case RING:
406: case STICK:
407: case RELIC:
408: while (add_pack(NULL, FALSE, NULL)); /* pick up everything there */
409: break;
410: }
411: }
412:
413: /*
414: * picky_inven:
415: * Allow player to inventory a single item
416: */
417: void
418: picky_inven(void)
419: {
420: register struct linked_list *item;
421: register char ch, mch;
422:
423: if (pack == NULL)
424: msg("You aren't carrying anything");
425: else if (next(pack) == NULL)
426: msg("a) %s", inv_name(OBJPTR(pack), FALSE));
427: else
428: {
429: msg(terse ? "Item: " : "Which item do you wish to inventory: ");
430: mpos = 0;
431: if ((mch = readchar()) == ESCAPE)
432: {
433: msg("");
434: return;
435: }
436:
437: /* Check for a special character */
438: switch (mch) {
439: case FOOD:
440: case SCROLL:
441: case POTION:
442: case RING:
443: case STICK:
444: case RELIC:
445: case ARMOR:
446: case WEAPON:
447: case MM:
448: msg("");
449: if (get_item(pack, NULL, mch) == NULL) {
450: if (terse) msg("None in pack.");
451: else msg("You have no %c in your pack.", mch);
452: }
453: return;
454: }
455:
456: for (ch = 'a', item = pack; item != NULL; item = next(item), ch++)
457: if (ch == mch)
458: {
459: sprintf(outstring, "%c) %s",ch ,inv_name(OBJPTR(item), FALSE));
460: msg(outstring);
461: return;
462: }
463: if (!terse)
464: msg("'%s' not in pack.", unctrl(mch));
465: msg("Range is 'a' to '%c'", --ch);
466: }
467: }
468:
469:
470: /*
471: * get_item:
472: * pick something out of a pack for a purpose
473: * purpose: NULL if we should be silent (no prompts) *
474: */
475: struct linked_list *
476: get_item(struct linked_list *list, char *purpose, int type)
477: {
478: reg struct linked_list *item;
479: reg struct object *obj;
480: reg int cnt, ch, och;
481: struct linked_list *saveitem = NULL;
482:
483: cnt = 0;
484: if (list == NULL) {
485: msg("You aren't carrying anything.");
486: return NULL;
487: }
488: /* see if we have any of the type requested */
489: for(ch = 'a',item = list ; item != NULL ; item = next(item), ch++) {
490: obj = OBJPTR(item);
491: if (is_type(obj, type)) {
492: cnt++;
493: saveitem = item;
494: }
495: }
496: if (cnt == 0) {
497: if (purpose) msg("Nothing to %s",purpose);
498: after = FALSE;
499: return NULL;
500: }
501: else if (cnt == 1) { /* only found one of 'em */
502: obj = OBJPTR(saveitem);
503: for(;;) {
504: if (purpose) { /* Should we prompt the player? */
505: msg("%s what (* for the item)? ",purpose);
506: ch = tolower(readchar());
507: }
508: else {
509: sprintf(outstring, "%c) %s", pack_char(list, obj), inv_name(obj,FALSE));
510: msg(outstring);
511: }
512:
513: if (ch == '*') {
514: mpos = 0;
515: sprintf(outstring, "%c) %s", pack_char(list, obj), inv_name(obj,FALSE));
516: msg(outstring);
517: continue;
518: }
519: if (ch == ESCAPE) {
520: msg("");
521: after = FALSE;
522: return NULL;
523: }
524: for(item = list,och = 'a'; item != NULL; item = next(item),och++) {
525: if (ch == och) break;
526: if (och == 'z') och = 'A' - 1;
527: }
528: if (item == NULL) {
529: msg("Please specify a letter between 'a' and '%c'",
530: och == 'A' ? 'z' : och-1);
531: continue;
532: }
533: if (is_type (OBJPTR(item), type)) {
534: if (purpose) mpos = 0;
535: return item;
536: }
537: else
538: msg ("You can't %s that!", purpose);
539:
540: }
541: }
542: for(;;) {
543: if (purpose) {
544: msg("%s what? (* for list): ",purpose);
545: ch = readchar();
546: }
547: else ch = '*';
548:
549: mpos = 0;
550: if (ch == ESCAPE) { /* abort if escape hit */
551: after = FALSE;
552: msg(""); /* clear display */
553: return NULL;
554: }
555: if (ch == '*') {
556: wclear(hw);
557: cnt = 0;
558: for(item = list,ch = 'a'; item != NULL ; item = next(item), ch++) {
559: obj = OBJPTR(item);
560: if (!is_type(OBJPTR(item), type))
561: continue;
562: wprintw(hw,"%c) %s\n\r",ch,inv_name(obj,FALSE));
563: if (++cnt >= LINES - 2 && next(item) != NULL) {
564: cnt = 0;
565: dbotline(hw, spacemsg);
566: wclear(hw);
567: }
568: if (ch == 'z') ch = 'A' - 1;
569: }
570: wmove(hw, LINES - 1,0);
571: if (purpose) wprintw(hw,"%s what? ",purpose);
572: else waddstr(hw, spacemsg);
573:
574: draw(hw); /* write screen */
575:
576: if (purpose) {
577: do {
578: ch = tolower(wgetch(hw));
579: } until (isalpha(ch) || ch == ESCAPE);
580: }
581: else {
582: ch = pack_char(list, OBJPTR(saveitem)); /* Pick a valid item */
583: wait_for(hw,' ');
584: }
585:
586: restscr(cw); /* redraw orig screen */
587: if(ch == ESCAPE) {
588: after = FALSE;
589: msg(""); /* clear top line */
590: return NULL; /* all done if abort */
591: }
592: /* ch has item to get from list */
593: }
594: for(item = list,och = 'a'; item != NULL; item = next(item),och++) {
595: if (ch == och) break;
596: if (och == 'z') och = 'A' - 1;
597: }
598: if (item == NULL) {
599: msg("Please specify a letter between 'a' and '%c'",
600: och == 'A' ? 'z' : och-1);
601: continue;
602: }
603: if (is_type(OBJPTR(item), type))
604: return (item);
605: else
606: msg ("You can't %s that!", purpose);
607: }
608: }
609:
610: char
611: pack_char(struct linked_list *list, struct object *obj)
612: {
613: register struct linked_list *item;
614: register char c;
615:
616: c = 'a';
617: for (item = list; item != NULL; item = next(item)) {
618: if (OBJPTR(item) == obj)
619: return c;
620: else {
621: if (c == 'z') c = 'A';
622: else c++;
623: }
624: }
625: return 'z';
626: }
627:
628:
629: /*
630: * cur_null:
631: * This updates cur_weapon etc for dropping things
632: */
633: void
634: cur_null(struct object *op)
635: {
636: if (op == cur_weapon) cur_weapon = NULL;
637: else if (op == cur_armor) cur_armor = NULL;
638: else if (op == cur_ring[LEFT_1]) cur_ring[LEFT_1] = NULL;
639: else if (op == cur_ring[LEFT_2]) cur_ring[LEFT_2] = NULL;
640: else if (op == cur_ring[LEFT_3]) cur_ring[LEFT_3] = NULL;
641: else if (op == cur_ring[LEFT_4]) cur_ring[LEFT_4] = NULL;
642: else if (op == cur_ring[RIGHT_1]) cur_ring[RIGHT_1] = NULL;
643: else if (op == cur_ring[RIGHT_2]) cur_ring[RIGHT_2] = NULL;
644: else if (op == cur_ring[RIGHT_3]) cur_ring[RIGHT_3] = NULL;
645: else if (op == cur_ring[RIGHT_4]) cur_ring[RIGHT_4] = NULL;
646: else if (op == cur_misc[WEAR_BOOTS]) cur_misc[WEAR_BOOTS] = NULL;
647: else if (op == cur_misc[WEAR_JEWEL]) cur_misc[WEAR_JEWEL] = NULL;
648: else if (op == cur_misc[WEAR_GAUNTLET]) cur_misc[WEAR_GAUNTLET] = NULL;
649: else if (op == cur_misc[WEAR_CLOAK]) cur_misc[WEAR_CLOAK] = NULL;
650: else if (op == cur_misc[WEAR_BRACERS]) cur_misc[WEAR_BRACERS] = NULL;
651: else if (op == cur_misc[WEAR_NECKLACE]) cur_misc[WEAR_NECKLACE] = NULL;
652: }
653:
654: /*
655: * idenpack:
656: * Identify all the items in the pack
657: */
658: void
659: idenpack(void)
660: {
661: reg struct linked_list *pc;
662:
663: for (pc = pack ; pc != NULL ; pc = next(pc))
664: whatis(pc);
665: }
666:
667: bool
668: is_type (struct object *obj, int type)
669: {
670: register bool current;
671:
672: if (type == obj->o_type)
673: return (TRUE);
674:
675: switch (type) {
676: case ALL:
677: return (TRUE);
678: when ZAPPABLE:
679: if (obj->o_type == STICK) return (TRUE);
680: if (obj->o_type == RELIC)
681: switch (obj->o_which) {
682: case MING_STAFF:
683: case ASMO_ROD:
684: case ORCUS_WAND:
685: return (TRUE);
686: }
687: when WEARABLE:
688: case REMOVABLE:
689: current = is_current(obj);
690:
691: /*
692: * Don't wear thing we are already wearing or remove things
693: * we aren't wearing.
694: */
695: if (type == WEARABLE && current) return (FALSE);
696: else if (type == REMOVABLE && !current) return (FALSE);
697:
698: switch (obj->o_type) {
699: case RELIC:
700: switch (obj->o_which) {
701: case HEIL_ANKH:
702: case EMORI_CLOAK:
703: return (TRUE);
704: }
705: when MM:
706: switch (obj->o_which) {
707: case MM_ELF_BOOTS:
708: case MM_DANCE:
709: case MM_BRACERS:
710: case MM_DISP:
711: case MM_PROTECT:
712: case MM_G_DEXTERITY:
713: case MM_G_OGRE:
714: case MM_JEWEL:
715: case MM_R_POWERLESS:
716: case MM_FUMBLE:
717: case MM_STRANGLE:
718: case MM_ADAPTION:
719: return (TRUE);
720: }
721: when ARMOR:
722: case RING:
723: return (TRUE);
724: }
725: when CALLABLE:
726: switch (obj->o_type) {
727: case RING:
728: case POTION:
729: case STICK:
730: case SCROLL:
731: case MM:
732: return(TRUE);
733: }
734: when WIELDABLE:
735: switch (obj->o_type) {
736: case STICK:
737: case WEAPON:
738: return(TRUE);
739: when RELIC:
740: switch (obj->o_which) {
741: case MUSTY_DAGGER:
742: case HRUGGEK_MSTAR:
743: case YEENOGHU_FLAIL:
744: case MING_STAFF:
745: case ORCUS_WAND:
746: case ASMO_ROD:
747: return(TRUE);
748: }
749: }
750: when IDENTABLE:
751: if (!(obj->o_flags & ISKNOW) && obj->o_type != FOOD)
752: return (TRUE);
753: if (obj->o_type == MM) {
754: switch (obj->o_which) {
755: case MM_JUG:
756: /* Can still identify a jug if we don't know the potion */
757: if (obj->o_ac != JUG_EMPTY && !p_know[obj->o_ac])
758: return (TRUE);
759: }
760: }
761: when USEABLE:
762: if (obj->o_type == MM) {
763: switch(obj->o_which) {
764: case MM_JUG:
765: case MM_BEAKER:
766: case MM_BOOK:
767: case MM_SKILLS:
768: case MM_OPEN:
769: case MM_HUNGER:
770: case MM_DRUMS:
771: case MM_DISAPPEAR:
772: case MM_CHOKE:
773: case MM_KEOGHTOM:
774: return (TRUE);
775: }
776: }
777: else if (obj->o_type == RELIC) {
778: switch (obj->o_which) {
779: case EMORI_CLOAK:
780: case BRIAN_MANDOLIN:
781: case HEIL_ANKH:
782: case YENDOR_AMULET:
783: case GERYON_HORN:
784: return (TRUE);
785: }
786: }
787: when PROTECTABLE:
788: switch (obj->o_type) {
789: case WEAPON:
790: if ((obj->o_flags & ISMETAL) == 0) return (FALSE);
791:
792: /* Fall through */
793: case ARMOR:
794: return (TRUE);
795:
796: when MM:
797: if (obj->o_which == MM_BRACERS) return (TRUE);
798: }
799: }
800: return(FALSE);
801: }
802:
803: void
804: del_pack(struct linked_list *item)
805: {
806: register struct object *obj;
807:
808: obj = OBJPTR(item);
809: if (obj->o_count > 1) {
810: obj->o_count--;
811: }
812: else {
813: cur_null(obj);
814: detach(pack, item);
815: o_discard(item);
816: inpack--;
817: }
818: }
819:
820: /*
821: * carry_obj:
822: * Check to see if a monster is carrying something and, if so, give
823: * it to him.
824: */
825:
826: void
827: carry_obj(struct thing *mp, int chance)
828: {
829: reg struct linked_list *item;
830: reg struct object *obj;
831:
832: /*
833: * If there is no chance, just return.
834: * Note that this means there must be a "chance" in order for
835: * the creature to carry a relic.
836: */
837: if (chance <= 0) return;
838:
839: /*
840: * check for the relic/artifacts
841: * Do the relics first so they end up last in the pack. Attach()
842: * always adds things to the beginning. This way they will be the
843: * last things dropped when the creature is killed. This will ensure
844: * the relic will be on top if there is a stack of item lying on the
845: * floor and so the hero will know where it is if he's trying to
846: * avoid it
847: */
848: if (on(*mp, CARRYDAGGER)) {
849: item = spec_item(RELIC, MUSTY_DAGGER, 0, 0);
850: obj = OBJPTR(item);
851: obj->o_pos = mp->t_pos;
852: attach(mp->t_pack, item);
853: }
854:
855: if (on(*mp, CARRYCLOAK)) {
856: item = spec_item(RELIC, EMORI_CLOAK, 0, 0);
857: obj = OBJPTR(item);
858: obj->o_pos = mp->t_pos;
859: attach(mp->t_pack, item);
860: }
861:
862: if (on(*mp, CARRYANKH)) {
863: item = spec_item(RELIC, HEIL_ANKH, 0, 0);
864: obj = OBJPTR(item);
865: obj->o_pos = mp->t_pos;
866: attach(mp->t_pack, item);
867: }
868:
869: if (on(*mp, CARRYSTAFF)) {
870: item = spec_item(RELIC, MING_STAFF, 0, 0);
871: obj = OBJPTR(item);
872: obj->o_pos = mp->t_pos;
873: attach(mp->t_pack, item);
874: }
875:
876: if (on(*mp, CARRYWAND)) {
877: item = spec_item(RELIC, ORCUS_WAND, 0, 0);
878: obj = OBJPTR(item);
879: obj->o_pos = mp->t_pos;
880: attach(mp->t_pack, item);
881: }
882:
883: if (on(*mp, CARRYROD)) {
884: item = spec_item(RELIC, ASMO_ROD, 0, 0);
885: obj = OBJPTR(item);
886: obj->o_pos = mp->t_pos;
887: attach(mp->t_pack, item);
888: }
889:
890: if (on(*mp, CARRYAMULET)) {
891: item = spec_item(RELIC, YENDOR_AMULET, 0, 0);
892: obj = OBJPTR(item);
893: obj->o_pos = mp->t_pos;
894: attach(mp->t_pack, item);
895: }
896:
897: if (on(*mp, CARRYMANDOLIN)) {
898: item = spec_item(RELIC, BRIAN_MANDOLIN, 0, 0);
899: obj = OBJPTR(item);
900: obj->o_pos = mp->t_pos;
901: attach(mp->t_pack, item);
902: }
903: if (on(*mp, CARRYMSTAR)) {
904: item = spec_item(RELIC, HRUGGEK_MSTAR, 0, 0);
905: obj = OBJPTR(item);
906: obj->o_pos = mp->t_pos;
907: attach(mp->t_pack, item);
908: }
909: if (on(*mp, CARRYFLAIL)) {
910: item = spec_item(RELIC, YEENOGHU_FLAIL, 0, 0);
911: obj = OBJPTR(item);
912: obj->o_pos = mp->t_pos;
913: attach(mp->t_pack, item);
914: }
915: if (on(*mp, CARRYHORN)) {
916: item = spec_item(RELIC, GERYON_HORN, 0, 0);
917: obj = OBJPTR(item);
918: obj->o_pos = mp->t_pos;
919: attach(mp->t_pack, item);
920: }
921: /*
922: * If it carries gold, give it some
923: */
924: if (on(*mp, CARRYGOLD) && rnd(100) < chance) {
925: item = spec_item(GOLD, 0, 0, 0);
926: obj = OBJPTR(item);
927: obj->o_count = GOLDCALC + GOLDCALC;
928: obj->o_pos = mp->t_pos;
929: attach(mp->t_pack, item);
930: }
931:
932: /*
933: * If it carries food, give it some
934: */
935: if (on(*mp, CARRYFOOD) && rnd(100) < chance) {
936: item = spec_item(FOOD, 0, 0, 0);
937: obj = OBJPTR(item);
938: obj->o_weight = things[TYP_FOOD].mi_wght;
939: obj->o_pos = mp->t_pos;
940: attach(mp->t_pack, item);
941: }
942:
943: /*
944: * If it carries a weapon, give it one
945: */
946: if (on(*mp, CARRYWEAPON) && rnd(100) < chance) {
947: int type, hit, dam;
948:
949: /* Get the "bonuses" */
950: hit = rnd(5) - 2;
951: dam = rnd(5) - 2;
952:
953: /* Only choose an appropriate type of weapon */
954: switch (rnd(11)) {
955: case 0: type = DAGGER;
956: when 1: type = BATTLEAXE;
957: when 2: type = MACE;
958: when 3: type = SWORD;
959: when 4: type = PIKE;
960: when 5: type = HALBERD;
961: when 6: type = SPETUM;
962: when 7: type = BARDICHE;
963: when 8: type = TRIDENT;
964: when 9: type = BASWORD;
965: otherwise: type = TWOSWORD;
966: }
967:
968: /* Create the item */
969: item = spec_item(WEAPON, type, hit, dam);
970: obj = OBJPTR(item);
971: obj->o_pos = mp->t_pos;
972: attach(mp->t_pack, item);
973: }
974:
975: /*
976: * If it carries a scroll, give it one
977: */
978: if (on(*mp, CARRYSCROLL) && rnd(100) < chance) {
979: item = new_thing(TYP_SCROLL);
980: obj = OBJPTR(item);
981: obj->o_pos = mp->t_pos;
982:
983: /* Can the monster carry this scroll? */
984: if (obj->o_which == S_SCARE && mp->t_stats.s_intel < 16)
985: fall(item, FALSE); /* This would scare us! */
986: else attach(mp->t_pack, item);
987: }
988:
989: /*
990: * If it carries a potion, give it one
991: */
992: if (on(*mp, CARRYPOTION) && rnd(100) < chance) {
993: item = new_thing(TYP_POTION);
994: obj = OBJPTR(item);
995: obj->o_pos = mp->t_pos;
996: attach(mp->t_pack, item);
997: }
998:
999: /*
1000: * If it carries a ring, give it one
1001: */
1002: if (on(*mp, CARRYRING) && rnd(100) < chance) {
1003: item = new_thing(TYP_RING);
1004: obj = OBJPTR(item);
1005: obj->o_pos = mp->t_pos;
1006: attach(mp->t_pack, item);
1007: }
1008:
1009: /*
1010: * If it carries a wand or staff, give it one
1011: */
1012: if (on(*mp, CARRYSTICK) && rnd(100) < chance) {
1013: item = new_thing(TYP_STICK);
1014: obj = OBJPTR(item);
1015: obj->o_pos = mp->t_pos;
1016: attach(mp->t_pack, item);
1017: }
1018:
1019: /*
1020: * If it carries any miscellaneous magic, give it one
1021: */
1022: if (on(*mp, CARRYMISC) && rnd(100) < chance) {
1023: item = new_thing(TYP_MM);
1024: obj = OBJPTR(item);
1025: obj->o_pos = mp->t_pos;
1026: attach(mp->t_pack, item);
1027: }
1028: }
1029:
1030:
1031: /*
1032: * grab():
1033: * See what is on the spot where the player is standing. If
1034: * nothing is there, do nothing. If there is one thing, pick it
1035: * up. If there are multiple things, prompt the player for what
1036: * he wants (* means everything).
1037: */
1038:
1039: int
1040: grab(int y, int x)
1041: {
1042: register struct linked_list *next_item, *item;
1043: register struct object *obj;
1044: register int cnt;
1045: int num_there = 0, ch, och;
1046:
1047: /*
1048: * Count how many objects there are and move them to the front
1049: * of the level list.
1050: */
1051: for (item = lvl_obj; item != NULL; item = next_item) {
1052: obj = OBJPTR(item);
1053: next_item = next(item);
1054: if (obj->o_pos.y == y && obj->o_pos.x == x) {
1055: num_there++;
1056: detach(lvl_obj, item); /* Remove it from the list */
1057: attach(lvl_obj, item); /* Place it at the front of the list */
1058: }
1059: }
1060:
1061: /* Nothing there. */
1062: if (num_there < 1) msg("Nothing %s", terse ? "there." : "to pick up.");
1063:
1064: /* One thing there */
1065: else if (num_there == 1) {
1066: add_pack(FALSE, FALSE, NULL);
1067: return(1);
1068: }
1069:
1070: /* Multiple things there */
1071: else {
1072: wclear(hw);
1073: cnt = 0;
1074: for (item = lvl_obj, ch = 'a'; item != NULL && cnt < num_there;
1075: item = next(item), ch++) {
1076: obj = OBJPTR(item);
1077: wprintw(hw,"%c) %s\n\r", ch, inv_name(obj,FALSE));
1078: if (++cnt >= LINES - 2 && next(item) != NULL) {
1079: cnt = 0;
1080: dbotline(hw, spacemsg);
1081: wclear(hw);
1082: }
1083: if (ch == 'z') ch = 'A' - 1;
1084: }
1085: wmove(hw, LINES - 1,0);
1086: wprintw(hw, "Pick up what? (* for all): ");
1087: draw(hw); /* write screen */
1088:
1089: for (;;) {
1090: do {
1091: ch = tolower(wgetch(hw));
1092: } until (isalpha(ch) || ch == '*' || ch == ESCAPE);
1093: restscr(cw); /* redraw orig screen */
1094: if (ch == ESCAPE) {
1095: after = FALSE;
1096: msg(""); /* clear top line */
1097: break;
1098: }
1099: if (ch == '*') {
1100: while (add_pack(NULL, TRUE, NULL)); /* pick up everything there */
1101: return(num_there);
1102: }
1103: /* ch has item to get from list */
1104:
1105: cnt = 0;
1106: for (item = lvl_obj, och = 'a'; item != NULL && cnt < num_there;
1107: item = next(item), och++, cnt++) {
1108: if (ch == och)
1109: break;
1110: if (och == 'z') och = 'A' - 1;
1111: }
1112: if (item == NULL || cnt >= num_there) {
1113: wmove(hw, LINES - 1, 25);
1114: wprintw(hw, " [between 'a' and '%c']:%c ",
1115: och == 'A' ? 'z' : och-1, '\007');
1116: draw(hw); /* write screen */
1117: continue;
1118: }
1119: else {
1120: detach(lvl_obj, item);
1121: if (add_pack(item, FALSE, NULL)) {
1122: /*
1123: * There should always be at least one item left since we
1124: * handle the one item case up above. But it never hurts
1125: * to make sure we don't have a NULL pointer.
1126: */
1127: if ((item = find_obj(hero.y, hero.x)) == NULL)
1128: mvaddch(y, x, (OBJPTR(item))->o_type);
1129: return(1);
1130: }
1131: else attach(lvl_obj, item); /* Couldn't pick it up! */
1132: break;
1133: }
1134: }
1135: }
1136:
1137: return(0);
1138: }