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         int tohit1 = randint1(5) + m_bonus(5, level);
2289         int todam1 = randint1(5) + m_bonus(5, level);
2290
2291         int tohit2 = m_bonus(10, level);
2292         int 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                                                         break;
2767                                                 }
2768                                           case EGO_DRUID:
2769                                                 if (o_ptr->tval != TV_SOFT_ARMOR)
2770                                                 {
2771                                                         okay_flag = FALSE;
2772                                                         break;
2773                                                 }
2774                                           default:
2775                                                 break;
2776                                         }
2777
2778                                         if (okay_flag)
2779                                                 break;
2780                                 }
2781                                 switch (o_ptr->name2)
2782                                 {
2783                                   case EGO_RESISTANCE:
2784                                         if (one_in_(4))
2785                                                 add_flag(o_ptr->art_flags, TR_RES_POIS);
2786                                                 break;
2787                                   case EGO_DWARVEN:
2788                                         o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2789                                         o_ptr->ac = k_info[o_ptr->k_idx].ac + 5;
2790                                         break;
2791
2792                                   case EGO_A_DEMON:
2793                                         if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2794                                         one_in_(3) ?
2795                                                 add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
2796                                                 one_in_(2) ?
2797                                                         add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
2798                                                         add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2799
2800                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2801                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
2802                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2803                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2804                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2805                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2806                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2807                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
2808                                         break;
2809                                   case EGO_A_MORGUL:
2810                                         if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2811                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2812                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2813                                         if (one_in_(6)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2814                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2815                                         if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2816                                         break;
2817                                   default:
2818                                         break;
2819                                 }
2820                         }
2821
2822                         break;
2823                 }
2824
2825                 case TV_SHIELD:
2826                 {
2827
2828                         if (o_ptr->sval == SV_DRAGON_SHIELD)
2829                         {
2830                                 dragon_resist(o_ptr);
2831                                 if (!one_in_(3)) break;
2832                         }
2833
2834                         /* Very good */
2835                         if (power > 1)
2836                         {
2837                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2838                                 {
2839                                         create_artifact(o_ptr, FALSE);
2840                                         break;
2841                                 }
2842
2843                                 while(1)
2844                                 {
2845                                         o_ptr->name2 = get_random_ego(INVEN_LARM, TRUE);
2846                                         if (o_ptr->sval != SV_SMALL_METAL_SHIELD && o_ptr->sval != SV_LARGE_METAL_SHIELD
2847                                                                 && o_ptr->name2 == EGO_S_DWARVEN)
2848                                         {
2849                                                 continue;
2850                                         }
2851                                         break;
2852                                 }
2853
2854                                 switch (o_ptr->name2)
2855                                 {
2856                                 case EGO_ENDURANCE:
2857                                         if (!one_in_(3)) one_high_resistance(o_ptr);
2858                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_POIS);
2859                                         break;
2860                                 case EGO_REFLECTION:
2861                                         if (o_ptr->sval == SV_MIRROR_SHIELD)
2862                                                 o_ptr->name2 = 0;
2863                                         break;
2864
2865                                 case EGO_S_DWARVEN:
2866                                         o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2867                                         o_ptr->ac = k_info[o_ptr->k_idx].ac + 3;
2868                                         break;
2869                                 }
2870                         }
2871                         break;
2872                 }
2873
2874                 case TV_GLOVES:
2875                 {
2876                         if (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)
2877                         {
2878                                 dragon_resist(o_ptr);
2879                                 if (!one_in_(3)) break;
2880                         }
2881                         if (power > 1)
2882                         {
2883                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2884                                 {
2885                                         create_artifact(o_ptr, FALSE);
2886                                         break;
2887                                 }
2888                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, TRUE);
2889                         }
2890
2891                         /* Very cursed */
2892                         else if (power < -1)
2893                         {
2894                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, FALSE);
2895                         }
2896
2897                         break;
2898                 }
2899
2900                 case TV_BOOTS:
2901                 {
2902                         if (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)
2903                         {
2904                                 dragon_resist(o_ptr);
2905                                 if (!one_in_(3)) break;
2906                         }
2907                         /* Very good */
2908                         if (power > 1)
2909                         {
2910                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2911                                 {
2912                                         create_artifact(o_ptr, FALSE);
2913                                         break;
2914                                 }
2915                                 o_ptr->name2 = get_random_ego(INVEN_FEET, TRUE);
2916
2917                                 switch (o_ptr->name2)
2918                                 {
2919                                 case EGO_SLOW_DESCENT:
2920                                         if (one_in_(2))
2921                                         {
2922                                                 one_high_resistance(o_ptr);
2923                                         }
2924                                         break;
2925                                 }
2926                         }
2927                         /* Very cursed */
2928                         else if (power < -1)
2929                         {
2930                                 o_ptr->name2 = get_random_ego(INVEN_FEET, FALSE);
2931                         }
2932
2933                         break;
2934                 }
2935
2936                 case TV_CROWN:
2937                 {
2938                         /* Very good */
2939                         if (power > 1)
2940                         {
2941                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2942                                 {
2943                                         create_artifact(o_ptr, FALSE);
2944                                         break;
2945                                 }
2946                                 while (1)
2947                                 {
2948                                         bool ok_flag = TRUE;
2949                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
2950
2951                                         switch (o_ptr->name2)
2952                                         {
2953                                         case EGO_TELEPATHY:
2954                                                 if (add_esp_strong(o_ptr)) add_esp_weak(o_ptr, TRUE);
2955                                                 else add_esp_weak(o_ptr, FALSE);
2956                                                 break;
2957                                         case EGO_MAGI:
2958                                         case EGO_MIGHT:
2959                                         case EGO_REGENERATION:
2960                                         case EGO_LORDLINESS:
2961                                         case EGO_BASILISK:
2962                                                 break;
2963                                         case EGO_SEEING:
2964                                                 if (one_in_(3))
2965                                                 {
2966                                                         if (one_in_(2)) add_esp_strong(o_ptr);
2967                                                         else add_esp_weak(o_ptr, FALSE);
2968                                                 }
2969                                                 break;
2970                                         default:/* not existing crown (wisdom,lite, etc...) */
2971                                                 ok_flag = FALSE;
2972                                         }
2973                                         if (ok_flag)
2974                                                 break; /* while (1) */
2975                                 }
2976                                 break;
2977                         }
2978
2979                         /* Very cursed */
2980                         else if (power < -1)
2981                         {
2982                                 while (1)
2983                                 {
2984                                         bool ok_flag = TRUE;
2985                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
2986
2987                                         switch (o_ptr->name2)
2988                                         {
2989                                           case EGO_ANCIENT_CURSE:
2990                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2991                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2992                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2993                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2994                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2995                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2996                                                 break;
2997                                         }
2998                                         if (ok_flag)
2999                                                 break; /* while (1) */
3000                                 }
3001                         }
3002
3003                         break;
3004                 }
3005
3006                 case TV_HELM:
3007                 {
3008                         if (o_ptr->sval == SV_DRAGON_HELM)
3009                         {
3010                                 dragon_resist(o_ptr);
3011                                 if (!one_in_(3)) break;
3012                         }
3013
3014                         /* Very good */
3015                         if (power > 1)
3016                         {
3017                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
3018                                 {
3019                                         create_artifact(o_ptr, FALSE);
3020                                         break;
3021                                 }
3022                                 while (1)
3023                                 {
3024                                         bool ok_flag = TRUE;
3025                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
3026
3027                                         switch (o_ptr->name2)
3028                                         {
3029                                         case EGO_BRILLIANCE:
3030                                         case EGO_DARK:
3031                                         case EGO_INFRAVISION:
3032                                         case EGO_H_PROTECTION:
3033                                                 break;
3034                                         case EGO_SEEING:
3035                                                 if (one_in_(7))
3036                                                 {
3037                                                         if (one_in_(2)) add_esp_strong(o_ptr);
3038                                                         else add_esp_weak(o_ptr, FALSE);
3039                                                 }
3040                                                 break;
3041                                         case EGO_LITE:
3042                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_1);
3043                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_2);
3044                                                 break;
3045                                         case EGO_H_DEMON:
3046                                                 if(one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
3047                                                 one_in_(3) ?
3048                                                         add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
3049                                                         one_in_(2) ?
3050                                                                 add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
3051                                                                 add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
3052
3053                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
3054                                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
3055                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
3056                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
3057                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
3058                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
3059                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
3060                                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
3061                                                 break;
3062                                         default:/* not existing helm (Magi, Might, etc...)*/
3063                                                 ok_flag = FALSE;
3064                                         }
3065                                         if (ok_flag)
3066                                                 break; /* while (1) */
3067                                 }
3068                                 break;
3069                         }
3070                         /* Very cursed */
3071                         else if (power < -1)
3072                         {
3073                                 while (1)
3074                                 {
3075                                         bool ok_flag = TRUE;
3076                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
3077
3078                                         switch (o_ptr->name2)
3079                                         {
3080                                           case EGO_ANCIENT_CURSE:
3081                                                 ok_flag = FALSE;
3082                                         }
3083                                         if (ok_flag)
3084                                                 break; /* while (1) */
3085                                 }
3086                         }
3087                         break;
3088                 }
3089
3090                 case TV_CLOAK:
3091                 {
3092                         /* Very good */
3093                         if (power > 1)
3094                         {
3095                                 if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
3096                                 {
3097                                         create_artifact(o_ptr, FALSE);
3098                                         break;
3099                                 }
3100                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, TRUE);
3101
3102                                 switch (o_ptr->name2)
3103                                 {
3104                                 case EGO_BAT:
3105                                         o_ptr->to_d -= 6;
3106                                         o_ptr->to_h -= 6;
3107                                         break;
3108                                   case EGO_NAZGUL:
3109                                         o_ptr->to_d -= 3;
3110                                         o_ptr->to_h -= 3;
3111                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_COWARDICE);
3112                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_CALL_UNDEAD);
3113                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_SLOW_REGEN);
3114                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
3115                                         break;
3116                                 }
3117
3118                         }
3119
3120                         /* Very cursed */
3121                         else if (power < -1)
3122                         {
3123                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, FALSE);
3124                         }
3125
3126                         break;
3127                 }
3128         }
3129
3130 }
3131
3132
3133 /*!
3134  * @brief 装飾品系オブジェクトに生成ランクごとの強化を与えるサブルーチン
3135  * Apply magic to an item known to be a "ring" or "amulet"
3136  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3137  * @param level 生成基準階
3138  * @param power 生成ランク
3139  * @return なし
3140  * @details
3141  * Hack -- note special "pval boost" code for ring of speed\n
3142  * Hack -- note that some items must be cursed (or blessed)\n
3143  */
3144 static void a_m_aux_3(object_type *o_ptr, int level, int power)
3145 {
3146         /* Apply magic (good or bad) according to type */
3147         switch (o_ptr->tval)
3148         {
3149                 case TV_RING:
3150                 {
3151                         /* Analyze */
3152                         switch (o_ptr->sval)
3153                         {
3154                                 case SV_RING_ATTACKS:
3155                                 {
3156                                         /* Stat bonus */
3157                                         o_ptr->pval = m_bonus(2, level);
3158                                         if (one_in_(15)) o_ptr->pval++;
3159                                         if (o_ptr->pval < 1) o_ptr->pval = 1;
3160
3161                                         /* Cursed */
3162                                         if (power < 0)
3163                                         {
3164                                                 /* Broken */
3165                                                 o_ptr->ident |= (IDENT_BROKEN);
3166
3167                                                 /* Cursed */
3168                                                 o_ptr->curse_flags |= TRC_CURSED;
3169
3170                                                 /* Reverse pval */
3171                                                 o_ptr->pval = 0 - (o_ptr->pval);
3172                                         }
3173
3174                                         break;
3175                                 }
3176
3177                                 case SV_RING_SHOTS:
3178                                 {
3179                                         break;
3180                                 }
3181
3182                                 /* Strength, Constitution, Dexterity, Intelligence */
3183                                 case SV_RING_STR:
3184                                 case SV_RING_CON:
3185                                 case SV_RING_DEX:
3186                                 {
3187                                         /* Stat bonus */
3188                                         o_ptr->pval = 1 + m_bonus(5, level);
3189
3190                                         /* Cursed */
3191                                         if (power < 0)
3192                                         {
3193                                                 /* Broken */
3194                                                 o_ptr->ident |= (IDENT_BROKEN);
3195
3196                                                 /* Cursed */
3197                                                 o_ptr->curse_flags |= TRC_CURSED;
3198
3199                                                 /* Reverse pval */
3200                                                 o_ptr->pval = 0 - (o_ptr->pval);
3201                                         }
3202
3203                                         break;
3204                                 }
3205
3206                                 /* Ring of Speed! */
3207                                 case SV_RING_SPEED:
3208                                 {
3209                                         /* Base speed (1 to 10) */
3210                                         o_ptr->pval = randint1(5) + m_bonus(5, level);
3211
3212                                         /* Super-charge the ring */
3213                                         while (randint0(100) < 50) o_ptr->pval++;
3214
3215                                         /* Cursed Ring */
3216                                         if (power < 0)
3217                                         {
3218                                                 /* Broken */
3219                                                 o_ptr->ident |= (IDENT_BROKEN);
3220
3221                                                 /* Cursed */
3222                                                 o_ptr->curse_flags |= TRC_CURSED;
3223
3224                                                 /* Reverse pval */
3225                                                 o_ptr->pval = 0 - (o_ptr->pval);
3226
3227                                                 break;
3228                                         }
3229
3230                                         break;
3231                                 }
3232
3233                                 case SV_RING_LORDLY:
3234                                 {
3235                                         do
3236                                         {
3237                                                 one_lordly_high_resistance(o_ptr);
3238                                         }
3239                                         while (one_in_(4));
3240
3241                                         /* Bonus to armor class */
3242                                         o_ptr->to_a = 10 + randint1(5) + m_bonus(10, level);
3243                                 }
3244                                 break;
3245
3246                                 case SV_RING_WARNING:
3247                                 {
3248                                         if (one_in_(3)) one_low_esp(o_ptr);
3249                                         break;
3250                                 }
3251
3252                                 /* Searching */
3253                                 case SV_RING_SEARCHING:
3254                                 {
3255                                         /* Bonus to searching */
3256                                         o_ptr->pval = 1 + m_bonus(5, level);
3257
3258                                         /* Cursed */
3259                                         if (power < 0)
3260                                         {
3261                                                 /* Broken */
3262                                                 o_ptr->ident |= (IDENT_BROKEN);
3263
3264                                                 /* Cursed */
3265                                                 o_ptr->curse_flags |= TRC_CURSED;
3266
3267                                                 /* Reverse pval */
3268                                                 o_ptr->pval = 0 - (o_ptr->pval);
3269                                         }
3270
3271                                         break;
3272                                 }
3273
3274                                 /* Flames, Acid, Ice */
3275                                 case SV_RING_FLAMES:
3276                                 case SV_RING_ACID:
3277                                 case SV_RING_ICE:
3278                                 case SV_RING_ELEC:
3279                                 {
3280                                         /* Bonus to armor class */
3281                                         o_ptr->to_a = 5 + randint1(5) + m_bonus(10, level);
3282                                         break;
3283                                 }
3284
3285                                 /* Weakness, Stupidity */
3286                                 case SV_RING_WEAKNESS:
3287                                 case SV_RING_STUPIDITY:
3288                                 {
3289                                         /* Broken */
3290                                         o_ptr->ident |= (IDENT_BROKEN);
3291
3292                                         /* Cursed */
3293                                         o_ptr->curse_flags |= TRC_CURSED;
3294
3295                                         /* Penalize */
3296                                         o_ptr->pval = 0 - (1 + m_bonus(5, level));
3297                                         if (power > 0) power = 0 - power;
3298
3299                                         break;
3300                                 }
3301
3302                                 /* WOE, Stupidity */
3303                                 case SV_RING_WOE:
3304                                 {
3305                                         /* Broken */
3306                                         o_ptr->ident |= (IDENT_BROKEN);
3307
3308                                         /* Cursed */
3309                                         o_ptr->curse_flags |= TRC_CURSED;
3310
3311                                         /* Penalize */
3312                                         o_ptr->to_a = 0 - (5 + m_bonus(10, level));
3313                                         o_ptr->pval = 0 - (1 + m_bonus(5, level));
3314                                         if (power > 0) power = 0 - power;
3315
3316                                         break;
3317                                 }
3318
3319                                 /* Ring of damage */
3320                                 case SV_RING_DAMAGE:
3321                                 {
3322                                         /* Bonus to damage */
3323                                         o_ptr->to_d = 1 + randint1(5) + m_bonus(16, level);
3324
3325                                         /* Cursed */
3326                                         if (power < 0)
3327                                         {
3328                                                 /* Broken */
3329                                                 o_ptr->ident |= (IDENT_BROKEN);
3330
3331                                                 /* Cursed */
3332                                                 o_ptr->curse_flags |= TRC_CURSED;
3333
3334                                                 /* Reverse bonus */
3335                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3336                                         }
3337
3338                                         break;
3339                                 }
3340
3341                                 /* Ring of Accuracy */
3342                                 case SV_RING_ACCURACY:
3343                                 {
3344                                         /* Bonus to hit */
3345                                         o_ptr->to_h = 1 + randint1(5) + m_bonus(16, level);
3346
3347                                         /* Cursed */
3348                                         if (power < 0)
3349                                         {
3350                                                 /* Broken */
3351                                                 o_ptr->ident |= (IDENT_BROKEN);
3352
3353                                                 /* Cursed */
3354                                                 o_ptr->curse_flags |= TRC_CURSED;
3355
3356                                                 /* Reverse tohit */
3357                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3358                                         }
3359
3360                                         break;
3361                                 }
3362
3363                                 /* Ring of Protection */
3364                                 case SV_RING_PROTECTION:
3365                                 {
3366                                         /* Bonus to armor class */
3367                                         o_ptr->to_a = 5 + randint1(8) + m_bonus(10, level);
3368
3369                                         /* Cursed */
3370                                         if (power < 0)
3371                                         {
3372                                                 /* Broken */
3373                                                 o_ptr->ident |= (IDENT_BROKEN);
3374
3375                                                 /* Cursed */
3376                                                 o_ptr->curse_flags |= TRC_CURSED;
3377
3378                                                 /* Reverse toac */
3379                                                 o_ptr->to_a = 0 - o_ptr->to_a;
3380                                         }
3381
3382                                         break;
3383                                 }
3384
3385                                 /* Ring of Slaying */
3386                                 case SV_RING_SLAYING:
3387                                 {
3388                                         /* Bonus to damage and to hit */
3389                                         o_ptr->to_d = randint1(5) + m_bonus(12, level);
3390                                         o_ptr->to_h = randint1(5) + m_bonus(12, level);
3391
3392                                         /* Cursed */
3393                                         if (power < 0)
3394                                         {
3395                                                 /* Broken */
3396                                                 o_ptr->ident |= (IDENT_BROKEN);
3397
3398                                                 /* Cursed */
3399                                                 o_ptr->curse_flags |= TRC_CURSED;
3400
3401                                                 /* Reverse bonuses */
3402                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3403                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3404                                         }
3405
3406                                         break;
3407                                 }
3408
3409                                 case SV_RING_MUSCLE:
3410                                 {
3411                                         o_ptr->pval = 1 + m_bonus(3, level);
3412                                         if (one_in_(4)) o_ptr->pval++;
3413
3414                                         /* Cursed */
3415                                         if (power < 0)
3416                                         {
3417                                                 /* Broken */
3418                                                 o_ptr->ident |= (IDENT_BROKEN);
3419
3420                                                 /* Cursed */
3421                                                 o_ptr->curse_flags |= TRC_CURSED;
3422
3423                                                 /* Reverse bonuses */
3424                                                 o_ptr->pval = 0 - o_ptr->pval;
3425                                         }
3426
3427                                         break;
3428                                 }
3429                                 case SV_RING_AGGRAVATION:
3430                                 {
3431                                         /* Broken */
3432                                         o_ptr->ident |= (IDENT_BROKEN);
3433
3434                                         /* Cursed */
3435                                         o_ptr->curse_flags |= TRC_CURSED;
3436
3437                                         if (power > 0) power = 0 - power;
3438                                         break;
3439                                 }
3440                         }
3441                         if ((one_in_(400) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
3442                             || (power > 2)) /* power > 2 is debug only */
3443                         {
3444                                 o_ptr->pval = MIN(o_ptr->pval, 4);
3445                                 /* Randart amulet */
3446                                 create_artifact(o_ptr, FALSE);
3447                         }
3448                         else if ((power == 2) && one_in_(2))
3449                         {
3450                                 while(!o_ptr->name2)
3451                                 {
3452                                         int tmp = m_bonus(10, level);
3453                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3454                                         switch(randint1(28))
3455                                         {
3456                                         case 1: case 2:
3457                                                 o_ptr->name2 = EGO_RING_THROW;
3458                                                 break;
3459                                         case 3: case 4:
3460                                                 if (have_flag(k_ptr->flags, TR_REGEN)) break;
3461                                                 o_ptr->name2 = EGO_RING_REGEN;
3462                                                 break;
3463                                         case 5: case 6:
3464                                                 if (have_flag(k_ptr->flags, TR_LITE_1)) break;
3465                                                 o_ptr->name2 = EGO_RING_LITE;
3466                                                 break;
3467                                         case 7: case 8:
3468                                                 if (have_flag(k_ptr->flags, TR_TELEPORT)) break;
3469                                                 o_ptr->name2 = EGO_RING_TELEPORT;
3470                                                 break;
3471                                         case 9: case 10:
3472                                                 if (o_ptr->to_h) break;
3473                                                 o_ptr->name2 = EGO_RING_TO_H;
3474                                                 break;
3475                                         case 11: case 12:
3476                                                 if (o_ptr->to_d) break;
3477                                                 o_ptr->name2 = EGO_RING_TO_D;
3478                                                 break;
3479                                         case 13:
3480                                                 if ((o_ptr->to_h) || (o_ptr->to_d)) break;
3481                                                 o_ptr->name2 = EGO_RING_SLAY;
3482                                                 break;
3483                                         case 14:
3484                                                 if ((have_flag(k_ptr->flags, TR_STR)) || o_ptr->to_h || o_ptr->to_d) break;
3485                                                 o_ptr->name2 = EGO_RING_WIZARD;
3486                                                 break;
3487                                         case 15:
3488                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3489                                                 o_ptr->name2 = EGO_RING_HERO;
3490                                                 break;
3491                                         case 16:
3492                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3493                                                 if (tmp > 8) o_ptr->name2 = EGO_RING_MANA_BALL;
3494                                                 else if (tmp > 4) o_ptr->name2 = EGO_RING_MANA_BOLT;
3495                                                 else o_ptr->name2 = EGO_RING_MAGIC_MIS;
3496                                                 break;
3497                                         case 17:
3498                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3499                                                 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;
3500                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_F;
3501                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_FIRE_BALL;
3502                                                 else o_ptr->name2 = EGO_RING_FIRE_BOLT;
3503                                                 break;
3504                                         case 18:
3505                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3506                                                 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;
3507                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_C;
3508                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_COLD_BALL;
3509                                                 else o_ptr->name2 = EGO_RING_COLD_BOLT;
3510                                                 break;
3511                                         case 19:
3512                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3513                                                 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;
3514                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ELEC_BALL;
3515                                                 else o_ptr->name2 = EGO_RING_ELEC_BOLT;
3516                                                 break;
3517                                         case 20:
3518                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3519                                                 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;
3520                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ACID_BALL;
3521                                                 else o_ptr->name2 = EGO_RING_ACID_BOLT;
3522                                                 break;
3523                                         case 21: case 22: case 23: case 24: case 25: case 26:
3524                                                 switch (o_ptr->sval)
3525                                                 {
3526                                                 case SV_RING_SPEED:
3527                                                         if (!one_in_(3)) break;
3528                                                         o_ptr->name2 = EGO_RING_D_SPEED;
3529                                                         break;
3530                                                 case SV_RING_DAMAGE:
3531                                                 case SV_RING_ACCURACY:
3532                                                 case SV_RING_SLAYING:
3533                                                         if (one_in_(2)) break;
3534                                                         if (one_in_(2)) o_ptr->name2 = EGO_RING_HERO;
3535                                                         else
3536                                                         {
3537                                                                 o_ptr->name2 = EGO_RING_BERSERKER;
3538                                                                 o_ptr->to_h -= 2+randint1(4);
3539                                                                 o_ptr->to_d += 2+randint1(4);
3540                                                         }
3541                                                         break;
3542                                                 case SV_RING_PROTECTION:
3543                                                         o_ptr->name2 = EGO_RING_SUPER_AC;
3544                                                         o_ptr->to_a += 7 + m_bonus(5, level);
3545                                                         break;
3546                                                 case SV_RING_RES_FEAR:
3547                                                         o_ptr->name2 = EGO_RING_HERO;
3548                                                         break;
3549                                                 case SV_RING_SHOTS:
3550                                                         if (one_in_(2)) break;
3551                                                         o_ptr->name2 = EGO_RING_HUNTER;
3552                                                         break;
3553                                                 case SV_RING_SEARCHING:
3554                                                         o_ptr->name2 = EGO_RING_STEALTH;
3555                                                         break;
3556                                                 case SV_RING_TELEPORTATION:
3557                                                         o_ptr->name2 = EGO_RING_TELE_AWAY;
3558                                                         break;
3559                                                 case SV_RING_RES_BLINDNESS:
3560                                                         if (one_in_(2))
3561                                                                 o_ptr->name2 = EGO_RING_RES_LITE;
3562                                                         else
3563                                                                 o_ptr->name2 = EGO_RING_RES_DARK;
3564                                                         break;
3565                                                 case SV_RING_LORDLY:
3566                                                         if (!one_in_(20)) break;
3567                                                         one_lordly_high_resistance(o_ptr);
3568                                                         one_lordly_high_resistance(o_ptr);
3569                                                         o_ptr->name2 = EGO_RING_TRUE;
3570                                                         break;
3571                                                 case SV_RING_SUSTAIN:
3572                                                         if (!one_in_(4)) break;
3573                                                         o_ptr->name2 = EGO_RING_RES_TIME;
3574                                                         break;
3575                                                 case SV_RING_FLAMES:
3576                                                         if (!one_in_(2)) break;
3577                                                         o_ptr->name2 = EGO_RING_DRAGON_F;
3578                                                         break;
3579                                                 case SV_RING_ICE:
3580                                                         if (!one_in_(2)) break;
3581                                                         o_ptr->name2 = EGO_RING_DRAGON_C;
3582                                                         break;
3583                                                 case SV_RING_WARNING:
3584                                                         if (!one_in_(2)) break;
3585                                                         o_ptr->name2 = EGO_RING_M_DETECT;
3586                                                         break;
3587                                                 default:
3588                                                         break;
3589                                                 }
3590                                                 break;
3591                                         }
3592                                 }
3593                                 /* Uncurse it */
3594                                 o_ptr->curse_flags = 0L;
3595                         }
3596                         else if ((power == -2) && one_in_(2))
3597                         {
3598                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3599                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3600                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3601                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3602                                 o_ptr->art_flags[0] = 0;
3603                                 o_ptr->art_flags[1] = 0;
3604                                 while(!o_ptr->name2)
3605                                 {
3606                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3607                                         switch(randint1(5))
3608                                         {
3609                                         case 1:
3610                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3611                                                 o_ptr->name2 = EGO_RING_DRAIN_EXP;
3612                                                 break;
3613                                         case 2:
3614                                                 o_ptr->name2 = EGO_RING_NO_MELEE;
3615                                                 break;
3616                                         case 3:
3617                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3618                                                 o_ptr->name2 = EGO_RING_AGGRAVATE;
3619                                                 break;
3620                                         case 4:
3621                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3622                                                 o_ptr->name2 = EGO_RING_TY_CURSE;
3623                                                 break;
3624                                         case 5:
3625                                                 o_ptr->name2 = EGO_RING_ALBINO;
3626                                                 break;
3627                                         }
3628                                 }
3629                                 /* Broken */
3630                                 o_ptr->ident |= (IDENT_BROKEN);
3631
3632                                 /* Cursed */
3633                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3634                         }
3635                         break;
3636                 }
3637
3638                 case TV_AMULET:
3639                 {
3640                         /* Analyze */
3641                         switch (o_ptr->sval)
3642                         {
3643                                 /* Amulet of wisdom/charisma */
3644                                 case SV_AMULET_INTELLIGENCE:
3645                                 case SV_AMULET_WISDOM:
3646                                 case SV_AMULET_CHARISMA:
3647                                 {
3648                                         o_ptr->pval = 1 + m_bonus(5, level);
3649
3650                                         /* Cursed */
3651                                         if (power < 0)
3652                                         {
3653                                                 /* Broken */
3654                                                 o_ptr->ident |= (IDENT_BROKEN);
3655
3656                                                 /* Cursed */
3657                                                 o_ptr->curse_flags |= (TRC_CURSED);
3658
3659                                                 /* Reverse bonuses */
3660                                                 o_ptr->pval = 0 - o_ptr->pval;
3661                                         }
3662
3663                                         break;
3664                                 }
3665
3666                                 /* Amulet of brilliance */
3667                                 case SV_AMULET_BRILLIANCE:
3668                                 {
3669                                         o_ptr->pval = 1 + m_bonus(3, level);
3670                                         if (one_in_(4)) o_ptr->pval++;
3671
3672                                         /* Cursed */
3673                                         if (power < 0)
3674                                         {
3675                                                 /* Broken */
3676                                                 o_ptr->ident |= (IDENT_BROKEN);
3677
3678                                                 /* Cursed */
3679                                                 o_ptr->curse_flags |= (TRC_CURSED);
3680
3681                                                 /* Reverse bonuses */
3682                                                 o_ptr->pval = 0 - o_ptr->pval;
3683                                         }
3684
3685                                         break;
3686                                 }
3687
3688                                 case SV_AMULET_NO_MAGIC: case SV_AMULET_NO_TELE:
3689                                 {
3690                                         if (power < 0)
3691                                         {
3692                                                 o_ptr->curse_flags |= (TRC_CURSED);
3693                                         }
3694                                         break;
3695                                 }
3696
3697                                 case SV_AMULET_RESISTANCE:
3698                                 {
3699                                         if (one_in_(5)) one_high_resistance(o_ptr);
3700                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_RES_POIS);
3701                                 }
3702                                 break;
3703
3704                                 /* Amulet of searching */
3705                                 case SV_AMULET_SEARCHING:
3706                                 {
3707                                         o_ptr->pval = randint1(2) + m_bonus(4, level);
3708
3709                                         /* Cursed */
3710                                         if (power < 0)
3711                                         {
3712                                                 /* Broken */
3713                                                 o_ptr->ident |= (IDENT_BROKEN);
3714
3715                                                 /* Cursed */
3716                                                 o_ptr->curse_flags |= (TRC_CURSED);
3717
3718                                                 /* Reverse bonuses */
3719                                                 o_ptr->pval = 0 - (o_ptr->pval);
3720                                         }
3721
3722                                         break;
3723                                 }
3724
3725                                 /* Amulet of the Magi -- never cursed */
3726                                 case SV_AMULET_THE_MAGI:
3727                                 {
3728                                         o_ptr->pval = randint1(5) + m_bonus(5, level);
3729                                         o_ptr->to_a = randint1(5) + m_bonus(5, level);
3730
3731                                         /* gain one low ESP */
3732                                         add_esp_weak(o_ptr, FALSE);
3733
3734                                         break;
3735                                 }
3736
3737                                 /* Amulet of Doom -- always cursed */
3738                                 case SV_AMULET_DOOM:
3739                                 {
3740                                         /* Broken */
3741                                         o_ptr->ident |= (IDENT_BROKEN);
3742
3743                                         /* Cursed */
3744                                         o_ptr->curse_flags |= (TRC_CURSED);
3745
3746                                         /* Penalize */
3747                                         o_ptr->pval = 0 - (randint1(5) + m_bonus(5, level));
3748                                         o_ptr->to_a = 0 - (randint1(5) + m_bonus(5, level));
3749                                         if (power > 0) power = 0 - power;
3750
3751                                         break;
3752                                 }
3753
3754                                 case SV_AMULET_MAGIC_MASTERY:
3755                                 {
3756                                         o_ptr->pval = 1 + m_bonus(4, level);
3757
3758                                         /* Cursed */
3759                                         if (power < 0)
3760                                         {
3761                                                 /* Broken */
3762                                                 o_ptr->ident |= (IDENT_BROKEN);
3763
3764                                                 /* Cursed */
3765                                                 o_ptr->curse_flags |= (TRC_CURSED);
3766
3767                                                 /* Reverse bonuses */
3768                                                 o_ptr->pval = 0 - o_ptr->pval;
3769                                         }
3770
3771                                         break;
3772                                 }
3773                         }
3774                         if ((one_in_(150) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
3775                             || (power > 2)) /* power > 2 is debug only */
3776                         {
3777                                 o_ptr->pval = MIN(o_ptr->pval, 4);
3778                                 /* Randart amulet */
3779                                 create_artifact(o_ptr, FALSE);
3780                         }
3781                         else if ((power == 2) && one_in_(2))
3782                         {
3783                                 while(!o_ptr->name2)
3784                                 {
3785                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3786                                         switch(randint1(21))
3787                                         {
3788                                         case 1: case 2:
3789                                                 if (have_flag(k_ptr->flags, TR_SLOW_DIGEST)) break;
3790                                                 o_ptr->name2 = EGO_AMU_SLOW_D;
3791                                                 break;
3792                                         case 3: case 4:
3793                                                 if (o_ptr->pval) break;
3794                                                 o_ptr->name2 = EGO_AMU_INFRA;
3795                                                 break;
3796                                         case 5: case 6:
3797                                                 if (have_flag(k_ptr->flags, TR_SEE_INVIS)) break;
3798                                                 o_ptr->name2 = EGO_AMU_SEE_INVIS;
3799                                                 break;
3800                                         case 7: case 8:
3801                                                 if (have_flag(k_ptr->flags, TR_HOLD_EXP)) break;
3802                                                 o_ptr->name2 = EGO_AMU_HOLD_EXP;
3803                                                 break;
3804                                         case 9:
3805                                                 if (have_flag(k_ptr->flags, TR_LEVITATION)) break;
3806                                                 o_ptr->name2 = EGO_AMU_LEVITATION;
3807                                                 break;
3808                                         case 10: case 11: case 21:
3809                                                 o_ptr->name2 = EGO_AMU_AC;
3810                                                 break;
3811                                         case 12:
3812                                                 if (have_flag(k_ptr->flags, TR_RES_FIRE)) break;
3813                                                 if (m_bonus(10, level) > 8)
3814                                                         o_ptr->name2 = EGO_AMU_RES_FIRE_;
3815                                                 else
3816                                                         o_ptr->name2 = EGO_AMU_RES_FIRE;
3817                                                 break;
3818                                         case 13:
3819                                                 if (have_flag(k_ptr->flags, TR_RES_COLD)) break;
3820                                                 if (m_bonus(10, level) > 8)
3821                                                         o_ptr->name2 = EGO_AMU_RES_COLD_;
3822                                                 else
3823                                                         o_ptr->name2 = EGO_AMU_RES_COLD;
3824                                                 break;
3825                                         case 14:
3826                                                 if (have_flag(k_ptr->flags, TR_RES_ELEC)) break;
3827                                                 if (m_bonus(10, level) > 8)
3828                                                         o_ptr->name2 = EGO_AMU_RES_ELEC_;
3829                                                 else
3830                                                         o_ptr->name2 = EGO_AMU_RES_ELEC;
3831                                                 break;
3832                                         case 15:
3833                                                 if (have_flag(k_ptr->flags, TR_RES_ACID)) break;
3834                                                 if (m_bonus(10, level) > 8)
3835                                                         o_ptr->name2 = EGO_AMU_RES_ACID_;
3836                                                 else
3837                                                         o_ptr->name2 = EGO_AMU_RES_ACID;
3838                                                 break;
3839                                         case 16: case 17: case 18: case 19: case 20:
3840                                                 switch (o_ptr->sval)
3841                                                 {
3842                                                 case SV_AMULET_TELEPORT:
3843                                                         if (m_bonus(10, level) > 9) o_ptr->name2 = EGO_AMU_D_DOOR;
3844                                                         else if (one_in_(2)) o_ptr->name2 = EGO_AMU_JUMP;
3845                                                         else o_ptr->name2 = EGO_AMU_TELEPORT;
3846                                                         break;
3847                                                 case SV_AMULET_RESIST_ACID:
3848                                                         if ((m_bonus(10, level) > 6) && one_in_(2)) o_ptr->name2 = EGO_AMU_RES_ACID_;
3849                                                         break;
3850                                                 case SV_AMULET_SEARCHING:
3851                                                         o_ptr->name2 = EGO_AMU_STEALTH;
3852                                                         break;
3853                                                 case SV_AMULET_BRILLIANCE:
3854                                                         if (!one_in_(3)) break;
3855                                                         o_ptr->name2 = EGO_AMU_IDENT;
3856                                                         break;
3857                                                 case SV_AMULET_CHARISMA:
3858                                                         if (!one_in_(3)) break;
3859                                                         o_ptr->name2 = EGO_AMU_CHARM;
3860                                                         break;
3861                                                 case SV_AMULET_THE_MAGI:
3862                                                         if (one_in_(2)) break;
3863                                                         o_ptr->name2 = EGO_AMU_GREAT;
3864                                                         break;
3865                                                 case SV_AMULET_RESISTANCE:
3866                                                         if (!one_in_(5)) break;
3867                                                         o_ptr->name2 = EGO_AMU_DEFENDER;
3868                                                         break;
3869                                                 case SV_AMULET_TELEPATHY:
3870                                                         if (!one_in_(3)) break;
3871                                                         o_ptr->name2 = EGO_AMU_DETECTION;
3872                                                         break;
3873                                                 }
3874                                         }
3875                                 }
3876                                 /* Uncurse it */
3877                                 o_ptr->curse_flags = 0L;
3878                         }
3879                         else if ((power == -2) && one_in_(2))
3880                         {
3881                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3882                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3883                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3884                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3885                                 o_ptr->art_flags[0] = 0;
3886                                 o_ptr->art_flags[1] = 0;
3887                                 while(!o_ptr->name2)
3888                                 {
3889                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3890                                         switch(randint1(5))
3891                                         {
3892                                         case 1:
3893                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3894                                                 o_ptr->name2 = EGO_AMU_DRAIN_EXP;
3895                                                 break;
3896                                         case 2:
3897                                                 o_ptr->name2 = EGO_AMU_FOOL;
3898                                                 break;
3899                                         case 3:
3900                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3901                                                 o_ptr->name2 = EGO_AMU_AGGRAVATE;
3902                                                 break;
3903                                         case 4:
3904                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3905                                                 o_ptr->name2 = EGO_AMU_TY_CURSE;
3906                                                 break;
3907                                         case 5:
3908                                                 o_ptr->name2 = EGO_AMU_NAIVETY;
3909                                                 break;
3910                                         }
3911                                 }
3912                                 /* Broken */
3913                                 o_ptr->ident |= (IDENT_BROKEN);
3914
3915                                 /* Cursed */
3916                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3917                         }
3918                         break;
3919                 }
3920         }
3921 }
3922
3923 /*!
3924  * @brief モンスターが人形のベースにできるかを返す
3925  * @param r_idx チェックしたいモンスター種族のID
3926  * @return 人形にできるならTRUEを返す
3927  */
3928 static bool item_monster_okay(int r_idx)
3929 {
3930         monster_race *r_ptr = &r_info[r_idx];
3931
3932         /* No uniques */
3933         if (r_ptr->flags1 & RF1_UNIQUE) return (FALSE);
3934         if (r_ptr->flags7 & RF7_KAGE) return (FALSE);
3935         if (r_ptr->flagsr & RFR_RES_ALL) return (FALSE);
3936         if (r_ptr->flags7 & RF7_NAZGUL) return (FALSE);
3937         if (r_ptr->flags1 & RF1_FORCE_DEPTH) return (FALSE);
3938         if (r_ptr->flags7 & RF7_UNIQUE2) return (FALSE);
3939
3940         /* Okay */
3941         return (TRUE);
3942 }
3943
3944
3945 /*!
3946  * @brief その他雑多のオブジェクトに生成ランクごとの強化を与えるサブルーチン
3947  * Apply magic to an item known to be "boring"
3948  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3949  * @param level 生成基準階
3950  * @param power 生成ランク
3951  * @return なし
3952  * @details
3953  * Hack -- note the special code for various items
3954  */
3955 static void a_m_aux_4(object_type *o_ptr, int level, int power)
3956 {
3957         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3958
3959         /* Unused */
3960         (void)level;
3961
3962         /* Apply magic (good or bad) according to type */
3963         switch (o_ptr->tval)
3964         {
3965                 case TV_WHISTLE:
3966                 {
3967 #if 0
3968                         /* Cursed */
3969                         if (power < 0)
3970                         {
3971                                 /* Broken */
3972                                 o_ptr->ident |= (IDENT_BROKEN);
3973
3974                                 /* Cursed */
3975                                 o_ptr->curse_flags |= (TRC_CURSED);
3976                         }
3977 #endif
3978                         break;
3979                 }
3980                 case TV_FLASK:
3981                 {
3982                         o_ptr->xtra4 = o_ptr->pval;
3983                         o_ptr->pval = 0;
3984                         break;
3985                 }
3986                 case TV_LITE:
3987                 {
3988                         /* Hack -- Torches -- random fuel */
3989                         if (o_ptr->sval == SV_LITE_TORCH)
3990                         {
3991                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3992                                 o_ptr->pval = 0;
3993                         }
3994
3995                         /* Hack -- Lanterns -- random fuel */
3996                         if (o_ptr->sval == SV_LITE_LANTERN)
3997                         {
3998                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3999                                 o_ptr->pval = 0;
4000                         }
4001
4002                         if (power > 2) /* power > 2 is debug only */
4003                         {
4004                                 create_artifact(o_ptr, FALSE);
4005                         }
4006                         else if ((power == 2) || ((power == 1) && one_in_(3)))
4007                         {
4008                                 while (!o_ptr->name2)
4009                                 {
4010                                         while (1)
4011                                         {
4012                                                 bool okay_flag = TRUE;
4013
4014                                                 o_ptr->name2 = get_random_ego(INVEN_LITE, TRUE);
4015
4016                                                 switch (o_ptr->name2)
4017                                                 {
4018                                                 case EGO_LITE_LONG:
4019                                                         if (o_ptr->sval == SV_LITE_FEANOR)
4020                                                                 okay_flag = FALSE;
4021                                                 }
4022                                                 if (okay_flag)
4023                                                         break;
4024                                         }
4025                                 }
4026                         }
4027                         else if (power == -2)
4028                         {
4029                                 o_ptr->name2 = get_random_ego(INVEN_LITE, FALSE);
4030
4031                                 switch (o_ptr->name2)
4032                                 {
4033                                 case EGO_LITE_DARKNESS:
4034                                         o_ptr->xtra4 = 0;
4035
4036                                         if (o_ptr->sval == SV_LITE_TORCH)
4037                                         {
4038                                                 add_flag(o_ptr->art_flags, TR_LITE_M1);
4039                                         }
4040                                         else if (o_ptr->sval == SV_LITE_LANTERN)
4041                                         {
4042                                                 add_flag(o_ptr->art_flags, TR_LITE_M2);
4043                                         }
4044                                         else if (o_ptr->sval == SV_LITE_FEANOR)
4045                                         {
4046                                                 add_flag(o_ptr->art_flags, TR_LITE_M3);
4047                                         }
4048                                         break;
4049                                 }
4050                         }
4051
4052                         break;
4053                 }
4054
4055                 case TV_WAND:
4056                 case TV_STAFF:
4057                 {
4058                         /* The wand or staff gets a number of initial charges equal
4059                          * to between 1/2 (+1) and the full object kind's pval. -LM-
4060                          */
4061                         o_ptr->pval = k_ptr->pval / 2 + randint1((k_ptr->pval + 1) / 2);
4062                         break;
4063                 }
4064
4065                 case TV_ROD:
4066                 {
4067                         /* Transfer the pval. -LM- */
4068                         o_ptr->pval = k_ptr->pval;
4069                         break;
4070                 }
4071
4072                 case TV_CAPTURE:
4073                 {
4074                         o_ptr->pval = 0;
4075                         object_aware(o_ptr);
4076                         object_known(o_ptr);
4077                         break;
4078                 }
4079
4080                 case TV_FIGURINE:
4081                 {
4082                         int i = 1;
4083                         int check;
4084
4085                         monster_race *r_ptr;
4086
4087                         /* Pick a random non-unique monster race */
4088                         while (1)
4089                         {
4090                                 i = randint1(max_r_idx - 1);
4091
4092                                 if (!item_monster_okay(i)) continue;
4093                                 if (i == MON_TSUCHINOKO) continue;
4094
4095                                 r_ptr = &r_info[i];
4096
4097                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
4098
4099                                 /* Ignore dead monsters */
4100                                 if (!r_ptr->rarity) continue;
4101
4102                                 /* Ignore uncommon monsters */
4103                                 if (r_ptr->rarity > 100) continue;
4104
4105                                 /* Prefer less out-of-depth monsters */
4106                                 if (randint0(check)) continue;
4107
4108                                 break;
4109                         }
4110
4111                         o_ptr->pval = i;
4112
4113                         /* Some figurines are cursed */
4114                         if (one_in_(6)) o_ptr->curse_flags |= TRC_CURSED;
4115
4116                         break;
4117                 }
4118
4119                 case TV_CORPSE:
4120                 {
4121                         int i = 1;
4122                         int check;
4123
4124                         u32b match = 0;
4125
4126                         monster_race *r_ptr;
4127
4128                         if (o_ptr->sval == SV_SKELETON)
4129                         {
4130                                 match = RF9_DROP_SKELETON;
4131                         }
4132                         else if (o_ptr->sval == SV_CORPSE)
4133                         {
4134                                 match = RF9_DROP_CORPSE;
4135                         }
4136
4137                         /* Hack -- Remove the monster restriction */
4138                         get_mon_num_prep(item_monster_okay, NULL);
4139
4140                         /* Pick a random non-unique monster race */
4141                         while (1)
4142                         {
4143                                 i = get_mon_num(dun_level);
4144
4145                                 r_ptr = &r_info[i];
4146
4147                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
4148
4149                                 /* Ignore dead monsters */
4150                                 if (!r_ptr->rarity) continue;
4151
4152                                 /* Ignore corpseless monsters */
4153                                 if (!(r_ptr->flags9 & match)) continue;
4154
4155                                 /* Prefer less out-of-depth monsters */
4156                                 if (randint0(check)) continue;
4157
4158                                 break;
4159                         }
4160
4161                         o_ptr->pval = i;
4162
4163
4164                         object_aware(o_ptr);
4165                         object_known(o_ptr);
4166                         break;
4167                 }
4168
4169                 case TV_STATUE:
4170                 {
4171                         int i = 1;
4172
4173                         monster_race *r_ptr;
4174
4175                         /* Pick a random monster race */
4176                         while (1)
4177                         {
4178                                 i = randint1(max_r_idx - 1);
4179
4180                                 r_ptr = &r_info[i];
4181
4182                                 /* Ignore dead monsters */
4183                                 if (!r_ptr->rarity) continue;
4184
4185                                 break;
4186                         }
4187
4188                         o_ptr->pval = i;
4189
4190                         if (cheat_peek)
4191                         {
4192                                 msg_format(_("%sの像", "Statue of %s"), r_name + r_ptr->name);
4193                         }
4194                         object_aware(o_ptr);
4195                         object_known(o_ptr);
4196
4197                         break;
4198                 }
4199
4200                 case TV_CHEST:
4201                 {
4202                         byte obj_level = k_info[o_ptr->k_idx].level;
4203
4204                         /* Hack -- skip ruined chests */
4205                         if (obj_level <= 0) break;
4206
4207                         /* Hack -- pick a "difficulty" */
4208                         o_ptr->pval = randint1(obj_level);
4209                         if (o_ptr->sval == SV_CHEST_KANDUME) o_ptr->pval = 6;
4210
4211                         o_ptr->xtra3 = dun_level + 5;
4212
4213                         /* Never exceed "difficulty" of 55 to 59 */
4214                         if (o_ptr->pval > 55) o_ptr->pval = 55 + (byte)randint0(5);
4215
4216                         break;
4217                 }
4218         }
4219 }
4220
4221 /*!
4222  * @brief 生成されたベースアイテムに魔法的な強化を与えるメインルーチン
4223  * Complete the "creation" of an object by applying "magic" to the item
4224  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
4225  * @param lev 生成基準階
4226  * @param mode 生成オプション
4227  * @return なし
4228  * @details
4229  * This includes not only rolling for random bonuses, but also putting the\n
4230  * finishing touches on ego-items and artifacts, giving charges to wands and\n
4231  * staffs, giving fuel to lites, and placing traps on chests.\n
4232  *\n
4233  * In particular, note that "Instant Artifacts", if "created" by an external\n
4234  * routine, must pass through this function to complete the actual creation.\n
4235  *\n
4236  * The base "chance" of the item being "good" increases with the "level"\n
4237  * parameter, which is usually derived from the dungeon level, being equal\n
4238  * to the level plus 10, up to a maximum of 75.  If "good" is true, then\n
4239  * the object is guaranteed to be "good".  If an object is "good", then\n
4240  * the chance that the object will be "great" (ego-item or artifact), also\n
4241  * increases with the "level", being equal to half the level, plus 5, up to\n
4242  * a maximum of 20.  If "great" is true, then the object is guaranteed to be\n
4243  * "great".  At dungeon level 65 and below, 15/100 objects are "great".\n
4244  *\n
4245  * If the object is not "good", there is a chance it will be "cursed", and\n
4246  * if it is "cursed", there is a chance it will be "broken".  These chances\n
4247  * are related to the "good" / "great" chances above.\n
4248  *\n
4249  * Otherwise "normal" rings and amulets will be "good" half the time and\n
4250  * "cursed" half the time, unless the ring/amulet is always good or cursed.\n
4251  *\n
4252  * If "okay" is true, and the object is going to be "great", then there is\n
4253  * a chance that an artifact will be created.  This is true even if both the\n
4254  * "good" and "great" arguments are false.  As a total hack, if "great" is\n
4255  * true, then the item gets 3 extra "attempts" to become an artifact.\n
4256  */
4257 void apply_magic(object_type *o_ptr, int lev, u32b mode)
4258 {
4259         int i, rolls, f1, f2, power;
4260
4261         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN) lev += randint0(p_ptr->lev/2+10);
4262
4263         /* Maximum "level" for various things */
4264         if (lev > MAX_DEPTH - 1) lev = MAX_DEPTH - 1;
4265
4266         /* Base chance of being "good" */
4267         f1 = lev + 10;
4268
4269         /* Maximal chance of being "good" */
4270         if (f1 > d_info[dungeon_type].obj_good) f1 = d_info[dungeon_type].obj_good;
4271
4272         /* Base chance of being "great" */
4273         f2 = f1 * 2 / 3;
4274
4275         /* Maximal chance of being "great" */
4276         if ((p_ptr->pseikaku != SEIKAKU_MUNCHKIN) && (f2 > d_info[dungeon_type].obj_great))
4277                 f2 = d_info[dungeon_type].obj_great;
4278
4279         if (p_ptr->muta3 & MUT3_GOOD_LUCK)
4280         {
4281                 f1 += 5;
4282                 f2 += 2;
4283         }
4284         else if(p_ptr->muta3 & MUT3_BAD_LUCK)
4285         {
4286                 f1 -= 5;
4287                 f2 -= 2;
4288         }
4289
4290         /* Assume normal */
4291         power = 0;
4292
4293         /* Roll for "good" */
4294         if ((mode & AM_GOOD) || magik(f1))
4295         {
4296                 /* Assume "good" */
4297                 power = 1;
4298
4299                 /* Roll for "great" */
4300                 if ((mode & AM_GREAT) || magik(f2))
4301                 {
4302                         power = 2;
4303
4304                         /* Roll for "special" */
4305                         if (mode & AM_SPECIAL) power = 3;
4306                 }
4307         }
4308
4309         /* Roll for "cursed" */
4310         else if (magik(f1))
4311         {
4312                 /* Assume "cursed" */
4313                 power = -1;
4314
4315                 /* Roll for "broken" */
4316                 if (magik(f2)) power = -2;
4317         }
4318
4319         /* Apply curse */
4320         if (mode & AM_CURSED)
4321         {
4322                 /* Assume 'cursed' */
4323                 if (power > 0)
4324                 {
4325                         power = 0 - power;
4326                 }
4327                 /* Everything else gets more badly cursed */
4328                 else
4329                 {
4330                         power--;
4331                 }
4332         }
4333
4334         /* Assume no rolls */
4335         rolls = 0;
4336
4337         /* Get one roll if excellent */
4338         if (power >= 2) rolls = 1;
4339
4340         /* Hack -- Get four rolls if forced great or special */
4341         if (mode & (AM_GREAT | AM_SPECIAL)) rolls = 4;
4342
4343         /* Hack -- Get no rolls if not allowed */
4344         if ((mode & AM_NO_FIXED_ART) || o_ptr->name1) rolls = 0;
4345
4346         /* Roll for artifacts if allowed */
4347         for (i = 0; i < rolls; i++)
4348         {
4349                 /* Roll for an artifact */
4350                 if (make_artifact(o_ptr)) break;
4351                 if ((p_ptr->muta3 & MUT3_GOOD_LUCK) && one_in_(77))
4352                 {
4353                         if (make_artifact(o_ptr)) break;
4354                 }
4355         }
4356
4357
4358         /* Hack -- analyze artifacts */
4359         if (object_is_fixed_artifact(o_ptr))
4360         {
4361                 artifact_type *a_ptr = &a_info[o_ptr->name1];
4362
4363                 /* Hack -- Mark the artifact as "created" */
4364                 a_ptr->cur_num = 1;
4365
4366                 /* Hack -- Memorize location of artifact in saved floors */
4367                 if (character_dungeon)
4368                         a_ptr->floor_id = p_ptr->floor_id;
4369
4370                 /* Extract the other fields */
4371                 o_ptr->pval = a_ptr->pval;
4372                 o_ptr->ac = a_ptr->ac;
4373                 o_ptr->dd = a_ptr->dd;
4374                 o_ptr->ds = a_ptr->ds;
4375                 o_ptr->to_a = a_ptr->to_a;
4376                 o_ptr->to_h = a_ptr->to_h;
4377                 o_ptr->to_d = a_ptr->to_d;
4378                 o_ptr->weight = a_ptr->weight;
4379                 o_ptr->xtra2 = a_ptr->act_idx;
4380
4381                 if (o_ptr->name1 == ART_MILIM)
4382                 {
4383                     if(p_ptr->pseikaku == SEIKAKU_SEXY)
4384                     {
4385                         o_ptr->pval = 3;
4386                     }
4387                 }
4388
4389                 /* Hack -- extract the "broken" flag */
4390                 if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4391
4392                 /* Hack -- extract the "cursed" flag */
4393                 if (a_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4394                 if (a_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4395                 if (a_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4396                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4397                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4398                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4399
4400                 /* Done */
4401                 return;
4402         }
4403
4404
4405         /* Apply magic */
4406         switch (o_ptr->tval)
4407         {
4408                 case TV_DIGGING:
4409                 case TV_HAFTED:
4410                 case TV_BOW:
4411                 case TV_SHOT:
4412                 case TV_ARROW:
4413                 case TV_BOLT:
4414                 {
4415                         if (power) a_m_aux_1(o_ptr, lev, power);
4416                         break;
4417                 }
4418
4419                 case TV_POLEARM:
4420                 {
4421                         if (power && !(o_ptr->sval == SV_DEATH_SCYTHE)) a_m_aux_1(o_ptr, lev, power);
4422                         break;
4423                 }
4424
4425                 case TV_SWORD:
4426                 {
4427                         if (power && !(o_ptr->sval == SV_DOKUBARI)) a_m_aux_1(o_ptr, lev, power);
4428                         break;
4429                 }
4430
4431                 case TV_DRAG_ARMOR:
4432                 case TV_HARD_ARMOR:
4433                 case TV_SOFT_ARMOR:
4434                 case TV_SHIELD:
4435                 case TV_HELM:
4436                 case TV_CROWN:
4437                 case TV_CLOAK:
4438                 case TV_GLOVES:
4439                 case TV_BOOTS:
4440                 {
4441                         /* Elven Cloak and Black Clothes ... */
4442                         if (((o_ptr->tval == TV_CLOAK) && (o_ptr->sval == SV_ELVEN_CLOAK)) ||
4443                             ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_KUROSHOUZOKU)))
4444                                 o_ptr->pval = randint1(4);
4445
4446 #if 1
4447                         if (power ||
4448                              ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
4449                              ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
4450                              ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
4451                              ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)))
4452                                 a_m_aux_2(o_ptr, lev, power);
4453 #else
4454                         if (power) a_m_aux_2(o_ptr, lev, power);
4455 #endif
4456                         break;
4457                 }
4458
4459                 case TV_RING:
4460                 case TV_AMULET:
4461                 {
4462                         if (!power && (randint0(100) < 50)) power = -1;
4463                         a_m_aux_3(o_ptr, lev, power);
4464                         break;
4465                 }
4466
4467                 default:
4468                 {
4469                         a_m_aux_4(o_ptr, lev, power);
4470                         break;
4471                 }
4472         }
4473
4474         if ((o_ptr->tval == TV_SOFT_ARMOR) &&
4475             (o_ptr->sval == SV_ABUNAI_MIZUGI) &&
4476             (p_ptr->pseikaku == SEIKAKU_SEXY))
4477         {
4478                 o_ptr->pval = 3;
4479                 add_flag(o_ptr->art_flags, TR_STR);
4480                 add_flag(o_ptr->art_flags, TR_INT);
4481                 add_flag(o_ptr->art_flags, TR_WIS);
4482                 add_flag(o_ptr->art_flags, TR_DEX);
4483                 add_flag(o_ptr->art_flags, TR_CON);
4484                 add_flag(o_ptr->art_flags, TR_CHR);
4485         }
4486
4487         /* Hack -- analyze ego-items */
4488         if (object_is_ego(o_ptr))
4489         {
4490                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
4491
4492                 /* Hack -- acquire "broken" flag */
4493                 if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4494
4495                 /* Hack -- acquire "cursed" flag */
4496                 if (e_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4497                 if (e_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4498                 if (e_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4499                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4500                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4501                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4502
4503                 if (e_ptr->gen_flags & (TRG_ONE_SUSTAIN)) one_sustain(o_ptr);
4504                 if (e_ptr->gen_flags & (TRG_XTRA_POWER)) one_ability(o_ptr);
4505                 if (e_ptr->gen_flags & (TRG_XTRA_H_RES)) one_high_resistance(o_ptr);
4506                 if (e_ptr->gen_flags & (TRG_XTRA_E_RES)) one_ele_resistance(o_ptr);
4507                 if (e_ptr->gen_flags & (TRG_XTRA_D_RES)) one_dragon_ele_resistance(o_ptr);
4508                 if (e_ptr->gen_flags & (TRG_XTRA_L_RES)) one_lordly_high_resistance(o_ptr);
4509                 if (e_ptr->gen_flags & (TRG_XTRA_RES)) one_resistance(o_ptr);
4510                 if (e_ptr->gen_flags & (TRG_XTRA_DICE))
4511                 {
4512                         do
4513                         {
4514                                 o_ptr->dd++;
4515                         }
4516                         while (one_in_(o_ptr->dd));
4517
4518                         if (o_ptr->dd > 9) o_ptr->dd = 9;
4519                 }
4520
4521                 /* Hack -- apply activatin index if needed */
4522                 if (e_ptr->act_idx) o_ptr->xtra2 = e_ptr->act_idx;
4523
4524                 /* Hack -- apply extra penalties if needed */
4525                 if ((object_is_cursed(o_ptr) || object_is_broken(o_ptr)) && !(e_ptr->gen_flags & (TRG_POWERFUL)))
4526                 {
4527                         /* Hack -- obtain bonuses */
4528                         if (e_ptr->max_to_h) o_ptr->to_h -= randint1(e_ptr->max_to_h);
4529                         if (e_ptr->max_to_d) o_ptr->to_d -= randint1(e_ptr->max_to_d);
4530                         if (e_ptr->max_to_a) o_ptr->to_a -= randint1(e_ptr->max_to_a);
4531
4532                         /* Hack -- obtain pval */
4533                         if (e_ptr->max_pval) o_ptr->pval -= randint1(e_ptr->max_pval);
4534                 }
4535
4536                 /* Hack -- apply extra bonuses if needed */
4537                 else
4538                 {
4539                         /* Hack -- obtain bonuses */
4540                         if (e_ptr->max_to_h)
4541                         {
4542                                 if (e_ptr->max_to_h > 127)
4543                                         o_ptr->to_h -= randint1(256-e_ptr->max_to_h);
4544                                 else o_ptr->to_h += randint1(e_ptr->max_to_h);
4545                         }
4546                         if (e_ptr->max_to_d)
4547                         {
4548                                 if (e_ptr->max_to_d > 127)
4549                                         o_ptr->to_d -= randint1(256-e_ptr->max_to_d);
4550                                 else o_ptr->to_d += randint1(e_ptr->max_to_d);
4551                         }
4552                         if (e_ptr->max_to_a)
4553                         {
4554                                 if (e_ptr->max_to_a > 127)
4555                                         o_ptr->to_a -= randint1(256-e_ptr->max_to_a);
4556                                 else o_ptr->to_a += randint1(e_ptr->max_to_a);
4557                         }
4558
4559                         /* Accuracy ego must have high to_h */
4560                         if(o_ptr->name2 == EGO_ACCURACY)
4561                         {
4562                                 while(o_ptr->to_h < o_ptr->to_d + 10)
4563                                 {
4564                                         o_ptr->to_h += 5;
4565                                         o_ptr->to_d -= 5;
4566                                 }
4567                                 o_ptr->to_h = MAX(o_ptr->to_h, 15);
4568                         }
4569
4570                         /* Accuracy ego must have high to_h */
4571                         if(o_ptr->name2 == EGO_VELOCITY)
4572                         {
4573                                 while(o_ptr->to_d < o_ptr->to_h + 10)
4574                                 {
4575                                         o_ptr->to_d += 5;
4576                                         o_ptr->to_h -= 5;
4577                                 }
4578                                 o_ptr->to_d = MAX(o_ptr->to_d, 15);
4579                         }
4580
4581                         /* Protection ego must have high to_a */
4582                         if((o_ptr->name2 == EGO_PROTECTION) || (o_ptr->name2 == EGO_S_PROTECTION) || (o_ptr->name2 == EGO_H_PROTECTION))
4583                         {
4584                                 o_ptr->to_a = MAX(o_ptr->to_a, 15);
4585                         }
4586
4587                         /* Hack -- obtain pval */
4588                         if (e_ptr->max_pval)
4589                         {
4590                                 if ((o_ptr->name2 == EGO_HA) && (have_flag(o_ptr->art_flags, TR_BLOWS)))
4591                                 {
4592                                         o_ptr->pval++;
4593                                         if ((lev > 60) && one_in_(3) && ((o_ptr->dd*(o_ptr->ds+1)) < 15)) o_ptr->pval++;
4594                                 }
4595                                 else if (o_ptr->name2 == EGO_DEMON)
4596                                 {
4597                                         if(have_flag(o_ptr->art_flags, TR_BLOWS))
4598                                         {
4599                                                 o_ptr->pval += randint1(2);
4600                                         }
4601                                         else
4602                                         {
4603                                                 o_ptr->pval += randint1(e_ptr->max_pval);
4604                                         }
4605                                 }
4606                                 else if (o_ptr->name2 == EGO_ATTACKS)
4607                                 {
4608                                         o_ptr->pval = randint1(e_ptr->max_pval*lev/100+1);
4609                                         if (o_ptr->pval > 3) o_ptr->pval = 3;
4610                                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA))
4611                                                 o_ptr->pval += randint1(2);
4612                                 }
4613                                 else if (o_ptr->name2 == EGO_BAT)
4614                                 {
4615                                         o_ptr->pval = randint1(e_ptr->max_pval);
4616                                         if (o_ptr->sval == SV_ELVEN_CLOAK) o_ptr->pval += randint1(2);
4617                                 }
4618                                 else if (o_ptr->name2 == EGO_A_DEMON || o_ptr->name2 == EGO_DRUID || o_ptr->name2 == EGO_OLOG)
4619                                 {
4620                                         o_ptr->pval = randint1(e_ptr->max_pval);
4621                                 }
4622                                 else
4623                                 {
4624                                         o_ptr->pval += randint1(e_ptr->max_pval);
4625                                 }
4626
4627
4628                         }
4629                         if ((o_ptr->name2 == EGO_SPEED) && (lev < 50))
4630                         {
4631                                 o_ptr->pval = randint1(o_ptr->pval);
4632                         }
4633                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA) && (o_ptr->pval > 2) && (o_ptr->name2 != EGO_ATTACKS))
4634                                 o_ptr->pval = 2;
4635                 }
4636
4637                 /* Done */
4638                 return;
4639         }
4640
4641         /* Examine real objects */
4642         if (o_ptr->k_idx)
4643         {
4644                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
4645
4646                 /* Hack -- acquire "broken" flag */
4647                 if (!k_info[o_ptr->k_idx].cost) o_ptr->ident |= (IDENT_BROKEN);
4648
4649                 /* Hack -- acquire "cursed" flag */
4650                 if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
4651                 if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
4652                 if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
4653                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4654                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4655                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4656         }
4657
4658
4659 }
4660
4661
4662 /*!
4663  * @brief ベースアイテムが上質として扱われるかどうかを返す。
4664  * Hack -- determine if a template is "good"
4665  * @param k_idx 判定したいベースアイテムのID
4666  * @return ベースアイテムが上質ならばTRUEを返す。
4667  */
4668 static bool kind_is_good(int k_idx)
4669 {
4670         object_kind *k_ptr = &k_info[k_idx];
4671
4672         /* Analyze the item type */
4673         switch (k_ptr->tval)
4674         {
4675                 /* Armor -- Good unless damaged */
4676                 case TV_HARD_ARMOR:
4677                 case TV_SOFT_ARMOR:
4678                 case TV_DRAG_ARMOR:
4679                 case TV_SHIELD:
4680                 case TV_CLOAK:
4681                 case TV_BOOTS:
4682                 case TV_GLOVES:
4683                 case TV_HELM:
4684                 case TV_CROWN:
4685                 {
4686                         if (k_ptr->to_a < 0) return (FALSE);
4687                         return (TRUE);
4688                 }
4689
4690                 /* Weapons -- Good unless damaged */
4691                 case TV_BOW:
4692                 case TV_SWORD:
4693                 case TV_HAFTED:
4694                 case TV_POLEARM:
4695                 case TV_DIGGING:
4696                 {
4697                         if (k_ptr->to_h < 0) return (FALSE);
4698                         if (k_ptr->to_d < 0) return (FALSE);
4699                         return (TRUE);
4700                 }
4701
4702                 /* Ammo -- Arrows/Bolts are good */
4703                 case TV_BOLT:
4704                 case TV_ARROW:
4705                 {
4706                         return (TRUE);
4707                 }
4708
4709                 /* Books -- High level books are good (except Arcane books) */
4710                 case TV_LIFE_BOOK:
4711                 case TV_SORCERY_BOOK:
4712                 case TV_NATURE_BOOK:
4713                 case TV_CHAOS_BOOK:
4714                 case TV_DEATH_BOOK:
4715                 case TV_TRUMP_BOOK:
4716                 case TV_CRAFT_BOOK:
4717                 case TV_DAEMON_BOOK:
4718                 case TV_CRUSADE_BOOK:
4719                 case TV_MUSIC_BOOK:
4720                 case TV_HISSATSU_BOOK:
4721                 case TV_HEX_BOOK:
4722                 {
4723                         if (k_ptr->sval >= SV_BOOK_MIN_GOOD) return (TRUE);
4724                         return (FALSE);
4725                 }
4726
4727                 /* Rings -- Rings of Speed are good */
4728                 case TV_RING:
4729                 {
4730                         if (k_ptr->sval == SV_RING_SPEED) return (TRUE);
4731                         if (k_ptr->sval == SV_RING_LORDLY) return (TRUE);
4732                         return (FALSE);
4733                 }
4734
4735                 /* Amulets -- Amulets of the Magi and Resistance are good */
4736                 case TV_AMULET:
4737                 {
4738                         if (k_ptr->sval == SV_AMULET_THE_MAGI) return (TRUE);
4739                         if (k_ptr->sval == SV_AMULET_RESISTANCE) return (TRUE);
4740                         return (FALSE);
4741                 }
4742         }
4743
4744         /* Assume not good */
4745         return (FALSE);
4746 }
4747
4748 /*!
4749  * @brief 生成階に応じたベースアイテムの生成を行う。
4750  * Attempt to make an object (normal or good/great)
4751  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4752  * @param mode オプションフラグ
4753  * @return 生成に成功したらTRUEを返す。
4754  * @details
4755  * This routine plays nasty games to generate the "special artifacts".\n
4756  * This routine uses "object_level" for the "generation level".\n
4757  * We assume that the given object has been "wiped".\n
4758  */
4759 bool make_object(object_type *j_ptr, u32b mode)
4760 {
4761         int prob, base;
4762         byte obj_level;
4763
4764
4765         /* Chance of "special object" */
4766         prob = ((mode & AM_GOOD) ? 10 : 1000);
4767
4768         /* Base level for the object */
4769         base = ((mode & AM_GOOD) ? (object_level + 10) : object_level);
4770
4771
4772         /* Generate a special object, or a normal object */
4773         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4774         {
4775                 int k_idx;
4776
4777                 /* Good objects */
4778                 if ((mode & AM_GOOD) && !get_obj_num_hook)
4779                 {
4780                         /* Activate restriction (if already specified, use that) */
4781                         get_obj_num_hook = kind_is_good;
4782                 }
4783
4784                 /* Restricted objects - prepare allocation table */
4785                 if (get_obj_num_hook) get_obj_num_prep();
4786
4787                 /* Pick a random object */
4788                 k_idx = get_obj_num(base);
4789
4790                 /* Restricted objects */
4791                 if (get_obj_num_hook)
4792                 {
4793                         /* Clear restriction */
4794                         get_obj_num_hook = NULL;
4795
4796                         /* Reset allocation table to default */
4797                         get_obj_num_prep();
4798                 }
4799
4800                 /* Handle failure */
4801                 if (!k_idx) return (FALSE);
4802
4803                 /* Prepare the object */
4804                 object_prep(j_ptr, k_idx);
4805         }
4806
4807         /* Apply magic (allow artifacts) */
4808         apply_magic(j_ptr, object_level, mode);
4809
4810         /* Hack -- generate multiple spikes/missiles */
4811         switch (j_ptr->tval)
4812         {
4813                 case TV_SPIKE:
4814                 case TV_SHOT:
4815                 case TV_ARROW:
4816                 case TV_BOLT:
4817                 {
4818                         if (!j_ptr->name1)
4819                                 j_ptr->number = (byte)damroll(6, 7);
4820                 }
4821         }
4822
4823         obj_level = k_info[j_ptr->k_idx].level;
4824         if (object_is_fixed_artifact(j_ptr)) obj_level = a_info[j_ptr->name1].level;
4825
4826         if (cheat_peek) object_mention(j_ptr);
4827
4828         /* Success */
4829         return (TRUE);
4830 }
4831
4832
4833 /*!
4834  * @brief フロアの指定位置に生成階に応じたベースアイテムの生成を行う。
4835  * Attempt to place an object (normal or good/great) at the given location.
4836  * @param y 配置したいフロアのY座標
4837  * @param x 配置したいフロアのX座標
4838  * @param mode オプションフラグ
4839  * @return 生成に成功したらTRUEを返す。
4840  * @details
4841  * This routine plays nasty games to generate the "special artifacts".\n
4842  * This routine uses "object_level" for the "generation level".\n
4843  * This routine requires a clean floor grid destination.\n
4844  */
4845 void place_object(int y, int x, u32b mode)
4846 {
4847         s16b o_idx;
4848
4849         /* Acquire grid */
4850         cave_type *c_ptr = &cave[y][x];
4851
4852         object_type forge;
4853         object_type *q_ptr;
4854
4855
4856         /* Paranoia -- check bounds */
4857         if (!in_bounds(y, x)) return;
4858
4859         /* Require floor space */
4860         if (!cave_drop_bold(y, x)) return;
4861
4862         /* Avoid stacking on other objects */
4863         if (c_ptr->o_idx) return;
4864
4865
4866         /* Get local object */
4867         q_ptr = &forge;
4868
4869         /* Wipe the object */
4870         object_wipe(q_ptr);
4871
4872         /* Make an object (if possible) */
4873         if (!make_object(q_ptr, mode)) return;
4874
4875
4876         /* Make an object */
4877         o_idx = o_pop();
4878
4879         /* Success */
4880         if (o_idx)
4881         {
4882                 object_type *o_ptr;
4883
4884                 /* Acquire object */
4885                 o_ptr = &o_list[o_idx];
4886
4887                 /* Structure Copy */
4888                 object_copy(o_ptr, q_ptr);
4889
4890                 /* Location */
4891                 o_ptr->iy = y;
4892                 o_ptr->ix = x;
4893
4894                 /* Build a stack */
4895                 o_ptr->next_o_idx = c_ptr->o_idx;
4896
4897                 /* Place the object */
4898                 c_ptr->o_idx = o_idx;
4899
4900                 /* Notice */
4901                 note_spot(y, x);
4902
4903                 /* Redraw */
4904                 lite_spot(y, x);
4905         }
4906         else
4907         {
4908                 /* Hack -- Preserve artifacts */
4909                 if (object_is_fixed_artifact(q_ptr))
4910                 {
4911                         a_info[q_ptr->name1].cur_num = 0;
4912                 }
4913         }
4914 }
4915
4916
4917 /*!
4918  * @brief 生成階に応じた財宝オブジェクトの生成を行う。
4919  * Make a treasure object
4920  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4921  * @return 生成に成功したらTRUEを返す。
4922  * @details
4923  * The location must be a legal, clean, floor grid.
4924  */
4925 bool make_gold(object_type *j_ptr)
4926 {
4927         int i;
4928
4929         s32b base;
4930
4931
4932         /* Hack -- Pick a Treasure variety */
4933         i = ((randint1(object_level + 2) + 2) / 2) - 1;
4934
4935         /* Apply "extra" magic */
4936         if (one_in_(GREAT_OBJ))
4937         {
4938                 i += randint1(object_level + 1);
4939         }
4940
4941         /* Hack -- Creeping Coins only generate "themselves" */
4942         if (coin_type) i = coin_type;
4943
4944         /* Do not create "illegal" Treasure Types */
4945         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4946
4947         /* Prepare a gold object */
4948         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4949
4950         /* Hack -- Base coin cost */
4951         base = k_info[OBJ_GOLD_LIST+i].cost;
4952
4953         /* Determine how much the treasure is "worth" */
4954         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4955
4956         /* Success */
4957         return (TRUE);
4958 }
4959
4960
4961 /*!
4962  * @brief フロアの指定位置に生成階に応じた財宝オブジェクトの生成を行う。
4963  * Places a treasure (Gold or Gems) at given location
4964  * @param y 配置したいフロアのY座標
4965  * @param x 配置したいフロアのX座標
4966  * @return 生成に成功したらTRUEを返す。
4967  * @details
4968  * The location must be a legal, clean, floor grid.
4969  */
4970 void place_gold(int y, int x)
4971 {
4972         s16b o_idx;
4973
4974         /* Acquire grid */
4975         cave_type *c_ptr = &cave[y][x];
4976
4977
4978         object_type forge;
4979         object_type *q_ptr;
4980
4981
4982         /* Paranoia -- check bounds */
4983         if (!in_bounds(y, x)) return;
4984
4985         /* Require floor space */
4986         if (!cave_drop_bold(y, x)) return;
4987
4988         /* Avoid stacking on other objects */
4989         if (c_ptr->o_idx) return;
4990
4991
4992         /* Get local object */
4993         q_ptr = &forge;
4994
4995         /* Wipe the object */
4996         object_wipe(q_ptr);
4997
4998         /* Make some gold */
4999         if (!make_gold(q_ptr)) return;
5000
5001
5002         /* Make an object */
5003         o_idx = o_pop();
5004
5005         /* Success */
5006         if (o_idx)
5007         {
5008                 object_type *o_ptr;
5009
5010                 /* Acquire object */
5011                 o_ptr = &o_list[o_idx];
5012
5013                 /* Copy the object */
5014                 object_copy(o_ptr, q_ptr);
5015
5016                 /* Save location */
5017                 o_ptr->iy = y;
5018                 o_ptr->ix = x;
5019
5020                 /* Build a stack */
5021                 o_ptr->next_o_idx = c_ptr->o_idx;
5022
5023                 /* Place the object */
5024                 c_ptr->o_idx = o_idx;
5025
5026                 /* Notice */
5027                 note_spot(y, x);
5028
5029                 /* Redraw */
5030                 lite_spot(y, x);
5031         }
5032 }
5033
5034
5035 /*!
5036  * @brief 生成済のオブジェクトをフロアの所定の位置に落とす。
5037  * Let an object fall to the ground at or near a location.
5038  * @param j_ptr 落としたいオブジェクト構造体の参照ポインタ
5039  * @param chance ドロップの成功率(%)
5040  * @param y 配置したいフロアのY座標
5041  * @param x 配置したいフロアのX座標
5042  * @return 生成に成功したらTRUEを返す。
5043  * @details
5044  * The initial location is assumed to be "in_bounds()".\n
5045  *\n
5046  * This function takes a parameter "chance".  This is the percentage\n
5047  * chance that the item will "disappear" instead of drop.  If the object\n
5048  * has been thrown, then this is the chance of disappearance on contact.\n
5049  *\n
5050  * Hack -- this function uses "chance" to determine if it should produce\n
5051  * some form of "description" of the drop event (under the player).\n
5052  *\n
5053  * We check several locations to see if we can find a location at which\n
5054  * the object can combine, stack, or be placed.  Artifacts will try very\n
5055  * hard to be placed, including "teleporting" to a useful grid if needed.\n
5056  */
5057 s16b drop_near(object_type *j_ptr, int chance, int y, int x)
5058 {
5059         int i, k, d, s;
5060
5061         int bs, bn;
5062         int by, bx;
5063         int dy, dx;
5064         int ty, tx = 0;
5065
5066         s16b o_idx = 0;
5067
5068         s16b this_o_idx, next_o_idx = 0;
5069
5070         cave_type *c_ptr;
5071
5072         char o_name[MAX_NLEN];
5073
5074         bool flag = FALSE;
5075         bool done = FALSE;
5076
5077 #ifndef JP
5078         /* Extract plural */
5079         bool plural = (j_ptr->number != 1);
5080 #endif
5081
5082         /* Describe object */
5083         object_desc(o_name, j_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
5084
5085
5086         /* Handle normal "breakage" */
5087         if (!object_is_artifact(j_ptr) && (randint0(100) < chance))
5088         {
5089                 /* Message */
5090 #ifdef JP
5091                 msg_format("%sは消えた。", o_name);
5092 #else
5093                 msg_format("The %s disappear%s.",
5094                            o_name, (plural ? "" : "s"));
5095 #endif
5096
5097
5098                 /* Debug */
5099                 if (p_ptr->wizard) msg_print(_("(破損)", "(breakage)"));
5100
5101                 /* Failure */
5102                 return (0);
5103         }
5104
5105
5106         /* Score */
5107         bs = -1;
5108
5109         /* Picker */
5110         bn = 0;
5111
5112         /* Default */
5113         by = y;
5114         bx = x;
5115
5116         /* Scan local grids */
5117         for (dy = -3; dy <= 3; dy++)
5118         {
5119                 /* Scan local grids */
5120                 for (dx = -3; dx <= 3; dx++)
5121                 {
5122                         bool comb = FALSE;
5123
5124                         /* Calculate actual distance */
5125                         d = (dy * dy) + (dx * dx);
5126
5127                         /* Ignore distant grids */
5128                         if (d > 10) continue;
5129
5130                         /* Location */
5131                         ty = y + dy;
5132                         tx = x + dx;
5133
5134                         /* Skip illegal grids */
5135                         if (!in_bounds(ty, tx)) continue;
5136
5137                         /* Require line of projection */
5138                         if (!projectable(y, x, ty, tx)) continue;
5139
5140                         /* Obtain grid */
5141                         c_ptr = &cave[ty][tx];
5142
5143                         /* Require floor space */
5144                         if (!cave_drop_bold(ty, tx)) continue;
5145
5146                         /* No objects */
5147                         k = 0;
5148
5149                         /* Scan objects in that grid */
5150                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5151                         {
5152                                 object_type *o_ptr;
5153
5154                                 /* Acquire object */
5155                                 o_ptr = &o_list[this_o_idx];
5156
5157                                 /* Acquire next object */
5158                                 next_o_idx = o_ptr->next_o_idx;
5159
5160                                 /* Check for possible combination */
5161                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
5162
5163                                 /* Count objects */
5164                                 k++;
5165                         }
5166
5167                         /* Add new object */
5168                         if (!comb) k++;
5169
5170                         /* Paranoia */
5171                         if (k > 99) continue;
5172
5173                         /* Calculate score */
5174                         s = 1000 - (d + k * 5);
5175
5176                         /* Skip bad values */
5177                         if (s < bs) continue;
5178
5179                         /* New best value */
5180                         if (s > bs) bn = 0;
5181
5182                         /* Apply the randomizer to equivalent values */
5183                         if ((++bn >= 2) && !one_in_(bn)) continue;
5184
5185                         /* Keep score */
5186                         bs = s;
5187
5188                         /* Track it */
5189                         by = ty;
5190                         bx = tx;
5191
5192                         /* Okay */
5193                         flag = TRUE;
5194                 }
5195         }
5196
5197
5198         /* Handle lack of space */
5199         if (!flag && !object_is_artifact(j_ptr))
5200         {
5201                 /* Message */
5202 #ifdef JP
5203                 msg_format("%sは消えた。", o_name);
5204 #else
5205                 msg_format("The %s disappear%s.",
5206                            o_name, (plural ? "" : "s"));
5207 #endif
5208
5209
5210                 /* Debug */
5211                 if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5212
5213                 /* Failure */
5214                 return (0);
5215         }
5216
5217
5218         /* Find a grid */
5219         for (i = 0; !flag && (i < 1000); i++)
5220         {
5221                 /* Bounce around */
5222                 ty = rand_spread(by, 1);
5223                 tx = rand_spread(bx, 1);
5224
5225                 /* Verify location */
5226                 if (!in_bounds(ty, tx)) continue;
5227
5228                 /* Bounce to that location */
5229                 by = ty;
5230                 bx = tx;
5231
5232                 /* Require floor space */
5233                 if (!cave_drop_bold(by, bx)) continue;
5234
5235                 /* Okay */
5236                 flag = TRUE;
5237         }
5238
5239
5240         if (!flag)
5241         {
5242                 int candidates = 0, pick;
5243
5244                 for (ty = 1; ty < cur_hgt - 1; ty++)
5245                 {
5246                         for (tx = 1; tx < cur_wid - 1; tx++)
5247                         {
5248                                 /* A valid space found */
5249                                 if (cave_drop_bold(ty, tx)) candidates++;
5250                         }
5251                 }
5252
5253                 /* No valid place! */
5254                 if (!candidates)
5255                 {
5256                         /* Message */
5257 #ifdef JP
5258                         msg_format("%sは消えた。", o_name);
5259 #else
5260                         msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
5261 #endif
5262
5263                         /* Debug */
5264                         if (p_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
5265
5266                         /* Mega-Hack -- preserve artifacts */
5267                         if (preserve_mode)
5268                         {
5269                                 /* Hack -- Preserve unknown artifacts */
5270                                 if (object_is_fixed_artifact(j_ptr) && !object_is_known(j_ptr))
5271                                 {
5272                                         /* Mega-Hack -- Preserve the artifact */
5273                                         a_info[j_ptr->name1].cur_num = 0;
5274                                 }
5275                         }
5276
5277                         /* Failure */
5278                         return 0;
5279                 }
5280
5281                 /* Choose a random one */
5282                 pick = randint1(candidates);
5283
5284                 for (ty = 1; ty < cur_hgt - 1; ty++)
5285                 {
5286                         for (tx = 1; tx < cur_wid - 1; tx++)
5287                         {
5288                                 if (cave_drop_bold(ty, tx))
5289                                 {
5290                                         pick--;
5291
5292                                         /* Is this a picked one? */
5293                                         if (!pick) break;
5294                                 }
5295                         }
5296
5297                         if (!pick) break;
5298                 }
5299
5300                 by = ty;
5301                 bx = tx;
5302         }
5303
5304
5305         /* Grid */
5306         c_ptr = &cave[by][bx];
5307
5308         /* Scan objects in that grid for combination */
5309         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5310         {
5311                 object_type *o_ptr;
5312
5313                 /* Acquire object */
5314                 o_ptr = &o_list[this_o_idx];
5315
5316                 /* Acquire next object */
5317                 next_o_idx = o_ptr->next_o_idx;
5318
5319                 /* Check for combination */
5320                 if (object_similar(o_ptr, j_ptr))
5321                 {
5322                         /* Combine the items */
5323                         object_absorb(o_ptr, j_ptr);
5324
5325                         /* Success */
5326                         done = TRUE;
5327
5328                         /* Done */
5329                         break;
5330                 }
5331         }
5332
5333         /* Get new object */
5334         if (!done) o_idx = o_pop();
5335
5336         /* Failure */
5337         if (!done && !o_idx)
5338         {
5339                 /* Message */
5340 #ifdef JP
5341                 msg_format("%sは消えた。", o_name);
5342 #else
5343                 msg_format("The %s disappear%s.",
5344                            o_name, (plural ? "" : "s"));
5345 #endif
5346
5347
5348                 /* Debug */
5349                 if (p_ptr->wizard) msg_print(_("(アイテムが多過ぎる)", "(too many objects)"));
5350
5351                 /* Hack -- Preserve artifacts */
5352                 if (object_is_fixed_artifact(j_ptr))
5353                 {
5354                         a_info[j_ptr->name1].cur_num = 0;
5355                 }
5356
5357                 /* Failure */
5358                 return (0);
5359         }
5360
5361         /* Stack */
5362         if (!done)
5363         {
5364                 /* Structure copy */
5365                 object_copy(&o_list[o_idx], j_ptr);
5366
5367                 /* Access new object */
5368                 j_ptr = &o_list[o_idx];
5369
5370                 /* Locate */
5371                 j_ptr->iy = by;
5372                 j_ptr->ix = bx;
5373
5374                 /* No monster */
5375                 j_ptr->held_m_idx = 0;
5376
5377                 /* Build a stack */
5378                 j_ptr->next_o_idx = c_ptr->o_idx;
5379
5380                 /* Place the object */
5381                 c_ptr->o_idx = o_idx;
5382
5383                 /* Success */
5384                 done = TRUE;
5385         }
5386
5387         /* Note the spot */
5388         note_spot(by, bx);
5389
5390         /* Draw the spot */
5391         lite_spot(by, bx);
5392
5393         /* Sound */
5394         sound(SOUND_DROP);
5395
5396         /* Mega-Hack -- no message if "dropped" by player */
5397         /* Message when an object falls under the player */
5398         if (chance && player_bold(by, bx))
5399         {
5400                 msg_print(_("何かが足下に転がってきた。", "You feel something roll beneath your feet."));
5401         }
5402
5403         /* XXX XXX XXX */
5404
5405         /* Result */
5406         return (o_idx);
5407 }
5408
5409
5410 /*!
5411  * @brief 獲得ドロップを行う。
5412  * Scatter some "great" objects near the player
5413  * @param y1 配置したいフロアのY座標
5414  * @param x1 配置したいフロアのX座標
5415  * @param num 獲得の処理回数
5416  * @param great TRUEならば必ず高級品以上を落とす
5417  * @param special TRUEならば必ず特別品を落とす
5418  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5419  * @return なし
5420  */
5421 void acquirement(int y1, int x1, int num, bool great, bool special, bool known)
5422 {
5423         object_type *i_ptr;
5424         object_type object_type_body;
5425         u32b mode = AM_GOOD | (great || special ? AM_GREAT : 0L) | (special ? AM_SPECIAL : 0L) ;
5426
5427         /* Acquirement */
5428         while (num--)
5429         {
5430                 /* Get local object */
5431                 i_ptr = &object_type_body;
5432
5433                 /* Wipe the object */
5434                 object_wipe(i_ptr);
5435
5436                 /* Make a good (or great) object (if possible) */
5437                 if (!make_object(i_ptr, mode)) continue;
5438
5439                 if (known)
5440                 {
5441                         object_aware(i_ptr);
5442                         object_known(i_ptr);
5443                 }
5444
5445                 /* Drop the object */
5446                 (void)drop_near(i_ptr, -1, y1, x1);
5447         }
5448 }
5449
5450 /*
5451  * Scatter some "amusing" objects near the player
5452  */
5453
5454 #define AMS_NOTHING   0x00 /* No restriction */
5455 #define AMS_NO_UNIQUE 0x01 /* Don't make the amusing object of uniques */
5456 #define AMS_FIXED_ART 0x02 /* Make a fixed artifact based on the amusing object */
5457 #define AMS_MULTIPLE  0x04 /* Drop 1-3 objects for one type */
5458 #define AMS_PILE      0x08 /* Drop 1-99 pile objects for one type */
5459
5460 typedef struct
5461 {
5462         int tval;
5463         int sval;
5464         int prob;
5465         byte flag;
5466 } amuse_type;
5467
5468 amuse_type amuse_info[] =
5469 {
5470         { TV_BOTTLE, SV_ANY, 5, AMS_NOTHING },
5471         { TV_JUNK, SV_ANY, 3, AMS_MULTIPLE },
5472         { TV_SPIKE, SV_ANY, 10, AMS_PILE },
5473         { TV_STATUE, SV_ANY, 15, AMS_NOTHING },
5474         { TV_CORPSE, SV_ANY, 15, AMS_NO_UNIQUE },
5475         { TV_SKELETON, SV_ANY, 10, AMS_NO_UNIQUE },
5476         { TV_FIGURINE, SV_ANY, 10, AMS_NO_UNIQUE },
5477         { TV_PARCHMENT, SV_ANY, 1, AMS_NOTHING },
5478         { TV_POLEARM, SV_TSURIZAO, 3, AMS_NOTHING }, //Fishing Pole of Taikobo
5479         { TV_SWORD, SV_BROKEN_DAGGER, 3, AMS_FIXED_ART }, //Broken Dagger of Magician
5480         { TV_SWORD, SV_BROKEN_DAGGER, 10, AMS_NOTHING },
5481         { TV_SWORD, SV_BROKEN_SWORD, 5, AMS_NOTHING },
5482         { TV_SCROLL, SV_SCROLL_AMUSEMENT, 10, AMS_NOTHING },
5483
5484         { 0, 0, 0 }
5485 };
5486
5487 /*!
5488  * @brief 誰得ドロップを行う。
5489  * @param y1 配置したいフロアのY座標
5490  * @param x1 配置したいフロアのX座標
5491  * @param num 誰得の処理回数
5492  * @param known TRUEならばオブジェクトが必ず＊鑑定＊済になる
5493  * @return なし
5494  */
5495 void amusement(int y1, int x1, int num, bool known)
5496 {
5497         object_type *i_ptr;
5498         object_type object_type_body;
5499         int n, t = 0;
5500
5501         for (n = 0; amuse_info[n].tval != 0; n++)
5502         {
5503                 t += amuse_info[n].prob;
5504         }
5505
5506         /* Acquirement */
5507         while (num)
5508         {
5509                 int i, k_idx, a_idx = 0;
5510                 int r = randint0(t);
5511                 bool insta_art, fixed_art;
5512
5513                 for (i = 0; ; i++)
5514                 {
5515                         r -= amuse_info[i].prob;
5516                         if (r <= 0) break;
5517                 }
5518
5519                 /* Get local object */
5520                 i_ptr = &object_type_body;
5521
5522                 /* Wipe the object */
5523                 object_wipe(i_ptr);
5524
5525                 /* Wipe the object */
5526                 k_idx = lookup_kind(amuse_info[i].tval, amuse_info[i].sval);
5527
5528                 /* Paranoia - reroll if nothing */
5529                 if (!k_idx) continue;
5530
5531                 /* Search an artifact index if need */
5532                 insta_art = (k_info[k_idx].gen_flags & TRG_INSTA_ART);
5533                 fixed_art = (amuse_info[i].flag & AMS_FIXED_ART);
5534
5535                 if (insta_art || fixed_art)
5536                 {
5537                         for (a_idx = 1; a_idx < max_a_idx; a_idx++)
5538                         {
5539                                 if (insta_art && !(a_info[a_idx].gen_flags & TRG_INSTA_ART)) continue;
5540                                 if (a_info[a_idx].tval != k_info[k_idx].tval) continue;
5541                                 if (a_info[a_idx].sval != k_info[k_idx].sval) continue;
5542                                 if (a_info[a_idx].cur_num > 0) continue;
5543                                 break;
5544                         }
5545
5546                         if (a_idx >= max_a_idx) continue;
5547                 }
5548
5549                 /* Make an object (if possible) */
5550                 object_prep(i_ptr, k_idx);
5551                 if (a_idx) i_ptr->name1 = a_idx;
5552                 apply_magic(i_ptr, 1, AM_NO_FIXED_ART);
5553
5554                 if (amuse_info[i].flag & AMS_NO_UNIQUE)
5555                 {
5556                         if (r_info[i_ptr->pval].flags1 & RF1_UNIQUE) continue;
5557                 }
5558
5559                 if (amuse_info[i].flag & AMS_MULTIPLE) i_ptr->number = randint1(3);
5560                 if (amuse_info[i].flag & AMS_PILE) i_ptr->number = randint1(99);
5561
5562                 if (known)
5563                 {
5564                         object_aware(i_ptr);
5565                         object_known(i_ptr);
5566                 }
5567
5568                 /* Paranoia - reroll if nothing */
5569                 if (!(i_ptr->k_idx)) continue;
5570
5571                 /* Drop the object */
5572                 (void)drop_near(i_ptr, -1, y1, x1);
5573
5574                 num--;
5575         }
5576 }
5577
5578
5579 #define MAX_NORMAL_TRAPS 18
5580
5581 /* See init_feat_variables() in init2.c */
5582 static s16b normal_traps[MAX_NORMAL_TRAPS];
5583
5584 /*!
5585  * @brief タグに従って、基本トラップテーブルを初期化する / Initialize arrays for normal traps
5586  * @return なし
5587  */
5588 void init_normal_traps(void)
5589 {
5590         int cur_trap = 0;
5591
5592         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPDOOR");
5593         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_PIT");
5594         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SPIKED_PIT");
5595         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON_PIT");
5596         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TY_CURSE");
5597         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TELEPORT");
5598         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_FIRE");
5599         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ACID");
5600         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLOW");
5601         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_STR");
5602         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_DEX");
5603         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_LOSE_CON");
5604         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_BLIND");
5605         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_CONFUSE");
5606         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_POISON");
5607         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_SLEEP");
5608         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_TRAPS");
5609         normal_traps[cur_trap++] = f_tag_to_index_in_init("TRAP_ALARM");
5610 }
5611
5612 /*!
5613  * @brief 基本トラップをランダムに選択する /
5614  * Get random trap
5615  * @return 選択したトラップのID
5616  * @details
5617  * XXX XXX XXX This routine should be redone to reflect trap "level".\n
5618  * That is, it does not make sense to have spiked pits at 50 feet.\n
5619  * Actually, it is not this routine, but the "trap instantiation"\n
5620  * code, which should also check for "trap doors" on quest levels.\n
5621  */
5622 s16b choose_random_trap(void)
5623 {
5624         s16b feat;
5625
5626         /* Pick a trap */
5627         while (1)
5628         {
5629                 /* Hack -- pick a trap */
5630                 feat = normal_traps[randint0(MAX_NORMAL_TRAPS)];
5631
5632                 /* Accept non-trapdoors */
5633                 if (!have_flag(f_info[feat].flags, FF_MORE)) break;
5634
5635                 /* Hack -- no trap doors on special levels */
5636                 if (p_ptr->inside_arena || quest_number(dun_level)) continue;
5637
5638                 /* Hack -- no trap doors on the deepest level */
5639                 if (dun_level >= d_info[dungeon_type].maxdepth) continue;
5640
5641                 break;
5642         }
5643
5644         return feat;
5645 }
5646
5647 /*!
5648  * @brief マスに存在するトラップを秘匿する /
5649  * Disclose an invisible trap
5650  * @param y 秘匿したいマスのY座標
5651  * @param x 秘匿したいマスのX座標
5652  * @return なし
5653  */
5654 void disclose_grid(int y, int x)
5655 {
5656         cave_type *c_ptr = &cave[y][x];
5657
5658         if (cave_have_flag_grid(c_ptr, FF_SECRET))
5659         {
5660                 /* No longer hidden */
5661                 cave_alter_feat(y, x, FF_SECRET);
5662         }
5663         else if (c_ptr->mimic)
5664         {
5665                 /* No longer hidden */
5666                 c_ptr->mimic = 0;
5667
5668                 /* Notice */
5669                 note_spot(y, x);
5670
5671                 /* Redraw */
5672                 lite_spot(y, x);
5673         }
5674 }
5675
5676 /*!
5677  * @brief マスをトラップを配置する /
5678  * The location must be a legal, naked, floor grid.
5679  * @param y 配置したいマスのY座標
5680  * @param x 配置したいマスのX座標
5681  * @return
5682  * Note that all traps start out as "invisible" and "untyped", and then\n
5683  * when they are "discovered" (by detecting them or setting them off),\n
5684  * the trap is "instantiated" as a visible, "typed", trap.\n
5685  */
5686 void place_trap(int y, int x)
5687 {
5688         cave_type *c_ptr = &cave[y][x];
5689
5690         /* Paranoia -- verify location */
5691         if (!in_bounds(y, x)) return;
5692
5693         /* Require empty, clean, floor grid */
5694         if (!cave_clean_bold(y, x)) return;
5695
5696         /* Place an invisible trap */
5697         c_ptr->mimic = c_ptr->feat;
5698         c_ptr->feat = choose_random_trap();
5699 }
5700
5701 /*!
5702  * @brief 魔道具の使用回数の残量を示すメッセージを表示する /
5703  * Describe the charges on an item in the inventory.
5704  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5705  * @return なし
5706  */
5707 void inven_item_charges(int item)
5708 {
5709         object_type *o_ptr = &inventory[item];
5710
5711         /* Require staff/wand */
5712         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5713
5714         /* Require known item */
5715         if (!object_is_known(o_ptr)) return;
5716
5717 #ifdef JP
5718         if (o_ptr->pval <= 0)
5719         {
5720                 msg_print("もう魔力が残っていない。");
5721         }
5722         else
5723         {
5724                 msg_format("あと %d 回分の魔力が残っている。", o_ptr->pval);
5725         }
5726 #else
5727         /* Multiple charges */
5728         if (o_ptr->pval != 1)
5729         {
5730                 /* Print a message */
5731                 msg_format("You have %d charges remaining.", o_ptr->pval);
5732         }
5733
5734         /* Single charge */
5735         else
5736         {
5737                 /* Print a message */
5738                 msg_format("You have %d charge remaining.", o_ptr->pval);
5739         }
5740 #endif
5741
5742 }
5743
5744 /*!
5745  * @brief アイテムの残り所持数メッセージを表示する /
5746  * Describe an item in the inventory.
5747  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
5748  * @return なし
5749  */
5750 void inven_item_describe(int item)
5751 {
5752         object_type *o_ptr = &inventory[item];
5753         char        o_name[MAX_NLEN];
5754
5755         /* Get a description */
5756         object_desc(o_name, o_ptr, 0);
5757
5758         /* Print a message */
5759 #ifdef JP
5760         /* "no more" の場合はこちらで表示する */
5761         if (o_ptr->number <= 0)
5762         {
5763                 /*FIRST*//*ここはもう通らないかも */
5764                 msg_format("もう%sを持っていない。", o_name);
5765         }
5766         else
5767         {
5768                 /* アイテム名を英日切り替え機能対応 */
5769                 msg_format("まだ %sを持っている。", o_name);
5770         }
5771 #else
5772         msg_format("You have %s.", o_name);
5773 #endif
5774
5775 }
5776
5777 /*!
5778  * @brief アイテムの残り所持数メッセージを表示する /
5779  * Increase the "number" of an item in the inventory
5780  * @param item 所持数を増やしたいプレイヤーのアイテム所持スロット
5781  * @param num 増やしたい量
5782  * @return なし
5783  */
5784 void inven_item_increase(int item, int num)
5785 {
5786         object_type *o_ptr = &inventory[item];
5787
5788         /* Apply */
5789         num += o_ptr->number;
5790
5791         /* Bounds check */
5792         if (num > 255) num = 255;
5793         else if (num < 0) num = 0;
5794
5795         /* Un-apply */
5796         num -= o_ptr->number;
5797
5798         /* Change the number and weight */
5799         if (num)
5800         {
5801                 /* Add the number */
5802                 o_ptr->number += num;
5803
5804                 /* Add the weight */
5805                 p_ptr->total_weight += (num * o_ptr->weight);
5806
5807                 /* Recalculate bonuses */
5808                 p_ptr->update |= (PU_BONUS);
5809
5810                 /* Recalculate mana XXX */
5811                 p_ptr->update |= (PU_MANA);
5812
5813                 /* Combine the pack */
5814                 p_ptr->notice |= (PN_COMBINE);
5815
5816                 /* Window stuff */
5817                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5818
5819                 /* Hack -- Clear temporary elemental brands if player takes off weapons */
5820                 if (!o_ptr->number && p_ptr->ele_attack)
5821                 {
5822                         if ((item == INVEN_RARM) || (item == INVEN_LARM))
5823                         {
5824                                 if (!buki_motteruka(INVEN_RARM + INVEN_LARM - item))
5825                                 {
5826                                         /* Clear all temporary elemental brands */
5827                                         set_ele_attack(0, 0);
5828                                 }
5829                         }
5830                 }
5831         }
5832 }
5833
5834 /*!
5835  * @brief 所持アイテムスロットから所持数のなくなったアイテムを消去する /
5836  * Erase an inventory slot if it has no more items
5837  * @param item 消去したいプレイヤーのアイテム所持スロット
5838  * @return なし
5839  */
5840 void inven_item_optimize(int item)
5841 {
5842         object_type *o_ptr = &inventory[item];
5843
5844         /* Only optimize real items */
5845         if (!o_ptr->k_idx) return;
5846
5847         /* Only optimize empty items */
5848         if (o_ptr->number) return;
5849
5850         /* The item is in the pack */
5851         if (item < INVEN_RARM)
5852         {
5853                 int i;
5854
5855                 /* One less item */
5856                 inven_cnt--;
5857
5858                 /* Slide everything down */
5859                 for (i = item; i < INVEN_PACK; i++)
5860                 {
5861                         /* Structure copy */
5862                         inventory[i] = inventory[i+1];
5863                 }
5864
5865                 /* Erase the "final" slot */
5866                 object_wipe(&inventory[i]);
5867
5868                 /* Window stuff */
5869                 p_ptr->window |= (PW_INVEN);
5870         }
5871
5872         /* The item is being wielded */
5873         else
5874         {
5875                 /* One less item */
5876                 equip_cnt--;
5877
5878                 /* Erase the empty slot */
5879                 object_wipe(&inventory[item]);
5880
5881                 /* Recalculate bonuses */
5882                 p_ptr->update |= (PU_BONUS);
5883
5884                 /* Recalculate torch */
5885                 p_ptr->update |= (PU_TORCH);
5886
5887                 /* Recalculate mana XXX */
5888                 p_ptr->update |= (PU_MANA);
5889
5890                 /* Window stuff */
5891                 p_ptr->window |= (PW_EQUIP);
5892         }
5893
5894         /* Window stuff */
5895         p_ptr->window |= (PW_SPELL);
5896 }
5897
5898 /*!
5899  * @brief 床上の魔道具の残り残量メッセージを表示する /
5900  * Describe the charges on an item on the floor.
5901  * @param item メッセージの対象にしたいアイテム所持スロット
5902  * @return なし
5903  */
5904 void floor_item_charges(int item)
5905 {
5906         object_type *o_ptr = &o_list[item];
5907
5908         /* Require staff/wand */
5909         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5910
5911         /* Require known item */
5912         if (!object_is_known(o_ptr)) return;
5913
5914 #ifdef JP
5915         if (o_ptr->pval <= 0)
5916         {
5917                 msg_print("この床上のアイテムは、もう魔力が残っていない。");
5918         }
5919         else
5920         {
5921                 msg_format("この床上のアイテムは、あと %d 回分の魔力が残っている。", o_ptr->pval);
5922         }
5923 #else
5924         /* Multiple charges */
5925         if (o_ptr->pval != 1)
5926         {
5927                 /* Print a message */
5928                 msg_format("There are %d charges remaining.", o_ptr->pval);
5929         }
5930
5931         /* Single charge */
5932         else
5933         {
5934                 /* Print a message */
5935                 msg_format("There is %d charge remaining.", o_ptr->pval);
5936         }
5937 #endif
5938
5939 }
5940
5941 /*!
5942  * @brief 床上のアイテムの残り数メッセージを表示する /
5943  * Describe the charges on an item on the floor.
5944  * @param item メッセージの対象にしたいアイテム所持スロット
5945  * @return なし
5946  */
5947 void floor_item_describe(int item)
5948 {
5949         object_type *o_ptr = &o_list[item];
5950         char        o_name[MAX_NLEN];
5951
5952         /* Get a description */
5953         object_desc(o_name, o_ptr, 0);
5954
5955         /* Print a message */
5956 #ifdef JP
5957         /* "no more" の場合はこちらで表示を分ける */
5958         if (o_ptr->number <= 0)
5959         {
5960                 msg_format("床上には、もう%sはない。", o_name);
5961         }
5962         else
5963         {
5964                 msg_format("床上には、まだ %sがある。", o_name);
5965         }
5966 #else
5967         msg_format("You see %s.", o_name);
5968 #endif
5969
5970 }
5971
5972
5973 /*!
5974  * @brief 床上のアイテムの数を増やす /
5975  * Increase the "number" of an item on the floor
5976  * @param item 増やしたいアイテムの所持スロット
5977  * @param num 増やしたいアイテムの数
5978  * @return なし
5979  */
5980 void floor_item_increase(int item, int num)
5981 {
5982         object_type *o_ptr = &o_list[item];
5983
5984         /* Apply */
5985         num += o_ptr->number;
5986
5987         /* Bounds check */
5988         if (num > 255) num = 255;
5989         else if (num < 0) num = 0;
5990
5991         /* Un-apply */
5992         num -= o_ptr->number;
5993
5994         /* Change the number */
5995         o_ptr->number += num;
5996 }
5997
5998
5999 /*!
6000  * @brief 床上の数の無くなったアイテムスロットを消去する /
6001  * Optimize an item on the floor (destroy "empty" items)
6002  * @param item 消去したいアイテムの所持スロット
6003  * @return なし
6004  */
6005 void floor_item_optimize(int item)
6006 {
6007         object_type *o_ptr = &o_list[item];
6008
6009         /* Paranoia -- be sure it exists */
6010         if (!o_ptr->k_idx) return;
6011
6012         /* Only optimize empty items */
6013         if (o_ptr->number) return;
6014
6015         /* Delete the object */
6016         delete_object_idx(item);
6017 }
6018
6019
6020 /*!
6021  * @brief アイテムを拾う際にザックから溢れずに済むかを判定する /
6022  * Check if we have space for an item in the pack without overflow
6023  * @param o_ptr 拾いたいオブジェクトの構造体参照ポインタ
6024  * @return 溢れずに済むならTRUEを返す
6025  */
6026 bool inven_carry_okay(object_type *o_ptr)
6027 {
6028         int j;
6029
6030         /* Empty slot? */
6031         if (inven_cnt < INVEN_PACK) return (TRUE);
6032
6033         /* Similar slot? */
6034         for (j = 0; j < INVEN_PACK; j++)
6035         {
6036                 object_type *j_ptr = &inventory[j];
6037
6038                 /* Skip non-objects */
6039                 if (!j_ptr->k_idx) continue;
6040
6041                 /* Check if the two items can be combined */
6042                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
6043         }
6044
6045         /* Nope */
6046         return (FALSE);
6047 }
6048
6049 /*!
6050  * @brief オブジェクトを定義された基準に従いソートするための関数 /
6051  * Check if we have space for an item in the pack without overflow
6052  * @param o_ptr 比較対象オブジェクトの構造体参照ポインタ1
6053  * @param o_value o_ptrのアイテム価値（手動であらかじめ代入する必要がある？）
6054  * @param j_ptr 比較対象オブジェクトの構造体参照ポインタ2
6055  * @return o_ptrの方が上位ならばTRUEを返す。
6056  */
6057 bool object_sort_comp(object_type *o_ptr, s32b o_value, object_type *j_ptr)
6058 {
6059         int o_type, j_type;
6060
6061         /* Use empty slots */
6062         if (!j_ptr->k_idx) return TRUE;
6063
6064         /* Hack -- readable books always come first */
6065         if ((o_ptr->tval == REALM1_BOOK) &&
6066             (j_ptr->tval != REALM1_BOOK)) return TRUE;
6067         if ((j_ptr->tval == REALM1_BOOK) &&
6068             (o_ptr->tval != REALM1_BOOK)) return FALSE;
6069
6070         if ((o_ptr->tval == REALM2_BOOK) &&
6071             (j_ptr->tval != REALM2_BOOK)) return TRUE;
6072         if ((j_ptr->tval == REALM2_BOOK) &&
6073             (o_ptr->tval != REALM2_BOOK)) return FALSE;
6074
6075         /* Objects sort by decreasing type */
6076         if (o_ptr->tval > j_ptr->tval) return TRUE;
6077         if (o_ptr->tval < j_ptr->tval) return FALSE;
6078
6079         /* Non-aware (flavored) items always come last */
6080         /* Can happen in the home */
6081         if (!object_is_aware(o_ptr)) return FALSE;
6082         if (!object_is_aware(j_ptr)) return TRUE;
6083
6084         /* Objects sort by increasing sval */
6085         if (o_ptr->sval < j_ptr->sval) return TRUE;
6086         if (o_ptr->sval > j_ptr->sval) return FALSE;
6087
6088         /* Unidentified objects always come last */
6089         /* Objects in the home can be unknown */
6090         if (!object_is_known(o_ptr)) return FALSE;
6091         if (!object_is_known(j_ptr)) return TRUE;
6092
6093         /* Fixed artifacts, random artifacts and ego items */
6094         if (object_is_fixed_artifact(o_ptr)) o_type = 3;
6095         else if (o_ptr->art_name) o_type = 2;
6096         else if (object_is_ego(o_ptr)) o_type = 1;
6097         else o_type = 0;
6098
6099         if (object_is_fixed_artifact(j_ptr)) j_type = 3;
6100         else if (j_ptr->art_name) j_type = 2;
6101         else if (object_is_ego(j_ptr)) j_type = 1;
6102         else j_type = 0;
6103
6104         if (o_type < j_type) return TRUE;
6105         if (o_type > j_type) return FALSE;
6106
6107         switch (o_ptr->tval)
6108         {
6109         case TV_FIGURINE:
6110         case TV_STATUE:
6111         case TV_CORPSE:
6112         case TV_CAPTURE:
6113                 if (r_info[o_ptr->pval].level < r_info[j_ptr->pval].level) return TRUE;
6114                 if ((r_info[o_ptr->pval].level == r_info[j_ptr->pval].level) && (o_ptr->pval < j_ptr->pval)) return TRUE;
6115                 return FALSE;
6116
6117         case TV_SHOT:
6118         case TV_ARROW:
6119         case TV_BOLT:
6120                 /* Objects sort by increasing hit/damage bonuses */
6121                 if (o_ptr->to_h + o_ptr->to_d < j_ptr->to_h + j_ptr->to_d) return TRUE;
6122                 if (o_ptr->to_h + o_ptr->to_d > j_ptr->to_h + j_ptr->to_d) return FALSE;
6123                 break;
6124
6125         /* Hack:  otherwise identical rods sort by
6126         increasing recharge time --dsb */
6127         case TV_ROD:
6128                 if (o_ptr->pval < j_ptr->pval) return TRUE;
6129                 if (o_ptr->pval > j_ptr->pval) return FALSE;
6130                 break;
6131         }
6132
6133         /* Objects sort by decreasing value */
6134         return o_value > object_value(j_ptr);
6135 }
6136
6137
6138 /*!
6139  * @brief オブジェクトをプレイヤーが拾って所持スロットに納めるメインルーチン /
6140  * Add an item to the players inventory, and return the slot used.
6141  * @param o_ptr 拾うオブジェクトの構造体参照ポインタ
6142  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6143  * @details
6144  * If the new item can combine with an existing item in the inventory,\n
6145  * it will do so, using "object_similar()" and "object_absorb()", else,\n
6146  * the item will be placed into the "proper" location in the inventory.\n
6147  *\n
6148  * This function can be used to "over-fill" the player's pack, but only\n
6149  * once, and such an action must trigger the "overflow" code immediately.\n
6150  * Note that when the pack is being "over-filled", the new item must be\n
6151  * placed into the "overflow" slot, and the "overflow" must take place\n
6152  * before the pack is reordered, but (optionally) after the pack is\n
6153  * combined.  This may be tricky.  See "dungeon.c" for info.\n
6154  *\n
6155  * Note that this code must remove any location/stack information\n
6156  * from the object once it is placed into the inventory.\n
6157  */
6158 s16b inven_carry(object_type *o_ptr)
6159 {
6160         int i, j, k;
6161         int n = -1;
6162
6163         object_type *j_ptr;
6164
6165
6166         /* Check for combining */
6167         for (j = 0; j < INVEN_PACK; j++)
6168         {
6169                 j_ptr = &inventory[j];
6170
6171                 /* Skip non-objects */
6172                 if (!j_ptr->k_idx) continue;
6173
6174                 /* Hack -- track last item */
6175                 n = j;
6176
6177                 /* Check if the two items can be combined */
6178                 if (object_similar(j_ptr, o_ptr))
6179                 {
6180                         /* Combine the items */
6181                         object_absorb(j_ptr, o_ptr);
6182
6183                         /* Increase the weight */
6184                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
6185
6186                         /* Recalculate bonuses */
6187                         p_ptr->update |= (PU_BONUS);
6188
6189                         /* Window stuff */
6190                         p_ptr->window |= (PW_INVEN);
6191
6192                         /* Success */
6193                         return (j);
6194                 }
6195         }
6196
6197
6198         /* Paranoia */
6199         if (inven_cnt > INVEN_PACK) return (-1);
6200
6201         /* Find an empty slot */
6202         for (j = 0; j <= INVEN_PACK; j++)
6203         {
6204                 j_ptr = &inventory[j];
6205
6206                 /* Use it if found */
6207                 if (!j_ptr->k_idx) break;
6208         }
6209
6210         /* Use that slot */
6211         i = j;
6212
6213
6214         /* Reorder the pack */
6215         if (i < INVEN_PACK)
6216         {
6217                 /* Get the "value" of the item */
6218                 s32b o_value = object_value(o_ptr);
6219
6220                 /* Scan every occupied slot */
6221                 for (j = 0; j < INVEN_PACK; j++)
6222                 {
6223                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6224                 }
6225
6226                 /* Use that slot */
6227                 i = j;
6228
6229                 /* Slide objects */
6230                 for (k = n; k >= i; k--)
6231                 {
6232                         /* Hack -- Slide the item */
6233                         object_copy(&inventory[k+1], &inventory[k]);
6234                 }
6235
6236                 /* Wipe the empty slot */
6237                 object_wipe(&inventory[i]);
6238         }
6239
6240
6241         /* Copy the item */
6242         object_copy(&inventory[i], o_ptr);
6243
6244         /* Access new object */
6245         j_ptr = &inventory[i];
6246
6247         /* Forget stack */
6248         j_ptr->next_o_idx = 0;
6249
6250         /* Forget monster */
6251         j_ptr->held_m_idx = 0;
6252
6253         /* Forget location */
6254         j_ptr->iy = j_ptr->ix = 0;
6255
6256         /* Player touches it, and no longer marked */
6257         j_ptr->marked = OM_TOUCHED;
6258
6259         /* Increase the weight */
6260         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
6261
6262         /* Count the items */
6263         inven_cnt++;
6264
6265         /* Recalculate bonuses */
6266         p_ptr->update |= (PU_BONUS);
6267
6268         /* Combine and Reorder pack */
6269         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
6270
6271         /* Window stuff */
6272         p_ptr->window |= (PW_INVEN);
6273
6274         /* Return the slot */
6275         return (i);
6276 }
6277
6278
6279 /*!
6280  * @brief 装備スロットからオブジェクトを外すメインルーチン /
6281  * Take off (some of) a non-cursed equipment item
6282  * @param item オブジェクトを外したい所持テーブルのID
6283  * @param amt 外したい個数
6284  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
6285  * @details
6286  * Note that only one item at a time can be wielded per slot.\n
6287  * Note that taking off an item when "full" may cause that item\n
6288  * to fall to the ground.\n
6289  * Return the inventory slot into which the item is placed.\n
6290  */
6291 s16b inven_takeoff(int item, int amt)
6292 {
6293         int slot;
6294
6295         object_type forge;
6296         object_type *q_ptr;
6297
6298         object_type *o_ptr;
6299
6300         cptr act;
6301
6302         char o_name[MAX_NLEN];
6303
6304
6305         /* Get the item to take off */
6306         o_ptr = &inventory[item];
6307
6308         /* Paranoia */
6309         if (amt <= 0) return (-1);
6310
6311         /* Verify */
6312         if (amt > o_ptr->number) amt = o_ptr->number;
6313
6314         /* Get local object */
6315         q_ptr = &forge;
6316
6317         /* Obtain a local object */
6318         object_copy(q_ptr, o_ptr);
6319
6320         /* Modify quantity */
6321         q_ptr->number = amt;
6322
6323         /* Describe the object */
6324         object_desc(o_name, q_ptr, 0);
6325
6326         /* Took off weapon */
6327         if (((item == INVEN_RARM) || (item == INVEN_LARM)) &&
6328             object_is_melee_weapon(o_ptr))
6329         {
6330                 act = _("を装備からはずした", "You were wielding");
6331         }
6332
6333         /* Took off bow */
6334         else if (item == INVEN_BOW)
6335         {
6336                 act = _("を装備からはずした", "You were holding");
6337         }
6338
6339         /* Took off light */
6340         else if (item == INVEN_LITE)
6341         {
6342                 act = _("を光源からはずした", "You were holding");
6343         }
6344
6345         /* Took off something */
6346         else
6347         {
6348                 act = _("を装備からはずした", "You were wearing");
6349         }
6350
6351         /* Modify, Optimize */
6352         inven_item_increase(item, -amt);
6353         inven_item_optimize(item);
6354
6355         /* Carry the object */
6356         slot = inven_carry(q_ptr);
6357
6358         /* Message */
6359 #ifdef JP
6360         msg_format("%s(%c)%s。", o_name, index_to_label(slot), act);
6361 #else
6362         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
6363 #endif
6364
6365
6366         /* Return slot */
6367         return (slot);
6368 }
6369
6370
6371 /*!
6372  * @brief 所持スロットから床下にオブジェクトを落とすメインルーチン /
6373  * Drop (some of) a non-cursed inventory/equipment item
6374  * @param item 所持テーブルのID
6375  * @param amt 落としたい個数
6376  * @return なし
6377  * @details
6378  * The object will be dropped "near" the current location
6379  */
6380 void inven_drop(int item, int amt)
6381 {
6382         object_type forge;
6383         object_type *q_ptr;
6384
6385         object_type *o_ptr;
6386
6387         char o_name[MAX_NLEN];
6388
6389
6390         /* Access original object */
6391         o_ptr = &inventory[item];
6392
6393         /* Error check */
6394         if (amt <= 0) return;
6395
6396         /* Not too many */
6397         if (amt > o_ptr->number) amt = o_ptr->number;
6398
6399
6400         /* Take off equipment */
6401         if (item >= INVEN_RARM)
6402         {
6403                 /* Take off first */
6404                 item = inven_takeoff(item, amt);
6405
6406                 /* Access original object */
6407                 o_ptr = &inventory[item];
6408         }
6409
6410
6411         /* Get local object */
6412         q_ptr = &forge;
6413
6414         /* Obtain local object */
6415         object_copy(q_ptr, o_ptr);
6416
6417         /* Distribute charges of wands or rods */
6418         distribute_charges(o_ptr, q_ptr, amt);
6419
6420         /* Modify quantity */
6421         q_ptr->number = amt;
6422
6423         /* Describe local object */
6424         object_desc(o_name, q_ptr, 0);
6425
6426         /* Message */
6427         msg_format(_("%s(%c)を落とした。", "You drop %s (%c)."), o_name, index_to_label(item));
6428
6429         /* Drop it near the player */
6430         (void)drop_near(q_ptr, 0, p_ptr->y, p_ptr->x);
6431
6432         /* Modify, Describe, Optimize */
6433         inven_item_increase(item, -amt);
6434         inven_item_describe(item);
6435         inven_item_optimize(item);
6436 }
6437
6438
6439 /*!
6440  * @brief プレイヤーの所持スロットに存在するオブジェクトをまとめなおす /
6441  * Combine items in the pack
6442  * @return なし
6443  * @details
6444  * Note special handling of the "overflow" slot
6445  */
6446 void combine_pack(void)
6447 {
6448         int             i, j, k;
6449         object_type     *o_ptr;
6450         object_type     *j_ptr;
6451         bool            flag = FALSE, combined;
6452
6453         do
6454         {
6455                 combined = FALSE;
6456
6457                 /* Combine the pack (backwards) */
6458                 for (i = INVEN_PACK; i > 0; i--)
6459                 {
6460                         /* Get the item */
6461                         o_ptr = &inventory[i];
6462
6463                         /* Skip empty items */
6464                         if (!o_ptr->k_idx) continue;
6465
6466                         /* Scan the items above that item */
6467                         for (j = 0; j < i; j++)
6468                         {
6469                                 int max_num;
6470
6471                                 /* Get the item */
6472                                 j_ptr = &inventory[j];
6473
6474                                 /* Skip empty items */
6475                                 if (!j_ptr->k_idx) continue;
6476
6477                                 /*
6478                                  * Get maximum number of the stack if these
6479                                  * are similar, get zero otherwise.
6480                                  */
6481                                 max_num = object_similar_part(j_ptr, o_ptr);
6482
6483                                 /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
6484                                 if (max_num && j_ptr->number < max_num)
6485                                 {
6486                                         if (o_ptr->number + j_ptr->number <= max_num)
6487                                         {
6488                                                 /* Take note */
6489                                                 flag = TRUE;
6490
6491                                                 /* Add together the item counts */
6492                                                 object_absorb(j_ptr, o_ptr);
6493
6494                                                 /* One object is gone */
6495                                                 inven_cnt--;
6496
6497                                                 /* Slide everything down */
6498                                                 for (k = i; k < INVEN_PACK; k++)
6499                                                 {
6500                                                         /* Structure copy */
6501                                                         inventory[k] = inventory[k+1];
6502                                                 }
6503
6504                                                 /* Erase the "final" slot */
6505                                                 object_wipe(&inventory[k]);
6506                                         }
6507                                         else
6508                                         {
6509                                                 int old_num = o_ptr->number;
6510                                                 int remain = j_ptr->number + o_ptr->number - max_num;
6511 #if 0
6512                                                 o_ptr->number -= remain;
6513 #endif
6514                                                 /* Add together the item counts */
6515                                                 object_absorb(j_ptr, o_ptr);
6516
6517                                                 o_ptr->number = remain;
6518
6519                                                 /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
6520                                                 if (o_ptr->tval == TV_ROD)
6521                                                 {
6522                                                         o_ptr->pval =  o_ptr->pval * remain / old_num;
6523                                                         o_ptr->timeout = o_ptr->timeout * remain / old_num;
6524                                                 }
6525
6526                                                 /* Hack -- if wands are stacking, combine the charges. -LM- */
6527                                                 if (o_ptr->tval == TV_WAND)
6528                                                 {
6529                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
6530                                                 }
6531                                         }
6532
6533                                         /* Window stuff */
6534                                         p_ptr->window |= (PW_INVEN);
6535
6536                                         /* Take note */
6537                                         combined = TRUE;
6538
6539                                         /* Done */
6540                                         break;
6541                                 }
6542                         }
6543                 }
6544         }
6545         while (combined);
6546
6547         /* Message */
6548         if (flag) msg_print(_("ザックの中のアイテムをまとめ直した。", "You combine some items in your pack."));
6549 }
6550
6551 /*!
6552  * @brief プレイヤーの所持スロットに存在するオブジェクトを並び替える /
6553  * Reorder items in the pack
6554  * @return なし
6555  * @details
6556  * Note special handling of the "overflow" slot
6557  */
6558 void reorder_pack(void)
6559 {
6560         int             i, j, k;
6561         s32b            o_value;
6562         object_type     forge;
6563         object_type     *q_ptr;
6564         object_type     *o_ptr;
6565         bool            flag = FALSE;
6566
6567
6568         /* Re-order the pack (forwards) */
6569         for (i = 0; i < INVEN_PACK; i++)
6570         {
6571                 /* Mega-Hack -- allow "proper" over-flow */
6572                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6573
6574                 /* Get the item */
6575                 o_ptr = &inventory[i];
6576
6577                 /* Skip empty slots */
6578                 if (!o_ptr->k_idx) continue;
6579
6580                 /* Get the "value" of the item */
6581                 o_value = object_value(o_ptr);
6582
6583                 /* Scan every occupied slot */
6584                 for (j = 0; j < INVEN_PACK; j++)
6585                 {
6586                         if (object_sort_comp(o_ptr, o_value, &inventory[j])) break;
6587                 }
6588
6589                 /* Never move down */
6590                 if (j >= i) continue;
6591
6592                 /* Take note */
6593                 flag = TRUE;
6594
6595                 /* Get local object */
6596                 q_ptr = &forge;
6597
6598                 /* Save a copy of the moving item */
6599                 object_copy(q_ptr, &inventory[i]);
6600
6601                 /* Slide the objects */
6602                 for (k = i; k > j; k--)
6603                 {
6604                         /* Slide the item */
6605                         object_copy(&inventory[k], &inventory[k-1]);
6606                 }
6607
6608                 /* Insert the moving item */
6609                 object_copy(&inventory[j], q_ptr);
6610
6611                 /* Window stuff */
6612                 p_ptr->window |= (PW_INVEN);
6613         }
6614
6615         /* Message */
6616         if (flag) msg_print(_("ザックの中のアイテムを並べ直した。", "You reorder some items in your pack."));
6617 }
6618
6619 /*!
6620  * @brief 現在アクティブになっているウィンドウにオブジェクトの詳細を表示する /
6621  * Hack -- display an object kind in the current window
6622  * @param k_idx ベースアイテムの参照ID
6623  * @return なし
6624  * @details
6625  * Include list of usable spells for readible books
6626  */
6627 void display_koff(int k_idx)
6628 {
6629         int y;
6630
6631         object_type forge;
6632         object_type *q_ptr;
6633         int         sval;
6634         int         use_realm;
6635
6636         char o_name[MAX_NLEN];
6637
6638
6639         /* Erase the window */
6640         for (y = 0; y < Term->hgt; y++)
6641         {
6642                 /* Erase the line */
6643                 Term_erase(0, y, 255);
6644         }
6645
6646         /* No info */
6647         if (!k_idx) return;
6648
6649         /* Get local object */
6650         q_ptr = &forge;
6651
6652         /* Prepare the object */
6653         object_prep(q_ptr, k_idx);
6654
6655         /* Describe */
6656         object_desc(o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
6657
6658         /* Mention the object name */
6659         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6660
6661         /* Access the item's sval */
6662         sval = q_ptr->sval;
6663         use_realm = tval2realm(q_ptr->tval);
6664
6665         /* Warriors are illiterate */
6666         if (p_ptr->realm1 || p_ptr->realm2)
6667         {
6668                 if ((use_realm != p_ptr->realm1) && (use_realm != p_ptr->realm2)) return;
6669         }
6670         else
6671         {
6672                 if ((p_ptr->pclass != CLASS_SORCERER) && (p_ptr->pclass != CLASS_RED_MAGE)) return;
6673                 if (!is_magic(use_realm)) return;
6674                 if ((p_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1)) return;
6675         }
6676
6677         /* Display spells in readible books */
6678         {
6679                 int     spell = -1;
6680                 int     num = 0;
6681                 byte    spells[64];
6682
6683                 /* Extract spells */
6684                 for (spell = 0; spell < 32; spell++)
6685                 {
6686                         /* Check for this spell */
6687                         if (fake_spell_flags[sval] & (1L << spell))
6688                         {
6689                                 /* Collect this spell */
6690                                 spells[num++] = spell;
6691                         }
6692                 }
6693
6694                 /* Print spells */
6695                 print_spells(0, spells, num, 2, 0, use_realm);
6696         }
6697 }
6698
6699 /*!
6700  * @brief 警告を放つアイテムを選択する /
6701  * Choose one of items that have warning flag
6702  * Calculate spell damages
6703  * @return 警告を行う
6704  */
6705 object_type *choose_warning_item(void)
6706 {
6707         int i;
6708         int choices[INVEN_TOTAL - INVEN_RARM];
6709         int number = 0;
6710
6711         /* Paranoia -- Player has no warning ability */
6712         if (!p_ptr->warning) return NULL;
6713
6714         /* Search Inventory */
6715         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6716         {
6717                 u32b flgs[TR_FLAG_SIZE];
6718                 object_type *o_ptr = &inventory[i];
6719
6720                 object_flags(o_ptr, flgs);
6721                 if (have_flag(flgs, TR_WARNING))
6722                 {
6723                         choices[number] = i;
6724                         number++;
6725                 }
6726         }
6727
6728         /* Choice one of them */
6729         return number ? &inventory[choices[randint0(number)]] : NULL;
6730 }
6731
6732 /*!
6733  * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する /
6734  * Calculate spell damages
6735  * @param m_ptr 魔法を行使するモンスターの構造体参照ポインタ
6736  * @param typ 効果属性のID
6737  * @param dam 基本ダメージ
6738  * @param max 算出した最大ダメージを返すポインタ
6739  * @return なし
6740  */
6741 static void spell_damcalc(monster_type *m_ptr, int typ, int dam, int *max)
6742 {
6743         monster_race *r_ptr = &r_info[m_ptr->r_idx];
6744         int          rlev = r_ptr->level;
6745         bool         ignore_wraith_form = FALSE;
6746
6747         /* Vulnerability, resistance and immunity */
6748         switch (typ)
6749         {
6750         case GF_ELEC:
6751                 if (p_ptr->immune_elec)
6752                 {
6753                         dam = 0;
6754                         ignore_wraith_form = TRUE;
6755                 }
6756                 else
6757                 {
6758                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6759                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6760                         if (prace_is_(RACE_ANDROID)) dam += dam / 3;
6761                         if (p_ptr->resist_elec) dam = (dam + 2) / 3;
6762                         if (IS_OPPOSE_ELEC())
6763                                 dam = (dam + 2) / 3;
6764                 }
6765                 break;
6766
6767         case GF_POIS:
6768                 if (p_ptr->resist_pois) dam = (dam + 2) / 3;
6769                 if (IS_OPPOSE_POIS()) dam = (dam + 2) / 3;
6770                 break;
6771
6772         case GF_ACID:
6773                 if (p_ptr->immune_acid)
6774                 {
6775                         dam = 0;
6776                         ignore_wraith_form = TRUE;
6777                 }
6778                 else
6779                 {
6780                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6781                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6782                         if (p_ptr->resist_acid) dam = (dam + 2) / 3;
6783                         if (IS_OPPOSE_ACID()) dam = (dam + 2) / 3;
6784                 }
6785                 break;
6786
6787         case GF_COLD:
6788         case GF_ICE:
6789                 if (p_ptr->immune_cold)
6790                 {
6791                         dam = 0;
6792                         ignore_wraith_form = TRUE;
6793                 }
6794                 else
6795                 {
6796                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6797                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6798                         if (p_ptr->resist_cold) dam = (dam + 2) / 3;
6799                         if (IS_OPPOSE_COLD()) dam = (dam + 2) / 3;
6800                 }
6801                 break;
6802
6803         case GF_FIRE:
6804                 if (p_ptr->immune_fire)
6805                 {
6806                         dam = 0;
6807                         ignore_wraith_form = TRUE;
6808                 }
6809                 else
6810                 {
6811                         if (p_ptr->muta3 & MUT3_VULN_ELEM) dam *= 2;
6812                         if (prace_is_(RACE_ENT)) dam += dam / 3;
6813                         if (p_ptr->special_defense & KATA_KOUKIJIN) dam += dam / 3;
6814                         if (p_ptr->resist_fire) dam = (dam + 2) / 3;
6815                         if (IS_OPPOSE_FIRE()) dam = (dam + 2) / 3;
6816                 }
6817                 break;
6818
6819         case GF_PSY_SPEAR:
6820                 ignore_wraith_form = TRUE;
6821                 break;
6822
6823         case GF_ARROW:
6824                 if (!p_ptr->blind &&
6825                     ((inventory[INVEN_RARM].k_idx && (inventory[INVEN_RARM].name1 == ART_ZANTETSU)) ||
6826                      (inventory[INVEN_LARM].k_idx && (inventory[INVEN_LARM].name1 == ART_ZANTETSU))))
6827                 {
6828                         dam = 0;
6829                         ignore_wraith_form = TRUE;
6830                 }
6831                 break;
6832
6833         case GF_LITE:
6834                 if (p_ptr->resist_lite) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6835                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE)) dam *= 2;
6836                 else if (prace_is_(RACE_S_FAIRY)) dam = dam * 4 / 3;
6837
6838                 /*
6839                  * Cannot use "ignore_wraith_form" strictly (for "random one damage")
6840                  * "dam *= 2;" for later "dam /= 2"
6841                  */
6842                 if (p_ptr->wraith_form) dam *= 2;
6843                 break;
6844
6845         case GF_DARK:
6846                 if (prace_is_(RACE_VAMPIRE) || (p_ptr->mimic_form == MIMIC_VAMPIRE) || p_ptr->wraith_form)
6847                 {
6848                         dam = 0;
6849                         ignore_wraith_form = TRUE;
6850                 }
6851                 else if (p_ptr->resist_dark) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6852                 break;
6853
6854         case GF_SHARDS:
6855                 if (p_ptr->resist_shard) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6856                 break;
6857
6858         case GF_SOUND:
6859                 if (p_ptr->resist_sound) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6860                 break;
6861
6862         case GF_CONFUSION:
6863                 if (p_ptr->resist_conf) dam = dam * 5 / 8; /* Worst case of 5 / (d4 + 7) */
6864                 break;
6865
6866         case GF_CHAOS:
6867                 if (p_ptr->resist_chaos) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6868                 break;
6869
6870         case GF_NETHER:
6871                 if (prace_is_(RACE_SPECTRE))
6872                 {
6873                         dam = 0;
6874                         ignore_wraith_form = TRUE;
6875                 }
6876                 else if (p_ptr->resist_neth) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6877                 break;
6878
6879         case GF_DISENCHANT:
6880                 if (p_ptr->resist_disen) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6881                 break;
6882
6883         case GF_NEXUS:
6884                 if (p_ptr->resist_nexus) dam = dam * 3 / 4; /* Worst case of 6 / (d4 + 7) */
6885                 break;
6886
6887         case GF_TIME:
6888                 if (p_ptr->resist_time) dam /= 2; /* Worst case of 4 / (d4 + 7) */
6889                 break;
6890
6891         case GF_GRAVITY:
6892                 if (p_ptr->levitation) dam = (dam * 2) / 3;
6893                 break;
6894
6895         case GF_ROCKET:
6896                 if (p_ptr->resist_shard) dam /= 2;
6897                 break;
6898
6899         case GF_NUKE:
6900                 if (p_ptr->resist_pois) dam = (2 * dam + 2) / 5;
6901                 if (IS_OPPOSE_POIS()) dam = (2 * dam + 2) / 5;
6902                 break;
6903
6904         case GF_DEATH_RAY:
6905                 if (p_ptr->mimic_form)
6906                 {
6907                         if (mimic_info[p_ptr->mimic_form].MIMIC_FLAGS & MIMIC_IS_NONLIVING)
6908                         {
6909                                 dam = 0;
6910                                 ignore_wraith_form = TRUE;
6911                         }
6912                 }
6913                 else
6914                 {
6915                         switch (p_ptr->prace)
6916                         {
6917                         case RACE_GOLEM:
6918                         case RACE_SKELETON:
6919                         case RACE_ZOMBIE:
6920                         case RACE_VAMPIRE:
6921                         case RACE_DEMON:
6922                         case RACE_SPECTRE:
6923                                 dam = 0;
6924                                 ignore_wraith_form = TRUE;
6925                                 break;
6926                         }
6927                 }
6928                 break;
6929
6930         case GF_HOLY_FIRE:
6931                 if (p_ptr->align > 10) dam /= 2;
6932                 else if (p_ptr->align < -10) dam *= 2;
6933                 break;
6934
6935         case GF_HELL_FIRE:
6936                 if (p_ptr->align > 10) dam *= 2;
6937                 break;
6938
6939         case GF_MIND_BLAST:
6940         case GF_BRAIN_SMASH:
6941                 if (100 + rlev / 2 <= MAX(5, p_ptr->skill_sav))
6942                 {
6943                         dam = 0;
6944                         ignore_wraith_form = TRUE;
6945                 }
6946                 break;
6947
6948         case GF_CAUSE_1:
6949         case GF_CAUSE_2:
6950         case GF_CAUSE_3:
6951         case GF_HAND_DOOM:
6952                 if (100 + rlev / 2 <= p_ptr->skill_sav)
6953                 {
6954                         dam = 0;
6955                         ignore_wraith_form = TRUE;
6956                 }
6957                 break;
6958
6959         case GF_CAUSE_4:
6960                 if ((100 + rlev / 2 <= p_ptr->skill_sav) && (m_ptr->r_idx != MON_KENSHIROU))
6961                 {
6962                         dam = 0;
6963                         ignore_wraith_form = TRUE;
6964                 }
6965                 break;
6966         }
6967
6968         if (p_ptr->wraith_form && !ignore_wraith_form)
6969         {
6970                 dam /= 2;
6971                 if (!dam) dam = 1;
6972         }
6973
6974         if (dam > *max) *max = dam;
6975 }
6976
6977 /*!
6978 * @brief 警告基準を定めるために魔法の効果属性に基づいて最大魔法ダメージを計算する。 /
6979 * Calculate spell damages
6980 * @param spell_num RF4ならRF4_SPELL_STARTのように32区切りのベースとなる数値
6981 * @param typ 効果属性のID
6982 * @param m_idx 魔法を行使するモンスターのID
6983 * @param max 算出した最大ダメージを返すポインタ
6984 * @return なし
6985 */
6986 void spell_damcalc_by_spellnum(int spell_num, int typ, int m_idx, int *max)
6987 {
6988     monster_type *m_ptr = &m_list[m_idx];
6989     int dam = monspell_damage((spell_num), m_idx, DAM_MAX);
6990     spell_damcalc(m_ptr, typ, dam, max);
6991 }
6992
6993 /*!
6994  * @brief 警告基準を定めるためにモンスターの打撃最大ダメージを算出する /
6995  * Calculate blow damages
6996  * @param m_ptr 打撃を行使するモンスターの構造体参照ポインタ
6997  * @param blow_ptr モンスターの打撃能力の構造体参照ポインタ
6998  * @return 算出された最大ダメージを返す。
6999  */
7000 static int blow_damcalc(monster_type *m_ptr, monster_blow *blow_ptr)
7001 {
7002         int  dam = blow_ptr->d_dice * blow_ptr->d_side;
7003         int  dummy_max = 0;
7004         bool check_wraith_form = TRUE;
7005
7006         if (blow_ptr->method != RBM_EXPLODE)
7007         {
7008                 int ac = p_ptr->ac + p_ptr->to_a;
7009
7010                 switch (blow_ptr->effect)
7011                 {
7012                 case RBE_SUPERHURT:
7013                 {
7014                         int tmp_dam = dam - (dam * ((ac < 150) ? ac : 150) / 250);
7015                         dam = MAX(dam, tmp_dam * 2);
7016                         break;
7017                 }
7018
7019                 case RBE_HURT:
7020                 case RBE_SHATTER:
7021                         dam -= (dam * ((ac < 150) ? ac : 150) / 250);
7022                         break;
7023
7024                 case RBE_ACID:
7025                         spell_damcalc(m_ptr, GF_ACID, dam, &dummy_max);
7026                         dam = dummy_max;
7027                         check_wraith_form = FALSE;
7028                         break;
7029
7030                 case RBE_ELEC:
7031                         spell_damcalc(m_ptr, GF_ELEC, dam, &dummy_max);
7032                         dam = dummy_max;
7033                         check_wraith_form = FALSE;
7034                         break;
7035
7036                 case RBE_FIRE:
7037                         spell_damcalc(m_ptr, GF_FIRE, dam, &dummy_max);
7038                         dam = dummy_max;
7039                         check_wraith_form = FALSE;
7040                         break;
7041
7042                 case RBE_COLD:
7043                         spell_damcalc(m_ptr, GF_COLD, dam, &dummy_max);
7044                         dam = dummy_max;
7045                         check_wraith_form = FALSE;
7046                         break;
7047
7048                 case RBE_DR_MANA:
7049                         dam = 0;
7050                         check_wraith_form = FALSE;
7051                         break;
7052                 }
7053
7054                 if (check_wraith_form && p_ptr->wraith_form)
7055                 {
7056                         dam /= 2;
7057                         if (!dam) dam = 1;
7058                 }
7059         }
7060         else
7061         {
7062                 dam = (dam + 1) / 2;
7063                 spell_damcalc(m_ptr, mbe_info[blow_ptr->effect].explode_type, dam, &dummy_max);
7064                 dam = dummy_max;
7065         }
7066
7067         return dam;
7068 }
7069
7070 /*!
7071  * @brief プレイヤーが特定地点へ移動した場合に警告を発する処理 /
7072  * Examine the grid (xx,yy) and warn the player if there are any danger
7073  * @param xx 危険性を調査するマスのX座標
7074  * @param yy 危険性を調査するマスのY座標
7075  * @return 警告を無視して進むことを選択するかか問題が無ければTRUE、警告に従ったならFALSEを返す。
7076  */
7077 bool process_warning(int xx, int yy)
7078 {
7079         int mx, my;
7080         cave_type *c_ptr;
7081         char o_name[MAX_NLEN];
7082
7083 #define WARNING_AWARE_RANGE 12
7084         int dam_max = 0;
7085         static int old_damage = 0;
7086
7087         for (mx = xx - WARNING_AWARE_RANGE; mx < xx + WARNING_AWARE_RANGE + 1; mx++)
7088         {
7089                 for (my = yy - WARNING_AWARE_RANGE; my < yy + WARNING_AWARE_RANGE + 1; my++)
7090                 {
7091                         int dam_max0 = 0;
7092                         monster_type *m_ptr;
7093                         monster_race *r_ptr;
7094
7095                         if (!in_bounds(my, mx) || (distance(my, mx, yy, xx) > WARNING_AWARE_RANGE)) continue;
7096
7097                         c_ptr = &cave[my][mx];
7098
7099                         if (!c_ptr->m_idx) continue;
7100
7101                         m_ptr = &m_list[c_ptr->m_idx];
7102
7103                         if (MON_CSLEEP(m_ptr)) continue;
7104                         if (!is_hostile(m_ptr)) continue;
7105
7106                         r_ptr = &r_info[m_ptr->r_idx];
7107
7108                         /* Monster spells (only powerful ones)*/
7109                         if (projectable(my, mx, yy, xx))
7110             {
7111                                 u32b f4 = r_ptr->flags4;
7112                                 u32b f5 = r_ptr->a_ability_flags1;
7113                                 u32b f6 = r_ptr->a_ability_flags2;
7114
7115                                 if (!(d_info[dungeon_type].flags1 & DF1_NO_MAGIC))
7116                                 {
7117                     if (f4 & RF4_BA_CHAO) spell_damcalc_by_spellnum(MS_BALL_CHAOS, GF_CHAOS, c_ptr->m_idx,  &dam_max0);
7118                     if (f5 & RF5_BA_MANA) spell_damcalc_by_spellnum(MS_BALL_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7119                     if (f5 & RF5_BA_DARK) spell_damcalc_by_spellnum(MS_BALL_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7120                     if (f5 & RF5_BA_LITE) spell_damcalc_by_spellnum(MS_STARBURST, GF_LITE, c_ptr->m_idx, &dam_max0);
7121                     if (f6 & RF6_HAND_DOOM) spell_damcalc_by_spellnum(MS_HAND_DOOM, GF_HAND_DOOM, c_ptr->m_idx, &dam_max0);
7122                     if (f6 & RF6_PSY_SPEAR) spell_damcalc_by_spellnum(MS_PSY_SPEAR, GF_PSY_SPEAR, c_ptr->m_idx, &dam_max0);
7123                                 }
7124                 if (f4 & RF4_ROCKET) spell_damcalc_by_spellnum(MS_ROCKET, GF_ROCKET, c_ptr->m_idx, &dam_max0);
7125                 if (f4 & RF4_BR_ACID) spell_damcalc_by_spellnum(MS_BR_ACID, GF_ACID, c_ptr->m_idx, &dam_max0);
7126                 if (f4 & RF4_BR_ELEC) spell_damcalc_by_spellnum(MS_BR_ELEC, GF_ELEC, c_ptr->m_idx, &dam_max0);
7127                 if (f4 & RF4_BR_FIRE) spell_damcalc_by_spellnum(MS_BR_FIRE, GF_FIRE, c_ptr->m_idx, &dam_max0);
7128                 if (f4 & RF4_BR_COLD) spell_damcalc_by_spellnum(MS_BR_COLD, GF_COLD, c_ptr->m_idx, &dam_max0);
7129                 if (f4 & RF4_BR_POIS) spell_damcalc_by_spellnum(MS_BR_POIS, GF_POIS, c_ptr->m_idx, &dam_max0);
7130                 if (f4 & RF4_BR_NETH) spell_damcalc_by_spellnum(MS_BR_NETHER, GF_NETHER, c_ptr->m_idx, &dam_max0);
7131                 if (f4 & RF4_BR_LITE) spell_damcalc_by_spellnum(MS_BR_LITE, GF_LITE, c_ptr->m_idx, &dam_max0);
7132                 if (f4 & RF4_BR_DARK) spell_damcalc_by_spellnum(MS_BR_DARK, GF_DARK, c_ptr->m_idx, &dam_max0);
7133                 if (f4 & RF4_BR_CONF) spell_damcalc_by_spellnum(MS_BR_CONF, GF_CONFUSION, c_ptr->m_idx, &dam_max0);
7134                 if (f4 & RF4_BR_SOUN) spell_damcalc_by_spellnum(MS_BR_SOUND, GF_SOUND, c_ptr->m_idx, &dam_max0);
7135                 if (f4 & RF4_BR_CHAO) spell_damcalc_by_spellnum(MS_BR_CHAOS, GF_CHAOS, c_ptr->m_idx, &dam_max0);
7136                 if (f4 & RF4_BR_DISE) spell_damcalc_by_spellnum(MS_BR_DISEN, GF_DISENCHANT, c_ptr->m_idx, &dam_max0);
7137                 if (f4 & RF4_BR_NEXU) spell_damcalc_by_spellnum(MS_BR_NEXUS, GF_NEXUS, c_ptr->m_idx, &dam_max0);
7138                 if (f4 & RF4_BR_TIME) spell_damcalc_by_spellnum(MS_BR_TIME, GF_TIME, c_ptr->m_idx, &dam_max0);
7139                 if (f4 & RF4_BR_INER) spell_damcalc_by_spellnum(MS_BR_INERTIA, GF_INERTIAL, c_ptr->m_idx, &dam_max0);
7140                 if (f4 & RF4_BR_GRAV) spell_damcalc_by_spellnum(MS_BR_GRAVITY, GF_GRAVITY, c_ptr->m_idx, &dam_max0);
7141                 if (f4 & RF4_BR_SHAR) spell_damcalc_by_spellnum(MS_BR_SHARDS, GF_SHARDS, c_ptr->m_idx, &dam_max0);
7142                 if (f4 & RF4_BR_PLAS) spell_damcalc_by_spellnum(MS_BR_PLASMA, GF_PLASMA, c_ptr->m_idx, &dam_max0);
7143                 if (f4 & RF4_BR_WALL) spell_damcalc_by_spellnum(MS_BR_FORCE, GF_FORCE, c_ptr->m_idx, &dam_max0);
7144                 if (f4 & RF4_BR_MANA) spell_damcalc_by_spellnum(MS_BR_MANA, GF_MANA, c_ptr->m_idx, &dam_max0);
7145                 if (f4 & RF4_BR_NUKE) spell_damcalc_by_spellnum(MS_BR_NUKE, GF_NUKE, c_ptr->m_idx, &dam_max0);
7146                 if (f4 & RF4_BR_DISI) spell_damcalc_by_spellnum(MS_BR_DISI, GF_DISINTEGRATE, c_ptr->m_idx, &dam_max0);
7147                         }
7148
7149                         /* Monster melee attacks */
7150                         if (!(r_ptr->flags1 & RF1_NEVER_BLOW) && !(d_info[dungeon_type].flags1 & DF1_NO_MELEE))
7151                         {
7152                                 if (mx <= xx + 1 && mx >= xx - 1 && my <= yy + 1 && my >= yy - 1)
7153                                 {
7154                                         int m;
7155                                         int dam_melee = 0;
7156                                         for (m = 0; m < 4; m++)
7157                                         {
7158                                                 /* Skip non-attacks */
7159                                                 if (!r_ptr->blow[m].method || (r_ptr->blow[m].method == RBM_SHOOT)) continue;
7160
7161                                                 /* Extract the attack info */
7162                                                 dam_melee += blow_damcalc(m_ptr, &r_ptr->blow[m]);
7163                                                 if (r_ptr->blow[m].method == RBM_EXPLODE) break;
7164                                         }
7165                                         if (dam_melee > dam_max0) dam_max0 = dam_melee;
7166                                 }
7167                         }
7168
7169                         /* Contribution from this monster */
7170                         dam_max += dam_max0;
7171                 }
7172         }
7173
7174         /* Prevent excessive warning */
7175         if (dam_max > old_damage)
7176         {
7177                 old_damage = dam_max * 3 / 2;
7178
7179                 if (dam_max > p_ptr->chp / 2)
7180                 {
7181                         object_type *o_ptr = choose_warning_item();
7182
7183                         if (o_ptr)
7184                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7185             else
7186                 strcpy(o_name, _("体", "body")); /* Warning ability without item */
7187             msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7188
7189                         disturb(0, 1);
7190             return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7191                 }
7192         }
7193         else old_damage = old_damage / 2;
7194
7195         c_ptr = &cave[yy][xx];
7196         if (((!easy_disarm && is_trap(c_ptr->feat))
7197             || (c_ptr->mimic && is_trap(c_ptr->feat))) && !one_in_(13))
7198         {
7199                 object_type *o_ptr = choose_warning_item();
7200
7201                 if (o_ptr)
7202             object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7203         else
7204             strcpy(o_name, _("体", "body")); /* Warning ability without item */
7205         msg_format(_("%sが鋭く震えた！", "Your %s pulsates sharply!"), o_name);
7206                 disturb(0, 1);
7207         return get_check(_("本当にこのまま進むか？", "Really want to go ahead? "));
7208         }
7209
7210         return TRUE;
7211 }
7212
7213 /*!
7214  * @brief エッセンスの付加可能な武器や矢弾かを返す
7215  * @param o_ptr チェックしたいオブジェクトの構造体参照ポインタ
7216  * @return エッセンスの付加可能な武器か矢弾ならばTRUEを返す。
7217  */
7218 static bool item_tester_hook_melee_ammo(object_type *o_ptr)
7219 {
7220         switch (o_ptr->tval)
7221         {
7222                 case TV_HAFTED:
7223                 case TV_POLEARM:
7224                 case TV_DIGGING:
7225                 case TV_BOLT:
7226                 case TV_ARROW:
7227                 case TV_SHOT:
7228                 {
7229                         return (TRUE);
7230                 }
7231                 case TV_SWORD:
7232                 {
7233                         if (o_ptr->sval != SV_DOKUBARI) return (TRUE);
7234                 }
7235         }
7236
7237         return (FALSE);
7238 }
7239
7240
7241 /*!
7242  * エッセンス情報の構造体 / A structure for smithing
7243  */
7244 typedef struct {
7245         int add;       /* TR flag number or special essence id */
7246         cptr add_name; /* Name of this ability */
7247         int type;      /* Menu number */
7248         int essence;   /* Index for carrying essences */
7249         int value;     /* Needed value to add this ability */
7250 } essence_type;
7251
7252
7253 /*!
7254  * エッセンス情報テーブル Smithing type data for Weapon smith
7255  */
7256 #ifdef JP
7257 static essence_type essence_info[] =
7258 {
7259         {TR_STR, "腕力", 4, TR_STR, 20},
7260         {TR_INT, "知能", 4, TR_INT, 20},
7261         {TR_WIS, "賢さ", 4, TR_WIS, 20},
7262         {TR_DEX, "器用さ", 4, TR_DEX, 20},
7263         {TR_CON, "耐久力", 4, TR_CON, 20},
7264         {TR_CHR, "魅力", 4, TR_CHR, 20},
7265         {TR_MAGIC_MASTERY, "魔力支配", 4, TR_MAGIC_MASTERY, 20},
7266         {TR_STEALTH, "隠密", 4, TR_STEALTH, 40},
7267         {TR_SEARCH, "探索", 4, TR_SEARCH, 15},
7268         {TR_INFRA, "赤外線視力", 4, TR_INFRA, 15},
7269         {TR_TUNNEL, "採掘", 4, TR_TUNNEL, 15},
7270         {TR_SPEED, "スピード", 4, TR_SPEED, 12},
7271         {TR_BLOWS, "追加攻撃", 1, TR_BLOWS, 20},
7272         {TR_CHAOTIC, "カオス攻撃", 1, TR_CHAOTIC, 15},
7273         {TR_VAMPIRIC, "吸血攻撃", 1, TR_VAMPIRIC, 60},
7274         {TR_IMPACT, "地震発動", 7, TR_IMPACT, 15},
7275         {TR_BRAND_POIS, "毒殺", 1, TR_BRAND_POIS, 20},
7276         {TR_BRAND_ACID, "溶解", 1, TR_BRAND_ACID, 20},
7277         {TR_BRAND_ELEC, "電撃", 1, TR_BRAND_ELEC, 20},
7278         {TR_BRAND_FIRE, "焼棄", 1, TR_BRAND_FIRE, 20},
7279         {TR_BRAND_COLD, "凍結", 1, TR_BRAND_COLD, 20},
7280         {TR_SUST_STR, "腕力維持", 3, TR_SUST_STR, 15},
7281         {TR_SUST_INT, "知能維持", 3, TR_SUST_STR, 15},
7282         {TR_SUST_WIS, "賢さ維持", 3, TR_SUST_STR, 15},
7283         {TR_SUST_DEX, "器用さ維持", 3, TR_SUST_STR, 15},
7284         {TR_SUST_CON, "耐久力維持", 3, TR_SUST_STR, 15},
7285         {TR_SUST_CHR, "魅力維持", 3, TR_SUST_STR, 15},
7286         {TR_IM_ACID, "酸免疫", 2, TR_IM_ACID, 20},
7287         {TR_IM_ELEC, "電撃免疫", 2, TR_IM_ACID, 20},
7288         {TR_IM_FIRE, "火炎免疫", 2, TR_IM_ACID, 20},
7289         {TR_IM_COLD, "冷気免疫", 2, TR_IM_ACID, 20},
7290         {TR_REFLECT, "反射", 2, TR_REFLECT, 20},
7291         {TR_FREE_ACT, "麻痺知らず", 3, TR_FREE_ACT, 20},
7292         {TR_HOLD_EXP, "経験値維持", 3, TR_HOLD_EXP, 20},
7293         {TR_RES_ACID, "耐酸", 2, TR_RES_ACID, 15},
7294         {TR_RES_ELEC, "耐電撃", 2, TR_RES_ELEC, 15},
7295         {TR_RES_FIRE, "耐火炎", 2, TR_RES_FIRE, 15},
7296         {TR_RES_COLD, "耐冷気", 2, TR_RES_COLD, 15},
7297         {TR_RES_POIS, "耐毒", 2, TR_RES_POIS, 25},
7298         {TR_RES_FEAR, "耐恐怖", 2, TR_RES_FEAR, 20},
7299         {TR_RES_LITE, "耐閃光", 2, TR_RES_LITE, 20},
7300         {TR_RES_DARK, "耐暗黒", 2, TR_RES_DARK, 20},
7301         {TR_RES_BLIND, "耐盲目", 2, TR_RES_BLIND, 20},
7302         {TR_RES_CONF, "耐混乱", 2, TR_RES_CONF, 20},
7303         {TR_RES_SOUND, "耐轟音", 2, TR_RES_SOUND, 20},
7304         {TR_RES_SHARDS, "耐破片", 2, TR_RES_SHARDS, 20},
7305         {TR_RES_NETHER, "耐地獄", 2, TR_RES_NETHER, 20},
7306         {TR_RES_NEXUS, "耐因果混乱", 2, TR_RES_NEXUS, 20},
7307         {TR_RES_CHAOS, "耐カオス", 2, TR_RES_CHAOS, 20},
7308         {TR_RES_DISEN, "耐劣化", 2, TR_RES_DISEN, 20},
7309         {TR_SH_FIRE, "", 0, -2, 0},
7310         {TR_SH_ELEC, "", 0, -2, 0},
7311         {TR_SH_COLD, "", 0, -2, 0},
7312         {TR_NO_MAGIC, "反魔法", 3, TR_NO_MAGIC, 15},
7313         {TR_WARNING, "警告", 3, TR_WARNING, 20},
7314         {TR_LEVITATION, "浮遊", 3, TR_LEVITATION, 20},
7315         {TR_LITE_1, "永久光源", 3, TR_LITE_1, 15},
7316         {TR_LITE_2, "", 0, -2, 0},
7317         {TR_LITE_3, "", 0, -2, 0},
7318         {TR_SEE_INVIS, "可視透明", 3, TR_SEE_INVIS, 20},
7319         {TR_TELEPATHY, "テレパシー", 6, TR_TELEPATHY, 15},
7320         {TR_SLOW_DIGEST, "遅消化", 3, TR_SLOW_DIGEST, 15},
7321         {TR_REGEN, "急速回復", 3, TR_REGEN, 20},
7322         {TR_TELEPORT, "テレポート", 3, TR_TELEPORT, 25},
7323
7324         {TR_SLAY_EVIL, "邪悪倍打", 5, TR_SLAY_EVIL, 100},
7325         {TR_KILL_EVIL, "邪悪倍倍打", 0, TR_SLAY_EVIL, 60},
7326         {TR_SLAY_ANIMAL, "動物倍打", 5, TR_SLAY_ANIMAL, 20},
7327         {TR_KILL_ANIMAL, "動物倍倍打", 5, TR_SLAY_ANIMAL, 60},
7328         {TR_SLAY_UNDEAD, "不死倍打", 5, TR_SLAY_UNDEAD, 20},
7329         {TR_KILL_UNDEAD, "不死倍倍打", 5, TR_SLAY_UNDEAD, 60},
7330         {TR_SLAY_DEMON, "悪魔倍打", 5, TR_SLAY_DEMON, 20},
7331         {TR_KILL_DEMON, "悪魔倍倍打", 5, TR_SLAY_DEMON, 60},
7332         {TR_SLAY_ORC, "オーク倍打", 5, TR_SLAY_ORC, 15},
7333         {TR_KILL_ORC, "オーク倍倍打", 5, TR_SLAY_ORC, 60},
7334         {TR_SLAY_TROLL, "トロル倍打", 5, TR_SLAY_TROLL, 15},
7335         {TR_KILL_TROLL, "トロル倍倍打", 5, TR_SLAY_TROLL, 60},
7336         {TR_SLAY_GIANT, "巨人倍打", 5, TR_SLAY_GIANT, 20},
7337         {TR_KILL_GIANT, "巨人倍倍打", 5, TR_SLAY_GIANT, 60},
7338         {TR_SLAY_DRAGON, "竜倍打", 5, TR_SLAY_DRAGON, 20},
7339         {TR_KILL_DRAGON, "竜倍倍打", 5, TR_SLAY_DRAGON, 60},
7340         {TR_SLAY_HUMAN, "人間倍打", 5, TR_SLAY_HUMAN, 20},
7341         {TR_KILL_HUMAN, "人間倍倍打", 5, TR_SLAY_HUMAN, 60},
7342
7343         {TR_ESP_ANIMAL, "動物ESP", 6, TR_SLAY_ANIMAL, 40},
7344         {TR_ESP_UNDEAD, "不死ESP", 6, TR_SLAY_UNDEAD, 40},
7345         {TR_ESP_DEMON, "悪魔ESP", 6, TR_SLAY_DEMON, 40},
7346         {TR_ESP_ORC, "オークESP", 6, TR_SLAY_ORC, 40},
7347         {TR_ESP_TROLL, "トロルESP", 6, TR_SLAY_TROLL, 40},
7348         {TR_ESP_GIANT, "巨人ESP", 6, TR_SLAY_GIANT, 40},
7349         {TR_ESP_DRAGON, "竜ESP", 6, TR_SLAY_DRAGON, 40},
7350         {TR_ESP_HUMAN, "人間ESP", 6, TR_SLAY_HUMAN, 40},
7351
7352         {ESSENCE_ATTACK, "攻撃", 10, TR_ES_ATTACK, 30},
7353         {ESSENCE_AC, "防御", 10, TR_ES_AC, 15},
7354         {ESSENCE_TMP_RES_ACID, "酸耐性発動", 7, TR_RES_ACID, 50},
7355         {ESSENCE_TMP_RES_ELEC, "電撃耐性発動", 7, TR_RES_ELEC, 50},
7356         {ESSENCE_TMP_RES_FIRE, "火炎耐性発動", 7, TR_RES_FIRE, 50},
7357         {ESSENCE_TMP_RES_COLD, "冷気耐性発動", 7, TR_RES_COLD, 50},
7358         {ESSENCE_SH_FIRE, "火炎オーラ", 7, -1, 50},
7359         {ESSENCE_SH_ELEC, "電撃オーラ", 7, -1, 50},
7360         {ESSENCE_SH_COLD, "冷気オーラ", 7, -1, 50},
7361         {ESSENCE_RESISTANCE, "全耐性", 2, -1, 150},
7362         {ESSENCE_SUSTAIN, "装備保持", 10, -1, 10},
7363         {ESSENCE_SLAY_GLOVE, "殺戮の小手", 1, TR_ES_ATTACK, 200},
7364
7365         {-1, NULL, 0, -1, 0}
7366 };
7367 #else
7368 static essence_type essence_info[] =
7369 {
7370         {TR_STR, "strength", 4, TR_STR, 20},
7371         {TR_INT, "intelligence", 4, TR_INT, 20},
7372         {TR_WIS, "wisdom", 4, TR_WIS, 20},
7373         {TR_DEX, "dexterity", 4, TR_DEX, 20},
7374         {TR_CON, "constitution", 4, TR_CON, 20},
7375         {TR_CHR, "charisma", 4, TR_CHR, 20},
7376         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
7377         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
7378         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
7379         {TR_INFRA, "infravision", 4, TR_INFRA, 15},
7380         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
7381         {TR_SPEED, "speed", 4, TR_SPEED, 12},
7382         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
7383         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
7384         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
7385         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
7386         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
7387         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
7388         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
7389         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
7390         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
7391         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
7392         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
7393         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
7394         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
7395         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
7396         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
7397         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
7398         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
7399         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
7400         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
7401         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
7402         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
7403         {TR_HOLD_EXP, "hold experience", 3, TR_HOLD_EXP, 20},
7404         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
7405         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
7406         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
7407         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
7408         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
7409         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
7410         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
7411         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
7412         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
7413         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
7414         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
7415         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
7416         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
7417         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
7418         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
7419         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
7420         {TR_SH_FIRE, "", 0, -2, 0},
7421         {TR_SH_ELEC, "", 0, -2, 0},
7422         {TR_SH_COLD, "", 0, -2, 0},
7423         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
7424         {TR_WARNING, "warning", 3, TR_WARNING, 20},
7425         {TR_LEVITATION, "levitation", 3, TR_LEVITATION, 20},
7426         {TR_LITE_1, "permanent light", 3, TR_LITE_1, 15},
7427         {TR_LITE_2, "", 0, -2, 0},
7428         {TR_LITE_3, "", 0, -2, 0},
7429         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
7430         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
7431         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
7432         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
7433         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
7434
7435         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
7436         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
7437         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
7438         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
7439         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
7440         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
7441         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
7442         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
7443         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
7444         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
7445         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
7446         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
7447         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
7448         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
7449         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
7450         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
7451         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
7452         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
7453
7454         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
7455         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
7456         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
7457         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
7458         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
7459         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
7460         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
7461         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
7462
7463         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
7464         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
7465         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
7466         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
7467         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
7468         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
7469         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
7470         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
7471         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
7472         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
7473         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
7474         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
7475
7476         {-1, NULL, 0, -1, 0}
7477 };
7478 #endif
7479
7480
7481 /*!
7482  * エッセンス名テーブル / Essense names for Weapon smith
7483  */
7484 #ifdef JP
7485 cptr essence_name[] =
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
7583         NULL
7584 };
7585
7586 #else
7587
7588 cptr essence_name[] =
7589 {
7590         "strength",
7591         "intelligen.",
7592         "wisdom",
7593         "dexterity",
7594         "constitut.",
7595         "charisma",
7596         "magic mast.",
7597         "",
7598         "stealth",
7599         "serching",
7600         "infravision",
7601         "digging",
7602         "speed",
7603         "extra atk",
7604         "chaos brand",
7605         "vampiric",
7606         "slay animal",
7607         "slay evil",
7608         "slay undead",
7609         "slay demon",
7610         "slay orc",
7611         "slay troll",
7612         "slay giant",
7613         "slay dragon",
7614         "",
7615         "",
7616         "quake",
7617         "pois. brand",
7618         "acid brand",
7619         "elec. brand",
7620         "fire brand",
7621         "cold brand",
7622         "sustain",
7623         "",
7624         "",
7625         "",
7626         "",
7627         "",
7628         "",
7629         "",
7630         "immunity",
7631         "",
7632         "",
7633         "",
7634         "",
7635         "reflection",
7636         "free action",
7637         "hold exp",
7638         "res. acid",
7639         "res. elec.",
7640         "res. fire",
7641         "res. cold",
7642         "res. poison",
7643         "res. fear",
7644         "res. light",
7645         "res. dark",
7646         "res. blind",
7647         "res.confuse",
7648         "res. sound",
7649         "res. shard",
7650         "res. nether",
7651         "res. nexus",
7652         "res. chaos",
7653         "res. disen.",
7654         "",
7655         "",
7656         "slay human",
7657         "",
7658         "",
7659         "anti magic",
7660         "",
7661         "",
7662         "warning",
7663         "",
7664         "",
7665         "",
7666         "levitation",
7667         "perm. light",
7668         "see invis.",
7669         "telepathy",
7670         "slow dige.",
7671         "regen.",
7672         "",
7673         "",
7674         "",
7675         "",
7676         "",
7677         "",
7678         "",
7679         "",
7680         "teleport",
7681         "",
7682         "",
7683         "weapon enc.",
7684         "armor enc.",
7685
7686         NULL
7687 };
7688 #endif
7689
7690 /*!
7691  * @brief 所持しているエッセンス一覧を表示する
7692  * @return なし
7693  */
7694 static void display_essence(void)
7695 {
7696         int i, num = 0;
7697
7698         screen_save();
7699         for (i = 1; i < 22; i++)
7700         {
7701                 prt("",i,0);
7702         }
7703         prt(_("エッセンス   個数     エッセンス   個数     エッセンス   個数",
7704                   "Essence      Num      Essence      Num      Essence      Num "), 1, 8);
7705         for (i = 0; essence_name[i]; i++)
7706         {
7707                 if (!essence_name[i][0]) continue;
7708                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
7709                 num++;
7710         }
7711         prt(_("現在所持しているエッセンス", "List of all essences you have."), 0, 0);
7712         (void)inkey();
7713         screen_load();
7714         return;
7715 }
7716
7717 /*!
7718  * @brief エッセンスの抽出処理
7719  * @return なし
7720  */
7721 static void drain_essence(void)
7722 {
7723         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
7724         int i, item;
7725         int dec = 4;
7726         bool observe = FALSE;
7727         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2, old_timeout;
7728         u32b old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7729         object_type *o_ptr;
7730         cptr            q, s;
7731         byte iy, ix, marked, number;
7732         s16b next_o_idx, weight;
7733
7734         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7735                 drain_value[i] = 0;
7736
7737         item_tester_hook = object_is_weapon_armour_ammo;
7738         item_tester_no_ryoute = TRUE;
7739
7740         /* Get an item */
7741         q = _("どのアイテムから抽出しますか？", "Extract from which item? ");
7742         s = _("抽出できるアイテムがありません。", "You have nothing you can extract from.");
7743
7744         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7745
7746         /* Get the item (in the pack) */
7747         if (item >= 0)
7748         {
7749                 o_ptr = &inventory[item];
7750         }
7751
7752         /* Get the item (on the floor) */
7753         else
7754         {
7755                 o_ptr = &o_list[0 - item];
7756         }
7757
7758         if (object_is_known(o_ptr) && !object_is_nameless(o_ptr))
7759         {
7760                 char o_name[MAX_NLEN];
7761                 object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
7762                 if (!get_check(format(_("本当に%sから抽出してよろしいですか？", "Really extract from %s? "), o_name))) return;
7763         }
7764
7765         p_ptr->energy_use = 100;
7766
7767         object_flags(o_ptr, old_flgs);
7768         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7769         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7770         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7771         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7772         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7773         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7774         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7775         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7776         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7777
7778         old_to_a = o_ptr->to_a;
7779         old_ac = o_ptr->ac;
7780         old_to_h = o_ptr->to_h;
7781         old_to_d = o_ptr->to_d;
7782         old_ds = o_ptr->ds;
7783         old_dd = o_ptr->dd;
7784         old_pval = o_ptr->pval;
7785         old_name2 = o_ptr->name2;
7786         old_timeout = o_ptr->timeout;
7787         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7788         if (have_flag(old_flgs, TR_ADD_L_CURSE)) dec--;
7789         if (have_flag(old_flgs, TR_ADD_H_CURSE)) dec--;
7790         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7791         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7792         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7793         if (have_flag(old_flgs, TR_DRAIN_HP)) dec--;
7794         if (have_flag(old_flgs, TR_DRAIN_MANA)) dec--;
7795         if (have_flag(old_flgs, TR_CALL_ANIMAL)) dec--;
7796         if (have_flag(old_flgs, TR_CALL_DEMON)) dec--;
7797         if (have_flag(old_flgs, TR_CALL_DRAGON)) dec--;
7798         if (have_flag(old_flgs, TR_CALL_UNDEAD)) dec--;
7799         if (have_flag(old_flgs, TR_COWARDICE)) dec--;
7800         if (have_flag(old_flgs, TR_LOW_MELEE)) dec--;
7801         if (have_flag(old_flgs, TR_LOW_AC)) dec--;
7802         if (have_flag(old_flgs, TR_LOW_MAGIC)) dec--;
7803         if (have_flag(old_flgs, TR_FAST_DIGEST)) dec--;
7804         if (have_flag(old_flgs, TR_SLOW_REGEN)) dec--;
7805         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7806
7807         iy = o_ptr->iy;
7808         ix = o_ptr->ix;
7809         next_o_idx = o_ptr->next_o_idx;
7810         marked = o_ptr->marked;
7811         weight = o_ptr->weight;
7812         number = o_ptr->number;
7813
7814         object_prep(o_ptr, o_ptr->k_idx);
7815
7816         o_ptr->iy=iy;
7817         o_ptr->ix=ix;
7818         o_ptr->next_o_idx=next_o_idx;
7819         o_ptr->marked=marked;
7820         o_ptr->number = number;
7821         if (o_ptr->tval == TV_DRAG_ARMOR) o_ptr->timeout = old_timeout;
7822         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7823         o_ptr->ident |= (IDENT_MENTAL);
7824         object_aware(o_ptr);
7825         object_known(o_ptr);
7826
7827         object_flags(o_ptr, new_flgs);
7828
7829         for (i = 0; essence_info[i].add_name; i++)
7830         {
7831                 essence_type *es_ptr = &essence_info[i];
7832                 int pval = 0;
7833
7834                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7835                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7836
7837                 if (es_ptr->add < TR_FLAG_MAX &&
7838                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7839                     have_flag(old_flgs, es_ptr->add))
7840                 {
7841                         if (pval)
7842                         {
7843                                 drain_value[es_ptr->essence] += 10 * pval;
7844                         }
7845                         else if (es_ptr->essence != -2)
7846                         {
7847                                 drain_value[es_ptr->essence] += 10;
7848                         }
7849                         else if (es_ptr->add == TR_SH_FIRE)
7850                         {
7851                                 drain_value[TR_BRAND_FIRE] += 10;
7852                                 drain_value[TR_RES_FIRE] += 10;
7853                         }
7854                         else if (es_ptr->add == TR_SH_ELEC)
7855                         {
7856                                 drain_value[TR_BRAND_ELEC] += 10;
7857                                 drain_value[TR_RES_ELEC] += 10;
7858                         }
7859                         else if (es_ptr->add == TR_SH_COLD)
7860                         {
7861                                 drain_value[TR_BRAND_COLD] += 10;
7862                                 drain_value[TR_RES_COLD] += 10;
7863                         }
7864                         else if (es_ptr->add == TR_LITE_2)
7865                         {
7866                                 drain_value[TR_LITE_1] += 20;
7867                         }
7868                         else if (es_ptr->add == TR_LITE_3)
7869                         {
7870                                 drain_value[TR_LITE_1] += 30;
7871                         }
7872                 }
7873         }
7874
7875         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7876         {
7877                 drain_value[TR_INT] += 5;
7878                 drain_value[TR_WIS] += 5;
7879         }
7880         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7881         {
7882                 drain_value[TR_BRAND_POIS] += 5;
7883                 drain_value[TR_BRAND_ACID] += 5;
7884                 drain_value[TR_BRAND_ELEC] += 5;
7885                 drain_value[TR_BRAND_FIRE] += 5;
7886                 drain_value[TR_BRAND_COLD] += 5;
7887         }
7888         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7889         {
7890                 drain_value[TR_INT] += 10;
7891         }
7892         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7893         {
7894                 drain_value[TR_STR] += 10;
7895         }
7896         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7897         {
7898                 drain_value[TR_DEX] += 10;
7899         }
7900         if (old_name2 == EGO_2WEAPON)
7901         {
7902                 drain_value[TR_DEX] += 20;
7903         }
7904         if (object_is_weapon_ammo(o_ptr))
7905         {
7906                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7907
7908                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7909         }
7910         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7911         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7912         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7913         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7914
7915         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7916         {
7917                 drain_value[i] *= number;
7918                 drain_value[i] = drain_value[i] * dec / 4;
7919                 drain_value[i] = MAX(drain_value[i], 0);
7920                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7921                 if (drain_value[i])
7922                 {
7923                         observe = TRUE;
7924                 }
7925         }
7926         if (!observe)
7927         {
7928                 msg_print(_("エッセンスは抽出できませんでした。", "You were not able to extract any essence."));
7929         }
7930         else
7931         {
7932                 msg_print(_("抽出したエッセンス:", "Extracted essences:"));
7933
7934                 for (i = 0; essence_name[i]; i++)
7935                 {
7936                         if (!essence_name[i][0]) continue;
7937                         if (!drain_value[i]) continue;
7938
7939                         p_ptr->magic_num1[i] += drain_value[i];
7940                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7941                         msg_print(NULL);
7942                         msg_format("%s...%d%s", essence_name[i], drain_value[i], _("。", ". "));
7943                 }
7944         }
7945
7946         /* Apply autodestroy/inscription to the drained item */
7947         autopick_alter_item(item, TRUE);
7948
7949         /* Combine the pack */
7950         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7951
7952         /* Window stuff */
7953         p_ptr->window |= (PW_INVEN);
7954 }
7955
7956 /*!
7957  * @brief 付加するエッセンスの大別を選択する
7958  * @return 選んだエッセンスの大別ID
7959  */
7960 static int choose_essence(void)
7961 {
7962         int mode = 0;
7963         char choice;
7964         int menu_line = (use_menu ? 1 : 0);
7965
7966 #ifdef JP
7967         cptr menu_name[] = {
7968                 "武器属性",
7969                 "耐性",
7970                 "能力",
7971                 "数値",
7972                 "スレイ",
7973                 "ESP",
7974                 "その他"
7975         };
7976 #else
7977         cptr menu_name[] = {
7978                 "Brand weapon",
7979                 "Resistance",
7980                 "Ability",
7981                 "Magic number",
7982                 "Slay",
7983                 "ESP",
7984                 "Others"
7985         };
7986 #endif
7987         const int mode_max = 7;
7988
7989 #ifdef ALLOW_REPEAT
7990         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
7991                 return mode;
7992         mode = 0;
7993 #endif /* ALLOW_REPEAT */
7994
7995         if (use_menu)
7996         {
7997                 screen_save();
7998
7999                 while(!mode)
8000                 {
8001                         int i;
8002                         for (i = 0; i < mode_max; i++)
8003 #ifdef JP
8004                                 prt(format(" %s %s", (menu_line == 1+i) ? "》" : "  ", menu_name[i]), 2 + i, 14);
8005                         prt("どの種類のエッセンス付加を行いますか？", 0, 0);
8006 #else
8007                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
8008                         prt("Choose from menu.", 0, 0);
8009 #endif
8010
8011                         choice = inkey();
8012                         switch(choice)
8013                         {
8014                         case ESCAPE:
8015                         case 'z':
8016                         case 'Z':
8017                                 screen_load();
8018                                 return 0;
8019                         case '2':
8020                         case 'j':
8021                         case 'J':
8022                                 menu_line++;
8023                                 break;
8024                         case '8':
8025                         case 'k':
8026                         case 'K':
8027                                 menu_line += mode_max - 1;
8028                                 break;
8029                         case '\r':
8030                         case '\n':
8031                         case 'x':
8032                         case 'X':
8033                                 mode = menu_line;
8034                                 break;
8035                         }
8036                         if (menu_line > mode_max) menu_line -= mode_max;
8037                 }
8038                 screen_load();
8039         }
8040         else
8041         {
8042                 screen_save();
8043                 while (!mode)
8044                 {
8045                         int i;
8046
8047                         for (i = 0; i < mode_max; i++)
8048                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
8049
8050                         if (!get_com(_("何を付加しますか:", "Command :"), &choice, TRUE))
8051                         {
8052                                 screen_load();
8053                                 return 0;
8054                         }
8055
8056                         if (isupper(choice)) choice = tolower(choice);
8057
8058                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
8059                                 mode = (int)choice - 'a' + 1;
8060                 }
8061                 screen_load();
8062         }
8063
8064 #ifdef ALLOW_REPEAT
8065         repeat_push(mode);
8066 #endif /* ALLOW_REPEAT */
8067         return mode;
8068 }
8069
8070 /*!
8071  * @brief エッセンスを実際に付加する
8072  * @param mode エッセンスの大別ID
8073  * @return なし
8074  */
8075 static void add_essence(int mode)
8076 {
8077         int item, max_num = 0;
8078         int i;
8079         bool flag,redraw;
8080         char choice;
8081         cptr            q, s;
8082         object_type *o_ptr;
8083         int ask = TRUE;
8084         char out_val[160];
8085         int num[22];
8086         char o_name[MAX_NLEN];
8087         int use_essence;
8088         essence_type *es_ptr;
8089
8090         int menu_line = (use_menu ? 1 : 0);
8091
8092         for (i = 0; essence_info[i].add_name; i++)
8093         {
8094                 es_ptr = &essence_info[i];
8095
8096                 if (es_ptr->type != mode) continue;
8097                 num[max_num++] = i;
8098         }
8099
8100 #ifdef ALLOW_REPEAT
8101         if (!repeat_pull(&i) || i<0 || i>=max_num)
8102         {
8103 #endif /* ALLOW_REPEAT */
8104
8105
8106         /* Nothing chosen yet */
8107         flag = FALSE;
8108
8109         /* No redraw yet */
8110         redraw = FALSE;
8111
8112         /* Build a prompt */
8113         (void) strnfmt(out_val, 78, _("('*'で一覧, ESCで中断) どの能力を付加しますか？", "(*=List, ESC=exit) Add which ability? "));
8114         if (use_menu) screen_save();
8115
8116         /* Get a spell from the user */
8117
8118         choice = (always_show_list || use_menu) ? ESCAPE:1;
8119         while (!flag)
8120         {
8121                 bool able[22];
8122                 if( choice==ESCAPE ) choice = ' ';
8123                 else if( !get_com(out_val, &choice, FALSE) )break;
8124
8125                 if (use_menu && choice != ' ')
8126                 {
8127                         switch(choice)
8128                         {
8129                                 case '0':
8130                                 {
8131                                         screen_load();
8132                                         return;
8133                                 }
8134
8135                                 case '8':
8136                                 case 'k':
8137                                 case 'K':
8138                                 {
8139                                         menu_line += (max_num-1);
8140                                         break;
8141                                 }
8142
8143                                 case '2':
8144                                 case 'j':
8145                                 case 'J':
8146                                 {
8147                                         menu_line++;
8148                                         break;
8149                                 }
8150
8151                                 case '4':
8152                                 case 'h':
8153                                 case 'H':
8154                                 {
8155                                         menu_line = 1;
8156                                         break;
8157                                 }
8158                                 case '6':
8159                                 case 'l':
8160                                 case 'L':
8161                                 {
8162                                         menu_line = max_num;
8163                                         break;
8164                                 }
8165
8166                                 case 'x':
8167                                 case 'X':
8168                                 case '\r':
8169                                 case '\n':
8170                                 {
8171                                         i = menu_line - 1;
8172                                         ask = FALSE;
8173                                         break;
8174                                 }
8175                         }
8176                         if (menu_line > max_num) menu_line -= max_num;
8177                 }
8178                 /* Request redraw */
8179                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
8180                 {
8181                         /* Show the list */
8182                         if (!redraw || use_menu)
8183                         {
8184                                 byte y, x = 10;
8185                                 int ctr;
8186                                 char dummy[80], dummy2[80];
8187                                 byte col;
8188
8189                                 strcpy(dummy, "");
8190
8191                                 /* Show list */
8192                                 redraw = TRUE;
8193
8194                                 /* Save the screen */
8195                                 if (!use_menu) screen_save();
8196
8197                                 for (y = 1; y < 24; y++)
8198                                         prt("", y, x);
8199
8200                                 /* Print header(s) */
8201 #ifdef JP
8202                                 prt(format("   %-43s %6s/%s", "能力(必要エッセンス)", "必要数", "所持数"), 1, x);
8203
8204 #else
8205                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
8206 #endif
8207                                 /* Print list */
8208                                 for (ctr = 0; ctr < max_num; ctr++)
8209                                 {
8210                                         es_ptr = &essence_info[num[ctr]];
8211
8212                                         if (use_menu)
8213                                         {
8214                                                 if (ctr == (menu_line-1))
8215                                                         strcpy(dummy, _("》 ", ">  "));
8216                                                 else strcpy(dummy, "   ");
8217
8218                                         }
8219                                         /* letter/number for power selection */
8220                                         else
8221                                         {
8222                                                 sprintf(dummy, "%c) ",I2A(ctr));
8223                                         }
8224
8225                                         strcat(dummy, es_ptr->add_name);
8226
8227                                         col = TERM_WHITE;
8228                                         able[ctr] = TRUE;
8229
8230                                         if (es_ptr->essence != -1)
8231                                         {
8232                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
8233                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
8234                                         }
8235                                         else
8236                                         {
8237                                                 switch(es_ptr->add)
8238                                                 {
8239                                                 case ESSENCE_SH_FIRE:
8240                                                         strcat(dummy, _("(焼棄+耐火炎)", "(brand fire + res.fire)"));
8241                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
8242                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8243                                                         break;
8244                                                 case ESSENCE_SH_ELEC:
8245                                                         strcat(dummy, _("(電撃+耐電撃)", "(brand elec. + res. elec.)"));
8246                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
8247                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8248                                                         break;
8249                                                 case ESSENCE_SH_COLD:
8250                                                         strcat(dummy, _("(凍結+耐冷気)", "(brand cold + res. cold)"));
8251                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
8252                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8253                                                         break;
8254                                                 case ESSENCE_RESISTANCE:
8255                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8256                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8257                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8258                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8259                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8260                                                         break;
8261                                                 case ESSENCE_SUSTAIN:
8262                                                         strcat(dummy, _("(耐火炎+耐冷気+耐電撃+耐酸)", "(r.fire+r.cold+r.elec+r.acid)"));
8263                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
8264                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
8265                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
8266                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
8267                                                         break;
8268                                                 }
8269                                         }
8270
8271                                         if (!able[ctr]) col = TERM_RED;
8272
8273                                         if (es_ptr->essence != -1)
8274                                         {
8275                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
8276                                         }
8277                                         else
8278                                         {
8279                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
8280                                         }
8281
8282                                         c_prt(col, dummy2, ctr+2, x);
8283                                 }
8284                         }
8285
8286                         /* Hide the list */
8287                         else
8288                         {
8289                                 /* Hide list */
8290                                 redraw = FALSE;
8291
8292                                 /* Restore the screen */
8293                                 screen_load();
8294                         }
8295
8296                         /* Redo asking */
8297                         continue;
8298                 }
8299
8300                 if (!use_menu)
8301                 {
8302                         /* Note verify */
8303                         ask = (isupper(choice));
8304
8305                         /* Lowercase */
8306                         if (ask) choice = tolower(choice);
8307
8308                         /* Extract request */
8309                         i = (islower(choice) ? A2I(choice) : -1);
8310                 }
8311
8312                 /* Totally Illegal */
8313                 if ((i < 0) || (i >= max_num) || !able[i])
8314                 {
8315                         bell();
8316                         continue;
8317                 }
8318
8319                 /* Verify it */
8320                 if (ask)
8321                 {
8322                         char tmp_val[160];
8323
8324                         /* Prompt */
8325                         (void) strnfmt(tmp_val, 78, _("%sを付加しますか？ ", "Add the abilitiy of %s? "), essence_info[num[i]].add_name);
8326
8327                         /* Belay that order */
8328                         if (!get_check(tmp_val)) continue;
8329                 }
8330
8331                 /* Stop the loop */
8332                 flag = TRUE;
8333         }
8334
8335         /* Restore the screen */
8336         if (redraw) screen_load();
8337
8338         if (!flag) return;
8339
8340 #ifdef ALLOW_REPEAT
8341         repeat_push(i);
8342         }
8343 #endif /* ALLOW_REPEAT */
8344
8345         es_ptr = &essence_info[num[i]];
8346
8347         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8348                 item_tester_tval = TV_GLOVES;
8349         else if (mode == 1 || mode == 5)
8350                 item_tester_hook = item_tester_hook_melee_ammo;
8351         else if (es_ptr->add == ESSENCE_ATTACK)
8352                 item_tester_hook = object_allow_enchant_weapon;
8353         else if (es_ptr->add == ESSENCE_AC)
8354                 item_tester_hook = object_is_armour;
8355         else
8356                 item_tester_hook = object_is_weapon_armour_ammo;
8357         item_tester_no_ryoute = TRUE;
8358
8359         /* Get an item */
8360         q = _("どのアイテムを改良しますか？", "Improve which item? ");
8361         s = _("改良できるアイテムがありません。", "You have nothing to improve.");
8362
8363         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8364
8365         /* Get the item (in the pack) */
8366         if (item >= 0)
8367         {
8368                 o_ptr = &inventory[item];
8369         }
8370
8371         /* Get the item (on the floor) */
8372         else
8373         {
8374                 o_ptr = &o_list[0 - item];
8375         }
8376
8377         if ((mode != 10) && (object_is_artifact(o_ptr) || object_is_smith(o_ptr)))
8378         {
8379                 msg_print(_("そのアイテムはこれ以上改良できない。", "This item is no more able to be improved."));
8380                 return;
8381         }
8382
8383         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8384
8385         use_essence = es_ptr->value;
8386         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
8387         if (o_ptr->number > 1)
8388         {
8389                 use_essence *= o_ptr->number;
8390                 msg_format(_("%d個あるのでエッセンスは%d必要です。", "It will take %d essences."), o_ptr->number, use_essence);
8391         }
8392
8393         if (es_ptr->essence != -1)
8394         {
8395                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8396                 {
8397                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8398                         return;
8399                 }
8400                 if (is_pval_flag(es_ptr->add))
8401                 {
8402                         if (o_ptr->pval < 0)
8403                         {
8404                                 msg_print(_("このアイテムの能力修正を強化することはできない。", "You cannot increase magic number of this item."));
8405                                 return;
8406                         }
8407                         else if (es_ptr->add == TR_BLOWS)
8408                         {
8409                                 if (o_ptr->pval > 1)
8410                                 {
8411                                         if (!get_check(_("修正値は1になります。よろしいですか？", "The magic number of this weapon will become 1. Are you sure? "))) return;
8412                                 }
8413
8414                                 o_ptr->pval = 1;
8415                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8416                         }
8417                         else if (o_ptr->pval > 0)
8418                         {
8419                                 use_essence *= o_ptr->pval;
8420                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8421                         }
8422                         else
8423                         {
8424                                 char tmp[80];
8425                                 char tmp_val[160];
8426                                 int pval;
8427                                 int limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
8428
8429                                 sprintf(tmp, _("いくつ付加しますか？ (1-%d): ", "Enchant how many? (1-%d): "), limit);
8430                                 strcpy(tmp_val, "1");
8431
8432                                 if (!get_string(tmp, tmp_val, 1)) return;
8433                                 pval = atoi(tmp_val);
8434                                 if (pval > limit) pval = limit;
8435                                 else if (pval < 1) pval = 1;
8436                                 o_ptr->pval += pval;
8437                                 use_essence *= pval;
8438                                 msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8439                         }
8440
8441                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8442                         {
8443                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8444                                 return;
8445                         }
8446                 }
8447                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
8448                 {
8449                         char tmp_val[160];
8450                         int val;
8451                         int get_to_h, get_to_d;
8452
8453                         strcpy(tmp_val, "1");
8454                         if (!get_string(format(_("いくつ付加しますか？ (1-%d):", "Enchant how many? (1-%d):"), p_ptr->lev/7+3), tmp_val, 2)) return;
8455                         val = atoi(tmp_val);
8456                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
8457                         else if (val < 1) val = 1;
8458                         use_essence *= val;
8459                         msg_format(_("エッセンスを%d個使用します。", "It will take %d essences."), use_essence);
8460                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
8461                         {
8462                                 msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8463                                 return;
8464                         }
8465                         get_to_h = ((val+1)/2+randint0(val/2+1));
8466                         get_to_d = ((val+1)/2+randint0(val/2+1));
8467                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
8468                         o_ptr->to_h += get_to_h;
8469                         o_ptr->to_d += get_to_d;
8470                 }
8471                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
8472                 if (es_ptr->add == ESSENCE_ATTACK)
8473                 {
8474                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
8475                         {
8476                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8477                                 p_ptr->energy_use = 100;
8478                                 return;
8479                         }
8480                         else
8481                         {
8482                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
8483                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
8484                         }
8485                 }
8486                 else if (es_ptr->add == ESSENCE_AC)
8487                 {
8488                         if (o_ptr->to_a >= p_ptr->lev/5+5)
8489                         {
8490                                 msg_print(_("改良に失敗した。", "You failed to enchant."));
8491                                 p_ptr->energy_use = 100;
8492                                 return;
8493                         }
8494                         else
8495                         {
8496                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
8497                         }
8498                 }
8499                 else
8500                 {
8501                         o_ptr->xtra3 = es_ptr->add + 1;
8502                 }
8503         }
8504         else
8505         {
8506                 bool success = TRUE;
8507
8508                 switch(es_ptr->add)
8509                 {
8510                 case ESSENCE_SH_FIRE:
8511                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
8512                         {
8513                                 success = FALSE;
8514                                 break;
8515                         }
8516                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
8517                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8518                         break;
8519                 case ESSENCE_SH_ELEC:
8520                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
8521                         {
8522                                 success = FALSE;
8523                                 break;
8524                         }
8525                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
8526                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8527                         break;
8528                 case ESSENCE_SH_COLD:
8529                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
8530                         {
8531                                 success = FALSE;
8532                                 break;
8533                         }
8534                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
8535                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8536                         break;
8537                 case ESSENCE_RESISTANCE:
8538                 case ESSENCE_SUSTAIN:
8539                         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))
8540                         {
8541                                 success = FALSE;
8542                                 break;
8543                         }
8544                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
8545                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
8546                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
8547                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
8548                         break;
8549                 }
8550                 if (!success)
8551                 {
8552                         msg_print(_("エッセンスが足りない。", "You don't have enough essences."));
8553                         return;
8554                 }
8555                 if (es_ptr->add == ESSENCE_SUSTAIN)
8556                 {
8557                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
8558                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
8559                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
8560                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
8561                 }
8562                 else
8563                 {
8564                         o_ptr->xtra3 = es_ptr->add + 1;
8565                 }
8566         }
8567
8568         p_ptr->energy_use = 100;
8569
8570 #ifdef JP
8571         msg_format("%sに%sの能力を付加しました。", o_name, es_ptr->add_name);
8572 #else
8573         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
8574 #endif
8575
8576         /* Combine the pack */
8577         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8578
8579         /* Window stuff */
8580         p_ptr->window |= (PW_INVEN);
8581 }
8582
8583 /*!
8584  * @brief エッセンスを消去する
8585  * @return なし
8586  */
8587 static void erase_essence(void)
8588 {
8589         int item;
8590         cptr q, s;
8591         object_type *o_ptr;
8592         char o_name[MAX_NLEN];
8593         u32b flgs[TR_FLAG_SIZE];
8594
8595         item_tester_hook = object_is_smith;
8596
8597         /* Get an item */
8598         q = _("どのアイテムのエッセンスを消去しますか？", "Remove from which item? ");
8599         s = _("エッセンスを付加したアイテムがありません。", "You have nothing to remove essence.");
8600
8601         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8602
8603         /* Get the item (in the pack) */
8604         if (item >= 0)
8605         {
8606                 o_ptr = &inventory[item];
8607         }
8608
8609         /* Get the item (on the floor) */
8610         else
8611         {
8612                 o_ptr = &o_list[0 - item];
8613         }
8614
8615         object_desc(o_name, o_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
8616         if (!get_check(format(_("よろしいですか？ [%s]", "Are you sure? [%s]"), o_name))) return;
8617
8618         p_ptr->energy_use = 100;
8619
8620         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8621         {
8622                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8623                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8624                 o_ptr->xtra4 = 0;
8625                 if (o_ptr->to_h < 0) o_ptr->to_h = 0;
8626                 if (o_ptr->to_d < 0) o_ptr->to_d = 0;
8627         }
8628         o_ptr->xtra3 = 0;
8629         object_flags(o_ptr, flgs);
8630         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8631         msg_print(_("エッセンスを取り去った。", "You removed all essence you have added."));
8632
8633         /* Combine the pack */
8634         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8635
8636         /* Window stuff */
8637         p_ptr->window |= (PW_INVEN);
8638 }
8639
8640 /*!
8641  * @brief 鍛冶コマンドのメインルーチン
8642  * @param only_browse TRUEならばエッセンス一覧の表示のみを行う
8643  * @return なし
8644  */
8645 void do_cmd_kaji(bool only_browse)
8646 {
8647         int mode = 0;
8648         char choice;
8649
8650         int menu_line = (use_menu ? 1 : 0);
8651
8652         if (!only_browse)
8653         {
8654                 if (p_ptr->confused)
8655                 {
8656                         msg_print(_("混乱していて作業できない！", "You are too confused!"));
8657                         return;
8658                 }
8659                 if (p_ptr->blind)
8660                 {
8661                         msg_print(_("目が見えなくて作業できない！", "You are blind!"));
8662                         return;
8663                 }
8664                 if (p_ptr->image)
8665                 {
8666                         msg_print(_("うまく見えなくて作業できない！", "You are hallucinating!"));
8667                         return;
8668                 }
8669         }
8670
8671 #ifdef ALLOW_REPEAT
8672         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8673         {
8674 #endif /* ALLOW_REPEAT */
8675
8676         if (only_browse) screen_save();
8677         do {
8678         if (!only_browse) screen_save();
8679         if (use_menu)
8680         {
8681                 while(!mode)
8682                 {
8683 #ifdef JP
8684                         prt(format(" %s エッセンス一覧", (menu_line == 1) ? "》" : "  "), 2, 14);
8685                         prt(format(" %s エッセンス抽出", (menu_line == 2) ? "》" : "  "), 3, 14);
8686                         prt(format(" %s エッセンス消去", (menu_line == 3) ? "》" : "  "), 4, 14);
8687                         prt(format(" %s エッセンス付加", (menu_line == 4) ? "》" : "  "), 5, 14);
8688                         prt(format(" %s 武器/防具強化", (menu_line == 5) ? "》" : "  "), 6, 14);
8689                         prt(format("どの種類の技術を%sますか？", only_browse ? "調べ" : "使い"), 0, 0);
8690 #else
8691                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8692                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8693                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8694                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8695                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8696                         prt(format("Choose command from menu."), 0, 0);
8697 #endif
8698                         choice = inkey();
8699                         switch(choice)
8700                         {
8701                         case ESCAPE:
8702                         case 'z':
8703                         case 'Z':
8704                                 screen_load();
8705                                 return;
8706                         case '2':
8707                         case 'j':
8708                         case 'J':
8709                                 menu_line++;
8710                                 break;
8711                         case '8':
8712                         case 'k':
8713                         case 'K':
8714                                 menu_line+= 4;
8715                                 break;
8716                         case '\r':
8717                         case '\n':
8718                         case 'x':
8719                         case 'X':
8720                                 mode = menu_line;
8721                                 break;
8722                         }
8723                         if (menu_line > 5) menu_line -= 5;
8724                 }
8725         }
8726
8727         else
8728         {
8729                 while (!mode)
8730                 {
8731 #ifdef JP
8732                         prt("  a) エッセンス一覧", 2, 14);
8733                         prt("  b) エッセンス抽出", 3, 14);
8734                         prt("  c) エッセンス消去", 4, 14);
8735                         prt("  d) エッセンス付加", 5, 14);
8736                         prt("  e) 武器/防具強化", 6, 14);
8737                         if (!get_com(format("どの能力を%sますか:", only_browse ? "調べ" : "使い"), &choice, TRUE))
8738 #else
8739                         prt("  a) List essences", 2, 14);
8740                         prt("  b) Extract essence", 3, 14);
8741                         prt("  c) Remove essence", 4, 14);
8742                         prt("  d) Add essence", 5, 14);
8743                         prt("  e) Enchant weapon/armor", 6, 14);
8744                         if (!get_com("Command :", &choice, TRUE))
8745 #endif
8746                         {
8747                                 screen_load();
8748                                 return;
8749                         }
8750                         switch (choice)
8751                         {
8752                         case 'A':
8753                         case 'a':
8754                                 mode = 1;
8755                                 break;
8756                         case 'B':
8757                         case 'b':
8758                                 mode = 2;
8759                                 break;
8760                         case 'C':
8761                         case 'c':
8762                                 mode = 3;
8763                                 break;
8764                         case 'D':
8765                         case 'd':
8766                                 mode = 4;
8767                                 break;
8768                         case 'E':
8769                         case 'e':
8770                                 mode = 5;
8771                                 break;
8772                         }
8773                 }
8774         }
8775
8776         if (only_browse)
8777         {
8778                 char temp[62*5];
8779                 int line, j;
8780
8781                 /* Clear lines, position cursor  (really should use strlen here) */
8782                 Term_erase(14, 21, 255);
8783                 Term_erase(14, 20, 255);
8784                 Term_erase(14, 19, 255);
8785                 Term_erase(14, 18, 255);
8786                 Term_erase(14, 17, 255);
8787                 Term_erase(14, 16, 255);
8788
8789                 roff_to_buf(kaji_tips[mode-1], 62, temp, sizeof(temp));
8790                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8791                 {
8792                         prt(&temp[j], line, 15);
8793                         line++;
8794                 }
8795                 mode = 0;
8796         }
8797         if (!only_browse) screen_load();
8798         } while (only_browse);
8799 #ifdef ALLOW_REPEAT
8800         repeat_push(mode);
8801         }
8802 #endif /* ALLOW_REPEAT */
8803
8804         switch(mode)
8805         {
8806                 case 1: display_essence();break;
8807                 case 2: drain_essence();break;
8808                 case 3: erase_essence();break;
8809                 case 4:
8810                         mode = choose_essence();
8811                         if (mode == 0)
8812                                 break;
8813                         add_essence(mode);
8814                         break;
8815                 case 5: add_essence(10);break;
8816         }
8817 }
8818
8819
8820 /*!
8821  * @brief 投擲時たいまつに投げやすい/焼棄/アンデッドスレイの特別効果を返す。
8822  * Torches have special abilities when they are flaming.
8823  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8824  * @param flgs 特別に追加するフラグを返す参照ポインタ
8825  * @return なし
8826  */
8827 void torch_flags(object_type *o_ptr, u32b *flgs)
8828 {
8829         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8830         {
8831                 if (o_ptr->xtra4 > 0)
8832                 {
8833                         add_flag(flgs, TR_BRAND_FIRE);
8834                         add_flag(flgs, TR_KILL_UNDEAD);
8835                         add_flag(flgs, TR_THROW);
8836                 }
8837         }
8838 }
8839
8840 /*!
8841  * @brief 投擲時たいまつにダイスを与える。
8842  * Torches have special abilities when they are flaming.
8843  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8844  * @param dd 特別なダイス数を返す参照ポインタ
8845  * @param ds 特別なダイス面数を返す参照ポインタ
8846  * @return なし
8847  */
8848 void torch_dice(object_type *o_ptr, int *dd, int *ds)
8849 {
8850         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8851         {
8852                 if (o_ptr->xtra4 > 0)
8853                 {
8854                         (*dd) = 1;
8855                         (*ds) = 6;
8856                 }
8857         }
8858 }
8859
8860 /*!
8861  * @brief 投擲時命中したたいまつの寿命を縮める。
8862  * Torches have special abilities when they are flaming.
8863  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
8864  * @return なし
8865  */
8866 void torch_lost_fuel(object_type *o_ptr)
8867 {
8868         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
8869         {
8870                 o_ptr->xtra4 -= (FUEL_TORCH / 25);
8871                 if (o_ptr->xtra4 < 0) o_ptr->xtra4 = 0;
8872         }
8873 }