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