src/object2.c

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