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