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