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