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