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