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