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