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