diff -pruN slashem-0.0.7E7F1-official-release/dat/opthelp slashem-0.0.7E7F1-itemcat/dat/opthelp --- slashem-0.0.7E7F1-official-release/dat/opthelp 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/dat/opthelp 2005-10-26 00:40:13.000000000 +0200 @@ -53,6 +53,10 @@ verbose print more commentary dur There are further boolean options controlled by compilation flags. +Boolean option if ITEMCAT was set at compile time: +like_swimming allow category "Items known to be Rustprone" in + selection menus [FALSE] + Boolean option if INSURANCE was set at compile time: checkpoint save game state after each level change, for possible [TRUE] recovery after program crash diff -pruN slashem-0.0.7E7F1-official-release/doc/Guidebook.mn slashem-0.0.7E7F1-itemcat/doc/Guidebook.mn --- slashem-0.0.7E7F1-official-release/doc/Guidebook.mn 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/doc/Guidebook.mn 2005-10-26 00:40:13.000000000 +0200 @@ -1984,6 +1984,8 @@ after you restore, making death permane restore from the last save. (default off). .lp legacy Display an introductory message when starting the game (default on). +.lp like_swimming +Allow category ``Items known to be Rustprone'' in selection menus. .lp lit_corridor Show corridor squares seen by night vision or a light source held by your character as lit (default off). diff -pruN slashem-0.0.7E7F1-official-release/doc/Guidebook.tex slashem-0.0.7E7F1-itemcat/doc/Guidebook.tex --- slashem-0.0.7E7F1-official-release/doc/Guidebook.tex 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/doc/Guidebook.tex 2005-10-26 00:40:13.000000000 +0200 @@ -2716,6 +2716,11 @@ restore from the last save. (default off Display an introductory message when starting the game (default on). %.lp +\item[\ib{like\_swimming}] +Allow category ``Items known to be Rustprone'' in selection menus. +%.lp + + \item[\ib{lit\_corridor}] Show corridor squares seen by night vision or a light source held by your character as lit (default off). diff -pruN slashem-0.0.7E7F1-official-release/include/extern.h slashem-0.0.7E7F1-itemcat/include/extern.h --- slashem-0.0.7E7F1-official-release/include/extern.h 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/include/extern.h 2005-10-26 00:40:13.000000000 +0200 @@ -1590,6 +1590,13 @@ E int FDECL(ck_bag, (struct obj *)); E int FDECL(in_container, (struct obj *)); E int FDECL(out_container, (struct obj *)); #endif +#ifdef ITEMCAT_JP +E void FDECL(jpick_free, (struct obj *)); +#endif +#ifdef ITEMCAT_AP +E int FDECL(is_autopicked, (struct obj *)); +#endif + E int FDECL(pickup, (int)); E int FDECL(pickup_object, (struct obj *, long, BOOLEAN_P)); E int FDECL(query_category, (const char *, struct obj *, int, diff -pruN slashem-0.0.7E7F1-official-release/include/flag.h slashem-0.0.7E7F1-itemcat/include/flag.h --- slashem-0.0.7E7F1-official-release/include/flag.h 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/include/flag.h 2005-10-26 00:40:13.000000000 +0200 @@ -173,6 +173,9 @@ struct flag { */ struct instance_flags { +#ifdef ITEMCAT + boolean like_swimming; /* category r - Items known to be Rustprone */ +#endif /* ITEMCAT */ boolean cbreak; /* in cbreak mode, rogue format */ boolean DECgraphics; /* use DEC VT-xxx extended character set */ boolean echo; /* 1 to echo characters */ diff -pruN slashem-0.0.7E7F1-official-release/include/hack.h slashem-0.0.7E7F1-itemcat/include/hack.h --- slashem-0.0.7E7F1-official-release/include/hack.h 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/include/hack.h 2005-10-26 00:40:13.000000000 +0200 @@ -171,6 +171,16 @@ NEARDATA extern coord bhitpos; /* place #define BUC_UNCURSED 0x200 #define BUC_UNKNOWN 0x400 #define BUC_ALLBKNOWN (BUC_BLESSED|BUC_CURSED|BUC_UNCURSED) +#ifdef ITEMCAT +#define UNIDENTIFIED 0x800 +#define RUSTPRONE 0x1000 +#endif +#ifdef ITEMCAT_JP +#define JUSTPICKED 0x2000 +#endif +#ifdef ITEMCAT_AP +#define AUTOPICKED 0x4000 +#endif #define ALL_TYPES_SELECTED -2 /* Flags to control find_mid() */ diff -pruN slashem-0.0.7E7F1-official-release/include/objclass.h slashem-0.0.7E7F1-itemcat/include/objclass.h --- slashem-0.0.7E7F1-official-release/include/objclass.h 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/include/objclass.h 2005-10-26 00:40:13.000000000 +0200 @@ -69,6 +69,14 @@ struct objclass { /* primary damage: fire/rust/--- */ /* is_flammable(otmp), is_rottable(otmp) in mkobj.c */ #define is_rustprone(otmp) (objects[otmp->otyp].oc_material == IRON) +#ifdef ITEMCAT +/* is rustprone, and rust matters (is displayed in inventory listing) */ +#define is_rustprone2(otmp) (is_rustprone(otmp) && (otmp->oclass==WEAPON_CLASS || otmp->oclass==ARMOR_CLASS || otmp->oclass==TOOL_CLASS || otmp->oclass==WAND_CLASS || otmp->oclass==RING_CLASS || otmp->oclass==BALL_CLASS || otmp->oclass==CHAIN_CLASS)) +/* rustproneness should not be immediately visible */ +#define hide_rust(otmp) ((otmp->otyp==GAUNTLETS_OF_POWER || otmp->otyp==KICKING_BOOTS) && !otmp->oeroded) +/* object is known to be rustprone and is NOT known to be rustproof */ +#define is_known_rustprone(otmp) (is_rustprone2(otmp) && !(otmp->rknown && otmp->oerodeproof) && (!hide_rust(otmp) || objects[otmp->otyp].oc_name_known)) +#endif /* ITEMCAT */ /* secondary damage: rot/acid/acid */ #define is_corrodeable(otmp) (objects[otmp->otyp].oc_material == COPPER || objects[otmp->otyp].oc_material == IRON) diff -pruN slashem-0.0.7E7F1-official-release/include/obj.h slashem-0.0.7E7F1-itemcat/include/obj.h --- slashem-0.0.7E7F1-official-release/include/obj.h 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/include/obj.h 2005-10-26 00:40:13.000000000 +0200 @@ -376,4 +376,21 @@ struct obj { #define CONTAINED_TOO 0x1 #define BURIED_TOO 0x2 +#ifdef ITEMCAT +#ifdef ITEMCAT_OLDSTYLE +# ifdef MAIL +# define BKNOWN(otmp) (otmp->bknown || otmp->otyp == SCR_MAIL) +# else +# define BKNOWN(otmp) (otmp->bknown) +# endif +#else +# define BKNOWN(otmp) (1) +#endif + +/* faster version of not_fully_identified() for item selection + * (invent.c/pickup.c) */ +#define NOT_IDENTIFIED_ITEMCAT(otmp) (otmp->oclass != COIN_CLASS && !(otmp->known && otmp->dknown && BKNOWN(otmp) && objects[otmp->otyp].oc_name_known) || (otmp->oartifact && undiscovered_artifact(otmp->oartifact)) || (!otmp->rknown && ((otmp->oclass == ARMOR_CLASS || otmp->oclass == WEAPON_CLASS || is_weptool(otmp) || otmp->oclass == BALL_CLASS)) && (is_rustprone(otmp) || is_corrodeable(otmp) || is_flammable(otmp)))) + +#endif /* ITEMCAT */ + #endif /* OBJ_H */ diff -pruN slashem-0.0.7E7F1-official-release/src/do.c slashem-0.0.7E7F1-itemcat/src/do.c --- slashem-0.0.7E7F1-official-release/src/do.c 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/src/do.c 2005-10-26 00:40:13.000000000 +0200 @@ -678,7 +678,11 @@ int retry; #endif menu_item *pick_list; boolean all_categories = TRUE; +#ifndef ITEMCAT_NEG boolean drop_everything = FALSE; +#else + int drop_everything = 0; +#endif #ifndef GOLDOBJ if (u.ugold) { @@ -698,18 +702,43 @@ int retry; all_categories = FALSE; n = query_category("Drop what type of items?", invent, - UNPAID_TYPES | ALL_TYPES | CHOOSE_ALL | - BUC_BLESSED | BUC_CURSED | BUC_UNCURSED | BUC_UNKNOWN, + UNPAID_TYPES | ALL_TYPES | CHOOSE_ALL +#ifdef ITEMCAT_JP + | JUSTPICKED +#endif +#ifdef ITEMCAT_AP + | AUTOPICKED +#endif +#ifdef ITEMCAT + | UNIDENTIFIED | RUSTPRONE +#endif + | BUC_BLESSED | BUC_CURSED | BUC_UNCURSED | BUC_UNKNOWN, &pick_list, PICK_ANY); if (!n) goto drop_done; for (i = 0; i < n; i++) { +#ifdef ITEMCAT_NEG + if (pick_list[i].item.a_int == 'Z') + drop_everything|=2; +#endif if (pick_list[i].item.a_int == ALL_TYPES_SELECTED) all_categories = TRUE; else if (pick_list[i].item.a_int == 'A') +#ifndef ITEMCAT_NEG drop_everything = TRUE; +#else + drop_everything|=1; +#endif else add_valid_menu_class(pick_list[i].item.a_int); } +#ifdef ITEMCAT_NEG + switch(drop_everything) { + case 3: + return 0; + case 2: + drop_everything=0; + } +#endif free((genericptr_t) pick_list); } else if (flags.menu_style == MENU_COMBINATION) { unsigned ggoresults = 0; diff -pruN slashem-0.0.7E7F1-official-release/src/invent.c slashem-0.0.7E7F1-itemcat/src/invent.c --- slashem-0.0.7E7F1-official-release/src/invent.c 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/src/invent.c 2005-10-26 00:40:13.000000000 +0200 @@ -609,6 +609,11 @@ void freeinv(obj) register struct obj *obj; { +#ifdef ITEMCAT_JP +/* this is a very uncritical thing so we do it here. if the jpicklist was + * persistent, this should have been in extract_nobj() itself */ + jpick_free(obj); +#endif /* ITEMCAT_JP */ extract_nobj(obj, &invent); freeinv_core(obj); update_inventory(); @@ -2097,6 +2102,21 @@ count_buc(list, type) if (list->oclass != COIN_CLASS && !list->bknown) count++; break; +#ifdef ITEMCAT + case UNIDENTIFIED: + if (NOT_IDENTIFIED_ITEMCAT(list)) + count++; + break; + case RUSTPRONE: + if (list->oclass != COIN_CLASS && is_known_rustprone(list)) + count++; + break; +#endif /* ITEMCAT */ +#ifdef ITEMCAT_AP + case AUTOPICKED: + count+=is_autopicked(list); + break; +#endif default: impossible("need count of curse status %d?", type); return 0; diff -pruN slashem-0.0.7E7F1-official-release/src/options.c slashem-0.0.7E7F1-itemcat/src/options.c --- slashem-0.0.7E7F1-official-release/src/options.c 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/src/options.c 2005-10-26 00:40:13.000000000 +0200 @@ -130,6 +130,9 @@ static struct Bool_Opt #endif {"large_font", &iflags.obsolete, FALSE, SET_IN_FILE}, /* OBSOLETE */ {"legacy", &flags.legacy, TRUE, DISP_IN_GAME}, +#ifdef ITEMCAT + {"like_swimming", &iflags.like_swimming, FALSE, SET_IN_GAME}, +#endif /* ITEMCAT */ {"lit_corridor", &flags.lit_corridor, FALSE, SET_IN_GAME}, {"lootabc", &iflags.lootabc, FALSE, SET_IN_GAME}, #ifdef MAC_GRAPHICS_ENV diff -pruN slashem-0.0.7E7F1-official-release/src/pickup.c slashem-0.0.7E7F1-itemcat/src/pickup.c --- slashem-0.0.7E7F1-official-release/src/pickup.c 2005-07-02 09:24:44.000000000 +0200 +++ slashem-0.0.7E7F1-itemcat/src/pickup.c 2005-10-26 00:40:13.000000000 +0200 @@ -38,6 +38,14 @@ STATIC_DCL int FDECL(container_at, (int, STATIC_DCL boolean FDECL(able_to_loot, (int, int)); STATIC_DCL boolean FDECL(mon_beside, (int, int)); +#ifdef ITEMCAT_JP +char *ctg_justpicked="Items just Picked up"; +char *ctg_justremoved="Items just taken out"; +char **jpick_ctg=&ctg_justpicked; +STATIC_PTR int FDECL(is_justpicked,(struct obj *)); +#define DESTROY_JPICK(j) while(*(j)) { struct jpick *next=(*(j))->next_pick; free((genericptr_t) *(j)); *(j)=next; } +#endif + /* define for query_objlist() and autopickup() */ #define FOLLOW(curr, flags) \ (((flags) & BY_NEXTHERE) ? (curr)->nexthere : (curr)->nobj) @@ -93,6 +101,61 @@ boolean here; /* flag for type of obj l } } +#ifdef ITEMCAT_AP +int +is_autopicked(obj) +register struct obj *obj; +{ + const char *otypes = flags.pickup_types; +#ifndef AUTOPICKUP_EXCEPTIONS + if (!*otypes || index(otypes, obj->oclass)) +#else + if ((!*otypes || index(otypes, obj->oclass) || + is_autopickup_exception(obj, TRUE)) && + !is_autopickup_exception(obj, FALSE)) +#endif + return 1; + return 0; +} +#endif /* ITEMCAT_AP */ +#ifdef ITEMCAT_JP +/* just picked items llist */ +struct jpick { + struct obj *o; + struct jpick *next_pick; +}; +static NEARDATA struct jpick *jpick_head=(struct jpick *)0; +STATIC_PTR int +is_justpicked(obj) +register struct obj *obj; +{ + struct jpick *list=jpick_head; + while(list) { + if(obj==list->o) + return 1; + list=list->next_pick; + } + return 0; +} +void +jpick_free(obj) +register struct obj *obj; +{ + struct jpick **p=&jpick_head; + struct jpick *next; + + while(*p) { + next=(*p)->next_pick; + if(obj==(*p)->o) { + free((genericptr_t) *p); + *p=next; + break; + } + p=&(*p)->next_pick; + } +} +#endif /* ITEMCAT_JP */ + #ifndef GOLDOBJ int collect_obj_classes(ilets, otmp, here, incl_gold, filter, itemcount) @@ -330,24 +393,53 @@ boolean allow_category(obj) struct obj *obj; { +#ifdef ITEMCAT_NEG + int result=0; + int itemcat_negate=(index(valid_menu_classes,'Z') != (char *)0); +#define Return result = +#else +#define Return return +#endif if (Role_if(PM_PRIEST)) obj->bknown = TRUE; if (((index(valid_menu_classes,'u') != (char *)0) && obj->unpaid) || (index(valid_menu_classes, obj->oclass) != (char *)0)) - return TRUE; + Return TRUE; else if (((index(valid_menu_classes,'U') != (char *)0) && (obj->oclass != COIN_CLASS && obj->bknown && !obj->blessed && !obj->cursed))) - return TRUE; + Return TRUE; else if (((index(valid_menu_classes,'B') != (char *)0) && (obj->oclass != COIN_CLASS && obj->bknown && obj->blessed))) - return TRUE; + Return TRUE; else if (((index(valid_menu_classes,'C') != (char *)0) && (obj->oclass != COIN_CLASS && obj->bknown && obj->cursed))) - return TRUE; + Return TRUE; else if (((index(valid_menu_classes,'X') != (char *)0) && (obj->oclass != COIN_CLASS && !obj->bknown))) - return TRUE; + Return TRUE; +#ifdef ITEMCAT + else if (((index(valid_menu_classes,'I') != (char *)0) && + NOT_IDENTIFIED_ITEMCAT(obj))) + Return TRUE; + else if (((index(valid_menu_classes,'r') != (char *)0) && + (obj->oclass != COIN_CLASS && is_known_rustprone(obj)))) + Return TRUE; +#endif /* ITEMCAT */ +#ifdef ITEMCAT_JP + else if (((index(valid_menu_classes,'P') != (char *)0) && + (is_justpicked(obj)))) + Return TRUE; +#endif +#ifdef ITEMCAT_AP + else if (((index(valid_menu_classes,'Q') != (char *)0) && + (is_autopicked(obj)))) + Return TRUE; +#endif else - return FALSE; + Return FALSE; +#ifdef ITEMCAT_NEG + return itemcat_negate?(!result):result; +#undef Return +#endif } #if 0 /* not used */ @@ -396,6 +488,9 @@ int what; /* should be a long */ boolean autopickup = what > 0; struct obj *objchain; int traverse_how; +#ifdef ITEMCAT_JP + struct jpick *jtmp=jpick_head; +#endif if (what < 0) /* pick N of something */ count = -what; @@ -449,6 +544,10 @@ int what; /* should be a long */ if (OBJ_AT(u.ux,u.uy) && flags.run && flags.run != 8 && !flags.nopick) nomul(0); } +#ifdef ITEMCAT_JP + jpick_head=(struct jpick *) 0; +#endif + add_valid_menu_class(0); /* reset */ if (!u.uswallow) { objchain = level.objects[u.ux][u.uy]; @@ -534,7 +633,19 @@ menu_pickup: FALSE, #endif &via_menu)) { - if (!via_menu) return (0); + if (!via_menu) +#ifdef ITEMCAT_JP + { + if(jpick_head) { + jpick_ctg=&ctg_justpicked; + DESTROY_JPICK(&jtmp) + } else + jpick_head=jtmp; + return (0); + } +#else + return (0); +#endif /* ITEMCAT_JP */ n = query_objlist("Pick up what?", objchain, traverse_how|(selective ? 0 : INVORDER_SORT), @@ -598,6 +709,13 @@ end_query: /* see whether there's anything else here, after auto-pickup is done */ if (autopickup) check_here(n_picked > 0); } +#ifdef ITEMCAT_JP + if(jpick_head) { + jpick_ctg=&ctg_justpicked; + DESTROY_JPICK(&jtmp) + } else + jpick_head=jtmp; +#endif return (n_tried > 0); } @@ -808,6 +926,19 @@ int how; /* type of query */ boolean collected_type_name; char invlet; int ccount; +#ifdef ITEMCAT + boolean do_unident = FALSE; + boolean do_rustprone = FALSE; +#endif +#ifdef ITEMCAT_JP + boolean do_justpicked = FALSE; +#endif +#ifdef ITEMCAT_AP + boolean do_autopicked = FALSE; +#endif +#ifdef ITEMCAT_NEG + boolean do_invsel = FALSE; +#endif boolean do_unpaid = FALSE; boolean do_blessed = FALSE, do_cursed = FALSE, do_uncursed = FALSE, do_buc_unknown = FALSE; @@ -833,6 +964,27 @@ int how; /* type of query */ num_buc_types++; } +#ifdef ITEMCAT + if ((qflags & UNIDENTIFIED) && count_buc(olist, UNIDENTIFIED)) + do_unident = TRUE; + + if (iflags.like_swimming && (qflags & RUSTPRONE) && count_buc(olist, RUSTPRONE)) + do_rustprone = TRUE; + +#endif +#ifdef ITEMCAT_JP + if ((qflags & JUSTPICKED) && jpick_head!=(struct jpick *) 0) + do_justpicked = TRUE; +#endif +#ifdef ITEMCAT_AP + if ((qflags & AUTOPICKED) && count_buc(olist, AUTOPICKED)) + do_autopicked = TRUE; +#endif +#ifdef ITEMCAT_NEG + if (how!=PICK_ONE) + do_invsel = TRUE; +#endif + ccount = count_categories(olist, qflags); /* no point in actually showing a menu for a single category */ if (ccount == 1 && !do_unpaid && num_buc_types <= 1 && !(qflags & BILLED_TYPES)) { @@ -917,6 +1069,48 @@ int how; /* type of query */ "Auto-select every item being worn" : "Auto-select every item", MENU_UNSELECTED); } +#ifdef ITEMCAT_JP + if (do_justpicked) { + invlet = 'P'; + any.a_void = 0; + any.a_int = 'P'; + add_menu(win, NO_GLYPH, &any, invlet, 0, ATR_NONE, + *jpick_ctg, + MENU_UNSELECTED); + } +#endif /*ITEMCAT_JP*/ +#ifdef ITEMCAT + if (do_unident) { + invlet = 'I'; + any.a_void = 0; + any.a_int = 'I'; + add_menu(win, NO_GLYPH, &any, invlet, 0, ATR_NONE, + "Unidentified Items", + MENU_UNSELECTED); + } +#endif /* ITEMCAT */ +#ifdef ITEMCAT_AP + if (do_autopicked) { + invlet = 'Q'; + any.a_void = 0; + any.a_int = 'Q'; + add_menu(win, NO_GLYPH, &any, invlet, 0, ATR_NONE, + "Auto-picked items", + MENU_UNSELECTED + ); + } +#endif /* ITEMCAT_AP */ +#ifdef ITEMCAT_NEG + if (do_invsel) { + invlet = 'Z'; + any.a_void = 0; + any.a_int = 'Z'; + add_menu(win, NO_GLYPH, &any, invlet, 0, ATR_NONE, + "Inverse selection", + MENU_UNSELECTED + ); + } +#endif /* ITEMCAT_AP */ /* items with b/u/c/unknown if there are any */ if (do_blessed) { invlet = 'B'; @@ -947,6 +1141,16 @@ int how; /* type of query */ "Items of unknown B/C/U status", MENU_UNSELECTED); } +#ifdef ITEMCAT + if (iflags.like_swimming && do_rustprone) { + invlet = 'r'; + any.a_void = 0; + any.a_int = 'r'; + add_menu(win, NO_GLYPH, &any, invlet, 0, ATR_NONE, + "Items known to be Rustprone", + MENU_UNSELECTED); + } +#endif /* ITEMCAT */ end_menu(win, qstr); n = select_menu(win, how, pick_list); destroy_nhwindow(win); @@ -1386,6 +1590,9 @@ struct obj * pick_obj(otmp) struct obj *otmp; { +#ifdef ITEMCAT_JP + struct jpick *pick; +#endif obj_extract_self(otmp); if (!u.uswallow && otmp != uball && costly_spot(otmp->ox, otmp->oy)) { char saveushops[5], fakeshop[2]; @@ -1409,7 +1616,18 @@ struct obj *otmp; if (otmp->was_thrown) /* likewise */ otmp->was_thrown = 0; newsym(otmp->ox, otmp->oy); - return addinv(otmp); /* might merge it with other objects */ +#ifdef ITEMCAT_JP + otmp=addinv(otmp); /* might merge it with other objects */ + if(otmp->oclass!=COIN_CLASS) { + pick=(struct jpick *) alloc(sizeof(struct jpick)); + pick->next_pick=jpick_head; + pick->o=otmp; + jpick_head=pick; + } + return otmp; +#else + return addinv(otmp); +#endif /* ITEMCAT_JP */ } /* @@ -2044,6 +2262,9 @@ register struct obj *obj; boolean is_gold = (obj->oclass == COIN_CLASS); int res, loadlev; long count; +#ifdef ITEMCAT_JP + struct jpick *pick; +#endif if (!current_container) { impossible(" no current_container?"); @@ -2099,6 +2320,14 @@ register struct obj *obj; verbalize("You sneaky cad! Get out of here with that pick!"); otmp = addinv(obj); +#ifdef ITEMCAT_JP + if(!is_gold) { + pick=(struct jpick *) alloc(sizeof(struct jpick)); + pick->next_pick=jpick_head; + pick->o=otmp; + jpick_head=pick; + } +#endif loadlev = near_capacity(); prinv(loadlev ? (loadlev < MOD_ENCUMBER ? @@ -2335,6 +2564,14 @@ ask_again2: FALSE, #endif &menu_on_request)) { +#ifdef ITEMCAT_JP + /* normally one wouldn't use traditional + itemcat_jp, + * so we don't make extra checks whether something + * relevant was in fact picked up, just destroy the + * list for consistency. */ + jpick_ctg=&ctg_justremoved; + DESTROY_JPICK(&jpick_head) +#endif if (askchain((struct obj **)¤t_container->cobj, (one_by_one ? (char *)0 : select), allflag, out_container, @@ -2464,14 +2701,33 @@ boolean put_in; menu_item *pick_list; int mflags, res; long count; +#ifdef ITEMCAT_JP + struct jpick *jtmp; +#endif if (retry) { all_categories = (retry == -2); } else if (flags.menu_style == MENU_FULL) { all_categories = FALSE; Sprintf(buf,"%s what type of objects?", put_in ? putin : takeout); - mflags = put_in ? ALL_TYPES | BUC_ALLBKNOWN | BUC_UNKNOWN : - ALL_TYPES | CHOOSE_ALL | BUC_ALLBKNOWN | BUC_UNKNOWN; + mflags = put_in ? ALL_TYPES | BUC_ALLBKNOWN | BUC_UNKNOWN +#ifdef ITEMCAT_JP + | JUSTPICKED +#endif +#ifdef ITEMCAT_AP + | AUTOPICKED +#endif +#ifdef ITEMCAT + | UNIDENTIFIED | RUSTPRONE +#endif + : ALL_TYPES | CHOOSE_ALL | BUC_ALLBKNOWN | BUC_UNKNOWN +#ifdef ITEMCAT + | UNIDENTIFIED | RUSTPRONE +#endif +#ifdef ITEMCAT_AP + | AUTOPICKED +#endif + ; n = query_category(buf, put_in ? invent : container->cobj, mflags, &pick_list, PICK_ANY); if (!n) return 0; @@ -2487,11 +2743,26 @@ boolean put_in; } if (loot_everything) { +#ifdef ITEMCAT_NEG + if(index(valid_menu_classes,'Z') != (char *)0) + return 0; +#endif +#ifdef ITEMCAT_JP + jtmp=jpick_head; + jpick_head=(struct jpick *) 0; +#endif for (otmp = container->cobj; otmp; otmp = otmp2) { otmp2 = otmp->nobj; res = out_container(otmp); if (res < 0) break; } +#ifdef ITEMCAT_JP + if(jpick_head) { + jpick_ctg=&ctg_justremoved; + DESTROY_JPICK(&jtmp) + } else + jpick_head=jtmp; +#endif } else { mflags = INVORDER_SORT; if (put_in && flags.invlet_constant) mflags |= USE_INVLET; @@ -2501,6 +2772,12 @@ boolean put_in; all_categories ? allow_all : allow_category); if (n) { n_looted = n; +#ifdef ITEMCAT_JP + if(!put_in) { + jtmp=jpick_head; + jpick_head=(struct jpick *) 0; + } +#endif for (i = 0; i < n; i++) { otmp = pick_list[i].item.a_obj; count = pick_list[i].count; @@ -2521,6 +2798,15 @@ boolean put_in; break; } } +#ifdef ITEMCAT_JP + if(!put_in) { + if(jpick_head) { + jpick_ctg=&ctg_justremoved; + DESTROY_JPICK(&jtmp) + } else + jpick_head=jtmp; + } +#endif free((genericptr_t)pick_list); } }