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