src/wizard/wizard-special-process.c

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