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