![[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 / urogue|
Return to pack.c CVS log | Up to [contributed] / early-roguelike / urogue |
1.1 rubenllo 1: /*
2: pack.c - Routines to deal with the pack.
3:
4: UltraRogue: The Ultimate Adventure in the Dungeons of Doom
5: Copyright (C) 1985, 1986, 1992, 1993, 1995 Herb Chong
6: All rights reserved.
7:
8: Based on "Advanced Rogue"
9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka
10: All rights reserved.
11:
12: Based on "Rogue: Exploring the Dungeons of Doom"
13: Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
14: All rights reserved.
15:
16: See the file LICENSE.TXT for full copyright and licensing information.
17: */
18:
19: /*
20: Notes
21:
22: The new pack is implemented through the use of bags,
23: and items are classed by their types (see rogue.h) which also
24: happen to be their display character.
25: */
26:
27: #include <stdlib.h>
28: #include <ctype.h>
29: #include "rogue.h"
30:
31: #define ESCAPE_EXIT(x) if (x == ESCAPE) {after = FALSE; msg(""); return(NULL);}
32: #define BAD_NEWS -1
33: #define BAD_LIST ((struct linked_list *) BAD_NEWS)
34: #define GOOD_NEWS 0
35:
36: static char type_list[] = "!?])/=:,"; /* things to inventory */
37:
38: /*
39: swap_top()
40: Takes an stacked object and exchanges places with the top
41: object. <node> must belong to the <top>'s stacked object list.
42: */
43:
44: void
45: swap_top(struct linked_list *top, struct linked_list *node)
46: {
47: struct object *obt, *obn;
48:
49: obt = OBJPTR(top);
50: obn = OBJPTR(node);
51:
52: detach((obt->next_obj), node); /* Take it out of the stack */
53: attach(lvl_obj, node); /* and put it into the level */
54: detach(lvl_obj, top); /* Remove item from level */
55:
56: obn->next_obj = obt->next_obj;
57: obt->next_obj = NULL;
58:
59: if (obn->next_obj)
60: obn->next_obj->l_prev = NULL;
61:
62: attach((obn->next_obj), top);
63: }
64:
65:
66: /*
67: get_all()
68: Get as many stacked items as possible.
69: */
70:
71: void
72: get_all(struct linked_list *top)
73: {
74: struct linked_list *node;
75: struct object *obt;
76:
77: while (top)
78: {
79: obt = OBJPTR(top);
80: node = obt->next_obj;
81:
82: rem_obj(top, FALSE);
83:
84: if (!add_pack(top, FALSE))
85: return;
86:
87: top = node;
88: }
89: }
90:
91:
92: /*
93: get_stack()
94: Allows the user to chose from a stack of items.
95: */
96:
97: struct linked_list *
98: get_stack(struct linked_list *item)
99: {
100: struct object *obj;
101: char buf[2 * LINELEN];
102: int i = 0, j;
103: struct linked_list *ll;
104: mpos = 0;
105: obj = OBJPTR(item);
106:
107: ll = obj->next_obj;
108:
109: sprintf(buf, "You are standing on top of the following items: ");
110: add_line(buf);
111: sprintf(buf, "%d) -- %s", i, inv_name(obj, TRUE));
112: add_line(buf);
113:
114: while (ll)
115: {
116: i++;
117: obj = OBJPTR(ll);
118: sprintf(buf, "%d) -- %s", i, inv_name(obj, TRUE));
119: add_line(buf);
120: ll = next(ll);
121: }
122:
123: end_line();
124:
125: msg("Which one do you want to pick up? [* for all] ");
126:
127: switch(get_string(buf, cw))
128: {
129: case NORM:
130: break;
131: case QUIT: /* pick up nothing */
132: msg("");
133: return (NULL);
134: }
135:
136: if (buf[0] == '*')
137: {
138: get_all(item);
139: msg("");
140: return(NULL);
141: }
142: else
143: {
144: i = atoi(buf);
145:
146: if (i)
147: {
148: obj = OBJPTR(item);
149: ll = obj->next_obj;
150: j = 1;
151:
152: while (ll && (j != i))
153: {
154: ll = next(ll);
155: j++;
156: }
157:
158: if (ll)
159: {
160: swap_top(item, ll);
161: return(ll);
162: }
163: else
164: {
165: debug("Got past last item while picking up.");
166: return(item);
167: }
168: }
169: else
170: return (item);
171: }
172: }
173:
174: /*
175: add_pack()
176: Pick up an object and add it to the pack. If the argument is
177: non-null use it as the linked_list pointer instead of getting it off the
178: ground.
179: */
180:
181: int
182: add_pack(struct linked_list *item, int print_message)
183: {
184: struct object *obj, *op;
185: int from_floor;
186:
187: if (item == NULL)
188: {
189: from_floor = TRUE;
190:
191: if ((item = find_obj(hero.y, hero.x)) == NULL)
192: {
193: msg("Nothing to pick up.");
194: return(FALSE);
195: }
196: }
197: else
198: from_floor = FALSE;
199:
200: if (from_floor)
201: {
202: item = get_stack(item);
203:
204: if (!item)
205: return(FALSE);
206: }
207:
208: obj = OBJPTR(item);
209:
210: /* If it is gold, just add its value to rogue's purse and get rid of */
211:
212: if (obj->o_type == GOLD)
213: {
214: struct linked_list *mitem;
215: struct thing *tp;
216:
217: if (print_message)
218: {
219: if (!terse)
220: addmsg("You found ");
221:
222: msg("%d gold pieces.", obj->o_count);
223: }
224:
225: /*
226: * First make sure no greedy monster is after this gold. If
227: * so, make the monster run after the rogue instead.
228: */
229:
230: for (mitem = mlist; mitem != NULL; mitem = next(mitem))
231: {
232: tp = THINGPTR(mitem);
233:
234: if (tp->t_horde==obj)
235: {
236: tp->t_ischasing = TRUE;
237: tp->t_chasee = &player;
238: tp->t_horde = NULL;
239: }
240: }
241:
242: /*
243: * This will cause problems if people are able to drop and
244: * pick up gold, or when GOLDSTEAL monsters are killed.
245: */
246:
247: /* Thieves get EXP for gold they pick up */
248:
249: if (player.t_ctype == C_THIEF)
250: {
251: pstats.s_exp += obj->o_count / 4;
252: check_level();
253: }
254:
255: purse += obj->o_count;
256:
257: if (from_floor)
258: rem_obj(item, TRUE); /* Remove object from the level */
259:
260: return (TRUE);
261: }
262:
263: /* see if he can carry any more weight */
264:
265: if (itemweight(obj) + pstats.s_pack > pstats.s_carry)
266: {
267: msg("Too much for you to carry.");
268:
269: if (print_message)
270: {
271: msg("%s onto %s", terse ? "Moved" : "You moved",
272: inv_name(obj, LOWERCASE));
273: }
274:
275: return(FALSE);
276: }
277:
278: /*
279: * Link it into the pack. If the item can be grouped, try to find its
280: * neighbors and bump the count. A special case is food, which can't
281: * be grouped, but an exact match allows the count to get
282: * incremented.
283: */
284:
285: if ((op = apply_to_bag(pack, obj->o_type, bff_group, NULL, obj)) != NULL)
286: {
287: op->o_count += obj->o_count; /* add it to the rest */
288:
289: if (from_floor)
290: rem_obj(item, FALSE);
291:
292: pack_report(op, print_message, "You now have ");
293:
294: return(TRUE);
295: }
296:
297: /* Check for and deal with scare monster scrolls */
298:
299: if (obj->o_type == SCROLL && obj->o_which == S_SCARE)
300: if (obj->o_flags & ISCURSED)
301: {
302: msg("The scroll turns to dust as you pick it up.");
303: rem_obj(item, TRUE);
304: return(TRUE);
305: }
306:
307: /* Check if there is room */
308:
309: if (count_bag(pack, obj->o_type, NULL) == max_print())
310: {
311: msg("You have no room for more %s.", name_type(obj->o_type));
312:
313: if (print_message)
314: {
315: obj = OBJPTR(item);
316: msg("%s onto %s.", terse ? "Moved" : "You moved",
317: inv_name(obj, LOWERCASE));
318: }
319:
320: return(FALSE);
321: }
322:
323: /*
324: * finally, add the new item to the bag, and free up the linked list
325: * on top of it.
326: */
327:
328: if (from_floor)
329: rem_obj(item, FALSE);
330:
331: push_bag(&pack, obj);
332: pack_report(obj, print_message, "You now have ");
333: ur_free(item);
334:
335: return(TRUE); /* signal success */
336: }
337:
338: /*
339: pack_report()
340: Notify the user about the results of the pack operation and do some
341: post processing.
342: */
343:
344: void
345: pack_report(object *obj, int print_message, char *message)
346: {
347: /* Notify the user */
348:
349: if (print_message)
350: {
351: if (!terse)
352: addmsg(message);
353:
354: msg("(%c%c) %s.", obj->o_type, print_letters[get_ident(obj)],
355: inv_name(obj, !terse));
356: }
357:
358: if (obj->o_type == ARTIFACT)
359: {
360: has_artifact |= (1 << obj->o_which);
361: picked_artifact |= (1 << obj->o_which);
362:
363: if (!(obj->ar_flags & ISUSED))
364: {
365: obj->ar_flags |= ISUSED;
366: pstats.s_exp += arts[obj->o_which].ar_worth / 10;
367: check_level();
368: }
369: }
370:
371: updpack();
372:
373: return;
374: }
375:
376: /*
377: inventory()
378: list what is in the pack
379: */
380:
381: void
382: inventory(struct linked_list *container, int type)
383: {
384: int cnt;
385:
386: if (type == 0)
387: {
388: msg("What kind of item <%s> to inventory (* for all)?", type_list);
389:
390: type = readchar();
391:
392: if (type == ESCAPE)
393: {
394: after = FALSE;
395: msg("");
396: return;
397: }
398: }
399:
400: /*
401: * Get a list of items to print out. If the user selects '*', list
402: * them all.
403: */
404:
405: if (type == '*')
406: type = 0; /* no type passed ->use them all */
407:
408: mpos = 0;
409:
410: if ((cnt = count_bag(container, type, NULL)) == 0)
411: msg("You don't have any %s.", name_type(type));
412: else
413: {
414: apply_to_bag(container, type, NULL, baf_print_item, &type);
415: end_line();
416: msg("");
417: }
418:
419: return;
420: }
421:
422: /*
423: pick_up()
424: Add something to characters pack.
425: */
426:
427: void
428: pick_up(char ch)
429: {
430: switch(ch)
431: {
432: default:
433: debug("Where did you pick that up???");
434: break;
435:
436: case GOLD:
437: case ARMOR:
438: case POTION:
439: case FOOD:
440: case WEAPON:
441: case SCROLL:
442: case ARTIFACT:
443: case RING:
444: case STICK:
445: add_pack(NULL, MESSAGE);
446: break;
447: }
448: }
449:
450: /*
451: get_object()
452:
453: Pick something out of a pack for a purpose. The basic idea is to
454: list all the possibilities, let the user select one, get that item
455: from the container, and pass it back to the calling routine.
456: */
457:
458: struct object *
459: get_object(struct linked_list *container, char *purpose, int type, int (*bff_p)(struct object *obj, bag_arg *junk))
460: /* char *container; what container has what we want */
461: /* char *purpose; a message (verb) to print if we cant find any */
462: /* char type; type (o_type) to pick out (NULL = any) */
463: /* int (*bff_p) (); bag filter function to test item */
464: {
465: struct object *obj_p = NULL;
466: char sel_id; /* selected type and id */
467: int sel_type;
468: char response;
469:
470: if (container == NULL)
471: {
472: msg("There isn't anything in there.");
473: after = FALSE;
474: return(NULL);
475: }
476:
477: /* Make sure we have at least one item that qualifies! */
478:
479: if (apply_to_bag(container, type, bff_p, NULL, NULL) == NULL)
480: {
481: msg("You seem to have nothing to %s.", purpose);
482: after = FALSE;
483: return(NULL);
484: }
485:
486: while (obj_p == NULL)
487: {
488: if (type == 0)
489: {
490: msg("What kind of item <%s> do you want to %s (* for list)?", type_list, purpose);
491:
492: response = readchar();
493: ESCAPE_EXIT(response);
494: msg("");
495:
496: if (response == '*')
497: {
498: add_line("! Potion");
499: add_line("? Scroll");
500: add_line("= Ring");
501: add_line("/ Stick");
502: add_line("] Armor");
503: add_line(") Weapon");
504: add_line(": Food");
505: end_line();
506: continue;
507: }
508:
509:
510: if (!is_member(type_list, response)) { beep();
511: continue; }
512:
513:
514: if (count_bag(container, response, NULL) == 0)
515: {
516: msg("You don't have any %s.", name_type(response));
517: continue;
518: }
519:
520: type = response;
521: }
522:
523: while(obj_p == NULL)
524: {
525: msg("What item do you want to %s (* for list)?", purpose);
526: response = readchar();
527: msg("");
528: ESCAPE_EXIT(response);
529:
530: if (response == '*')
531: {
532: mpos = 0;
533: apply_to_bag(container, type, bff_p, baf_print_item, &type);
534: end_line();
535: continue;
536: }
537:
538: sel_type = type;
539: sel_id = response;
540:
541: obj_p = scan_bag(container, sel_type,unprint_id(&sel_id));
542: }
543: }
544:
545: mpos = 0;
546: msg("");
547: return(obj_p);
548: }
549:
550: /*
551: get_item()
552:
553: This is only an interim function that serves as an interface to
554: the old function get_item and its replacement get_object. It
555: assumes a NULL action routine and allocates a linked_list
556: structure on top of the object pointer.
557: */
558:
559: struct linked_list *
560: get_item(char *purpose, int type)
561: {
562: struct object *obj_p;
563:
564: if ((obj_p = get_object(pack, purpose, type, NULL)) == NULL)
565: return(NULL);
566:
567: return(make_item(obj_p));
568: }
569:
570: /*
571: del_pack()
572: Take something out of the hero's pack and throw it away.
573: */
574:
575: void
576: del_pack(struct linked_list *what)
577: {
578: rem_pack(OBJPTR(what));
579: discard(what);
580: }
581:
582: /*
583: discard_pack
584: take an object from the pack and throw it away (like del_pack,
585: but without the linked_list structure)
586: */
587:
588: void
589: discard_pack(struct object *obj_p)
590: {
591: rem_pack(obj_p);
592: throw_away(obj_p);
593: }
594:
595: /*
596: rem_pack()
597: Removes an item from the pack.
598: */
599:
600: void
601: rem_pack(struct object *obj_p)
602: {
603: cur_null(obj_p); /* check for current stuff */
604: pop_bag(&pack, obj_p);
605: updpack();
606: return; /* tell caller an item has been removed */
607: }
608:
609: /*
610: cur_null()
611: This updates cur_weapon etc for dropping things
612: */
613:
614: void
615: cur_null(struct object *op)
616: {
617: if (op == cur_weapon)
618: cur_weapon = NULL;
619: else if (op == cur_armor)
620: cur_armor = NULL;
621: else if (op == cur_ring[LEFT_1])
622: cur_ring[LEFT_1] = NULL;
623: else if (op == cur_ring[LEFT_2])
624: cur_ring[LEFT_2] = NULL;
625: else if (op == cur_ring[LEFT_3])
626: cur_ring[LEFT_3] = NULL;
627: else if (op == cur_ring[LEFT_4])
628: cur_ring[LEFT_4] = NULL;
629: else if (op == cur_ring[LEFT_5])
630: cur_ring[LEFT_5] = NULL;
631: else if (op == cur_ring[RIGHT_1])
632: cur_ring[RIGHT_1] = NULL;
633: else if (op == cur_ring[RIGHT_2])
634: cur_ring[RIGHT_2] = NULL;
635: else if (op == cur_ring[RIGHT_3])
636: cur_ring[RIGHT_3] = NULL;
637: else if (op == cur_ring[RIGHT_4])
638: cur_ring[RIGHT_4] = NULL;
639: else if (op == cur_ring[RIGHT_5])
640: cur_ring[RIGHT_5] = NULL;
641: }
642:
643: /*
644: idenpack()
645: Identify all the items in the pack
646: */
647:
648: void
649: idenpack(void)
650: {
651: apply_to_bag(pack, 0, NULL, baf_identify, NULL);
652: }
653:
654: /*
655: show_floor()
656: Print out the item on the floor. Used by the move command.
657: */
658:
659: void
660: show_floor(void)
661: {
662: struct linked_list *item;
663: struct object *obj;
664:
665: item = find_obj(hero.y, hero.x);
666:
667: if (item != NULL)
668: {
669: addmsg("%s onto ", terse ? "Moved" : "You moved");
670:
671: obj = OBJPTR(item);
672:
673: if (obj->next_obj != NULL)
674: msg("a stack of things.");
675: else if (obj->o_type == GOLD)
676: msg("%d gold pieces.", obj->o_count);
677: else
678: {
679: addmsg(inv_name(obj, TRUE));
680: addmsg(".");
681: endmsg();
682: }
683: }
684: }