src/wizard/wizard-special-process.c

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