src/wizard/wizard-special-process.c

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