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