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