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