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