/*

pack.c - Routines to deal with the pack.

UltraRogue: The Ultimate Adventure in the Dungeons of Doom

Copyright (C) 1985, 1986, 1992, 1993, 1995 Herb Chong

All rights reserved.

Based on "Advanced Rogue"

Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka

All rights reserved.

Based on "Rogue: Exploring the Dungeons of Doom"

Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman

All rights reserved.

See the file LICENSE.TXT for full copyright and licensing information.

*/

/*

Notes

The new pack is implemented through the use of bags,

and items are classed by their types (see rogue.h) which also

happen to be their display character.

*/

#include <stdlib.h>

#include <ctype.h>

#include "rogue.h"

#define ESCAPE_EXIT(x) if (x == ESCAPE) {after = FALSE; msg(""); return(NULL);}

#define BAD_NEWS -1

#define BAD_LIST ((struct linked_list *) BAD_NEWS)

#define GOOD_NEWS 0

static char type_list[] = "!?])/=:,"; /* things to inventory */

/*

swap_top()

Takes an stacked object and exchanges places with the top

object. <node> must belong to the <top>'s stacked object list.

*/

void

swap_top(struct linked_list *top, struct linked_list *node)

{

struct object *obt, *obn;

obt = OBJPTR(top);

obn = OBJPTR(node);

detach((obt->next_obj), node); /* Take it out of the stack */

attach(lvl_obj, node); /* and put it into the level */

detach(lvl_obj, top); /* Remove item from level */

obn->next_obj = obt->next_obj;

if (obn->next_obj)

obn->next_obj->l_prev = NULL;

attach((obn->next_obj), top);

}

/*

get_all()

Get as many stacked items as possible.

*/

void

get_all(struct linked_list *top)

{

struct linked_list *node;

struct object *obt;

while (top)

{

obt = OBJPTR(top);

node = obt->next_obj;

rem_obj(top, FALSE);

if (!add_pack(top, FALSE))

return;

top = node;

}

}

/*

get_stack()

Allows the user to chose from a stack of items.

*/

struct linked_list *

get_stack(struct linked_list *item)

{

struct object *obj;

char buf[2 * LINELEN];

int i = 0, j;

struct linked_list *ll;

mpos = 0;

obj = OBJPTR(item);

ll = obj->next_obj;

sprintf(buf, "You are standing on top of the following items: ");

add_line(buf);

sprintf(buf, "%d) -- %s", i, inv_name(obj, TRUE));

add_line(buf);

while (ll)

{

i++;

obj = OBJPTR(ll);

sprintf(buf, "%d) -- %s", i, inv_name(obj, TRUE));

add_line(buf);

ll = next(ll);

}

end_line();

msg("Which one do you want to pick up? [* for all] ");

switch(get_string(buf, cw))

{

case NORM:

break;

case QUIT: /* pick up nothing */

msg("");

return (NULL);

}

if (buf[0] == '*')

{

get_all(item);

msg("");

return(NULL);

}

else

{

i = atoi(buf);

if (i)

{

obj = OBJPTR(item);

ll = obj->next_obj;

j = 1;

while (ll && (j != i))

{

ll = next(ll);

j++;

}

if (ll)

{

swap_top(item, ll);

return(ll);

}

else

{

debug("Got past last item while picking up.");

return(item);

}

}

else

return (item);

}

}

/*

add_pack()

Pick up an object and add it to the pack. If the argument is

non-null use it as the linked_list pointer instead of getting it off the

ground.

*/

int

add_pack(struct linked_list *item, int print_message)

