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