/*
* The "Squelch on walk-on" function.
*/
void do_squelch_pile(int y, int x)
{
s16b o_idx, next_o_idx;
object_type *o_ptr;
bool sq_flag = FALSE;
for (o_idx = cave_o_idx[y][x]; o_idx; o_idx = next_o_idx)
{
o_ptr = &(o_list[o_idx]);
next_o_idx = o_ptr->next_o_idx;
/* Always squelch "¬hing" */
if (!o_ptr->k_idx) sq_flag = TRUE;
/* Hack - never squelch artifacts */
else if (artifact_p(o_ptr)) sq_flag = FALSE;
/* Squelch it? */
else sq_flag = (k_info[o_ptr->k_idx].squelch & k_info[o_ptr->k_idx].aware);
/* Unwanted and unloved */
if (sq_flag)
{
/* Actual Squelch */
if (strong_squelch) delete_object_idx(o_idx);
/* Or inscription */
else o_ptr->note = quark_add("SQUELCH");
}
}
}
/*
* Carry an object and delete it.
*/
static void py_pickup_aux(int o_idx, bool domsg)
{
int slot, quiver_slot = 0;
char o_name[80];
object_type *o_ptr = object_byid(o_idx);
/* Carry the object */
slot = inven_carry(p_ptr, o_ptr);
/* Handle errors (paranoia) */
if (slot < 0) return;
/* If we have picked up ammo which matches something in the quiver, note
* that it so that we can wield it later (and suppress pick up message) */
if (obj_is_ammo(o_ptr))
{
int i;
for (i = QUIVER_START; i < QUIVER_END; i++)
{
if (!p_ptr->inventory[i].kind) continue;
if (!object_similar(&p_ptr->inventory[i], o_ptr,
OSTACK_QUIVER)) continue;
quiver_slot = i;
break;
}
}
/* Get the new object */
o_ptr = &p_ptr->inventory[slot];
/* Set squelch status */
p_ptr->notice |= PN_SQUELCH;
/* Automatically sense artifacts */
object_notice_artifact(o_ptr);
/* Optionally, display a message */
if (domsg && !quiver_slot)
{
/* Describe the object */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL);
/* Message */
msg("You have %s (%c).", o_name, index_to_label(slot));
}
/* Update object_idx if necessary */
if (p_ptr->object_idx == (0 - o_idx))
{
track_object(slot);
}
/* Delete the object */
delete_object_idx(o_idx);
/* If we have a quiver slot that this ammo matches, use it */
if (quiver_slot) wield_item(o_ptr, slot, quiver_slot);
}
/*
* Create a feature near the player.
*/
static void do_cmd_wiz_feature(int feat)
{
int px = p_ptr->px;
int py = p_ptr->py;
int y, x, d = 3, attempts = 30;
while (1)
{
/* Find a location */
y = rand_spread(py, d);
x = rand_spread(px, d);
/* Reject illegal grids */
if (!in_bounds(y, x)) continue;
/* Reject the player */
if ((y == py) && (x == px)) continue;
attempts--;
if (!attempts)
{
d++;
attempts = 8 * d;
}
/* Try to place a new feature */
if (area(y, x)->feat == feat) continue;
/* Okay */
break;
}
/* Nuke objects */
delete_object_idx(area(y, x)->o_idx);
/* Nuke monsters */
delete_monster_idx(area(y, x)->m_idx);
/* Forget this grid */
area(y, x)->info &= ~(CAVE_MARK);
/* Place the feature */
cave_set_feat(y, x, feat);
/* Update stuff */
p_ptr->update |= (PU_VIEW | PU_MONSTERS | PU_MON_LITE);
}
/* Helper function for monster_death - drop any objects the monster is holding */
static void mon_drop_held_objects(monster_type *m_ptr)
{
s16b this_o_idx, next_o_idx = 0;
object_type *i_ptr;
object_type object_type_body;
/* Drop objects being carried */
for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
{
object_type *o_ptr;
/* Get the object */
o_ptr = &o_list[this_o_idx];
/*Remove the mark to hide when monsters carry this object*/
o_ptr->ident &= ~(IDENT_HIDE_CARRY);
/* Get the next object */
next_o_idx = o_ptr->next_o_idx;
/* Paranoia */
o_ptr->held_m_idx = 0;
/* Get local object */
i_ptr = &object_type_body;
/* Copy the object */
object_copy(i_ptr, o_ptr);
/* Delete the object */
delete_object_idx(this_o_idx);
/* Drop it */
drop_near(i_ptr, -1, m_ptr->fy, m_ptr->fx);
}
/* Forget objects */
m_ptr->hold_o_idx = 0;
}
/*
* Pickup all gold at the player's current location.
*/
static void py_pickup_gold(void)
{
int py = p_ptr->py;
int px = p_ptr->px;
s32b total_gold = 0L;
byte *treasure;
s16b this_o_idx = 0;
s16b next_o_idx = 0;
object_type *o_ptr;
int sound_msg;
bool verbal = FALSE;
/* Allocate an array of ordinary gold objects */
treasure = C_ZNEW(SV_GOLD_MAX, byte);
/* Pick up all the ordinary gold objects */
for (this_o_idx = cave->o_idx[py][px]; this_o_idx; this_o_idx = next_o_idx)
{
/* Get the object */
o_ptr = object_byid(this_o_idx);
/* Get the next object */
next_o_idx = o_ptr->next_o_idx;
/* Ignore if not legal treasure */
if ((o_ptr->tval != TV_GOLD) ||
(o_ptr->sval >= SV_GOLD_MAX)) continue;
/* Note that we have this kind of treasure */
treasure[o_ptr->sval]++;
/* Remember whether feedback message is in order */
if (!squelch_item_ok(o_ptr))
verbal = TRUE;
/* Increment total value */
total_gold += (s32b)o_ptr->pval[DEFAULT_PVAL];
/* Delete the gold */
delete_object_idx(this_o_idx);
}
/* Pick up the gold, if present */
if (total_gold)
{
char buf[1024];
char tmp[80];
int i, count, total;
object_kind *kind;
/* Build a message */
(void)strnfmt(buf, sizeof(buf), "You have found %ld gold pieces worth of ", (long)total_gold);
/* Count the types of treasure present */
for (total = 0, i = 0; i < SV_GOLD_MAX; i++)
{
if (treasure[i]) total++;
}
/* List the treasure types */
for (count = 0, i = 0; i < SV_GOLD_MAX; i++)
{
/* Skip if no treasure of this type */
if (!treasure[i]) continue;
/* Get this object index */
kind = lookup_kind(TV_GOLD, i);
if (!kind) continue;
/* Get the object name */
object_kind_name(tmp, sizeof tmp, kind, TRUE);
/* Build up the pickup string */
my_strcat(buf, tmp, sizeof(buf));
/* Added another kind of treasure */
count++;
/* Add a comma if necessary */
if ((total > 2) && (count < total)) my_strcat(buf, ",", sizeof(buf));
/* Add an "and" if necessary */
if ((total >= 2) && (count == total-1)) my_strcat(buf, " and", sizeof(buf));
/* Add a space or period if necessary */
if (count < total) my_strcat(buf, " ", sizeof(buf));
else my_strcat(buf, ".", sizeof(buf));
}
/* Determine which sound to play */
if (total_gold < 200) sound_msg = MSG_MONEY1;
else if (total_gold < 600) sound_msg = MSG_MONEY2;
else sound_msg = MSG_MONEY3;
/* Display the message */
if (verbal)
msgt(sound_msg, "%s", buf);
/* Add gold to purse */
p_ptr->au += total_gold;
/* Redraw gold */
p_ptr->redraw |= (PR_GOLD);
}
/* Free the gold array */
FREE(treasure);
}
/**
* Pick up objects and treasure on the floor, now also used for telekinesis.
*
* Called with pickup:
* 0 to grab gold and describe non-gold objects.
* 1 to pick up objects either with or without displaying a menu.
* 2 to pick up objects, forcing a menu for multiple objects.
* 3 to pick up objects, forcing a menu for any number of objects.
*
* Scan the list of objects in that floor grid. Pick up gold automatically.
* Pick up objects automatically until pile or backpack space is full if
* auto-pickup option is on, carry_query_floor option is not, and menus are
* not forced (which the "get" command does). Otherwise, store objects on
* floor in an array, and tally both how many there are and can be picked up.
*
* If the player is not picking up objects, describe a single object or
* indicate the presence of a floor stack. If player is picking up objects,
* name a single object, or indicate a stack of objects, that cannot go in
* the backpack.
*
* Pick up a single object without menus, unless menus for single items are
* forced. Confirm pickup if that option is on.
*
* Pick up multiple objects (unless using autopickup, no confirm) using Tim
* Baker's menu system. Recursively call this function (forcing menus for any
* number of objects) until objects are gone, backpack is full, or player is
* satisfied.
*
* Keep track of number of objects picked up (to calculate time spent).
*/
byte py_pickup(int pickup, int y, int x)
{
s16b this_o_idx, next_o_idx = 0;
char o_name[120];
object_type *o_ptr;
/* Objects picked up. Used to determine time cost of command. */
byte objs_picked_up = 0;
size_t floor_num = 0;
int floor_list[MAX_FLOOR_STACK + 1], floor_o_idx = 0;
int can_pickup = 0;
bool call_function_again = FALSE;
bool blind = ((p_ptr->timed[TMD_BLIND]) || (no_light()));
bool msg = TRUE;
bool telekinesis = (!(y == p_ptr->py) || !(x == p_ptr->px));
/* Nothing to pick up -- return */
if (!cave_o_idx[y][x]) return (0);
/* Always pickup gold, effortlessly */
if (!telekinesis) py_pickup_gold();
/* Scan the pile of objects */
for (this_o_idx = cave_o_idx[y][x]; this_o_idx; this_o_idx = next_o_idx) {
/* Access the object */
o_ptr = &o_list[this_o_idx];
/* Access the next object */
next_o_idx = o_ptr->next_o_idx;
/* Ordinary pickup */
if (!telekinesis) {
/* Ignore all hidden objects and non-objects */
if (squelch_hide_item(o_ptr) || !o_ptr->k_idx)
continue;
/* Hack -- disturb */
disturb(0, 0);
/* Automatically pick up some items */
if (auto_pickup_okay(o_ptr)) {
/* Pick up the object */
py_pickup_aux(this_o_idx, TRUE);
objs_picked_up++;
/* Check the next object */
continue;
}
}
/* Tally objects and store them in an array. */
/* Remember this object index */
floor_list[floor_num] = this_o_idx;
/* Count non-gold objects that remain on the floor. */
floor_num++;
/* Tally objects that can be picked up.*/
if (inven_carry_okay(o_ptr))
can_pickup++;
}
/* There are no non-gold objects */
if (!floor_num)
return (objs_picked_up);
/* Get hold of the last floor index */
floor_o_idx = floor_list[floor_num - 1];
/* Mention the objects if player is not picking them up. */
if (pickup == 0 || !(can_pickup || telekinesis))
{
const char *p = "see";
/* One object */
if (floor_num == 1)
{
if (!can_pickup) p = "have no room for";
else if (blind) p = "feel";
/* Get the object */
o_ptr = &o_list[floor_o_idx];
/* Describe the object. Less detail if blind. */
if (blind)
object_desc(o_name, sizeof(o_name), o_ptr,
ODESC_PREFIX | ODESC_BASE);
else
object_desc(o_name, sizeof(o_name), o_ptr,
ODESC_PREFIX | ODESC_FULL);
/* Message */
message_flush();
msg_format("You %s %s.", p, o_name);
}
else
{
/* Optionally, display more information about floor items */
if (OPT(pickup_detail))
{
ui_event_data e;
if (!can_pickup) p = "have no room for the following objects";
else if (blind) p = "feel something on the floor";
/* Scan all marked objects in the grid */
floor_num = scan_floor(floor_list, N_ELEMENTS(floor_list), y, x, 0x03);
/* Save screen */
screen_save();
/* Display objects on the floor */
show_floor(floor_list, floor_num, (OLIST_WEIGHT));
/* Display prompt */
prt(format("You %s: ", p), 0, 0);
/* Move cursor back to character, if needed */
if (OPT(highlight_player)) move_cursor_relative(p_ptr->py, p_ptr->px);
/* Wait for it. Use key as next command. */
e = inkey_ex();
Term_event_push(&e);
/* Restore screen */
screen_load();
}
/* Show less detail */
else
{
message_flush();
if (!can_pickup)
msg_print("You have no room for any of the items on the floor.");
else
msg_format("You %s a pile of %d items.", (blind ? "feel" : "see"), floor_num);
}
}
/* Done */
return (objs_picked_up);
}
/* We can pick up objects. Menus are not requested (yet). */
if (pickup == 1)
{
/* Scan floor (again) */
floor_num = scan_floor(floor_list, N_ELEMENTS(floor_list), y, x, 0x03);
/* Use a menu interface for multiple objects, or get single objects */
if (floor_num > 1)
pickup = 2;
else
this_o_idx = floor_o_idx;
}
/* Display a list if requested. */
if (pickup == 2)
{
cptr q, s;
int item;
/* Get an object or exit. */
q = "Get which item?";
s = "You see nothing there.";
/* Telekinesis */
if (telekinesis) {
item_tester_hook = inven_carry_okay;
if (!get_item(&item, q, s, CMD_PICKUP, USE_TARGET))
return (objs_picked_up);
this_o_idx = 0 - item;
}
else {
/* Restrict the choices */
item_tester_hook = inven_carry_okay;
if (!get_item(&item, q, s, CMD_PICKUP, USE_FLOOR))
return (objs_picked_up);
this_o_idx = 0 - item;
call_function_again = TRUE;
}
/* With a list, we do not need explicit pickup messages */
msg = FALSE;
}
/* Pick up object, if legal */
if (this_o_idx)
{
/* Regular pickup or telekinesis with pack not full */
if (can_pickup) {
/* Pick up the object */
py_pickup_aux(this_o_idx, msg);
}
/* Telekinesis with pack full */
else {
/* Access the object */
o_ptr = &o_list[this_o_idx];
/* Drop it */
drop_near(o_ptr, -1, p_ptr->py, p_ptr->px, TRUE);
/* Delete the old object */
delete_object_idx(this_o_idx);
}
}
/* Indicate an object picked up. */
objs_picked_up = 1;
/* If requested, call this function recursively. Count objects picked up.
* Force the display of a menu in all cases. */
if (call_function_again)
objs_picked_up += py_pickup(3, y, x);
/* Indicate how many objects have been picked up. */
return (objs_picked_up);
}
/**
* Carry an object and delete it.
*/
extern void py_pickup_aux(int o_idx, bool msg)
{
int slot, quiver_slot = 0;
char o_name[120];
object_type *o_ptr = &o_list[o_idx];
object_type *i_ptr = &p_ptr->inventory[INVEN_LIGHT];
bitflag f[OF_SIZE], obvious_mask[OF_SIZE];
flags_init(obvious_mask, OF_SIZE, OF_OBVIOUS_MASK, FLAG_END);
of_copy(f, o_ptr->flags_obj);
/* Carry the object */
slot = inven_carry(p_ptr, o_ptr);
/* Handle errors (paranoia) */
if (slot < 0) return;
/* If we have picked up ammo which matches something in the quiver, note
* that it so that we can wield it later (and suppress pick up message) */
if (obj_is_quiver_obj(o_ptr))
{
int i;
for (i = QUIVER_START; i < QUIVER_END; i++)
{
if (!p_ptr->inventory[i].k_idx) continue;
if (!object_similar(&p_ptr->inventory[i], o_ptr,
OSTACK_QUIVER)) continue;
quiver_slot = i;
break;
}
}
/* Get the object again */
o_ptr = &p_ptr->inventory[slot];
/* Set squelch status */
p_ptr->notice |= PN_SQUELCH;
/* Stone of Lore gives id on pickup */
if (!object_known_p(o_ptr)) {
if (i_ptr->sval == SV_STONE_LORE)
identify_object(o_ptr);
/* Otherwise pseudo-ID */
else {
bool heavy = FALSE;
int feel;
/* Heavy sensing */
heavy = (player_has(PF_PSEUDO_ID_HEAVY));
/* Type of feeling */
feel = (heavy ? value_check_aux1(o_ptr) : value_check_aux2(o_ptr));
/* We have "felt" it */
o_ptr->ident |= (IDENT_SENSE);
/* Inscribe it textually */
o_ptr->feel = feel;
/* Set squelch flag as appropriate */
p_ptr->notice |= PN_SQUELCH;
}
}
/* Log artifacts if found */
if (artifact_p(o_ptr))
history_add_artifact(o_ptr->name1, object_is_known(o_ptr), TRUE);
/* Notice dice and other obvious stuff */
notice_other(IF_DD_DS, slot + 1);
(void) of_inter(f, obvious_mask);
of_union(o_ptr->id_obj, f);
/* Average things are average */
if ((o_ptr->feel == FEEL_AVERAGE) && (is_weapon(o_ptr) || is_armour(o_ptr))){
notice_other(IF_AC, slot + 1);
notice_other(IF_TO_A, slot + 1);
notice_other(IF_TO_H, slot + 1);
notice_other(IF_TO_D, slot + 1);
}
/* Recalculate the bonuses */
p_ptr->update |= (PU_BONUS);
/* Optionally, display a message */
if (msg && !quiver_slot)
{
/* Describe the object */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_PREFIX | ODESC_FULL);
/* Message */
msg_format("You have %s (%c).", o_name, index_to_label(slot));
}
/* Delete the object */
delete_object_idx(o_idx);
/* If we have a quiver slot that this item matches, use it */
if (quiver_slot) wield_item(o_ptr, slot, quiver_slot);
}
/* Possessor incarnates */
bool ai_possessor(s32b m_idx, s32b o_idx)
{
#if 0 // DGDGDGDG
object_type *o_ptr = o_list[o_idx];
monster_type *m_ptr = get_monster(m_idx);
s32b r_idx = m_ptr->r_idx, r2_idx = get_flag(o_ptr, FLAG_MONSTER_IDX);
s32b i;
monster_race *r_ptr = &r_info[r2_idx];
char m_name[80], m_name2[80];
monster_desc(m_name, m_ptr, 0x00);
monster_race_desc(m_name2, r2_idx, 0);
if (m_ptr->ml) msg_format("%^s incarnates into a %s!", m_name, m_name2);
/* Remove the old one */
delete_object_idx(o_idx);
m_ptr->r_idx = r2_idx;
m_ptr->ego = 0;
/* No "damage" yet */
m_ptr->stunned = 0;
m_ptr->confused = 0;
m_ptr->monfear = 0;
/* No target yet */
m_ptr->target = -1;
/* Assume no sleeping */
m_ptr->csleep = 0;
/* Assign maximal hitpoints */
if (has_flag(r_ptr, FLAG_FORCE_MAXHP))
{
m_ptr->maxhp = maxroll(r_ptr->hdice, r_ptr->hside);
}
else
{
m_ptr->maxhp = damroll(r_ptr->hdice, r_ptr->hside);
}
/* And start out fully healthy */
m_ptr->hp = m_ptr->maxhp;
/* Some basic info */
for (i = 0; i < 4; i++)
{
m_ptr->blow[i].method = r_ptr->blow[i].method;
m_ptr->blow[i].effect = r_ptr->blow[i].effect;
m_ptr->blow[i].d_dice = r_ptr->blow[i].d_dice;
m_ptr->blow[i].d_side = r_ptr->blow[i].d_side;
}
m_ptr->ac = r_ptr->ac;
m_ptr->level = r_ptr->level;
m_ptr->speed = r_ptr->speed;
m_ptr->exp = MONSTER_EXP(m_ptr->level);
/* Extract the monster base speed */
m_ptr->mspeed = m_ptr->speed;
m_ptr->energy = 0;
/* Hack -- Count the number of "reproducers" */
if (has_flag(r_ptr, FLAG_MULTIPLY)) num_repro++;
/* Hack -- Notice new multi-hued monsters */
if (has_flag(r_ptr, FLAG_ATTR_MULTI)) shimmer_monsters = TRUE;
/* Hack -- Count the monsters on the level */
r_ptr->cur_num++;
r_info[r_idx].cur_num--;
m_ptr->possessor = r_idx;
/* Update the monster */
update_mon(m_idx, TRUE);
#endif
return TRUE;
}
/**
* Rogues may set traps. Only one such trap may exist at any one time,
* but an old trap can be disarmed to free up equipment for a new trap.
* -LM-
*/
extern bool py_set_trap(int y, int x)
{
int max_traps;
s16b this_o_idx, next_o_idx = 0;
object_type *o_ptr;
bool destroy_message = FALSE;
max_traps =
1 + ((p_ptr->lev >= 25) ? 1 : 0) +
(player_has(PF_EXTRA_TRAP) ? 1 : 0);
if (p_ptr->timed[TMD_BLIND] || no_light()) {
msg_print("You can not see to set a trap.");
return FALSE;
}
if (p_ptr->timed[TMD_CONFUSED] || p_ptr->timed[TMD_IMAGE]) {
msg_print("You are too confused.");
return FALSE;
}
/* Paranoia -- Forbid more than max_traps being set. */
if (num_trap_on_level >= max_traps) {
msg_print
("You must disarm your existing trap to free up your equipment.");
return FALSE;
}
/* No setting traps while shapeshifted */
if (SCHANGE) {
msg_print("You can not set traps while shapechanged.");
msg_print("Use the ']' command to return to your normal form.");
return FALSE;
}
/* Scan all objects in the grid */
for (this_o_idx = cave_o_idx[y][x]; this_o_idx; this_o_idx = next_o_idx) {
/* Acquire object */
o_ptr = &o_list[this_o_idx];
/* Acquire next object */
next_o_idx = o_ptr->next_o_idx;
/* Artifact */
if (o_ptr->name1) {
msg_print("There is an indestructible object here.");
return FALSE;
}
/* Visible object to be destroyed */
if (!squelch_hide_item(o_ptr))
destroy_message = TRUE;
}
/* Verify */
if (cave_o_idx[y][x]) {
if (destroy_message)
if (!get_check("Destroy all items and set a trap?"))
return FALSE;
for (this_o_idx = cave_o_idx[y][x]; this_o_idx; this_o_idx = next_o_idx) {
/* Acquire object */
o_ptr = &o_list[this_o_idx];
/* Acquire next object */
next_o_idx = o_ptr->next_o_idx;
/* Delete the object */
delete_object_idx(this_o_idx);
}
/* Redraw */
light_spot(y, x);
}
/* Set the trap, and draw it. */
cave_set_feat(y, x, FEAT_MTRAP_BASE);
/* Notify the player. */
msg_print("You set a monster trap.");
/* Increment the number of monster traps. */
num_trap_on_level++;
/* A trap has been set */
return TRUE;
}
/*!
* @brief フロアの切り替え処理 / Enter new floor.
* @return なし
* @details
* If the floor is an old saved floor, it will be\n
* restored from the temporal file. If the floor is new one, new cave\n
* will be generated.\n
*/
void change_floor(void)
{
saved_floor_type *sf_ptr;
bool loaded = FALSE;
/* The dungeon is not ready */
character_dungeon = FALSE;
/* No longer in the trap detecteded region */
p_ptr->dtrap = FALSE;
/* Mega-Hack -- no panel yet */
panel_row_min = 0;
panel_row_max = 0;
panel_col_min = 0;
panel_col_max = 0;
/* Mega-Hack -- not ambushed on the wildness? */
ambush_flag = FALSE;
/* No saved floors (On the surface etc.) */
if (!(change_floor_mode & CFM_SAVE_FLOORS) &&
!(change_floor_mode & CFM_FIRST_FLOOR))
{
/* Create cave */
generate_cave();
/* Paranoia -- No new saved floor */
new_floor_id = 0;
}
/* In the dungeon */
else
{
/* No floor_id yet */
if (!new_floor_id)
{
/* Get new id */
new_floor_id = get_new_floor_id();
}
/* Pointer for infomations of new floor */
sf_ptr = get_sf_ptr(new_floor_id);
/* Try to restore old floor */
if (sf_ptr->last_visit)
{
/* Old saved floor is exist */
if (load_floor(sf_ptr, 0))
{
loaded = TRUE;
/* Forbid return stairs */
if (change_floor_mode & CFM_NO_RETURN)
{
cave_type *c_ptr = &cave[p_ptr->y][p_ptr->x];
if (!feat_uses_special(c_ptr->feat))
{
if (change_floor_mode & (CFM_DOWN | CFM_UP))
{
/* Reset to floor */
c_ptr->feat = floor_type[randint0(100)];
}
c_ptr->special = 0;
}
}
}
}
/*
* Set lower/upper_floor_id of new floor when the new
* floor is right-above/right-under the current floor.
*
* Stair creation/Teleport level/Trap door will take
* you the same floor when you used it later again.
*/
if (p_ptr->floor_id)
{
saved_floor_type *cur_sf_ptr = get_sf_ptr(p_ptr->floor_id);
if (change_floor_mode & CFM_UP)
{
/* New floor is right-above */
if (cur_sf_ptr->upper_floor_id == new_floor_id)
sf_ptr->lower_floor_id = p_ptr->floor_id;
}
else if (change_floor_mode & CFM_DOWN)
{
/* New floor is right-under */
if (cur_sf_ptr->lower_floor_id == new_floor_id)
sf_ptr->upper_floor_id = p_ptr->floor_id;
}
}
/* Break connection to killed floor */
else
{
if (change_floor_mode & CFM_UP)
sf_ptr->lower_floor_id = 0;
else if (change_floor_mode & CFM_DOWN)
sf_ptr->upper_floor_id = 0;
}
/* Maintain monsters and artifacts */
if (loaded)
{
IDX i;
s32b tmp_last_visit = sf_ptr->last_visit;
s32b absence_ticks;
int alloc_chance = d_info[dungeon_type].max_m_alloc_chance;
int alloc_times;
while (tmp_last_visit > turn) tmp_last_visit -= TURNS_PER_TICK * TOWN_DAWN;
absence_ticks = (turn - tmp_last_visit) / TURNS_PER_TICK;
/* Maintain monsters */
for (i = 1; i < m_max; i++)
{
monster_race *r_ptr;
monster_type *m_ptr = &m_list[i];
/* Skip dead monsters */
if (!m_ptr->r_idx) continue;
if (!is_pet(m_ptr))
{
/* Restore HP */
m_ptr->hp = m_ptr->maxhp = m_ptr->max_maxhp;
/* Remove timed status (except MTIMED_CSLEEP) */
(void)set_monster_fast(i, 0);
(void)set_monster_slow(i, 0);
(void)set_monster_stunned(i, 0);
(void)set_monster_confused(i, 0);
(void)set_monster_monfear(i, 0);
(void)set_monster_invulner(i, 0, FALSE);
}
/* Extract real monster race */
r_ptr = real_r_ptr(m_ptr);
/* Ignore non-unique */
if (!(r_ptr->flags1 & RF1_UNIQUE) &&
!(r_ptr->flags7 & RF7_NAZGUL)) continue;
/* Appear at a different floor? */
if (r_ptr->floor_id != new_floor_id)
{
/* Disapper from here */
delete_monster_idx(i);
}
}
/* Maintain artifatcs */
for (i = 1; i < o_max; i++)
{
object_type *o_ptr = &o_list[i];
/* Skip dead objects */
if (!o_ptr->k_idx) continue;
/* Ignore non-artifact */
if (!object_is_fixed_artifact(o_ptr)) continue;
/* Appear at a different floor? */
if (a_info[o_ptr->name1].floor_id != new_floor_id)
{
/* Disappear from here */
delete_object_idx(i);
}
else
{
/* Cancel preserve */
a_info[o_ptr->name1].cur_num = 1;
}
}
(void)place_quest_monsters();
/* Place some random monsters */
alloc_times = absence_ticks / alloc_chance;
if (randint0(alloc_chance) < (absence_ticks % alloc_chance))
alloc_times++;
for (i = 0; i < alloc_times; i++)
{
/* Make a (group of) new monster */
(void)alloc_monster(0, 0);
}
}
/* New floor_id or failed to restore */
else /* if (!loaded) */
{
if (sf_ptr->last_visit)
{
/* Temporal file is broken? */
#ifdef JP
msg_print("階段は行き止まりだった。");
#else
msg_print("The staircases come to a dead end...");
#endif
/* Create simple dead end */
build_dead_end();
/* Break connection */
if (change_floor_mode & CFM_UP)
{
sf_ptr->upper_floor_id = 0;
}
else if (change_floor_mode & CFM_DOWN)
{
sf_ptr->lower_floor_id = 0;
}
}
else
{
/* Newly create cave */
generate_cave();
}
/* Record last visit turn */
sf_ptr->last_visit = turn;
/* Set correct dun_level value */
sf_ptr->dun_level = dun_level;
/* Create connected stairs */
if (!(change_floor_mode & CFM_NO_RETURN))
{
/* Extract stair position */
cave_type *c_ptr = &cave[p_ptr->y][p_ptr->x];
/*** Create connected stairs ***/
/* No stairs down from Quest */
if ((change_floor_mode & CFM_UP) && !quest_number(dun_level))
{
c_ptr->feat = (change_floor_mode & CFM_SHAFT) ? feat_state(feat_down_stair, FF_SHAFT) : feat_down_stair;
}
/* No stairs up when ironman_downward */
else if ((change_floor_mode & CFM_DOWN) && !ironman_downward)
{
c_ptr->feat = (change_floor_mode & CFM_SHAFT) ? feat_state(feat_up_stair, FF_SHAFT) : feat_up_stair;
}
/* Paranoia -- Clear mimic */
c_ptr->mimic = 0;
/* Connect to previous floor */
c_ptr->special = p_ptr->floor_id;
}
}
/* Arrive at random grid */
if (change_floor_mode & (CFM_RAND_PLACE))
{
(void)new_player_spot();
}
/* You see stairs blocked */
else if ((change_floor_mode & CFM_NO_RETURN) &&
(change_floor_mode & (CFM_DOWN | CFM_UP)))
{
if (!p_ptr->blind)
{
#ifdef JP
msg_print("突然階段が塞がれてしまった。");
#else
msg_print("Suddenly the stairs is blocked!");
#endif
}
else
{
#ifdef JP
msg_print("ゴトゴトと何か音がした。");
#else
msg_print("You hear some noises.");
#endif
}
}
/*
* Update visit mark
*
* The "turn" is not always different number because
* the level teleport doesn't take any turn. Use
* visit mark instead of last visit turn to find the
* oldest saved floor.
*/
sf_ptr->visit_mark = latest_visit_mark++;
}
/* Place preserved pet monsters */
place_pet();
/* Reset travel target place */
forget_travel_flow();
/* Hack -- maintain unique and artifacts */
update_unique_artifact(new_floor_id);
/* Now the player is in new floor */
p_ptr->floor_id = new_floor_id;
/* The dungeon is ready */
character_dungeon = TRUE;
/* Hack -- Munchkin characters always get whole map */
if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN)
wiz_lite((bool)(p_ptr->pclass == CLASS_NINJA));
/* Remember when this level was "created" */
old_turn = turn;
/* No dungeon feeling yet */
p_ptr->feeling_turn = old_turn;
p_ptr->feeling = 0;
/* Clear all flags */
change_floor_mode = 0L;
select_floor_music();
}
/**
* Handles the "death" of a monster.
*
* Disperses treasures carried by the monster centered at the monster location.
* Note that objects dropped may disappear in crowded rooms.
*
* Checks for "Quest" completion when a quest monster is killed.
*
* Note that only the player can induce "monster_death()" on Uniques.
* Thus (for now) all Quest monsters should be Uniques.
*
* If `stats` is true, then we skip updating the monster memory. This is
* used by stats-generation code, for efficiency.
*/
void monster_death(struct monster *m_ptr, bool stats)
{
int i;
int dump_item = 0;
int dump_gold = 0;
int total = 0;
s16b this_o_idx, next_o_idx = 0;
object_type *i_ptr;
object_type object_type_body;
bool visible = (m_ptr->ml || rf_has(m_ptr->race->flags, RF_UNIQUE));
int y = m_ptr->fy;
int x = m_ptr->fx;
/* Delete any mimicked objects */
if (m_ptr->mimicked_o_idx > 0)
delete_object_idx(m_ptr->mimicked_o_idx);
/* Drop objects being carried */
for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx) {
object_type *o_ptr;
/* Get the object */
o_ptr = object_byid(this_o_idx);
/* Line up the next object */
next_o_idx = o_ptr->next_o_idx;
/* Paranoia */
o_ptr->held_m_idx = 0;
/* Get local object, copy it and delete the original */
i_ptr = &object_type_body;
object_copy(i_ptr, o_ptr);
delete_object_idx(this_o_idx);
/* Count it and drop it - refactor once origin is a bitflag */
if (!stats) {
if ((i_ptr->tval == TV_GOLD) && (i_ptr->origin != ORIGIN_STOLEN))
dump_gold++;
else if ((i_ptr->tval != TV_GOLD) && ((i_ptr->origin == ORIGIN_DROP)
|| (i_ptr->origin == ORIGIN_DROP_PIT)
|| (i_ptr->origin == ORIGIN_DROP_VAULT)
|| (i_ptr->origin == ORIGIN_DROP_SUMMON)
|| (i_ptr->origin == ORIGIN_DROP_SPECIAL)
|| (i_ptr->origin == ORIGIN_DROP_BREED)
|| (i_ptr->origin == ORIGIN_DROP_POLY)
|| (i_ptr->origin == ORIGIN_DROP_WIZARD)))
dump_item++;
}
/* Change origin if monster is invisible, unless we're in stats mode */
if (!visible && !stats)
i_ptr->origin = ORIGIN_DROP_UNKNOWN;
drop_near(cave, i_ptr, 0, y, x, TRUE);
}
/* Forget objects */
m_ptr->hold_o_idx = 0;
/* Take note of any dropped treasure */
if (visible && (dump_item || dump_gold))
lore_treasure(m_ptr, dump_item, dump_gold);
/* Update monster list window */
p_ptr->redraw |= PR_MONLIST;
/* Nothing else to do for non-"Quest Monsters" */
if (!rf_has(m_ptr->race->flags, RF_QUESTOR)) return;
/* Mark quests as complete */
for (i = 0; i < MAX_Q_IDX; i++) {
/* Note completed quests */
if (q_list[i].level == m_ptr->race->level) q_list[i].level = 0;
/* Count incomplete quests */
if (q_list[i].level) total++;
}
/* Build magical stairs */
build_quest_stairs(y, x);
/* Nothing left, game over... */
if (total == 0) {
p_ptr->total_winner = TRUE;
p_ptr->redraw |= (PR_TITLE);
msg("*** CONGRATULATIONS ***");
msg("You have won the game!");
msg("You may retire (commit suicide) when you are ready.");
}
}
/**
* Deletes a monster by index.
*
* When a monster is deleted, all of its objects are deleted.
*/
void delete_monster_idx(int m_idx)
{
int x, y;
s16b this_o_idx, next_o_idx = 0;
monster_type *m_ptr;
assert(m_idx > 0);
m_ptr = cave_monster(cave, m_idx);
/* Monster location */
y = m_ptr->fy;
x = m_ptr->fx;
/* Hack -- Reduce the racial counter */
m_ptr->race->cur_num--;
/* Hack -- count the number of "reproducers" */
if (rf_has(m_ptr->race->flags, RF_MULTIPLY)) num_repro--;
/* Hack -- remove target monster */
if (target_get_monster() == m_ptr) target_set_monster(NULL);
/* Hack -- remove tracked monster */
if (p_ptr->health_who == m_ptr) health_track(p_ptr, NULL);
/* Monster is gone */
cave->m_idx[y][x] = 0;
/* Delete objects */
for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
{
object_type *o_ptr;
/* Get the object */
o_ptr = object_byid(this_o_idx);
/* Get the next object */
next_o_idx = o_ptr->next_o_idx;
/* Preserve unseen artifacts (we assume they were created as this
* monster's drop) - this will cause unintended behaviour in preserve
* off mode if monsters can pick up artifacts */
if (o_ptr->artifact && !object_was_sensed(o_ptr))
o_ptr->artifact->created = FALSE;
/* Clear held_m_idx now to avoid wasting time in delete_object_idx */
o_ptr->held_m_idx = 0;
/* Delete the object */
delete_object_idx(this_o_idx);
}
/* Delete mimicked objects */
if (m_ptr->mimicked_o_idx > 0)
delete_object_idx(m_ptr->mimicked_o_idx);
/* Wipe the Monster */
(void)WIPE(m_ptr, monster_type);
/* Count monsters */
cave->mon_cnt--;
/* Visual update */
cave_light_spot(cave, y, x);
}
/*
* Handle the "death" of a monster.
*
* Disperse treasures centered at the monster location based on the
* various flags contained in the monster flags fields.
*
* Check for "Quest" completion when a quest monster is killed.
*
* Note that only the player can induce "monster_death()" on Uniques or quest monsters.
*
* Note that monsters can now carry objects, and when a monster dies,
* it drops all of its objects, which may disappear in crowded rooms.
*/
void monster_death(int m_idx, int who)
{
int i, j, y, x;
int dump_item = 0;
int dump_gold = 0;
int number_drops = 0;
int total = 0;
bool questlevel = FALSE;
bool completed = FALSE;
bool fixedquest = FALSE;
bool writenote = TRUE;
bool need_stairs = FALSE;
s16b set_object_level;
s16b this_o_idx, next_o_idx = 0;
monster_type *m_ptr = &mon_list[m_idx];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
bool visible = (m_ptr->ml || (r_ptr->flags1 & (RF1_UNIQUE)));
bool chest = (r_ptr->flags1 & (RF1_DROP_CHEST)) ? TRUE : FALSE;
bool good = (r_ptr->flags1 & (RF1_DROP_GOOD)) ? TRUE : FALSE;
bool great = (r_ptr->flags1 & (RF1_DROP_GREAT)) ? TRUE : FALSE;
bool do_gold = (!(r_ptr->flags1 & (RF1_ONLY_ITEM)));
bool do_item = (!(r_ptr->flags1 & (RF1_ONLY_GOLD)));
int force_coin = get_coin_type(r_ptr);
object_type *i_ptr;
object_type object_type_body;
/* Get the location */
y = m_ptr->fy;
x = m_ptr->fx;
/* Drop objects being carried */
for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
{
object_type *o_ptr;
/* Get the object */
o_ptr = &o_list[this_o_idx];
/*Remove the mark to hide when monsters carry this object*/
o_ptr->ident &= ~(IDENT_HIDE_CARRY);
/* Get the next object */
next_o_idx = o_ptr->next_o_idx;
/* Paranoia */
o_ptr->held_m_idx = 0;
/* Get local object */
i_ptr = &object_type_body;
/* Copy the object */
object_copy(i_ptr, o_ptr);
/* Delete the object */
delete_object_idx(this_o_idx);
/* Drop it */
drop_near(i_ptr, -1, y, x);
}
/* Forget objects */
m_ptr->hold_o_idx = 0;
/* Mega-Hack -- drop "winner" treasures */
if (r_ptr->flags1 & (RF1_DROP_CHOSEN))
{
/* Get local object */
i_ptr = &object_type_body;
/* Mega-Hack -- Prepare to make "Grond" */
object_prep(i_ptr, lookup_kind(TV_HAFTED, SV_GROND));
/* Mega-Hack -- Mark this item as "Grond" */
i_ptr->art_num = ART_GROND;
/* Mega-Hack -- Actually create "Grond" */
apply_magic(i_ptr, -1, TRUE, TRUE, TRUE, FALSE);
/* Remember history */
object_history(i_ptr, ORIGIN_MORGOTH, 0);
/* Drop it in the dungeon */
drop_near(i_ptr, -1, y, x);
/* Get local object */
i_ptr = &object_type_body;
/* Mega-Hack -- Prepare to make "Morgoth's crown" */
object_prep(i_ptr, lookup_kind(TV_CROWN, SV_MORGOTH));
/* Mega-Hack -- Mark this item as "Morgoth" */
i_ptr->art_num = ART_MORGOTH;
/* Mega-Hack -- Actually create "Morgoth" */
apply_magic(i_ptr, -1, TRUE, TRUE, TRUE, FALSE);
/* Remember history */
object_history(i_ptr, ORIGIN_MORGOTH, 0);
/* Drop it in the dungeon */
drop_near(i_ptr, -1, y, x);
}
/* Determine how much we can drop */
if ((r_ptr->flags1 & (RF1_DROP_60)) && (rand_int(100) < 60)) number_drops++;
if ((r_ptr->flags1 & (RF1_DROP_90)) && (rand_int(100) < 90)) number_drops++;
if (r_ptr->flags1 & (RF1_DROP_1D2)) number_drops += damroll(1, 2);
if (r_ptr->flags1 & (RF1_DROP_2D2)) number_drops += damroll(2, 2);
if (r_ptr->flags1 & (RF1_DROP_3D2)) number_drops += damroll(3, 2);
if (r_ptr->flags1 & (RF1_DROP_4D2)) number_drops += damroll(4, 2);
/* Hack -- handle creeping coins */
coin_type = force_coin;
/* Average dungeon and monster levels */
set_object_level = object_level = (effective_depth(p_ptr->depth) + r_ptr->level) / 2;
/* Drop some objects */
for (j = 0; j < number_drops; j++)
{
bool interesting = FALSE;
/* Re-set the object level */
object_level = set_object_level;
/* Get local object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
/* work on the "too much junk" problem, large drops sometimes are less items with a "boost". */
if ((randint(750) < (number_drops * number_drops)) && (!(r_ptr->flags1 & (RF1_UNIQUE))))
{
interesting = TRUE;
number_drops -= 5;
object_level += 5;
/*Boundry Control*/
if (number_drops < 0) number_drops = 0;
if (object_level > MAX_DEPTH) object_level = MAX_DEPTH;
}
/* Make Gold */
if (do_gold && (!chest) && (!do_item || (rand_int(100) < 70)))
{
/* Make some gold */
if (!make_gold(i_ptr)) continue;
/* Assume seen XXX XXX XXX */
dump_gold++;
}
/* Make Object */
else
{
if (chest)
{
if (!make_object(i_ptr, good, great, DROP_TYPE_CHEST, FALSE)) continue;
}
/* Make an object */
else if (!make_object(i_ptr, good, great, DROP_TYPE_UNTHEMED, interesting)) continue;
/* Remember history */
if (visible) object_history(i_ptr, ORIGIN_DROP_KNOWN, m_ptr->r_idx);
else object_history(i_ptr, ORIGIN_DROP_UNKNOWN, 0);
/* Assume seen XXX XXX XXX */
dump_item++;
}
/* Drop it in the dungeon */
drop_near(i_ptr, -1, y, x);
}
/* Re-set the object level */
object_level = set_object_level;
/*If marked for a bonus item, create it and drop it */
if (m_ptr->mflag & (MFLAG_BONUS_ITEM))
{
bool this_good = good;
bool this_great = great;
bool this_chest = chest;
bool interesting = FALSE;
char o_name[80];
/* Get local object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
if (one_in_(50)) this_chest = TRUE;
if (one_in_(15)) this_great = TRUE;
if (one_in_(5)) this_good = TRUE;
if ((!this_good) && (!this_great) && (!this_chest))
{
object_level += 5;
if (object_level > MAX_DEPTH) object_level = MAX_DEPTH;
interesting = TRUE;
}
if (this_chest)
{
while (!make_object(i_ptr, TRUE, TRUE, DROP_TYPE_CHEST, FALSE)) continue;
}
/* Make an object */
else while (!make_object(i_ptr, this_good, this_good, DROP_TYPE_UNTHEMED, interesting)) continue;
/* Remember history */
if (visible) object_history(i_ptr, ORIGIN_DROP_KNOWN, m_ptr->r_idx);
else object_history(i_ptr, ORIGIN_DROP_UNKNOWN, 0);
object_desc(o_name, sizeof(o_name), i_ptr, ODESC_PREFIX | ODESC_FULL);
/* Drop it in the dungeon */
drop_near(i_ptr, -1, y, x);
}
/* Reset the object level */
object_level = effective_depth(p_ptr->depth);
/* Reset "coin" type */
coin_type = 0;
/* Take note of any dropped treasure */
if (visible && (dump_item || dump_gold))
{
/* Take notes on treasure */
lore_treasure(m_idx, dump_item, dump_gold);
}
/* Update monster list window */
p_ptr->redraw |= (PR_MONLIST);
/* Count incomplete quests */
for (i = 0; i < z_info->q_max; i++)
{
quest_type *q_ptr = &q_info[i];
/*
* Hack - don't count if player didn't kill, or on a town level
* This assumes only a player can kill quest monsters!!!!!
* This line is also ugly coding. :)
*/
if (((who != SOURCE_PLAYER) && (who != SOURCE_TRAP)) || (!p_ptr->depth)) continue;
/* Quest level? */
if ((q_ptr->active_level == p_ptr->depth) && (p_ptr->depth > 0))
{
/* One on the level */
questlevel = TRUE;
/* Require "Quest Monsters" */
if (q_ptr->mon_idx == m_ptr->r_idx)
{
char race_name[80];
/* Get the monster race name (singular)*/
monster_desc_race(race_name, sizeof(race_name), q_ptr->mon_idx);
/* Mark kills */
q_ptr->cur_num++;
/* Redraw quest indicator */
p_ptr->redraw |= (PR_QUEST_ST);
/* Completed quest? */
if (q_ptr->cur_num == q_ptr->max_num)
{
/* Mark complete */
q_ptr->active_level = 0;
/* Mark fixed quests */
if ((q_ptr->q_type == QUEST_FIXED) ||
(q_ptr->q_type == QUEST_FIXED_U))
fixedquest = TRUE;
if (q_ptr->q_type == QUEST_GUARDIAN) need_stairs = TRUE;
/* One complete */
completed = TRUE;
/*make a note of the completed quest, but not for fixed or
* fixed unique quests
*/
if ((adult_take_notes) && (!fixedquest))
{
char note[120];
/* Multiple quest monsters */
if (q_ptr->max_num > 1)
{
plural_aux(race_name, sizeof(race_name));
}
if (r_ptr->flags1 & (RF1_UNIQUE))
{
/*write note*/
if monster_nonliving(r_ptr)
sprintf(note, "Quest: Destroyed %s", race_name);
else sprintf(note, "Quest: Killed %s", race_name);
}
else
{
/* Write note */
if monster_nonliving(r_ptr)
bool leprechaun_steal(int m_idx)
{
bool result = FALSE;
monster_type *m_ptr = &m_list[m_idx];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
if ( !mon_save_p(m_ptr->r_idx, A_DEX)
|| (MON_CSLEEP(m_ptr) && !mon_save_p(m_ptr->r_idx, A_DEX)))
{
object_type loot = {0};
if (m_ptr->hold_o_idx && one_in_(2))
{
object_copy(&loot, &o_list[m_ptr->hold_o_idx]);
delete_object_idx(m_ptr->hold_o_idx);
loot.held_m_idx = 0;
}
else if (m_ptr->drop_ct > m_ptr->stolen_ct)
{
if (get_monster_drop(m_idx, &loot))
{
m_ptr->stolen_ct++;
if (r_ptr->flags1 & RF1_UNIQUE)
r_ptr->stolen_ct++;
}
}
if (!loot.k_idx)
{
msg_print("There is nothing to steal!");
}
else
{
char o_name[MAX_NLEN];
result = TRUE;
object_desc(o_name, &loot, 0);
if (mon_save_p(m_ptr->r_idx, A_DEX))
{
msg_format("Oops! You drop %s.", o_name);
drop_near(&loot, -1, py, px);
}
else if (loot.tval == TV_GOLD)
{
msg_format("You steal %d gold pieces worth of %s.", (int)loot.pval, o_name);
sound(SOUND_SELL);
p_ptr->au += loot.pval;
stats_on_gold_find(loot.pval);
p_ptr->redraw |= (PR_GOLD);
if (prace_is_(RACE_MON_LEPRECHAUN))
p_ptr->update |= (PU_BONUS | PU_HP | PU_MANA);
}
else if (!inven_carry_okay(&loot))
{
msg_format("You have no room for %s.", o_name);
drop_near(&loot, -1, py, px);
}
else
{
int slot = inven_carry(&loot);
msg_format("You steal %s (%c).", o_name, index_to_label(slot));
autopick_alter_item(slot, TRUE);
}
}
}
return result;
}
