/**
* Check if a monster should stagger or not. Always stagger when confused,
* but also deal with random movement for RAND_25 and _50 monsters.
*/
static bool monster_turn_should_stagger(struct monster *mon)
{
struct monster_lore *lore = get_lore(mon->race);
int chance = 0;
/* Increase chance of being erratic for every level of confusion */
int conf_level = monster_effect_level(mon, MON_TMD_CONF);
while (conf_level) {
int accuracy = 100 - chance;
accuracy *= (100 - CONF_ERRATIC_CHANCE);
accuracy /= 100;
chance = 100 - accuracy;
conf_level--;
}
/* RAND_25 and RAND_50 are cumulative */
if (rf_has(mon->race->flags, RF_RAND_25)) {
chance += 25;
if (monster_is_visible(mon))
rf_on(lore->flags, RF_RAND_25);
}
if (rf_has(mon->race->flags, RF_RAND_50)) {
chance += 50;
if (monster_is_visible(mon))
rf_on(lore->flags, RF_RAND_50);
}
return randint0(100) < chance;
}
/**
* Try to push past / kill another monster. Returns true on success.
*/
static bool monster_turn_try_push(struct chunk *c, struct monster *mon,
const char *m_name, int nx, int ny)
{
struct monster *mon1 = square_monster(c, ny, nx);
struct monster_lore *lore = get_lore(mon->race);
/* Kill weaker monsters */
int kill_ok = rf_has(mon->race->flags, RF_KILL_BODY);
/* Move weaker monsters if they can swap places */
/* (not in a wall) */
int move_ok = (rf_has(mon->race->flags, RF_MOVE_BODY) &&
square_ispassable(c, mon->fy, mon->fx));
if (compare_monsters(mon, mon1) > 0) {
/* Learn about pushing and shoving */
if (monster_is_visible(mon)) {
rf_on(lore->flags, RF_KILL_BODY);
rf_on(lore->flags, RF_MOVE_BODY);
}
if (kill_ok || move_ok) {
/* Get the names of the monsters involved */
char n_name[80];
monster_desc(n_name, sizeof(n_name), mon1, MDESC_IND_HID);
/* Reveal mimics */
if (monster_is_mimicking(mon1))
become_aware(mon1);
/* Note if visible */
if (monster_is_visible(mon) && monster_is_in_view(mon))
msg("%s %s %s.", m_name,
kill_ok ? "tramples over" : "pushes past", n_name);
/* Monster ate another monster */
if (kill_ok)
delete_monster(ny, nx);
monster_swap(mon->fy, mon->fx, ny, nx);
return true;
}
}
return false;
}
/**
* True if the player's current target is in LOS.
*/
bool target_sighted(void)
{
return target_okay() &&
panel_contains(target.grid.y, target.grid.x) &&
/* either the target is a grid and is visible, or it is a monster
* that is visible */
((!target.midx && square_isseen(cave, target.grid)) ||
(target.midx && monster_is_visible(cave_monster(cave, target.midx))));
}
/**
* Attempt to reproduce, if possible. All monsters are checked here for
* lore purposes, the unfit fail.
*/
static bool monster_turn_multiply(struct chunk *c, struct monster *mon)
{
int k = 0, y, x;
struct monster_lore *lore = get_lore(mon->race);
/* Too many breeders on the level already */
if (num_repro >= z_info->repro_monster_max) return false;
/* Count the adjacent monsters */
for (y = mon->fy - 1; y <= mon->fy + 1; y++)
for (x = mon->fx - 1; x <= mon->fx + 1; x++)
if (c->squares[y][x].mon > 0) k++;
/* Multiply slower in crowded areas */
if ((k < 4) && (k == 0 || one_in_(k * z_info->repro_monster_rate))) {
/* Successful breeding attempt, learn about that now */
if (monster_is_visible(mon))
rf_on(lore->flags, RF_MULTIPLY);
/* Leave now if not a breeder */
if (!rf_has(mon->race->flags, RF_MULTIPLY))
return false;
/* Try to multiply */
if (multiply_monster(c, mon)) {
/* Make a sound */
if (monster_is_visible(mon))
sound(MSG_MULTIPLY);
/* Multiplying takes energy */
return true;
}
}
return false;
}
/**
* Called from project() to affect the player
*
* Called for projections with the PROJECT_PLAY flag set, which includes
* bolt, beam, ball and breath effects.
*
* \param src is the origin of the effect
* \param r is the distance from the centre of the effect
* \param y the coordinates of the grid being handled
* \param x the coordinates of the grid being handled
* \param dam is the "damage" from the effect at distance r from the centre
* \param typ is the projection (PROJ_) type
* \return whether the effects were obvious
*
* If "r" is non-zero, then the blast was centered elsewhere; the damage
* is reduced in project() before being passed in here. This can happen if a
* monster breathes at the player and hits a wall instead.
*
* We assume the player is aware of some effect, and always return "true".
*/
bool project_p(struct source origin, int r, int y, int x, int dam, int typ)
{
bool blind = (player->timed[TMD_BLIND] ? true : false);
bool seen = !blind;
bool obvious = true;
/* Monster or trap name (for damage) */
char killer[80];
project_player_handler_f player_handler = player_handlers[typ];
project_player_handler_context_t context = {
origin,
r,
y,
x,
dam,
typ,
obvious,
};
/* No player here */
if (!square_isplayer(cave, y, x)) {
return false;
}
switch (origin.what) {
case SRC_PLAYER:
/* Never affect projector */
return false;
case SRC_MONSTER: {
struct monster *mon = cave_monster(cave, origin.which.monster);
/* Check it is visible */
if (!monster_is_visible(mon))
seen = false;
/* Get the monster's real name */
monster_desc(killer, sizeof(killer), mon, MDESC_DIED_FROM);
break;
}
case SRC_TRAP: {
struct trap *trap = origin.which.trap;
/* Get the trap name */
strnfmt(killer, sizeof(killer), "a %s", trap->kind->desc);
break;
}
case SRC_OBJECT: {
struct object *obj = origin.which.object;
object_desc(killer, sizeof(killer), obj, ODESC_PREFIX | ODESC_BASE);
break;
}
case SRC_NONE: {
/* Assume the caller has set the killer variable */
break;
}
}
/* Let player know what is going on */
if (!seen) {
msg("You are hit by %s!", projections[typ].blind_desc);
}
/* Adjust damage for resistance, immunity or vulnerability, and apply it */
dam = adjust_dam(player,
typ,
dam,
RANDOMISE,
player->state.el_info[typ].res_level,
true);
if (dam) {
take_hit(player, dam, killer);
}
/* Handle side effects */
if (player_handler != NULL && player->is_dead == false) {
player_handler(&context);
}
/* Disturb */
disturb(player, 1);
/* Return "Anything seen?" */
return context.obvious;
}
/**
* 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. */
}
/**
* Work out if a monster can move through the grid, if necessary bashing
* down doors in the way.
*
* Returns true if the monster is able to move through the grid.
*/
static bool monster_turn_can_move(struct chunk *c, struct monster *mon,
const char *m_name, int nx, int ny, bool *did_something)
{
struct monster_lore *lore = get_lore(mon->race);
/* Dangerous terrain in the way */
if (monster_hates_grid(c, mon, ny, nx)) {
return false;
}
/* Floor is open? */
if (square_ispassable(c, ny, nx)) {
return true;
}
/* Permanent wall in the way */
if (square_iswall(c, ny, nx) && square_isperm(c, ny, nx)) {
return false;
}
/* Normal wall, door, or secret door in the way */
/* There's some kind of feature in the way, so learn about
* kill-wall and pass-wall now */
if (monster_is_visible(mon)) {
rf_on(lore->flags, RF_PASS_WALL);
rf_on(lore->flags, RF_KILL_WALL);
}
/* Monster may be able to deal with walls and doors */
if (rf_has(mon->race->flags, RF_PASS_WALL)) {
return true;
} else if (rf_has(mon->race->flags, RF_KILL_WALL)) {
/* Remove the wall */
square_destroy_wall(c, ny, nx);
/* Note changes to viewable region */
if (square_isview(c, ny, nx))
player->upkeep->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
return true;
} else if (square_iscloseddoor(c, ny, nx) ||
square_issecretdoor(c, ny, nx)) {
bool can_open = rf_has(mon->race->flags, RF_OPEN_DOOR);
bool can_bash = rf_has(mon->race->flags, RF_BASH_DOOR);
bool will_bash = false;
/* Take a turn */
*did_something = true;
/* Learn about door abilities */
if (monster_is_visible(mon)) {
rf_on(lore->flags, RF_OPEN_DOOR);
rf_on(lore->flags, RF_BASH_DOOR);
}
/* If creature can open or bash doors, make a choice */
if (can_open) {
/* Sometimes bash anyway (impatient) */
if (can_bash) {
will_bash = one_in_(2) ? true : false;
}
} else if (can_bash) {
/* Only choice */
will_bash = true;
} else {
/* Door is an insurmountable obstacle */
return false;
}
/* Now outcome depends on type of door */
if (square_islockeddoor(c, ny, nx)) {
/* Locked door -- test monster strength against door strength */
int k = square_door_power(c, ny, nx);
if (randint0(mon->hp / 10) > k) {
if (will_bash) {
msg("%s slams against the door.", m_name);
} else {
msg("%s fiddles with the lock.", m_name);
}
/* Reduce the power of the door by one */
square_set_door_lock(c, ny, nx, k - 1);
}
} else {
/* Closed or secret door -- always open or bash */
if (square_isview(c, ny, nx))
player->upkeep->update |= (PU_UPDATE_VIEW | PU_MONSTERS);
if (will_bash) {
square_smash_door(c, ny, nx);
msg("You hear a door burst open!");
disturb(player, 0);
/* Fall into doorway */
return true;
} else {
square_open_door(c, ny, nx);
}
}
}
return false;
}
/**
* Process a monster's turn
*
* In several cases, we directly update the monster lore
*
* Note that a monster is only allowed to "reproduce" if there
* are a limited number of "reproducing" monsters on the current
* level. This should prevent the level from being "swamped" by
* reproducing monsters. It also allows a large mass of mice to
* prevent a louse from multiplying, but this is a small price to
* pay for a simple multiplication method.
*
* XXX Monster fear is slightly odd, in particular, monsters will
* fixate on opening a door even if they cannot open it. Actually,
* the same thing happens to normal monsters when they hit a door
*
* In addition, monsters which *cannot* open or bash down a door
* will still stand there trying to open it... XXX XXX XXX
*
* Technically, need to check for monster in the way combined
* with that monster being in a wall (or door?) XXX
*/
static void monster_turn(struct chunk *c, struct monster *mon)
{
struct monster_lore *lore = get_lore(mon->race);
bool did_something = false;
int i;
int dir = 0;
bool stagger = false;
bool tracking = false;
char m_name[80];
/* Get the monster name */
monster_desc(m_name, sizeof(m_name), mon, MDESC_CAPITAL | MDESC_IND_HID);
/* Try to multiply - this can use up a turn */
if (monster_turn_multiply(c, mon))
return;
/* Attempt to cast a spell */
if (make_attack_spell(mon)) return;
/* Work out what kind of movement to use - AI or staggered movement */
if (!monster_turn_should_stagger(mon)) {
if (!get_move(c, mon, &dir, &tracking)) return;
} else {
stagger = true;
}
/* Process moves */
for (i = 0; i < 5 && !did_something; i++) {
int oy = mon->fy;
int ox = mon->fx;
/* Get the direction (or stagger) */
int d = (stagger ? ddd[randint0(8)] : side_dirs[dir][i]);
/* Get the destination */
int ny = oy + ddy[d];
int nx = ox + ddx[d];
/* Tracking monsters have their best direction, don't change */
if ((i > 0) && !stagger && !square_isview(c, oy, ox) && tracking) {
break;
}
/* Check if we can move */
if (!monster_turn_can_move(c, mon, m_name, nx, ny, &did_something))
continue;
/* Try to break the glyph if there is one. This can happen multiple
* times per turn because failure does not break the loop */
if (square_iswarded(c, ny, nx) &&
!monster_turn_glyph(c, mon, nx, ny))
continue;
/* Break a decoy if there is one */
if (square_isdecoyed(c, ny, nx)) {
/* Learn about if the monster attacks */
if (monster_is_visible(mon))
rf_on(lore->flags, RF_NEVER_BLOW);
/* Some monsters never attack */
if (rf_has(mon->race->flags, RF_NEVER_BLOW))
continue;
/* Wait a minute... */
square_destroy_decoy(c, ny, nx);
did_something = true;
break;
}
/* The player is in the way. */
if (square_isplayer(c, ny, nx)) {
/* Learn about if the monster attacks */
if (monster_is_visible(mon))
rf_on(lore->flags, RF_NEVER_BLOW);
/* Some monsters never attack */
if (rf_has(mon->race->flags, RF_NEVER_BLOW))
continue;
/* Otherwise, attack the player */
make_attack_normal(mon, player);
did_something = true;
break;
} else {
/* Some monsters never move */
if (rf_has(mon->race->flags, RF_NEVER_MOVE)) {
/* Learn about lack of movement */
if (monster_is_visible(mon))
rf_on(lore->flags, RF_NEVER_MOVE);
return;
}
}
/* A monster is in the way, try to push past/kill */
if (square_monster(c, ny, nx)) {
did_something = monster_turn_try_push(c, mon, m_name, nx, ny);
} else {
/* Otherwise we can just move */
monster_swap(oy, ox, ny, nx);
did_something = true;
}
/* Scan all objects in the grid, if we reached it */
if (mon == square_monster(c, ny, nx)) {
monster_desc(m_name, sizeof(m_name), mon,
MDESC_CAPITAL | MDESC_IND_HID);
monster_turn_grab_objects(c, mon, m_name, nx, ny);
}
}
if (did_something) {
/* Learn about no lack of movement */
if (monster_is_visible(mon))
rf_on(lore->flags, RF_NEVER_MOVE);
/* Possible disturb */
if (monster_is_visible(mon) && monster_is_in_view(mon) &&
OPT(player, disturb_near))
disturb(player, 0);
}
/* Hack -- get "bold" if out of options */
if (!did_something && mon->m_timed[MON_TMD_FEAR])
mon_clear_timed(mon, MON_TMD_FEAR, MON_TMD_FLG_NOTIFY, false);
/* If we see an unaware monster do something, become aware of it */
if (did_something && monster_is_camouflaged(mon))
become_aware(mon);
}
/**
* Grab all objects from the grid.
*/
void monster_turn_grab_objects(struct chunk *c, struct monster *mon,
const char *m_name, int nx, int ny)
{
struct monster_lore *lore = get_lore(mon->race);
struct object *obj;
bool visible = monster_is_visible(mon);
/* Learn about item pickup behavior */
for (obj = square_object(c, ny, nx); obj; obj = obj->next) {
if (!tval_is_money(obj) && visible) {
rf_on(lore->flags, RF_TAKE_ITEM);
rf_on(lore->flags, RF_KILL_ITEM);
break;
}
}
/* Abort if can't pickup/kill */
if (!rf_has(mon->race->flags, RF_TAKE_ITEM) &&
!rf_has(mon->race->flags, RF_KILL_ITEM)) {
return;
}
/* Take or kill objects on the floor */
obj = square_object(c, ny, nx);
while (obj) {
char o_name[80];
bool safe = obj->artifact ? true : false;
struct object *next = obj->next;
/* Skip gold */
if (tval_is_money(obj)) {
obj = next;
continue;
}
/* Skip mimicked objects */
if (obj->mimicking_m_idx) {
obj = next;
continue;
}
/* Get the object name */
object_desc(o_name, sizeof(o_name), obj, ODESC_PREFIX | ODESC_FULL);
/* React to objects that hurt the monster */
if (react_to_slay(obj, mon))
safe = true;
/* Try to pick up, or crush */
if (safe) {
/* Only give a message for "take_item" */
if (rf_has(mon->race->flags, RF_TAKE_ITEM) && visible &&
square_isview(c, ny, nx) && !ignore_item_ok(obj)) {
/* Dump a message */
msg("%s tries to pick up %s, but fails.", m_name, o_name);
}
} else if (rf_has(mon->race->flags, RF_TAKE_ITEM)) {
/* Describe observable situations */
if (square_isseen(c, ny, nx) && !ignore_item_ok(obj))
msg("%s picks up %s.", m_name, o_name);
/* Carry the object */
square_excise_object(c, ny, nx, obj);
monster_carry(c, mon, obj);
square_note_spot(c, ny, nx);
square_light_spot(c, ny, nx);
} else {
/* Describe observable situations */
if (square_isseen(c, ny, nx) && !ignore_item_ok(obj))
msgt(MSG_DESTROY, "%s crushes %s.", m_name, o_name);
/* Delete the object */
square_excise_object(c, ny, nx, obj);
delist_object(c, obj);
object_delete(&obj);
square_note_spot(c, ny, nx);
square_light_spot(c, ny, nx);
}
/* Next object */
obj = next;
}
}
/**
* Monster is recognisably a monster to the player
*/
bool monster_is_obvious(const struct monster *mon)
{
return monster_is_visible(mon) && !monster_is_camouflaged(mon);
}
