/**
* Change the current panel to the panel lying in the given direction.
*
* Return TRUE if the panel was changed.
*/
bool change_panel(int dir)
{
bool changed = FALSE;
int j;
/* Scan windows */
for (j = 0; j < ANGBAND_TERM_MAX; j++)
{
int screen_hgt, screen_wid;
int wx, wy;
term *t = angband_term[j];
/* No window */
if (!t) continue;
/* No relevant flags */
if ((j > 0) && !(window_flag[j] & PW_MAPS)) continue;
screen_hgt = (j == 0) ? SCREEN_HGT : t->hgt;
screen_wid = (j == 0) ? SCREEN_WID : t->wid;
/* Shift by half a panel */
wy = t->offset_y + ddy[dir] * screen_hgt / 2;
wx = t->offset_x + ddx[dir] * screen_wid / 2;
/* Use "modify_panel" */
if (modify_panel(t, wy, wx)) changed = TRUE;
}
return (changed);
}
void verify_panel_int(bool centered)
{
int wy, wx;
int screen_hgt, screen_wid;
int panel_wid, panel_hgt;
int py = p_ptr->py;
int px = p_ptr->px;
int j;
int hor = 3 * (1 + op_ptr->panel_change);
int vert = 3 * (1 + op_ptr->panel_change);
/* Scan windows */
for (j = 0; j < ANGBAND_TERM_MAX; j++) {
term *t = angband_term[j];
/* No window */
if (!t)
continue;
/* No relevant flags */
if ((j > 0) && !(op_ptr->window_flag[j] & (PW_MAP)))
continue;
wy = t->offset_y;
wx = t->offset_x;
screen_hgt = (j == 0) ? SCREEN_HGT : t->hgt;
screen_wid = (j == 0) ? SCREEN_WID : t->wid;
panel_wid = screen_wid / 2;
panel_hgt = screen_hgt / 2;
/* Scroll screen vertically when off-center */
if (centered && !p_ptr->running && (py != wy + panel_hgt))
wy = py - panel_hgt;
/* Scroll screen vertically when 3 grids from top/bottom edge */
else if ((py < wy + vert) || (py >= wy + screen_hgt - vert))
wy = py - panel_hgt;
/* Scroll screen horizontally when off-center */
if (centered && !p_ptr->running && (px != wx + panel_wid))
wx = px - panel_wid;
/* Scroll screen horizontally when 3 grids from left/right edge */
else if ((px < wx + hor) || (px >= wx + screen_wid - hor))
wx = px - panel_wid;
/* Scroll if needed */
modify_panel(t, wy, wx);
}
}
/*
* Perform the minimum "whole panel" adjustment to ensure that the given
* location is contained inside the current panel, and return TRUE if any
* such adjustment was performed. Optionally accounts for the targeting
* help window.
*/
bool adjust_panel_help(int y, int x, bool help)
{
bool changed = FALSE;
int j;
int screen_hgt_main = help ? (Term->hgt - ROW_MAP - 3)
: (Term->hgt - ROW_MAP - 1);
/* Scan windows */
for (j = 0; j < ANGBAND_TERM_MAX; j++)
{
int wx, wy;
int screen_hgt, screen_wid;
term *t = angband_term[j];
/* No window */
if (!t) continue;
/* No relevant flags */
if ((j > 0) && !(op_ptr->window_flag[j] & PW_MAP)) continue;
wy = t->offset_y;
wx = t->offset_x;
screen_hgt = (j == 0) ? screen_hgt_main : t->hgt;
screen_wid = (j == 0) ? (Term->wid - COL_MAP - 1) : t->wid;
/* Bigtile panels need adjustment */
screen_wid = screen_wid / tile_width;
screen_hgt = screen_hgt / tile_height;
/* Adjust as needed */
while (y >= wy + screen_hgt) wy += screen_hgt / 2;
while (y < wy) wy -= screen_hgt / 2;
/* Adjust as needed */
while (x >= wx + screen_wid) wx += screen_wid / 2;
while (x < wx) wx -= screen_wid / 2;
/* Use "modify_panel" */
if (modify_panel(t, wy, wx)) changed = TRUE;
}
return (changed);
}
/*
* Perform the minimum "whole panel" adjustment to ensure that the given
* location is contained inside the current panel, and return TRUE if any
* such adjustment was performed.
*/
bool adjust_panel(int y, int x)
{
bool changed = FALSE;
int j;
/* Scan windows */
for (j = 0; j < ANGBAND_TERM_MAX; j++) {
int wx, wy;
int screen_hgt, screen_wid;
term *t = angband_term[j];
/* No window */
if (!t)
continue;
/* No relevant flags */
if ((j > 0) && !(op_ptr->window_flag[j] & PW_MAP))
continue;
wy = t->offset_y;
wx = t->offset_x;
screen_hgt = (j == 0) ? SCREEN_HGT : t->hgt;
screen_wid = (j == 0) ? SCREEN_WID : t->wid;
/* Adjust as needed */
while (y >= wy + screen_hgt)
wy += screen_hgt / 2;
while (y < wy)
wy -= screen_hgt / 2;
/* Adjust as needed */
while (x >= wx + screen_wid)
wx += screen_wid / 2;
while (x < wx)
wx -= screen_wid / 2;
/* Use "modify_panel" */
if (modify_panel(t, wy, wx))
changed = TRUE;
}
return (changed);
}
/*
* 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);
}
/*
* 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 i, d, m, t, bd;
int wid, hgt, help_prompt_loc;
bool done = FALSE;
bool flag = TRUE;
bool help = FALSE;
ui_event_data query;
/* 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)
{
/* 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 */
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));
}
/* Describe and Prompt */
query = target_set_interactive_aux(y, x, mode);
/* Cancel tracking */
/* health_track(0); */
/* Assume no "direction" */
d = 0;
/* 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. */
if (query.type == EVT_MOUSE)
{
x = KEY_GRID_X(query);
y = KEY_GRID_Y(query);
flag = FALSE;
break;
}
else
{
/* 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 = 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(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.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
{
/* 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));
}
/* Describe and Prompt (enable "TARGET_LOOK") */
query = target_set_interactive_aux(y, x, mode | TARGET_LOOK);
/* Cancel tracking */
/* health_track(0); */
/* Assume no direction */
d = 0;
if (query.type == EVT_MOUSE)
{
/* 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;
}
else
{
/* 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 = 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.key);
/* 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);
}
/*
* 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);
}
/*
* 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);
}