public static void cmd_rest()
{
/* Prompt for time if needed */
if (Misc.p_ptr.command_arg <= 0)
{
string p = "Rest (0-9999, '!' for HP or SP, '*' for HP and SP, '&' as needed): ";
string out_val = "& ";
//char out_val[5] = "& ";
/* Ask for duration */
if (!Utilities.get_string(p, ref out_val, 4))
{
return;
}
/* Rest until done */
if (out_val[0] == '&')
{
Game_Command.insert(Command_Code.REST);
Game_Command.get_top().set_arg_choice(0, (int)Misc.REST.COMPLETE);
}
/* Rest a lot */
else if (out_val[0] == '*')
{
Game_Command.insert(Command_Code.REST);
Game_Command.get_top().set_arg_choice(0, (int)Misc.REST.ALL_POINTS);
}
/* Rest until HP or SP filled */
else if (out_val[0] == '!')
{
Game_Command.insert(Command_Code.REST);
Game_Command.get_top().set_arg_choice(0, (int)Misc.REST.SOME_POINTS);
}
/* Rest some */
else
{
int turns = int.Parse(out_val);
if (turns <= 0)
{
return;
}
if (turns > 9999)
{
turns = 9999;
}
Game_Command.insert(Command_Code.REST);
Game_Command.get_top().set_arg_choice(0, (int)turns);
}
}
}
/* ------------------------------------------------------------------------
* Final confirmation of character.
* ------------------------------------------------------------------------ */
static birth_stage get_confirm_command()
{
Player.Player p_ptr = Player.Player.instance;
string prompt = "['ESC' to step back, 'S' to start over, or any other key to continue]";
keypress ke;
birth_stage next;
/* Prompt for it */
Utilities.prt(prompt, Term.instance.hgt - 1, Term.instance.wid / 2 - (prompt.Length / 2));
/* Buttons */
Button.button_kill_all();
Button.button_add("[Continue]", 'q');
Button.button_add("[ESC]", (char)keycode_t.ESCAPE);
Button.button_add("[S]", 'S');
p_ptr.redraw_stuff();
/* Get a key */
ke = Utilities.inkey();
/* Start over */
if (ke.code == (keycode_t)'S' || ke.code == (keycode_t)'s')
{
next = birth_stage.BIRTH_RESET;
}
else if (ke.code == (keycode_t)UIEvent.KTRL('X'))
{
Game_Command.insert(Command_Code.QUIT);
next = birth_stage.BIRTH_COMPLETE;
}
else if (ke.code == keycode_t.ESCAPE)
{
next = birth_stage.BIRTH_BACK;
}
else
{
Game_Command.insert(Command_Code.ACCEPT_CHARACTER);
next = birth_stage.BIRTH_COMPLETE;
}
/* Buttons */
Button.button_kill_all();
p_ptr.redraw_stuff();
/* Clear prompt */
Utilities.clear_from(23);
return(next);
}
/*
* Pass the appropriate "Initialisation screen" command to the game,
* getting user input if needed.
*/
static int get_init_cmd()
{
/* Wait for response */
Utilities.pause_line(Term.instance);
if (new_game)
{
Game_Command.insert(Command_Code.NEWGAME);
}
else
{
/* This might be modified to supply the filename in future. */
Game_Command.insert(Command_Code.LOADFILE);
}
/* Everything's OK. */
return(0);
}
/* ------------------------------------------------------------------------
* Asking for the player's chosen name.
* ------------------------------------------------------------------------ */
static birth_stage get_name_command()
{
birth_stage next;
string name = "";
if (Utilities.get_name(ref name, 32))
{
Game_Command.insert(Command_Code.NAME_CHOICE);
Game_Command.get_top().set_arg_choice(0, name);
next = birth_stage.BIRTH_FINAL_CONFIRM;
}
else
{
next = birth_stage.BIRTH_BACK;
}
return(next);
}
/*
* Move player in the given direction.
*
* This routine should only be called when energy has been expended.
*
* Note that this routine handles monsters in the destination grid,
* and also handles attempting to move into walls/doors/rubble/etc.
*/
public static void move_player(int dir, bool disarm)
{
int py = Misc.p_ptr.py;
int px = Misc.p_ptr.px;
int y = py + Misc.ddy[dir];
int x = px + Misc.ddx[dir];
int m_idx = Cave.cave.m_idx[y][x];
/* Attack monsters */
if (m_idx > 0)
{
/* Mimics surprise the player */
if (Monster.Monster.is_mimicking(m_idx))
{
throw new NotImplementedException();
//become_aware(m_idx);
///* Mimic wakes up */
//mon_clear_timed(m_idx, MON_TMD_SLEEP, MON_TMD_FLG_NOMESSAGE, false);
}
else
{
Attack.py_attack(y, x);
}
}
/* Optionally alter traps/doors on movement */
else if (disarm && (Cave.cave.info[y][x] & Cave.CAVE_MARK) != 0 &&
(Cave.cave_isknowntrap(Cave.cave, y, x) ||
Cave.cave_iscloseddoor(Cave.cave, y, x)))
{
/* Auto-repeat if not already repeating */
if (Game_Command.get_nrepeats() == 0)
{
Game_Command.set_repeat(99);
}
Do_Command.alter_aux(dir);
}
/* Cannot walk through walls */
else if (!Cave.cave_floor_bold(y, x))
{
/* Disturb the player */
Cave.disturb(Misc.p_ptr, 0, 0);
/* Notice unknown obstacles */
if ((Cave.cave.info[y][x] & Cave.CAVE_MARK) == 0)
{
/* Rubble */
if (Cave.cave.feat[y][x] == Cave.FEAT_RUBBLE)
{
Utilities.msgt(Message_Type.MSG_HITWALL, "You feel a pile of rubble blocking your way.");
Cave.cave.info[y][x] |= (Cave.CAVE_MARK);
Cave.cave_light_spot(Cave.cave, y, x);
}
/* Closed door */
else if (Cave.cave.feat[y][x] < Cave.FEAT_SECRET)
{
Utilities.msgt(Message_Type.MSG_HITWALL, "You feel a door blocking your way.");
Cave.cave.info[y][x] |= (Cave.CAVE_MARK);
Cave.cave_light_spot(Cave.cave, y, x);
}
/* Wall (or secret door) */
else
{
Utilities.msgt(Message_Type.MSG_HITWALL, "You feel a wall blocking your way.");
Cave.cave.info[y][x] |= (Cave.CAVE_MARK);
Cave.cave_light_spot(Cave.cave, y, x);
}
}
/* Mention known obstacles */
else
{
if (Cave.cave.feat[y][x] == Cave.FEAT_RUBBLE)
{
Utilities.msgt(Message_Type.MSG_HITWALL, "There is a pile of rubble blocking your way.");
}
else if (Cave.cave.feat[y][x] < Cave.FEAT_SECRET)
{
Utilities.msgt(Message_Type.MSG_HITWALL, "There is a door blocking your way.");
}
else
{
Utilities.msgt(Message_Type.MSG_HITWALL, "There is a wall blocking your way.");
}
}
}
/* Normal movement */
else
{
/* See if trap detection status will change */
bool old_dtrap = ((Cave.cave.info2[py][px] & (Cave.CAVE2_DTRAP)) != 0);
bool new_dtrap = ((Cave.cave.info2[y][x] & (Cave.CAVE2_DTRAP)) != 0);
/* Note the change in the detect status */
if (old_dtrap != new_dtrap)
{
Misc.p_ptr.redraw |= (Misc.PR_DTRAP);
}
/* Disturb player if the player is about to leave the area */
if (Option.disturb_detect.value && Misc.p_ptr.running != 0 &&
!Misc.p_ptr.running_firststep && old_dtrap && !new_dtrap)
{
Cave.disturb(Misc.p_ptr, 0, 0);
return;
}
/* Move player */
Monster.Monster.monster_swap(py, px, y, x);
/* New location */
y = py = Misc.p_ptr.py;
x = px = Misc.p_ptr.px;
/* Searching */
if (Misc.p_ptr.searching != 0 || (Misc.p_ptr.state.skills[(int)Skill.SEARCH_FREQUENCY] >= 50) ||
Random.one_in_(50 - Misc.p_ptr.state.skills[(int)Skill.SEARCH_FREQUENCY]))
{
search(false);
}
/* Handle "store doors" */
if ((Cave.cave.feat[Misc.p_ptr.py][Misc.p_ptr.px] >= Cave.FEAT_SHOP_HEAD) &&
(Cave.cave.feat[Misc.p_ptr.py][Misc.p_ptr.px] <= Cave.FEAT_SHOP_TAIL))
{
/* Disturb */
Cave.disturb(Misc.p_ptr, 0, 0);
Game_Command.insert(Command_Code.ENTER_STORE);
}
/* All other grids (including traps) */
else
{
/* Handle objects (later) */
Misc.p_ptr.notice |= (Misc.PN_PICKUP);
}
/* Discover invisible traps */
if (Cave.cave.feat[y][x] == Cave.FEAT_INVIS)
{
/* Disturb */
Cave.disturb(Misc.p_ptr, 0, 0);
/* Message */
Utilities.msg("You found a trap!");
/* Pick a trap */
Trap.pick_trap(y, x);
/* Hit the trap */
Trap.hit_trap(y, x);
}
/* Set off an visible trap */
else if (Cave.cave_isknowntrap(Cave.cave, y, x))
{
/* Disturb */
Cave.disturb(Misc.p_ptr, 0, 0);
throw new NotImplementedException();
/* Hit the trap */
//hit_trap(y, x);
}
}
Misc.p_ptr.running_firststep = false;
}
static birth_stage point_based_command()
{
birth_stage next = birth_stage.BIRTH_POINTBASED;
/* point_based_display();*/
/* Place cursor just after cost of current stat */
/* Draw the Selection Cursor */
new Region(COSTS_COL + 4, COSTS_ROW, 1, 6).erase();
Utilities.put_str("<", COSTS_ROW + stat, COSTS_COL + 4);
/* Get key */
keypress ch = Utilities.inkey();
if (ch.code == (keycode_t)UIEvent.KTRL('X'))
{
Game_Command.insert(Command_Code.QUIT);
next = birth_stage.BIRTH_COMPLETE;
}
/* Go back a step, or back to the start of this step */
else if (ch.code == keycode_t.ESCAPE)
{
next = birth_stage.BIRTH_BACK;
}
else if (ch.code == (keycode_t)'r' || ch.code == (keycode_t)'R')
{
Game_Command.insert(Command_Code.RESET_STATS);
Game_Command.get_top().set_arg_choice(0, 0);
}
/* Done */
else if ((ch.code == (keycode_t)'\r') || (ch.code == (keycode_t)'\n'))
{
next = birth_stage.BIRTH_NAME_CHOICE;
}
else
{
int dir = Utilities.target_dir(ch);
/* Prev stat, looping round to the bottom when going off the top */
if (dir == 8)
{
stat = (stat + (int)Stat.Max - 1) % (int)Stat.Max;
}
/* Next stat, looping round to the top when going off the bottom */
if (dir == 2)
{
stat = (stat + 1) % (int)Stat.Max;
}
/* Decrease stat (if possible) */
if (dir == 4)
{
Game_Command.insert(Command_Code.SELL_STAT);
Game_Command.get_top().set_arg_choice(0, stat);
}
/* Increase stat (if possible) */
if (dir == 6)
{
Game_Command.insert(Command_Code.BUY_STAT);
Game_Command.get_top().set_arg_choice(0, stat);
}
}
return(next);
}
/* Allow the user to select from the current menu, and return the
* corresponding command to the game. Some actions are handled entirely
* by the UI (displaying help text, for instance). */
static birth_stage menu_question(birth_stage current, Menu_Type current_menu, Command_Code choice_command)
{
birthmenu_data menu_data = current_menu.menu_data as birthmenu_data;
birth_stage next = birth_stage.BIRTH_RESET;
/* Print the question currently being asked. */
clear_question();
Term.putstr(QUESTION_COL, QUESTION_ROW, -1, ConsoleColor.Yellow, menu_data.hint);
current_menu.cmd_keys = "?=*\x18"; /* ?, =, *, <ctl-X> */
while (next == birth_stage.BIRTH_RESET)
{
/* Display the menu, wait for a selection of some sort to be made. */
ui_event cx = current_menu.select(ui_event_type.EVT_KBRD, false);
/* As all the menus are displayed in "hierarchical" style, we allow
* use of "back" (left arrow key or equivalent) to step back in
* the proces as well as "escape". */
if (cx.type == ui_event_type.EVT_ESCAPE)
{
next = birth_stage.BIRTH_BACK;
}
else if (cx.type == ui_event_type.EVT_SELECT)
{
if (current == birth_stage.BIRTH_ROLLER_CHOICE)
{
Game_Command.insert(Command_Code.FINALIZE_OPTIONS);
if (current_menu.cursor != 0)
{
/* Do a first roll of the stats */
Game_Command.insert(Command_Code.ROLL_STATS);
next = current + 2;
}
else
{
/*
* Make sure we've got a point-based char to play with.
* We call point_based_start here to make sure we get
* an update on the points totals before trying to
* display the screen. The call to CMD_RESET_STATS
* forces a rebuying of the stats to give us up-to-date
* totals. This is, it should go without saying, a hack.
*/
point_based_start();
Game_Command.insert(Command_Code.RESET_STATS);
Game_Command.get_top().set_arg_choice(0, 1);
next = current + 1;
}
}
else
{
Game_Command.insert(choice_command);
Game_Command.get_top().set_arg_choice(0, current_menu.cursor);
next = current + 1;
}
}
else if (cx.type == ui_event_type.EVT_KBRD)
{
/* '*' chooses an option at random from those the game's provided. */
if (cx.key.code == (keycode_t)'*' && menu_data.allow_random)
{
current_menu.cursor = Random.randint0(current_menu.count);
Game_Command.insert(choice_command);
Game_Command.get_top().set_arg_choice(0, current_menu.cursor);
current_menu.refresh(false);
next = current + 1;
}
else if (cx.key.code == (keycode_t)'=')
{
Do_Command.options_birth();
next = current;
}
else if (cx.key.code == (keycode_t)UIEvent.KTRL('X'))
{
Game_Command.insert(Command_Code.QUIT);
next = birth_stage.BIRTH_COMPLETE;
}
else if (cx.key.code == (keycode_t)'?')
{
Do_Command.help();
}
}
}
return(next);
}
public static int get_birth_command(bool wait)
{
birth_stage next = current_stage;
switch (current_stage)
{
case birth_stage.BIRTH_RESET:
{
Game_Command.insert(Command_Code.BIRTH_RESET);
roller = birth_stage.BIRTH_RESET;
if (quickstart_allowed)
{
next = birth_stage.BIRTH_QUICKSTART;
}
else
{
next = birth_stage.BIRTH_SEX_CHOICE;
}
break;
}
case birth_stage.BIRTH_QUICKSTART:
{
Files.display_player(0);
next = get_quickstart_command();
break;
}
case birth_stage.BIRTH_SEX_CHOICE:
case birth_stage.BIRTH_CLASS_CHOICE:
case birth_stage.BIRTH_RACE_CHOICE:
case birth_stage.BIRTH_ROLLER_CHOICE:
{
Menu_Type menu = sex_menu;
Command_Code command = Command_Code.CHOOSE_SEX;
Term.clear();
print_menu_instructions();
if (current_stage > birth_stage.BIRTH_SEX_CHOICE)
{
sex_menu.refresh(false);
menu = race_menu;
command = Command_Code.CHOOSE_RACE;
}
if (current_stage > birth_stage.BIRTH_RACE_CHOICE)
{
race_menu.refresh(false);
menu = class_menu;
command = Command_Code.CHOOSE_CLASS;
}
if (current_stage > birth_stage.BIRTH_CLASS_CHOICE)
{
class_menu.refresh(false);
menu = roller_menu;
command = Command_Code.NULL;
}
next = menu_question(current_stage, menu, command);
if (next == birth_stage.BIRTH_BACK)
{
next = current_stage - 1;
}
/* Make sure that the character gets reset before quickstarting */
if (next == birth_stage.BIRTH_QUICKSTART)
{
next = birth_stage.BIRTH_RESET;
}
break;
}
case birth_stage.BIRTH_POINTBASED:
{
roller = birth_stage.BIRTH_POINTBASED;
if (prev > birth_stage.BIRTH_POINTBASED)
{
point_based_start();
}
next = point_based_command();
if (next == birth_stage.BIRTH_BACK)
{
next = birth_stage.BIRTH_ROLLER_CHOICE;
}
if (next != birth_stage.BIRTH_POINTBASED)
{
point_based_stop();
}
break;
}
case birth_stage.BIRTH_ROLLER:
{
roller = birth_stage.BIRTH_ROLLER;
next = roller_command(prev < birth_stage.BIRTH_ROLLER);
if (next == birth_stage.BIRTH_BACK)
{
next = birth_stage.BIRTH_ROLLER_CHOICE;
}
break;
}
case birth_stage.BIRTH_NAME_CHOICE:
{
if (prev < birth_stage.BIRTH_NAME_CHOICE)
{
Files.display_player(0);
}
next = get_name_command();
if (next == birth_stage.BIRTH_BACK)
{
next = roller;
}
break;
}
case birth_stage.BIRTH_FINAL_CONFIRM:
{
if (prev < birth_stage.BIRTH_FINAL_CONFIRM)
{
Files.display_player(0);
}
next = get_confirm_command();
if (next == birth_stage.BIRTH_BACK)
{
next = birth_stage.BIRTH_NAME_CHOICE;
}
break;
}
}
prev = current_stage;
current_stage = next;
return(0);
}