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