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