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