src/object2.c

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