int SCHED_CONFIG::parse_file(const char* dir) {
char path[MAXPATHLEN], path_aux[MAXPATHLEN];
int retval;
if (dir && strlen(dir)) {
snprintf(path, sizeof(path), "%s/%s", dir, CONFIG_FILE);
snprintf(path_aux, sizeof(path_aux), "%s/%s", dir, CONFIG_FILE_AUX);
} else {
safe_strcpy(path, project_path(CONFIG_FILE));
safe_strcpy(path_aux, project_path(CONFIG_FILE_AUX));
}
#ifndef _USING_FCGI_
FILE* f = fopen(path, "r");
#else
FCGI_FILE *f = FCGI::fopen(path, "r");
#endif
if (!f) return ERR_FOPEN;
retval = parse(f);
fclose(f);
if (retval) return retval;
#ifndef _USING_FCGI_
FILE* f_aux = fopen(path_aux, "r");
#else
FCGI_FILE *f_aux = FCGI::fopen(path_aux, "r");
#endif
if (!f_aux) return 0;
retval = parse_aux(f_aux);
fclose(f_aux);
return retval;
}
std::string FindProjectIncludeDirectory::get_project_include_directory() {
std::string project_include = "";
if (m_project_directory.empty()) {
return project_include;
}
std::string indent = " \"";
std::string end_indent = "\",\n";
boost::filesystem::path project_path(m_project_directory);
for (boost::filesystem::directory_entry &dir_entry: boost::filesystem::directory_iterator(project_path)) {
boost::filesystem::path single_path(dir_entry.path());
single_path += "\\Inc";
if (!boost::filesystem::is_directory(single_path)) {
continue;
}
for (auto &sub_dir_entry: boost::filesystem::directory_iterator(single_path)) {
project_include += indent;
project_include += sub_dir_entry.path().string();
project_include += end_indent;
}
}
return project_include;
}
//---------------------------------------------------------------------------------------
void SkUERemote::get_project_info(SkProjectInfo * out_project_info_p)
{
// Get platform id string
out_project_info_p->m_platform_id = FStringToAString(UGameplayStatics::GetPlatformName());
// Get engine id string
out_project_info_p->m_engine_id.ensure_size(20);
out_project_info_p->m_engine_id.format("UE%d.%d.%d-%s", ENGINE_MAJOR_VERSION, ENGINE_MINOR_VERSION, ENGINE_PATCH_VERSION, BUILT_FROM_CHANGELIST ? "Installed" : "Compiled");
// Get game name
out_project_info_p->m_project_name = FStringToAString(FApp::GetGameName());
// Name of generated scripts overlay
TCHAR const * const generated_overlay_name_p = TEXT("Project-Generated");
// Look for default SkookumScript project file in engine folder.
FString default_project_path(FPaths::EnginePluginsDir() / TEXT("SkookumScript/Scripts/Skookum-project-default.ini"));
SK_ASSERTX(FPaths::FileExists(default_project_path), a_str_format("Cannot find default project settings file '%S'!", *default_project_path));
out_project_info_p->m_default_project_path = FStringToAString(FPaths::ConvertRelativePathToFull(default_project_path));
// Check if we have loaded any game
if (!out_project_info_p->m_project_name.is_empty())
{
// Look for specific SkookumScript project in game/project folder.
// 1) Check permanent location
FString project_path(FPaths::GameDir() / TEXT("Scripts/Skookum-project.ini"));
if (FPaths::FileExists(project_path))
{
#if WITH_EDITORONLY_DATA
if (m_editor_interface_p)
{
m_editor_interface_p->set_overlay_path(FPaths::GetPath(project_path), generated_overlay_name_p);
}
#endif
}
else
{
project_path.Empty();
#if WITH_EDITORONLY_DATA
if (m_editor_interface_p)
{
// 2) Check/create temp location
project_path = m_editor_interface_p->ensure_temp_project(generated_overlay_name_p);
SK_ASSERTX(!project_path.IsEmpty(), a_str_format("Could not generated project file '%S' for project '%s'!", *project_path, out_project_info_p->m_project_name.as_cstr()));
}
#endif
}
out_project_info_p->m_project_path = FStringToAString(FPaths::ConvertRelativePathToFull(project_path));
}
}
/*!
* @brief モンスターにとってボルト型魔法が有効な状態かを返す /
* Determine if a bolt spell will hit the player.
* @param y1 ボルト魔法発射地点のY座標
* @param x1 ボルト魔法発射地点のX座標
* @param y2 ボルト魔法目標地点のY座標
* @param x2 ボルト魔法目標地点のX座標
* @param is_friend モンスターがプレイヤーに害意を持たない(ペットか友好的)ならばTRUEをつける
* @return ボルト型魔法が有効ならばTRUEを返す。
* @details
* Originally, it was possible for a friendly to shoot another friendly.\n
* Change it so a "clean shot" means no equally friendly monster is\n
* between the attacker and target.\n
*\n
* This is exactly like "projectable", but it will\n
* return FALSE if a monster is in the way.\n
* no equally friendly monster is\n
* between the attacker and target.\n
*/
bool clean_shot(int y1, int x1, int y2, int x2, bool is_friend)
{
/* Must be the same as projectable() */
int i, y, x;
int grid_n = 0;
u16b grid_g[512];
/* Check the projection path */
grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, 0);
/* No grid is ever projectable from itself */
if (!grid_n) return (FALSE);
/* Final grid */
y = GRID_Y(grid_g[grid_n-1]);
x = GRID_X(grid_g[grid_n-1]);
/* May not end in an unrequested grid */
if ((y != y2) || (x != x2)) return (FALSE);
for (i = 0; i < grid_n; i++)
{
y = GRID_Y(grid_g[i]);
x = GRID_X(grid_g[i]);
if ((cave[y][x].m_idx > 0) && !((y == y2) && (x == x2)))
{
monster_type *m_ptr = &m_list[cave[y][x].m_idx];
if (is_friend == is_pet(m_ptr))
{
return (FALSE);
}
}
/* Pets may not shoot through the character - TNB */
if (player_bold(y, x))
{
if (is_friend) return (FALSE);
}
}
return (TRUE);
}
/*!
* @brief モンスターが特殊能力の目標地点を決める処理 /
* Get the actual center point of ball spells (rad > 1) (originally from TOband)
* @param sy 始点のY座標
* @param sx 始点のX座標
* @param ty 目標Y座標を返す参照ポインタ
* @param tx 目標X座標を返す参照ポインタ
* @param flg 判定のフラグ配列
* @return なし
*/
void get_project_point(int sy, int sx, int *ty, int *tx, int flg)
{
u16b path_g[128];
int path_n, i;
path_n = project_path(path_g, MAX_RANGE, sy, sx, *ty, *tx, flg);
*ty = sy;
*tx = sx;
/* Project along the path */
for (i = 0; i < path_n; i++)
{
sy = GRID_Y(path_g[i]);
sx = GRID_X(path_g[i]);
/* Hack -- Balls explode before reaching walls */
if (!cave_have_flag_bold(sy, sx, FF_PROJECT)) break;
*ty = sy;
*tx = sx;
}
}
/*!
* @brief モンスターが敵対モンスターにビームを当てること可能かを判定する /
* Determine if a beam spell will hit the target.
* @param y1 始点のY座標
* @param x1 始点のX座標
* @param y2 目標のY座標
* @param x2 目標のX座標
* @param m_ptr 使用するモンスターの構造体参照ポインタ
* @return ビームが到達可能ならばTRUEを返す
*/
static bool direct_beam(int y1, int x1, int y2, int x2, monster_type *m_ptr)
{
bool hit2 = FALSE;
int i, y, x;
int grid_n = 0;
u16b grid_g[512];
bool is_friend = is_pet(m_ptr);
/* Check the projection path */
grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, PROJECT_THRU);
/* No grid is ever projectable from itself */
if (!grid_n) return (FALSE);
for (i = 0; i < grid_n; i++)
{
y = GRID_Y(grid_g[i]);
x = GRID_X(grid_g[i]);
if (y == y2 && x == x2)
hit2 = TRUE;
else if (is_friend && cave[y][x].m_idx > 0 &&
!are_enemies(m_ptr, &m_list[cave[y][x].m_idx]))
{
/* Friends don't shoot friends */
return FALSE;
}
if (is_friend && player_bold(y, x))
return FALSE;
}
if (!hit2)
return FALSE;
return TRUE;
}
/**
* This is a helper function used by do_cmd_throw and do_cmd_fire.
*
* It abstracts out the projectile path, display code, identify and clean up
* logic, while using the 'attack' parameter to do work particular to each
* kind of attack.
*/
static void ranged_helper(int item, int dir, int range, int shots, ranged_attack attack) {
/* Get the ammo */
object_type *o_ptr = object_from_item_idx(item);
int i, j;
byte missile_attr = object_attr(o_ptr);
char missile_char = object_char(o_ptr);
object_type object_type_body;
object_type *i_ptr = &object_type_body;
char o_name[80];
int path_n;
u16b path_g[256];
int msec = op_ptr->delay_factor;
/* Start at the player */
int x = p_ptr->px;
int y = p_ptr->py;
/* Predict the "target" location */
s16b ty = y + 99 * ddy[dir];
s16b tx = x + 99 * ddx[dir];
bool hit_target = FALSE;
/* Check for target validity */
if ((dir == 5) && target_okay()) {
int taim;
char msg[80];
target_get(&tx, &ty);
taim = distance(y, x, ty, tx);
if (taim > range) {
sprintf (msg, "Target out of range by %d squares. Fire anyway? ",
taim - range);
if (!get_check(msg)) return;
}
}
/* Sound */
sound(MSG_SHOOT);
object_notice_on_firing(o_ptr);
/* Describe the object */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_FULL | ODESC_SINGULAR);
/* Actually "fire" the object -- Take a partial turn */
p_ptr->energy_use = (100 / shots);
/* Calculate the path */
path_n = project_path(path_g, range, y, x, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff(p_ptr);
/* Start at the player */
x = p_ptr->px;
y = p_ptr->py;
/* Project along the path */
for (i = 0; i < path_n; ++i) {
int ny = GRID_Y(path_g[i]);
int nx = GRID_X(path_g[i]);
/* Hack -- Stop before hitting walls */
if (!cave_floor_bold(ny, nx)) break;
/* Advance */
x = nx;
y = ny;
/* Only do visuals if the player can "see" the missile */
if (player_can_see_bold(y, x)) {
print_rel(missile_char, missile_attr, y, x);
move_cursor_relative(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff(p_ptr);
Term_xtra(TERM_XTRA_DELAY, msec);
cave_light_spot(cave, y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff(p_ptr);
} else {
/* Delay anyway for consistency */
Term_xtra(TERM_XTRA_DELAY, msec);
}
/* Handle monster */
if (cave->m_idx[y][x] > 0) break;
}
/* Try the attack on the monster at (x, y) if any */
if (cave->m_idx[y][x] > 0) {
monster_type *m_ptr = cave_monster(cave, cave->m_idx[y][x]);
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int visible = m_ptr->ml;
bool fear = FALSE;
char m_name[80];
const char *note_dies = monster_is_unusual(r_ptr) ? " is destroyed." : " dies.";
struct attack_result result = attack(o_ptr, y, x);
int dmg = result.dmg;
u32b msg_type = result.msg_type;
const char *hit_verb = result.hit_verb;
if (result.success) {
hit_target = TRUE;
/* Get "the monster" or "it" */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
object_notice_attack_plusses(o_ptr);
/* No negative damage; change verb if no damage done */
if (dmg <= 0) {
dmg = 0;
hit_verb = "fail to harm";
}
if (!visible) {
/* Invisible monster */
msgt(MSG_SHOOT_HIT, "The %s finds a mark.", o_name);
} else {
/* Visible monster */
if (msg_type == MSG_SHOOT_HIT)
msgt(MSG_SHOOT_HIT, "The %s %s %s.", o_name, hit_verb, m_name);
else if (msg_type == MSG_HIT_GOOD) {
msgt(MSG_HIT_GOOD, "The %s %s %s. %s", o_name, hit_verb, m_name, "It was a good hit!");
} else if (msg_type == MSG_HIT_GREAT) {
msgt(MSG_HIT_GREAT, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a great hit!");
} else if (msg_type == MSG_HIT_SUPERB) {
msgt(MSG_HIT_SUPERB, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a superb hit!");
}
/* Track this monster */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
if (m_ptr->ml) health_track(p_ptr, cave->m_idx[y][x]);
}
/* Complex message */
if (p_ptr->wizard)
msg("You do %d (out of %d) damage.", dmg, m_ptr->hp);
/* Hit the monster, check for death */
if (!mon_take_hit(cave->m_idx[y][x], dmg, &fear, note_dies)) {
message_pain(cave->m_idx[y][x], dmg);
if (fear && m_ptr->ml)
add_monster_message(m_name, cave->m_idx[y][x], MON_MSG_FLEE_IN_TERROR, TRUE);
}
}
}
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
object_split(i_ptr, o_ptr, 1);
/* See if the ammunition broke or not */
j = breakage_chance(i_ptr, hit_target);
/* Drop (or break) near that location */
drop_near(cave, i_ptr, j, y, x, TRUE);
if (item >= 0) {
/* The ammo is from the inventory */
inven_item_increase(item, -1);
inven_item_describe(item);
inven_item_optimize(item);
} else {
/* The ammo is from the floor */
floor_item_increase(0 - item, -1);
floor_item_optimize(0 - item);
}
}
/*
* Handle "target" and "look".
*
* Note that this code can be called from "get_aim_dir()".
*
* Currently, when "flag" is true, that is, when
* "interesting" grids are being used, and a directional key is used, we
* only scroll by a single panel, in the direction requested, and check
* for any interesting grids on that panel. The "correct" solution would
* actually involve scanning a larger set of grids, including ones in
* panels which are adjacent to the one currently scanned, but this is
* overkill for this function. XXX XXX
*
* Hack -- targetting/observing an "outer border grid" may induce
* problems, so this is not currently allowed.
*
* The player can use the direction keys to move among "interesting"
* grids in a heuristic manner, or the "space", "+", and "-" keys to
* move through the "interesting" grids in a sequential manner, or
* can enter "location" mode, and use the direction keys to move one
* grid at a time in any direction. The "t" (set target) command will
* only target a monster (as opposed to a location) if the monster is
* target_able and the "interesting" mode is being used.
*
* The current grid is described using the "look" method above, and
* a new command may be entered at any time, but note that if the
* "TARGET_LOOK" bit flag is set (or if we are in "location" mode,
* where "space" has no obvious meaning) then "space" will scan
* through the description of the current grid until done, instead
* of immediately jumping to the next "interesting" grid. This
* allows the "target" command to retain its old semantics.
*
* The "*", "+", and "-" keys may always be used to jump immediately
* to the next (or previous) interesting grid, in the proper mode.
*
* The "return" key may always be used to scan through a complete
* grid description (forever).
*
* This command will cancel any old target, even if used from
* inside the "look" command.
*
*
* 'mode' is one of TARGET_LOOK or TARGET_KILL.
* 'x' and 'y' are the initial position of the target to be highlighted,
* or -1 if no location is specified.
* Returns TRUE if a target has been successfully set, FALSE otherwise.
*/
bool target_set_interactive(int mode, int x, int y)
{
int py = p_ptr->py;
int px = p_ptr->px;
int path_n;
u16b path_g[256];
int i, d, m, t, bd;
int wid, hgt, help_prompt_loc;
bool done = FALSE;
bool flag = TRUE;
bool help = FALSE;
//struct keypress query;
ui_event press;
/* These are used for displaying the path to the target */
wchar_t path_char[MAX_RANGE_LGE];
int path_attr[MAX_RANGE_LGE];
struct point_set *targets;
/* If we haven't been given an initial location, start on the
player. */
if (x == -1 || y == -1)
{
x = p_ptr->px;
y = p_ptr->py;
}
/* If we /have/ been given an initial location, make sure we
honour it by going into "free targetting" mode. */
else
{
flag = FALSE;
}
/* Cancel target */
target_set_monster(0);
/* Cancel tracking */
/* health_track(NULL); */
/* Calculate the window location for the help prompt */
Term_get_size(&wid, &hgt);
help_prompt_loc = hgt - 1;
/* Display the help prompt */
prt("Press '?' for help.", help_prompt_loc, 0);
/* Prepare the target set */
targets = target_set_interactive_prepare(mode);
/* Start near the player */
m = 0;
/* Interact */
while (!done) {
bool path_drawn = FALSE;
/* Interesting grids */
if (flag && point_set_size(targets))
{
y = targets->pts[m].y;
x = targets->pts[m].x;
/* Adjust panel if needed */
if (adjust_panel_help(y, x, help)) handle_stuff(p_ptr);
/* Update help */
if (help) {
bool good_target = target_able(cave_monster_at(cave, y, x));
target_display_help(good_target, !(flag && point_set_size(targets)));
}
/* Find the path. */
path_n = project_path(path_g, MAX_RANGE, py, px, y, x, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if (mode & (TARGET_KILL))
path_drawn = draw_path(path_n, path_g, path_char, path_attr, py, px);
/* Describe and Prompt */
press = target_set_interactive_aux(y, x, mode);
/* Remove the path */
if (path_drawn) load_path(path_n, path_g, path_char, path_attr);
/* Cancel tracking */
/* health_track(NULL); */
/* Assume no "direction" */
d = 0;
/* Analyze */
if (press.type == EVT_MOUSE) {
if (press.mouse.button == 3) {
/* give the target selection command */
press.mouse.button = 2;
press.mouse.mods = KC_MOD_CONTROL;
}
if (press.mouse.button == 2) {
y = KEY_GRID_Y(press);//.mouse.y;
x = KEY_GRID_X(press);//.mouse.x;
if (press.mouse.mods & KC_MOD_CONTROL) {
/* same as keyboard target selection command below */
struct monster *m = cave_monster_at(cave, y, x);
if (target_able(m)) {
/* Set up target information */
monster_race_track(m->race);
health_track(p_ptr, m);
target_set_monster(m);
done = TRUE;
} else {
bell("Illegal target!");
}
} else
if (press.mouse.mods & KC_MOD_ALT) {
/* go to spot - same as 'g' command below */
cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, y, x);
done = TRUE;
} else
{
/* cancel look mode */
done = TRUE;
}
} else
/*if (press.mouse.button == 3) {
} else*/
{
y = KEY_GRID_Y(press);//.mouse.y;
x = KEY_GRID_X(press);//.mouse.x;
if (cave->m_idx[y][x] || cave->o_idx[y][x]){// || cave->feat[y][x]&) {
/* reset the flag, to make sure we stay in this mode if
* something is actually there */
flag = FALSE;
/* scan the interesting list and see if there in anything here */
for (i = 0; i < point_set_size(targets); i++) {
if ((y == targets->pts[i].y) && (x == targets->pts[i].x)) {
m = i;
flag = TRUE;
break;
}
}
} else {
flag = FALSE;
}
}
} else
switch (press.key.code)
{
case ESCAPE:
case 'q':
{
done = TRUE;
break;
}
case ' ':
case '*':
case '+':
{
if (++m == point_set_size(targets))
m = 0;
break;
}
case '-':
{
if (m-- == 0)
m = point_set_size(targets) - 1;
break;
}
case 'p':
{
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff(p_ptr);
y = p_ptr->py;
x = p_ptr->px;
}
case 'o':
{
flag = FALSE;
break;
}
case 'm':
{
break;
}
case 't':
case '5':
case '0':
case '.':
{
struct monster *m = cave_monster_at(cave, y, x);
if (target_able(m))
{
health_track(p_ptr, m);
target_set_monster(m);
done = TRUE;
}
else
{
bell("Illegal target!");
}
break;
}
case 'g':
{
cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, y, x);
done = TRUE;
break;
}
case '?':
{
help = !help;
/* Redraw main window */
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
handle_stuff(p_ptr);
if (!help)
prt("Press '?' for help.", help_prompt_loc, 0);
break;
}
default:
{
/* Extract direction */
d = target_dir(press.key);
/* Oops */
if (!d) bell("Illegal command for target mode!");
break;
}
}
/* Hack -- move around */
if (d)
{
int old_y = targets->pts[m].y;
int old_x = targets->pts[m].x;
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d], targets);
/* Scroll to find interesting grid */
if (i < 0)
{
int old_wy = Term->offset_y;
int old_wx = Term->offset_x;
/* Change if legal */
if (change_panel(d))
{
/* Recalculate interesting grids */
point_set_dispose(targets);
targets = target_set_interactive_prepare(mode);
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d], targets);
/* Restore panel if needed */
if ((i < 0) && modify_panel(Term, old_wy, old_wx))
{
/* Recalculate interesting grids */
point_set_dispose(targets);
targets = target_set_interactive_prepare(mode);
}
/* Handle stuff */
handle_stuff(p_ptr);
}
}
/* Use interesting grid if found */
if (i >= 0) m = i;
}
}
/* Arbitrary grids */
else
{
/* Update help */
if (help)
{
bool good_target = target_able(cave_monster_at(cave, y, x));
target_display_help(good_target, !(flag && point_set_size(targets)));
}
/* Find the path. */
path_n = project_path(path_g, MAX_RANGE, py, px, y, x, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if (mode & (TARGET_KILL))
path_drawn = draw_path (path_n, path_g, path_char, path_attr, py, px);
/* Describe and Prompt (enable "TARGET_LOOK") */
press = target_set_interactive_aux(y, x, mode | TARGET_LOOK);
/* Remove the path */
if (path_drawn) load_path(path_n, path_g, path_char, path_attr);
/* Cancel tracking */
/* health_track(0); */
/* Assume no direction */
d = 0;
/* Analyze the keypress */
if (press.type == EVT_MOUSE) {
if (press.mouse.button == 3) {
/* give the target selection command */
press.mouse.button = 2;
press.mouse.mods = KC_MOD_CONTROL;
}
if (press.mouse.button == 2) {
if (mode & (TARGET_KILL)) {
if ((y == KEY_GRID_Y(press))
&& (x == KEY_GRID_X(press))) {
d = -1;
}
}
y = KEY_GRID_Y(press);//.mouse.y;
x = KEY_GRID_X(press);//.mouse.x;
if (press.mouse.mods & KC_MOD_CONTROL) {
/* same as keyboard target selection command below */
target_set_location(y, x);
done = TRUE;
} else
if (press.mouse.mods & KC_MOD_ALT) {
/* go to spot - same as 'g' command below */
cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, y, x);
done = TRUE;
} else
{
/* cancel look mode */
done = TRUE;
if (d == -1) {
target_set_location(y, x);
d = 0;
}
}
} else
/*if (press.mouse.button == 3) {
} else*/
{
int dungeon_hgt = cave->height;
int dungeon_wid = cave->width;
y = KEY_GRID_Y(press);//.mouse.y;
x = KEY_GRID_X(press);//.mouse.x;
if (Term) {
if (press.mouse.y <= 1) {
/* move the screen north */
y--;
} else
if (press.mouse.y >= (Term->hgt - 2)) {
/* move the screen south */
y++;
} else
if (press.mouse.x <= COL_MAP) {
/* move the screen in west */
x--;
} else
if (press.mouse.x >= (Term->wid - 2)) {
/* move the screen east */
x++;
}
}
if (y < 0) y = 0;
if (x < 0) x = 0;
if (y >= dungeon_hgt-1) y = dungeon_hgt-1;
if (x >= dungeon_wid-1) x = dungeon_wid-1;
/* Adjust panel if needed */
if (adjust_panel_help(y, x, help))
{
/* Handle stuff */
handle_stuff(p_ptr);
/* Recalculate interesting grids */
point_set_dispose(targets);
targets = target_set_interactive_prepare(mode);
}
if (cave->m_idx[y][x] || cave->o_idx[y][x]) {
/* scan the interesting list and see if there in anything here */
for (i = 0; i < point_set_size(targets); i++) {
if ((y == targets->pts[i].y) && (x == targets->pts[i].x)) {
m = i;
flag = TRUE;
break;
}
}
} else {
flag = FALSE;
}
}
} else
switch (press.key.code)
{
case ESCAPE:
case 'q':
{
done = TRUE;
break;
}
case ' ':
case '*':
case '+':
case '-':
{
break;
}
case 'p':
{
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff(p_ptr);
y = p_ptr->py;
x = p_ptr->px;
}
case 'o':
{
break;
}
case 'm':
{
flag = TRUE;
m = 0;
bd = 999;
/* Pick a nearby monster */
for (i = 0; i < point_set_size(targets); i++)
{
t = distance(y, x, targets->pts[i].y, targets->pts[i].x);
/* Pick closest */
if (t < bd)
{
m = i;
bd = t;
}
}
/* Nothing interesting */
if (bd == 999) flag = FALSE;
break;
}
case 't':
case '5':
case '0':
case '.':
{
target_set_location(y, x);
done = TRUE;
break;
}
case 'g':
{
cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, y, x);
done = TRUE;
break;
}
case '?':
{
help = !help;
/* Redraw main window */
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
handle_stuff(p_ptr);
if (!help)
prt("Press '?' for help.", help_prompt_loc, 0);
break;
}
default:
{
/* Extract a direction */
d = target_dir(press.key);
/* Oops */
if (!d) bell("Illegal command for target mode!");
break;
}
}
/* Handle "direction" */
if (d)
{
int dungeon_hgt = cave->height;
int dungeon_wid = cave->width;
/* Move */
x += ddx[d];
y += ddy[d];
/* Slide into legality */
if (x >= dungeon_wid - 1) x--;
else if (x <= 0) x++;
/* Slide into legality */
if (y >= dungeon_hgt - 1) y--;
else if (y <= 0) y++;
/* Adjust panel if needed */
if (adjust_panel_help(y, x, help))
{
/* Handle stuff */
handle_stuff(p_ptr);
/* Recalculate interesting grids */
point_set_dispose(targets);
targets = target_set_interactive_prepare(mode);
}
}
}
}
/* Forget */
point_set_dispose(targets);
/* Redraw as necessary */
if (help)
{
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
}
else
{
prt("", 0, 0);
prt("", help_prompt_loc, 0);
p_ptr->redraw |= (PR_DEPTH | PR_STATUS);
}
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff(p_ptr);
/* Failure to set target */
if (!target_set) return (FALSE);
/* Success */
return (TRUE);
}
/*
* Fire an object from the pack or floor.
*
* You may only fire items that "match" your missile launcher.
*
* See "calc_bonuses()" for more calculations and such.
*
* Note that "firing" a missile is MUCH better than "throwing" it.
*
* Note: "unseen" monsters are very hard to hit.
*
* Objects are more likely to break if they "attempt" to hit a monster.
*
* Rangers (with Bows) and Anyone (with "Extra Shots") get extra shots.
* The "extra shot" code works by decreasing the amount of energy
* required to make each shot, spreading the shots out over time.
*
* Note that when firing missiles, the launcher multiplier is applied
* after all the bonuses are added in, making multipliers very useful.
*
* Note that Bows of "Extra Might" get extra range and an extra bonus
* for the damage multiplier.
*/
void do_cmd_fire(cmd_code code, cmd_arg args[])
{
int dir, item;
int i, j, y, x;
s16b ty, tx;
int tdam, tdis, thits;
int bonus, chance;
object_type *o_ptr;
object_type *j_ptr;
object_type *i_ptr;
object_type object_type_body;
bool hit_body = FALSE;
byte missile_attr;
char missile_char;
char o_name[80];
u32b msg_type = 0;
int path_n;
u16b path_g[256];
int msec = op_ptr->delay_factor * op_ptr->delay_factor;
/* Get the "bow" */
j_ptr = &p_ptr->inventory[INVEN_BOW];
/* Require a usable launcher */
if (!j_ptr->tval || !p_ptr->state.ammo_tval)
{
msg_print("You have nothing to fire with.");
return;
}
/* Get item to fire and direction to fire in. */
item = args[0].item;
dir = args[1].direction;
/* Check the item being fired is usable by the player. */
if (!item_is_available(item, NULL, (USE_EQUIP | USE_INVEN | USE_FLOOR)))
{
msg_format("That item is not within your reach.");
return;
}
/* Get the object for the ammo */
o_ptr = object_from_item_idx(item);
/* Check the ammo can be used with the launcher */
if (o_ptr->tval != p_ptr->state.ammo_tval)
{
msg_format("That ammo cannot be fired by your current weapon.");
return;
}
/* Base range XXX XXX */
tdis = 6 + 2 * p_ptr->state.ammo_mult;
/* Start at the player */
x = p_ptr->px;
y = p_ptr->py;
/* Predict the "target" location */
ty = y + 99 * ddy[dir];
tx = x + 99 * ddx[dir];
/* Check for target validity */
if ((dir == 5) && target_okay())
{
target_get(&tx, &ty);
if (distance(y, x, ty, tx) > tdis)
{
if (!get_check("Target out of range. Fire anyway? "))
return;
}
}
/* Sound */
sound(MSG_SHOOT);
object_notice_on_firing(o_ptr);
/* Describe the object */
object_desc(o_name, sizeof(o_name), o_ptr, ODESC_FULL | ODESC_SINGULAR);
/* Find the color and symbol for the object for throwing */
missile_attr = object_attr(o_ptr);
missile_char = object_char(o_ptr);
/* Use the proper number of shots */
thits = p_ptr->state.num_fire;
/* Actually "fire" the object */
bonus = (p_ptr->state.to_h + o_ptr->to_h + j_ptr->to_h);
chance = p_ptr->state.skills[SKILL_TO_HIT_BOW] +
(bonus * BTH_PLUS_ADJ);
/* Take a (partial) turn */
p_ptr->energy_use = (100 / thits);
/* Calculate the path */
path_n = project_path(path_g, tdis, y, x, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff();
/* Project along the path */
for (i = 0; i < path_n; ++i)
{
int ny = GRID_Y(path_g[i]);
int nx = GRID_X(path_g[i]);
/* Hack -- Stop before hitting walls */
if (!cave_floor_bold(ny, nx)) break;
/* Advance */
x = nx;
y = ny;
/* Only do visuals if the player can "see" the missile */
if (player_can_see_bold(y, x))
{
/* Visual effects */
print_rel(missile_char, missile_attr, y, x);
move_cursor_relative(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
Term_xtra(TERM_XTRA_DELAY, msec);
light_spot(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
}
/* Delay anyway for consistency */
else
{
/* Pause anyway, for consistancy */
Term_xtra(TERM_XTRA_DELAY, msec);
}
/* Handle monster */
if (cave_m_idx[y][x] > 0)
{
monster_type *m_ptr = &mon_list[cave_m_idx[y][x]];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int chance2 = chance - distance(p_ptr->py, p_ptr->px, y, x);
int visible = m_ptr->ml;
int multiplier = 1;
const char *hit_verb = "hits";
const slay_t *best_s_ptr = NULL;
/* Note the collision */
hit_body = TRUE;
/* Did we hit it (penalize distance travelled) */
if (test_hit(chance2, r_ptr->ac, m_ptr->ml))
{
bool fear = FALSE;
/* Assume a default death */
cptr note_dies = " dies.";
improve_attack_modifier(o_ptr, m_ptr, &best_s_ptr);
improve_attack_modifier(j_ptr, m_ptr, &best_s_ptr);
if (best_s_ptr != NULL)
hit_verb = best_s_ptr->range_verb;
/* Some monsters get "destroyed" */
if (monster_is_unusual(r_ptr))
{
/* Special note at death */
note_dies = " is destroyed.";
}
/* Calculate multiplier */
multiplier = p_ptr->state.ammo_mult;
if (best_s_ptr != NULL) multiplier += best_s_ptr->mult;
/* Apply damage: multiplier, slays, criticals, bonuses */
tdam = damroll(o_ptr->dd, o_ptr->ds);
tdam += o_ptr->to_d + j_ptr->to_d;
tdam *= multiplier;
tdam = critical_shot(o_ptr->weight, o_ptr->to_h, tdam, &msg_type);
object_notice_attack_plusses(o_ptr);
object_notice_attack_plusses(&p_ptr->inventory[INVEN_BOW]);
/* No negative damage; change verb if no damage done */
if (tdam <= 0)
{
tdam = 0;
hit_verb = "fail to harm";
}
/* Handle unseen monster */
if (!visible)
{
/* Invisible monster */
message_format(MSG_SHOOT_HIT, 0, "The %s finds a mark.", o_name);
}
/* Handle visible monster */
else
{
char m_name[80];
/* Get "the monster" or "it" */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Tell the player what happened */
if (msg_type == MSG_SHOOT_HIT)
message_format(MSG_SHOOT_HIT, 0, "The %s %s %s.", o_name, hit_verb, m_name);
else
{
if (msg_type == MSG_HIT_GOOD)
{
message_format(MSG_HIT_GOOD, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a good hit!");
}
else if (msg_type == MSG_HIT_GREAT)
{
message_format(MSG_HIT_GREAT, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a great hit!");
}
else if (msg_type == MSG_HIT_SUPERB)
{
message_format(MSG_HIT_SUPERB, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a superb hit!");
}
}
/* Hack -- Track this monster race */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
/* Hack -- Track this monster */
if (m_ptr->ml) health_track(cave_m_idx[y][x]);
}
/* Complex message */
if (p_ptr->wizard)
{
msg_format("You do %d (out of %d) damage.",
tdam, m_ptr->hp);
}
/* Hit the monster, check for death */
if (mon_take_hit(cave_m_idx[y][x], tdam, &fear, note_dies))
{
/* Dead monster */
}
/* No death */
else
{
/* Message */
message_pain(cave_m_idx[y][x], tdam);
/* Take note */
if (fear && m_ptr->ml)
{
char m_name[80];
/* Get the monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Message */
message_format(MSG_FLEE, m_ptr->r_idx,
"%^s flees in terror!", m_name);
}
}
}
/* Stop looking */
break;
}
}
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Single object */
i_ptr->number = 1;
if (item >= 0)
{
inven_item_increase(item, -1);
inven_item_describe(item);
inven_item_optimize(item);
}
/* Reduce and describe floor item */
else
{
floor_item_increase(0 - item, -1);
floor_item_optimize(0 - item);
}
/* Chance of breakage (during attacks) */
j = (hit_body ? breakage_chance(i_ptr) : 0);
/* Drop (or break) near that location */
drop_near(i_ptr, j, y, x, TRUE);
}
/*
* Throw an object from the pack or floor.
*
* Note: "unseen" monsters are very hard to hit.
*
* Should throwing a weapon do full damage? Should it allow the magic
* to hit bonus of the weapon to have an effect? Should it ever cause
* the item to be destroyed? Should it do any damage at all?
*/
void do_cmd_throw(cmd_code code, cmd_arg args[])
{
int dir, item;
int i, j, y, x;
s16b ty, tx;
int chance, tdam, tdis;
int weight;
object_type *o_ptr;
object_type *i_ptr;
object_type object_type_body;
bool hit_body = FALSE;
byte missile_attr;
char missile_char;
char o_name[80];
u32b msg_type = 0;
int path_n;
u16b path_g[256];
int msec = op_ptr->delay_factor * op_ptr->delay_factor;
/* Get item to throw and direction in which to throw it. */
item = args[0].item;
dir = args[1].direction;
/* Make sure the player isn't throwing wielded items */
if (item >= INVEN_WIELD && item < QUIVER_START)
{
msg_print("You have cannot throw wielded items.");
return;
}
/* Check the item being thrown is usable by the player. */
if (!item_is_available(item, NULL, (USE_EQUIP | USE_INVEN | USE_FLOOR)))
{
msg_format("That item is not within your reach.");
return;
}
/* Get the object */
o_ptr = object_from_item_idx(item);
object_notice_on_firing(o_ptr);
/* Get local object */
i_ptr = &object_type_body;
/* Obtain a local object */
object_copy(i_ptr, o_ptr);
/* Distribute the charges of rods/wands/staves between the stacks */
distribute_charges(o_ptr, i_ptr, 1);
/* Single object */
i_ptr->number = 1;
/* Reduce and describe inventory */
if (item >= 0)
{
inven_item_increase(item, -1);
inven_item_describe(item);
inven_item_optimize(item);
}
/* Reduce and describe floor item */
else
{
floor_item_increase(0 - item, -1);
floor_item_optimize(0 - item);
}
/* Description */
object_desc(o_name, sizeof(o_name), i_ptr, ODESC_FULL);
/* Find the color and symbol for the object for throwing */
missile_attr = object_attr(i_ptr);
missile_char = object_char(i_ptr);
/* Enforce a minimum "weight" of one pound */
weight = ((i_ptr->weight > 10) ? i_ptr->weight : 10);
/* Hack -- Distance -- Reward strength, penalize weight */
tdis = (adj_str_blow[p_ptr->state.stat_ind[A_STR]] + 20) * 10 / weight;
/* Max distance of 10 */
if (tdis > 10) tdis = 10;
/* Hack -- Base damage from thrown object */
tdam = damroll(i_ptr->dd, i_ptr->ds);
if (!tdam) tdam = 1;
tdam += i_ptr->to_d;
/* Chance of hitting */
chance = (p_ptr->state.skills[SKILL_TO_HIT_THROW] + (p_ptr->state.to_h * BTH_PLUS_ADJ));
/* Take a turn */
p_ptr->energy_use = 100;
/* Start at the player */
y = p_ptr->py;
x = p_ptr->px;
/* Predict the "target" location */
ty = p_ptr->py + 99 * ddy[dir];
tx = p_ptr->px + 99 * ddx[dir];
/* Check for "target request" */
if ((dir == 5) && target_okay())
{
target_get(&tx, &ty);
}
/* Calculate the path */
path_n = project_path(path_g, tdis, p_ptr->py, p_ptr->px, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff();
/* Project along the path */
for (i = 0; i < path_n; ++i)
{
int ny = GRID_Y(path_g[i]);
int nx = GRID_X(path_g[i]);
/* Hack -- Stop before hitting walls */
if (!cave_floor_bold(ny, nx)) break;
/* Advance */
x = nx;
y = ny;
/* Only do visuals if the player can "see" the missile */
if (player_can_see_bold(y, x))
{
/* Visual effects */
print_rel(missile_char, missile_attr, y, x);
move_cursor_relative(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
Term_xtra(TERM_XTRA_DELAY, msec);
light_spot(y, x);
Term_fresh();
if (p_ptr->redraw) redraw_stuff();
}
/* Delay anyway for consistency */
else
{
/* Pause anyway, for consistancy */
Term_xtra(TERM_XTRA_DELAY, msec);
}
/* Handle monster */
if (cave_m_idx[y][x] > 0)
{
monster_type *m_ptr = &mon_list[cave_m_idx[y][x]];
monster_race *r_ptr = &r_info[m_ptr->r_idx];
int chance2 = chance - distance(p_ptr->py, p_ptr->px, y, x);
int visible = m_ptr->ml;
/* Note the collision */
hit_body = TRUE;
/* Did we hit it (penalize range) */
if (test_hit(chance2, r_ptr->ac, m_ptr->ml))
{
const char *hit_verb = "hits";
bool fear = FALSE;
const slay_t *best_s_ptr = NULL;
/* Assume a default death */
cptr note_dies = " dies.";
/* Some monsters get "destroyed" */
if (monster_is_unusual(r_ptr))
{
/* Special note at death */
note_dies = " is destroyed.";
}
/* Apply special damage - brought forward to fill in hit_verb XXX XXX XXX */
improve_attack_modifier(i_ptr, m_ptr, &best_s_ptr);
if (best_s_ptr != NULL)
{
tdam *= best_s_ptr->mult;
hit_verb = best_s_ptr->range_verb;
}
/* Apply special damage XXX XXX XXX */
tdam = critical_shot(i_ptr->weight, i_ptr->to_h, tdam, &msg_type);
/* No negative damage; change verb if no damage done */
if (tdam <= 0)
{
tdam = 0;
hit_verb = "fail to harm";
}
/* Handle unseen monster */
if (!visible)
{
/* Invisible monster */
msg_format("The %s finds a mark.", o_name);
}
/* Handle visible monster */
else
{
char m_name[80];
/* Get "the monster" or "it" */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Tell the player what happened */
if (msg_type == MSG_SHOOT_HIT)
message_format(MSG_SHOOT_HIT, 0, "The %s %s %s.", o_name, hit_verb, m_name);
else
{
if (msg_type == MSG_HIT_GOOD)
{
message_format(MSG_HIT_GOOD, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a good hit!");
}
else if (msg_type == MSG_HIT_GREAT)
{
message_format(MSG_HIT_GREAT, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a great hit!");
}
else if (msg_type == MSG_HIT_SUPERB)
{
message_format(MSG_HIT_SUPERB, 0, "The %s %s %s. %s", o_name, hit_verb, m_name,
"It was a superb hit!");
}
}
/* Hack -- Track this monster race */
if (m_ptr->ml) monster_race_track(m_ptr->r_idx);
/* Hack -- Track this monster */
if (m_ptr->ml) health_track(cave_m_idx[y][x]);
}
/* Learn the bonuses */
/* XXX Eddie This is messed up, better done for firing, */
/* should use that method [split last] instead */
/* check if inven_optimize removed what o_ptr referenced */
if (object_similar(i_ptr, o_ptr, OSTACK_PACK))
object_notice_attack_plusses(o_ptr);
object_notice_attack_plusses(i_ptr);
/* Complex message */
if (p_ptr->wizard)
msg_format("You do %d (out of %d) damage.",
tdam, m_ptr->hp);
/* Hit the monster, check for death */
if (mon_take_hit(cave_m_idx[y][x], tdam, &fear, note_dies))
{
/* Dead monster */
}
/* No death */
else
{
/* Message */
message_pain(cave_m_idx[y][x], tdam);
/* Take note */
if (fear && m_ptr->ml)
{
char m_name[80];
/* Get the monster name (or "it") */
monster_desc(m_name, sizeof(m_name), m_ptr, 0);
/* Message */
message_format(MSG_FLEE, m_ptr->r_idx,
"%^s flees in terror!", m_name);
}
}
}
/* Stop looking */
break;
}
}
/* Chance of breakage (during attacks) */
j = (hit_body ? breakage_chance(i_ptr) : 0);
/* Drop (or break) near that location */
drop_near(i_ptr, j, y, x, TRUE);
}
/*
* Handle "target" and "look".
*
* Note that this code can be called from "get_aim_dir()".
*
* Currently, when "flag" is true, that is, when
* "interesting" grids are being used, and a directional key is used, we
* only scroll by a single panel, in the direction requested, and check
* for any interesting grids on that panel. The "correct" solution would
* actually involve scanning a larger set of grids, including ones in
* panels which are adjacent to the one currently scanned, but this is
* overkill for this function. XXX XXX
*
* Hack -- targeting/observing an "outer border grid" may induce
* problems, so this is not currently allowed.
*
* The player can use the direction keys to move among "interesting"
* grids in a heuristic manner, or the "space", "+", and "-" keys to
* move through the "interesting" grids in a sequential manner, or
* can enter "location" mode, and use the direction keys to move one
* grid at a time in any direction. The "t" (set target) command will
* only target a monster (as opposed to a location) if the monster is
* target_able and the "interesting" mode is being used.
*
* The current grid is described using the "look" method above, and
* a new command may be entered at any time, but note that if the
* "TARGET_LOOK" bit flag is set (or if we are in "location" mode,
* where "space" has no obvious meaning) then "space" will scan
* through the description of the current grid until done, instead
* of immediately jumping to the next "interesting" grid. This
* allows the "target" command to retain its old semantics.
*
* The "*", "+", and "-" keys may always be used to jump immediately
* to the next (or previous) interesting grid, in the proper mode.
*
* The "return" key may always be used to scan through a complete
* grid description (forever).
*
* This command will cancel any old target, even if used from
* inside the "look" command.
*
* 'mode' is one of TARGET_LOOK or TARGET_KILL.
* 'x' and 'y' are the initial position of the target to be highlighted,
* or -1 if no location is specified.
* Returns TRUE if a target has been successfully set, FALSE otherwise.
*/
bool target_set_interactive(int mode, int x, int y)
{
int py = p_ptr->py;
int px = p_ptr->px;
int i, d, target_count;
bool done = FALSE;
bool interactive = TRUE;
u16b path_n;
u16b path_g[PATH_SIZE];
u16b path_gx[PATH_SIZE];
/* Cancel target */
target_set_monster(0, FALSE);
/* All grids are selectable */
if (mode & (TARGET_GRID))
{
/* Disable other modes */
mode &= ~(TARGET_LOOK | TARGET_KILL | TARGET_TRAP);
/* Disable interesting grids */
interactive = FALSE;
}
/* Prepare the "temp" array */
target_set_interactive_prepare(mode);
/* If we haven't been given an initial location, start on the
player. */
if ((x == -1 || y == -1) && target_grids.size())
{
x = p_ptr->px;
y = p_ptr->py;
ui_targeting_show(MODE_TARGETING_INTERACTIVE);
ui_update_message_label(color_string("Interactive Target Mode", TERM_L_RED));
}
/*
* If we /have/ been given an initial location, make sure we
* honour it by going into "free targeting" mode.
*/
else
{
if (x == -1 || y == -1)
{
x = p_ptr->px;
y = p_ptr->py;
}
interactive = FALSE;
ui_targeting_show(MODE_TARGETING_MANUAL);
ui_update_message_label(color_string("Manual Target Mode", TERM_L_RED));
}
/* Start near the player */
target_count = 0;
/* Interact */
while (!done)
{
/* Interesting grids */
if (interactive && target_grids.size())
{
bool path_drawn = FALSE;
int yy, xx;
y = target_grids[target_count].y;
x = target_grids[target_count].x;
/* Dummy pointers to send to project_path */
yy = y;
xx = x;
/* Adjust panel if needed */
ui_ensure(y, x);
/* Find the path. */
path_n = project_path(path_g, path_gx, MAX_RANGE, py, px, &yy, &xx, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if ((mode & (TARGET_KILL)) && (dungeon_info[y][x].projectable()))
{
path_drawn = ui_draw_path(path_n, path_g, y, x);
}
ui_show_cursor(y, x);
/* Describe and Prompt */
describe_grid_brief(y, x);
UserInput input = ui_get_input();
/* Remove the path */
if (path_drawn) ui_destroy_path();
ui_show_cursor(-1, -1);
/* Assume no "direction" */
d = 0;
// Use the mouse wheel to go through targets
if (input.mode == INPUT_MODE_MOUSE_WHEEL)
{
if (input.key == Qt::Key_Plus)
{
if (++target_count == target_grids.size()) target_count = 0;
}
else if (input.key == Qt::Key_Minus)
{
if (target_count-- == 0) target_count = target_grids.size() - 1;
}
continue;
}
// double-click - automatically target if appropriate
if (input.mode == INPUT_MODE_MOUSE_DOUBLE_CLICK)
{
if (!set_selected_target(mode, y, x))
{
target_set_location(y, x);
}
done = TRUE;
continue;
}
/*
* If we click, move the target location to the click and
* switch to "free targeting" mode by unsetting 'flag'.
* This means we get some info about wherever we've picked.
*/
if (input.mode == INPUT_MODE_MOUSE_SINGLE_CLICK)
{
// If clicking twice on the same square, accept
if (input.x == x && input.y == y)
{
if (set_selected_target(mode, y, x)) done = TRUE;
continue;
}
x = input.x;
y = input.y;
ui_update_message_label(color_string("Interactive Target Mode", TERM_L_RED));
ui_targeting_show(MODE_TARGETING_MANUAL);
interactive = FALSE;
continue;
}
/* Analyze */
switch (input.key)
{
case Qt::Key_Escape:
case Qt::Key_X:
{
done = TRUE;
break;
}
case Qt::Key_C:
case Qt::Key_Comma:
{
/* Set to closest target */
if (target_set_closest(TARGET_KILL)) done = TRUE;
break;
}
case Qt::Key_Space:
case Qt::Key_Plus:
{
if (++target_count == target_grids.size()) target_count = 0;
break;
}
case Qt::Key_Minus:
{
if (target_count-- == 0) target_count = target_grids.size() - 1;
break;
}
case Qt::Key_Exclam:
case Qt::Key_L:
{
GridDialog(y, x);
break;
}
case Qt::Key_Asterisk:
case Qt::Key_M:
{
ui_update_message_label(color_string("Manual Target Mode", TERM_L_RED));
ui_targeting_show(MODE_TARGETING_MANUAL);
interactive = FALSE;
break;
}
case Qt::Key_Question:
{
do_cmd_list_targeting_commands();
break;
}
case Qt::Key_H:
case Qt::Key_5:
case Qt::Key_Period:
case Qt::Key_Clear:
{
if (set_selected_target(mode, y, x)) done = TRUE;
break;
}
default:
{
/* Extract direction */
d = target_dir(input);
/* Oops */
if (!d) message("Illegal command for target mode!");
break;
}
}
/* Hack -- move around */
if (d)
{
int old_y = target_grids[target_count].y;
int old_x = target_grids[target_count].x;
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d]);
/* Scroll to find interesting grid */
if (i < 0)
{
QRect vis = visible_dungeon();
int old_wy = vis.y();
int old_wx = vis.x();
/* Change if legal */
if (ui_change_panel(d))
{
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d]);
/* Restore panel if needed */
if ((i < 0) && ui_modify_panel(old_wy, old_wx))
{
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
}
}
}
/* Use interesting grid if found */
if (i >= 0) target_count = i;
}
}
/* Arbitrary grids */
else
{
bool path_drawn = FALSE;
/* Dummy pointers to send to project_path */
int yy = y;
int xx = x;
/* Find the path. */
path_n = project_path(path_g, path_gx, MAX_RANGE, py, px, &yy, &xx, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if ((mode & (TARGET_KILL)) && (dungeon_info[y][x].projectable()))
{
/* Save target info */
path_drawn = ui_draw_path(path_n, path_g, y, x);
}
describe_grid_brief(y, x);
ui_show_cursor(y, x);
UserInput input = ui_get_input();
/* Remove the path */
if (path_drawn) ui_destroy_path();
ui_show_cursor(y, x);
/* Assume no direction */
d = 0;
if (input.mode == INPUT_MODE_MOUSE_WHEEL) continue;
// double-click - automatically target if appropriate
if (input.mode == INPUT_MODE_MOUSE_DOUBLE_CLICK)
{
if (set_selected_target(mode, y, x)) done = TRUE;
else
{
message(QString("Illegal target!"));
}
break;
}
if (input.mode == INPUT_MODE_MOUSE_SINGLE_CLICK)
{
/* We only target if we click somewhere where the cursor
is already (i.e. a double-click without a time limit) */
if (input.x == x && input.y == y)
{
target_set_location(y, x);
done = TRUE;
}
else
{
/* Just move the cursor for now - another click will
target. */
x = input.x;
y = input.y;
}
continue;
}
/* Analyze the keypress */
switch (input.key)
{
case Qt::Key_Escape:
case Qt::Key_X:
{
done = TRUE;
continue;
}
case Qt::Key_Asterisk:
case Qt::Key_M:
{
if (((mode & (TARGET_GRID)) != TARGET_GRID) && target_grids.size())
{
ui_update_message_label(color_string("Interactive Target Mode", TERM_L_RED));
ui_targeting_show(MODE_TARGETING_INTERACTIVE);
interactive = TRUE;
}
break;
}
case Qt::Key_copyright:
case Qt::Key_C:
case Qt::Key_Comma:
{
/* Set to closest target */
if (target_set_closest(TARGET_KILL)) done = TRUE;
break;
}
case Qt::Key_Exclam:
case Qt::Key_L:
{
GridDialog(y, x);
break;
}
case Qt::Key_Ampersand:
case Qt::Key_P:
{
/* Recenter around player */
ui_center(py, px);
y = py;
x = px;
break;
}
case Qt::Key_H:
case Qt::Key_5:
case Qt::Key_Period:
case Qt::Key_Clear:
{
target_set_location(y, x);
done = TRUE;
break;
}
case Qt::Key_Question:
{
do_cmd_list_targeting_commands();
break;
}
default:
{
/* Extract a direction */
d = target_dir(input);
/* Oops */
if (!d) message("Illegal command for target mode!");
break;
}
}
/* Handle "direction" */
if (d)
{
int dungeon_hgt = p_ptr->cur_map_hgt;
int dungeon_wid = p_ptr->cur_map_wid;
/* Move */
x += ddx[d];
y += ddy[d];
/* Slide into legality */
if (x >= dungeon_wid - 1) x--;
else if (x <= 0) x++;
/* Slide into legality */
if (y >= dungeon_hgt - 1) y--;
else if (y <= 0) y++;
/* Adjust panel if needed */
if (ui_adjust_panel(y, x))
{
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
}
}
}
}
/* Forget */
target_grids.clear();
ui_targeting_hide();
/* Recenter around player */
ui_ensure(py, px);
/* Failure to set target */
if (!p_ptr->target_set) return (FALSE);
/* Success */
return (TRUE);
}
/*
* Handle "target" and "look".
*
* Note that this code can be called from "get_aim_dir()".
*
* Currently, when "flag" is true, that is, when
* "interesting" grids are being used, and a directional key is used, we
* only scroll by a single panel, in the direction requested, and check
* for any interesting grids on that panel. The "correct" solution would
* actually involve scanning a larger set of grids, including ones in
* panels which are adjacent to the one currently scanned, but this is
* overkill for this function. XXX XXX
*
* Hack -- targetting/observing an "outer border grid" may induce
* problems, so this is not currently allowed.
*
* The player can use the direction keys to move among "interesting"
* grids in a heuristic manner, or the "space", "+", and "-" keys to
* move through the "interesting" grids in a sequential manner, or
* can enter "location" mode, and use the direction keys to move one
* grid at a time in any direction. The "t" (set target) command will
* only target a monster (as opposed to a location) if the monster is
* target_able and the "interesting" mode is being used.
*
* The current grid is described using the "look" method above, and
* a new command may be entered at any time, but note that if the
* "TARGET_LOOK" bit flag is set (or if we are in "location" mode,
* where "space" has no obvious meaning) then "space" will scan
* through the description of the current grid until done, instead
* of immediately jumping to the next "interesting" grid. This
* allows the "target" command to retain its old semantics.
*
* The "*", "+", and "-" keys may always be used to jump immediately
* to the next (or previous) interesting grid, in the proper mode.
*
* The "return" key may always be used to scan through a complete
* grid description (forever).
*
* This command will cancel any old target, even if used from
* inside the "look" command.
*
*
* 'mode' is one of TARGET_LOOK or TARGET_KILL.
* 'x' and 'y' are the initial position of the target to be highlighted,
* or -1 if no location is specified.
* Returns TRUE if a target has been successfully set, FALSE otherwise.
*/
bool target_set_interactive(int mode, int x, int y)
{
int py = p_ptr->py;
int px = p_ptr->px;
int path_n;
u16b path_g[256];
int i, d, m, t, bd;
int wid, hgt, help_prompt_loc;
bool done = FALSE;
bool flag = TRUE;
bool help = FALSE;
struct keypress query;
/* These are used for displaying the path to the target */
char path_char[MAX_RANGE];
byte path_attr[MAX_RANGE];
/* If we haven't been given an initial location, start on the
player. */
if (x == -1 || y == -1)
{
x = p_ptr->px;
y = p_ptr->py;
}
/* If we /have/ been given an initial location, make sure we
honour it by going into "free targetting" mode. */
else
{
flag = FALSE;
}
/* Cancel target */
target_set_monster(0);
/* Cancel tracking */
/* health_track(0); */
/* Calculate the window location for the help prompt */
Term_get_size(&wid, &hgt);
help_prompt_loc = hgt - 1;
/* Display the help prompt */
prt("Press '?' for help.", help_prompt_loc, 0);
/* Prepare the "temp" array */
target_set_interactive_prepare(mode);
/* Start near the player */
m = 0;
/* Interact */
while (!done) {
bool path_drawn = FALSE;
/* Interesting grids */
if (flag && temp_n)
{
y = temp_y[m];
x = temp_x[m];
/* Adjust panel if needed */
if (adjust_panel_help(y, x, help)) handle_stuff();
/* Update help */
if (help) {
bool good_target = (cave->m_idx[y][x] > 0) &&
target_able(cave->m_idx[y][x]);
target_display_help(good_target, !(flag && temp_n));
}
/* Find the path. */
path_n = project_path(path_g, MAX_RANGE, py, px, y, x, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if (mode & (TARGET_KILL))
path_drawn = draw_path(path_n, path_g, path_char, path_attr, py, px);
/* Describe and Prompt */
query = target_set_interactive_aux(y, x, mode);
/* Remove the path */
if (path_drawn) load_path(path_n, path_g, path_char, path_attr);
/* Cancel tracking */
/* health_track(0); */
/* Assume no "direction" */
d = 0;
/* Analyze */
switch (query.code)
{
case ESCAPE:
case 'q':
{
done = TRUE;
break;
}
case ' ':
case '*':
case '+':
{
if (++m == temp_n)
m = 0;
break;
}
case '-':
{
if (m-- == 0)
m = temp_n - 1;
break;
}
case 'p':
{
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff();
y = p_ptr->py;
x = p_ptr->px;
}
case 'o':
{
flag = FALSE;
break;
}
case 'm':
{
break;
}
case 't':
case '5':
case '0':
case '.':
{
int m_idx = cave->m_idx[y][x];
if ((m_idx > 0) && target_able(m_idx))
{
health_track(p_ptr, m_idx);
target_set_monster(m_idx);
done = TRUE;
}
else
{
bell("Illegal target!");
}
break;
}
case 'g':
{
cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, y, x);
done = TRUE;
break;
}
case '?':
{
help = !help;
/* Redraw main window */
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
handle_stuff();
if (!help)
prt("Press '?' for help.", help_prompt_loc, 0);
break;
}
default:
{
/* Extract direction */
d = target_dir(query);
/* Oops */
if (!d) bell("Illegal command for target mode!");
break;
}
}
/* Hack -- move around */
if (d)
{
int old_y = temp_y[m];
int old_x = temp_x[m];
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d]);
/* Scroll to find interesting grid */
if (i < 0)
{
int old_wy = Term->offset_y;
int old_wx = Term->offset_x;
/* Change if legal */
if (change_panel(d))
{
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d]);
/* Restore panel if needed */
if ((i < 0) && modify_panel(Term, old_wy, old_wx))
{
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
}
/* Handle stuff */
handle_stuff();
}
}
/* Use interesting grid if found */
if (i >= 0) m = i;
}
}
/* Arbitrary grids */
else
{
/* Update help */
if (help)
{
bool good_target = ((cave->m_idx[y][x] > 0) && target_able(cave->m_idx[y][x]));
target_display_help(good_target, !(flag && temp_n));
}
/* Find the path. */
path_n = project_path(path_g, MAX_RANGE, py, px, y, x, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if (mode & (TARGET_KILL))
path_drawn = draw_path (path_n, path_g, path_char, path_attr, py, px);
/* Describe and Prompt (enable "TARGET_LOOK") */
query = target_set_interactive_aux(y, x, mode | TARGET_LOOK);
/* Remove the path */
if (path_drawn) load_path(path_n, path_g, path_char, path_attr);
/* Cancel tracking */
/* health_track(0); */
/* Assume no direction */
d = 0;
/* Analyze the keypress */
switch (query.code)
{
case ESCAPE:
case 'q':
{
done = TRUE;
break;
}
case ' ':
case '*':
case '+':
case '-':
{
break;
}
case 'p':
{
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff();
y = p_ptr->py;
x = p_ptr->px;
}
case 'o':
{
break;
}
case 'm':
{
flag = TRUE;
m = 0;
bd = 999;
/* Pick a nearby monster */
for (i = 0; i < temp_n; i++)
{
t = distance(y, x, temp_y[i], temp_x[i]);
/* Pick closest */
if (t < bd)
{
m = i;
bd = t;
}
}
/* Nothing interesting */
if (bd == 999) flag = FALSE;
break;
}
case 't':
case '5':
case '0':
case '.':
{
target_set_location(y, x);
done = TRUE;
break;
}
case 'g':
{
cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, y, x);
done = TRUE;
break;
}
case '?':
{
help = !help;
/* Redraw main window */
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
handle_stuff();
if (!help)
prt("Press '?' for help.", help_prompt_loc, 0);
break;
}
default:
{
/* Extract a direction */
d = target_dir(query);
/* Oops */
if (!d) bell("Illegal command for target mode!");
break;
}
}
/* Handle "direction" */
if (d)
{
int dungeon_hgt = (p_ptr->depth == 0) ? TOWN_HGT : DUNGEON_HGT;
int dungeon_wid = (p_ptr->depth == 0) ? TOWN_WID : DUNGEON_WID;
/* Move */
x += ddx[d];
y += ddy[d];
/* Slide into legality */
if (x >= dungeon_wid - 1) x--;
else if (x <= 0) x++;
/* Slide into legality */
if (y >= dungeon_hgt - 1) y--;
else if (y <= 0) y++;
/* Adjust panel if needed */
if (adjust_panel_help(y, x, help))
{
/* Handle stuff */
handle_stuff();
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
}
}
}
}
/* Forget */
temp_n = 0;
/* Redraw as necessary */
if (help)
{
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
}
else
{
prt("", 0, 0);
prt("", help_prompt_loc, 0);
p_ptr->redraw |= (PR_DEPTH | PR_STATUS);
}
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff();
/* Failure to set target */
if (!target_set) return (FALSE);
/* Success */
return (TRUE);
}
_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;
}
/*!
* @brief モンスターが敵対モンスターに直接ブレスを当てることが可能かを判定する /
* Determine if a breath will hit the target.
* @param y1 始点のY座標
* @param x1 始点のX座標
* @param y2 目標のY座標
* @param x2 目標のX座標
* @param rad 半径
* @param typ 効果属性ID
* @param is_friend TRUEならば、プレイヤーを巻き込む時にブレスの判定をFALSEにする。
* @return ブレスを直接当てられるならばTRUEを返す
*/
static bool breath_direct(int y1, int x1, int y2, int x2, int rad, int typ, bool is_friend)
{
/* Must be the same as projectable() */
int i;
/* Initial grid */
int y = y1;
int x = x1;
int grid_n = 0;
u16b grid_g[512];
int grids = 0;
byte gx[1024], gy[1024];
byte gm[32];
int gm_rad = rad;
bool hit2 = FALSE;
bool hityou = FALSE;
int flg;
switch (typ)
{
case GF_LITE:
case GF_LITE_WEAK:
flg = PROJECT_LOS;
break;
case GF_DISINTEGRATE:
flg = PROJECT_DISI;
break;
default:
flg = 0;
break;
}
/* Check the projection path */
grid_n = project_path(grid_g, MAX_RANGE, y1, x1, y2, x2, flg);
/* Project along the path */
for (i = 0; i < grid_n; ++i)
{
int ny = GRID_Y(grid_g[i]);
int nx = GRID_X(grid_g[i]);
if (flg & PROJECT_DISI)
{
/* Hack -- Balls explode before reaching walls */
if (cave_stop_disintegration(ny, nx)) break;
}
else if (flg & PROJECT_LOS)
{
/* Hack -- Balls explode before reaching walls */
if (!cave_los_bold(ny, nx)) break;
}
else
{
/* Hack -- Balls explode before reaching walls */
if (!cave_have_flag_bold(ny, nx, FF_PROJECT)) break;
}
/* Save the "blast epicenter" */
y = ny;
x = nx;
}
grid_n = i;
if (!grid_n)
{
if (flg & PROJECT_DISI)
{
if (in_disintegration_range(y1, x1, y2, x2) && (distance(y1, x1, y2, x2) <= rad)) hit2 = TRUE;
if (in_disintegration_range(y1, x1, p_ptr->y, p_ptr->x) && (distance(y1, x1, p_ptr->y, p_ptr->x) <= rad)) hityou = TRUE;
}
else if (flg & PROJECT_LOS)
{
if (los(y1, x1, y2, x2) && (distance(y1, x1, y2, x2) <= rad)) hit2 = TRUE;
if (los(y1, x1, p_ptr->y, p_ptr->x) && (distance(y1, x1, p_ptr->y, p_ptr->x) <= rad)) hityou = TRUE;
}
else
{
if (projectable(y1, x1, y2, x2) && (distance(y1, x1, y2, x2) <= rad)) hit2 = TRUE;
if (projectable(y1, x1, p_ptr->y, p_ptr->x) && (distance(y1, x1, p_ptr->y, p_ptr->x) <= rad)) hityou = TRUE;
}
}
else
{
breath_shape(grid_g, grid_n, &grids, gx, gy, gm, &gm_rad, rad, y1, x1, y, x, typ);
for (i = 0; i < grids; i++)
{
/* Extract the location */
y = gy[i];
x = gx[i];
if ((y == y2) && (x == x2)) hit2 = TRUE;
if (player_bold(y, x)) hityou = TRUE;
}
}
if (!hit2) return FALSE;
if (is_friend && hityou) return FALSE;
return TRUE;
}
int context_menu_cave(int cy, int cx, int adjacent, int mx, int my)
{
menu_type *m;
rect_region r;
int selected;
char *labels;
cave_type *c_ptr = area(cx,cy);
pcave_type *pc_ptr = parea(cx,cy);
feature_type *feat;
object_type *o_ptr;
/* paranoia */
if (!in_boundsp(cx,cy)) return 0;
m = menu_dynamic_new();
if (!m) {
return 0;
}
labels = (char*)string_make(lower_case);
m->selections = labels;
feat = &(f_info[c_ptr->feat]);
menu_dynamic_add_label(m, "Look At", 'l', 1, labels);
if (c_ptr->m_idx) {
menu_dynamic_add_label(m, "Recall Info", '/', 18, labels);
}
menu_dynamic_add_label(m, "Use Item On", 'u', 2, labels);
if (player_can_cast()) {
menu_dynamic_add_label(m, "Cast On", 'm', 3, labels);
}
if (adjacent) {
if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml) {
menu_dynamic_add_label(m, "Attack", '+', 4, labels);
} else {
menu_dynamic_add_label(m, "Alter", '+', 4, labels);
}
if (c_ptr->o_idx) {
o_ptr = chest_check(cx,cy);
if (o_ptr && o_ptr->pval) {
//if (!squelch_item_ok(o_ptr)) {
if (object_known_p(o_ptr)) {
if (chest_traps[o_ptr->pval]) {
menu_dynamic_add_label(m, "Disarm Chest", 'D', 5, labels);
menu_dynamic_add_label(m, "Open Chest", 'o', 8, labels);
} else {
menu_dynamic_add_label(m, "Open Disarmed Chest", 'o', 8, labels);
}
} else {
menu_dynamic_add_label(m, "Open Chest", 'o', 8, labels);
}
//}
}
}
if (is_visible_trap(c_ptr)) {
menu_dynamic_add_label(m, "Disarm", 'D', 5, labels);
menu_dynamic_add_label(m, "Jump Onto", 'W', 6, labels);
}
if (pc_ptr->feat) {
if ((feat->flags & FF_CLOSEABLE)
|| ((feat->flags & FF_BROKEN) && (feat->flags & FF_DOOR)))
{
menu_dynamic_add_label(m, "Close", 'c', 7, labels);
}
if (feat->flags & FF_CLOSED) {
menu_dynamic_add_label(m, "Open", 'o', 8, labels);
menu_dynamic_add_label(m, "Bash Open", 'B', 9, labels);
menu_dynamic_add_label(m, "Lock", 'D', 5, labels);
menu_dynamic_add_label(m, "Jam", 'j', 10, labels);
}
if (feat->flags & FF_DIG) {
menu_dynamic_add_label(m, "Tunnel", 'T', 11, labels);
}
}
menu_dynamic_add_label(m, "Search", 's', 12, labels);
menu_dynamic_add_label(m, "Walk Towards", ';', 14, labels);
} else {
menu_dynamic_add_label(m, "Pathfind To", ',', 13, labels);
menu_dynamic_add_label(m, "Walk Towards", ';', 14, labels);
menu_dynamic_add_label(m, "Run Towards", '.', 15, labels);
}
if (player_can_fire()) {
menu_dynamic_add_label(m, "Fire On", 'f', 16, labels);
}
if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml) {
if (is_pet(&(m_list[c_ptr->m_idx]))) {
menu_dynamic_add_label(m, "Pet Commands", 'p', 19, labels);
}
}
menu_dynamic_add_label(m, "Throw To", 'v', 17, labels);
/* work out display region */
r.width = menu_dynamic_longest_entry(m) + 3 + 2; /* +3 for tag, 2 for pad */
if (mx > Term->wid - r.width - 1) {
r.col = Term->wid - r.width - 1;
} else {
r.col = mx + 1;
}
r.page_rows = m->count;
if (my > Term->hgt - r.page_rows - 1) {
if (my - r.page_rows - 1 <= 0) {
/* menu has too many items, so put in upper right corner */
r.row = 1;
r.col = Term->wid - r.width - 1;
} else {
r.row = Term->hgt - r.page_rows - 1;
}
} else {
r.row = my + 1;
}
/* Hack -- no flush needed */
msg_flag = FALSE;
screen_save();
button_backup_all(TRUE);
/* if there is a monster, draw a target path, which will be erased by the
* screen load below */
if (c_ptr->m_idx && m_list[c_ptr->m_idx].ml) {
sint path_n;
coord path_g[2*MAX_RANGE+1];
/* Find the path. */
path_n = project_path(path_g, p_ptr->px, p_ptr->py, cx, cy, PROJECT_THRU);
/* Draw the path. */
draw_path(path_n, path_g, NULL, NULL, p_ptr->px, p_ptr->py);
}
menu_layout(m, &r);
rect_region_erase_bordered(&r);
/* display the prompt for the context menu */
target_look_grid_prompt(0, 0, cx, cy,
format("($UEnter to select command$Y\n$V, $UESC$ to cancel$Y%c$V) You see", ESCAPE));
/* Hack - redraw stuff to show the target health bar */
health_redraw();
/* show the menu and pick from it */
selected = menu_dynamic_select(m);
menu_dynamic_free(m);
string_free(labels);
button_restore();
screen_load();
if (selected == 1) {
/* look at the spot */
if (target_set_interactive(TARGET_LOOK, cx, cy)) {
msgf("Target Selected.");
}
} else
if (selected == 2) {
/* use an item on the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'u';
repeat_check();
do_cmd_use();
/*cmd_insert(CMD_USE_AIMED);
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);*/
} else
if (selected == 3) {
/* cast a spell on the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'm';
repeat_check();
do_cmd_cast_wrapper();
/*if (textui_obj_cast_ret() >= 0) {
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);
}*/
} else
if (selected == 4) {
/* attack a spot adjacent to the player */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 16;
p_ptr->cmd.cmd = '+';
repeat_check();
do_cmd_alter();
/*cmd_insert(CMD_ALTER);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 5) {
/* disarm an adjacent trap or chest */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 1;
p_ptr->cmd.cmd = 'D';
repeat_check();
do_cmd_disarm();
/*cmd_insert(CMD_DISARM);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 6) {
/* walk onto an adjacent spot even if there is a trap there */
bool orig_disarm = easy_disarm;
easy_disarm = always_pickup;
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 1;
p_ptr->cmd.cmd = 'W';
repeat_check();
do_cmd_walk(always_pickup);
easy_disarm = orig_disarm;
/*cmd_insert(CMD_JUMP);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 7) {
/* close a door */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'c';
repeat_check();
do_cmd_close();
/*cmd_insert(CMD_CLOSE);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 8) {
/* open a door or chest */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'o';
repeat_check();
do_cmd_open();
/*cmd_insert(CMD_OPEN);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 9) {
/* bash a door */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'o';
repeat_check();
do_cmd_open();
/*p_ptr->cmd.cmd = 'B';
do_cmd_bash();*/
/*cmd_insert(CMD_BASH);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 10) {
/* jam a door */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 'j';
repeat_check();
do_cmd_spike();
/*cmd_insert(CMD_JAM);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 11) {
/* Tunnel in a direction */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.arg = 16;
p_ptr->cmd.cmd = 'T';
repeat_check();
do_cmd_tunnel();
/*cmd_insert(CMD_TUNNEL);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 12) {
/* Search */
/*p_ptr->cmd.arg = 1;*/
p_ptr->cmd.cmd = 's';
repeat_check();
do_cmd_search();
/*cmd_insert(CMD_SEARCH);*/
} else
if (selected == 13) {
/* pathfind to the spot */
/*p_ptr->cmd.arg = 16;*/
p_ptr->cmd.cmd = ',';
do_cmd_pathfind(cx,cy);
/*cmd_insert(CMD_PATHFIND);
cmd_set_arg_point(cmd_get_top(), 0, cx, cy);*/
} else
if (selected == 14) {
/* walk towards the spot */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.cmd = ';';
repeat_check();
do_cmd_walk(always_pickup);
/*cmd_insert(CMD_WALK);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 15) {
/* run towards the spot */
p_ptr->cmd.dir = coords_to_dir(cx, cy);
p_ptr->cmd.cmd = '.';
repeat_check();
do_cmd_run();
/*cmd_insert(CMD_RUN);
cmd_set_arg_direction(cmd_get_top(), 0, coords_to_dir(cy,cx));*/
} else
if (selected == 16) {
/* Fire ammo towards the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'f';
repeat_check();
do_cmd_fire();
/*cmd_insert(CMD_FIRE);
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);*/
} else
if (selected == 17) {
/* throw an item towards the spot */
p_ptr->cmd.dir = 5;
p_ptr->cmd.cmd = 'v';
repeat_check();
do_cmd_throw();
/*cmd_insert(CMD_THROW);
cmd_set_arg_target(cmd_get_top(), 1, DIR_TARGET);*/
} else
if (selected == 18) {
/* recall monster Info */
monster_type *m_ptr = &m_list[c_ptr->m_idx];
if (m_ptr) {
/* Save screen */
screen_save();
button_backup_all(TRUE);
/* Recall on screen */
screen_roff_mon(m_ptr->r_idx, 0);
/* wait for a key or mouse press */
inkey();
/* Load screen */
button_restore();
screen_load();
}
} else
if (selected == 19) {
/* issue a pet command */
p_ptr->cmd.cmd = 'p';
repeat_check();
do_cmd_pet();
}
return 1;
}
/*
* Handle "target" and "look".
*
* Note that this code can be called from "get_aim_dir()".
*
* Currently, when "flag" is true, that is, when
* "interesting" grids are being used, and a directional key is used, we
* only scroll by a single panel, in the direction requested, and check
* for any interesting grids on that panel. The "correct" solution would
* actually involve scanning a larger set of grids, including ones in
* panels which are adjacent to the one currently scanned, but this is
* overkill for this function. XXX XXX
*
* Hack -- targetting/observing an "outer border grid" may induce
* problems, so this is not currently allowed.
*
* The player can use the direction keys to move among "interesting"
* grids in a heuristic manner, or the "space", "+", and "-" keys to
* move through the "interesting" grids in a sequential manner, or
* can enter "location" mode, and use the direction keys to move one
* grid at a time in any direction. The "t" (set target) command will
* only target a monster (as opposed to a location) if the monster is
* target_able and the "interesting" mode is being used.
*
* The current grid is described using the "look" method above, and
* a new command may be entered at any time, but note that if the
* "TARGET_LOOK" bit flag is set (or if we are in "location" mode,
* where "space" has no obvious meaning) then "space" will scan
* through the description of the current grid until done, instead
* of immediately jumping to the next "interesting" grid. This
* allows the "target" command to retain its old semantics.
*
* The "*", "+", and "-" keys may always be used to jump immediately
* to the next (or previous) interesting grid, in the proper mode.
*
* The "return" key may always be used to scan through a complete
* grid description (forever).
*
* This command will cancel any old target, even if used from
* inside the "look" command.
*
* 'mode' is one of TARGET_LOOK or TARGET_KILL.
* 'x' and 'y' are the initial position of the target to be highlighted,
* or -1 if no location is specified.
* Returns TRUE if a target has been successfully set, FALSE otherwise.
*/
bool target_set_interactive(int mode, int x, int y)
{
int py = p_ptr->py;
int px = p_ptr->px;
int i, d, m, t, bd;
int wid, hgt, help_prompt_loc;
bool done = FALSE;
bool flag = TRUE;
bool help = FALSE;
bool list_floor_objects = auto_display_lists;
u16b path_n;
u16b path_g[PATH_SIZE];
u16b path_gx[PATH_SIZE];
ui_event_data query;
char info[80];
/* These are used for displaying the path to the target */
char path_char[MAX_RANGE];
byte path_attr[MAX_RANGE];
/* If we haven't been given an initial location, start on the
player. */
if (x == -1 || y == -1)
{
x = p_ptr->px;
y = p_ptr->py;
}
/* If we /have/ been given an initial location, make sure we
honour it by going into "free targeting" mode. */
else
{
flag = FALSE;
}
/* Cancel target */
target_set_monster(0);
/* make some buttons */
button_backup_all();
button_kill_all();
button_add("[ESCAPE]", ESCAPE);
button_add("[NEXT]", '+');
button_add("[PREV]", '-');
button_add("[PLAYER]", 'p');
button_add("[PATHFIND]", 'g');
button_add("[TARGET]", 't');
/* health_track(0); */
/* All grids are selectable */
if (mode & (TARGET_GRID))
{
/* Disable other modes */
mode &= ~(TARGET_LOOK | TARGET_KILL | TARGET_TRAP);
/* Disable interesting grids */
flag = FALSE;
}
/* Calculate the window location for the help prompt */
Term_get_size(&wid, &hgt);
help_prompt_loc = hgt - (mouse_buttons ? 2 : 1);
/* Display the help prompt */
prt("'?' - help", help_prompt_loc, 0);
/* Prepare the "temp" array */
target_set_interactive_prepare(mode);
/* Start near the player */
m = 0;
/* Interact */
while (!done)
{
button_kill('l');
button_kill('?');
if (list_floor_objects)
{
button_add("[HIDE_OBJLIST]", 'l');
}
else button_add("[SHOW_OBJLIST]", 'l');
if (help)
{
button_add("[HIDE_HELP]", '?');
}
else button_add("[SHOW_HELP]",'?');
/* Interesting grids */
if (flag && temp_n)
{
bool path_drawn = FALSE;
int yy, xx;
y = temp_y[m];
x = temp_x[m];
button_add("[SCAN]",'o');
/* Update help */
if (help)
{
bool good_target = ((cave_m_idx[y][x] > 0) && target_able(cave_m_idx[y][x]));
target_display_help(good_target, !(flag && temp_n));
}
/* Dummy pointers to send to project_path */
yy = y;
xx = x;
/* Allow targets for monsters....or traps, if applicable */
if (((cave_m_idx[y][x] > 0) && target_able(cave_m_idx[y][x])) ||
((mode & (TARGET_TRAP)) && target_able_trap(y, x)))
{
strcpy(info, "q,t,r,l,p,o,+,-,<dir>");
}
/* Dis-allow target */
else
{
strcpy(info, "q,p,l,o,+,-,<dir>");
}
/* Adjust panel if needed */
if (adjust_panel(y, x))
{
/* Handle stuff */
handle_stuff();
}
/* Find the path. */
path_n = project_path(path_g, path_gx, MAX_RANGE, py, px, &yy, &xx, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if ((mode & (TARGET_KILL)) && (cave_info[y][x] & (CAVE_FIRE)))
{
path_drawn = draw_path(path_n, path_g, path_char, path_attr, py, px, y, x);
}
event_signal(EVENT_MOUSEBUTTONS);
/* Describe and Prompt */
query = target_set_interactive_aux(y, x, mode, info, list_floor_objects);
/* Remove the path */
if (path_drawn) load_path(path_n, path_g, path_char, path_attr);
/* Cancel tracking */
/* health_track(0); */
/* Assume no "direction" */
d = 0;
/* Analyze */
switch (query.key)
{
case ESCAPE:
case 'q':
{
done = TRUE;
break;
}
case ' ':
case '*':
case '+':
{
if (++m == temp_n) m = 0;
break;
}
case '-':
{
if (m-- == 0) m = temp_n - 1;
break;
}
case 'p':
{
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff();
y = py;
x = px;
}
case 'o':
{
flag = FALSE;
break;
}
case 'm':
{
break;
}
/* If we click, move the target location to the click and
switch to "free targetting" mode by unsetting 'flag'.
This means we get some info about wherever we've picked. */
case DEFINED_XFF:
{
x = KEY_GRID_X(query);
y = KEY_GRID_Y(query);
flag = FALSE;
break;
}
case 't':
case '5':
case '0':
case '.':
{
int m_idx = cave_m_idx[y][x];
if ((m_idx > 0) && target_able(m_idx))
{
health_track(m_idx);
target_set_monster(m_idx);
done = TRUE;
}
else if ((mode & (TARGET_TRAP)) && target_able_trap(y, x))
{
target_set_location(y, x);
done = TRUE;
}
else if (mode & (TARGET_PROBE))
{
target_set_location(y, x);
done = TRUE;
}
else
{
bell("Illegal target!");
}
break;
}
case 'g':
{
cmd_insert(CMD_PATHFIND, y, x);
done = TRUE;
break;
}
case 'l':
{
list_floor_objects = (!list_floor_objects);
}
case '?':
{
help = !help;
/* Redraw main window */
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
handle_stuff();
if (!help)
prt("'?' - help", help_prompt_loc, 0);
break;
}
default:
{
/* Extract direction */
d = target_dir(query.key);
/* Oops */
if (!d) bell("Illegal command for target mode!");
break;
}
}
/* Hack -- move around */
if (d)
{
int old_y = temp_y[m];
int old_x = temp_x[m];
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d]);
/* Scroll to find interesting grid */
if (i < 0)
{
int old_wy = Term->offset_y;
int old_wx = Term->offset_x;
/* Change if legal */
if (change_panel(d))
{
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
/* Find a new monster */
i = target_pick(old_y, old_x, ddy[d], ddx[d]);
/* Restore panel if needed */
if ((i < 0) && modify_panel(Term, old_wy, old_wx))
{
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
}
/* Handle stuff */
handle_stuff();
}
}
/* Use interesting grid if found */
if (i >= 0) m = i;
}
}
/* Arbitrary grids */
else
{
bool path_drawn = FALSE;
/* Dummy pointers to send to project_path */
int yy = y;
int xx = x;
/* Don't need this button any more */
button_kill('o');
/* Update help */
if (help)
{
bool good_target = ((cave_m_idx[y][x] > 0) && target_able(cave_m_idx[y][x]));
target_display_help(good_target, !(flag && temp_n));
}
/* Default prompt */
if (!(mode & (TARGET_GRID)))
{
strcpy(info, "q,t,l,p,m,+,-,<dir>");
}
/* Disable monster selection */
else
{
strcpy(info, "q,t,l.p,+,-,<dir>");
}
/* Find the path. */
path_n = project_path(path_g, path_gx, MAX_RANGE, py, px, &yy, &xx, PROJECT_THRU);
/* Draw the path in "target" mode. If there is one */
if ((mode & (TARGET_KILL)) && (cave_info[y][x] & (CAVE_FIRE)))
{
/* Save target info */
path_drawn = draw_path(path_n, path_g, path_char, path_attr, py, px, y, x);
}
event_signal(EVENT_MOUSEBUTTONS);
/* Describe and Prompt (enable "TARGET_LOOK") */
query = target_set_interactive_aux(y, x, (mode | TARGET_LOOK), info, list_floor_objects);
/* Remove the path */
if (path_drawn) load_path(path_n, path_g, path_char, path_attr);
/* Cancel tracking */
/* health_track(0); */
/* Assume no direction */
d = 0;
/* Analyze the keypress */
switch (query.key)
{
case ESCAPE:
case 'q':
{
done = TRUE;
break;
}
case ' ':
case '*':
case '+':
case '-':
{
break;
}
case 'p':
{
/* Recenter around player */
verify_panel();
/* Handle stuff */
handle_stuff();
y = py;
x = px;
}
case 'o':
{
break;
}
case 'm':
{
/* Monster selection is disabled */
if (mode & (TARGET_GRID)) break;
flag = TRUE;
m = 0;
bd = 999;
/* Pick a nearby monster */
for (i = 0; i < temp_n; i++)
{
t = distance(y, x, temp_y[i], temp_x[i]);
/* Pick closest */
if (t < bd)
{
m = i;
bd = t;
}
}
/* Nothing interesting */
if (bd == 999) flag = FALSE;
break;
}
case '\xff':
{
/* We only target if we click somewhere where the cursor
is already (i.e. a double-click without a time limit) */
if (KEY_GRID_X(query) == x && KEY_GRID_Y(query) == y)
{
/* Make an attempt to target the monster on the given
square rather than the square itself (it seems this
is the more likely intention of clicking on a
monster). */
int m_idx = cave_m_idx[y][x];
if ((m_idx > 0) && target_able(m_idx))
{
health_track(m_idx);
target_set_monster(m_idx);
}
else
{
/* There is no monster, or it isn't targettable,
so target the location instead. */
target_set_location(y, x);
}
done = TRUE;
}
else
{
/* Just move the cursor for now - another click will
target. */
x = KEY_GRID_X(query);
y = KEY_GRID_Y(query);
}
break;
}
case 't':
case '5':
case '0':
case '.':
{
target_set_location(y, x);
done = TRUE;
break;
}
case 'g':
{
cmd_insert(CMD_PATHFIND, y, x);
done = TRUE;
break;
}
case 'l':
{
list_floor_objects = (!list_floor_objects);
}
case '?':
{
help = !help;
/* Redraw main window */
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
handle_stuff();
if (!help)
prt("'?' - help.", help_prompt_loc, 0);
break;
}
default:
{
/* Extract a direction */
d = target_dir(query.key);
/* Oops */
if (!d) bell("Illegal command for target mode!");
break;
}
}
/* Handle "direction" */
if (d)
{
int dungeon_hgt = p_ptr->cur_map_hgt;
int dungeon_wid = p_ptr->cur_map_wid;
/* Move */
x += ddx[d];
y += ddy[d];
/* Slide into legality */
if (x >= dungeon_wid - 1) x--;
else if (x <= 0) x++;
/* Slide into legality */
if (y >= dungeon_hgt - 1) y--;
else if (y <= 0) y++;
/* Adjust panel if needed */
if (adjust_panel(y, x))
{
/* Handle stuff */
handle_stuff();
/* Recalculate interesting grids */
target_set_interactive_prepare(mode);
}
}
}
}
/* Forget */
temp_n = 0;
/* Redraw as necessary */
if (help)
{
p_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_MAP | PR_EQUIP);
Term_clear();
}
else
{
prt("", 0, 0);
prt("", help_prompt_loc, 0);
p_ptr->redraw |= (PR_DEPTH | PR_STATUS);
}
/* Recenter around player */
verify_panel();
/* Restore buttons */
button_restore();
/* Handle stuff */
handle_stuff();
/* Failure to set target */
if (!p_ptr->target_set) return (FALSE);
/* Success */
return (TRUE);
}
/**
* This is a helper function used by do_cmd_throw and do_cmd_fire.
*
* It abstracts out the projectile path, display code, identify and clean up
* logic, while using the 'attack' parameter to do work particular to each
* kind of attack.
*/
static void ranged_helper(struct object *obj, int dir, int range, int shots,
ranged_attack attack)
{
int i, j;
char o_name[80];
int path_n;
struct loc path_g[256];
/* Start at the player */
int x = player->px;
int y = player->py;
/* Predict the "target" location */
int ty = y + 99 * ddy[dir];
int tx = x + 99 * ddx[dir];
bool hit_target = FALSE;
bool none_left = FALSE;
struct object *missile;
/* Check for target validity */
if ((dir == 5) && target_okay()) {
int taim;
target_get(&tx, &ty);
taim = distance(y, x, ty, tx);
if (taim > range) {
char msg[80];
strnfmt(msg, sizeof(msg),
"Target out of range by %d squares. Fire anyway? ",
taim - range);
if (!get_check(msg)) return;
}
}
/* Sound */
sound(MSG_SHOOT);
/* Describe the object */
object_desc(o_name, sizeof(o_name), obj, ODESC_FULL | ODESC_SINGULAR);
/* Actually "fire" the object -- Take a partial turn */
player->upkeep->energy_use = (z_info->move_energy / shots);
/* Calculate the path */
path_n = project_path(path_g, range, y, x, ty, tx, 0);
/* Hack -- Handle stuff */
handle_stuff(player);
/* Start at the player */
x = player->px;
y = player->py;
/* Project along the path */
for (i = 0; i < path_n; ++i) {
struct monster *mon = NULL;
int ny = path_g[i].y;
int nx = path_g[i].x;
bool see = square_isseen(cave, ny, nx);
/* Stop before hitting walls */
if (!(square_ispassable(cave, ny, nx)) &&
!(square_isprojectable(cave, ny, nx)))
break;
/* Advance */
x = nx;
y = ny;
/* Tell the UI to display the missile */
event_signal_missile(EVENT_MISSILE, obj, see, y, x);
/* Try the attack on the monster at (x, y) if any */
mon = square_monster(cave, y, x);
if (mon) {
int visible = mflag_has(mon->mflag, MFLAG_VISIBLE);
bool fear = FALSE;
const char *note_dies = monster_is_unusual(mon->race) ?
" is destroyed." : " dies.";
struct attack_result result = attack(obj, y, x);
int dmg = result.dmg;
u32b msg_type = result.msg_type;
char hit_verb[20];
my_strcpy(hit_verb, result.hit_verb, sizeof(hit_verb));
mem_free(result.hit_verb);
if (result.success) {
hit_target = TRUE;
object_notice_attack_plusses(obj);
/* Learn by use for other equipped items */
equip_notice_to_hit_on_attack(player);
/* No negative damage; change verb if no damage done */
if (dmg <= 0) {
dmg = 0;
msg_type = MSG_MISS;
my_strcpy(hit_verb, "fails to harm", sizeof(hit_verb));
}
if (!visible) {
/* Invisible monster */
msgt(MSG_SHOOT_HIT, "The %s finds a mark.", o_name);
} else {
for (j = 0; j < (int)N_ELEMENTS(ranged_hit_types); j++) {
char m_name[80];
const char *dmg_text = "";
if (msg_type != ranged_hit_types[j].msg)
continue;
if (OPT(show_damage))
dmg_text = format(" (%d)", dmg);
monster_desc(m_name, sizeof(m_name), mon, MDESC_OBJE);
if (ranged_hit_types[j].text)
msgt(msg_type, "Your %s %s %s%s. %s", o_name,
hit_verb, m_name, dmg_text,
ranged_hit_types[j].text);
else
msgt(msg_type, "Your %s %s %s%s.", o_name, hit_verb,
m_name, dmg_text);
}
/* Track this monster */
if (mflag_has(mon->mflag, MFLAG_VISIBLE)) {
monster_race_track(player->upkeep, mon->race);
health_track(player->upkeep, mon);
}
}
/* Hit the monster, check for death */
if (!mon_take_hit(mon, dmg, &fear, note_dies)) {
message_pain(mon, dmg);
if (fear && mflag_has(mon->mflag, MFLAG_VISIBLE)) {
char m_name[80];
monster_desc(m_name, sizeof(m_name), mon,
MDESC_DEFAULT);
add_monster_message(m_name, mon,
MON_MSG_FLEE_IN_TERROR, TRUE);
}
}
}
/* Stop the missile */
break;
}
/* Stop if non-projectable but passable */
if (!(square_isprojectable(cave, ny, nx)))
break;
}
/* Get the missile */
if (object_is_carried(player, obj))
missile = gear_object_for_use(obj, 1, TRUE, &none_left);
else
missile = floor_object_for_use(obj, 1, TRUE, &none_left);
/* Drop (or break) near that location */
drop_near(cave, missile, breakage_chance(missile, hit_target), y, x, TRUE);
}