/* Remove a mirror */
void remove_mirror(int y, int x)
{
cave_type *c_ptr = &cave[y][x];
/* Remove the mirror */
c_ptr->info &= ~(CAVE_OBJECT);
c_ptr->mimic = 0;
if (d_info[dungeon_type].flags1 & DF1_DARKNESS)
{
c_ptr->info &= ~(CAVE_GLOW);
if (!view_torch_grids) c_ptr->info &= ~(CAVE_MARK);
/* Update the monster */
if (c_ptr->m_idx) update_mon(c_ptr->m_idx, FALSE);
update_local_illumination(y, x);
}
/* Notice */
note_spot(y, x);
/* Redraw */
lite_spot(y, x);
}
/*
* Un-hide all monsters
*/
static void do_cmd_wiz_unhide(int d)
{
int i;
/* Process monsters */
for (i = 1; i < m_max; i++)
{
monster_type *m_ptr = &m_list[i];
/* Skip dead monsters */
if (!m_ptr->r_idx) continue;
/* Skip distant monsters */
if (m_ptr->cdis > d) continue;
/* Optimize -- Repair flags */
repair_mflag_mark = repair_mflag_show = TRUE;
/* Detect the monster */
m_ptr->mflag |= (MFLAG_MARK | MFLAG_SHOW);
/* Update the monster */
update_mon(i, FALSE);
}
}
void WizardModeDialog::wiz_detect_all_monsters(void)
{
int i;
this->accept();
/* Process monsters */
for (i = 1; i < mon_max; i++)
{
monster_type *m_ptr = &mon_list[i];
/* Skip dead monsters */
if (!m_ptr->r_idx) continue;
/* Optimize -- Repair flags */
repair_mflag_mark = TRUE;
repair_mflag_show = TRUE;
/* Detect the monster */
m_ptr->mflag |= (MFLAG_MARK | MFLAG_SHOW);
/* Update the monster */
update_mon(i, FALSE);
}
}
/**
* Housekeeping after the processing of a player command
*/
static void process_player_cleanup(void)
{
int i;
/* Significant */
if (player->upkeep->energy_use) {
/* Use some energy */
player->energy -= player->upkeep->energy_use;
/* Increment the total energy counter */
player->total_energy += player->upkeep->energy_use;
/* Do nothing else if player has auto-dropped stuff */
if (!player->upkeep->dropping) {
/* Hack -- constant hallucination */
if (player->timed[TMD_IMAGE])
player->upkeep->redraw |= (PR_MAP);
/* Shimmer multi-hued monsters */
for (i = 1; i < cave_monster_max(cave); i++) {
struct monster *mon = cave_monster(cave, i);
if (!mon->race)
continue;
if (!rf_has(mon->race->flags, RF_ATTR_MULTI))
continue;
square_light_spot(cave, mon->fy, mon->fx);
}
/* Clear NICE flag, and show marked monsters */
for (i = 1; i < cave_monster_max(cave); i++) {
struct monster *mon = cave_monster(cave, i);
mflag_off(mon->mflag, MFLAG_NICE);
if (mflag_has(mon->mflag, MFLAG_MARK)) {
if (!mflag_has(mon->mflag, MFLAG_SHOW)) {
mflag_off(mon->mflag, MFLAG_MARK);
update_mon(mon, cave, false);
}
}
}
}
}
/* Clear SHOW flag and player drop status */
for (i = 1; i < cave_monster_max(cave); i++) {
struct monster *mon = cave_monster(cave, i);
mflag_off(mon->mflag, MFLAG_SHOW);
}
player->upkeep->dropping = false;
/* Hack - update needed first because inventory may have changed */
update_stuff(player);
redraw_stuff(player);
}
/*
* Town logic flow for generation of arena -KMW-
*/
static void battle_gen(void)
{
int y, x, i;
int qy = 0;
int qx = 0;
/* Start with solid walls */
for (y = 0; y < MAX_HGT; y++)
{
for (x = 0; x < MAX_WID; x++)
{
/* Create "solid" perma-wall */
place_solid_perm_bold(y, x);
/* Illuminate and memorize the walls */
cave[y][x].info |= (CAVE_GLOW | CAVE_MARK);
}
}
/* Then place some floors */
for (y = qy + 1; y < qy + SCREEN_HGT - 1; y++)
{
for (x = qx + 1; x < qx + SCREEN_WID - 1; x++)
{
/* Create empty floor */
cave[y][x].feat = feat_floor;
}
}
build_battle();
for(i=0;i<4;i++)
{
place_monster_aux(0, py + 8 + (i/2)*4, px - 2 + (i%2)*4, battle_mon[i],
(PM_NO_KAGE | PM_NO_PET));
set_friendly(&m_list[cave[py+8+(i/2)*4][px-2+(i%2)*4].m_idx]);
}
for(i = 1; i < m_max; i++)
{
monster_type *m_ptr = &m_list[i];
if (!m_ptr->r_idx) continue;
/* Hack -- Detect monster */
m_ptr->mflag2 |= (MFLAG2_MARK | MFLAG2_SHOW);
/* Update the monster */
update_mon(i, FALSE);
}
}
/**
* Attempts to place a copy of the given monster at the given position in
* the dungeon.
*
* All of the monster placement routines eventually call this function. This
* is what actually puts the monster in the dungeon (i.e., it notifies the cave
* and sets the monsters position). The dungeon loading code also calls this
* function directly.
*
* `origin` is the item origin to use for any monster drops (e.g. ORIGIN_DROP,
* ORIGIN_DROP_PIT, etc.) The dungeon loading code calls this with origin = 0,
* which prevents the monster's drops from being generated again.
*
* Returns the m_idx of the newly copied monster, or 0 if the placement fails.
*/
s16b place_monster(struct chunk *c, int y, int x, struct monster *mon,
byte origin)
{
s16b m_idx;
struct monster *new_mon;
assert(square_in_bounds(c, y, x));
assert(!square_monster(c, y, x));
/* Get a new record */
m_idx = mon_pop(c);
if (!m_idx) return 0;
/* Copy the monster */
new_mon = cave_monster(c, m_idx);
memcpy(new_mon, mon, sizeof(struct monster));
/* Set the ID */
new_mon->midx = m_idx;
/* Set the location */
c->squares[y][x].mon = new_mon->midx;
new_mon->fy = y;
new_mon->fx = x;
assert(square_monster(c, y, x) == new_mon);
update_mon(new_mon, c, true);
/* Hack -- Count the number of "reproducers" */
if (rf_has(new_mon->race->flags, RF_MULTIPLY)) num_repro++;
/* Count racial occurrences */
new_mon->race->cur_num++;
/* Create the monster's drop, if any */
if (origin)
(void)mon_create_drop(c, new_mon, origin);
/* Make mimics start mimicking */
if (origin && new_mon->race->mimic_kinds) {
mon_create_mimicked_object(c, new_mon, m_idx);
}
/* Result */
return m_idx;
}
/* Player and monster swap places */
bool player_monster_swap(monster_type *m_ptr)
{
char m_name[80];
cave_type *c_ptr;
if (!m_ptr) return FALSE;
if (has_flag(m_ptr, FLAG_NO_PUSHBACK)) return FALSE;
c_ptr = &cave[m_ptr->fy][m_ptr->fx];
m_ptr->csleep = 0;
/* Extract monster name (or "it") */
monster_desc(m_name, m_ptr, 0);
/* Auto-Recall if possible and visible */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx, m_ptr->ego);
/* Track a new monster */
if (m_ptr->ml) health_track(c_ptr->m_idx);
/* displace? */
if (cave_floor_bold(p_ptr->py, p_ptr->px) ||
monst_can_pass_square(m_ptr, p_ptr->py, p_ptr->px, NULL))
{
msg_format("You push past %s.", m_name);
m_ptr->fy = p_ptr->py;
m_ptr->fx = p_ptr->px;
cave[p_ptr->py][p_ptr->px].m_idx = c_ptr->m_idx;
c_ptr->m_idx = 0;
update_mon(cave[p_ptr->py][p_ptr->px].m_idx, TRUE);
return TRUE;
}
else
{
msg_format("%^s is in your way!", m_name);
energy_use = 0;
return FALSE;
}
}
void ai_deincarnate(s32b m_idx)
{
#if 0 // DGDGDGDG
monster_type *m_ptr = get_monster(m_idx);
s32b r2_idx = m_ptr->possessor, r_idx = m_ptr->r_idx;
monster_race *r_ptr = &r_info[r2_idx];
s32b i;
char m_name[80];
monster_desc(m_name, m_ptr, 0x04);
if (m_ptr->ml) msg_format("The soul of %s deincarnates!", m_name);
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 = 0;
/* Update the monster */
update_mon(m_idx, TRUE);
#endif
}
/*!
* @brief 移動先のフロアに伴ったペットを配置する / Place preserved pet monsters on new floor
* @return なし
*/
static void place_pet(void)
{
int i;
int max_num = p_ptr->wild_mode ? 1 : MAX_PARTY_MON;
for (i = 0; i < max_num; i++)
{
POSITION cy = 0, cx = 0;
MONSTER_IDX m_idx;
if (!(party_mon[i].r_idx)) continue;
if (i == 0)
{
m_idx = m_pop();
p_ptr->riding = m_idx;
if (m_idx)
{
cy = p_ptr->y;
cx = p_ptr->x;
}
}
else
{
int j;
POSITION d;
for (d = 1; d < 6; d++)
{
for (j = 1000; j > 0; j--)
{
scatter(&cy, &cx, p_ptr->y, p_ptr->x, d, 0);
if (monster_can_enter(cy, cx, &r_info[party_mon[i].r_idx], 0)) break;
}
if (j) break;
}
m_idx = (d == 6) ? 0 : m_pop();
}
if (m_idx)
{
monster_type *m_ptr = &m_list[m_idx];
monster_race *r_ptr;
cave[cy][cx].m_idx = m_idx;
m_ptr->r_idx = party_mon[i].r_idx;
/* Copy all member of the structure */
*m_ptr = party_mon[i];
r_ptr = real_r_ptr(m_ptr);
m_ptr->fy = cy;
m_ptr->fx = cx;
m_ptr->ml = TRUE;
m_ptr->mtimed[MTIMED_CSLEEP] = 0;
/* Paranoia */
m_ptr->hold_o_idx = 0;
m_ptr->target_y = 0;
if ((r_ptr->flags1 & RF1_FORCE_SLEEP) && !ironman_nightmare)
{
/* Monster is still being nice */
m_ptr->mflag |= (MFLAG_NICE);
/* Must repair monsters */
repair_monsters = TRUE;
}
/* Update the monster */
update_mon(m_idx, TRUE);
lite_spot(cy, cx);
/* Pre-calculated in precalc_cur_num_of_pet() */
/* r_ptr->cur_num++; */
/* Hack -- Count the number of "reproducers" */
if (r_ptr->flags2 & RF2_MULTIPLY) num_repro++;
/* Hack -- Notice new multi-hued monsters */
{
monster_race *ap_r_ptr = &r_info[m_ptr->ap_r_idx];
if (ap_r_ptr->flags1 & (RF1_ATTR_MULTI | RF1_SHAPECHANGER))
shimmer_monsters = TRUE;
}
}
else
{
monster_type *m_ptr = &party_mon[i];
monster_race *r_ptr = real_r_ptr(m_ptr);
char m_name[80];
monster_desc(m_name, m_ptr, 0);
#ifdef JP
msg_format("%sとはぐれてしまった。", m_name);
#else
msg_format("You have lost sight of %s.", m_name);
#endif
if (record_named_pet && m_ptr->nickname)
{
monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
do_cmd_write_nikki(NIKKI_NAMED_PET, RECORD_NAMED_PET_LOST_SIGHT, m_name);
}
/* Pre-calculated in precalc_cur_num_of_pet(), but need to decrease */
if (r_ptr->cur_num) r_ptr->cur_num--;
}
}
/* For accuracy of precalc_cur_num_of_pet() */
(void)C_WIPE(party_mon, MAX_PARTY_MON, monster_type);
}
/**********************************************************************
* Spells: Note, we are still using the old "Book Spell System"
**********************************************************************/
cptr do_necromancy_spell(int spell, int mode)
{
bool name = (mode == SPELL_NAME) ? TRUE : FALSE;
bool desc = (mode == SPELL_DESC) ? TRUE : FALSE;
bool info = (mode == SPELL_INFO) ? TRUE : FALSE;
bool cast = (mode == SPELL_CAST) ? TRUE : FALSE;
bool fail = (mode == SPELL_FAIL) ? TRUE : FALSE;
int plev = p_ptr->lev;
switch (spell)
{
/* Stench of Death */
case 0:
if (name) return "Cold Touch";
if (desc) return "Damage an adjacent monster with a chilling touch.";
if (info) return _necro_info_damage(2, 6, plev + p_ptr->to_d_spell);
if (cast && !_necro_do_touch(GF_COLD, 2, 6, plev + p_ptr->to_d_spell)) return NULL;
break;
case 1:
if (name) return "Summon Rat";
if (desc) return "Summons a rat to feast on the dead!";
if (cast || fail) _necro_do_summon(SUMMON_RAT, 1, fail);
break;
case 2:
if (name) return "Detect Life";
if (desc) return "Detects all living monsters in your vicinity.";
if (info) return info_radius(DETECT_RAD_DEFAULT);
if (cast) detect_monsters_living(DETECT_RAD_DEFAULT, "You sense the presence of life around you.");
break;
case 3:
if (name) return "Detect Unlife";
if (desc) return "Detects all nonliving monsters in your vicinity.";
if (info) return info_radius(DETECT_RAD_DEFAULT);
if (cast) detect_monsters_nonliving(DETECT_RAD_DEFAULT);
break;
case 4:
if (name) return "Poison Touch";
if (desc) return "Damage an adjacent monster with a venomous touch.";
if (info) return _necro_info_damage(4, 6, plev + p_ptr->to_d_spell);
if (cast && !_necro_do_touch(GF_POIS, 4, 6, plev + p_ptr->to_d_spell)) return NULL;
break;
case 5:
if (name) return "Summon Bats";
if (desc) return "Summons bats to feast on the living!";
if (cast || fail) _necro_do_summon(SUMMON_BAT, 1 + randint1(2), fail);
break;
case 6:
if (name) return "Eldritch Howl";
if (desc) return "Emit a terrifying howl.";
if (cast) project_hack(GF_ELDRITCH_HOWL, spell_power(plev * 3));
break;
case 7:
if (name) return "Black Touch";
if (desc) return "Damage an adjacent monster with a dark touch.";
if (info) return _necro_info_damage(6, 6, plev * 3 / 2 + p_ptr->to_d_spell);
if (cast && !_necro_do_touch(GF_DARK, 6, 6, plev * 3 / 2 + p_ptr->to_d_spell)) return NULL;
break;
/* Sepulchral Ways */
case 8:
if (name) return "Summon Wolves";
if (desc) return "Summons wolves to feast on the living!";
if (cast || fail) _necro_do_summon(SUMMON_WOLF, 1 + randint1(2), fail);
break;
case 9:
if (name) return "Black Cloak";
if (desc) return "You become shrouded in darkness.";
if (cast)
{
set_tim_dark_stalker(spell_power(randint1(plev) + plev), FALSE);
}
break;
case 10:
if (name) return "Undead Sight";
if (desc) return "Learn about your nearby surroundings by communing with the dead.";
if (info) return info_radius(DETECT_RAD_MAP);
if (cast)
{
map_area(DETECT_RAD_MAP);
detect_traps(DETECT_RAD_DEFAULT, TRUE);
detect_doors(DETECT_RAD_DEFAULT);
detect_stairs(DETECT_RAD_DEFAULT);
}
break;
case 11:
if (name) return "Undead Lore";
if (desc) return "Ask the dead to examine an object for you.";
if (cast) ident_spell(NULL);
break;
case 12:
if (name) return "Repelling Touch";
if (desc) return "Conjure a foul wind to blow an adjacent monster away.";
if (cast)
{
int y, x, dir;
if (!_necro_check_touch()) return NULL;
if (!get_rep_dir2(&dir)) return NULL;
if (dir == 5) return NULL;
y = py + ddy[dir];
x = px + ddx[dir];
if (!cave[y][x].m_idx)
{
msg_print("There is no monster.");
return NULL;
}
else
{
int i;
int ty = y, tx = x;
int oy = y, ox = x;
int m_idx = cave[y][x].m_idx;
monster_type *m_ptr = &m_list[m_idx];
char m_name[80];
monster_desc(m_name, m_ptr, 0);
touch_zap_player(cave[y][x].m_idx);
for (i = 0; i < 10; i++)
{
y += ddy[dir];
x += ddx[dir];
if (cave_empty_bold(y, x))
{
ty = y;
tx = x;
}
else break;
}
if ((ty != oy) || (tx != ox))
{
msg_format("A foul wind blows %s away!", m_name);
cave[oy][ox].m_idx = 0;
cave[ty][tx].m_idx = m_idx;
m_ptr->fy = ty;
m_ptr->fx = tx;
update_mon(m_idx, TRUE);
lite_spot(oy, ox);
lite_spot(ty, tx);
if (r_info[m_ptr->r_idx].flags7 & (RF7_LITE_MASK | RF7_DARK_MASK))
p_ptr->update |= (PU_MON_LITE);
}
}
}
break;
case 13:
if (name) return "Vampiric Touch";
if (desc) return "Steal life from an adjacent foe.";
if (info) return _necro_info_damage(0, 0, plev * 4 + p_ptr->to_d_spell);
if (cast && !_necro_do_touch(GF_OLD_DRAIN, 0, 0, plev * 4 + p_ptr->to_d_spell)) return NULL;
break;
case 14:
if (name) return "Dread of Night";
if (desc) return "Summons Dread to do your bidding. Beware of failure!";
if (cast || fail) _necro_do_summon(SUMMON_DREAD, 1 + randint0(3), fail);
break;
case 15:
if (name) return "Entomb";
if (desc) return "Entombs chosen foe.";
if (cast)
{
int dir;
if (!get_fire_dir(&dir)) return NULL;
fire_ball_hide(GF_ENTOMB, dir, plev, 0);
p_ptr->update |= (PU_FLOW);
p_ptr->redraw |= (PR_MAP);
}
break;
/* Return of the Dead */
case 16:
if (name) return "Summon Zombies";
if (desc) return "The dead are back and hungry for brains!";
if (cast || fail) _necro_do_summon(SUMMON_ZOMBIE, 2 + randint1(3), fail);
break;
case 17:
if (name) return "Summon Skeletons";
if (desc) return "Summon skeletal assistance.";
if (cast || fail) _necro_do_summon(SUMMON_SKELETON, 1 + randint0(3), fail);
break;
case 18:
if (name) return "Summon Ghosts";
if (desc) return "Recall the spirits of slain warriors for unholy servitude.";
if (cast || fail) _necro_do_summon(SUMMON_GHOST, 1 + randint0(3), fail);
break;
case 19:
if (name) return "Summon Vampires";
if (desc) return "Its time to command the commanders!";
if (cast || fail) _necro_do_summon(SUMMON_VAMPIRE, 1 + randint0(2), fail);
break;
case 20:
if (name) return "Summon Wraiths";
if (desc) return "Summon wights and wraiths to do your bidding.";
if (cast || fail) _necro_do_summon(SUMMON_WIGHT, 1 + randint0(2), fail);
break;
case 21:
if (name) return "Summon Liches";
if (desc) return "Call forth former necromancers.";
if (cast || fail) _necro_do_summon(SUMMON_LICH, 1 + randint0(2), fail);
break;
case 22:
if (name) return "Unholy Word";
if (desc) return "Utter an unspeakable word. The morale of your visible evil pets is temporarily boosted and they will serve you with renewed enthusiasm.";
if (cast) project_hack(GF_UNHOLY_WORD, plev * 6);
break;
case 23:
if (name) return "Lost Cause";
if (desc) return "Make a last ditch Kamikaze effort for victory!";
if (cast) discharge_minion();
break;
/* Necromatic Tome */
case 24:
if (name) return "Draining Touch";
if (desc) return "Steal mana from an adjacent foe.";
if (info) return _necro_info_damage(5, 5, plev/2 + p_ptr->to_d_spell);
if (cast && !_necro_do_touch(GF_DRAINING_TOUCH, 5, 5, plev/2 + p_ptr->to_d_spell)) return NULL;
break;
case 25:
if (name) return "Unhallow Ground";
if (desc) return "Makes the current square unholy.";
if (cast) warding_glyph(); /* TODO: Add new cave feature! */
break;
case 26:
{
int base = spell_power(20);
if (name) return "Shield of the Dead";
if (desc) return "Grants temporary protection";
if (info) return info_duration(base, base);
if (cast)
{
set_tim_res_nether(randint1(base) + base, FALSE);
set_oppose_pois(randint1(base) + base, FALSE);
set_oppose_cold(randint1(base) + base, FALSE);
set_shield(randint1(base) + base, FALSE);
}
break;
}
case 27:
if (name) return "Rending Touch";
if (desc) return "Damage an adjacent monster with a disintegrating touch.";
if (info) return _necro_info_damage(20, 20, plev + p_ptr->to_d_spell);
if (cast && !_necro_do_touch(GF_DISINTEGRATE, 20, 20, plev + p_ptr->to_d_spell)) return NULL;
break;
case 28:
if (name) return "Repose of the Dead";
if (desc) return "Sleep the sleep of the dead for a few rounds, during which time nothing can awaken you, except perhaps death. When (if?) you wake up, you will be thoroughly refreshed!";
if (cast)
{
if (!get_check("You will enter a deep slumber. Are you sure?")) return NULL;
repose_of_the_dead = TRUE;
set_paralyzed(4 + randint1(4), FALSE);
}
break;
case 29:
if (name) return "Sepulchral Wind";
if (desc) return "You call forth the wind of the dead. All nearby monsters are blown away!";
{
int power = spell_power(plev * 4);
if (info) return info_power(power);
if (cast) banish_monsters(power);
}
break;
case 30:
if (name) return "Deadly Touch";
if (desc) return "Attempt to kill an adjacent monster.";
if (cast && !_necro_do_touch(GF_DEATH_TOUCH, 0, 0, plev * 200)) return NULL;
break;
case 31:
if (name) return "Necromancy";
if (desc) return "Bridge the world of the living with the world of the dead! Vast hordes of undead will come forth to serve the one true necromancer!";
if (cast)
{
int i;
int sp_sides = 20 + plev;
int sp_base = plev;
int power = spell_power(plev);
power += randint1(power);
for (i = 0; i < 18; i++)
{
int attempt = 10;
int my, mx, what;
while (attempt--)
{
scatter(&my, &mx, py, px, 4, 0);
/* Require empty grids */
if (cave_empty_bold2(my, mx)) break;
}
if (attempt < 0) continue;
switch (randint1(4))
{
case 1: what = SUMMON_LICH; break;
case 2: what = SUMMON_WIGHT; break;
case 3: what = SUMMON_VAMPIRE; break;
case 4:
default: what = SUMMON_GHOST; break;
}
summon_specific(-1, my, mx, power, what, (PM_ALLOW_GROUP | PM_FORCE_PET | PM_HASTE));
}
set_fast(randint1(sp_sides) + sp_base, FALSE);
}
break;
}
return "";
}
/**
* Attempts to place a copy of the given monster at the given position in
* the dungeon.
*
* All of the monster placement routines eventually call this function. This
* is what actually puts the monster in the dungeon (i.e., it notifies the cave
* and sets the monsters position). The dungeon loading code also calls this
* function directly.
*
* `origin` is the item origin to use for any monster drops (e.g. ORIGIN_DROP,
* ORIGIN_DROP_PIT, etc.) The dungeon loading code calls this with origin = 0,
* which prevents the monster's drops from being generated again.
*
* Returns the m_idx of the newly copied monster, or 0 if the placement fails.
*/
s16b place_monster(int y, int x, monster_type *mon, byte origin)
{
s16b m_idx;
monster_type *m_ptr;
assert(cave_in_bounds(cave, y, x));
assert(!cave_monster_at(cave, y, x));
/* Get a new record */
m_idx = mon_pop();
if (!m_idx) return 0;
/* Copy the monster */
m_ptr = cave_monster(cave, m_idx);
COPY(m_ptr, mon, monster_type);
/* Set the ID */
m_ptr->midx = m_idx;
/* Set the location */
cave->m_idx[y][x] = m_ptr->midx;
m_ptr->fy = y;
m_ptr->fx = x;
assert(cave_monster_at(cave, y, x) == m_ptr);
update_mon(m_ptr, TRUE);
/* Hack -- Count the number of "reproducers" */
if (rf_has(m_ptr->race->flags, RF_MULTIPLY)) num_repro++;
/* Count racial occurrences */
m_ptr->race->cur_num++;
/* Create the monster's drop, if any */
if (origin)
(void)mon_create_drop(m_ptr, origin);
/* Make mimics start mimicking */
if (origin && m_ptr->race->mimic_kinds) {
object_type *i_ptr;
object_type object_type_body;
object_kind *kind = m_ptr->race->mimic_kinds->kind;
struct monster_mimic *mimic_kind;
int i = 1;
/* Pick a random object kind to mimic */
for (mimic_kind = m_ptr->race->mimic_kinds; mimic_kind;
mimic_kind = mimic_kind->next, i++) {
if (one_in_(i)) kind = mimic_kind->kind;
}
i_ptr = &object_type_body;
if (kind->tval == TV_GOLD) {
make_gold(i_ptr, p_ptr->depth, kind->sval);
} else {
object_prep(i_ptr, kind, m_ptr->race->level, RANDOMISE);
apply_magic(i_ptr, m_ptr->race->level, TRUE, FALSE, FALSE, FALSE);
i_ptr->number = 1;
}
i_ptr->origin = origin;
i_ptr->mimicking_m_idx = m_idx;
m_ptr->mimicked_o_idx = floor_carry(cave, y, x, i_ptr);
}
/* Result */
return m_idx;
}
_rush_result _rush_attack(int rng, _rush_type type)
{
_rush_result result = _rush_cancelled;
int tx, ty;
int tm_idx = 0;
u16b path_g[32];
int path_n, i;
bool moved = FALSE;
int flg = 0;
int dis = 0;
if (type == _rush_normal)
flg = PROJECT_STOP | PROJECT_KILL;
else if (type == _rush_acrobatic)
flg = PROJECT_THRU | PROJECT_KILL;
else
flg = PROJECT_DISI | PROJECT_THRU;
if (!p_ptr->duelist_target_idx)
{
msg_print("You need to select a foe first (Mark Target).");
return result;
}
tm_idx = p_ptr->duelist_target_idx;
tx = m_list[tm_idx].fx;
ty = m_list[tm_idx].fy;
dis = distance(ty, tx, py, px);
/* Foe must be visible. For all charges except the phase charge, the
foe must also be in your line of sight */
if (!m_list[p_ptr->duelist_target_idx].ml ||
(type != _rush_phase && !los(ty, tx, py, px)))
{
msg_format("%^s is not in your line of sight.", duelist_current_challenge());
return result;
}
if (dis > rng)
{
msg_format("Your foe is out of range (%d vs %d).", dis, rng);
if (!get_check("Charge anyway? ")) return result;
}
project_length = rng;
path_n = project_path(path_g, project_length, py, px, ty, tx, flg);
project_length = 0;
if (!path_n) return result;
result = _rush_failed;
/* Use ty and tx as to-move point */
ty = py;
tx = px;
/* Scrolling the cave would invalidate our path! */
if (!dun_level && !p_ptr->wild_mode && !p_ptr->inside_arena && !p_ptr->inside_battle)
wilderness_scroll_lock = TRUE;
/* Project along the path */
for (i = 0; i < path_n; i++)
{
monster_type *m_ptr;
cave_type *c_ptr;
bool can_enter = FALSE;
bool old_pass_wall = p_ptr->pass_wall;
int ny = GRID_Y(path_g[i]);
int nx = GRID_X(path_g[i]);
c_ptr = &cave[ny][nx];
switch (type)
{
case _rush_normal:
can_enter = cave_empty_bold(ny, nx) && player_can_enter(c_ptr->feat, 0);
break;
case _rush_acrobatic:
can_enter = !c_ptr->m_idx && player_can_enter(c_ptr->feat, 0);
break;
case _rush_phase:
p_ptr->pass_wall = TRUE;
can_enter = !c_ptr->m_idx && player_can_enter(c_ptr->feat, 0);
p_ptr->pass_wall = old_pass_wall;
break;
}
if (can_enter)
{
ty = ny;
tx = nx;
continue;
}
if (!c_ptr->m_idx)
{
msg_print("Failed!");
break;
}
/* Move player before updating the monster */
if (!player_bold(ty, tx)) move_player_effect(ty, tx, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
moved = TRUE;
/* Update the monster */
update_mon(c_ptr->m_idx, TRUE);
/* Found a monster */
m_ptr = &m_list[c_ptr->m_idx];
/* But it is not the monster we seek! */
if (tm_idx != c_ptr->m_idx)
{
/* Acrobatic Charge attempts to displace monsters on route */
if (type == _rush_acrobatic)
{
/* Swap position of player and monster */
set_monster_csleep(c_ptr->m_idx, 0);
move_player_effect(ny, nx, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
ty = ny;
tx = nx;
continue;
}
/* Normal Charge just attacks first monster on route */
else
msg_format("There is %s in the way!", m_ptr->ml ? (tm_idx ? "another monster" : "a monster") : "someone");
}
/* Attack the monster */
if (tm_idx == p_ptr->duelist_target_idx) result = _rush_succeeded;
py_attack(ny, nx, 0);
break;
}
if (!moved && !player_bold(ty, tx)) move_player_effect(ty, tx, MPE_FORGET_FLOW | MPE_HANDLE_STUFF | MPE_DONT_PICKUP);
if (!dun_level && !p_ptr->wild_mode && !p_ptr->inside_arena && !p_ptr->inside_battle)
{
wilderness_scroll_lock = FALSE;
wilderness_move_player(px, py);
}
return result;
}
/**
* Attempts to place a copy of the given monster at the given position in
* the dungeon.
*
* All of the monster placement routines eventually call this function. This
* is what actually puts the monster in the dungeon (i.e., it notifies the cave
* and sets the monsters position). The dungeon loading code also calls this
* function directly.
*
* `origin` is the item origin to use for any monster drops (e.g. ORIGIN_DROP,
* ORIGIN_DROP_PIT, etc.) The dungeon loading code calls this with origin = 0,
* which prevents the monster's drops from being generated again.
*
* Returns the m_idx of the newly copied monster, or 0 if the placement fails.
*/
s16b place_monster(struct chunk *c, int y, int x, struct monster *mon,
byte origin)
{
s16b m_idx;
struct monster *new_mon;
assert(square_in_bounds(c, y, x));
assert(!square_monster(c, y, x));
/* Get a new record */
m_idx = mon_pop(c);
if (!m_idx) return 0;
/* Copy the monster */
new_mon = cave_monster(c, m_idx);
memcpy(new_mon, mon, sizeof(struct monster));
/* Set the ID */
new_mon->midx = m_idx;
/* Set the location */
c->squares[y][x].mon = new_mon->midx;
new_mon->fy = y;
new_mon->fx = x;
assert(square_monster(c, y, x) == new_mon);
update_mon(new_mon, c, true);
/* Hack -- Count the number of "reproducers" */
if (rf_has(new_mon->race->flags, RF_MULTIPLY)) num_repro++;
/* Count racial occurrences */
new_mon->race->cur_num++;
/* Create the monster's drop, if any */
if (origin)
(void)mon_create_drop(c, new_mon, origin);
/* Make mimics start mimicking */
if (origin && new_mon->race->mimic_kinds) {
struct object *obj;
struct object_kind *kind = new_mon->race->mimic_kinds->kind;
struct monster_mimic *mimic_kind;
int i = 1;
/* Pick a random object kind to mimic */
for (mimic_kind = new_mon->race->mimic_kinds; mimic_kind;
mimic_kind = mimic_kind->next, i++) {
if (one_in_(i)) kind = mimic_kind->kind;
}
if (tval_is_money_k(kind)) {
obj = make_gold(player->depth, kind->name);
} else {
obj = object_new();
object_prep(obj, kind, new_mon->race->level, RANDOMISE);
apply_magic(obj, new_mon->race->level, true, false, false, false);
obj->number = 1;
obj->origin = ORIGIN_DROP_MIMIC;
obj->origin_depth = player->depth;
}
obj->mimicking_m_idx = m_idx;
new_mon->mimicked_obj = obj;
/* Put the object on the floor if it goes, otherwise no mimicry */
if (floor_carry(c, y, x, obj, false)) {
list_object(c, obj);
} else {
/* Clear the mimicry */
obj->mimicking_m_idx = 0;
new_mon->mimicked_obj = NULL;
/* Give the object to the monster if appropriate */
if (rf_has(new_mon->race->flags, RF_MIMIC_INV)) {
monster_carry(c, new_mon, obj);
} else {
/* Otherwise delete the mimicked object */
object_delete(&obj);
}
}
}
/* Result */
return m_idx;
}
