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