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