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