src/object2.c

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