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