{

struct object *obj, *op;

int from_floor;

if (item == NULL)

{

from_floor = TRUE;

if ((item = find_obj(hero.y, hero.x)) == NULL)

{

msg("Nothing to pick up.");

return(FALSE);

}

}

else

from_floor = FALSE;

if (from_floor)

{

item = get_stack(item);

if (!item)

return(FALSE);

}

obj = OBJPTR(item);

/* If it is gold, just add its value to rogue's purse and get rid of */

if (obj->o_type == GOLD)

{

struct linked_list *mitem;

struct thing *tp;

if (print_message)

{

if (!terse)

addmsg("You found ");

msg("%d gold pieces.", obj->o_count);

}

/*

* First make sure no greedy monster is after this gold. If

* so, make the monster run after the rogue instead.

*/

for (mitem = mlist; mitem != NULL; mitem = next(mitem))

{

tp = THINGPTR(mitem);

if (tp->t_horde==obj)

{

tp->t_ischasing = TRUE;

tp->t_chasee = &player;

tp->t_horde = NULL;

}

}

/*

* This will cause problems if people are able to drop and

* pick up gold, or when GOLDSTEAL monsters are killed.

*/

/* Thieves get EXP for gold they pick up */

if (player.t_ctype == C_THIEF)

{

pstats.s_exp += obj->o_count / 4;

check_level();

}

purse += obj->o_count;

if (from_floor)

rem_obj(item, TRUE); /* Remove object from the level */

return (TRUE);

}

/* see if he can carry any more weight */

if (itemweight(obj) + pstats.s_pack > pstats.s_carry)

{

msg("Too much for you to carry.");

if (print_message)

{

msg("%s onto %s", terse ? "Moved" : "You moved",

inv_name(obj, LOWERCASE));

}

return(FALSE);

}

/*

* Link it into the pack. If the item can be grouped, try to find its

* neighbors and bump the count. A special case is food, which can't

* be grouped, but an exact match allows the count to get

* incremented.

*/

if ((op = apply_to_bag(pack, obj->o_type, bff_group, NULL, obj)) != NULL)

{

op->o_count += obj->o_count; /* add it to the rest */

if (from_floor)

rem_obj(item, FALSE);

pack_report(op, print_message, "You now have ");

return(TRUE);

}

/* Check for and deal with scare monster scrolls */

if (obj->o_type == SCROLL && obj->o_which == S_SCARE)

if (obj->o_flags & ISCURSED)

{

msg("The scroll turns to dust as you pick it up.");

rem_obj(item, TRUE);

return(TRUE);

}

/* Check if there is room */

if (count_bag(pack, obj->o_type, NULL) == max_print())

{

msg("You have no room for more %s.", name_type(obj->o_type));

if (print_message)

{

obj = OBJPTR(item);

msg("%s onto %s.", terse ? "Moved" : "You moved",

inv_name(obj, LOWERCASE));

}

return(FALSE);

}

/*

* finally, add the new item to the bag, and free up the linked list

* on top of it.

*/

if (from_floor)

rem_obj(item, FALSE);

push_bag(&pack, obj);

pack_report(obj, print_message, "You now have ");

ur_free(item);

return(TRUE); /* signal success */

}

/*

pack_report()

Notify the user about the results of the pack operation and do some

post processing.

*/

void

pack_report(object *obj, int print_message, char *message)

{

/* Notify the user */

if (print_message)

{

if (!terse)

addmsg(message);

msg("(%c%c) %s.", obj->o_type, print_letters[get_ident(obj)],

inv_name(obj, !terse));

}

if (obj->o_type == ARTIFACT)

{

has_artifact |= (1 << obj->o_which);

picked_artifact |= (1 << obj->o_which);

if (!(obj->ar_flags & ISUSED))

{

obj->ar_flags |= ISUSED;

pstats.s_exp += arts[obj->o_which].ar_worth / 10;

check_level();

}

}

updpack();

return;

}

/*

inventory()

list what is in the pack

*/

void

inventory(struct linked_list *container, int type)

{

int cnt;

if (type == 0)

{

msg("What kind of item <%s> to inventory (* for all)?", type_list);

type = readchar();

if (type == ESCAPE)

{

after = FALSE;

msg("");

return;

}

}

/*

* Get a list of items to print out. If the user selects '*', list

* them all.

*/

if (type == '*')

type = 0; /* no type passed ->use them all */

mpos = 0;

if ((cnt = count_bag(container, type, NULL)) == 0)

msg("You don't have any %s.", name_type(type));

else

{

apply_to_bag(container, type, NULL, baf_print_item, &type);

end_line();

msg("");

}

return;

}

/*

pick_up()

Add something to characters pack.

*/

void

pick_up(char ch)

{

switch(ch)

{

default:

debug("Where did you pick that up???");

break;

case GOLD:

case ARMOR:

case POTION:

case FOOD:

case WEAPON:

case SCROLL:

case ARTIFACT:

case RING:

case STICK:

add_pack(NULL, MESSAGE);

break;

}

}

/*

get_object()

Pick something out of a pack for a purpose. The basic idea is to

list all the possibilities, let the user select one, get that item

from the container, and pass it back to the calling routine.

*/

struct object *

get_object(struct linked_list *container, char *purpose, int type, int (*bff_p)(struct object *obj, bag_arg *junk))

/* char *container; what container has what we want */

/* char *purpose; a message (verb) to print if we cant find any */

/* char type; type (o_type) to pick out (NULL = any) */

/* int (*bff_p) (); bag filter function to test item */

