src/object2.c

   1 /*!
   2  * @file object2.c
   3  * @brief オブジェクトの実装 / Object code, part 2
   4  * @date 2014/01/11
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
   7  *\n
   8  * This software may be copied and distributed for educational, research,\n
   9  * and not for profit purposes provided that this copyright and statement\n
  10  * are included in all such copies.  Other copyrights may also apply.\n
  11  * 2014 Deskull rearranged comment for Doxygen.\n
  12  */
  13
  14 #include "angband.h"
  15
  16 static cptr const kaji_tips[5] =
  17 {
  18 #ifdef JP
  19         "現在持っているエッセンスの一覧を表示する。",
  20         "アイテムからエッセンスを取り出す。エッセンスを取られたアイテムは全く魔法がかかっていない初期状態に戻る。",
  21         "既にエッセンスが付加されたアイテムからエッセンスのみ消し去る。エッセンスは手に入らない。",
  22         "アイテムにエッセンスを付加する。既にエッセンスが付加されたアイテムやアーティファクトには付加できない。",
  23         "武器や防具を強化したり、攻撃で傷つかないようにしたりする。エッセンスが付加されたアイテムやアーティファクトに対しても使用できる。",
  24 #else
  25         "Display essences you have.",
  26         "Extract essences from an item. The item become non magical.",
  27         "Remove added essences from an equipment which was improved before. The removed essence will be ruined.",
  28         "Add essences to an item. The improved items or artifacts cannot be reimprove.",
  29         "Enchant an equipment or make an equiment element-proofed. The improved items and artifacts can be enchanted too.",
  30 #endif
  31 };
  32
  33 /*!
  34  * @brief 床上、モンスター所持でスタックされたアイテムを削除しスタックを補完する / Excise a dungeon object from any stacks
  35  * @param o_idx 削除対象のオブジェクト構造体ポインタ
  36  * @return なし
  37  */
  38 void excise_object_idx(int o_idx)
  39 {
  40         object_type *j_ptr;
  41
  42         s16b this_o_idx, next_o_idx = 0;
  43
  44         s16b prev_o_idx = 0;
  45
  46
  47         /* Object */
  48         j_ptr = &o_list[o_idx];
  49
  50         /* Monster */
  51         if (j_ptr->held_m_idx)
  52         {
  53                 monster_type *m_ptr;
  54
  55                 /* Monster */
  56                 m_ptr = &m_list[j_ptr->held_m_idx];
  57
  58                 /* Scan all objects in the grid */
  59                 for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
  60                 {
  61                         object_type *o_ptr;
  62
  63                         /* Acquire object */
  64                         o_ptr = &o_list[this_o_idx];
  65
  66                         /* Acquire next object */
  67                         next_o_idx = o_ptr->next_o_idx;
  68
  69                         /* Done */
  70                         if (this_o_idx == o_idx)
  71                         {
  72                                 /* No previous */
  73                                 if (prev_o_idx == 0)
  74                                 {
  75                                         /* Remove from list */
  76                                         m_ptr->hold_o_idx = next_o_idx;
  77                                 }
  78
  79                                 /* Real previous */
  80                                 else
  81                                 {
  82                                         object_type *k_ptr;
  83
  84                                         /* Previous object */
  85                                         k_ptr = &o_list[prev_o_idx];
  86
  87                                         /* Remove from list */
  88                                         k_ptr->next_o_idx = next_o_idx;
  89                                 }
  90
  91                                 /* Forget next pointer */
  92                                 o_ptr->next_o_idx = 0;
  93
  94                                 /* Done */
  95                                 break;
  96                         }
  97
  98                         /* Save prev_o_idx */
  99                         prev_o_idx = this_o_idx;
 100                 }
 101         }
 102
 103         /* Dungeon */
 104         else
 105         {
 106                 cave_type *c_ptr;
 107
 108                 int y = j_ptr->iy;
 109                 int x = j_ptr->ix;
 110
 111                 /* Grid */
 112                 c_ptr = &cave[y][x];
 113
 114                 /* Scan all objects in the grid */
 115                 for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 116                 {
 117                         object_type *o_ptr;
 118
 119                         /* Acquire object */
 120                         o_ptr = &o_list[this_o_idx];
 121
 122                         /* Acquire next object */
 123                         next_o_idx = o_ptr->next_o_idx;
 124
 125                         /* Done */
 126                         if (this_o_idx == o_idx)
 127                         {
 128                                 /* No previous */
 129                                 if (prev_o_idx == 0)
 130                                 {
 131                                         /* Remove from list */
 132                                         c_ptr->o_idx = next_o_idx;
 133                                 }
 134
 135                                 /* Real previous */
 136                                 else
 137                                 {
 138                                         object_type *k_ptr;
 139
 140                                         /* Previous object */
 141                                         k_ptr = &o_list[prev_o_idx];
 142
 143                                         /* Remove from list */
 144                                         k_ptr->next_o_idx = next_o_idx;
 145                                 }
 146
 147                                 /* Forget next pointer */
 148                                 o_ptr->next_o_idx = 0;
 149
 150                                 /* Done */
 151                                 break;
 152                         }
 153
 154                         /* Save prev_o_idx */
 155                         prev_o_idx = this_o_idx;
 156                 }
 157         }
 158 }
 159
 160 /*!
 161  * @brief オブジェクトを削除する /
 162  * Delete a dungeon object
 163  * @param o_idx 削除対象のオブジェクト構造体ポインタ
 164  * @return なし
 165  * @details
 166  * Handle "stacks" of objects correctly.
 167  */
 168 void delete_object_idx(int o_idx)
 169 {
 170         object_type *j_ptr;
 171
 172         /* Excise */
 173         excise_object_idx(o_idx);
 174
 175         /* Object */
 176         j_ptr = &o_list[o_idx];
 177
 178         /* Dungeon floor */
 179         if (!(j_ptr->held_m_idx))
 180         {
 181                 int y, x;
 182
 183                 /* Location */
 184                 y = j_ptr->iy;
 185                 x = j_ptr->ix;
 186
 187                 /* Visual update */
 188                 lite_spot(y, x);
 189         }
 190
 191         /* Wipe the object */
 192         object_wipe(j_ptr);
 193
 194         /* Count objects */
 195         o_cnt--;
 196 }
 197
 198
 199 /*!
 200  * @brief フロアにマスに落ちているオブジェクトを全て削除する / Deletes all objects at given location
 201  * Delete a dungeon object
 202  * @param y 削除したフロアマスのY座標
 203  * @param x 削除したフロアマスのX座標
 204  * @return なし
 205  */
 206 void delete_object(int y, int x)
 207 {
 208         cave_type *c_ptr;
 209
 210         s16b this_o_idx, next_o_idx = 0;
 211
 212
 213         /* Refuse "illegal" locations */
 214         if (!in_bounds(y, x)) return;
 215
 216
 217         /* Grid */
 218         c_ptr = &cave[y][x];
 219
 220         /* Scan all objects in the grid */
 221         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 222         {
 223                 object_type *o_ptr;
 224
 225                 /* Acquire object */
 226                 o_ptr = &o_list[this_o_idx];
 227
 228                 /* Acquire next object */
 229                 next_o_idx = o_ptr->next_o_idx;
 230
 231                 /* Wipe the object */
 232                 object_wipe(o_ptr);
 233
 234                 /* Count objects */
 235                 o_cnt--;
 236         }
 237
 238         /* Objects are gone */
 239         c_ptr->o_idx = 0;
 240
 241         /* Visual update */
 242         lite_spot(y, x);
 243 }
 244
 245
 246 /*!
 247  * @brief グローバルオブジェクト配列に対し指定範囲のオブジェクトを整理してIDの若い順に寄せる /
 248  * Move an object from index i1 to index i2 in the object list
 249  * @param i1 整理したい配列の始点
 250  * @param i2 整理したい配列の終点
 251  * @return なし
 252  */
 253 static void compact_objects_aux(IDX i1, IDX i2)
 254 {
 255         IDX i;
 256         cave_type *c_ptr;
 257         object_type *o_ptr;
 258
 259         /* Do nothing */
 260         if (i1 == i2) return;
 261
 262
 263         /* Repair objects */
 264         for (i = 1; i < o_max; i++)
 265         {
 266                 /* Acquire object */
 267                 o_ptr = &o_list[i];
 268
 269                 /* Skip "dead" objects */
 270                 if (!o_ptr->k_idx) continue;
 271
 272                 /* Repair "next" pointers */
 273                 if (o_ptr->next_o_idx == i1)
 274                 {
 275                         /* Repair */
 276                         o_ptr->next_o_idx = i2;
 277                 }
 278         }
 279
 280
 281         /* Acquire object */
 282         o_ptr = &o_list[i1];
 283
 284
 285         /* Monster */
 286         if (o_ptr->held_m_idx)
 287         {
 288                 monster_type *m_ptr;
 289
 290                 /* Acquire monster */
 291                 m_ptr = &m_list[o_ptr->held_m_idx];
 292
 293                 /* Repair monster */
 294                 if (m_ptr->hold_o_idx == i1)
 295                 {
 296                         /* Repair */
 297                         m_ptr->hold_o_idx = i2;
 298                 }
 299         }
 300
 301         /* Dungeon */
 302         else
 303         {
 304                 int y, x;
 305
 306                 /* Acquire location */
 307                 y = o_ptr->iy;
 308                 x = o_ptr->ix;
 309
 310                 /* Acquire grid */
 311                 c_ptr = &cave[y][x];
 312
 313                 /* Repair grid */
 314                 if (c_ptr->o_idx == i1)
 315                 {
 316                         /* Repair */
 317                         c_ptr->o_idx = i2;
 318                 }
 319         }
 320
 321
 322         /* Structure copy */
 323         o_list[i2] = o_list[i1];
 324
 325         /* Wipe the hole */
 326         object_wipe(o_ptr);
 327 }
 328
 329
 330 /*!
 331  * @brief グローバルオブジェクト配列から優先度の低いものを削除し、データを圧縮する。 /
 332  * Compact and Reorder the object list.
 333  * @param size 最低でも減らしたいオブジェクト数の水準
 334  * @return なし
 335  * @details
 336  * （危険なので使用には注意すること）
 337  * This function can be very dangerous, use with caution!\n
 338  *\n
 339  * When actually "compacting" objects, we base the saving throw on a\n
 340  * combination of object level, distance from player, and current\n
 341  * "desperation".\n
 342  *\n
 343  * After "compacting" (if needed), we "reorder" the objects into a more\n
 344  * compact order, and we reset the allocation info, and the "live" array.\n
 345  */
 346 void compact_objects(int size)
 347 {
 348         int i, y, x, num, cnt;
 349         int cur_lev, cur_dis, chance;
 350         object_type *o_ptr;
 351
 352
 353         /* Compact */
 354         if (size)
 355         {
 356                 /* Message */
 357                 msg_print(_("アイテム情報を圧縮しています...", "Compacting objects..."));
 358
 359                 /* Redraw map */
 360                 p_ptr->redraw |= (PR_MAP);
 361
 362                 /* Window stuff */
 363                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 364         }
 365
 366
 367         /* Compact at least 'size' objects */
 368         for (num = 0, cnt = 1; num < size; cnt++)
 369         {
 370                 /* Get more vicious each iteration */
 371                 cur_lev = 5 * cnt;
 372
 373                 /* Get closer each iteration */
 374                 cur_dis = 5 * (20 - cnt);
 375
 376                 /* Examine the objects */
 377                 for (i = 1; i < o_max; i++)
 378                 {
 379                         o_ptr = &o_list[i];
 380
 381                         /* Skip dead objects */
 382                         if (!o_ptr->k_idx) continue;
 383
 384                         /* Hack -- High level objects start out "immune" */
 385                         if (k_info[o_ptr->k_idx].level > cur_lev) continue;
 386
 387                         /* Monster */
 388                         if (o_ptr->held_m_idx)
 389                         {
 390                                 monster_type *m_ptr;
 391
 392                                 /* Acquire monster */
 393                                 m_ptr = &m_list[o_ptr->held_m_idx];
 394
 395                                 /* Get the location */
 396                                 y = m_ptr->fy;
 397                                 x = m_ptr->fx;
 398
 399                                 /* Monsters protect their objects */
 400                                 if (randint0(100) < 90) continue;
 401                         }
 402
 403                         /* Dungeon */
 404                         else
 405                         {
 406                                 /* Get the location */
 407                                 y = o_ptr->iy;
 408                                 x = o_ptr->ix;
 409                         }
 410
 411                         /* Nearby objects start out "immune" */
 412                         if ((cur_dis > 0) && (distance(p_ptr->y, p_ptr->x, y, x) < cur_dis)) continue;
 413
 414                         /* Saving throw */
 415                         chance = 90;
 416
 417                         /* Hack -- only compact artifacts in emergencies */
 418                         if ((object_is_fixed_artifact(o_ptr) || o_ptr->art_name) &&
 419                             (cnt < 1000)) chance = 100;
 420
 421                         /* Apply the saving throw */
 422                         if (randint0(100) < chance) continue;
 423
 424                         /* Delete the object */
 425                         delete_object_idx(i);
 426
 427                         /* Count it */
 428                         num++;
 429                 }
 430         }
 431
 432
 433         /* Excise dead objects (backwards!) */
 434         for (i = o_max - 1; i >= 1; i--)
 435         {
 436                 o_ptr = &o_list[i];
 437
 438                 /* Skip real objects */
 439                 if (o_ptr->k_idx) continue;
 440
 441                 /* Move last object into open hole */
 442                 compact_objects_aux(o_max - 1, i);
 443
 444                 /* Compress "o_max" */
 445                 o_max--;
 446         }
 447 }
 448
 449
 450 /*!
 451  * @brief グローバルオブジェクト配列を初期化する /
 452  * Delete all the items when player leaves the level
 453  * @note we do NOT visually reflect these (irrelevant) changes
 454  * @details
 455  * Hack -- we clear the "c_ptr->o_idx" field for every grid,
 456  * and the "m_ptr->next_o_idx" field for every monster, since
 457  * we know we are clearing every object.  Technically, we only
 458  * clear those fields for grids/monsters containing objects,
 459  * and we clear it once for every such object.
 460  * @return なし
 461  */
 462 void wipe_o_list(void)
 463 {
 464         int i;
 465
 466         /* Delete the existing objects */
 467         for (i = 1; i < o_max; i++)
 468         {
 469                 object_type *o_ptr = &o_list[i];
 470
 471                 /* Skip dead objects */
 472                 if (!o_ptr->k_idx) continue;
 473
 474                 /* Mega-Hack -- preserve artifacts */
 475                 if (!character_dungeon || preserve_mode)
 476                 {
 477                         /* Hack -- Preserve unknown artifacts */
 478                         if (object_is_fixed_artifact(o_ptr) && !object_is_known(o_ptr))
 479                         {
 480                                 /* Mega-Hack -- Preserve the artifact */
 481                                 a_info[o_ptr->name1].cur_num = 0;
 482                         }
 483                 }
 484
 485                 /* Monster */
 486                 if (o_ptr->held_m_idx)
 487                 {
 488                         monster_type *m_ptr;
 489
 490                         /* Monster */
 491                         m_ptr = &m_list[o_ptr->held_m_idx];
 492
 493                         /* Hack -- see above */
 494                         m_ptr->hold_o_idx = 0;
 495                 }
 496
 497                 /* Dungeon */
 498                 else
 499                 {
 500                         cave_type *c_ptr;
 501
 502                         /* Access location */
 503                         int y = o_ptr->iy;
 504                         int x = o_ptr->ix;
 505
 506                         /* Access grid */
 507                         c_ptr = &cave[y][x];
 508
 509                         /* Hack -- see above */
 510                         c_ptr->o_idx = 0;
 511                 }
 512
 513                 /* Wipe the object */
 514                 object_wipe(o_ptr);
 515         }
 516
 517         /* Reset "o_max" */
 518         o_max = 1;
 519
 520         /* Reset "o_cnt" */
 521         o_cnt = 0;
 522 }
 523
 524
 525 /*!
 526  * @brief グローバルオブジェクト配列から空きを取得する /
 527  * Acquires and returns the index of a "free" object.
 528  * @return 開いているオブジェクト要素のID
 529  * @details
 530  * This routine should almost never fail, but in case it does,
 531  * we must be sure to handle "failure" of this routine.
 532  */
 533 s16b o_pop(void)
 534 {
 535         int i;
 536
 537
 538         /* Initial allocation */
 539         if (o_max < max_o_idx)
 540         {
 541                 /* Get next space */
 542                 i = o_max;
 543
 544                 /* Expand object array */
 545                 o_max++;
 546
 547                 /* Count objects */
 548                 o_cnt++;
 549
 550                 /* Use this object */
 551                 return (i);
 552         }
 553
 554
 555         /* Recycle dead objects */
 556         for (i = 1; i < o_max; i++)
 557         {
 558                 object_type *o_ptr;
 559
 560                 /* Acquire object */
 561                 o_ptr = &o_list[i];
 562
 563                 /* Skip live objects */
 564                 if (o_ptr->k_idx) continue;
 565
 566                 /* Count objects */
 567                 o_cnt++;
 568
 569                 /* Use this object */
 570                 return (i);
 571         }
 572
 573
 574         /* Warn the player (except during dungeon creation) */
 575         if (character_dungeon) msg_print(_("アイテムが多すぎる！", "Too many objects!"));
 576
 577         /* Oops */
 578         return (0);
 579 }
 580
 581
 582 /*!
 583  * @brief オブジェクト生成テーブルに生成制約を加える /
 584  * Apply a "object restriction function" to the "object allocation table"
 585  * @return 常に0を返す。
 586  * @details 生成の制約はグローバルのget_obj_num_hook関数ポインタで加える
 587  */
 588 static errr get_obj_num_prep(void)
 589 {
 590         int i;
 591
 592         /* Get the entry */
 593         alloc_entry *table = alloc_kind_table;
 594
 595         /* Scan the allocation table */
 596         for (i = 0; i < alloc_kind_size; i++)
 597         {
 598                 /* Accept objects which pass the restriction, if any */
 599                 if (!get_obj_num_hook || (*get_obj_num_hook)(table[i].index))
 600                 {
 601                         /* Accept this object */
 602                         table[i].prob2 = table[i].prob1;
 603                 }
 604
 605                 /* Do not use this object */
 606                 else
 607                 {
 608                         /* Decline this object */
 609                         table[i].prob2 = 0;
 610                 }
 611         }
 612
 613         /* Success */
 614         return (0);
 615 }
 616
 617
 618 /*!
 619  * @brief オブジェクト生成テーブルからアイテムを取得する /
 620  * Choose an object kind that seems "appropriate" to the given level
 621  * @param level 生成階
 622  * @return 選ばれたオブジェクトベースID
 623  * @details
 624  * This function uses the "prob2" field of the "object allocation table",\n
 625  * and various local information, to calculate the "prob3" field of the\n
 626  * same table, which is then used to choose an "appropriate" object, in\n
 627  * a relatively efficient manner.\n
 628  *\n
 629  * It is (slightly) more likely to acquire an object of the given level\n
 630  * than one of a lower level.  This is done by choosing several objects\n
 631  * appropriate to the given level and keeping the "hardest" one.\n
 632  *\n
 633  * Note that if no objects are "appropriate", then this function will\n
 634  * fail, and return zero, but this should *almost* never happen.\n
 635  */
 636 s16b get_obj_num(int level)
 637 {
 638         int             i, j, p;
 639         int             k_idx;
 640         long            value, total;
 641         object_kind     *k_ptr;
 642         alloc_entry     *table = alloc_kind_table;
 643
 644         if (level > MAX_DEPTH - 1) level = MAX_DEPTH - 1;
 645
 646         /* Boost level */
 647         if ((level > 0) && !(d_info[dungeon_type].flags1 & DF1_BEGINNER))
 648         {
 649                 /* Occasional "boost" */
 650                 if (one_in_(GREAT_OBJ))
 651                 {
 652                         /* What a bizarre calculation */
 653                         level = 1 + (level * MAX_DEPTH / randint1(MAX_DEPTH));
 654                 }
 655         }
 656
 657         /* Reset total */
 658         total = 0L;
 659
 660         /* Process probabilities */
 661         for (i = 0; i < alloc_kind_size; i++)
 662         {
 663                 /* Objects are sorted by depth */
 664                 if (table[i].level > level) break;
 665
 666                 /* Default */
 667                 table[i].prob3 = 0;
 668
 669                 /* Access the index */
 670                 k_idx = table[i].index;
 671
 672                 /* Access the actual kind */
 673                 k_ptr = &k_info[k_idx];
 674
 675                 /* Hack -- prevent embedded chests */
 676                 if (opening_chest && (k_ptr->tval == TV_CHEST)) continue;
 677
 678                 /* Accept */
 679                 table[i].prob3 = table[i].prob2;
 680
 681                 /* Total */
 682                 total += table[i].prob3;
 683         }
 684
 685         /* No legal objects */
 686         if (total <= 0) return (0);
 687
 688
 689         /* Pick an object */
 690         value = randint0(total);
 691
 692         /* Find the object */
 693         for (i = 0; i < alloc_kind_size; i++)
 694         {
 695                 /* Found the entry */
 696                 if (value < table[i].prob3) break;
 697
 698                 /* Decrement */
 699                 value = value - table[i].prob3;
 700         }
 701
 702
 703         /* Power boost */
 704         p = randint0(100);
 705
 706         /* Try for a "better" object once (50%) or twice (10%) */
 707         if (p < 60)
 708         {
 709                 /* Save old */
 710                 j = i;
 711
 712                 /* Pick a object */
 713                 value = randint0(total);
 714
 715                 /* Find the object */
 716                 for (i = 0; i < alloc_kind_size; i++)
 717                 {
 718                         /* Found the entry */
 719                         if (value < table[i].prob3) break;
 720
 721                         /* Decrement */
 722                         value = value - table[i].prob3;
 723                 }
 724
 725                 /* Keep the "best" one */
 726                 if (table[i].level < table[j].level) i = j;
 727         }
 728
 729         /* Try for a "better" object twice (10%) */
 730         if (p < 10)
 731         {
 732                 /* Save old */
 733                 j = i;
 734
 735                 /* Pick a object */
 736                 value = randint0(total);
 737
 738                 /* Find the object */
 739                 for (i = 0; i < alloc_kind_size; i++)
 740                 {
 741                         /* Found the entry */
 742                         if (value < table[i].prob3) break;
 743
 744                         /* Decrement */
 745                         value = value - table[i].prob3;
 746                 }
 747
 748                 /* Keep the "best" one */
 749                 if (table[i].level < table[j].level) i = j;
 750         }
 751
 752
 753         /* Result */
 754         return (table[i].index);
 755 }
 756
 757
 758 /*!
 759  * @brief オブジェクトを鑑定済にする /
 760  * Known is true when the "attributes" of an object are "known".
 761  * @param o_ptr 鑑定済にするオブジェクトの構造体参照ポインタ
 762  * @return なし
 763  * These include tohit, todam, toac, cost, and pval (charges).\n
 764  *\n
 765  * Note that "knowing" an object gives you everything that an "awareness"\n
 766  * gives you, and much more.  In fact, the player is always "aware" of any\n
 767  * item of which he has full "knowledge".\n
 768  *\n
 769  * But having full knowledge of, say, one "wand of wonder", does not, by\n
 770  * itself, give you knowledge, or even awareness, of other "wands of wonder".\n
 771  * It happens that most "identify" routines (including "buying from a shop")\n
 772  * will make the player "aware" of the object as well as fully "know" it.\n
 773  *\n
 774  * This routine also removes any inscriptions generated by "feelings".\n
 775  */
 776 void object_known(object_type *o_ptr)
 777 {
 778         /* Remove "default inscriptions" */
 779         o_ptr->feeling = FEEL_NONE;
 780
 781         /* Clear the "Felt" info */
 782         o_ptr->ident &= ~(IDENT_SENSE);
 783
 784         /* Clear the "Empty" info */
 785         o_ptr->ident &= ~(IDENT_EMPTY);
 786
 787         /* Now we know about the item */
 788         o_ptr->ident |= (IDENT_KNOWN);
 789 }
 790
 791 /*!
 792  * @brief オブジェクトを＊鑑定＊済にする /
 793  * The player is now aware of the effects of the given object.
 794  * @param o_ptr ＊鑑定＊済にするオブジェクトの構造体参照ポインタ
 795  * @return なし
 796  */
 797 void object_aware(object_type *o_ptr)
 798 {
 799         bool mihanmei = !object_is_aware(o_ptr);
 800
 801         /* Fully aware of the effects */
 802         k_info[o_ptr->k_idx].aware = TRUE;
 803
 804         if(mihanmei && !(k_info[o_ptr->k_idx].gen_flags & TRG_INSTA_ART) && record_ident &&
 805            !p_ptr->is_dead && ((o_ptr->tval >= TV_AMULET && o_ptr->tval <= TV_POTION) || (o_ptr->tval == TV_FOOD)))
 806         {
 807                 object_type forge;
 808                 object_type *q_ptr;
 809                 char o_name[MAX_NLEN];
 810
 811                 q_ptr = &forge;
 812                 object_copy(q_ptr, o_ptr);
 813
 814                 q_ptr->number = 1;
 815                 object_desc(o_name, q_ptr, OD_NAME_ONLY);
 816
 817                 do_cmd_write_nikki(NIKKI_HANMEI, 0, o_name);
 818         }
 819 }
 820
 821
 822 /*!
 823  * @brief オブジェクトを試行済にする /
 824  * Something has been "sampled"
 825  * @param o_ptr 試行済にするオブジェクトの構造体参照ポインタ
 826  * @return なし
 827  */
 828 void object_tried(object_type *o_ptr)
 829 {
 830         /* Mark it as tried (even if "aware") */
 831         k_info[o_ptr->k_idx].tried = TRUE;
 832 }
 833
 834
 835 /*!
 836  * @brief 未鑑定なベースアイテムの基本価格を返す /
 837  * Return the "value" of an "unknown" item Make a guess at the value of non-aware items
 838  * @param o_ptr 未鑑定価格を確認したいオブジェクトの構造体参照ポインタ
 839  * @return オブジェクトの未鑑定価格
 840  */
 841 static s32b object_value_base(object_type *o_ptr)
 842 {
 843         /* Aware item -- use template cost */
 844         if (object_is_aware(o_ptr)) return (k_info[o_ptr->k_idx].cost);
 845
 846         /* Analyze the type */
 847         switch (o_ptr->tval)
 848         {
 849
 850                 /* Un-aware Food */
 851                 case TV_FOOD: return (5L);
 852
 853                 /* Un-aware Potions */
 854                 case TV_POTION: return (20L);
 855
 856                 /* Un-aware Scrolls */
 857                 case TV_SCROLL: return (20L);
 858
 859                 /* Un-aware Staffs */
 860                 case TV_STAFF: return (70L);
 861
 862                 /* Un-aware Wands */
 863                 case TV_WAND: return (50L);
 864
 865                 /* Un-aware Rods */
 866                 case TV_ROD: return (90L);
 867
 868                 /* Un-aware Rings */
 869                 case TV_RING: return (45L);
 870
 871                 /* Un-aware Amulets */
 872                 case TV_AMULET: return (45L);
 873
 874                 /* Figurines, relative to monster level */
 875                 case TV_FIGURINE:
 876                 {
 877                         int level = r_info[o_ptr->pval].level;
 878                         if (level < 20) return level*50L;
 879                         else if (level < 30) return 1000+(level-20)*150L;
 880                         else if (level < 40) return 2500+(level-30)*350L;
 881                         else if (level < 50) return 6000+(level-40)*800L;
 882                         else return 14000+(level-50)*2000L;
 883                 }
 884
 885                 case TV_CAPTURE:
 886                         if (!o_ptr->pval) return 1000L;
 887                         else return ((r_info[o_ptr->pval].level) * 50L + 1000);
 888         }
 889
 890         /* Paranoia -- Oops */
 891         return (0L);
 892 }
 893
 894
 895 /*!
 896  * @brief オブジェクトのフラグ類から価格を算出する /
 897  * Return the value of the flags the object has...
 898  * @param o_ptr フラグ価格を確認したいオブジェクトの構造体参照ポインタ
 899  * @param plusses フラグに与える価格の基本重み
 900  * @return オブジェクトのフラグ価格
 901  */
 902 s32b flag_cost(object_type *o_ptr, int plusses)
 903 {
 904         s32b total = 0;
 905         u32b flgs[TR_FLAG_SIZE];
 906         s32b tmp_cost;
 907         int count;
 908         int i;
 909         object_kind *k_ptr = &k_info[o_ptr->k_idx];
 910
 911         object_flags(o_ptr, flgs);
 912
 913         /*
 914          * Exclude fixed flags of the base item.
 915          * pval bonuses of base item will be treated later.
 916          */
 917         for (i = 0; i < TR_FLAG_SIZE; i++)
 918                 flgs[i] &= ~(k_ptr->flags[i]);
 919
 920         /* Exclude fixed flags of the fixed artifact. */
 921         if (object_is_fixed_artifact(o_ptr))
 922         {
 923                 artifact_type *a_ptr = &a_info[o_ptr->name1];
 924
 925                 for (i = 0; i < TR_FLAG_SIZE; i++)
 926                         flgs[i] &= ~(a_ptr->flags[i]);
 927         }
 928
 929         /* Exclude fixed flags of the ego-item. */
 930         else if (object_is_ego(o_ptr))
 931         {
 932                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
 933
 934                 for (i = 0; i < TR_FLAG_SIZE; i++)
 935                         flgs[i] &= ~(e_ptr->flags[i]);
 936         }
 937
 938
 939         /*
 940          * Calucurate values of remaining flags
 941          */
 942         if (have_flag(flgs, TR_STR)) total += (1500 * plusses);
 943         if (have_flag(flgs, TR_INT)) total += (1500 * plusses);
 944         if (have_flag(flgs, TR_WIS)) total += (1500 * plusses);
 945         if (have_flag(flgs, TR_DEX)) total += (1500 * plusses);
 946         if (have_flag(flgs, TR_CON)) total += (1500 * plusses);
 947         if (have_flag(flgs, TR_CHR)) total += (750 * plusses);
 948         if (have_flag(flgs, TR_MAGIC_MASTERY)) total += (600 * plusses);
 949         if (have_flag(flgs, TR_STEALTH)) total += (250 * plusses);
 950         if (have_flag(flgs, TR_SEARCH)) total += (100 * plusses);
 951         if (have_flag(flgs, TR_INFRA)) total += (150 * plusses);
 952         if (have_flag(flgs, TR_TUNNEL)) total += (175 * plusses);
 953         if ((have_flag(flgs, TR_SPEED)) && (plusses > 0))
 954                 total += (10000 + (2500 * plusses));
 955         if ((have_flag(flgs, TR_BLOWS)) && (plusses > 0))
 956                 total += (10000 + (2500 * plusses));
 957
 958         tmp_cost = 0;
 959         count = 0;
 960         if (have_flag(flgs, TR_CHAOTIC)) {total += 5000;count++;}
 961         if (have_flag(flgs, TR_VAMPIRIC)) {total += 6500;count++;}
 962         if (have_flag(flgs, TR_FORCE_WEAPON)) {tmp_cost += 2500;count++;}
 963         if (have_flag(flgs, TR_KILL_ANIMAL)) {tmp_cost += 2800;count++;}
 964         else if (have_flag(flgs, TR_SLAY_ANIMAL)) {tmp_cost += 1800;count++;}
 965         if (have_flag(flgs, TR_KILL_EVIL)) {tmp_cost += 3300;count++;}
 966         else if (have_flag(flgs, TR_SLAY_EVIL)) {tmp_cost += 2300;count++;}
 967         if (have_flag(flgs, TR_KILL_HUMAN)) {tmp_cost += 2800;count++;}
 968         else if (have_flag(flgs, TR_SLAY_HUMAN)) {tmp_cost += 1800;count++;}
 969         if (have_flag(flgs, TR_KILL_UNDEAD)) {tmp_cost += 2800;count++;}
 970         else if (have_flag(flgs, TR_SLAY_UNDEAD)) {tmp_cost += 1800;count++;}
 971         if (have_flag(flgs, TR_KILL_DEMON)) {tmp_cost += 2800;count++;}
 972         else if (have_flag(flgs, TR_SLAY_DEMON)) {tmp_cost += 1800;count++;}
 973         if (have_flag(flgs, TR_KILL_ORC)) {tmp_cost += 2500;count++;}
 974         else if (have_flag(flgs, TR_SLAY_ORC)) {tmp_cost += 1500;count++;}
 975         if (have_flag(flgs, TR_KILL_TROLL)) {tmp_cost += 2800;count++;}
 976         else if (have_flag(flgs, TR_SLAY_TROLL)) {tmp_cost += 1800;count++;}
 977         if (have_flag(flgs, TR_KILL_GIANT)) {tmp_cost += 2800;count++;}
 978         else if (have_flag(flgs, TR_SLAY_GIANT)) {tmp_cost += 1800;count++;}
 979         if (have_flag(flgs, TR_KILL_DRAGON)) {tmp_cost += 2800;count++;}
 980         else if (have_flag(flgs, TR_SLAY_DRAGON)) {tmp_cost += 1800;count++;}
 981
 982         if (have_flag(flgs, TR_VORPAL)) {tmp_cost += 2500;count++;}
 983         if (have_flag(flgs, TR_IMPACT)) {tmp_cost += 2500;count++;}
 984         if (have_flag(flgs, TR_BRAND_POIS)) {tmp_cost += 3800;count++;}
 985         if (have_flag(flgs, TR_BRAND_ACID)) {tmp_cost += 3800;count++;}
 986         if (have_flag(flgs, TR_BRAND_ELEC)) {tmp_cost += 3800;count++;}
 987         if (have_flag(flgs, TR_BRAND_FIRE)) {tmp_cost += 2500;count++;}
 988         if (have_flag(flgs, TR_BRAND_COLD)) {tmp_cost += 2500;count++;}
 989         total += (tmp_cost * count);
 990
 991         if (have_flag(flgs, TR_SUST_STR)) total += 850;
 992         if (have_flag(flgs, TR_SUST_INT)) total += 850;
 993         if (have_flag(flgs, TR_SUST_WIS)) total += 850;
 994         if (have_flag(flgs, TR_SUST_DEX)) total += 850;
 995         if (have_flag(flgs, TR_SUST_CON)) total += 850;
 996         if (have_flag(flgs, TR_SUST_CHR)) total += 250;
 997         if (have_flag(flgs, TR_RIDING)) total += 0;
 998         if (have_flag(flgs, TR_EASY_SPELL)) total += 1500;
 999         if (have_flag(flgs, TR_THROW)) total += 5000;
1000         if (have_flag(flgs, TR_FREE_ACT)) total += 4500;
1001         if (have_flag(flgs, TR_HOLD_EXP)) total += 8500;
1002
1003         tmp_cost = 0;
1004         count = 0;
1005         if (have_flag(flgs, TR_IM_ACID)) {tmp_cost += 15000;count += 2;}
1006         if (have_flag(flgs, TR_IM_ELEC)) {tmp_cost += 15000;count += 2;}
1007         if (have_flag(flgs, TR_IM_FIRE)) {tmp_cost += 15000;count += 2;}
1008         if (have_flag(flgs, TR_IM_COLD)) {tmp_cost += 15000;count += 2;}
1009         if (have_flag(flgs, TR_REFLECT)) {tmp_cost += 5000;count += 2;}
1010         if (have_flag(flgs, TR_RES_ACID)) {tmp_cost += 500;count++;}
1011         if (have_flag(flgs, TR_RES_ELEC)) {tmp_cost += 500;count++;}
1012         if (have_flag(flgs, TR_RES_FIRE)) {tmp_cost += 500;count++;}
1013         if (have_flag(flgs, TR_RES_COLD)) {tmp_cost += 500;count++;}
1014         if (have_flag(flgs, TR_RES_POIS)) {tmp_cost += 1000;count += 2;}
1015         if (have_flag(flgs, TR_RES_FEAR)) {tmp_cost += 1000;count += 2;}
1016         if (have_flag(flgs, TR_RES_LITE)) {tmp_cost += 800;count += 2;}
1017         if (have_flag(flgs, TR_RES_DARK)) {tmp_cost += 800;count += 2;}
1018         if (have_flag(flgs, TR_RES_BLIND)) {tmp_cost += 900;count += 2;}
1019         if (have_flag(flgs, TR_RES_CONF)) {tmp_cost += 900;count += 2;}
1020         if (have_flag(flgs, TR_RES_SOUND)) {tmp_cost += 900;count += 2;}
1021         if (have_flag(flgs, TR_RES_SHARDS)) {tmp_cost += 900;count += 2;}
1022         if (have_flag(flgs, TR_RES_NETHER)) {tmp_cost += 900;count += 2;}
1023         if (have_flag(flgs, TR_RES_NEXUS)) {tmp_cost += 900;count += 2;}
1024         if (have_flag(flgs, TR_RES_CHAOS)) {tmp_cost += 1000;count += 2;}
1025         if (have_flag(flgs, TR_RES_DISEN)) {tmp_cost += 2000;count += 2;}
1026         total += (tmp_cost * count);
1027
1028         if (have_flag(flgs, TR_SH_FIRE)) total += 5000;
1029         if (have_flag(flgs, TR_SH_ELEC)) total += 5000;
1030         if (have_flag(flgs, TR_SH_COLD)) total += 5000;
1031         if (have_flag(flgs, TR_NO_TELE)) total -= 10000;
1032         if (have_flag(flgs, TR_NO_MAGIC)) total += 2500;
1033         if (have_flag(flgs, TR_TY_CURSE)) total -= 15000;
1034         if (have_flag(flgs, TR_HIDE_TYPE)) total += 0;
1035         if (have_flag(flgs, TR_SHOW_MODS)) total += 0;
1036         if (have_flag(flgs, TR_LEVITATION)) total += 1250;
1037         if (have_flag(flgs, TR_LITE_1)) total += 1500;
1038         if (have_flag(flgs, TR_LITE_2)) total += 2500;
1039         if (have_flag(flgs, TR_LITE_3)) total += 4000;
1040         if (have_flag(flgs, TR_LITE_M1)) total -= 1500;
1041         if (have_flag(flgs, TR_LITE_M2)) total -= 2500;
1042         if (have_flag(flgs, TR_LITE_M3)) total -= 4000;
1043         if (have_flag(flgs, TR_SEE_INVIS)) total += 2000;
1044         if (have_flag(flgs, TR_TELEPATHY)) total += 20000;
1045         if (have_flag(flgs, TR_ESP_ANIMAL)) total += 1000;
1046         if (have_flag(flgs, TR_ESP_UNDEAD)) total += 1000;
1047         if (have_flag(flgs, TR_ESP_DEMON)) total += 1000;
1048         if (have_flag(flgs, TR_ESP_ORC)) total += 1000;
1049         if (have_flag(flgs, TR_ESP_TROLL)) total += 1000;
1050         if (have_flag(flgs, TR_ESP_GIANT)) total += 1000;
1051         if (have_flag(flgs, TR_ESP_DRAGON)) total += 1000;
1052         if (have_flag(flgs, TR_ESP_HUMAN)) total += 1000;
1053         if (have_flag(flgs, TR_ESP_EVIL)) total += 15000;
1054         if (have_flag(flgs, TR_ESP_GOOD)) total += 2000;
1055         if (have_flag(flgs, TR_ESP_NONLIVING)) total += 2000;
1056         if (have_flag(flgs, TR_ESP_UNIQUE)) total += 10000;
1057         if (have_flag(flgs, TR_SLOW_DIGEST)) total += 750;
1058         if (have_flag(flgs, TR_REGEN)) total += 2500;
1059         if (have_flag(flgs, TR_WARNING)) total += 2000;
1060         if (have_flag(flgs, TR_DEC_MANA)) total += 10000;
1061         if (have_flag(flgs, TR_XTRA_MIGHT)) total += 2250;
1062         if (have_flag(flgs, TR_XTRA_SHOTS)) total += 10000;
1063         if (have_flag(flgs, TR_IGNORE_ACID)) total += 100;
1064         if (have_flag(flgs, TR_IGNORE_ELEC)) total += 100;
1065         if (have_flag(flgs, TR_IGNORE_FIRE)) total += 100;
1066         if (have_flag(flgs, TR_IGNORE_COLD)) total += 100;
1067         if (have_flag(flgs, TR_ACTIVATE)) total += 100;
1068         if (have_flag(flgs, TR_DRAIN_EXP)) total -= 12500;
1069         if (have_flag(flgs, TR_DRAIN_HP)) total -= 12500;
1070         if (have_flag(flgs, TR_DRAIN_MANA)) total -= 12500;
1071         if (have_flag(flgs, TR_CALL_ANIMAL)) total -= 12500;
1072         if (have_flag(flgs, TR_CALL_DEMON)) total -= 10000;
1073         if (have_flag(flgs, TR_CALL_DRAGON)) total -= 10000;
1074         if (have_flag(flgs, TR_CALL_UNDEAD)) total -= 10000;
1075         if (have_flag(flgs, TR_COWARDICE)) total -= 5000;
1076         if (have_flag(flgs, TR_LOW_MELEE)) total -= 5000;
1077         if (have_flag(flgs, TR_LOW_AC)) total -= 5000;
1078         if (have_flag(flgs, TR_LOW_MAGIC)) total -= 15000;
1079         if (have_flag(flgs, TR_FAST_DIGEST)) total -= 10000;
1080         if (have_flag(flgs, TR_SLOW_REGEN)) total -= 10000;
1081         if (have_flag(flgs, TR_TELEPORT))
1082         {
1083                 if (object_is_cursed(o_ptr))
1084                         total -= 7500;
1085                 else
1086                         total += 250;
1087         }
1088         if (have_flag(flgs, TR_AGGRAVATE)) total -= 10000;
1089         if (have_flag(flgs, TR_BLESSED)) total += 750;
1090         if (o_ptr->curse_flags & TR_ADD_L_CURSE) total -= 5000;
1091         if (o_ptr->curse_flags & TR_ADD_H_CURSE) total -= 12500;
1092         if (o_ptr->curse_flags & TRC_CURSED) total -= 5000;
1093         if (o_ptr->curse_flags & TRC_HEAVY_CURSE) total -= 12500;
1094         if (o_ptr->curse_flags & TRC_PERMA_CURSE) total -= 15000;
1095
1096         /* Also, give some extra for activatable powers... */
1097         if (o_ptr->art_name && (have_flag(o_ptr->art_flags, TR_ACTIVATE)))
1098         {
1099                 const activation_type* const act_ptr = find_activation_info(o_ptr);
1100                 if (act_ptr) {
1101                         total += act_ptr->value;
1102                 }
1103         }
1104
1105         return total;
1106 }
1107
1108
1109 /*!
1110  * @brief オブジェクトの真の価格を算出する /
1111  * Return the value of the flags the object has...
1112  * @param o_ptr 本価格を確認したいオブジェクトの構造体参照ポインタ
1113  * @return オブジェクトの本価格
1114  * @details
1115  * Return the "real" price of a "known" item, not including discounts\n
1116  *\n
1117  * Wand and staffs get cost for each charge\n
1118  *\n
1119  * Armor is worth an extra 100 gold per bonus point to armor class.\n
1120  *\n
1121  * Weapons are worth an extra 100 gold per bonus point (AC,TH,TD).\n
1122  *\n
1123  * Missiles are only worth 5 gold per bonus point, since they\n
1124  * usually appear in groups of 20, and we want the player to get\n
1125  * the same amount of cash for any "equivalent" item.  Note that\n
1126  * missiles never have any of the "pval" flags, and in fact, they\n
1127  * only have a few of the available flags, primarily of the "slay"\n
1128  * and "brand" and "ignore" variety.\n
1129  *\n
1130  * Armor with a negative armor bonus is worthless.\n
1131  * Weapons with negative hit+damage bonuses are worthless.\n
1132  *\n
1133  * Every wearable item with a "pval" bonus is worth extra (see below).\n
1134  */
1135 s32b object_value_real(object_type *o_ptr)
1136 {
1137         s32b value;
1138
1139         u32b flgs[TR_FLAG_SIZE];
1140
1141         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1142
1143
1144         /* Hack -- "worthless" items */
1145         if (!k_info[o_ptr->k_idx].cost) return (0L);
1146
1147         /* Base cost */
1148         value = k_info[o_ptr->k_idx].cost;
1149
1150         /* Extract some flags */
1151         object_flags(o_ptr, flgs);
1152
1153         /* Artifact */
1154         if (object_is_fixed_artifact(o_ptr))
1155         {
1156                 artifact_type *a_ptr = &a_info[o_ptr->name1];
1157
1158                 /* Hack -- "worthless" artifacts */
1159                 if (!a_ptr->cost) return (0L);
1160
1161                 /* Hack -- Use the artifact cost instead */
1162                 value = a_ptr->cost;
1163                 value += flag_cost(o_ptr, o_ptr->pval);
1164
1165                 /* Don't add pval bonuses etc. */
1166                 return (value);
1167         }
1168
1169         /* Ego-Item */
1170         else if (object_is_ego(o_ptr))
1171         {
1172                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
1173
1174                 /* Hack -- "worthless" ego-items */
1175                 if (!e_ptr->cost) return (0L);
1176
1177                 /* Hack -- Reward the ego-item with a bonus */
1178                 value += e_ptr->cost;
1179                 value += flag_cost(o_ptr, o_ptr->pval);
1180         }
1181
1182         else
1183         {
1184                 int i;
1185                 bool flag = FALSE;
1186
1187                 for (i = 0; i < TR_FLAG_SIZE; i++)
1188                         if (o_ptr->art_flags[i]) flag = TRUE;
1189
1190                 if (flag) value += flag_cost(o_ptr, o_ptr->pval);
1191         }
1192
1193         /* Analyze pval bonus for normal object */
1194         switch (o_ptr->tval)
1195         {
1196         case TV_SHOT:
1197         case TV_ARROW:
1198         case TV_BOLT:
1199         case TV_BOW:
1200         case TV_DIGGING:
1201         case TV_HAFTED:
1202         case TV_POLEARM:
1203         case TV_SWORD:
1204         case TV_BOOTS:
1205         case TV_GLOVES:
1206         case TV_HELM:
1207         case TV_CROWN:
1208         case TV_SHIELD:
1209         case TV_CLOAK:
1210         case TV_SOFT_ARMOR:
1211         case TV_HARD_ARMOR:
1212         case TV_DRAG_ARMOR:
1213         case TV_LITE:
1214         case TV_AMULET:
1215         case TV_RING:
1216                 /* No pval */
1217                 if (!o_ptr->pval) break;
1218
1219                 /* Hack -- Negative "pval" is always bad */
1220                 if (o_ptr->pval < 0) return (0L);
1221
1222                 /* Give credit for stat bonuses */
1223                 if (have_flag(flgs, TR_STR)) value += (o_ptr->pval * 200L);
1224                 if (have_flag(flgs, TR_INT)) value += (o_ptr->pval * 200L);
1225                 if (have_flag(flgs, TR_WIS)) value += (o_ptr->pval * 200L);
1226                 if (have_flag(flgs, TR_DEX)) value += (o_ptr->pval * 200L);
1227                 if (have_flag(flgs, TR_CON)) value += (o_ptr->pval * 200L);
1228                 if (have_flag(flgs, TR_CHR)) value += (o_ptr->pval * 200L);
1229
1230                 /* Give credit for stealth and searching */
1231                 if (have_flag(flgs, TR_MAGIC_MASTERY)) value += (o_ptr->pval * 100);
1232                 if (have_flag(flgs, TR_STEALTH)) value += (o_ptr->pval * 100L);
1233                 if (have_flag(flgs, TR_SEARCH)) value += (o_ptr->pval * 100L);
1234
1235                 /* Give credit for infra-vision and tunneling */
1236                 if (have_flag(flgs, TR_INFRA)) value += (o_ptr->pval * 50L);
1237                 if (have_flag(flgs, TR_TUNNEL)) value += (o_ptr->pval * 50L);
1238
1239                 /* Give credit for extra attacks */
1240                 if (have_flag(flgs, TR_BLOWS)) value += (o_ptr->pval * 5000L);
1241
1242                 /* Give credit for speed bonus */
1243                 if (have_flag(flgs, TR_SPEED)) value += (o_ptr->pval * 10000L);
1244
1245                 break;
1246         }
1247
1248
1249         /* Analyze the item */
1250         switch (o_ptr->tval)
1251         {
1252                 /* Wands/Staffs */
1253                 case TV_WAND:
1254                 {
1255                         /* Pay extra for charges, depending on standard number of
1256                          * charges.  Handle new-style wands correctly. -LM-
1257                          */
1258                         value += (value * o_ptr->pval / o_ptr->number / (k_ptr->pval * 2));
1259
1260                         /* Done */
1261                         break;
1262                 }
1263                 case TV_STAFF:
1264                 {
1265                         /* Pay extra for charges, depending on standard number of
1266                          * charges.  -LM-
1267                          */
1268                         value += (value * o_ptr->pval / (k_ptr->pval * 2));
1269
1270                         /* Done */
1271                         break;
1272                 }
1273
1274                 /* Rings/Amulets */
1275                 case TV_RING:
1276                 case TV_AMULET:
1277                 {
1278                         /* Hack -- negative bonuses are bad */
1279                         if (o_ptr->to_h + o_ptr->to_d + o_ptr->to_a < 0) return (0L);
1280
1281                         /* Give credit for bonuses */
1282                         value += ((o_ptr->to_h + o_ptr->to_d + o_ptr->to_a) * 200L);
1283
1284                         /* Done */
1285                         break;
1286                 }
1287
1288                 /* Armor */
1289                 case TV_BOOTS:
1290                 case TV_GLOVES:
1291                 case TV_CLOAK:
1292                 case TV_CROWN:
1293                 case TV_HELM:
1294                 case TV_SHIELD:
1295                 case TV_SOFT_ARMOR:
1296                 case TV_HARD_ARMOR:
1297                 case TV_DRAG_ARMOR:
1298                 {
1299                         /* Hack -- negative armor bonus */
1300                         if (o_ptr->to_a < 0) return (0L);
1301
1302                         /* Give credit for bonuses */
1303                         value += (((o_ptr->to_h - k_ptr->to_h) + (o_ptr->to_d - k_ptr->to_d)) * 200L + (o_ptr->to_a) * 100L);
1304
1305                         /* Done */
1306                         break;
1307                 }
1308
1309                 /* Bows/Weapons */
1310                 case TV_BOW:
1311                 case TV_DIGGING:
1312                 case TV_HAFTED:
1313                 case TV_SWORD:
1314                 case TV_POLEARM:
1315                 {
1316                         /* Hack -- negative hit/damage bonuses */
1317                         if (o_ptr->to_h + o_ptr->to_d < 0) return (0L);
1318
1319                         /* Factor in the bonuses */
1320                         value += ((o_ptr->to_h + o_ptr->to_d + o_ptr->to_a) * 100L);
1321
1322                         /* Hack -- Factor in extra damage dice and sides */
1323                         value += (o_ptr->dd - k_ptr->dd) * o_ptr->ds * 250L;
1324                         value += (o_ptr->ds - k_ptr->ds) * o_ptr->dd * 250L;
1325
1326                         /* Done */
1327                         break;
1328                 }
1329
1330                 /* Ammo */
1331                 case TV_SHOT:
1332                 case TV_ARROW:
1333                 case TV_BOLT:
1334                 {
1335                         /* Hack -- negative hit/damage bonuses */
1336                         if (o_ptr->to_h + o_ptr->to_d < 0) return (0L);
1337
1338                         /* Factor in the bonuses */
1339                         value += ((o_ptr->to_h + o_ptr->to_d) * 5L);
1340
1341                         /* Hack -- Factor in extra damage dice and sides */
1342                         value += (o_ptr->dd - k_ptr->dd) * o_ptr->ds * 5L;
1343                         value += (o_ptr->ds - k_ptr->ds) * o_ptr->dd * 5L;
1344
1345                         /* Done */
1346                         break;
1347                 }
1348
1349                 /* Figurines, relative to monster level */
1350                 case TV_FIGURINE:
1351                 {
1352                         int level = r_info[o_ptr->pval].level;
1353                         if (level < 20) value = level*50L;
1354                         else if (level < 30) value = 1000+(level-20)*150L;
1355                         else if (level < 40) value = 2500+(level-30)*350L;
1356                         else if (level < 50) value = 6000+(level-40)*800L;
1357                         else value = 14000+(level-50)*2000L;
1358                         break;
1359                 }
1360
1361                 case TV_CAPTURE:
1362                 {
1363                         if (!o_ptr->pval) value = 1000L;
1364                         else value = ((r_info[o_ptr->pval].level) * 50L + 1000);
1365                         break;
1366                 }
1367
1368                 case TV_CHEST:
1369                 {
1370                         if (!o_ptr->pval) value = 0L;
1371                         break;
1372                 }
1373         }
1374
1375         /* Worthless object */
1376         if (value < 0) return 0L;
1377
1378         /* Return the value */
1379         return (value);
1380 }
1381
1382
1383 /*!
1384  * @brief オブジェクト価格算出のメインルーチン /
1385  * Return the price of an item including plusses (and charges)
1386  * @param o_ptr 判明している現価格を確認したいオブジェクトの構造体参照ポインタ
1387  * @return オブジェクトの判明している現価格
1388  * @details
1389  * This function returns the "value" of the given item (qty one)\n
1390  *\n
1391  * Never notice "unknown" bonuses or properties, including "curses",\n
1392  * since that would give the player information he did not have.\n
1393  *\n
1394  * Note that discounted items stay discounted forever, even if\n
1395  * the discount is "forgotten" by the player via memory loss.\n
1396  */
1397 s32b object_value(object_type *o_ptr)
1398 {
1399         s32b value;
1400
1401
1402         /* Unknown items -- acquire a base value */
1403         if (object_is_known(o_ptr))
1404         {
1405                 /* Broken items -- worthless */
1406                 if (object_is_broken(o_ptr)) return (0L);
1407
1408                 /* Cursed items -- worthless */
1409                 if (object_is_cursed(o_ptr)) return (0L);
1410
1411                 /* Real value (see above) */
1412                 value = object_value_real(o_ptr);
1413         }
1414
1415         /* Known items -- acquire the actual value */
1416         else
1417         {
1418                 /* Hack -- Felt broken items */
1419                 if ((o_ptr->ident & (IDENT_SENSE)) && object_is_broken(o_ptr)) return (0L);
1420
1421                 /* Hack -- Felt cursed items */
1422                 if ((o_ptr->ident & (IDENT_SENSE)) && object_is_cursed(o_ptr)) return (0L);
1423
1424                 /* Base value (see above) */
1425                 value = object_value_base(o_ptr);
1426         }
1427
1428
1429         /* Apply discount (if any) */
1430         if (o_ptr->discount) value -= (value * o_ptr->discount / 100L);
1431
1432
1433         /* Return the final value */
1434         return (value);
1435 }
1436
1437
1438
1439 /*!
1440  * @brief 破壊可能なアイテムかを返す /
1441  * Determines whether an object can be destroyed, and makes fake inscription.
1442  * @param o_ptr 破壊可能かを確認したいオブジェクトの構造体参照ポインタ
1443  * @return オブジェクトが破壊可能ならばTRUEを返す
1444  */
1445 bool can_player_destroy_object(object_type *o_ptr)
1446 {
1447         /* Artifacts cannot be destroyed */
1448         if (!object_is_artifact(o_ptr)) return TRUE;
1449
1450         /* If object is unidentified, makes fake inscription */
1451         if (!object_is_known(o_ptr))
1452         {
1453                 byte feel = FEEL_SPECIAL;
1454
1455                 /* Hack -- Handle icky artifacts */
1456                 if (object_is_cursed(o_ptr) || object_is_broken(o_ptr)) feel = FEEL_TERRIBLE;
1457
1458                 /* Hack -- inscribe the artifact */
1459                 o_ptr->feeling = feel;
1460
1461                 /* We have "felt" it (again) */
1462                 o_ptr->ident |= (IDENT_SENSE);
1463
1464                 /* Combine the pack */
1465                 p_ptr->notice |= (PN_COMBINE);
1466
1467                 /* Window stuff */
1468                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
1469
1470                 /* Done */
1471                 return FALSE;
1472         }
1473
1474         /* Identified artifact -- Nothing to do */
1475         return FALSE;
1476 }
1477
1478
1479 /*!
1480  * @brief 魔法棒やロッドのスロット分割時に使用回数を分配する /
1481  * Distribute charges of rods or wands.
1482  * @param o_ptr 分割元オブジェクトの構造体参照ポインタ source item
1483  * @param q_ptr 分割先オブジェクトの構造体参照ポインタ target item, must be of the same type as o_ptr
1484  * @param amt 分割したい回数量 number of items that are transfered
1485  * @return なし
1486  * @details
1487  * Hack -- If rods or wands are dropped, the total maximum timeout or\n
1488  * charges need to be allocated between the two stacks.  If all the items\n
1489  * are being dropped, it makes for a neater message to leave the original\n
1490  * stack's pval alone. -LM-\n
1491  */
1492 void distribute_charges(object_type *o_ptr, object_type *q_ptr, int amt)
1493 {
1494         if ((o_ptr->tval == TV_WAND) || (o_ptr->tval == TV_ROD))
1495         {
1496                 q_ptr->pval = o_ptr->pval * amt / o_ptr->number;
1497                 if (amt < o_ptr->number) o_ptr->pval -= q_ptr->pval;
1498
1499                 /* Hack -- Rods also need to have their timeouts distributed.  The
1500                  * dropped stack will accept all time remaining to charge up to its
1501                  * maximum.
1502                  */
1503                 if ((o_ptr->tval == TV_ROD) && (o_ptr->timeout))
1504                 {
1505                         if (q_ptr->pval > o_ptr->timeout)
1506                                 q_ptr->timeout = o_ptr->timeout;
1507                         else
1508                                 q_ptr->timeout = q_ptr->pval;
1509
1510                         if (amt < o_ptr->number) o_ptr->timeout -= q_ptr->timeout;
1511                 }
1512         }
1513 }
1514
1515 /*!
1516  * @brief 魔法棒やロッドの使用回数を減らす /
1517  * @param o_ptr オブジェクトの構造体参照ポインタ source item
1518  * @param amt 減らしたい回数量 number of items that are transfered
1519  * @return なし
1520  * @details
1521  * Hack -- If rods or wand are destroyed, the total maximum timeout or\n
1522  * charges of the stack needs to be reduced, unless all the items are\n
1523  * being destroyed. -LM-\n
1524  */
1525 void reduce_charges(object_type *o_ptr, int amt)
1526 {
1527         if (((o_ptr->tval == TV_WAND) || (o_ptr->tval == TV_ROD)) &&
1528                 (amt < o_ptr->number))
1529         {
1530                 o_ptr->pval -= o_ptr->pval * amt / o_ptr->number;
1531         }
1532 }
1533
1534 /*
1535  * Determine if an item can "absorb" a second item
1536  *
1537  * See "object_absorb()" for the actual "absorption" code.
1538  *
1539  * If permitted, we allow staffs (if they are known to have equal charges
1540  * and both are either known or confirmed empty) and wands (if both are
1541  * either known or confirmed empty) and rods (in all cases) to combine.
1542  * Staffs will unstack (if necessary) when they are used, but wands and
1543  * rods will only unstack if one is dropped. -LM-
1544  *
1545  * If permitted, we allow weapons/armor to stack, if fully "known".
1546  *
1547  * Missiles will combine if both stacks have the same "known" status.
1548  * This is done to make unidentified stacks of missiles useful.
1549  *
1550  * Food, potions, scrolls, and "easy know" items always stack.
1551  *
1552  * Chests, and activatable items, never stack (for various reasons).
1553  */
1554
1555 /*
1556  * A "stack" of items is limited to less than or equal to 99 items (hard-coded).
1557  */
1558 #define MAX_STACK_SIZE 99
1559
1560
1561 /*!
1562  * @brief 両オブジェクトをスロットに重ね合わせ可能な最大数を返す。
1563  * Determine if an item can partly absorb a second item. Return maximum number of stack.
1564  * @param o_ptr 検証したいオブジェクトの構造体参照ポインタ1
1565  * @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
1566  * @return 重ね合わせ可能なアイテム数
1567  */
1568 int object_similar_part(object_type *o_ptr, object_type *j_ptr)
1569 {
1570         int i;
1571
1572         /* Default maximum number of stack */
1573         int max_num = MAX_STACK_SIZE;
1574
1575         /* Require identical object types */
1576         if (o_ptr->k_idx != j_ptr->k_idx) return 0;
1577
1578
1579         /* Analyze the items */
1580         switch (o_ptr->tval)
1581         {
1582                 /* Chests and Statues*/
1583                 case TV_CHEST:
1584                 case TV_CARD:
1585                 case TV_CAPTURE:
1586                 {
1587                         /* Never okay */
1588                         return 0;
1589                 }
1590
1591                 case TV_STATUE:
1592                 {
1593                         if ((o_ptr->sval != SV_PHOTO) || (j_ptr->sval != SV_PHOTO)) return 0;
1594                         if (o_ptr->pval != j_ptr->pval) return 0;
1595                         break;
1596                 }
1597
1598                 /* Figurines and Corpses*/
1599                 case TV_FIGURINE:
1600                 case TV_CORPSE:
1601                 {
1602                         /* Same monster */
1603                         if (o_ptr->pval != j_ptr->pval) return 0;
1604
1605                         /* Assume okay */
1606                         break;
1607                 }
1608
1609                 /* Food and Potions and Scrolls */
1610                 case TV_FOOD:
1611                 case TV_POTION:
1612                 case TV_SCROLL:
1613                 {
1614                         /* Assume okay */
1615                         break;
1616                 }
1617
1618                 /* Staffs */
1619                 case TV_STAFF:
1620                 {
1621                         /* Require either knowledge or known empty for both staffs. */
1622                         if ((!(o_ptr->ident & (IDENT_EMPTY)) &&
1623                                 !object_is_known(o_ptr)) ||
1624                                 (!(j_ptr->ident & (IDENT_EMPTY)) &&
1625                                 !object_is_known(j_ptr))) return 0;
1626
1627                         /* Require identical charges, since staffs are bulky. */
1628                         if (o_ptr->pval != j_ptr->pval) return 0;
1629
1630                         /* Assume okay */
1631                         break;
1632                 }
1633
1634                 /* Wands */
1635                 case TV_WAND:
1636                 {
1637                         /* Require either knowledge or known empty for both wands. */
1638                         if ((!(o_ptr->ident & (IDENT_EMPTY)) &&
1639                                 !object_is_known(o_ptr)) ||
1640                                 (!(j_ptr->ident & (IDENT_EMPTY)) &&
1641                                 !object_is_known(j_ptr))) return 0;
1642
1643                         /* Wand charges combine in O&ZAngband.  */
1644
1645                         /* Assume okay */
1646                         break;
1647                 }
1648
1649                 /* Staffs and Wands and Rods */
1650                 case TV_ROD:
1651                 {
1652                         /* Prevent overflaw of timeout */
1653                         max_num = MIN(max_num, MAX_SHORT / k_info[o_ptr->k_idx].pval);
1654
1655                         /* Assume okay */
1656                         break;
1657                 }
1658
1659                 /* Weapons and Armor */
1660                 case TV_BOW:
1661                 case TV_DIGGING:
1662                 case TV_HAFTED:
1663                 case TV_POLEARM:
1664                 case TV_SWORD:
1665                 case TV_BOOTS:
1666                 case TV_GLOVES:
1667                 case TV_HELM:
1668                 case TV_CROWN:
1669                 case TV_SHIELD:
1670                 case TV_CLOAK:
1671                 case TV_SOFT_ARMOR:
1672                 case TV_HARD_ARMOR:
1673                 case TV_DRAG_ARMOR:
1674
1675                 /* Rings, Amulets, Lites */
1676                 case TV_RING:
1677                 case TV_AMULET:
1678                 case TV_LITE:
1679                 case TV_WHISTLE:
1680                 {
1681                         /* Require full knowledge of both items */
1682                         if (!object_is_known(o_ptr) || !object_is_known(j_ptr)) return 0;
1683
1684                         /* Fall through */
1685                 }
1686
1687                 /* Missiles */
1688                 case TV_BOLT:
1689                 case TV_ARROW:
1690                 case TV_SHOT:
1691                 {
1692                         /* Require identical knowledge of both items */
1693                         if (object_is_known(o_ptr) != object_is_known(j_ptr)) return 0;
1694                         if (o_ptr->feeling != j_ptr->feeling) return 0;
1695
1696                         /* Require identical "bonuses" */
1697                         if (o_ptr->to_h != j_ptr->to_h) return 0;
1698                         if (o_ptr->to_d != j_ptr->to_d) return 0;
1699                         if (o_ptr->to_a != j_ptr->to_a) return 0;
1700
1701                         /* Require identical "pval" code */
1702                         if (o_ptr->pval != j_ptr->pval) return 0;
1703
1704                         /* Artifacts never stack */
1705                         if (object_is_artifact(o_ptr) || object_is_artifact(j_ptr)) return 0;
1706
1707                         /* Require identical "ego-item" names */
1708                         if (o_ptr->name2 != j_ptr->name2) return 0;
1709
1710                         /* Require identical added essence  */
1711                         if (o_ptr->xtra3 != j_ptr->xtra3) return 0;
1712                         if (o_ptr->xtra4 != j_ptr->xtra4) return 0;
1713
1714                         /* Hack -- Never stack "powerful" items */
1715                         if (o_ptr->xtra1 || j_ptr->xtra1) return 0;
1716
1717                         /* Hack -- Never stack recharging items */
1718                         if (o_ptr->timeout || j_ptr->timeout) return 0;
1719
1720                         /* Require identical "values" */
1721                         if (o_ptr->ac != j_ptr->ac) return 0;
1722                         if (o_ptr->dd != j_ptr->dd) return 0;
1723                         if (o_ptr->ds != j_ptr->ds) return 0;
1724
1725                         /* Probably okay */
1726                         break;
1727                 }
1728
1729                 /* Various */
1730                 default:
1731                 {
1732                         /* Require knowledge */
1733                         if (!object_is_known(o_ptr) || !object_is_known(j_ptr)) return 0;
1734
1735                         /* Probably okay */
1736                         break;
1737                 }
1738         }
1739
1740
1741         /* Hack -- Identical art_flags! */
1742         for (i = 0; i < TR_FLAG_SIZE; i++)
1743                 if (o_ptr->art_flags[i] != j_ptr->art_flags[i]) return 0;
1744
1745         /* Hack -- Require identical "cursed" status */
1746         if (o_ptr->curse_flags != j_ptr->curse_flags) return 0;
1747
1748         /* Hack -- Require identical "broken" status */
1749         if ((o_ptr->ident & (IDENT_BROKEN)) != (j_ptr->ident & (IDENT_BROKEN))) return 0;
1750
1751
1752         /* Hack -- require semi-matching "inscriptions" */
1753         if (o_ptr->inscription && j_ptr->inscription &&
1754             (o_ptr->inscription != j_ptr->inscription))
1755                 return 0;
1756
1757         /* Hack -- normally require matching "inscriptions" */
1758         if (!stack_force_notes && (o_ptr->inscription != j_ptr->inscription)) return 0;
1759
1760         /* Hack -- normally require matching "discounts" */
1761         if (!stack_force_costs && (o_ptr->discount != j_ptr->discount)) return 0;
1762
1763
1764         /* They match, so they must be similar */
1765         return max_num;
1766 }
1767
1768 /*!
1769  * @brief 両オブジェクトをスロットに重ねることができるかどうかを返す。
1770  * Determine if an item can absorb a second item.
1771  * @param o_ptr 検証したいオブジェクトの構造体参照ポインタ1
1772  * @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
1773  * @return 重ね合わせ可能ならばTRUEを返す。
1774  */
1775 bool object_similar(object_type *o_ptr, object_type *j_ptr)
1776 {
1777         int total = o_ptr->number + j_ptr->number;
1778         int max_num;
1779
1780         /* Are these objects similar? */
1781         max_num = object_similar_part(o_ptr, j_ptr);
1782
1783         /* Return if not similar */
1784         if (!max_num) return FALSE;
1785
1786         /* Maximal "stacking" limit */
1787         if (total > max_num) return (0);
1788
1789
1790         /* They match, so they must be similar */
1791         return (TRUE);
1792 }
1793
1794
1795 /*!
1796  * @brief 両オブジェクトをスロットに重ね合わせる。
1797  * Allow one item to "absorb" another, assuming they are similar
1798  * @param o_ptr 重ね合わせ先のオブジェクトの構造体参照ポインタ
1799  * @param j_ptr 重ね合わせ元のオブジェクトの構造体参照ポインタ
1800  * @return なし
1801  */
1802 void object_absorb(object_type *o_ptr, object_type *j_ptr)
1803 {
1804         int max_num = object_similar_part(o_ptr, j_ptr);
1805         int total = o_ptr->number + j_ptr->number;
1806         int diff = (total > max_num) ? total - max_num : 0;
1807
1808         /* Combine quantity, lose excess items */
1809         o_ptr->number = (total > max_num) ? max_num : total;
1810
1811         /* Hack -- blend "known" status */
1812         if (object_is_known(j_ptr)) object_known(o_ptr);
1813
1814         /* Hack -- clear "storebought" if only one has it */
1815         if (((o_ptr->ident & IDENT_STORE) || (j_ptr->ident & IDENT_STORE)) &&
1816             (!((o_ptr->ident & IDENT_STORE) && (j_ptr->ident & IDENT_STORE))))
1817         {
1818                 if (j_ptr->ident & IDENT_STORE) j_ptr->ident &= 0xEF;
1819                 if (o_ptr->ident & IDENT_STORE) o_ptr->ident &= 0xEF;
1820         }
1821
1822         /* Hack -- blend "mental" status */
1823         if (j_ptr->ident & (IDENT_MENTAL)) o_ptr->ident |= (IDENT_MENTAL);
1824
1825         /* Hack -- blend "inscriptions" */
1826         if (j_ptr->inscription) o_ptr->inscription = j_ptr->inscription;
1827
1828         /* Hack -- blend "feelings" */
1829         if (j_ptr->feeling) o_ptr->feeling = j_ptr->feeling;
1830
1831         /* Hack -- could average discounts XXX XXX XXX */
1832         /* Hack -- save largest discount XXX XXX XXX */
1833         if (o_ptr->discount < j_ptr->discount) o_ptr->discount = j_ptr->discount;
1834
1835         /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
1836         if (o_ptr->tval == TV_ROD)
1837         {
1838                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
1839                 o_ptr->timeout += j_ptr->timeout * (j_ptr->number - diff) / j_ptr->number;
1840         }
1841
1842         /* Hack -- if wands are stacking, combine the charges. -LM- */
1843         if (o_ptr->tval == TV_WAND)
1844         {
1845                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
1846         }
1847 }
1848
1849
1850 /*!
1851  * @brief tvalとsvalに対応するベースアイテムのIDを返す。
1852  * Find the index of the object_kind with the given tval and sval
1853  * @param tval 検索したいベースアイテムのtval
1854  * @param sval 検索したいベースアイテムのsval
1855  * @return なし
1856  */
1857 s16b lookup_kind(int tval, int sval)
1858 {
1859         int k;
1860         int num = 0;
1861         int bk = 0;
1862
1863         /* Look for it */
1864         for (k = 1; k < max_k_idx; k++)
1865         {
1866                 object_kind *k_ptr = &k_info[k];
1867
1868                 /* Require correct tval */
1869                 if (k_ptr->tval != tval) continue;
1870
1871                 /* Found a match */
1872                 if (k_ptr->sval == sval) return (k);
1873
1874                 /* Ignore illegal items */
1875                 if (sval != SV_ANY) continue;
1876
1877                 /* Apply the randomizer */
1878                 if (!one_in_(++num)) continue;
1879
1880                 /* Use this value */
1881                 bk = k;
1882         }
1883
1884         /* Return this choice */
1885         if (sval == SV_ANY)
1886         {
1887                 return bk;
1888         }
1889
1890 #if 0
1891         /* Oops */
1892         msg_format(_("アイテムがない (%d,%d)", "No object (%d,%d)"), tval, sval);
1893 #endif
1894
1895
1896         /* Oops */
1897         return (0);
1898 }
1899
1900
1901 /*!
1902  * @brief オブジェクトを初期化する
1903  * Wipe an object clean.
1904  * @param o_ptr 初期化したいオブジェクトの構造体参照ポインタ
1905  * @return なし
1906  */
1907 void object_wipe(object_type *o_ptr)
1908 {
1909         /* Wipe the structure */
1910         (void)WIPE(o_ptr, object_type);
1911 }
1912
1913
1914 /*!
1915  * @brief オブジェクトを複製する
1916  * Wipe an object clean.
1917  * @param o_ptr 複製元のオブジェクトの構造体参照ポインタ
1918  * @param j_ptr 複製先のオブジェクトの構造体参照ポインタ
1919  * @return なし
1920  */
1921 void object_copy(object_type *o_ptr, object_type *j_ptr)
1922 {
1923         /* Copy the structure */
1924         (void)COPY(o_ptr, j_ptr, object_type);
1925 }
1926
1927
1928 /*!
1929  * @brief オブジェクト構造体にベースアイテムを作成する
1930  * Prepare an object based on an object kind.
1931  * @param o_ptr 代入したいオブジェクトの構造体参照ポインタ
1932  * @param k_idx 新たに作成したいベースアイテム情報のID
1933  * @return なし
1934  */
1935 void object_prep(object_type *o_ptr, int k_idx)
1936 {
1937         object_kind *k_ptr = &k_info[k_idx];
1938
1939         /* Clear the record */
1940         object_wipe(o_ptr);
1941
1942         /* Save the kind index */
1943         o_ptr->k_idx = k_idx;
1944
1945         /* Efficiency -- tval/sval */
1946         o_ptr->tval = k_ptr->tval;
1947         o_ptr->sval = k_ptr->sval;
1948
1949         /* Default "pval" */
1950         o_ptr->pval = k_ptr->pval;
1951
1952         /* Default number */
1953         o_ptr->number = 1;
1954
1955         /* Default weight */
1956         o_ptr->weight = k_ptr->weight;
1957
1958         /* Default magic */
1959         o_ptr->to_h = k_ptr->to_h;
1960         o_ptr->to_d = k_ptr->to_d;
1961         o_ptr->to_a = k_ptr->to_a;
1962
1963         /* Default power */
1964         o_ptr->ac = k_ptr->ac;
1965         o_ptr->dd = k_ptr->dd;
1966         o_ptr->ds = k_ptr->ds;
1967
1968         /* Default activation */
1969         if (k_ptr->act_idx > 0) o_ptr->xtra2 = k_ptr->act_idx;
1970
1971         /* Hack -- worthless items are always "broken" */
1972         if (k_info[o_ptr->k_idx].cost <= 0) o_ptr->ident |= (IDENT_BROKEN);
1973
1974         /* Hack -- cursed items are always "cursed" */
1975         if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
1976         if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
1977         if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
1978         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
1979         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
1980         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
1981 }
1982
1983
1984 /*!
1985  * @brief 上質以上のオブジェクトに与えるための各種ボーナスを正規乱数も加えて算出する。
1986  * Help determine an "enchantment bonus" for an object.
1987  * @param max ボーナス値の限度
1988  * @param level ボーナス値に加味する基準生成階
1989  * @return 算出されたボーナス値
1990  * @details
1991  * To avoid floating point but still provide a smooth distribution of bonuses,\n
1992  * we simply round the results of division in such a way as to "average" the\n
1993  * correct floating point value.\n
1994  *\n
1995  * This function has been changed.  It uses "randnor()" to choose values from\n
1996  * a normal distribution, whose mean moves from zero towards the max as the\n
1997  * level increases, and whose standard deviation is equal to 1/4 of the max,\n
1998  * and whose values are forced to lie between zero and the max, inclusive.\n
1999  *\n
2000  * Since the "level" rarely passes 100 before Morgoth is dead, it is very\n
2001  * rare to get the "full" enchantment on an object, even a deep levels.\n
2002  *\n
2003  * It is always possible (albeit unlikely) to get the "full" enchantment.\n
2004  *\n
2005  * A sample distribution of values from "m_bonus(10, N)" is shown below:\n
2006  *\n
2007  *   N       0     1     2     3     4     5     6     7     8     9    10\n
2008  * ---    ----  ----  ----  ----  ----  ----  ----  ----  ----  ----  ----\n
2009  *   0   66.37 13.01  9.73  5.47  2.89  1.31  0.72  0.26  0.12  0.09  0.03\n
2010  *   8   46.85 24.66 12.13  8.13  4.20  2.30  1.05  0.36  0.19  0.08  0.05\n
2011  *  16   30.12 27.62 18.52 10.52  6.34  3.52  1.95  0.90  0.31  0.15  0.05\n
2012  *  24   22.44 15.62 30.14 12.92  8.55  5.30  2.39  1.63  0.62  0.28  0.11\n
2013  *  32   16.23 11.43 23.01 22.31 11.19  7.18  4.46  2.13  1.20  0.45  0.41\n
2014  *  40   10.76  8.91 12.80 29.51 16.00  9.69  5.90  3.43  1.47  0.88  0.65\n
2015  *  48    7.28  6.81 10.51 18.27 27.57 11.76  7.85  4.99  2.80  1.22  0.94\n
2016  *  56    4.41  4.73  8.52 11.96 24.94 19.78 11.06  7.18  3.68  1.96  1.78\n
2017  *  64    2.81  3.07  5.65  9.17 13.01 31.57 13.70  9.30  6.04  3.04  2.64\n
2018  *  72    1.87  1.99  3.68  7.15 10.56 20.24 25.78 12.17  7.52  4.42  4.62\n
2019  *  80    1.02  1.23  2.78  4.75  8.37 12.04 27.61 18.07 10.28  6.52  7.33\n
2020  *  88    0.70  0.57  1.56  3.12  6.34 10.06 15.76 30.46 12.58  8.47 10.38\n
2021  *  96    0.27  0.60  1.25  2.28  4.30  7.60 10.77 22.52 22.51 11.37 16.53\n
2022  * 104    0.22  0.42  0.77  1.36  2.62  5.33  8.93 13.05 29.54 15.23 22.53\n
2023  * 112    0.15  0.20  0.56  0.87  2.00  3.83  6.86 10.06 17.89 27.31 30.27\n
2024  * 120    0.03  0.11  0.31  0.46  1.31  2.48  4.60  7.78 11.67 25.53 45.72\n
2025  * 128    0.02  0.01  0.13  0.33  0.83  1.41  3.24  6.17  9.57 14.22 64.07\n
2026  */
2027 s16b m_bonus(int max, int level)
2028 {
2029         int bonus, stand, extra, value;
2030
2031
2032         /* Paranoia -- enforce maximal "level" */
2033         if (level > MAX_DEPTH - 1) level = MAX_DEPTH - 1;
2034
2035
2036         /* The "bonus" moves towards the max */
2037         bonus = ((max * level) / MAX_DEPTH);
2038
2039         /* Hack -- determine fraction of error */
2040         extra = ((max * level) % MAX_DEPTH);
2041
2042         /* Hack -- simulate floating point computations */
2043         if (randint0(MAX_DEPTH) < extra) bonus++;
2044
2045
2046         /* The "stand" is equal to one quarter of the max */
2047         stand = (max / 4);
2048
2049         /* Hack -- determine fraction of error */
2050         extra = (max % 4);
2051
2052         /* Hack -- simulate floating point computations */
2053         if (randint0(4) < extra) stand++;
2054
2055
2056         /* Choose an "interesting" value */
2057         value = randnor(bonus, stand);
2058
2059         /* Enforce the minimum value */
2060         if (value < 0) return (0);
2061
2062         /* Enforce the maximum value */
2063         if (value > max) return (max);
2064
2065         /* Result */
2066         return (value);
2067 }
2068
2069
2070 /*!
2071  * @brief デバッグ時にアイテム生成情報をメッセージに出力する / Cheat -- describe a created object for the user
2072  * @param o_ptr デバッグ出力するオブジェクトの構造体参照ポインタ
2073  * @return なし
2074  */
2075 static void object_mention(object_type *o_ptr)
2076 {
2077         char o_name[MAX_NLEN];
2078
2079         object_aware(o_ptr);
2080         object_known(o_ptr);
2081
2082         /* Mark the item as fully known */
2083         o_ptr->ident |= (IDENT_MENTAL);
2084
2085         /* Description */
2086         object_desc(o_name, o_ptr, 0);
2087         msg_format_wizard(CHEAT_OBJECT, _("%sを生成しました。", "%s was generated."), o_name);
2088 }
2089
2090 /*!
2091  * @brief INSTA_ART型の固定アーティファクトの生成を確率に応じて試行する。
2092  * Mega-Hack -- Attempt to create one of the "Special Objects"
2093  * @param o_ptr 生成に割り当てたいオブジェクトの構造体参照ポインタ
2094  * @return 生成に成功したらTRUEを返す。
2095  * @details
2096  * We are only called from "make_object()", and we assume that\n
2097  * "apply_magic()" is called immediately after we return.\n
2098  *\n
2099  * Note -- see "make_artifact()" and "apply_magic()"\n
2100  */
2101 static bool make_artifact_special(object_type *o_ptr)
2102 {
2103         int i;
2104         int k_idx = 0;
2105
2106         /*! @note 地上ではキャンセルする / No artifacts in the town */
2107         if (!dun_level) return (FALSE);
2108
2109         /*! @note get_obj_num_hookによる指定がある場合は生成をキャンセルする / Themed object */
2110         if (get_obj_num_hook) return (FALSE);
2111
2112         /*! @note 全固定アーティファクト中からIDの若い順に生成対象とその確率を走査する / Check the artifact list (just the "specials") */
2113         for (i = 0; i < max_a_idx; i++)
2114         {
2115                 artifact_type *a_ptr = &a_info[i];
2116
2117                 /*! @note アーティファクト名が空の不正なデータは除外する / Skip "empty" artifacts */
2118                 if (!a_ptr->name) continue;
2119
2120                 /*! @note 既に生成回数がカウントされたアーティファクト、QUESTITEMと非INSTA_ARTは除外 / Cannot make an artifact twice */
2121                 if (a_ptr->cur_num) continue;
2122                 if (a_ptr->gen_flags & TRG_QUESTITEM) continue;
2123                 if (!(a_ptr->gen_flags & TRG_INSTA_ART)) continue;
2124
2125                 /*! @note アーティファクト生成階が現在に対して足りない場合は高確率で1/(不足階層*2)を満たさないと生成リストに加えられない /
2126                  *  XXX XXX Enforce minimum "depth" (loosely) */
2127                 if (a_ptr->level > object_level)
2128                 {
2129                         /* @note  / Acquire the "out-of-depth factor". Roll for out-of-depth creation. */
2130                         int d = (a_ptr->level - object_level) * 2;
2131                         if (!one_in_(d)) continue;
2132                 }
2133
2134                 /*! @note 1/(レア度)の確率を満たさないと除外される / Artifact "rarity roll" */
2135                 if (!one_in_(a_ptr->rarity)) continue;
2136
2137                 /*! @note INSTA_ART型固定アーティファクトのベースアイテムもチェック対象とする。ベースアイテムの生成階層が足りない場合1/(不足階層*5) を満たさないと除外される。 /
2138                  *  Find the base object. XXX XXX Enforce minimum "object" level (loosely). Acquire the "out-of-depth factor". Roll for out-of-depth creation. */
2139                 k_idx = lookup_kind(a_ptr->tval, a_ptr->sval);
2140                 if (k_info[k_idx].level > object_level)
2141                 {
2142                         int d = (k_info[k_idx].level - object_level) * 5;
2143                         if (!one_in_(d)) continue;
2144                 }
2145
2146                 /*! @note 前述の条件を満たしたら、後のIDのアーティファクトはチェックせずすぐ確定し生成処理に移す /
2147                  * Assign the template. Mega-Hack -- mark the item as an artifact. Hack: Some artifacts get random extra powers. Success. */
2148                 object_prep(o_ptr, k_idx);
2149
2150                 o_ptr->name1 = i;
2151                 random_artifact_resistance(o_ptr, a_ptr);
2152                 return (TRUE);
2153         }
2154
2155         /*! @note 全INSTA_ART固定アーティファクトを試行しても決まらなかった場合 FALSEを返す / Failure */
2156         return (FALSE);
2157 }
2158
2159
2160 /*!
2161  * @brief 非INSTA_ART型の固定アーティファクトの生成を確率に応じて試行する。
2162  * Mega-Hack -- Attempt to create one of the "Special Objects"
2163  * @param o_ptr 生成に割り当てたいオブジェクトの構造体参照ポインタ
2164  * @return 生成に成功したらTRUEを返す。
2165  * @details
2166  * Attempt to change an object into an artifact\n
2167  * This routine should only be called by "apply_magic()"\n
2168  * Note -- see "make_artifact_special()" and "apply_magic()"\n
2169  */
2170 static bool make_artifact(object_type *o_ptr)
2171 {
2172         int i;
2173
2174
2175         /* No artifacts in the town */
2176         if (!dun_level) return (FALSE);
2177
2178         /* Paranoia -- no "plural" artifacts */
2179         if (o_ptr->number != 1) return (FALSE);
2180
2181         /* Check the artifact list (skip the "specials") */
2182         for (i = 0; i < max_a_idx; i++)
2183         {
2184                 artifact_type *a_ptr = &a_info[i];
2185
2186                 /* Skip "empty" items */
2187                 if (!a_ptr->name) continue;
2188
2189                 /* Cannot make an artifact twice */
2190                 if (a_ptr->cur_num) continue;
2191
2192                 if (a_ptr->gen_flags & TRG_QUESTITEM) continue;
2193
2194                 if (a_ptr->gen_flags & TRG_INSTA_ART) continue;
2195
2196                 /* Must have the correct fields */
2197                 if (a_ptr->tval != o_ptr->tval) continue;
2198                 if (a_ptr->sval != o_ptr->sval) continue;
2199
2200                 /* XXX XXX Enforce minimum "depth" (loosely) */
2201                 if (a_ptr->level > dun_level)
2202                 {
2203                         /* Acquire the "out-of-depth factor" */
2204                         int d = (a_ptr->level - dun_level) * 2;
2205
2206                         /* Roll for out-of-depth creation */
2207                         if (!one_in_(d)) continue;
2208                 }
2209
2210                 /* We must make the "rarity roll" */
2211                 if (!one_in_(a_ptr->rarity)) continue;
2212
2213                 /* Hack -- mark the item as an artifact */
2214                 o_ptr->name1 = i;
2215
2216                 /* Hack: Some artifacts get random extra powers */
2217                 random_artifact_resistance(o_ptr, a_ptr);
2218
2219                 /* Success */
2220                 return (TRUE);
2221         }
2222
2223         /* Failure */
2224         return (FALSE);
2225 }
2226
2227
2228 /*!
2229  * @brief アイテムのエゴをレア度の重みに合わせてランダムに選択する
2230  * Choose random ego type
2231  * @param slot 取得したいエゴの装備部位
2232  * @param good TRUEならば通常のエゴ、FALSEならば呪いのエゴが選択対象となる。
2233  * @return 選択されたエゴ情報のID、万一選択できなかった場合はmax_e_idxが返る。
2234  */
2235 static byte get_random_ego(byte slot, bool good)
2236 {
2237         int i, value;
2238         ego_item_type *e_ptr;
2239
2240         long total = 0L;
2241
2242         for (i = 1; i < max_e_idx; i++)
2243         {
2244                 e_ptr = &e_info[i];
2245
2246                 if (e_ptr->slot == slot
2247                     && ((good && e_ptr->rating) || (!good && !e_ptr->rating)) )
2248                 {
2249                         if (e_ptr->rarity)
2250                                 total += (255 / e_ptr->rarity);
2251                 }
2252         }
2253
2254         value = randint1(total);
2255
2256         for (i = 1; i < max_e_idx; i++)
2257         {
2258                 e_ptr = &e_info[i];
2259
2260                 if (e_ptr->slot == slot
2261                     && ((good && e_ptr->rating) || (!good && !e_ptr->rating)) )
2262                 {
2263                         if (e_ptr->rarity)
2264                                 value -= (255 / e_ptr->rarity);
2265                         if (value <= 0L) break;
2266                 }
2267         }
2268         return (byte)i;
2269 }
2270
2271
2272 /*!
2273  * @brief 武器系オブジェクトに生成ランクごとの強化を与えるサブルーチン
2274  * Apply magic to an item known to be a "weapon"
2275  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2276  * @param level 生成基準階
2277  * @param power 生成ランク
2278  * @return なし
2279  * @details
2280  * Hack -- note special base damage dice boosting\n
2281  * Hack -- note special processing for weapon/digger\n
2282  */
2283 static void a_m_aux_1(object_type *o_ptr, int level, int power)
2284 {
2285         HIT_PROB tohit1 = randint1(5) + m_bonus(5, level);
2286         HIT_POINT todam1 = randint1(5) + m_bonus(5, level);
2287
2288         HIT_PROB tohit2 = m_bonus(10, level);
2289         HIT_POINT todam2 = m_bonus(10, level);
2290
2291         if ((o_ptr->tval == TV_BOLT) || (o_ptr->tval == TV_ARROW) || (o_ptr->tval == TV_SHOT))
2292         {
2293                 tohit2 = (tohit2+1)/2;
2294                 todam2 = (todam2+1)/2;
2295         }
2296
2297         /* Good */
2298         if (power > 0)
2299         {
2300                 /* Enchant */
2301                 o_ptr->to_h += tohit1;
2302                 o_ptr->to_d += todam1;
2303
2304                 /* Very good */
2305                 if (power > 1)
2306                 {
2307                         /* Enchant again */
2308                         o_ptr->to_h += tohit2;
2309                         o_ptr->to_d += todam2;
2310                 }
2311         }
2312
2313         /* Cursed */
2314         else if (power < 0)
2315         {
2316                 /* Penalize */
2317                 o_ptr->to_h -= tohit1;
2318                 o_ptr->to_d -= todam1;
2319
2320                 /* Very cursed */
2321                 if (power < -1)
2322                 {
2323                         /* Penalize again */
2324                         o_ptr->to_h -= tohit2;
2325                         o_ptr->to_d -= todam2;
2326                 }
2327
2328                 /* Cursed (if "bad") */
2329                 if (o_ptr->to_h + o_ptr->to_d < 0) o_ptr->curse_flags |= TRC_CURSED;
2330         }
2331
2332         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DIAMOND_EDGE)) return;
2333
2334         /* Analyze type */
2335         switch (o_ptr->tval)
2336         {
2337                 case TV_DIGGING:
2338                 {
2339                         /* Very good */
2340                         if (power > 1)
2341                         {
2342                                 if (one_in_(30) || (power > 2)) /* power > 2 is debug only */
2343                                         create_artifact(o_ptr, FALSE);
2344                                 else
2345                                         /* Special Ego-item */
2346                                         o_ptr->name2 = EGO_DIGGING;
2347                         }
2348
2349                         /* Very bad */
2350                         else if (power < -1)
2351                         {
2352                                 /* Hack -- Horrible digging bonus */
2353                                 o_ptr->pval = 0 - (5 + randint1(5));
2354                         }
2355
2356                         /* Bad */
2357                         else if (power < 0)
2358                         {
2359                                 /* Hack -- Reverse digging bonus */
2360                                 o_ptr->pval = 0 - (o_ptr->pval);
2361                         }
2362
2363                         break;
2364                 }
2365
2366
2367                 case TV_HAFTED:
2368                 case TV_POLEARM:
2369                 case TV_SWORD:
2370                 {
2371                         /* Very Good */
2372                         if (power > 1)
2373                         {
2374                                 if (one_in_(40) || (power > 2)) /* power > 2 is debug only */
2375                                 {
2376                                         create_artifact(o_ptr, FALSE);
2377                                         break;
2378                                 }
2379                                 while (1)
2380                                 {
2381                                         /* Roll for an ego-item */
2382                                         o_ptr->name2 = get_random_ego(INVEN_RARM, TRUE);
2383                                         if (o_ptr->name2 == EGO_SHARPNESS && o_ptr->tval != TV_SWORD)
2384                                                 continue;
2385                                         if (o_ptr->name2 == EGO_EARTHQUAKES && o_ptr->tval != TV_HAFTED)
2386                                                 continue;
2387                                         if (o_ptr->name2 == EGO_WEIRD && o_ptr->tval != TV_SWORD)
2388                                                 continue;
2389                                         break;
2390                                 }
2391
2392                                 switch (o_ptr->name2)
2393                                 {
2394                                 case EGO_HA:
2395                                         if (one_in_(4) && (level > 40))
2396                                                 add_flag(o_ptr->art_flags, TR_BLOWS);
2397                                         break;
2398                                 case EGO_DF:
2399                                         if (one_in_(3))
2400                                                 add_flag(o_ptr->art_flags, TR_RES_POIS);
2401                                         if (one_in_(3))
2402                                                 add_flag(o_ptr->art_flags, TR_WARNING);
2403                                         break;
2404                                 case EGO_KILL_DRAGON:
2405                                         if (one_in_(3))
2406                                                 add_flag(o_ptr->art_flags, TR_RES_POIS);
2407                                         break;
2408                                 case EGO_WEST:
2409                                         if (one_in_(3))
2410                                                 add_flag(o_ptr->art_flags, TR_RES_FEAR);
2411                                         break;
2412                                 case EGO_SLAYING_WEAPON:
2413                                         if (one_in_(3)) /* double damage */
2414                                                 o_ptr->dd *= 2;
2415                                         else
2416                                         {
2417                                                 do
2418                                                 {
2419                                                         o_ptr->dd++;
2420                                                 }
2421                                                 while (one_in_(o_ptr->dd));
2422
2423                                                 do
2424                                                 {
2425                                                         o_ptr->ds++;
2426                                                 }
2427                                                 while (one_in_(o_ptr->ds));
2428                                         }
2429
2430                                         if (one_in_(5))
2431                                         {
2432                                                 add_flag(o_ptr->art_flags, TR_BRAND_POIS);
2433                                         }
2434                                         if (o_ptr->tval == TV_SWORD && one_in_(3))
2435                                         {
2436                                                 add_flag(o_ptr->art_flags, TR_VORPAL);
2437                                         }
2438                                         break;
2439                                 case EGO_TRUMP:
2440                                         if (one_in_(5))
2441                                                 add_flag(o_ptr->art_flags, TR_SLAY_DEMON);
2442                                         if (one_in_(7))
2443                                                 one_ability(o_ptr);
2444                                         break;
2445                                 case EGO_PATTERN:
2446                                         if (one_in_(3))
2447                                                 add_flag(o_ptr->art_flags, TR_HOLD_EXP);
2448                                         if (one_in_(3))
2449                                                 add_flag(o_ptr->art_flags, TR_DEX);
2450                                         if (one_in_(5))
2451                                                 add_flag(o_ptr->art_flags, TR_RES_FEAR);
2452                                         break;
2453                                 case EGO_SHARPNESS:
2454                                         o_ptr->pval = m_bonus(5, level) + 1;
2455                                         break;
2456                                 case EGO_EARTHQUAKES:
2457                                         if (one_in_(3) && (level > 60))
2458                                                 add_flag(o_ptr->art_flags, TR_BLOWS);
2459                                         else
2460                                                 o_ptr->pval = m_bonus(3, level);
2461                                         break;
2462                                 case EGO_VAMPIRIC:
2463                                         if (one_in_(5))
2464                                                 add_flag(o_ptr->art_flags, TR_SLAY_HUMAN);
2465                                         break;
2466                                 case EGO_DEMON:
2467
2468                                         if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2469                                         one_in_(3) ?
2470                                                 add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
2471                                                 one_in_(2) ?
2472                                                         add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
2473                                                         add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2474
2475
2476                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_CHAOTIC);
2477                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_BLOWS);
2478                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2479                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
2480                                         break;
2481                                 }
2482
2483                                 if (!o_ptr->art_name)
2484                                 {
2485                                         /* Hack -- Super-charge the damage dice */
2486                                         while (one_in_(10L * o_ptr->dd * o_ptr->ds)) o_ptr->dd++;
2487
2488                                         /* Hack -- Lower the damage dice */
2489                                         if (o_ptr->dd > 9) o_ptr->dd = 9;
2490                                 }
2491                         }
2492
2493                         /* Very cursed */
2494                         else if (power < -1)
2495                         {
2496                                 /* Roll for ego-item */
2497                                 if (randint0(MAX_DEPTH) < level)
2498                                 {
2499                                         while(1)
2500                                         {
2501                                                 o_ptr->name2 = get_random_ego(INVEN_RARM, FALSE);
2502                                                 if (o_ptr->name2 == EGO_WEIRD && o_ptr->tval != TV_SWORD)
2503                                                 {
2504                                                         continue;
2505                                                 }
2506                                                 break;
2507                                         }
2508                                         switch (o_ptr->name2)
2509                                         {
2510                                         case EGO_MORGUL:
2511                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2512                                                 if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2513                                         case EGO_WEIRD:
2514                                                 if (one_in_(4)) add_flag(o_ptr->art_flags, TR_BRAND_POIS);
2515                                                 if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_NETHER);
2516                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2517                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2518                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2519                                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2520                                         }
2521                                 }
2522                         }
2523
2524                         break;
2525                 }
2526
2527
2528                 case TV_BOW:
2529                 {
2530                         /* Very good */
2531                         if (power > 1)
2532                         {
2533                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2534                                 {
2535                                         create_artifact(o_ptr, FALSE);
2536                                         break;
2537                                 }
2538                                 o_ptr->name2 = get_random_ego(INVEN_BOW, TRUE);
2539                         }
2540
2541                         break;
2542                 }
2543
2544
2545                 case TV_BOLT:
2546                 case TV_ARROW:
2547                 case TV_SHOT:
2548                 {
2549                         /* Very good */
2550                         if (power > 1)
2551                         {
2552                                 if (power > 2) /* power > 2 is debug only */
2553                                 {
2554                                         create_artifact(o_ptr, FALSE);
2555                                         break;
2556                                 }
2557
2558                                 o_ptr->name2 = get_random_ego(INVEN_AMMO, TRUE);
2559
2560                                 switch (o_ptr->name2)
2561                                 {
2562                                 case EGO_SLAYING_BOLT:
2563                                         o_ptr->dd++;
2564                                         break;
2565                                 }
2566
2567                                 /* Hack -- super-charge the damage dice */
2568                                 while (one_in_(10L * o_ptr->dd * o_ptr->ds)) o_ptr->dd++;
2569
2570                                 /* Hack -- restrict the damage dice */
2571                                 if (o_ptr->dd > 9) o_ptr->dd = 9;
2572                         }
2573
2574                         /* Very cursed */
2575                         else if (power < -1)
2576                         {
2577                                 /* Roll for ego-item */
2578                                 if (randint0(MAX_DEPTH) < level)
2579                                 {
2580                                         o_ptr->name2 = get_random_ego(INVEN_AMMO, FALSE);
2581                                 }
2582                         }
2583
2584                         break;
2585                 }
2586         }
2587 }
2588
2589 /*!
2590  * @brief ドラゴン装備にランダムな耐性を与える
2591  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2592  * @return なし
2593  */
2594 static void dragon_resist(object_type * o_ptr)
2595 {
2596         do
2597         {
2598                 if (one_in_(4))
2599                         one_dragon_ele_resistance(o_ptr);
2600                 else
2601                         one_high_resistance(o_ptr);
2602         }
2603         while (one_in_(2));
2604 }
2605
2606 /*!
2607  * @brief オブジェクトにランダムな強いESPを与える
2608  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2609  * @return なし
2610  */
2611 static bool add_esp_strong(object_type *o_ptr)
2612 {
2613         bool nonliv = FALSE;
2614
2615         switch (randint1(3))
2616         {
2617         case 1: add_flag(o_ptr->art_flags, TR_ESP_EVIL); break;
2618         case 2: add_flag(o_ptr->art_flags, TR_TELEPATHY); break;
2619         case 3: add_flag(o_ptr->art_flags, TR_ESP_NONLIVING); nonliv = TRUE; break;
2620         }
2621
2622         return nonliv;
2623 }
2624
2625 /*!
2626  * @brief オブジェクトにランダムな弱いESPを与える
2627  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2628  * @param extra TRUEならばESPの最大付与数が増える(TRUE -> 3+1d6 / FALSE -> 1d3)
2629  * @return なし
2630  */
2631 static void add_esp_weak(object_type *o_ptr, bool extra)
2632 {
2633         int i;
2634         u32b weak_esp_list[] = {
2635                 TR_ESP_ANIMAL,
2636                 TR_ESP_UNDEAD,
2637                 TR_ESP_DEMON,
2638                 TR_ESP_ORC,
2639                 TR_ESP_TROLL,
2640                 TR_ESP_GIANT,
2641                 TR_ESP_DRAGON,
2642                 TR_ESP_HUMAN,
2643                 TR_ESP_GOOD,
2644                 TR_ESP_UNIQUE,
2645         };
2646         const int MAX_ESP_WEAK = sizeof(weak_esp_list) / sizeof(weak_esp_list[0]);
2647         const int add_count = MIN(MAX_ESP_WEAK, (extra) ? (3 + randint1(randint1(6))) : randint1(3));
2648
2649         /* Add unduplicated weak esp flags randomly */
2650         for (i = 0; i < add_count; ++ i)
2651         {
2652                 int choice = rand_range(i, MAX_ESP_WEAK - 1);
2653
2654                 add_flag(o_ptr->art_flags, weak_esp_list[choice]);
2655                 weak_esp_list[choice] = weak_esp_list[i];
2656         }
2657 }
2658
2659
2660 /*!
2661  * @brief 防具系オブジェクトに生成ランクごとの強化を与えるサブルーチン
2662  * Apply magic to an item known to be "armor"
2663  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2664  * @param level 生成基準階
2665  * @param power 生成ランク
2666  * @return なし
2667  * @details
2668  * Hack -- note special processing for crown/helm\n
2669  * Hack -- note special processing for robe of permanence\n
2670  */
2671 static void a_m_aux_2(object_type *o_ptr, int level, int power)
2672 {
2673         ARMOUR_CLASS toac1 = randint1(5) + m_bonus(5, level);
2674         ARMOUR_CLASS toac2 = m_bonus(10, level);
2675
2676         /* Good */
2677         if (power > 0)
2678         {
2679                 /* Enchant */
2680                 o_ptr->to_a += toac1;
2681
2682                 /* Very good */
2683                 if (power > 1)
2684                 {
2685                         /* Enchant again */
2686                         o_ptr->to_a += toac2;
2687                 }
2688         }
2689
2690         /* Cursed */
2691         else if (power < 0)
2692         {
2693                 /* Penalize */
2694                 o_ptr->to_a -= toac1;
2695
2696                 /* Very cursed */
2697                 if (power < -1)
2698                 {
2699                         /* Penalize again */
2700                         o_ptr->to_a -= toac2;
2701                 }
2702
2703                 /* Cursed (if "bad") */
2704                 if (o_ptr->to_a < 0) o_ptr->curse_flags |= TRC_CURSED;
2705         }
2706
2707
2708         /* Analyze type */
2709         switch (o_ptr->tval)
2710         {
2711                 case TV_DRAG_ARMOR:
2712                 {
2713                         if (one_in_(50) || (power > 2)) /* power > 2 is debug only */
2714                                 create_artifact(o_ptr, FALSE);
2715                         break;
2716                 }
2717
2718                 case TV_HARD_ARMOR:
2719                 case TV_SOFT_ARMOR:
2720                 {
2721                         /* Very good */
2722                         if (power > 1)
2723                         {
2724                                 /* Hack -- Try for "Robes of the Magi" */
2725                                 if ((o_ptr->tval == TV_SOFT_ARMOR) &&
2726                                     (o_ptr->sval == SV_ROBE) &&
2727                                     (randint0(100) < 15))
2728                                 {
2729                                         if (one_in_(5))
2730                                         {
2731                                                 o_ptr->name2 = EGO_YOIYAMI;
2732                                                 o_ptr->k_idx = lookup_kind(TV_SOFT_ARMOR, SV_YOIYAMI_ROBE);
2733                                                 o_ptr->sval = SV_YOIYAMI_ROBE;
2734                                                 o_ptr->ac = 0;
2735                                                 o_ptr->to_a = 0;
2736                                         }
2737                                         else
2738                                         {
2739                                                 o_ptr->name2 = EGO_PERMANENCE;
2740                                         }
2741                                         break;
2742                                 }
2743
2744                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2745                                 {
2746                                         create_artifact(o_ptr, FALSE);
2747                                         break;
2748                                 }
2749
2750                                 while (1)
2751                                 {
2752                                         bool okay_flag = TRUE;
2753
2754                                         o_ptr->name2 = get_random_ego(INVEN_BODY, TRUE);
2755
2756                                         switch (o_ptr->name2)
2757                                         {
2758                                                 case EGO_DWARVEN:
2759                                                         if (o_ptr->tval != TV_HARD_ARMOR)
2760                                                         {
2761                                                                 okay_flag = FALSE;
2762                                                         }
2763                                                 break;
2764                                                 case EGO_DRUID:
2765                                                         if (o_ptr->tval != TV_SOFT_ARMOR)
2766                                                         {
2767                                                                 okay_flag = FALSE;
2768                                                         }
2769                                                 break;
2770                                                 default:
2771                                                 break;
2772                                         }
2773
2774                                         if (okay_flag) break;
2775                                 }
2776                                 switch (o_ptr->name2)
2777                                 {
2778                                   case EGO_RESISTANCE:
2779                                         if (one_in_(4))
2780                                                 add_flag(o_ptr->art_flags, TR_RES_POIS);
2781                                                 break;
2782                                   case EGO_DWARVEN:
2783                                         o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2784                                         o_ptr->ac = k_info[o_ptr->k_idx].ac + 5;
2785                                         break;
2786
2787                                   case EGO_A_DEMON:
2788                                         if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2789                                         one_in_(3) ?
2790                                                 add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
2791                                                 one_in_(2) ?
2792                                                         add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
2793                                                         add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2794
2795                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2796                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
2797                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2798                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2799                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2800                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2801                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2802                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
2803                                         break;
2804                                   case EGO_A_MORGUL:
2805                                         if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2806                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2807                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2808                                         if (one_in_(6)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2809                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2810                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2811                                         break;
2812                                   default:
2813                                         break;
2814                                 }
2815                         }
2816
2817                         break;
2818                 }
2819
2820                 case TV_SHIELD:
2821                 {
2822
2823                         if (o_ptr->sval == SV_DRAGON_SHIELD)
2824                         {
2825                                 dragon_resist(o_ptr);
2826                                 if (!one_in_(3)) break;
2827                         }
2828
2829                         /* Very good */
2830                         if (power > 1)
2831                         {
2832                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2833                                 {
2834                                         create_artifact(o_ptr, FALSE);
2835                                         break;
2836                                 }
2837
2838                                 while(1)
2839                                 {
2840                                         o_ptr->name2 = get_random_ego(INVEN_LARM, TRUE);
2841                                         if (o_ptr->sval != SV_SMALL_METAL_SHIELD && o_ptr->sval != SV_LARGE_METAL_SHIELD
2842                                                                 && o_ptr->name2 == EGO_S_DWARVEN)
2843                                         {
2844                                                 continue;
2845                                         }
2846                                         break;
2847                                 }
2848
2849                                 switch (o_ptr->name2)
2850                                 {
2851                                 case EGO_ENDURANCE:
2852                                         if (!one_in_(3)) one_high_resistance(o_ptr);
2853                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_POIS);
2854                                         break;
2855                                 case EGO_REFLECTION:
2856                                         if (o_ptr->sval == SV_MIRROR_SHIELD)
2857                                                 o_ptr->name2 = 0;
2858                                         break;
2859
2860                                 case EGO_S_DWARVEN:
2861                                         o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2862                                         o_ptr->ac = k_info[o_ptr->k_idx].ac + 3;
2863                                         break;
2864                                 }
2865                         }
2866                         break;
2867                 }
2868
2869                 case TV_GLOVES:
2870                 {
2871                         if (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)
2872                         {
2873                                 dragon_resist(o_ptr);
2874                                 if (!one_in_(3)) break;
2875                         }
2876                         if (power > 1)
2877                         {
2878                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2879                                 {
2880                                         create_artifact(o_ptr, FALSE);
2881                                         break;
2882                                 }
2883                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, TRUE);
2884                         }
2885
2886                         /* Very cursed */
2887                         else if (power < -1)
2888                         {
2889                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, FALSE);
2890                         }
2891
2892                         break;
2893                 }
2894
2895                 case TV_BOOTS:
2896                 {
2897                         if (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)
2898                         {
2899                                 dragon_resist(o_ptr);
2900                                 if (!one_in_(3)) break;
2901                         }
2902                         /* Very good */
2903                         if (power > 1)
2904                         {
2905                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2906                                 {
2907                                         create_artifact(o_ptr, FALSE);
2908                                         break;
2909                                 }
2910                                 o_ptr->name2 = get_random_ego(INVEN_FEET, TRUE);
2911
2912                                 switch (o_ptr->name2)
2913                                 {
2914                                 case EGO_SLOW_DESCENT:
2915                                         if (one_in_(2))
2916                                         {
2917                                                 one_high_resistance(o_ptr);
2918                                         }
2919                                         break;
2920                                 }
2921                         }
2922                         /* Very cursed */
2923                         else if (power < -1)
2924                         {
2925                                 o_ptr->name2 = get_random_ego(INVEN_FEET, FALSE);
2926                         }
2927
2928                         break;
2929                 }
2930
2931                 case TV_CROWN:
2932                 {
2933                         /* Very good */
2934                         if (power > 1)
2935                         {
2936                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2937                                 {
2938                                         create_artifact(o_ptr, FALSE);
2939                                         break;
2940                                 }
2941                                 while (1)
2942                                 {
2943                                         bool ok_flag = TRUE;
2944                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
2945
2946                                         switch (o_ptr->name2)
2947                                         {
2948                                         case EGO_TELEPATHY:
2949                                                 if (add_esp_strong(o_ptr)) add_esp_weak(o_ptr, TRUE);
2950                                                 else add_esp_weak(o_ptr, FALSE);
2951                                                 break;
2952                                         case EGO_MAGI:
2953                                         case EGO_MIGHT:
2954                                         case EGO_REGENERATION:
2955                                         case EGO_LORDLINESS:
2956                                         case EGO_BASILISK:
2957                                                 break;
2958                                         case EGO_SEEING:
2959                                                 if (one_in_(3))
2960                                                 {
2961                                                         if (one_in_(2)) add_esp_strong(o_ptr);
2962                                                         else add_esp_weak(o_ptr, FALSE);
2963                                                 }
2964                                                 break;
2965                                         default:/* not existing crown (wisdom,lite, etc...) */
2966                                                 ok_flag = FALSE;
2967                                         }
2968                                         if (ok_flag)
2969                                                 break; /* while (1) */
2970                                 }
2971                                 break;
2972                         }
2973
2974                         /* Very cursed */
2975                         else if (power < -1)
2976                         {
2977                                 while (1)
2978                                 {
2979                                         bool ok_flag = TRUE;
2980                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
2981
2982                                         switch (o_ptr->name2)
2983                                         {
2984                                           case EGO_ANCIENT_CURSE:
2985                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2986                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2987                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2988                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2989                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2990                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2991                                                 break;
2992                                         }
2993                                         if (ok_flag)
2994                                                 break; /* while (1) */
2995                                 }
2996                         }
2997
2998                         break;
2999                 }
3000
3001                 case TV_HELM:
3002                 {
3003                         if (o_ptr->sval == SV_DRAGON_HELM)
3004                         {
3005                                 dragon_resist(o_ptr);
3006                                 if (!one_in_(3)) break;
3007                         }
3008
3009                         /* Very good */
3010                         if (power > 1)
3011                         {
3012                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
3013                                 {
3014                                         create_artifact(o_ptr, FALSE);
3015                                         break;
3016                                 }
3017                                 while (1)
3018                                 {
3019                                         bool ok_flag = TRUE;
3020                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
3021
3022                                         switch (o_ptr->name2)
3023                                         {
3024                                         case EGO_BRILLIANCE:
3025                                         case EGO_DARK:
3026                                         case EGO_INFRAVISION:
3027                                         case EGO_H_PROTECTION:
3028                                                 break;
3029                                         case EGO_SEEING:
3030                                                 if (one_in_(7))
3031                                                 {
3032                                                         if (one_in_(2)) add_esp_strong(o_ptr);
3033                                                         else add_esp_weak(o_ptr, FALSE);
3034                                                 }
3035                                                 break;
3036                                         case EGO_LITE:
3037                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_1);
3038                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_2);
3039                                                 break;
3040                                         case EGO_H_DEMON:
3041                                                 if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
3042                                                 one_in_(3) ?
3043                                                         add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
3044                                                         one_in_(2) ?
3045                                                                 add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
3046                                                                 add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
3047
3048                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
3049                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
3050                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
3051                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
3052                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
3053                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
3054                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
3055                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
3056                                                 break;
3057                                         default:/* not existing helm (Magi, Might, etc...)*/
3058                                                 ok_flag = FALSE;
3059                                         }
3060                                         if (ok_flag)
3061                                                 break; /* while (1) */
3062                                 }
3063                                 break;
3064                         }
3065                         /* Very cursed */
3066                         else if (power < -1)
3067                         {
3068                                 while (1)
3069                                 {
3070                                         bool ok_flag = TRUE;
3071                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
3072
3073                                         switch (o_ptr->name2)
3074                                         {
3075                                           case EGO_ANCIENT_CURSE:
3076                                                 ok_flag = FALSE;
3077                                         }
3078                                         if (ok_flag)
3079                                                 break; /* while (1) */
3080                                 }
3081                         }
3082                         break;
3083                 }
3084
3085                 case TV_CLOAK:
3086                 {
3087                         /* Very good */
3088                         if (power > 1)
3089                         {
3090                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
3091                                 {
3092                                         create_artifact(o_ptr, FALSE);
3093                                         break;
3094                                 }
3095                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, TRUE);
3096
3097                                 switch (o_ptr->name2)
3098                                 {
3099                                 case EGO_BAT:
3100                                         o_ptr->to_d -= 6;
3101                                         o_ptr->to_h -= 6;
3102                                         break;
3103                                   case EGO_NAZGUL:
3104                                         o_ptr->to_d -= 3;
3105                                         o_ptr->to_h -= 3;
3106                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_COWARDICE);
3107                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_CALL_UNDEAD);
3108                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_SLOW_REGEN);
3109                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
3110                                         break;
3111                                 }
3112
3113                         }
3114
3115                         /* Very cursed */
3116                         else if (power < -1)
3117                         {
3118                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, FALSE);
3119                         }
3120
3121                         break;
3122                 }
3123         }
3124
3125 }
3126
3127
3128 /*!
3129  * @brief 装飾品系オブジェクトに生成ランクごとの強化を与えるサブルーチン
3130  * Apply magic to an item known to be a "ring" or "amulet"
3131  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3132  * @param level 生成基準階
3133  * @param power 生成ランク
3134  * @return なし
3135  * @details
3136  * Hack -- note special "pval boost" code for ring of speed\n
3137  * Hack -- note that some items must be cursed (or blessed)\n
3138  */
3139 static void a_m_aux_3(object_type *o_ptr, int level, int power)
3140 {
3141         /* Apply magic (good or bad) according to type */
3142         switch (o_ptr->tval)
3143         {
3144                 case TV_RING:
3145                 {
3146                         /* Analyze */
3147                         switch (o_ptr->sval)
3148                         {
3149                                 case SV_RING_ATTACKS:
3150                                 {
3151                                         /* Stat bonus */
3152                                         o_ptr->pval = m_bonus(2, level);
3153                                         if (one_in_(15)) o_ptr->pval++;
3154                                         if (o_ptr->pval < 1) o_ptr->pval = 1;
3155
3156                                         /* Cursed */
3157                                         if (power < 0)
3158                                         {
3159                                                 /* Broken */
3160                                                 o_ptr->ident |= (IDENT_BROKEN);
3161
3162                                                 /* Cursed */
3163                                                 o_ptr->curse_flags |= TRC_CURSED;
3164
3165                                                 /* Reverse pval */
3166                                                 o_ptr->pval = 0 - (o_ptr->pval);
3167                                         }
3168
3169                                         break;
3170                                 }
3171
3172                                 case SV_RING_SHOTS:
3173                                 {
3174                                         break;
3175                                 }
3176
3177                                 /* Strength, Constitution, Dexterity, Intelligence */
3178                                 case SV_RING_STR:
3179                                 case SV_RING_CON:
3180                                 case SV_RING_DEX:
3181                                 {
3182                                         /* Stat bonus */
3183                                         o_ptr->pval = 1 + m_bonus(5, level);
3184
3185                                         /* Cursed */
3186                                         if (power < 0)
3187                                         {
3188                                                 /* Broken */
3189                                                 o_ptr->ident |= (IDENT_BROKEN);
3190
3191                                                 /* Cursed */
3192                                                 o_ptr->curse_flags |= TRC_CURSED;
3193
3194                                                 /* Reverse pval */
3195                                                 o_ptr->pval = 0 - (o_ptr->pval);
3196                                         }
3197
3198                                         break;
3199                                 }
3200
3201                                 /* Ring of Speed! */
3202                                 case SV_RING_SPEED:
3203                                 {
3204                                         /* Base speed (1 to 10) */
3205                                         o_ptr->pval = randint1(5) + m_bonus(5, level);
3206
3207                                         /* Super-charge the ring */
3208                                         while (randint0(100) < 50) o_ptr->pval++;
3209
3210                                         /* Cursed Ring */
3211                                         if (power < 0)
3212                                         {
3213                                                 /* Broken */
3214                                                 o_ptr->ident |= (IDENT_BROKEN);
3215
3216                                                 /* Cursed */
3217                                                 o_ptr->curse_flags |= TRC_CURSED;
3218
3219                                                 /* Reverse pval */
3220                                                 o_ptr->pval = 0 - (o_ptr->pval);
3221
3222                                                 break;
3223                                         }
3224
3225                                         break;
3226                                 }
3227
3228                                 case SV_RING_LORDLY:
3229                                 {
3230                                         do
3231                                         {
3232                                                 one_lordly_high_resistance(o_ptr);
3233                                         }
3234                                         while (one_in_(4));
3235
3236                                         /* Bonus to armor class */
3237                                         o_ptr->to_a = 10 + randint1(5) + m_bonus(10, level);
3238                                 }
3239                                 break;
3240
3241                                 case SV_RING_WARNING:
3242                                 {
3243                                         if (one_in_(3)) one_low_esp(o_ptr);
3244                                         break;
3245                                 }
3246
3247                                 /* Searching */
3248                                 case SV_RING_SEARCHING:
3249                                 {
3250                                         /* Bonus to searching */
3251                                         o_ptr->pval = 1 + m_bonus(5, level);
3252
3253                                         /* Cursed */
3254                                         if (power < 0)
3255                                         {
3256                                                 /* Broken */
3257                                                 o_ptr->ident |= (IDENT_BROKEN);
3258
3259                                                 /* Cursed */
3260                                                 o_ptr->curse_flags |= TRC_CURSED;
3261
3262                                                 /* Reverse pval */
3263                                                 o_ptr->pval = 0 - (o_ptr->pval);
3264                                         }
3265
3266                                         break;
3267                                 }
3268
3269                                 /* Flames, Acid, Ice */
3270                                 case SV_RING_FLAMES:
3271                                 case SV_RING_ACID:
3272                                 case SV_RING_ICE:
3273                                 case SV_RING_ELEC:
3274                                 {
3275                                         /* Bonus to armor class */
3276                                         o_ptr->to_a = 5 + randint1(5) + m_bonus(10, level);
3277                                         break;
3278                                 }
3279
3280                                 /* Weakness, Stupidity */
3281                                 case SV_RING_WEAKNESS:
3282                                 case SV_RING_STUPIDITY:
3283                                 {
3284                                         /* Broken */
3285                                         o_ptr->ident |= (IDENT_BROKEN);
3286
3287                                         /* Cursed */
3288                                         o_ptr->curse_flags |= TRC_CURSED;
3289
3290                                         /* Penalize */
3291                                         o_ptr->pval = 0 - (1 + m_bonus(5, level));
3292                                         if (power > 0) power = 0 - power;
3293
3294                                         break;
3295                                 }
3296
3297                                 /* WOE, Stupidity */
3298                                 case SV_RING_WOE:
3299                                 {
3300                                         /* Broken */
3301                                         o_ptr->ident |= (IDENT_BROKEN);
3302
3303                                         /* Cursed */
3304                                         o_ptr->curse_flags |= TRC_CURSED;
3305
3306                                         /* Penalize */
3307                                         o_ptr->to_a = 0 - (5 + m_bonus(10, level));
3308                                         o_ptr->pval = 0 - (1 + m_bonus(5, level));
3309                                         if (power > 0) power = 0 - power;
3310
3311                                         break;
3312                                 }
3313
3314                                 /* Ring of damage */
3315                                 case SV_RING_DAMAGE:
3316                                 {
3317                                         /* Bonus to damage */
3318                                         o_ptr->to_d = 1 + randint1(5) + m_bonus(16, level);
3319
3320                                         /* Cursed */
3321                                         if (power < 0)
3322                                         {
3323                                                 /* Broken */
3324                                                 o_ptr->ident |= (IDENT_BROKEN);
3325
3326                                                 /* Cursed */
3327                                                 o_ptr->curse_flags |= TRC_CURSED;
3328
3329                                                 /* Reverse bonus */
3330                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3331                                         }
3332
3333                                         break;
3334                                 }
3335
3336                                 /* Ring of Accuracy */
3337                                 case SV_RING_ACCURACY:
3338                                 {
3339                                         /* Bonus to hit */
3340                                         o_ptr->to_h = 1 + randint1(5) + m_bonus(16, level);
3341
3342                                         /* Cursed */
3343                                         if (power < 0)
3344                                         {
3345                                                 /* Broken */
3346                                                 o_ptr->ident |= (IDENT_BROKEN);
3347
3348                                                 /* Cursed */
3349                                                 o_ptr->curse_flags |= TRC_CURSED;
3350
3351                                                 /* Reverse tohit */
3352                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3353                                         }
3354
3355                                         break;
3356                                 }
3357
3358                                 /* Ring of Protection */
3359                                 case SV_RING_PROTECTION:
3360                                 {
3361                                         /* Bonus to armor class */
3362                                         o_ptr->to_a = 5 + randint1(8) + m_bonus(10, level);
3363
3364                                         /* Cursed */
3365                                         if (power < 0)
3366                                         {
3367                                                 /* Broken */
3368                                                 o_ptr->ident |= (IDENT_BROKEN);
3369
3370                                                 /* Cursed */
3371                                                 o_ptr->curse_flags |= TRC_CURSED;
3372
3373                                                 /* Reverse toac */
3374                                                 o_ptr->to_a = 0 - o_ptr->to_a;
3375                                         }
3376
3377                                         break;
3378                                 }
3379
3380                                 /* Ring of Slaying */
3381                                 case SV_RING_SLAYING:
3382                                 {
3383                                         /* Bonus to damage and to hit */
3384                                         o_ptr->to_d = randint1(5) + m_bonus(12, level);
3385                                         o_ptr->to_h = randint1(5) + m_bonus(12, level);
3386
3387                                         /* Cursed */
3388                                         if (power < 0)
3389                                         {
3390                                                 /* Broken */
3391                                                 o_ptr->ident |= (IDENT_BROKEN);
3392
3393                                                 /* Cursed */
3394                                                 o_ptr->curse_flags |= TRC_CURSED;
3395
3396                                                 /* Reverse bonuses */
3397                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3398                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3399                                         }
3400
3401                                         break;
3402                                 }
3403
3404                                 case SV_RING_MUSCLE:
3405                                 {
3406                                         o_ptr->pval = 1 + m_bonus(3, level);
3407                                         if (one_in_(4)) o_ptr->pval++;
3408
3409                                         /* Cursed */
3410                                         if (power < 0)
3411                                         {
3412                                                 /* Broken */
3413                                                 o_ptr->ident |= (IDENT_BROKEN);
3414
3415                                                 /* Cursed */
3416                                                 o_ptr->curse_flags |= TRC_CURSED;
3417
3418                                                 /* Reverse bonuses */
3419                                                 o_ptr->pval = 0 - o_ptr->pval;
3420                                         }
3421
3422                                         break;
3423                                 }
3424                                 case SV_RING_AGGRAVATION:
3425                                 {
3426                                         /* Broken */
3427                                         o_ptr->ident |= (IDENT_BROKEN);
3428
3429                                         /* Cursed */
3430                                         o_ptr->curse_flags |= TRC_CURSED;
3431
3432                                         if (power > 0) power = 0 - power;
3433                                         break;
3434                                 }
3435                         }
3436                         if ((one_in_(400) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
3437                             || (power > 2)) /* power > 2 is debug only */
3438                         {
3439                                 o_ptr->pval = MIN(o_ptr->pval, 4);
3440                                 /* Randart amulet */
3441                                 create_artifact(o_ptr, FALSE);
3442                         }
3443                         else if ((power == 2) && one_in_(2))
3444                         {
3445                                 while(!o_ptr->name2)
3446                                 {
3447                                         int tmp = m_bonus(10, level);
3448                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3449                                         switch(randint1(28))
3450                                         {
3451                                         case 1: case 2:
3452                                                 o_ptr->name2 = EGO_RING_THROW;
3453                                                 break;
3454                                         case 3: case 4:
3455                                                 if (have_flag(k_ptr->flags, TR_REGEN)) break;
3456                                                 o_ptr->name2 = EGO_RING_REGEN;
3457                                                 break;
3458                                         case 5: case 6:
3459                                                 if (have_flag(k_ptr->flags, TR_LITE_1)) break;
3460                                                 o_ptr->name2 = EGO_RING_LITE;
3461                                                 break;
3462                                         case 7: case 8:
3463                                                 if (have_flag(k_ptr->flags, TR_TELEPORT)) break;
3464                                                 o_ptr->name2 = EGO_RING_TELEPORT;
3465                                                 break;
3466                                         case 9: case 10:
3467                                                 if (o_ptr->to_h) break;
3468                                                 o_ptr->name2 = EGO_RING_TO_H;
3469                                                 break;
3470                                         case 11: case 12:
3471                                                 if (o_ptr->to_d) break;
3472                                                 o_ptr->name2 = EGO_RING_TO_D;
3473                                                 break;
3474                                         case 13:
3475                                                 if ((o_ptr->to_h) || (o_ptr->to_d)) break;
3476                                                 o_ptr->name2 = EGO_RING_SLAY;
3477                                                 break;
3478                                         case 14:
3479                                                 if ((have_flag(k_ptr->flags, TR_STR)) || o_ptr->to_h || o_ptr->to_d) break;
3480                                                 o_ptr->name2 = EGO_RING_WIZARD;
3481                                                 break;
3482                                         case 15:
3483                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3484                                                 o_ptr->name2 = EGO_RING_HERO;
3485                                                 break;
3486                                         case 16:
3487                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3488                                                 if (tmp > 8) o_ptr->name2 = EGO_RING_MANA_BALL;
3489                                                 else if (tmp > 4) o_ptr->name2 = EGO_RING_MANA_BOLT;
3490                                                 else o_ptr->name2 = EGO_RING_MAGIC_MIS;
3491                                                 break;
3492                                         case 17:
3493                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3494                                                 if (!(have_flag(k_ptr->flags, TR_RES_FIRE)) && (have_flag(k_ptr->flags, TR_RES_COLD) || have_flag(k_ptr->flags, TR_RES_ELEC) || have_flag(k_ptr->flags, TR_RES_ACID))) break;
3495                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_F;
3496                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_FIRE_BALL;
3497                                                 else o_ptr->name2 = EGO_RING_FIRE_BOLT;
3498                                                 break;
3499                                         case 18:
3500                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3501                                                 if (!(have_flag(k_ptr->flags, TR_RES_COLD)) && (have_flag(k_ptr->flags, TR_RES_FIRE) || have_flag(k_ptr->flags, TR_RES_ELEC) || have_flag(k_ptr->flags, TR_RES_ACID))) break;
3502                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_C;
3503                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_COLD_BALL;
3504                                                 else o_ptr->name2 = EGO_RING_COLD_BOLT;
3505                                                 break;
3506                                         case 19:
3507                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3508                                                 if (!(have_flag(k_ptr->flags, TR_RES_ELEC)) && (have_flag(k_ptr->flags, TR_RES_COLD) || have_flag(k_ptr->flags, TR_RES_FIRE) || have_flag(k_ptr->flags, TR_RES_ACID))) break;
3509                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ELEC_BALL;
3510                                                 else o_ptr->name2 = EGO_RING_ELEC_BOLT;
3511                                                 break;
3512                                         case 20:
3513                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3514                                                 if (!(have_flag(k_ptr->flags, TR_RES_ACID)) && (have_flag(k_ptr->flags, TR_RES_COLD) || have_flag(k_ptr->flags, TR_RES_ELEC) || have_flag(k_ptr->flags, TR_RES_FIRE))) break;
3515                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ACID_BALL;
3516                                                 else o_ptr->name2 = EGO_RING_ACID_BOLT;
3517                                                 break;
3518                                         case 21: case 22: case 23: case 24: case 25: case 26:
3519                                                 switch (o_ptr->sval)
3520                                                 {
3521                                                 case SV_RING_SPEED:
3522                                                         if (!one_in_(3)) break;
3523                                                         o_ptr->name2 = EGO_RING_D_SPEED;
3524                                                         break;
3525                                                 case SV_RING_DAMAGE:
3526                                                 case SV_RING_ACCURACY:
3527                                                 case SV_RING_SLAYING:
3528                                                         if (one_in_(2)) break;
3529                                                         if (one_in_(2)) o_ptr->name2 = EGO_RING_HERO;
3530                                                         else
3531                                                         {
3532                                                                 o_ptr->name2 = EGO_RING_BERSERKER;
3533                                                                 o_ptr->to_h -= 2+randint1(4);
3534                                                                 o_ptr->to_d += 2+randint1(4);
3535                                                         }
3536                                                         break;
3537                                                 case SV_RING_PROTECTION:
3538                                                         o_ptr->name2 = EGO_RING_SUPER_AC;
3539                                                         o_ptr->to_a += 7 + m_bonus(5, level);
3540                                                         break;
3541                                                 case SV_RING_RES_FEAR:
3542                                                         o_ptr->name2 = EGO_RING_HERO;
3543                                                         break;
3544                                                 case SV_RING_SHOTS:
3545                                                         if (one_in_(2)) break;
3546                                                         o_ptr->name2 = EGO_RING_HUNTER;
3547                                                         break;
3548                                                 case SV_RING_SEARCHING:
3549                                                         o_ptr->name2 = EGO_RING_STEALTH;
3550                                                         break;
3551                                                 case SV_RING_TELEPORTATION:
3552                                                         o_ptr->name2 = EGO_RING_TELE_AWAY;
3553                                                         break;
3554                                                 case SV_RING_RES_BLINDNESS:
3555                                                         if (one_in_(2))
3556                                                                 o_ptr->name2 = EGO_RING_RES_LITE;
3557                                                         else
3558                                                                 o_ptr->name2 = EGO_RING_RES_DARK;
3559                                                         break;
3560                                                 case SV_RING_LORDLY:
3561                                                         if (!one_in_(20)) break;
3562                                                         one_lordly_high_resistance(o_ptr);
3563                                                         one_lordly_high_resistance(o_ptr);
3564                                                         o_ptr->name2 = EGO_RING_TRUE;
3565                                                         break;
3566                                                 case SV_RING_SUSTAIN:
3567                                                         if (!one_in_(4)) break;
3568                                                         o_ptr->name2 = EGO_RING_RES_TIME;
3569                                                         break;
3570                                                 case SV_RING_FLAMES:
3571                                                         if (!one_in_(2)) break;
3572                                                         o_ptr->name2 = EGO_RING_DRAGON_F;
3573                                                         break;
3574                                                 case SV_RING_ICE:
3575                                                         if (!one_in_(2)) break;
3576                                                         o_ptr->name2 = EGO_RING_DRAGON_C;
3577                                                         break;
3578                                                 case SV_RING_WARNING:
3579                                                         if (!one_in_(2)) break;
3580                                                         o_ptr->name2 = EGO_RING_M_DETECT;
3581                                                         break;
3582                                                 default:
3583                                                         break;
3584                                                 }
3585                                                 break;
3586                                         }
3587                                 }
3588                                 /* Uncurse it */
3589                                 o_ptr->curse_flags = 0L;
3590                         }
3591                         else if ((power == -2) && one_in_(2))
3592                         {
3593                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3594                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3595                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3596                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3597                                 o_ptr->art_flags[0] = 0;
3598                                 o_ptr->art_flags[1] = 0;
3599                                 while(!o_ptr->name2)
3600                                 {
3601                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3602                                         switch(randint1(5))
3603                                         {
3604                                         case 1:
3605                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3606                                                 o_ptr->name2 = EGO_RING_DRAIN_EXP;
3607                                                 break;
3608                                         case 2:
3609                                                 o_ptr->name2 = EGO_RING_NO_MELEE;
3610                                                 break;
3611                                         case 3:
3612                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3613                                                 o_ptr->name2 = EGO_RING_AGGRAVATE;
3614                                                 break;
3615                                         case 4:
3616                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3617                                                 o_ptr->name2 = EGO_RING_TY_CURSE;
3618                                                 break;
3619                                         case 5:
3620                                                 o_ptr->name2 = EGO_RING_ALBINO;
3621                                                 break;
3622                                         }
3623                                 }
3624                                 /* Broken */
3625                                 o_ptr->ident |= (IDENT_BROKEN);
3626
3627                                 /* Cursed */
3628                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3629                         }
3630                         break;
3631                 }
3632
3633                 case TV_AMULET:
3634                 {
3635                         /* Analyze */
3636                         switch (o_ptr->sval)
3637                         {
3638                                 /* Amulet of wisdom/charisma */
3639                                 case SV_AMULET_INTELLIGENCE:
3640                                 case SV_AMULET_WISDOM:
3641                                 case SV_AMULET_CHARISMA:
3642                                 {
3643                                         o_ptr->pval = 1 + m_bonus(5, level);
3644
3645                                         /* Cursed */
3646                                         if (power < 0)
3647                                         {
3648                                                 /* Broken */
3649                                                 o_ptr->ident |= (IDENT_BROKEN);
3650
3651                                                 /* Cursed */
3652                                                 o_ptr->curse_flags |= (TRC_CURSED);
3653
3654                                                 /* Reverse bonuses */
3655                                                 o_ptr->pval = 0 - o_ptr->pval;
3656                                         }
3657
3658                                         break;
3659                                 }
3660
3661                                 /* Amulet of brilliance */
3662                                 case SV_AMULET_BRILLIANCE:
3663                                 {
3664                                         o_ptr->pval = 1 + m_bonus(3, level);
3665                                         if (one_in_(4)) o_ptr->pval++;
3666
3667                                         /* Cursed */
3668                                         if (power < 0)
3669                                         {
3670                                                 /* Broken */
3671                                                 o_ptr->ident |= (IDENT_BROKEN);
3672
3673                                                 /* Cursed */
3674                                                 o_ptr->curse_flags |= (TRC_CURSED);
3675
3676                                                 /* Reverse bonuses */
3677                                                 o_ptr->pval = 0 - o_ptr->pval;
3678                                         }
3679
3680                                         break;
3681                                 }
3682
3683                                 case SV_AMULET_NO_MAGIC: case SV_AMULET_NO_TELE:
3684                                 {
3685                                         if (power < 0)
3686                                         {
3687                                                 o_ptr->curse_flags |= (TRC_CURSED);
3688                                         }
3689                                         break;
3690                                 }
3691
3692                                 case SV_AMULET_RESISTANCE:
3693                                 {
3694                                         if (one_in_(5)) one_high_resistance(o_ptr);
3695                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_RES_POIS);
3696                                 }
3697                                 break;
3698
3699                                 /* Amulet of searching */
3700                                 case SV_AMULET_SEARCHING:
3701                                 {
3702                                         o_ptr->pval = randint1(2) + m_bonus(4, level);
3703
3704                                         /* Cursed */
3705                                         if (power < 0)
3706                                         {
3707                                                 /* Broken */
3708                                                 o_ptr->ident |= (IDENT_BROKEN);
3709
3710                                                 /* Cursed */
3711                                                 o_ptr->curse_flags |= (TRC_CURSED);
3712
3713                                                 /* Reverse bonuses */
3714                                                 o_ptr->pval = 0 - (o_ptr->pval);
3715                                         }
3716
3717                                         break;
3718                                 }
3719
3720                                 /* Amulet of the Magi -- never cursed */
3721                                 case SV_AMULET_THE_MAGI:
3722                                 {
3723                                         o_ptr->pval = randint1(5) + m_bonus(5, level);
3724                                         o_ptr->to_a = randint1(5) + m_bonus(5, level);
3725
3726                                         /* gain one low ESP */
3727                                         add_esp_weak(o_ptr, FALSE);
3728
3729                                         break;
3730                                 }
3731
3732                                 /* Amulet of Doom -- always cursed */
3733                                 case SV_AMULET_DOOM:
3734                                 {
3735                                         /* Broken */
3736                                         o_ptr->ident |= (IDENT_BROKEN);
3737
3738                                         /* Cursed */
3739                                         o_ptr->curse_flags |= (TRC_CURSED);
3740
3741                                         /* Penalize */
3742                                         o_ptr->pval = 0 - (randint1(5) + m_bonus(5, level));
3743                                         o_ptr->to_a = 0 - (randint1(5) + m_bonus(5, level));
3744                                         if (power > 0) power = 0 - power;
3745
3746                                         break;
3747                                 }
3748
3749                                 case SV_AMULET_MAGIC_MASTERY:
3750                                 {
3751                                         o_ptr->pval = 1 + m_bonus(4, level);
3752
3753                                         /* Cursed */
3754                                         if (power < 0)
3755                                         {
3756                                                 /* Broken */
3757                                                 o_ptr->ident |= (IDENT_BROKEN);
3758
3759                                                 /* Cursed */
3760                                                 o_ptr->curse_flags |= (TRC_CURSED);
3761
3762                                                 /* Reverse bonuses */
3763                                                 o_ptr->pval = 0 - o_ptr->pval;
3764                                         }
3765
3766                                         break;
3767                                 }
3768                         }
3769                         if ((one_in_(150) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
3770                             || (power > 2)) /* power > 2 is debug only */
3771                         {
3772                                 o_ptr->pval = MIN(o_ptr->pval, 4);
3773                                 /* Randart amulet */
3774                                 create_artifact(o_ptr, FALSE);
3775                         }
3776                         else if ((power == 2) && one_in_(2))
3777                         {
3778                                 while(!o_ptr->name2)
3779                                 {
3780                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3781                                         switch(randint1(21))
3782                                         {
3783                                         case 1: case 2:
3784                                                 if (have_flag(k_ptr->flags, TR_SLOW_DIGEST)) break;
3785                                                 o_ptr->name2 = EGO_AMU_SLOW_D;
3786                                                 break;
3787                                         case 3: case 4:
3788                                                 if (o_ptr->pval) break;
3789                                                 o_ptr->name2 = EGO_AMU_INFRA;
3790                                                 break;
3791                                         case 5: case 6:
3792                                                 if (have_flag(k_ptr->flags, TR_SEE_INVIS)) break;
3793                                                 o_ptr->name2 = EGO_AMU_SEE_INVIS;
3794                                                 break;
3795                                         case 7: case 8:
3796                                                 if (have_flag(k_ptr->flags, TR_HOLD_EXP)) break;
3797                                                 o_ptr->name2 = EGO_AMU_HOLD_EXP;
3798                                                 break;
3799                                         case 9:
3800                                                 if (have_flag(k_ptr->flags, TR_LEVITATION)) break;
3801                                                 o_ptr->name2 = EGO_AMU_LEVITATION;
3802                                                 break;
3803                                         case 10: case 11: case 21:
3804                                                 o_ptr->name2 = EGO_AMU_AC;
3805                                                 break;
3806                                         case 12:
3807                                                 if (have_flag(k_ptr->flags, TR_RES_FIRE)) break;
3808                                                 if (m_bonus(10, level) > 8)
3809                                                         o_ptr->name2 = EGO_AMU_RES_FIRE_;
3810                                                 else
3811                                                         o_ptr->name2 = EGO_AMU_RES_FIRE;
3812                                                 break;
3813                                         case 13:
3814                                                 if (have_flag(k_ptr->flags, TR_RES_COLD)) break;
3815                                                 if (m_bonus(10, level) > 8)
3816                                                         o_ptr->name2 = EGO_AMU_RES_COLD_;
3817                                                 else
3818                                                         o_ptr->name2 = EGO_AMU_RES_COLD;
3819                                                 break;
3820                                         case 14:
3821                                                 if (have_flag(k_ptr->flags, TR_RES_ELEC)) break;
3822                                                 if (m_bonus(10, level) > 8)
3823                                                         o_ptr->name2 = EGO_AMU_RES_ELEC_;
3824                                                 else
3825                                                         o_ptr->name2 = EGO_AMU_RES_ELEC;
3826                                                 break;
3827                                         case 15:
3828                                                 if (have_flag(k_ptr->flags, TR_RES_ACID)) break;
3829                                                 if (m_bonus(10, level) > 8)
3830                                                         o_ptr->name2 = EGO_AMU_RES_ACID_;
3831                                                 else
3832                                                         o_ptr->name2 = EGO_AMU_RES_ACID;
3833                                                 break;
3834                                         case 16: case 17: case 18: case 19: case 20:
3835                                                 switch (o_ptr->sval)
3836                                                 {
3837                                                 case SV_AMULET_TELEPORT:
3838                                                         if (m_bonus(10, level) > 9) o_ptr->name2 = EGO_AMU_D_DOOR;
3839                                                         else if (one_in_(2)) o_ptr->name2 = EGO_AMU_JUMP;
3840                                                         else o_ptr->name2 = EGO_AMU_TELEPORT;
3841                                                         break;
3842                                                 case SV_AMULET_RESIST_ACID:
3843                                                         if ((m_bonus(10, level) > 6) && one_in_(2)) o_ptr->name2 = EGO_AMU_RES_ACID_;
3844                                                         break;
3845                                                 case SV_AMULET_SEARCHING:
3846                                                         o_ptr->name2 = EGO_AMU_STEALTH;
3847                                                         break;
3848                                                 case SV_AMULET_BRILLIANCE:
3849                                                         if (!one_in_(3)) break;
3850                                                         o_ptr->name2 = EGO_AMU_IDENT;
3851                                                         break;
3852                                                 case SV_AMULET_CHARISMA:
3853                                                         if (!one_in_(3)) break;
3854                                                         o_ptr->name2 = EGO_AMU_CHARM;
3855                                                         break;
3856                                                 case SV_AMULET_THE_MAGI:
3857                                                         if (one_in_(2)) break;
3858                                                         o_ptr->name2 = EGO_AMU_GREAT;
3859                                                         break;
3860                                                 case SV_AMULET_RESISTANCE:
3861                                                         if (!one_in_(5)) break;
3862                                                         o_ptr->name2 = EGO_AMU_DEFENDER;
3863                                                         break;
3864                                                 case SV_AMULET_TELEPATHY:
3865                                                         if (!one_in_(3)) break;
3866                                                         o_ptr->name2 = EGO_AMU_DETECTION;
3867                                                         break;
3868                                                 }
3869                                         }
3870                                 }
3871                                 /* Uncurse it */
3872                                 o_ptr->curse_flags = 0L;
3873                         }
3874                         else if ((power == -2) && one_in_(2))
3875                         {
3876                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3877                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3878                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3879                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3880                                 o_ptr->art_flags[0] = 0;
3881                                 o_ptr->art_flags[1] = 0;
3882                                 while(!o_ptr->name2)
3883                                 {
3884                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3885                                         switch(randint1(5))
3886                                         {
3887                                         case 1:
3888                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3889                                                 o_ptr->name2 = EGO_AMU_DRAIN_EXP;
3890                                                 break;
3891                                         case 2:
3892                                                 o_ptr->name2 = EGO_AMU_FOOL;
3893                                                 break;
3894                                         case 3:
3895                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3896                                                 o_ptr->name2 = EGO_AMU_AGGRAVATE;
3897                                                 break;
3898                                         case 4:
3899                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3900                                                 o_ptr->name2 = EGO_AMU_TY_CURSE;
3901                                                 break;
3902                                         case 5:
3903                                                 o_ptr->name2 = EGO_AMU_NAIVETY;
3904                                                 break;
3905                                         }
3906                                 }
3907                                 /* Broken */
3908                                 o_ptr->ident |= (IDENT_BROKEN);
3909
3910                                 /* Cursed */
3911                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3912                         }
3913                         break;
3914                 }
3915         }
3916 }
3917
3918 /*!
3919  * @brief モンスターが人形のベースにできるかを返す
3920  * @param r_idx チェックしたいモンスター種族のID
3921  * @return 人形にできるならTRUEを返す
3922  */
3923 static bool item_monster_okay(int r_idx)
3924 {
3925         monster_race *r_ptr = &r_info[r_idx];
3926
3927         /* No uniques */
3928         if (r_ptr->flags1 & RF1_UNIQUE) return (FALSE);
3929         if (r_ptr->flags7 & RF7_KAGE) return (FALSE);
3930         if (r_ptr->flagsr & RFR_RES_ALL) return (FALSE);
3931         if (r_ptr->flags7 & RF7_NAZGUL) return (FALSE);
3932         if (r_ptr->flags1 & RF1_FORCE_DEPTH) return (FALSE);
3933         if (r_ptr->flags7 & RF7_UNIQUE2) return (FALSE);
3934
3935         /* Okay */
3936         return (TRUE);
3937 }
3938
3939
3940 /*!
3941  * @brief その他雑多のオブジェクトに生成ランクごとの強化を与えるサブルーチン
3942  * Apply magic to an item known to be "boring"
3943  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3944  * @param level 生成基準階
3945  * @param power 生成ランク
3946  * @return なし
3947  * @details
3948  * Hack -- note the special code for various items
3949  */
3950 static void a_m_aux_4(object_type *o_ptr, int level, int power)
3951 {
3952         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3953
3954         /* Unused */
3955         (void)level;
3956
3957         /* Apply magic (good or bad) according to type */
3958         switch (o_ptr->tval)
3959         {
3960                 case TV_WHISTLE:
3961                 {
3962 #if 0
3963                         /* Cursed */
3964                         if (power < 0)
3965                         {
3966                                 /* Broken */
3967                                 o_ptr->ident |= (IDENT_BROKEN);
3968
3969                                 /* Cursed */
3970                                 o_ptr->curse_flags |= (TRC_CURSED);
3971                         }
3972 #endif
3973                         break;
3974                 }
3975                 case TV_FLASK:
3976                 {
3977                         o_ptr->xtra4 = o_ptr->pval;
3978                         o_ptr->pval = 0;
3979                         break;
3980                 }
3981                 case TV_LITE:
3982                 {
3983                         /* Hack -- Torches -- random fuel */
3984                         if (o_ptr->sval == SV_LITE_TORCH)
3985                         {
3986                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3987                                 o_ptr->pval = 0;
3988                         }
3989
3990                         /* Hack -- Lanterns -- random fuel */
3991                         if (o_ptr->sval == SV_LITE_LANTERN)
3992                         {
3993                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3994                                 o_ptr->pval = 0;
3995                         }
3996
3997                         if (power > 2) /* power > 2 is debug only */
3998                         {
3999                                 create_artifact(o_ptr, FALSE);
4000                         }
4001                         else if ((power == 2) || ((power == 1) && one_in_(3)))
4002                         {
4003                                 while (!o_ptr->name2)
4004                                 {
4005                                         while (1)
4006                                         {
4007                                                 bool okay_flag = TRUE;
4008
4009                                                 o_ptr->name2 = get_random_ego(INVEN_LITE, TRUE);
4010
4011                                                 switch (o_ptr->name2)
4012                                                 {
4013                                                 case EGO_LITE_LONG:
4014                                                         if (o_ptr->sval == SV_LITE_FEANOR)
4015                                                                 okay_flag = FALSE;
4016                                                 }
4017                                                 if (okay_flag)
4018                                                         break;
4019                                         }
4020                                 }
4021                         }
4022                         else if (power == -2)
4023                         {
4024                                 o_ptr->name2 = get_random_ego(INVEN_LITE, FALSE);
4025
4026                                 switch (o_ptr->name2)
4027                                 {
4028                                 case EGO_LITE_DARKNESS:
4029                                         o_ptr->xtra4 = 0;
4030
4031                                         if (o_ptr->sval == SV_LITE_TORCH)
4032                                         {
4033                                                 add_flag(o_ptr->art_flags, TR_LITE_M1);
4034                                         }
4035                                         else if (o_ptr->sval == SV_LITE_LANTERN)
4036                                         {
4037                                                 add_flag(o_ptr->art_flags, TR_LITE_M2);
4038                                         }
4039                                         else if (o_ptr->sval == SV_LITE_FEANOR)
4040                                         {
4041                                                 add_flag(o_ptr->art_flags, TR_LITE_M3);
4042                                         }
4043                                         break;
4044                                 }
4045                         }
4046
4047                         break;
4048                 }
4049
4050                 case TV_WAND:
4051                 case TV_STAFF:
4052                 {
4053                         /* The wand or staff gets a number of initial charges equal
4054                          * to between 1/2 (+1) and the full object kind's pval. -LM-
4055                          */
4056                         o_ptr->pval = k_ptr->pval / 2 + randint1((k_ptr->pval + 1) / 2);
4057                         break;
4058                 }
4059
4060                 case TV_ROD:
4061                 {
4062                         /* Transfer the pval. -LM- */
4063                         o_ptr->pval = k_ptr->pval;
4064                         break;
4065                 }
4066
4067                 case TV_CAPTURE:
4068                 {
4069                         o_ptr->pval = 0;
4070                         object_aware(o_ptr);
4071                         object_known(o_ptr);
4072                         break;
4073                 }
4074
4075                 case TV_FIGURINE:
4076                 {
4077                         int i = 1;
4078                         int check;
4079
4080                         monster_race *r_ptr;
4081
4082                         /* Pick a random non-unique monster race */
4083                         while (1)
4084                         {
4085                                 i = randint1(max_r_idx - 1);
4086
4087                                 if (!item_monster_okay(i)) continue;
4088                                 if (i == MON_TSUCHINOKO) continue;
4089
4090                                 r_ptr = &r_info[i];
4091
4092                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
4093
4094                                 /* Ignore dead monsters */
4095                                 if (!r_ptr->rarity) continue;
4096
4097                                 /* Ignore uncommon monsters */
4098                                 if (r_ptr->rarity > 100) continue;
4099
4100                                 /* Prefer less out-of-depth monsters */
4101                                 if (randint0(check)) continue;
4102
4103                                 break;
4104                         }
4105
4106                         o_ptr->pval = i;
4107
4108                         /* Some figurines are cursed */
4109                         if (one_in_(6)) o_ptr->curse_flags |= TRC_CURSED;
4110
4111                         break;
4112                 }
4113
4114                 case TV_CORPSE:
4115                 {
4116                         int i = 1;
4117                         int check;
4118
4119                         u32b match = 0;
4120
4121                         monster_race *r_ptr;
4122
4123                         if (o_ptr->sval == SV_SKELETON)
4124                         {
4125                                 match = RF9_DROP_SKELETON;
4126                         }
4127                         else if (o_ptr->sval == SV_CORPSE)
4128                         {
4129                                 match = RF9_DROP_CORPSE;
4130                         }
4131
4132                         /* Hack -- Remove the monster restriction */
4133                         get_mon_num_prep(item_monster_okay, NULL);
4134
4135                         /* Pick a random non-unique monster race */
4136                         while (1)
4137                         {
4138                                 i = get_mon_num(dun_level);
4139
4140                                 r_ptr = &r_info[i];
4141
4142                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
4143
4144                                 /* Ignore dead monsters */
4145                                 if (!r_ptr->rarity) continue;
4146
4147                                 /* Ignore corpseless monsters */
4148                                 if (!(r_ptr->flags9 & match)) continue;
4149
4150                                 /* Prefer less out-of-depth monsters */
4151                                 if (randint0(check)) continue;
4152
4153                                 break;
4154                         }
4155
4156                         o_ptr->pval = i;
4157
4158
4159                         object_aware(o_ptr);
4160                         object_known(o_ptr);
4161                         break;
4162                 }
4163
4164                 case TV_STATUE:
4165                 {
4166                         int i = 1;
4167
4168                         monster_race *r_ptr;
4169
4170                         /* Pick a random monster race */
4171                         while (1)
4172                         {
4173                                 i = randint1(max_r_idx - 1);
4174
4175                                 r_ptr = &r_info[i];
4176
4177                                 /* Ignore dead monsters */
4178                                 if (!r_ptr->rarity) continue;
4179
4180                                 break;
4181                         }
4182
4183                         o_ptr->pval = i;
4184
4185                         if (cheat_peek)
4186                         {
4187                                 msg_format(_("%sの像", "Statue of %s"), r_name + r_ptr->name);
4188                         }
4189                         object_aware(o_ptr);
4190                         object_known(o_ptr);
4191
4192                         break;
4193                 }
4194
4195                 case TV_CHEST:
4196                 {
4197                         byte obj_level = k_info[o_ptr->k_idx].level;
4198
4199                         /* Hack -- skip ruined chests */
4200                         if (obj_level <= 0) break;
4201
4202                         /* Hack -- pick a "difficulty" */
4203                         o_ptr->pval = randint1(obj_level);
4204                         if (o_ptr->sval == SV_CHEST_KANDUME) o_ptr->pval = 6;
4205
4206                         o_ptr->xtra3 = dun_level + 5;
4207
4208                         /* Never exceed "difficulty" of 55 to 59 */
4209                         if (o_ptr->pval > 55) o_ptr->pval = 55 + (byte)randint0(5);
4210
4211                         break;
4212                 }
4213         }
4214 }
4215
4216 /*!
4217  * @brief 生成されたベースアイテムに魔法的な強化を与えるメインルーチン
4218  * Complete the "creation" of an object by applying "magic" to the item
4219  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
4220  * @param lev 生成基準階
4221  * @param mode 生成オプション
4222  * @return なし
4223  * @details
4224  * This includes not only rolling for random bonuses, but also putting the\n
4225  * finishing touches on ego-items and artifacts, giving charges to wands and\n
4226  * staffs, giving fuel to lites, and placing traps on chests.\n
4227  *\n
4228  * In particular, note that "Instant Artifacts", if "created" by an external\n
4229  * routine, must pass through this function to complete the actual creation.\n
4230  *\n
4231  * The base "chance" of the item being "good" increases with the "level"\n
4232  * parameter, which is usually derived from the dungeon level, being equal\n
4233  * to the level plus 10, up to a maximum of 75.  If "good" is true, then\n
4234  * the object is guaranteed to be "good".  If an object is "good", then\n
4235  * the chance that the object will be "great" (ego-item or artifact), also\n
4236  * increases with the "level", being equal to half the level, plus 5, up to\n
4237  * a maximum of 20.  If "great" is true, then the object is guaranteed to be\n
4238  * "great".  At dungeon level 65 and below, 15/100 objects are "great".\n
4239  *\n
4240  * If the object is not "good", there is a chance it will be "cursed", and\n
4241  * if it is "cursed", there is a chance it will be "broken".  These chances\n
4242  * are related to the "good" / "great" chances above.\n
4243  *\n
4244  * Otherwise "normal" rings and amulets will be "good" half the time and\n
4245  * "cursed" half the time, unless the ring/amulet is always good or cursed.\n
4246  *\n
4247  * If "okay" is true, and the object is going to be "great", then there is\n
4248  * a chance that an artifact will be created.  This is true even if both the\n
4249  * "good" and "great" arguments are false.  As a total hack, if "great" is\n
4250  * true, then the item gets 3 extra "attempts" to become an artifact.\n
4251  */
4252 void apply_magic(object_type *o_ptr, int lev, u32b mode)
4253 {
4254         int i, rolls, f1, f2, power;
4255
4256         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN) lev += randint0(p_ptr->lev/2+10);
4257
4258         /* Maximum "level" for various things */
4259         if (lev > MAX_DEPTH - 1) lev = MAX_DEPTH - 1;
4260
4261         /* Base chance of being "good" */
4262         f1 = lev + 10;
4263
4264         /* Maximal chance of being "good" */
4265         if (f1 > d_info[dungeon_type].obj_good) f1 = d_info[dungeon_type].obj_good;
4266
4267         /* Base chance of being "great" */
4268         f2 = f1 * 2 / 3;
4269
4270         /* Maximal chance of being "great" */
4271         if ((p_ptr->pseikaku != SEIKAKU_MUNCHKIN) && (f2 > d_info[dungeon_type].obj_great))
4272                 f2 = d_info[dungeon_type].obj_great;
4273
4274         if (p_ptr->muta3 & MUT3_GOOD_LUCK)
4275         {
4276                 f1 += 5;
4277                 f2 += 2;
4278         }
4279         else if(p_ptr->muta3 & MUT3_BAD_LUCK)
4280         {
4281                 f1 -= 5;
4282                 f2 -= 2;
4283         }
4284
4285         /* Assume normal */
4286         power = 0;
4287
4288         /* Roll for "good" */
4289         if ((mode & AM_GOOD) || magik(f1))
4290         {
4291                 /* Assume "good" */
4292                 power = 1;
4293
4294                 /* Roll for "great" */
4295                 if ((mode & AM_GREAT) || magik(f2))
4296                 {
4297                         power = 2;
4298
4299                         /* Roll for "special" */
4300                         if (mode & AM_SPECIAL) power = 3;
4301                 }
4302         }
4303
4304         /* Roll for "cursed" */
4305         else if (magik(f1))
4306         {
4307                 /* Assume "cursed" */
4308                 power = -1;
4309
4310                 /* Roll for "broken" */
4311                 if (magik(f2)) power = -2;
4312         }
4313
4314         /* Apply curse */
4315         if (mode & AM_CURSED)
4316         {
4317                 /* Assume 'cursed' */
4318                 if (power > 0)
4319                 {
4320                         power = 0 - power;
4321                 }
4322                 /* Everything else gets more badly cursed */
4323                 else
4324                 {
4325                         power--;
4326                 }
4327         }
4328
4329         /* Assume no rolls */
4330         rolls = 0;
4331
4332         /* Get one roll if excellent */
4333         if (power >= 2) rolls = 1;
4334
4335         /* Hack -- Get four rolls if forced great or special */
4336         if (mode & (AM_GREAT | AM_SPECIAL)) rolls = 4;
4337
4338         /* Hack -- Get no rolls if not allowed */
4339         if ((mode & AM_NO_FIXED_ART) || o_ptr->name1) rolls = 0;
4340
4341         /* Roll for artifacts if allowed */
4342         for (i = 0; i < rolls; i++)
4343         {
4344                 /* Roll for an artifact */
4345                 if (make_artifact(o_ptr)) break;
4346                 if ((p_ptr->muta3 & MUT3_GOOD_LUCK) && one_in_(77))
4347                 {
4348                         if (make_artifact(o_ptr)) break;
4349                 }
4350         }
4351
4352
4353         /* Hack -- analyze artifacts */
4354         if (object_is_fixed_artifact(o_ptr))
4355         {
4356                 artifact_type *a_ptr = &a_info[o_ptr->name1];
4357
4358                 /* Hack -- Mark the artifact as "created" */
4359                 a_ptr->cur_num = 1;
4360
4361                 /* Hack -- Memorize location of artifact in saved floors */
4362                 if (character_dungeon)
4363                         a_ptr->floor_id = p_ptr->floor_id;
4364
4365                 /* Extract the other fields */
4366                 o_ptr->pval = a_ptr->pval;
4367                 o_ptr->ac = a_ptr->ac;
4368                 o_ptr->dd = a_ptr->dd;
4369                 o_ptr->ds = a_ptr->ds;
4370                 o_ptr->to_a = a_ptr->to_a;
4371                 o_ptr->to_h = a_ptr->to_h;
4372                 o_ptr->to_d = a_ptr->to_d;
4373                 o_ptr->weight = a_ptr->weight;
4374                 o_ptr->xtra2 = a_ptr->act_idx;
4375
4376                 if (o_ptr->name1 == ART_MILIM)
4377                 {
4378                     if(p_ptr->pseikaku == SEIKAKU_SEXY)
4379                     {
4380                         o_ptr->pval = 3;
4381                     }
4382                 }
4383
4384                 /* Hack -- extract the "broken" flag */
4385                 if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4386
4387                 /* Hack -- extract the "cursed" flag */
4388                 if (a_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4389                 if (a_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4390                 if (a_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4391                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4392                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4393                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4394
4395                 /* Done */
4396                 return;
4397         }
4398
4399
4400         /* Apply magic */
4401         switch (o_ptr->tval)
4402         {
4403                 case TV_DIGGING:
4404                 case TV_HAFTED:
4405                 case TV_BOW:
4406                 case TV_SHOT:
4407                 case TV_ARROW:
4408                 case TV_BOLT:
4409                 {
4410                         if (power) a_m_aux_1(o_ptr, lev, power);
4411                         break;
4412                 }
4413
4414                 case TV_POLEARM:
4415                 {
4416                         if (power && !(o_ptr->sval == SV_DEATH_SCYTHE)) a_m_aux_1(o_ptr, lev, power);
4417                         break;
4418                 }
4419
4420                 case TV_SWORD:
4421                 {
4422                         if (power && !(o_ptr->sval == SV_DOKUBARI)) a_m_aux_1(o_ptr, lev, power);
4423                         break;
4424                 }
4425
4426                 case TV_DRAG_ARMOR:
4427                 case TV_HARD_ARMOR:
4428                 case TV_SOFT_ARMOR:
4429                 case TV_SHIELD:
4430                 case TV_HELM:
4431                 case TV_CROWN:
4432                 case TV_CLOAK:
4433                 case TV_GLOVES:
4434                 case TV_BOOTS:
4435                 {
4436                         /* Elven Cloak and Black Clothes ... */
4437                         if (((o_ptr->tval == TV_CLOAK) && (o_ptr->sval == SV_ELVEN_CLOAK)) ||
4438                             ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_KUROSHOUZOKU)))
4439                                 o_ptr->pval = randint1(4);
4440
4441 #if 1
4442                         if (power ||
4443                              ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
4444                              ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
4445                              ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
4446                              ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)))
4447                                 a_m_aux_2(o_ptr, lev, power);
4448 #else
4449                         if (power) a_m_aux_2(o_ptr, lev, power);
4450 #endif
4451                         break;
4452                 }
4453
4454                 case TV_RING:
4455                 case TV_AMULET:
4456                 {
4457                         if (!power && (randint0(100) < 50)) power = -1;
4458                         a_m_aux_3(o_ptr, lev, power);
4459                         break;
4460                 }
4461
4462                 default:
4463                 {
4464                         a_m_aux_4(o_ptr, lev, power);
4465                         break;
4466                 }
4467         }
4468
4469         if ((o_ptr->tval == TV_SOFT_ARMOR) &&
4470             (o_ptr->sval == SV_ABUNAI_MIZUGI) &&
4471             (p_ptr->pseikaku == SEIKAKU_SEXY))
4472         {
4473                 o_ptr->pval = 3;
4474                 add_flag(o_ptr->art_flags, TR_STR);
4475                 add_flag(o_ptr->art_flags, TR_INT);
4476                 add_flag(o_ptr->art_flags, TR_WIS);
4477                 add_flag(o_ptr->art_flags, TR_DEX);
4478                 add_flag(o_ptr->art_flags, TR_CON);
4479                 add_flag(o_ptr->art_flags, TR_CHR);
4480         }
4481
4482         /* Hack -- analyze ego-items */
4483         if (object_is_ego(o_ptr))
4484         {
4485                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
4486
4487                 /* Hack -- acquire "broken" flag */
4488                 if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4489
4490                 /* Hack -- acquire "cursed" flag */
4491                 if (e_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4492                 if (e_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4493                 if (e_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4494                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4495                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4496                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4497
4498                 if (e_ptr->gen_flags & (TRG_ONE_SUSTAIN)) one_sustain(o_ptr);
4499                 if (e_ptr->gen_flags & (TRG_XTRA_POWER)) one_ability(o_ptr);
4500                 if (e_ptr->gen_flags & (TRG_XTRA_H_RES)) one_high_resistance(o_ptr);
4501                 if (e_ptr->gen_flags & (TRG_XTRA_E_RES)) one_ele_resistance(o_ptr);
4502                 if (e_ptr->gen_flags & (TRG_XTRA_D_RES)) one_dragon_ele_resistance(o_ptr);
4503                 if (e_ptr->gen_flags & (TRG_XTRA_L_RES)) one_lordly_high_resistance(o_ptr);
4504                 if (e_ptr->gen_flags & (TRG_XTRA_RES)) one_resistance(o_ptr);
4505                 if (e_ptr->gen_flags & (TRG_XTRA_DICE))
4506                 {
4507                         do
4508                         {
4509                                 o_ptr->dd++;
4510                         }
4511                         while (one_in_(o_ptr->dd));
4512
4513                         if (o_ptr->dd > 9) o_ptr->dd = 9;
4514                 }
4515
4516                 /* Hack -- apply activatin index if needed */
4517                 if (e_ptr->act_idx) o_ptr->xtra2 = e_ptr->act_idx;
4518
4519                 /* Hack -- apply extra penalties if needed */
4520                 if ((object_is_cursed(o_ptr) || object_is_broken(o_ptr)) && !(e_ptr->gen_flags & (TRG_POWERFUL)))
4521                 {
4522                         /* Hack -- obtain bonuses */
4523                         if (e_ptr->max_to_h) o_ptr->to_h -= randint1(e_ptr->max_to_h);
4524                         if (e_ptr->max_to_d) o_ptr->to_d -= randint1(e_ptr->max_to_d);
4525                         if (e_ptr->max_to_a) o_ptr->to_a -= randint1(e_ptr->max_to_a);
4526
4527                         /* Hack -- obtain pval */
4528                         if (e_ptr->max_pval) o_ptr->pval -= randint1(e_ptr->max_pval);
4529                 }
4530
4531                 /* Hack -- apply extra bonuses if needed */
4532                 else
4533                 {
4534                         /* Hack -- obtain bonuses */
4535                         if (e_ptr->max_to_h)
4536                         {
4537                                 if (e_ptr->max_to_h > 127)
4538                                         o_ptr->to_h -= randint1(256-e_ptr->max_to_h);
4539                                 else o_ptr->to_h += randint1(e_ptr->max_to_h);
4540                         }
4541                         if (e_ptr->max_to_d)
4542                         {
4543                                 if (e_ptr->max_to_d > 127)
4544                                         o_ptr->to_d -= randint1(256-e_ptr->max_to_d);
4545                                 else o_ptr->to_d += randint1(e_ptr->max_to_d);
4546                         }
4547                         if (e_ptr->max_to_a)
4548                         {
4549                                 if (e_ptr->max_to_a > 127)
4550                                         o_ptr->to_a -= randint1(256-e_ptr->max_to_a);
4551                                 else o_ptr->to_a += randint1(e_ptr->max_to_a);
4552                         }
4553
4554                         /* Accuracy ego must have high to_h */
4555                         if(o_ptr->name2 == EGO_ACCURACY)
4556                         {
4557                                 while(o_ptr->to_h < o_ptr->to_d + 10)
4558                                 {
4559                                         o_ptr->to_h += 5;
4560                                         o_ptr->to_d -= 5;
4561                                 }
4562                                 o_ptr->to_h = MAX(o_ptr->to_h, 15);
4563                         }
4564
4565                         /* Accuracy ego must have high to_h */
4566                         if(o_ptr->name2 == EGO_VELOCITY)
4567                         {
4568                                 while(o_ptr->to_d < o_ptr->to_h + 10)
4569                                 {
4570                                         o_ptr->to_d += 5;
4571                                         o_ptr->to_h -= 5;
4572                                 }
4573                                 o_ptr->to_d = MAX(o_ptr->to_d, 15);
4574                         }
4575
4576                         /* Protection ego must have high to_a */
4577                         if((o_ptr->name2 == EGO_PROTECTION) || (o_ptr->name2 == EGO_S_PROTECTION) || (o_ptr->name2 == EGO_H_PROTECTION))
4578                         {
4579                                 o_ptr->to_a = MAX(o_ptr->to_a, 15);
4580                         }
4581
4582                         /* Hack -- obtain pval */
4583                         if (e_ptr->max_pval)
4584                         {
4585                                 if ((o_ptr->name2 == EGO_HA) && (have_flag(o_ptr->art_flags, TR_BLOWS)))
4586                                 {
4587                                         o_ptr->pval++;
4588                                         if ((lev > 60) && one_in_(3) && ((o_ptr->dd*(o_ptr->ds+1)) < 15)) o_ptr->pval++;
4589                                 }
4590                                 else if (o_ptr->name2 == EGO_DEMON)
4591                                 {
4592                                         if(have_flag(o_ptr->art_flags, TR_BLOWS))
4593                                         {
4594                                                 o_ptr->pval += randint1(2);
4595                                         }
4596                                         else
4597                                         {
4598                                                 o_ptr->pval += randint1(e_ptr->max_pval);
4599                                         }
4600                                 }
4601                                 else if (o_ptr->name2 == EGO_ATTACKS)
4602                                 {
4603                                         o_ptr->pval = randint1(e_ptr->max_pval*lev/100+1);
4604                                         if (o_ptr->pval > 3) o_ptr->pval = 3;
4605                                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA))
4606                                                 o_ptr->pval += randint1(2);
4607                                 }
4608                                 else if (o_ptr->name2 == EGO_BAT)
4609                                 {
4610                                         o_ptr->pval = randint1(e_ptr->max_pval);
4611                                         if (o_ptr->sval == SV_ELVEN_CLOAK) o_ptr->pval += randint1(2);
4612                                 }
4613                                 else if (o_ptr->name2 == EGO_A_DEMON || o_ptr->name2 == EGO_DRUID || o_ptr->name2 == EGO_OLOG)
4614                                 {
4615                                         o_ptr->pval = randint1(e_ptr->max_pval);
4616                                 }
4617                                 else
4618                                 {
4619                                         o_ptr->pval += randint1(e_ptr->max_pval);
4620                                 }
4621
4622
4623                         }
4624                         if ((o_ptr->name2 == EGO_SPEED) && (lev < 50))
4625                         {
4626                                 o_ptr->pval = randint1(o_ptr->pval);
4627                         }
4628                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA) && (o_ptr->pval > 2) && (o_ptr->name2 != EGO_ATTACKS))
4629                                 o_ptr->pval = 2;
4630                 }
4631
4632                 /* Done */
4633                 return;
4634         }
4635
4636         /* Examine real objects */
4637         if (o_ptr->k_idx)
4638         {
4639                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
4640
4641                 /* Hack -- acquire "broken" flag */
4642                 if (!k_info[o_ptr->k_idx].cost) o_ptr->ident |= (IDENT_BROKEN);
4643
4644                 /* Hack -- acquire "cursed" flag */
4645                 if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
4646                 if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
4647                 if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
4648                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4649                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4650                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4651         }
4652
4653
4654 }
4655
4656
4657 /*!
4658  * @brief ベースアイテムが上質として扱われるかどうかを返す。
4659  * Hack -- determine if a template is "good"
4660  * @param k_idx 判定したいベースアイテムのID
4661  * @return ベースアイテムが上質ならばTRUEを返す。
4662  */
4663 static bool kind_is_good(int k_idx)
4664 {
4665         object_kind *k_ptr = &k_info[k_idx];
4666
4667         /* Analyze the item type */
4668         switch (k_ptr->tval)
4669         {
4670                 /* Armor -- Good unless damaged */
4671                 case TV_HARD_ARMOR:
4672                 case TV_SOFT_ARMOR:
4673                 case TV_DRAG_ARMOR:
4674                 case TV_SHIELD:
4675                 case TV_CLOAK:
4676                 case TV_BOOTS:
4677                 case TV_GLOVES:
4678                 case TV_HELM:
4679                 case TV_CROWN:
4680                 {
4681                         if (k_ptr->to_a < 0) return (FALSE);
4682                         return (TRUE);
4683                 }
4684
4685                 /* Weapons -- Good unless damaged */
4686                 case TV_BOW:
4687                 case TV_SWORD:
4688                 case TV_HAFTED:
4689                 case TV_POLEARM:
4690                 case TV_DIGGING:
4691                 {
4692                         if (k_ptr->to_h < 0) return (FALSE);
4693                         if (k_ptr->to_d < 0) return (FALSE);
4694                         return (TRUE);
4695                 }
4696
4697                 /* Ammo -- Arrows/Bolts are good */
4698                 case TV_BOLT:
4699                 case TV_ARROW:
4700                 {
4701                         return (TRUE);
4702                 }
4703
4704                 /* Books -- High level books are good (except Arcane books) */
4705                 case TV_LIFE_BOOK:
4706                 case TV_SORCERY_BOOK:
4707                 case TV_NATURE_BOOK:
4708                 case TV_CHAOS_BOOK:
4709                 case TV_DEATH_BOOK:
4710                 case TV_TRUMP_BOOK:
4711                 case TV_CRAFT_BOOK:
4712                 case TV_DAEMON_BOOK:
4713                 case TV_CRUSADE_BOOK:
4714                 case TV_MUSIC_BOOK:
4715                 case TV_HISSATSU_BOOK:
4716                 case TV_HEX_BOOK:
4717                 {
4718                         if (k_ptr->sval >= SV_BOOK_MIN_GOOD) return (TRUE);
4719                         return (FALSE);
4720                 }
4721
4722                 /* Rings -- Rings of Speed are good */
4723                 case TV_RING:
4724                 {
4725                         if (k_ptr->sval == SV_RING_SPEED) return (TRUE);
4726                         if (k_ptr->sval == SV_RING_LORDLY) return (TRUE);
4727                         return (FALSE);
4728                 }
4729
4730                 /* Amulets -- Amulets of the Magi and Resistance are good */
4731                 case TV_AMULET:
4732                 {
4733                         if (k_ptr->sval == SV_AMULET_THE_MAGI) return (TRUE);
4734                         if (k_ptr->sval == SV_AMULET_RESISTANCE) return (TRUE);
4735                         return (FALSE);
4736                 }
4737         }
4738
4739         /* Assume not good */
4740         return (FALSE);
4741 }
4742
4743 /*!
4744  * @brief 生成階に応じたベースアイテムの生成を行う。
4745  * Attempt to make an object (normal or good/great)
4746  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4747  * @param mode オプションフラグ
4748  * @return 生成に成功したらTRUEを返す。
4749  * @details
4750  * This routine plays nasty games to generate the "special artifacts".\n
4751  * This routine uses "object_level" for the "generation level".\n
4752  * We assume that the given object has been "wiped".\n
4753  */
4754 bool make_object(object_type *j_ptr, u32b mode)
4755 {
4756         int prob, base;
4757         byte obj_level;
4758
4759
4760         /* Chance of "special object" */
4761         prob = ((mode & AM_GOOD) ? 10 : 1000);
4762
4763         /* Base level for the object */
4764         base = ((mode & AM_GOOD) ? (object_level + 10) : object_level);
4765
4766
4767         /* Generate a special object, or a normal object */
4768         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4769         {
4770                 int k_idx;
4771
4772                 /* Good objects */
4773                 if ((mode & AM_GOOD) && !get_obj_num_hook)
4774                 {
4775                         /* Activate restriction (if already specified, use that) */
4776                         get_obj_num_hook = kind_is_good;
4777                 }
4778
4779                 /* Restricted objects - prepare allocation table */
4780                 if (get_obj_num_hook) get_obj_num_prep();
4781
4782                 /* Pick a random object */
4783                 k_idx = get_obj_num(base);
4784
4785                 /* Restricted objects */
4786                 if (get_obj_num_hook)
4787                 {
4788                         /* Clear restriction */
4789                         get_obj_num_hook = NULL;
4790
4791                         /* Reset allocation table to default */
4792                         get_obj_num_prep();
4793                 }
4794
4795                 /* Handle failure */
4796                 if (!k_idx) return (FALSE);
4797
4798                 /* Prepare the object */
4799                 object_prep(j_ptr, k_idx);
4800         }
4801
4802         /* Apply magic (allow artifacts) */
4803         apply_magic(j_ptr, object_level, mode);
4804
4805         /* Hack -- generate multiple spikes/missiles */
4806         switch (j_ptr->tval)
4807         {
4808                 case TV_SPIKE:
4809                 case TV_SHOT:
4810                 case TV_ARROW:
4811                 case TV_BOLT:
4812                 {
4813                         if (!j_ptr->name1)
4814                                 j_ptr->number = (byte)damroll(6, 7);
4815                 }
4816         }
4817
4818         obj_level = k_info[j_ptr->k_idx].level;
4819         if (object_is_fixed_artifact(j_ptr)) obj_level = a_info[j_ptr->name1].level;
4820
4821         if (cheat_peek) object_mention(j_ptr);
4822
4823         /* Success */
4824         return (TRUE);
4825 }
4826
4827
4828 /*!
4829  * @brief フロアの指定位置に生成階に応じたベースアイテムの生成を行う。
4830  * Attempt to place an object (normal or good/great) at the given location.
4831  * @param y 配置したいフロアのY座標
4832  * @param x 配置したいフロアのX座標
4833  * @param mode オプションフラグ
4834  * @return 生成に成功したらTRUEを返す。
4835  * @details
4836  * This routine plays nasty games to generate the "special artifacts".\n
4837  * This routine uses "object_level" for the "generation level".\n
4838  * This routine requires a clean floor grid destination.\n
4839  */
4840 void place_object(POSITION y, POSITION x, u32b mode)
4841 {
4842         IDX o_idx;
4843
4844         /* Acquire grid */
4845         cave_type *c_ptr = &cave[y][x];
4846
4847         object_type forge;
4848         object_type *q_ptr;
4849
4850
4851         /* Paranoia -- check bounds */
4852         if (!in_bounds(y, x)) return;
4853
4854         /* Require floor space */
4855         if (!cave_drop_bold(y, x)) return;
4856
4857         /* Avoid stacking on other objects */
4858         if (c_ptr->o_idx) return;
4859
4860
4861         /* Get local object */
4862         q_ptr = &forge;
4863
4864         /* Wipe the object */
4865         object_wipe(q_ptr);
4866
4867         /* Make an object (if possible) */
4868         if (!make_object(q_ptr, mode)) return;
4869
4870
4871         /* Make an object */
4872         o_idx = o_pop();
4873
4874         /* Success */
4875         if (o_idx)
4876         {
4877                 object_type *o_ptr;
4878
4879                 /* Acquire object */
4880                 o_ptr = &o_list[o_idx];
4881
4882                 /* Structure Copy */
4883                 object_copy(o_ptr, q_ptr);
4884
4885                 /* Location */
4886                 o_ptr->iy = y;
4887                 o_ptr->ix = x;
4888
4889                 /* Build a stack */
4890                 o_ptr->next_o_idx = c_ptr->o_idx;
4891
4892                 /* Place the object */
4893                 c_ptr->o_idx = o_idx;
4894
4895                 /* Notice */
4896                 note_spot(y, x);
4897
4898                 /* Redraw */
4899                 lite_spot(y, x);
4900         }
4901         else
4902         {
4903                 /* Hack -- Preserve artifacts */
4904                 if (object_is_fixed_artifact(q_ptr))
4905                 {
4906                         a_info[q_ptr->name1].cur_num = 0;
4907                 }
4908         }
4909 }
4910
4911
4912 /*!
4913  * @brief 生成階に応じた財宝オブジェクトの生成を行う。
4914  * Make a treasure object
4915  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4916  * @return 生成に成功したらTRUEを返す。
4917  * @details
4918  * The location must be a legal, clean, floor grid.
4919  */
4920 bool make_gold(object_type *j_ptr)
4921 {
4922         int i;
4923
4924         s32b base;
4925
4926
4927         /* Hack -- Pick a Treasure variety */
4928         i = ((randint1(object_level + 2) + 2) / 2) - 1;
4929
4930         /* Apply "extra" magic */
4931         if (one_in_(GREAT_OBJ))
4932         {
4933                 i += randint1(object_level + 1);
4934         }
4935
4936         /* Hack -- Creeping Coins only generate "themselves" */
4937         if (coin_type) i = coin_type;
4938
4939         /* Do not create "illegal" Treasure Types */
4940         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4941
4942         /* Prepare a gold object */
4943         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4944
4945         /* Hack -- Base coin cost */
4946         base = k_info[OBJ_GOLD_LIST+i].cost;
4947
4948         /* Determine how much the treasure is "worth" */
4949         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4950
4951         /* Success */
4952         return (TRUE);
4953 }
4954
4955
4956 /*!
4957  * @brief フロアの指定位置に生成階に応じた財宝オブジェクトの生成を行う。
4958  * Places a treasure (Gold or Gems) at given location
4959  * @param y 配置したいフロアのY座標
4960  * @param x 配置したいフロアのX座標
4961  * @return 生成に成功したらTRUEを返す。
4962  * @details
4963  * The location must be a legal, clean, floor grid.
4964  */
4965 void place_gold(POSITION y, POSITION x)
4966 {
4967         s16b o_idx;
4968
4969         /* Acquire grid */
4970         cave_type *c_ptr = &cave[y][x];
4971
4972
4973         object_type forge;
4974         object_type *q_ptr;
4975
4976
4977         /* Paranoia -- check bounds */
4978         if (!in_bounds(y, x)) return;
4979
4980         /* Require floor space */
4981         if (!cave_drop_bold(y, x)) return;
4982
4983         /* Avoid stacking on other objects */
4984         if (c_ptr->o_idx) return;
4985
4986
4987         /* Get local object */
4988         q_ptr = &forge;
4989
4990         /* Wipe the object */
4991         object_wipe(q_ptr);
4992
4993         /* Make some gold */
4994         if (!make_gold(q_ptr)) return;
4995
4996
4997         /* Make an object */
4998         o_idx = o_pop();
4999
5000         /* Success */
5001         if (o_idx)
5002         {
5003                 object_type *o_ptr;
5004
5005                 /* Acquire object */
5006                 o_ptr = &o_list[o_idx];
5007
5008                 /* Copy the object */
5009                 object_copy(o_ptr, q_ptr);
5010
5011                 /* Save location */
5012                 o_ptr->iy = y;
5013                 o_ptr->ix = x;
5014
5015                 /* Build a stack */
5016                 o_ptr->next_o_idx = c_ptr->o_idx;
5017
5018                 /* Place the object */
5019                 c_ptr->o_idx = o_idx;
5020
5021                 /* Notice */
5022                 note_spot(y, x);
5023
5024                 /* Redraw */
5025                 lite_spot(y, x);
5026         }
5027 }
5028
5029
5030 /*!
5031  * @brief 生成済のオブジェクトをフロアの所定の位置に落とす。
5032  * Let an object fall to the ground at or near a location.
5033  * @param j_ptr 落としたいオブジェクト構造体の参照ポインタ
5034  * @param chance ドロップの成功率(%)
5035  * @param y 配置したいフロアのY座標
5036  * @param x 配置したいフロアのX座標
5037  * @return 生成に成功したらTRUEを返す。
5038  * @details
5039  * The initial location is assumed to be "in_bounds()".\n
5040  *\n
5041  * This function takes a parameter "chance".  This is the percentage\n
5042  * chance that the item will "disappear" instead of drop.  If the object\n
5043  * has been thrown, then this is the chance of disappearance on contact.\n
5044  *\n
5045  * Hack -- this function uses "chance" to determine if it should produce\n
5046  * some form of "description" of the drop event (under the player).\n
5047  *\n
5048  * We check several locations to see if we can find a location at which\n
5049  * the object can combine, stack, or be placed.  Artifacts will try very\n
5050  * hard to be placed, including "teleporting" to a useful grid if needed.\n
5051  */
5052 s16b drop_near(object_type *j_ptr, int chance, int y, int x)
5053 {
5054         int i, k, d, s;
5055
5056         int bs, bn;
5057         int by, bx;
5058         int dy, dx;
5059         int ty, tx = 0;
5060
5061         s16b o_idx = 0;
5062
5063         s16b this_o_idx, next_o_idx = 0;
5064
5065         cave_type *c_ptr;
5066
5067         char o_name[MAX_NLEN];
5068
5069         bool flag = FALSE;
5070         bool done = FALSE;
5071
5072 #ifndef JP
5073         /* Extract plural */
5074         bool plural = (j_ptr->number != 1);
5075 #endif
5076
5077         /* Describe object */
5078         object_desc(o_name, j_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
5079
5080
5081         /* Handle normal "breakage" */
5082         if (!object_is_artifact(j_ptr) && (randint0(100) < chance))
5083         {
5084                 /* Message */
5085 #ifdef JP
5086                 msg_format("%sは消えた。", o_name);
5087 #else
5088                 msg_format("The %s disappear%s.",
5089                            o_name, (plural ? "" : "s"));
5090 #endif
5091
5092
5093                 /* Debug */
5094                 if (p_ptr->wizard) msg_print(_("(破損)", "(breakage)"));
5095
5096                 /* Failure */
5097                 return (0);
5098         }
5099
5100
5101         /* Score */
5102         bs = -1;
5103
5104         /* Picker */
5105         bn = 0;
5106
5107         /* Default */
5108         by = y;
5109         bx = x;
5110
5111         /* Scan local grids */
5112         for (dy = -3; dy <= 3; dy++)
5113         {
5114                 /* Scan local grids */
5115                 for (dx = -3; dx <= 3; dx++)
5116                 {
5117                         bool comb = FALSE;
5118
5119                         /* Calculate actual distance */
5120                         d = (dy * dy) + (dx * dx);
5121
5122                         /* Ignore distant grids */
5123                         if (d > 10) continue;
5124
5125                         /* Location */
5126                         ty = y + dy;
5127                         tx = x + dx;
5128
5129                         /* Skip illegal grids */
5130                         if (!in_bounds(ty, tx)) continue;
5131
5132                         /* Require line of projection */
5133                         if (!projectable(y, x, ty, tx)) continue;
5134
5135                         /* Obtain grid */
5136                         c_ptr = &cave[ty][tx];
5137
5138                         /* Require floor space */
5139                         if (!cave_drop_bold(ty, tx)) continue;
5140
5141                         /* No objects */
5142                         k = 0;
5143
5144                         /* Scan objects in that grid */
5145                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5146                         {
5147                                 object_type *o_ptr;
5148
5149                                 /* Acquire object */
5150                                 o_ptr = &o_list[this_o_idx];
5151
5152                                 /* Acquire next object */
5153                                 next_o_idx = o_ptr->next_o_idx;
5154
5155                                 /* Check for possible combination */
5156                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
5157
5158                                 /* Count objects */
5159                                 k++;
5160                         }
5161
5162                         /* Add new object */
5163                         if (!comb) k++;
5164
5165                         /* Paranoia */
5166                         if (k > 99) continue;
5167
5168                         /* Calculate score */
5169                         s = 1000 - (d + k * 5);
5170
5171                         /* Skip bad values */
5172                         if (s < bs) continue;
5173
5174                         /* New best value */
5175                         if (s > bs) bn = 0;
5176
5177                         /* Apply the randomizer to equivalent values */
5178                         if ((++bn >= 2) && !one_in_(bn)) continue;
5179
5180                         /* Keep score */
5181                         bs = s;
5182
5183                         /* Track it */
5184                         by = ty;
5185                         bx = tx;
5186
5187                         /* Okay */
5188                         flag = TRUE;
5189                 }
5190         }
5191
5192
5193         /* Handle lack of space */
5194         if (!flag && !object_is_artifact(j_ptr))
5195         {
5196                 /* Message */
5197 #ifdef JP
5198                 msg_format("%sは消えた。", o_name);
5199 #else
5200                 msg_format("The %s disappear%s.",
5201                            o_name, (plural ? "" : "s"));
5202 #endif
5203
5204
5205                 /* Debug */
5206                 if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5207
5208                 /* Failure */
5209                 return (0);
5210         }
5211
5212
5213         /* Find a grid */
5214         for (i = 0; !flag && (i < 1000); i++)
5215         {
5216                 /* Bounce around */
5217                 ty = rand_spread(by, 1);
5218                 tx = rand_spread(bx, 1);
5219
5220                 /* Verify location */
5221                 if (!in_bounds(ty, tx)) continue;
5222
5223                 /* Bounce to that location */
5224                 by = ty;
5225                 bx = tx;
5226
5227                 /* Require floor space */
5228                 if (!cave_drop_bold(by, bx)) continue;
5229
5230                 /* Okay */
5231                 flag = TRUE;
5232         }
5233
5234
5235         if (!flag)
5236         {
5237                 int candidates = 0, pick;
5238
5239                 for (ty = 1; ty < cur_hgt - 1; ty++)
5240                 {
5241                         for (tx = 1; tx < cur_wid - 1; tx++)
5242                         {
5243                                 /* A valid space found */
5244                                 if (cave_drop_bold(ty, tx)) candidates++;
5245                         }
5246                 }
5247
5248                 /* No valid place! */
5249                 if (!candidates)
5250                 {
5251                         /* Message */
5252 #ifdef JP
5253                         msg_format("%sは消えた。", o_name);
5254 #else
5255                         msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
5256 #endif
5257
5258                         /* Debug */
5259                         if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5260
5261                         /* Mega-Hack -- preserve artifacts */
5262                         if (preserve_mode)
5263                         {
5264                                 /* Hack -- Preserve unknown artifacts */
5265                                 if (object_is_fixed_artifact(j_ptr) && !object_is_known(j_ptr))
5266                                 {
5267                                         /* Mega-Hack -- Preserve the artifact */
5268                                         a_info[j_ptr->name1].cur_num = 0;
5269                                 }
5270                         }
5271
5272                         /* Failure */
5273                         return 0;
5274                 }
5275
5276                 /* Choose a random one */
5277                 pick = randint1(candidates);
5278
5279                 for (ty = 1; ty < cur_hgt - 1; ty++)
5280                 {
5281                         for (tx = 1; tx < cur_wid - 1; tx++)
5282                         {
5283                                 if (cave_drop_bold(ty, tx))
5284                                 {
5285                                         pick--;
5286
5287                                         /* Is this a picked one? */
5288                                         if (!pick) break;
5289                                 }
5290                         }
5291
5292                         if (!pick) break;
5293                 }
5294
5295                 by = ty;
5296                 bx = tx;
5297         }
5298
5299
5300         /* Grid */
5301         c_ptr = &cave[by][bx];
5302
5303         /* Scan objects in that grid for combination */
5304         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5305         {
5306                 object_type *o_ptr;
5307
5308                 /* Acquire object */
5309                 o_ptr = &o_list[this_o_idx];
5310
5311                 /* Acquire next object */
5312                 next_o_idx = o_ptr->next_o_idx;
5313
5314                 /* Check for combination */
5315                 if (object_similar(o_ptr, j_ptr))
5316                 {
5317                         /* Combine the items */
5318                         object_absorb(o_ptr, j_ptr);
5319
5320                         /* Success */
5321                         done = TRUE;
5322
5323                         /* Done */
5324                         break;
5325                 }
5326         }
5327
5328         /* Get new object */
5329         if (!done) o_idx = o_pop();
5330
5331         /* Failure */
5332         if (!done && !o_idx)
5333         {
5334                 /* Message */
5335 #ifdef JP
5336                 msg_format("%sは消えた。", o_name);
5337 #else
5338                 msg_format("The %s disappear%s.",
5339                            o_name, (plural ? "" : "s"));
5340 #endif
5341
5342
5343                 /* Debug */
5344                 if (p_ptr->wizard) msg_print(_("(アイテムが多過ぎる)", "(too many objects)"));
5345
5346                 /* Hack -- Preserve artifacts */
5347                 if (object_is_fixed_artifact(j_ptr))
5348                 {
5349                         a_info[j_ptr->name1].cur_num = 0;
5350                 }
5351
5352                 /* Failure */
5353                 return (0);
5354         }
5355
5356         /* Stack */
5357         if (!done)
5358         {
5359                 /* Structure copy */
5360                 object_copy(&o_list[o_idx], j_ptr);
5361
5362                 /* Access new object */
5363                 j_ptr = &o_list[o_idx];
5364
5365                 /* Locate */
5366                 j_ptr->iy = by;
5367                 j_ptr->ix = bx;
5368
5369                 /* No monster */
5370                 j_ptr->held_m_idx = 0;
5371
5372                 /* Build a stack */
5373                 j_ptr->next_o_idx = c_ptr->o_idx;
5374
5375                 /* Place the object */
5376                 c_ptr->o_idx = o_idx;
5377
5378                 /* Success */
5379                 done = TRUE;
5380         }
5381
5382         /* Note the spot */
5383         note_spot(by, bx);
5384
5385         /* Draw the spot */
5386         lite_spot(by, bx);
5387
5388         /* Sound */
5389         sound(SOUND_DROP);
5390
5391         /* Mega-Hack -- no message if "dropped" by player */
5392         /* Message when an object falls under the player */
5393         if (chance && player_bold(by, bx))
5394         {
5395                 msg_print(_("何かが足下に転がってきた。", "You feel something roll beneath your feet."));
5396         }
5397
5398         /* XXX XXX XXX */
5399
5400         /* Result */
5401         return (o_idx);
5402 }
5403
5404
5405 /*!
5406  * @brief 獲得ドロップを行う。
5407  * Scatter some "great" objects near the player
5408  * @param y1 配置したいフロアのY座標
5409  * @param x1 配置したいフロアのX座標
5410  * @param num 獲得の処理回数
5411  * @param great TRUEならば必ず高級品以上を落とす
5412  * @param special TRUEならば必ず特別品を落とす
5413  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5414  * @return なし
5415  */
5416 void acquirement(int y1, int x1, int num, bool great, bool special, bool known)
5417 {
5418         object_type *i_ptr;
5419         object_type object_type_body;
5420         u32b mode = AM_GOOD | (great || special ? AM_GREAT : 0L) | (special ? AM_SPECIAL : 0L) ;
5421
5422         /* Acquirement */
5423         while (num--)
5424         {
5425                 /* Get local object */
5426                 i_ptr = &object_type_body;
5427
5428                 /* Wipe the object */
5429                 object_wipe(i_ptr);
5430
5431                 /* Make a good (or great) object (if possible) */
5432                 if (!make_object(i_ptr, mode)) continue;
5433
5434                 if (known)
5435                 {
5436                         object_aware(i_ptr);
5437                         object_known(i_ptr);
5438                 }
5439
5440                 /* Drop the object */
5441                 (void)drop_near(i_ptr, -1, y1, x1);
5442         }
5443 }
5444
5445 /*
5446  * Scatter some "amusing" objects near the player
5447  */
5448
5449 #define AMS_NOTHING   0x00 /* No restriction */
5450 #define AMS_NO_UNIQUE 0x01 /* Don't make the amusing object of uniques */
5451 #define AMS_FIXED_ART 0x02 /* Make a fixed artifact based on the amusing object */
5452 #define AMS_MULTIPLE  0x04 /* Drop 1-3 objects for one type */
5453 #define AMS_PILE      0x08 /* Drop 1-99 pile objects for one type */
5454
5455 typedef struct
5456 {
5457         int tval;
5458         int sval;
5459         int prob;
5460         byte flag;
5461 } amuse_type;
5462
5463 amuse_type amuse_info[] =
5464 {
5465         { TV_BOTTLE, SV_ANY, 5, AMS_NOTHING },
5466         { TV_JUNK, SV_ANY, 3, AMS_MULTIPLE },
5467         { TV_SPIKE, SV_ANY, 10, AMS_PILE },
5468         { TV_STATUE, SV_ANY, 15, AMS_NOTHING },
5469         { TV_CORPSE, SV_ANY, 15, AMS_NO_UNIQUE },
5470         { TV_SKELETON, SV_ANY, 10, AMS_NO_UNIQUE },
5471         { TV_FIGURINE, SV_ANY, 10, AMS_NO_UNIQUE },
5472         { TV_PARCHMENT, SV_ANY, 1, AMS_NOTHING },
5473         { TV_POLEARM, SV_TSURIZAO, 3, AMS_NOTHING }, //Fishing Pole of Taikobo
5474         { TV_SWORD, SV_BROKEN_DAGGER, 3, AMS_FIXED_ART }, //Broken Dagger of Magician
5475         { TV_SWORD, SV_BROKEN_DAGGER, 10, AMS_NOTHING },
5476         { TV_SWORD, SV_BROKEN_SWORD, 5, AMS_NOTHING },
5477         { TV_SCROLL, SV_SCROLL_AMUSEMENT, 10, AMS_NOTHING },
5478
5479         { 0, 0, 0 }
5480 };
5481
5482 /*!
5483  * @brief 誰得ドロップを行う。
5484  * @param y1 配置したいフロアのY座標
5485  * @param x1 配置したいフロアのX座標
5486  * @param num 誰得の処理回数
5487  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5488  * @return なし
5489  */
5490 void amusement(int y1, int x1, int num, bool known)
5491 {
5492         object_type *i_ptr;
5493         object_type object_type_body;
5494         int n, t = 0;
5495
5496         for (n = 0; amuse_info[n].tval != 0; n++)
5497         {
5498                 t += amuse_info[n].prob;
5499         }
5500
5501         /* Acquirement */
5502         while (num)
5503         {
5504                 int i, k_idx, a_idx = 0;
5505                 int r = randint0(t);
5506                 bool insta_art, fixed_art;
5507
5508                 for (i = 0; ; i++)
5509                 {
5510                         r -= amuse_info[i].prob;
5511                         if (r <= 0) break;
5512                 }
5513
5514                 /* Get local object */
5515                 i_ptr = &object_type_body;
5516
5517                 /* Wipe the object */
5518                 object_wipe(i_ptr);
5519
5520                 /* Wipe the object */
5521                 k_idx = lookup_kind(amuse_info[i].tval, amuse_info[i].sval);
5522
5523                 /* Paranoia - reroll if nothing */
5524                 if (!k_idx) continue;
5525
5526                 /* Search an artifact index if need */
5527                 insta_art = (k_info[k_idx].gen_flags & TRG_INSTA_ART);
5528                 fixed_art = (amuse_info[i].flag & AMS_FIXED_ART);
5529
5530                 if (insta_art || fixed_art)
5531                 {
5532                         for (a_idx = 1; a_idx < max_a_idx; a_idx++)
5533                         {
5534                                 if (insta_art && !(a_info[a_idx].gen_flags & TRG_INSTA_ART)) continue;
5535                                 if (a_info[a_idx].tval != k_info[k_idx].tval) continue;
5536                                 if (a_info[a_idx].sval != k_info[k_idx].sval) continue;
5537                                 if (a_info[a_idx].cur_num > 0) continue;
5538                                 break;
5539                         }
5540
5541                         if (a_idx >= max_a_idx) continue;
5542                 }
5543
5544                 /* Make an object (if possible) */
5545                 object_prep(i_ptr, k_idx);
5546                 if (a_idx) i_ptr->name1 = a_idx;
5547                 apply_magic(i_ptr, 1, AM_NO_FIXED_ART);
5548
5549                 if (amuse_info[i].flag & AMS_NO_UNIQUE)
5550                 {
5551                         if (r_info[i_ptr->pval].flags1 & RF1_UNIQUE) continue;
5552                 }
5553
5554                 if (amuse_info[i].flag & AMS_MULTIPLE) i_ptr->number = randint1(3);
5555                 if (amuse_info[i].flag & AMS_PILE) i_ptr->number = randint1(99);
5556
5557                 if (known)
5558                 {
5559                         object_aware(i_ptr);
5560                         object_known(i_ptr);
5561                 }
5562
5563                 /* Paranoia - reroll if nothing */
5564                 if (!(i_ptr->k_idx)) continue;
5565
5566                 /* Drop the object */
5567                 (void)drop_near(i_ptr, -1, y1, x1);
5568
5569                 num--;
5570         }
5571 }
5572
5573
5574 #define MAX_NORMAL_TRAPS 18
5575
5576 /* See init_feat_variables() in init2.c */
5577 static s16b normal_traps[MAX_NORMAL_TRAPS];
5578
5579 /*!
5580  * @brief タグに従って、基本トラップテーブルを初期化する / Initialize arrays for normal traps
5581  * @return なし
5582  */
5583 void init_normal_traps(void)
5584 {
5585         int cur_trap = 0;
5586
5587         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPDOOR");
5588         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_PIT");
5589         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SPIKED_PIT");
5590         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON_PIT");
5591         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TY_CURSE");
5592         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TELEPORT");
5593         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_FIRE");
5594         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ACID");
5595         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLOW");
5596         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_STR");
5597         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_DEX");
5598         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_CON");
5599         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_BLIND");
5600         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_CONFUSE");
5601         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON");
5602         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLEEP");
5603         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPS");
5604         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ALARM");
5605 }
5606
5607 /*!
5608  * @brief 基本トラップをランダムに選択する /
5609  * Get random trap
5610  * @return 選択したトラップのID
5611  * @details
5612  * XXX XXX XXX This routine should be redone to reflect trap "level".\n
5613  * That is, it does not make sense to have spiked pits at 50 feet.\n
5614  * Actually, it is not this routine, but the "trap instantiation"\n
5615  * code, which should also check for "trap doors" on quest levels.\n
5616  */
5617 s16b choose_random_trap(void)
5618 {
5619         s16b feat;
5620
5621         /* Pick a trap */
5622         while (1)
5623         {
5624                 /* Hack -- pick a trap */
5625                 feat = normal_traps[randint0(MAX_NORMAL_TRAPS)];
5626
5627                 /* Accept non-trapdoors */
5628                 if (!have_flag(f_info[feat].flags, FF_MORE)) break;
5629
5630                 /* Hack -- no trap doors on special levels */
5631                 if (p_ptr->inside_arena || quest_number(dun_level)) continue;
5632
5633                 /* Hack -- no trap doors on the deepest level */
5634                 if (dun_level >= d_info[dungeon_type].maxdepth) continue;
5635
5636                 break;
5637         }
5638
5639         return feat;
5640 }
5641
5642 /*!
5643  * @brief マスに存在するトラップを秘匿する /
5644  * Disclose an invisible trap
5645  * @param y 秘匿したいマスのY座標
5646  * @param x 秘匿したいマスのX座標
5647  * @return なし
5648  */
5649 void disclose_grid(int y, int x)
5650 {
5651         cave_type *c_ptr = &cave[y][x];
5652
5653         if (cave_have_flag_grid(c_ptr, FF_SECRET))
5654         {
5655                 /* No longer hidden */
5656                 cave_alter_feat(y, x, FF_SECRET);
5657         }
5658         else if (c_ptr->mimic)
5659         {
5660                 /* No longer hidden */
5661                 c_ptr->mimic = 0;
5662
5663                 /* Notice */
5664                 note_spot(y, x);
5665
5666                 /* Redraw */
5667                 lite_spot(y, x);
5668         }
5669 }
5670
5671 /*!
5672  * @brief マスをトラップを配置する /
5673  * The location must be a legal, naked, floor grid.
5674  * @param y 配置したいマスのY座標
5675  * @param x 配置したいマスのX座標
5676  * @return
5677  * Note that all traps start out as "invisible" and "untyped", and then\n
5678  * when they are "discovered" (by detecting them or setting them off),\n
5679  * the trap is "instantiated" as a visible, "typed", trap.\n
5680  */
5681 void place_trap(int y, int x)
5682 {
5683         cave_type *c_ptr = &cave[y][x];
5684
5685         /* Paranoia -- verify location */
5686         if (!in_bounds(y, x)) return;
5687
5688         /* Require empty, clean, floor grid */
5689         if (!cave_clean_bold(y, x)) return;
5690
5691         /* Place an invisible trap */
5692         c_ptr->mimic = c_ptr->feat;
5693         c_ptr->feat = choose_random_trap();
5694 }
5695
5696 /*!
5697  * @brief 魔道具の使用回数の残量を示すメッセージを表示する /
5698  * Describe the charges on an item in the inventory.
5699  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5700  * @return なし
5701  */
5702 void inven_item_charges(int item)
5703 {
5704         object_type *o_ptr = &inventory[item];
5705
5706         /* Require staff/wand */
5707         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5708
5709         /* Require known item */
5710         if (!object_is_known(o_ptr)) return;
5711
5712 #ifdef JP
5713         if (o_ptr->pval <= 0)
5714         {
5715                 msg_print("もう魔力が残っていない。");
5716         }
5717         else
5718         {
5719                 msg_format("あと %d 回分の魔力が残っている。", o_ptr->pval);
5720         }
5721 #else
5722         /* Multiple charges */
5723         if (o_ptr->pval != 1)
5724         {
5725                 /* Print a message */
5726                 msg_format("You have %d charges remaining.", o_ptr->pval);
5727         }
5728
5729         /* Single charge */
5730         else
5731         {
5732                 /* Print a message */
5733                 msg_format("You have %d charge remaining.", o_ptr->pval);
5734         }
5735 #endif
5736
5737 }
5738
5739 /*!
5740  * @brief アイテムの残り所持数メッセージを表示する /
5741  * Describe an item in the inventory.
5742  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5743  * @return なし
5744  */
5745 void inven_item_describe(int item)
5746 {
5747         object_type *o_ptr = &inventory[item];
5748         char        o_name[MAX_NLEN];
5749
5750         /* Get a description */
5751         object_desc(o_name, o_ptr, 0);
5752
5753         /* Print a message */
5754 #ifdef JP
5755         /* "no more" の場合はこちらで表示する */
5756         if (o_ptr->number <= 0)
5757         {
5758                 /*FIRST*//*ここはもう通らないかも */
5759                 msg_format("もう%sを持っていない。", o_name);
5760         }
5761         else
5762         {
5763                 /* アイテム名を英日切り替え機能対応 */
5764                 msg_format("まだ %sを持っている。", o_name);
5765         }
5766 #else
5767         msg_format("You have %s.", o_name);
5768 #endif
5769
5770 }
5771
5772 /*!
5773  * @brief アイテムの残り所持数メッセージを表示する /
5774  * Increase the "number" of an item in the inventory
5775  * @param item 所持数を増やしたいプレイヤーのアイテム所持スロット
5776  * @param num 増やしたい量
5777  * @return なし
5778  */
5779 void inven_item_increase(int item, int num)
5780 {
5781         object_type *o_ptr = &inventory[item];
5782
5783         /* Apply */
5784         num += o_ptr->number;
5785
5786         /* Bounds check */
5787         if (num > 255) num = 255;
5788         else if (num < 0) num = 0;
5789
5790         /* Un-apply */
5791         num -= (ITEM_NUMBER)o_ptr->number;
5792
5793         /* Change the number and weight */
5794         if (num)
5795         {
5796                 /* Add the number */
5797                 o_ptr->number += num;
5798
5799                 /* Add the weight */
5800                 p_ptr->total_weight += (num * o_ptr->weight);
5801
5802                 /* Recalculate bonuses */
5803                 p_ptr->update |= (PU_BONUS);
5804
5805                 /* Recalculate mana XXX */
5806                 p_ptr->update |= (PU_MANA);
5807
5808                 /* Combine the pack */
5809                 p_ptr->notice |= (PN_COMBINE);
5810
5811                 /* Window stuff */
5812                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5813
5814                 /* Hack -- Clear temporary elemental brands if player takes off weapons */
5815                 if (!o_ptr->number && p_ptr->ele_attack)
5816                 {
5817                         if ((item == INVEN_RARM) || (item == INVEN_LARM))
5818                         {
5819                                 if (!buki_motteruka(INVEN_RARM + INVEN_LARM - item))
5820                                 {
5821                                         /* Clear all temporary elemental brands */
5822                                         set_ele_attack(0, 0);
5823                                 }
5824                         }
5825                 }
5826         }
5827 }
5828
5829 /*!
5830  * @brief 所持アイテムスロットから所持数のなくなったアイテムを消去する /
5831  * Erase an inventory slot if it has no more items
5832  * @param item 消去したいプレイヤーのアイテム所持スロット
5833  * @return なし
5834  */
5835 void inven_item_optimize(int item)
5836 {
5837         object_type *o_ptr = &inventory[item];
5838
5839         /* Only optimize real items */
5840         if (!o_ptr->k_idx) return;
5841
5842         /* Only optimize empty items */
5843         if (o_ptr->number) return;
5844
5845         /* The item is in the pack */
5846         if (item < INVEN_RARM)
5847         {
5848                 int i;
5849
5850                 /* One less item */
5851                 inven_cnt--;
5852
5853                 /* Slide everything down */
5854                 for (i = item; i < INVEN_PACK; i++)
5855                 {
5856                         /* Structure copy */
5857                         inventory[i] = inventory[i+1];
5858                 }
5859
5860                 /* Erase the "final" slot */
5861                 object_wipe(&inventory[i]);
5862
5863                 /* Window stuff */
5864                 p_ptr->window |= (PW_INVEN);
5865         }
5866
5867         /* The item is being wielded */
5868         else
5869         {
5870                 /* One less item */
5871                 equip_cnt--;
5872
5873                 /* Erase the empty slot */
5874                 object_wipe(&inventory[item]);
5875
5876                 /* Recalculate bonuses */
5877                 p_ptr->update |= (PU_BONUS);
5878
5879                 /* Recalculate torch */
5880                 p_ptr->update |= (PU_TORCH);
5881
5882                 /* Recalculate mana XXX */
5883                 p_ptr->update |= (PU_MANA);
5884
5885                 /* Window stuff */
5886                 p_ptr->window |= (PW_EQUIP);
5887         }
5888
5889         /* Window stuff */
5890         p_ptr->window |= (PW_SPELL);
5891 }
5892
5893 /*!
5894  * @brief 床上の魔道具の残り残量メッセージを表示する /
5895  * Describe the charges on an item on the floor.
5896  * @param item メッセージの対象にしたいアイテム所持スロット
5897  * @return なし
5898  */
5899 void floor_item_charges(int item)
5900 {
5901         object_type *o_ptr = &o_list[item];
5902
5903         /* Require staff/wand */
5904         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5905
5906         /* Require known item */
5907         if (!object_is_known(o_ptr)) return;
5908
5909 #ifdef JP
5910         if (o_ptr->pval <= 0)
5911         {
5912                 msg_print("この床上のアイテムは、もう魔力が残っていない。");
5913         }
5914         else
5915         {
5916                 msg_format("この床上のアイテムは、あと %d 回分の魔力が残っている。", o_ptr->pval);
5917         }
5918 #else
5919         /* Multiple charges */
5920         if (o_ptr->pval != 1)
5921         {
5922                 /* Print a message */
5923                 msg_format("There are %d charges remaining.", o_ptr->pval);
5924         }
5925
5926         /* Single charge */
5927         else
5928         {
5929                 /* Print a message */
5930                 msg_format("There is %d charge remaining.", o_ptr->pval);
5931         }
5932 #endif
5933
5934 }
5935
5936 /*!
5937  * @brief 床上のアイテムの残り数メッセージを表示する /
5938  * Describe the charges on an item on the floor.
5939  * @param item メッセージの対象にしたいアイテム所持スロット
5940  * @return なし
5941  */
5942 void floor_item_describe(int item)
5943 {
5944         object_type *o_ptr = &o_list[item];
5945         char        o_name[MAX_NLEN];
5946
5947         /* Get a description */
5948         object_desc(o_name, o_ptr, 0);
5949
5950         /* Print a message */
5951 #ifdef JP
5952         /* "no more" の場合はこちらで表示を分ける */
5953         if (o_ptr->number <= 0)
5954         {
5955                 msg_format("床上には、もう%sはない。", o_name);
5956         }
5957         else
5958         {
5959                 msg_format("床上には、まだ %sがある。", o_name);
5960         }
5961 #else
5962         msg_format("You see %s.", o_name);
5963 #endif
5964
5965 }
5966
5967
5968 /*!
5969  * @brief 床上のアイテムの数を増やす /
5970  * Increase the "number" of an item on the floor
5971  * @param item 増やしたいアイテムの所持スロット
5972  * @param num 増やしたいアイテムの数
5973  * @return なし
5974  */
5975 void floor_item_increase(int item, int num)
5976 {
5977         object_type *o_ptr = &o_list[item];
5978
5979         /* Apply */
5980         num += o_ptr->number;
5981
5982         /* Bounds check */
5983         if (num > 255) num = 255;
5984         else if (num < 0) num = 0;
5985
5986         /* Un-apply */
5987         num -= (int)o_ptr->number;
5988
5989         /* Change the number */
5990         o_ptr->number += (ITEM_NUMBER)num;
5991 }
5992
5993
5994 /*!
5995  * @brief 床上の数の無くなったアイテムスロットを消去する /
5996  * Optimize an item on the floor (destroy "empty" items)
5997  * @param item 消去したいアイテムの所持スロット
5998  * @return なし
5999  */
6000 void floor_item_optimize(int item)
6001 {
6002         object_type *o_ptr = &o_list[item];
6003
6004         /* Paranoia -- be sure it exists */
6005         if (!o_ptr->k_idx) return;
6006
6007         /* Only optimize empty items */
6008         if (o_ptr->number) return;
6009
6010         /* Delete the object */
6011         delete_object_idx(item);
6012 }
6013
6014
6015 /*!
6016  * @brief アイテムを拾う際にザックから溢れずに済むかを判定する /
6017  * Check if we have space for an item in the pack without overflow
6018  * @param o_ptr 拾いたいオブジェクトの構造体参照ポインタ
6019  * @return 溢れずに済むならTRUEを返す
6020  */
6021 bool inven_carry_okay(object_type *o_ptr)
6022 {
6023         int j;
6024
6025         /* Empty slot? */
6026         if (inven_cnt < INVEN_PACK) return (TRUE);
6027
6028         /* Similar slot? */
6029         for (j = 0; j < INVEN_PACK; j++)
6030         {
6031                 object_type *j_ptr = &inventory[j];
6032
6033                 /* Skip non-objects */
6034                 if (!j_ptr->k_idx) continue;
6035
6036                 /* Check if the two items can be combined */
6037                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
6038         }
6039
6040         /* Nope */
6041         return (FALSE);
6042 }
6043
6044 /*!
6045  * @brief オブジェクトを定義された基準に従いソートするための関数 /
6046  * Check if we have space for an item in the pack without overflow
6047  * @param o_ptr 比較対象オブジェクトの構造体参照ポインタ1
6048  * @param o_value o_ptrのアイテム価値（手動であらかじめ代入する必要がある？）
6049  * @param j_ptr 比較対象オブジェクトの構造体参照ポインタ2
6050  * @return o_ptrの方が上位ならばTRUEを返す。
6051  */
6052 bool object_sort_comp(object_type *o_ptr, s32b o_value, object_type *j_ptr)
6053 {
6054         int o_type, j_type;
6055
6056         /* Use empty slots */
6057         if (!j_ptr->k_idx) return TRUE;
6058
6059         /* Hack -- readable books always come first */
6060         if ((o_ptr->tval == REALM1_BOOK) &&
6061             (j_ptr->tval != REALM1_BOOK)) return TRUE;
6062         if ((j_ptr->tval == REALM1_BOOK) &&
6063             (o_ptr->tval != REALM1_BOOK)) return FALSE;
6064
6065         if ((o_ptr->tval == REALM2_BOOK) &&
6066             (j_ptr->tval != REALM2_BOOK)) return TRUE;
6067         if ((j_ptr->tval == REALM2_BOOK) &&
6068             (o_ptr->tval != REALM2_BOOK)) return FALSE;
6069
6070         /* Objects sort by decreasing type */
6071         if (o_ptr->tval > j_ptr->tval) return TRUE;
6072         if (o_ptr->tval < j_ptr->tval) return FALSE;
6073
6074         /* Non-aware (flavored) items always come last */
6075         /* Can happen in the home */
6076         if (!object_is_aware(o_ptr)) return FALSE;
6077         if (!object_is_aware(j_ptr)) return TRUE;
6078
6079         /* Objects sort by increasing sval */
6080         if (o_ptr->sval < j_ptr->sval) return TRUE;
6081         if (o_ptr->sval > j_ptr->sval) return FALSE;
6082
6083         /* Unidentified objects always come last */
6084         /* Objects in the home can be unknown */
6085         if (!object_is_known(o_ptr)) return FALSE;
6086         if (!object_is_known(j_ptr)) return TRUE;
6087
6088         /* Fixed artifacts, random artifacts and ego items */
6089         if (object_is_fixed_artifact(o_ptr)) o_type = 3;
6090         else if (o_ptr->art_name) o_type = 2;
6091         else if (object_is_ego(o_ptr)) o_type = 1;
6092         else o_type = 0;
6093
6094         if (object_is_fixed_artifact(j_ptr)) j_type = 3;
6095         else if (j_ptr->art_name) j_type = 2;
6096         else if (object_is_ego(j_ptr)) j_type = 1;
6097         else j_type = 0;
6098
6099         if (o_type < j_type) return TRUE;
6100         if (o_type > j_type) return FALSE;
6101
6102         switch (o_ptr->tval)
6103         {
6104         case TV_FIGURINE:
6105         case TV_STATUE:
6106         case TV_CORPSE:
6107         case TV_CAPTURE:
6108                 if (r_info[o_ptr->pval].level < r_info[j_ptr->pval].level) return TRUE;
6109                 if ((r_info[o_ptr->pval].level == r_info[j_ptr->pval].level) && (o_ptr->pval < j_ptr->pval)) return TRUE;
6110                 return FALSE;
6111
6112         case TV_SHOT:
6113         case TV_ARROW:
6114         case TV_BOLT:
6115                 /* Objects sort by increasing hit/damage bonuses */
6116                 if (o_ptr->to_h + o_ptr->to_d < j_ptr->to_h + j_ptr->to_d) return TRUE;
6117                 if (o_ptr->to_h + o_ptr->to_d > j_ptr->to_h + j_ptr->to_d) return FALSE;
6118                 break;
6119
6120         /* Hack:  otherwise identical rods sort by
6121         increasing recharge time --dsb */
6122         case TV_ROD:
6123                 if (o_ptr->pval < j_ptr->pval) return TRUE;
6124                 if (o_ptr->pval > j_ptr->pval) return FALSE;
6125                 break;
6126         }
6127
6128         /* Objects sort by decreasing value */
6129         return o_value > object_value(j_ptr);
6130 }
6131
6132
6133 /*!
6134  * @brief オブジェクトをプレイヤーが拾って所持スロットに納めるメインルーチン /
6135  * Add an item to the players inventory, and return the slot used.
6136  * @param o_ptr 拾うオブジェクトの構造体参照ポインタ
6137  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6138  * @details
6139  * If the new item can combine with an existing item in the inventory,\n
6140  * it will do so, using "object_similar()" and "object_absorb()", else,\n
6141  * the item will be placed into the "proper" location in the inventory.\n
6142  *\n
6143  * This function can be used to "over-fill" the player's pack, but only\n
6144  * once, and such an action must trigger the "overflow" code immediately.\n
6145  * Note that when the pack is being "over-filled", the new item must be\n
6146  * placed into the "overflow" slot, and the "overflow" must take place\n
6147  * before the pack is reordered, but (optionally) after the pack is\n
6148  * combined.  This may be tricky.  See "dungeon.c" for info.\n
6149  *\n
6150  * Note that this code must remove any location/stack information\n
6151  * from the object once it is placed into the inventory.\n
6152  */
6153 s16b inven_carry(object_type *o_ptr)
6154 {
6155         int i, j, k;
6156         int n = -1;
6157
6158         object_type *j_ptr;
6159
6160
6161         /* Check for combining */
6162         for (j = 0; j < INVEN_PACK; j++)
6163         {
6164                 j_ptr = &inventory[j];
6165
6166                 /* Skip non-objects */
6167                 if (!j_ptr->k_idx) continue;
6168
6169                 /* Hack -- track last item */
6170                 n = j;
6171
6172                 /* Check if the two items can be combined */
6173                 if (object_similar(j_ptr, o_ptr))
6174                 {
6175                         /* Combine the items */
6176                         object_absorb(j_ptr, o_ptr);
6177
6178                         /* Increase the weight */
6179                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
6180
6181                         /* Recalculate bonuses */
6182                         p_ptr->update |= (PU_BONUS);
6183
6184                         /* Window stuff */
6185                         p_ptr->window |= (PW_INVEN);
6186
6187                         /* Success */
6188                         return (j);
6189                 }
6190         }
6191
6192
6193         /* Paranoia */
6194         if (inven_cnt > INVEN_PACK) return (-1);
6195
6196         /* Find an empty slot */
6197         for (j = 0; j <= INVEN_PACK; j++)
6198         {
6199                 j_ptr = &inventory[j];
6200
6201                 /* Use it if found */
6202                 if (!j_ptr->k_idx) break;
6203         }
6204
6205         /* Use that slot */
6206         i = j;
6207
6208
6209         /* Reorder the pack */
6210         if (i < INVEN_PACK)
6211         {
6212                 /* Get the "value" of the item */
6213                 s32b o_value = object_value(o_ptr);
6214
6215                 /* Scan every occupied slot */
6216                 for (j = 0; j < INVEN_PACK; j++)
6217                 {
6218                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6219                 }
6220
6221                 /* Use that slot */
6222                 i = j;
6223
6224                 /* Slide objects */
6225                 for (k = n; k >= i; k--)
6226                 {
6227                         /* Hack -- Slide the item */
6228                         object_copy(&inventory[k+1], &inventory[k]);
6229                 }
6230
6231                 /* Wipe the empty slot */
6232                 object_wipe(&inventory[i]);
6233         }
6234
6235
6236         /* Copy the item */
6237         object_copy(&inventory[i], o_ptr);
6238
6239         /* Access new object */
6240         j_ptr = &inventory[i];
6241
6242         /* Forget stack */
6243         j_ptr->next_o_idx = 0;
6244
6245         /* Forget monster */
6246         j_ptr->held_m_idx = 0;
6247
6248         /* Forget location */
6249         j_ptr->iy = j_ptr->ix = 0;
6250
6251         /* Player touches it, and no longer marked */
6252         j_ptr->marked = OM_TOUCHED;
6253
6254         /* Increase the weight */
6255         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
6256
6257         /* Count the items */
6258         inven_cnt++;
6259
6260         /* Recalculate bonuses */
6261         p_ptr->update |= (PU_BONUS);
6262
6263         /* Combine and Reorder pack */
6264         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
6265
6266         /* Window stuff */
6267         p_ptr->window |= (PW_INVEN);
6268
6269         /* Return the slot */
6270         return (i);
6271 }
6272
6273
6274 /*!
6275  * @brief 装備スロットからオブジェクトを外すメインルーチン /
6276  * Take off (some of) a non-cursed equipment item
6277  * @param item オブジェクトを外したい所持テーブルのID
6278  * @param amt 外したい個数
6279  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6280  * @details
6281  * Note that only one item at a time can be wielded per slot.\n
6282  * Note that taking off an item when "full" may cause that item\n
6283  * to fall to the ground.\n
6284  * Return the inventory slot into which the item is placed.\n
6285  */
6286 s16b inven_takeoff(int item, int amt)
6287 {
6288         int slot;
6289
6290         object_type forge;
6291         object_type *q_ptr;
6292
6293         object_type *o_ptr;
6294
6295         cptr act;
6296
6297         char o_name[MAX_NLEN];
6298
6299
6300         /* Get the item to take off */
6301         o_ptr = &inventory[item];
6302
6303         /* Paranoia */
6304         if (amt <= 0) return (-1);
6305
6306         /* Verify */
6307         if (amt > o_ptr->number) amt = o_ptr->number;
6308
6309         /* Get local object */
6310         q_ptr = &forge;
6311
6312         /* Obtain a local object */
6313         object_copy(q_ptr, o_ptr);
6314
6315         /* Modify quantity */
6316         q_ptr->number = amt;
6317
6318         /* Describe the object */
6319         object_desc(o_name, q_ptr, 0);
6320
6321         /* Took off weapon */
6322         if (((item == INVEN_RARM) || (item == INVEN_LARM)) &&
6323             object_is_melee_weapon(o_ptr))
6324         {
6325                 act = _("を装備からはずした", "You were wielding");
6326         }
6327
6328         /* Took off bow */
6329         else if (item == INVEN_BOW)
6330         {
6331                 act = _("を装備からはずした", "You were holding");
6332         }
6333
6334         /* Took off light */
6335         else if (item == INVEN_LITE)
6336         {
6337                 act = _("を光源からはずした", "You were holding");
6338         }
6339
6340         /* Took off something */
6341         else
6342         {
6343                 act = _("を装備からはずした", "You were wearing");
6344         }
6345
6346         /* Modify, Optimize */
6347         inven_item_increase(item, -amt);
6348         inven_item_optimize(item);
6349
6350         /* Carry the object */
6351         slot = inven_carry(q_ptr);
6352
6353         /* Message */
6354 #ifdef JP
6355         msg_format("%s(%c)%s。", o_name, index_to_label(slot), act);
6356 #else
6357         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
6358 #endif
6359
6360
6361         /* Return slot */
6362         return (slot);
6363 }
6364
6365
6366 /*!
6367  * @brief 所持スロットから床下にオブジェクトを落とすメインルーチン /
6368  * Drop (some of) a non-cursed inventory/equipment item
6369  * @param item 所持テーブルのID
6370  * @param amt 落としたい個数
6371  * @return なし
6372  * @details
6373  * The object will be dropped "near" the current location
6374  */
6375 void inven_drop(int item, int amt)
6376 {
6377         object_type forge;
6378         object_type *q_ptr;
6379
6380         object_type *o_ptr;
6381
6382         char o_name[MAX_NLEN];
6383
6384
6385         /* Access original object */
6386         o_ptr = &inventory[item];
6387
6388         /* Error check */
6389         if (amt <= 0) return;
6390
6391         /* Not too many */
6392         if (amt > o_ptr->number) amt = o_ptr->number;
6393
6394
6395         /* Take off equipment */
6396         if (item >= INVEN_RARM)
6397         {
6398                 /* Take off first */
6399                 item = inven_takeoff(item, amt);
6400
6401                 /* Access original object */
6402                 o_ptr = &inventory[item];
6403         }
6404
6405
6406         /* Get local object */
6407         q_ptr = &forge;
6408
6409         /* Obtain local object */
6410         object_copy(q_ptr, o_ptr);
6411
6412         /* Distribute charges of wands or rods */
6413         distribute_charges(o_ptr, q_ptr, amt);
6414
6415         /* Modify quantity */
6416         q_ptr->number = amt;
6417
6418         /* Describe local object */
6419         object_desc(o_name, q_ptr, 0);
6420
6421         /* Message */
6422         msg_format(_("%s(%c)を落とした。", "You drop %s (%c)."), o_name, index_to_label(item));
6423
6424         /* Drop it near the player */
6425         (void)drop_near(q_ptr, 0, p_ptr->y, p_ptr->x);
6426
6427         /* Modify, Describe, Optimize */
6428         inven_item_increase(item, -amt);
6429         inven_item_describe(item);
6430         inven_item_optimize(item);
6431 }
6432
6433
6434 /*!
6435  * @brief プレイヤーの所持スロットに存在するオブジェクトをまとめなおす /
6436  * Combine items in the pack
6437  * @return なし
6438  * @details
6439  * Note special handling of the "overflow" slot
6440  */
6441 void combine_pack(void)
6442 {
6443         int             i, j, k;
6444         object_type     *o_ptr;
6445         object_type     *j_ptr;
6446         bool            flag = FALSE, combined;
6447
6448         do
6449         {
6450                 combined = FALSE;
6451
6452                 /* Combine the pack (backwards) */
6453                 for (i = INVEN_PACK; i > 0; i--)
6454                 {
6455                         /* Get the item */
6456                         o_ptr = &inventory[i];
6457
6458                         /* Skip empty items */
6459                         if (!o_ptr->k_idx) continue;
6460
6461                         /* Scan the items above that item */
6462                         for (j = 0; j < i; j++)
6463                         {
6464                                 int max_num;
6465
6466                                 /* Get the item */
6467                                 j_ptr = &inventory[j];
6468
6469                                 /* Skip empty items */
6470                                 if (!j_ptr->k_idx) continue;
6471
6472                                 /*
6473                                  * Get maximum number of the stack if these
6474                                  * are similar, get zero otherwise.
6475                                  */
6476                                 max_num = object_similar_part(j_ptr, o_ptr);
6477
6478                                 /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
6479                                 if (max_num && j_ptr->number < max_num)
6480                                 {
6481                                         if (o_ptr->number + j_ptr->number <= max_num)
6482                                         {
6483                                                 /* Take note */
6484                                                 flag = TRUE;
6485
6486                                                 /* Add together the item counts */
6487                                                 object_absorb(j_ptr, o_ptr);
6488
6489                                                 /* One object is gone */
6490                                                 inven_cnt--;
6491
6492                                                 /* Slide everything down */
6493                                                 for (k = i; k < INVEN_PACK; k++)
6494                                                 {
6495                                                         /* Structure copy */
6496                                                         inventory[k] = inventory[k+1];
6497                                                 }
6498
6499                                                 /* Erase the "final" slot */
6500                                                 object_wipe(&inventory[k]);
6501                                         }
6502                                         else
6503                                         {
6504                                                 int old_num = o_ptr->number;
6505                                                 int remain = j_ptr->number + o_ptr->number - max_num;
6506 #if 0
6507                                                 o_ptr->number -= remain;
6508 #endif
6509                                                 /* Add together the item counts */
6510                                                 object_absorb(j_ptr, o_ptr);
6511
6512                                                 o_ptr->number = remain;
6513
6514                                                 /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
6515                                                 if (o_ptr->tval == TV_ROD)
6516                                                 {
6517                                                         o_ptr->pval =  o_ptr->pval * remain / old_num;
6518                                                         o_ptr->timeout = o_ptr->timeout * remain / old_num;
6519                                                 }
6520
6521                                                 /* Hack -- if wands are stacking, combine the charges. -LM- */
6522                                                 if (o_ptr->tval == TV_WAND)
6523                                                 {
6524                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
6525                                                 }
6526                                         }
6527
6528                                         /* Window stuff */
6529                                         p_ptr->window |= (PW_INVEN);
6530
6531                                         /* Take note */
6532                                         combined = TRUE;
6533
6534                                         /* Done */
6535                                         break;
6536                                 }
6537                         }
6538                 }
6539         }
6540         while (combined);
6541
6542         /* Message */
6543         if (flag) msg_print(_("ザックの中のアイテムをまとめ直した。", "You combine some items in your pack."));
6544 }
6545
6546 /*!
6547  * @brief プレイヤーの所持スロットに存在するオブジェクトを並び替える /
6548  * Reorder items in the pack
6549  * @return なし
6550  * @details
6551  * Note special handling of the "overflow" slot
6552  */
6553 void reorder_pack(void)
6554 {
6555         int             i, j, k;
6556         s32b            o_value;
6557         object_type     forge;
6558         object_type     *q_ptr;
6559         object_type     *o_ptr;
6560         bool            flag = FALSE;
6561
6562
6563         /* Re-order the pack (forwards) */
6564         for (i = 0; i < INVEN_PACK; i++)
6565         {
6566                 /* Mega-Hack -- allow "proper" over-flow */
6567                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6568
6569                 /* Get the item */
6570                 o_ptr = &inventory[i];
6571
6572                 /* Skip empty slots */
6573                 if (!o_ptr->k_idx) continue;
6574
6575                 /* Get the "value" of the item */
6576                 o_value = object_value(o_ptr);
6577
6578                 /* Scan every occupied slot */
6579                 for (j = 0; j < INVEN_PACK; j++)
6580                 {
6581                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6582                 }
6583
6584                 /* Never move down */
6585                 if (j >= i) continue;
6586
6587                 /* Take note */
6588                 flag = TRUE;
6589
6590                 /* Get local object */
6591                 q_ptr = &forge;
6592
6593                 /* Save a copy of the moving item */
6594                 object_copy(q_ptr, &inventory[i]);
6595
6596                 /* Slide the objects */
6597                 for (k = i; k > j; k--)
6598                 {
6599                         /* Slide the item */
6600                         object_copy(&inventory[k], &inventory[k-1]);
6601                 }
6602
6603                 /* Insert the moving item */
6604                 object_copy(&inventory[j], q_ptr);
6605
6606                 /* Window stuff */
6607                 p_ptr->window |= (PW_INVEN);
6608         }
6609
6610         /* Message */
6611         if (flag) msg_print(_("ザックの中のアイテムを並べ直した。", "You reorder some items in your pack."));
6612 }
6613
6614 /*!
6615  * @brief 現在アクティブになっているウィンドウにオブジェクトの詳細を表示する /
6616  * Hack -- display an object kind in the current window
6617  * @param k_idx ベースアイテムの参照ID
6618  * @return なし
6619  * @details
6620  * Include list of usable spells for readible books
6621  */
6622 void display_koff(int k_idx)
6623 {
6624         int y;
6625
6626         object_type forge;
6627         object_type *q_ptr;
6628         int         sval;
6629         int         use_realm;
6630
6631         char o_name[MAX_NLEN];
6632
6633
6634         /* Erase the window */
6635         for (y = 0; y < Term->hgt; y++)
6636         {
6637                 /* Erase the line */
6638                 Term_erase(0, y, 255);
6639         }
6640
6641         /* No info */
6642         if (!k_idx) return;
6643
6644         /* Get local object */
6645         q_ptr = &forge;
6646
6647         /* Prepare the object */
6648         object_prep(q_ptr, k_idx);
6649
6650         /* Describe */
6651         object_desc(o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
6652
6653         /* Mention the object name */
6654         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6655
6656         /* Access the item's sval */
6657         sval = q_ptr->sval;
6658         use_realm = tval2realm(q_ptr->tval);
6659
6660         /* Warriors are illiterate */
6661         if (p_ptr->realm1 || p_ptr->realm2)
6662         {
6663                 if ((use_realm != p_ptr->realm1) && (use_realm != p_ptr->realm2)) return;
6664         }
6665         else
6666         {
6667                 if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return;
6668                 if (!is_magic(use_realm)) return;
6669                 if ((p_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1)) return;
6670         }
6671
6672         /* Display spells in readible books */
6673         {
6674                 int     spell = -1;
6675                 int     num = 0;
6676                 byte    spells[64];
6677
6678                 /* Extract spells */
6679                 for (spell = 0; spell < 32; spell++)
6680                 {
6681                         /* Check for this spell */
6682                         if (fake_spell_flags[sval] & (1L << spell))
6683                         {
6684                                 /* Collect this spell */
6685                                 spells[num++] = spell;
6686                         }
6687                 }
6688
6689                 /* Print spells */
6690                 print_spells(0, spells, num, 2, 0, use_realm);
6691         }
6692 }
6693
6694 /*!
6695  * @brief 警告を放つアイテムを選択する /
6696  * Choose one of items that have warning flag
6697  * Calculate spell damages
6698  * @return 警告を行う
6699  */
6700 object_type *choose_warning_item(void)
6701 {
6702         int i;
6703         int choices[INVEN_TOTAL - INVEN_RARM];
6704         int number = 0;
6705
6706         /* Paranoia -- Player has no warning ability */
6707         if (!p_ptr->warning) return NULL;
6708
6709         /* Search Inventory */
6710         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6711         {
6712                 u32b flgs[TR_FLAG_SIZE];
6713                 object_type *o_ptr = &inventory[i];
6714
6715                 object_flags(o_ptr, flgs);
6716                 if (have_flag(flgs, TR_WARNING))
6717                 {
6718                         choices[number] = i;
6719                         number++;
6720                 }
6721         }
6722
6723         /* Choice one of them */
6724         return number ? &inventory[choices[randint0(number)]] : NULL;
6725 }
6726
6727 /*!
6728  * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する /
6729  * Calculate spell damages
6730  * @param m_ptr 魔法を行使するモンスターの構造体参照ポインタ
6731  * @param typ 効果属性のID
6732  * @param dam 基本ダメージ
6733  * @param max 算出した最大ダメージを返すポインタ
6734  * @return なし
6735  */
6736 static void spell_damcalc(monster_type *m_ptr, int typ, int dam, int *max)
6737 {
6738         monster_race *r_ptr = &r_info[m_ptr->r_idx];
6739         int          rlev = r_ptr->level;
6740         bool         ignore_wraith_form = FALSE;
6741
6742         /* Vulnerability, resistance and immunity */
6743         switch (typ)
6744         {
6745         case GF_ELEC:
6746                 if (p_ptr->immune_elec)
6747                 {
6748                         dam = 0;
6749                         ignore_wraith_form = TRUE;
6750                 }
6751                 else
6752                 {
6753                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6754                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6755                         if (prace_is_(RACE_ANDROID)) dam += dam / 3;
6756                         if (p_ptr->resist_elec) dam = (dam + 2) / 3;
6757                         if (IS_OPPOSE_ELEC())
6758                                 dam = (dam + 2) / 3;
6759                 }
6760                 break;
6761
6762         case GF_POIS:
6763                 if (p_ptr->resist_pois) dam = (dam + 2) / 3;
6764                 if (IS_OPPOSE_POIS()) dam = (dam + 2) / 3;
6765                 break;
6766
6767         case GF_ACID:
6768                 if (p_ptr->immune_acid)
6769                 {
6770                         dam = 0;
6771                         ignore_wraith_form = TRUE;
6772                 }
6773                 else
6774                 {
6775                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6776                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6777                         if (p_ptr->resist_acid) dam = (dam + 2) / 3;
6778                         if (IS_OPPOSE_ACID()) dam = (dam + 2) / 3;
6779                 }
6780                 break;
6781
6782         case GF_COLD:
6783         case GF_ICE:
6784                 if (p_ptr->immune_cold)
6785                 {
6786                         dam = 0;
6787                         ignore_wraith_form = TRUE;
6788                 }
6789                 else
6790                 {
6791                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6792                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6793                         if (p_ptr->resist_cold) dam = (dam + 2) / 3;
6794                         if (IS_OPPOSE_COLD()) dam = (dam + 2) / 3;
6795                 }
6796                 break;
6797
6798         case GF_FIRE:
6799                 if (p_ptr->immune_fire)
6800                 {
6801                         dam = 0;
6802                         ignore_wraith_form = TRUE;
6803                 }
6804                 else
6805                 {
6806                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6807                         if (prace_is_(RACE_ENT)) dam += dam / 3;
6808                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6809                         if (p_ptr->resist_fire) dam = (dam + 2) / 3;
6810                         if (IS_OPPOSE_FIRE()) dam = (dam + 2) / 3;
6811                 }
6812                 break;
6813
6814         case GF_PSY_SPEAR:
6815                 ignore_wraith_form = TRUE;
6816                 break;
6817
6818         case GF_ARROW:
6819                 if (!p_ptr->blind &&
6820                     ((inventory[INVEN_RARM].k_idx && (inventory[INVEN_RARM].name1 == ART_ZANTETSU)) ||
6821                      (inventory[INVEN_LARM].k_idx && (inventory[INVEN_LARM].name1 == ART_ZANTETSU))))
6822                 {
6823                         dam = 0;
6824                         ignore_wraith_form = TRUE;
6825                 }
6826                 break;
6827
6828         case GF_LITE:
6829                 if (p_ptr->resist_lite) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6830                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE)) dam *= 2;
6831                 else if (prace_is_(RACE_S_FAIRY)) dam = dam * 4 / 3;
6832
6833                 /*
6834                  * Cannot use "ignore_wraith_form" strictly (for "random one damage")
6835                  * "dam *= 2;" for later "dam /= 2"
6836                  */
6837                 if (p_ptr->wraith_form) dam *= 2;
6838                 break;
6839
6840         case GF_DARK:
6841                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE) || p_ptr->wraith_form)
6842                 {
6843                         dam = 0;
6844                         ignore_wraith_form = TRUE;
6845                 }
6846                 else if (p_ptr->resist_dark) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6847                 break;
6848
6849         case GF_SHARDS:
6850                 if (p_ptr->resist_shard) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6851                 break;
6852
6853         case GF_SOUND:
6854                 if (p_ptr->resist_sound) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6855                 break;
6856
6857         case GF_CONFUSION:
6858                 if (p_ptr->resist_conf) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6859                 break;
6860
6861         case GF_CHAOS:
6862                 if (p_ptr->resist_chaos) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6863                 break;
6864
6865         case GF_NETHER:
6866                 if (prace_is_(RACE_SPECTRE))
6867                 {
6868                         dam = 0;
6869                         ignore_wraith_form = TRUE;
6870                 }
6871                 else if (p_ptr->resist_neth) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6872                 break;
6873
6874         case GF_DISENCHANT:
6875                 if (p_ptr->resist_disen) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6876                 break;
6877
6878         case GF_NEXUS:
6879                 if (p_ptr->resist_nexus) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6880                 break;
6881
6882         case GF_TIME:
6883                 if (p_ptr->resist_time) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6884                 break;
6885
6886         case GF_GRAVITY:
6887                 if (p_ptr->levitation) dam = (dam * 2) / 3;
6888                 break;
6889
6890         case GF_ROCKET:
6891                 if (p_ptr->resist_shard) dam /= 2;
6892                 break;
6893
6894         case GF_NUKE:
6895                 if (p_ptr->resist_pois) dam = (2 * dam + 2) / 5;
6896                 if (IS_OPPOSE_POIS()) dam = (2 * dam + 2) / 5;
6897                 break;
6898
6899         case GF_DEATH_RAY:
6900                 if (p_ptr->mimic_form)
6901                 {
6902                         if (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_NONLIVING)
6903                         {
6904                                 dam = 0;
6905                                 ignore_wraith_form = TRUE;
6906                         }
6907                 }
6908                 else
6909                 {
6910                         switch (p_ptr->prace)
6911                         {
6912                         case RACE_GOLEM:
6913                         case RACE_SKELETON:
6914                         case RACE_ZOMBIE:
6915                         case RACE_VAMPIRE:
6916                         case RACE_DEMON:
6917                         case RACE_SPECTRE:
6918                                 dam = 0;
6919                                 ignore_wraith_form = TRUE;
6920                                 break;
6921                         }
6922                 }
6923                 break;
6924
6925         case GF_HOLY_FIRE:
6926                 if (p_ptr->align > 10) dam /= 2;
6927                 else if (p_ptr->align < -10) dam *= 2;
6928                 break;
6929
6930         case GF_HELL_FIRE:
6931                 if (p_ptr->align > 10) dam *= 2;
6932                 break;
6933
6934         case GF_MIND_BLAST:
6935         case GF_BRAIN_SMASH:
6936                 if (100 + rlev / 2 <= MAX(5, p_ptr->skill_sav))
6937                 {
6938                         dam = 0;
6939                         ignore_wraith_form = TRUE;
6940                 }
6941                 break;
6942
6943         case GF_CAUSE_1:
6944         case GF_CAUSE_2:
6945         case GF_CAUSE_3:
6946         case GF_HAND_DOOM:
6947                 if (100 + rlev / 2 <= p_ptr->skill_sav)
6948                 {
6949                         dam = 0;
6950                         ignore_wraith_form = TRUE;
6951                 }
6952                 break;
6953
6954         case GF_CAUSE_4:
6955                 if ((100 + rlev / 2 <= p_ptr->skill_sav) && (m_ptr->r_idx != MON_KENSHIROU))
6956                 {
6957                         dam = 0;
6958                         ignore_wraith_form = TRUE;
6959                 }
6960                 break;
6961         }
6962
6963         if (p_ptr->wraith_form && !ignore_wraith_form)
6964         {
6965                 dam /= 2;
6966                 if (!dam) dam = 1;
6967         }
6968
6969         if (dam > *max) *max = dam;
6970 }
6971
6972 /*!
6973 * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する。 /
6974 * Calculate spell damages
6975 * @param spell_num RF4ならRF4_SPELL_STARTのように32区切りのベースとなる数値
6976 * @param typ 効果属性のID
6977 * @param m_idx 魔法を行使するモンスターのID
6978 * @param max 算出した最大ダメージを返すポインタ
6979 * @return なし
6980 */
6981 void spell_damcalc_by_spellnum(int spell_num, int typ, int m_idx, int *max)
6982 {
6983     monster_type *m_ptr = &m_list[m_idx];
6984     int dam = monspell_damage((spell_num), m_idx, DAM_MAX);
6985     spell_damcalc(m_ptr, typ, dam, max);
6986 }
6987
6988 /*!
6989  * @brief 警告基準を定めるためにモンスターの打撃最大ダメージを算出する /
6990  * Calculate blow damages
6991  * @param m_ptr 打撃を行使するモンスターの構造体参照ポインタ
6992  * @param blow_ptr モンスターの打撃能力の構造体参照ポインタ
6993  * @return 算出された最大ダメージを返す。
6994  */
6995 static int blow_damcalc(monster_type *m_ptr, monster_blow *blow_ptr)
6996 {
6997         int  dam = blow_ptr->d_dice * blow_ptr->d_side;
6998         int  dummy_max = 0;
6999         bool check_wraith_form = TRUE;
7000
7001         if (blow_ptr->method != RBM_EXPLODE)
7002         {
7003                 int ac = p_ptr->ac + p_ptr->to_a;
7004
7005                 switch (blow_ptr->effect)
7006                 {
7007                 case RBE_SUPERHURT:
7008                 {
7009                         int tmp_dam = dam - (dam * ((ac < 150) ? ac : 150) / 250);
7010                         dam = MAX(dam, tmp_dam * 2);
7011                         break;
7012                 }
7013
7014                 case RBE_HURT:
7015                 case RBE_SHATTER:
7016                         dam -= (dam * ((ac < 150) ? ac : 150) / 250);
7017                         break;
7018
7019                 case RBE_ACID:
7020                         spell_damcalc(m_ptr, GF_ACID, dam, &dummy_max);
7021                         dam = dummy_max;
7022                         check_wraith_form = FALSE;
7023                         break;
7024
7025                 case RBE_ELEC:
7026                         spell_damcalc(m_ptr, GF_ELEC, dam, &dummy_max);
7027                         dam = dummy_max;
7028                         check_wraith_form = FALSE;
7029                         break;
7030
7031                 case RBE_FIRE:
7032                         spell_damcalc(m_ptr, GF_FIRE, dam, &dummy_max);
7033                         dam = dummy_max;
7034                         check_wraith_form = FALSE;
7035                         break;
7036
7037                 case RBE_COLD:
7038                         spell_damcalc(m_ptr, GF_COLD, dam, &dummy_max);
7039                         dam = dummy_max;
7040                         check_wraith_form = FALSE;
7041                         break;
7042
7043                 case RBE_DR_MANA:
7044                         dam = 0;
7045                         check_wraith_form = FALSE;
7046                         break;
7047                 }
7048
7049                 if (check_wraith_form && p_ptr->wraith_form)
7050                 {
7051                         dam /= 2;
7052                         if (!dam) dam = 1;
7053                 }
7054         }
7055         else
7056         {
7057                 dam = (dam + 1) / 2;
7058                 spell_damcalc(m_ptr, mbe_info[blow_ptr->effect].explode_type, dam, &dummy_max);
7059                 dam = dummy_max;
7060         }
7061
7062         return dam;
7063 }
7064
7065 /*!
7066  * @brief プレイヤーが特定地点へ移動した場合に警告を発する処理 /
7067  * Examine the grid (xx,yy) and warn the player if there are any danger
7068  * @param xx 危険性を調査するマスのX座標
7069  * @param yy 危険性を調査するマスのY座標
7070  * @return 警告を無視して進むことを選択するかか問題が無ければTRUE、警告に従ったならFALSEを返す。
7071  */
7072 bool process_warning(int xx, int yy)
7073 {
7074         int mx, my;
7075         cave_type *c_ptr;
7076         char o_name[MAX_NLEN];
7077
7078 #define WARNING_AWARE_RANGE 12
7079         int dam_max = 0;
7080         static int old_damage = 0;
7081
7082         for (mx = xx - WARNING_AWARE_RANGE; mx < xx + WARNING_AWARE_RANGE + 1; mx++)
7083         {
7084                 for (my = yy - WARNING_AWARE_RANGE; my < yy + WARNING_AWARE_RANGE + 1; my++)
7085                 {
7086                         int dam_max0 = 0;
7087                         monster_type *m_ptr;
7088                         monster_race *r_ptr;
7089
7090                         if (!in_bounds(my, mx) || (distance(my, mx, yy, xx) > WARNING_AWARE_RANGE)) continue;
7091
7092                         c_ptr = &cave[my][mx];
7093
7094                         if (!c_ptr->m_idx) continue;
7095
7096                         m_ptr = &m_list[c_ptr->m_idx];
7097
7098                         if (MON_CSLEEP(m_ptr)) continue;
7099                         if (!is_hostile(m_ptr)) continue;
7100
7101                         r_ptr = &r_info[m_ptr->r_idx];
7102
7103                         /* Monster spells (only powerful ones)*/
7104                         if (projectable(my, mx, yy, xx))
7105             {
7106                                 u32b f4 = r_ptr->flags4;
7107                                 u32b f5 = r_ptr->a_ability_flags1;
7108                                 u32b f6 = r_ptr->a_ability_flags2;
7109
7110                                 if (!(d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
7111                                 {
7112                     if (f4 & RF4_BA_CHAO) spell_damcalc_by_spellnum(MS_BALL_CHAOS, GF_CHAOS, c_ptr->m_idx,  &dam_max0);
7113                     if (f5 & RF5_BA_MANA) spell_damcalc_by_spellnum(MS_BALL_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7114                     if (f5 & RF5_BA_DARK) spell_damcalc_by_spellnum(MS_BALL_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7115                     if (f5 & RF5_BA_LITE) spell_damcalc_by_spellnum(MS_STARBURST, GF_LITE, c_ptr->m_idx, &dam_max0);
7116                     if (f6 & RF6_HAND_DOOM) spell_damcalc_by_spellnum(MS_HAND_DOOM, GF_HAND_DOOM, c_ptr->m_idx, &dam_max0);
7117                     if (f6 & RF6_PSY_SPEAR) spell_damcalc_by_spellnum(MS_PSY_SPEAR, GF_PSY_SPEAR, c_ptr->m_idx, &dam_max0);
7118                                 }
7119                 if (f4 & RF4_ROCKET) spell_damcalc_by_spellnum(MS_ROCKET, GF_ROCKET, c_ptr->m_idx, &dam_max0);
7120                 if (f4 & RF4_BR_ACID) spell_damcalc_by_spellnum(MS_BR_ACID, GF_ACID, c_ptr->m_idx, &dam_max0);
7121                 if (f4 & RF4_BR_ELEC) spell_damcalc_by_spellnum(MS_BR_ELEC, GF_ELEC, c_ptr->m_idx, &dam_max0);
7122                 if (f4 & RF4_BR_FIRE) spell_damcalc_by_spellnum(MS_BR_FIRE, GF_FIRE, c_ptr->m_idx, &dam_max0);
7123                 if (f4 & RF4_BR_COLD) spell_damcalc_by_spellnum(MS_BR_COLD, GF_COLD, c_ptr->m_idx, &dam_max0);
7124                 if (f4 & RF4_BR_POIS) spell_damcalc_by_spellnum(MS_BR_POIS, GF_POIS, c_ptr->m_idx, &dam_max0);
7125                 if (f4 & RF4_BR_NETH) spell_damcalc_by_spellnum(MS_BR_NETHER, GF_NETHER, c_ptr->m_idx, &dam_max0);
7126                 if (f4 & RF4_BR_LITE) spell_damcalc_by_spellnum(MS_BR_LITE, GF_LITE, c_ptr->m_idx, &dam_max0);
7127                 if (f4 & RF4_BR_DARK) spell_damcalc_by_spellnum(MS_BR_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7128                 if (f4 & RF4_BR_CONF) spell_damcalc_by_spellnum(MS_BR_CONF, GF_CONFUSION, c_ptr->m_idx, &dam_max0);
7129                 if (f4 & RF4_BR_SOUN) spell_damcalc_by_spellnum(MS_BR_SOUND, GF_SOUND, c_ptr->m_idx, &dam_max0);
7130                 if (f4 & RF4_BR_CHAO) spell_damcalc_by_spellnum(MS_BR_CHAOS, GF_CHAOS, c_ptr->m_idx, &dam_max0);
7131                 if (f4 & RF4_BR_DISE) spell_damcalc_by_spellnum(MS_BR_DISEN, GF_DISENCHANT, c_ptr->m_idx, &dam_max0);
7132                 if (f4 & RF4_BR_NEXU) spell_damcalc_by_spellnum(MS_BR_NEXUS, GF_NEXUS, c_ptr->m_idx, &dam_max0);
7133                 if (f4 & RF4_BR_TIME) spell_damcalc_by_spellnum(MS_BR_TIME, GF_TIME, c_ptr->m_idx, &dam_max0);
7134                 if (f4 & RF4_BR_INER) spell_damcalc_by_spellnum(MS_BR_INERTIA, GF_INERTIAL, c_ptr->m_idx, &dam_max0);
7135                 if (f4 & RF4_BR_GRAV) spell_damcalc_by_spellnum(MS_BR_GRAVITY, GF_GRAVITY, c_ptr->m_idx, &dam_max0);
7136                 if (f4 & RF4_BR_SHAR) spell_damcalc_by_spellnum(MS_BR_SHARDS, GF_SHARDS, c_ptr->m_idx, &dam_max0);
7137                 if (f4 & RF4_BR_PLAS) spell_damcalc_by_spellnum(MS_BR_PLASMA, GF_PLASMA, c_ptr->m_idx, &dam_max0);
7138                 if (f4 & RF4_BR_WALL) spell_damcalc_by_spellnum(MS_BR_FORCE, GF_FORCE, c_ptr->m_idx, &dam_max0);
7139                 if (f4 & RF4_BR_MANA) spell_damcalc_by_spellnum(MS_BR_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7140                 if (f4 & RF4_BR_NUKE) spell_damcalc_by_spellnum(MS_BR_NUKE, GF_NUKE, c_ptr->m_idx, &dam_max0);
7141                 if (f4 & RF4_BR_DISI) spell_damcalc_by_spellnum(MS_BR_DISI, GF_DISINTEGRATE, c_ptr->m_idx, &dam_max0);
7142                         }
7143
7144                         /* Monster melee attacks */
7145                         if (!(r_ptr->flags1 & RF1_NEVER_BLOW) && !(d_info[dungeon_type].flags1 & DF1_NO_MELEE))
7146                         {
7147                                 if (mx <= xx + 1 && mx >= xx - 1 && my <= yy + 1 && my >= yy - 1)
7148                                 {
7149                                         int m;
7150                                         int dam_melee = 0;
7151                                         for (m = 0; m < 4; m++)
7152                                         {
7153                                                 /* Skip non-attacks */
7154                                                 if (!r_ptr->blow[m].method || (r_ptr->blow[m].method == RBM_SHOOT)) continue;
7155
7156                                                 /* Extract the attack info */
7157                                                 dam_melee += blow_damcalc(m_ptr, &r_ptr->blow[m]);
7158                                                 if (r_ptr->blow[m].method == RBM_EXPLODE) break;
7159                                         }
7160                                         if (dam_melee > dam_max0) dam_max0 = dam_melee;
7161                                 }
7162                         }
7163
7164                         /* Contribution from this monster */
7165                         dam_max += dam_max0;
7166                 }
7167         }
7168
7169         /* Prevent excessive warning */
7170         if (dam_max > old_damage)
7171         {
7172                 old_damage = dam_max * 3 / 2;
7173
7174                 if (dam_max > p_ptr->chp / 2)
7175                 {
7176                         object_type *o_ptr = choose_warning_item();
7177
7178                         if (o_ptr)
7179                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7180             else
7181                 strcpy(o_name, _("体", "body")); /* Warning ability without item */
7182             msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7183
7184                         disturb(0, 1);
7185             return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7186                 }
7187         }
7188         else old_damage = old_damage / 2;
7189
7190         c_ptr = &cave[yy][xx];
7191         if (((!easy_disarm && is_trap(c_ptr->feat))
7192             || (c_ptr->mimic && is_trap(c_ptr->feat))) && !one_in_(13))
7193         {
7194                 object_type *o_ptr = choose_warning_item();
7195
7196                 if (o_ptr)
7197             object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7198         else
7199             strcpy(o_name, _("体", "body")); /* Warning ability without item */
7200         msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7201                 disturb(0, 1);
7202         return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7203         }
7204
7205         return TRUE;
7206 }
7207
7208 /*!
7209  * @brief エッセンスの付加可能な武器や矢弾かを返す
7210  * @param o_ptr チェックしたいオブジェクトの構造体参照ポインタ
7211  * @return エッセンスの付加可能な武器か矢弾ならばTRUEを返す。
7212  */
7213 static bool item_tester_hook_melee_ammo(object_type *o_ptr)
7214 {
7215         switch (o_ptr->tval)
7216         {
7217                 case TV_HAFTED:
7218                 case TV_POLEARM:
7219                 case TV_DIGGING:
7220                 case TV_BOLT:
7221                 case TV_ARROW:
7222                 case TV_SHOT:
7223                 {
7224                         return (TRUE);
7225                 }
7226                 case TV_SWORD:
7227                 {
7228                         if (o_ptr->sval != SV_DOKUBARI) return (TRUE);
7229                 }
7230         }
7231
7232         return (FALSE);
7233 }
7234
7235
7236 /*!
7237  * エッセンス情報の構造体 / A structure for smithing
7238  */
7239 typedef struct {
7240         int add;       /* TR flag number or special essence id */
7241         cptr add_name; /* Name of this ability */
7242         int type;      /* Menu number */
7243         int essence;   /* Index for carrying essences */
7244         int value;     /* Needed value to add this ability */
7245 } essence_type;
7246
7247
7248 /*!
7249  * エッセンス情報テーブル Smithing type data for Weapon smith
7250  */
7251 #ifdef JP
7252 static essence_type essence_info[] =
7253 {
7254         {TR_STR, "腕力", 4, TR_STR, 20},
7255         {TR_INT, "知能", 4, TR_INT, 20},
7256         {TR_WIS, "賢さ", 4, TR_WIS, 20},
7257         {TR_DEX, "器用さ", 4, TR_DEX, 20},
7258         {TR_CON, "耐久力", 4, TR_CON, 20},
7259         {TR_CHR, "魅力", 4, TR_CHR, 20},
7260         {TR_MAGIC_MASTERY, "魔力支配", 4, TR_MAGIC_MASTERY, 20},
7261         {TR_STEALTH, "隠密", 4, TR_STEALTH, 40},
7262         {TR_SEARCH, "探索", 4, TR_SEARCH, 15},
7263         {TR_INFRA, "赤外線視力", 4, TR_INFRA, 15},
7264         {TR_TUNNEL, "採掘", 4, TR_TUNNEL, 15},
7265         {TR_SPEED, "スピード", 4, TR_SPEED, 12},
7266         {TR_BLOWS, "追加攻撃", 1, TR_BLOWS, 20},
7267         {TR_CHAOTIC, "カオス攻撃", 1, TR_CHAOTIC, 15},
7268         {TR_VAMPIRIC, "吸血攻撃", 1, TR_VAMPIRIC, 60},
7269         {TR_IMPACT, "地震発動", 7, TR_IMPACT, 15},
7270         {TR_BRAND_POIS, "毒殺", 1, TR_BRAND_POIS, 20},
7271         {TR_BRAND_ACID, "溶解", 1, TR_BRAND_ACID, 20},
7272         {TR_BRAND_ELEC, "電撃", 1, TR_BRAND_ELEC, 20},
7273         {TR_BRAND_FIRE, "焼棄", 1, TR_BRAND_FIRE, 20},
7274         {TR_BRAND_COLD, "凍結", 1, TR_BRAND_COLD, 20},
7275         {TR_SUST_STR, "腕力維持", 3, TR_SUST_STR, 15},
7276         {TR_SUST_INT, "知能維持", 3, TR_SUST_STR, 15},
7277         {TR_SUST_WIS, "賢さ維持", 3, TR_SUST_STR, 15},
7278         {TR_SUST_DEX, "器用さ維持", 3, TR_SUST_STR, 15},
7279         {TR_SUST_CON, "耐久力維持", 3, TR_SUST_STR, 15},
7280         {TR_SUST_CHR, "魅力維持", 3, TR_SUST_STR, 15},
7281         {TR_IM_ACID, "酸免疫", 2, TR_IM_ACID, 20},
7282         {TR_IM_ELEC, "電撃免疫", 2, TR_IM_ACID, 20},
7283         {TR_IM_FIRE, "火炎免疫", 2, TR_IM_ACID, 20},
7284         {TR_IM_COLD, "冷気免疫", 2, TR_IM_ACID, 20},
7285         {TR_REFLECT, "反射", 2, TR_REFLECT, 20},
7286         {TR_FREE_ACT, "麻痺知らず", 3, TR_FREE_ACT, 20},
7287         {TR_HOLD_EXP, "経験値維持", 3, TR_HOLD_EXP, 20},
7288         {TR_RES_ACID, "耐酸", 2, TR_RES_ACID, 15},
7289         {TR_RES_ELEC, "耐電撃", 2, TR_RES_ELEC, 15},
7290         {TR_RES_FIRE, "耐火炎", 2, TR_RES_FIRE, 15},
7291         {TR_RES_COLD, "耐冷気", 2, TR_RES_COLD, 15},
7292         {TR_RES_POIS, "耐毒", 2, TR_RES_POIS, 25},
7293         {TR_RES_FEAR, "耐恐怖", 2, TR_RES_FEAR, 20},
7294         {TR_RES_LITE, "耐閃光", 2, TR_RES_LITE, 20},
7295         {TR_RES_DARK, "耐暗黒", 2, TR_RES_DARK, 20},
7296         {TR_RES_BLIND, "耐盲目", 2, TR_RES_BLIND, 20},
7297         {TR_RES_CONF, "耐混乱", 2, TR_RES_CONF, 20},
7298         {TR_RES_SOUND, "耐轟音", 2, TR_RES_SOUND, 20},
7299         {TR_RES_SHARDS, "耐破片", 2, TR_RES_SHARDS, 20},
7300         {TR_RES_NETHER, "耐地獄", 2, TR_RES_NETHER, 20},
7301         {TR_RES_NEXUS, "耐因果混乱", 2, TR_RES_NEXUS, 20},
7302         {TR_RES_CHAOS, "耐カオス", 2, TR_RES_CHAOS, 20},
7303         {TR_RES_DISEN, "耐劣化", 2, TR_RES_DISEN, 20},
7304         {TR_SH_FIRE, "", 0, -2, 0},
7305         {TR_SH_ELEC, "", 0, -2, 0},
7306         {TR_SH_COLD, "", 0, -2, 0},
7307         {TR_NO_MAGIC, "反魔法", 3, TR_NO_MAGIC, 15},
7308         {TR_WARNING, "警告", 3, TR_WARNING, 20},
7309         {TR_LEVITATION, "浮遊", 3, TR_LEVITATION, 20},
7310         {TR_LITE_1, "永久光源", 3, TR_LITE_1, 15},
7311         {TR_LITE_2, "", 0, -2, 0},
7312         {TR_LITE_3, "", 0, -2, 0},
7313         {TR_SEE_INVIS, "可視透明", 3, TR_SEE_INVIS, 20},
7314         {TR_TELEPATHY, "テレパシー", 6, TR_TELEPATHY, 15},
7315         {TR_SLOW_DIGEST, "遅消化", 3, TR_SLOW_DIGEST, 15},
7316         {TR_REGEN, "急速回復", 3, TR_REGEN, 20},
7317         {TR_TELEPORT, "テレポート", 3, TR_TELEPORT, 25},
7318
7319         {TR_SLAY_EVIL, "邪悪倍打", 5, TR_SLAY_EVIL, 100},
7320         {TR_KILL_EVIL, "邪悪倍倍打", 0, TR_SLAY_EVIL, 60},
7321         {TR_SLAY_ANIMAL, "動物倍打", 5, TR_SLAY_ANIMAL, 20},
7322         {TR_KILL_ANIMAL, "動物倍倍打", 5, TR_SLAY_ANIMAL, 60},
7323         {TR_SLAY_UNDEAD, "不死倍打", 5, TR_SLAY_UNDEAD, 20},
7324         {TR_KILL_UNDEAD, "不死倍倍打", 5, TR_SLAY_UNDEAD, 60},
7325         {TR_SLAY_DEMON, "悪魔倍打", 5, TR_SLAY_DEMON, 20},
7326         {TR_KILL_DEMON, "悪魔倍倍打", 5, TR_SLAY_DEMON, 60},
7327         {TR_SLAY_ORC, "オーク倍打", 5, TR_SLAY_ORC, 15},
7328         {TR_KILL_ORC, "オーク倍倍打", 5, TR_SLAY_ORC, 60},
7329         {TR_SLAY_TROLL, "トロル倍打", 5, TR_SLAY_TROLL, 15},
7330         {TR_KILL_TROLL, "トロル倍倍打", 5, TR_SLAY_TROLL, 60},
7331         {TR_SLAY_GIANT, "巨人倍打", 5, TR_SLAY_GIANT, 20},
7332         {TR_KILL_GIANT, "巨人倍倍打", 5, TR_SLAY_GIANT, 60},
7333         {TR_SLAY_DRAGON, "竜倍打", 5, TR_SLAY_DRAGON, 20},
7334         {TR_KILL_DRAGON, "竜倍倍打", 5, TR_SLAY_DRAGON, 60},
7335         {TR_SLAY_HUMAN, "人間倍打", 5, TR_SLAY_HUMAN, 20},
7336         {TR_KILL_HUMAN, "人間倍倍打", 5, TR_SLAY_HUMAN, 60},
7337
7338         {TR_ESP_ANIMAL, "動物ESP", 6, TR_SLAY_ANIMAL, 40},
7339         {TR_ESP_UNDEAD, "不死ESP", 6, TR_SLAY_UNDEAD, 40},
7340         {TR_ESP_DEMON, "悪魔ESP", 6, TR_SLAY_DEMON, 40},
7341         {TR_ESP_ORC, "オークESP", 6, TR_SLAY_ORC, 40},
7342         {TR_ESP_TROLL, "トロルESP", 6, TR_SLAY_TROLL, 40},
7343         {TR_ESP_GIANT, "巨人ESP", 6, TR_SLAY_GIANT, 40},
7344         {TR_ESP_DRAGON, "竜ESP", 6, TR_SLAY_DRAGON, 40},
7345         {TR_ESP_HUMAN, "人間ESP", 6, TR_SLAY_HUMAN, 40},
7346
7347         {ESSENCE_ATTACK, "攻撃", 10, TR_ES_ATTACK, 30},
7348         {ESSENCE_AC, "防御", 10, TR_ES_AC, 15},
7349         {ESSENCE_TMP_RES_ACID, "酸耐性発動", 7, TR_RES_ACID, 50},
7350         {ESSENCE_TMP_RES_ELEC, "電撃耐性発動", 7, TR_RES_ELEC, 50},
7351         {ESSENCE_TMP_RES_FIRE, "火炎耐性発動", 7, TR_RES_FIRE, 50},
7352         {ESSENCE_TMP_RES_COLD, "冷気耐性発動", 7, TR_RES_COLD, 50},
7353         {ESSENCE_SH_FIRE, "火炎オーラ", 7, -1, 50},
7354         {ESSENCE_SH_ELEC, "電撃オーラ", 7, -1, 50},
7355         {ESSENCE_SH_COLD, "冷気オーラ", 7, -1, 50},
7356         {ESSENCE_RESISTANCE, "全耐性", 2, -1, 150},
7357         {ESSENCE_SUSTAIN, "装備保持", 10, -1, 10},
7358         {ESSENCE_SLAY_GLOVE, "殺戮の小手", 1, TR_ES_ATTACK, 200},
7359
7360         {-1, NULL, 0, -1, 0}
7361 };
7362 #else
7363 static essence_type essence_info[] =
7364 {
7365         {TR_STR, "strength", 4, TR_STR, 20},
7366         {TR_INT, "intelligence", 4, TR_INT, 20},
7367         {TR_WIS, "wisdom", 4, TR_WIS, 20},
7368         {TR_DEX, "dexterity", 4, TR_DEX, 20},
7369         {TR_CON, "constitution", 4, TR_CON, 20},
7370         {TR_CHR, "charisma", 4, TR_CHR, 20},
7371         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
7372         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
7373         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
7374         {TR_INFRA, "infravision", 4, TR_INFRA, 15},
7375         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
7376         {TR_SPEED, "speed", 4, TR_SPEED, 12},
7377         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
7378         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
7379         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
7380         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
7381         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
7382         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
7383         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
7384         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
7385         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
7386         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
7387         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
7388         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
7389         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
7390         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
7391         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
7392         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
7393         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
7394         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
7395         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
7396         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
7397         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
7398         {TR_HOLD_EXP, "hold experience", 3, TR_HOLD_EXP, 20},
7399         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
7400         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
7401         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
7402         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
7403         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
7404         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
7405         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
7406         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
7407         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
7408         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
7409         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
7410         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
7411         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
7412         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
7413         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
7414         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
7415         {TR_SH_FIRE, "", 0, -2, 0},
7416         {TR_SH_ELEC, "", 0, -2, 0},
7417         {TR_SH_COLD, "", 0, -2, 0},
7418         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
7419         {TR_WARNING, "warning", 3, TR_WARNING, 20},
7420         {TR_LEVITATION, "levitation", 3, TR_LEVITATION, 20},
7421         {TR_LITE_1, "permanent light", 3, TR_LITE_1, 15},
7422         {TR_LITE_2, "", 0, -2, 0},
7423         {TR_LITE_3, "", 0, -2, 0},
7424         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
7425         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
7426         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
7427         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
7428         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
7429
7430         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
7431         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
7432         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
7433         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
7434         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
7435         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
7436         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
7437         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
7438         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
7439         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
7440         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
7441         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
7442         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
7443         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
7444         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
7445         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
7446         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
7447         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
7448
7449         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
7450         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
7451         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
7452         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
7453         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
7454         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
7455         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
7456         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
7457
7458         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
7459         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
7460         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
7461         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
7462         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
7463         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
7464         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
7465         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
7466         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
7467         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
7468         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
7469         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
7470
7471         {-1, NULL, 0, -1, 0}
7472 };
7473 #endif
7474
7475
7476 /*!
7477  * エッセンス名テーブル / Essense names for Weapon smith
7478  */
7479 #ifdef JP
7480 cptr essence_name[] =
7481 {
7482         "腕力",
7483         "知能",
7484         "賢さ",
7485         "器用さ",
7486         "耐久力",
7487         "魅力",
7488         "魔力支配",
7489         "",
7490         "隠密",
7491         "探索",
7492         "赤外線視力",
7493         "採掘",
7494         "スピード",
7495         "追加攻撃",
7496         "カオス攻撃",
7497         "吸血攻撃",
7498         "動物倍打",
7499         "邪悪倍打",
7500         "不死倍打",
7501         "悪魔倍打",
7502         "オーク倍打",
7503         "トロル倍打",
7504         "巨人倍打",
7505         "竜倍打",
7506         "",
7507         "",
7508         "地震",
7509         "毒殺",
7510         "溶解",
7511         "電撃",
7512         "焼棄",
7513         "凍結",
7514         "能力維持",
7515         "",
7516         "",
7517         "",
7518         "",
7519         "",
7520         "",
7521         "",
7522         "免疫",
7523         "",
7524         "",
7525         "",
7526         "",
7527         "反射",
7528         "麻痺知らず",
7529         "経験値維持",
7530         "耐酸",
7531         "耐電撃",
7532         "耐火炎",
7533         "耐冷気",
7534         "耐毒",
7535         "耐恐怖",
7536         "耐閃光",
7537         "耐暗黒",
7538         "耐盲目",
7539         "耐混乱",
7540         "耐轟音",
7541         "耐破片",
7542         "耐地獄",
7543         "耐因果混乱",
7544         "耐カオス",
7545         "耐劣化",
7546         "",
7547         "",
7548         "人間倍打",
7549         "",
7550         "",
7551         "反魔法",
7552         "",
7553         "",
7554         "警告",
7555         "",
7556         "",
7557         "",
7558         "浮遊",
7559         "永久光源",
7560         "可視透明",
7561         "テレパシー",
7562         "遅消化",
7563         "急速回復",
7564         "",
7565         "",
7566         "",
7567         "",
7568         "",
7569         "",
7570         "",
7571         "",
7572         "テレポート",
7573         "",
7574         "",
7575         "攻撃",
7576         "防御",
7577
7578         NULL
7579 };
7580
7581 #else
7582
7583 cptr essence_name[] =
7584 {
7585         "strength",
7586         "intelligen.",
7587         "wisdom",
7588         "dexterity",
7589         "constitut.",
7590         "charisma",
7591         "magic mast.",
7592         "",
7593         "stealth",
7594         "serching",
7595         "infravision",
7596         "digging",
7597         "speed",
7598         "extra atk",
7599         "chaos brand",
7600         "vampiric",
7601         "slay animal",
7602         "slay evil",
7603         "slay undead",
7604         "slay demon",
7605         "slay orc",
7606         "slay troll",
7607         "slay giant",
7608         "slay dragon",
7609         "",
7610         "",
7611         "quake",
7612         "pois. brand",
7613         "acid brand",
7614         "elec. brand",
7615         "fire brand",
7616         "cold brand",
7617         "sustain",
7618         "",
7619         "",
7620         "",
7621         "",
7622         "",
7623         "",
7624         "",
7625         "immunity",
7626         "",
7627         "",
7628         "",
7629         "",
7630         "reflection",
7631         "free action",
7632         "hold exp",
7633         "res. acid",
7634         "res. elec.",
7635         "res. fire",
7636         "res. cold",
7637         "res. poison",
7638         "res. fear",
7639         "res. light",
7640         "res. dark",
7641         "res. blind",
7642         "res.confuse",
7643         "res. sound",
7644         "res. shard",
7645         "res. nether",
7646         "res. nexus",
7647         "res. chaos",
7648         "res. disen.",
7649         "",
7650         "",
7651         "slay human",
7652         "",
7653         "",
7654         "anti magic",
7655         "",
7656         "",
7657         "warning",
7658         "",
7659         "",
7660         "",
7661         "levitation",
7662         "perm. light",
7663         "see invis.",
7664         "telepathy",
7665         "slow dige.",
7666         "regen.",
7667         "",
7668         "",
7669         "",
7670         "",
7671         "",
7672         "",
7673         "",
7674         "",
7675         "teleport",
7676         "",
7677         "",
7678         "weapon enc.",
7679         "armor enc.",
7680
7681         NULL
7682 };
7683 #endif
7684
7685 /*!
7686  * @brief 所持しているエッセンス一覧を表示する
7687  * @return なし
7688  */
7689 static void display_essence(void)
7690 {
7691         int i, num = 0;
7692
7693         screen_save();
7694         for (i = 1; i < 22; i++)
7695         {
7696                 prt("",i,0);
7697         }
7698         prt(_("エッセンス   個数     エッセンス   個数     エッセンス   個数",
7699                   "Essence      Num      Essence      Num      Essence      Num "), 1, 8);
7700         for (i = 0; essence_name[i]; i++)
7701         {
7702                 if (!essence_name[i][0]) continue;
7703                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
7704                 num++;
7705         }
7706         prt(_("現在所持しているエッセンス", "List of all essences you have."), 0, 0);
7707         (void)inkey();
7708         screen_load();
7709         return;
7710 }
7711
7712 /*!
7713  * @brief エッセンスの抽出処理
7714  * @return なし
7715  */
7716 static void drain_essence(void)
7717 {
7718         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
7719         int i, item;
7720         int dec = 4;
7721         bool observe = FALSE;
7722         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2, old_timeout;
7723         u32b old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7724         object_type *o_ptr;
7725         cptr            q, s;
7726         byte iy, ix, marked, number;
7727         s16b next_o_idx, weight;
7728
7729         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7730                 drain_value[i] = 0;
7731
7732         item_tester_hook = object_is_weapon_armour_ammo;
7733         item_tester_no_ryoute = TRUE;
7734
7735         /* Get an item */
7736         q = _("どのアイテムから抽出しますか？", "Extract from which item? ");
7737         s = _("抽出できるアイテムがありません。", "You have nothing you can extract from.");
7738
7739         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7740
7741         /* Get the item (in the pack) */
7742         if (item >= 0)
7743         {
7744                 o_ptr = &inventory[item];
7745         }
7746
7747         /* Get the item (on the floor) */
7748         else
7749         {
7750                 o_ptr = &o_list[0 - item];
7751         }
7752
7753         if (object_is_known(o_ptr) && !object_is_nameless(o_ptr))
7754         {
7755                 char o_name[MAX_NLEN];
7756                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7757                 if (!get_check(format(_("本当に%sから抽出してよろしいですか？", "Really extract from %s? "), o_name))) return;
7758         }
7759
7760         p_ptr->energy_use = 100;
7761
7762         object_flags(o_ptr, old_flgs);
7763         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7764         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7765         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7766         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7767         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7768         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7769         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7770         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7771         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7772
7773         old_to_a = o_ptr->to_a;
7774         old_ac = o_ptr->ac;
7775         old_to_h = o_ptr->to_h;
7776         old_to_d = o_ptr->to_d;
7777         old_ds = o_ptr->ds;
7778         old_dd = o_ptr->dd;
7779         old_pval = o_ptr->pval;
7780         old_name2 = o_ptr->name2;
7781         old_timeout = o_ptr->timeout;
7782         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7783         if (have_flag(old_flgs, TR_ADD_L_CURSE)) dec--;
7784         if (have_flag(old_flgs, TR_ADD_H_CURSE)) dec--;
7785         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7786         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7787         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7788         if (have_flag(old_flgs, TR_DRAIN_HP)) dec--;
7789         if (have_flag(old_flgs, TR_DRAIN_MANA)) dec--;
7790         if (have_flag(old_flgs, TR_CALL_ANIMAL)) dec--;
7791         if (have_flag(old_flgs, TR_CALL_DEMON)) dec--;
7792         if (have_flag(old_flgs, TR_CALL_DRAGON)) dec--;
7793         if (have_flag(old_flgs, TR_CALL_UNDEAD)) dec--;
7794         if (have_flag(old_flgs, TR_COWARDICE)) dec--;
7795         if (have_flag(old_flgs, TR_LOW_MELEE)) dec--;
7796         if (have_flag(old_flgs, TR_LOW_AC)) dec--;
7797         if (have_flag(old_flgs, TR_LOW_MAGIC)) dec--;
7798         if (have_flag(old_flgs, TR_FAST_DIGEST)) dec--;
7799         if (have_flag(old_flgs, TR_SLOW_REGEN)) dec--;
7800         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7801
7802         iy = o_ptr->iy;
7803         ix = o_ptr->ix;
7804         next_o_idx = o_ptr->next_o_idx;
7805         marked = o_ptr->marked;
7806         weight = o_ptr->weight;
7807         number = o_ptr->number;
7808
7809         object_prep(o_ptr, o_ptr->k_idx);
7810
7811         o_ptr->iy=iy;
7812         o_ptr->ix=ix;
7813         o_ptr->next_o_idx=next_o_idx;
7814         o_ptr->marked=marked;
7815         o_ptr->number = number;
7816         if (o_ptr->tval == TV_DRAG_ARMOR) o_ptr->timeout = old_timeout;
7817         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7818         o_ptr->ident |= (IDENT_MENTAL);
7819         object_aware(o_ptr);
7820         object_known(o_ptr);
7821
7822         object_flags(o_ptr, new_flgs);
7823
7824         for (i = 0; essence_info[i].add_name; i++)
7825         {
7826                 essence_type *es_ptr = &essence_info[i];
7827                 int pval = 0;
7828
7829                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7830                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7831
7832                 if (es_ptr->add < TR_FLAG_MAX &&
7833                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7834                     have_flag(old_flgs, es_ptr->add))
7835                 {
7836                         if (pval)
7837                         {
7838                                 drain_value[es_ptr->essence] += 10 * pval;
7839                         }
7840                         else if (es_ptr->essence != -2)
7841                         {
7842                                 drain_value[es_ptr->essence] += 10;
7843                         }
7844                         else if (es_ptr->add == TR_SH_FIRE)
7845                         {
7846                                 drain_value[TR_BRAND_FIRE] += 10;
7847                                 drain_value[TR_RES_FIRE] += 10;
7848                         }
7849                         else if (es_ptr->add == TR_SH_ELEC)
7850                         {
7851                                 drain_value[TR_BRAND_ELEC] += 10;
7852                                 drain_value[TR_RES_ELEC] += 10;
7853                         }
7854                         else if (es_ptr->add == TR_SH_COLD)
7855                         {
7856                                 drain_value[TR_BRAND_COLD] += 10;
7857                                 drain_value[TR_RES_COLD] += 10;
7858                         }
7859                         else if (es_ptr->add == TR_LITE_2)
7860                         {
7861                                 drain_value[TR_LITE_1] += 20;
7862                         }
7863                         else if (es_ptr->add == TR_LITE_3)
7864                         {
7865                                 drain_value[TR_LITE_1] += 30;
7866                         }
7867                 }
7868         }
7869
7870         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7871         {
7872                 drain_value[TR_INT] += 5;
7873                 drain_value[TR_WIS] += 5;
7874         }
7875         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7876         {
7877                 drain_value[TR_BRAND_POIS] += 5;
7878                 drain_value[TR_BRAND_ACID] += 5;
7879                 drain_value[TR_BRAND_ELEC] += 5;
7880                 drain_value[TR_BRAND_FIRE] += 5;
7881                 drain_value[TR_BRAND_COLD] += 5;
7882         }
7883         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7884         {
7885                 drain_value[TR_INT] += 10;
7886         }
7887         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7888         {
7889                 drain_value[TR_STR] += 10;
7890         }
7891         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7892         {
7893                 drain_value[TR_DEX] += 10;
7894         }
7895         if (old_name2 == EGO_2WEAPON)
7896         {
7897                 drain_value[TR_DEX] += 20;
7898         }
7899         if (object_is_weapon_ammo(o_ptr))
7900         {
7901                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7902
7903                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7904         }
7905         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7906         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7907         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7908         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7909
7910         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7911         {
7912                 drain_value[i] *= number;
7913                 drain_value[i] = drain_value[i] * dec / 4;
7914                 drain_value[i] = MAX(drain_value[i], 0);
7915                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7916                 if (drain_value[i])
7917                 {
7918                         observe = TRUE;
7919                 }
7920         }
7921         if (!observe)
7922         {
7923                 msg_print(_("エッセンスは抽出できませんでした。", "You were not able to extract any essence."));
7924         }
7925         else
7926         {
7927                 msg_print(_("抽出したエッセンス:", "Extracted essences:"));
7928
7929                 for (i = 0; essence_name[i]; i++)
7930                 {
7931                         if (!essence_name[i][0]) continue;
7932                         if (!drain_value[i]) continue;
7933
7934                         p_ptr->magic_num1[i] += drain_value[i];
7935                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7936                         msg_print(NULL);
7937                         msg_format("%s...%d%s", essence_name[i], drain_value[i], _("。", ". "));
7938                 }
7939         }
7940
7941         /* Apply autodestroy/inscription to the drained item */
7942         autopick_alter_item(item, TRUE);
7943
7944         /* Combine the pack */
7945         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7946
7947         /* Window stuff */
7948         p_ptr->window |= (PW_INVEN);
7949 }
7950
7951 /*!
7952  * @brief 付加するエッセンスの大別を選択する
7953  * @return 選んだエッセンスの大別ID
7954  */
7955 static int choose_essence(void)
7956 {
7957         int mode = 0;
7958         char choice;
7959         int menu_line = (use_menu ? 1 : 0);
7960
7961 #ifdef JP
7962         cptr menu_name[] = {
7963                 "武器属性",
7964                 "耐性",
7965                 "能力",
7966                 "数値",
7967                 "スレイ",
7968                 "ESP",
7969                 "その他"
7970         };
7971 #else
7972         cptr menu_name[] = {
7973                 "Brand weapon",
7974                 "Resistance",
7975                 "Ability",
7976                 "Magic number",
7977                 "Slay",
7978                 "ESP",
7979                 "Others"
7980         };
7981 #endif
7982         const int mode_max = 7;
7983
7984 #ifdef ALLOW_REPEAT
7985         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
7986                 return mode;
7987         mode = 0;
7988 #endif /* ALLOW_REPEAT */
7989
7990         if (use_menu)
7991         {
7992                 screen_save();
7993
7994                 while(!mode)
7995                 {
7996                         int i;
7997                         for (i = 0; i < mode_max; i++)
7998 #ifdef JP
7999                                 prt(format(" %s %s", (menu_line == 1+i) ? "》" : "  ", menu_name[i]), 2 + i, 14);
8000                         prt("どの種類のエッセンス付加を行いますか？", 0, 0);
8001 #else
8002                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
8003                         prt("Choose from menu.", 0, 0);
8004 #endif
8005
8006                         choice = inkey();
8007                         switch(choice)
8008                         {
8009                         case ESCAPE:
8010                         case 'z':
8011                         case 'Z':
8012                                 screen_load();
8013                                 return 0;
8014                         case '2':
8015                         case 'j':
8016                         case 'J':
8017                                 menu_line++;
8018                                 break;
8019                         case '8':
8020                         case 'k':
8021                         case 'K':
8022                                 menu_line += mode_max - 1;
8023                                 break;
8024                         case '\r':
8025                         case '\n':
8026                         case 'x':
8027                         case 'X':
8028                                 mode = menu_line;
8029                                 break;
8030                         }
8031                         if (menu_line > mode_max) menu_line -= mode_max;
8032                 }
8033                 screen_load();
8034         }
8035         else
8036         {
8037                 screen_save();
8038                 while (!mode)
8039                 {
8040                         int i;
8041
8042                         for (i = 0; i < mode_max; i++)
8043                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
8044
8045                         if (!get_com(_("何を付加しますか:", "Command :"), &choice, TRUE))
8046                         {
8047                                 screen_load();
8048                                 return 0;
8049                         }
8050
8051                         if (isupper(choice)) choice = tolower(choice);
8052
8053                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
8054                                 mode = (int)choice - 'a' + 1;
8055                 }
8056                 screen_load();
8057         }
8058
8059 #ifdef ALLOW_REPEAT
8060         repeat_push(mode);
8061 #endif /* ALLOW_REPEAT */
8062         return mode;
8063 }
8064
8065 /*!
8066  * @brief エッセンスを実際に付加する
8067  * @param mode エッセンスの大別ID
8068  * @return なし
8069  */
8070 static void add_essence(int mode)
8071 {
8072         int item, max_num = 0;
8073         int i;
8074         bool flag,redraw;
8075         char choice;
8076         cptr            q, s;
8077         object_type *o_ptr;
8078         int ask = TRUE;
8079         char out_val[160];
8080         int num[22];
8081         char o_name[MAX_NLEN];
8082         int use_essence;
8083         essence_type *es_ptr;
8084
8085         int menu_line = (use_menu ? 1 : 0);
8086
8087         for (i = 0; essence_info[i].add_name; i++)
8088         {
8089                 es_ptr = &essence_info[i];
8090
8091                 if (es_ptr->type != mode) continue;
8092                 num[max_num++] = i;
8093         }
8094
8095 #ifdef ALLOW_REPEAT
8096         if (!repeat_pull(&i) || i<0 || i>=max_num)
8097         {
8098 #endif /* ALLOW_REPEAT */
8099
8100
8101         /* Nothing chosen yet */
8102         flag = FALSE;
8103
8104         /* No redraw yet */
8105         redraw = FALSE;
8106
8107         /* Build a prompt */
8108         (void) strnfmt(out_val, 78, _("('*'で一覧, ESCで中断) どの能力を付加しますか？", "(*=List, ESC=exit) Add which ability? "));
8109         if (use_menu) screen_save();
8110
8111         /* Get a spell from the user */
8112
8113         choice = (always_show_list || use_menu) ? ESCAPE:1;
8114         while (!flag)
8115         {
8116                 bool able[22];
8117                 if( choice==ESCAPE ) choice = ' ';
8118                 else if( !get_com(out_val, &choice, FALSE) )break;
8119
8120                 if (use_menu && choice != ' ')
8121                 {
8122                         switch(choice)
8123                         {
8124                                 case '0':
8125                                 {
8126                                         screen_load();
8127                                         return;
8128                                 }
8129
8130                                 case '8':
8131                                 case 'k':
8132                                 case 'K':
8133                                 {
8134                                         menu_line += (max_num-1);
8135                                         break;
8136                                 }
8137
8138                                 case '2':
8139                                 case 'j':
8140                                 case 'J':
8141                                 {
8142                                         menu_line++;
8143                                         break;
8144                                 }
8145
8146                                 case '4':
8147                                 case 'h':
8148                                 case 'H':
8149                                 {
8150                                         menu_line = 1;
8151                                         break;
8152                                 }
8153                                 case '6':
8154                                 case 'l':
8155                                 case 'L':
8156                                 {
8157                                         menu_line = max_num;
8158                                         break;
8159                                 }
8160
8161                                 case 'x':
8162                                 case 'X':
8163                                 case '\r':
8164                                 case '\n':
8165                                 {
8166                                         i = menu_line - 1;
8167                                         ask = FALSE;
8168                                         break;
8169                                 }
8170                         }
8171                         if (menu_line > max_num) menu_line -= max_num;
8172                 }
8173                 /* Request redraw */
8174                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
8175                 {
8176                         /* Show the list */
8177                         if (!redraw || use_menu)
8178                         {
8179                                 byte y, x = 10;
8180                                 int ctr;
8181                                 char dummy[80], dummy2[80];
8182                                 byte col;
8183
8184                                 strcpy(dummy, "");
8185
8186                                 /* Show list */
8187                                 redraw = TRUE;
8188
8189                                 /* Save the screen */
8190                                 if (!use_menu) screen_save();
8191
8192                                 for (y = 1; y < 24; y++)
8193                                         prt("", y, x);
8194
8195                                 /* Print header(s) */
8196 #ifdef JP
8197                                 prt(format("   %-43s %6s/%s", "能力(必要エッセンス)", "必要数", "所持数"), 1, x);
8198
8199 #else
8200                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
8201 #endif
8202                                 /* Print list */
8203                                 for (ctr = 0; ctr < max_num; ctr++)
8204                                 {
8205                                         es_ptr = &essence_info[num[ctr]];
8206
8207                                         if (use_menu)
8208                                         {
8209                                                 if (ctr == (menu_line-1))
8210                                                         strcpy(dummy, _("》 ", ">  "));
8211                                                 else strcpy(dummy, "   ");
8212
8213                                         }
8214                                         /* letter/number for power selection */
8215                                         else
8216                                         {
8217                                                 sprintf(dummy, "%c) ",I2A(ctr));
8218                                         }
8219
8220                                         strcat(dummy, es_ptr->add_name);
8221
8222                                         col = TERM_WHITE;
8223                                         able[ctr] = TRUE;
8224
8225                                         if (es_ptr->essence != -1)
8226                                         {
8227                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
8228                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
8229                                         }
8230                                         else
8231                                         {
8232                                                 switch(es_ptr->add)
8233                                                 {
8234                                                 case ESSENCE_SH_FIRE:
8235                                                         strcat(dummy, _("(焼棄+耐火炎)", "(brand fire + res.fire)"));
8236                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
8237                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8238                                                         break;
8239                                                 case ESSENCE_SH_ELEC:
8240                                                         strcat(dummy, _("(電撃+耐電撃)", "(brand elec. + res. elec.)"));
8241                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
8242                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8243                                                         break;
8244                                                 case ESSENCE_SH_COLD:
8245                                                         strcat(dummy, _("(凍結+耐冷気)", "(brand cold + res. cold)"));
8246                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
8247                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8248                                                         break;
8249                                                 case ESSENCE_RESISTANCE:
8250                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8251                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8252                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8253                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8254                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8255                                                         break;
8256                                                 case ESSENCE_SUSTAIN:
8257                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8258                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8259                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8260                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8261                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8262                                                         break;
8263                                                 }
8264                                         }
8265
8266                                         if (!able[ctr]) col = TERM_RED;
8267
8268                                         if (es_ptr->essence != -1)
8269                                         {
8270                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
8271                                         }
8272                                         else
8273                                         {
8274                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
8275                                         }
8276
8277                                         c_prt(col, dummy2, ctr+2, x);
8278                                 }
8279                         }
8280
8281                         /* Hide the list */
8282                         else
8283                         {
8284                                 /* Hide list */
8285                                 redraw = FALSE;
8286
8287                                 /* Restore the screen */
8288                                 screen_load();
8289                         }
8290
8291                         /* Redo asking */
8292                         continue;
8293                 }
8294
8295                 if (!use_menu)
8296                 {
8297                         /* Note verify */
8298                         ask = (isupper(choice));
8299
8300                         /* Lowercase */
8301                         if (ask) choice = tolower(choice);
8302
8303                         /* Extract request */
8304                         i = (islower(choice) ? A2I(choice) : -1);
8305                 }
8306
8307                 /* Totally Illegal */
8308                 if ((i < 0) || (i >= max_num) || !able[i])
8309                 {
8310                         bell();
8311                         continue;
8312                 }
8313
8314                 /* Verify it */
8315                 if (ask)
8316                 {
8317                         char tmp_val[160];
8318
8319                         /* Prompt */
8320                         (void) strnfmt(tmp_val, 78, _("%sを付加しますか？ ", "Add the abilitiy of %s? "), essence_info[num[i]].add_name);
8321
8322                         /* Belay that order */
8323                         if (!get_check(tmp_val)) continue;
8324                 }
8325
8326                 /* Stop the loop */
8327                 flag = TRUE;
8328         }
8329
8330         /* Restore the screen */
8331         if (redraw) screen_load();
8332
8333         if (!flag) return;
8334
8335 #ifdef ALLOW_REPEAT
8336         repeat_push(i);
8337         }
8338 #endif /* ALLOW_REPEAT */
8339
8340         es_ptr = &essence_info[num[i]];
8341
8342         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8343                 item_tester_tval = TV_GLOVES;
8344         else if (mode == 1 || mode == 5)
8345                 item_tester_hook = item_tester_hook_melee_ammo;
8346         else if (es_ptr->add == ESSENCE_ATTACK)
8347                 item_tester_hook = object_allow_enchant_weapon;
8348         else if (es_ptr->add == ESSENCE_AC)
8349                 item_tester_hook = object_is_armour;
8350         else
8351                 item_tester_hook = object_is_weapon_armour_ammo;
8352         item_tester_no_ryoute = TRUE;
8353
8354         /* Get an item */
8355         q = _("どのアイテムを改良しますか？", "Improve which item? ");
8356         s = _("改良できるアイテムがありません。", "You have nothing to improve.");
8357
8358         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8359
8360         /* Get the item (in the pack) */
8361         if (item >= 0)
8362         {
8363                 o_ptr = &inventory[item];
8364         }
8365
8366         /* Get the item (on the floor) */
8367         else
8368         {
8369                 o_ptr = &o_list[0 - item];
8370         }
8371
8372         if ((mode != 10) && (object_is_artifact(o_ptr) || object_is_smith(o_ptr)))
8373         {
8374                 msg_print(_("そのアイテムはこれ以上改良できない。", "This item is no more able to be improved."));
8375                 return;
8376         }
8377
8378         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8379
8380         use_essence = es_ptr->value;
8381         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
8382         if (o_ptr->number > 1)
8383         {
8384                 use_essence *= o_ptr->number;
8385                 msg_format(_("%d個あるのでエッセンスは%d必要です。", "It will take %d essences."), o_ptr->number, use_essence);
8386         }
8387
8388         if (es_ptr->essence != -1)
8389         {
8390                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8391                 {
8392                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8393                         return;
8394                 }
8395                 if (is_pval_flag(es_ptr->add))
8396                 {
8397                         if (o_ptr->pval < 0)
8398                         {
8399                                 msg_print(_("このアイテムの能力修正を強化することはできない。", "You cannot increase magic number of this item."));
8400                                 return;
8401                         }
8402                         else if (es_ptr->add == TR_BLOWS)
8403                         {
8404                                 if (o_ptr->pval > 1)
8405                                 {
8406                                         if (!get_check(_("修正値は1になります。よろしいですか？", "The magic number of this weapon will become 1. Are you sure? "))) return;
8407                                 }
8408
8409                                 o_ptr->pval = 1;
8410                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8411                         }
8412                         else if (o_ptr->pval > 0)
8413                         {
8414                                 use_essence *= o_ptr->pval;
8415                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8416                         }
8417                         else
8418                         {
8419                                 char tmp[80];
8420                                 char tmp_val[160];
8421                                 int pval;
8422                                 int limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
8423
8424                                 sprintf(tmp, _("いくつ付加しますか？ (1-%d): ", "Enchant how many? (1-%d): "), limit);
8425                                 strcpy(tmp_val, "1");
8426
8427                                 if (!get_string(tmp, tmp_val, 1)) return;
8428                                 pval = atoi(tmp_val);
8429                                 if (pval > limit) pval = limit;
8430                                 else if (pval < 1) pval = 1;
8431                                 o_ptr->pval += pval;
8432                                 use_essence *= pval;
8433                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8434                         }
8435
8436                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8437                         {
8438                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8439                                 return;
8440                         }
8441                 }
8442                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8443                 {
8444                         char tmp_val[160];
8445                         int val;
8446                         int get_to_h, get_to_d;
8447
8448                         strcpy(tmp_val, "1");
8449                         if (!get_string(format(_("いくつ付加しますか？ (1-%d):", "Enchant how many? (1-%d):"), p_ptr->lev/7+3), tmp_val, 2)) return;
8450                         val = atoi(tmp_val);
8451                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
8452                         else if (val < 1) val = 1;
8453                         use_essence *= val;
8454                         msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8455                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8456                         {
8457                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8458                                 return;
8459                         }
8460                         get_to_h = ((val+1)/2+randint0(val/2+1));
8461                         get_to_d = ((val+1)/2+randint0(val/2+1));
8462                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
8463                         o_ptr->to_h += get_to_h;
8464                         o_ptr->to_d += get_to_d;
8465                 }
8466                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
8467                 if (es_ptr->add == ESSENCE_ATTACK)
8468                 {
8469                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
8470                         {
8471                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8472                                 p_ptr->energy_use = 100;
8473                                 return;
8474                         }
8475                         else
8476                         {
8477                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
8478                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
8479                         }
8480                 }
8481                 else if (es_ptr->add == ESSENCE_AC)
8482                 {
8483                         if (o_ptr->to_a >= p_ptr->lev/5+5)
8484                         {
8485                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8486                                 p_ptr->energy_use = 100;
8487                                 return;
8488                         }
8489                         else
8490                         {
8491                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
8492                         }
8493                 }
8494                 else
8495                 {
8496                         o_ptr->xtra3 = es_ptr->add + 1;
8497                 }
8498         }
8499         else
8500         {
8501                 bool success = TRUE;
8502
8503                 switch(es_ptr->add)
8504                 {
8505                 case ESSENCE_SH_FIRE:
8506                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
8507                         {
8508                                 success = FALSE;
8509                                 break;
8510                         }
8511                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
8512                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8513                         break;
8514                 case ESSENCE_SH_ELEC:
8515                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
8516                         {
8517                                 success = FALSE;
8518                                 break;
8519                         }
8520                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
8521                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8522                         break;
8523                 case ESSENCE_SH_COLD:
8524                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8525                         {
8526                                 success = FALSE;
8527                                 break;
8528                         }
8529                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
8530                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8531                         break;
8532                 case ESSENCE_RESISTANCE:
8533                 case ESSENCE_SUSTAIN:
8534                         if ((p_ptr->magic_num1[TR_RES_ACID] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8535                         {
8536                                 success = FALSE;
8537                                 break;
8538                         }
8539                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
8540                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8541                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8542                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8543                         break;
8544                 }
8545                 if (!success)
8546                 {
8547                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8548                         return;
8549                 }
8550                 if (es_ptr->add == ESSENCE_SUSTAIN)
8551                 {
8552                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
8553                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
8554                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
8555                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
8556                 }
8557                 else
8558                 {
8559                         o_ptr->xtra3 = es_ptr->add + 1;
8560                 }
8561         }
8562
8563         p_ptr->energy_use = 100;
8564
8565 #ifdef JP
8566         msg_format("%sに%sの能力を付加しました。", o_name, es_ptr->add_name);
8567 #else
8568         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
8569 #endif
8570
8571         /* Combine the pack */
8572         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8573
8574         /* Window stuff */
8575         p_ptr->window |= (PW_INVEN);
8576 }
8577
8578 /*!
8579  * @brief エッセンスを消去する
8580  * @return なし
8581  */
8582 static void erase_essence(void)
8583 {
8584         int item;
8585         cptr q, s;
8586         object_type *o_ptr;
8587         char o_name[MAX_NLEN];
8588         u32b flgs[TR_FLAG_SIZE];
8589
8590         item_tester_hook = object_is_smith;
8591
8592         /* Get an item */
8593         q = _("どのアイテムのエッセンスを消去しますか？", "Remove from which item? ");
8594         s = _("エッセンスを付加したアイテムがありません。", "You have nothing to remove essence.");
8595
8596         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8597
8598         /* Get the item (in the pack) */
8599         if (item >= 0)
8600         {
8601                 o_ptr = &inventory[item];
8602         }
8603
8604         /* Get the item (on the floor) */
8605         else
8606         {
8607                 o_ptr = &o_list[0 - item];
8608         }
8609
8610         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8611         if (!get_check(format(_("よろしいですか？ [%s]", "Are you sure? [%s]"), o_name))) return;
8612
8613         p_ptr->energy_use = 100;
8614
8615         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8616         {
8617                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8618                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8619                 o_ptr->xtra4 = 0;
8620                 if (o_ptr->to_h < 0) o_ptr->to_h = 0;
8621                 if (o_ptr->to_d < 0) o_ptr->to_d = 0;
8622         }
8623         o_ptr->xtra3 = 0;
8624         object_flags(o_ptr, flgs);
8625         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8626         msg_print(_("エッセンスを取り去った。", "You removed all essence you have added."));
8627
8628         /* Combine the pack */
8629         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8630
8631         /* Window stuff */
8632         p_ptr->window |= (PW_INVEN);
8633 }
8634
8635 /*!
8636  * @brief 鍛冶コマンドのメインルーチン
8637  * @param only_browse TRUEならばエッセンス一覧の表示のみを行う
8638  * @return なし
8639  */
8640 void do_cmd_kaji(bool only_browse)
8641 {
8642         int mode = 0;
8643         char choice;
8644
8645         int menu_line = (use_menu ? 1 : 0);
8646
8647         if (!only_browse)
8648         {
8649                 if (p_ptr->confused)
8650                 {
8651                         msg_print(_("混乱していて作業できない！", "You are too confused!"));
8652                         return;
8653                 }
8654                 if (p_ptr->blind)
8655                 {
8656                         msg_print(_("目が見えなくて作業できない！", "You are blind!"));
8657                         return;
8658                 }
8659                 if (p_ptr->image)
8660                 {
8661                         msg_print(_("うまく見えなくて作業できない！", "You are hallucinating!"));
8662                         return;
8663                 }
8664         }
8665
8666 #ifdef ALLOW_REPEAT
8667         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8668         {
8669 #endif /* ALLOW_REPEAT */
8670
8671         if (only_browse) screen_save();
8672         do {
8673         if (!only_browse) screen_save();
8674         if (use_menu)
8675         {
8676                 while(!mode)
8677                 {
8678 #ifdef JP
8679                         prt(format(" %s エッセンス一覧", (menu_line == 1) ? "》" : "  "), 2, 14);
8680                         prt(format(" %s エッセンス抽出", (menu_line == 2) ? "》" : "  "), 3, 14);
8681                         prt(format(" %s エッセンス消去", (menu_line == 3) ? "》" : "  "), 4, 14);
8682                         prt(format(" %s エッセンス付加", (menu_line == 4) ? "》" : "  "), 5, 14);
8683                         prt(format(" %s 武器/防具強化", (menu_line == 5) ? "》" : "  "), 6, 14);
8684                         prt(format("どの種類の技術を%sますか？", only_browse ? "調べ" : "使い"), 0, 0);
8685 #else
8686                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8687                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8688                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8689                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8690                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8691                         prt(format("Choose command from menu."), 0, 0);
8692 #endif
8693                         choice = inkey();
8694                         switch(choice)
8695                         {
8696                         case ESCAPE:
8697                         case 'z':
8698                         case 'Z':
8699                                 screen_load();
8700                                 return;
8701                         case '2':
8702                         case 'j':
8703                         case 'J':
8704                                 menu_line++;
8705                                 break;
8706                         case '8':
8707                         case 'k':
8708                         case 'K':
8709                                 menu_line+= 4;
8710                                 break;
8711                         case '\r':
8712                         case '\n':
8713                         case 'x':
8714                         case 'X':
8715                                 mode = menu_line;
8716                                 break;
8717                         }
8718                         if (menu_line > 5) menu_line -= 5;
8719                 }
8720         }
8721
8722         else
8723         {
8724                 while (!mode)
8725                 {
8726 #ifdef JP
8727                         prt("  a) エッセンス一覧", 2, 14);
8728                         prt("  b) エッセンス抽出", 3, 14);
8729                         prt("  c) エッセンス消去", 4, 14);
8730                         prt("  d) エッセンス付加", 5, 14);
8731                         prt("  e) 武器/防具強化", 6, 14);
8732                         if (!get_com(format("どの能力を%sますか:", only_browse ? "調べ" : "使い"), &choice, TRUE))
8733 #else
8734                         prt("  a) List essences", 2, 14);
8735                         prt("  b) Extract essence", 3, 14);
8736                         prt("  c) Remove essence", 4, 14);
8737                         prt("  d) Add essence", 5, 14);
8738                         prt("  e) Enchant weapon/armor", 6, 14);
8739                         if (!get_com("Command :", &choice, TRUE))
8740 #endif
8741                         {
8742                                 screen_load();
8743                                 return;
8744                         }
8745                         switch (choice)
8746                         {
8747                         case 'A':
8748                         case 'a':
8749                                 mode = 1;
8750                                 break;
8751                         case 'B':
8752                         case 'b':
8753                                 mode = 2;
8754                                 break;
8755                         case 'C':
8756                         case 'c':
8757                                 mode = 3;
8758                                 break;
8759                         case 'D':
8760                         case 'd':
8761                                 mode = 4;
8762                                 break;
8763                         case 'E':
8764                         case 'e':
8765                                 mode = 5;
8766                                 break;
8767                         }
8768                 }
8769         }
8770
8771         if (only_browse)
8772         {
8773                 char temp[62*5];
8774                 int line, j;
8775
8776                 /* Clear lines, position cursor  (really should use strlen here) */
8777                 Term_erase(14, 21, 255);
8778                 Term_erase(14, 20, 255);
8779                 Term_erase(14, 19, 255);
8780                 Term_erase(14, 18, 255);
8781                 Term_erase(14, 17, 255);
8782                 Term_erase(14, 16, 255);
8783
8784                 roff_to_buf(kaji_tips[mode-1], 62, temp, sizeof(temp));
8785                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8786                 {
8787                         prt(&temp[j], line, 15);
8788                         line++;
8789                 }
8790                 mode = 0;
8791         }
8792         if (!only_browse) screen_load();
8793         } while (only_browse);
8794 #ifdef ALLOW_REPEAT
8795         repeat_push(mode);
8796         }
8797 #endif /* ALLOW_REPEAT */
8798
8799         switch(mode)
8800         {
8801                 case 1: display_essence();break;
8802                 case 2: drain_essence();break;
8803                 case 3: erase_essence();break;
8804                 case 4:
8805                         mode = choose_essence();
8806                         if (mode == 0)
8807                                 break;
8808                         add_essence(mode);
8809                         break;
8810                 case 5: add_essence(10);break;
8811         }
8812 }
8813
8814
8815 /*!
8816  * @brief 投擲時たいまつに投げやすい/焼棄/アンデッドスレイの特別効果を返す。
8817  * Torches have special abilities when they are flaming.
8818  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8819  * @param flgs 特別に追加するフラグを返す参照ポインタ
8820  * @return なし
8821  */
8822 void torch_flags(object_type *o_ptr, u32b *flgs)
8823 {
8824         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8825         {
8826                 if (o_ptr->xtra4 > 0)
8827                 {
8828                         add_flag(flgs, TR_BRAND_FIRE);
8829                         add_flag(flgs, TR_KILL_UNDEAD);
8830                         add_flag(flgs, TR_THROW);
8831                 }
8832         }
8833 }
8834
8835 /*!
8836  * @brief 投擲時たいまつにダイスを与える。
8837  * Torches have special abilities when they are flaming.
8838  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8839  * @param dd 特別なダイス数を返す参照ポインタ
8840  * @param ds 特別なダイス面数を返す参照ポインタ
8841  * @return なし
8842  */
8843 void torch_dice(object_type *o_ptr, int *dd, int *ds)
8844 {
8845         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8846         {
8847                 if (o_ptr->xtra4 > 0)
8848                 {
8849                         (*dd) = 1;
8850                         (*ds) = 6;
8851                 }
8852         }
8853 }
8854
8855 /*!
8856  * @brief 投擲時命中したたいまつの寿命を縮める。
8857  * Torches have special abilities when they are flaming.
8858  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8859  * @return なし
8860  */
8861 void torch_lost_fuel(object_type *o_ptr)
8862 {
8863         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8864         {
8865                 o_ptr->xtra4 -= (FUEL_TORCH / 25);
8866                 if (o_ptr->xtra4 < 0) o_ptr->xtra4 = 0;
8867         }
8868 }