src/wizard2.c

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