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