src/wizard/wizard-special-process.c

   1 /*!
   2  * @file wizard2.c
   3  * @brief ウィザードモードの処理(特別処理中心) / Wizard commands
   4  * @date 2014/09/07
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, and others<br>
   7  * This software may be copied and distributed for educational, research,
   8  * and not for profit purposes provided that this copyright and statement
   9  * are included in all such copies.  Other copyrights may also apply.<br>
  10  * 2014 Deskull rearranged comment for Doxygen.<br>
  11  */
  12
  13 #include "wizard/wizard-special-process.h"
  14 #include "birth/inventory-initializer.h"
  15 #include "cmd-io/cmd-dump.h"
  16 #include "cmd-io/cmd-help.h"
  17 #include "cmd-io/cmd-save.h"
  18 #include "cmd/cmd-draw.h"
  19 #include "core/stuff-handler.h"
  20 #include "dungeon/dungeon-file.h"
  21 #include "dungeon/dungeon.h"
  22 #include "dungeon/quest.h"
  23 #include "floor/floor-object.h"
  24 #include "floor/floor-save.h"
  25 #include "floor/floor.h"
  26 #include "grid/grid.h"
  27 #include "inventory/inventory-object.h"
  28 #include "inventory/player-inventory.h"
  29 #include "io/files-util.h"
  30 #include "io/targeting.h"
  31 #include "io/write-diary.h"
  32 #include "market/arena.h"
  33 #include "monster/monster-status.h"
  34 #include "mspell/monster-spell.h"
  35 #include "mutation/mutation.h"
  36 #include "object-enchant/apply-magic.h"
  37 #include "object-enchant/artifact.h"
  38 #include "object-enchant/item-apply-magic.h"
  39 #include "object/item-use-flags.h"
  40 #include "perception/object-perception.h"
  41 #include "object/object-flavor.h"
  42 #include "object/object-generator.h"
  43 #include "object/object-hook.h"
  44 #include "object/object-kind.h"
  45 #include "object/object-value.h"
  46 #include "object-enchant/trc-types.h"
  47 #include "player/patron.h"
  48 #include "player/player-class.h"
  49 #include "player/player-effects.h"
  50 #include "player/player-races-table.h"
  51 #include "player/player-skill.h"
  52 #include "player/player-status.h"
  53 #include "player/selfinfo.h"
  54 #include "spell/spells-detection.h"
  55 #include "spell/spells-floor.h"
  56 #include "spell/spells-object.h"
  57 #include "spell/spells-status.h"
  58 #include "spell/spells-summon.h"
  59 #include "spell/spells-util.h"
  60 #include "spell/spells-world.h"
  61 #include "spell/spells2.h"
  62 #include "spell/spells3.h"
  63 #include "system/angband-version.h"
  64 #include "term/gameterm.h"
  65 #include "util/util.h"
  66 #include "view/display-main-window.h"
  67 #include "wizard/wizard-spoiler.h"
  68 #include "world/world.h"
  69
  70 #define NUM_O_SET 8
  71 #define NUM_O_BIT 32
  72
  73 typedef union spell_functions {
  74         struct debug_spell_type1 { bool(*spell_function)(player_type *, floor_type *); } spell1;
  75         struct debug_spell_type2 { bool(*spell_function)(player_type *); } spell2;
  76         struct debug_spell_type3 { bool(*spell_function)(player_type *, HIT_POINT); } spell3;
  77 } spell_functions;
  78
  79 typedef struct debug_spell_command
  80 {
  81         int type;
  82         char *command_name;
  83         spell_functions command_function;
  84 } debug_spell_command;
  85
  86 #define SPELL_MAX 3
  87 debug_spell_command debug_spell_commands_list[SPELL_MAX] =
  88 {
  89         { 2, "vanish dungeon", {.spell2 = { vanish_dungeon } } },
  90         { 3, "true healing", {.spell3 = { true_healing } } },
  91         { 2, "drop weapons", {.spell2 = { drop_weapons } } }
  92 };
  93
  94 /*!
  95  * @brief コマンド入力により任意にスペル効果を起こす / Wizard spells
  96  * @return 実際にテレポートを行ったらTRUEを返す
  97  */
  98 static bool do_cmd_debug_spell(player_type *creature_ptr)
  99 {
 100         char tmp_val[50] = "\0";
 101         int tmp_int;
 102
 103         if (!get_string("SPELL: ", tmp_val, 32)) return FALSE;
 104
 105         for (int i = 0; i < SPELL_MAX; i++)
 106         {
 107                 if (strcmp(tmp_val, debug_spell_commands_list[i].command_name) != 0)
 108                         continue;
 109                 switch (debug_spell_commands_list[i].type)
 110                 {
 111                 case 2:
 112                         (*(debug_spell_commands_list[i].command_function.spell2.spell_function))(creature_ptr);
 113                         return TRUE;
 114                         break;
 115                 case 3:
 116                         tmp_val[0] = '\0';
 117                         if (!get_string("POWER:", tmp_val, 32)) return FALSE;
 118                         tmp_int = atoi(tmp_val);
 119                         (*(debug_spell_commands_list[i].command_function.spell3.spell_function))(creature_ptr, tmp_int);
 120                         return TRUE;
 121                         break;
 122                 default:
 123                         break;
 124                 }
 125         }
 126
 127         msg_format("Command not found.");
 128
 129         return FALSE;
 130 }
 131
 132
 133 /*!
 134  * @brief 必ず成功するウィザードモード用次元の扉処理 / Wizard Dimension Door
 135  * @param caster_ptr プレーヤーへの参照ポインタ
 136  * @return 実際にテレポートを行ったらTRUEを返す
 137  */
 138 static bool wiz_dimension_door(player_type *caster_ptr)
 139 {
 140         POSITION x = 0, y = 0;
 141         if (!tgt_pt(caster_ptr, &x, &y)) return FALSE;
 142         teleport_player_to(caster_ptr, y, x, TELEPORT_NONMAGICAL);
 143         return TRUE;
 144 }
 145
 146 /*!
 147  * @brief 指定されたIDの固定アーティファクトを生成する / Create the artifact of the specified number
 148  * @param caster_ptr プレーヤーへの参照ポインタ
 149  * @return なし
 150  */
 151 static void wiz_create_named_art(player_type *caster_ptr)
 152 {
 153         char tmp_val[10] = "";
 154         ARTIFACT_IDX a_idx;
 155
 156         /* Query */
 157         if (!get_string("Artifact ID:", tmp_val, 3)) return;
 158
 159         /* Extract */
 160         a_idx = (ARTIFACT_IDX)atoi(tmp_val);
 161         if (a_idx < 0) a_idx = 0;
 162         if (a_idx >= max_a_idx) a_idx = 0;
 163
 164         (void)create_named_art(caster_ptr, a_idx, caster_ptr->y, caster_ptr->x);
 165
 166         /* All done */
 167         msg_print("Allocated.");
 168 }
 169
 170 /*!
 171  * @brief ウィザードモード用モンスターの群れ生成 / Summon a horde of monsters
 172  * @param caster_ptr プレーヤーへの参照ポインタ
 173  * @return なし
 174  */
 175 static void do_cmd_summon_horde(player_type *caster_ptr)
 176 {
 177         POSITION wy = caster_ptr->y, wx = caster_ptr->x;
 178         int attempts = 1000;
 179
 180         while (--attempts)
 181         {
 182                 scatter(caster_ptr, &wy, &wx, caster_ptr->y, caster_ptr->x, 3, 0);
 183                 if (is_cave_empty_bold(caster_ptr, wy, wx)) break;
 184         }
 185
 186         (void)alloc_horde(caster_ptr, wy, wx);
 187 }
 188
 189 /*!
 190  * @brief 32ビット変数のビット配列を並べて描画する / Output a long int in binary format.
 191  * @return なし
 192  */
 193 static void prt_binary(BIT_FLAGS flags, int row, int col)
 194 {
 195         int i;
 196         u32b bitmask;
 197
 198         /* Scan the flags */
 199         for (i = bitmask = 1; i <= 32; i++, bitmask *= 2)
 200         {
 201                 /* Dump set bits */
 202                 if (flags & bitmask)
 203                 {
 204                         Term_putch(col++, row, TERM_BLUE, '*');
 205                 }
 206
 207                 /* Dump unset bits */
 208                 else
 209                 {
 210                         Term_putch(col++, row, TERM_WHITE, '-');
 211                 }
 212         }
 213 }
 214
 215
 216 #define K_MAX_DEPTH 110 /*!< アイテムの階層毎生成率を表示する最大階 */
 217
 218 /*!
 219  * @brief アイテムの階層毎生成率を表示する / Output a rarity graph for a type of object.
 220  * @param tval ベースアイテムの大項目ID
 221  * @param sval ベースアイテムの小項目ID
 222  * @param row 表示列
 223  * @param col 表示行
 224  * @return なし
 225  */
 226 static void prt_alloc(tval_type tval, OBJECT_SUBTYPE_VALUE sval, TERM_LEN row, TERM_LEN col)
 227 {
 228         u32b rarity[K_MAX_DEPTH];
 229         (void)C_WIPE(rarity, K_MAX_DEPTH, u32b);
 230         u32b total[K_MAX_DEPTH];
 231         (void)C_WIPE(total, K_MAX_DEPTH, u32b);
 232         s32b display[22];
 233         (void)C_WIPE(display, 22, s32b);
 234
 235         /* Scan all entries */
 236         int home = 0;
 237         for (int i = 0; i < K_MAX_DEPTH; i++)
 238         {
 239                 int total_frac = 0;
 240                 object_kind *k_ptr;
 241                 alloc_entry *table = alloc_kind_table;
 242                 for (int j = 0; j < alloc_kind_size; j++)
 243                 {
 244                         PERCENTAGE prob = 0;
 245
 246                         if (table[j].level <= i)
 247                         {
 248                                 prob = table[j].prob1 * GREAT_OBJ * K_MAX_DEPTH;
 249                         }
 250                         else if (table[j].level - 1 > 0)
 251                         {
 252                                 prob = table[j].prob1 * i * K_MAX_DEPTH / (table[j].level - 1);
 253                         }
 254
 255                         /* Acquire this kind */
 256                         k_ptr = &k_info[table[j].index];
 257
 258                         /* Accumulate probabilities */
 259                         total[i] += prob / (GREAT_OBJ * K_MAX_DEPTH);
 260                         total_frac += prob % (GREAT_OBJ * K_MAX_DEPTH);
 261
 262                         /* Accumulate probabilities */
 263                         if ((k_ptr->tval == tval) && (k_ptr->sval == sval))
 264                         {
 265                                 home = k_ptr->level;
 266                                 rarity[i] += prob / (GREAT_OBJ * K_MAX_DEPTH);
 267                         }
 268                 }
 269                 total[i] += total_frac / (GREAT_OBJ * K_MAX_DEPTH);
 270         }
 271
 272         /* Calculate probabilities for each range */
 273         for (int i = 0; i < 22; i++)
 274         {
 275                 /* Shift the values into view */
 276                 int possibility = 0;
 277                 for (int j = i * K_MAX_DEPTH / 22; j < (i + 1) * K_MAX_DEPTH / 22; j++)
 278                         possibility += rarity[j] * 100000 / total[j];
 279                 display[i] = possibility / 5;
 280         }
 281
 282         /* Graph the rarities */
 283         for (int i = 0; i < 22; i++)
 284         {
 285                 Term_putch(col, row + i + 1, TERM_WHITE, '|');
 286
 287                 prt(format("%2dF", (i * 5)), row + i + 1, col);
 288
 289
 290                 /* Note the level */
 291                 if ((i * K_MAX_DEPTH / 22 <= home) && (home < (i + 1) * K_MAX_DEPTH / 22))
 292                 {
 293                         c_prt(TERM_RED, format("%3d.%04d%%", display[i] / 1000, display[i] % 1000), row + i + 1, col + 3);
 294                 }
 295                 else
 296                 {
 297                         c_prt(TERM_WHITE, format("%3d.%04d%%", display[i] / 1000, display[i] % 1000), row + i + 1, col + 3);
 298                 }
 299         }
 300
 301         /* Make it look nice */
 302         concptr r = "+---Rate---+";
 303         prt(r, row, col);
 304 }
 305
 306 /*!
 307  * @brief プレイヤーの職業を変更する
 308  * @return なし
 309  * @todo 魔法領域の再選択などがまだ不完全、要実装。
 310  */
 311 static void do_cmd_wiz_reset_class(player_type *creature_ptr)
 312 {
 313         /* Prompt */
 314         char ppp[80];
 315         sprintf(ppp, "Class (0-%d): ", MAX_CLASS - 1);
 316
 317         /* Default */
 318         char tmp_val[160];
 319         sprintf(tmp_val, "%d", creature_ptr->pclass);
 320
 321         /* Query */
 322         if (!get_string(ppp, tmp_val, 2)) return;
 323
 324         /* Extract */
 325         int tmp_int = atoi(tmp_val);
 326
 327         /* Verify */
 328         if (tmp_int < 0 || tmp_int >= MAX_CLASS) return;
 329
 330         /* Save it */
 331         creature_ptr->pclass = (byte)tmp_int;
 332
 333         /* Redraw inscription */
 334         creature_ptr->window |= (PW_PLAYER);
 335
 336         /* {.} and {$} effect creature_ptr->warning and TRC_TELEPORT_SELF */
 337         creature_ptr->update |= (PU_BONUS | PU_HP | PU_MANA | PU_SPELLS);
 338
 339         handle_stuff(creature_ptr);
 340 }
 341
 342
 343 /*!
 344  * @brief ウィザードモード用処理としてターゲット中の相手をテレポートバックする / Hack -- Teleport to the target
 345  * @return なし
 346  */
 347 static void do_cmd_wiz_bamf(player_type *caster_ptr)
 348 {
 349         /* Must have a target */
 350         if (!target_who) return;
 351
 352         /* Teleport to the target */
 353         teleport_player_to(caster_ptr, target_row, target_col, TELEPORT_NONMAGICAL);
 354 }
 355
 356
 357 /*!
 358  * @brief プレイヤーの現能力値を調整する
 359  * Aux function for "do_cmd_wiz_change()".      -RAK-
 360  * @return なし
 361  */
 362 static void do_cmd_wiz_change_aux(player_type *creature_ptr)
 363 {
 364         int tmp_int;
 365         long tmp_long;
 366         s16b tmp_s16b;
 367         char tmp_val[160];
 368         char ppp[80];
 369
 370         /* Query the stats */
 371         for (int i = 0; i < A_MAX; i++)
 372         {
 373                 /* Prompt */
 374                 sprintf(ppp, "%s (3-%d): ", stat_names[i], creature_ptr->stat_max_max[i]);
 375
 376                 /* Default */
 377                 sprintf(tmp_val, "%d", creature_ptr->stat_max[i]);
 378
 379                 /* Query */
 380                 if (!get_string(ppp, tmp_val, 3)) return;
 381
 382                 /* Extract */
 383                 tmp_int = atoi(tmp_val);
 384
 385                 /* Verify */
 386                 if (tmp_int > creature_ptr->stat_max_max[i]) tmp_int = creature_ptr->stat_max_max[i];
 387                 else if (tmp_int < 3) tmp_int = 3;
 388
 389                 /* Save it */
 390                 creature_ptr->stat_cur[i] = creature_ptr->stat_max[i] = (BASE_STATUS)tmp_int;
 391         }
 392
 393
 394         /* Default */
 395         sprintf(tmp_val, "%d", WEAPON_EXP_MASTER);
 396
 397         /* Query */
 398         if (!get_string(_("熟練度: ", "Proficiency: "), tmp_val, 9)) return;
 399
 400         /* Extract */
 401         tmp_s16b = (s16b)atoi(tmp_val);
 402
 403         /* Verify */
 404         if (tmp_s16b < WEAPON_EXP_UNSKILLED) tmp_s16b = WEAPON_EXP_UNSKILLED;
 405         if (tmp_s16b > WEAPON_EXP_MASTER) tmp_s16b = WEAPON_EXP_MASTER;
 406
 407         for (int j = 0; j <= TV_WEAPON_END - TV_WEAPON_BEGIN; j++)
 408         {
 409                 for (int i = 0; i < 64; i++)
 410                 {
 411                         creature_ptr->weapon_exp[j][i] = tmp_s16b;
 412                         if (creature_ptr->weapon_exp[j][i] > s_info[creature_ptr->pclass].w_max[j][i]) creature_ptr->weapon_exp[j][i] = s_info[creature_ptr->pclass].w_max[j][i];
 413                 }
 414         }
 415
 416         for (int j = 0; j < 10; j++)
 417         {
 418                 creature_ptr->skill_exp[j] = tmp_s16b;
 419                 if (creature_ptr->skill_exp[j] > s_info[creature_ptr->pclass].s_max[j]) creature_ptr->skill_exp[j] = s_info[creature_ptr->pclass].s_max[j];
 420         }
 421
 422         int k;
 423         for (k = 0; k < 32; k++)
 424                 creature_ptr->spell_exp[k] = (tmp_s16b > SPELL_EXP_MASTER ? SPELL_EXP_MASTER : tmp_s16b);
 425         for (; k < 64; k++)
 426                 creature_ptr->spell_exp[k] = (tmp_s16b > SPELL_EXP_EXPERT ? SPELL_EXP_EXPERT : tmp_s16b);
 427
 428         /* Default */
 429         sprintf(tmp_val, "%ld", (long)(creature_ptr->au));
 430
 431         /* Query */
 432         if (!get_string("Gold: ", tmp_val, 9)) return;
 433
 434         /* Extract */
 435         tmp_long = atol(tmp_val);
 436
 437         /* Verify */
 438         if (tmp_long < 0) tmp_long = 0L;
 439
 440         /* Save */
 441         creature_ptr->au = tmp_long;
 442
 443         /* Default */
 444         sprintf(tmp_val, "%ld", (long)(creature_ptr->max_exp));
 445
 446         /* Query */
 447         if (!get_string("Experience: ", tmp_val, 9)) return;
 448
 449         /* Extract */
 450         tmp_long = atol(tmp_val);
 451
 452         /* Verify */
 453         if (tmp_long < 0) tmp_long = 0L;
 454
 455         if (creature_ptr->prace == RACE_ANDROID) return;
 456
 457         /* Save */
 458         creature_ptr->max_exp = tmp_long;
 459         creature_ptr->exp = tmp_long;
 460
 461         /* Update */
 462         check_experience(creature_ptr);
 463 }
 464
 465
 466 /*!
 467  * @brief プレイヤーの現能力値を調整する(メインルーチン)
 468  * Change various "permanent" player variables.
 469  * @return なし
 470  */
 471 static void do_cmd_wiz_change(player_type *creature_ptr)
 472 {
 473         /* Interact */
 474         do_cmd_wiz_change_aux(creature_ptr);
 475         do_cmd_redraw(creature_ptr);
 476 }
 477
 478
 479 /*!
 480  * @brief アイテムの詳細ステータスを表示する /
 481  * Change various "permanent" player variables.
 482  * @param player_ptr プレーヤーへの参照ポインタ
 483  * @param o_ptr 詳細を表示するアイテム情報の参照ポインタ
 484  * @return なし
 485  * @details
 486  * Wizard routines for creating objects         -RAK-
 487  * And for manipulating them!                   -Bernd-
 488  *
 489  * This has been rewritten to make the whole procedure
 490  * of debugging objects much easier and more comfortable.
 491  *
 492  * The following functions are meant to play with objects:
 493  * Create, modify, roll for them (for statistic purposes) and more.
 494  * The original functions were by RAK.
 495  * The function to show an item's debug information was written
 496  * by David Reeve Sward <sward+@CMU.EDU>.
 497  *                             Bernd (wiebelt@mathematik.hu-berlin.de)
 498  *
 499  * Here are the low-level functions
 500  * - wiz_display_item()
 501  *     display an item's debug-info
 502  * - wiz_create_itemtype()
 503  *     specify tval and sval (type and subtype of object)
 504  * - wiz_tweak_item()
 505  *     specify pval, +AC, +tohit, +todam
 506  *     Note that the wizard can leave this function anytime,
 507  *     thus accepting the default-values for the remaining values.
 508  *     pval comes first now, since it is most important.
 509  * - wiz_reroll_item()
 510  *     apply some magic to the item or turn it into an artifact.
 511  * - wiz_roll_item()
 512  *     Get some statistics about the rarity of an item:
 513  *     We create a lot of fake items and see if they are of the
 514  *     same type (tval and sval), then we compare pval and +AC.
 515  *     If the fake-item is better or equal it is counted.
 516  *     Note that cursed items that are better or equal (absolute values)
 517  *     are counted, too.
 518  *     HINT: This is *very* useful for balancing the game!
 519  * - wiz_quantity_item()
 520  *     change the quantity of an item, but be sane about it.
 521  *
 522  * And now the high-level functions
 523  * - do_cmd_wiz_play()
 524  *     play with an existing object
 525  * - wiz_create_item()
 526  *     create a new object
 527  *
 528  * Note -- You do not have to specify "pval" and other item-properties
 529  * directly. Just apply magic until you are satisfied with the item.
 530  *
 531  * Note -- For some items (such as wands, staffs, some rings, etc), you
 532  * must apply magic, or you will get "broken" or "uncharged" objects.
 533  *
 534  * Note -- Redefining artifacts via "do_cmd_wiz_play()" may destroy
 535  * the artifact.  Be careful.
 536  *
 537  * Hack -- this function will allow you to create multiple artifacts.
 538  * This "feature" may induce crashes or other nasty effects.
 539  * Just display an item's properties (debug-info)
 540  * Originally by David Reeve Sward <sward+@CMU.EDU>
 541  * Verbose item flags by -Bernd-
 542  */
 543 static void wiz_display_item(player_type *player_ptr, object_type *o_ptr)
 544 {
 545         BIT_FLAGS flgs[TR_FLAG_SIZE];
 546         object_flags(o_ptr, flgs);
 547
 548         /* Clear the screen */
 549         int j = 13;
 550         for (int i = 1; i <= 23; i++) prt("", i, j - 2);
 551
 552         prt_alloc(o_ptr->tval, o_ptr->sval, 1, 0);
 553
 554         /* Describe fully */
 555         char buf[256];
 556         object_desc(player_ptr, buf, o_ptr, OD_STORE);
 557
 558         prt(buf, 2, j);
 559
 560         prt(format("kind = %-5d  level = %-4d  tval = %-5d  sval = %-5d",
 561                 o_ptr->k_idx, k_info[o_ptr->k_idx].level,
 562                 o_ptr->tval, o_ptr->sval), 4, j);
 563
 564         prt(format("number = %-3d  wgt = %-6d  ac = %-5d    damage = %dd%d",
 565                 o_ptr->number, o_ptr->weight,
 566                 o_ptr->ac, o_ptr->dd, o_ptr->ds), 5, j);
 567
 568         prt(format("pval = %-5d  toac = %-5d  tohit = %-4d  todam = %-4d",
 569                 o_ptr->pval, o_ptr->to_a, o_ptr->to_h, o_ptr->to_d), 6, j);
 570
 571         prt(format("name1 = %-4d  name2 = %-4d  cost = %ld",
 572                 o_ptr->name1, o_ptr->name2, (long)object_value_real(o_ptr)), 7, j);
 573
 574         prt(format("ident = %04x  xtra1 = %-4d  xtra2 = %-4d  timeout = %-d",
 575                 o_ptr->ident, o_ptr->xtra1, o_ptr->xtra2, o_ptr->timeout), 8, j);
 576
 577         prt(format("xtra3 = %-4d  xtra4 = %-4d  xtra5 = %-4d  cursed  = %-d",
 578                 o_ptr->xtra3, o_ptr->xtra4, o_ptr->xtra5, o_ptr->curse_flags), 9, j);
 579
 580         prt("+------------FLAGS1------------+", 10, j);
 581         prt("AFFECT........SLAY........BRAND.", 11, j);
 582         prt("      mf      cvae      xsqpaefc", 12, j);
 583         prt("siwdccsossidsahanvudotgddhuoclio", 13, j);
 584         prt("tnieohtctrnipttmiinmrrnrrraiierl", 14, j);
 585         prt("rtsxnarelcfgdkcpmldncltggpksdced", 15, j);
 586         prt_binary(flgs[0], 16, j);
 587
 588         prt("+------------FLAGS2------------+", 17, j);
 589         prt("SUST....IMMUN.RESIST............", 18, j);
 590         prt("      reaefctrpsaefcpfldbc sn   ", 19, j);
 591         prt("siwdcciaclioheatcliooeialoshtncd", 20, j);
 592         prt("tnieohdsierlrfraierliatrnnnrhehi", 21, j);
 593         prt("rtsxnaeydcedwlatdcedsrekdfddrxss", 22, j);
 594         prt_binary(flgs[1], 23, j);
 595
 596         prt("+------------FLAGS3------------+", 10, j + 32);
 597         prt("fe cnn t      stdrmsiiii d ab   ", 11, j + 32);
 598         prt("aa aoomywhs lleeieihgggg rtgl   ", 12, j + 32);
 599         prt("uu utmacaih eielgggonnnnaaere   ", 13, j + 32);
 600         prt("rr reanurdo vtieeehtrrrrcilas   ", 14, j + 32);
 601         prt("aa algarnew ienpsntsaefctnevs   ", 15, j + 32);
 602         prt_binary(flgs[2], 16, j + 32);
 603
 604         prt("+------------FLAGS4------------+", 17, j + 32);
 605         prt("KILL....ESP.........            ", 18, j + 32);
 606         prt("aeud tghaud tgdhegnu            ", 19, j + 32);
 607         prt("nvneoriunneoriruvoon            ", 20, j + 32);
 608         prt("iidmroamidmroagmionq            ", 21, j + 32);
 609         prt("mlenclnmmenclnnnldlu            ", 22, j + 32);
 610         prt_binary(flgs[3], 23, j + 32);
 611 }
 612
 613
 614 /*!
 615  * ベースアイテムの大項目IDの種別名をまとめる構造体 / A structure to hold a tval and its description
 616  */
 617 typedef struct tval_desc
 618 {
 619         int        tval; /*!< 大項目のID */
 620         concptr       desc; /*!< 大項目名 */
 621 } tval_desc;
 622
 623 /*!
 624  * ベースアイテムの大項目IDの種別名定義 / A list of tvals and their textual names
 625  */
 626 static tval_desc tvals[] =
 627 {
 628         { TV_SWORD,             "Sword"                },
 629         { TV_POLEARM,           "Polearm"              },
 630         { TV_HAFTED,            "Hafted Weapon"        },
 631         { TV_BOW,               "Bow"                  },
 632         { TV_ARROW,             "Arrows"               },
 633         { TV_BOLT,              "Bolts"                },
 634         { TV_SHOT,              "Shots"                },
 635         { TV_SHIELD,            "Shield"               },
 636         { TV_CROWN,             "Crown"                },
 637         { TV_HELM,              "Helm"                 },
 638         { TV_GLOVES,            "Gloves"               },
 639         { TV_BOOTS,             "Boots"                },
 640         { TV_CLOAK,             "Cloak"                },
 641         { TV_DRAG_ARMOR,        "Dragon Scale Mail"    },
 642         { TV_HARD_ARMOR,        "Hard Armor"           },
 643         { TV_SOFT_ARMOR,        "Soft Armor"           },
 644         { TV_RING,              "Ring"                 },
 645         { TV_AMULET,            "Amulet"               },
 646         { TV_LITE,              "Lite"                 },
 647         { TV_POTION,            "Potion"               },
 648         { TV_SCROLL,            "Scroll"               },
 649         { TV_WAND,              "Wand"                 },
 650         { TV_STAFF,             "Staff"                },
 651         { TV_ROD,               "Rod"                  },
 652         { TV_LIFE_BOOK,         "Life Spellbook"       },
 653         { TV_SORCERY_BOOK,      "Sorcery Spellbook"    },
 654         { TV_NATURE_BOOK,       "Nature Spellbook"     },
 655         { TV_CHAOS_BOOK,        "Chaos Spellbook"      },
 656         { TV_DEATH_BOOK,        "Death Spellbook"      },
 657         { TV_TRUMP_BOOK,        "Trump Spellbook"      },
 658         { TV_ARCANE_BOOK,       "Arcane Spellbook"     },
 659         { TV_CRAFT_BOOK,      "Craft Spellbook"},
 660         { TV_DAEMON_BOOK,       "Daemon Spellbook"},
 661         { TV_CRUSADE_BOOK,      "Crusade Spellbook"},
 662         { TV_MUSIC_BOOK,        "Music Spellbook"      },
 663         { TV_HISSATSU_BOOK,     "Book of Kendo" },
 664         { TV_HEX_BOOK,          "Hex Spellbook"        },
 665         { TV_PARCHMENT,         "Parchment" },
 666         { TV_WHISTLE,           "Whistle"       },
 667         { TV_SPIKE,             "Spikes"               },
 668         { TV_DIGGING,           "Digger"               },
 669         { TV_CHEST,             "Chest"                },
 670         { TV_CAPTURE,           "Capture Ball"         },
 671         { TV_CARD,              "Express Card"         },
 672         { TV_FIGURINE,          "Magical Figurine"     },
 673         { TV_STATUE,            "Statue"               },
 674         { TV_CORPSE,            "Corpse"               },
 675         { TV_FOOD,              "Food"                 },
 676         { TV_FLASK,             "Flask"                },
 677         { TV_JUNK,              "Junk"                 },
 678         { TV_SKELETON,          "Skeleton"             },
 679         { 0,                    NULL                   }
 680 };
 681
 682
 683 /*!
 684  * 選択処理用キーコード /
 685  * Global array for converting numbers to a logical list symbol
 686  */
 687 static const char listsym[] =
 688 {
 689         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 690         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
 691         'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
 692         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
 693         'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 694         '\0'
 695 };
 696
 697 /*!
 698  * @brief ベースアイテムのウィザード生成のために大項目IDと小項目IDを取得する /
 699  * Specify tval and sval (type and subtype of object) originally
 700  * @return ベースアイテムID
 701  * @details
 702  * by RAK, heavily modified by -Bernd-
 703  * This function returns the k_idx of an object type, or zero if failed
 704  * List up to 50 choices in three columns
 705  */
 706 static KIND_OBJECT_IDX wiz_create_itemtype(void)
 707 {
 708         KIND_OBJECT_IDX i;
 709         int num, max_num;
 710         TERM_LEN col, row;
 711         tval_type tval;
 712
 713         concptr tval_desc;
 714         char ch;
 715
 716         KIND_OBJECT_IDX choice[80];
 717
 718         char buf[160];
 719
 720         Term_clear();
 721
 722         /* Print all tval's and their descriptions */
 723         for (num = 0; (num < 80) && tvals[num].tval; num++)
 724         {
 725                 row = 2 + (num % 20);
 726                 col = 20 * (num / 20);
 727                 ch = listsym[num];
 728                 prt(format("[%c] %s", ch, tvals[num].desc), row, col);
 729         }
 730
 731         /* Me need to know the maximal possible tval_index */
 732         max_num = num;
 733
 734         /* Choose! */
 735         if (!get_com("Get what type of object? ", &ch, FALSE)) return 0;
 736
 737         /* Analyze choice */
 738         for (num = 0; num < max_num; num++)
 739         {
 740                 if (listsym[num] == ch) break;
 741         }
 742
 743         /* Bail out if choice is illegal */
 744         if ((num < 0) || (num >= max_num)) return 0;
 745
 746         /* Base object type chosen, fill in tval */
 747         tval = tvals[num].tval;
 748         tval_desc = tvals[num].desc;
 749
 750         /*** And now we go for k_idx ***/
 751         Term_clear();
 752
 753         /* We have to search the whole itemlist. */
 754         for (num = 0, i = 1; (num < 80) && (i < max_k_idx); i++)
 755         {
 756                 object_kind *k_ptr = &k_info[i];
 757
 758                 /* Analyze matching items */
 759                 if (k_ptr->tval != tval) continue;
 760
 761                 /* Prepare it */
 762                 row = 2 + (num % 20);
 763                 col = 20 * (num / 20);
 764                 ch = listsym[num];
 765                 strcpy(buf, "                    ");
 766
 767                 /* Acquire the "name" of object "i" */
 768                 strip_name(buf, i);
 769
 770                 /* Print it */
 771                 prt(format("[%c] %s", ch, buf), row, col);
 772
 773                 /* Remember the object index */
 774                 choice[num++] = i;
 775         }
 776
 777         /* Me need to know the maximal possible remembered object_index */
 778         max_num = num;
 779
 780         /* Choose! */
 781         if (!get_com(format("What Kind of %s? ", tval_desc), &ch, FALSE)) return 0;
 782
 783         /* Analyze choice */
 784         for (num = 0; num < max_num; num++)
 785         {
 786                 if (listsym[num] == ch) break;
 787         }
 788
 789         /* Bail out if choice is "illegal" */
 790         if ((num < 0) || (num >= max_num)) return 0;
 791
 792         /* And return successful */
 793         return (choice[num]);
 794 }
 795
 796
 797 /*!
 798  * @briefアイテムの基礎能力値を調整する / Tweak an item
 799  * @param player_ptr プレーヤーへの参照ポインタ
 800  * @param o_ptr 調整するアイテムの参照ポインタ
 801  * @return なし
 802  */
 803 static void wiz_tweak_item(player_type *player_ptr, object_type *o_ptr)
 804 {
 805         if (object_is_artifact(o_ptr)) return;
 806
 807         concptr p = "Enter new 'pval' setting: ";
 808         char tmp_val[80];
 809         sprintf(tmp_val, "%d", o_ptr->pval);
 810         if (!get_string(p, tmp_val, 5)) return;
 811         o_ptr->pval = (s16b)atoi(tmp_val);
 812         wiz_display_item(player_ptr, o_ptr);
 813
 814         p = "Enter new 'to_a' setting: ";
 815         sprintf(tmp_val, "%d", o_ptr->to_a);
 816         if (!get_string(p, tmp_val, 5)) return;
 817         o_ptr->to_a = (s16b)atoi(tmp_val);
 818         wiz_display_item(player_ptr, o_ptr);
 819
 820         p = "Enter new 'to_h' setting: ";
 821         sprintf(tmp_val, "%d", o_ptr->to_h);
 822         if (!get_string(p, tmp_val, 5)) return;
 823         o_ptr->to_h = (s16b)atoi(tmp_val);
 824         wiz_display_item(player_ptr, o_ptr);
 825
 826         p = "Enter new 'to_d' setting: ";
 827         sprintf(tmp_val, "%d", (int)o_ptr->to_d);
 828         if (!get_string(p, tmp_val, 5)) return;
 829         o_ptr->to_d = (s16b)atoi(tmp_val);
 830         wiz_display_item(player_ptr, o_ptr);
 831 }
 832
 833
 834 /*!
 835  * @brief アイテムの質を選択して再生成する /
 836  * Apply magic to an item or turn it into an artifact. -Bernd-
 837  * @param o_ptr 再生成の対象となるアイテム情報の参照ポインタ
 838  * @return なし
 839  */
 840 static void wiz_reroll_item(player_type *owner_ptr, object_type *o_ptr)
 841 {
 842         if (object_is_artifact(o_ptr)) return;
 843
 844         object_type forge;
 845         object_type *q_ptr;
 846         q_ptr = &forge;
 847         object_copy(q_ptr, o_ptr);
 848
 849         /* Main loop. Ask for magification and artifactification */
 850         char ch;
 851         bool changed = FALSE;
 852         while (TRUE)
 853         {
 854                 /* Display full item debug information */
 855                 wiz_display_item(owner_ptr, q_ptr);
 856
 857                 /* Ask wizard what to do. */
 858                 if (!get_com("[a]ccept, [w]orthless, [c]ursed, [n]ormal, [g]ood, [e]xcellent, [s]pecial? ", &ch, FALSE))
 859                 {
 860                         /* Preserve wizard-generated artifacts */
 861                         if (object_is_fixed_artifact(q_ptr))
 862                         {
 863                                 a_info[q_ptr->name1].cur_num = 0;
 864                                 q_ptr->name1 = 0;
 865                         }
 866
 867                         changed = FALSE;
 868                         break;
 869                 }
 870
 871                 /* Create/change it! */
 872                 if (ch == 'A' || ch == 'a')
 873                 {
 874                         changed = TRUE;
 875                         break;
 876                 }
 877
 878                 /* Preserve wizard-generated artifacts */
 879                 if (object_is_fixed_artifact(q_ptr))
 880                 {
 881                         a_info[q_ptr->name1].cur_num = 0;
 882                         q_ptr->name1 = 0;
 883                 }
 884
 885                 switch (ch)
 886                 {
 887                         /* Apply bad magic, but first clear object */
 888                 case 'w': case 'W':
 889                 {
 890                         object_prep(q_ptr, o_ptr->k_idx);
 891                         apply_magic(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD | AM_GREAT | AM_CURSED);
 892                         break;
 893                 }
 894                 /* Apply bad magic, but first clear object */
 895                 case 'c': case 'C':
 896                 {
 897                         object_prep(q_ptr, o_ptr->k_idx);
 898                         apply_magic(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD | AM_CURSED);
 899                         break;
 900                 }
 901                 /* Apply normal magic, but first clear object */
 902                 case 'n': case 'N':
 903                 {
 904                         object_prep(q_ptr, o_ptr->k_idx);
 905                         apply_magic(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART);
 906                         break;
 907                 }
 908                 /* Apply good magic, but first clear object */
 909                 case 'g': case 'G':
 910                 {
 911                         object_prep(q_ptr, o_ptr->k_idx);
 912                         apply_magic(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD);
 913                         break;
 914                 }
 915                 /* Apply great magic, but first clear object */
 916                 case 'e': case 'E':
 917                 {
 918                         object_prep(q_ptr, o_ptr->k_idx);
 919                         apply_magic(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART | AM_GOOD | AM_GREAT);
 920                         break;
 921                 }
 922                 /* Apply special magic, but first clear object */
 923                 case 's': case 'S':
 924                 {
 925                         object_prep(q_ptr, o_ptr->k_idx);
 926                         apply_magic(owner_ptr, q_ptr, owner_ptr->current_floor_ptr->dun_level, AM_GOOD | AM_GREAT | AM_SPECIAL);
 927
 928                         /* Failed to create artifact; make a random one */
 929                         if (!object_is_artifact(q_ptr)) become_random_artifact(owner_ptr, q_ptr, FALSE);
 930                         break;
 931                 }
 932                 }
 933
 934                 q_ptr->iy = o_ptr->iy;
 935                 q_ptr->ix = o_ptr->ix;
 936                 q_ptr->next_o_idx = o_ptr->next_o_idx;
 937                 q_ptr->marked = o_ptr->marked;
 938         }
 939
 940         /* Notice change */
 941         if (changed)
 942         {
 943                 object_copy(o_ptr, q_ptr);
 944                 owner_ptr->update |= (PU_BONUS);
 945                 owner_ptr->update |= (PU_COMBINE | PU_REORDER);
 946                 owner_ptr->window |= (PW_INVEN | PW_EQUIP | PW_SPELL | PW_PLAYER);
 947         }
 948 }
 949
 950
 951 /*!
 952  * @brief 検査対象のアイテムを基準とした生成テストを行う /
 953  * Try to create an item again. Output some statistics.    -Bernd-
 954  * @param caster_ptr プレーヤーへの参照ポインタ
 955  * @param o_ptr 生成テストの基準となるアイテム情報の参照ポインタ
 956  * @return なし
 957  * The statistics are correct now.  We acquire a clean grid, and then
 958  * repeatedly place an object in this grid, copying it into an item
 959  * holder, and then deleting the object.  We fiddle with the artifact
 960  * counter flags to prevent weirdness.  We use the items to collect
 961  * statistics on item creation relative to the initial item.
 962  */
 963 static void wiz_statistics(player_type *caster_ptr, object_type *o_ptr)
 964 {
 965         object_type forge;
 966         object_type     *q_ptr;
 967
 968         concptr q = "Rolls: %ld  Correct: %ld  Matches: %ld  Better: %ld  Worse: %ld  Other: %ld";
 969         concptr p = "Enter number of items to roll: ";
 970         char tmp_val[80];
 971
 972         /* Mega-Hack -- allow multiple artifacts */
 973         if (object_is_fixed_artifact(o_ptr)) a_info[o_ptr->name1].cur_num = 0;
 974
 975         /* Interact */
 976         u32b i, matches, better, worse, other, correct;
 977         u32b test_roll = 1000000;
 978         char ch;
 979         concptr quality;
 980         BIT_FLAGS mode;
 981         while (TRUE)
 982         {
 983                 concptr pmt = "Roll for [n]ormal, [g]ood, or [e]xcellent treasure? ";
 984
 985                 /* Display item */
 986                 wiz_display_item(caster_ptr, o_ptr);
 987
 988                 /* Get choices */
 989                 if (!get_com(pmt, &ch, FALSE)) break;
 990
 991                 if (ch == 'n' || ch == 'N')
 992                 {
 993                         mode = 0L;
 994                         quality = "normal";
 995                 }
 996                 else if (ch == 'g' || ch == 'G')
 997                 {
 998                         mode = AM_GOOD;
 999                         quality = "good";
1000                 }
1001                 else if (ch == 'e' || ch == 'E')
1002                 {
1003                         mode = AM_GOOD | AM_GREAT;
1004                         quality = "excellent";
1005                 }
1006                 else
1007                 {
1008                         break;
1009                 }
1010
1011                 sprintf(tmp_val, "%ld", (long int)test_roll);
1012                 if (get_string(p, tmp_val, 10)) test_roll = atol(tmp_val);
1013                 test_roll = MAX(1, test_roll);
1014
1015                 /* Let us know what we are doing */
1016                 msg_format("Creating a lot of %s items. Base level = %d.",
1017                         quality, caster_ptr->current_floor_ptr->dun_level);
1018                 msg_print(NULL);
1019
1020                 /* Set counters to zero */
1021                 correct = matches = better = worse = other = 0;
1022
1023                 /* Let's rock and roll */
1024                 for (i = 0; i <= test_roll; i++)
1025                 {
1026                         /* Output every few rolls */
1027                         if ((i < 100) || (i % 100 == 0))
1028                         {
1029                                 /* Do not wait */
1030                                 inkey_scan = TRUE;
1031
1032                                 /* Allow interupt */
1033                                 if (inkey())
1034                                 {
1035                                         flush();
1036                                         break; // stop rolling
1037                                 }
1038
1039                                 /* Dump the stats */
1040                                 prt(format(q, i, correct, matches, better, worse, other), 0, 0);
1041                                 Term_fresh();
1042                         }
1043                         q_ptr = &forge;
1044                         object_wipe(q_ptr);
1045
1046                         /* Create an object */
1047                         make_object(caster_ptr, q_ptr, mode);
1048
1049
1050                         /* Mega-Hack -- allow multiple artifacts */
1051                         if (object_is_fixed_artifact(q_ptr)) a_info[q_ptr->name1].cur_num = 0;
1052
1053
1054                         /* Test for the same tval and sval. */
1055                         if ((o_ptr->tval) != (q_ptr->tval)) continue;
1056                         if ((o_ptr->sval) != (q_ptr->sval)) continue;
1057
1058                         /* One more correct item */
1059                         correct++;
1060
1061                         /* Check for match */
1062                         if ((q_ptr->pval == o_ptr->pval) &&
1063                                 (q_ptr->to_a == o_ptr->to_a) &&
1064                                 (q_ptr->to_h == o_ptr->to_h) &&
1065                                 (q_ptr->to_d == o_ptr->to_d) &&
1066                                 (q_ptr->name1 == o_ptr->name1))
1067                         {
1068                                 matches++;
1069                         }
1070
1071                         /* Check for better */
1072                         else if ((q_ptr->pval >= o_ptr->pval) &&
1073                                 (q_ptr->to_a >= o_ptr->to_a) &&
1074                                 (q_ptr->to_h >= o_ptr->to_h) &&
1075                                 (q_ptr->to_d >= o_ptr->to_d))
1076                         {
1077                                 better++;
1078                         }
1079
1080                         /* Check for worse */
1081                         else if ((q_ptr->pval <= o_ptr->pval) &&
1082                                 (q_ptr->to_a <= o_ptr->to_a) &&
1083                                 (q_ptr->to_h <= o_ptr->to_h) &&
1084                                 (q_ptr->to_d <= o_ptr->to_d))
1085                         {
1086                                 worse++;
1087                         }
1088
1089                         /* Assume different */
1090                         else
1091                         {
1092                                 other++;
1093                         }
1094                 }
1095
1096                 /* Final dump */
1097                 msg_format(q, i, correct, matches, better, worse, other);
1098                 msg_print(NULL);
1099         }
1100
1101         /* Hack -- Normally only make a single artifact */
1102         if (object_is_fixed_artifact(o_ptr)) a_info[o_ptr->name1].cur_num = 1;
1103 }
1104
1105
1106 /*!
1107  * @brief 検査対象のアイテムの数を変更する /
1108  * Change the quantity of a the item
1109  * @param caster_ptr プレーヤーへの参照ポインタ
1110  * @param o_ptr 変更するアイテム情報構造体の参照ポインタ
1111  * @return なし
1112  */
1113 static void wiz_quantity_item(object_type *o_ptr)
1114 {
1115         /* Never duplicate artifacts */
1116         if (object_is_artifact(o_ptr)) return;
1117
1118         /* Store old quantity. -LM- */
1119         int tmp_qnt = o_ptr->number;
1120
1121         /* Default */
1122         char tmp_val[100];
1123         sprintf(tmp_val, "%d", (int)o_ptr->number);
1124
1125         /* Query */
1126         if (get_string("Quantity: ", tmp_val, 2))
1127         {
1128                 /* Extract */
1129                 int tmp_int = atoi(tmp_val);
1130                 if (tmp_int < 1) tmp_int = 1;
1131                 if (tmp_int > 99) tmp_int = 99;
1132
1133                 /* Accept modifications */
1134                 o_ptr->number = (byte)tmp_int;
1135         }
1136
1137         if (o_ptr->tval == TV_ROD)
1138         {
1139                 o_ptr->pval = o_ptr->pval * o_ptr->number / tmp_qnt;
1140         }
1141 }
1142
1143
1144 /*!
1145  * @brief 青魔導師の魔法を全て習得済みにする /
1146  * debug command for blue mage
1147  * @return なし
1148  */
1149 static void do_cmd_wiz_blue_mage(player_type *caster_ptr)
1150 {
1151         BIT_FLAGS f4 = 0L, f5 = 0L, f6 = 0L;
1152         for (int j = 1; j < A_MAX; j++)
1153         {
1154                 set_rf_masks(&f4, &f5, &f6, j);
1155
1156                 int i;
1157                 for (i = 0; i < 32; i++)
1158                 {
1159                         if ((0x00000001 << i) & f4) caster_ptr->magic_num2[i] = 1;
1160                 }
1161
1162                 for (; i < 64; i++)
1163                 {
1164                         if ((0x00000001 << (i - 32)) & f5) caster_ptr->magic_num2[i] = 1;
1165                 }
1166
1167                 for (; i < 96; i++)
1168                 {
1169                         if ((0x00000001 << (i - 64)) & f6) caster_ptr->magic_num2[i] = 1;
1170                 }
1171         }
1172 }
1173
1174
1175 /*!
1176  * @brief アイテム検査のメインルーチン /
1177  * Play with an item. Options include:
1178  * @return なし
1179  * @details
1180  *   - Output statistics (via wiz_roll_item)<br>
1181  *   - Reroll item (via wiz_reroll_item)<br>
1182  *   - Change properties (via wiz_tweak_item)<br>
1183  *   - Change the number of items (via wiz_quantity_item)<br>
1184  */
1185 static void do_cmd_wiz_play(player_type *creature_ptr)
1186 {
1187         concptr q = "Play with which object? ";
1188         concptr s = "You have nothing to play with.";
1189
1190         OBJECT_IDX item;
1191         object_type *o_ptr;
1192         o_ptr = choose_object(creature_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), 0);
1193
1194         if (!o_ptr) return;
1195
1196         screen_save(creature_ptr);
1197
1198         object_type     forge;
1199         object_type *q_ptr;
1200         q_ptr = &forge;
1201         object_copy(q_ptr, o_ptr);
1202
1203         /* The main loop */
1204         char ch;
1205         bool changed = FALSE;
1206         while (TRUE)
1207         {
1208                 /* Display the item */
1209                 wiz_display_item(creature_ptr, q_ptr);
1210
1211                 /* Get choice */
1212                 if (!get_com("[a]ccept [s]tatistics [r]eroll [t]weak [q]uantity? ", &ch, FALSE))
1213                 {
1214                         changed = FALSE;
1215                         break;
1216                 }
1217
1218                 if (ch == 'A' || ch == 'a')
1219                 {
1220                         changed = TRUE;
1221                         break;
1222                 }
1223
1224                 if (ch == 's' || ch == 'S')
1225                 {
1226                         wiz_statistics(creature_ptr, q_ptr);
1227                 }
1228
1229                 if (ch == 'r' || ch == 'r')
1230                 {
1231                         wiz_reroll_item(creature_ptr, q_ptr);
1232                 }
1233
1234                 if (ch == 't' || ch == 'T')
1235                 {
1236                         wiz_tweak_item(creature_ptr, q_ptr);
1237                 }
1238
1239                 if (ch == 'q' || ch == 'Q')
1240                 {
1241                         wiz_quantity_item(q_ptr);
1242                 }
1243         }
1244
1245         screen_load(creature_ptr);
1246
1247         /* Accept change */
1248         if (changed)
1249         {
1250                 msg_print("Changes accepted.");
1251
1252                 /* Recalcurate object's weight */
1253                 if (item >= 0)
1254                 {
1255                         creature_ptr->total_weight += (q_ptr->weight * q_ptr->number)
1256                                 - (o_ptr->weight * o_ptr->number);
1257                 }
1258
1259                 /* Change */
1260                 object_copy(o_ptr, q_ptr);
1261
1262                 creature_ptr->update |= (PU_BONUS);
1263                 creature_ptr->update |= (PU_COMBINE | PU_REORDER);
1264
1265                 creature_ptr->window |= (PW_INVEN | PW_EQUIP | PW_SPELL | PW_PLAYER);
1266         }
1267
1268         /* Ignore change */
1269         else
1270         {
1271                 msg_print("Changes ignored.");
1272         }
1273 }
1274
1275
1276 /*!
1277  * @brief 任意のベースアイテム生成のメインルーチン /
1278  * Wizard routine for creating objects          -RAK-
1279  * @return なし
1280  * @details
1281  * Heavily modified to allow magification and artifactification  -Bernd-
1282  *
1283  * Note that wizards cannot create objects on top of other objects.
1284  *
1285  * Hack -- this routine always makes a "dungeon object", and applies
1286  * magic to it, and attempts to decline cursed items.
1287  */
1288 static void wiz_create_item(player_type *caster_ptr)
1289 {
1290         screen_save(caster_ptr);
1291
1292         /* Get object base type */
1293         OBJECT_IDX k_idx = wiz_create_itemtype();
1294
1295         screen_load(caster_ptr);
1296
1297         /* Return if failed */
1298         if (!k_idx) return;
1299
1300         if (k_info[k_idx].gen_flags & TRG_INSTA_ART)
1301         {
1302                 ARTIFACT_IDX i;
1303
1304                 /* Artifactify */
1305                 for (i = 1; i < max_a_idx; i++)
1306                 {
1307                         /* Ignore incorrect tval */
1308                         if (a_info[i].tval != k_info[k_idx].tval) continue;
1309
1310                         /* Ignore incorrect sval */
1311                         if (a_info[i].sval != k_info[k_idx].sval) continue;
1312
1313                         /* Create this artifact */
1314                         (void)create_named_art(caster_ptr, i, caster_ptr->y, caster_ptr->x);
1315
1316                         /* All done */
1317                         msg_print("Allocated(INSTA_ART).");
1318
1319                         return;
1320                 }
1321         }
1322
1323         object_type     forge;
1324         object_type *q_ptr;
1325         q_ptr = &forge;
1326         object_prep(q_ptr, k_idx);
1327
1328         apply_magic(caster_ptr, q_ptr, caster_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART);
1329
1330         /* Drop the object from heaven */
1331         (void)drop_near(caster_ptr, q_ptr, -1, caster_ptr->y, caster_ptr->x);
1332
1333         /* All done */
1334         msg_print("Allocated.");
1335 }
1336
1337
1338 /*!
1339  * @brief プレイヤーを完全回復する /
1340  * Cure everything instantly
1341  * @return なし
1342  */
1343 static void do_cmd_wiz_cure_all(player_type *creature_ptr)
1344 {
1345         (void)life_stream(creature_ptr, FALSE, FALSE);
1346         (void)restore_mana(creature_ptr, TRUE);
1347         (void)set_food(creature_ptr, PY_FOOD_MAX - 1);
1348 }
1349
1350
1351 /*!
1352  * @brief 任意のダンジョン及び階層に飛ぶ /
1353  * Go to any level
1354  * @return なし
1355  */
1356 static void do_cmd_wiz_jump(player_type *creature_ptr)
1357 {
1358         /* Ask for level */
1359         if (command_arg <= 0)
1360         {
1361                 char    ppp[80];
1362                 char    tmp_val[160];
1363                 DUNGEON_IDX tmp_dungeon_type;
1364
1365                 /* Prompt */
1366                 sprintf(ppp, "Jump which dungeon : ");
1367
1368                 /* Default */
1369                 sprintf(tmp_val, "%d", creature_ptr->dungeon_idx);
1370
1371                 /* Ask for a level */
1372                 if (!get_string(ppp, tmp_val, 2)) return;
1373
1374                 tmp_dungeon_type = (DUNGEON_IDX)atoi(tmp_val);
1375                 if (!d_info[tmp_dungeon_type].maxdepth || (tmp_dungeon_type > current_world_ptr->max_d_idx)) tmp_dungeon_type = DUNGEON_ANGBAND;
1376
1377                 /* Prompt */
1378                 sprintf(ppp, "Jump to level (0, %d-%d): ",
1379                         (int)d_info[tmp_dungeon_type].mindepth, (int)d_info[tmp_dungeon_type].maxdepth);
1380
1381                 /* Default */
1382                 sprintf(tmp_val, "%d", (int)creature_ptr->current_floor_ptr->dun_level);
1383
1384                 /* Ask for a level */
1385                 if (!get_string(ppp, tmp_val, 10)) return;
1386
1387                 /* Extract request */
1388                 command_arg = (COMMAND_ARG)atoi(tmp_val);
1389
1390                 creature_ptr->dungeon_idx = tmp_dungeon_type;
1391         }
1392
1393         if (command_arg < d_info[creature_ptr->dungeon_idx].mindepth) command_arg = 0;
1394         if (command_arg > d_info[creature_ptr->dungeon_idx].maxdepth) command_arg = (COMMAND_ARG)d_info[creature_ptr->dungeon_idx].maxdepth;
1395
1396         /* Accept request */
1397         msg_format("You jump to dungeon level %d.", command_arg);
1398
1399         if (autosave_l) do_cmd_save_game(creature_ptr, TRUE);
1400
1401         /* Change level */
1402         creature_ptr->current_floor_ptr->dun_level = command_arg;
1403
1404         prepare_change_floor_mode(creature_ptr, CFM_RAND_PLACE);
1405
1406         if (!creature_ptr->current_floor_ptr->dun_level) creature_ptr->dungeon_idx = 0;
1407         creature_ptr->current_floor_ptr->inside_arena = FALSE;
1408         creature_ptr->wild_mode = FALSE;
1409
1410         leave_quest_check(creature_ptr);
1411
1412         if (record_stair) exe_write_diary(creature_ptr, DIARY_WIZ_TELE, 0, NULL);
1413
1414         creature_ptr->current_floor_ptr->inside_quest = 0;
1415         free_turn(creature_ptr);
1416
1417         /* Prevent energy_need from being too lower than 0 */
1418         creature_ptr->energy_need = 0;
1419
1420         /*
1421          * Clear all saved floors
1422          * and create a first saved floor
1423          */
1424         prepare_change_floor_mode(creature_ptr, CFM_FIRST_FLOOR);
1425         creature_ptr->leaving = TRUE;
1426 }
1427
1428
1429 /*!
1430  * @brief 全ベースアイテムを鑑定済みにする /
1431  * Become aware of a lot of objects
1432  * @param caster_ptr プレーヤーへの参照ポインタ
1433  * @return なし
1434  */
1435 static void do_cmd_wiz_learn(player_type *caster_ptr)
1436 {
1437         /* Scan every object */
1438         object_type forge;
1439         object_type *q_ptr;
1440         for (KIND_OBJECT_IDX i = 1; i < max_k_idx; i++)
1441         {
1442                 object_kind *k_ptr = &k_info[i];
1443
1444                 /* Induce awareness */
1445                 if (k_ptr->level <= command_arg)
1446                 {
1447                         q_ptr = &forge;
1448                         object_prep(q_ptr, i);
1449                         object_aware(caster_ptr, q_ptr);
1450                 }
1451         }
1452 }
1453
1454
1455 /*!
1456  * @brief 現在のフロアに合ったモンスターをランダムに召喚する /
1457  * Summon some creatures
1458  * @param caster_ptr プレーヤーへの参照ポインタ
1459  * @param num 生成処理回数
1460  * @return なし
1461  */
1462 static void do_cmd_wiz_summon(player_type *caster_ptr, int num)
1463 {
1464         for (int i = 0; i < num; i++)
1465         {
1466                 (void)summon_specific(caster_ptr, 0, caster_ptr->y, caster_ptr->x, caster_ptr->current_floor_ptr->dun_level, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
1467         }
1468 }
1469
1470
1471 /*!
1472  * @brief モンスターを種族IDを指定して敵対的に召喚する /
1473  * Summon a creature of the specified type
1474  * @param r_idx モンスター種族ID
1475  * @return なし
1476  * @details
1477  * This function is rather dangerous
1478  */
1479 static void do_cmd_wiz_named(player_type *summoner_ptr, MONRACE_IDX r_idx)
1480 {
1481         (void)summon_named_creature(summoner_ptr, 0, summoner_ptr->y, summoner_ptr->x, r_idx, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
1482 }
1483
1484
1485 /*!
1486  * @brief モンスターを種族IDを指定してペット召喚する /
1487  * Summon a creature of the specified type
1488  * @param r_idx モンスター種族ID
1489  * @return なし
1490  * @details
1491  * This function is rather dangerous
1492  */
1493 static void do_cmd_wiz_named_friendly(player_type *summoner_ptr, MONRACE_IDX r_idx)
1494 {
1495         (void)summon_named_creature(summoner_ptr, 0, summoner_ptr->y, summoner_ptr->x, r_idx, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP | PM_FORCE_PET));
1496 }
1497
1498
1499 /*!
1500  * @brief プレイヤー近辺の全モンスターを消去する /
1501  * Hack -- Delete all nearby monsters
1502  * @return なし
1503  */
1504 static void do_cmd_wiz_zap(player_type *caster_ptr)
1505 {
1506         /* Genocide everyone nearby */
1507         for (MONSTER_IDX i = 1; i < caster_ptr->current_floor_ptr->m_max; i++)
1508         {
1509                 monster_type *m_ptr = &caster_ptr->current_floor_ptr->m_list[i];
1510                 if (!monster_is_valid(m_ptr)) continue;
1511
1512                 /* Skip the mount */
1513                 if (i == caster_ptr->riding) continue;
1514
1515                 /* Delete nearby monsters */
1516                 if (m_ptr->cdis > MAX_SIGHT) continue;
1517
1518                 if (record_named_pet && is_pet(m_ptr) && m_ptr->nickname)
1519                 {
1520                         GAME_TEXT m_name[MAX_NLEN];
1521
1522                         monster_desc(caster_ptr, m_name, m_ptr, MD_INDEF_VISIBLE);
1523                         exe_write_diary(caster_ptr, DIARY_NAMED_PET, RECORD_NAMED_PET_WIZ_ZAP, m_name);
1524                 }
1525
1526                 delete_monster_idx(caster_ptr, i);
1527         }
1528 }
1529
1530
1531 /*!
1532  * @brief フロアに存在する全モンスターを消去する /
1533  * Hack -- Delete all monsters
1534  * @param caster_ptr 術者の参照ポインタ
1535  * @return なし
1536  */
1537 static void do_cmd_wiz_zap_all(player_type *caster_ptr)
1538 {
1539         /* Genocide everyone */
1540         for (MONSTER_IDX i = 1; i < caster_ptr->current_floor_ptr->m_max; i++)
1541         {
1542                 monster_type *m_ptr = &caster_ptr->current_floor_ptr->m_list[i];
1543                 if (!monster_is_valid(m_ptr)) continue;
1544
1545                 /* Skip the mount */
1546                 if (i == caster_ptr->riding) continue;
1547
1548                 if (record_named_pet && is_pet(m_ptr) && m_ptr->nickname)
1549                 {
1550                         GAME_TEXT m_name[MAX_NLEN];
1551
1552                         monster_desc(caster_ptr, m_name, m_ptr, MD_INDEF_VISIBLE);
1553                         exe_write_diary(caster_ptr, DIARY_NAMED_PET, RECORD_NAMED_PET_WIZ_ZAP, m_name);
1554                 }
1555
1556                 /* Delete this monster */
1557                 delete_monster_idx(caster_ptr, i);
1558         }
1559 }
1560
1561
1562 /*!
1563  * @brief 指定された地点の地形IDを変更する /
1564  * Create desired feature
1565  * @param creaturer_ptr プレーヤーへの参照ポインタ
1566  * @return なし
1567  */
1568 static void do_cmd_wiz_create_feature(player_type *creature_ptr)
1569 {
1570         POSITION y, x;
1571         if (!tgt_pt(creature_ptr, &x, &y)) return;
1572
1573         grid_type *g_ptr;
1574         g_ptr = &creature_ptr->current_floor_ptr->grid_array[y][x];
1575
1576         /* Default */
1577         static int prev_feat = 0;
1578         char tmp_val[160];
1579         sprintf(tmp_val, "%d", prev_feat);
1580
1581         /* Query */
1582         if (!get_string(_("地形: ", "Feature: "), tmp_val, 3)) return;
1583
1584         /* Extract */
1585         FEAT_IDX tmp_feat = (FEAT_IDX)atoi(tmp_val);
1586         if (tmp_feat < 0) tmp_feat = 0;
1587         else if (tmp_feat >= max_f_idx) tmp_feat = max_f_idx - 1;
1588
1589         /* Default */
1590         static int prev_mimic = 0;
1591         sprintf(tmp_val, "%d", prev_mimic);
1592
1593         /* Query */
1594         if (!get_string(_("地形 (mimic): ", "Feature (mimic): "), tmp_val, 3)) return;
1595
1596         /* Extract */
1597         FEAT_IDX tmp_mimic = (FEAT_IDX)atoi(tmp_val);
1598         if (tmp_mimic < 0) tmp_mimic = 0;
1599         else if (tmp_mimic >= max_f_idx) tmp_mimic = max_f_idx - 1;
1600
1601         cave_set_feat(creature_ptr, y, x, tmp_feat);
1602         g_ptr->mimic = (s16b)tmp_mimic;
1603
1604         feature_type *f_ptr;
1605         f_ptr = &f_info[get_feat_mimic(g_ptr)];
1606
1607         if (have_flag(f_ptr->flags, FF_GLYPH) ||
1608                 have_flag(f_ptr->flags, FF_MINOR_GLYPH))
1609                 g_ptr->info |= (CAVE_OBJECT);
1610         else if (have_flag(f_ptr->flags, FF_MIRROR))
1611                 g_ptr->info |= (CAVE_GLOW | CAVE_OBJECT);
1612
1613         note_spot(creature_ptr, y, x);
1614         lite_spot(creature_ptr, y, x);
1615         creature_ptr->update |= (PU_FLOW);
1616
1617         prev_feat = tmp_feat;
1618         prev_mimic = tmp_mimic;
1619 }
1620
1621
1622 /*!
1623  * @brief 現在のオプション設定をダンプ出力する /
1624  * @param creature_ptr プレーヤーへの参照ポインタ
1625  * Hack -- Dump option bits usage
1626  * @return なし
1627  */
1628 static void do_cmd_dump_options()
1629 {
1630         char buf[1024];
1631         path_build(buf, sizeof buf, ANGBAND_DIR_USER, "opt_info.txt");
1632
1633         FILE *fff;
1634         fff = my_fopen(buf, "a");
1635
1636         if (!fff)
1637         {
1638                 msg_format(_("ファイル %s を開けませんでした。", "Failed to open file %s."), buf);
1639                 msg_print(NULL);
1640                 return;
1641         }
1642
1643         /* Allocate the "exist" array (2-dimension) */
1644         int  **exist;
1645         C_MAKE(exist, NUM_O_SET, int *);
1646         C_MAKE(*exist, NUM_O_BIT * NUM_O_SET, int);
1647         for (int i = 1; i < NUM_O_SET; i++) exist[i] = *exist + i * NUM_O_BIT;
1648
1649         /* Check for exist option bits */
1650         for (int i = 0; option_info[i].o_desc; i++)
1651         {
1652                 const option_type *ot_ptr = &option_info[i];
1653                 if (ot_ptr->o_var) exist[ot_ptr->o_set][ot_ptr->o_bit] = i + 1;
1654         }
1655
1656         fprintf(fff, "[Option bits usage on Hengband %d.%d.%d]\n\n",
1657                 FAKE_VER_MAJOR - 10, FAKE_VER_MINOR, FAKE_VER_PATCH);
1658
1659         fputs("Set - Bit (Page) Option Name\n", fff);
1660         fputs("------------------------------------------------\n", fff);
1661
1662         /* Dump option bits usage */
1663         for (int i = 0; i < NUM_O_SET; i++)
1664         {
1665                 for (int j = 0; j < NUM_O_BIT; j++)
1666                 {
1667                         if (exist[i][j])
1668                         {
1669                                 const option_type *ot_ptr = &option_info[exist[i][j] - 1];
1670                                 fprintf(fff, "  %d -  %02d (%4d) %s\n",
1671                                         i, j, ot_ptr->o_page, ot_ptr->o_text);
1672                         }
1673                         else
1674                         {
1675                                 fprintf(fff, "  %d -  %02d\n", i, j);
1676                         }
1677                 }
1678
1679                 fputc('\n', fff);
1680         }
1681
1682         /* Free the "exist" array (2-dimension) */
1683         C_KILL(*exist, NUM_O_BIT * NUM_O_SET, int);
1684         C_KILL(exist, NUM_O_SET, int *);
1685         my_fclose(fff);
1686
1687         msg_format(_("オプションbit使用状況をファイル %s に書き出しました。", "Option bits usage dump saved to file %s."), buf);
1688 }
1689
1690
1691 /*!
1692  * @brief デバッグコマンドを選択する処理のメインルーチン /
1693  * Ask for and parse a "debug command"
1694  * The "command_arg" may have been set.
1695  * @param creature_ptr プレーヤーへの参照ポインタ
1696  * @return なし
1697  */
1698 void do_cmd_debug(player_type *creature_ptr)
1699 {
1700         char cmd;
1701         get_com("Debug Command: ", &cmd, FALSE);
1702
1703         switch (cmd)
1704         {
1705         case ESCAPE:
1706         case ' ':
1707         case '\n':
1708         case '\r':
1709                 break;
1710
1711                 /* Hack -- Generate Spoilers */
1712         case '"':
1713                 do_cmd_spoilers(creature_ptr);
1714                 break;
1715
1716                 /* Hack -- Help */
1717         case '?':
1718                 do_cmd_help(creature_ptr);
1719                 break;
1720
1721                 /* Cure all maladies */
1722         case 'a':
1723                 do_cmd_wiz_cure_all(creature_ptr);
1724                 break;
1725
1726                 /* Know alignment */
1727         case 'A':
1728                 msg_format("Your alignment is %d.", creature_ptr->align);
1729                 break;
1730
1731                 /* Teleport to target */
1732         case 'b':
1733                 do_cmd_wiz_bamf(creature_ptr);
1734                 break;
1735
1736         case 'B':
1737                 update_gambling_monsters(creature_ptr);
1738                 break;
1739
1740                 /* Create any object */
1741         case 'c':
1742                 wiz_create_item(creature_ptr);
1743                 break;
1744
1745                 /* Create a named artifact */
1746         case 'C':
1747                 wiz_create_named_art(creature_ptr);
1748                 break;
1749
1750                 /* Detect everything */
1751         case 'd':
1752                 detect_all(creature_ptr, DETECT_RAD_ALL * 3);
1753                 break;
1754
1755                 /* Dimension_door */
1756         case 'D':
1757                 wiz_dimension_door(creature_ptr);
1758                 break;
1759
1760                 /* Edit character */
1761         case 'e':
1762                 do_cmd_wiz_change(creature_ptr);
1763                 break;
1764
1765                 /* Blue Mage Only */
1766         case 'E':
1767                 if (creature_ptr->pclass == CLASS_BLUE_MAGE)
1768                 {
1769                         do_cmd_wiz_blue_mage(creature_ptr);
1770                 }
1771                 break;
1772
1773                 /* View item info */
1774         case 'f':
1775                 identify_fully(creature_ptr, FALSE, 0);
1776                 break;
1777
1778                 /* Create desired feature */
1779         case 'F':
1780                 do_cmd_wiz_create_feature(creature_ptr);
1781                 break;
1782
1783                 /* Good Objects */
1784         case 'g':
1785                 if (command_arg <= 0) command_arg = 1;
1786                 acquirement(creature_ptr, creature_ptr->y, creature_ptr->x, command_arg, FALSE, FALSE, TRUE);
1787                 break;
1788
1789                 /* Hitpoint rerating */
1790         case 'h':
1791                 roll_hitdice(creature_ptr, SPOP_DISPLAY_MES | SPOP_DEBUG);
1792                 break;
1793
1794         case 'H':
1795                 do_cmd_summon_horde(creature_ptr);
1796                 break;
1797
1798                 /* Identify */
1799         case 'i':
1800                 (void)ident_spell(creature_ptr, FALSE, 0);
1801                 break;
1802
1803                 /* Go up or down in the dungeon */
1804         case 'j':
1805                 do_cmd_wiz_jump(creature_ptr);
1806                 break;
1807
1808                 /* Self-Knowledge */
1809         case 'k':
1810                 self_knowledge(creature_ptr);
1811                 break;
1812
1813                 /* Learn about objects */
1814         case 'l':
1815                 do_cmd_wiz_learn(creature_ptr);
1816                 break;
1817
1818                 /* Magic Mapping */
1819         case 'm':
1820                 map_area(creature_ptr, DETECT_RAD_ALL * 3);
1821                 break;
1822
1823                 /* Mutation */
1824         case 'M':
1825                 (void)gain_mutation(creature_ptr, command_arg);
1826                 break;
1827
1828                 /* Reset Class */
1829         case 'R':
1830                 (void)do_cmd_wiz_reset_class(creature_ptr);
1831                 break;
1832
1833                 /* Specific reward */
1834         case 'r':
1835                 (void)gain_level_reward(creature_ptr, command_arg);
1836                 break;
1837
1838                 /* Summon _friendly_ named monster */
1839         case 'N':
1840                 do_cmd_wiz_named_friendly(creature_ptr, command_arg);
1841                 break;
1842
1843                 /* Summon Named Monster */
1844         case 'n':
1845                 do_cmd_wiz_named(creature_ptr, command_arg);
1846                 break;
1847
1848                 /* Dump option bits usage */
1849         case 'O':
1850                 do_cmd_dump_options();
1851                 break;
1852
1853                 /* Object playing routines */
1854         case 'o':
1855                 do_cmd_wiz_play(creature_ptr);
1856                 break;
1857
1858                 /* Phase Door */
1859         case 'p':
1860                 teleport_player(creature_ptr, 10, TELEPORT_SPONTANEOUS);
1861                 break;
1862
1863                 /* Take a Quests */
1864         case 'Q':
1865         {
1866                 char ppp[30];
1867                 char tmp_val[5];
1868                 int tmp_int;
1869                 sprintf(ppp, "QuestID (0-%d):", max_q_idx - 1);
1870                 sprintf(tmp_val, "%d", 0);
1871
1872                 if (!get_string(ppp, tmp_val, 3)) return;
1873                 tmp_int = atoi(tmp_val);
1874
1875                 if (tmp_int < 0) break;
1876                 if (tmp_int >= max_q_idx) break;
1877
1878                 creature_ptr->current_floor_ptr->inside_quest = (QUEST_IDX)tmp_int;
1879                 process_dungeon_file(creature_ptr, "q_info.txt", 0, 0, 0, 0);
1880                 quest[tmp_int].status = QUEST_STATUS_TAKEN;
1881                 creature_ptr->current_floor_ptr->inside_quest = 0;
1882         }
1883
1884         break;
1885
1886         /* Complete a Quest -KMW- */
1887         case 'q':
1888                 if (creature_ptr->current_floor_ptr->inside_quest)
1889                 {
1890                         if (quest[creature_ptr->current_floor_ptr->inside_quest].status == QUEST_STATUS_TAKEN)
1891                         {
1892                                 complete_quest(creature_ptr, creature_ptr->current_floor_ptr->inside_quest);
1893                                 break;
1894                         }
1895                 }
1896                 else
1897                 {
1898                         msg_print("No current quest");
1899                         msg_print(NULL);
1900                 }
1901
1902                 break;
1903
1904                 /* Make every dungeon square "known" to test streamers -KMW- */
1905         case 'u':
1906                 for (int y = 0; y < creature_ptr->current_floor_ptr->height; y++)
1907                 {
1908                         for (int x = 0; x < creature_ptr->current_floor_ptr->width; x++)
1909                         {
1910                                 creature_ptr->current_floor_ptr->grid_array[y][x].info |= (CAVE_GLOW | CAVE_MARK);
1911                         }
1912                 }
1913
1914                 wiz_lite(creature_ptr, FALSE);
1915                 break;
1916
1917                 /* Summon Random Monster(s) */
1918         case 's':
1919                 if (command_arg <= 0) command_arg = 1;
1920                 do_cmd_wiz_summon(creature_ptr, command_arg);
1921                 break;
1922
1923                 /* Special(Random Artifact) Objects */
1924         case 'S':
1925                 if (command_arg <= 0) command_arg = 1;
1926                 acquirement(creature_ptr, creature_ptr->y, creature_ptr->x, command_arg, TRUE, TRUE, TRUE);
1927                 break;
1928
1929                 /* Teleport */
1930         case 't':
1931                 teleport_player(creature_ptr, 100, TELEPORT_SPONTANEOUS);
1932                 break;
1933
1934                 /* Game Time Setting */
1935         case 'T':
1936                 set_gametime();
1937                 break;
1938
1939                 /* Very Good Objects */
1940         case 'v':
1941                 if (command_arg <= 0) command_arg = 1;
1942                 acquirement(creature_ptr, creature_ptr->y, creature_ptr->x, command_arg, TRUE, FALSE, TRUE);
1943                 break;
1944
1945                 /* Wizard Light the Level */
1946         case 'w':
1947                 wiz_lite(creature_ptr, (bool)(creature_ptr->pclass == CLASS_NINJA));
1948                 break;
1949
1950                 /* Increase Experience */
1951         case 'x':
1952                 gain_exp(creature_ptr, command_arg ? command_arg : (creature_ptr->exp + 1));
1953                 break;
1954
1955                 /* Zap Monsters (Genocide) */
1956         case 'z':
1957                 do_cmd_wiz_zap(creature_ptr);
1958                 break;
1959
1960                 /* Zap Monsters (Omnicide) */
1961         case 'Z':
1962                 do_cmd_wiz_zap_all(creature_ptr);
1963                 break;
1964
1965                 /* Hack -- whatever I desire */
1966         case '_':
1967                 probing(creature_ptr);
1968                 break;
1969
1970                 /* For temporary test. */
1971         case 'X':
1972         {
1973                 INVENTORY_IDX i;
1974                 for (i = INVEN_TOTAL - 1; i >= 0; i--)
1975                 {
1976                         if (creature_ptr->inventory_list[i].k_idx) drop_from_inventory(creature_ptr, i, 999);
1977                 }
1978                 player_outfit(creature_ptr);
1979                 break;
1980         }
1981
1982         case 'V':
1983                 do_cmd_wiz_reset_class(creature_ptr);
1984                 break;
1985
1986         case '@':
1987                 do_cmd_debug_spell(creature_ptr);
1988                 break;
1989
1990         default:
1991                 msg_print("That is not a valid debug command.");
1992                 break;
1993         }
1994 }