/* Destroy Traps (and Locks) */
static void project_feature_handler_KILL_TRAP(project_feature_handler_context_t *context)
{
const int x = context->x;
const int y = context->y;
/* Reveal secret doors */
if (square_issecretdoor(cave, y, x)) {
place_closed_door(cave, y, x);
/* Check line of sight */
if (square_isseen(cave, y, x))
context->obvious = true;
}
/* Destroy traps, unlock doors */
if (square_istrap(cave, y, x)) {
/* Check line of sight */
if (square_isview(cave, y, x)) {
msg("There is a bright flash of light!");
context->obvious = true;
}
/* Destroy the trap */
square_destroy_trap(cave, y, x);
} else if (square_islockeddoor(cave, y, x)) {
/* Unlock the door */
square_unlock_door(cave, y, x);
/* Check line of sound */
if (square_isview(cave, y, x)) {
msg("Click!");
context->obvious = true;
}
}
}
/**
* Determine if a cave grid is allowed to have player traps in it.
*/
bool square_player_trap_allowed(struct chunk *c, int y, int x)
{
/*
* We currently forbid multiple traps in a grid under normal conditions.
* If this changes, various bits of code elsewhere will have to change too.
*/
if (square_istrap(c, y, x))
return FALSE;
/* We currently forbid traps in a grid with objects. */
if (square_object(c, y, x))
return FALSE;
/* Check the feature trap flag */
return (tf_has(f_info[c->squares[y][x].feat].flags, TF_TRAP));
}
/**
* Determine if a cave grid is allowed to have player traps in it.
*/
bool square_player_trap_allowed(struct chunk *c, int y, int x)
{
/*
* We currently forbid multiple traps in a grid under normal conditions.
* If this changes, various bits of code elsewhere will have to change too.
*/
if (square_istrap(c, y, x))
return false;
/* We currently forbid traps in a grid with objects. */
if (square_object(c, y, x))
return false;
/* Check it's a trappable square */
return (square_istrappable(c, y, x));
}
/**
* Is there a trap with a given flag in this square?
*/
bool square_trap_flag(struct chunk *c, int y, int x, int flag)
{
struct trap *trap = c->squares[y][x].trap;
/* First, check the trap marker */
if (!square_istrap(c, y, x))
return FALSE;
/* Scan the square trap list */
while (trap) {
/* We found a trap with the right flag */
if (trf_has(trap->flags, flag))
return TRUE;
trap = trap->next;
}
/* Report failure */
return FALSE;
}
/**
* Is there a specific kind of trap in this square?
*/
bool square_trap_specific(struct chunk *c, int y, int x, int t_idx)
{
struct trap *trap = c->squares[y][x].trap;
/* First, check the trap marker */
if (!square_istrap(c, y, x))
return FALSE;
/* Scan the square trap list */
while (trap) {
/* We found a trap of the right kind */
if (trap->t_idx == t_idx)
return TRUE;
trap = trap->next;
}
/* Report failure */
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(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, grid_data *g)
{
object_type *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 = 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;
g->trapborder = (square_isdedge(cave, y, x)) ? TRUE : FALSE;
if (g->in_view) {
g->lighting = LIGHTING_LOS;
if (!square_isglow(cave, y, x) && OPT(view_yellow_light))
g->lighting = LIGHTING_TORCH;
/* Remember seen feature */
cave_k->squares[y][x].feat = cave->squares[y][x].feat;
} else if (!square_ismark(cave, y, x)) {
g->f_idx = FEAT_NONE;
//cave_k->squares[y][x].feat = FEAT_NONE;
} else if (square_isglow(cave, y, x)) {
g->lighting = LIGHTING_LIT;
}
/* Use known feature */
/* g->f_idx = cave_k->squares[y][x].feat;
if (f_info[g->f_idx].mimic)
g->f_idx = f_info[g->f_idx].mimic;*/
/* There is a trap in this square */
if (square_istrap(cave, y, x) && square_ismark(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 */
g->trap = trap;
break;
}
trap = trap->next;
}
}
/* Objects */
for (obj = square_object(cave, y, x); obj; obj = obj->next) {
if (obj->marked == MARK_AWARE) {
/* Distinguish between unseen money and objects */
if (tval_is_money(obj)) {
g->unseen_money = TRUE;
} else {
g->unseen_object = TRUE;
}
} else if (obj->marked == MARK_SEEN && !ignore_item_ok(obj)) {
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.*/
monster_type *m_ptr = cave_monster(cave, g->m_idx);
if (!mflag_has(m_ptr->mflag, MFLAG_VISIBLE)) 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. */
}
/**
* 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. */
}