/**
* Get a list of the known objects at the given location.
*
* Return the number of objects acquired.
*/
int scan_distant_floor(struct object **items, int max_size, int y, int x)
{
struct object *obj;
int num = 0;
/* Sanity */
if (!square_in_bounds(player->cave, y, x)) return 0;
/* Scan all objects in the grid */
for (obj = square_object(player->cave, y, x); obj; obj = obj->next) {
/* Enforce limit */
if (num >= max_size) break;
/* Known */
if (obj->kind == unknown_item_kind) continue;
/* Visible */
if (ignore_known_item_ok(obj)) continue;
/* Accept this item's base object */
items[num++] = cave->objects[obj->oidx];
}
return num;
}
/**
* Return true if the object should be omitted from the object list.
*/
static bool object_list_should_ignore_object(const struct object *obj)
{
struct object *base_obj = cave->objects[obj->oidx];
assert(obj->kind);
assert(base_obj);
if (!is_unknown(base_obj) && ignore_known_item_ok(obj))
return true;
if (tval_is_money(base_obj))
return true;
return false;
}
/**
* Determine if a given location is "interesting"
*/
bool target_accept(int y, int x)
{
struct loc grid = loc(x, y);
struct object *obj;
/* Player grids are always interesting */
if (square(cave, grid).mon < 0) return true;
/* Handle hallucination */
if (player->timed[TMD_IMAGE]) return false;
/* Obvious monsters */
if (square(cave, grid).mon > 0) {
struct monster *mon = square_monster(cave, grid);
if (monster_is_obvious(mon)) {
return true;
}
}
/* Traps */
if (square_isvisibletrap(cave, grid)) return true;
/* Scan all objects in the grid */
for (obj = square_object(player->cave, grid); obj; obj = obj->next) {
/* Memorized object */
if ((obj->kind == unknown_item_kind) || !ignore_known_item_ok(obj)) {
return true;
}
}
/* Interesting memorized features */
if (square_isknown(cave, grid) && square_isinteresting(cave, grid)) {
return true;
}
/* Nope */
return false;
}
/**
* Determine if a given location is "interesting"
*/
bool target_accept(int y, int x)
{
struct object *obj;
/* Player grids are always interesting */
if (cave->squares[y][x].mon < 0) return (true);
/* Handle hallucination */
if (player->timed[TMD_IMAGE]) return (false);
/* Visible monsters */
if (cave->squares[y][x].mon > 0) {
struct monster *mon = square_monster(cave, y, x);
/* Visible monsters */
if (mflag_has(mon->mflag, MFLAG_VISIBLE) &&
!mflag_has(mon->mflag, MFLAG_UNAWARE))
return (true);
}
/* Traps */
if (square_isvisibletrap(cave, y, x))
return(true);
/* Scan all objects in the grid */
for (obj = square_object(cave_k, y, x); obj; obj = obj->next)
/* Memorized object */
if (!ignore_known_item_ok(obj)) return (true);
/* Interesting memorized features */
if (square_isknown(cave, y, x) && square_isinteresting(cave, y, x))
return (true);
/* Nope */
return (false);
}
/**
* This function takes a grid location (x, y) and extracts information the
* player is allowed to know about it, filling in the grid_data structure
* passed in 'g'.
*
* The information filled in is as follows:
* - g->f_idx is filled in with the terrain's feature type, or FEAT_NONE
* if the player doesn't know anything about the grid. The function
* makes use of the "mimic" field in terrain in order to allow one
* feature to look like another (hiding secret doors, invisible traps,
* etc). This will return the terrain type the player "Knows" about,
* not necessarily the real terrain.
* - g->m_idx is set to the monster index, or 0 if there is none (or the
* player doesn't know it).
* - g->first_kind is set to the object_kind of the first object in a grid
* that the player knows about, or NULL for no objects.
* - g->muliple_objects is true if there is more than one object in the
* grid that the player knows and cares about (to facilitate any special
* floor stack symbol that might be used).
* - g->in_view is true if the player can currently see the grid - this can
* be used to indicate field-of-view, such as through the
* OPT(player, view_bright_light) option.
* - g->lighting is set to indicate the lighting level for the grid:
* LIGHTING_DARK for unlit grids, LIGHTING_LIT for inherently light
* grids (lit rooms, etc), LIGHTING_TORCH for grids lit by the player's
* light source, and LIGHTING_LOS for grids in the player's line of sight.
* Note that lighting is always LIGHTING_LIT for known "interesting" grids
* like walls.
* - g->is_player is true if the player is on the given grid.
* - g->hallucinate is true if the player is hallucinating something "strange"
* for this grid - this should pick a random monster to show if the m_idx
* is non-zero, and a random object if first_kind is non-zero.
*
* NOTES:
* This is called pretty frequently, whenever a grid on the map display
* needs updating, so don't overcomplicate it.
*
* Terrain is remembered separately from objects and monsters, so can be
* shown even when the player can't "see" it. This leads to things like
* doors out of the player's view still change from closed to open and so on.
*
* TODO:
* Hallucination is currently disabled (it was a display-level hack before,
* and we need it to be a knowledge-level hack). The idea is that objects
* may turn into different objects, monsters into different monsters, and
* terrain may be objects, monsters, or stay the same.
*/
void map_info(unsigned y, unsigned x, struct grid_data *g)
{
struct object *obj;
assert(x < (unsigned) cave->width);
assert(y < (unsigned) cave->height);
/* Default "clear" values, others will be set later where appropriate. */
g->first_kind = NULL;
g->trap = NULL;
g->multiple_objects = false;
g->lighting = LIGHTING_DARK;
g->unseen_object = false;
g->unseen_money = false;
/* Use real feature (remove later) */
g->f_idx = cave->squares[y][x].feat;
if (f_info[g->f_idx].mimic)
g->f_idx = lookup_feat(f_info[g->f_idx].mimic);
g->in_view = (square_isseen(cave, y, x)) ? true : false;
g->is_player = (cave->squares[y][x].mon < 0) ? true : false;
g->m_idx = (g->is_player) ? 0 : cave->squares[y][x].mon;
g->hallucinate = player->timed[TMD_IMAGE] ? true : false;
if (g->in_view) {
g->lighting = LIGHTING_LOS;
if (!square_isglow(cave, y, x) && OPT(player, view_yellow_light))
g->lighting = LIGHTING_TORCH;
/* Remember seen feature */
square_memorize(cave, y, x);
} else if (!square_isknown(cave, y, x)) {
g->f_idx = FEAT_NONE;
} else if (square_isglow(cave, y, x)) {
g->lighting = LIGHTING_LIT;
}
/* Use known feature */
g->f_idx = player->cave->squares[y][x].feat;
if (f_info[g->f_idx].mimic)
g->f_idx = lookup_feat(f_info[g->f_idx].mimic);
/* There is a trap in this square */
if (square_istrap(cave, y, x) && square_isknown(cave, y, x)) {
struct trap *trap = cave->squares[y][x].trap;
/* Scan the square trap list */
while (trap) {
if (trf_has(trap->flags, TRF_TRAP) ||
trf_has(trap->flags, TRF_RUNE)) {
/* Accept the trap - only if not disabled, maybe we need
* a special graphic for this */
if (!trap->timeout) {
g->trap = trap;
break;
}
}
trap = trap->next;
}
}
/* Objects */
for (obj = square_object(player->cave, y, x); obj; obj = obj->next) {
if (obj->kind == unknown_gold_kind) {
g->unseen_money = true;
} else if (obj->kind == unknown_item_kind) {
g->unseen_object = true;
} else if (ignore_known_item_ok(obj)) {
/* Item stays hidden */
} else if (!g->first_kind) {
g->first_kind = obj->kind;
} else {
g->multiple_objects = true;
break;
}
}
/* Monsters */
if (g->m_idx > 0) {
/* If the monster isn't "visible", make sure we don't list it.*/
struct monster *mon = cave_monster(cave, g->m_idx);
if (!monster_is_visible(mon)) g->m_idx = 0;
}
/* Rare random hallucination on non-outer walls */
if (g->hallucinate && g->m_idx == 0 && g->first_kind == 0) {
if (one_in_(128) && (int) g->f_idx != FEAT_PERM)
g->m_idx = 1;
else if (one_in_(128) && (int) g->f_idx != FEAT_PERM)
/* if hallucinating, we just need first_kind to not be NULL */
g->first_kind = k_info;
else
g->hallucinate = false;
}
assert((int) g->f_idx <= FEAT_PASS_RUBBLE);
if (!g->hallucinate)
assert((int)g->m_idx < cave->mon_max);
/* All other g fields are 'flags', mostly booleans. */
}