{

struct object *obj_p = NULL;

char sel_id; /* selected type and id */

int sel_type;

char response;

if (container == NULL)

{

msg("There isn't anything in there.");

after = FALSE;

return(NULL);

}

/* Make sure we have at least one item that qualifies! */

if (apply_to_bag(container, type, bff_p, NULL, NULL) == NULL)

{

msg("You seem to have nothing to %s.", purpose);

after = FALSE;

return(NULL);

}

while (obj_p == NULL)

{

if (type == 0)

{

msg("What kind of item <%s> do you want to %s (* for list)?", type_list, purpose);

response = readchar();

ESCAPE_EXIT(response);

msg("");

if (response == '*')

{

add_line("! Potion");

add_line("? Scroll");

add_line("= Ring");

add_line("/ Stick");

add_line("] Armor");

add_line(") Weapon");

add_line(": Food");

end_line();

continue;

}

if (!is_member(type_list, response)) { beep();

continue; }

if (count_bag(container, response, NULL) == 0)

{

msg("You don't have any %s.", name_type(response));

continue;

}

type = response;

}

while(obj_p == NULL)

{

msg("What item do you want to %s (* for list)?", purpose);

response = readchar();

msg("");

ESCAPE_EXIT(response);

if (response == '*')

{

mpos = 0;

apply_to_bag(container, type, bff_p, baf_print_item, &type);

end_line();

continue;

}

sel_type = type;

sel_id = response;

obj_p = scan_bag(container, sel_type,unprint_id(&sel_id));

}

}

mpos = 0;

msg("");

return(obj_p);

}

/*

get_item()

This is only an interim function that serves as an interface to

the old function get_item and its replacement get_object. It

assumes a NULL action routine and allocates a linked_list

structure on top of the object pointer.

*/

struct linked_list *

get_item(char *purpose, int type)

{

struct object *obj_p;

if ((obj_p = get_object(pack, purpose, type, NULL)) == NULL)

return(NULL);

return(make_item(obj_p));

}

/*

del_pack()

Take something out of the hero's pack and throw it away.

*/

void

del_pack(struct linked_list *what)

{

rem_pack(OBJPTR(what));

discard(what);

}

/*

discard_pack

take an object from the pack and throw it away (like del_pack,

but without the linked_list structure)

*/

void

discard_pack(struct object *obj_p)

{

rem_pack(obj_p);

throw_away(obj_p);

}

/*

rem_pack()

Removes an item from the pack.

*/

void

rem_pack(struct object *obj_p)

{

cur_null(obj_p); /* check for current stuff */

pop_bag(&pack, obj_p);

updpack();

return; /* tell caller an item has been removed */

}

/*

cur_null()

This updates cur_weapon etc for dropping things

*/

void

cur_null(struct object *op)

{

if (op == cur_weapon)

cur_weapon = NULL;

else if (op == cur_armor)

cur_armor = NULL;

else if (op == cur_ring[LEFT_1])

cur_ring[LEFT_1] = NULL;

else if (op == cur_ring[LEFT_2])

cur_ring[LEFT_2] = NULL;

else if (op == cur_ring[LEFT_3])

cur_ring[LEFT_3] = NULL;

else if (op == cur_ring[LEFT_4])

cur_ring[LEFT_4] = NULL;

else if (op == cur_ring[LEFT_5])

cur_ring[LEFT_5] = NULL;

else if (op == cur_ring[RIGHT_1])

cur_ring[RIGHT_1] = NULL;

else if (op == cur_ring[RIGHT_2])

cur_ring[RIGHT_2] = NULL;

else if (op == cur_ring[RIGHT_3])

cur_ring[RIGHT_3] = NULL;

else if (op == cur_ring[RIGHT_4])

cur_ring[RIGHT_4] = NULL;

else if (op == cur_ring[RIGHT_5])

cur_ring[RIGHT_5] = NULL;

}

/*

idenpack()

Identify all the items in the pack

*/

void

idenpack(void)

{

apply_to_bag(pack, 0, NULL, baf_identify, NULL);

}

/*

show_floor()

Print out the item on the floor. Used by the move command.

*/

void

show_floor(void)

{

struct linked_list *item;

struct object *obj;

item = find_obj(hero.y, hero.x);

if (item != NULL)

{

addmsg("%s onto ", terse ? "Moved" : "You moved");

obj = OBJPTR(item);

if (obj->next_obj != NULL)

msg("a stack of things.");

else if (obj->o_type == GOLD)

msg("%d gold pieces.", obj->o_count);

else

{

addmsg(inv_name(obj, TRUE));

addmsg(".");

endmsg();

}

}

}