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