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 "util.h"
  16 #include "world.h"
  17 #include "term.h"
  18
  19 #include "object.h"
  20
  21 #include "cmd-dump.h"
  22 #include "cmd-spell.h"
  23 #include "spells.h"
  24 #include "dungeon.h"
  25 #include "floor.h"
  26 #include "grid.h"
  27 #include "objectkind.h"
  28 #include "object-boost.h"
  29 #include "object-ego.h"
  30 #include "object-flavor.h"
  31 #include "object-hook.h"
  32 #include "object-curse.h"
  33 #include "objectkind-hook.h"
  34 #include "artifact.h"
  35 #include "feature.h"
  36 #include "player-status.h"
  37 #include "player-move.h"
  38 #include "player-effects.h"
  39 #include "player-class.h"
  40 #include "player-personality.h"
  41 #include "monster.h"
  42 #include "monsterrace-hook.h"
  43 #include "object-ego.h"
  44 #include "view-mainwindow.h"
  45
  46  /*
  47   * todo この説明長すぎ。何とかしたい
  48   * Determine if an item can "absorb" a second item
  49   *
  50   * See "object_absorb()" for the actual "absorption" code.
  51   *
  52   * If permitted, we allow staffs (if they are known to have equal charges
  53   * and both are either known or confirmed empty) and wands (if both are
  54   * either known or confirmed empty) and rods (in all cases) to combine.
  55   * Staffs will unstack (if necessary) when they are used, but wands and
  56   * rods will only unstack if one is dropped. -LM-
  57   *
  58   * If permitted, we allow weapons/armor to stack, if fully "known".
  59   *
  60   * Missiles will combine if both stacks have the same "known" status.
  61   * This is done to make unidentified stacks of missiles useful.
  62   *
  63   * Food, potions, scrolls, and "easy know" items always stack.
  64   *
  65   * Chests, and activatable items, never stack (for various reasons).
  66   */
  67
  68   /*
  69    * A "stack" of items is limited to less than or equal to 99 items (hard-coded).
  70    */
  71 #define MAX_STACK_SIZE 99
  72
  73    /*!
  74         * todo この関数ポインタは何とかならんのか？
  75         * Hack -- function hook to restrict "get_obj_num_prep()" function
  76         */
  77 bool(*get_obj_num_hook)(KIND_OBJECT_IDX k_idx);
  78
  79 /*!
  80 * todo これを消すとコンパイルは通るがリンカがエラーを吐く、何とか既存の構造に押し込みたい
  81 */
  82 OBJECT_SUBTYPE_VALUE coin_type; /* Hack -- force coin type */
  83
  84 void floor_item_describe(floor_type *floor_ptr, INVENTORY_IDX item);
  85
  86 /*!
  87  * @brief 床上、モンスター所持でスタックされたアイテムを削除しスタックを補完する / Excise a dungeon object from any stacks
  88  * @param floo_ptr 現在フロアへの参照ポインタ
  89  * @param o_idx 削除対象のオブジェクト構造体ポインタ
  90  * @return なし
  91  */
  92 void excise_object_idx(floor_type *floor_ptr, OBJECT_IDX o_idx)
  93 {
  94         object_type *j_ptr;
  95
  96         OBJECT_IDX this_o_idx, next_o_idx = 0;
  97         OBJECT_IDX prev_o_idx = 0;
  98
  99         /* Object */
 100         j_ptr = &floor_ptr->o_list[o_idx];
 101
 102         if (OBJECT_IS_HELD_MONSTER(j_ptr))
 103         {
 104                 monster_type *m_ptr;
 105                 m_ptr = &floor_ptr->m_list[j_ptr->held_m_idx];
 106
 107                 /* Scan all objects in the grid */
 108                 for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
 109                 {
 110                         object_type *o_ptr;
 111                         o_ptr = &floor_ptr->o_list[this_o_idx];
 112                         next_o_idx = o_ptr->next_o_idx;
 113
 114                         if (this_o_idx == o_idx)
 115                         {
 116                                 /* No previous */
 117                                 if (prev_o_idx == 0)
 118                                 {
 119                                         /* Remove from list */
 120                                         m_ptr->hold_o_idx = next_o_idx;
 121                                 }
 122
 123                                 /* Real previous */
 124                                 else
 125                                 {
 126                                         object_type *k_ptr;
 127
 128                                         /* Previous object */
 129                                         k_ptr = &floor_ptr->o_list[prev_o_idx];
 130
 131                                         /* Remove from list */
 132                                         k_ptr->next_o_idx = next_o_idx;
 133                                 }
 134
 135                                 /* Forget next pointer */
 136                                 o_ptr->next_o_idx = 0;
 137
 138                                 break;
 139                         }
 140
 141                         /* Save prev_o_idx */
 142                         prev_o_idx = this_o_idx;
 143                 }
 144         }
 145
 146         /* Dungeon */
 147         else
 148         {
 149                 grid_type *g_ptr;
 150
 151                 POSITION y = j_ptr->iy;
 152                 POSITION x = j_ptr->ix;
 153
 154                 g_ptr = &floor_ptr->grid_array[y][x];
 155
 156                 /* Scan all objects in the grid */
 157                 for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 158                 {
 159                         object_type *o_ptr;
 160                         o_ptr = &floor_ptr->o_list[this_o_idx];
 161                         next_o_idx = o_ptr->next_o_idx;
 162
 163                         if (this_o_idx == o_idx)
 164                         {
 165                                 /* No previous */
 166                                 if (prev_o_idx == 0)
 167                                 {
 168                                         /* Remove from list */
 169                                         g_ptr->o_idx = next_o_idx;
 170                                 }
 171
 172                                 /* Real previous */
 173                                 else
 174                                 {
 175                                         object_type *k_ptr;
 176
 177                                         /* Previous object */
 178                                         k_ptr = &floor_ptr->o_list[prev_o_idx];
 179
 180                                         /* Remove from list */
 181                                         k_ptr->next_o_idx = next_o_idx;
 182                                 }
 183
 184                                 /* Forget next pointer */
 185                                 o_ptr->next_o_idx = 0;
 186
 187                                 break;
 188                         }
 189
 190                         /* Save prev_o_idx */
 191                         prev_o_idx = this_o_idx;
 192                 }
 193         }
 194 }
 195
 196
 197 /*!
 198  * @brief オブジェクトを削除する /
 199  * Delete a dungeon object
 200  * @param floo_ptr 現在フロアへの参照ポインタ
 201  * @param o_idx 削除対象のオブジェクト構造体ポインタ
 202  * @return なし
 203  * @details
 204  * Handle "stacks" of objects correctly.
 205  */
 206 void delete_object_idx(floor_type *floor_ptr, OBJECT_IDX o_idx)
 207 {
 208         object_type *j_ptr;
 209
 210         /* Excise */
 211         excise_object_idx(floor_ptr, o_idx);
 212
 213         /* Object */
 214         j_ptr = &floor_ptr->o_list[o_idx];
 215
 216         /* Dungeon floor */
 217         if (!OBJECT_IS_HELD_MONSTER(j_ptr))
 218         {
 219                 POSITION y, x;
 220                 y = j_ptr->iy;
 221                 x = j_ptr->ix;
 222                 lite_spot(y, x);
 223         }
 224         object_wipe(j_ptr);
 225
 226         floor_ptr->o_cnt--;
 227 }
 228
 229
 230 /*!
 231  * @brief フロアにマスに落ちているオブジェクトを全て削除する / Deletes all objects at given location
 232  * Delete a dungeon object
 233  * @param floo_ptr 現在フロアへの参照ポインタ
 234  * @param y 削除したフロアマスのY座標
 235  * @param x 削除したフロアマスのX座標
 236  * @return なし
 237  */
 238 void delete_object(floor_type *floor_ptr, POSITION y, POSITION x)
 239 {
 240         grid_type *g_ptr;
 241         OBJECT_IDX this_o_idx, next_o_idx = 0;
 242
 243         /* Refuse "illegal" locations */
 244         if (!in_bounds(floor_ptr, y, x)) return;
 245
 246         g_ptr = &floor_ptr->grid_array[y][x];
 247
 248         /* Scan all objects in the grid */
 249         for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 250         {
 251                 object_type *o_ptr;
 252                 o_ptr = &floor_ptr->o_list[this_o_idx];
 253                 next_o_idx = o_ptr->next_o_idx;
 254                 object_wipe(o_ptr);
 255                 floor_ptr->o_cnt--;
 256         }
 257
 258         g_ptr->o_idx = 0;
 259         lite_spot(y, x);
 260 }
 261
 262
 263 /*!
 264  * @brief グローバルオブジェクト配列から空きを取得する /
 265  * Acquires and returns the index of a "free" object.
 266  * @param floo_ptr 現在フロアへの参照ポインタ
 267  * @return 開いているオブジェクト要素のID
 268  * @details
 269  * This routine should almost never fail, but in case it does,
 270  * we must be sure to handle "failure" of this routine.
 271  */
 272 OBJECT_IDX o_pop(floor_type *floor_ptr)
 273 {
 274         OBJECT_IDX i;
 275
 276         /* Initial allocation */
 277         if (floor_ptr->o_max < current_world_ptr->max_o_idx)
 278         {
 279                 /* Get next space */
 280                 i = floor_ptr->o_max;
 281
 282                 /* Expand object array */
 283                 floor_ptr->o_max++;
 284                 floor_ptr->o_cnt++;
 285
 286                 /* Use this object */
 287                 return i;
 288         }
 289
 290
 291         /* Recycle dead objects */
 292         for (i = 1; i < floor_ptr->o_max; i++)
 293         {
 294                 object_type *o_ptr;
 295                 o_ptr = &floor_ptr->o_list[i];
 296
 297                 /* Skip live objects */
 298                 if (o_ptr->k_idx) continue;
 299                 floor_ptr->o_cnt++;
 300
 301                 /* Use this object */
 302                 return i;
 303         }
 304
 305         /* Warn the player (except during dungeon creation) */
 306         if (current_world_ptr->character_dungeon) msg_print(_("アイテムが多すぎる！", "Too many objects!"));
 307
 308         return 0;
 309 }
 310
 311
 312 /*!
 313  * @brief オブジェクト生成テーブルに生成制約を加える /
 314  * Apply a "object restriction function" to the "object allocation table"
 315  * @return 常に0を返す。
 316  * @details 生成の制約はグローバルのget_obj_num_hook関数ポインタで加える
 317  */
 318 static errr get_obj_num_prep(void)
 319 {
 320         int i;
 321
 322         /* Get the entry */
 323         alloc_entry *table = alloc_kind_table;
 324
 325         /* Scan the allocation table */
 326         for (i = 0; i < alloc_kind_size; i++)
 327         {
 328                 /* Accept objects which pass the restriction, if any */
 329                 if (!get_obj_num_hook || (*get_obj_num_hook)(table[i].index))
 330                 {
 331                         /* Accept this object */
 332                         table[i].prob2 = table[i].prob1;
 333                 }
 334
 335                 /* Do not use this object */
 336                 else
 337                 {
 338                         /* Decline this object */
 339                         table[i].prob2 = 0;
 340                 }
 341         }
 342
 343         return 0;
 344 }
 345
 346
 347 /*!
 348  * @brief オブジェクト生成テーブルからアイテムを取得する /
 349  * Choose an object kind that seems "appropriate" to the given level
 350  * @param owner_ptr プレーヤーへの参照ポインタ
 351  * @param level 生成階
 352  * @return 選ばれたオブジェクトベースID
 353  * @details
 354  * This function uses the "prob2" field of the "object allocation table",\n
 355  * and various local information, to calculate the "prob3" field of the\n
 356  * same table, which is then used to choose an "appropriate" object, in\n
 357  * a relatively efficient manner.\n
 358  *\n
 359  * It is (slightly) more likely to acquire an object of the given level\n
 360  * than one of a lower level.  This is done by choosing several objects\n
 361  * appropriate to the given level and keeping the "hardest" one.\n
 362  *\n
 363  * Note that if no objects are "appropriate", then this function will\n
 364  * fail, and return zero, but this should *almost* never happen.\n
 365  */
 366 OBJECT_IDX get_obj_num(player_type *owner_ptr, DEPTH level, BIT_FLAGS mode)
 367 {
 368         int i, j, p;
 369         KIND_OBJECT_IDX k_idx;
 370         long value, total;
 371         object_kind     *k_ptr;
 372         alloc_entry     *table = alloc_kind_table;
 373
 374         if (level > MAX_DEPTH - 1) level = MAX_DEPTH - 1;
 375
 376         /* Boost level */
 377         if ((level > 0) && !(d_info[owner_ptr->dungeon_idx].flags1 & DF1_BEGINNER))
 378         {
 379                 /* Occasional "boost" */
 380                 if (one_in_(GREAT_OBJ))
 381                 {
 382                         /* What a bizarre calculation */
 383                         level = 1 + (level * MAX_DEPTH / randint1(MAX_DEPTH));
 384                 }
 385         }
 386
 387         /* Reset total */
 388         total = 0L;
 389
 390         /* Process probabilities */
 391         for (i = 0; i < alloc_kind_size; i++)
 392         {
 393                 /* Objects are sorted by depth */
 394                 if (table[i].level > level) break;
 395
 396                 /* Default */
 397                 table[i].prob3 = 0;
 398
 399                 k_idx = table[i].index;
 400
 401                 /* Access the actual kind */
 402                 k_ptr = &k_info[k_idx];
 403
 404                 if ((mode & AM_FORBID_CHEST) && (k_ptr->tval == TV_CHEST)) continue;
 405
 406                 /* Accept */
 407                 table[i].prob3 = table[i].prob2;
 408
 409                 /* Total */
 410                 total += table[i].prob3;
 411         }
 412
 413         /* No legal objects */
 414         if (total <= 0) return (0);
 415
 416
 417         /* Pick an object */
 418         value = randint0(total);
 419
 420         /* Find the object */
 421         for (i = 0; i < alloc_kind_size; i++)
 422         {
 423                 /* Found the entry */
 424                 if (value < table[i].prob3) break;
 425
 426                 /* Decrement */
 427                 value = value - table[i].prob3;
 428         }
 429
 430         /* Power boost */
 431         p = randint0(100);
 432
 433         /* Try for a "better" object once (50%) or twice (10%) */
 434         if (p < 60)
 435         {
 436                 /* Save old */
 437                 j = i;
 438
 439                 /* Pick a object */
 440                 value = randint0(total);
 441
 442                 /* Find the object */
 443                 for (i = 0; i < alloc_kind_size; i++)
 444                 {
 445                         /* Found the entry */
 446                         if (value < table[i].prob3) break;
 447
 448                         /* Decrement */
 449                         value = value - table[i].prob3;
 450                 }
 451
 452                 /* Keep the "best" one */
 453                 if (table[i].level < table[j].level) i = j;
 454         }
 455
 456         /* Try for a "better" object twice (10%) */
 457         if (p < 10)
 458         {
 459                 /* Save old */
 460                 j = i;
 461
 462                 /* Pick a object */
 463                 value = randint0(total);
 464
 465                 /* Find the object */
 466                 for (i = 0; i < alloc_kind_size; i++)
 467                 {
 468                         /* Found the entry */
 469                         if (value < table[i].prob3) break;
 470
 471                         /* Decrement */
 472                         value = value - table[i].prob3;
 473                 }
 474
 475                 /* Keep the "best" one */
 476                 if (table[i].level < table[j].level) i = j;
 477         }
 478
 479         return (table[i].index);
 480 }
 481
 482
 483 /*!
 484  * @brief オブジェクトを鑑定済にする /
 485  * Known is true when the "attributes" of an object are "known".
 486  * @param o_ptr 鑑定済にするオブジェクトの構造体参照ポインタ
 487  * @return なし
 488  * These include tohit, todam, toac, cost, and pval (charges).\n
 489  *\n
 490  * Note that "knowing" an object gives you everything that an "awareness"\n
 491  * gives you, and much more.  In fact, the player is always "aware" of any\n
 492  * item of which he has full "knowledge".\n
 493  *\n
 494  * But having full knowledge of, say, one "wand of wonder", does not, by\n
 495  * itself, give you knowledge, or even awareness, of other "wands of wonder".\n
 496  * It happens that most "identify" routines (including "buying from a shop")\n
 497  * will make the player "aware" of the object as well as fully "know" it.\n
 498  *\n
 499  * This routine also removes any inscriptions generated by "feelings".\n
 500  */
 501 void object_known(object_type *o_ptr)
 502 {
 503         /* Remove "default inscriptions" */
 504         o_ptr->feeling = FEEL_NONE;
 505
 506         /* Clear the "Felt" info */
 507         o_ptr->ident &= ~(IDENT_SENSE);
 508
 509         /* Clear the "Empty" info */
 510         o_ptr->ident &= ~(IDENT_EMPTY);
 511
 512         /* Now we know about the item */
 513         o_ptr->ident |= (IDENT_KNOWN);
 514 }
 515
 516
 517 /*!
 518  * @brief オブジェクトを＊鑑定＊済にする /
 519  * The player is now aware of the effects of the given object.
 520  * @param owner_ptr プレーヤーへの参照ポインタ
 521  * @param o_ptr ＊鑑定＊済にするオブジェクトの構造体参照ポインタ
 522  * @return なし
 523  */
 524 void object_aware(player_type *owner_ptr, object_type *o_ptr)
 525 {
 526         bool mihanmei = !object_is_aware(o_ptr);
 527
 528         /* Fully aware of the effects */
 529         k_info[o_ptr->k_idx].aware = TRUE;
 530
 531         if (mihanmei && !(k_info[o_ptr->k_idx].gen_flags & TRG_INSTA_ART) && record_ident &&
 532                 !owner_ptr->is_dead && ((o_ptr->tval >= TV_AMULET && o_ptr->tval <= TV_POTION) || (o_ptr->tval == TV_FOOD)))
 533         {
 534                 object_type forge;
 535                 object_type *q_ptr;
 536                 GAME_TEXT o_name[MAX_NLEN];
 537
 538                 q_ptr = &forge;
 539                 object_copy(q_ptr, o_ptr);
 540
 541                 q_ptr->number = 1;
 542                 object_desc(o_name, q_ptr, OD_NAME_ONLY);
 543
 544                 exe_write_diary(owner_ptr, NIKKI_HANMEI, 0, o_name);
 545         }
 546 }
 547
 548
 549 /*!
 550  * @brief オブジェクトを試行済にする /
 551  * Something has been "sampled"
 552  * @param o_ptr 試行済にするオブジェクトの構造体参照ポインタ
 553  * @return なし
 554  */
 555 void object_tried(object_type *o_ptr)
 556 {
 557         /* Mark it as tried (even if "aware") */
 558         k_info[o_ptr->k_idx].tried = TRUE;
 559 }
 560
 561
 562 /*!
 563 * @brief 重度擬似鑑定の判断処理 / Return a "feeling" (or NULL) about an item.  Method 1 (Heavy).
 564 * @param o_ptr 擬似鑑定を行うオブジェクトの参照ポインタ。
 565 * @return 擬似鑑定結果のIDを返す。
 566 */
 567 byte value_check_aux1(object_type *o_ptr)
 568 {
 569         /* Artifacts */
 570         if (object_is_artifact(o_ptr))
 571         {
 572                 /* Cursed/Broken */
 573                 if (object_is_cursed(o_ptr) || object_is_broken(o_ptr)) return FEEL_TERRIBLE;
 574
 575                 /* Normal */
 576                 return FEEL_SPECIAL;
 577         }
 578
 579         /* Ego-Items */
 580         if (object_is_ego(o_ptr))
 581         {
 582                 /* Cursed/Broken */
 583                 if (object_is_cursed(o_ptr) || object_is_broken(o_ptr)) return FEEL_WORTHLESS;
 584
 585                 /* Normal */
 586                 return FEEL_EXCELLENT;
 587         }
 588
 589         /* Cursed items */
 590         if (object_is_cursed(o_ptr)) return FEEL_CURSED;
 591
 592         /* Broken items */
 593         if (object_is_broken(o_ptr)) return FEEL_BROKEN;
 594
 595         if ((o_ptr->tval == TV_RING) || (o_ptr->tval == TV_AMULET)) return FEEL_AVERAGE;
 596
 597         /* Good "armor" bonus */
 598         if (o_ptr->to_a > 0) return FEEL_GOOD;
 599
 600         /* Good "weapon" bonus */
 601         if (o_ptr->to_h + o_ptr->to_d > 0) return FEEL_GOOD;
 602
 603         /* Default to "average" */
 604         return FEEL_AVERAGE;
 605 }
 606
 607
 608 /*!
 609 * @brief 軽度擬似鑑定の判断処理 / Return a "feeling" (or NULL) about an item.  Method 2 (Light).
 610 * @param o_ptr 擬似鑑定を行うオブジェクトの参照ポインタ。
 611 * @return 擬似鑑定結果のIDを返す。
 612 */
 613 byte value_check_aux2(object_type *o_ptr)
 614 {
 615         /* Cursed items (all of them) */
 616         if (object_is_cursed(o_ptr)) return FEEL_CURSED;
 617
 618         /* Broken items (all of them) */
 619         if (object_is_broken(o_ptr)) return FEEL_BROKEN;
 620
 621         /* Artifacts -- except cursed/broken ones */
 622         if (object_is_artifact(o_ptr)) return FEEL_UNCURSED;
 623
 624         /* Ego-Items -- except cursed/broken ones */
 625         if (object_is_ego(o_ptr)) return FEEL_UNCURSED;
 626
 627         /* Good armor bonus */
 628         if (o_ptr->to_a > 0) return FEEL_UNCURSED;
 629
 630         /* Good weapon bonuses */
 631         if (o_ptr->to_h + o_ptr->to_d > 0) return FEEL_UNCURSED;
 632
 633         /* No feeling */
 634         return FEEL_NONE;
 635 }
 636
 637
 638 /*!
 639  * @brief 未鑑定なベースアイテムの基本価格を返す /
 640  * Return the "value" of an "unknown" item Make a guess at the value of non-aware items
 641  * @param o_ptr 未鑑定価格を確認したいオブジェクトの構造体参照ポインタ
 642  * @return オブジェクトの未鑑定価格
 643  */
 644 static PRICE object_value_base(object_type *o_ptr)
 645 {
 646         /* Aware item -- use template cost */
 647         if (object_is_aware(o_ptr)) return (k_info[o_ptr->k_idx].cost);
 648
 649         /* Analyze the type */
 650         switch (o_ptr->tval)
 651         {
 652
 653                 /* Un-aware Food */
 654         case TV_FOOD: return (5L);
 655
 656                 /* Un-aware Potions */
 657         case TV_POTION: return (20L);
 658
 659                 /* Un-aware Scrolls */
 660         case TV_SCROLL: return (20L);
 661
 662                 /* Un-aware Staffs */
 663         case TV_STAFF: return (70L);
 664
 665                 /* Un-aware Wands */
 666         case TV_WAND: return (50L);
 667
 668                 /* Un-aware Rods */
 669         case TV_ROD: return (90L);
 670
 671                 /* Un-aware Rings */
 672         case TV_RING: return (45L);
 673
 674                 /* Un-aware Amulets */
 675         case TV_AMULET: return (45L);
 676
 677                 /* Figurines, relative to monster level */
 678         case TV_FIGURINE:
 679         {
 680                 DEPTH level = r_info[o_ptr->pval].level;
 681                 if (level < 20) return level * 50L;
 682                 else if (level < 30) return 1000 + (level - 20) * 150L;
 683                 else if (level < 40) return 2500 + (level - 30) * 350L;
 684                 else if (level < 50) return 6000 + (level - 40) * 800L;
 685                 else return 14000 + (level - 50) * 2000L;
 686         }
 687
 688         case TV_CAPTURE:
 689                 if (!o_ptr->pval) return 1000L;
 690                 else return ((r_info[o_ptr->pval].level) * 50L + 1000);
 691         }
 692
 693         /* Paranoia -- Oops */
 694         return (0L);
 695 }
 696
 697
 698 /*!
 699  * @brief オブジェクトのフラグ類から価格を算出する /
 700  * Return the value of the flags the object has...
 701  * @param o_ptr フラグ価格を確認したいオブジェクトの構造体参照ポインタ
 702  * @param plusses フラグに与える価格の基本重み
 703  * @return オブジェクトのフラグ価格
 704  */
 705 PRICE flag_cost(object_type *o_ptr, int plusses)
 706 {
 707         PRICE total = 0;
 708         BIT_FLAGS flgs[TR_FLAG_SIZE];
 709         PRICE tmp_cost;
 710         int count;
 711         int i;
 712         object_kind *k_ptr = &k_info[o_ptr->k_idx];
 713
 714         object_flags(o_ptr, flgs);
 715
 716         /*
 717          * Exclude fixed flags of the base item.
 718          * pval bonuses of base item will be treated later.
 719          */
 720         for (i = 0; i < TR_FLAG_SIZE; i++)
 721                 flgs[i] &= ~(k_ptr->flags[i]);
 722
 723         /* Exclude fixed flags of the fixed artifact. */
 724         if (object_is_fixed_artifact(o_ptr))
 725         {
 726                 artifact_type *a_ptr = &a_info[o_ptr->name1];
 727
 728                 for (i = 0; i < TR_FLAG_SIZE; i++)
 729                         flgs[i] &= ~(a_ptr->flags[i]);
 730         }
 731
 732         /* Exclude fixed flags of the ego-item. */
 733         else if (object_is_ego(o_ptr))
 734         {
 735                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
 736
 737                 for (i = 0; i < TR_FLAG_SIZE; i++)
 738                         flgs[i] &= ~(e_ptr->flags[i]);
 739         }
 740
 741
 742         /*
 743          * Calucurate values of remaining flags
 744          */
 745         if (have_flag(flgs, TR_STR)) total += (1500 * plusses);
 746         if (have_flag(flgs, TR_INT)) total += (1500 * plusses);
 747         if (have_flag(flgs, TR_WIS)) total += (1500 * plusses);
 748         if (have_flag(flgs, TR_DEX)) total += (1500 * plusses);
 749         if (have_flag(flgs, TR_CON)) total += (1500 * plusses);
 750         if (have_flag(flgs, TR_CHR)) total += (750 * plusses);
 751         if (have_flag(flgs, TR_MAGIC_MASTERY)) total += (600 * plusses);
 752         if (have_flag(flgs, TR_STEALTH)) total += (250 * plusses);
 753         if (have_flag(flgs, TR_SEARCH)) total += (100 * plusses);
 754         if (have_flag(flgs, TR_INFRA)) total += (150 * plusses);
 755         if (have_flag(flgs, TR_TUNNEL)) total += (175 * plusses);
 756         if ((have_flag(flgs, TR_SPEED)) && (plusses > 0))
 757                 total += (10000 + (2500 * plusses));
 758         if ((have_flag(flgs, TR_BLOWS)) && (plusses > 0))
 759                 total += (10000 + (2500 * plusses));
 760
 761         tmp_cost = 0;
 762         count = 0;
 763         if (have_flag(flgs, TR_CHAOTIC)) { total += 5000; count++; }
 764         if (have_flag(flgs, TR_VAMPIRIC)) { total += 6500; count++; }
 765         if (have_flag(flgs, TR_FORCE_WEAPON)) { tmp_cost += 2500; count++; }
 766         if (have_flag(flgs, TR_KILL_ANIMAL)) { tmp_cost += 2800; count++; }
 767         else if (have_flag(flgs, TR_SLAY_ANIMAL)) { tmp_cost += 1800; count++; }
 768         if (have_flag(flgs, TR_KILL_EVIL)) { tmp_cost += 3300; count++; }
 769         else if (have_flag(flgs, TR_SLAY_EVIL)) { tmp_cost += 2300; count++; }
 770         if (have_flag(flgs, TR_KILL_HUMAN)) { tmp_cost += 2800; count++; }
 771         else if (have_flag(flgs, TR_SLAY_HUMAN)) { tmp_cost += 1800; count++; }
 772         if (have_flag(flgs, TR_KILL_UNDEAD)) { tmp_cost += 2800; count++; }
 773         else if (have_flag(flgs, TR_SLAY_UNDEAD)) { tmp_cost += 1800; count++; }
 774         if (have_flag(flgs, TR_KILL_DEMON)) { tmp_cost += 2800; count++; }
 775         else if (have_flag(flgs, TR_SLAY_DEMON)) { tmp_cost += 1800; count++; }
 776         if (have_flag(flgs, TR_KILL_ORC)) { tmp_cost += 2500; count++; }
 777         else if (have_flag(flgs, TR_SLAY_ORC)) { tmp_cost += 1500; count++; }
 778         if (have_flag(flgs, TR_KILL_TROLL)) { tmp_cost += 2800; count++; }
 779         else if (have_flag(flgs, TR_SLAY_TROLL)) { tmp_cost += 1800; count++; }
 780         if (have_flag(flgs, TR_KILL_GIANT)) { tmp_cost += 2800; count++; }
 781         else if (have_flag(flgs, TR_SLAY_GIANT)) { tmp_cost += 1800; count++; }
 782         if (have_flag(flgs, TR_KILL_DRAGON)) { tmp_cost += 2800; count++; }
 783         else if (have_flag(flgs, TR_SLAY_DRAGON)) { tmp_cost += 1800; count++; }
 784
 785         if (have_flag(flgs, TR_VORPAL)) { tmp_cost += 2500; count++; }
 786         if (have_flag(flgs, TR_IMPACT)) { tmp_cost += 2500; count++; }
 787         if (have_flag(flgs, TR_BRAND_POIS)) { tmp_cost += 3800; count++; }
 788         if (have_flag(flgs, TR_BRAND_ACID)) { tmp_cost += 3800; count++; }
 789         if (have_flag(flgs, TR_BRAND_ELEC)) { tmp_cost += 3800; count++; }
 790         if (have_flag(flgs, TR_BRAND_FIRE)) { tmp_cost += 2500; count++; }
 791         if (have_flag(flgs, TR_BRAND_COLD)) { tmp_cost += 2500; count++; }
 792         total += (tmp_cost * count);
 793
 794         if (have_flag(flgs, TR_SUST_STR)) total += 850;
 795         if (have_flag(flgs, TR_SUST_INT)) total += 850;
 796         if (have_flag(flgs, TR_SUST_WIS)) total += 850;
 797         if (have_flag(flgs, TR_SUST_DEX)) total += 850;
 798         if (have_flag(flgs, TR_SUST_CON)) total += 850;
 799         if (have_flag(flgs, TR_SUST_CHR)) total += 250;
 800         if (have_flag(flgs, TR_RIDING)) total += 0;
 801         if (have_flag(flgs, TR_EASY_SPELL)) total += 1500;
 802         if (have_flag(flgs, TR_THROW)) total += 5000;
 803         if (have_flag(flgs, TR_FREE_ACT)) total += 4500;
 804         if (have_flag(flgs, TR_HOLD_EXP)) total += 8500;
 805
 806         tmp_cost = 0;
 807         count = 0;
 808         if (have_flag(flgs, TR_IM_ACID)) { tmp_cost += 15000; count += 2; }
 809         if (have_flag(flgs, TR_IM_ELEC)) { tmp_cost += 15000; count += 2; }
 810         if (have_flag(flgs, TR_IM_FIRE)) { tmp_cost += 15000; count += 2; }
 811         if (have_flag(flgs, TR_IM_COLD)) { tmp_cost += 15000; count += 2; }
 812         if (have_flag(flgs, TR_REFLECT)) { tmp_cost += 5000; count += 2; }
 813         if (have_flag(flgs, TR_RES_ACID)) { tmp_cost += 500; count++; }
 814         if (have_flag(flgs, TR_RES_ELEC)) { tmp_cost += 500; count++; }
 815         if (have_flag(flgs, TR_RES_FIRE)) { tmp_cost += 500; count++; }
 816         if (have_flag(flgs, TR_RES_COLD)) { tmp_cost += 500; count++; }
 817         if (have_flag(flgs, TR_RES_POIS)) { tmp_cost += 1000; count += 2; }
 818         if (have_flag(flgs, TR_RES_FEAR)) { tmp_cost += 1000; count += 2; }
 819         if (have_flag(flgs, TR_RES_LITE)) { tmp_cost += 800; count += 2; }
 820         if (have_flag(flgs, TR_RES_DARK)) { tmp_cost += 800; count += 2; }
 821         if (have_flag(flgs, TR_RES_BLIND)) { tmp_cost += 900; count += 2; }
 822         if (have_flag(flgs, TR_RES_CONF)) { tmp_cost += 900; count += 2; }
 823         if (have_flag(flgs, TR_RES_SOUND)) { tmp_cost += 900; count += 2; }
 824         if (have_flag(flgs, TR_RES_SHARDS)) { tmp_cost += 900; count += 2; }
 825         if (have_flag(flgs, TR_RES_NETHER)) { tmp_cost += 900; count += 2; }
 826         if (have_flag(flgs, TR_RES_NEXUS)) { tmp_cost += 900; count += 2; }
 827         if (have_flag(flgs, TR_RES_CHAOS)) { tmp_cost += 1000; count += 2; }
 828         if (have_flag(flgs, TR_RES_DISEN)) { tmp_cost += 2000; count += 2; }
 829         total += (tmp_cost * count);
 830
 831         if (have_flag(flgs, TR_SH_FIRE)) total += 5000;
 832         if (have_flag(flgs, TR_SH_ELEC)) total += 5000;
 833         if (have_flag(flgs, TR_SH_COLD)) total += 5000;
 834         if (have_flag(flgs, TR_NO_TELE)) total -= 10000;
 835         if (have_flag(flgs, TR_NO_MAGIC)) total += 2500;
 836         if (have_flag(flgs, TR_TY_CURSE)) total -= 15000;
 837         if (have_flag(flgs, TR_HIDE_TYPE)) total += 0;
 838         if (have_flag(flgs, TR_SHOW_MODS)) total += 0;
 839         if (have_flag(flgs, TR_LEVITATION)) total += 1250;
 840         if (have_flag(flgs, TR_LITE_1)) total += 1500;
 841         if (have_flag(flgs, TR_LITE_2)) total += 2500;
 842         if (have_flag(flgs, TR_LITE_3)) total += 4000;
 843         if (have_flag(flgs, TR_LITE_M1)) total -= 1500;
 844         if (have_flag(flgs, TR_LITE_M2)) total -= 2500;
 845         if (have_flag(flgs, TR_LITE_M3)) total -= 4000;
 846         if (have_flag(flgs, TR_SEE_INVIS)) total += 2000;
 847         if (have_flag(flgs, TR_TELEPATHY)) total += 20000;
 848         if (have_flag(flgs, TR_ESP_ANIMAL)) total += 1000;
 849         if (have_flag(flgs, TR_ESP_UNDEAD)) total += 1000;
 850         if (have_flag(flgs, TR_ESP_DEMON)) total += 1000;
 851         if (have_flag(flgs, TR_ESP_ORC)) total += 1000;
 852         if (have_flag(flgs, TR_ESP_TROLL)) total += 1000;
 853         if (have_flag(flgs, TR_ESP_GIANT)) total += 1000;
 854         if (have_flag(flgs, TR_ESP_DRAGON)) total += 1000;
 855         if (have_flag(flgs, TR_ESP_HUMAN)) total += 1000;
 856         if (have_flag(flgs, TR_ESP_EVIL)) total += 15000;
 857         if (have_flag(flgs, TR_ESP_GOOD)) total += 2000;
 858         if (have_flag(flgs, TR_ESP_NONLIVING)) total += 2000;
 859         if (have_flag(flgs, TR_ESP_UNIQUE)) total += 10000;
 860         if (have_flag(flgs, TR_SLOW_DIGEST)) total += 750;
 861         if (have_flag(flgs, TR_REGEN)) total += 2500;
 862         if (have_flag(flgs, TR_WARNING)) total += 2000;
 863         if (have_flag(flgs, TR_DEC_MANA)) total += 10000;
 864         if (have_flag(flgs, TR_XTRA_MIGHT)) total += 2250;
 865         if (have_flag(flgs, TR_XTRA_SHOTS)) total += 10000;
 866         if (have_flag(flgs, TR_IGNORE_ACID)) total += 100;
 867         if (have_flag(flgs, TR_IGNORE_ELEC)) total += 100;
 868         if (have_flag(flgs, TR_IGNORE_FIRE)) total += 100;
 869         if (have_flag(flgs, TR_IGNORE_COLD)) total += 100;
 870         if (have_flag(flgs, TR_ACTIVATE)) total += 100;
 871         if (have_flag(flgs, TR_DRAIN_EXP)) total -= 12500;
 872         if (have_flag(flgs, TR_DRAIN_HP)) total -= 12500;
 873         if (have_flag(flgs, TR_DRAIN_MANA)) total -= 12500;
 874         if (have_flag(flgs, TR_CALL_ANIMAL)) total -= 12500;
 875         if (have_flag(flgs, TR_CALL_DEMON)) total -= 10000;
 876         if (have_flag(flgs, TR_CALL_DRAGON)) total -= 10000;
 877         if (have_flag(flgs, TR_CALL_UNDEAD)) total -= 10000;
 878         if (have_flag(flgs, TR_COWARDICE)) total -= 5000;
 879         if (have_flag(flgs, TR_LOW_MELEE)) total -= 5000;
 880         if (have_flag(flgs, TR_LOW_AC)) total -= 5000;
 881         if (have_flag(flgs, TR_LOW_MAGIC)) total -= 15000;
 882         if (have_flag(flgs, TR_FAST_DIGEST)) total -= 10000;
 883         if (have_flag(flgs, TR_SLOW_REGEN)) total -= 10000;
 884         if (have_flag(flgs, TR_TELEPORT))
 885         {
 886                 if (object_is_cursed(o_ptr))
 887                         total -= 7500;
 888                 else
 889                         total += 250;
 890         }
 891         if (have_flag(flgs, TR_AGGRAVATE)) total -= 10000;
 892         if (have_flag(flgs, TR_BLESSED)) total += 750;
 893         if (o_ptr->curse_flags & TR_ADD_L_CURSE) total -= 5000;
 894         if (o_ptr->curse_flags & TR_ADD_H_CURSE) total -= 12500;
 895         if (o_ptr->curse_flags & TRC_CURSED) total -= 5000;
 896         if (o_ptr->curse_flags & TRC_HEAVY_CURSE) total -= 12500;
 897         if (o_ptr->curse_flags & TRC_PERMA_CURSE) total -= 15000;
 898
 899         /* Also, give some extra for activatable powers... */
 900         if (o_ptr->art_name && (have_flag(o_ptr->art_flags, TR_ACTIVATE)))
 901         {
 902                 const activation_type* const act_ptr = find_activation_info(o_ptr);
 903                 if (act_ptr) {
 904                         total += act_ptr->value;
 905                 }
 906         }
 907
 908         return total;
 909 }
 910
 911
 912 /*!
 913  * @brief オブジェクトの真の価格を算出する /
 914  * Return the value of the flags the object has...
 915  * @param o_ptr 本価格を確認したいオブジェクトの構造体参照ポインタ
 916  * @return オブジェクトの本価格
 917  * @details
 918  * Return the "real" price of a "known" item, not including discounts\n
 919  *\n
 920  * Wand and staffs get cost for each charge\n
 921  *\n
 922  * Armor is worth an extra 100 gold per bonus point to armor class.\n
 923  *\n
 924  * Weapons are worth an extra 100 gold per bonus point (AC,TH,TD).\n
 925  *\n
 926  * Missiles are only worth 5 gold per bonus point, since they\n
 927  * usually appear in groups of 20, and we want the player to get\n
 928  * the same amount of cash for any "equivalent" item.  Note that\n
 929  * missiles never have any of the "pval" flags, and in fact, they\n
 930  * only have a few of the available flags, primarily of the "slay"\n
 931  * and "brand" and "ignore" variety.\n
 932  *\n
 933  * Armor with a negative armor bonus is worthless.\n
 934  * Weapons with negative hit+damage bonuses are worthless.\n
 935  *\n
 936  * Every wearable item with a "pval" bonus is worth extra (see below).\n
 937  */
 938 PRICE object_value_real(object_type *o_ptr)
 939 {
 940         PRICE value;
 941         BIT_FLAGS flgs[TR_FLAG_SIZE];
 942         object_kind *k_ptr = &k_info[o_ptr->k_idx];
 943
 944
 945         /* Hack -- "worthless" items */
 946         if (!k_info[o_ptr->k_idx].cost) return (0L);
 947
 948         /* Base cost */
 949         value = k_info[o_ptr->k_idx].cost;
 950
 951         /* Extract some flags */
 952         object_flags(o_ptr, flgs);
 953
 954         /* Artifact */
 955         if (object_is_fixed_artifact(o_ptr))
 956         {
 957                 artifact_type *a_ptr = &a_info[o_ptr->name1];
 958
 959                 /* Hack -- "worthless" artifacts */
 960                 if (!a_ptr->cost) return (0L);
 961
 962                 /* Hack -- Use the artifact cost instead */
 963                 value = a_ptr->cost;
 964                 value += flag_cost(o_ptr, o_ptr->pval);
 965
 966                 /* Don't add pval bonuses etc. */
 967                 return (value);
 968         }
 969
 970         /* Ego-Item */
 971         else if (object_is_ego(o_ptr))
 972         {
 973                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
 974
 975                 /* Hack -- "worthless" ego-items */
 976                 if (!e_ptr->cost) return (0L);
 977
 978                 /* Hack -- Reward the ego-item with a bonus */
 979                 value += e_ptr->cost;
 980                 value += flag_cost(o_ptr, o_ptr->pval);
 981         }
 982
 983         else
 984         {
 985                 int i;
 986                 bool flag = FALSE;
 987
 988                 for (i = 0; i < TR_FLAG_SIZE; i++)
 989                         if (o_ptr->art_flags[i]) flag = TRUE;
 990
 991                 if (flag) value += flag_cost(o_ptr, o_ptr->pval);
 992         }
 993
 994         /* Analyze pval bonus for normal object */
 995         switch (o_ptr->tval)
 996         {
 997         case TV_SHOT:
 998         case TV_ARROW:
 999         case TV_BOLT:
1000         case TV_BOW:
1001         case TV_DIGGING:
1002         case TV_HAFTED:
1003         case TV_POLEARM:
1004         case TV_SWORD:
1005         case TV_BOOTS:
1006         case TV_GLOVES:
1007         case TV_HELM:
1008         case TV_CROWN:
1009         case TV_SHIELD:
1010         case TV_CLOAK:
1011         case TV_SOFT_ARMOR:
1012         case TV_HARD_ARMOR:
1013         case TV_DRAG_ARMOR:
1014         case TV_LITE:
1015         case TV_AMULET:
1016         case TV_RING:
1017                 /* No pval */
1018                 if (!o_ptr->pval) break;
1019
1020                 /* Hack -- Negative "pval" is always bad */
1021                 if (o_ptr->pval < 0) return (0L);
1022
1023                 /* Give credit for stat bonuses */
1024                 if (have_flag(flgs, TR_STR)) value += (o_ptr->pval * 200L);
1025                 if (have_flag(flgs, TR_INT)) value += (o_ptr->pval * 200L);
1026                 if (have_flag(flgs, TR_WIS)) value += (o_ptr->pval * 200L);
1027                 if (have_flag(flgs, TR_DEX)) value += (o_ptr->pval * 200L);
1028                 if (have_flag(flgs, TR_CON)) value += (o_ptr->pval * 200L);
1029                 if (have_flag(flgs, TR_CHR)) value += (o_ptr->pval * 200L);
1030
1031                 /* Give credit for stealth and searching */
1032                 if (have_flag(flgs, TR_MAGIC_MASTERY)) value += (o_ptr->pval * 100);
1033                 if (have_flag(flgs, TR_STEALTH)) value += (o_ptr->pval * 100L);
1034                 if (have_flag(flgs, TR_SEARCH)) value += (o_ptr->pval * 100L);
1035
1036                 /* Give credit for infra-vision and tunneling */
1037                 if (have_flag(flgs, TR_INFRA)) value += (o_ptr->pval * 50L);
1038                 if (have_flag(flgs, TR_TUNNEL)) value += (o_ptr->pval * 50L);
1039
1040                 /* Give credit for extra attacks */
1041                 if (have_flag(flgs, TR_BLOWS)) value += (o_ptr->pval * 5000L);
1042
1043                 /* Give credit for speed bonus */
1044                 if (have_flag(flgs, TR_SPEED)) value += (o_ptr->pval * 10000L);
1045
1046                 break;
1047         }
1048
1049
1050         /* Analyze the item */
1051         switch (o_ptr->tval)
1052         {
1053                 /* Wands/Staffs */
1054         case TV_WAND:
1055         {
1056                 /* Pay extra for charges, depending on standard number of
1057                  * charges.  Handle new-style wands correctly. -LM-
1058                  */
1059                 value += (value * o_ptr->pval / o_ptr->number / (k_ptr->pval * 2));
1060
1061                 break;
1062         }
1063         case TV_STAFF:
1064         {
1065                 /* Pay extra for charges, depending on standard number of
1066                  * charges.  -LM-
1067                  */
1068                 value += (value * o_ptr->pval / (k_ptr->pval * 2));
1069
1070                 break;
1071         }
1072
1073         /* Rings/Amulets */
1074         case TV_RING:
1075         case TV_AMULET:
1076         {
1077                 /* Hack -- negative bonuses are bad */
1078                 if (o_ptr->to_h + o_ptr->to_d + o_ptr->to_a < 0) return (0L);
1079
1080                 /* Give credit for bonuses */
1081                 value += ((o_ptr->to_h + o_ptr->to_d + o_ptr->to_a) * 200L);
1082
1083                 break;
1084         }
1085
1086         /* Armor */
1087         case TV_BOOTS:
1088         case TV_GLOVES:
1089         case TV_CLOAK:
1090         case TV_CROWN:
1091         case TV_HELM:
1092         case TV_SHIELD:
1093         case TV_SOFT_ARMOR:
1094         case TV_HARD_ARMOR:
1095         case TV_DRAG_ARMOR:
1096         {
1097                 /* Hack -- negative armor bonus */
1098                 if (o_ptr->to_a < 0) return (0L);
1099
1100                 /* Give credit for bonuses */
1101                 value += (((o_ptr->to_h - k_ptr->to_h) + (o_ptr->to_d - k_ptr->to_d)) * 200L + (o_ptr->to_a) * 100L);
1102
1103                 break;
1104         }
1105
1106         /* Bows/Weapons */
1107         case TV_BOW:
1108         case TV_DIGGING:
1109         case TV_HAFTED:
1110         case TV_SWORD:
1111         case TV_POLEARM:
1112         {
1113                 /* Hack -- negative hit/damage bonuses */
1114                 if (o_ptr->to_h + o_ptr->to_d < 0) return (0L);
1115
1116                 /* Factor in the bonuses */
1117                 value += ((o_ptr->to_h + o_ptr->to_d + o_ptr->to_a) * 100L);
1118
1119                 /* Hack -- Factor in extra damage dice and sides */
1120                 value += (o_ptr->dd - k_ptr->dd) * o_ptr->ds * 250L;
1121                 value += (o_ptr->ds - k_ptr->ds) * o_ptr->dd * 250L;
1122
1123                 break;
1124         }
1125
1126         /* Ammo */
1127         case TV_SHOT:
1128         case TV_ARROW:
1129         case TV_BOLT:
1130         {
1131                 /* Hack -- negative hit/damage bonuses */
1132                 if (o_ptr->to_h + o_ptr->to_d < 0) return (0L);
1133
1134                 /* Factor in the bonuses */
1135                 value += ((o_ptr->to_h + o_ptr->to_d) * 5L);
1136
1137                 /* Hack -- Factor in extra damage dice and sides */
1138                 value += (o_ptr->dd - k_ptr->dd) * o_ptr->ds * 5L;
1139                 value += (o_ptr->ds - k_ptr->ds) * o_ptr->dd * 5L;
1140
1141                 break;
1142         }
1143
1144         /* Figurines, relative to monster level */
1145         case TV_FIGURINE:
1146         {
1147                 DEPTH level = r_info[o_ptr->pval].level;
1148                 if (level < 20) value = level * 50L;
1149                 else if (level < 30) value = 1000 + (level - 20) * 150L;
1150                 else if (level < 40) value = 2500 + (level - 30) * 350L;
1151                 else if (level < 50) value = 6000 + (level - 40) * 800L;
1152                 else value = 14000 + (level - 50) * 2000L;
1153                 break;
1154         }
1155
1156         case TV_CAPTURE:
1157         {
1158                 if (!o_ptr->pval) value = 1000L;
1159                 else value = ((r_info[o_ptr->pval].level) * 50L + 1000);
1160                 break;
1161         }
1162
1163         case TV_CHEST:
1164         {
1165                 if (!o_ptr->pval) value = 0L;
1166                 break;
1167         }
1168         }
1169
1170         /* Worthless object */
1171         if (value < 0) return 0L;
1172
1173         /* Return the value */
1174         return (value);
1175 }
1176
1177
1178 /*!
1179  * @brief オブジェクト価格算出のメインルーチン /
1180  * Return the price of an item including plusses (and charges)
1181  * @param o_ptr 判明している現価格を確認したいオブジェクトの構造体参照ポインタ
1182  * @return オブジェクトの判明している現価格
1183  * @details
1184  * This function returns the "value" of the given item (qty one)\n
1185  *\n
1186  * Never notice "unknown" bonuses or properties, including "curses",\n
1187  * since that would give the player information he did not have.\n
1188  *\n
1189  * Note that discounted items stay discounted forever, even if\n
1190  * the discount is "forgotten" by the player via memory loss.\n
1191  */
1192 PRICE object_value(object_type *o_ptr)
1193 {
1194         PRICE value;
1195
1196         /* Unknown items -- acquire a base value */
1197         if (object_is_known(o_ptr))
1198         {
1199                 /* Broken items -- worthless */
1200                 if (object_is_broken(o_ptr)) return (0L);
1201
1202                 /* Cursed items -- worthless */
1203                 if (object_is_cursed(o_ptr)) return (0L);
1204
1205                 /* Real value (see above) */
1206                 value = object_value_real(o_ptr);
1207         }
1208
1209         /* Known items -- acquire the actual value */
1210         else
1211         {
1212                 /* Hack -- Felt broken items */
1213                 if ((o_ptr->ident & (IDENT_SENSE)) && object_is_broken(o_ptr)) return (0L);
1214
1215                 /* Hack -- Felt cursed items */
1216                 if ((o_ptr->ident & (IDENT_SENSE)) && object_is_cursed(o_ptr)) return (0L);
1217
1218                 /* Base value (see above) */
1219                 value = object_value_base(o_ptr);
1220         }
1221
1222         /* Apply discount (if any) */
1223         if (o_ptr->discount) value -= (value * o_ptr->discount / 100L);
1224
1225         /* Return the final value */
1226         return (value);
1227 }
1228
1229
1230 /*!
1231  * @brief 魔法棒やロッドのスロット分割時に使用回数を分配する /
1232  * Distribute charges of rods or wands.
1233  * @param o_ptr 分割元オブジェクトの構造体参照ポインタ source item
1234  * @param q_ptr 分割先オブジェクトの構造体参照ポインタ target item, must be of the same type as o_ptr
1235  * @param amt 分割したい回数量 number of items that are transfered
1236  * @return なし
1237  * @details
1238  * Hack -- If rods or wands are dropped, the total maximum timeout or\n
1239  * charges need to be allocated between the two stacks.  If all the items\n
1240  * are being dropped, it makes for a neater message to leave the original\n
1241  * stack's pval alone. -LM-\n
1242  */
1243 void distribute_charges(object_type *o_ptr, object_type *q_ptr, int amt)
1244 {
1245         if ((o_ptr->tval == TV_WAND) || (o_ptr->tval == TV_ROD))
1246         {
1247                 q_ptr->pval = o_ptr->pval * amt / o_ptr->number;
1248                 if (amt < o_ptr->number) o_ptr->pval -= q_ptr->pval;
1249
1250                 /* Hack -- Rods also need to have their timeouts distributed.  The
1251                  * dropped stack will accept all time remaining to charge up to its
1252                  * maximum.
1253                  */
1254                 if ((o_ptr->tval == TV_ROD) && (o_ptr->timeout))
1255                 {
1256                         if (q_ptr->pval > o_ptr->timeout)
1257                                 q_ptr->timeout = o_ptr->timeout;
1258                         else
1259                                 q_ptr->timeout = q_ptr->pval;
1260
1261                         if (amt < o_ptr->number) o_ptr->timeout -= q_ptr->timeout;
1262                 }
1263         }
1264 }
1265
1266
1267 /*!
1268  * @brief 魔法棒やロッドの使用回数を減らす /
1269  * @param o_ptr オブジェクトの構造体参照ポインタ source item
1270  * @param amt 減らしたい回数量 number of items that are transfered
1271  * @return なし
1272  * @details
1273  * Hack -- If rods or wand are destroyed, the total maximum timeout or\n
1274  * charges of the stack needs to be reduced, unless all the items are\n
1275  * being destroyed. -LM-\n
1276  */
1277 void reduce_charges(object_type *o_ptr, int amt)
1278 {
1279         if (((o_ptr->tval == TV_WAND) || (o_ptr->tval == TV_ROD)) &&
1280                 (amt < o_ptr->number))
1281         {
1282                 o_ptr->pval -= o_ptr->pval * amt / o_ptr->number;
1283         }
1284 }
1285
1286
1287 /*!
1288  * @brief 両オブジェクトをスロットに重ね合わせ可能な最大数を返す。
1289  * Determine if an item can partly absorb a second item. Return maximum number of stack.
1290  * @param o_ptr 検証したいオブジェクトの構造体参照ポインタ1
1291  * @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
1292  * @return 重ね合わせ可能なアイテム数
1293  */
1294 int object_similar_part(object_type *o_ptr, object_type *j_ptr)
1295 {
1296         int i;
1297
1298         /* Default maximum number of stack */
1299         int max_num = MAX_STACK_SIZE;
1300
1301         /* Require identical object types */
1302         if (o_ptr->k_idx != j_ptr->k_idx) return 0;
1303
1304
1305         /* Analyze the items */
1306         switch (o_ptr->tval)
1307         {
1308                 /* Chests and Statues*/
1309         case TV_CHEST:
1310         case TV_CARD:
1311         case TV_CAPTURE:
1312         {
1313                 /* Never okay */
1314                 return 0;
1315         }
1316
1317         case TV_STATUE:
1318         {
1319                 if ((o_ptr->sval != SV_PHOTO) || (j_ptr->sval != SV_PHOTO)) return 0;
1320                 if (o_ptr->pval != j_ptr->pval) return 0;
1321                 break;
1322         }
1323
1324         /* Figurines and Corpses*/
1325         case TV_FIGURINE:
1326         case TV_CORPSE:
1327         {
1328                 /* Same monster */
1329                 if (o_ptr->pval != j_ptr->pval) return 0;
1330
1331                 /* Assume okay */
1332                 break;
1333         }
1334
1335         /* Food and Potions and Scrolls */
1336         case TV_FOOD:
1337         case TV_POTION:
1338         case TV_SCROLL:
1339         {
1340                 /* Assume okay */
1341                 break;
1342         }
1343
1344         /* Staffs */
1345         case TV_STAFF:
1346         {
1347                 /* Require either knowledge or known empty for both staffs. */
1348                 if ((!(o_ptr->ident & (IDENT_EMPTY)) &&
1349                         !object_is_known(o_ptr)) ||
1350                         (!(j_ptr->ident & (IDENT_EMPTY)) &&
1351                                 !object_is_known(j_ptr))) return 0;
1352
1353                 /* Require identical charges, since staffs are bulky. */
1354                 if (o_ptr->pval != j_ptr->pval) return 0;
1355
1356                 /* Assume okay */
1357                 break;
1358         }
1359
1360         /* Wands */
1361         case TV_WAND:
1362         {
1363                 /* Require either knowledge or known empty for both wands. */
1364                 if ((!(o_ptr->ident & (IDENT_EMPTY)) &&
1365                         !object_is_known(o_ptr)) ||
1366                         (!(j_ptr->ident & (IDENT_EMPTY)) &&
1367                                 !object_is_known(j_ptr))) return 0;
1368
1369                 /* Wand charges combine in O&ZAngband.  */
1370
1371                 /* Assume okay */
1372                 break;
1373         }
1374
1375         /* Staffs and Wands and Rods */
1376         case TV_ROD:
1377         {
1378                 /* Prevent overflaw of timeout */
1379                 max_num = MIN(max_num, MAX_SHORT / k_info[o_ptr->k_idx].pval);
1380
1381                 /* Assume okay */
1382                 break;
1383         }
1384
1385         /* Weapons and Armor */
1386         case TV_BOW:
1387         case TV_DIGGING:
1388         case TV_HAFTED:
1389         case TV_POLEARM:
1390         case TV_SWORD:
1391         case TV_BOOTS:
1392         case TV_GLOVES:
1393         case TV_HELM:
1394         case TV_CROWN:
1395         case TV_SHIELD:
1396         case TV_CLOAK:
1397         case TV_SOFT_ARMOR:
1398         case TV_HARD_ARMOR:
1399         case TV_DRAG_ARMOR:
1400
1401                 /* Rings, Amulets, Lites */
1402         case TV_RING:
1403         case TV_AMULET:
1404         case TV_LITE:
1405         case TV_WHISTLE:
1406         {
1407                 /* Require full knowledge of both items */
1408                 if (!object_is_known(o_ptr) || !object_is_known(j_ptr)) return 0;
1409
1410                 /* Fall through */
1411         }
1412
1413         /* Missiles */
1414         case TV_BOLT:
1415         case TV_ARROW:
1416         case TV_SHOT:
1417         {
1418                 /* Require identical knowledge of both items */
1419                 if (object_is_known(o_ptr) != object_is_known(j_ptr)) return 0;
1420                 if (o_ptr->feeling != j_ptr->feeling) return 0;
1421
1422                 /* Require identical "bonuses" */
1423                 if (o_ptr->to_h != j_ptr->to_h) return 0;
1424                 if (o_ptr->to_d != j_ptr->to_d) return 0;
1425                 if (o_ptr->to_a != j_ptr->to_a) return 0;
1426
1427                 /* Require identical "pval" code */
1428                 if (o_ptr->pval != j_ptr->pval) return 0;
1429
1430                 /* Artifacts never stack */
1431                 if (object_is_artifact(o_ptr) || object_is_artifact(j_ptr)) return 0;
1432
1433                 /* Require identical "ego-item" names */
1434                 if (o_ptr->name2 != j_ptr->name2) return 0;
1435
1436                 /* Require identical added essence  */
1437                 if (o_ptr->xtra3 != j_ptr->xtra3) return 0;
1438                 if (o_ptr->xtra4 != j_ptr->xtra4) return 0;
1439
1440                 /* Hack -- Never stack "powerful" items */
1441                 if (o_ptr->xtra1 || j_ptr->xtra1) return 0;
1442
1443                 /* Hack -- Never stack recharging items */
1444                 if (o_ptr->timeout || j_ptr->timeout) return 0;
1445
1446                 /* Require identical "values" */
1447                 if (o_ptr->ac != j_ptr->ac) return 0;
1448                 if (o_ptr->dd != j_ptr->dd) return 0;
1449                 if (o_ptr->ds != j_ptr->ds) return 0;
1450
1451                 /* Probably okay */
1452                 break;
1453         }
1454
1455         /* Various */
1456         default:
1457         {
1458                 /* Require knowledge */
1459                 if (!object_is_known(o_ptr) || !object_is_known(j_ptr)) return 0;
1460
1461                 /* Probably okay */
1462                 break;
1463         }
1464         }
1465
1466
1467         /* Hack -- Identical art_flags! */
1468         for (i = 0; i < TR_FLAG_SIZE; i++)
1469                 if (o_ptr->art_flags[i] != j_ptr->art_flags[i]) return 0;
1470
1471         /* Hack -- Require identical "cursed" status */
1472         if (o_ptr->curse_flags != j_ptr->curse_flags) return 0;
1473
1474         /* Hack -- Require identical "broken" status */
1475         if ((o_ptr->ident & (IDENT_BROKEN)) != (j_ptr->ident & (IDENT_BROKEN))) return 0;
1476
1477
1478         /* Hack -- require semi-matching "inscriptions" */
1479         if (o_ptr->inscription && j_ptr->inscription &&
1480                 (o_ptr->inscription != j_ptr->inscription))
1481                 return 0;
1482
1483         /* Hack -- normally require matching "inscriptions" */
1484         if (!stack_force_notes && (o_ptr->inscription != j_ptr->inscription)) return 0;
1485
1486         /* Hack -- normally require matching "discounts" */
1487         if (!stack_force_costs && (o_ptr->discount != j_ptr->discount)) return 0;
1488
1489
1490         /* They match, so they must be similar */
1491         return max_num;
1492 }
1493
1494
1495 /*!
1496  * @brief 両オブジェクトをスロットに重ねることができるかどうかを返す。
1497  * Determine if an item can absorb a second item.
1498  * @param o_ptr 検証したいオブジェクトの構造体参照ポインタ1
1499  * @param j_ptr 検証したいオブジェクトの構造体参照ポインタ2
1500  * @return 重ね合わせ可能ならばTRUEを返す。
1501  */
1502 bool object_similar(object_type *o_ptr, object_type *j_ptr)
1503 {
1504         int total = o_ptr->number + j_ptr->number;
1505         int max_num;
1506
1507         /* Are these objects similar? */
1508         max_num = object_similar_part(o_ptr, j_ptr);
1509
1510         /* Return if not similar */
1511         if (!max_num) return FALSE;
1512
1513         /* Maximal "stacking" limit */
1514         if (total > max_num) return (0);
1515
1516
1517         /* They match, so they must be similar */
1518         return TRUE;
1519 }
1520
1521
1522 /*!
1523  * @brief 両オブジェクトをスロットに重ね合わせる。
1524  * Allow one item to "absorb" another, assuming they are similar
1525  * @param o_ptr 重ね合わせ先のオブジェクトの構造体参照ポインタ
1526  * @param j_ptr 重ね合わせ元のオブジェクトの構造体参照ポインタ
1527  * @return なし
1528  */
1529 void object_absorb(object_type *o_ptr, object_type *j_ptr)
1530 {
1531         int max_num = object_similar_part(o_ptr, j_ptr);
1532         int total = o_ptr->number + j_ptr->number;
1533         int diff = (total > max_num) ? total - max_num : 0;
1534
1535         /* Combine quantity, lose excess items */
1536         o_ptr->number = (total > max_num) ? max_num : total;
1537
1538         /* Hack -- blend "known" status */
1539         if (object_is_known(j_ptr)) object_known(o_ptr);
1540
1541         /* Hack -- clear "storebought" if only one has it */
1542         if (((o_ptr->ident & IDENT_STORE) || (j_ptr->ident & IDENT_STORE)) &&
1543                 (!((o_ptr->ident & IDENT_STORE) && (j_ptr->ident & IDENT_STORE))))
1544         {
1545                 if (j_ptr->ident & IDENT_STORE) j_ptr->ident &= 0xEF;
1546                 if (o_ptr->ident & IDENT_STORE) o_ptr->ident &= 0xEF;
1547         }
1548
1549         /* Hack -- blend "mental" status */
1550         if (j_ptr->ident & (IDENT_MENTAL)) o_ptr->ident |= (IDENT_MENTAL);
1551
1552         /* Hack -- blend "inscriptions" */
1553         if (j_ptr->inscription) o_ptr->inscription = j_ptr->inscription;
1554
1555         /* Hack -- blend "feelings" */
1556         if (j_ptr->feeling) o_ptr->feeling = j_ptr->feeling;
1557
1558         /* Hack -- could average discounts */
1559         /* Hack -- save largest discount */
1560         if (o_ptr->discount < j_ptr->discount) o_ptr->discount = j_ptr->discount;
1561
1562         /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
1563         if (o_ptr->tval == TV_ROD)
1564         {
1565                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
1566                 o_ptr->timeout += j_ptr->timeout * (j_ptr->number - diff) / j_ptr->number;
1567         }
1568
1569         /* Hack -- if wands are stacking, combine the charges. -LM- */
1570         if (o_ptr->tval == TV_WAND)
1571         {
1572                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
1573         }
1574 }
1575
1576
1577 /*!
1578  * @brief tvalとsvalに対応するベースアイテムのIDを返す。
1579  * Find the index of the object_kind with the given tval and sval
1580  * @param tval 検索したいベースアイテムのtval
1581  * @param sval 検索したいベースアイテムのsval
1582  * @return なし
1583  */
1584 KIND_OBJECT_IDX lookup_kind(OBJECT_TYPE_VALUE tval, OBJECT_SUBTYPE_VALUE sval)
1585 {
1586         KIND_OBJECT_IDX k;
1587         int num = 0;
1588         KIND_OBJECT_IDX bk = 0;
1589
1590         /* Look for it */
1591         for (k = 1; k < max_k_idx; k++)
1592         {
1593                 object_kind *k_ptr = &k_info[k];
1594
1595                 /* Require correct tval */
1596                 if (k_ptr->tval != tval) continue;
1597
1598                 /* Found a match */
1599                 if (k_ptr->sval == sval) return (k);
1600
1601                 /* Ignore illegal items */
1602                 if (sval != SV_ANY) continue;
1603
1604                 /* Apply the randomizer */
1605                 if (!one_in_(++num)) continue;
1606
1607                 /* Use this value */
1608                 bk = k;
1609         }
1610
1611         /* Return this choice */
1612         if (sval == SV_ANY)
1613         {
1614                 return bk;
1615         }
1616
1617 #if 0
1618         msg_format(_("アイテムがない (%d,%d)", "No object (%d,%d)"), tval, sval);
1619 #endif
1620
1621
1622         return (0);
1623 }
1624
1625
1626 /*!
1627  * @brief オブジェクトを初期化する
1628  * Wipe an object clean.
1629  * @param o_ptr 初期化したいオブジェクトの構造体参照ポインタ
1630  * @return なし
1631  */
1632 void object_wipe(object_type *o_ptr)
1633 {
1634         /* Wipe the structure */
1635         (void)WIPE(o_ptr, object_type);
1636 }
1637
1638
1639 /*!
1640  * @brief オブジェクトを複製する
1641  * Wipe an object clean.
1642  * @param o_ptr 複製元のオブジェクトの構造体参照ポインタ
1643  * @param j_ptr 複製先のオブジェクトの構造体参照ポインタ
1644  * @return なし
1645  */
1646 void object_copy(object_type *o_ptr, object_type *j_ptr)
1647 {
1648         /* Copy the structure */
1649         (void)COPY(o_ptr, j_ptr, object_type);
1650 }
1651
1652
1653 /*!
1654  * @brief オブジェクト構造体にベースアイテムを作成する
1655  * Prepare an object based on an object kind.
1656  * @param o_ptr 代入したいオブジェクトの構造体参照ポインタ
1657  * @param k_idx 新たに作成したいベースアイテム情報のID
1658  * @return なし
1659  */
1660 void object_prep(object_type *o_ptr, KIND_OBJECT_IDX k_idx)
1661 {
1662         object_kind *k_ptr = &k_info[k_idx];
1663
1664         /* Clear the record */
1665         object_wipe(o_ptr);
1666
1667         /* Save the kind index */
1668         o_ptr->k_idx = k_idx;
1669
1670         /* Efficiency -- tval/sval */
1671         o_ptr->tval = k_ptr->tval;
1672         o_ptr->sval = k_ptr->sval;
1673
1674         /* Default "pval" */
1675         o_ptr->pval = k_ptr->pval;
1676
1677         /* Default number */
1678         o_ptr->number = 1;
1679
1680         /* Default weight */
1681         o_ptr->weight = k_ptr->weight;
1682
1683         /* Default magic */
1684         o_ptr->to_h = k_ptr->to_h;
1685         o_ptr->to_d = k_ptr->to_d;
1686         o_ptr->to_a = k_ptr->to_a;
1687
1688         /* Default power */
1689         o_ptr->ac = k_ptr->ac;
1690         o_ptr->dd = k_ptr->dd;
1691         o_ptr->ds = k_ptr->ds;
1692
1693         /* Default activation */
1694         if (k_ptr->act_idx > 0) o_ptr->xtra2 = (XTRA8)k_ptr->act_idx;
1695
1696         /* Hack -- worthless items are always "broken" */
1697         if (k_info[o_ptr->k_idx].cost <= 0) o_ptr->ident |= (IDENT_BROKEN);
1698
1699         /* Hack -- cursed items are always "cursed" */
1700         if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
1701         if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
1702         if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
1703         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
1704         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
1705         if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
1706 }
1707
1708
1709 /*!
1710  * @brief デバッグ時にアイテム生成情報をメッセージに出力する / Cheat -- describe a created object for the user
1711  * @param owner_ptr プレーヤーへの参照ポインタ
1712  * @param o_ptr デバッグ出力するオブジェクトの構造体参照ポインタ
1713  * @return なし
1714  */
1715 static void object_mention(player_type *owner_ptr, object_type *o_ptr)
1716 {
1717         GAME_TEXT o_name[MAX_NLEN];
1718
1719         object_aware(owner_ptr, o_ptr);
1720         object_known(o_ptr);
1721
1722         /* Mark the item as fully known */
1723         o_ptr->ident |= (IDENT_MENTAL);
1724         object_desc(o_name, o_ptr, 0);
1725         msg_format_wizard(CHEAT_OBJECT, _("%sを生成しました。", "%s was generated."), o_name);
1726 }
1727
1728
1729 /*!
1730  * @brief アイテムのエゴをレア度の重みに合わせてランダムに選択する
1731  * Choose random ego type
1732  * @param slot 取得したいエゴの装備部位
1733  * @param good TRUEならば通常のエゴ、FALSEならば呪いのエゴが選択対象となる。
1734  * @return 選択されたエゴ情報のID、万一選択できなかった場合はmax_e_idxが返る。
1735  */
1736 static byte get_random_ego(byte slot, bool good)
1737 {
1738         int i, value;
1739         ego_item_type *e_ptr;
1740
1741         long total = 0L;
1742
1743         for (i = 1; i < max_e_idx; i++)
1744         {
1745                 e_ptr = &e_info[i];
1746
1747                 if (e_ptr->slot == slot
1748                         && ((good && e_ptr->rating) || (!good && !e_ptr->rating)))
1749                 {
1750                         if (e_ptr->rarity)
1751                                 total += (255 / e_ptr->rarity);
1752                 }
1753         }
1754
1755         value = randint1(total);
1756
1757         for (i = 1; i < max_e_idx; i++)
1758         {
1759                 e_ptr = &e_info[i];
1760
1761                 if (e_ptr->slot == slot
1762                         && ((good && e_ptr->rating) || (!good && !e_ptr->rating)))
1763                 {
1764                         if (e_ptr->rarity)
1765                                 value -= (255 / e_ptr->rarity);
1766                         if (value <= 0L) break;
1767                 }
1768         }
1769         return (byte)i;
1770 }
1771
1772
1773 /*!
1774  * @brief 武器系オブジェクトに生成ランクごとの強化を与えるサブルーチン
1775  * Apply magic to an item known to be a "weapon"
1776  * @param owner_ptr プレーヤーへの参照ポインタ
1777  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
1778  * @param level 生成基準階
1779  * @param power 生成ランク
1780  * @return なし
1781  * @details
1782  * Hack -- note special base damage dice boosting\n
1783  * Hack -- note special processing for weapon/digger\n
1784  */
1785 void apply_magic_weapon(player_type *owner_ptr, object_type *o_ptr, DEPTH level, int power)
1786 {
1787         HIT_PROB tohit1 = randint1(5) + (HIT_PROB)m_bonus(5, level);
1788         HIT_POINT todam1 = randint1(5) + (HIT_POINT)m_bonus(5, level);
1789
1790         HIT_PROB tohit2 = (HIT_PROB)m_bonus(10, level);
1791         HIT_POINT todam2 = (HIT_POINT)m_bonus(10, level);
1792
1793         if ((o_ptr->tval == TV_BOLT) || (o_ptr->tval == TV_ARROW) || (o_ptr->tval == TV_SHOT))
1794         {
1795                 tohit2 = (tohit2 + 1) / 2;
1796                 todam2 = (todam2 + 1) / 2;
1797         }
1798
1799         /* Good */
1800         if (power > 0)
1801         {
1802                 /* Enchant */
1803                 o_ptr->to_h += tohit1;
1804                 o_ptr->to_d += todam1;
1805
1806                 /* Very good */
1807                 if (power > 1)
1808                 {
1809                         /* Enchant again */
1810                         o_ptr->to_h += tohit2;
1811                         o_ptr->to_d += todam2;
1812                 }
1813         }
1814
1815         /* Cursed */
1816         else if (power < 0)
1817         {
1818                 /* Penalize */
1819                 o_ptr->to_h -= tohit1;
1820                 o_ptr->to_d -= todam1;
1821
1822                 /* Very cursed */
1823                 if (power < -1)
1824                 {
1825                         /* Penalize again */
1826                         o_ptr->to_h -= tohit2;
1827                         o_ptr->to_d -= todam2;
1828                 }
1829
1830                 /* Cursed (if "bad") */
1831                 if (o_ptr->to_h + o_ptr->to_d < 0) o_ptr->curse_flags |= TRC_CURSED;
1832         }
1833
1834         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_DIAMOND_EDGE)) return;
1835
1836         switch (o_ptr->tval)
1837         {
1838         case TV_DIGGING:
1839         {
1840                 /* Very good */
1841                 if (power > 1)
1842                 {
1843                         if (one_in_(30) || (power > 2)) /* power > 2 is debug only */
1844                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
1845                         else
1846                                 /* Special Ego-item */
1847                                 o_ptr->name2 = EGO_DIGGING;
1848                 }
1849
1850                 /* Very bad */
1851                 else if (power < -1)
1852                 {
1853                         /* Hack -- Horrible digging bonus */
1854                         o_ptr->pval = 0 - (5 + randint1(5));
1855                 }
1856
1857                 /* Bad */
1858                 else if (power < 0)
1859                 {
1860                         /* Hack -- Reverse digging bonus */
1861                         o_ptr->pval = 0 - (o_ptr->pval);
1862                 }
1863
1864                 break;
1865         }
1866
1867         case TV_HAFTED:
1868         case TV_POLEARM:
1869         case TV_SWORD:
1870         {
1871                 /* Very Good */
1872                 if (power > 1)
1873                 {
1874                         if (one_in_(40) || (power > 2)) /* power > 2 is debug only */
1875                         {
1876                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
1877                                 break;
1878                         }
1879                         while (1)
1880                         {
1881                                 /* Roll for an ego-item */
1882                                 o_ptr->name2 = get_random_ego(INVEN_RARM, TRUE);
1883                                 if (o_ptr->name2 == EGO_SHARPNESS && o_ptr->tval != TV_SWORD)
1884                                         continue;
1885                                 if (o_ptr->name2 == EGO_EARTHQUAKES && o_ptr->tval != TV_HAFTED)
1886                                         continue;
1887                                 if (o_ptr->name2 == EGO_WEIRD && o_ptr->tval != TV_SWORD)
1888                                         continue;
1889                                 break;
1890                         }
1891
1892                         switch (o_ptr->name2)
1893                         {
1894                         case EGO_HA:
1895                                 if (one_in_(4) && (level > 40))
1896                                         add_flag(o_ptr->art_flags, TR_BLOWS);
1897                                 break;
1898                         case EGO_DF:
1899                                 if (one_in_(3))
1900                                         add_flag(o_ptr->art_flags, TR_RES_POIS);
1901                                 if (one_in_(3))
1902                                         add_flag(o_ptr->art_flags, TR_WARNING);
1903                                 break;
1904                         case EGO_KILL_DRAGON:
1905                                 if (one_in_(3))
1906                                         add_flag(o_ptr->art_flags, TR_RES_POIS);
1907                                 break;
1908                         case EGO_WEST:
1909                                 if (one_in_(3))
1910                                         add_flag(o_ptr->art_flags, TR_RES_FEAR);
1911                                 break;
1912                         case EGO_SLAYING_WEAPON:
1913                                 if (one_in_(3)) /* double damage */
1914                                         o_ptr->dd *= 2;
1915                                 else
1916                                 {
1917                                         do
1918                                         {
1919                                                 o_ptr->dd++;
1920                                         } while (one_in_(o_ptr->dd));
1921
1922                                         do
1923                                         {
1924                                                 o_ptr->ds++;
1925                                         } while (one_in_(o_ptr->ds));
1926                                 }
1927
1928                                 if (one_in_(5))
1929                                 {
1930                                         add_flag(o_ptr->art_flags, TR_BRAND_POIS);
1931                                 }
1932                                 if (o_ptr->tval == TV_SWORD && one_in_(3))
1933                                 {
1934                                         add_flag(o_ptr->art_flags, TR_VORPAL);
1935                                 }
1936                                 break;
1937                         case EGO_TRUMP:
1938                                 if (one_in_(5))
1939                                         add_flag(o_ptr->art_flags, TR_SLAY_DEMON);
1940                                 if (one_in_(7))
1941                                         one_ability(o_ptr);
1942                                 break;
1943                         case EGO_PATTERN:
1944                                 if (one_in_(3))
1945                                         add_flag(o_ptr->art_flags, TR_HOLD_EXP);
1946                                 if (one_in_(3))
1947                                         add_flag(o_ptr->art_flags, TR_DEX);
1948                                 if (one_in_(5))
1949                                         add_flag(o_ptr->art_flags, TR_RES_FEAR);
1950                                 break;
1951                         case EGO_SHARPNESS:
1952                                 o_ptr->pval = (PARAMETER_VALUE)m_bonus(5, level) + 1;
1953                                 break;
1954                         case EGO_EARTHQUAKES:
1955                                 if (one_in_(3) && (level > 60))
1956                                         add_flag(o_ptr->art_flags, TR_BLOWS);
1957                                 else
1958                                         o_ptr->pval = (PARAMETER_VALUE)m_bonus(3, level);
1959                                 break;
1960                         case EGO_VAMPIRIC:
1961                                 if (one_in_(5))
1962                                         add_flag(o_ptr->art_flags, TR_SLAY_HUMAN);
1963                                 break;
1964                         case EGO_DEMON:
1965
1966                                 if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
1967                                 one_in_(3) ?
1968                                         add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
1969                                         one_in_(2) ?
1970                                         add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
1971                                         add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
1972
1973
1974                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_CHAOTIC);
1975                                 if (one_in_(4)) add_flag(o_ptr->art_flags, TR_BLOWS);
1976                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
1977                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
1978                                 break;
1979                         }
1980
1981                         if (!o_ptr->art_name)
1982                         {
1983                                 /* Hack -- Super-charge the damage dice */
1984                                 while (one_in_(10L * o_ptr->dd * o_ptr->ds)) o_ptr->dd++;
1985
1986                                 /* Hack -- Lower the damage dice */
1987                                 if (o_ptr->dd > 9) o_ptr->dd = 9;
1988                         }
1989                 }
1990
1991                 /* Very cursed */
1992                 else if (power < -1)
1993                 {
1994                         /* Roll for ego-item */
1995                         if (randint0(MAX_DEPTH) < level)
1996                         {
1997                                 while (1)
1998                                 {
1999                                         o_ptr->name2 = get_random_ego(INVEN_RARM, FALSE);
2000                                         if (o_ptr->name2 == EGO_WEIRD && o_ptr->tval != TV_SWORD)
2001                                         {
2002                                                 continue;
2003                                         }
2004                                         break;
2005                                 }
2006                                 switch (o_ptr->name2)
2007                                 {
2008                                 case EGO_MORGUL:
2009                                         if (one_in_(6)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2010                                         if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2011                                         break;
2012                                 case EGO_WEIRD:
2013                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_BRAND_POIS);
2014                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_NETHER);
2015                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2016                                         if (one_in_(6)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2017                                         if (one_in_(6)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2018                                         if (one_in_(6)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2019                                         break;
2020                                 }
2021                         }
2022                 }
2023
2024                 break;
2025         }
2026
2027
2028         case TV_BOW:
2029         {
2030                 /* Very good */
2031                 if (power > 1)
2032                 {
2033                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2034                         {
2035                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2036                                 break;
2037                         }
2038                         o_ptr->name2 = get_random_ego(INVEN_BOW, TRUE);
2039                 }
2040
2041                 break;
2042         }
2043
2044
2045         case TV_BOLT:
2046         case TV_ARROW:
2047         case TV_SHOT:
2048         {
2049                 /* Very good */
2050                 if (power > 1)
2051                 {
2052                         if (power > 2) /* power > 2 is debug only */
2053                         {
2054                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2055                                 break;
2056                         }
2057
2058                         o_ptr->name2 = get_random_ego(INVEN_AMMO, TRUE);
2059
2060                         switch (o_ptr->name2)
2061                         {
2062                         case EGO_SLAYING_BOLT:
2063                                 o_ptr->dd++;
2064                                 break;
2065                         }
2066
2067                         /* Hack -- super-charge the damage dice */
2068                         while (one_in_(10L * o_ptr->dd * o_ptr->ds)) o_ptr->dd++;
2069
2070                         /* Hack -- restrict the damage dice */
2071                         if (o_ptr->dd > 9) o_ptr->dd = 9;
2072                 }
2073
2074                 /* Very cursed */
2075                 else if (power < -1)
2076                 {
2077                         /* Roll for ego-item */
2078                         if (randint0(MAX_DEPTH) < level)
2079                         {
2080                                 o_ptr->name2 = get_random_ego(INVEN_AMMO, FALSE);
2081                         }
2082                 }
2083
2084                 break;
2085         }
2086         }
2087 }
2088
2089
2090 /*!
2091  * @brief 防具系オブジェクトに生成ランクごとの強化を与えるサブルーチン
2092  * Apply magic to an item known to be "armor"
2093  * @param owner_ptr プレーヤーへの参照ポインタ
2094  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2095  * @param level 生成基準階
2096  * @param power 生成ランク
2097  * @return なし
2098  * @details
2099  * Hack -- note special processing for crown/helm\n
2100  * Hack -- note special processing for robe of permanence\n
2101  */
2102 static void a_m_aux_2(player_type *owner_ptr, object_type *o_ptr, DEPTH level, int power)
2103 {
2104         ARMOUR_CLASS toac1 = (ARMOUR_CLASS)randint1(5) + m_bonus(5, level);
2105         ARMOUR_CLASS toac2 = (ARMOUR_CLASS)m_bonus(10, level);
2106
2107         /* Good */
2108         if (power > 0)
2109         {
2110                 /* Enchant */
2111                 o_ptr->to_a += toac1;
2112
2113                 /* Very good */
2114                 if (power > 1)
2115                 {
2116                         /* Enchant again */
2117                         o_ptr->to_a += toac2;
2118                 }
2119         }
2120
2121         /* Cursed */
2122         else if (power < 0)
2123         {
2124                 /* Penalize */
2125                 o_ptr->to_a -= toac1;
2126
2127                 /* Very cursed */
2128                 if (power < -1)
2129                 {
2130                         /* Penalize again */
2131                         o_ptr->to_a -= toac2;
2132                 }
2133
2134                 /* Cursed (if "bad") */
2135                 if (o_ptr->to_a < 0) o_ptr->curse_flags |= TRC_CURSED;
2136         }
2137
2138         switch (o_ptr->tval)
2139         {
2140         case TV_DRAG_ARMOR:
2141         {
2142                 if (one_in_(50) || (power > 2)) /* power > 2 is debug only */
2143                         become_random_artifact(owner_ptr, o_ptr, FALSE);
2144                 break;
2145         }
2146
2147         case TV_HARD_ARMOR:
2148         case TV_SOFT_ARMOR:
2149         {
2150                 /* Very good */
2151                 if (power > 1)
2152                 {
2153                         /* Hack -- Try for "Robes of the Magi" */
2154                         if ((o_ptr->tval == TV_SOFT_ARMOR) &&
2155                                 (o_ptr->sval == SV_ROBE) &&
2156                                 (randint0(100) < 15))
2157                         {
2158                                 if (one_in_(5))
2159                                 {
2160                                         o_ptr->name2 = EGO_YOIYAMI;
2161                                         o_ptr->k_idx = lookup_kind(TV_SOFT_ARMOR, SV_YOIYAMI_ROBE);
2162                                         o_ptr->sval = SV_YOIYAMI_ROBE;
2163                                         o_ptr->ac = 0;
2164                                         o_ptr->to_a = 0;
2165                                 }
2166                                 else
2167                                 {
2168                                         o_ptr->name2 = EGO_PERMANENCE;
2169                                 }
2170                                 break;
2171                         }
2172
2173                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2174                         {
2175                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2176                                 break;
2177                         }
2178
2179                         while (1)
2180                         {
2181                                 bool okay_flag = TRUE;
2182
2183                                 o_ptr->name2 = get_random_ego(INVEN_BODY, TRUE);
2184
2185                                 switch (o_ptr->name2)
2186                                 {
2187                                 case EGO_DWARVEN:
2188                                         if (o_ptr->tval != TV_HARD_ARMOR)
2189                                         {
2190                                                 okay_flag = FALSE;
2191                                         }
2192                                         break;
2193                                 case EGO_DRUID:
2194                                         if (o_ptr->tval != TV_SOFT_ARMOR)
2195                                         {
2196                                                 okay_flag = FALSE;
2197                                         }
2198                                         break;
2199                                 default:
2200                                         break;
2201                                 }
2202
2203                                 if (okay_flag) break;
2204                         }
2205                         switch (o_ptr->name2)
2206                         {
2207                         case EGO_RESISTANCE:
2208                                 if (one_in_(4))
2209                                         add_flag(o_ptr->art_flags, TR_RES_POIS);
2210                                 break;
2211                         case EGO_DWARVEN:
2212                                 o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2213                                 o_ptr->ac = k_info[o_ptr->k_idx].ac + 5;
2214                                 break;
2215
2216                         case EGO_A_DEMON:
2217                                 if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2218                                 one_in_(3) ?
2219                                         add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
2220                                         one_in_(2) ?
2221                                         add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
2222                                         add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2223
2224                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2225                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
2226                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2227                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2228                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2229                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2230                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2231                                 if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
2232                                 break;
2233                         case EGO_A_MORGUL:
2234                                 if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2235                                 if (one_in_(9)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2236                                 if (one_in_(4)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2237                                 if (one_in_(6)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2238                                 if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2239                                 if (one_in_(9)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2240                                 break;
2241                         default:
2242                                 break;
2243                         }
2244                 }
2245
2246                 break;
2247         }
2248
2249         case TV_SHIELD:
2250         {
2251
2252                 if (o_ptr->sval == SV_DRAGON_SHIELD)
2253                 {
2254                         dragon_resist(o_ptr);
2255                         if (!one_in_(3)) break;
2256                 }
2257
2258                 /* Very good */
2259                 if (power > 1)
2260                 {
2261                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2262                         {
2263                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2264                                 break;
2265                         }
2266
2267                         while (1)
2268                         {
2269                                 o_ptr->name2 = get_random_ego(INVEN_LARM, TRUE);
2270                                 if (o_ptr->sval != SV_SMALL_METAL_SHIELD && o_ptr->sval != SV_LARGE_METAL_SHIELD
2271                                         && o_ptr->name2 == EGO_S_DWARVEN)
2272                                 {
2273                                         continue;
2274                                 }
2275                                 break;
2276                         }
2277
2278                         switch (o_ptr->name2)
2279                         {
2280                         case EGO_ENDURANCE:
2281                                 if (!one_in_(3)) one_high_resistance(o_ptr);
2282                                 if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_POIS);
2283                                 break;
2284                         case EGO_REFLECTION:
2285                                 if (o_ptr->sval == SV_MIRROR_SHIELD)
2286                                         o_ptr->name2 = 0;
2287                                 break;
2288
2289                         case EGO_S_DWARVEN:
2290                                 o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2291                                 o_ptr->ac = k_info[o_ptr->k_idx].ac + 3;
2292                                 break;
2293                         }
2294                 }
2295                 break;
2296         }
2297
2298         case TV_GLOVES:
2299         {
2300                 if (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)
2301                 {
2302                         dragon_resist(o_ptr);
2303                         if (!one_in_(3)) break;
2304                 }
2305                 if (power > 1)
2306                 {
2307                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2308                         {
2309                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2310                                 break;
2311                         }
2312                         o_ptr->name2 = get_random_ego(INVEN_HANDS, TRUE);
2313                 }
2314
2315                 /* Very cursed */
2316                 else if (power < -1)
2317                 {
2318                         o_ptr->name2 = get_random_ego(INVEN_HANDS, FALSE);
2319                 }
2320
2321                 break;
2322         }
2323
2324         case TV_BOOTS:
2325         {
2326                 if (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)
2327                 {
2328                         dragon_resist(o_ptr);
2329                         if (!one_in_(3)) break;
2330                 }
2331                 /* Very good */
2332                 if (power > 1)
2333                 {
2334                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2335                         {
2336                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2337                                 break;
2338                         }
2339                         o_ptr->name2 = get_random_ego(INVEN_FEET, TRUE);
2340
2341                         switch (o_ptr->name2)
2342                         {
2343                         case EGO_SLOW_DESCENT:
2344                                 if (one_in_(2))
2345                                 {
2346                                         one_high_resistance(o_ptr);
2347                                 }
2348                                 break;
2349                         }
2350                 }
2351                 /* Very cursed */
2352                 else if (power < -1)
2353                 {
2354                         o_ptr->name2 = get_random_ego(INVEN_FEET, FALSE);
2355                 }
2356
2357                 break;
2358         }
2359
2360         case TV_CROWN:
2361         {
2362                 /* Very good */
2363                 if (power > 1)
2364                 {
2365                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2366                         {
2367                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2368                                 break;
2369                         }
2370                         while (1)
2371                         {
2372                                 bool ok_flag = TRUE;
2373                                 o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
2374
2375                                 switch (o_ptr->name2)
2376                                 {
2377                                 case EGO_TELEPATHY:
2378                                         if (add_esp_strong(o_ptr)) add_esp_weak(o_ptr, TRUE);
2379                                         else add_esp_weak(o_ptr, FALSE);
2380                                         break;
2381                                 case EGO_MAGI:
2382                                 case EGO_MIGHT:
2383                                 case EGO_REGENERATION:
2384                                 case EGO_LORDLINESS:
2385                                 case EGO_BASILISK:
2386                                         break;
2387                                 case EGO_SEEING:
2388                                         if (one_in_(3))
2389                                         {
2390                                                 if (one_in_(2)) add_esp_strong(o_ptr);
2391                                                 else add_esp_weak(o_ptr, FALSE);
2392                                         }
2393                                         break;
2394                                 default:/* not existing crown (wisdom,lite, etc...) */
2395                                         ok_flag = FALSE;
2396                                 }
2397                                 if (ok_flag)
2398                                         break; /* while (1) */
2399                         }
2400                         break;
2401                 }
2402
2403                 /* Very cursed */
2404                 else if (power < -1)
2405                 {
2406                         while (1)
2407                         {
2408                                 bool ok_flag = TRUE;
2409                                 o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
2410
2411                                 switch (o_ptr->name2)
2412                                 {
2413                                 case EGO_ANCIENT_CURSE:
2414                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_MAGIC);
2415                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_NO_TELE);
2416                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2417                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2418                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2419                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2420                                         break;
2421                                 }
2422                                 if (ok_flag)
2423                                         break; /* while (1) */
2424                         }
2425                 }
2426
2427                 break;
2428         }
2429
2430         case TV_HELM:
2431         {
2432                 if (o_ptr->sval == SV_DRAGON_HELM)
2433                 {
2434                         dragon_resist(o_ptr);
2435                         if (!one_in_(3)) break;
2436                 }
2437
2438                 /* Very good */
2439                 if (power > 1)
2440                 {
2441                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2442                         {
2443                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2444                                 break;
2445                         }
2446                         while (1)
2447                         {
2448                                 bool ok_flag = TRUE;
2449                                 o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
2450
2451                                 switch (o_ptr->name2)
2452                                 {
2453                                 case EGO_BRILLIANCE:
2454                                 case EGO_DARK:
2455                                 case EGO_INFRAVISION:
2456                                 case EGO_H_PROTECTION:
2457                                         break;
2458                                 case EGO_SEEING:
2459                                         if (one_in_(7))
2460                                         {
2461                                                 if (one_in_(2)) add_esp_strong(o_ptr);
2462                                                 else add_esp_weak(o_ptr, FALSE);
2463                                         }
2464                                         break;
2465                                 case EGO_LITE:
2466                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_1);
2467                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_LITE_2);
2468                                         break;
2469                                 case EGO_H_DEMON:
2470                                         if (one_in_(3)) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
2471                                         one_in_(3) ?
2472                                                 add_flag(o_ptr->art_flags, TR_DRAIN_EXP) :
2473                                                 one_in_(2) ?
2474                                                 add_flag(o_ptr->art_flags, TR_DRAIN_HP) :
2475                                                 add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2476
2477                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_AGGRAVATE);
2478                                         if (one_in_(3)) add_flag(o_ptr->art_flags, TR_ADD_L_CURSE);
2479                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_ADD_H_CURSE);
2480                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_HP);
2481                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_MANA);
2482                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2483                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_TY_CURSE);
2484                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_CALL_DEMON);
2485                                         break;
2486                                 default:/* not existing helm (Magi, Might, etc...)*/
2487                                         ok_flag = FALSE;
2488                                 }
2489                                 if (ok_flag)
2490                                         break; /* while (1) */
2491                         }
2492                         break;
2493                 }
2494                 /* Very cursed */
2495                 else if (power < -1)
2496                 {
2497                         while (1)
2498                         {
2499                                 bool ok_flag = TRUE;
2500                                 o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
2501
2502                                 switch (o_ptr->name2)
2503                                 {
2504                                 case EGO_ANCIENT_CURSE:
2505                                         ok_flag = FALSE;
2506                                 }
2507                                 if (ok_flag)
2508                                         break; /* while (1) */
2509                         }
2510                 }
2511                 break;
2512         }
2513
2514         case TV_CLOAK:
2515         {
2516                 /* Very good */
2517                 if (power > 1)
2518                 {
2519                         if (one_in_(20) || (power > 2)) /* power > 2 is debug only */
2520                         {
2521                                 become_random_artifact(owner_ptr, o_ptr, FALSE);
2522                                 break;
2523                         }
2524                         o_ptr->name2 = get_random_ego(INVEN_OUTER, TRUE);
2525
2526                         switch (o_ptr->name2)
2527                         {
2528                         case EGO_BAT:
2529                                 o_ptr->to_d -= 6;
2530                                 o_ptr->to_h -= 6;
2531                                 break;
2532                         case EGO_NAZGUL:
2533                                 o_ptr->to_d -= 3;
2534                                 o_ptr->to_h -= 3;
2535                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_COWARDICE);
2536                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_CALL_UNDEAD);
2537                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_SLOW_REGEN);
2538                                 if (one_in_(3)) add_flag(o_ptr->art_flags, TR_DRAIN_EXP);
2539                                 break;
2540                         }
2541
2542                 }
2543
2544                 /* Very cursed */
2545                 else if (power < -1)
2546                 {
2547                         o_ptr->name2 = get_random_ego(INVEN_OUTER, FALSE);
2548                 }
2549
2550                 break;
2551         }
2552         }
2553 }
2554
2555
2556 /*!
2557  * @brief 装飾品系オブジェクトに生成ランクごとの強化を与えるサブルーチン
2558  * Apply magic to an item known to be a "ring" or "amulet"
2559  * @param owner_ptr プレーヤーへの参照ポインタ
2560  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
2561  * @param level 生成基準階
2562  * @param power 生成ランク
2563  * @return なし
2564  * @details
2565  * Hack -- note special "pval boost" code for ring of speed\n
2566  * Hack -- note that some items must be cursed (or blessed)\n
2567  */
2568 static void a_m_aux_3(player_type *owner_ptr, object_type *o_ptr, DEPTH level, int power)
2569 {
2570         /* Apply magic (good or bad) according to type */
2571         switch (o_ptr->tval)
2572         {
2573         case TV_RING:
2574         {
2575                 /* Analyze */
2576                 switch (o_ptr->sval)
2577                 {
2578                 case SV_RING_ATTACKS:
2579                 {
2580                         /* Stat bonus */
2581                         o_ptr->pval = (PARAMETER_VALUE)m_bonus(2, level);
2582                         if (one_in_(15)) o_ptr->pval++;
2583                         if (o_ptr->pval < 1) o_ptr->pval = 1;
2584
2585                         /* Cursed */
2586                         if (power < 0)
2587                         {
2588                                 /* Broken */
2589                                 o_ptr->ident |= (IDENT_BROKEN);
2590
2591                                 /* Cursed */
2592                                 o_ptr->curse_flags |= TRC_CURSED;
2593
2594                                 /* Reverse pval */
2595                                 o_ptr->pval = 0 - (o_ptr->pval);
2596                         }
2597
2598                         break;
2599                 }
2600
2601                 case SV_RING_SHOTS:
2602                 {
2603                         break;
2604                 }
2605
2606                 /* Strength, Constitution, Dexterity, Intelligence */
2607                 case SV_RING_STR:
2608                 case SV_RING_CON:
2609                 case SV_RING_DEX:
2610                 {
2611                         /* Stat bonus */
2612                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(5, level);
2613
2614                         /* Cursed */
2615                         if (power < 0)
2616                         {
2617                                 /* Broken */
2618                                 o_ptr->ident |= (IDENT_BROKEN);
2619
2620                                 /* Cursed */
2621                                 o_ptr->curse_flags |= TRC_CURSED;
2622
2623                                 /* Reverse pval */
2624                                 o_ptr->pval = 0 - (o_ptr->pval);
2625                         }
2626
2627                         break;
2628                 }
2629
2630                 /* Ring of Speed! */
2631                 case SV_RING_SPEED:
2632                 {
2633                         /* Base speed (1 to 10) */
2634                         o_ptr->pval = randint1(5) + (PARAMETER_VALUE)m_bonus(5, level);
2635
2636                         /* Super-charge the ring */
2637                         while (randint0(100) < 50) o_ptr->pval++;
2638
2639                         /* Cursed Ring */
2640                         if (power < 0)
2641                         {
2642                                 /* Broken */
2643                                 o_ptr->ident |= (IDENT_BROKEN);
2644
2645                                 /* Cursed */
2646                                 o_ptr->curse_flags |= TRC_CURSED;
2647
2648                                 /* Reverse pval */
2649                                 o_ptr->pval = 0 - (o_ptr->pval);
2650
2651                                 break;
2652                         }
2653
2654                         break;
2655                 }
2656
2657                 case SV_RING_LORDLY:
2658                 {
2659                         do
2660                         {
2661                                 one_lordly_high_resistance(o_ptr);
2662                         } while (one_in_(4));
2663
2664                         /* Bonus to armor class */
2665                         o_ptr->to_a = 10 + randint1(5) + (ARMOUR_CLASS)m_bonus(10, level);
2666                 }
2667                 break;
2668
2669                 case SV_RING_WARNING:
2670                 {
2671                         if (one_in_(3)) one_low_esp(o_ptr);
2672                         break;
2673                 }
2674
2675                 /* Searching */
2676                 case SV_RING_SEARCHING:
2677                 {
2678                         /* Bonus to searching */
2679                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(5, level);
2680
2681                         /* Cursed */
2682                         if (power < 0)
2683                         {
2684                                 /* Broken */
2685                                 o_ptr->ident |= (IDENT_BROKEN);
2686
2687                                 /* Cursed */
2688                                 o_ptr->curse_flags |= TRC_CURSED;
2689
2690                                 /* Reverse pval */
2691                                 o_ptr->pval = 0 - (o_ptr->pval);
2692                         }
2693
2694                         break;
2695                 }
2696
2697                 /* Flames, Acid, Ice */
2698                 case SV_RING_FLAMES:
2699                 case SV_RING_ACID:
2700                 case SV_RING_ICE:
2701                 case SV_RING_ELEC:
2702                 {
2703                         /* Bonus to armor class */
2704                         o_ptr->to_a = 5 + randint1(5) + (ARMOUR_CLASS)m_bonus(10, level);
2705                         break;
2706                 }
2707
2708                 /* Weakness, Stupidity */
2709                 case SV_RING_WEAKNESS:
2710                 case SV_RING_STUPIDITY:
2711                 {
2712                         /* Broken */
2713                         o_ptr->ident |= (IDENT_BROKEN);
2714
2715                         /* Cursed */
2716                         o_ptr->curse_flags |= TRC_CURSED;
2717
2718                         /* Penalize */
2719                         o_ptr->pval = 0 - (1 + (PARAMETER_VALUE)m_bonus(5, level));
2720                         if (power > 0) power = 0 - power;
2721
2722                         break;
2723                 }
2724
2725                 /* WOE, Stupidity */
2726                 case SV_RING_WOE:
2727                 {
2728                         /* Broken */
2729                         o_ptr->ident |= (IDENT_BROKEN);
2730
2731                         /* Cursed */
2732                         o_ptr->curse_flags |= TRC_CURSED;
2733
2734                         /* Penalize */
2735                         o_ptr->to_a = 0 - (5 + (ARMOUR_CLASS)m_bonus(10, level));
2736                         o_ptr->pval = 0 - (1 + (PARAMETER_VALUE)m_bonus(5, level));
2737                         if (power > 0) power = 0 - power;
2738
2739                         break;
2740                 }
2741
2742                 /* Ring of damage */
2743                 case SV_RING_DAMAGE:
2744                 {
2745                         /* Bonus to damage */
2746                         o_ptr->to_d = 1 + randint1(5) + (HIT_POINT)m_bonus(16, level);
2747
2748                         /* Cursed */
2749                         if (power < 0)
2750                         {
2751                                 /* Broken */
2752                                 o_ptr->ident |= (IDENT_BROKEN);
2753
2754                                 /* Cursed */
2755                                 o_ptr->curse_flags |= TRC_CURSED;
2756
2757                                 /* Reverse bonus */
2758                                 o_ptr->to_d = 0 - o_ptr->to_d;
2759                         }
2760
2761                         break;
2762                 }
2763
2764                 /* Ring of Accuracy */
2765                 case SV_RING_ACCURACY:
2766                 {
2767                         /* Bonus to hit */
2768                         o_ptr->to_h = 1 + randint1(5) + (HIT_PROB)m_bonus(16, level);
2769
2770                         /* Cursed */
2771                         if (power < 0)
2772                         {
2773                                 /* Broken */
2774                                 o_ptr->ident |= (IDENT_BROKEN);
2775
2776                                 /* Cursed */
2777                                 o_ptr->curse_flags |= TRC_CURSED;
2778
2779                                 /* Reverse tohit */
2780                                 o_ptr->to_h = 0 - o_ptr->to_h;
2781                         }
2782
2783                         break;
2784                 }
2785
2786                 /* Ring of Protection */
2787                 case SV_RING_PROTECTION:
2788                 {
2789                         /* Bonus to armor class */
2790                         o_ptr->to_a = 5 + randint1(8) + (ARMOUR_CLASS)m_bonus(10, level);
2791
2792                         /* Cursed */
2793                         if (power < 0)
2794                         {
2795                                 /* Broken */
2796                                 o_ptr->ident |= (IDENT_BROKEN);
2797
2798                                 /* Cursed */
2799                                 o_ptr->curse_flags |= TRC_CURSED;
2800
2801                                 /* Reverse toac */
2802                                 o_ptr->to_a = 0 - o_ptr->to_a;
2803                         }
2804
2805                         break;
2806                 }
2807
2808                 /* Ring of Slaying */
2809                 case SV_RING_SLAYING:
2810                 {
2811                         /* Bonus to damage and to hit */
2812                         o_ptr->to_d = randint1(5) + (HIT_POINT)m_bonus(12, level);
2813                         o_ptr->to_h = randint1(5) + (HIT_PROB)m_bonus(12, level);
2814
2815                         /* Cursed */
2816                         if (power < 0)
2817                         {
2818                                 /* Broken */
2819                                 o_ptr->ident |= (IDENT_BROKEN);
2820
2821                                 /* Cursed */
2822                                 o_ptr->curse_flags |= TRC_CURSED;
2823
2824                                 /* Reverse bonuses */
2825                                 o_ptr->to_h = 0 - o_ptr->to_h;
2826                                 o_ptr->to_d = 0 - o_ptr->to_d;
2827                         }
2828
2829                         break;
2830                 }
2831
2832                 case SV_RING_MUSCLE:
2833                 {
2834                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(3, level);
2835                         if (one_in_(4)) o_ptr->pval++;
2836
2837                         /* Cursed */
2838                         if (power < 0)
2839                         {
2840                                 /* Broken */
2841                                 o_ptr->ident |= (IDENT_BROKEN);
2842
2843                                 /* Cursed */
2844                                 o_ptr->curse_flags |= TRC_CURSED;
2845
2846                                 /* Reverse bonuses */
2847                                 o_ptr->pval = 0 - o_ptr->pval;
2848                         }
2849
2850                         break;
2851                 }
2852                 case SV_RING_AGGRAVATION:
2853                 {
2854                         /* Broken */
2855                         o_ptr->ident |= (IDENT_BROKEN);
2856
2857                         /* Cursed */
2858                         o_ptr->curse_flags |= TRC_CURSED;
2859
2860                         if (power > 0) power = 0 - power;
2861                         break;
2862                 }
2863                 }
2864                 if ((one_in_(400) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
2865                         || (power > 2)) /* power > 2 is debug only */
2866                 {
2867                         o_ptr->pval = MIN(o_ptr->pval, 4);
2868                         /* Randart amulet */
2869                         become_random_artifact(owner_ptr, o_ptr, FALSE);
2870                 }
2871                 else if ((power == 2) && one_in_(2))
2872                 {
2873                         while (!o_ptr->name2)
2874                         {
2875                                 int tmp = m_bonus(10, level);
2876                                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
2877                                 switch (randint1(28))
2878                                 {
2879                                 case 1: case 2:
2880                                         o_ptr->name2 = EGO_RING_THROW;
2881                                         break;
2882                                 case 3: case 4:
2883                                         if (have_flag(k_ptr->flags, TR_REGEN)) break;
2884                                         o_ptr->name2 = EGO_RING_REGEN;
2885                                         break;
2886                                 case 5: case 6:
2887                                         if (have_flag(k_ptr->flags, TR_LITE_1)) break;
2888                                         o_ptr->name2 = EGO_RING_LITE;
2889                                         break;
2890                                 case 7: case 8:
2891                                         if (have_flag(k_ptr->flags, TR_TELEPORT)) break;
2892                                         o_ptr->name2 = EGO_RING_TELEPORT;
2893                                         break;
2894                                 case 9: case 10:
2895                                         if (o_ptr->to_h) break;
2896                                         o_ptr->name2 = EGO_RING_TO_H;
2897                                         break;
2898                                 case 11: case 12:
2899                                         if (o_ptr->to_d) break;
2900                                         o_ptr->name2 = EGO_RING_TO_D;
2901                                         break;
2902                                 case 13:
2903                                         if ((o_ptr->to_h) || (o_ptr->to_d)) break;
2904                                         o_ptr->name2 = EGO_RING_SLAY;
2905                                         break;
2906                                 case 14:
2907                                         if ((have_flag(k_ptr->flags, TR_STR)) || o_ptr->to_h || o_ptr->to_d) break;
2908                                         o_ptr->name2 = EGO_RING_WIZARD;
2909                                         break;
2910                                 case 15:
2911                                         if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
2912                                         o_ptr->name2 = EGO_RING_HERO;
2913                                         break;
2914                                 case 16:
2915                                         if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
2916                                         if (tmp > 8) o_ptr->name2 = EGO_RING_MANA_BALL;
2917                                         else if (tmp > 4) o_ptr->name2 = EGO_RING_MANA_BOLT;
2918                                         else o_ptr->name2 = EGO_RING_MAGIC_MIS;
2919                                         break;
2920                                 case 17:
2921                                         if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
2922                                         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;
2923                                         if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_F;
2924                                         else if (tmp > 3) o_ptr->name2 = EGO_RING_FIRE_BALL;
2925                                         else o_ptr->name2 = EGO_RING_FIRE_BOLT;
2926                                         break;
2927                                 case 18:
2928                                         if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
2929                                         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;
2930                                         if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_C;
2931                                         else if (tmp > 3) o_ptr->name2 = EGO_RING_COLD_BALL;
2932                                         else o_ptr->name2 = EGO_RING_COLD_BOLT;
2933                                         break;
2934                                 case 19:
2935                                         if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
2936                                         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;
2937                                         if (tmp > 4) o_ptr->name2 = EGO_RING_ELEC_BALL;
2938                                         else o_ptr->name2 = EGO_RING_ELEC_BOLT;
2939                                         break;
2940                                 case 20:
2941                                         if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
2942                                         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;
2943                                         if (tmp > 4) o_ptr->name2 = EGO_RING_ACID_BALL;
2944                                         else o_ptr->name2 = EGO_RING_ACID_BOLT;
2945                                         break;
2946                                 case 21: case 22: case 23: case 24: case 25: case 26:
2947                                         switch (o_ptr->sval)
2948                                         {
2949                                         case SV_RING_SPEED:
2950                                                 if (!one_in_(3)) break;
2951                                                 o_ptr->name2 = EGO_RING_D_SPEED;
2952                                                 break;
2953                                         case SV_RING_DAMAGE:
2954                                         case SV_RING_ACCURACY:
2955                                         case SV_RING_SLAYING:
2956                                                 if (one_in_(2)) break;
2957                                                 if (one_in_(2)) o_ptr->name2 = EGO_RING_HERO;
2958                                                 else
2959                                                 {
2960                                                         o_ptr->name2 = EGO_RING_BERSERKER;
2961                                                         o_ptr->to_h -= 2 + randint1(4);
2962                                                         o_ptr->to_d += 2 + randint1(4);
2963                                                 }
2964                                                 break;
2965                                         case SV_RING_PROTECTION:
2966                                                 o_ptr->name2 = EGO_RING_SUPER_AC;
2967                                                 o_ptr->to_a += 7 + m_bonus(5, level);
2968                                                 break;
2969                                         case SV_RING_RES_FEAR:
2970                                                 o_ptr->name2 = EGO_RING_HERO;
2971                                                 break;
2972                                         case SV_RING_SHOTS:
2973                                                 if (one_in_(2)) break;
2974                                                 o_ptr->name2 = EGO_RING_HUNTER;
2975                                                 break;
2976                                         case SV_RING_SEARCHING:
2977                                                 o_ptr->name2 = EGO_RING_STEALTH;
2978                                                 break;
2979                                         case SV_RING_TELEPORTATION:
2980                                                 o_ptr->name2 = EGO_RING_TELE_AWAY;
2981                                                 break;
2982                                         case SV_RING_RES_BLINDNESS:
2983                                                 if (one_in_(2))
2984                                                         o_ptr->name2 = EGO_RING_RES_LITE;
2985                                                 else
2986                                                         o_ptr->name2 = EGO_RING_RES_DARK;
2987                                                 break;
2988                                         case SV_RING_LORDLY:
2989                                                 if (!one_in_(20)) break;
2990                                                 one_lordly_high_resistance(o_ptr);
2991                                                 one_lordly_high_resistance(o_ptr);
2992                                                 o_ptr->name2 = EGO_RING_TRUE;
2993                                                 break;
2994                                         case SV_RING_SUSTAIN:
2995                                                 if (!one_in_(4)) break;
2996                                                 o_ptr->name2 = EGO_RING_RES_TIME;
2997                                                 break;
2998                                         case SV_RING_FLAMES:
2999                                                 if (!one_in_(2)) break;
3000                                                 o_ptr->name2 = EGO_RING_DRAGON_F;
3001                                                 break;
3002                                         case SV_RING_ICE:
3003                                                 if (!one_in_(2)) break;
3004                                                 o_ptr->name2 = EGO_RING_DRAGON_C;
3005                                                 break;
3006                                         case SV_RING_WARNING:
3007                                                 if (!one_in_(2)) break;
3008                                                 o_ptr->name2 = EGO_RING_M_DETECT;
3009                                                 break;
3010                                         default:
3011                                                 break;
3012                                         }
3013                                         break;
3014                                 }
3015                         }
3016                         o_ptr->curse_flags = 0L;
3017                 }
3018                 else if ((power == -2) && one_in_(2))
3019                 {
3020                         if (o_ptr->to_h > 0) o_ptr->to_h = 0 - o_ptr->to_h;
3021                         if (o_ptr->to_d > 0) o_ptr->to_d = 0 - o_ptr->to_d;
3022                         if (o_ptr->to_a > 0) o_ptr->to_a = 0 - o_ptr->to_a;
3023                         if (o_ptr->pval > 0) o_ptr->pval = 0 - o_ptr->pval;
3024                         o_ptr->art_flags[0] = 0;
3025                         o_ptr->art_flags[1] = 0;
3026                         while (!o_ptr->name2)
3027                         {
3028                                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
3029                                 switch (randint1(5))
3030                                 {
3031                                 case 1:
3032                                         if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3033                                         o_ptr->name2 = EGO_RING_DRAIN_EXP;
3034                                         break;
3035                                 case 2:
3036                                         o_ptr->name2 = EGO_RING_NO_MELEE;
3037                                         break;
3038                                 case 3:
3039                                         if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3040                                         o_ptr->name2 = EGO_RING_AGGRAVATE;
3041                                         break;
3042                                 case 4:
3043                                         if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3044                                         o_ptr->name2 = EGO_RING_TY_CURSE;
3045                                         break;
3046                                 case 5:
3047                                         o_ptr->name2 = EGO_RING_ALBINO;
3048                                         break;
3049                                 }
3050                         }
3051                         /* Broken */
3052                         o_ptr->ident |= (IDENT_BROKEN);
3053
3054                         /* Cursed */
3055                         o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3056                 }
3057                 break;
3058         }
3059
3060         case TV_AMULET:
3061         {
3062                 /* Analyze */
3063                 switch (o_ptr->sval)
3064                 {
3065                         /* Amulet of wisdom/charisma */
3066                 case SV_AMULET_INTELLIGENCE:
3067                 case SV_AMULET_WISDOM:
3068                 case SV_AMULET_CHARISMA:
3069                 {
3070                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(5, level);
3071
3072                         /* Cursed */
3073                         if (power < 0)
3074                         {
3075                                 /* Broken */
3076                                 o_ptr->ident |= (IDENT_BROKEN);
3077
3078                                 /* Cursed */
3079                                 o_ptr->curse_flags |= (TRC_CURSED);
3080
3081                                 /* Reverse bonuses */
3082                                 o_ptr->pval = 0 - o_ptr->pval;
3083                         }
3084
3085                         break;
3086                 }
3087
3088                 /* Amulet of brilliance */
3089                 case SV_AMULET_BRILLIANCE:
3090                 {
3091                         o_ptr->pval = 1 + m_bonus(3, level);
3092                         if (one_in_(4)) o_ptr->pval++;
3093
3094                         /* Cursed */
3095                         if (power < 0)
3096                         {
3097                                 /* Broken */
3098                                 o_ptr->ident |= (IDENT_BROKEN);
3099
3100                                 /* Cursed */
3101                                 o_ptr->curse_flags |= (TRC_CURSED);
3102
3103                                 /* Reverse bonuses */
3104                                 o_ptr->pval = 0 - o_ptr->pval;
3105                         }
3106
3107                         break;
3108                 }
3109
3110                 case SV_AMULET_NO_MAGIC: case SV_AMULET_NO_TELE:
3111                 {
3112                         if (power < 0)
3113                         {
3114                                 o_ptr->curse_flags |= (TRC_CURSED);
3115                         }
3116                         break;
3117                 }
3118
3119                 case SV_AMULET_RESISTANCE:
3120                 {
3121                         if (one_in_(5)) one_high_resistance(o_ptr);
3122                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_RES_POIS);
3123                 }
3124                 break;
3125
3126                 /* Amulet of searching */
3127                 case SV_AMULET_SEARCHING:
3128                 {
3129                         o_ptr->pval = randint1(2) + (PARAMETER_VALUE)m_bonus(4, level);
3130
3131                         /* Cursed */
3132                         if (power < 0)
3133                         {
3134                                 /* Broken */
3135                                 o_ptr->ident |= (IDENT_BROKEN);
3136
3137                                 /* Cursed */
3138                                 o_ptr->curse_flags |= (TRC_CURSED);
3139
3140                                 /* Reverse bonuses */
3141                                 o_ptr->pval = 0 - (o_ptr->pval);
3142                         }
3143
3144                         break;
3145                 }
3146
3147                 /* Amulet of the Magi -- never cursed */
3148                 case SV_AMULET_THE_MAGI:
3149                 {
3150                         o_ptr->pval = randint1(5) + (PARAMETER_VALUE)m_bonus(5, level);
3151                         o_ptr->to_a = randint1(5) + (ARMOUR_CLASS)m_bonus(5, level);
3152
3153                         /* gain one low ESP */
3154                         add_esp_weak(o_ptr, FALSE);
3155
3156                         break;
3157                 }
3158
3159                 /* Amulet of Doom -- always cursed */
3160                 case SV_AMULET_DOOM:
3161                 {
3162                         /* Broken */
3163                         o_ptr->ident |= (IDENT_BROKEN);
3164
3165                         /* Cursed */
3166                         o_ptr->curse_flags |= (TRC_CURSED);
3167
3168                         /* Penalize */
3169                         o_ptr->pval = 0 - (randint1(5) + (PARAMETER_VALUE)m_bonus(5, level));
3170                         o_ptr->to_a = 0 - (randint1(5) + (ARMOUR_CLASS)m_bonus(5, level));
3171                         if (power > 0) power = 0 - power;
3172
3173                         break;
3174                 }
3175
3176                 case SV_AMULET_MAGIC_MASTERY:
3177                 {
3178                         o_ptr->pval = 1 + (PARAMETER_VALUE)m_bonus(4, level);
3179
3180                         /* Cursed */
3181                         if (power < 0)
3182                         {
3183                                 /* Broken */
3184                                 o_ptr->ident |= (IDENT_BROKEN);
3185
3186                                 /* Cursed */
3187                                 o_ptr->curse_flags |= (TRC_CURSED);
3188
3189                                 /* Reverse bonuses */
3190                                 o_ptr->pval = 0 - o_ptr->pval;
3191                         }
3192
3193                         break;
3194                 }
3195                 }
3196
3197                 if ((one_in_(150) && (power > 0) && !object_is_cursed(o_ptr) && (level > 79))
3198                         || (power > 2)) /* power > 2 is debug only */
3199                 {
3200                         o_ptr->pval = MIN(o_ptr->pval, 4);
3201                         /* Randart amulet */
3202                         become_random_artifact(owner_ptr, o_ptr, FALSE);
3203                 }
3204                 else if ((power == 2) && one_in_(2))
3205                 {
3206                         while (!o_ptr->name2)
3207                         {
3208                                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
3209                                 switch (randint1(21))
3210                                 {
3211                                 case 1: case 2:
3212                                         if (have_flag(k_ptr->flags, TR_SLOW_DIGEST)) break;
3213                                         o_ptr->name2 = EGO_AMU_SLOW_D;
3214                                         break;
3215                                 case 3: case 4:
3216                                         if (o_ptr->pval) break;
3217                                         o_ptr->name2 = EGO_AMU_INFRA;
3218                                         break;
3219                                 case 5: case 6:
3220                                         if (have_flag(k_ptr->flags, TR_SEE_INVIS)) break;
3221                                         o_ptr->name2 = EGO_AMU_SEE_INVIS;
3222                                         break;
3223                                 case 7: case 8:
3224                                         if (have_flag(k_ptr->flags, TR_HOLD_EXP)) break;
3225                                         o_ptr->name2 = EGO_AMU_HOLD_EXP;
3226                                         break;
3227                                 case 9:
3228                                         if (have_flag(k_ptr->flags, TR_LEVITATION)) break;
3229                                         o_ptr->name2 = EGO_AMU_LEVITATION;
3230                                         break;
3231                                 case 10: case 11: case 21:
3232                                         o_ptr->name2 = EGO_AMU_AC;
3233                                         break;
3234                                 case 12:
3235                                         if (have_flag(k_ptr->flags, TR_RES_FIRE)) break;
3236                                         if (m_bonus(10, level) > 8)
3237                                                 o_ptr->name2 = EGO_AMU_RES_FIRE_;
3238                                         else
3239                                                 o_ptr->name2 = EGO_AMU_RES_FIRE;
3240                                         break;
3241                                 case 13:
3242                                         if (have_flag(k_ptr->flags, TR_RES_COLD)) break;
3243                                         if (m_bonus(10, level) > 8)
3244                                                 o_ptr->name2 = EGO_AMU_RES_COLD_;
3245                                         else
3246                                                 o_ptr->name2 = EGO_AMU_RES_COLD;
3247                                         break;
3248                                 case 14:
3249                                         if (have_flag(k_ptr->flags, TR_RES_ELEC)) break;
3250                                         if (m_bonus(10, level) > 8)
3251                                                 o_ptr->name2 = EGO_AMU_RES_ELEC_;
3252                                         else
3253                                                 o_ptr->name2 = EGO_AMU_RES_ELEC;
3254                                         break;
3255                                 case 15:
3256                                         if (have_flag(k_ptr->flags, TR_RES_ACID)) break;
3257                                         if (m_bonus(10, level) > 8)
3258                                                 o_ptr->name2 = EGO_AMU_RES_ACID_;
3259                                         else
3260                                                 o_ptr->name2 = EGO_AMU_RES_ACID;
3261                                         break;
3262                                 case 16: case 17: case 18: case 19: case 20:
3263                                         switch (o_ptr->sval)
3264                                         {
3265                                         case SV_AMULET_TELEPORT:
3266                                                 if (m_bonus(10, level) > 9) o_ptr->name2 = EGO_AMU_D_DOOR;
3267                                                 else if (one_in_(2)) o_ptr->name2 = EGO_AMU_JUMP;
3268                                                 else o_ptr->name2 = EGO_AMU_TELEPORT;
3269                                                 break;
3270                                         case SV_AMULET_RESIST_ACID:
3271                                                 if ((m_bonus(10, level) > 6) && one_in_(2)) o_ptr->name2 = EGO_AMU_RES_ACID_;
3272                                                 break;
3273                                         case SV_AMULET_SEARCHING:
3274                                                 o_ptr->name2 = EGO_AMU_STEALTH;
3275                                                 break;
3276                                         case SV_AMULET_BRILLIANCE:
3277                                                 if (!one_in_(3)) break;
3278                                                 o_ptr->name2 = EGO_AMU_IDENT;
3279                                                 break;
3280                                         case SV_AMULET_CHARISMA:
3281                                                 if (!one_in_(3)) break;
3282                                                 o_ptr->name2 = EGO_AMU_CHARM;
3283                                                 break;
3284                                         case SV_AMULET_THE_MAGI:
3285                                                 if (one_in_(2)) break;
3286                                                 o_ptr->name2 = EGO_AMU_GREAT;
3287                                                 break;
3288                                         case SV_AMULET_RESISTANCE:
3289                                                 if (!one_in_(5)) break;
3290                                                 o_ptr->name2 = EGO_AMU_DEFENDER;
3291                                                 break;
3292                                         case SV_AMULET_TELEPATHY:
3293                                                 if (!one_in_(3)) break;
3294                                                 o_ptr->name2 = EGO_AMU_DETECTION;
3295                                                 break;
3296                                         }
3297                                 }
3298                         }
3299                         o_ptr->curse_flags = 0L;
3300                 }
3301                 else if ((power == -2) && one_in_(2))
3302                 {
3303                         if (o_ptr->to_h > 0) o_ptr->to_h = 0 - o_ptr->to_h;
3304                         if (o_ptr->to_d > 0) o_ptr->to_d = 0 - o_ptr->to_d;
3305                         if (o_ptr->to_a > 0) o_ptr->to_a = 0 - o_ptr->to_a;
3306                         if (o_ptr->pval > 0) o_ptr->pval = 0 - o_ptr->pval;
3307                         o_ptr->art_flags[0] = 0;
3308                         o_ptr->art_flags[1] = 0;
3309                         while (!o_ptr->name2)
3310                         {
3311                                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
3312                                 switch (randint1(5))
3313                                 {
3314                                 case 1:
3315                                         if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3316                                         o_ptr->name2 = EGO_AMU_DRAIN_EXP;
3317                                         break;
3318                                 case 2:
3319                                         o_ptr->name2 = EGO_AMU_FOOL;
3320                                         break;
3321                                 case 3:
3322                                         if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3323                                         o_ptr->name2 = EGO_AMU_AGGRAVATE;
3324                                         break;
3325                                 case 4:
3326                                         if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3327                                         o_ptr->name2 = EGO_AMU_TY_CURSE;
3328                                         break;
3329                                 case 5:
3330                                         o_ptr->name2 = EGO_AMU_NAIVETY;
3331                                         break;
3332                                 }
3333                         }
3334                         /* Broken */
3335                         o_ptr->ident |= (IDENT_BROKEN);
3336
3337                         /* Cursed */
3338                         o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3339                 }
3340                 break;
3341         }
3342         }
3343 }
3344
3345
3346 /*!
3347  * @brief その他雑多のオブジェクトに生成ランクごとの強化を与えるサブルーチン
3348  * Apply magic to an item known to be "boring"
3349  * @param owner_ptr プレーヤーへの参照ポインタ
3350  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3351  * @param level 生成基準階
3352  * @param power 生成ランク
3353  * @return なし
3354  * @details
3355  * Hack -- note the special code for various items
3356  */
3357 static void a_m_aux_4(player_type *owner_ptr, object_type *o_ptr, DEPTH level, int power)
3358 {
3359         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3360
3361         /* Unused */
3362         (void)level;
3363
3364         /* Apply magic (good or bad) according to type */
3365         floor_type *floor_ptr = owner_ptr->current_floor_ptr;
3366         switch (o_ptr->tval)
3367         {
3368         case TV_WHISTLE:
3369         {
3370 #if 0
3371                 /* Cursed */
3372                 if (power < 0)
3373                 {
3374                         /* Broken */
3375                         o_ptr->ident |= (IDENT_BROKEN);
3376
3377                         /* Cursed */
3378                         o_ptr->curse_flags |= (TRC_CURSED);
3379                 }
3380 #endif
3381                 break;
3382         }
3383         case TV_FLASK:
3384         {
3385                 o_ptr->xtra4 = o_ptr->pval;
3386                 o_ptr->pval = 0;
3387                 break;
3388         }
3389         case TV_LITE:
3390         {
3391                 /* Hack -- Torches -- random fuel */
3392                 if (o_ptr->sval == SV_LITE_TORCH)
3393                 {
3394                         if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3395                         o_ptr->pval = 0;
3396                 }
3397
3398                 /* Hack -- Lanterns -- random fuel */
3399                 if (o_ptr->sval == SV_LITE_LANTERN)
3400                 {
3401                         if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3402                         o_ptr->pval = 0;
3403                 }
3404
3405                 if (power > 2) /* power > 2 is debug only */
3406                 {
3407                         become_random_artifact(owner_ptr, o_ptr, FALSE);
3408                 }
3409                 else if ((power == 2) || ((power == 1) && one_in_(3)))
3410                 {
3411                         while (!o_ptr->name2)
3412                         {
3413                                 while (1)
3414                                 {
3415                                         bool okay_flag = TRUE;
3416
3417                                         o_ptr->name2 = get_random_ego(INVEN_LITE, TRUE);
3418
3419                                         switch (o_ptr->name2)
3420                                         {
3421                                         case EGO_LITE_LONG:
3422                                                 if (o_ptr->sval == SV_LITE_FEANOR)
3423                                                         okay_flag = FALSE;
3424                                         }
3425                                         if (okay_flag)
3426                                                 break;
3427                                 }
3428                         }
3429                 }
3430                 else if (power == -2)
3431                 {
3432                         o_ptr->name2 = get_random_ego(INVEN_LITE, FALSE);
3433
3434                         switch (o_ptr->name2)
3435                         {
3436                         case EGO_LITE_DARKNESS:
3437                                 o_ptr->xtra4 = 0;
3438
3439                                 if (o_ptr->sval == SV_LITE_TORCH)
3440                                 {
3441                                         add_flag(o_ptr->art_flags, TR_LITE_M1);
3442                                 }
3443                                 else if (o_ptr->sval == SV_LITE_LANTERN)
3444                                 {
3445                                         add_flag(o_ptr->art_flags, TR_LITE_M2);
3446                                 }
3447                                 else if (o_ptr->sval == SV_LITE_FEANOR)
3448                                 {
3449                                         add_flag(o_ptr->art_flags, TR_LITE_M3);
3450                                 }
3451                                 break;
3452                         }
3453                 }
3454
3455                 break;
3456         }
3457
3458         case TV_WAND:
3459         case TV_STAFF:
3460         {
3461                 /* The wand or staff gets a number of initial charges equal
3462                  * to between 1/2 (+1) and the full object kind's pval. -LM-
3463                  */
3464                 o_ptr->pval = k_ptr->pval / 2 + randint1((k_ptr->pval + 1) / 2);
3465                 break;
3466         }
3467
3468         case TV_ROD:
3469         {
3470                 /* Transfer the pval. -LM- */
3471                 o_ptr->pval = k_ptr->pval;
3472                 break;
3473         }
3474
3475         case TV_CAPTURE:
3476         {
3477                 o_ptr->pval = 0;
3478                 object_aware(owner_ptr, o_ptr);
3479                 object_known(o_ptr);
3480                 break;
3481         }
3482
3483         case TV_FIGURINE:
3484         {
3485                 PARAMETER_VALUE i = 1;
3486                 int check;
3487
3488                 monster_race *r_ptr;
3489
3490                 /* Pick a random non-unique monster race */
3491                 while (1)
3492                 {
3493                         i = randint1(max_r_idx - 1);
3494
3495                         if (!item_monster_okay(i)) continue;
3496                         if (i == MON_TSUCHINOKO) continue;
3497
3498                         r_ptr = &r_info[i];
3499
3500                         check = (floor_ptr->dun_level < r_ptr->level) ? (r_ptr->level - floor_ptr->dun_level) : 0;
3501
3502                         /* Ignore dead monsters */
3503                         if (!r_ptr->rarity) continue;
3504
3505                         /* Ignore uncommon monsters */
3506                         if (r_ptr->rarity > 100) continue;
3507
3508                         /* Prefer less out-of-depth monsters */
3509                         if (randint0(check)) continue;
3510
3511                         break;
3512                 }
3513
3514                 o_ptr->pval = i;
3515
3516                 /* Some figurines are cursed */
3517                 if (one_in_(6)) o_ptr->curse_flags |= TRC_CURSED;
3518
3519                 break;
3520         }
3521
3522         case TV_CORPSE:
3523         {
3524                 PARAMETER_VALUE i = 1;
3525                 int check;
3526
3527                 u32b match = 0;
3528
3529                 monster_race *r_ptr;
3530
3531                 if (o_ptr->sval == SV_SKELETON)
3532                 {
3533                         match = RF9_DROP_SKELETON;
3534                 }
3535                 else if (o_ptr->sval == SV_CORPSE)
3536                 {
3537                         match = RF9_DROP_CORPSE;
3538                 }
3539
3540                 /* Hack -- Remove the monster restriction */
3541                 get_mon_num_prep(item_monster_okay, NULL);
3542
3543                 /* Pick a random non-unique monster race */
3544                 while (1)
3545                 {
3546                         i = get_mon_num(floor_ptr->dun_level);
3547
3548                         r_ptr = &r_info[i];
3549
3550                         check = (floor_ptr->dun_level < r_ptr->level) ? (r_ptr->level - floor_ptr->dun_level) : 0;
3551
3552                         /* Ignore dead monsters */
3553                         if (!r_ptr->rarity) continue;
3554
3555                         /* Ignore corpseless monsters */
3556                         if (!(r_ptr->flags9 & match)) continue;
3557
3558                         /* Prefer less out-of-depth monsters */
3559                         if (randint0(check)) continue;
3560
3561                         break;
3562                 }
3563
3564                 o_ptr->pval = i;
3565
3566                 object_aware(owner_ptr, o_ptr);
3567                 object_known(o_ptr);
3568                 break;
3569         }
3570
3571         case TV_STATUE:
3572         {
3573                 PARAMETER_VALUE i = 1;
3574
3575                 monster_race *r_ptr;
3576
3577                 /* Pick a random monster race */
3578                 while (1)
3579                 {
3580                         i = randint1(max_r_idx - 1);
3581
3582                         r_ptr = &r_info[i];
3583
3584                         /* Ignore dead monsters */
3585                         if (!r_ptr->rarity) continue;
3586
3587                         break;
3588                 }
3589
3590                 o_ptr->pval = i;
3591
3592                 if (cheat_peek)
3593                 {
3594                         msg_format(_("%sの像", "Statue of %s"), r_name + r_ptr->name);
3595                 }
3596
3597                 object_aware(owner_ptr, o_ptr);
3598                 object_known(o_ptr);
3599
3600                 break;
3601         }
3602
3603         case TV_CHEST:
3604         {
3605                 DEPTH obj_level = k_info[o_ptr->k_idx].level;
3606
3607                 /* Hack -- skip ruined chests */
3608                 if (obj_level <= 0) break;
3609
3610                 /* Hack -- pick a "difficulty" */
3611                 o_ptr->pval = randint1(obj_level);
3612                 if (o_ptr->sval == SV_CHEST_KANDUME) o_ptr->pval = 6;
3613
3614                 o_ptr->xtra3 = floor_ptr->dun_level + 5;
3615
3616                 /* Never exceed "difficulty" of 55 to 59 */
3617                 if (o_ptr->pval > 55) o_ptr->pval = 55 + (byte)randint0(5);
3618
3619                 break;
3620         }
3621         }
3622 }
3623
3624
3625 /*!
3626  * @brief 生成されたベースアイテムに魔法的な強化を与えるメインルーチン
3627  * Complete the "creation" of an object by applying "magic" to the item
3628  * @param owner_ptr プレーヤーへの参照ポインタ
3629  * @param o_ptr 強化を与えたいオブジェクトの構造体参照ポインタ
3630  * @param lev 生成基準階
3631  * @param mode 生成オプション
3632  * @return なし
3633  * @details
3634  * This includes not only rolling for random bonuses, but also putting the\n
3635  * finishing touches on ego-items and artifacts, giving charges to wands and\n
3636  * staffs, giving fuel to lites, and placing traps on chests.\n
3637  *\n
3638  * In particular, note that "Instant Artifacts", if "created" by an external\n
3639  * routine, must pass through this function to complete the actual creation.\n
3640  *\n
3641  * The base "chance" of the item being "good" increases with the "level"\n
3642  * parameter, which is usually derived from the dungeon level, being equal\n
3643  * to the level plus 10, up to a maximum of 75.  If "good" is true, then\n
3644  * the object is guaranteed to be "good".  If an object is "good", then\n
3645  * the chance that the object will be "great" (ego-item or artifact), also\n
3646  * increases with the "level", being equal to half the level, plus 5, up to\n
3647  * a maximum of 20.  If "great" is true, then the object is guaranteed to be\n
3648  * "great".  At dungeon level 65 and below, 15/100 objects are "great".\n
3649  *\n
3650  * If the object is not "good", there is a chance it will be "cursed", and\n
3651  * if it is "cursed", there is a chance it will be "broken".  These chances\n
3652  * are related to the "good" / "great" chances above.\n
3653  *\n
3654  * Otherwise "normal" rings and amulets will be "good" half the time and\n
3655  * "cursed" half the time, unless the ring/amulet is always good or cursed.\n
3656  *\n
3657  * If "okay" is true, and the object is going to be "great", then there is\n
3658  * a chance that an artifact will be created.  This is true even if both the\n
3659  * "good" and "great" arguments are false.  As a total hack, if "great" is\n
3660  * true, then the item gets 3 extra "attempts" to become an artifact.\n
3661  */
3662 void apply_magic(player_type *owner_ptr, object_type *o_ptr, DEPTH lev, BIT_FLAGS mode)
3663 {
3664         int i, rolls, f1, f2, power;
3665
3666         if (owner_ptr->pseikaku == SEIKAKU_MUNCHKIN) lev += randint0(owner_ptr->lev / 2 + 10);
3667
3668         /* Maximum "level" for various things */
3669         if (lev > MAX_DEPTH - 1) lev = MAX_DEPTH - 1;
3670
3671         /* Base chance of being "good" */
3672         f1 = lev + 10;
3673
3674         /* Maximal chance of being "good" */
3675         if (f1 > d_info[owner_ptr->dungeon_idx].obj_good) f1 = d_info[owner_ptr->dungeon_idx].obj_good;
3676
3677         /* Base chance of being "great" */
3678         f2 = f1 * 2 / 3;
3679
3680         /* Maximal chance of being "great" */
3681         if ((owner_ptr->pseikaku != SEIKAKU_MUNCHKIN) && (f2 > d_info[owner_ptr->dungeon_idx].obj_great))
3682                 f2 = d_info[owner_ptr->dungeon_idx].obj_great;
3683
3684         if (owner_ptr->muta3 & MUT3_GOOD_LUCK)
3685         {
3686                 f1 += 5;
3687                 f2 += 2;
3688         }
3689         else if (owner_ptr->muta3 & MUT3_BAD_LUCK)
3690         {
3691                 f1 -= 5;
3692                 f2 -= 2;
3693         }
3694
3695         /* Assume normal */
3696         power = 0;
3697
3698         /* Roll for "good" */
3699         if ((mode & AM_GOOD) || magik(f1))
3700         {
3701                 /* Assume "good" */
3702                 power = 1;
3703
3704                 /* Roll for "great" */
3705                 if ((mode & AM_GREAT) || magik(f2))
3706                 {
3707                         power = 2;
3708
3709                         /* Roll for "special" */
3710                         if (mode & AM_SPECIAL) power = 3;
3711                 }
3712         }
3713
3714         /* Roll for "cursed" */
3715         else if (magik(f1))
3716         {
3717                 /* Assume "cursed" */
3718                 power = -1;
3719
3720                 /* Roll for "broken" */
3721                 if (magik(f2)) power = -2;
3722         }
3723
3724         /* Apply curse */
3725         if (mode & AM_CURSED)
3726         {
3727                 /* Assume 'cursed' */
3728                 if (power > 0)
3729                 {
3730                         power = 0 - power;
3731                 }
3732                 /* Everything else gets more badly cursed */
3733                 else
3734                 {
3735                         power--;
3736                 }
3737         }
3738
3739         /* Assume no rolls */
3740         rolls = 0;
3741
3742         /* Get one roll if excellent */
3743         if (power >= 2) rolls = 1;
3744
3745         /* Hack -- Get four rolls if forced great or special */
3746         if (mode & (AM_GREAT | AM_SPECIAL)) rolls = 4;
3747
3748         /* Hack -- Get no rolls if not allowed */
3749         if ((mode & AM_NO_FIXED_ART) || o_ptr->name1) rolls = 0;
3750
3751         /* Roll for artifacts if allowed */
3752         for (i = 0; i < rolls; i++)
3753         {
3754                 /* Roll for an artifact */
3755                 if (make_artifact(o_ptr)) break;
3756                 if ((owner_ptr->muta3 & MUT3_GOOD_LUCK) && one_in_(77))
3757                 {
3758                         if (make_artifact(o_ptr)) break;
3759                 }
3760         }
3761
3762         /* Hack -- analyze artifacts */
3763         if (object_is_fixed_artifact(o_ptr))
3764         {
3765                 artifact_type *a_ptr = &a_info[o_ptr->name1];
3766
3767                 /* Hack -- Mark the artifact as "created" */
3768                 a_ptr->cur_num = 1;
3769
3770                 /* Hack -- Memorize location of artifact in saved floors */
3771                 if (current_world_ptr->character_dungeon)
3772                         a_ptr->floor_id = owner_ptr->floor_id;
3773
3774                 /* Extract the other fields */
3775                 o_ptr->pval = a_ptr->pval;
3776                 o_ptr->ac = a_ptr->ac;
3777                 o_ptr->dd = a_ptr->dd;
3778                 o_ptr->ds = a_ptr->ds;
3779                 o_ptr->to_a = a_ptr->to_a;
3780                 o_ptr->to_h = a_ptr->to_h;
3781                 o_ptr->to_d = a_ptr->to_d;
3782                 o_ptr->weight = a_ptr->weight;
3783                 o_ptr->xtra2 = a_ptr->act_idx;
3784
3785                 if (o_ptr->name1 == ART_MILIM)
3786                 {
3787                         if (owner_ptr->pseikaku == SEIKAKU_SEXY)
3788                         {
3789                                 o_ptr->pval = 3;
3790                         }
3791                 }
3792
3793                 /* Hack -- extract the "broken" flag */
3794                 if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
3795
3796                 /* Hack -- extract the "cursed" flag */
3797                 if (a_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
3798                 if (a_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
3799                 if (a_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
3800                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
3801                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
3802                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
3803
3804                 return;
3805         }
3806
3807         switch (o_ptr->tval)
3808         {
3809         case TV_DIGGING:
3810         case TV_HAFTED:
3811         case TV_BOW:
3812         case TV_SHOT:
3813         case TV_ARROW:
3814         case TV_BOLT:
3815         {
3816                 if (power) apply_magic_weapon(owner_ptr, o_ptr, lev, power);
3817                 break;
3818         }
3819
3820         case TV_POLEARM:
3821         {
3822                 if (power && !(o_ptr->sval == SV_DEATH_SCYTHE)) apply_magic_weapon(owner_ptr, o_ptr, lev, power);
3823                 break;
3824         }
3825
3826         case TV_SWORD:
3827         {
3828                 if (power && !(o_ptr->sval == SV_DOKUBARI)) apply_magic_weapon(owner_ptr, o_ptr, lev, power);
3829                 break;
3830         }
3831
3832         case TV_DRAG_ARMOR:
3833         case TV_HARD_ARMOR:
3834         case TV_SOFT_ARMOR:
3835         case TV_SHIELD:
3836         case TV_HELM:
3837         case TV_CROWN:
3838         case TV_CLOAK:
3839         case TV_GLOVES:
3840         case TV_BOOTS:
3841         {
3842                 /* Elven Cloak and Black Clothes ... */
3843                 if (((o_ptr->tval == TV_CLOAK) && (o_ptr->sval == SV_ELVEN_CLOAK)) ||
3844                         ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_KUROSHOUZOKU)))
3845                         o_ptr->pval = randint1(4);
3846
3847 #if 1
3848                 if (power ||
3849                         ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
3850                         ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
3851                         ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
3852                         ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)))
3853                         a_m_aux_2(owner_ptr, o_ptr, lev, power);
3854 #else
3855                 if (power) a_m_aux_2(o_ptr, lev, power);
3856 #endif
3857                 break;
3858         }
3859
3860         case TV_RING:
3861         case TV_AMULET:
3862         {
3863                 if (!power && (randint0(100) < 50)) power = -1;
3864                 a_m_aux_3(owner_ptr, o_ptr, lev, power);
3865                 break;
3866         }
3867
3868         default:
3869         {
3870                 a_m_aux_4(owner_ptr, o_ptr, lev, power);
3871                 break;
3872         }
3873         }
3874
3875         if ((o_ptr->tval == TV_SOFT_ARMOR) &&
3876                 (o_ptr->sval == SV_ABUNAI_MIZUGI) &&
3877                 (owner_ptr->pseikaku == SEIKAKU_SEXY))
3878         {
3879                 o_ptr->pval = 3;
3880                 add_flag(o_ptr->art_flags, TR_STR);
3881                 add_flag(o_ptr->art_flags, TR_INT);
3882                 add_flag(o_ptr->art_flags, TR_WIS);
3883                 add_flag(o_ptr->art_flags, TR_DEX);
3884                 add_flag(o_ptr->art_flags, TR_CON);
3885                 add_flag(o_ptr->art_flags, TR_CHR);
3886         }
3887
3888         /* Hack -- analyze ego-items */
3889         if (object_is_ego(o_ptr))
3890         {
3891                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
3892
3893                 /* Hack -- acquire "broken" flag */
3894                 if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
3895
3896                 /* Hack -- acquire "cursed" flag */
3897                 if (e_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
3898                 if (e_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
3899                 if (e_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
3900                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
3901                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
3902                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
3903
3904                 if (e_ptr->gen_flags & (TRG_ONE_SUSTAIN)) one_sustain(o_ptr);
3905                 if (e_ptr->gen_flags & (TRG_XTRA_POWER)) one_ability(o_ptr);
3906                 if (e_ptr->gen_flags & (TRG_XTRA_H_RES)) one_high_resistance(o_ptr);
3907                 if (e_ptr->gen_flags & (TRG_XTRA_E_RES)) one_ele_resistance(o_ptr);
3908                 if (e_ptr->gen_flags & (TRG_XTRA_D_RES)) one_dragon_ele_resistance(o_ptr);
3909                 if (e_ptr->gen_flags & (TRG_XTRA_L_RES)) one_lordly_high_resistance(o_ptr);
3910                 if (e_ptr->gen_flags & (TRG_XTRA_RES)) one_resistance(o_ptr);
3911                 if (e_ptr->gen_flags & (TRG_XTRA_DICE))
3912                 {
3913                         do
3914                         {
3915                                 o_ptr->dd++;
3916                         } while (one_in_(o_ptr->dd));
3917
3918                         if (o_ptr->dd > 9) o_ptr->dd = 9;
3919                 }
3920
3921                 /* Hack -- apply activatin index if needed */
3922                 if (e_ptr->act_idx) o_ptr->xtra2 = (XTRA8)e_ptr->act_idx;
3923
3924                 /* Hack -- apply extra penalties if needed */
3925                 if ((object_is_cursed(o_ptr) || object_is_broken(o_ptr)) && !(e_ptr->gen_flags & (TRG_POWERFUL)))
3926                 {
3927                         /* Hack -- obtain bonuses */
3928                         if (e_ptr->max_to_h) o_ptr->to_h -= randint1(e_ptr->max_to_h);
3929                         if (e_ptr->max_to_d) o_ptr->to_d -= randint1(e_ptr->max_to_d);
3930                         if (e_ptr->max_to_a) o_ptr->to_a -= randint1(e_ptr->max_to_a);
3931
3932                         /* Hack -- obtain pval */
3933                         if (e_ptr->max_pval) o_ptr->pval -= randint1(e_ptr->max_pval);
3934                 }
3935
3936                 /* Hack -- apply extra bonuses if needed */
3937                 else
3938                 {
3939                         /* Hack -- obtain bonuses */
3940                         if (e_ptr->max_to_h)
3941                         {
3942                                 if (e_ptr->max_to_h > 127)
3943                                         o_ptr->to_h -= randint1(256 - e_ptr->max_to_h);
3944                                 else o_ptr->to_h += randint1(e_ptr->max_to_h);
3945                         }
3946                         if (e_ptr->max_to_d)
3947                         {
3948                                 if (e_ptr->max_to_d > 127)
3949                                         o_ptr->to_d -= randint1(256 - e_ptr->max_to_d);
3950                                 else o_ptr->to_d += randint1(e_ptr->max_to_d);
3951                         }
3952                         if (e_ptr->max_to_a)
3953                         {
3954                                 if (e_ptr->max_to_a > 127)
3955                                         o_ptr->to_a -= randint1(256 - e_ptr->max_to_a);
3956                                 else o_ptr->to_a += randint1(e_ptr->max_to_a);
3957                         }
3958
3959                         /* Accuracy ego must have high to_h */
3960                         if (o_ptr->name2 == EGO_ACCURACY)
3961                         {
3962                                 while (o_ptr->to_h < o_ptr->to_d + 10)
3963                                 {
3964                                         o_ptr->to_h += 5;
3965                                         o_ptr->to_d -= 5;
3966                                 }
3967                                 o_ptr->to_h = MAX(o_ptr->to_h, 15);
3968                         }
3969
3970                         /* Accuracy ego must have high to_h */
3971                         if (o_ptr->name2 == EGO_VELOCITY)
3972                         {
3973                                 while (o_ptr->to_d < o_ptr->to_h + 10)
3974                                 {
3975                                         o_ptr->to_d += 5;
3976                                         o_ptr->to_h -= 5;
3977                                 }
3978                                 o_ptr->to_d = MAX(o_ptr->to_d, 15);
3979                         }
3980
3981                         /* Protection ego must have high to_a */
3982                         if ((o_ptr->name2 == EGO_PROTECTION) || (o_ptr->name2 == EGO_S_PROTECTION) || (o_ptr->name2 == EGO_H_PROTECTION))
3983                         {
3984                                 o_ptr->to_a = MAX(o_ptr->to_a, 15);
3985                         }
3986
3987                         /* Hack -- obtain pval */
3988                         if (e_ptr->max_pval)
3989                         {
3990                                 if ((o_ptr->name2 == EGO_HA) && (have_flag(o_ptr->art_flags, TR_BLOWS)))
3991                                 {
3992                                         o_ptr->pval++;
3993                                         if ((lev > 60) && one_in_(3) && ((o_ptr->dd*(o_ptr->ds + 1)) < 15)) o_ptr->pval++;
3994                                 }
3995                                 else if (o_ptr->name2 == EGO_DEMON)
3996                                 {
3997                                         if (have_flag(o_ptr->art_flags, TR_BLOWS))
3998                                         {
3999                                                 o_ptr->pval += randint1(2);
4000                                         }
4001                                         else
4002                                         {
4003                                                 o_ptr->pval += randint1(e_ptr->max_pval);
4004                                         }
4005                                 }
4006                                 else if (o_ptr->name2 == EGO_ATTACKS)
4007                                 {
4008                                         o_ptr->pval = randint1(e_ptr->max_pval*lev / 100 + 1);
4009                                         if (o_ptr->pval > 3) o_ptr->pval = 3;
4010                                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA))
4011                                                 o_ptr->pval += randint1(2);
4012                                 }
4013                                 else if (o_ptr->name2 == EGO_BAT)
4014                                 {
4015                                         o_ptr->pval = randint1(e_ptr->max_pval);
4016                                         if (o_ptr->sval == SV_ELVEN_CLOAK) o_ptr->pval += randint1(2);
4017                                 }
4018                                 else if (o_ptr->name2 == EGO_A_DEMON || o_ptr->name2 == EGO_DRUID || o_ptr->name2 == EGO_OLOG)
4019                                 {
4020                                         o_ptr->pval = randint1(e_ptr->max_pval);
4021                                 }
4022                                 else
4023                                 {
4024                                         o_ptr->pval += randint1(e_ptr->max_pval);
4025                                 }
4026
4027
4028                         }
4029                         if ((o_ptr->name2 == EGO_SPEED) && (lev < 50))
4030                         {
4031                                 o_ptr->pval = randint1(o_ptr->pval);
4032                         }
4033                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA) && (o_ptr->pval > 2) && (o_ptr->name2 != EGO_ATTACKS))
4034                                 o_ptr->pval = 2;
4035                 }
4036
4037                 return;
4038         }
4039
4040         /* Examine real objects */
4041         if (o_ptr->k_idx)
4042         {
4043                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
4044
4045                 /* Hack -- acquire "broken" flag */
4046                 if (!k_info[o_ptr->k_idx].cost) o_ptr->ident |= (IDENT_BROKEN);
4047
4048                 /* Hack -- acquire "cursed" flag */
4049                 if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
4050                 if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
4051                 if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
4052                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4053                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4054                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4055         }
4056 }
4057
4058
4059 /*!
4060  * @brief 生成階に応じたベースアイテムの生成を行う。
4061  * Attempt to make an object (normal or good/great)
4062  * @param owner_ptr プレーヤーへの参照ポインタ
4063  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4064  * @param mode オプションフラグ
4065  * @return 生成に成功したらTRUEを返す。
4066  * @details
4067  * This routine plays nasty games to generate the "special artifacts".\n
4068  * This routine uses "floor_ptr->object_level" for the "generation level".\n
4069  * We assume that the given object has been "wiped".\n
4070  */
4071 bool make_object(player_type *owner_ptr, object_type *j_ptr, BIT_FLAGS mode)
4072 {
4073         floor_type *floor_ptr = owner_ptr->current_floor_ptr;
4074
4075         /* Chance of "special object" */
4076         PERCENTAGE prob = ((mode & AM_GOOD) ? 10 : 1000);
4077
4078         /* Base level for the object */
4079         DEPTH base = ((mode & AM_GOOD) ? (floor_ptr->object_level + 10) : floor_ptr->object_level);
4080
4081
4082         /* Generate a special object, or a normal object */
4083         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4084         {
4085                 KIND_OBJECT_IDX k_idx;
4086
4087                 /* Good objects */
4088                 if ((mode & AM_GOOD) && !get_obj_num_hook)
4089                 {
4090                         /* Activate restriction (if already specified, use that) */
4091                         get_obj_num_hook = kind_is_good;
4092                 }
4093
4094                 /* Restricted objects - prepare allocation table */
4095                 if (get_obj_num_hook) get_obj_num_prep();
4096
4097                 /* Pick a random object */
4098                 k_idx = get_obj_num(owner_ptr, base, mode);
4099
4100                 /* Restricted objects */
4101                 if (get_obj_num_hook)
4102                 {
4103                         /* Clear restriction */
4104                         get_obj_num_hook = NULL;
4105
4106                         /* Reset allocation table to default */
4107                         get_obj_num_prep();
4108                 }
4109
4110                 /* Handle failure */
4111                 if (!k_idx) return (FALSE);
4112
4113                 /* Prepare the object */
4114                 object_prep(j_ptr, k_idx);
4115         }
4116
4117         /* Apply magic (allow artifacts) */
4118         apply_magic(owner_ptr, j_ptr, floor_ptr->object_level, mode);
4119
4120         /* Hack -- generate multiple spikes/missiles */
4121         switch (j_ptr->tval)
4122         {
4123         case TV_SPIKE:
4124         case TV_SHOT:
4125         case TV_ARROW:
4126         case TV_BOLT:
4127         {
4128                 if (!j_ptr->name1)
4129                         j_ptr->number = (byte)damroll(6, 7);
4130         }
4131         }
4132
4133         if (cheat_peek) object_mention(owner_ptr, j_ptr);
4134
4135         return TRUE;
4136 }
4137
4138
4139 /*!
4140  * @brief 生成階に応じた財宝オブジェクトの生成を行う。
4141  * Make a treasure object
4142  * @param floor_ptr 現在フロアへの参照ポインタ
4143  * @param j_ptr 生成結果を収めたいオブジェクト構造体の参照ポインタ
4144  * @return 生成に成功したらTRUEを返す。
4145  * @details
4146  * The location must be a legal, clean, floor grid.
4147  */
4148 bool make_gold(floor_type *floor_ptr, object_type *j_ptr)
4149 {
4150         int i;
4151         s32b base;
4152
4153         /* Hack -- Pick a Treasure variety */
4154         i = ((randint1(floor_ptr->object_level + 2) + 2) / 2) - 1;
4155
4156         /* Apply "extra" magic */
4157         if (one_in_(GREAT_OBJ))
4158         {
4159                 i += randint1(floor_ptr->object_level + 1);
4160         }
4161
4162         /* Hack -- Creeping Coins only generate "themselves" */
4163         if (coin_type) i = coin_type;
4164
4165         /* Do not create "illegal" Treasure Types */
4166         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4167
4168         /* Prepare a gold object */
4169         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4170
4171         /* Hack -- Base coin cost */
4172         base = k_info[OBJ_GOLD_LIST + i].cost;
4173
4174         /* Determine how much the treasure is "worth" */
4175         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4176
4177         /* Success */
4178         return (TRUE);
4179 }
4180
4181
4182 /*!
4183  * @brief 生成済のオブジェクトをフロアの所定の位置に落とす。
4184  * Let an object fall to the ground at or near a location.
4185  * @param owner_ptr プレーヤーへの参照ポインタ
4186  * @param j_ptr 落としたいオブジェクト構造体の参照ポインタ
4187  * @param chance ドロップの消滅率(%)
4188  * @param y 配置したいフロアのY座標
4189  * @param x 配置したいフロアのX座標
4190  * @return 生成に成功したらオブジェクトのIDを返す。
4191  * @details
4192  * The initial location is assumed to be "in_bounds(floor_ptr, )".\n
4193  *\n
4194  * This function takes a parameter "chance".  This is the percentage\n
4195  * chance that the item will "disappear" instead of drop.  If the object\n
4196  * has been thrown, then this is the chance of disappearance on contact.\n
4197  *\n
4198  * Hack -- this function uses "chance" to determine if it should produce\n
4199  * some form of "description" of the drop event (under the player).\n
4200  *\n
4201  * We check several locations to see if we can find a location at which\n
4202  * the object can combine, stack, or be placed.  Artifacts will try very\n
4203  * hard to be placed, including "teleporting" to a useful grid if needed.\n
4204  */
4205 OBJECT_IDX drop_near(player_type *owner_type, object_type *j_ptr, PERCENTAGE chance, POSITION y, POSITION x)
4206 {
4207         int i, k, d, s;
4208
4209         int bs, bn;
4210         POSITION by, bx;
4211         POSITION dy, dx;
4212         POSITION ty, tx = 0;
4213
4214         OBJECT_IDX o_idx = 0;
4215         OBJECT_IDX this_o_idx, next_o_idx = 0;
4216
4217         grid_type *g_ptr;
4218
4219         GAME_TEXT o_name[MAX_NLEN];
4220
4221         bool flag = FALSE;
4222         bool done = FALSE;
4223
4224 #ifndef JP
4225         /* Extract plural */
4226         bool plural = (j_ptr->number != 1);
4227 #endif
4228
4229         /* Describe object */
4230         object_desc(o_name, j_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
4231
4232
4233         /* Handle normal "breakage" */
4234         if (!object_is_artifact(j_ptr) && (randint0(100) < chance))
4235         {
4236 #ifdef JP
4237                 msg_format("%sは消えた。", o_name);
4238 #else
4239                 msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
4240 #endif
4241                 if (current_world_ptr->wizard) msg_print(_("(破損)", "(breakage)"));
4242
4243                 /* Failure */
4244                 return (0);
4245         }
4246
4247
4248         /* Score */
4249         bs = -1;
4250
4251         /* Picker */
4252         bn = 0;
4253
4254         /* Default */
4255         by = y;
4256         bx = x;
4257         floor_type *floor_ptr = owner_type->current_floor_ptr;
4258         /* Scan local grids */
4259         for (dy = -3; dy <= 3; dy++)
4260         {
4261                 /* Scan local grids */
4262                 for (dx = -3; dx <= 3; dx++)
4263                 {
4264                         bool comb = FALSE;
4265
4266                         /* Calculate actual distance */
4267                         d = (dy * dy) + (dx * dx);
4268
4269                         /* Ignore distant grids */
4270                         if (d > 10) continue;
4271
4272                         ty = y + dy;
4273                         tx = x + dx;
4274
4275                         if (!in_bounds(floor_ptr, ty, tx)) continue;
4276
4277                         /* Require line of projection */
4278                         if (!projectable(floor_ptr, y, x, ty, tx)) continue;
4279
4280                         /* Obtain grid */
4281                         g_ptr = &floor_ptr->grid_array[ty][tx];
4282
4283                         /* Require floor space */
4284                         if (!cave_drop_bold(floor_ptr, ty, tx)) continue;
4285
4286                         /* No objects */
4287                         k = 0;
4288
4289                         /* Scan objects in that grid */
4290                         for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
4291                         {
4292                                 object_type *o_ptr;
4293                                 o_ptr = &floor_ptr->o_list[this_o_idx];
4294                                 next_o_idx = o_ptr->next_o_idx;
4295
4296                                 /* Check for possible combination */
4297                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
4298
4299                                 /* Count objects */
4300                                 k++;
4301                         }
4302
4303                         /* Add new object */
4304                         if (!comb) k++;
4305                         if (k > 99) continue;
4306
4307                         /* Calculate score */
4308                         s = 1000 - (d + k * 5);
4309
4310                         /* Skip bad values */
4311                         if (s < bs) continue;
4312
4313                         /* New best value */
4314                         if (s > bs) bn = 0;
4315
4316                         /* Apply the randomizer to equivalent values */
4317                         if ((++bn >= 2) && !one_in_(bn)) continue;
4318
4319                         /* Keep score */
4320                         bs = s;
4321
4322                         /* Track it */
4323                         by = ty;
4324                         bx = tx;
4325
4326                         flag = TRUE;
4327                 }
4328         }
4329
4330         /* Handle lack of space */
4331         if (!flag && !object_is_artifact(j_ptr))
4332         {
4333 #ifdef JP
4334                 msg_format("%sは消えた。", o_name);
4335 #else
4336                 msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
4337 #endif
4338
4339                 if (current_world_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
4340
4341                 /* Failure */
4342                 return (0);
4343         }
4344
4345
4346         /* Find a grid */
4347         for (i = 0; !flag && (i < 1000); i++)
4348         {
4349                 /* Bounce around */
4350                 ty = rand_spread(by, 1);
4351                 tx = rand_spread(bx, 1);
4352
4353                 if (!in_bounds(floor_ptr, ty, tx)) continue;
4354
4355                 /* Bounce to that location */
4356                 by = ty;
4357                 bx = tx;
4358
4359                 /* Require floor space */
4360                 if (!cave_drop_bold(floor_ptr, by, bx)) continue;
4361
4362                 flag = TRUE;
4363         }
4364
4365
4366         if (!flag)
4367         {
4368                 int candidates = 0, pick;
4369
4370                 for (ty = 1; ty < floor_ptr->height - 1; ty++)
4371                 {
4372                         for (tx = 1; tx < floor_ptr->width - 1; tx++)
4373                         {
4374                                 /* A valid space found */
4375                                 if (cave_drop_bold(floor_ptr, ty, tx)) candidates++;
4376                         }
4377                 }
4378
4379                 /* No valid place! */
4380                 if (!candidates)
4381                 {
4382 #ifdef JP
4383                         msg_format("%sは消えた。", o_name);
4384 #else
4385                         msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
4386 #endif
4387
4388                         if (current_world_ptr->wizard) msg_print(_("(床スペースがない)", "(no floor space)"));
4389
4390                         /* Mega-Hack -- preserve artifacts */
4391                         if (preserve_mode)
4392                         {
4393                                 /* Hack -- Preserve unknown artifacts */
4394                                 if (object_is_fixed_artifact(j_ptr) && !object_is_known(j_ptr))
4395                                 {
4396                                         /* Mega-Hack -- Preserve the artifact */
4397                                         a_info[j_ptr->name1].cur_num = 0;
4398                                 }
4399                         }
4400
4401                         /* Failure */
4402                         return 0;
4403                 }
4404
4405                 /* Choose a random one */
4406                 pick = randint1(candidates);
4407
4408                 for (ty = 1; ty < floor_ptr->height - 1; ty++)
4409                 {
4410                         for (tx = 1; tx < floor_ptr->width - 1; tx++)
4411                         {
4412                                 if (cave_drop_bold(floor_ptr, ty, tx))
4413                                 {
4414                                         pick--;
4415
4416                                         /* Is this a picked one? */
4417                                         if (!pick) break;
4418                                 }
4419                         }
4420
4421                         if (!pick) break;
4422                 }
4423
4424                 by = ty;
4425                 bx = tx;
4426         }
4427
4428
4429         g_ptr = &floor_ptr->grid_array[by][bx];
4430
4431         /* Scan objects in that grid for combination */
4432         for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
4433         {
4434                 object_type *o_ptr;
4435                 o_ptr = &floor_ptr->o_list[this_o_idx];
4436                 next_o_idx = o_ptr->next_o_idx;
4437
4438                 /* Check for combination */
4439                 if (object_similar(o_ptr, j_ptr))
4440                 {
4441                         object_absorb(o_ptr, j_ptr);
4442
4443                         /* Success */
4444                         done = TRUE;
4445
4446                         break;
4447                 }
4448         }
4449
4450         if (!done) o_idx = o_pop(floor_ptr);
4451
4452         if (!done && !o_idx)
4453         {
4454 #ifdef JP
4455                 msg_format("%sは消えた。", o_name);
4456 #else
4457                 msg_format("The %s disappear%s.", o_name, (plural ? "" : "s"));
4458 #endif
4459
4460                 if (current_world_ptr->wizard) msg_print(_("(アイテムが多過ぎる)", "(too many objects)"));
4461
4462                 /* Hack -- Preserve artifacts */
4463                 if (object_is_fixed_artifact(j_ptr))
4464                 {
4465                         a_info[j_ptr->name1].cur_num = 0;
4466                 }
4467
4468                 return 0;
4469         }
4470
4471         /* Stack */
4472         if (!done)
4473         {
4474                 /* Structure copy */
4475                 object_copy(&floor_ptr->o_list[o_idx], j_ptr);
4476
4477                 /* Access new object */
4478                 j_ptr = &floor_ptr->o_list[o_idx];
4479
4480                 /* Locate */
4481                 j_ptr->iy = by;
4482                 j_ptr->ix = bx;
4483
4484                 /* No monster */
4485                 j_ptr->held_m_idx = 0;
4486
4487                 /* Build a stack */
4488                 j_ptr->next_o_idx = g_ptr->o_idx;
4489
4490                 g_ptr->o_idx = o_idx;
4491
4492                 /* Success */
4493                 done = TRUE;
4494         }
4495
4496         note_spot(by, bx);
4497         lite_spot(by, bx);
4498         sound(SOUND_DROP);
4499
4500         /* Mega-Hack -- no message if "dropped" by player */
4501         /* Message when an object falls under the player */
4502         if (chance && player_bold(owner_type, by, bx))
4503         {
4504                 msg_print(_("何かが足下に転がってきた。", "You feel something roll beneath your feet."));
4505         }
4506
4507         return o_idx;
4508 }
4509
4510
4511 /*!
4512  * @brief 魔道具の使用回数の残量を示すメッセージを表示する /
4513  * Describe the charges on an item in the inventory.
4514  * @param owner_ptr プレーヤーへの参照ポインタ
4515  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
4516  * @return なし
4517  */
4518 void inven_item_charges(player_type *owner_ptr, INVENTORY_IDX item)
4519 {
4520         object_type *o_ptr = &owner_ptr->inventory_list[item];
4521
4522         /* Require staff/wand */
4523         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
4524
4525         /* Require known item */
4526         if (!object_is_known(o_ptr)) return;
4527
4528 #ifdef JP
4529         if (o_ptr->pval <= 0)
4530         {
4531                 msg_print("もう魔力が残っていない。");
4532         }
4533         else
4534         {
4535                 msg_format("あと %d 回分の魔力が残っている。", o_ptr->pval);
4536         }
4537 #else
4538         /* Multiple charges */
4539         if (o_ptr->pval != 1)
4540         {
4541                 msg_format("You have %d charges remaining.", o_ptr->pval);
4542         }
4543
4544         /* Single charge */
4545         else
4546         {
4547                 msg_format("You have %d charge remaining.", o_ptr->pval);
4548         }
4549 #endif
4550
4551 }
4552
4553 /*!
4554  * @brief アイテムの残り所持数メッセージを表示する /
4555  * Describe an item in the inventory.
4556  * @param owner_ptr プレーヤーへの参照ポインタ
4557  * @param item 残量を表示したいプレイヤーのアイテム所持スロット
4558  * @return なし
4559  */
4560 void inven_item_describe(player_type *owner_ptr, INVENTORY_IDX item)
4561 {
4562         object_type *o_ptr = &owner_ptr->inventory_list[item];
4563         GAME_TEXT o_name[MAX_NLEN];
4564
4565         object_desc(o_name, o_ptr, 0);
4566
4567 #ifdef JP
4568         /* "no more" の場合はこちらで表示する */
4569         if (o_ptr->number <= 0)
4570         {
4571                 /*FIRST*//*ここはもう通らないかも */
4572                 msg_format("もう%sを持っていない。", o_name);
4573         }
4574         else
4575         {
4576                 /* アイテム名を英日切り替え機能対応 */
4577                 msg_format("まだ %sを持っている。", o_name);
4578         }
4579 #else
4580         msg_format("You have %s.", o_name);
4581 #endif
4582
4583 }
4584
4585
4586 void vary_item(player_type *owner_ptr, INVENTORY_IDX item, ITEM_NUMBER num)
4587 {
4588         if (item >= 0)
4589         {
4590                 inven_item_increase(owner_ptr, item, num);
4591                 inven_item_describe(owner_ptr, item);
4592                 inven_item_optimize(owner_ptr, item);
4593                 return;
4594         }
4595
4596         floor_type *floor_ptr = owner_ptr->current_floor_ptr;
4597         floor_item_increase(floor_ptr, 0 - item, num);
4598         floor_item_describe(floor_ptr, 0 - item);
4599         floor_item_optimize(floor_ptr, 0 - item);
4600 }
4601
4602
4603 /*!
4604  * @brief アイテムを増減させ残り所持数メッセージを表示する /
4605  * Increase the "number" of an item in the inventory
4606  * @param owner_ptr プレーヤーへの参照ポインタ
4607  * @param item 所持数を増やしたいプレイヤーのアイテム所持スロット
4608  * @param num 増やしたい量
4609  * @return なし
4610  */
4611 void inven_item_increase(player_type *owner_ptr, INVENTORY_IDX item, ITEM_NUMBER num)
4612 {
4613         object_type *o_ptr = &owner_ptr->inventory_list[item];
4614
4615         /* Apply */
4616         num += o_ptr->number;
4617
4618         /* Bounds check */
4619         if (num > 255) num = 255;
4620         else if (num < 0) num = 0;
4621
4622         /* Un-apply */
4623         num -= o_ptr->number;
4624
4625         /* Change the number and weight */
4626         if (num != 0) return;
4627
4628         /* Add the number */
4629         o_ptr->number += num;
4630
4631         /* Add the weight */
4632         owner_ptr->total_weight += (num * o_ptr->weight);
4633         owner_ptr->update |= (PU_BONUS);
4634         owner_ptr->update |= (PU_MANA);
4635         owner_ptr->update |= (PU_COMBINE);
4636         owner_ptr->window |= (PW_INVEN | PW_EQUIP);
4637
4638         /* Hack -- Clear temporary elemental brands if player takes off weapons */
4639         if (o_ptr->number || !owner_ptr->ele_attack) return;
4640         if (!(item == INVEN_RARM) && !(item == INVEN_LARM)) return;
4641         if (has_melee_weapon(owner_ptr, INVEN_RARM + INVEN_LARM - item)) return;
4642
4643         /* Clear all temporary elemental brands */
4644         set_ele_attack(owner_ptr, 0, 0);
4645 }
4646
4647
4648 /*!
4649  * @brief 所持アイテムスロットから所持数のなくなったアイテムを消去する /
4650  * Erase an inventory slot if it has no more items
4651  * @param owner_ptr プレーヤーへの参照ポインタ
4652  * @param item 消去したいプレイヤーのアイテム所持スロット
4653  * @return なし
4654  */
4655 void inven_item_optimize(player_type *owner_ptr, INVENTORY_IDX item)
4656 {
4657         object_type *o_ptr = &owner_ptr->inventory_list[item];
4658
4659         /* Only optimize real items */
4660         if (!o_ptr->k_idx) return;
4661
4662         /* Only optimize empty items */
4663         if (o_ptr->number) return;
4664
4665         /* The item is in the pack */
4666         if (item < INVEN_RARM)
4667         {
4668                 int i;
4669
4670                 /* One less item */
4671                 owner_ptr->inven_cnt--;
4672
4673                 /* Slide everything down */
4674                 for (i = item; i < INVEN_PACK; i++)
4675                 {
4676                         /* Structure copy */
4677                         owner_ptr->inventory_list[i] = owner_ptr->inventory_list[i + 1];
4678                 }
4679
4680                 /* Erase the "final" slot */
4681                 object_wipe(&owner_ptr->inventory_list[i]);
4682
4683                 owner_ptr->window |= (PW_INVEN);
4684         }
4685
4686         /* The item is being wielded */
4687         else
4688         {
4689                 /* One less item */
4690                 owner_ptr->equip_cnt--;
4691
4692                 /* Erase the empty slot */
4693                 object_wipe(&owner_ptr->inventory_list[item]);
4694                 owner_ptr->update |= (PU_BONUS);
4695                 owner_ptr->update |= (PU_TORCH);
4696                 owner_ptr->update |= (PU_MANA);
4697
4698                 owner_ptr->window |= (PW_EQUIP);
4699         }
4700
4701         owner_ptr->window |= (PW_SPELL);
4702 }
4703
4704
4705 /*!
4706  * @brief 床上の魔道具の残り残量メッセージを表示する /
4707  * Describe the charges on an item on the floor.
4708  * @param floo_ptr 現在フロアへの参照ポインタ
4709  * @param item メッセージの対象にしたいアイテム所持スロット
4710  * @return なし
4711  */
4712 void floor_item_charges(floor_type *floor_ptr, INVENTORY_IDX item)
4713 {
4714         object_type *o_ptr = &floor_ptr->o_list[item];
4715
4716         /* Require staff/wand */
4717         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
4718
4719         /* Require known item */
4720         if (!object_is_known(o_ptr)) return;
4721
4722 #ifdef JP
4723         if (o_ptr->pval <= 0)
4724         {
4725                 msg_print("この床上のアイテムは、もう魔力が残っていない。");
4726         }
4727         else
4728         {
4729                 msg_format("この床上のアイテムは、あと %d 回分の魔力が残っている。", o_ptr->pval);
4730         }
4731 #else
4732         /* Multiple charges */
4733         if (o_ptr->pval != 1)
4734         {
4735                 msg_format("There are %d charges remaining.", o_ptr->pval);
4736         }
4737
4738         /* Single charge */
4739         else
4740         {
4741                 msg_format("There is %d charge remaining.", o_ptr->pval);
4742         }
4743 #endif
4744
4745 }
4746
4747
4748 /*!
4749  * @brief 床上のアイテムの残り数メッセージを表示する /
4750  * Describe the charges on an item on the floor.
4751  * @param floo_ptr 現在フロアへの参照ポインタ
4752  * @param item メッセージの対象にしたいアイテム所持スロット
4753  * @return なし
4754  */
4755 void floor_item_describe(floor_type *floor_ptr, INVENTORY_IDX item)
4756 {
4757         object_type *o_ptr = &floor_ptr->o_list[item];
4758         GAME_TEXT o_name[MAX_NLEN];
4759
4760         object_desc(o_name, o_ptr, 0);
4761
4762 #ifdef JP
4763         /* "no more" の場合はこちらで表示を分ける */
4764         if (o_ptr->number <= 0)
4765         {
4766                 msg_format("床上には、もう%sはない。", o_name);
4767         }
4768         else
4769         {
4770                 msg_format("床上には、まだ %sがある。", o_name);
4771         }
4772 #else
4773         msg_format("You see %s.", o_name);
4774 #endif
4775
4776 }
4777
4778
4779 /*!
4780  * @brief 床上のアイテムの数を増やす /
4781  * Increase the "number" of an item on the floor
4782  * @param floo_ptr 現在フロアへの参照ポインタ
4783  * @param item 増やしたいアイテムの所持スロット
4784  * @param num 増やしたいアイテムの数
4785  * @return なし
4786  */
4787 void floor_item_increase(floor_type *floor_ptr, INVENTORY_IDX item, ITEM_NUMBER num)
4788 {
4789         object_type *o_ptr = &floor_ptr->o_list[item];
4790
4791         /* Apply */
4792         num += o_ptr->number;
4793
4794         /* Bounds check */
4795         if (num > 255) num = 255;
4796         else if (num < 0) num = 0;
4797
4798         /* Un-apply */
4799         num -= o_ptr->number;
4800
4801         /* Change the number */
4802         o_ptr->number += num;
4803 }
4804
4805
4806 /*!
4807  * @brief 床上の数の無くなったアイテムスロットを消去する /
4808  * Optimize an item on the floor (destroy "empty" items)
4809  * @param floo_ptr 現在フロアへの参照ポインタ
4810  * @param item 消去したいアイテムの所持スロット
4811  * @return なし
4812  */
4813 void floor_item_optimize(floor_type *floor_ptr, INVENTORY_IDX item)
4814 {
4815         object_type *o_ptr = &floor_ptr->o_list[item];
4816
4817         /* Paranoia -- be sure it exists */
4818         if (!o_ptr->k_idx) return;
4819
4820         /* Only optimize empty items */
4821         if (o_ptr->number) return;
4822
4823         delete_object_idx(floor_ptr, item);
4824 }
4825
4826
4827 /*!
4828  * @brief アイテムを拾う際にザックから溢れずに済むかを判定する /
4829  * Check if we have space for an item in the pack without overflow
4830  * @param owner_ptr プレーヤーへの参照ポインタ
4831  * @param o_ptr 拾いたいオブジェクトの構造体参照ポインタ
4832  * @return 溢れずに済むならTRUEを返す
4833  */
4834 bool inven_carry_okay(object_type *o_ptr)
4835 {
4836         int j;
4837
4838         /* Empty slot? */
4839         if (p_ptr->inven_cnt < INVEN_PACK) return (TRUE);
4840
4841         /* Similar slot? */
4842         for (j = 0; j < INVEN_PACK; j++)
4843         {
4844                 object_type *j_ptr = &p_ptr->inventory_list[j];
4845                 if (!j_ptr->k_idx) continue;
4846
4847                 /* Check if the two items can be combined */
4848                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
4849         }
4850
4851         return (FALSE);
4852 }
4853
4854 /*!
4855  * @brief オブジェクトを定義された基準に従いソートするための関数 /
4856  * Check if we have space for an item in the pack without overflow
4857  * @param o_ptr 比較対象オブジェクトの構造体参照ポインタ1
4858  * @param o_value o_ptrのアイテム価値（手動であらかじめ代入する必要がある？）
4859  * @param j_ptr 比較対象オブジェクトの構造体参照ポインタ2
4860  * @return o_ptrの方が上位ならばTRUEを返す。
4861  */
4862 bool object_sort_comp(object_type *o_ptr, s32b o_value, object_type *j_ptr)
4863 {
4864         int o_type, j_type;
4865
4866         /* Use empty slots */
4867         if (!j_ptr->k_idx) return TRUE;
4868
4869         /* Hack -- readable books always come first */
4870         if ((o_ptr->tval == REALM1_BOOK) &&
4871                 (j_ptr->tval != REALM1_BOOK)) return TRUE;
4872         if ((j_ptr->tval == REALM1_BOOK) &&
4873                 (o_ptr->tval != REALM1_BOOK)) return FALSE;
4874
4875         if ((o_ptr->tval == REALM2_BOOK) &&
4876                 (j_ptr->tval != REALM2_BOOK)) return TRUE;
4877         if ((j_ptr->tval == REALM2_BOOK) &&
4878                 (o_ptr->tval != REALM2_BOOK)) return FALSE;
4879
4880         /* Objects sort by decreasing type */
4881         if (o_ptr->tval > j_ptr->tval) return TRUE;
4882         if (o_ptr->tval < j_ptr->tval) return FALSE;
4883
4884         /* Non-aware (flavored) items always come last */
4885         /* Can happen in the home */
4886         if (!object_is_aware(o_ptr)) return FALSE;
4887         if (!object_is_aware(j_ptr)) return TRUE;
4888
4889         /* Objects sort by increasing sval */
4890         if (o_ptr->sval < j_ptr->sval) return TRUE;
4891         if (o_ptr->sval > j_ptr->sval) return FALSE;
4892
4893         /* Unidentified objects always come last */
4894         /* Objects in the home can be unknown */
4895         if (!object_is_known(o_ptr)) return FALSE;
4896         if (!object_is_known(j_ptr)) return TRUE;
4897
4898         /* Fixed artifacts, random artifacts and ego items */
4899         if (object_is_fixed_artifact(o_ptr)) o_type = 3;
4900         else if (o_ptr->art_name) o_type = 2;
4901         else if (object_is_ego(o_ptr)) o_type = 1;
4902         else o_type = 0;
4903
4904         if (object_is_fixed_artifact(j_ptr)) j_type = 3;
4905         else if (j_ptr->art_name) j_type = 2;
4906         else if (object_is_ego(j_ptr)) j_type = 1;
4907         else j_type = 0;
4908
4909         if (o_type < j_type) return TRUE;
4910         if (o_type > j_type) return FALSE;
4911
4912         switch (o_ptr->tval)
4913         {
4914         case TV_FIGURINE:
4915         case TV_STATUE:
4916         case TV_CORPSE:
4917         case TV_CAPTURE:
4918                 if (r_info[o_ptr->pval].level < r_info[j_ptr->pval].level) return TRUE;
4919                 if ((r_info[o_ptr->pval].level == r_info[j_ptr->pval].level) && (o_ptr->pval < j_ptr->pval)) return TRUE;
4920                 return FALSE;
4921
4922         case TV_SHOT:
4923         case TV_ARROW:
4924         case TV_BOLT:
4925                 /* Objects sort by increasing hit/damage bonuses */
4926                 if (o_ptr->to_h + o_ptr->to_d < j_ptr->to_h + j_ptr->to_d) return TRUE;
4927                 if (o_ptr->to_h + o_ptr->to_d > j_ptr->to_h + j_ptr->to_d) return FALSE;
4928                 break;
4929
4930                 /* Hack:  otherwise identical rods sort by
4931                 increasing recharge time --dsb */
4932         case TV_ROD:
4933                 if (o_ptr->pval < j_ptr->pval) return TRUE;
4934                 if (o_ptr->pval > j_ptr->pval) return FALSE;
4935                 break;
4936         }
4937
4938         /* Objects sort by decreasing value */
4939         return o_value > object_value(j_ptr);
4940 }
4941
4942
4943 /*!
4944  * @brief オブジェクトをプレイヤーが拾って所持スロットに納めるメインルーチン /
4945  * Add an item to the players inventory, and return the slot used.
4946  * @param o_ptr 拾うオブジェクトの構造体参照ポインタ
4947  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
4948  * @details
4949  * If the new item can combine with an existing item in the inventory,\n
4950  * it will do so, using "object_similar()" and "object_absorb()", else,\n
4951  * the item will be placed into the "proper" location in the inventory.\n
4952  *\n
4953  * This function can be used to "over-fill" the player's pack, but only\n
4954  * once, and such an action must trigger the "overflow" code immediately.\n
4955  * Note that when the pack is being "over-filled", the new item must be\n
4956  * placed into the "overflow" slot, and the "overflow" must take place\n
4957  * before the pack is reordered, but (optionally) after the pack is\n
4958  * combined.  This may be tricky.  See "dungeon.c" for info.\n
4959  *\n
4960  * Note that this code must remove any location/stack information\n
4961  * from the object once it is placed into the inventory.\n
4962  */
4963 s16b inven_carry(player_type *owner_ptr, object_type *o_ptr)
4964 {
4965         INVENTORY_IDX i, j, k;
4966         INVENTORY_IDX n = -1;
4967
4968         object_type *j_ptr;
4969
4970
4971         /* Check for combining */
4972         for (j = 0; j < INVEN_PACK; j++)
4973         {
4974                 j_ptr = &owner_ptr->inventory_list[j];
4975                 if (!j_ptr->k_idx) continue;
4976
4977                 /* Hack -- track last item */
4978                 n = j;
4979
4980                 /* Check if the two items can be combined */
4981                 if (object_similar(j_ptr, o_ptr))
4982                 {
4983                         object_absorb(j_ptr, o_ptr);
4984
4985                         owner_ptr->total_weight += (o_ptr->number * o_ptr->weight);
4986                         owner_ptr->update |= (PU_BONUS);
4987                         owner_ptr->window |= (PW_INVEN);
4988
4989                         /* Success */
4990                         return (j);
4991                 }
4992         }
4993
4994         if (owner_ptr->inven_cnt > INVEN_PACK) return (-1);
4995
4996         /* Find an empty slot */
4997         for (j = 0; j <= INVEN_PACK; j++)
4998         {
4999                 j_ptr = &owner_ptr->inventory_list[j];
5000
5001                 /* Use it if found */
5002                 if (!j_ptr->k_idx) break;
5003         }
5004
5005         /* Use that slot */
5006         i = j;
5007
5008
5009         /* Reorder the pack */
5010         if (i < INVEN_PACK)
5011         {
5012                 /* Get the "value" of the item */
5013                 s32b o_value = object_value(o_ptr);
5014
5015                 /* Scan every occupied slot */
5016                 for (j = 0; j < INVEN_PACK; j++)
5017                 {
5018                         if (object_sort_comp(o_ptr, o_value, &owner_ptr->inventory_list[j])) break;
5019                 }
5020
5021                 /* Use that slot */
5022                 i = j;
5023
5024                 /* Slide objects */
5025                 for (k = n; k >= i; k--)
5026                 {
5027                         /* Hack -- Slide the item */
5028                         object_copy(&owner_ptr->inventory_list[k + 1], &owner_ptr->inventory_list[k]);
5029                 }
5030
5031                 /* Wipe the empty slot */
5032                 object_wipe(&owner_ptr->inventory_list[i]);
5033         }
5034
5035
5036         /* Copy the item */
5037         object_copy(&owner_ptr->inventory_list[i], o_ptr);
5038
5039         /* Access new object */
5040         j_ptr = &owner_ptr->inventory_list[i];
5041
5042         /* Forget stack */
5043         j_ptr->next_o_idx = 0;
5044
5045         /* Forget monster */
5046         j_ptr->held_m_idx = 0;
5047
5048         /* Forget location */
5049         j_ptr->iy = j_ptr->ix = 0;
5050
5051         /* Player touches it, and no longer marked */
5052         j_ptr->marked = OM_TOUCHED;
5053
5054         owner_ptr->total_weight += (j_ptr->number * j_ptr->weight);
5055
5056         /* Count the items */
5057         owner_ptr->inven_cnt++;
5058         owner_ptr->update |= (PU_BONUS | PU_COMBINE | PU_REORDER);
5059         owner_ptr->window |= (PW_INVEN);
5060
5061         /* Return the slot */
5062         return (i);
5063 }
5064
5065
5066 /*!
5067  * @brief 装備スロットからオブジェクトを外すメインルーチン /
5068  * Take off (some of) a non-cursed equipment item
5069  * @param owner_ptr プレーヤーへの参照ポインタ
5070  * @param item オブジェクトを外したい所持テーブルのID
5071  * @param amt 外したい個数
5072  * @return 収められた所持スロットのID、拾うことができなかった場合-1を返す。
5073  * @details
5074  * Note that only one item at a time can be wielded per slot.\n
5075  * Note that taking off an item when "full" may cause that item\n
5076  * to fall to the ground.\n
5077  * Return the inventory slot into which the item is placed.\n
5078  */
5079 INVENTORY_IDX inven_takeoff(player_type *owner_ptr, INVENTORY_IDX item, ITEM_NUMBER amt)
5080 {
5081         INVENTORY_IDX slot;
5082
5083         object_type forge;
5084         object_type *q_ptr;
5085
5086         object_type *o_ptr;
5087
5088         concptr act;
5089
5090         GAME_TEXT o_name[MAX_NLEN];
5091
5092
5093         /* Get the item to take off */
5094         o_ptr = &owner_ptr->inventory_list[item];
5095         if (amt <= 0) return (-1);
5096
5097         /* Verify */
5098         if (amt > o_ptr->number) amt = o_ptr->number;
5099         q_ptr = &forge;
5100         object_copy(q_ptr, o_ptr);
5101
5102         /* Modify quantity */
5103         q_ptr->number = amt;
5104
5105         object_desc(o_name, q_ptr, 0);
5106
5107         /* Took off weapon */
5108         if (((item == INVEN_RARM) || (item == INVEN_LARM)) &&
5109                 object_is_melee_weapon(o_ptr))
5110         {
5111                 act = _("を装備からはずした", "You were wielding");
5112         }
5113
5114         /* Took off bow */
5115         else if (item == INVEN_BOW)
5116         {
5117                 act = _("を装備からはずした", "You were holding");
5118         }
5119
5120         /* Took off light */
5121         else if (item == INVEN_LITE)
5122         {
5123                 act = _("を光源からはずした", "You were holding");
5124         }
5125
5126         /* Took off something */
5127         else
5128         {
5129                 act = _("を装備からはずした", "You were wearing");
5130         }
5131
5132         /* Modify, Optimize */
5133         inven_item_increase(owner_ptr, item, -amt);
5134         inven_item_optimize(owner_ptr, item);
5135
5136         /* Carry the object */
5137         slot = inven_carry(owner_ptr, q_ptr);
5138
5139 #ifdef JP
5140         msg_format("%s(%c)%s。", o_name, index_to_label(slot), act);
5141 #else
5142         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
5143 #endif
5144
5145
5146         /* Return slot */
5147         return (slot);
5148 }
5149
5150
5151 /*!
5152  * @brief 所持スロットから床下にオブジェクトを落とすメインルーチン /
5153  * Drop (some of) a non-cursed inventory/equipment item
5154  * @param owner_ptr プレーヤーへの参照ポインタ
5155  * @param item 所持テーブルのID
5156  * @param amt 落としたい個数
5157  * @return なし
5158  * @details
5159  * The object will be dropped "near" the current location
5160  */
5161 void drop_from_inventory(player_type *owner_ptr, INVENTORY_IDX item, ITEM_NUMBER amt)
5162 {
5163         object_type forge;
5164         object_type *q_ptr;
5165         object_type *o_ptr;
5166
5167         GAME_TEXT o_name[MAX_NLEN];
5168
5169         /* Access original object */
5170         o_ptr = &owner_ptr->inventory_list[item];
5171
5172         /* Error check */
5173         if (amt <= 0) return;
5174
5175         /* Not too many */
5176         if (amt > o_ptr->number) amt = o_ptr->number;
5177
5178         /* Take off equipment */
5179         if (item >= INVEN_RARM)
5180         {
5181                 /* Take off first */
5182                 item = inven_takeoff(owner_ptr, item, amt);
5183
5184                 /* Access original object */
5185                 o_ptr = &owner_ptr->inventory_list[item];
5186         }
5187
5188         q_ptr = &forge;
5189
5190         /* Obtain local object */
5191         object_copy(q_ptr, o_ptr);
5192
5193         /* Distribute charges of wands or rods */
5194         distribute_charges(o_ptr, q_ptr, amt);
5195
5196         /* Modify quantity */
5197         q_ptr->number = amt;
5198
5199         /* Describe local object */
5200         object_desc(o_name, q_ptr, 0);
5201
5202         msg_format(_("%s(%c)を落とした。", "You drop %s (%c)."), o_name, index_to_label(item));
5203
5204         /* Drop it near the player */
5205         (void)drop_near(owner_ptr, q_ptr, 0, owner_ptr->y, owner_ptr->x);
5206
5207         vary_item(owner_ptr, item, -amt);
5208 }
5209
5210
5211 /*!
5212  * @brief プレイヤーの所持スロットに存在するオブジェクトをまとめなおす /
5213  * Combine items in the pack
5214  * @return なし
5215  * @details
5216  * Note special handling of the "overflow" slot
5217  */
5218 void combine_pack(player_type *owner_ptr)
5219 {
5220         int             i, j, k;
5221         object_type *o_ptr;
5222         object_type     *j_ptr;
5223         bool            flag = FALSE, combined;
5224
5225         do
5226         {
5227                 combined = FALSE;
5228
5229                 /* Combine the pack (backwards) */
5230                 for (i = INVEN_PACK; i > 0; i--)
5231                 {
5232                         o_ptr = &owner_ptr->inventory_list[i];
5233
5234                         /* Skip empty items */
5235                         if (!o_ptr->k_idx) continue;
5236
5237                         /* Scan the items above that item */
5238                         for (j = 0; j < i; j++)
5239                         {
5240                                 int max_num;
5241
5242                                 j_ptr = &owner_ptr->inventory_list[j];
5243
5244                                 /* Skip empty items */
5245                                 if (!j_ptr->k_idx) continue;
5246
5247                                 /*
5248                                  * Get maximum number of the stack if these
5249                                  * are similar, get zero otherwise.
5250                                  */
5251                                 max_num = object_similar_part(j_ptr, o_ptr);
5252
5253                                 /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
5254                                 if (max_num && j_ptr->number < max_num)
5255                                 {
5256                                         if (o_ptr->number + j_ptr->number <= max_num)
5257                                         {
5258                                                 /* Take note */
5259                                                 flag = TRUE;
5260
5261                                                 /* Add together the item counts */
5262                                                 object_absorb(j_ptr, o_ptr);
5263
5264                                                 /* One object is gone */
5265                                                 owner_ptr->inven_cnt--;
5266
5267                                                 /* Slide everything down */
5268                                                 for (k = i; k < INVEN_PACK; k++)
5269                                                 {
5270                                                         /* Structure copy */
5271                                                         owner_ptr->inventory_list[k] = owner_ptr->inventory_list[k + 1];
5272                                                 }
5273
5274                                                 /* Erase the "final" slot */
5275                                                 object_wipe(&owner_ptr->inventory_list[k]);
5276                                         }
5277                                         else
5278                                         {
5279                                                 int old_num = o_ptr->number;
5280                                                 int remain = j_ptr->number + o_ptr->number - max_num;
5281 #if 0
5282                                                 o_ptr->number -= remain;
5283 #endif
5284                                                 /* Add together the item counts */
5285                                                 object_absorb(j_ptr, o_ptr);
5286
5287                                                 o_ptr->number = remain;
5288
5289                                                 /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
5290                                                 if (o_ptr->tval == TV_ROD)
5291                                                 {
5292                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
5293                                                         o_ptr->timeout = o_ptr->timeout * remain / old_num;
5294                                                 }
5295
5296                                                 /* Hack -- if wands are stacking, combine the charges. -LM- */
5297                                                 if (o_ptr->tval == TV_WAND)
5298                                                 {
5299                                                         o_ptr->pval = o_ptr->pval * remain / old_num;
5300                                                 }
5301                                         }
5302
5303                                         owner_ptr->window |= (PW_INVEN);
5304
5305                                         /* Take note */
5306                                         combined = TRUE;
5307
5308                                         break;
5309                                 }
5310                         }
5311                 }
5312         } while (combined);
5313
5314         if (flag) msg_print(_("ザックの中のアイテムをまとめ直した。", "You combine some items in your pack."));
5315 }
5316
5317
5318 /*!
5319  * @brief プレイヤーの所持スロットに存在するオブジェクトを並び替える /
5320  * Reorder items in the pack
5321  * @param owner_ptr プレーヤーへの参照ポインタ
5322  * @return なし
5323  * @details
5324  * Note special handling of the "overflow" slot
5325  */
5326 void reorder_pack(player_type *owner_ptr)
5327 {
5328         int             i, j, k;
5329         s32b            o_value;
5330         object_type     forge;
5331         object_type     *q_ptr;
5332         object_type *o_ptr;
5333         bool            flag = FALSE;
5334
5335         /* Re-order the pack (forwards) */
5336         for (i = 0; i < INVEN_PACK; i++)
5337         {
5338                 /* Mega-Hack -- allow "proper" over-flow */
5339                 if ((i == INVEN_PACK) && (owner_ptr->inven_cnt == INVEN_PACK)) break;
5340
5341                 o_ptr = &owner_ptr->inventory_list[i];
5342
5343                 /* Skip empty slots */
5344                 if (!o_ptr->k_idx) continue;
5345
5346                 /* Get the "value" of the item */
5347                 o_value = object_value(o_ptr);
5348
5349                 /* Scan every occupied slot */
5350                 for (j = 0; j < INVEN_PACK; j++)
5351                 {
5352                         if (object_sort_comp(o_ptr, o_value, &owner_ptr->inventory_list[j])) break;
5353                 }
5354
5355                 /* Never move down */
5356                 if (j >= i) continue;
5357
5358                 /* Take note */
5359                 flag = TRUE;
5360                 q_ptr = &forge;
5361
5362                 /* Save a copy of the moving item */
5363                 object_copy(q_ptr, &owner_ptr->inventory_list[i]);
5364
5365                 /* Slide the objects */
5366                 for (k = i; k > j; k--)
5367                 {
5368                         /* Slide the item */
5369                         object_copy(&owner_ptr->inventory_list[k], &owner_ptr->inventory_list[k - 1]);
5370                 }
5371
5372                 /* Insert the moving item */
5373                 object_copy(&owner_ptr->inventory_list[j], q_ptr);
5374
5375                 owner_ptr->window |= (PW_INVEN);
5376         }
5377
5378         if (flag) msg_print(_("ザックの中のアイテムを並べ直した。", "You reorder some items in your pack."));
5379 }
5380
5381
5382 /*!
5383  * @brief 現在アクティブになっているウィンドウにオブジェクトの詳細を表示する /
5384  * Hack -- display an object kind in the current window
5385  * @param owner_ptr プレーヤーへの参照ポインタ
5386  * @param k_idx ベースアイテムの参照ID
5387  * @return なし
5388  * @details
5389  * Include list of usable spells for readible books
5390  */
5391 void display_koff(player_type *owner_ptr, KIND_OBJECT_IDX k_idx)
5392 {
5393         int y;
5394
5395         object_type forge;
5396         object_type *q_ptr;
5397         int         sval;
5398         REALM_IDX   use_realm;
5399
5400         GAME_TEXT o_name[MAX_NLEN];
5401
5402
5403         /* Erase the window */
5404         for (y = 0; y < Term->hgt; y++)
5405         {
5406                 /* Erase the line */
5407                 Term_erase(0, y, 255);
5408         }
5409
5410         /* No info */
5411         if (!k_idx) return;
5412         q_ptr = &forge;
5413
5414         /* Prepare the object */
5415         object_prep(q_ptr, k_idx);
5416         object_desc(o_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY | OD_STORE));
5417
5418         /* Mention the object name */
5419         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
5420
5421         /* Access the item's sval */
5422         sval = q_ptr->sval;
5423         use_realm = tval2realm(q_ptr->tval);
5424
5425         /* Warriors are illiterate */
5426         if (owner_ptr->realm1 || owner_ptr->realm2)
5427         {
5428                 if ((use_realm != owner_ptr->realm1) && (use_realm != owner_ptr->realm2)) return;
5429         }
5430         else
5431         {
5432                 if ((owner_ptr->pclass != CLASS_SORCERER) && (owner_ptr->pclass != CLASS_RED_MAGE)) return;
5433                 if (!is_magic(use_realm)) return;
5434                 if ((owner_ptr->pclass == CLASS_RED_MAGE) && (use_realm != REALM_ARCANE) && (sval > 1)) return;
5435         }
5436
5437         /* Display spells in readible books */
5438         int     spell = -1;
5439         int     num = 0;
5440         SPELL_IDX    spells[64];
5441
5442         /* Extract spells */
5443         for (spell = 0; spell < 32; spell++)
5444         {
5445                 /* Check for this spell */
5446                 if (fake_spell_flags[sval] & (1L << spell))
5447                 {
5448                         /* Collect this spell */
5449                         spells[num++] = spell;
5450                 }
5451         }
5452
5453         /* Print spells */
5454         print_spells(owner_ptr, 0, spells, num, 2, 0, use_realm);
5455 }
5456
5457
5458 /*!
5459  * @brief 投擲時たいまつに投げやすい/焼棄/アンデッドスレイの特別効果を返す。
5460  * Torches have special abilities when they are flaming.
5461  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
5462  * @param flgs 特別に追加するフラグを返す参照ポインタ
5463  * @return なし
5464  */
5465 void torch_flags(object_type *o_ptr, BIT_FLAGS *flgs)
5466 {
5467         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
5468         {
5469                 if (o_ptr->xtra4 > 0)
5470                 {
5471                         add_flag(flgs, TR_BRAND_FIRE);
5472                         add_flag(flgs, TR_KILL_UNDEAD);
5473                         add_flag(flgs, TR_THROW);
5474                 }
5475         }
5476 }
5477
5478
5479 /*!
5480  * @brief 投擲時たいまつにダイスを与える。
5481  * Torches have special abilities when they are flaming.
5482  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
5483  * @param dd 特別なダイス数を返す参照ポインタ
5484  * @param ds 特別なダイス面数を返す参照ポインタ
5485  * @return なし
5486  */
5487 void torch_dice(object_type *o_ptr, DICE_NUMBER *dd, DICE_SID *ds)
5488 {
5489         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
5490         {
5491                 if (o_ptr->xtra4 > 0)
5492                 {
5493                         (*dd) = 1;
5494                         (*ds) = 6;
5495                 }
5496         }
5497 }
5498
5499
5500 /*!
5501  * @brief 投擲時命中したたいまつの寿命を縮める。
5502  * Torches have special abilities when they are flaming.
5503  * @param o_ptr 投擲するオブジェクトの構造体参照ポインタ
5504  * @return なし
5505  */
5506 void torch_lost_fuel(object_type *o_ptr)
5507 {
5508         if ((o_ptr->tval == TV_LITE) && (o_ptr->sval == SV_LITE_TORCH))
5509         {
5510                 o_ptr->xtra4 -= (FUEL_TORCH / 25);
5511                 if (o_ptr->xtra4 < 0) o_ptr->xtra4 = 0;
5512         }
5513 }
5514
5515
5516 /*!
5517  * @brief 射撃武器に対応する矢/弾薬のベースアイテムIDを返す /
5518  * @param o_ptr 判定する射撃武器のアイテム情報参照ポインタ
5519  * @return 対応する矢/弾薬のベースアイテムID
5520  */
5521 int bow_tval_ammo(object_type *o_ptr)
5522 {
5523         /* Analyze the launcher */
5524         switch (o_ptr->sval)
5525         {
5526         case SV_SLING:
5527         {
5528                 return TV_SHOT;
5529         }
5530
5531         case SV_SHORT_BOW:
5532         case SV_LONG_BOW:
5533         case SV_NAMAKE_BOW:
5534         {
5535                 return TV_ARROW;
5536         }
5537
5538         case SV_LIGHT_XBOW:
5539         case SV_HEAVY_XBOW:
5540         {
5541                 return TV_BOLT;
5542         }
5543         case SV_CRIMSON:
5544         case SV_HARP:
5545         {
5546                 return TV_NO_AMMO;
5547         }
5548         }
5549
5550         return 0;
5551 }