/**
* True if the square is an untrapped floor square without items.
*/
bool square_canputitem(struct chunk *c, int y, int x) {
if (!square_isfloor(c, y, x))
return FALSE;
if (square_iswarded(c, y, x) || square_isplayertrap(c, y, x))
return FALSE;
return !square_object(c, y, x);
}
/* Make traps */
static void project_feature_handler_MAKE_TRAP(project_feature_handler_context_t *context)
{
const int x = context->x;
const int y = context->y;
/* Require an "empty", non-warded floor grid */
if (!square_isempty(cave, y, x)) return;
if (square_iswarded(cave, y, x)) return;
/* Create a trap */
square_add_trap(cave, y, x);
context->obvious = true;
}
/**
* This will push objects off a square.
*
* The methodology is to load all objects on the square into a queue. Replace
* the previous square with a type that does not allow for objects. Drop the
* objects. Last, put the square back to its original type.
*/
void push_object(int y, int x)
{
/* Save the original terrain feature */
struct feature *feat_old = square_feat(cave, y, x);
struct object *obj = square_object(cave, y, x);
struct queue *queue = q_new(z_info->floor_size);
bool glyph = square_iswarded(cave, y, x);
/* Push all objects on the square, stripped of pile info, into the queue */
while (obj) {
struct object *next = obj->next;
q_push_ptr(queue, obj);
/* Orphan the object */
obj->next = NULL;
obj->prev = NULL;
obj->iy = 0;
obj->ix = 0;
/* Next object */
obj = next;
}
/* Disassociate the objects from the square */
cave->squares[y][x].obj = NULL;
/* Set feature to an open door */
square_force_floor(cave, y, x);
square_add_door(cave, y, x, false);
/* Drop objects back onto the floor */
while (q_len(queue) > 0) {
/* Take object from the queue */
obj = q_pop_ptr(queue);
/* Drop the object */
drop_near(cave, &obj, 0, y, x, false);
}
/* Reset cave feature and rune if needed */
square_set_feat(cave, y, x, feat_old->fidx);
if (glyph)
square_add_ward(cave, y, x);
q_free(queue);
}
/**
* Try to break a glyph.
*/
static bool process_monster_glyph(struct chunk *c, struct monster *m_ptr,
int nx, int ny)
{
assert(square_iswarded(c, ny, nx));
/* Break the ward */
if (randint1(z_info->glyph_hardness) < m_ptr->race->level) {
/* Describe observable breakage */
if (square_ismark(c, ny, nx))
msg("The rune of protection is broken!");
/* Forget the rune */
sqinfo_off(c->squares[ny][nx].info, SQUARE_MARK);
/* Break the rune */
square_remove_ward(c, ny, nx);
return TRUE;
}
/* Unbroken ward - can't move */
return FALSE;
}
/**
* Try to break a glyph.
*/
static bool process_monster_glyph(struct chunk *c, struct monster *mon,
int nx, int ny)
{
assert(square_iswarded(c, ny, nx));
/* Break the ward */
if (randint1(z_info->glyph_hardness) < mon->race->level) {
/* Describe observable breakage */
if (square_isseen(c, ny, nx)) {
msg("The rune of protection is broken!");
/* Forget the rune */
square_forget(c, ny, nx);
}
/* Break the rune */
square_remove_ward(c, ny, nx);
return true;
}
/* Unbroken ward - can't move */
return false;
}
/**
* Determine if there is a space near the selected spot in which
* a summoned creature can appear
*/
static bool summon_possible(int y1, int x1)
{
int y, x;
/* Start at the location, and check 2 grids in each dir */
for (y = y1 - 2; y <= y1 + 2; y++) {
for (x = x1 - 2; x <= x1 + 2; x++) {
/* Ignore illegal locations */
if (!square_in_bounds(cave, y, x)) continue;
/* Only check a circular area */
if (distance(y1, x1, y, x) > 2) continue;
/* Hack: no summon on glyph of warding */
if (square_iswarded(cave, y, x)) continue;
/* If it's empty floor grid in line of sight, we're good */
if (square_isempty(cave, y, x) && los(cave, y1, x1, y, x))
return (true);
}
}
return false;
}
void square_remove_ward(struct chunk *c, int y, int x)
{
struct trap_kind *rune = lookup_trap("glyph of warding");
assert(square_iswarded(c, y, x));
square_remove_trap(c, y, x, TRUE, rune->tidx);
}
/**
* Process a monster
*
* 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 process_monster(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;
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 (process_monster_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 (!process_monster_should_stagger(mon)) {
if (!get_moves(c, mon, &dir)) 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];
/* Check if we can move */
if (!process_monster_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) &&
!process_monster_glyph(c, mon, nx, ny))
continue;
/* The player is in the way. */
if (square_isplayer(c, ny, nx)) {
/* Learn about if the monster attacks */
if (mflag_has(mon->mflag, MFLAG_VISIBLE))
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 (mflag_has(mon->mflag, MFLAG_VISIBLE))
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 = process_monster_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);
process_monster_grab_objects(c, mon, m_name, nx, ny);
}
}
if (did_something) {
/* Learn about no lack of movement */
if (mflag_has(mon->mflag, MFLAG_VISIBLE))
rf_on(lore->flags, RF_NEVER_MOVE);
/* Possible disturb */
if (mflag_has(mon->mflag, MFLAG_VISIBLE) &&
mflag_has(mon->mflag, MFLAG_VIEW) && 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 && mflag_has(mon->mflag, MFLAG_UNAWARE))
become_aware(mon);
}
/**
* Places a monster (of the specified "type") near the given
* location. Return the siummoned monster's level iff a monster was
* actually summoned.
*
* We will attempt to place the monster up to 10 times before giving up.
*
* This function takes the "monster level"
* of the summoning monster as a parameter, and use that, along with
* the current dungeon level, to help determine the level of the
* desired monster. Note that this is an upper bound, and also
* tends to "prefer" monsters of that level. Currently, we use
* the average of the dungeon and monster levels, and then add
* five to allow slight increases in monster power.
*
* Note that we use the new "monster allocation table" creation code
* to restrict the "get_mon_num()" function to the set of "legal"
* monsters, making this function much faster and more reliable.
*
* Note that this function may not succeed, though this is very rare.
*/
int summon_specific(int y1, int x1, int lev, int type, bool delay, bool call)
{
int i, x = 0, y = 0;
struct monster *mon;
struct monster_race *race;
/* Look for a location, allow up to 4 squares away */
for (i = 0; i < 60; ++i) {
/* Pick a distance */
int d = (i / 15) + 1;
/* Pick a location */
scatter(cave, &y, &x, y1, x1, d, true);
/* Require "empty" floor grid */
if (!square_isempty(cave, y, x)) continue;
/* No summon on glyphs */
if (square_iswarded(cave, y, x) || square_isdecoyed(cave, y, x)) {
continue;
}
/* Okay */
break;
}
/* Failure */
if (i == 60) return (0);
/* Save the "summon" type */
summon_specific_type = type;
/* Use the new calling scheme if requested */
if (call && (type != summon_name_to_idx("UNIQUE")) &&
(type != summon_name_to_idx("WRAITH"))) {
return (call_monster(y, x));
}
/* Prepare allocation table */
get_mon_num_prep(summon_specific_okay);
/* Pick a monster, using the level calculation */
race = get_mon_num((player->depth + lev) / 2 + 5);
/* Prepare allocation table */
get_mon_num_prep(NULL);
/* Handle failure */
if (!race) return (0);
/* Attempt to place the monster (awake, don't allow groups) */
if (!place_new_monster(cave, y, x, race, false, false, ORIGIN_DROP_SUMMON))
return (0);
/* Success, return the level of the monster */
mon = square_monster(cave, y, x);
/* If delay, try to let the player act before the summoned monsters,
* including slowing down faster monsters for one turn */
/* XXX should this now be hold monster for a turn? */
if (delay) {
mon->energy = 0;
if (mon->race->speed > player->state.speed)
mon_inc_timed(mon, MON_TMD_SLOW, 1, MON_TMD_FLG_NOMESSAGE, false);
}
return (mon->race->level);
}
/**
* Find a grid near the given one for an object to fall on
*
* We check several locations to see if we can find a location at which
* the object can combine, stack, or be placed. Artifacts will try very
* hard to be placed, including "teleporting" to a useful grid if needed.
*
* If no appropriate grid is found, the given grid is unchanged
*/
static void drop_find_grid(struct object *drop, int *y, int *x)
{
int best_score = -1;
int best_y = *y;
int best_x = *x;
int i, dy, dx;
struct object *obj;
/* Scan local grids */
for (dy = -3; dy <= 3; dy++) {
for (dx = -3; dx <= 3; dx++) {
bool combine = false;
int dist = (dy * dy) + (dx * dx);
int ty = *y + dy;
int tx = *x + dx;
int num_shown = 0;
int num_ignored = 0;
int score;
/* Lots of reasons to say no */
if ((dist > 10) ||
!square_in_bounds_fully(cave, ty, tx) ||
!los(cave, *y, *x, ty, tx) ||
!square_isfloor(cave, ty, tx) ||
square_isplayertrap(cave, ty, tx) ||
square_iswarded(cave, ty, tx))
continue;
/* Analyse the grid for carrying the new object */
for (obj = square_object(cave, ty, tx); obj; obj = obj->next) {
/* Check for possible combination */
if (object_similar(obj, drop, OSTACK_FLOOR))
combine = true;
/* Count objects */
if (!ignore_item_ok(obj))
num_shown++;
else
num_ignored++;
}
if (!combine)
num_shown++;
/* Disallow if the stack size is too big */
if ((OPT(player, birth_stacking) && (num_shown > 1)) ||
((num_shown + num_ignored) > z_info->floor_size &&
!floor_get_oldest_ignored(ty, tx)))
continue;
/* Score the location based on how close and how full the grid is */
score = 1000 - (dist + num_shown * 5);
if ((score < best_score) || ((score == best_score) && one_in_(2)))
continue;
best_score = score;
best_y = ty;
best_x = tx;
}
}
/* Return if we have a score, otherwise fail or try harder for artifacts */
if (best_score >= 0) {
*y = best_y;
*x = best_x;
return;
} else if (!drop->artifact) {
return;
}
for (i = 0; i < 2000; i++) {
/* Start bouncing from grid to grid, stopping if we find an empty one */
if (i < 1000) {
best_y = rand_spread(best_y, 1);
best_x = rand_spread(best_x, 1);
} else {
/* Now go to purely random locations */
best_y = randint0(cave->height);
best_x = randint0(cave->width);
}
if (square_canputitem(cave, best_y, best_x)) {
*y = best_y;
*x = best_x;
return;
}
}
}
/**
* Attempts to place a monster of the given race at the given location.
*
* If `sleep` is true, the monster is placed with its default sleep value,
* which is given in monster.txt.
*
* `origin` is the item origin to use for any monster drops (e.g. ORIGIN_DROP,
* ORIGIN_DROP_PIT, etc.)
*
* To give the player a sporting chance, some especially dangerous
* monsters are marked as "FORCE_SLEEP" in monster.txt, which will
* cause them to be placed with low energy. This helps ensure that
* if such a monster suddenly appears in line-of-sight (due to a
* summon, for instance), the player gets a chance to move before
* they do.
*
* This routine refuses to place out-of-depth "FORCE_DEPTH" monsters.
*
* This is the only function which may place a monster in the dungeon,
* except for the savefile loading code, which calls place_monster()
* directly.
*/
static bool place_new_monster_one(struct chunk *c, int y, int x,
struct monster_race *race, bool sleep,
byte origin)
{
int i;
struct monster *mon;
struct monster monster_body;
assert(square_in_bounds(c, y, x));
assert(race && race->name);
/* Not where monsters already are */
if (square_monster(c, y, x))
return false;
/* Not where the player already is */
if ((player->py == y) && (player->px == x))
return false;
/* Prevent monsters from being placed where they cannot walk, but allow other feature types */
if (!square_is_monster_walkable(c, y, x))
return false;
/* No creation on glyph of warding */
if (square_iswarded(c, y, x)) return false;
/* "unique" monsters must be "unique" */
if (rf_has(race->flags, RF_UNIQUE) && race->cur_num >= race->max_num)
return (false);
/* Depth monsters may NOT be created out of depth */
if (rf_has(race->flags, RF_FORCE_DEPTH) && player->depth < race->level)
return (false);
/* Add to level feeling, note uniques for cheaters */
c->mon_rating += race->level * race->level;
/* Check out-of-depth-ness */
if (race->level > c->depth) {
if (rf_has(race->flags, RF_UNIQUE)) { /* OOD unique */
if (OPT(player, cheat_hear))
msg("Deep unique (%s).", race->name);
} else { /* Normal monsters but OOD */
if (OPT(player, cheat_hear))
msg("Deep monster (%s).", race->name);
}
/* Boost rating by power per 10 levels OOD */
c->mon_rating += (race->level - c->depth) * race->level * race->level;
} else if (rf_has(race->flags, RF_UNIQUE) && OPT(player, cheat_hear))
msg("Unique (%s).", race->name);
/* Get local monster */
mon = &monster_body;
/* Clean out the monster */
memset(mon, 0, sizeof(struct monster));
/* Save the race */
mon->race = race;
/* Enforce sleeping if needed */
if (sleep && race->sleep) {
int val = race->sleep;
mon->m_timed[MON_TMD_SLEEP] = ((val * 2) + randint1(val * 10));
}
/* Uniques get a fixed amount of HP */
if (rf_has(race->flags, RF_UNIQUE))
mon->maxhp = race->avg_hp;
else {
mon->maxhp = mon_hp(race, RANDOMISE);
mon->maxhp = MAX(mon->maxhp, 1);
}
/* And start out fully healthy */
mon->hp = mon->maxhp;
/* Extract the monster base speed */
mon->mspeed = race->speed;
/* Hack -- small racial variety */
if (!rf_has(race->flags, RF_UNIQUE)) {
/* Allow some small variation per monster */
i = turn_energy(race->speed) / 10;
if (i) mon->mspeed += rand_spread(0, i);
}
/* Give a random starting energy */
mon->energy = (byte)randint0(50);
/* Force monster to wait for player */
if (rf_has(race->flags, RF_FORCE_SLEEP))
mflag_on(mon->mflag, MFLAG_NICE);
/* Radiate light? */
if (rf_has(race->flags, RF_HAS_LIGHT))
player->upkeep->update |= PU_UPDATE_VIEW;
/* Is this obviously a monster? (Mimics etc. aren't) */
if (rf_has(race->flags, RF_UNAWARE))
mflag_on(mon->mflag, MFLAG_CAMOUFLAGE);
else
mflag_off(mon->mflag, MFLAG_CAMOUFLAGE);
/* Set the color if necessary */
if (rf_has(race->flags, RF_ATTR_RAND))
mon->attr = randint1(BASIC_COLORS - 1);
/* Place the monster in the dungeon */
if (!place_monster(c, y, x, mon, origin))
return (false);
/* Success */
return (true);
}
/**
* Let an object fall to the ground at or near a location.
*
* The initial location is assumed to be "square_in_bounds_fully(cave, )".
*
* This function takes a parameter "chance". This is the percentage
* chance that the item will "disappear" instead of drop. If the object
* has been thrown, then this is the chance of disappearance on contact.
*
* This function will produce a description of a drop event under the player
* when "verbose" is true.
*
* We check several locations to see if we can find a location at which
* the object can combine, stack, or be placed. Artifacts will try very
* hard to be placed, including "teleporting" to a useful grid if needed.
*
* Objects which fail to be carried by the floor are deleted. This function
* attempts to add successfully dropped objects to, and to remove failures
* from, the object list (as dropped items may or may not be already listed).
*/
void drop_near(struct chunk *c, struct object *dropped, int chance, int y,
int x, bool verbose)
{
int i, k, n, d, s;
int bs, bn;
int by, bx;
int dy, dx;
int ty, tx;
struct object *obj;
char o_name[80];
bool flag = false;
/* Only called in the current level */
assert(c == cave);
/* Describe object */
object_desc(o_name, sizeof(o_name), dropped, ODESC_BASE);
/* Handle normal "breakage" */
if (!dropped->artifact && (randint0(100) < chance)) {
/* Message */
msg("The %s %s.", o_name,
VERB_AGREEMENT(dropped->number, "breaks", "break"));
/* Failure */
if (dropped->known) {
delist_object(cave_k, dropped->known);
object_delete(&dropped->known);
}
delist_object(c, dropped);
object_delete(&dropped);
return;
}
/* Score */
bs = -1;
/* Picker */
bn = 0;
/* Default */
by = y;
bx = x;
/* Scan local grids */
for (dy = -3; dy <= 3; dy++) {
for (dx = -3; dx <= 3; dx++) {
bool comb = false;
/* Calculate actual distance */
d = (dy * dy) + (dx * dx);
/* Ignore distant grids */
if (d > 10) continue;
/* Location */
ty = y + dy;
tx = x + dx;
/* Skip illegal grids */
if (!square_in_bounds_fully(c, ty, tx)) continue;
/* Require line of sight */
if (!los(c, y, x, ty, tx)) continue;
/* Require floor space */
if (!square_isfloor(c, ty, tx)) continue;
/* Require no trap or rune */
if (square_isplayertrap(c, ty, tx) ||
square_iswarded(c, ty, tx))
continue;
/* No objects */
k = 0;
n = 0;
/* Scan objects in that grid */
for (obj = square_object(c, ty, tx); obj; obj = obj->next) {
/* Check for possible combination */
if (object_similar(obj, dropped, OSTACK_FLOOR))
comb = true;
/* Count objects */
if (!ignore_item_ok(obj))
k++;
else
n++;
}
/* Add new object */
if (!comb) k++;
/* Option -- disallow stacking */
if (OPT(birth_no_stacking) && (k > 1)) continue;
/* Paranoia? */
if ((k + n) > z_info->floor_size &&
!floor_get_oldest_ignored(ty, tx)) continue;
/* Calculate score */
s = 1000 - (d + k * 5);
/* Skip bad values */
if (s < bs) continue;
/* New best value */
if (s > bs) bn = 0;
/* Apply the randomizer to equivalent values */
if ((++bn >= 2) && (randint0(bn) != 0)) continue;
/* Keep score */
bs = s;
/* Track it */
by = ty;
bx = tx;
/* Okay */
flag = true;
}
}
/* Handle lack of space */
if (!flag && !dropped->artifact) {
/* Message */
msg("The %s %s.", o_name,
VERB_AGREEMENT(dropped->number, "disappears", "disappear"));
/* Debug */
if (player->wizard) msg("Breakage (no floor space).");
/* Failure */
if (dropped->known) {
delist_object(cave_k, dropped->known);
object_delete(&dropped->known);
}
delist_object(c, dropped);
object_delete(&dropped);
return;
}
/* Find a grid */
for (i = 0; !flag; i++) {
/* Bounce around */
if (i < 1000) {
ty = rand_spread(by, 1);
tx = rand_spread(bx, 1);
} else {
/* Random locations */
ty = randint0(c->height);
tx = randint0(c->width);
}
/* Require floor space */
if (!square_canputitem(c, ty, tx)) continue;
/* Bounce to that location */
by = ty;
bx = tx;
/* Okay */
flag = true;
}
/* Give it to the floor */
if (!floor_carry(c, by, bx, dropped, false)) {
/* Message */
msg("The %s %s.", o_name,
VERB_AGREEMENT(dropped->number, "disappears", "disappear"));
/* Debug */
if (player->wizard) msg("Breakage (too many objects).");
if (dropped->artifact) dropped->artifact->created = false;
/* Failure */
if (dropped->known) {
delist_object(cave_k, dropped->known);
object_delete(&dropped->known);
}
delist_object(c, dropped);
object_delete(&dropped);
return;
}
/* Sound */
sound(MSG_DROP);
/* Message when an object falls under the player */
if (verbose && (c->squares[by][bx].mon < 0))
/* Check the item still exists and isn't ignored */
if (c->objects[dropped->oidx] && !ignore_item_ok(dropped))
msg("You feel something roll beneath your feet.");
}
