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