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(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(&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();
 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(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(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(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(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(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(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(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
 985         concptr p = "Enter number of items to roll: ";
 986         char tmp_val[80];
 987
 988
 989         /* Mega-Hack -- allow multiple artifacts */
 990         if (object_is_fixed_artifact(o_ptr)) a_info[o_ptr->name1].cur_num = 0;
 991
 992         /* Interact */
 993         u32b i, matches, better, worse, other, correct;
 994         u32b test_roll = 1000000;
 995         char ch;
 996         concptr quality;
 997         BIT_FLAGS mode;
 998         while (TRUE)
 999         {
1000                 concptr pmt = "Roll for [n]ormal, [g]ood, or [e]xcellent treasure? ";
1001
1002                 /* Display item */
1003                 wiz_display_item(o_ptr);
1004
1005                 /* Get choices */
1006                 if (!get_com(pmt, &ch, FALSE)) break;
1007
1008                 if (ch == 'n' || ch == 'N')
1009                 {
1010                         mode = 0L;
1011                         quality = "normal";
1012                 }
1013                 else if (ch == 'g' || ch == 'G')
1014                 {
1015                         mode = AM_GOOD;
1016                         quality = "good";
1017                 }
1018                 else if (ch == 'e' || ch == 'E')
1019                 {
1020                         mode = AM_GOOD | AM_GREAT;
1021                         quality = "excellent";
1022                 }
1023                 else
1024                 {
1025                         break;
1026                 }
1027
1028                 sprintf(tmp_val, "%ld", (long int)test_roll);
1029                 if (get_string(p, tmp_val, 10)) test_roll = atol(tmp_val);
1030                 test_roll = MAX(1, test_roll);
1031
1032                 /* Let us know what we are doing */
1033                 msg_format("Creating a lot of %s items. Base level = %d.",
1034                         quality, caster_ptr->current_floor_ptr->dun_level);
1035                 msg_print(NULL);
1036
1037                 /* Set counters to zero */
1038                 correct = matches = better = worse = other = 0;
1039
1040                 /* Let's rock and roll */
1041                 for (i = 0; i <= test_roll; i++)
1042                 {
1043                         /* Output every few rolls */
1044                         if ((i < 100) || (i % 100 == 0))
1045                         {
1046                                 /* Do not wait */
1047                                 inkey_scan = TRUE;
1048
1049                                 /* Allow interupt */
1050                                 if (inkey())
1051                                 {
1052                                         flush();
1053                                         break; // stop rolling
1054                                 }
1055
1056                                 /* Dump the stats */
1057                                 prt(format(q, i, correct, matches, better, worse, other), 0, 0);
1058                                 Term_fresh();
1059                         }
1060                         q_ptr = &forge;
1061                         object_wipe(q_ptr);
1062
1063                         /* Create an object */
1064                         make_object(q_ptr, mode);
1065
1066
1067                         /* Mega-Hack -- allow multiple artifacts */
1068                         if (object_is_fixed_artifact(q_ptr)) a_info[q_ptr->name1].cur_num = 0;
1069
1070
1071                         /* Test for the same tval and sval. */
1072                         if ((o_ptr->tval) != (q_ptr->tval)) continue;
1073                         if ((o_ptr->sval) != (q_ptr->sval)) continue;
1074
1075                         /* One more correct item */
1076                         correct++;
1077
1078                         /* Check for match */
1079                         if ((q_ptr->pval == o_ptr->pval) &&
1080                                 (q_ptr->to_a == o_ptr->to_a) &&
1081                                 (q_ptr->to_h == o_ptr->to_h) &&
1082                                 (q_ptr->to_d == o_ptr->to_d) &&
1083                                 (q_ptr->name1 == o_ptr->name1))
1084                         {
1085                                 matches++;
1086                         }
1087
1088                         /* Check for better */
1089                         else if ((q_ptr->pval >= o_ptr->pval) &&
1090                                 (q_ptr->to_a >= o_ptr->to_a) &&
1091                                 (q_ptr->to_h >= o_ptr->to_h) &&
1092                                 (q_ptr->to_d >= o_ptr->to_d))
1093                         {
1094                                 better++;
1095                         }
1096
1097                         /* Check for worse */
1098                         else if ((q_ptr->pval <= o_ptr->pval) &&
1099                                 (q_ptr->to_a <= o_ptr->to_a) &&
1100                                 (q_ptr->to_h <= o_ptr->to_h) &&
1101                                 (q_ptr->to_d <= o_ptr->to_d))
1102                         {
1103                                 worse++;
1104                         }
1105
1106                         /* Assume different */
1107                         else
1108                         {
1109                                 other++;
1110                         }
1111                 }
1112
1113                 /* Final dump */
1114                 msg_format(q, i, correct, matches, better, worse, other);
1115                 msg_print(NULL);
1116         }
1117
1118         /* Hack -- Normally only make a single artifact */
1119         if (object_is_fixed_artifact(o_ptr)) a_info[o_ptr->name1].cur_num = 1;
1120 }
1121
1122
1123 /*!
1124  * @brief 検査対象のアイテムの数を変更する /
1125  * Change the quantity of a the item
1126  * @param o_ptr 変更するアイテム情報構造体の参照ポインタ
1127  * @return なし
1128  */
1129 static void wiz_quantity_item(object_type *o_ptr)
1130 {
1131         /* Never duplicate artifacts */
1132         if (object_is_artifact(o_ptr)) return;
1133
1134         /* Store old quantity. -LM- */
1135         int tmp_qnt = o_ptr->number;
1136
1137         /* Default */
1138         char tmp_val[100];
1139         sprintf(tmp_val, "%d", (int)o_ptr->number);
1140
1141         /* Query */
1142         if (get_string("Quantity: ", tmp_val, 2))
1143         {
1144                 /* Extract */
1145                 int tmp_int = atoi(tmp_val);
1146                 if (tmp_int < 1) tmp_int = 1;
1147                 if (tmp_int > 99) tmp_int = 99;
1148
1149                 /* Accept modifications */
1150                 o_ptr->number = (byte_hack)tmp_int;
1151         }
1152
1153         if (o_ptr->tval == TV_ROD)
1154         {
1155                 o_ptr->pval = o_ptr->pval * o_ptr->number / tmp_qnt;
1156         }
1157 }
1158
1159
1160 /*!
1161  * @brief 青魔導師の魔法を全て習得済みにする /
1162  * debug command for blue mage
1163  * @return なし
1164  */
1165 static void do_cmd_wiz_blue_mage(player_type *caster_ptr)
1166 {
1167         BIT_FLAGS f4 = 0L, f5 = 0L, f6 = 0L;
1168         for (int j = 1; j < A_MAX; j++)
1169         {
1170                 set_rf_masks(&f4, &f5, &f6, j);
1171
1172                 int i;
1173                 for (i = 0; i < 32; i++)
1174                 {
1175                         if ((0x00000001 << i) & f4) caster_ptr->magic_num2[i] = 1;
1176                 }
1177
1178                 for (; i < 64; i++)
1179                 {
1180                         if ((0x00000001 << (i - 32)) & f5) caster_ptr->magic_num2[i] = 1;
1181                 }
1182
1183                 for (; i < 96; i++)
1184                 {
1185                         if ((0x00000001 << (i - 64)) & f6) caster_ptr->magic_num2[i] = 1;
1186                 }
1187         }
1188 }
1189
1190
1191 /*!
1192  * @brief アイテム検査のメインルーチン /
1193  * Play with an item. Options include:
1194  * @return なし
1195  * @details
1196  *   - Output statistics (via wiz_roll_item)<br>
1197  *   - Reroll item (via wiz_reroll_item)<br>
1198  *   - Change properties (via wiz_tweak_item)<br>
1199  *   - Change the number of items (via wiz_quantity_item)<br>
1200  */
1201 static void do_cmd_wiz_play(player_type *creature_ptr)
1202 {
1203         concptr q = "Play with which object? ";
1204         concptr s = "You have nothing to play with.";
1205
1206         OBJECT_IDX item;
1207         object_type *o_ptr;
1208         o_ptr = choose_object(creature_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), 0);
1209
1210         if (!o_ptr) return;
1211
1212         screen_save();
1213
1214         object_type     forge;
1215         object_type *q_ptr;
1216         q_ptr = &forge;
1217         object_copy(q_ptr, o_ptr);
1218
1219         /* The main loop */
1220         char ch;
1221         bool changed = FALSE;
1222         while (TRUE)
1223         {
1224                 /* Display the item */
1225                 wiz_display_item(q_ptr);
1226
1227                 /* Get choice */
1228                 if (!get_com("[a]ccept [s]tatistics [r]eroll [t]weak [q]uantity? ", &ch, FALSE))
1229                 {
1230                         changed = FALSE;
1231                         break;
1232                 }
1233
1234                 if (ch == 'A' || ch == 'a')
1235                 {
1236                         changed = TRUE;
1237                         break;
1238                 }
1239
1240                 if (ch == 's' || ch == 'S')
1241                 {
1242                         wiz_statistics(creature_ptr, q_ptr);
1243                 }
1244
1245                 if (ch == 'r' || ch == 'r')
1246                 {
1247                         wiz_reroll_item(creature_ptr, q_ptr);
1248                 }
1249
1250                 if (ch == 't' || ch == 'T')
1251                 {
1252                         wiz_tweak_item(q_ptr);
1253                 }
1254
1255                 if (ch == 'q' || ch == 'Q')
1256                 {
1257                         wiz_quantity_item(q_ptr);
1258                 }
1259         }
1260
1261         screen_load();
1262
1263
1264         /* Accept change */
1265         if (changed)
1266         {
1267                 msg_print("Changes accepted.");
1268
1269                 /* Recalcurate object's weight */
1270                 if (item >= 0)
1271                 {
1272                         creature_ptr->total_weight += (q_ptr->weight * q_ptr->number)
1273                                 - (o_ptr->weight * o_ptr->number);
1274                 }
1275
1276                 /* Change */
1277                 object_copy(o_ptr, q_ptr);
1278
1279                 creature_ptr->update |= (PU_BONUS);
1280                 creature_ptr->update |= (PU_COMBINE | PU_REORDER);
1281
1282                 creature_ptr->window |= (PW_INVEN | PW_EQUIP | PW_SPELL | PW_PLAYER);
1283         }
1284
1285         /* Ignore change */
1286         else
1287         {
1288                 msg_print("Changes ignored.");
1289         }
1290 }
1291
1292
1293 /*!
1294  * @brief 任意のベースアイテム生成のメインルーチン /
1295  * Wizard routine for creating objects          -RAK-
1296  * @return なし
1297  * @details
1298  * Heavily modified to allow magification and artifactification  -Bernd-
1299  *
1300  * Note that wizards cannot create objects on top of other objects.
1301  *
1302  * Hack -- this routine always makes a "dungeon object", and applies
1303  * magic to it, and attempts to decline cursed items.
1304  */
1305 static void wiz_create_item(player_type *caster_ptr)
1306 {
1307         screen_save();
1308
1309         /* Get object base type */
1310         OBJECT_IDX k_idx = wiz_create_itemtype();
1311
1312         screen_load();
1313
1314         /* Return if failed */
1315         if (!k_idx) return;
1316
1317         if (k_info[k_idx].gen_flags & TRG_INSTA_ART)
1318         {
1319                 ARTIFACT_IDX i;
1320
1321                 /* Artifactify */
1322                 for (i = 1; i < max_a_idx; i++)
1323                 {
1324                         /* Ignore incorrect tval */
1325                         if (a_info[i].tval != k_info[k_idx].tval) continue;
1326
1327                         /* Ignore incorrect sval */
1328                         if (a_info[i].sval != k_info[k_idx].sval) continue;
1329
1330                         /* Create this artifact */
1331                         (void)create_named_art(i, caster_ptr->y, caster_ptr->x);
1332
1333                         /* All done */
1334                         msg_print("Allocated(INSTA_ART).");
1335
1336                         return;
1337                 }
1338         }
1339
1340         object_type     forge;
1341         object_type *q_ptr;
1342         q_ptr = &forge;
1343         object_prep(q_ptr, k_idx);
1344
1345         apply_magic(q_ptr, caster_ptr->current_floor_ptr->dun_level, AM_NO_FIXED_ART);
1346
1347         /* Drop the object from heaven */
1348         (void)drop_near(q_ptr, -1, caster_ptr->y, caster_ptr->x);
1349
1350         /* All done */
1351         msg_print("Allocated.");
1352 }
1353
1354
1355 /*!
1356  * @brief プレイヤーを完全回復する /
1357  * Cure everything instantly
1358  * @return なし
1359  */
1360 static void do_cmd_wiz_cure_all(player_type *creature_ptr)
1361 {
1362         (void)life_stream(creature_ptr, FALSE, FALSE);
1363         (void)restore_mana(creature_ptr, TRUE);
1364         (void)set_food(creature_ptr, PY_FOOD_MAX - 1);
1365 }
1366
1367
1368 /*!
1369  * @brief 任意のダンジョン及び階層に飛ぶ /
1370  * Go to any level
1371  * @return なし
1372  */
1373 static void do_cmd_wiz_jump(player_type *creature_ptr)
1374 {
1375         /* Ask for level */
1376         if (command_arg <= 0)
1377         {
1378                 char    ppp[80];
1379                 char    tmp_val[160];
1380                 DUNGEON_IDX tmp_dungeon_type;
1381
1382                 /* Prompt */
1383                 sprintf(ppp, "Jump which dungeon : ");
1384
1385                 /* Default */
1386                 sprintf(tmp_val, "%d", creature_ptr->dungeon_idx);
1387
1388                 /* Ask for a level */
1389                 if (!get_string(ppp, tmp_val, 2)) return;
1390
1391                 tmp_dungeon_type = (DUNGEON_IDX)atoi(tmp_val);
1392                 if (!d_info[tmp_dungeon_type].maxdepth || (tmp_dungeon_type > current_world_ptr->max_d_idx)) tmp_dungeon_type = DUNGEON_ANGBAND;
1393
1394                 /* Prompt */
1395                 sprintf(ppp, "Jump to level (0, %d-%d): ",
1396                         (int)d_info[tmp_dungeon_type].mindepth, (int)d_info[tmp_dungeon_type].maxdepth);
1397
1398                 /* Default */
1399                 sprintf(tmp_val, "%d", (int)creature_ptr->current_floor_ptr->dun_level);
1400
1401                 /* Ask for a level */
1402                 if (!get_string(ppp, tmp_val, 10)) return;
1403
1404                 /* Extract request */
1405                 command_arg = (COMMAND_ARG)atoi(tmp_val);
1406
1407                 creature_ptr->dungeon_idx = tmp_dungeon_type;
1408         }
1409
1410         if (command_arg < d_info[creature_ptr->dungeon_idx].mindepth) command_arg = 0;
1411         if (command_arg > d_info[creature_ptr->dungeon_idx].maxdepth) command_arg = (COMMAND_ARG)d_info[creature_ptr->dungeon_idx].maxdepth;
1412
1413         /* Accept request */
1414         msg_format("You jump to dungeon level %d.", command_arg);
1415
1416         if (autosave_l) do_cmd_save_game(TRUE);
1417
1418         /* Change level */
1419         creature_ptr->current_floor_ptr->dun_level = command_arg;
1420
1421         prepare_change_floor_mode(CFM_RAND_PLACE);
1422
1423         if (!creature_ptr->current_floor_ptr->dun_level) creature_ptr->dungeon_idx = 0;
1424         creature_ptr->current_floor_ptr->inside_arena = FALSE;
1425         creature_ptr->wild_mode = FALSE;
1426
1427         leave_quest_check();
1428
1429         if (record_stair) exe_write_diary(creature_ptr, NIKKI_WIZ_TELE, 0, NULL);
1430
1431         creature_ptr->current_floor_ptr->inside_quest = 0;
1432         free_turn(creature_ptr);
1433
1434         /* Prevent energy_need from being too lower than 0 */
1435         creature_ptr->energy_need = 0;
1436
1437         /*
1438          * Clear all saved floors
1439          * and create a first saved floor
1440          */
1441         prepare_change_floor_mode(CFM_FIRST_FLOOR);
1442         creature_ptr->leaving = TRUE;
1443 }
1444
1445
1446 /*!
1447  * @brief 全ベースアイテムを鑑定済みにする /
1448  * Become aware of a lot of objects
1449  * @return なし
1450  */
1451 static void do_cmd_wiz_learn(void)
1452 {
1453         /* Scan every object */
1454         object_type forge;
1455         object_type *q_ptr;
1456         for (KIND_OBJECT_IDX i = 1; i < max_k_idx; i++)
1457         {
1458                 object_kind *k_ptr = &k_info[i];
1459
1460                 /* Induce awareness */
1461                 if (k_ptr->level <= command_arg)
1462                 {
1463                         q_ptr = &forge;
1464                         object_prep(q_ptr, i);
1465                         object_aware(q_ptr);
1466                 }
1467         }
1468 }
1469
1470
1471 /*!
1472  * @brief 現在のフロアに合ったモンスターをランダムに召喚する /
1473  * Summon some creatures
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  * Hack -- Dump option bits usage
1640  * @return なし
1641  */
1642 static void do_cmd_dump_options(void)
1643 {
1644         char buf[1024];
1645         path_build(buf, sizeof buf, ANGBAND_DIR_USER, "opt_info.txt");
1646
1647         /* File type is "TEXT" */
1648         FILE *fff;
1649         FILE_TYPE(FILE_TYPE_TEXT);
1650         fff = my_fopen(buf, "a");
1651
1652         if (!fff)
1653         {
1654                 msg_format(_("ファイル %s を開けませんでした。", "Failed to open file %s."), buf);
1655                 msg_print(NULL);
1656                 return;
1657         }
1658
1659         /* Allocate the "exist" array (2-dimension) */
1660         int  **exist;
1661         C_MAKE(exist, NUM_O_SET, int *);
1662         C_MAKE(*exist, NUM_O_BIT * NUM_O_SET, int);
1663         for (int i = 1; i < NUM_O_SET; i++) exist[i] = *exist + i * NUM_O_BIT;
1664
1665         /* Check for exist option bits */
1666         for (int i = 0; option_info[i].o_desc; i++)
1667         {
1668                 const option_type *ot_ptr = &option_info[i];
1669                 if (ot_ptr->o_var) exist[ot_ptr->o_set][ot_ptr->o_bit] = i + 1;
1670         }
1671
1672         fprintf(fff, "[Option bits usage on Hengband %d.%d.%d]\n\n",
1673                 FAKE_VER_MAJOR - 10, FAKE_VER_MINOR, FAKE_VER_PATCH);
1674
1675         fputs("Set - Bit (Page) Option Name\n", fff);
1676         fputs("------------------------------------------------\n", fff);
1677
1678         /* Dump option bits usage */
1679         for (int i = 0; i < NUM_O_SET; i++)
1680         {
1681                 for (int j = 0; j < NUM_O_BIT; j++)
1682                 {
1683                         if (exist[i][j])
1684                         {
1685                                 const option_type *ot_ptr = &option_info[exist[i][j] - 1];
1686                                 fprintf(fff, "  %d -  %02d (%4d) %s\n",
1687                                         i, j, ot_ptr->o_page, ot_ptr->o_text);
1688                         }
1689                         else
1690                         {
1691                                 fprintf(fff, "  %d -  %02d\n", i, j);
1692                         }
1693                 }
1694
1695                 fputc('\n', fff);
1696         }
1697
1698         /* Free the "exist" array (2-dimension) */
1699         C_KILL(*exist, NUM_O_BIT * NUM_O_SET, int);
1700         C_KILL(exist, NUM_O_SET, int *);
1701         my_fclose(fff);
1702
1703         msg_format(_("オプションbit使用状況をファイル %s に書き出しました。", "Option bits usage dump saved to file %s."), buf);
1704 }
1705
1706
1707 /*!
1708  * @brief デバッグコマンドを選択する処理のメインルーチン /
1709  * Ask for and parse a "debug command"
1710  * The "command_arg" may have been set.
1711  * @return なし
1712  */
1713 void do_cmd_debug(player_type *creature_ptr)
1714 {
1715         char cmd;
1716         get_com("Debug Command: ", &cmd, FALSE);
1717
1718         switch (cmd)
1719         {
1720         case ESCAPE:
1721         case ' ':
1722         case '\n':
1723         case '\r':
1724                 break;
1725
1726 #ifdef ALLOW_SPOILERS
1727                 /* Hack -- Generate Spoilers */
1728         case '"':
1729                 do_cmd_spoilers();
1730                 break;
1731 #endif /* ALLOW_SPOILERS */
1732
1733                 /* Hack -- Help */
1734         case '?':
1735                 do_cmd_help();
1736                 break;
1737
1738                 /* Cure all maladies */
1739         case 'a':
1740                 do_cmd_wiz_cure_all(creature_ptr);
1741                 break;
1742
1743                 /* Know alignment */
1744         case 'A':
1745                 msg_format("Your alignment is %d.", creature_ptr->align);
1746                 break;
1747
1748                 /* Teleport to target */
1749         case 'b':
1750                 do_cmd_wiz_bamf(creature_ptr);
1751                 break;
1752
1753         case 'B':
1754                 update_gambling_monsters();
1755                 break;
1756
1757                 /* Create any object */
1758         case 'c':
1759                 wiz_create_item(creature_ptr);
1760                 break;
1761
1762                 /* Create a named artifact */
1763         case 'C':
1764                 wiz_create_named_art(creature_ptr);
1765                 break;
1766
1767                 /* Detect everything */
1768         case 'd':
1769                 detect_all(DETECT_RAD_ALL * 3);
1770                 break;
1771
1772                 /* Dimension_door */
1773         case 'D':
1774                 wiz_dimension_door(creature_ptr);
1775                 break;
1776
1777                 /* Edit character */
1778         case 'e':
1779                 do_cmd_wiz_change(creature_ptr);
1780                 break;
1781
1782                 /* Blue Mage Only */
1783         case 'E':
1784                 if (creature_ptr->pclass == CLASS_BLUE_MAGE)
1785                 {
1786                         do_cmd_wiz_blue_mage(creature_ptr);
1787                 }
1788                 break;
1789
1790                 /* View item info */
1791         case 'f':
1792                 identify_fully(FALSE);
1793                 break;
1794
1795                 /* Create desired feature */
1796         case 'F':
1797                 do_cmd_wiz_create_feature(creature_ptr);
1798                 break;
1799
1800                 /* Good Objects */
1801         case 'g':
1802                 if (command_arg <= 0) command_arg = 1;
1803                 acquirement(creature_ptr->y, creature_ptr->x, command_arg, FALSE, FALSE, TRUE);
1804                 break;
1805
1806                 /* Hitpoint rerating */
1807         case 'h':
1808                 roll_hitdice(creature_ptr, SPOP_DISPLAY_MES | SPOP_DEBUG);
1809                 break;
1810
1811         case 'H':
1812                 do_cmd_summon_horde(creature_ptr);
1813                 break;
1814
1815                 /* Identify */
1816         case 'i':
1817                 (void)ident_spell(creature_ptr, FALSE);
1818                 break;
1819
1820                 /* Go up or down in the dungeon */
1821         case 'j':
1822                 do_cmd_wiz_jump(creature_ptr);
1823                 break;
1824
1825                 /* Self-Knowledge */
1826         case 'k':
1827                 self_knowledge(creature_ptr);
1828                 break;
1829
1830                 /* Learn about objects */
1831         case 'l':
1832                 do_cmd_wiz_learn();
1833                 break;
1834
1835                 /* Magic Mapping */
1836         case 'm':
1837                 map_area(creature_ptr, DETECT_RAD_ALL * 3);
1838                 break;
1839
1840                 /* Mutation */
1841         case 'M':
1842                 (void)gain_mutation(creature_ptr, command_arg);
1843                 break;
1844
1845                 /* Reset Class */
1846         case 'R':
1847                 (void)do_cmd_wiz_reset_class(creature_ptr);
1848                 break;
1849
1850                 /* Specific reward */
1851         case 'r':
1852                 (void)gain_level_reward(creature_ptr, command_arg);
1853                 break;
1854
1855                 /* Summon _friendly_ named monster */
1856         case 'N':
1857                 do_cmd_wiz_named_friendly(creature_ptr, command_arg);
1858                 break;
1859
1860                 /* Summon Named Monster */
1861         case 'n':
1862                 do_cmd_wiz_named(creature_ptr, command_arg);
1863                 break;
1864
1865                 /* Dump option bits usage */
1866         case 'O':
1867                 do_cmd_dump_options();
1868                 break;
1869
1870                 /* Object playing routines */
1871         case 'o':
1872                 do_cmd_wiz_play(creature_ptr);
1873                 break;
1874
1875                 /* Phase Door */
1876         case 'p':
1877                 teleport_player(creature_ptr, 10, 0L);
1878                 break;
1879
1880                 /* Take a Quests */
1881         case 'Q':
1882         {
1883                 char ppp[30];
1884                 char tmp_val[5];
1885                 int tmp_int;
1886                 sprintf(ppp, "QuestID (0-%d):", max_q_idx - 1);
1887                 sprintf(tmp_val, "%d", 0);
1888
1889                 if (!get_string(ppp, tmp_val, 3)) return;
1890                 tmp_int = atoi(tmp_val);
1891
1892                 if (tmp_int < 0) break;
1893                 if (tmp_int >= max_q_idx) break;
1894
1895                 creature_ptr->current_floor_ptr->inside_quest = (QUEST_IDX)tmp_int;
1896                 process_dungeon_file("q_info.txt", 0, 0, 0, 0);
1897                 quest[tmp_int].status = QUEST_STATUS_TAKEN;
1898                 creature_ptr->current_floor_ptr->inside_quest = 0;
1899         }
1900
1901         break;
1902
1903         /* Complete a Quest -KMW- */
1904         case 'q':
1905                 if (creature_ptr->current_floor_ptr->inside_quest)
1906                 {
1907                         if (quest[creature_ptr->current_floor_ptr->inside_quest].status == QUEST_STATUS_TAKEN)
1908                         {
1909                                 complete_quest(creature_ptr->current_floor_ptr->inside_quest);
1910                                 break;
1911                         }
1912                 }
1913                 else
1914                 {
1915                         msg_print("No current quest");
1916                         msg_print(NULL);
1917                 }
1918
1919                 break;
1920
1921                 /* Make every dungeon square "known" to test streamers -KMW- */
1922         case 'u':
1923                 for (int y = 0; y < creature_ptr->current_floor_ptr->height; y++)
1924                 {
1925                         for (int x = 0; x < creature_ptr->current_floor_ptr->width; x++)
1926                         {
1927                                 creature_ptr->current_floor_ptr->grid_array[y][x].info |= (CAVE_GLOW | CAVE_MARK);
1928                         }
1929                 }
1930
1931                 wiz_lite(creature_ptr, FALSE);
1932                 break;
1933
1934                 /* Summon Random Monster(s) */
1935         case 's':
1936                 if (command_arg <= 0) command_arg = 1;
1937                 do_cmd_wiz_summon(creature_ptr, command_arg);
1938                 break;
1939
1940                 /* Special(Random Artifact) Objects */
1941         case 'S':
1942                 if (command_arg <= 0) command_arg = 1;
1943                 acquirement(creature_ptr->y, creature_ptr->x, command_arg, TRUE, TRUE, TRUE);
1944                 break;
1945
1946                 /* Teleport */
1947         case 't':
1948                 teleport_player(creature_ptr, 100, 0L);
1949                 break;
1950
1951                 /* Game Time Setting */
1952         case 'T':
1953                 set_gametime();
1954                 break;
1955
1956                 /* Very Good Objects */
1957         case 'v':
1958                 if (command_arg <= 0) command_arg = 1;
1959                 acquirement(creature_ptr->y, creature_ptr->x, command_arg, TRUE, FALSE, TRUE);
1960                 break;
1961
1962                 /* Wizard Light the Level */
1963         case 'w':
1964                 wiz_lite(creature_ptr, (bool)(creature_ptr->pclass == CLASS_NINJA));
1965                 break;
1966
1967                 /* Increase Experience */
1968         case 'x':
1969                 gain_exp(creature_ptr, command_arg ? command_arg : (creature_ptr->exp + 1));
1970                 break;
1971
1972                 /* Zap Monsters (Genocide) */
1973         case 'z':
1974                 do_cmd_wiz_zap(creature_ptr);
1975                 break;
1976
1977                 /* Zap Monsters (Omnicide) */
1978         case 'Z':
1979                 do_cmd_wiz_zap_all(creature_ptr);
1980                 break;
1981
1982                 /* Hack -- whatever I desire */
1983         case '_':
1984                 probing(creature_ptr);
1985                 break;
1986
1987                 /* For temporary test. */
1988         case 'X':
1989         {
1990                 INVENTORY_IDX i;
1991                 for (i = INVEN_TOTAL - 1; i >= 0; i--)
1992                 {
1993                         if (creature_ptr->inventory_list[i].k_idx) inven_drop(i, 999);
1994                 }
1995                 player_outfit(creature_ptr);
1996                 break;
1997         }
1998
1999         case 'V':
2000                 do_cmd_wiz_reset_class(creature_ptr);
2001                 break;
2002
2003         case '@':
2004                 do_cmd_debug_spell(creature_ptr);
2005                 break;
2006
2007         default:
2008                 msg_print("That is not a valid debug command.");
2009                 break;
2010         }
2011 }
2012
2013 #else
2014
2015 #ifdef MACINTOSH
2016 static int i = 0;
2017 #endif
2018
2019 #endif