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