src/wizard/wizard-special-process.c

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