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