void ClassCPV::state_change(const unsigned char cl, const unsigned char t)
{
myteam = e_Team(t);
hp = 0; // we are dead until further notice (the further notice being a status update)
// print PC info:
if((myclass = e_Class(cl)) == NO_CLASS) // spectator
Base::print_str("Spectator ", team_colour[T_SPEC], PC_INFO_X, 3, STAT_WIN, false);
else // actual class
{
Base::print_str(pcview_classname[myclass].c_str(), team_colour[myteam],
PC_INFO_X, 3, STAT_WIN, false);
dam_die = classes[myclass].dam_die;
dv = classes[myclass].dv;
pv = classes[myclass].pv;
}
// Clear the rest:
for(char y = 4; y < 7; ++y)
Base::print_str(" ", team_colour[T_SPEC], PC_INFO_X, y, STAT_WIN, false);
Base::print_str(" ", team_colour[T_SPEC], 52, 3, STAT_WIN, false); // map area
// class/team change requires any class-specific action to end:
if(clientstate >= CS_AIMING)
{
clientstate = CS_NORMAL;
redraw_view();
}
}
void ClassCPV::move(const e_Dir d)
{
if(clientstate == CS_NORMAL) // regular movement
Network::send_action(XN_MOVE, d);
else if(clientstate == CS_AIMING) // moving the aimer
{
aimer = aimer.in(d);
if(aimer.x > VIEWSIZE/2) aimer.x--;
else if(aimer.x < -VIEWSIZE/2) aimer.x++;
if(aimer.y > VIEWSIZE/2) aimer.y--;
else if(aimer.y < -VIEWSIZE/2) aimer.y++;
redraw_view();
}
else if(clientstate == CS_DIR) // waiting for dir input (and now got it!)
{
if(myclass == C_FIGHTER)
Network::send_action(XN_CIRCLE_ATTACK, d);
else if(myclass == C_HEALER)
Network::send_action(XN_HEAL, d);
else if(myclass == C_MINER)
Network::send_action(XN_MINE, d);
else if(myclass == C_COMBAT_MAGE)
Network::send_action(XN_ZAP, d);
clientstate = CS_NORMAL;
}
// else ignore
}
void toggle_titles()
{
if((showtitles = !showtitles))
draw_titles();
else
redraw_view();
}
static void redraw_display(bool clear)
{
struct view *view;
view = display[0];
if (clear)
wclear(view->win);
redraw_view(view);
update_title_win(view);
}
static void
leave_menu_mode(void)
{
reset_popup_menu(menu);
clean_selected_files(view);
redraw_view(view);
*mode = NORMAL_MODE;
if(was_redraw)
update_screen(UT_FULL);
else
update_all_windows();
}
void
redraw_display(bool clear)
{
struct view *view;
int i;
foreach_displayed_view (view, i) {
if (clear)
wclear(view->win);
redraw_view(view);
update_view_title(view);
}
redraw_display_separator(clear);
}
void
view_explore_mode_quit(FileView *view)
{
assert(!vle_mode_is(VIEW_MODE) && "Unexpected mode.");
if(!view->explore_mode)
{
return;
}
view->explore_mode = 0;
reset_view_info(&view_info[(view == &lwin) ? VI_LWIN : VI_RWIN]);
redraw_view(view);
ui_view_title_update(view);
}
void ClassCPV::five()
{
if(clientstate == CS_AIMING)
{
if(aimer.x || aimer.y)
{
aimer.x = aimer.y = 0;
redraw_view();
}
}
else if(clientstate == CS_DIR && myclass == C_HEALER)
{
Network::send_action(XN_HEAL, MAX_D); // heal self
clientstate = CS_NORMAL;
}
// else ignore
}
void ClassCPV::space()
{
if(!im_alive())
Network::send_action(XN_FOLLOW_SWITCH);
else
{
switch(myclass)
{
case C_ARCHER:
if(clientstate == CS_AIMING)
{
if(aimer.x || aimer.y) // aiming *somewhere*
Network::send_action(XN_SHOOT, aimer.x, aimer.y);
clientstate = CS_NORMAL;
}
else
{
aimer.x = aimer.y = 0;
clientstate = CS_AIMING;
}
redraw_view();
break;
case C_ASSASSIN:
Network::send_action(XN_FLASH);
break;
case C_MINDCRAFTER:
Network::send_action(XN_BLINK);
break;
case C_SCOUT:
Network::send_action(XN_DISGUISE);
break;
case C_TRAPPER:
Network::send_action(XN_SET_TRAP);
break;
case C_WIZARD:
Network::send_action(XN_MM);
break;
case C_PLANEWALKER:
Network::send_action(XN_MINDS_EYE);
break;
default: //C_FIGHTER, C_HEALER, C_MINER, C_COMBAT_MAGE
clientstate = CS_DIR;
break;
}
} // not spectator or dead
}
static void
prompt_update_display(enum view_flag flags)
{
struct view *view;
int i;
if (flags & VIEW_RESET_DISPLAY) {
resize_display();
redraw_display(TRUE);
}
foreach_displayed_view(view, i) {
if (view_has_flags(view, flags) && view_can_refresh(view))
reload_view(view);
else
redraw_view(view);
}
}
/* Leaves menu mode, possibly resetting selection. Does nothing if current mode
* isn't menu mode. */
static void
leave_menu_mode(int reset_selection)
{
/* Some menu implementation could have switched mode from one of handlers. */
if(!vle_mode_is(MENU_MODE))
{
return;
}
reset_popup_menu(menu);
if(reset_selection)
{
clean_selected_files(view);
redraw_view(view);
}
vle_mode_set(NORMAL_MODE, VMT_PRIMARY);
update_ui_on_leaving();
}
/* Leaves menu mode, possibly resetting selection. Does nothing if current mode
* isn't menu mode. */
static void
leave_menu_mode(int reset_selection)
{
/* Some menu implementation could have switched mode from one of handlers. */
if(!vle_mode_is(MENU_MODE))
{
return;
}
menus_reset_data(menu);
if(reset_selection)
{
flist_sel_stash(view);
redraw_view(view);
}
vle_mode_set(NORMAL_MODE, VMT_PRIMARY);
update_ui_on_leaving();
}
/* Callback that is called when menu item is selected. Should return non-zero
* to stay in menu mode. */
int
execute_filetype_cb(FileView *view, menu_info *m)
{
if(view->dir_entry[view->list_pos].type == FT_DIR && m->pos == 0)
{
open_dir(view);
}
else
{
const char *prog_str = strchr(m->data[m->pos], '|') + 1;
if(prog_str[0] != '\0')
{
int background = m->extra_data & 1;
run_using_prog(view, prog_str, 0, background);
}
}
clean_selected_files(view);
redraw_view(view);
return 0;
}
void
enter_visual_mode(VisualSubmodes sub_mode)
{
const int ub = check_mark_directory(curr_view, '<');
const int lb = check_mark_directory(curr_view, '>');
if(sub_mode == VS_RESTORE && (ub < 0 || lb < 0))
{
return;
}
view = curr_view;
start_pos = view->list_pos;
vle_mode_set(VISUAL_MODE, VMT_PRIMARY);
switch(sub_mode)
{
case VS_NORMAL:
amend_type = AT_NONE;
flist_sel_stash(view);
backup_selection_flags(view);
select_first_one();
break;
case VS_RESTORE:
amend_type = AT_NONE;
flist_sel_stash(view);
backup_selection_flags(view);
restore_previous_selection();
break;
case VS_AMEND:
amend_type = AT_APPEND;
backup_selection_flags(view);
select_first_one();
break;
}
redraw_view(view);
}
void
leave_visual_mode(int save_msg, int goto_top, int clear_selection)
{
if(goto_top)
{
int ub = check_mark_directory(view, '<');
if(ub != -1)
view->list_pos = ub;
}
if(clear_selection)
{
reset_search_results(view);
restore_selection_flags(view);
redraw_view(view);
}
curr_stats.save_msg = save_msg;
if(vle_mode_is(VISUAL_MODE))
{
vle_mode_set(NORMAL_MODE, VMT_PRIMARY);
}
}
/* Performs postponed updates for the view, if any. Returns non-zero if
* something was indeed updated, and zero otherwise. */
TSTATIC int
process_scheduled_updates_of_view(view_t *view)
{
if(!window_shows_dirlist(view))
{
return 0;
}
switch(ui_view_query_scheduled_event(view))
{
case UUE_NONE:
/* Nothing to do. */
return 0;
case UUE_REDRAW:
redraw_view(view);
return 1;
case UUE_RELOAD:
load_saving_pos(view);
return 1;
}
assert(0 && "Unexpected type of scheduled UI event.");
return 0;
}
enum request
run_prompt_command(struct view *view, const char *argv[])
{
enum request request;
const char *cmd = argv[0];
size_t cmdlen = cmd ? strlen(cmd) : 0;
if (!cmd)
return REQ_NONE;
if (string_isnumber(cmd)) {
int lineno = view->pos.lineno + 1;
if (parse_int(&lineno, cmd, 1, view->lines + 1) == SUCCESS) {
select_view_line(view, lineno - 1);
report_clear();
} else {
report("Unable to parse '%s' as a line number", cmd);
}
} else if (iscommit(cmd)) {
string_ncopy(view->env->search, cmd, cmdlen);
return REQ_JUMP_COMMIT;
} else if (cmdlen > 1 && (cmd[0] == '/' || cmd[0] == '?')) {
char search[SIZEOF_STR];
if (!argv_to_string(argv, search, sizeof(search), " ")) {
report("Failed to copy search string");
return REQ_NONE;
}
if (!strcmp(search + 1, view->env->search))
return cmd[0] == '/' ? REQ_FIND_NEXT : REQ_FIND_PREV;
string_ncopy(view->env->search, search + 1, strlen(search + 1));
return cmd[0] == '/' ? REQ_SEARCH : REQ_SEARCH_BACK;
} else if (cmdlen > 1 && cmd[0] == '!') {
struct view *next = &pager_view;
bool copied;
/* Trim the leading '!'. */
argv[0] = cmd + 1;
copied = argv_format(view->env, &next->argv, argv, FALSE, TRUE);
argv[0] = cmd;
if (!copied) {
report("Argument formatting failed");
} else {
/* When running random commands, initially show the
* command in the title. However, it maybe later be
* overwritten if a commit line is selected. */
argv_to_string(next->argv, next->ref, sizeof(next->ref), " ");
next->dir = NULL;
open_pager_view(view, OPEN_PREPARED | OPEN_WITH_STDERR);
}
} else if (!strcmp(cmd, "toggle")) {
char action[SIZEOF_STR] = "";
enum view_flag flags = prompt_toggle(view, argv, action);
int i;
if (flags & VIEW_RESET_DISPLAY) {
resize_display();
redraw_display(TRUE);
}
foreach_displayed_view(view, i) {
if (view_has_flags(view, flags) && !view->unrefreshable)
reload_view(view);
else
redraw_view(view);
}
if (*action)
report("%s", action);
} else {
bool Input::inputhandle()
{
if(clientstate == CS_TYPE_CHAT || clientstate == CS_TYPE_SHOUT)
{
if(check_typing()) // returns true if done typing
{
clientstate = CS_NORMAL;
Base::def_cursor();
}
return false;
}
// else
int key = getch();
if(key != ERR) // there is some key
{
if(key == KEYCODE_INT)
return true; // ^C quits
if(clientstate == CS_HELP || clientstate == CS_TEAM_INFO)
{
// any key in help screen closes help
leave_limbo(); // not leaving limbo, but the functionality is the same
return false;
}
// Quickshouts handled regardless of clientstate:
if(ClassCPV::im_alive())
{
for(char f = 1; f <= MAX_QUICK_SHOUTS; ++f)
{
if(key == KEY_F(f))
{
if(!Config::quick_shout(--f).empty())
Network::send_line(Config::quick_shout(f), false);
return false;
}
}
}
if(clientstate == CS_LIMBO)
{
key = tolower(key);
if(key <= 'k' && key >= 'a') // switch class
{
Network::send_spawn((unsigned char)(key - 'a'));
leave_limbo();
}
else if(key == 't')
{
Network::send_switch();
leave_limbo();
}
else if(key == 's')
{
Network::send_spawn(NO_CLASS);
leave_limbo();
}
else if(key == 'l' || key == 27) // 27: escape
leave_limbo();
}
else
{
if(key == '?') // help key
{
clientstate = CS_HELP;
walkmode_off();
redraw_view();
Base::type_cursor(0);
return false;
}
// if here, we need to convert the key:
e_Key_binding kb = MAX_KEY_BINDING;
if(key < 256) // fits in a byte; try to convert
kb = Config::convert_key(char(key));
// map arrow keys to the directions, for the n00bs:
else if(key == KEY_UP)
kb = KB_8;
else if(key == KEY_DOWN)
kb = KB_2;
else if(key == KEY_LEFT)
kb = KB_4;
else if(key == KEY_RIGHT)
kb = KB_6;
if(kb < MAX_KEY_BINDING) // a recognized key
{
switch(kb)
{
/*
* The effect of these depends on clientstate & class.
* The handling is delegated to class_cpv.cpp
*/
case KB_1: // movement
case KB_2: case KB_3: case KB_4: case KB_6: case KB_7: case KB_8: case KB_9:
ClassCPV::move((last_dir = e_Dir(kb)));
break;
case KB_5: // special direction
ClassCPV::five();
last_dir = MAX_D;
break;
case KB_SPACE: // action key
ClassCPV::space();
walkmode_off();
break;
case KB_p: // follow previous key
ClassCPV::follow_prev();
walkmode_off();
break;
/*
* These can be done in the middle of unfinished actions, but will cause
* interruption:
*/
case KB_C: // say in chat
clientstate = CS_TYPE_CHAT;
init_type();
walkmode_off();
break;
case KB_s: // say aloud
clientstate = CS_TYPE_SHOUT;
init_type();
walkmode_off();
break;
case KB_c: // close a door
Network::send_action(XN_CLOSE_DOOR);
// interrupts any aiming/casting etc:
clientstate = CS_NORMAL;
walkmode_off();
break;
case KB_u: // torch handling
Network::send_action(XN_TORCH_HANDLE);
// interrupts any aiming/casting etc:
clientstate = CS_NORMAL;
walkmode_off();
break;
case KB_T: // trigger a trap
Network::send_action(XN_TRAP_TRIGGER);
// interrupts any aiming/casting etc:
clientstate = CS_NORMAL;
walkmode_off();
break;
case KB_X: // suicide
ClassCPV::suicide();
walkmode_off();
break;
case KB_l: // limbo toggle
clientstate = CS_LIMBO;
walkmode_off();
redraw_view();
Base::type_cursor(0);
break;
case KB_i: // request team info
Network::send_teami_req();
break;
case KB_Q: // quit
return true; // confirmation? nah
/*
* The following can be carried out in any clientstate except limbo
* without interruption:
*/
case KB_w: // walk toggle
if(walkmode)
walkmode_off();
else
Base::print_walk((walkmode = true));
break;
case KB_t: // titles toggle
toggle_titles();
break;
case KB_d: // differentiate titles
diff_titles();
break;
case KB_o: // ouching toggle
add_msg(string("[Reacting to damage ") + offon[Config::toggle_ouch()], 15);
break;
case KB_PLUS:
scroll_chat_up();
break;
case KB_MINUS:
scroll_chat_down();
break;
case KB_PERCENT:
add_msg(string("[Act per turn ") + offon[Config::toggle_act_per_turn()], 15);
break;
default: break;
}
} // a recognized key binding
} // need to convert key
} // key != ERR
else if(clientstate == CS_NORMAL && walkmode && last_dir != MAX_D
&& Network::not_acted())
ClassCPV::move(last_dir);
return false;
}
static int
view_driver(struct view *view, enum request request)
{
int i;
if (request == REQ_NONE)
return TRUE;
if (request >= REQ_RUN_REQUESTS) {
request = open_run_request(view, request);
// exit quickly rather than going through view_request and back
if (request == REQ_QUIT)
return FALSE;
}
request = view_request(view, request);
if (request == REQ_NONE)
return TRUE;
switch (request) {
case REQ_MOVE_UP:
case REQ_MOVE_DOWN:
case REQ_MOVE_PAGE_UP:
case REQ_MOVE_PAGE_DOWN:
case REQ_MOVE_FIRST_LINE:
case REQ_MOVE_LAST_LINE:
move_view(view, request);
break;
case REQ_SCROLL_FIRST_COL:
case REQ_SCROLL_LEFT:
case REQ_SCROLL_RIGHT:
case REQ_SCROLL_LINE_DOWN:
case REQ_SCROLL_LINE_UP:
case REQ_SCROLL_PAGE_DOWN:
case REQ_SCROLL_PAGE_UP:
case REQ_SCROLL_WHEEL_DOWN:
case REQ_SCROLL_WHEEL_UP:
scroll_view(view, request);
break;
case REQ_VIEW_GREP:
open_grep_view(view);
break;
case REQ_VIEW_MAIN:
case REQ_VIEW_DIFF:
case REQ_VIEW_LOG:
case REQ_VIEW_TREE:
case REQ_VIEW_HELP:
case REQ_VIEW_BRANCH:
case REQ_VIEW_BLAME:
case REQ_VIEW_BLOB:
case REQ_VIEW_STATUS:
case REQ_VIEW_STAGE:
case REQ_VIEW_PAGER:
case REQ_VIEW_STASH:
open_view(view, request, OPEN_DEFAULT);
break;
case REQ_NEXT:
case REQ_PREVIOUS:
if (view->parent) {
int line;
view = view->parent;
line = view->pos.lineno;
view_request(view, request);
move_view(view, request);
if (view_is_displayed(view))
update_view_title(view);
if (line != view->pos.lineno)
view_request(view, REQ_ENTER);
} else {
move_view(view, request);
}
break;
case REQ_VIEW_NEXT:
{
int nviews = displayed_views();
int next_view = (current_view + 1) % nviews;
if (next_view == current_view) {
report("Only one view is displayed");
break;
}
current_view = next_view;
/* Blur out the title of the previous view. */
update_view_title(view);
report_clear();
break;
}
case REQ_REFRESH:
report("Refreshing is not supported by the %s view", view->name);
break;
case REQ_PARENT:
report("Moving to parent is not supported by the the %s view", view->name);
break;
case REQ_BACK:
report("Going back is not supported for by %s view", view->name);
break;
case REQ_MAXIMIZE:
if (displayed_views() == 2)
maximize_view(view, TRUE);
break;
case REQ_OPTIONS:
case REQ_TOGGLE_LINENO:
case REQ_TOGGLE_DATE:
case REQ_TOGGLE_AUTHOR:
case REQ_TOGGLE_FILENAME:
case REQ_TOGGLE_GRAPHIC:
case REQ_TOGGLE_REV_GRAPH:
case REQ_TOGGLE_REFS:
case REQ_TOGGLE_CHANGES:
case REQ_TOGGLE_IGNORE_SPACE:
case REQ_TOGGLE_ID:
case REQ_TOGGLE_FILES:
case REQ_TOGGLE_TITLE_OVERFLOW:
case REQ_TOGGLE_FILE_SIZE:
case REQ_TOGGLE_UNTRACKED_DIRS:
case REQ_TOGGLE_VERTICAL_SPLIT:
{
char action[SIZEOF_STR] = "";
enum view_flag flags = toggle_option(view, request, action);
if (flags == VIEW_FLAG_RESET_DISPLAY) {
resize_display();
redraw_display(TRUE);
} else {
foreach_displayed_view(view, i) {
if (view_has_flags(view, flags) && !view->unrefreshable)
reload_view(view);
else
redraw_view(view);
}
}
if (*action)
report("%s", action);
}
break;
case REQ_TOGGLE_SORT_FIELD:
case REQ_TOGGLE_SORT_ORDER:
report("Sorting is not yet supported for the %s view", view->name);
break;
case REQ_DIFF_CONTEXT_UP:
case REQ_DIFF_CONTEXT_DOWN:
report("Changing the diff context is not yet supported for the %s view", view->name);
break;
case REQ_SEARCH:
case REQ_SEARCH_BACK:
search_view(view, request);
break;
case REQ_FIND_NEXT:
case REQ_FIND_PREV:
find_next(view, request);
break;
case REQ_STOP_LOADING:
foreach_view(view, i) {
if (view->pipe)
report("Stopped loading the %s view", view->name),
end_update(view, TRUE);
}
break;
case REQ_SHOW_VERSION:
report("tig-%s (built %s)", TIG_VERSION, __DATE__);
return TRUE;
case REQ_SCREEN_REDRAW:
redraw_display(TRUE);
break;
case REQ_EDIT:
report("Nothing to edit");
break;
case REQ_ENTER:
report("Nothing to enter");
break;
case REQ_VIEW_CLOSE:
/* XXX: Mark closed views by letting view->prev point to the
* view itself. Parents to closed view should never be
* followed. */
if (view->prev && view->prev != view) {
maximize_view(view->prev, TRUE);
view->prev = view;
break;
}
/* Fall-through */
case REQ_QUIT:
return FALSE;
default:
report("Unknown key, press %s for help",
get_view_key(view, REQ_VIEW_HELP));
return TRUE;
}
return TRUE;
}
