Annotation of early-roguelike/urogue/bag.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: bag.c - functions for dealing with bags
! 3:
! 4: UltraRogue: The Ultimate Adventure in the Dungeons of Doom
! 5: Copyright (C) 1986, 1992, 1993, 1995 Herb Chong
! 6: All rights reserved.
! 7:
! 8: See the file LICENSE.TXT for full copyright and licensing information.
! 9: */
! 10:
! 11: /*
! 12: * new bag functions
! 13: *
! 14: * This is a simple version of bag.c that uses linked lists to perform the bag
! 15: * functions. The bag is just a linked list of objects (struct object) to be
! 16: * specific, but most of that is supposed to be hidden from the user, who
! 17: * should access the bag only through the functions presented here.
! 18: */
! 19:
! 20: #include <stdlib.h>
! 21: #include "rogue.h"
! 22:
! 23: /*
! 24: * apply_to_bag
! 25: *
! 26: * This is the general bag manipulation routine. The bag is subjected to
! 27: * selection criteria and those objects which pass are processed by an action
! 28: * routine. The two criteria are type and filter function. The filter
! 29: * function returns TRUE if the object passes and FALSE otherwise. The filter
! 30: * function is passed the object and the user-supplied argument. This gives
! 31: * the user plenty of flexibility in determining which items will be
! 32: * processed. The action routine is passed the object, the id, and the
! 33: * user-supplied argument given to apply_to_bag. Specifying NULL for either
! 34: * the type or filter function means that criterion always selects. A NULL
! 35: * action routine means no processing is done and the first object which
! 36: * passes the filter is returned to the user. The action routine returns TRUE
! 37: * if processing should continue or FALSE if the current item should be
! 38: * returned to the caller.
! 39: *
! 40: * Returns NULL if the bag is empty or if nothing qualified.
! 41: *
! 42: * linked_list *bag_p; // linked list of objects
! 43: * int type; // what is its type (ARMOR, ...)
! 44: * int (*bff_p)(); // bag filter function
! 45: * int (*baf_p)(); // bag action routine
! 46: * long user_arg; // user argument for filter, action
! 47: *
! 48: */
! 49:
! 50: struct object *
! 51: apply_to_bag(struct linked_list *bag_p,
! 52: int type,
! 53: int (*bff_p)(struct object *obj, bag_arg *user_arg),
! 54: int (*baf_p)(struct object *obj, bag_arg *user_arg, int id),
! 55: void *user_arg)
! 56: {
! 57: struct object *bag_obj_p = NULL; /* qualifying object */
! 58: struct object *cur_obj_p; /* current object */
! 59: bag_arg arg;
! 60:
! 61: arg.varg = user_arg;
! 62:
! 63: if (bag_p == NULL)
! 64: return (NULL);
! 65:
! 66: for (; bag_p != NULL; bag_p = next(bag_p))
! 67: {
! 68: cur_obj_p = OBJPTR(bag_p);
! 69:
! 70: if (type != 0 && type != cur_obj_p->o_type)
! 71: continue;
! 72:
! 73: if (bff_p != NULL && !(*bff_p)(cur_obj_p, &arg))
! 74: continue;
! 75:
! 76: /*
! 77: * At this point, we have an object which qualifies for
! 78: * processing
! 79: */
! 80:
! 81: bag_obj_p = cur_obj_p; /* in case the user wants it */
! 82:
! 83: if (baf_p != NULL && (*baf_p)(cur_obj_p, &arg, identifier(bag_obj_p)))
! 84: continue;
! 85:
! 86: /*
! 87: * We have an object which qualifies, quit now!
! 88: */
! 89:
! 90: break;
! 91: }
! 92:
! 93: if (bag_p == NULL)
! 94: return (NULL);
! 95:
! 96: return (bag_obj_p);
! 97: }
! 98:
! 99: /*
! 100: count_bag()
! 101:
! 102: Counts up all bag items which meet the selection criteria
! 103: */
! 104:
! 105: int
! 106: count_bag(linked_list *bag_p,
! 107: int type,
! 108: int (*bff_p)(struct object *obj, bag_arg *junk))
! 109: {
! 110: int cnt = 0;
! 111: apply_to_bag(bag_p, type, bff_p, baf_increment, &cnt);
! 112:
! 113: return(cnt);
! 114: }
! 115:
! 116: /*
! 117: del_bag()
! 118:
! 119: Removes an object from a bag and throws it away.
! 120: */
! 121:
! 122: void
! 123: del_bag(linked_list *bag_p, object *obj_p)
! 124: {
! 125: pop_bag(&bag_p, obj_p); /* get the thing from the bag */
! 126: ur_free(obj_p); /* release the memory */
! 127: }
! 128:
! 129: /*
! 130: pop_bag()
! 131:
! 132: Removes an item from a bag and returns it to the user. If the item is
! 133: not in the bag, return NULL.
! 134: */
! 135:
! 136: struct object *
! 137: pop_bag(linked_list **bag_pp, object *obj_p)
! 138: {
! 139: linked_list *item_p;
! 140:
! 141: for (item_p = *bag_pp; item_p != NULL && OBJPTR(item_p) != obj_p;
! 142: item_p = next(item_p));
! 143:
! 144: if (item_p == NULL)
! 145: return (NULL);
! 146:
! 147: _detach(bag_pp, item_p);
! 148:
! 149: return (obj_p);
! 150: }
! 151:
! 152: /*
! 153: push_bag()
! 154:
! 155: stuff another item into the bag
! 156: */
! 157:
! 158: void
! 159: push_bag(linked_list **bag_pp, object *obj_p)
! 160: {
! 161: struct linked_list *item_p = NULL;
! 162: struct linked_list *new_p = NULL;
! 163: struct linked_list *best_p = NULL;
! 164:
! 165: new_p = new_list();
! 166: new_p->data.obj = obj_p; /* attach our object */
! 167: identifier(obj_p) = get_ident(obj_p); /* tag this object for */
! 168: /* inventory */
! 169: /*
! 170: * Find a place in the bag - try to match the type, then sort by
! 171: * identifier
! 172: */
! 173:
! 174: for (item_p = *bag_pp; item_p != NULL; item_p = next(item_p))
! 175: {
! 176: if ((OBJPTR(item_p))->o_type == obj_p->o_type)
! 177: {
! 178: if (best_p == NULL)
! 179: best_p = item_p;
! 180: else if (identifier((OBJPTR(item_p))) >
! 181: identifier((OBJPTR(best_p))) &&
! 182: identifier((OBJPTR(item_p))) <
! 183: identifier(obj_p))
! 184: best_p = item_p;
! 185: }
! 186: }
! 187:
! 188: _attach_after(bag_pp, best_p, new_p); /* stuff it in the list */
! 189:
! 190: return;
! 191: }
! 192:
! 193: /*
! 194: scan_bag()
! 195:
! 196: Gets the object from the bag that matches the type and id. The object
! 197: is not removed from the bag.
! 198: */
! 199:
! 200: struct object *
! 201: scan_bag(linked_list *bag_p, int type, int id)
! 202: {
! 203: object *obj_p = NULL;
! 204:
! 205: for (; bag_p != NULL; bag_p = next(bag_p))
! 206: {
! 207: obj_p = OBJPTR(bag_p);
! 208:
! 209: if (obj_p->o_type == type && identifier(obj_p) == id)
! 210: break;
! 211: }
! 212:
! 213: if (bag_p == NULL)
! 214: return(NULL);
! 215:
! 216: return(obj_p);
! 217: }
! 218:
! 219: /*
! 220: baf_decrement_test()
! 221:
! 222: Assumes the argument is a pointer to int and it just decrements it.
! 223: Returns TRUE, except when the count goes to zero.
! 224: */
! 225:
! 226: int
! 227: baf_decrement_test(struct object *obj_p, bag_arg *count_p, int id)
! 228: {
! 229: NOOP(obj_p);
! 230: NOOP(id);
! 231:
! 232: if (*count_p->iarg > 0)
! 233: return(TRUE);
! 234:
! 235: return(FALSE);
! 236: }
! 237:
! 238: /*
! 239: baf_identify()
! 240:
! 241: Bag action function to identify an object. This is needed to conform
! 242: to bag action routine calling conventions and to put the linked list
! 243: structure on top of the object before calling whatis()
! 244: */
! 245:
! 246: int
! 247: baf_identify(struct object *obj_p, bag_arg *junk, int id)
! 248: {
! 249: linked_list l;
! 250: linked_list *lp = &l;
! 251:
! 252: NOOP(junk);
! 253: NOOP(id);
! 254:
! 255: lp->data.obj = obj_p; /* stuff object in the right place */
! 256: whatis(lp);
! 257:
! 258: return(TRUE);
! 259: }
! 260:
! 261: /*
! 262: baf_increment()
! 263:
! 264: Assumes the argument is a pointer to int and it just increments it and
! 265: returns TRUE
! 266: */
! 267:
! 268: int
! 269: baf_increment(object *obj_p, bag_arg *count_p, int id)
! 270: {
! 271: NOOP(obj_p);
! 272: NOOP(id);
! 273:
! 274: (*count_p->iarg)++;
! 275:
! 276: return(TRUE);
! 277: }
! 278:
! 279: /*
! 280: baf_print_item()
! 281: Bag action function to print a single item, inventory style.
! 282: */
! 283:
! 284: int
! 285: baf_print_item(struct object *obj_p, bag_arg *type, int id)
! 286: {
! 287: char inv_temp[3 * LINELEN]; /* plenty of space for paranoid programmers */
! 288:
! 289: if (*type->iarg == 0)
! 290: sprintf(inv_temp, "%c%c) %s", obj_p->o_type,
! 291: print_letters[id], inv_name(obj_p, LOWERCASE));
! 292: else
! 293: sprintf(inv_temp, "%c) %s", print_letters[id],
! 294: inv_name(obj_p, LOWERCASE));
! 295:
! 296: add_line(inv_temp);
! 297: return(TRUE);
! 298: }
! 299:
! 300: /*
! 301: bff_group()
! 302: This bag filter function checks to see if two items can be combined by
! 303: adjusting the count. Grouped items can be combined if the group numbers
! 304: match. The only other item that is allowed to have a count is food, and
! 305: there an exact match is required.
! 306: */
! 307:
! 308: int
! 309: bff_group(struct object *obj_p, bag_arg *arg)
! 310: {
! 311: struct object *new_obj_p = arg->obj;
! 312:
! 313: if (new_obj_p->o_group > 0 && new_obj_p->o_group == obj_p->o_group)
! 314: return(TRUE);
! 315:
! 316: if (new_obj_p->o_type == FOOD &&
! 317: obj_p->o_type == new_obj_p->o_type &&
! 318: obj_p->o_which == new_obj_p->o_which)
! 319: return(TRUE);
! 320:
! 321: return(FALSE);
! 322: }
! 323:
! 324: /*
! 325: bff_callable
! 326: Figures out which items can be callable: current rules are:
! 327: potions, scrolls, staffs, and rings.
! 328: */
! 329:
! 330: int
! 331: bff_callable(struct object *obj_p, bag_arg *junk)
! 332: {
! 333: NOOP(junk);
! 334:
! 335: if (obj_p->o_type == POTION || obj_p->o_type == RING ||
! 336: obj_p->o_type == STICK || obj_p->o_type == SCROLL)
! 337: return(TRUE);
! 338:
! 339: return(FALSE);
! 340: }
! 341:
! 342: /*
! 343: bff_markable()
! 344: Selects which items can be marked. Current rules exclude only gold.
! 345: */
! 346:
! 347: int
! 348: bff_markable(struct object *obj_p, bag_arg *junk)
! 349: {
! 350: NOOP(junk);
! 351:
! 352: if (obj_p->o_type == GOLD)
! 353: return(FALSE);
! 354:
! 355: return(TRUE);
! 356: }
! 357:
! 358: /*
! 359: bffron()
! 360: returns TRUE if hero is wearing this ring
! 361: */
! 362:
! 363: int
! 364: bffron(object *obj_p, bag_arg *junk)
! 365: {
! 366: NOOP(junk);
! 367:
! 368: return(cur_ring[LEFT_1] == obj_p || cur_ring[LEFT_2] == obj_p ||
! 369: cur_ring[LEFT_3] == obj_p || cur_ring[LEFT_4] == obj_p ||
! 370: cur_ring[LEFT_5] ||
! 371: cur_ring[RIGHT_1] == obj_p || cur_ring[RIGHT_2] == obj_p ||
! 372: cur_ring[RIGHT_3] == obj_p || cur_ring[RIGHT_4] == obj_p ||
! 373: cur_ring[RIGHT_5]);
! 374: }
! 375:
! 376: /*
! 377: bff_zappable()
! 378: Selects which items can be zapped. This includes both sticks and
! 379: magically enhanced weapons with lightning ability.
! 380: */
! 381:
! 382: int
! 383: bff_zappable(struct object *obj_p, bag_arg *junk)
! 384: {
! 385: NOOP(junk);
! 386:
! 387: if (obj_p->o_type == STICK)
! 388: return(TRUE);
! 389:
! 390: if (obj_p->o_type == WEAPON && obj_p->o_flags & ISZAPPED)
! 391: return(TRUE);
! 392:
! 393: return (FALSE);
! 394: }
! 395:
! 396: /*
! 397: baf_curse()
! 398: Curse all non-artifact items in the player's pack
! 399: */
! 400:
! 401: int
! 402: baf_curse(struct object *obj_p, bag_arg *junk, int id)
! 403: {
! 404: NOOP(junk);
! 405: NOOP(id);
! 406:
! 407: if (obj_p->o_type != ARTIFACT && rnd(8) == 0)
! 408: {
! 409: obj_p->o_flags |= ISCURSED;
! 410: obj_p->o_flags &= ~ISBLESSED;
! 411: }
! 412:
! 413: return(TRUE);
! 414: }
! 415:
! 416: /*
! 417: bafcweapon()
! 418: bag action routine to fetch the current weapon
! 419: */
! 420:
! 421: int
! 422: bafcweapon(struct object *obj_p, bag_arg *junk, int id)
! 423: {
! 424: NOOP(junk);
! 425: NOOP(id);
! 426:
! 427: if (obj_p == cur_weapon)
! 428: return(FALSE); /* found what we wanted - stop and return it */
! 429:
! 430: return(TRUE);
! 431: }
! 432:
! 433: /*
! 434: bafcarmor()
! 435: bag action routine to fetch the current armor
! 436: */
! 437:
! 438: int
! 439: bafcarmor(struct object *obj_p, bag_arg *junk, int id)
! 440: {
! 441: NOOP(junk);
! 442: NOOP(id);
! 443:
! 444: if (obj_p == cur_armor)
! 445: return(FALSE); /* found what we wanted - stop and return it */
! 446:
! 447: return(TRUE);
! 448: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bag.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / urogue