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();
 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         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(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 o_ptr 変更するアイテム情報構造体の参照ポインタ
1125  * @return なし
1126  */
1127 static void wiz_quantity_item(object_type *o_ptr)
1128 {
1129         /* Never duplicate artifacts */
1130         if (object_is_artifact(o_ptr)) return;
1131
1132         /* Store old quantity. -LM- */
1133         int tmp_qnt = o_ptr->number;
1134
1135         /* Default */
1136         char tmp_val[100];
1137         sprintf(tmp_val, "%d", (int)o_ptr->number);
1138
1139         /* Query */
1140         if (get_string("Quantity: ", tmp_val, 2))
1141         {
1142                 /* Extract */
1143                 int tmp_int = atoi(tmp_val);
1144                 if (tmp_int < 1) tmp_int = 1;
1145                 if (tmp_int > 99) tmp_int = 99;
1146
1147                 /* Accept modifications */
1148                 o_ptr->number = (byte_hack)tmp_int;
1149         }
1150
1151         if (o_ptr->tval == TV_ROD)
1152         {
1153                 o_ptr->pval = o_ptr->pval * o_ptr->number / tmp_qnt;
1154         }
1155 }
1156
1157
1158 /*!
1159  * @brief 青魔導師の魔法を全て習得済みにする /
1160  * debug command for blue mage
1161  * @return なし
1162  */
1163 static void do_cmd_wiz_blue_mage(player_type *caster_ptr)
1164 {
1165         BIT_FLAGS f4 = 0L, f5 = 0L, f6 = 0L;
1166         for (int j = 1; j < A_MAX; j++)
1167         {
1168                 set_rf_masks(&f4, &f5, &f6, j);
1169
1170                 int i;
1171                 for (i = 0; i < 32; i++)
1172                 {
1173                         if ((0x00000001 << i) & f4) caster_ptr->magic_num2[i] = 1;
1174                 }
1175
1176                 for (; i < 64; i++)
1177                 {
1178                         if ((0x00000001 << (i - 32)) & f5) caster_ptr->magic_num2[i] = 1;
1179                 }
1180
1181                 for (; i < 96; i++)
1182                 {
1183                         if ((0x00000001 << (i - 64)) & f6) caster_ptr->magic_num2[i] = 1;
1184                 }
1185         }
1186 }
1187
1188
1189 /*!
1190  * @brief アイテム検査のメインルーチン /
1191  * Play with an item. Options include:
1192  * @return なし
1193  * @details
1194  *   - Output statistics (via wiz_roll_item)<br>
1195  *   - Reroll item (via wiz_reroll_item)<br>
1196  *   - Change properties (via wiz_tweak_item)<br>
1197  *   - Change the number of items (via wiz_quantity_item)<br>
1198  */
1199 static void do_cmd_wiz_play(player_type *creature_ptr)
1200 {
1201         concptr q = "Play with which object? ";
1202         concptr s = "You have nothing to play with.";
1203
1204         OBJECT_IDX item;
1205         object_type *o_ptr;
1206         o_ptr = choose_object(creature_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | USE_FLOOR | IGNORE_BOTHHAND_SLOT), 0);
1207
1208         if (!o_ptr) return;
1209
1210         screen_save();
1211
1212         object_type     forge;
1213         object_type *q_ptr;
1214         q_ptr = &forge;
1215         object_copy(q_ptr, o_ptr);
1216
1217         /* The main loop */
1218         char ch;
1219         bool changed = FALSE;
1220         while (TRUE)
1221         {
1222                 /* Display the item */
1223                 wiz_display_item(q_ptr);
1224
1225                 /* Get choice */
1226                 if (!get_com("[a]ccept [s]tatistics [r]eroll [t]weak [q]uantity? ", &ch, FALSE))
1227                 {
1228                         changed = FALSE;
1229                         break;
1230                 }
1231
1232                 if (ch == 'A' || ch == 'a')
1233                 {
1234                         changed = TRUE;
1235                         break;
1236                 }
1237
1238                 if (ch == 's' || ch == 'S')
1239                 {
1240                         wiz_statistics(creature_ptr, q_ptr);
1241                 }
1242
1243                 if (ch == 'r' || ch == 'r')
1244                 {
1245                         wiz_reroll_item(creature_ptr, q_ptr);
1246                 }
1247
1248                 if (ch == 't' || ch == 'T')
1249                 {
1250                         wiz_tweak_item(q_ptr);
1251                 }
1252
1253                 if (ch == 'q' || ch == 'Q')
1254                 {
1255                         wiz_quantity_item(q_ptr);
1256                 }
1257         }
1258
1259         screen_load();
1260
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();
1306
1307         /* Get object base type */
1308         OBJECT_IDX k_idx = wiz_create_itemtype();
1309
1310         screen_load();
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(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  * @return なし
1448  */
1449 static void do_cmd_wiz_learn(void)
1450 {
1451         /* Scan every object */
1452         object_type forge;
1453         object_type *q_ptr;
1454         for (KIND_OBJECT_IDX i = 1; i < max_k_idx; i++)
1455         {
1456                 object_kind *k_ptr = &k_info[i];
1457
1458                 /* Induce awareness */
1459                 if (k_ptr->level <= command_arg)
1460                 {
1461                         q_ptr = &forge;
1462                         object_prep(q_ptr, i);
1463                         object_aware(q_ptr);
1464                 }
1465         }
1466 }
1467
1468
1469 /*!
1470  * @brief 現在のフロアに合ったモンスターをランダムに召喚する /
1471  * Summon some creatures
1472  * @param num 生成処理回数
1473  * @return なし
1474  */
1475 static void do_cmd_wiz_summon(player_type *caster_ptr, int num)
1476 {
1477         for (int i = 0; i < num; i++)
1478         {
1479                 (void)summon_specific(0, caster_ptr->y, caster_ptr->x, caster_ptr->current_floor_ptr->dun_level, 0, (PM_ALLOW_GROUP | PM_ALLOW_UNIQUE));
1480         }
1481 }
1482
1483
1484 /*!
1485  * @brief モンスターを種族IDを指定して敵対的に召喚する /
1486  * Summon a creature of the specified type
1487  * @param r_idx モンスター種族ID
1488  * @return なし
1489  * @details
1490  * This function is rather dangerous
1491  */
1492 static void do_cmd_wiz_named(player_type *summoner_ptr, MONRACE_IDX r_idx)
1493 {
1494         (void)summon_named_creature(0, summoner_ptr->y, summoner_ptr->x, r_idx, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP));
1495 }
1496
1497
1498 /*!
1499  * @brief モンスターを種族IDを指定してペット召喚する /
1500  * Summon a creature of the specified type
1501  * @param r_idx モンスター種族ID
1502  * @return なし
1503  * @details
1504  * This function is rather dangerous
1505  */
1506 static void do_cmd_wiz_named_friendly(player_type *summoner_ptr, MONRACE_IDX r_idx)
1507 {
1508         (void)summon_named_creature(0, summoner_ptr->y, summoner_ptr->x, r_idx, (PM_ALLOW_SLEEP | PM_ALLOW_GROUP | PM_FORCE_PET));
1509 }
1510
1511
1512 /*!
1513  * @brief プレイヤー近辺の全モンスターを消去する /
1514  * Hack -- Delete all nearby monsters
1515  * @return なし
1516  */
1517 static void do_cmd_wiz_zap(player_type *caster_ptr)
1518 {
1519         /* Genocide everyone nearby */
1520         for (MONSTER_IDX i = 1; i < caster_ptr->current_floor_ptr->m_max; i++)
1521         {
1522                 monster_type *m_ptr = &caster_ptr->current_floor_ptr->m_list[i];
1523                 if (!monster_is_valid(m_ptr)) continue;
1524
1525                 /* Skip the mount */
1526                 if (i == caster_ptr->riding) continue;
1527
1528                 /* Delete nearby monsters */
1529                 if (m_ptr->cdis > MAX_SIGHT) continue;
1530
1531                 if (record_named_pet && is_pet(m_ptr) && m_ptr->nickname)
1532                 {
1533                         GAME_TEXT m_name[MAX_NLEN];
1534
1535                         monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
1536                         exe_write_diary(caster_ptr, NIKKI_NAMED_PET, RECORD_NAMED_PET_WIZ_ZAP, m_name);
1537                 }
1538
1539                 delete_monster_idx(i);
1540         }
1541 }
1542
1543
1544 /*!
1545  * @brief フロアに存在する全モンスターを消去する /
1546  * Hack -- Delete all monsters
1547  * @param caster_ptr 術者の参照ポインタ
1548  * @return なし
1549  */
1550 static void do_cmd_wiz_zap_all(player_type *caster_ptr)
1551 {
1552         /* Genocide everyone */
1553         for (MONSTER_IDX i = 1; i < caster_ptr->current_floor_ptr->m_max; i++)
1554         {
1555                 monster_type *m_ptr = &caster_ptr->current_floor_ptr->m_list[i];
1556                 if (!monster_is_valid(m_ptr)) continue;
1557
1558                 /* Skip the mount */
1559                 if (i == caster_ptr->riding) continue;
1560
1561                 if (record_named_pet && is_pet(m_ptr) && m_ptr->nickname)
1562                 {
1563                         GAME_TEXT m_name[MAX_NLEN];
1564
1565                         monster_desc(m_name, m_ptr, MD_INDEF_VISIBLE);
1566                         exe_write_diary(caster_ptr, NIKKI_NAMED_PET, RECORD_NAMED_PET_WIZ_ZAP, m_name);
1567                 }
1568
1569                 /* Delete this monster */
1570                 delete_monster_idx(i);
1571         }
1572 }
1573
1574
1575 /*!
1576  * @brief 指定された地点の地形IDを変更する /
1577  * Create desired feature
1578  * @param creaturer_ptr プレーヤーへの参照ポインタ
1579  * @return なし
1580  */
1581 static void do_cmd_wiz_create_feature(player_type *creature_ptr)
1582 {
1583         POSITION y, x;
1584         if (!tgt_pt(creature_ptr, &x, &y)) return;
1585
1586         grid_type *g_ptr;
1587         g_ptr = &creature_ptr->current_floor_ptr->grid_array[y][x];
1588
1589         /* Default */
1590         static int prev_feat = 0;
1591         char tmp_val[160];
1592         sprintf(tmp_val, "%d", prev_feat);
1593
1594         /* Query */
1595         if (!get_string(_("地形: ", "Feature: "), tmp_val, 3)) return;
1596
1597         /* Extract */
1598         FEAT_IDX tmp_feat = (FEAT_IDX)atoi(tmp_val);
1599         if (tmp_feat < 0) tmp_feat = 0;
1600         else if (tmp_feat >= max_f_idx) tmp_feat = max_f_idx - 1;
1601
1602         /* Default */
1603         static int prev_mimic = 0;
1604         sprintf(tmp_val, "%d", prev_mimic);
1605
1606         /* Query */
1607         if (!get_string(_("地形 (mimic): ", "Feature (mimic): "), tmp_val, 3)) return;
1608
1609         /* Extract */
1610         FEAT_IDX tmp_mimic = (FEAT_IDX)atoi(tmp_val);
1611         if (tmp_mimic < 0) tmp_mimic = 0;
1612         else if (tmp_mimic >= max_f_idx) tmp_mimic = max_f_idx - 1;
1613
1614         cave_set_feat(creature_ptr->current_floor_ptr, y, x, tmp_feat);
1615         g_ptr->mimic = (s16b)tmp_mimic;
1616
1617         feature_type *f_ptr;
1618         f_ptr = &f_info[get_feat_mimic(g_ptr)];
1619
1620         if (have_flag(f_ptr->flags, FF_GLYPH) ||
1621                 have_flag(f_ptr->flags, FF_MINOR_GLYPH))
1622                 g_ptr->info |= (CAVE_OBJECT);
1623         else if (have_flag(f_ptr->flags, FF_MIRROR))
1624                 g_ptr->info |= (CAVE_GLOW | CAVE_OBJECT);
1625
1626         note_spot(y, x);
1627         lite_spot(y, x);
1628         creature_ptr->update |= (PU_FLOW);
1629
1630         prev_feat = tmp_feat;
1631         prev_mimic = tmp_mimic;
1632 }
1633
1634
1635 /*!
1636  * @brief 現在のオプション設定をダンプ出力する /
1637  * Hack -- Dump option bits usage
1638  * @return なし
1639  */
1640 static void do_cmd_dump_options(void)
1641 {
1642         char buf[1024];
1643         path_build(buf, sizeof buf, ANGBAND_DIR_USER, "opt_info.txt");
1644
1645         /* File type is "TEXT" */
1646         FILE *fff;
1647         FILE_TYPE(FILE_TYPE_TEXT);
1648         fff = my_fopen(buf, "a");
1649
1650         if (!fff)
1651         {
1652                 msg_format(_("ファイル %s を開けませんでした。", "Failed to open file %s."), buf);
1653                 msg_print(NULL);
1654                 return;
1655         }
1656
1657         /* Allocate the "exist" array (2-dimension) */
1658         int  **exist;
1659         C_MAKE(exist, NUM_O_SET, int *);
1660         C_MAKE(*exist, NUM_O_BIT * NUM_O_SET, int);
1661         for (int i = 1; i < NUM_O_SET; i++) exist[i] = *exist + i * NUM_O_BIT;
1662
1663         /* Check for exist option bits */
1664         for (int i = 0; option_info[i].o_desc; i++)
1665         {
1666                 const option_type *ot_ptr = &option_info[i];
1667                 if (ot_ptr->o_var) exist[ot_ptr->o_set][ot_ptr->o_bit] = i + 1;
1668         }
1669
1670         fprintf(fff, "[Option bits usage on Hengband %d.%d.%d]\n\n",
1671                 FAKE_VER_MAJOR - 10, FAKE_VER_MINOR, FAKE_VER_PATCH);
1672
1673         fputs("Set - Bit (Page) Option Name\n", fff);
1674         fputs("------------------------------------------------\n", fff);
1675
1676         /* Dump option bits usage */
1677         for (int i = 0; i < NUM_O_SET; i++)
1678         {
1679                 for (int j = 0; j < NUM_O_BIT; j++)
1680                 {
1681                         if (exist[i][j])
1682                         {
1683                                 const option_type *ot_ptr = &option_info[exist[i][j] - 1];
1684                                 fprintf(fff, "  %d -  %02d (%4d) %s\n",
1685                                         i, j, ot_ptr->o_page, ot_ptr->o_text);
1686                         }
1687                         else
1688                         {
1689                                 fprintf(fff, "  %d -  %02d\n", i, j);
1690                         }
1691                 }
1692
1693                 fputc('\n', fff);
1694         }
1695
1696         /* Free the "exist" array (2-dimension) */
1697         C_KILL(*exist, NUM_O_BIT * NUM_O_SET, int);
1698         C_KILL(exist, NUM_O_SET, int *);
1699         my_fclose(fff);
1700
1701         msg_format(_("オプションbit使用状況をファイル %s に書き出しました。", "Option bits usage dump saved to file %s."), buf);
1702 }
1703
1704
1705 /*!
1706  * @brief デバッグコマンドを選択する処理のメインルーチン /
1707  * Ask for and parse a "debug command"
1708  * The "command_arg" may have been set.
1709  * @param creature_ptr プレーヤーへの参照ポインタ
1710  * @return なし
1711  */
1712 void do_cmd_debug(player_type *creature_ptr)
1713 {
1714         char cmd;
1715         get_com("Debug Command: ", &cmd, FALSE);
1716
1717         switch (cmd)
1718         {
1719         case ESCAPE:
1720         case ' ':
1721         case '\n':
1722         case '\r':
1723                 break;
1724
1725 #ifdef ALLOW_SPOILERS
1726                 /* Hack -- Generate Spoilers */
1727         case '"':
1728                 do_cmd_spoilers();
1729                 break;
1730 #endif /* ALLOW_SPOILERS */
1731
1732                 /* Hack -- Help */
1733         case '?':
1734                 do_cmd_help();
1735                 break;
1736
1737                 /* Cure all maladies */
1738         case 'a':
1739                 do_cmd_wiz_cure_all(creature_ptr);
1740                 break;
1741
1742                 /* Know alignment */
1743         case 'A':
1744                 msg_format("Your alignment is %d.", creature_ptr->align);
1745                 break;
1746
1747                 /* Teleport to target */
1748         case 'b':
1749                 do_cmd_wiz_bamf(creature_ptr);
1750                 break;
1751
1752         case 'B':
1753                 update_gambling_monsters();
1754                 break;
1755
1756                 /* Create any object */
1757         case 'c':
1758                 wiz_create_item(creature_ptr);
1759                 break;
1760
1761                 /* Create a named artifact */
1762         case 'C':
1763                 wiz_create_named_art(creature_ptr);
1764                 break;
1765
1766                 /* Detect everything */
1767         case 'd':
1768                 detect_all(creature_ptr, DETECT_RAD_ALL * 3);
1769                 break;
1770
1771                 /* Dimension_door */
1772         case 'D':
1773                 wiz_dimension_door(creature_ptr);
1774                 break;
1775
1776                 /* Edit character */
1777         case 'e':
1778                 do_cmd_wiz_change(creature_ptr);
1779                 break;
1780
1781                 /* Blue Mage Only */
1782         case 'E':
1783                 if (creature_ptr->pclass == CLASS_BLUE_MAGE)
1784                 {
1785                         do_cmd_wiz_blue_mage(creature_ptr);
1786                 }
1787                 break;
1788
1789                 /* View item info */
1790         case 'f':
1791                 identify_fully(creature_ptr, FALSE);
1792                 break;
1793
1794                 /* Create desired feature */
1795         case 'F':
1796                 do_cmd_wiz_create_feature(creature_ptr);
1797                 break;
1798
1799                 /* Good Objects */
1800         case 'g':
1801                 if (command_arg <= 0) command_arg = 1;
1802                 acquirement(creature_ptr, creature_ptr->y, creature_ptr->x, command_arg, FALSE, FALSE, TRUE);
1803                 break;
1804
1805                 /* Hitpoint rerating */
1806         case 'h':
1807                 roll_hitdice(creature_ptr, SPOP_DISPLAY_MES | SPOP_DEBUG);
1808                 break;
1809
1810         case 'H':
1811                 do_cmd_summon_horde(creature_ptr);
1812                 break;
1813
1814                 /* Identify */
1815         case 'i':
1816                 (void)ident_spell(creature_ptr, FALSE);
1817                 break;
1818
1819                 /* Go up or down in the dungeon */
1820         case 'j':
1821                 do_cmd_wiz_jump(creature_ptr);
1822                 break;
1823
1824                 /* Self-Knowledge */
1825         case 'k':
1826                 self_knowledge(creature_ptr);
1827                 break;
1828
1829                 /* Learn about objects */
1830         case 'l':
1831                 do_cmd_wiz_learn();
1832                 break;
1833
1834                 /* Magic Mapping */
1835         case 'm':
1836                 map_area(creature_ptr, DETECT_RAD_ALL * 3);
1837                 break;
1838
1839                 /* Mutation */
1840         case 'M':
1841                 (void)gain_mutation(creature_ptr, command_arg);
1842                 break;
1843
1844                 /* Reset Class */
1845         case 'R':
1846                 (void)do_cmd_wiz_reset_class(creature_ptr);
1847                 break;
1848
1849                 /* Specific reward */
1850         case 'r':
1851                 (void)gain_level_reward(creature_ptr, command_arg);
1852                 break;
1853
1854                 /* Summon _friendly_ named monster */
1855         case 'N':
1856                 do_cmd_wiz_named_friendly(creature_ptr, command_arg);
1857                 break;
1858
1859                 /* Summon Named Monster */
1860         case 'n':
1861                 do_cmd_wiz_named(creature_ptr, command_arg);
1862                 break;
1863
1864                 /* Dump option bits usage */
1865         case 'O':
1866                 do_cmd_dump_options();
1867                 break;
1868
1869                 /* Object playing routines */
1870         case 'o':
1871                 do_cmd_wiz_play(creature_ptr);
1872                 break;
1873
1874                 /* Phase Door */
1875         case 'p':
1876                 teleport_player(creature_ptr, 10, 0L);
1877                 break;
1878
1879                 /* Take a Quests */
1880         case 'Q':
1881         {
1882                 char ppp[30];
1883                 char tmp_val[5];
1884                 int tmp_int;
1885                 sprintf(ppp, "QuestID (0-%d):", max_q_idx - 1);
1886                 sprintf(tmp_val, "%d", 0);
1887
1888                 if (!get_string(ppp, tmp_val, 3)) return;
1889                 tmp_int = atoi(tmp_val);
1890
1891                 if (tmp_int < 0) break;
1892                 if (tmp_int >= max_q_idx) break;
1893
1894                 creature_ptr->current_floor_ptr->inside_quest = (QUEST_IDX)tmp_int;
1895                 process_dungeon_file(creature_ptr, "q_info.txt", 0, 0, 0, 0);
1896                 quest[tmp_int].status = QUEST_STATUS_TAKEN;
1897                 creature_ptr->current_floor_ptr->inside_quest = 0;
1898         }
1899
1900         break;
1901
1902         /* Complete a Quest -KMW- */
1903         case 'q':
1904                 if (creature_ptr->current_floor_ptr->inside_quest)
1905                 {
1906                         if (quest[creature_ptr->current_floor_ptr->inside_quest].status == QUEST_STATUS_TAKEN)
1907                         {
1908                                 complete_quest(creature_ptr->current_floor_ptr->inside_quest);
1909                                 break;
1910                         }
1911                 }
1912                 else
1913                 {
1914                         msg_print("No current quest");
1915                         msg_print(NULL);
1916                 }
1917
1918                 break;
1919
1920                 /* Make every dungeon square "known" to test streamers -KMW- */
1921         case 'u':
1922                 for (int y = 0; y < creature_ptr->current_floor_ptr->height; y++)
1923                 {
1924                         for (int x = 0; x < creature_ptr->current_floor_ptr->width; x++)
1925                         {
1926                                 creature_ptr->current_floor_ptr->grid_array[y][x].info |= (CAVE_GLOW | CAVE_MARK);
1927                         }
1928                 }
1929
1930                 wiz_lite(creature_ptr, FALSE);
1931                 break;
1932
1933                 /* Summon Random Monster(s) */
1934         case 's':
1935                 if (command_arg <= 0) command_arg = 1;
1936                 do_cmd_wiz_summon(creature_ptr, command_arg);
1937                 break;
1938
1939                 /* Special(Random Artifact) Objects */
1940         case 'S':
1941                 if (command_arg <= 0) command_arg = 1;
1942                 acquirement(creature_ptr, creature_ptr->y, creature_ptr->x, command_arg, TRUE, TRUE, TRUE);
1943                 break;
1944
1945                 /* Teleport */
1946         case 't':
1947                 teleport_player(creature_ptr, 100, 0L);
1948                 break;
1949
1950                 /* Game Time Setting */
1951         case 'T':
1952                 set_gametime();
1953                 break;
1954
1955                 /* Very Good Objects */
1956         case 'v':
1957                 if (command_arg <= 0) command_arg = 1;
1958                 acquirement(creature_ptr, creature_ptr->y, creature_ptr->x, command_arg, TRUE, FALSE, TRUE);
1959                 break;
1960
1961                 /* Wizard Light the Level */
1962         case 'w':
1963                 wiz_lite(creature_ptr, (bool)(creature_ptr->pclass == CLASS_NINJA));
1964                 break;
1965
1966                 /* Increase Experience */
1967         case 'x':
1968                 gain_exp(creature_ptr, command_arg ? command_arg : (creature_ptr->exp + 1));
1969                 break;
1970
1971                 /* Zap Monsters (Genocide) */
1972         case 'z':
1973                 do_cmd_wiz_zap(creature_ptr);
1974                 break;
1975
1976                 /* Zap Monsters (Omnicide) */
1977         case 'Z':
1978                 do_cmd_wiz_zap_all(creature_ptr);
1979                 break;
1980
1981                 /* Hack -- whatever I desire */
1982         case '_':
1983                 probing(creature_ptr);
1984                 break;
1985
1986                 /* For temporary test. */
1987         case 'X':
1988         {
1989                 INVENTORY_IDX i;
1990                 for (i = INVEN_TOTAL - 1; i >= 0; i--)
1991                 {
1992                         if (creature_ptr->inventory_list[i].k_idx) inven_drop(creature_ptr, i, 999);
1993                 }
1994                 player_outfit(creature_ptr);
1995                 break;
1996         }
1997
1998         case 'V':
1999                 do_cmd_wiz_reset_class(creature_ptr);
2000                 break;
2001
2002         case '@':
2003                 do_cmd_debug_spell(creature_ptr);
2004                 break;
2005
2006         default:
2007                 msg_print("That is not a valid debug command.");
2008                 break;
2009         }
2010 }
2011
2012 #else
2013
2014 #ifdef MACINTOSH
2015 static int i = 0;
2016 #endif
2017
2018 #endif