src/wizard/wizard-special-process.c

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