src/bldg.c

   1 /*!
   2         @file bldg.c
   3         @brief 町の施設処理 / Building commands
   4         @date 2013/12/23
   5         @author
   6         Created by Ken Wigle for Kangband - a variant of Angband 2.8.3\n
   7         -KMW-\n
   8         \n
   9         Rewritten for Kangband 2.8.3i using Kamband's version of\n
  10         bldg.c as written by Ivan Tkatchev\n
  11         \n
  12         Changed for ZAngband by Robert Ruehlmann\n
  13 */
  14
  15 #include "angband.h"
  16 #include "util.h"
  17 #include "gameterm.h"
  18
  19 #include "core.h"
  20 #include "core/show-file.h"
  21 #include "io/write-diary.h"
  22 #include "cmd/cmd-dump.h"
  23 #include "cmd/cmd-magiceat.h"
  24 #include "floor.h"
  25 #include "floor-events.h"
  26 #include "floor-save.h"
  27 #include "autopick.h"
  28 #include "objectkind.h"
  29 #include "object-boost.h"
  30 #include "object-flavor.h"
  31 #include "object-hook.h"
  32 #include "monster.h"
  33 #include "monsterrace-hook.h"
  34 #include "melee.h"
  35 #include "wild.h"
  36 #include "world.h"
  37 #include "sort.h"
  38
  39 #include "avatar.h"
  40 #include "bldg.h"
  41 #include "dungeon.h"
  42 #include "mutation.h"
  43 #include "quest.h"
  44 #include "artifact.h"
  45 #include "cmd-spell.h"
  46 #include "rumor.h"
  47 #include "spells.h"
  48 #include "spells-object.h"
  49 #include "spells-status.h"
  50 #include "realm-hex.h"
  51 #include "dungeon-file.h"
  52
  53 #include "files.h"
  54 #include "player-status.h"
  55 #include "player-effects.h"
  56 #include "player-class.h"
  57 #include "player-personality.h"
  58 #include "player-inventory.h"
  59 #include "scores.h"
  60 #include "shoot.h"
  61 #include "view-mainwindow.h"
  62 #include "monsterrace.h"
  63 #include "autopick.h"
  64
  65 #include "market/poker.h"
  66
  67 /*
  68  * todo MAX_BLDGが定義されていない旨のエラーが出る……がコンパイルには成功する
  69  * Buildings
  70  */
  71 building_type building[MAX_BLDG];
  72
  73 MONRACE_IDX battle_mon[4];
  74 u32b mon_odds[4];
  75 int battle_odds;
  76 PRICE kakekin;
  77 int sel_monster;
  78
  79 bool reinit_wilderness = FALSE;
  80 MONSTER_IDX today_mon;
  81
  82 /*!
  83  * todo MAX_ARENA_MONSが定義されていない旨のエラーが出る……がコンパイルには成功する
  84  * @brief 闘技場のモンスターID及び報酬アイテムテーブル
  85  */
  86 const arena_type arena_info[MAX_ARENA_MONS + 2] =
  87 {
  88         { MON_NOBORTA,       TV_AMULET, SV_AMULET_ADORNMENT           },
  89         { MON_MORI_TROLL,    TV_FOOD,   SV_FOOD_PINT_OF_WINE          },
  90         { MON_IMP,           TV_POTION, SV_POTION_SPEED               },
  91         { MON_LION_HEART,    0,         0                             },
  92         { MON_MASTER_YEEK,   TV_POTION, SV_POTION_CURING              },
  93         { MON_SABRE_TIGER,   TV_WAND,   SV_WAND_STONE_TO_MUD          },
  94         { MON_LIZARD_KING,   TV_WAND,   SV_WAND_TELEPORT_AWAY         },
  95         { MON_WYVERN,        TV_POTION, SV_POTION_HEALING             },
  96         { MON_ARCH_VILE,     TV_POTION, SV_POTION_RESISTANCE          },
  97         { MON_ELF_LORD   ,   TV_POTION, SV_POTION_ENLIGHTENMENT       },
  98         { MON_GHOUL_KING,    TV_FOOD,   SV_FOOD_RESTORING             },
  99         { MON_COLBRAN,       TV_RING,   SV_RING_ELEC                  },
 100         { MON_BICLOPS,       TV_WAND,   SV_WAND_ACID_BALL             },
 101         { MON_M_MINDCRAFTER, TV_POTION, SV_POTION_SELF_KNOWLEDGE      },
 102         { MON_GROO,          TV_SCROLL, SV_SCROLL_ACQUIREMENT         },
 103         { MON_RAAL,          TV_SCROLL, SV_SCROLL_STAR_DESTRUCTION    },
 104         { MON_DREADMASTER,   TV_WAND,   SV_WAND_HYPODYNAMIA            },
 105         { MON_ULTRA_PALADIN, TV_STAFF,  SV_STAFF_DISPEL_EVIL          },
 106         { MON_BARNEY,        TV_RING,   SV_RING_RES_CHAOS             },
 107         { MON_TROLL_KING,    TV_SCROLL, SV_SCROLL_MASS_GENOCIDE       },
 108         { MON_BARON_HELL,    TV_POTION, SV_POTION_AUGMENTATION        },
 109         { MON_F_ANGEL,       TV_SCROLL, SV_SCROLL_RUNE_OF_PROTECTION  },
 110         { MON_G_C_DRAKE,     TV_WAND,   SV_WAND_DRAGON_FIRE           },
 111         { MON_IRON_LICH,     TV_STAFF,  SV_STAFF_DESTRUCTION          },
 112         { MON_DROLEM,        TV_POTION, SV_POTION_STAR_HEALING        },
 113         { MON_G_TITAN,       TV_WAND,   SV_WAND_GENOCIDE              },
 114         { MON_G_BALROG,      TV_POTION, SV_POTION_EXPERIENCE          },
 115         { MON_ELDER_VAMPIRE, TV_RING,   SV_RING_SUSTAIN               },
 116         { MON_NIGHTWALKER,   TV_WAND,   SV_WAND_STRIKING              },
 117         { MON_S_TYRANNO,     TV_SCROLL, SV_SCROLL_STAR_ACQUIREMENT    },
 118         { MON_G_MASTER_MYS,  TV_ROD,    SV_ROD_IDENTIFY               },
 119         { MON_LORD_CHAOS,    TV_POTION, SV_POTION_LIFE                },
 120         { MON_SHADOWLORD,    TV_POTION, SV_POTION_STAR_ENLIGHTENMENT  },
 121         { MON_ULT_BEHOLDER,  TV_AMULET, SV_AMULET_REFLECTION          },
 122         { MON_JABBERWOCK,    TV_ROD,    SV_ROD_HEALING                },
 123         { MON_LOCKE_CLONE,   TV_WAND,   SV_WAND_DISINTEGRATE          },
 124         { MON_WYRM_SPACE,    TV_ROD,    SV_ROD_RESTORATION            },
 125         { MON_SHAMBLER,      TV_SCROLL, SV_SCROLL_STAR_ACQUIREMENT    },
 126         { MON_BLACK_REAVER,  TV_RING,   SV_RING_LORDLY                },
 127         { MON_FENGHUANG,     TV_STAFF,  SV_STAFF_THE_MAGI             },
 128         { MON_WYRM_POWER,    TV_SCROLL, SV_SCROLL_ARTIFACT            },
 129         { 0,                 0,         0                             }, /* Victory prizing */
 130         { MON_HAGURE,        TV_SCROLL, SV_SCROLL_ARTIFACT            },
 131 };
 132
 133 /*!
 134  * @brief 施設毎に設定された種族、職業、魔法領域フラグがプレイヤーと一致するかを判定する。
 135  * @details 各種ギルドや寺院など、特定の職業ならば優遇措置を得られる施設、
 136  * あるいは食堂など特定の種族では利用できない施設の判定処理を行う。
 137  * @param player_ptr プレーヤーへの参照ポインタ
 138  * @param bldg 施設構造体の参照ポインタ
 139  * @return 種族、職業、魔法領域のいずれかが一致しているかの是非。
 140  */
 141 static bool is_owner(player_type *player_ptr, building_type *bldg)
 142 {
 143         if (bldg->member_class[player_ptr->pclass] == BUILDING_OWNER)
 144         {
 145                 return TRUE;
 146         }
 147
 148         if (bldg->member_race[player_ptr->prace] == BUILDING_OWNER)
 149         {
 150                 return TRUE;
 151         }
 152
 153         REALM_IDX realm1 = player_ptr->realm1;
 154         REALM_IDX realm2 = player_ptr->realm2;
 155         if ((is_magic(realm1) && (bldg->member_realm[realm1] == BUILDING_OWNER)) ||
 156                 (is_magic(realm2) && (bldg->member_realm[realm2] == BUILDING_OWNER)))
 157         {
 158                 return TRUE;
 159         }
 160
 161         return FALSE;
 162 }
 163
 164
 165 /*!
 166  * @brief 施設毎に設定された種族、職業、魔法領域フラグがプレイヤーと一致するかを判定する。
 167  （スペルマスターの特別判定つき）
 168  * @details 各種ギルドや寺院など、特定の職業ならば優遇措置を得られる施設、
 169  * あるいは食堂など特定の種族では利用できない施設の判定処理を行う。
 170  * @param player_ptr プレーヤーへの参照ポインタ
 171  * @param bldg 施設構造体の参照ポインタ
 172  * @return 種族、職業、魔法領域のいずれかが一致しているかの是非。
 173  * @todo is_owner()との実質的な多重実装なので、リファクタリングを行うべきである。
 174  */
 175 static bool is_member(player_type *player_ptr, building_type *bldg)
 176 {
 177         if (bldg->member_class[player_ptr->pclass])
 178         {
 179                 return TRUE;
 180         }
 181
 182         if (bldg->member_race[player_ptr->prace])
 183         {
 184                 return TRUE;
 185         }
 186
 187         REALM_IDX realm1 = player_ptr->realm1;
 188         REALM_IDX realm2 = player_ptr->realm2;
 189         if ((is_magic(realm1) && bldg->member_realm[realm1]) ||
 190                 (is_magic(realm2) && bldg->member_realm[realm2]))
 191         {
 192                 return TRUE;
 193         }
 194
 195         if (player_ptr->pclass != CLASS_SORCERER) return FALSE;
 196
 197         for (int i = 0; i < MAX_MAGIC; i++)
 198         {
 199                 if (bldg->member_realm[i + 1]) return TRUE;
 200         }
 201
 202         return FALSE;
 203 }
 204
 205
 206 /*!
 207  * @brief コンソールに表示された施設に関する情報を消去する / Clear the building information
 208  * @details 消去は行毎にヌル文字列で行われる。
 209  * @param min_row 開始行番号
 210  * @param max_row 末尾行番号
 211  * @return なし
 212  */
 213 void clear_bldg(int min_row, int max_row)
 214 {
 215         for (int i = min_row; i <= max_row; i++)
 216         {
 217                 prt("", i, 0);
 218         }
 219 }
 220
 221
 222 /*!
 223  * @brief 所持金を表示する。
 224  * @param player_ptr プレーヤーへの参照ポインタ
 225  * @return なし
 226  */
 227 static void building_prt_gold(player_type *player_ptr)
 228 {
 229         char tmp_str[80];
 230         prt(_("手持ちのお金: ", "Gold Remaining: "), 23, 53);
 231         sprintf(tmp_str, "%9ld", (long)player_ptr->au);
 232         prt(tmp_str, 23, 68);
 233 }
 234
 235
 236 /*!
 237  * @brief 施設のサービス一覧を表示する / Display a building.
 238  * @param player_ptr プレーヤーへの参照ポインタ
 239  * @param bldg 施設構造体の参照ポインタ
 240  * @return なし
 241  */
 242 static void show_building(player_type *player_ptr, building_type* bldg)
 243 {
 244         char buff[20];
 245         byte action_color;
 246         char tmp_str[80];
 247
 248         Term_clear();
 249         sprintf(tmp_str, "%s (%s) %35s", bldg->owner_name, bldg->owner_race, bldg->name);
 250         prt(tmp_str, 2, 1);
 251
 252         for (int i = 0; i < 8; i++)
 253         {
 254                 if (!bldg->letters[i]) continue;
 255
 256                 if (bldg->action_restr[i] == 0)
 257                 {
 258                         if ((is_owner(player_ptr, bldg) && (bldg->member_costs[i] == 0)) ||
 259                                 (!is_owner(player_ptr, bldg) && (bldg->other_costs[i] == 0)))
 260                         {
 261                                 action_color = TERM_WHITE;
 262                                 buff[0] = '\0';
 263                         }
 264                         else if (is_owner(player_ptr, bldg))
 265                         {
 266                                 action_color = TERM_YELLOW;
 267                                 sprintf(buff, _("($%ld)", "(%ldgp)"), (long int)bldg->member_costs[i]);
 268                         }
 269                         else
 270                         {
 271                                 action_color = TERM_YELLOW;
 272                                 sprintf(buff, _("($%ld)", "(%ldgp)"), (long int)bldg->other_costs[i]);
 273                         }
 274
 275                         sprintf(tmp_str, " %c) %s %s", bldg->letters[i], bldg->act_names[i], buff);
 276                         c_put_str(action_color, tmp_str, 19 + (i / 2), 35 * (i % 2));
 277                         continue;
 278                 }
 279
 280                 if (bldg->action_restr[i] == 1)
 281                 {
 282                         if (!is_member(player_ptr, bldg))
 283                         {
 284                                 action_color = TERM_L_DARK;
 285                                 strcpy(buff, _("(閉店)", "(closed)"));
 286                         }
 287                         else if ((is_owner(player_ptr, bldg) && (bldg->member_costs[i] == 0)) ||
 288                                 (is_member(player_ptr, bldg) && (bldg->other_costs[i] == 0)))
 289                         {
 290                                 action_color = TERM_WHITE;
 291                                 buff[0] = '\0';
 292                         }
 293                         else if (is_owner(player_ptr, bldg))
 294                         {
 295                                 action_color = TERM_YELLOW;
 296                                 sprintf(buff, _("($%ld)", "(%ldgp)"), (long int)bldg->member_costs[i]);
 297                         }
 298                         else
 299                         {
 300                                 action_color = TERM_YELLOW;
 301                                 sprintf(buff, _("($%ld)", "(%ldgp)"), (long int)bldg->other_costs[i]);
 302                         }
 303
 304                         sprintf(tmp_str, " %c) %s %s", bldg->letters[i], bldg->act_names[i], buff);
 305                         c_put_str(action_color, tmp_str, 19 + (i / 2), 35 * (i % 2));
 306                         continue;
 307                 }
 308
 309                 if (!is_owner(player_ptr, bldg))
 310                 {
 311                         action_color = TERM_L_DARK;
 312                         strcpy(buff, _("(閉店)", "(closed)"));
 313                 }
 314                 else if (bldg->member_costs[i] != 0)
 315                 {
 316                         action_color = TERM_YELLOW;
 317                         sprintf(buff, _("($%ld)", "(%ldgp)"), (long int)bldg->member_costs[i]);
 318                 }
 319                 else
 320                 {
 321                         action_color = TERM_WHITE;
 322                         buff[0] = '\0';
 323                 }
 324
 325                 sprintf(tmp_str, " %c) %s %s", bldg->letters[i], bldg->act_names[i], buff);
 326                 c_put_str(action_color, tmp_str, 19 + (i / 2), 35 * (i % 2));
 327         }
 328
 329         prt(_(" ESC) 建物を出る", " ESC) Exit building"), 23, 0);
 330 }
 331
 332
 333 /*!
 334  * @brief 闘技場に入るコマンドの処理 / arena commands
 335  * @param player_ptr プレーヤーへの参照ポインタ
 336  * @param cmd 闘技場処理のID
 337  * @return なし
 338  */
 339 static void arena_comm(player_type *player_ptr, int cmd)
 340 {
 341         monster_race    *r_ptr;
 342         concptr            name;
 343
 344         switch (cmd)
 345         {
 346         case BACT_ARENA:
 347                 if (player_ptr->arena_number == MAX_ARENA_MONS)
 348                 {
 349                         clear_bldg(5, 19);
 350                         prt(_("アリーナの優勝者！", "               Arena Victor!"), 5, 0);
 351                         prt(_("おめでとう！あなたは全ての敵を倒しました。", "Congratulations!  You have defeated all before you."), 7, 0);
 352                         prt(_("賞金として $1,000,000 が与えられます。", "For that, receive the prize: 1,000,000 gold pieces"), 8, 0);
 353
 354                         prt("", 10, 0);
 355                         prt("", 11, 0);
 356                         player_ptr->au += 1000000L;
 357                         msg_print(_("スペースキーで続行", "Press the space bar to continue"));
 358                         msg_print(NULL);
 359                         player_ptr->arena_number++;
 360                         break;
 361                 }
 362
 363                 if (player_ptr->arena_number > MAX_ARENA_MONS)
 364                 {
 365                         if (player_ptr->arena_number < MAX_ARENA_MONS + 2)
 366                         {
 367                                 msg_print(_("君のために最強の挑戦者を用意しておいた。", "The strongest challenger is waiting for you."));
 368                                 msg_print(NULL);
 369                                 if (get_check(_("挑戦するかね？", "Do you fight? ")))
 370                                 {
 371                                         msg_print(_("死ぬがよい。", "Die, maggots."));
 372                                         msg_print(NULL);
 373
 374                                         player_ptr->exit_bldg = FALSE;
 375                                         reset_tim_flags(player_ptr);
 376
 377                                         /* Save the surface floor as saved floor */
 378                                         prepare_change_floor_mode(player_ptr, CFM_SAVE_FLOORS);
 379
 380                                         player_ptr->current_floor_ptr->inside_arena = TRUE;
 381                                         player_ptr->leaving = TRUE;
 382                                         player_ptr->leave_bldg = TRUE;
 383                                 }
 384                                 else
 385                                 {
 386                                         msg_print(_("残念だ。", "We are disappointed."));
 387                                 }
 388                         }
 389                         else
 390                         {
 391                                 msg_print(_("あなたはアリーナに入り、しばらくの間栄光にひたった。",
 392                                         "You enter the arena briefly and bask in your glory."));
 393                                 msg_print(NULL);
 394                         }
 395
 396                         break;
 397                 }
 398
 399                 if (player_ptr->riding && (player_ptr->pclass != CLASS_BEASTMASTER) && (player_ptr->pclass != CLASS_CAVALRY))
 400                 {
 401                         msg_print(_("ペットに乗ったままではアリーナへ入れさせてもらえなかった。",
 402                                 "You don't have permission to enter with pet."));
 403                         msg_print(NULL);
 404                         break;
 405                 }
 406
 407                 player_ptr->exit_bldg = FALSE;
 408                 reset_tim_flags(player_ptr);
 409                 prepare_change_floor_mode(player_ptr, CFM_SAVE_FLOORS);
 410
 411                 player_ptr->current_floor_ptr->inside_arena = TRUE;
 412                 player_ptr->leaving = TRUE;
 413                 player_ptr->leave_bldg = TRUE;
 414                 break;
 415         case BACT_POSTER:
 416                 if (player_ptr->arena_number == MAX_ARENA_MONS)
 417                 {
 418                         msg_print(_("あなたは勝利者だ。 アリーナでのセレモニーに参加しなさい。",
 419                                 "You are victorious. Enter the arena for the ceremony."));
 420                         break;
 421                 }
 422
 423                 if (player_ptr->arena_number > MAX_ARENA_MONS)
 424                 {
 425                         msg_print(_("あなたはすべての敵に勝利した。", "You have won against all foes."));
 426                         break;
 427                 }
 428
 429                 r_ptr = &r_info[arena_info[player_ptr->arena_number].r_idx];
 430                 name = (r_name + r_ptr->name);
 431                 msg_format(_("%s に挑戦するものはいないか？", "Do I hear any challenges against: %s"), name);
 432
 433                 player_ptr->monster_race_idx = arena_info[player_ptr->arena_number].r_idx;
 434                 player_ptr->window |= (PW_MONSTER);
 435                 handle_stuff(player_ptr);
 436                 break;
 437         case BACT_ARENA_RULES:
 438                 screen_save();
 439
 440                 /* Peruse the arena help file */
 441                 (void)show_file(player_ptr, TRUE, _("arena_j.txt", "arena.txt"), NULL, 0, 0);
 442                 screen_load();
 443                 break;
 444         }
 445 }
 446
 447
 448 /*!
 449  * @brief カジノのスロットシンボルを表示する / display fruit for dice slots
 450  * @param row シンボルを表示する行の上端
 451  * @param col シンボルを表示する行の左端
 452  * @param fruit 表示するシンボルID
 453  * @return なし
 454  */
 455 static void display_fruit(int row, int col, int fruit)
 456 {
 457         switch (fruit)
 458         {
 459         case 0: /* lemon */
 460                 c_put_str(TERM_YELLOW, "   ####.", row, col);
 461                 c_put_str(TERM_YELLOW, "  #    #", row + 1, col);
 462                 c_put_str(TERM_YELLOW, " #     #", row + 2, col);
 463                 c_put_str(TERM_YELLOW, "#      #", row + 3, col);
 464                 c_put_str(TERM_YELLOW, "#      #", row + 4, col);
 465                 c_put_str(TERM_YELLOW, "#     # ", row + 5, col);
 466                 c_put_str(TERM_YELLOW, "#    #  ", row + 6, col);
 467                 c_put_str(TERM_YELLOW, ".####   ", row + 7, col);
 468                 prt(_(" レモン ",
 469                         " Lemon  "), row + 8, col);
 470                 break;
 471         case 1: /* orange */
 472                 c_put_str(TERM_ORANGE, "   ##   ", row, col);
 473                 c_put_str(TERM_ORANGE, "  #..#  ", row + 1, col);
 474                 c_put_str(TERM_ORANGE, " #....# ", row + 2, col);
 475                 c_put_str(TERM_ORANGE, "#......#", row + 3, col);
 476                 c_put_str(TERM_ORANGE, "#......#", row + 4, col);
 477                 c_put_str(TERM_ORANGE, " #....# ", row + 5, col);
 478                 c_put_str(TERM_ORANGE, "  #..#  ", row + 6, col);
 479                 c_put_str(TERM_ORANGE, "   ##   ", row + 7, col);
 480                 prt(_("オレンジ",
 481                         " Orange "), row + 8, col);
 482                 break;
 483         case 2: /* sword */
 484                 c_put_str(TERM_SLATE, _("   Λ   ", "   /\\   "), row, col);
 485                 c_put_str(TERM_SLATE, _("   ||   ", "   ##   "), row + 1, col);
 486                 c_put_str(TERM_SLATE, _("   ||   ", "   ##   "), row + 2, col);
 487                 c_put_str(TERM_SLATE, _("   ||   ", "   ##   "), row + 3, col);
 488                 c_put_str(TERM_SLATE, _("   ||   ", "   ##   "), row + 4, col);
 489                 c_put_str(TERM_SLATE, _("   ||   ", "   ##   "), row + 5, col);
 490                 c_put_str(TERM_UMBER, _(" |=亜=| ", " ###### "), row + 6, col);
 491                 c_put_str(TERM_UMBER, _("   目   ", "   ##   "), row + 7, col);
 492                 prt(_("   剣   ", " Sword  "), row + 8, col);
 493                 break;
 494         case 3: /* shield */
 495                 c_put_str(TERM_SLATE, " ###### ", row, col);
 496                 c_put_str(TERM_SLATE, "#      #", row + 1, col);
 497                 c_put_str(TERM_SLATE, "# ++++ #", row + 2, col);
 498                 c_put_str(TERM_SLATE, "# +==+ #", row + 3, col);
 499                 c_put_str(TERM_SLATE, "#  ++  #", row + 4, col);
 500                 c_put_str(TERM_SLATE, " #    # ", row + 5, col);
 501                 c_put_str(TERM_SLATE, "  #  #  ", row + 6, col);
 502                 c_put_str(TERM_SLATE, "   ##   ", row + 7, col);
 503                 prt(_("   盾   ",
 504                         " Shield "), row + 8, col);
 505                 break;
 506         case 4: /* plum */
 507                 c_put_str(TERM_VIOLET, "   ##   ", row, col);
 508                 c_put_str(TERM_VIOLET, " ###### ", row + 1, col);
 509                 c_put_str(TERM_VIOLET, "########", row + 2, col);
 510                 c_put_str(TERM_VIOLET, "########", row + 3, col);
 511                 c_put_str(TERM_VIOLET, "########", row + 4, col);
 512                 c_put_str(TERM_VIOLET, " ###### ", row + 5, col);
 513                 c_put_str(TERM_VIOLET, "  ####  ", row + 6, col);
 514                 c_put_str(TERM_VIOLET, "   ##   ", row + 7, col);
 515                 prt(_(" プラム ",
 516                         "  Plum  "), row + 8, col);
 517                 break;
 518         case 5: /* cherry */
 519                 c_put_str(TERM_RED, "      ##", row, col);
 520                 c_put_str(TERM_RED, "   ###  ", row + 1, col);
 521                 c_put_str(TERM_RED, "  #..#  ", row + 2, col);
 522                 c_put_str(TERM_RED, "  #..#  ", row + 3, col);
 523                 c_put_str(TERM_RED, " ###### ", row + 4, col);
 524                 c_put_str(TERM_RED, "#..##..#", row + 5, col);
 525                 c_put_str(TERM_RED, "#..##..#", row + 6, col);
 526                 c_put_str(TERM_RED, " ##  ## ", row + 7, col);
 527                 prt(_("チェリー",
 528                         " Cherry "), row + 8, col);
 529                 break;
 530         }
 531 }
 532
 533
 534 /*!
 535  * @brief カジノ1プレイごとのメインルーチン / gamble_comm
 536  * @param player_ptr プレーヤーへの参照ポインタ
 537  * @param cmd プレイするゲームID
 538  * @return なし
 539  */
 540 static bool gamble_comm(player_type *player_ptr, int cmd)
 541 {
 542         int i;
 543         int roll1, roll2, roll3, choice, odds, win;
 544         s32b wager;
 545         s32b maxbet;
 546         s32b oldgold;
 547
 548         char out_val[160], tmp_str[80], again;
 549         concptr p;
 550
 551         screen_save();
 552
 553         if (cmd == BACT_GAMBLE_RULES)
 554         {
 555                 (void)show_file(player_ptr, TRUE, _("jgambling.txt", "gambling.txt"), NULL, 0, 0);
 556                 screen_load();
 557                 return TRUE;
 558         }
 559
 560         if (player_ptr->au < 1)
 561         {
 562                 msg_print(_("おい！おまえ一文なしじゃないか！こっから出ていけ！",
 563                         "Hey! You don't have gold - get out of here!"));
 564                 msg_print(NULL);
 565                 screen_load();
 566                 return FALSE;
 567         }
 568
 569         clear_bldg(5, 23);
 570         maxbet = player_ptr->lev * 200;
 571         maxbet = MIN(maxbet, player_ptr->au);
 572
 573         strcpy(out_val, "");
 574         sprintf(tmp_str, _("賭け金 (1-%ld)？", "Your wager (1-%ld) ? "), (long int)maxbet);
 575
 576
 577         /*
 578          * Use get_string() because we may need more than
 579          * the s16b value returned by get_quantity().
 580          */
 581         if (!get_string(tmp_str, out_val, 32))
 582         {
 583                 msg_print(NULL);
 584                 screen_load();
 585                 return TRUE;
 586         }
 587
 588         for (p = out_val; *p == ' '; p++);
 589
 590         wager = atol(p);
 591         if (wager > player_ptr->au)
 592         {
 593                 msg_print(_("おい！金が足りないじゃないか！出ていけ！", "Hey! You don't have the gold - get out of here!"));
 594                 msg_print(NULL);
 595                 screen_load();
 596                 return FALSE;
 597         }
 598         else if (wager > maxbet)
 599         {
 600                 msg_format(_("%ldゴールドだけ受けよう。残りは取っときな。",
 601                         "I'll take %ld gold of that. Keep the rest."), (long int)maxbet);
 602                 wager = maxbet;
 603         }
 604         else if (wager < 1)
 605         {
 606                 msg_print(_("ＯＫ、１ゴールドからはじめよう。", "Ok, we'll start with 1 gold."));
 607                 wager = 1;
 608         }
 609         msg_print(NULL);
 610         win = FALSE;
 611         odds = 0;
 612         oldgold = player_ptr->au;
 613
 614         sprintf(tmp_str, _("ゲーム前の所持金: %9ld", "Gold before game: %9ld"), (long int)oldgold);
 615         prt(tmp_str, 20, 2);
 616         sprintf(tmp_str, _("現在の掛け金:     %9ld", "Current Wager:    %9ld"), (long int)wager);
 617         prt(tmp_str, 21, 2);
 618
 619         do
 620         {
 621                 player_ptr->au -= wager;
 622                 switch (cmd)
 623                 {
 624                 case BACT_IN_BETWEEN: /* Game of In-Between */
 625                         c_put_str(TERM_GREEN, _("イン・ビトイーン", "In Between"), 5, 2);
 626
 627                         odds = 4;
 628                         win = FALSE;
 629                         roll1 = randint1(10);
 630                         roll2 = randint1(10);
 631                         choice = randint1(10);
 632                         sprintf(tmp_str, _("黒ダイス: %d        黒ダイス: %d", "Black die: %d       Black Die: %d"), roll1, roll2);
 633
 634                         prt(tmp_str, 8, 3);
 635                         sprintf(tmp_str, _("赤ダイス: %d", "Red die: %d"), choice);
 636
 637                         prt(tmp_str, 11, 14);
 638                         if (((choice > roll1) && (choice < roll2)) ||
 639                                 ((choice < roll1) && (choice > roll2)))
 640                                 win = TRUE;
 641                         break;
 642                 case BACT_CRAPS:  /* Game of Craps */
 643                         c_put_str(TERM_GREEN, _("クラップス", "Craps"), 5, 2);
 644
 645                         win = 3;
 646                         odds = 2;
 647                         roll1 = randint1(6);
 648                         roll2 = randint1(6);
 649                         roll3 = roll1 + roll2;
 650                         choice = roll3;
 651                         sprintf(tmp_str, _("１振りめ: %d %d      Total: %d",
 652                                 "First roll: %d %d    Total: %d"), roll1, roll2, roll3);
 653                         prt(tmp_str, 7, 5);
 654                         if ((roll3 == 7) || (roll3 == 11))
 655                                 win = TRUE;
 656                         else if ((roll3 == 2) || (roll3 == 3) || (roll3 == 12))
 657                                 win = FALSE;
 658                         else
 659                         {
 660                                 do
 661                                 {
 662                                         msg_print(_("なにかキーを押すともう一回振ります。", "Hit any key to roll again"));
 663
 664                                         msg_print(NULL);
 665                                         roll1 = randint1(6);
 666                                         roll2 = randint1(6);
 667                                         roll3 = roll1 + roll2;
 668                                         sprintf(tmp_str, _("出目: %d %d          合計:      %d",
 669                                                 "Roll result: %d %d   Total:     %d"), roll1, roll2, roll3);
 670                                         prt(tmp_str, 8, 5);
 671                                         if (roll3 == choice)
 672                                                 win = TRUE;
 673                                         else if (roll3 == 7)
 674                                                 win = FALSE;
 675                                 } while ((win != TRUE) && (win != FALSE));
 676                         }
 677
 678                         break;
 679
 680                 case BACT_SPIN_WHEEL:  /* Spin the Wheel Game */
 681                         win = FALSE;
 682                         odds = 9;
 683                         c_put_str(TERM_GREEN, _("ルーレット", "Wheel"), 5, 2);
 684
 685                         prt("0  1  2  3  4  5  6  7  8  9", 7, 5);
 686                         prt("--------------------------------", 8, 3);
 687                         strcpy(out_val, "");
 688                         get_string(_("何番？ (0-9): ", "Pick a number (0-9): "), out_val, 32);
 689
 690                         for (p = out_val; iswspace(*p); p++);
 691                         choice = atol(p);
 692                         if (choice < 0)
 693                         {
 694                                 msg_print(_("0番にしとくぜ。", "I'll put you down for 0."));
 695                                 choice = 0;
 696                         }
 697                         else if (choice > 9)
 698                         {
 699                                 msg_print(_("ＯＫ、9番にしとくぜ。", "Ok, I'll put you down for 9."));
 700                                 choice = 9;
 701                         }
 702                         msg_print(NULL);
 703                         roll1 = randint0(10);
 704                         sprintf(tmp_str, _("ルーレットは回り、止まった。勝者は %d番だ。",
 705                                 "The wheel spins to a stop and the winner is %d"), roll1);
 706                         prt(tmp_str, 13, 3);
 707                         prt("", 9, 0);
 708                         prt("*", 9, (3 * roll1 + 5));
 709                         if (roll1 == choice)
 710                                 win = TRUE;
 711                         break;
 712
 713                 case BACT_DICE_SLOTS: /* The Dice Slots */
 714                         c_put_str(TERM_GREEN, _("ダイス・スロット", "Dice Slots"), 5, 2);
 715                         c_put_str(TERM_YELLOW, _("レモン   レモン            2", ""), 6, 37);
 716                         c_put_str(TERM_YELLOW, _("レモン   レモン   レモン   5", ""), 7, 37);
 717                         c_put_str(TERM_ORANGE, _("オレンジ オレンジ オレンジ 10", ""), 8, 37);
 718                         c_put_str(TERM_UMBER, _("剣       剣       剣       20", ""), 9, 37);
 719                         c_put_str(TERM_SLATE, _("盾       盾       盾       50", ""), 10, 37);
 720                         c_put_str(TERM_VIOLET, _("プラム   プラム   プラム   200", ""), 11, 37);
 721                         c_put_str(TERM_RED, _("チェリー チェリー チェリー 1000", ""), 12, 37);
 722
 723                         win = FALSE;
 724                         roll1 = randint1(21);
 725                         for (i = 6; i > 0; i--)
 726                         {
 727                                 if ((roll1 - i) < 1)
 728                                 {
 729                                         roll1 = 7 - i;
 730                                         break;
 731                                 }
 732                                 roll1 -= i;
 733                         }
 734                         roll2 = randint1(21);
 735                         for (i = 6; i > 0; i--)
 736                         {
 737                                 if ((roll2 - i) < 1)
 738                                 {
 739                                         roll2 = 7 - i;
 740                                         break;
 741                                 }
 742                                 roll2 -= i;
 743                         }
 744                         choice = randint1(21);
 745                         for (i = 6; i > 0; i--)
 746                         {
 747                                 if ((choice - i) < 1)
 748                                 {
 749                                         choice = 7 - i;
 750                                         break;
 751                                 }
 752                                 choice -= i;
 753                         }
 754                         put_str("/--------------------------\\", 7, 2);
 755                         prt("\\--------------------------/", 17, 2);
 756                         display_fruit(8, 3, roll1 - 1);
 757                         display_fruit(8, 12, roll2 - 1);
 758                         display_fruit(8, 21, choice - 1);
 759                         if ((roll1 == roll2) && (roll2 == choice))
 760                         {
 761                                 win = TRUE;
 762                                 switch (roll1)
 763                                 {
 764                                 case 1:
 765                                         odds = 5; break;
 766                                 case 2:
 767                                         odds = 10; break;
 768                                 case 3:
 769                                         odds = 20; break;
 770                                 case 4:
 771                                         odds = 50; break;
 772                                 case 5:
 773                                         odds = 200; break;
 774                                 case 6:
 775                                         odds = 1000; break;
 776                                 }
 777                         }
 778                         else if ((roll1 == 1) && (roll2 == 1))
 779                         {
 780                                 win = TRUE;
 781                                 odds = 2;
 782                         }
 783                         break;
 784                 case BACT_POKER:
 785                         win = FALSE;
 786                         odds = do_poker();
 787                         if (odds) win = TRUE;
 788                         break;
 789                 }
 790
 791                 if (win)
 792                 {
 793                         prt(_("あなたの勝ち", "YOU WON"), 16, 37);
 794
 795                         player_ptr->au += odds * wager;
 796                         sprintf(tmp_str, _("倍率: %d", "Payoff: %d"), odds);
 797
 798                         prt(tmp_str, 17, 37);
 799                 }
 800                 else
 801                 {
 802                         prt(_("あなたの負け", "You Lost"), 16, 37);
 803                         prt("", 17, 37);
 804                 }
 805
 806                 sprintf(tmp_str, _("現在の所持金:     %9ld", "Current Gold:     %9ld"), (long int)player_ptr->au);
 807
 808                 prt(tmp_str, 22, 2);
 809                 prt(_("もう一度(Y/N)？", "Again(Y/N)?"), 18, 37);
 810
 811                 move_cursor(18, 52);
 812                 again = inkey();
 813                 prt("", 16, 37);
 814                 prt("", 17, 37);
 815                 prt("", 18, 37);
 816                 if (wager > player_ptr->au)
 817                 {
 818                         msg_print(_("おい！金が足りないじゃないか！ここから出て行け！",
 819                                 "Hey! You don't have the gold - get out of here!"));
 820                         msg_print(NULL);
 821
 822                         /* Get out here */
 823                         break;
 824                 }
 825         } while ((again == 'y') || (again == 'Y'));
 826
 827         prt("", 18, 37);
 828         if (player_ptr->au >= oldgold)
 829         {
 830                 msg_print(_("「今回は儲けたな！でも次はこっちが勝ってやるからな、絶対に！」",
 831                         "You came out a winner! We'll win next time, I'm sure."));
 832                 chg_virtue(player_ptr, V_CHANCE, 3);
 833         }
 834         else
 835         {
 836                 msg_print(_("「金をスッてしまったな、わはは！うちに帰った方がいいぜ。」", "You lost gold! Haha, better head home."));
 837                 chg_virtue(player_ptr, V_CHANCE, -3);
 838         }
 839
 840         msg_print(NULL);
 841         screen_load();
 842         return TRUE;
 843 }
 844
 845
 846 /*!
 847  * @brief モンスター闘技場に参加するモンスターを更新する。
 848  * @param player_ptr プレーヤーへの参照ポインタ
 849  * @return なし
 850  */
 851 void update_gambling_monsters(player_type *player_ptr)
 852 {
 853         int total, i;
 854         int max_dl = 0;
 855         int mon_level;
 856         int power[4];
 857         bool tekitou;
 858
 859         for (i = 0; i < current_world_ptr->max_d_idx; i++)
 860         {
 861                 if (max_dl < max_dlv[i]) max_dl = max_dlv[i];
 862         }
 863
 864         mon_level = randint1(MIN(max_dl, 122)) + 5;
 865         if (randint0(100) < 60)
 866         {
 867                 i = randint1(MIN(max_dl, 122)) + 5;
 868                 mon_level = MAX(i, mon_level);
 869         }
 870
 871         if (randint0(100) < 30)
 872         {
 873                 i = randint1(MIN(max_dl, 122)) + 5;
 874                 mon_level = MAX(i, mon_level);
 875         }
 876
 877         while (TRUE)
 878         {
 879                 total = 0;
 880                 tekitou = FALSE;
 881                 for (i = 0; i < 4; i++)
 882                 {
 883                         MONRACE_IDX r_idx;
 884                         int j;
 885                         while (TRUE)
 886                         {
 887                                 get_mon_num_prep(player_ptr, monster_can_entry_arena, NULL);
 888                                 r_idx = get_mon_num(player_ptr, mon_level, GMN_ARENA);
 889                                 if (!r_idx) continue;
 890
 891                                 if ((r_info[r_idx].flags1 & RF1_UNIQUE) || (r_info[r_idx].flags7 & RF7_UNIQUE2))
 892                                 {
 893                                         if ((r_info[r_idx].level + 10) > mon_level) continue;
 894                                 }
 895
 896                                 for (j = 0; j < i; j++)
 897                                         if (r_idx == battle_mon[j]) break;
 898                                 if (j < i) continue;
 899
 900                                 break;
 901                         }
 902                         battle_mon[i] = r_idx;
 903                         if (r_info[r_idx].level < 45) tekitou = TRUE;
 904                 }
 905
 906                 for (i = 0; i < 4; i++)
 907                 {
 908                         monster_race *r_ptr = &r_info[battle_mon[i]];
 909                         int num_taisei = count_bits(r_ptr->flagsr & (RFR_IM_ACID | RFR_IM_ELEC | RFR_IM_FIRE | RFR_IM_COLD | RFR_IM_POIS));
 910
 911                         if (r_ptr->flags1 & RF1_FORCE_MAXHP)
 912                                 power[i] = r_ptr->hdice * r_ptr->hside * 2;
 913                         else
 914                                 power[i] = r_ptr->hdice * (r_ptr->hside + 1);
 915                         power[i] = power[i] * (100 + r_ptr->level) / 100;
 916                         if (r_ptr->speed > 110)
 917                                 power[i] = power[i] * (r_ptr->speed * 2 - 110) / 100;
 918                         if (r_ptr->speed < 110)
 919                                 power[i] = power[i] * (r_ptr->speed - 20) / 100;
 920                         if (num_taisei > 2)
 921                                 power[i] = power[i] * (num_taisei * 2 + 5) / 10;
 922                         else if (r_ptr->a_ability_flags2 & RF6_INVULNER)
 923                                 power[i] = power[i] * 4 / 3;
 924                         else if (r_ptr->a_ability_flags2 & RF6_HEAL)
 925                                 power[i] = power[i] * 4 / 3;
 926                         else if (r_ptr->a_ability_flags1 & RF5_DRAIN_MANA)
 927                                 power[i] = power[i] * 11 / 10;
 928                         if (r_ptr->flags1 & RF1_RAND_25)
 929                                 power[i] = power[i] * 9 / 10;
 930                         if (r_ptr->flags1 & RF1_RAND_50)
 931                                 power[i] = power[i] * 9 / 10;
 932                         if (r_ptr->flagsr & RFR_RES_ALL) power[i] *= 100000;
 933                         if (r_ptr->arena_ratio) power[i] = power[i] * r_ptr->arena_ratio / 100;
 934                         total += power[i];
 935                 }
 936
 937                 for (i = 0; i < 4; i++)
 938                 {
 939                         if (power[i] <= 0) break;
 940                         power[i] = total * 60 / power[i];
 941                         if (tekitou && ((power[i] < 160) || power[i] > 1500)) break;
 942                         if ((power[i] < 160) && randint0(20)) break;
 943                         if (power[i] < 101) power[i] = 100 + randint1(5);
 944                         mon_odds[i] = power[i];
 945                 }
 946
 947                 if (i == 4) break;
 948         }
 949 }
 950
 951
 952 /*!
 953  * @brief モンスター闘技場のメインルーチン
 954  * @param player_ptr プレーヤーへの参照ポインタ
 955  * @return 賭けを開始したか否か
 956  */
 957 static bool kakutoujou(player_type *player_ptr)
 958 {
 959         PRICE maxbet;
 960         PRICE wager;
 961         char out_val[160], tmp_str[80];
 962         concptr p;
 963
 964         if ((current_world_ptr->game_turn - current_world_ptr->arena_start_turn) > TURNS_PER_TICK * 250)
 965         {
 966                 update_gambling_monsters(player_ptr);
 967                 current_world_ptr->arena_start_turn = current_world_ptr->game_turn;
 968         }
 969
 970         screen_save();
 971
 972         /* No money */
 973         if (player_ptr->au <= 1)
 974         {
 975                 msg_print(_("おい！おまえ一文なしじゃないか！こっから出ていけ！", "Hey! You don't have gold - get out of here!"));
 976                 msg_print(NULL);
 977                 screen_load();
 978                 return FALSE;
 979         }
 980
 981         clear_bldg(4, 10);
 982
 983         prt(_("モンスター                                                     倍率",
 984                 "Monsters                                                       Odds"), 4, 4);
 985         for (int i = 0; i < 4; i++)
 986         {
 987                 char buf[80];
 988                 monster_race *r_ptr = &r_info[battle_mon[i]];
 989
 990                 sprintf(buf, _("%d) %-58s  %4ld.%02ld倍", "%d) %-58s  %4ld.%02ld"), i + 1,
 991                         _(format("%s%s", r_name + r_ptr->name, (r_ptr->flags1 & RF1_UNIQUE) ? "もどき" : "      "),
 992                                 format("%s%s", (r_ptr->flags1 & RF1_UNIQUE) ? "Fake " : "", r_name + r_ptr->name)),
 993                                 (long int)mon_odds[i] / 100, (long int)mon_odds[i] % 100);
 994                 prt(buf, 5 + i, 1);
 995         }
 996
 997         prt(_("どれに賭けますか:", "Which monster: "), 0, 0);
 998         while (TRUE)
 999         {
1000                 int i = inkey();
1001
1002                 if (i == ESCAPE)
1003                 {
1004                         screen_load();
1005                         return FALSE;
1006                 }
1007
1008                 if (i >= '1' && i <= '4')
1009                 {
1010                         sel_monster = i - '1';
1011                         battle_odds = mon_odds[sel_monster];
1012                         break;
1013                 }
1014
1015                 else bell();
1016         }
1017
1018         clear_bldg(4, 4);
1019         for (int i = 0; i < 4; i++)
1020                 if (i != sel_monster) clear_bldg(i + 5, i + 5);
1021
1022         maxbet = player_ptr->lev * 200;
1023
1024         /* We can't bet more than we have */
1025         maxbet = MIN(maxbet, player_ptr->au);
1026
1027         /* Get the wager */
1028         strcpy(out_val, "");
1029         sprintf(tmp_str, _("賭け金 (1-%ld)？", "Your wager (1-%ld) ? "), (long int)maxbet);
1030
1031         /*
1032          * Use get_string() because we may need more than
1033          * the s16b value returned by get_quantity().
1034          */
1035         if (!get_string(tmp_str, out_val, 32))
1036         {
1037                 screen_load();
1038                 return FALSE;
1039         }
1040
1041         for (p = out_val; *p == ' '; p++);
1042
1043         wager = atol(p);
1044         if (wager > player_ptr->au)
1045         {
1046                 msg_print(_("おい！金が足りないじゃないか！出ていけ！", "Hey! You don't have the gold - get out of here!"));
1047
1048                 msg_print(NULL);
1049                 screen_load();
1050                 return FALSE;
1051         }
1052         else if (wager > maxbet)
1053         {
1054                 msg_format(_("%ldゴールドだけ受けよう。残りは取っときな。", "I'll take %ld gold of that. Keep the rest."), (long int)maxbet);
1055
1056                 wager = maxbet;
1057         }
1058         else if (wager < 1)
1059         {
1060                 msg_print(_("ＯＫ、１ゴールドでいこう。", "Ok, we'll start with 1 gold."));
1061                 wager = 1;
1062         }
1063
1064         msg_print(NULL);
1065         battle_odds = MAX(wager + 1, wager * battle_odds / 100);
1066         kakekin = wager;
1067         player_ptr->au -= wager;
1068         reset_tim_flags(player_ptr);
1069
1070         prepare_change_floor_mode(player_ptr, CFM_SAVE_FLOORS);
1071
1072         player_ptr->phase_out = TRUE;
1073         player_ptr->leaving = TRUE;
1074         player_ptr->leave_bldg = TRUE;
1075
1076         screen_load();
1077         return TRUE;
1078 }
1079
1080
1081 /*!
1082  * @brief 本日の賞金首情報を表示する。
1083  * @param player_ptr プレーヤーへの参照ポインタ
1084  * @return なし
1085  */
1086 static void today_target(player_type *player_ptr)
1087 {
1088         char buf[160];
1089         monster_race *r_ptr = &r_info[today_mon];
1090
1091         clear_bldg(4, 18);
1092         c_put_str(TERM_YELLOW, _("本日の賞金首", "Wanted monster that changes from day to day"), 5, 10);
1093         sprintf(buf, _("ターゲット： %s", "target: %s"), r_name + r_ptr->name);
1094         c_put_str(TERM_YELLOW, buf, 6, 10);
1095         sprintf(buf, _("死体 ---- $%d", "corpse   ---- $%d"), (int)r_ptr->level * 50 + 100);
1096         prt(buf, 8, 10);
1097         sprintf(buf, _("骨   ---- $%d", "skeleton ---- $%d"), (int)r_ptr->level * 30 + 60);
1098         prt(buf, 9, 10);
1099         player_ptr->today_mon = today_mon;
1100 }
1101
1102
1103 /*!
1104  * @brief ツチノコの賞金首情報を表示する。
1105  * @return なし
1106  */
1107 static void tsuchinoko(void)
1108 {
1109         clear_bldg(4, 18);
1110         c_put_str(TERM_YELLOW, _("一獲千金の大チャンス！！！", "Big chance for quick money!!!"), 5, 10);
1111         c_put_str(TERM_YELLOW, _("ターゲット：幻の珍獣「ツチノコ」", "target: the rarest animal 'Tsuchinoko'"), 6, 10);
1112         c_put_str(TERM_WHITE, _("生け捕り ---- $1,000,000", "catch alive ---- $1,000,000"), 8, 10);
1113         c_put_str(TERM_WHITE, _("死体     ----   $200,000", "corpse      ----   $200,000"), 9, 10);
1114         c_put_str(TERM_WHITE, _("骨       ----   $100,000", "bones       ----   $100,000"), 10, 10);
1115 }
1116
1117
1118 /*!
1119  * @brief 通常の賞金首情報を表示する。
1120  * @return なし
1121  */
1122 static void show_bounty(void)
1123 {
1124         TERM_LEN y = 0;
1125
1126         clear_bldg(4, 18);
1127         prt(_("死体を持ち帰れば報酬を差し上げます。", "Offer a prize when you bring a wanted monster's corpse"), 4, 10);
1128         c_put_str(TERM_YELLOW, _("現在の賞金首", "Wanted monsters"), 6, 10);
1129
1130         for (int i = 0; i < MAX_BOUNTY; i++)
1131         {
1132                 byte color;
1133                 concptr done_mark;
1134                 monster_race *r_ptr = &r_info[(current_world_ptr->bounty_r_idx[i] > 10000 ? current_world_ptr->bounty_r_idx[i] - 10000 : current_world_ptr->bounty_r_idx[i])];
1135
1136                 if (current_world_ptr->bounty_r_idx[i] > 10000)
1137                 {
1138                         color = TERM_RED;
1139                         done_mark = _("(済)", "(done)");
1140                 }
1141                 else
1142                 {
1143                         color = TERM_WHITE;
1144                         done_mark = "";
1145                 }
1146
1147                 c_prt(color, format("%s %s", r_name + r_ptr->name, done_mark), y + 7, 10);
1148
1149                 y = (y + 1) % 10;
1150                 if (!y && (i < MAX_BOUNTY - 1))
1151                 {
1152                         prt(_("何かキーを押してください", "Hit any key."), 0, 0);
1153                         (void)inkey();
1154                         prt("", 0, 0);
1155                         clear_bldg(7, 18);
1156                 }
1157         }
1158 }
1159
1160
1161 /*!
1162  * 賞金首の報酬テーブル / List of prize object
1163  */
1164 static struct {
1165         OBJECT_TYPE_VALUE tval; /*!< ベースアイテムのメイン種別ID */
1166         OBJECT_SUBTYPE_VALUE sval; /*!< ベースアイテムのサブ種別ID */
1167 } prize_list[MAX_BOUNTY] =
1168 {
1169         {TV_POTION, SV_POTION_CURING},
1170         {TV_POTION, SV_POTION_SPEED},
1171         {TV_POTION, SV_POTION_SPEED},
1172         {TV_POTION, SV_POTION_RESISTANCE},
1173         {TV_POTION, SV_POTION_ENLIGHTENMENT},
1174
1175         {TV_POTION, SV_POTION_HEALING},
1176         {TV_POTION, SV_POTION_RESTORE_MANA},
1177         {TV_SCROLL, SV_SCROLL_STAR_DESTRUCTION},
1178         {TV_POTION, SV_POTION_STAR_ENLIGHTENMENT},
1179         {TV_SCROLL, SV_SCROLL_SUMMON_PET},
1180
1181         {TV_SCROLL, SV_SCROLL_GENOCIDE},
1182         {TV_POTION, SV_POTION_STAR_HEALING},
1183         {TV_POTION, SV_POTION_STAR_HEALING},
1184         {TV_POTION, SV_POTION_NEW_LIFE},
1185         {TV_SCROLL, SV_SCROLL_MASS_GENOCIDE},
1186
1187         {TV_POTION, SV_POTION_LIFE},
1188         {TV_POTION, SV_POTION_LIFE},
1189         {TV_POTION, SV_POTION_AUGMENTATION},
1190         {TV_POTION, SV_POTION_INVULNERABILITY},
1191         {TV_SCROLL, SV_SCROLL_ARTIFACT},
1192 };
1193
1194
1195 /*!
1196  * @brief 賞金首の引き換え処理 / Get prize
1197  * @param player_ptr プレーヤーへの参照ポインタ
1198  * @return 各種賞金首のいずれかでも換金が行われたか否か。
1199  */
1200 static bool kankin(player_type *player_ptr)
1201 {
1202         bool change = FALSE;
1203         GAME_TEXT o_name[MAX_NLEN];
1204         object_type *o_ptr;
1205
1206         for (INVENTORY_IDX i = 0; i <= INVEN_LARM; i++)
1207         {
1208                 o_ptr = &player_ptr->inventory_list[i];
1209                 if ((o_ptr->tval == TV_CAPTURE) && (o_ptr->pval == MON_TSUCHINOKO))
1210                 {
1211                         char buf[MAX_NLEN + 20];
1212                         object_desc(player_ptr, o_name, o_ptr, 0);
1213                         sprintf(buf, _("%s を換金しますか？", "Convert %s into money? "), o_name);
1214                         if (get_check(buf))
1215                         {
1216                                 msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)(1000000L * o_ptr->number));
1217                                 player_ptr->au += 1000000L * o_ptr->number;
1218                                 player_ptr->redraw |= (PR_GOLD);
1219                                 vary_item(player_ptr, i, -o_ptr->number);
1220                         }
1221
1222                         change = TRUE;
1223                 }
1224         }
1225
1226         for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++)
1227         {
1228                 o_ptr = &player_ptr->inventory_list[i];
1229                 if ((o_ptr->tval == TV_CORPSE) && (o_ptr->sval == SV_CORPSE) && (o_ptr->pval == MON_TSUCHINOKO))
1230                 {
1231                         char buf[MAX_NLEN + 20];
1232                         object_desc(player_ptr, o_name, o_ptr, 0);
1233                         sprintf(buf, _("%s を換金しますか？", "Convert %s into money? "), o_name);
1234                         if (get_check(buf))
1235                         {
1236                                 msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)(200000L * o_ptr->number));
1237                                 player_ptr->au += 200000L * o_ptr->number;
1238                                 player_ptr->redraw |= (PR_GOLD);
1239                                 vary_item(player_ptr, i, -o_ptr->number);
1240                         }
1241
1242                         change = TRUE;
1243                 }
1244         }
1245
1246         for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++)
1247         {
1248                 o_ptr = &player_ptr->inventory_list[i];
1249                 if ((o_ptr->tval == TV_CORPSE) && (o_ptr->sval == SV_SKELETON) && (o_ptr->pval == MON_TSUCHINOKO))
1250                 {
1251                         char buf[MAX_NLEN + 20];
1252                         object_desc(player_ptr, o_name, o_ptr, 0);
1253                         sprintf(buf, _("%s を換金しますか？", "Convert %s into money? "), o_name);
1254                         if (get_check(buf))
1255                         {
1256                                 msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)(100000L * o_ptr->number));
1257                                 player_ptr->au += 100000L * o_ptr->number;
1258                                 player_ptr->redraw |= (PR_GOLD);
1259                                 vary_item(player_ptr, i, -o_ptr->number);
1260                         }
1261                         change = TRUE;
1262                 }
1263         }
1264
1265         for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++)
1266         {
1267                 o_ptr = &player_ptr->inventory_list[i];
1268                 if ((o_ptr->tval == TV_CORPSE) && (o_ptr->sval == SV_CORPSE) && (streq(r_name + r_info[o_ptr->pval].name, r_name + r_info[today_mon].name)))
1269                 {
1270                         char buf[MAX_NLEN + 20];
1271                         object_desc(player_ptr, o_name, o_ptr, 0);
1272                         sprintf(buf, _("%s を換金しますか？", "Convert %s into money? "), o_name);
1273                         if (get_check(buf))
1274                         {
1275                                 msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)((r_info[today_mon].level * 50 + 100) * o_ptr->number));
1276                                 player_ptr->au += (r_info[today_mon].level * 50 + 100) * o_ptr->number;
1277                                 player_ptr->redraw |= (PR_GOLD);
1278                                 vary_item(player_ptr, i, -o_ptr->number);
1279                         }
1280                         change = TRUE;
1281                 }
1282         }
1283
1284         for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++)
1285         {
1286                 o_ptr = &player_ptr->inventory_list[i];
1287
1288                 if ((o_ptr->tval == TV_CORPSE) && (o_ptr->sval == SV_SKELETON) && (streq(r_name + r_info[o_ptr->pval].name, r_name + r_info[today_mon].name)))
1289                 {
1290                         char buf[MAX_NLEN + 20];
1291                         object_desc(player_ptr, o_name, o_ptr, 0);
1292                         sprintf(buf, _("%s を換金しますか？", "Convert %s into money? "), o_name);
1293                         if (get_check(buf))
1294                         {
1295                                 msg_format(_("賞金 %ld＄を手に入れた。", "You get %ldgp."), (long int)((r_info[today_mon].level * 30 + 60) * o_ptr->number));
1296                                 player_ptr->au += (r_info[today_mon].level * 30 + 60) * o_ptr->number;
1297                                 player_ptr->redraw |= (PR_GOLD);
1298                                 vary_item(player_ptr, i, -o_ptr->number);
1299                         }
1300
1301                         change = TRUE;
1302                 }
1303         }
1304
1305         for (int j = 0; j < MAX_BOUNTY; j++)
1306         {
1307                 for (INVENTORY_IDX i = INVEN_PACK - 1; i >= 0; i--)
1308                 {
1309                         o_ptr = &player_ptr->inventory_list[i];
1310                         if ((o_ptr->tval != TV_CORPSE) || (o_ptr->pval != current_world_ptr->bounty_r_idx[j])) continue;
1311
1312                         char buf[MAX_NLEN + 20];
1313                         int num, k;
1314                         INVENTORY_IDX item_new;
1315                         object_type forge;
1316
1317                         object_desc(player_ptr, o_name, o_ptr, 0);
1318                         sprintf(buf, _("%sを渡しますか？", "Hand %s over? "), o_name);
1319                         if (!get_check(buf)) continue;
1320
1321                         vary_item(player_ptr, i, -o_ptr->number);
1322                         chg_virtue(player_ptr, V_JUSTICE, 5);
1323                         current_world_ptr->bounty_r_idx[j] += 10000;
1324
1325                         for (num = 0, k = 0; k < MAX_BOUNTY; k++)
1326                         {
1327                                 if (current_world_ptr->bounty_r_idx[k] >= 10000) num++;
1328                         }
1329
1330                         msg_format(_("これで合計 %d ポイント獲得しました。", "You earned %d point%s total."), num, (num > 1 ? "s" : ""));
1331
1332                         object_prep(&forge, lookup_kind(prize_list[num - 1].tval, prize_list[num - 1].sval));
1333                         apply_magic(player_ptr, &forge, player_ptr->current_floor_ptr->object_level, AM_NO_FIXED_ART);
1334
1335                         object_aware(player_ptr, &forge);
1336                         object_known(&forge);
1337
1338                         /*
1339                          * Hand it --- Assume there is an empty slot.
1340                          * Since a corpse is handed at first,
1341                          * there is at least one empty slot.
1342                          */
1343                         item_new = inven_carry(player_ptr, &forge);
1344                         object_desc(player_ptr, o_name, &forge, 0);
1345                         msg_format(_("%s(%c)を貰った。", "You get %s (%c). "), o_name, index_to_label(item_new));
1346
1347                         autopick_alter_item(player_ptr, item_new, FALSE);
1348                         handle_stuff(player_ptr);
1349                         change = TRUE;
1350                 }
1351         }
1352
1353         if (change) return TRUE;
1354
1355         msg_print(_("賞金を得られそうなものは持っていなかった。", "You have nothing."));
1356         msg_print(NULL);
1357         return FALSE;
1358 }
1359
1360
1361 /*!
1362  * @brief 宿屋の利用サブルーチン
1363  * @details inn commands\n
1364  * Note that resting for the night was a perfect way to avoid player\n
1365  * ghosts in the town *if* you could only make it to the inn in time (-:\n
1366  * Now that the ghosts are temporarily disabled in 2.8.X, this function\n
1367  * will not be that useful.  I will keep it in the hopes the player\n
1368  * ghost code does become a reality again. Does help to avoid filthy urchins.\n
1369  * Resting at night is also a quick way to restock stores -KMW-\n
1370  * @param cmd 宿屋の利用施設ID
1371  * @return 施設の利用が実際に行われたか否か。
1372  */
1373 static bool inn_comm(player_type *customer_ptr, int cmd)
1374 {
1375         switch (cmd)
1376         {
1377         case BACT_FOOD: /* Buy food & drink */
1378                 if (customer_ptr->food >= PY_FOOD_FULL)
1379                 {
1380                         msg_print(_("今は満腹だ。", "You are full now."));
1381                         return FALSE;
1382                 }
1383
1384                 msg_print(_("バーテンはいくらかの食べ物とビールをくれた。", "The barkeep gives you some gruel and a beer."));
1385                 (void)set_food(customer_ptr, PY_FOOD_MAX - 1);
1386                 break;
1387
1388         case BACT_REST: /* Rest for the night */
1389         {
1390                 if ((customer_ptr->poisoned) || (customer_ptr->cut))
1391                 {
1392                         msg_print(_("あなたに必要なのは部屋ではなく、治療者です。", "You need a healer, not a room."));
1393                         msg_print(NULL);
1394                         msg_print(_("すみません、でもうちで誰かに死なれちゃ困りますんで。", "Sorry, but don't want anyone dying in here."));
1395                         break;
1396                 }
1397
1398                 s32b oldturn = current_world_ptr->game_turn;
1399                 int prev_day, prev_hour, prev_min;
1400
1401                 extract_day_hour_min(customer_ptr, &prev_day, &prev_hour, &prev_min);
1402                 if ((prev_hour >= 6) && (prev_hour <= 17))
1403                         exe_write_diary(customer_ptr, DIARY_DESCRIPTION, 0, _("宿屋に泊まった。", "stayed during the day at the inn."));
1404                 else
1405                         exe_write_diary(customer_ptr, DIARY_DESCRIPTION, 0, _("宿屋に泊まった。", "stayed overnight at the inn."));
1406
1407                 current_world_ptr->game_turn = (current_world_ptr->game_turn / (TURNS_PER_TICK * TOWN_DAWN / 2) + 1) * (TURNS_PER_TICK * TOWN_DAWN / 2);
1408                 if (current_world_ptr->dungeon_turn < current_world_ptr->dungeon_turn_limit)
1409                 {
1410                         current_world_ptr->dungeon_turn += MIN((current_world_ptr->game_turn - oldturn), TURNS_PER_TICK * 250) * INN_DUNGEON_TURN_ADJ;
1411                         if (current_world_ptr->dungeon_turn > current_world_ptr->dungeon_turn_limit) current_world_ptr->dungeon_turn = current_world_ptr->dungeon_turn_limit;
1412                 }
1413
1414                 prevent_turn_overflow(customer_ptr);
1415
1416                 if ((prev_hour >= 18) && (prev_hour <= 23)) exe_write_diary(customer_ptr, DIARY_DIALY, 0, NULL);
1417                 customer_ptr->chp = customer_ptr->mhp;
1418
1419                 if (ironman_nightmare)
1420                 {
1421                         msg_print(_("眠りに就くと恐ろしい光景が心をよぎった。", "Horrible visions flit through your mind as you sleep."));
1422
1423                         while (TRUE)
1424                         {
1425                                 sanity_blast(customer_ptr, NULL, FALSE);
1426                                 if (!one_in_(3)) break;
1427                         }
1428
1429                         msg_print(_("あなたは絶叫して目を覚ました。", "You awake screaming."));
1430                         exe_write_diary(customer_ptr, DIARY_DESCRIPTION, 0, _("悪夢にうなされてよく眠れなかった。", "had a nightmare."));
1431                         break;
1432                 }
1433
1434                 set_blind(customer_ptr, 0);
1435                 set_confused(customer_ptr, 0);
1436                 customer_ptr->stun = 0;
1437                 customer_ptr->chp = customer_ptr->mhp;
1438                 customer_ptr->csp = customer_ptr->msp;
1439                 if (customer_ptr->pclass == CLASS_MAGIC_EATER)
1440                 {
1441                         int i;
1442                         for (i = 0; i < 72; i++)
1443                         {
1444                                 customer_ptr->magic_num1[i] = customer_ptr->magic_num2[i] * EATER_CHARGE;
1445                         }
1446
1447                         for (; i < 108; i++)
1448                         {
1449                                 customer_ptr->magic_num1[i] = 0;
1450                         }
1451                 }
1452
1453                 if ((prev_hour >= 6) && (prev_hour <= 17))
1454                 {
1455                         msg_print(_("あなたはリフレッシュして目覚め、夕方を迎えた。", "You awake refreshed for the evening."));
1456                         exe_write_diary(customer_ptr, DIARY_DESCRIPTION, 0, _("夕方を迎えた。", "awoke refreshed."));
1457                         break;
1458                 }
1459
1460                 msg_print(_("あなたはリフレッシュして目覚め、新たな日を迎えた。", "You awake refreshed for the new day."));
1461                 exe_write_diary(customer_ptr, DIARY_DESCRIPTION, 0, _("すがすがしい朝を迎えた。", "awoke refreshed."));
1462                 break;
1463         }
1464         case BACT_RUMORS: /* Listen for rumors */
1465         {
1466                 display_rumor(customer_ptr, TRUE);
1467                 break;
1468         }
1469         }
1470
1471         return TRUE;
1472 }
1473
1474
1475 /*!
1476  * @brief クエスト情報を表示しつつ処理する。/ Display quest information
1477  * @param player_ptr プレーヤーへの参照ポインタ
1478  * @param questnum クエストのID
1479  * @param do_init クエストの開始処理(TRUE)、結果処理か(FALSE)
1480  * @return なし
1481  */
1482 static void get_questinfo(player_type *player_ptr, IDX questnum, bool do_init)
1483 {
1484         for (int i = 0; i < 10; i++)
1485         {
1486                 quest_text[i][0] = '\0';
1487         }
1488
1489         quest_text_line = 0;
1490
1491         floor_type *floor_ptr = player_ptr->current_floor_ptr;
1492         QUEST_IDX old_quest = floor_ptr->inside_quest;
1493         floor_ptr->inside_quest = questnum;
1494
1495         init_flags = INIT_SHOW_TEXT;
1496         if (do_init) init_flags |= INIT_ASSIGN;
1497
1498         process_dungeon_file(player_ptr, "q_info.txt", 0, 0, 0, 0);
1499         floor_ptr->inside_quest = old_quest;
1500
1501         GAME_TEXT tmp_str[80];
1502         sprintf(tmp_str, _("クエスト情報 (危険度: %d 階相当)", "Quest Information (Danger level: %d)"), (int)quest[questnum].level);
1503         prt(tmp_str, 5, 0);
1504         prt(quest[questnum].name, 7, 0);
1505
1506         for (int i = 0; i < 10; i++)
1507         {
1508                 c_put_str(TERM_YELLOW, quest_text[i], i + 8, 0);
1509         }
1510 }
1511
1512 /*!
1513  * @brief クエスト処理のメインルーチン / Request a quest from the Lord.
1514  * @param player_ptr プレーヤーへの参照ポインタ
1515  * @return なし
1516  */
1517 static void castle_quest(player_type *player_ptr)
1518 {
1519         clear_bldg(4, 18);
1520         QUEST_IDX q_index = player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].special;
1521
1522         if (!q_index)
1523         {
1524                 put_str(_("今のところクエストはありません。", "I don't have a quest for you at the moment."), 8, 0);
1525                 return;
1526         }
1527
1528         quest_type *q_ptr;
1529         q_ptr = &quest[q_index];
1530         if (q_ptr->status == QUEST_STATUS_COMPLETED)
1531         {
1532                 q_ptr->status = QUEST_STATUS_REWARDED;
1533                 get_questinfo(player_ptr, q_index, FALSE);
1534                 reinit_wilderness = TRUE;
1535                 return;
1536         }
1537
1538         if (q_ptr->status == QUEST_STATUS_FAILED)
1539         {
1540                 get_questinfo(player_ptr, q_index, FALSE);
1541                 q_ptr->status = QUEST_STATUS_FAILED_DONE;
1542                 reinit_wilderness = TRUE;
1543                 return;
1544         }
1545
1546         if (q_ptr->status == QUEST_STATUS_TAKEN)
1547         {
1548                 put_str(_("あなたは現在のクエストを終了させていません！", "You have not completed your current quest yet!"), 8, 0);
1549                 put_str(_("CTRL-Qを使えばクエストの状態がチェックできます。", "Use CTRL-Q to check the status of your quest."), 9, 0);
1550                 put_str(_("クエストを終わらせたら戻って来て下さい。", "Return when you have completed your quest."), 12, 0);
1551                 return;
1552         }
1553
1554         if (q_ptr->status != QUEST_STATUS_UNTAKEN) return;
1555
1556         q_ptr->status = QUEST_STATUS_TAKEN;
1557         reinit_wilderness = TRUE;
1558         if (q_ptr->type != QUEST_TYPE_KILL_ANY_LEVEL)
1559         {
1560                 get_questinfo(player_ptr, q_index, TRUE);
1561                 return;
1562         }
1563
1564         if (q_ptr->r_idx == 0)
1565         {
1566                 q_ptr->r_idx = get_mon_num(player_ptr, q_ptr->level + 4 + randint1(6), 0);
1567         }
1568
1569         monster_race *r_ptr;
1570         r_ptr = &r_info[q_ptr->r_idx];
1571         while ((r_ptr->flags1 & RF1_UNIQUE) || (r_ptr->rarity != 1))
1572         {
1573                 q_ptr->r_idx = get_mon_num(player_ptr, q_ptr->level + 4 + randint1(6), 0);
1574                 r_ptr = &r_info[q_ptr->r_idx];
1575         }
1576
1577         if (q_ptr->max_num == 0)
1578         {
1579                 if (randint1(10) > 7)
1580                         q_ptr->max_num = 1;
1581                 else
1582                         q_ptr->max_num = randint1(3) + 1;
1583         }
1584
1585         q_ptr->cur_num = 0;
1586         concptr name = (r_name + r_ptr->name);
1587 #ifdef JP
1588         msg_format("クエスト: %sを %d体倒す", name, q_ptr->max_num);
1589 #else
1590         msg_format("Your quest: kill %d %s", q_ptr->max_num, name);
1591 #endif
1592         get_questinfo(player_ptr, q_index, TRUE);
1593 }
1594
1595
1596 /*!
1597  * @brief 町に関するヘルプを表示する / Display town history
1598  * @param player_ptr プレーヤーへの参照ポインタ
1599  * @return なし
1600  */
1601 static void town_history(player_type *player_ptr)
1602 {
1603         screen_save();
1604         (void)show_file(player_ptr, TRUE, _("jbldg.txt", "bldg.txt"), NULL, 0, 0);
1605         screen_load();
1606 }
1607
1608
1609 /*!
1610  * @brief 攻撃時スレイによるダメージ期待値修正計算 / critical happens at i / 10000
1611  * @param dam 基本ダメージ
1612  * @param mult スレイ倍率（掛け算部分）
1613  * @param div スレイ倍率（割り算部分）
1614  * @param force 理力特別計算フラグ
1615  * @return ダメージ期待値
1616  */
1617 static HIT_POINT calc_slaydam(HIT_POINT dam, int mult, int div, bool force)
1618 {
1619         int tmp;
1620         if (force)
1621         {
1622                 tmp = dam * 60;
1623                 tmp *= mult * 3;
1624                 tmp /= div * 2;
1625                 tmp += dam * 60 * 2;
1626                 tmp /= 60;
1627                 return tmp;
1628         }
1629
1630         tmp = dam * 60;
1631         tmp *= mult;
1632         tmp /= div;
1633         tmp /= 60;
1634         return tmp;
1635 }
1636
1637
1638 /*!
1639  * @brief 攻撃時の期待値計算（スレイ→重量クリティカル→切れ味効果）
1640  * @param player_ptr プレーヤーへの参照ポインタ
1641  * @param dam 基本ダメージ
1642  * @param mult スレイ倍率（掛け算部分）
1643  * @param div スレイ倍率（割り算部分）
1644  * @param force 理力特別計算フラグ
1645  * @param weight 重量
1646  * @param plus 武器ダメージ修正
1647  * @param meichuu 命中値
1648  * @param dokubari 毒針処理か否か
1649  * @param vorpal_mult 切れ味倍率（掛け算部分）
1650  * @param vorpal_div 切れ味倍率（割り算部分）
1651  * @return ダメージ期待値
1652  */
1653 static u32b calc_expect_dice(player_type *owner_ptr, u32b dam, int mult, int div, bool force, WEIGHT weight, int plus, s16b meichuu, bool dokubari, int vorpal_mult, int vorpal_div)
1654 {
1655         dam = calc_slaydam(dam, mult, div, force);
1656         dam = calc_expect_crit(owner_ptr, weight, plus, dam, meichuu, dokubari);
1657         dam = calc_slaydam(dam, vorpal_mult, vorpal_div, FALSE);
1658         return dam;
1659 }
1660
1661
1662 /*!
1663  * @brief 武器の各条件毎のダメージ期待値を表示する。
1664  * @param r 表示行
1665  * @param c 表示列
1666  * @param mindice ダイス部分最小値
1667  * @param maxdice ダイス部分最大値
1668  * @param blows 攻撃回数
1669  * @param dam_bonus ダメージ修正値
1670  * @param attr 条件内容
1671  * @param color 条件内容の表示色
1672  * @details
1673  * Display the damage figure of an object\n
1674  * (used by compare_weapon_aux)\n
1675  * \n
1676  * Only accurate for the current weapon, because it includes\n
1677  * the current +dam of the player.\n
1678  * @return なし
1679  */
1680 static void show_weapon_dmg(int r, int c, int mindice, int maxdice, int blows, int dam_bonus, concptr attr, byte color)
1681 {
1682         c_put_str(color, attr, r, c);
1683         GAME_TEXT tmp_str[80];
1684         int mindam = blows * (mindice + dam_bonus);
1685         int maxdam = blows * (maxdice + dam_bonus);
1686         sprintf(tmp_str, _("１ターン: %d-%d ダメージ", "Attack: %d-%d damage"), mindam, maxdam);
1687         put_str(tmp_str, r, c + 8);
1688 }
1689
1690
1691 /*!
1692  * @brief 武器一つ毎のダメージ情報を表示する。
1693  * @param o_ptr オブジェクトの構造体の参照ポインタ。
1694  * @param col 表示する行の上端
1695  * @param r 表示する列の左端
1696  * @details
1697  * Show the damage figures for the various monster types\n
1698  * \n
1699  * Only accurate for the current weapon, because it includes\n
1700  * the current number of blows for the player.\n
1701  * @return なし
1702  */
1703 static void compare_weapon_aux(player_type *owner_ptr, object_type *o_ptr, int col, int r)
1704 {
1705         BIT_FLAGS flgs[TR_FLAG_SIZE];
1706         int blow = owner_ptr->num_blow[0];
1707         bool force = FALSE;
1708         bool dokubari = FALSE;
1709
1710         int eff_dd = o_ptr->dd + owner_ptr->to_dd[0];
1711         int eff_ds = o_ptr->ds + owner_ptr->to_ds[0];
1712
1713         int mindice = eff_dd;
1714         int maxdice = eff_ds * eff_dd;
1715         int mindam = 0;
1716         int maxdam = 0;
1717         int vorpal_mult = 1;
1718         int vorpal_div = 1;
1719         int dmg_bonus = o_ptr->to_d + owner_ptr->to_d[0];
1720
1721         object_flags(o_ptr, flgs);
1722         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_POISON_NEEDLE)) dokubari = TRUE;
1723
1724         mindam = calc_expect_crit(owner_ptr, o_ptr->weight, o_ptr->to_h, mindice, owner_ptr->to_h[0], dokubari);
1725         maxdam = calc_expect_crit(owner_ptr, o_ptr->weight, o_ptr->to_h, maxdice, owner_ptr->to_h[0], dokubari);
1726         show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("会心:", "Critical:"), TERM_L_RED);
1727         if ((have_flag(flgs, TR_VORPAL) || hex_spelling(owner_ptr, HEX_RUNESWORD)))
1728         {
1729                 if ((o_ptr->name1 == ART_VORPAL_BLADE) || (o_ptr->name1 == ART_CHAINSWORD))
1730                 {
1731                         vorpal_mult = 5;
1732                         vorpal_div = 3;
1733                 }
1734                 else
1735                 {
1736                         vorpal_mult = 11;
1737                         vorpal_div = 9;
1738                 }
1739
1740                 mindam = calc_expect_dice(owner_ptr, mindice, 1, 1, FALSE, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1741                 maxdam = calc_expect_dice(owner_ptr, maxdice, 1, 1, FALSE, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1742                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("切れ味:", "Vorpal:"), TERM_L_RED);
1743         }
1744
1745         if ((owner_ptr->pclass != CLASS_SAMURAI) && have_flag(flgs, TR_FORCE_WEAPON) && (owner_ptr->csp > (o_ptr->dd * o_ptr->ds / 5)))
1746         {
1747                 force = TRUE;
1748
1749                 mindam = calc_expect_dice(owner_ptr, mindice, 1, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1750                 maxdam = calc_expect_dice(owner_ptr, maxdice, 1, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1751                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("理力:", "Force  :"), TERM_L_BLUE);
1752         }
1753
1754         if (have_flag(flgs, TR_KILL_ANIMAL))
1755         {
1756                 mindam = calc_expect_dice(owner_ptr, mindice, 4, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1757                 maxdam = calc_expect_dice(owner_ptr, maxdice, 4, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1758                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("動物:", "Animals:"), TERM_YELLOW);
1759         }
1760         else if (have_flag(flgs, TR_SLAY_ANIMAL))
1761         {
1762                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1763                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1764                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("動物:", "Animals:"), TERM_YELLOW);
1765         }
1766
1767         if (have_flag(flgs, TR_KILL_EVIL))
1768         {
1769                 mindam = calc_expect_dice(owner_ptr, mindice, 7, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1770                 maxdam = calc_expect_dice(owner_ptr, maxdice, 7, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1771                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("邪悪:", "Evil:"), TERM_YELLOW);
1772         }
1773         else if (have_flag(flgs, TR_SLAY_EVIL))
1774         {
1775                 mindam = calc_expect_dice(owner_ptr, mindice, 2, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1776                 maxdam = calc_expect_dice(owner_ptr, maxdice, 2, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1777                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("邪悪:", "Evil:"), TERM_YELLOW);
1778         }
1779
1780         if (have_flag(flgs, TR_KILL_HUMAN))
1781         {
1782                 mindam = calc_expect_dice(owner_ptr, mindice, 4, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1783                 maxdam = calc_expect_dice(owner_ptr, maxdice, 4, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1784                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("人間:", "Human:"), TERM_YELLOW);
1785         }
1786         else if (have_flag(flgs, TR_SLAY_HUMAN))
1787         {
1788                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1789                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1790                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("人間:", "Human:"), TERM_YELLOW);
1791         }
1792
1793         if (have_flag(flgs, TR_KILL_UNDEAD))
1794         {
1795                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1796                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1797                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("不死:", "Undead:"), TERM_YELLOW);
1798         }
1799         else if (have_flag(flgs, TR_SLAY_UNDEAD))
1800         {
1801                 mindam = calc_expect_dice(owner_ptr, mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1802                 maxdam = calc_expect_dice(owner_ptr, maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1803                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("不死:", "Undead:"), TERM_YELLOW);
1804         }
1805
1806         if (have_flag(flgs, TR_KILL_DEMON))
1807         {
1808                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1809                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1810                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("悪魔:", "Demons:"), TERM_YELLOW);
1811         }
1812         else if (have_flag(flgs, TR_SLAY_DEMON))
1813         {
1814                 mindam = calc_expect_dice(owner_ptr, mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1815                 maxdam = calc_expect_dice(owner_ptr, maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1816                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("悪魔:", "Demons:"), TERM_YELLOW);
1817         }
1818
1819         if (have_flag(flgs, TR_KILL_ORC))
1820         {
1821                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1822                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1823                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("オーク:", "Orcs:"), TERM_YELLOW);
1824         }
1825         else if (have_flag(flgs, TR_SLAY_ORC))
1826         {
1827                 mindam = calc_expect_dice(owner_ptr, mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1828                 maxdam = calc_expect_dice(owner_ptr, maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1829                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("オーク:", "Orcs:"), TERM_YELLOW);
1830         }
1831
1832         if (have_flag(flgs, TR_KILL_TROLL))
1833         {
1834                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1835                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1836                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("トロル:", "Trolls:"), TERM_YELLOW);
1837         }
1838         else if (have_flag(flgs, TR_SLAY_TROLL))
1839         {
1840                 mindam = calc_expect_dice(owner_ptr, mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1841                 maxdam = calc_expect_dice(owner_ptr, maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1842                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("トロル:", "Trolls:"), TERM_YELLOW);
1843         }
1844
1845         if (have_flag(flgs, TR_KILL_GIANT))
1846         {
1847                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1848                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1849                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("巨人:", "Giants:"), TERM_YELLOW);
1850         }
1851         else if (have_flag(flgs, TR_SLAY_GIANT))
1852         {
1853                 mindam = calc_expect_dice(owner_ptr, mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1854                 maxdam = calc_expect_dice(owner_ptr, maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1855                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("巨人:", "Giants:"), TERM_YELLOW);
1856         }
1857
1858         if (have_flag(flgs, TR_KILL_DRAGON))
1859         {
1860                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1861                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1862                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("竜:", "Dragons:"), TERM_YELLOW);
1863         }
1864         else if (have_flag(flgs, TR_SLAY_DRAGON))
1865         {
1866                 mindam = calc_expect_dice(owner_ptr, mindice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1867                 maxdam = calc_expect_dice(owner_ptr, maxdice, 3, 1, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1868                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("竜:", "Dragons:"), TERM_YELLOW);
1869         }
1870
1871         if (have_flag(flgs, TR_BRAND_ACID))
1872         {
1873                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1874                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1875                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("酸属性:", "Acid:"), TERM_RED);
1876         }
1877
1878         if (have_flag(flgs, TR_BRAND_ELEC))
1879         {
1880                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1881                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1882                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("電属性:", "Elec:"), TERM_RED);
1883         }
1884
1885         if (have_flag(flgs, TR_BRAND_FIRE))
1886         {
1887                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1888                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1889                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("炎属性:", "Fire:"), TERM_RED);
1890         }
1891
1892         if (have_flag(flgs, TR_BRAND_COLD))
1893         {
1894                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1895                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1896                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("冷属性:", "Cold:"), TERM_RED);
1897         }
1898
1899         if (have_flag(flgs, TR_BRAND_POIS))
1900         {
1901                 mindam = calc_expect_dice(owner_ptr, mindice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1902                 maxdam = calc_expect_dice(owner_ptr, maxdice, 5, 2, force, o_ptr->weight, o_ptr->to_h, owner_ptr->to_h[0], dokubari, vorpal_mult, vorpal_div);
1903                 show_weapon_dmg(r++, col, mindam, maxdam, blow, dmg_bonus, _("毒属性:", "Poison:"), TERM_RED);
1904         }
1905 }
1906
1907
1908 /*!
1909  * @brief 武器匠における武器一つ毎の完全情報を表示する。
1910  * @param player_type プレーヤーへの参照ポインタ
1911  * @param o_ptr オブジェクトの構造体の参照ポインタ。
1912  * @param row 表示する列の左端
1913  * @param col 表示する行の上端
1914  * @details
1915  * Displays all info about a weapon
1916  *
1917  * Only accurate for the current weapon, because it includes
1918  * various info about the player's +to_dam and number of blows.
1919  * @return なし
1920  */
1921 static void list_weapon(player_type *player_ptr, object_type *o_ptr, TERM_LEN row, TERM_LEN col)
1922 {
1923         GAME_TEXT o_name[MAX_NLEN];
1924         GAME_TEXT tmp_str[80];
1925
1926         DICE_NUMBER eff_dd = o_ptr->dd + player_ptr->to_dd[0];
1927         DICE_SID eff_ds = o_ptr->ds + player_ptr->to_ds[0];
1928         HIT_RELIABILITY reli = player_ptr->skill_thn + (player_ptr->to_h[0] + o_ptr->to_h) * BTH_PLUS_ADJ;
1929
1930         object_desc(player_ptr, o_name, o_ptr, OD_NAME_ONLY);
1931         c_put_str(TERM_YELLOW, o_name, row, col);
1932         sprintf(tmp_str, _("攻撃回数: %d", "Number of Blows: %d"), player_ptr->num_blow[0]);
1933         put_str(tmp_str, row + 1, col);
1934
1935         sprintf(tmp_str, _("命中率:  0  50 100 150 200 (敵のAC)", "To Hit:  0  50 100 150 200 (AC)"));
1936         put_str(tmp_str, row + 2, col);
1937         sprintf(tmp_str, "        %2d  %2d  %2d  %2d  %2d (%%)",
1938                 (int)hit_chance(player_ptr, reli, 0),
1939                 (int)hit_chance(player_ptr, reli, 50),
1940                 (int)hit_chance(player_ptr, reli, 100),
1941                 (int)hit_chance(player_ptr, reli, 150),
1942                 (int)hit_chance(player_ptr, reli, 200));
1943         put_str(tmp_str, row + 3, col);
1944         c_put_str(TERM_YELLOW, _("可能なダメージ:", "Possible Damage:"), row + 5, col);
1945
1946         sprintf(tmp_str, _("攻撃一回につき %d-%d", "One Strike: %d-%d damage"),
1947                 (int)(eff_dd + o_ptr->to_d + player_ptr->to_d[0]),
1948                 (int)(eff_ds * eff_dd + o_ptr->to_d + player_ptr->to_d[0]));
1949         put_str(tmp_str, row + 6, col + 1);
1950
1951         sprintf(tmp_str, _("１ターンにつき %d-%d", "One Attack: %d-%d damage"),
1952                 (int)(player_ptr->num_blow[0] * (eff_dd + o_ptr->to_d + player_ptr->to_d[0])),
1953                 (int)(player_ptr->num_blow[0] * (eff_ds * eff_dd + o_ptr->to_d + player_ptr->to_d[0])));
1954         put_str(tmp_str, row + 7, col + 1);
1955 }
1956
1957
1958 /*!
1959  * @brief 武器匠鑑定1回分（オブジェクト2種）の処理。/ Compare weapons
1960  * @details
1961  * Copies the weapons to compare into the weapon-slot and\n
1962  * compares the values for both weapons.\n
1963  * 武器1つだけで比較をしないなら費用は半額になる。
1964  * @param bcost 基本鑑定費用
1965  * @return 最終的にかかった費用
1966  */
1967 static PRICE compare_weapons(player_type *customer_ptr, PRICE bcost)
1968 {
1969         object_type *o_ptr[2];
1970         object_type orig_weapon;
1971         object_type *i_ptr;
1972         TERM_LEN row = 2;
1973         TERM_LEN wid = 38, mgn = 2;
1974         bool old_character_xtra = current_world_ptr->character_xtra;
1975         char ch;
1976         PRICE total = 0;
1977         PRICE cost = 0; /* First time no price */
1978
1979         screen_save();
1980         clear_bldg(0, 22);
1981         i_ptr = &customer_ptr->inventory_list[INVEN_RARM];
1982         object_copy(&orig_weapon, i_ptr);
1983
1984         item_tester_hook = item_tester_hook_orthodox_melee_weapons;
1985         concptr q = _("第一の武器は？", "What is your first weapon? ");
1986         concptr s = _("比べるものがありません。", "You have nothing to compare.");
1987
1988         OBJECT_IDX item;
1989         o_ptr[0] = choose_object(customer_ptr, &item, q, s, (USE_EQUIP | USE_INVEN | IGNORE_BOTHHAND_SLOT), 0);
1990         if (!o_ptr[0])
1991         {
1992                 screen_load();
1993                 return 0;
1994         }
1995
1996         int n = 1;
1997         total = bcost;
1998
1999         while (TRUE)
2000         {
2001                 clear_bldg(0, 22);
2002                 item_tester_hook = item_tester_hook_orthodox_melee_weapons;
2003                 current_world_ptr->character_xtra = TRUE;
2004                 for (int i = 0; i < n; i++)
2005                 {
2006                         int col = (wid * i + mgn);
2007                         if (o_ptr[i] != i_ptr) object_copy(i_ptr, o_ptr[i]);
2008
2009                         customer_ptr->update |= PU_BONUS;
2010                         handle_stuff(customer_ptr);
2011
2012                         list_weapon(customer_ptr, o_ptr[i], row, col);
2013                         compare_weapon_aux(customer_ptr, o_ptr[i], col, row + 8);
2014                         object_copy(i_ptr, &orig_weapon);
2015                 }
2016
2017                 customer_ptr->update |= PU_BONUS;
2018                 handle_stuff(customer_ptr);
2019
2020                 current_world_ptr->character_xtra = old_character_xtra;
2021 #ifdef JP
2022                 put_str(format("[ 比較対象: 's'で変更 ($%d) ]", cost), 1, (wid + mgn));
2023                 put_str("(一番高いダメージが適用されます。複数の倍打効果は足し算されません。)", row + 4, 0);
2024                 prt("現在の技量から判断すると、あなたの武器は以下のような威力を発揮します:", 0, 0);
2025 #else
2026                 put_str(format("[ 's' Select secondary weapon($%d) ]", cost), 1, (wid + mgn));
2027                 put_str("(Only highest damage applies per monster. Special damage not cumulative.)", row + 4, 0);
2028                 prt("Based on your current abilities, here is what your weapons will do", 0, 0);
2029 #endif
2030
2031                 flush();
2032                 ch = inkey();
2033                 if (ch != 's') break;
2034
2035                 if (total + cost > customer_ptr->au)
2036                 {
2037                         msg_print(_("お金が足りません！", "You don't have enough money!"));
2038                         msg_print(NULL);
2039                         continue;
2040                 }
2041
2042                 q = _("第二の武器は？", "What is your second weapon? ");
2043                 s = _("比べるものがありません。", "You have nothing to compare.");
2044                 OBJECT_IDX item2;
2045                 o_ptr[1] = choose_object(customer_ptr, &item2, q, s, (USE_EQUIP | USE_INVEN | IGNORE_BOTHHAND_SLOT), 0);
2046                 if (!o_ptr[1]) continue;
2047
2048                 total += cost;
2049                 cost = bcost / 2;
2050                 n = 2;
2051         }
2052
2053         screen_load();
2054         return total;
2055 }
2056
2057
2058 /*!
2059  * @brief ACから回避率、ダメージ減少率を計算し表示する。 / Evaluate AC
2060  * @details
2061  * Calculate and display the dodge-rate and the protection-rate
2062  * based on AC
2063  * @param iAC プレイヤーのAC。
2064  * @return 常にTRUEを返す。
2065  */
2066 static bool eval_ac(ARMOUR_CLASS iAC)
2067 {
2068 #ifdef JP
2069         const char memo[] =
2070                 "ダメージ軽減率とは、敵の攻撃が当たった時そのダメージを\n"
2071                 "何パーセント軽減するかを示します。\n"
2072                 "ダメージ軽減は通常の直接攻撃(種類が「攻撃する」と「粉砕する」の物)\n"
2073                 "に対してのみ効果があります。\n \n"
2074                 "敵のレベルとは、その敵が通常何階に現れるかを示します。\n \n"
2075                 "回避率は敵の直接攻撃を何パーセントの確率で避けるかを示し、\n"
2076                 "敵のレベルとあなたのACによって決定されます。\n \n"
2077                 "ダメージ期待値とは、敵の１００ポイントの通常攻撃に対し、\n"
2078                 "回避率とダメージ軽減率を考慮したダメージの期待値を示します。\n";
2079 #else
2080         const char memo[] =
2081                 "'Protection Rate' means how much damage is reduced by your armor.\n"
2082                 "Note that the Protection rate is effective only against normal "
2083                 "'attack' and 'shatter' type melee attacks, "
2084                 "and has no effect against any other types such as 'poison'.\n \n"
2085                 "'Dodge Rate' indicates the success rate on dodging the "
2086                 "monster's melee attacks.  "
2087                 "It is depend on the level of the monster and your AC.\n \n"
2088                 "'Average Damage' indicates the expected amount of damage "
2089                 "when you are attacked by normal melee attacks with power=100.";
2090 #endif
2091
2092         int protection;
2093         TERM_LEN col, row = 2;
2094         DEPTH lvl;
2095         char buf[80 * 20], *t;
2096
2097         if (iAC < 0) iAC = 0;
2098
2099         protection = 100 * MIN(iAC, 150) / 250;
2100         screen_save();
2101         clear_bldg(0, 22);
2102
2103         put_str(format(_("あなたの現在のAC: %3d", "Your current AC : %3d"), iAC), row++, 0);
2104         put_str(format(_("ダメージ軽減率  : %3d%%", "Protection rate : %3d%%"), protection), row++, 0);
2105         row++;
2106
2107         put_str(_("敵のレベル      :", "Level of Monster:"), row + 0, 0);
2108         put_str(_("回避率          :", "Dodge Rate      :"), row + 1, 0);
2109         put_str(_("ダメージ期待値  :", "Average Damage  :"), row + 2, 0);
2110
2111         for (col = 17 + 1, lvl = 0; lvl <= 100; lvl += 10, col += 5)
2112         {
2113                 int quality = 60 + lvl * 3; /* attack quality with power 60 */
2114                 int dodge;   /* 回避率(%) */
2115                 int average; /* ダメージ期待値 */
2116
2117                 put_str(format("%3d", lvl), row + 0, col);
2118
2119                 /* 回避率を計算 */
2120                 dodge = 5 + (MIN(100, 100 * (iAC * 3 / 4) / quality) * 9 + 5) / 10;
2121                 put_str(format("%3d%%", dodge), row + 1, col);
2122
2123                 /* 100点の攻撃に対してのダメージ期待値を計算 */
2124                 average = (100 - dodge) * (100 - protection) / 100;
2125                 put_str(format("%3d", average), row + 2, col);
2126         }
2127
2128         roff_to_buf(memo, 70, buf, sizeof(buf));
2129         for (t = buf; t[0]; t += strlen(t) + 1)
2130                 put_str(t, (row++) + 4, 4);
2131
2132         prt(_("現在のあなたの装備からすると、あなたの防御力はこれくらいです:", "Defense abilities from your current Armor Class are evaluated below."), 0, 0);
2133
2134         flush();
2135         (void)inkey();
2136         screen_load();
2137
2138         return TRUE;
2139 }
2140
2141
2142 /*!
2143  * @brief 修復材料のオブジェクトから修復対象に特性を移植する。
2144  * @param to_ptr 修復対象オブジェクトの構造体の参照ポインタ。
2145  * @param from_ptr 修復材料オブジェクトの構造体の参照ポインタ。
2146  * @return 修復対象になるならTRUEを返す。
2147  */
2148 static void give_one_ability_of_object(object_type *to_ptr, object_type *from_ptr)
2149 {
2150         BIT_FLAGS to_flgs[TR_FLAG_SIZE];
2151         BIT_FLAGS from_flgs[TR_FLAG_SIZE];
2152         object_flags(to_ptr, to_flgs);
2153         object_flags(from_ptr, from_flgs);
2154
2155         int n = 0;
2156         int cand[TR_FLAG_MAX];
2157         for (int i = 0; i < TR_FLAG_MAX; i++)
2158         {
2159                 switch (i)
2160                 {
2161                 case TR_IGNORE_ACID:
2162                 case TR_IGNORE_ELEC:
2163                 case TR_IGNORE_FIRE:
2164                 case TR_IGNORE_COLD:
2165                 case TR_ACTIVATE:
2166                 case TR_RIDING:
2167                 case TR_THROW:
2168                 case TR_SHOW_MODS:
2169                 case TR_HIDE_TYPE:
2170                 case TR_ES_ATTACK:
2171                 case TR_ES_AC:
2172                 case TR_FULL_NAME:
2173                 case TR_FIXED_FLAVOR:
2174                         break;
2175                 default:
2176                         if (have_flag(from_flgs, i) && !have_flag(to_flgs, i))
2177                         {
2178                                 if (!(is_pval_flag(i) && (from_ptr->pval < 1))) cand[n++] = i;
2179                         }
2180                 }
2181         }
2182
2183         if (n <= 0) return;
2184
2185         int tr_idx = cand[randint0(n)];
2186         add_flag(to_ptr->art_flags, tr_idx);
2187         if (is_pval_flag(tr_idx)) to_ptr->pval = MAX(to_ptr->pval, 1);
2188         int bmax = MIN(3, MAX(1, 40 / (to_ptr->dd * to_ptr->ds)));
2189         if (tr_idx == TR_BLOWS) to_ptr->pval = MIN(to_ptr->pval, bmax);
2190         if (tr_idx == TR_SPEED) to_ptr->pval = MIN(to_ptr->pval, 4);
2191 }
2192
2193
2194 /*!
2195  * @brief アイテム修復処理のメインルーチン / Repair broken weapon
2196  * @param player_ptr プレーヤーへの参照ポインタ
2197  * @param bcost 基本修復費用
2198  * @return 実際にかかった費用
2199  */
2200 static PRICE repair_broken_weapon_aux(player_type *player_ptr, PRICE bcost)
2201 {
2202         clear_bldg(0, 22);
2203         int row = 7;
2204         prt(_("修復には材料となるもう1つの武器が必要です。", "Hand one material weapon to repair a broken weapon."), row, 2);
2205         prt(_("材料に使用した武器はなくなります！", "The material weapon will disappear after repairing!!"), row + 1, 2);
2206
2207         concptr q = _("どの折れた武器を修復しますか？", "Repair which broken weapon? ");
2208         concptr s = _("修復できる折れた武器がありません。", "You have no broken weapon to repair.");
2209         item_tester_hook = item_tester_hook_broken_weapon;
2210
2211         OBJECT_IDX item;
2212         object_type *o_ptr;
2213         o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_EQUIP), 0);
2214         if (!o_ptr) return 0;
2215
2216         if (!object_is_ego(o_ptr) && !object_is_artifact(o_ptr))
2217         {
2218                 msg_format(_("それは直してもしょうがないぜ。", "It is worthless to repair."));
2219                 return 0;
2220         }
2221
2222         if (o_ptr->number > 1)
2223         {
2224                 msg_format(_("一度に複数を修復することはできません！", "They are too many to repair at once!"));
2225                 return 0;
2226         }
2227
2228         char basenm[MAX_NLEN];
2229         object_desc(player_ptr, basenm, o_ptr, OD_NAME_ONLY);
2230         prt(format(_("修復する武器　： %s", "Repairing: %s"), basenm), row + 3, 2);
2231
2232         q = _("材料となる武器は？", "Which weapon for material? ");
2233         s = _("材料となる武器がありません。", "You have no material to repair.");
2234
2235         item_tester_hook = item_tester_hook_orthodox_melee_weapons;
2236         OBJECT_IDX mater;
2237         object_type *mo_ptr;
2238         mo_ptr = choose_object(player_ptr, &mater, q, s, (USE_INVEN | USE_EQUIP), 0);
2239         if (!mo_ptr) return 0;
2240         if (mater == item)
2241         {
2242                 msg_print(_("クラインの壷じゃない！", "This is not a klein bottle!"));
2243                 return 0;
2244         }
2245
2246         object_desc(player_ptr, basenm, mo_ptr, OD_NAME_ONLY);
2247         prt(format(_("材料とする武器： %s", "Material : %s"), basenm), row + 4, 2);
2248         PRICE cost = bcost + object_value_real(o_ptr) * 2;
2249         if (!get_check(format(_("＄%dかかりますがよろしいですか？ ", "Costs %d gold, okay? "), cost))) return 0;
2250
2251         if (player_ptr->au < cost)
2252         {
2253                 object_desc(player_ptr, basenm, o_ptr, OD_NAME_ONLY);
2254                 msg_format(_("%sを修復するだけのゴールドがありません！", "You do not have the gold to repair %s!"), basenm);
2255                 msg_print(NULL);
2256                 return 0;
2257         }
2258
2259         player_ptr->total_weight -= o_ptr->weight;
2260         KIND_OBJECT_IDX k_idx;
2261         if (o_ptr->sval == SV_BROKEN_DAGGER)
2262         {
2263                 int n = 1;
2264                 k_idx = 0;
2265                 for (KIND_OBJECT_IDX j = 1; j < max_k_idx; j++)
2266                 {
2267                         object_kind *k_aux_ptr = &k_info[j];
2268
2269                         if (k_aux_ptr->tval != TV_SWORD) continue;
2270                         if ((k_aux_ptr->sval == SV_BROKEN_DAGGER) ||
2271                                 (k_aux_ptr->sval == SV_BROKEN_SWORD) ||
2272                                 (k_aux_ptr->sval == SV_POISON_NEEDLE)) continue;
2273                         if (k_aux_ptr->weight > 99) continue;
2274
2275                         if (one_in_(n))
2276                         {
2277                                 k_idx = j;
2278                                 n++;
2279                         }
2280                 }
2281         }
2282         else
2283         {
2284                 OBJECT_TYPE_VALUE tval = (one_in_(5) ? mo_ptr->tval : TV_SWORD);
2285                 while (TRUE)
2286                 {
2287                         object_kind *ck_ptr;
2288                         k_idx = lookup_kind(tval, SV_ANY);
2289                         ck_ptr = &k_info[k_idx];
2290
2291                         if (tval == TV_SWORD)
2292                         {
2293                                 if ((ck_ptr->sval == SV_BROKEN_DAGGER) ||
2294                                         (ck_ptr->sval == SV_BROKEN_SWORD) ||
2295                                         (ck_ptr->sval == SV_DIAMOND_EDGE) ||
2296                                         (ck_ptr->sval == SV_POISON_NEEDLE)) continue;
2297                         }
2298                         if (tval == TV_POLEARM)
2299                         {
2300                                 if ((ck_ptr->sval == SV_DEATH_SCYTHE) ||
2301                                         (ck_ptr->sval == SV_TSURIZAO)) continue;
2302                         }
2303                         if (tval == TV_HAFTED)
2304                         {
2305                                 if ((ck_ptr->sval == SV_GROND) ||
2306                                         (ck_ptr->sval == SV_WIZSTAFF) ||
2307                                         (ck_ptr->sval == SV_NAMAKE_HAMMER)) continue;
2308                         }
2309
2310                         break;
2311                 }
2312         }
2313
2314         int dd_bonus = o_ptr->dd - k_info[o_ptr->k_idx].dd;
2315         int ds_bonus = o_ptr->ds - k_info[o_ptr->k_idx].ds;
2316         dd_bonus += mo_ptr->dd - k_info[mo_ptr->k_idx].dd;
2317         ds_bonus += mo_ptr->ds - k_info[mo_ptr->k_idx].ds;
2318
2319         object_kind *k_ptr;
2320         k_ptr = &k_info[k_idx];
2321         o_ptr->k_idx = k_idx;
2322         o_ptr->weight = k_ptr->weight;
2323         o_ptr->tval = k_ptr->tval;
2324         o_ptr->sval = k_ptr->sval;
2325         o_ptr->dd = k_ptr->dd;
2326         o_ptr->ds = k_ptr->ds;
2327
2328         for (int i = 0; i < TR_FLAG_SIZE; i++) o_ptr->art_flags[i] |= k_ptr->flags[i];
2329         if (k_ptr->pval) o_ptr->pval = MAX(o_ptr->pval, randint1(k_ptr->pval));
2330         if (have_flag(k_ptr->flags, TR_ACTIVATE)) o_ptr->xtra2 = (byte)k_ptr->act_idx;
2331
2332         if (dd_bonus > 0)
2333         {
2334                 o_ptr->dd++;
2335                 for (int i = 1; i < dd_bonus; i++)
2336                 {
2337                         if (one_in_(o_ptr->dd + i)) o_ptr->dd++;
2338                 }
2339         }
2340
2341         if (ds_bonus > 0)
2342         {
2343                 o_ptr->ds++;
2344                 for (int i = 1; i < ds_bonus; i++)
2345                 {
2346                         if (one_in_(o_ptr->ds + i)) o_ptr->ds++;
2347                 }
2348         }
2349
2350         if (have_flag(k_ptr->flags, TR_BLOWS))
2351         {
2352                 int bmax = MIN(3, MAX(1, 40 / (o_ptr->dd * o_ptr->ds)));
2353                 o_ptr->pval = MIN(o_ptr->pval, bmax);
2354         }
2355
2356         give_one_ability_of_object(o_ptr, mo_ptr);
2357         o_ptr->to_d += MAX(0, (mo_ptr->to_d / 3));
2358         o_ptr->to_h += MAX(0, (mo_ptr->to_h / 3));
2359         o_ptr->to_a += MAX(0, (mo_ptr->to_a));
2360
2361         if ((o_ptr->name1 == ART_NARSIL) ||
2362                 (object_is_random_artifact(o_ptr) && one_in_(1)) ||
2363                 (object_is_ego(o_ptr) && one_in_(7)))
2364         {
2365                 if (object_is_ego(o_ptr))
2366                 {
2367                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
2368                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
2369                 }
2370
2371                 give_one_ability_of_object(o_ptr, mo_ptr);
2372                 if (!activation_index(o_ptr)) one_activation(o_ptr);
2373
2374                 if (o_ptr->name1 == ART_NARSIL)
2375                 {
2376                         one_high_resistance(o_ptr);
2377                         one_ability(o_ptr);
2378                 }
2379
2380                 msg_print(_("これはかなりの業物だったようだ。", "This blade seems to be exceptional."));
2381         }
2382
2383         object_desc(player_ptr, basenm, o_ptr, OD_NAME_ONLY);
2384 #ifdef JP
2385         msg_format("＄%dで%sに修復しました。", cost, basenm);
2386 #else
2387         msg_format("Repaired into %s for %d gold.", basenm, cost);
2388 #endif
2389         msg_print(NULL);
2390         o_ptr->ident &= ~(IDENT_BROKEN);
2391         o_ptr->discount = 99;
2392
2393         player_ptr->total_weight += o_ptr->weight;
2394         calc_android_exp(player_ptr);
2395         inven_item_increase(player_ptr, mater, -1);
2396         inven_item_optimize(player_ptr, mater);
2397
2398         player_ptr->update |= PU_BONUS;
2399         handle_stuff(player_ptr);
2400         return (cost);
2401 }
2402
2403
2404 /*!
2405  * @brief アイテム修復処理の過渡ルーチン / Repair broken weapon
2406  * @param player_ptr プレーヤーへの参照ポインタ
2407  * @param bcost 基本鑑定費用
2408  * @return 実際にかかった費用
2409  */
2410 static int repair_broken_weapon(player_type *player_ptr, PRICE bcost)
2411 {
2412         PRICE cost;
2413         screen_save();
2414         cost = repair_broken_weapon_aux(player_ptr, bcost);
2415         screen_load();
2416         return cost;
2417 }
2418
2419
2420 /*!
2421  * @brief アイテムの強化を行う。 / Enchant item
2422  * @param player_ptr プレーヤーへの参照ポインタ
2423  * @param cost 1回毎の費用
2424  * @param to_hit 命中をアップさせる量
2425  * @param to_dam ダメージをアップさせる量
2426  * @param to_ac ＡＣをアップさせる量
2427  * @return 実際に行ったらTRUE
2428  */
2429 static bool enchant_item(player_type *player_ptr, PRICE cost, HIT_PROB to_hit, HIT_POINT to_dam, ARMOUR_CLASS to_ac)
2430 {
2431         clear_bldg(4, 18);
2432         int maxenchant = (player_ptr->lev / 5);
2433         prt(format(_("現在のあなたの技量だと、+%d まで改良できます。", "  Based on your skill, we can improve up to +%d."), maxenchant), 5, 0);
2434         prt(format(_(" 改良の料金は一個につき＄%d です。", "  The price for the service is %d gold per item."), cost), 7, 0);
2435
2436         concptr q = _("どのアイテムを改良しますか？", "Improve which item? ");
2437         concptr s = _("改良できるものがありません。", "You have nothing to improve.");
2438
2439         OBJECT_IDX item;
2440         object_type *o_ptr;
2441         o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_EQUIP | IGNORE_BOTHHAND_SLOT), item_tester_tval);
2442         if (!o_ptr) return FALSE;
2443
2444         char tmp_str[MAX_NLEN];
2445         if (player_ptr->au < (cost * o_ptr->number))
2446         {
2447                 object_desc(player_ptr, tmp_str, o_ptr, OD_NAME_ONLY);
2448                 msg_format(_("%sを改良するだけのゴールドがありません！", "You do not have the gold to improve %s!"), tmp_str);
2449                 return FALSE;
2450         }
2451
2452         bool okay = FALSE;
2453         for (int i = 0; i < to_hit; i++)
2454         {
2455                 if ((o_ptr->to_h < maxenchant) && enchant(player_ptr, o_ptr, 1, (ENCH_TOHIT | ENCH_FORCE)))
2456                 {
2457                         okay = TRUE;
2458                         break;
2459                 }
2460         }
2461
2462         for (int i = 0; i < to_dam; i++)
2463         {
2464                 if ((o_ptr->to_d < maxenchant) && enchant(player_ptr, o_ptr, 1, (ENCH_TODAM | ENCH_FORCE)))
2465                 {
2466                         okay = TRUE;
2467                         break;
2468                 }
2469         }
2470
2471         for (int i = 0; i < to_ac; i++)
2472         {
2473                 if ((o_ptr->to_a < maxenchant) && enchant(player_ptr, o_ptr, 1, (ENCH_TOAC | ENCH_FORCE)))
2474                 {
2475                         okay = TRUE;
2476                         break;
2477                 }
2478         }
2479
2480         if (!okay)
2481         {
2482                 if (flush_failure) flush();
2483                 msg_print(_("改良に失敗した。", "The improvement failed."));
2484                 return FALSE;
2485         }
2486
2487         object_desc(player_ptr, tmp_str, o_ptr, OD_NAME_AND_ENCHANT);
2488 #ifdef JP
2489         msg_format("＄%dで%sに改良しました。", cost * o_ptr->number, tmp_str);
2490 #else
2491         msg_format("Improved into %s for %d gold.", tmp_str, cost * o_ptr->number);
2492 #endif
2493
2494         player_ptr->au -= (cost * o_ptr->number);
2495         if (item >= INVEN_RARM) calc_android_exp(player_ptr);
2496         return TRUE;
2497 }
2498
2499
2500 /*!
2501  * @brief 魔道具の使用回数を回復させる施設のメインルーチン / Recharge rods, wands and staffs
2502  * @details
2503  * The player can select the number of charges to add\n
2504  * (up to a limit), and the recharge never fails.\n
2505  *\n
2506  * The cost for rods depends on the level of the rod. The prices\n
2507  * for recharging wands and staffs are dependent on the cost of\n
2508  * the base-item.\n
2509  * @param player_ptr プレーヤーへの参照ポインタ
2510  * @return なし
2511  */
2512 static void building_recharge(player_type *player_ptr)
2513 {
2514         msg_flag = FALSE;
2515         clear_bldg(4, 18);
2516         prt(_("  再充填の費用はアイテムの種類によります。", "  The prices of recharge depend on the type."), 6, 0);
2517         item_tester_hook = item_tester_hook_recharge;
2518
2519         concptr q = _("どのアイテムに魔力を充填しますか? ", "Recharge which item? ");
2520         concptr s = _("魔力を充填すべきアイテムがない。", "You have nothing to recharge.");
2521
2522         OBJECT_IDX item;
2523         object_type *o_ptr;
2524         o_ptr = choose_object(player_ptr, &item, q, s, (USE_INVEN | USE_FLOOR), 0);
2525         if (!o_ptr) return;
2526
2527         object_kind *k_ptr;
2528         k_ptr = &k_info[o_ptr->k_idx];
2529
2530         /*
2531          * We don't want to give the player free info about
2532          * the level of the item or the number of charges.
2533          */
2534          /* The item must be "known" */
2535         char tmp_str[MAX_NLEN];
2536         if (!object_is_known(o_ptr))
2537         {
2538                 msg_format(_("充填する前に鑑定されている必要があります！", "The item must be identified first!"));
2539                 msg_print(NULL);
2540
2541                 if ((player_ptr->au >= 50) &&
2542                         get_check(_("＄50で鑑定しますか？ ", "Identify for 50 gold? ")))
2543
2544                 {
2545                         player_ptr->au -= 50;
2546                         identify_item(player_ptr, o_ptr);
2547                         object_desc(player_ptr, tmp_str, o_ptr, 0);
2548                         msg_format(_("%s です。", "You have: %s."), tmp_str);
2549
2550                         autopick_alter_item(player_ptr, item, FALSE);
2551                         building_prt_gold(player_ptr);
2552                 }
2553
2554                 return;
2555         }
2556
2557         DEPTH lev = k_info[o_ptr->k_idx].level;
2558         PRICE price;
2559         if (o_ptr->tval == TV_ROD)
2560         {
2561                 if (o_ptr->timeout > 0)
2562                 {
2563                         price = (lev * 50 * o_ptr->timeout) / k_ptr->pval;
2564                 }
2565                 else
2566                 {
2567                         price = 0;
2568                         msg_format(_("それは再充填する必要はありません。", "That doesn't need to be recharged."));
2569                         return;
2570                 }
2571         }
2572         else if (o_ptr->tval == TV_STAFF)
2573         {
2574                 price = (k_info[o_ptr->k_idx].cost / 10) * o_ptr->number;
2575                 price = MAX(10, price);
2576         }
2577         else
2578         {
2579                 price = (k_info[o_ptr->k_idx].cost / 10);
2580                 price = MAX(10, price);
2581         }
2582
2583         if (o_ptr->tval == TV_WAND
2584                 && (o_ptr->pval / o_ptr->number >= k_ptr->pval))
2585         {
2586                 if (o_ptr->number > 1)
2587                 {
2588                         msg_print(_("この魔法棒はもう充分に充填されています。", "These wands are already fully charged."));
2589                 }
2590                 else
2591                 {
2592                         msg_print(_("この魔法棒はもう充分に充填されています。", "This wand is already fully charged."));
2593                 }
2594
2595                 return;
2596         }
2597         else if (o_ptr->tval == TV_STAFF && o_ptr->pval >= k_ptr->pval)
2598         {
2599                 if (o_ptr->number > 1)
2600                 {
2601                         msg_print(_("この杖はもう充分に充填されています。", "These staffs are already fully charged."));
2602                 }
2603                 else
2604                 {
2605                         msg_print(_("この杖はもう充分に充填されています。", "This staff is already fully charged."));
2606                 }
2607
2608                 return;
2609         }
2610
2611         if (player_ptr->au < price)
2612         {
2613                 object_desc(player_ptr, tmp_str, o_ptr, OD_NAME_ONLY);
2614 #ifdef JP
2615                 msg_format("%sを再充填するには＄%d 必要です！", tmp_str, price);
2616 #else
2617                 msg_format("You need %d gold to recharge %s!", price, tmp_str);
2618 #endif
2619                 return;
2620         }
2621
2622         PARAMETER_VALUE charges;
2623         if (o_ptr->tval == TV_ROD)
2624         {
2625 #ifdef JP
2626                 if (get_check(format("そのロッドを＄%d で再充填しますか？", price)))
2627 #else
2628                 if (get_check(format("Recharge the %s for %d gold? ",
2629                         ((o_ptr->number > 1) ? "rods" : "rod"), price)))
2630 #endif
2631
2632                 {
2633                         o_ptr->timeout = 0;
2634                 }
2635                 else
2636                 {
2637                         return;
2638                 }
2639         }
2640         else
2641         {
2642                 int max_charges;
2643                 if (o_ptr->tval == TV_STAFF)
2644                         max_charges = k_ptr->pval - o_ptr->pval;
2645                 else
2646                         max_charges = o_ptr->number * k_ptr->pval - o_ptr->pval;
2647
2648                 charges = (PARAMETER_VALUE)get_quantity(format(_("一回分＄%d で何回分充填しますか？", "Add how many charges for %d gold? "), price),
2649                         MIN(player_ptr->au / price, max_charges));
2650
2651                 if (charges < 1) return;
2652
2653                 price *= charges;
2654                 o_ptr->pval += charges;
2655                 o_ptr->ident &= ~(IDENT_EMPTY);
2656         }
2657
2658         object_desc(player_ptr, tmp_str, o_ptr, 0);
2659 #ifdef JP
2660         msg_format("%sを＄%d で再充填しました。", tmp_str, price);
2661 #else
2662         msg_format("%^s %s recharged for %d gold.", tmp_str, ((o_ptr->number > 1) ? "were" : "was"), price);
2663 #endif
2664         player_ptr->update |= (PU_COMBINE | PU_REORDER);
2665         player_ptr->window |= (PW_INVEN);
2666         player_ptr->au -= price;
2667 }
2668
2669
2670 /*!
2671  * @brief 魔道具の使用回数を回復させる施設の一括処理向けサブルーチン / Recharge rods, wands and staffs
2672  * @details
2673  * The player can select the number of charges to add\n
2674  * (up to a limit), and the recharge never fails.\n
2675  *\n
2676  * The cost for rods depends on the level of the rod. The prices\n
2677  * for recharging wands and staffs are dependent on the cost of\n
2678  * the base-item.\n
2679  * @param player_ptr プレーヤーへの参照ポインタ
2680  * @return なし
2681  */
2682 static void building_recharge_all(player_type *player_ptr)
2683 {
2684         msg_flag = FALSE;
2685         clear_bldg(4, 18);
2686         prt(_("  再充填の費用はアイテムの種類によります。", "  The prices of recharge depend on the type."), 6, 0);
2687
2688         PRICE price = 0;
2689         PRICE total_cost = 0;
2690         for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++)
2691         {
2692                 object_type *o_ptr;
2693                 o_ptr = &player_ptr->inventory_list[i];
2694
2695                 if (o_ptr->tval < TV_STAFF || o_ptr->tval > TV_ROD) continue;
2696                 if (!object_is_known(o_ptr)) total_cost += 50;
2697
2698                 DEPTH lev = k_info[o_ptr->k_idx].level;
2699                 object_kind *k_ptr;
2700                 k_ptr = &k_info[o_ptr->k_idx];
2701
2702                 switch (o_ptr->tval)
2703                 {
2704                 case TV_ROD:
2705                         price = (lev * 50 * o_ptr->timeout) / k_ptr->pval;
2706                         break;
2707
2708                 case TV_STAFF:
2709                         price = (k_info[o_ptr->k_idx].cost / 10) * o_ptr->number;
2710                         price = MAX(10, price);
2711                         price = (k_ptr->pval - o_ptr->pval) * price;
2712                         break;
2713
2714                 case TV_WAND:
2715                         price = (k_info[o_ptr->k_idx].cost / 10);
2716                         price = MAX(10, price);
2717                         price = (o_ptr->number * k_ptr->pval - o_ptr->pval) * price;
2718                         break;
2719                 }
2720
2721                 if (price > 0) total_cost += price;
2722         }
2723
2724         if (!total_cost)
2725         {
2726                 msg_print(_("充填する必要はありません。", "No need to recharge."));
2727                 msg_print(NULL);
2728                 return;
2729         }
2730
2731         if (player_ptr->au < total_cost)
2732         {
2733                 msg_format(_("すべてのアイテムを再充填するには＄%d 必要です！", "You need %d gold to recharge all items!"), total_cost);
2734                 msg_print(NULL);
2735                 return;
2736         }
2737
2738         if (!get_check(format(_("すべてのアイテムを ＄%d で再充填しますか？", "Recharge all items for %d gold? "), total_cost))) return;
2739
2740         for (INVENTORY_IDX i = 0; i < INVEN_PACK; i++)
2741         {
2742                 object_type *o_ptr;
2743                 o_ptr = &player_ptr->inventory_list[i];
2744                 object_kind *k_ptr;
2745                 k_ptr = &k_info[o_ptr->k_idx];
2746
2747                 if (o_ptr->tval < TV_STAFF || o_ptr->tval > TV_ROD) continue;
2748
2749                 if (!object_is_known(o_ptr))
2750                 {
2751                         identify_item(player_ptr, o_ptr);
2752                         autopick_alter_item(player_ptr, i, FALSE);
2753                 }
2754
2755                 switch (o_ptr->tval)
2756                 {
2757                 case TV_ROD:
2758                         o_ptr->timeout = 0;
2759                         break;
2760                 case TV_STAFF:
2761                         if (o_ptr->pval < k_ptr->pval) o_ptr->pval = k_ptr->pval;
2762
2763                         o_ptr->ident &= ~(IDENT_EMPTY);
2764                         break;
2765                 case TV_WAND:
2766                         if (o_ptr->pval < o_ptr->number * k_ptr->pval)
2767                                 o_ptr->pval = o_ptr->number * k_ptr->pval;
2768
2769                         o_ptr->ident &= ~(IDENT_EMPTY);
2770                         break;
2771                 }
2772         }
2773
2774         msg_format(_("＄%d で再充填しました。", "You pay %d gold."), total_cost);
2775         msg_print(NULL);
2776         player_ptr->update |= (PU_COMBINE | PU_REORDER);
2777         player_ptr->window |= (PW_INVEN);
2778         player_ptr->au -= total_cost;
2779 }
2780
2781
2782 /*!
2783  * @brief 施設でモンスターの情報を知るメインルーチン / research_mon -KMW-
2784  * @param player_ptr プレーヤーへの参照ポインタ
2785  * @return 常にTRUEを返す。
2786  * @todo 返り値が意味不明なので直した方が良いかもしれない。
2787  */
2788 static bool research_mon(player_type *player_ptr)
2789 {
2790         char buf[128];
2791         bool notpicked;
2792         bool recall = FALSE;
2793         u16b why = 0;
2794         MONSTER_IDX *who;
2795
2796         bool all = FALSE;
2797         bool uniq = FALSE;
2798         bool norm = FALSE;
2799         char temp[80] = "";
2800
2801         static int old_sym = '\0';
2802         static IDX old_i = 0;
2803         screen_save();
2804
2805         char sym;
2806         if (!get_com(_("モンスターの文字を入力して下さい(記号 or ^A全,^Uユ,^N非ユ,^M名前):",
2807                 "Enter character to be identified(^A:All,^U:Uniqs,^N:Non uniqs,^M:Name): "), &sym, FALSE))
2808
2809         {
2810                 screen_load();
2811                 return FALSE;
2812         }
2813
2814         IDX i;
2815         for (i = 0; ident_info[i]; ++i)
2816         {
2817                 if (sym == ident_info[i][0]) break;
2818         }
2819
2820         /* XTRA HACK WHATSEARCH */
2821         if (sym == KTRL('A'))
2822         {
2823                 all = TRUE;
2824                 strcpy(buf, _("全モンスターのリスト", "Full monster list."));
2825         }
2826         else if (sym == KTRL('U'))
2827         {
2828                 all = uniq = TRUE;
2829                 strcpy(buf, _("ユニーク・モンスターのリスト", "Unique monster list."));
2830         }
2831         else if (sym == KTRL('N'))
2832         {
2833                 all = norm = TRUE;
2834                 strcpy(buf, _("ユニーク外モンスターのリスト", "Non-unique monster list."));
2835         }
2836         else if (sym == KTRL('M'))
2837         {
2838                 all = TRUE;
2839                 if (!get_string(_("名前(英語の場合小文字で可)", "Enter name:"), temp, 70))
2840                 {
2841                         temp[0] = 0;
2842                         screen_load();
2843
2844                         return FALSE;
2845                 }
2846
2847                 sprintf(buf, _("名前:%sにマッチ", "Monsters with a name \"%s\""), temp);
2848         }
2849         else if (ident_info[i])
2850         {
2851                 sprintf(buf, "%c - %s.", sym, ident_info[i] + 2);
2852         }
2853         else
2854         {
2855                 sprintf(buf, "%c - %s", sym, _("無効な文字", "Unknown Symbol"));
2856         }
2857
2858         /* Display the result */
2859         prt(buf, 16, 10);
2860
2861         /* Allocate the "who" array */
2862         C_MAKE(who, max_r_idx, MONRACE_IDX);
2863
2864         /* Collect matching monsters */
2865         int n = 0;
2866         for (i = 1; i < max_r_idx; i++)
2867         {
2868                 monster_race *r_ptr = &r_info[i];
2869
2870                 /* Empty monster */
2871                 if (!r_ptr->name) continue;
2872
2873                 /* XTRA HACK WHATSEARCH */
2874                 /* Require non-unique monsters if needed */
2875                 if (norm && (r_ptr->flags1 & (RF1_UNIQUE))) continue;
2876
2877                 /* Require unique monsters if needed */
2878                 if (uniq && !(r_ptr->flags1 & (RF1_UNIQUE))) continue;
2879
2880                 /* 名前検索 */
2881                 if (temp[0])
2882                 {
2883                         for (int xx = 0; temp[xx] && xx < 80; xx++)
2884                         {
2885 #ifdef JP
2886                                 if (iskanji(temp[xx]))
2887                                 {
2888                                         xx++;
2889                                         continue;
2890                                 }
2891 #endif
2892                                 if (isupper(temp[xx])) temp[xx] = (char)tolower(temp[xx]);
2893                         }
2894
2895                         char temp2[80];
2896 #ifdef JP
2897                         strcpy(temp2, r_name + r_ptr->E_name);
2898 #else
2899                         strcpy(temp2, r_name + r_ptr->name);
2900 #endif
2901                         for (int xx = 0; temp2[xx] && xx < 80; xx++)
2902                         {
2903                                 if (isupper(temp2[xx])) temp2[xx] = (char)tolower(temp2[xx]);
2904                         }
2905
2906 #ifdef JP
2907                         if (my_strstr(temp2, temp) || my_strstr(r_name + r_ptr->name, temp))
2908 #else
2909                         if (my_strstr(temp2, temp))
2910 #endif
2911                                 who[n++] = i;
2912                 }
2913                 else if (all || (r_ptr->d_char == sym))
2914                 {
2915                         who[n++] = i;
2916                 }
2917         }
2918
2919         if (n == 0)
2920         {
2921                 C_KILL(who, max_r_idx, MONRACE_IDX);
2922                 screen_load();
2923
2924                 return FALSE;
2925         }
2926
2927         why = 2;
2928         char query = 'y';
2929
2930         if (why)
2931         {
2932                 ang_sort(who, &why, n, ang_sort_comp_hook, ang_sort_swap_hook);
2933         }
2934
2935         if (old_sym == sym && old_i < n) i = old_i;
2936         else i = n - 1;
2937
2938         notpicked = TRUE;
2939         MONRACE_IDX r_idx;
2940         while (notpicked)
2941         {
2942                 r_idx = who[i];
2943                 roff_top(r_idx);
2944                 Term_addstr(-1, TERM_WHITE, _(" ['r'思い出, ' 'で続行, ESC]", " [(r)ecall, ESC, space to continue]"));
2945                 while (TRUE)
2946                 {
2947                         if (recall)
2948                         {
2949                                 lore_do_probe(player_ptr, r_idx);
2950                                 monster_race_track(player_ptr, r_idx);
2951                                 handle_stuff(player_ptr);
2952                                 screen_roff(player_ptr, r_idx, 0x01);
2953                                 notpicked = FALSE;
2954                                 old_sym = sym;
2955                                 old_i = i;
2956                         }
2957
2958                         query = inkey();
2959                         if (query != 'r') break;
2960
2961                         recall = !recall;
2962                 }
2963
2964                 if (query == ESCAPE) break;
2965
2966                 if (query == '-')
2967                 {
2968                         if (++i == n)
2969                         {
2970                                 i = 0;
2971                                 if (!expand_list) break;
2972                         }
2973
2974                         continue;
2975                 }
2976
2977                 if (i-- == 0)
2978                 {
2979                         i = n - 1;
2980                         if (!expand_list) break;
2981                 }
2982         }
2983
2984         C_KILL(who, max_r_idx, MONRACE_IDX);
2985         screen_load();
2986         return !notpicked;
2987 }
2988
2989
2990 /*!
2991  * @brief 施設の処理実行メインルーチン / Execute a building command
2992  * @param player_ptr プレーヤーへの参照ポインタ
2993  * @param bldg 施設構造体の参照ポインタ
2994  * @param i 実行したい施設のサービステーブルの添字
2995  * @return なし
2996  */
2997 static void bldg_process_command(player_type *player_ptr, building_type *bldg, int i)
2998 {
2999         msg_flag = FALSE;
3000         msg_erase();
3001
3002         PRICE bcost;
3003         if (is_owner(player_ptr, bldg))
3004                 bcost = bldg->member_costs[i];
3005         else
3006                 bcost = bldg->other_costs[i];
3007
3008         /* action restrictions */
3009         if (((bldg->action_restr[i] == 1) && !is_member(player_ptr, bldg)) ||
3010                 ((bldg->action_restr[i] == 2) && !is_owner(player_ptr, bldg)))
3011         {
3012                 msg_print(_("それを選択する権利はありません！", "You have no right to choose that!"));
3013                 return;
3014         }
3015
3016         BACT_IDX bact = bldg->actions[i];
3017         if ((bact != BACT_RECHARGE) &&
3018                 (((bldg->member_costs[i] > player_ptr->au) && is_owner(player_ptr, bldg)) ||
3019                 ((bldg->other_costs[i] > player_ptr->au) && !is_owner(player_ptr, bldg))))
3020         {
3021                 msg_print(_("お金が足りません！", "You do not have the gold!"));
3022                 return;
3023         }
3024
3025         bool paid = FALSE;
3026         switch (bact)
3027         {
3028         case BACT_NOTHING:
3029                 /* Do nothing */
3030                 break;
3031         case BACT_RESEARCH_ITEM:
3032                 paid = identify_fully(player_ptr, FALSE);
3033                 break;
3034         case BACT_TOWN_HISTORY:
3035                 town_history(player_ptr);
3036                 break;
3037         case BACT_RACE_LEGENDS:
3038                 race_legends(player_ptr);
3039                 break;
3040         case BACT_QUEST:
3041                 castle_quest(player_ptr);
3042                 break;
3043         case BACT_KING_LEGENDS:
3044         case BACT_ARENA_LEGENDS:
3045         case BACT_LEGENDS:
3046                 show_highclass(player_ptr);
3047                 break;
3048         case BACT_POSTER:
3049         case BACT_ARENA_RULES:
3050         case BACT_ARENA:
3051                 arena_comm(player_ptr, bact);
3052                 break;
3053         case BACT_IN_BETWEEN:
3054         case BACT_CRAPS:
3055         case BACT_SPIN_WHEEL:
3056         case BACT_DICE_SLOTS:
3057         case BACT_GAMBLE_RULES:
3058         case BACT_POKER:
3059                 gamble_comm(player_ptr, bact);
3060                 break;
3061         case BACT_REST:
3062         case BACT_RUMORS:
3063         case BACT_FOOD:
3064                 paid = inn_comm(player_ptr, bact);
3065                 break;
3066         case BACT_RESEARCH_MONSTER:
3067                 paid = research_mon(player_ptr);
3068                 break;
3069         case BACT_COMPARE_WEAPONS:
3070                 paid = TRUE;
3071                 bcost = compare_weapons(player_ptr, bcost);
3072                 break;
3073         case BACT_ENCHANT_WEAPON:
3074                 item_tester_hook = object_allow_enchant_melee_weapon;
3075                 enchant_item(player_ptr, bcost, 1, 1, 0);
3076                 break;
3077         case BACT_ENCHANT_ARMOR:
3078                 item_tester_hook = object_is_armour;
3079                 enchant_item(player_ptr, bcost, 0, 0, 1);
3080                 break;
3081         case BACT_RECHARGE:
3082                 building_recharge(player_ptr);
3083                 break;
3084         case BACT_RECHARGE_ALL:
3085                 building_recharge_all(player_ptr);
3086                 break;
3087         case BACT_IDENTS:
3088                 if (!get_check(_("持ち物を全て鑑定してよろしいですか？", "Do you pay for identify all your possession? "))) break;
3089                 identify_pack(player_ptr);
3090                 msg_print(_(" 持ち物全てが鑑定されました。", "Your possessions have been identified."));
3091                 paid = TRUE;
3092                 break;
3093         case BACT_IDENT_ONE:
3094                 paid = ident_spell(player_ptr, FALSE);
3095                 break;
3096         case BACT_LEARN:
3097                 do_cmd_study(player_ptr);
3098                 break;
3099         case BACT_HEALING:
3100                 paid = cure_critical_wounds(player_ptr, 200);
3101                 break;
3102         case BACT_RESTORE:
3103                 paid = restore_all_status(player_ptr);
3104                 break;
3105         case BACT_ENCHANT_ARROWS:
3106                 item_tester_hook = item_tester_hook_ammo;
3107                 enchant_item(player_ptr, bcost, 1, 1, 0);
3108                 break;
3109         case BACT_ENCHANT_BOW:
3110                 item_tester_tval = TV_BOW;
3111                 enchant_item(player_ptr, bcost, 1, 1, 0);
3112                 break;
3113
3114         case BACT_RECALL:
3115                 if (recall_player(player_ptr, 1)) paid = TRUE;
3116                 break;
3117
3118         case BACT_TELEPORT_LEVEL:
3119                 clear_bldg(4, 20);
3120                 paid = free_level_recall(player_ptr);
3121                 break;
3122
3123         case BACT_LOSE_MUTATION:
3124                 if (player_ptr->muta1 || player_ptr->muta2 || (player_ptr->muta3 & ~MUT3_GOOD_LUCK) ||
3125                         (player_ptr->pseikaku != SEIKAKU_LUCKY && (player_ptr->muta3 & MUT3_GOOD_LUCK)))
3126                 {
3127                         while (!lose_mutation(player_ptr, 0));
3128                         paid = TRUE;
3129                         break;
3130                 }
3131
3132                 msg_print(_("治すべき突然変異が無い。", "You have no mutations."));
3133                 msg_print(NULL);
3134                 break;
3135
3136         case BACT_BATTLE:
3137                 kakutoujou(player_ptr);
3138                 break;
3139
3140         case BACT_TSUCHINOKO:
3141                 tsuchinoko();
3142                 break;
3143
3144         case BACT_BOUNTY:
3145                 show_bounty();
3146                 break;
3147
3148         case BACT_TARGET:
3149                 today_target(player_ptr);
3150                 break;
3151
3152         case BACT_KANKIN:
3153                 kankin(player_ptr);
3154                 break;
3155
3156         case BACT_HEIKOUKA:
3157                 msg_print(_("平衡化の儀式を行なった。", "You received an equalization ritual."));
3158                 set_virtue(player_ptr, V_COMPASSION, 0);
3159                 set_virtue(player_ptr, V_HONOUR, 0);
3160                 set_virtue(player_ptr, V_JUSTICE, 0);
3161                 set_virtue(player_ptr, V_SACRIFICE, 0);
3162                 set_virtue(player_ptr, V_KNOWLEDGE, 0);
3163                 set_virtue(player_ptr, V_FAITH, 0);
3164                 set_virtue(player_ptr, V_ENLIGHTEN, 0);
3165                 set_virtue(player_ptr, V_ENCHANT, 0);
3166                 set_virtue(player_ptr, V_CHANCE, 0);
3167                 set_virtue(player_ptr, V_NATURE, 0);
3168                 set_virtue(player_ptr, V_HARMONY, 0);
3169                 set_virtue(player_ptr, V_VITALITY, 0);
3170                 set_virtue(player_ptr, V_UNLIFE, 0);
3171                 set_virtue(player_ptr, V_PATIENCE, 0);
3172                 set_virtue(player_ptr, V_TEMPERANCE, 0);
3173                 set_virtue(player_ptr, V_DILIGENCE, 0);
3174                 set_virtue(player_ptr, V_VALOUR, 0);
3175                 set_virtue(player_ptr, V_INDIVIDUALISM, 0);
3176                 get_virtues(player_ptr);
3177                 paid = TRUE;
3178                 break;
3179
3180         case BACT_TELE_TOWN:
3181                 paid = tele_town(player_ptr);
3182                 break;
3183
3184         case BACT_EVAL_AC:
3185                 paid = eval_ac(player_ptr->dis_ac + player_ptr->dis_to_a);
3186                 break;
3187
3188         case BACT_BROKEN_WEAPON:
3189                 paid = TRUE;
3190                 bcost = repair_broken_weapon(player_ptr, bcost);
3191                 break;
3192         }
3193
3194         if (paid) player_ptr->au -= bcost;
3195 }
3196
3197
3198 /*!
3199  * @brief 施設入り口にプレイヤーが乗った際の処理 / Do building commands
3200  * @param プレーヤーへの参照ポインタ
3201  * @return なし
3202  */
3203 void do_cmd_bldg(player_type *player_ptr)
3204 {
3205         if (player_ptr->wild_mode) return;
3206
3207         take_turn(player_ptr, 100);
3208
3209         if (!cave_have_flag_bold(player_ptr->current_floor_ptr, player_ptr->y, player_ptr->x, FF_BLDG))
3210         {
3211                 msg_print(_("ここには建物はない。", "You see no building here."));
3212                 return;
3213         }
3214
3215         int which = f_info[player_ptr->current_floor_ptr->grid_array[player_ptr->y][player_ptr->x].feat].subtype;
3216
3217         building_type *bldg;
3218         bldg = &building[which];
3219
3220         reinit_wilderness = FALSE;
3221
3222         if ((which == 2) && (player_ptr->arena_number < 0))
3223         {
3224                 msg_print(_("「敗者に用はない。」", "'There's no place here for a LOSER like you!'"));
3225                 return;
3226         }
3227         else if ((which == 2) && player_ptr->current_floor_ptr->inside_arena)
3228         {
3229                 if (!player_ptr->exit_bldg && player_ptr->current_floor_ptr->m_cnt > 0)
3230                 {
3231                         prt(_("ゲートは閉まっている。モンスターがあなたを待っている！", "The gates are closed.  The monster awaits!"), 0, 0);
3232                 }
3233                 else
3234                 {
3235                         prepare_change_floor_mode(player_ptr, CFM_SAVE_FLOORS | CFM_NO_RETURN);
3236                         player_ptr->current_floor_ptr->inside_arena = FALSE;
3237                         player_ptr->leaving = TRUE;
3238                         command_new = SPECIAL_KEY_BUILDING;
3239                         free_turn(player_ptr);
3240                 }
3241
3242                 return;
3243         }
3244         else if (player_ptr->phase_out)
3245         {
3246                 prepare_change_floor_mode(player_ptr, CFM_SAVE_FLOORS | CFM_NO_RETURN);
3247                 player_ptr->leaving = TRUE;
3248                 player_ptr->phase_out = FALSE;
3249                 command_new = SPECIAL_KEY_BUILDING;
3250                 free_turn(player_ptr);
3251                 return;
3252         }
3253         else
3254         {
3255                 player_ptr->oldpy = player_ptr->y;
3256                 player_ptr->oldpx = player_ptr->x;
3257         }
3258
3259         forget_lite(player_ptr->current_floor_ptr);
3260         forget_view(player_ptr->current_floor_ptr);
3261         current_world_ptr->character_icky++;
3262
3263         command_arg = 0;
3264         command_rep = 0;
3265         command_new = 0;
3266
3267         show_building(player_ptr, bldg);
3268         player_ptr->leave_bldg = FALSE;
3269         play_music(TERM_XTRA_MUSIC_BASIC, MUSIC_BASIC_BUILD);
3270
3271         bool validcmd;
3272         while (!player_ptr->leave_bldg)
3273         {
3274                 validcmd = FALSE;
3275                 prt("", 1, 0);
3276
3277                 building_prt_gold(player_ptr);
3278
3279                 char command = inkey();
3280
3281                 if (command == ESCAPE)
3282                 {
3283                         player_ptr->leave_bldg = TRUE;
3284                         player_ptr->current_floor_ptr->inside_arena = FALSE;
3285                         player_ptr->phase_out = FALSE;
3286                         break;
3287                 }
3288
3289                 int i;
3290                 for (i = 0; i < 8; i++)
3291                 {
3292                         if (bldg->letters[i] && (bldg->letters[i] == command))
3293                         {
3294                                 validcmd = TRUE;
3295                                 break;
3296                         }
3297                 }
3298
3299                 if (validcmd) bldg_process_command(player_ptr, bldg, i);
3300
3301                 handle_stuff(player_ptr);
3302         }
3303
3304         select_floor_music(player_ptr);
3305
3306         msg_flag = FALSE;
3307         msg_erase();
3308
3309         if (reinit_wilderness) player_ptr->leaving = TRUE;
3310
3311         current_world_ptr->character_icky--;
3312         Term_clear();
3313
3314         player_ptr->update |= (PU_VIEW | PU_MONSTERS | PU_BONUS | PU_LITE | PU_MON_LITE);
3315         player_ptr->redraw |= (PR_BASIC | PR_EXTRA | PR_EQUIPPY | PR_MAP);
3316         player_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
3317 }
3318
3319
3320 /*!
3321  * @brief 今日の賞金首を確定する / Determine today's bounty monster
3322  * @param player_type プレーヤーへの参照ポインタ
3323  * @return なし
3324  * @note conv_old is used if loaded 0.0.3 or older save file
3325  */
3326 void determine_daily_bounty(player_type *player_ptr, bool conv_old)
3327 {
3328         int max_dl = 3, i;
3329         if (!conv_old)
3330         {
3331                 for (i = 0; i < current_world_ptr->max_d_idx; i++)
3332                 {
3333                         if (max_dlv[i] < d_info[i].mindepth) continue;
3334                         if (max_dl < max_dlv[i]) max_dl = max_dlv[i];
3335                 }
3336         }
3337         else
3338         {
3339                 max_dl = MAX(max_dlv[DUNGEON_ANGBAND], 3);
3340         }
3341
3342         get_mon_num_prep(player_ptr, NULL, NULL);
3343
3344         while (TRUE)
3345         {
3346                 today_mon = get_mon_num(player_ptr, max_dl, GMN_ARENA);
3347                 monster_race *r_ptr;
3348                 r_ptr = &r_info[today_mon];
3349
3350                 if (r_ptr->flags1 & RF1_UNIQUE) continue;
3351                 if (r_ptr->flags7 & (RF7_NAZGUL | RF7_UNIQUE2)) continue;
3352                 if (r_ptr->flags2 & RF2_MULTIPLY) continue;
3353                 if ((r_ptr->flags9 & (RF9_DROP_CORPSE | RF9_DROP_SKELETON)) != (RF9_DROP_CORPSE | RF9_DROP_SKELETON)) continue;
3354                 if (r_ptr->level < MIN(max_dl / 2, 40)) continue;
3355                 if (r_ptr->rarity > 10) continue;
3356                 break;
3357         }
3358 }
3359
3360
3361 /*!
3362  * @brief 賞金首となるユニークを確定する / Determine bounty uniques
3363  * @param player_ptr プレーヤーへの参照ポインタ
3364  * @return なし
3365  */
3366 void determine_bounty_uniques(player_type *player_ptr)
3367 {
3368         get_mon_num_prep(player_ptr, NULL, NULL);
3369         for (int i = 0; i < MAX_BOUNTY; i++)
3370         {
3371                 while (TRUE)
3372                 {
3373                         current_world_ptr->bounty_r_idx[i] = get_mon_num(player_ptr, MAX_DEPTH - 1, GMN_ARENA);
3374                         monster_race *r_ptr;
3375                         r_ptr = &r_info[current_world_ptr->bounty_r_idx[i]];
3376
3377                         if (!(r_ptr->flags1 & RF1_UNIQUE)) continue;
3378
3379                         if (!(r_ptr->flags9 & (RF9_DROP_CORPSE | RF9_DROP_SKELETON)))
3380                                 continue;
3381
3382                         if (r_ptr->rarity > 100) continue;
3383
3384                         if (no_questor_or_bounty_uniques(current_world_ptr->bounty_r_idx[i]))
3385                                 continue;
3386
3387                         int j;
3388                         for (j = 0; j < i; j++)
3389                         {
3390                                 if (current_world_ptr->bounty_r_idx[i] == current_world_ptr->bounty_r_idx[j])
3391                                         break;
3392                         }
3393
3394                         if (j == i) break;
3395                 }
3396         }
3397
3398         for (int i = 0; i < MAX_BOUNTY - 1; i++)
3399         {
3400                 for (int j = i; j < MAX_BOUNTY; j++)
3401                 {
3402                         MONRACE_IDX tmp;
3403                         if (r_info[current_world_ptr->bounty_r_idx[i]].level > r_info[current_world_ptr->bounty_r_idx[j]].level)
3404                         {
3405                                 tmp = current_world_ptr->bounty_r_idx[i];
3406                                 current_world_ptr->bounty_r_idx[i] = current_world_ptr->bounty_r_idx[j];
3407                                 current_world_ptr->bounty_r_idx[j] = tmp;
3408                         }
3409                 }
3410         }
3411 }