void
shopping_list(char *arg, struct char_data *ch,
struct char_data * keeper, int shop_nr)
{
char buf[MAX_STRING_LENGTH], name[MAX_INPUT_LENGTH];
struct obj_data *obj, *last_obj = 0;
int cnt = 0, index = 0;
bool found = FALSE;
if (!(is_ok(keeper, ch, shop_nr)))
return;
if (SHOP_SORT(shop_nr) < IS_CARRYING_N(keeper))
sort_keeper_objs(keeper, shop_nr);
one_argument(arg, name);
strcpy(buf, " ## Available Item Cost\n\r");
strcat(buf, "-------------------------------------------------------------------------\n\r");
if (keeper->carrying)
for (obj = keeper->carrying; obj; obj = obj->next_content)
if (CAN_SEE_OBJ(ch, obj) && (obj->obj_flags.cost > 0))
{
if (!last_obj)
{
last_obj = obj;
cnt = 1;
}
else if (same_obj(last_obj, obj))
cnt++;
else {
index++;
if (!(*name) || isname(name, last_obj->name))
{
strcat(buf, list_object(ch, last_obj, cnt, index, shop_nr));
found = TRUE;
}
cnt = 1;
last_obj = obj;
}
}
index++;
if (!last_obj)
stc("Currently, there is nothing for sale.\r\n", ch);
else if (*name && !found)
stc("Presently, none of those are for sale.\r\n", ch);
else {
if (!(*name) || isname(name, last_obj->name))
strcat(buf, list_object(ch, last_obj, cnt, index, shop_nr));
page_string(ch->desc, buf, 1);
}
}
void *
list_tail(list_t *list)
{
if (list_empty(list))
return (NULL);
return (list_object(list, list->list_head.list_prev));
}
void *
list_head(list_t *list)
{
if (list_empty(list))
return (NULL);
return (list_object(list, list->list_head.list_next));
}
/**
* Place a random object at (x, y).
* \param c current chunk
* \param y co-ordinates
* \param x co-ordinates
* \param level generation depth
* \param good is it a good object?
* \param great is it a great object?
* \param origin item origin
* \param tval specified tval, if any
*/
void place_object(struct chunk *c, int y, int x, int level, bool good,
bool great, byte origin, int tval)
{
s32b rating = 0;
struct object *new_obj;
bool dummy = true;
if (!square_in_bounds(c, y, x)) return;
if (!square_canputitem(c, y, x)) return;
/* Make an appropriate object */
new_obj = make_object(c, level, good, great, false, &rating, tval);
if (!new_obj) return;
new_obj->origin = origin;
new_obj->origin_depth = c->depth;
/* Give it to the floor */
if (!floor_carry(c, y, x, new_obj, &dummy)) {
if (new_obj->artifact) {
new_obj->artifact->created = false;
}
object_delete(&new_obj);
return;
} else {
list_object(c, new_obj);
if (new_obj->artifact) {
c->good_item = true;
}
/* Avoid overflows */
if (rating > 2500000) {
rating = 2500000;
}
c->obj_rating += (rating / 100) * (rating / 100);
}
}
int list_and_get(const Json::Value& list, const bool withNumbers, string * const retVal, const bool listKeys, const vector<string> keys, const bool displayObjectKeysInsideArray) {
list_object(list, withNumbers, listKeys, keys, displayObjectKeysInsideArray);
if (retVal != NULL) {
int ret = -1;
cout << endl << "Select an option from the list above (press 0 to exit): ";
cin >> ret;
while (ret > list.size() || ret < 0) {
cout << "Invalid option!" << endl;
cout << "Select an option from the list above (press 0 to exit): ";
cin >> ret;
}
//the user has signaled to exit
if (ret == 0)
return 1;
//Increment the iterator to the desired position
Value::iterator iterator = list.begin();
for (int i = 0; i < ret - 1; i++)
iterator++;
//Figure out how to return the object appropriately.
if (list.isObject())
*retVal = iterator->asString();
else if (list.isArray())
*retVal = to_string(ret - 1);
else
return 2;
return 0;
}
/**
* Let the floor carry an object, deleting old ignored items if necessary.
* The calling function must deal with the dropped object on failure.
*
* Optionally put the object at the top or bottom of the pile
*/
bool floor_carry(struct chunk *c, int y, int x, struct object *drop, bool last)
{
int n = 0;
struct object *obj, *ignore = floor_get_oldest_ignored(y, x);
/* Fail if the square can't hold objects */
if (!square_isobjectholding(c, y, x))
return false;
/* Scan objects in that grid for combination */
for (obj = square_object(c, y, x); obj; obj = obj->next) {
/* Check for combination */
if (object_similar(obj, drop, OSTACK_FLOOR)) {
/* Combine the items */
object_absorb(obj, drop);
/* Result */
return true;
}
/* Count objects */
n++;
}
/* The stack is already too large */
if (n >= z_info->floor_size || (!OPT(player, birth_stacking) && n)) {
/* Delete the oldest ignored object */
if (ignore) {
square_excise_object(c, y, x, ignore);
delist_object(c, ignore);
object_delete(&ignore);
} else
return false;
}
/* Location */
drop->iy = y;
drop->ix = x;
/* Forget monster */
drop->held_m_idx = 0;
/* Link to the first or last object in the pile */
if (last)
pile_insert_end(&c->squares[y][x].obj, drop);
else
pile_insert(&c->squares[y][x].obj, drop);
/* Record in the level list */
list_object(c, drop);
/* Redraw */
square_note_spot(c, y, x);
square_light_spot(c, y, x);
/* Result */
return true;
}
void *
list_remove_tail(list_t *list)
{
list_node_t *tail = list->list_head.list_prev;
if (tail == &list->list_head)
return (NULL);
list_remove_node(tail);
return (list_object(list, tail));
}
void *
list_remove_head(list_t *list)
{
list_node_t *head = list->list_head.list_next;
if (head == &list->list_head)
return (NULL);
list_remove_node(head);
return (list_object(list, head));
}
void *
list_prev(list_t *list, void *object)
{
list_node_t *node = list_d2l(list, object);
if (node->list_prev != &list->list_head)
return (list_object(list, node->list_prev));
return (NULL);
}
/**
* Creates the onbject a mimic is imitating.
*/
void mon_create_mimicked_object(struct chunk *c, struct monster *mon, int index)
{
struct object *obj;
struct object_kind *kind = mon->race->mimic_kinds->kind;
struct monster_mimic *mimic_kind;
int i = 1;
bool dummy = true;
/* Pick a random object kind to mimic */
for (mimic_kind = mon->race->mimic_kinds;
mimic_kind;
mimic_kind = mimic_kind->next, i++) {
if (one_in_(i)) {
kind = mimic_kind->kind;
}
}
if (tval_is_money_k(kind)) {
obj = make_gold(player->depth, kind->name);
} else {
obj = object_new();
object_prep(obj, kind, mon->race->level, RANDOMISE);
apply_magic(obj, mon->race->level, true, false, false, false);
obj->number = 1;
obj->origin = ORIGIN_DROP_MIMIC;
obj->origin_depth = player->depth;
}
obj->mimicking_m_idx = index;
mon->mimicked_obj = obj;
/* Put the object on the floor if it goes, otherwise no mimicry */
if (floor_carry(c, mon->fy, mon->fx, obj, &dummy)) {
list_object(c, obj);
} else {
/* Clear the mimicry */
obj->mimicking_m_idx = 0;
mon->mimicked_obj = NULL;
/* Give the object to the monster if appropriate */
if (rf_has(mon->race->flags, RF_MIMIC_INV)) {
monster_carry(c, mon, obj);
} else {
/* Otherwise delete the mimicked object */
object_delete(&obj);
}
}
}
/**
* Place a random amount of gold at (x, y).
* \param c current chunk
* \param y co-ordinates
* \param x co-ordinates
* \param level generation depth
* \param origin item origin
*/
void place_gold(struct chunk *c, int y, int x, int level, byte origin)
{
struct object *money = NULL;
bool dummy = true;
if (!square_in_bounds(c, y, x)) return;
if (!square_canputitem(c, y, x)) return;
money = make_gold(level, "any");
money->origin = origin;
money->origin_depth = level;
if (!floor_carry(c, y, x, money, &dummy)) {
object_delete(&money);
} else {
list_object(c, money);
}
}
/**
* Place a random amount of gold at (x, y).
* \param c current chunk
* \param y
* \param x co-ordinates
* \param level generation depth
* \param origin item origin
*/
void place_gold(struct chunk *c, int y, int x, int level, byte origin)
{
struct object *money = NULL;
assert(square_in_bounds(c, y, x));
if (!square_canputitem(c, y, x)) return;
money = make_gold(level, "any");
money->origin = origin;
money->origin_depth = level;
if (!floor_carry(c, y, x, money, false))
object_delete(&money);
else
list_object(c, money);
}
/*
* SCTP interface for geting the first source address of a sctp_t.
*/
int
sctp_getsockaddr(sctp_t *sctp, struct sockaddr *addr)
{
int err = -1;
int i;
int l;
sctp_saddr_ipif_t *pobj;
sctp_saddr_ipif_t obj;
size_t added = 0;
sin6_t *sin6;
sin_t *sin4;
int scanned = 0;
boolean_t skip_lback = B_FALSE;
conn_t *connp = sctp->sctp_connp;
addr->sa_family = connp->conn_family;
if (sctp->sctp_nsaddrs == 0)
goto done;
/*
* Skip loopback addresses for non-loopback assoc.
*/
if (sctp->sctp_state >= SCTPS_ESTABLISHED && !sctp->sctp_loopback) {
skip_lback = B_TRUE;
}
for (i = 0; i < SCTP_IPIF_HASH; i++) {
if (sctp->sctp_saddrs[i].ipif_count == 0)
continue;
pobj = list_object(&sctp->sctp_saddrs[i].sctp_ipif_list,
sctp->sctp_saddrs[i].sctp_ipif_list.list_head.list_next);
if (mdb_vread(&obj, sizeof (sctp_saddr_ipif_t),
(uintptr_t)pobj) == -1) {
mdb_warn("failed to read sctp_saddr_ipif_t");
return (err);
}
for (l = 0; l < sctp->sctp_saddrs[i].ipif_count; l++) {
sctp_ipif_t ipif;
in6_addr_t laddr;
list_node_t *pnode;
list_node_t node;
if (mdb_vread(&ipif, sizeof (sctp_ipif_t),
(uintptr_t)obj.saddr_ipifp) == -1) {
mdb_warn("failed to read sctp_ipif_t");
return (err);
}
laddr = ipif.sctp_ipif_saddr;
scanned++;
if ((ipif.sctp_ipif_state == SCTP_IPIFS_CONDEMNED) ||
SCTP_DONT_SRC(&obj) ||
(ipif.sctp_ipif_ill->sctp_ill_flags &
PHYI_LOOPBACK) && skip_lback) {
if (scanned >= sctp->sctp_nsaddrs)
goto done;
/* LINTED: alignment */
pnode = list_d2l(&sctp->sctp_saddrs[i].
sctp_ipif_list, pobj);
if (mdb_vread(&node, sizeof (list_node_t),
(uintptr_t)pnode) == -1) {
mdb_warn("failed to read list_node_t");
return (err);
}
pobj = list_object(&sctp->sctp_saddrs[i].
sctp_ipif_list, node.list_next);
if (mdb_vread(&obj, sizeof (sctp_saddr_ipif_t),
(uintptr_t)pobj) == -1) {
mdb_warn("failed to read "
"sctp_saddr_ipif_t");
return (err);
}
continue;
}
switch (connp->conn_family) {
case AF_INET:
/* LINTED: alignment */
sin4 = (sin_t *)addr;
if ((sctp->sctp_state <= SCTPS_LISTEN) &&
sctp->sctp_bound_to_all) {
sin4->sin_addr.s_addr = INADDR_ANY;
sin4->sin_port = connp->conn_lport;
} else {
sin4 += added;
sin4->sin_family = AF_INET;
sin4->sin_port = connp->conn_lport;
IN6_V4MAPPED_TO_INADDR(&laddr,
&sin4->sin_addr);
}
break;
case AF_INET6:
/* LINTED: alignment */
sin6 = (sin6_t *)addr;
if ((sctp->sctp_state <= SCTPS_LISTEN) &&
sctp->sctp_bound_to_all) {
bzero(&sin6->sin6_addr,
sizeof (sin6->sin6_addr));
sin6->sin6_port = connp->conn_lport;
} else {
sin6 += added;
sin6->sin6_family = AF_INET6;
sin6->sin6_port = connp->conn_lport;
sin6->sin6_addr = laddr;
}
sin6->sin6_flowinfo = connp->conn_flowinfo;
sin6->sin6_scope_id = 0;
sin6->__sin6_src_id = 0;
break;
}
added++;
if (added >= 1) {
err = 0;
goto done;
}
if (scanned >= sctp->sctp_nsaddrs)
goto done;
/* LINTED: alignment */
pnode = list_d2l(&sctp->sctp_saddrs[i].sctp_ipif_list,
pobj);
if (mdb_vread(&node, sizeof (list_node_t),
(uintptr_t)pnode) == -1) {
mdb_warn("failed to read list_node_t");
return (err);
}
pobj = list_object(&sctp->sctp_saddrs[i].
sctp_ipif_list, node.list_next);
if (mdb_vread(&obj, sizeof (sctp_saddr_ipif_t),
(uintptr_t)pobj) == -1) {
mdb_warn("failed to read sctp_saddr_ipif_t");
return (err);
}
}
}
done:
return (err);
}
/**
* Attempts to place a copy of the given monster at the given position in
* the dungeon.
*
* All of the monster placement routines eventually call this function. This
* is what actually puts the monster in the dungeon (i.e., it notifies the cave
* and sets the monsters position). The dungeon loading code also calls this
* function directly.
*
* `origin` is the item origin to use for any monster drops (e.g. ORIGIN_DROP,
* ORIGIN_DROP_PIT, etc.) The dungeon loading code calls this with origin = 0,
* which prevents the monster's drops from being generated again.
*
* Returns the m_idx of the newly copied monster, or 0 if the placement fails.
*/
s16b place_monster(struct chunk *c, int y, int x, struct monster *mon,
byte origin)
{
s16b m_idx;
struct monster *new_mon;
assert(square_in_bounds(c, y, x));
assert(!square_monster(c, y, x));
/* Get a new record */
m_idx = mon_pop(c);
if (!m_idx) return 0;
/* Copy the monster */
new_mon = cave_monster(c, m_idx);
memcpy(new_mon, mon, sizeof(struct monster));
/* Set the ID */
new_mon->midx = m_idx;
/* Set the location */
c->squares[y][x].mon = new_mon->midx;
new_mon->fy = y;
new_mon->fx = x;
assert(square_monster(c, y, x) == new_mon);
update_mon(new_mon, c, true);
/* Hack -- Count the number of "reproducers" */
if (rf_has(new_mon->race->flags, RF_MULTIPLY)) num_repro++;
/* Count racial occurrences */
new_mon->race->cur_num++;
/* Create the monster's drop, if any */
if (origin)
(void)mon_create_drop(c, new_mon, origin);
/* Make mimics start mimicking */
if (origin && new_mon->race->mimic_kinds) {
struct object *obj;
struct object_kind *kind = new_mon->race->mimic_kinds->kind;
struct monster_mimic *mimic_kind;
int i = 1;
/* Pick a random object kind to mimic */
for (mimic_kind = new_mon->race->mimic_kinds; mimic_kind;
mimic_kind = mimic_kind->next, i++) {
if (one_in_(i)) kind = mimic_kind->kind;
}
if (tval_is_money_k(kind)) {
obj = make_gold(player->depth, kind->name);
} else {
obj = object_new();
object_prep(obj, kind, new_mon->race->level, RANDOMISE);
apply_magic(obj, new_mon->race->level, true, false, false, false);
obj->number = 1;
obj->origin = ORIGIN_DROP_MIMIC;
obj->origin_depth = player->depth;
}
obj->mimicking_m_idx = m_idx;
new_mon->mimicked_obj = obj;
/* Put the object on the floor if it goes, otherwise no mimicry */
if (floor_carry(c, y, x, obj, false)) {
list_object(c, obj);
} else {
/* Clear the mimicry */
obj->mimicking_m_idx = 0;
new_mon->mimicked_obj = NULL;
/* Give the object to the monster if appropriate */
if (rf_has(new_mon->race->flags, RF_MIMIC_INV)) {
monster_carry(c, new_mon, obj);
} else {
/* Otherwise delete the mimicked object */
object_delete(&obj);
}
}
}
/* Result */
return m_idx;
}
