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