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