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