src/wizard/wizard-special-process.c

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