src/wizard2.c

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