src/object2.c

   1 /* File: object2.c */
   2
   3 /* Purpose: Object code, part 2 */
   4
   5 /*
   6  * Copyright (c) 1989 James E. Wilson, Robert A. Koeneke
   7  *
   8  * This software may be copied and distributed for educational, research, and
   9  * not for profit purposes provided that this copyright and statement are
  10  * included in all such copies.
  11  */
  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 void add_esp_strong(object_type *o_ptr)
2579 {
2580         switch (randint1(3))
2581         {
2582         case 1: add_flag(o_ptr->art_flags, TR_ESP_EVIL); break;
2583         case 2: add_flag(o_ptr->art_flags, TR_ESP_NONLIVING); break;
2584         case 3: add_flag(o_ptr->art_flags, TR_TELEPATHY); break;
2585         }
2586 }
2587
2588
2589 static void add_esp_weak(object_type *o_ptr)
2590 {
2591         int idx[3];
2592         int n = randint1(3);
2593
2594         idx[0] = randint1(9);
2595
2596         idx[1] = randint1(8);
2597         if (idx[1] >= idx[0]) idx[1]++;
2598
2599         idx[2] = randint1(7);
2600         if (idx[2] >= idx[0]) idx[2]++;
2601         if (idx[2] >= idx[1]) idx[2]++;
2602
2603         while (n--) switch (idx[n])
2604         {
2605         case 1: add_flag(o_ptr->art_flags, TR_ESP_ANIMAL); break;
2606         case 2: add_flag(o_ptr->art_flags, TR_ESP_UNDEAD); break;
2607         case 3: add_flag(o_ptr->art_flags, TR_ESP_DEMON); break;
2608         case 4: add_flag(o_ptr->art_flags, TR_ESP_ORC); break;
2609         case 5: add_flag(o_ptr->art_flags, TR_ESP_TROLL); break;
2610         case 6: add_flag(o_ptr->art_flags, TR_ESP_GIANT); break;
2611         case 7: add_flag(o_ptr->art_flags, TR_ESP_DRAGON);   break;
2612         case 8: add_flag(o_ptr->art_flags, TR_ESP_HUMAN); break;
2613         case 9: add_flag(o_ptr->art_flags, TR_ESP_GOOD); break;
2614         }
2615 }
2616
2617
2618 /*
2619  * Apply magic to an item known to be "armor"
2620  *
2621  * Hack -- note special processing for crown/helm
2622  * Hack -- note special processing for robe of permanence
2623  */
2624 static void a_m_aux_2(object_type *o_ptr, int level, int power)
2625 {
2626         int toac1 = randint1(5) + m_bonus(5, level);
2627
2628         int toac2 = m_bonus(10, level);
2629
2630         /* Good */
2631         if (power > 0)
2632         {
2633                 /* Enchant */
2634                 o_ptr->to_a += toac1;
2635
2636                 /* Very good */
2637                 if (power > 1)
2638                 {
2639                         /* Enchant again */
2640                         o_ptr->to_a += toac2;
2641                 }
2642         }
2643
2644         /* Cursed */
2645         else if (power < 0)
2646         {
2647                 /* Penalize */
2648                 o_ptr->to_a -= toac1;
2649
2650                 /* Very cursed */
2651                 if (power < -1)
2652                 {
2653                         /* Penalize again */
2654                         o_ptr->to_a -= toac2;
2655                 }
2656
2657                 /* Cursed (if "bad") */
2658                 if (o_ptr->to_a < 0) o_ptr->curse_flags |= TRC_CURSED;
2659         }
2660
2661
2662         /* Analyze type */
2663         switch (o_ptr->tval)
2664         {
2665                 case TV_DRAG_ARMOR:
2666                 {
2667                         /* Rating boost */
2668                         rating += 30;
2669                         if(one_in_(50))
2670                                 create_artifact(o_ptr, FALSE);
2671
2672                         /* Mention the item */
2673                         if (cheat_peek) object_mention(o_ptr);
2674
2675                         break;
2676                 }
2677
2678                 case TV_HARD_ARMOR:
2679                 case TV_SOFT_ARMOR:
2680                 {
2681                         /* Very good */
2682                         if (power > 1)
2683                         {
2684                                 /* Hack -- Try for "Robes of the Magi" */
2685                                 if ((o_ptr->tval == TV_SOFT_ARMOR) &&
2686                                     (o_ptr->sval == SV_ROBE) &&
2687                                     (randint0(100) < 15))
2688                                 {
2689                                         if (one_in_(5))
2690                                         {
2691                                                 o_ptr->name2 = EGO_YOIYAMI;
2692                                                 o_ptr->k_idx = lookup_kind(TV_SOFT_ARMOR, SV_YOIYAMI_ROBE);
2693                                                 o_ptr->sval = SV_YOIYAMI_ROBE;
2694                                                 o_ptr->ac = 0;
2695                                                 o_ptr->to_a = 0;
2696                                         }
2697                                         else
2698                                         {
2699                                                 o_ptr->name2 = EGO_PERMANENCE;
2700                                         }
2701                                         break;
2702                                 }
2703
2704                                 if (one_in_(20))
2705                                 {
2706                                         create_artifact(o_ptr, FALSE);
2707                                         break;
2708                                 }
2709
2710                                 while (1)
2711                                 {
2712                                         bool okay_flag = TRUE;
2713
2714                                         o_ptr->name2 = get_random_ego(INVEN_BODY, TRUE);
2715
2716                                         switch (o_ptr->name2)
2717                                         {
2718                                         case EGO_RESISTANCE:
2719                                                 if (one_in_(4))
2720                                                         add_flag(o_ptr->art_flags, TR_RES_POIS);
2721                                                 break;
2722                                         case EGO_ELVENKIND:
2723                                                 break;
2724                                         case EGO_DWARVEN:
2725                                                 if (o_ptr->tval != TV_HARD_ARMOR)
2726                                                 {
2727                                                         okay_flag = FALSE;
2728                                                         break;
2729                                                 }
2730                                                 else
2731                                                 {
2732                                                         o_ptr->weight = (2 * k_info[o_ptr->k_idx].weight / 3);
2733                                                         o_ptr->ac = k_info[o_ptr->k_idx].ac + 5;
2734                                                         if (one_in_(4))
2735                                                                 add_flag(o_ptr->art_flags, TR_CON);
2736                                                         break;
2737                                                 }
2738                                         }
2739
2740                                         if (okay_flag)
2741                                                 break;
2742                                 }
2743                         }
2744
2745                         break;
2746                 }
2747
2748                 case TV_SHIELD:
2749                 {
2750
2751                         if (o_ptr->sval == SV_DRAGON_SHIELD)
2752                         {
2753                                 /* Rating boost */
2754                                 rating += 5;
2755
2756                                 /* Mention the item */
2757                                 if (cheat_peek) object_mention(o_ptr);
2758                                 dragon_resist(o_ptr);
2759                                 if (!one_in_(3)) break;
2760                         }
2761
2762                         /* Very good */
2763                         if (power > 1)
2764                         {
2765                                 if (one_in_(20))
2766                                 {
2767                                         create_artifact(o_ptr, FALSE);
2768                                         break;
2769                                 }
2770                                 o_ptr->name2 = get_random_ego(INVEN_LARM, TRUE);
2771
2772                                 switch (o_ptr->name2)
2773                                 {
2774                                 case EGO_ENDURANCE:
2775                                         if (!one_in_(3)) one_high_resistance(o_ptr);
2776                                         if (one_in_(4)) add_flag(o_ptr->art_flags, TR_RES_POIS);
2777                                         break;
2778                                 case EGO_REFLECTION:
2779                                         if (o_ptr->sval == SV_SHIELD_OF_DEFLECTION)
2780                                                 o_ptr->name2 = 0;
2781                                         break;
2782                                 }
2783                         }
2784                         break;
2785                 }
2786
2787                 case TV_GLOVES:
2788                 {
2789                         if (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)
2790                         {
2791                                 /* Rating boost */
2792                                 rating += 5;
2793
2794                                 /* Mention the item */
2795                                 if (cheat_peek) object_mention(o_ptr);
2796                                 dragon_resist(o_ptr);
2797                                 if (!one_in_(3)) break;
2798                         }
2799                         if (power > 1)
2800                         {
2801                                 if (one_in_(20))
2802                                 {
2803                                         create_artifact(o_ptr, FALSE);
2804                                         break;
2805                                 }
2806                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, TRUE);
2807                         }
2808
2809                         /* Very cursed */
2810                         else if (power < -1)
2811                         {
2812                                 o_ptr->name2 = get_random_ego(INVEN_HANDS, FALSE);
2813                         }
2814
2815                         break;
2816                 }
2817
2818                 case TV_BOOTS:
2819                 {
2820                         if (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)
2821                         {
2822                                 /* Rating boost */
2823                                 rating += 5;
2824
2825                                 /* Mention the item */
2826                                 if (cheat_peek) object_mention(o_ptr);
2827                                 dragon_resist(o_ptr);
2828                                 if (!one_in_(3)) break;
2829                         }
2830                         /* Very good */
2831                         if (power > 1)
2832                         {
2833                                 if (one_in_(20))
2834                                 {
2835                                         create_artifact(o_ptr, FALSE);
2836                                         break;
2837                                 }
2838                                 o_ptr->name2 = get_random_ego(INVEN_FEET, TRUE);
2839
2840                                 switch (o_ptr->name2)
2841                                 {
2842                                 case EGO_SLOW_DESCENT:
2843                                         if (one_in_(2))
2844                                         {
2845                                                 one_high_resistance(o_ptr);
2846                                         }
2847                                         break;
2848                                 }
2849                         }
2850                         /* Very cursed */
2851                         else if (power < -1)
2852                         {
2853                                 o_ptr->name2 = get_random_ego(INVEN_FEET, FALSE);
2854                         }
2855
2856                         break;
2857                 }
2858
2859                 case TV_CROWN:
2860                 {
2861                         /* Very good */
2862                         if (power > 1)
2863                         {
2864                                 if (one_in_(20))
2865                                 {
2866                                         create_artifact(o_ptr, FALSE);
2867                                         break;
2868                                 }
2869                                 while (1)
2870                                 {
2871                                         bool ok_flag = TRUE;
2872                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
2873
2874                                         switch (o_ptr->name2)
2875                                         {
2876                                         case EGO_TELEPATHY:
2877                                                 add_esp_strong(o_ptr);
2878                                                 add_esp_weak(o_ptr);
2879                                                 break;
2880                                         case EGO_MAGI:
2881                                         case EGO_MIGHT:
2882                                         case EGO_REGENERATION:
2883                                         case EGO_LORDLINESS:
2884                                                 break;
2885                                         case EGO_SEEING:
2886                                                 if (one_in_(3))
2887                                                 {
2888                                                         if (one_in_(2)) add_esp_strong(o_ptr);
2889                                                         else add_esp_weak(o_ptr);
2890                                                 }
2891                                                 break;
2892                                         default:/* not existing crown (wisdom,lite, etc...) */
2893                                                 ok_flag = FALSE;
2894                                         }
2895                                         if (ok_flag)
2896                                                 break; /* while (1) */
2897                                 }
2898                                 break;
2899                         }
2900
2901                         /* Very cursed */
2902                         else if (power < -1)
2903                         {
2904                                 o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
2905                         }
2906
2907                         break;
2908                 }
2909
2910                 case TV_HELM:
2911                 {
2912                         if (o_ptr->sval == SV_DRAGON_HELM)
2913                         {
2914                                 /* Rating boost */
2915                                 rating += 5;
2916
2917                                 /* Mention the item */
2918                                 if (cheat_peek) object_mention(o_ptr);
2919                                 dragon_resist(o_ptr);
2920                                 if (!one_in_(3)) break;
2921                         }
2922
2923                         /* Very good */
2924                         if (power > 1)
2925                         {
2926                                 if (one_in_(20))
2927                                 {
2928                                         create_artifact(o_ptr, FALSE);
2929                                         break;
2930                                 }
2931                                 while (1)
2932                                 {
2933                                         bool ok_flag = TRUE;
2934                                         o_ptr->name2 = get_random_ego(INVEN_HEAD, TRUE);
2935
2936                                         switch (o_ptr->name2)
2937                                         {
2938                                         case EGO_INTELLIGENCE:
2939                                         case EGO_WISDOM:
2940                                         case EGO_BEAUTY:
2941                                         case EGO_LITE:
2942                                         case EGO_INFRAVISION:
2943                                                 break;
2944                                         case EGO_SEEING:
2945                                                 if (one_in_(7))
2946                                                 {
2947                                                         if (one_in_(2)) add_esp_strong(o_ptr);
2948                                                         else add_esp_weak(o_ptr);
2949                                                 }
2950                                                 break;
2951                                         default:/* not existing helm (Magi, Might, etc...)*/
2952                                                 ok_flag = FALSE;
2953                                         }
2954                                         if (ok_flag)
2955                                                 break; /* while (1) */
2956                                 }
2957                                 break;
2958                         }
2959                         /* Very cursed */
2960                         else if (power < -1)
2961                         {
2962                                 o_ptr->name2 = get_random_ego(INVEN_HEAD, FALSE);
2963                         }
2964                         break;
2965                 }
2966
2967                 case TV_CLOAK:
2968                 {
2969                         /* Very good */
2970                         if (power > 1)
2971                         {
2972                                 if (one_in_(20))
2973                                 {
2974                                         create_artifact(o_ptr, FALSE);
2975                                         break;
2976                                 }
2977                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, TRUE);
2978
2979                                 switch (o_ptr->name2)
2980                                 {
2981                                 case EGO_BAT:
2982                                         o_ptr->to_d -= 6;
2983                                         o_ptr->to_h -= 6;
2984                                         break;
2985                                 }
2986
2987                         }
2988
2989                         /* Very cursed */
2990                         else if (power < -1)
2991                         {
2992                                 o_ptr->name2 = get_random_ego(INVEN_OUTER, FALSE);
2993                         }
2994
2995                         break;
2996                 }
2997         }
2998 }
2999
3000
3001 /*
3002  * Apply magic to an item known to be a "ring" or "amulet"
3003  *
3004  * Hack -- note special rating boost for ring of speed
3005  * Hack -- note special rating boost for amulet of the magi
3006  * Hack -- note special "pval boost" code for ring of speed
3007  * Hack -- note that some items must be cursed (or blessed)
3008  */
3009 static void a_m_aux_3(object_type *o_ptr, int level, int power)
3010 {
3011         /* Apply magic (good or bad) according to type */
3012         switch (o_ptr->tval)
3013         {
3014                 case TV_RING:
3015                 {
3016                         /* Analyze */
3017                         switch (o_ptr->sval)
3018                         {
3019                                 case SV_RING_ATTACKS:
3020                                 {
3021                                         /* Stat bonus */
3022                                         o_ptr->pval = m_bonus(2, level);
3023                                         if (one_in_(15)) o_ptr->pval++;
3024                                         if (o_ptr->pval < 1) o_ptr->pval = 1;
3025
3026                                         /* Cursed */
3027                                         if (power < 0)
3028                                         {
3029                                                 /* Broken */
3030                                                 o_ptr->ident |= (IDENT_BROKEN);
3031
3032                                                 /* Cursed */
3033                                                 o_ptr->curse_flags |= TRC_CURSED;
3034
3035                                                 /* Reverse pval */
3036                                                 o_ptr->pval = 0 - (o_ptr->pval);
3037                                         }
3038
3039                                         break;
3040                                 }
3041
3042                                 case SV_RING_SHOTS:
3043                                 {
3044                                         break;
3045                                 }
3046
3047                                 /* Strength, Constitution, Dexterity, Intelligence */
3048                                 case SV_RING_STR:
3049                                 case SV_RING_CON:
3050                                 case SV_RING_DEX:
3051                                 {
3052                                         /* Stat bonus */
3053                                         o_ptr->pval = 1 + m_bonus(5, level);
3054
3055                                         /* Cursed */
3056                                         if (power < 0)
3057                                         {
3058                                                 /* Broken */
3059                                                 o_ptr->ident |= (IDENT_BROKEN);
3060
3061                                                 /* Cursed */
3062                                                 o_ptr->curse_flags |= TRC_CURSED;
3063
3064                                                 /* Reverse pval */
3065                                                 o_ptr->pval = 0 - (o_ptr->pval);
3066                                         }
3067
3068                                         break;
3069                                 }
3070
3071                                 /* Ring of Speed! */
3072                                 case SV_RING_SPEED:
3073                                 {
3074                                         /* Base speed (1 to 10) */
3075                                         o_ptr->pval = randint1(5) + m_bonus(5, level);
3076
3077                                         /* Super-charge the ring */
3078                                         while (randint0(100) < 50) o_ptr->pval++;
3079
3080                                         /* Cursed Ring */
3081                                         if (power < 0)
3082                                         {
3083                                                 /* Broken */
3084                                                 o_ptr->ident |= (IDENT_BROKEN);
3085
3086                                                 /* Cursed */
3087                                                 o_ptr->curse_flags |= TRC_CURSED;
3088
3089                                                 /* Reverse pval */
3090                                                 o_ptr->pval = 0 - (o_ptr->pval);
3091
3092                                                 break;
3093                                         }
3094
3095                                         /* Rating boost */
3096                                         rating += 25;
3097
3098                                         /* Mention the item */
3099                                         if (cheat_peek) object_mention(o_ptr);
3100
3101                                         break;
3102                                 }
3103
3104                                 case SV_RING_LORDLY:
3105                                 {
3106                                         do
3107                                         {
3108                                                 one_lordly_high_resistance(o_ptr);
3109                                         }
3110                                         while (one_in_(4));
3111
3112                                         /* Bonus to armor class */
3113                                         o_ptr->to_a = 10 + randint1(5) + m_bonus(10, level);
3114                                         rating += 15;
3115                                 }
3116                                 break;
3117
3118                                 case SV_RING_WARNING:
3119                                 {
3120                                         if (one_in_(3)) one_low_esp(o_ptr);
3121                                         break;
3122                                 }
3123
3124                                 /* Searching */
3125                                 case SV_RING_SEARCHING:
3126                                 {
3127                                         /* Bonus to searching */
3128                                         o_ptr->pval = 1 + m_bonus(5, level);
3129
3130                                         /* Cursed */
3131                                         if (power < 0)
3132                                         {
3133                                                 /* Broken */
3134                                                 o_ptr->ident |= (IDENT_BROKEN);
3135
3136                                                 /* Cursed */
3137                                                 o_ptr->curse_flags |= TRC_CURSED;
3138
3139                                                 /* Reverse pval */
3140                                                 o_ptr->pval = 0 - (o_ptr->pval);
3141                                         }
3142
3143                                         break;
3144                                 }
3145
3146                                 /* Flames, Acid, Ice */
3147                                 case SV_RING_FLAMES:
3148                                 case SV_RING_ACID:
3149                                 case SV_RING_ICE:
3150                                 case SV_RING_ELEC:
3151                                 {
3152                                         /* Bonus to armor class */
3153                                         o_ptr->to_a = 5 + randint1(5) + m_bonus(10, level);
3154                                         break;
3155                                 }
3156
3157                                 /* Weakness, Stupidity */
3158                                 case SV_RING_WEAKNESS:
3159                                 case SV_RING_STUPIDITY:
3160                                 {
3161                                         /* Broken */
3162                                         o_ptr->ident |= (IDENT_BROKEN);
3163
3164                                         /* Cursed */
3165                                         o_ptr->curse_flags |= TRC_CURSED;
3166
3167                                         /* Penalize */
3168                                         o_ptr->pval = 0 - (1 + m_bonus(5, level));
3169                                         if (power > 0) power = 0 - power;
3170
3171                                         break;
3172                                 }
3173
3174                                 /* WOE, Stupidity */
3175                                 case SV_RING_WOE:
3176                                 {
3177                                         /* Broken */
3178                                         o_ptr->ident |= (IDENT_BROKEN);
3179
3180                                         /* Cursed */
3181                                         o_ptr->curse_flags |= TRC_CURSED;
3182
3183                                         /* Penalize */
3184                                         o_ptr->to_a = 0 - (5 + m_bonus(10, level));
3185                                         o_ptr->pval = 0 - (1 + m_bonus(5, level));
3186                                         if (power > 0) power = 0 - power;
3187
3188                                         break;
3189                                 }
3190
3191                                 /* Ring of damage */
3192                                 case SV_RING_DAMAGE:
3193                                 {
3194                                         /* Bonus to damage */
3195                                         o_ptr->to_d = 1 + randint1(5) + m_bonus(16, level);
3196
3197                                         /* Cursed */
3198                                         if (power < 0)
3199                                         {
3200                                                 /* Broken */
3201                                                 o_ptr->ident |= (IDENT_BROKEN);
3202
3203                                                 /* Cursed */
3204                                                 o_ptr->curse_flags |= TRC_CURSED;
3205
3206                                                 /* Reverse bonus */
3207                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3208                                         }
3209
3210                                         break;
3211                                 }
3212
3213                                 /* Ring of Accuracy */
3214                                 case SV_RING_ACCURACY:
3215                                 {
3216                                         /* Bonus to hit */
3217                                         o_ptr->to_h = 1 + randint1(5) + m_bonus(16, level);
3218
3219                                         /* Cursed */
3220                                         if (power < 0)
3221                                         {
3222                                                 /* Broken */
3223                                                 o_ptr->ident |= (IDENT_BROKEN);
3224
3225                                                 /* Cursed */
3226                                                 o_ptr->curse_flags |= TRC_CURSED;
3227
3228                                                 /* Reverse tohit */
3229                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3230                                         }
3231
3232                                         break;
3233                                 }
3234
3235                                 /* Ring of Protection */
3236                                 case SV_RING_PROTECTION:
3237                                 {
3238                                         /* Bonus to armor class */
3239                                         o_ptr->to_a = 5 + randint1(8) + m_bonus(10, level);
3240
3241                                         /* Cursed */
3242                                         if (power < 0)
3243                                         {
3244                                                 /* Broken */
3245                                                 o_ptr->ident |= (IDENT_BROKEN);
3246
3247                                                 /* Cursed */
3248                                                 o_ptr->curse_flags |= TRC_CURSED;
3249
3250                                                 /* Reverse toac */
3251                                                 o_ptr->to_a = 0 - o_ptr->to_a;
3252                                         }
3253
3254                                         break;
3255                                 }
3256
3257                                 /* Ring of Slaying */
3258                                 case SV_RING_SLAYING:
3259                                 {
3260                                         /* Bonus to damage and to hit */
3261                                         o_ptr->to_d = randint1(5) + m_bonus(12, level);
3262                                         o_ptr->to_h = randint1(5) + m_bonus(12, level);
3263
3264                                         /* Cursed */
3265                                         if (power < 0)
3266                                         {
3267                                                 /* Broken */
3268                                                 o_ptr->ident |= (IDENT_BROKEN);
3269
3270                                                 /* Cursed */
3271                                                 o_ptr->curse_flags |= TRC_CURSED;
3272
3273                                                 /* Reverse bonuses */
3274                                                 o_ptr->to_h = 0 - o_ptr->to_h;
3275                                                 o_ptr->to_d = 0 - o_ptr->to_d;
3276                                         }
3277
3278                                         break;
3279                                 }
3280
3281                                 case SV_RING_MUSCLE:
3282                                 {
3283                                         o_ptr->pval = 1 + m_bonus(3, level);
3284                                         if (one_in_(4)) o_ptr->pval++;
3285
3286                                         /* Cursed */
3287                                         if (power < 0)
3288                                         {
3289                                                 /* Broken */
3290                                                 o_ptr->ident |= (IDENT_BROKEN);
3291
3292                                                 /* Cursed */
3293                                                 o_ptr->curse_flags |= TRC_CURSED;
3294
3295                                                 /* Reverse bonuses */
3296                                                 o_ptr->pval = 0 - o_ptr->pval;
3297                                         }
3298
3299                                         break;
3300                                 }
3301                                 case SV_RING_AGGRAVATION:
3302                                 {
3303                                         /* Broken */
3304                                         o_ptr->ident |= (IDENT_BROKEN);
3305
3306                                         /* Cursed */
3307                                         o_ptr->curse_flags |= TRC_CURSED;
3308
3309                                         if (power > 0) power = 0 - power;
3310                                         break;
3311                                 }
3312                         }
3313                         if (one_in_(400) && (power > 0) && !cursed_p(o_ptr) && (level > 79))
3314                         {
3315                                 o_ptr->pval = MIN(o_ptr->pval,4);
3316                                 /* Randart amulet */
3317                                 create_artifact(o_ptr, FALSE);
3318                         }
3319                         else if ((power == 2) && one_in_(2))
3320                         {
3321                                 while(!o_ptr->name2)
3322                                 {
3323                                         int tmp = m_bonus(10, level);
3324                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3325                                         switch(randint1(28))
3326                                         {
3327                                         case 1: case 2:
3328                                                 o_ptr->name2 = EGO_RING_THROW;
3329                                                 break;
3330                                         case 3: case 4:
3331                                                 if (have_flag(k_ptr->flags, TR_REGEN)) break;
3332                                                 o_ptr->name2 = EGO_RING_REGEN;
3333                                                 break;
3334                                         case 5: case 6:
3335                                                 if (have_flag(k_ptr->flags, TR_LITE)) break;
3336                                                 o_ptr->name2 = EGO_RING_LITE;
3337                                                 break;
3338                                         case 7: case 8:
3339                                                 if (have_flag(k_ptr->flags, TR_TELEPORT)) break;
3340                                                 o_ptr->name2 = EGO_RING_TELEPORT;
3341                                                 break;
3342                                         case 9: case 10:
3343                                                 if (o_ptr->to_h) break;
3344                                                 o_ptr->name2 = EGO_RING_TO_H;
3345                                                 break;
3346                                         case 11: case 12:
3347                                                 if (o_ptr->to_d) break;
3348                                                 o_ptr->name2 = EGO_RING_TO_D;
3349                                                 break;
3350                                         case 13:
3351                                                 if ((o_ptr->to_h) || (o_ptr->to_d)) break;
3352                                                 o_ptr->name2 = EGO_RING_SLAY;
3353                                                 break;
3354                                         case 14:
3355                                                 if ((have_flag(k_ptr->flags, TR_STR)) || o_ptr->to_h || o_ptr->to_d) break;
3356                                                 o_ptr->name2 = EGO_RING_WIZARD;
3357                                                 break;
3358                                         case 15:
3359                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3360                                                 o_ptr->name2 = EGO_RING_HERO;
3361                                                 break;
3362                                         case 16:
3363                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3364                                                 if (tmp > 8) o_ptr->name2 = EGO_RING_MANA_BALL;
3365                                                 else if (tmp > 4) o_ptr->name2 = EGO_RING_MANA_BOLT;
3366                                                 else o_ptr->name2 = EGO_RING_MAGIC_MIS;
3367                                                 break;
3368                                         case 17:
3369                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3370                                                 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;
3371                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_F;
3372                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_FIRE_BALL;
3373                                                 else o_ptr->name2 = EGO_RING_FIRE_BOLT;
3374                                                 break;
3375                                         case 18:
3376                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3377                                                 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;
3378                                                 if (tmp > 7) o_ptr->name2 = EGO_RING_DRAGON_C;
3379                                                 else if (tmp > 3) o_ptr->name2 = EGO_RING_COLD_BALL;
3380                                                 else o_ptr->name2 = EGO_RING_COLD_BOLT;
3381                                                 break;
3382                                         case 19:
3383                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3384                                                 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;
3385                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ELEC_BALL;
3386                                                 else o_ptr->name2 = EGO_RING_ELEC_BOLT;
3387                                                 break;
3388                                         case 20:
3389                                                 if (have_flag(k_ptr->flags, TR_ACTIVATE)) break;
3390                                                 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;
3391                                                 if (tmp > 4) o_ptr->name2 = EGO_RING_ACID_BALL;
3392                                                 else o_ptr->name2 = EGO_RING_ACID_BOLT;
3393                                                 break;
3394                                         case 21: case 22: case 23: case 24: case 25: case 26:
3395                                                 switch (o_ptr->sval)
3396                                                 {
3397                                                 case SV_RING_SPEED:
3398                                                         if (!one_in_(3)) break;
3399                                                         o_ptr->name2 = EGO_RING_D_SPEED;
3400                                                         break;
3401                                                 case SV_RING_DAMAGE:
3402                                                 case SV_RING_ACCURACY:
3403                                                 case SV_RING_SLAYING:
3404                                                         if (one_in_(2)) break;
3405                                                         if (one_in_(2)) o_ptr->name2 = EGO_RING_HERO;
3406                                                         else
3407                                                         {
3408                                                                 o_ptr->name2 = EGO_RING_BERSERKER;
3409                                                                 o_ptr->to_h -= 2+randint1(4);
3410                                                                 o_ptr->to_d += 2+randint1(4);
3411                                                         }
3412                                                         break;
3413                                                 case SV_RING_PROTECTION:
3414                                                         o_ptr->name2 = EGO_RING_SUPER_AC;
3415                                                         o_ptr->to_a += 7 + m_bonus(5, level);
3416                                                         break;
3417                                                 case SV_RING_RES_FEAR:
3418                                                         o_ptr->name2 = EGO_RING_HERO;
3419                                                         break;
3420                                                 case SV_RING_SHOTS:
3421                                                         if (one_in_(2)) break;
3422                                                         o_ptr->name2 = EGO_RING_HUNTER;
3423                                                         break;
3424                                                 case SV_RING_SEARCHING:
3425                                                         o_ptr->name2 = EGO_RING_STEALTH;
3426                                                         break;
3427                                                 case SV_RING_TELEPORTATION:
3428                                                         o_ptr->name2 = EGO_RING_TELE_AWAY;
3429                                                         break;
3430                                                 case SV_RING_RES_BLINDNESS:
3431                                                         if (one_in_(2))
3432                                                                 o_ptr->name2 = EGO_RING_RES_LITE;
3433                                                         else
3434                                                                 o_ptr->name2 = EGO_RING_RES_DARK;
3435                                                         break;
3436                                                 case SV_RING_LORDLY:
3437                                                         if (!one_in_(20)) break;
3438                                                         one_lordly_high_resistance(o_ptr);
3439                                                         one_lordly_high_resistance(o_ptr);
3440                                                         o_ptr->name2 = EGO_RING_TRUE;
3441                                                         break;
3442                                                 case SV_RING_SUSTAIN:
3443                                                         if (!one_in_(4)) break;
3444                                                         o_ptr->name2 = EGO_RING_RES_TIME;
3445                                                         break;
3446                                                 case SV_RING_FLAMES:
3447                                                         if (!one_in_(2)) break;
3448                                                         o_ptr->name2 = EGO_RING_DRAGON_F;
3449                                                         break;
3450                                                 case SV_RING_ICE:
3451                                                         if (!one_in_(2)) break;
3452                                                         o_ptr->name2 = EGO_RING_DRAGON_C;
3453                                                         break;
3454                                                 case SV_RING_WARNING:
3455                                                         if (!one_in_(2)) break;
3456                                                         o_ptr->name2 = EGO_RING_M_DETECT;
3457                                                         break;
3458                                                 default:
3459                                                         break;
3460                                                 }
3461                                                 break;
3462                                         }
3463                                 }
3464                                 /* Uncurse it */
3465                                 o_ptr->curse_flags = 0L;
3466                         }
3467                         else if ((power == -2) && one_in_(2))
3468                         {
3469                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3470                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3471                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3472                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3473                                 o_ptr->art_flags[0] = 0;
3474                                 o_ptr->art_flags[1] = 0;
3475                                 while(!o_ptr->name2)
3476                                 {
3477                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3478                                         switch(randint1(5))
3479                                         {
3480                                         case 1:
3481                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3482                                                 o_ptr->name2 = EGO_RING_DRAIN_EXP;
3483                                                 break;
3484                                         case 2:
3485                                                 o_ptr->name2 = EGO_RING_NO_MELEE;
3486                                                 break;
3487                                         case 3:
3488                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3489                                                 o_ptr->name2 = EGO_RING_AGGRAVATE;
3490                                                 break;
3491                                         case 4:
3492                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3493                                                 o_ptr->name2 = EGO_RING_TY_CURSE;
3494                                                 break;
3495                                         case 5:
3496                                                 o_ptr->name2 = EGO_RING_ALBINO;
3497                                                 break;
3498                                         }
3499                                 }
3500                                 /* Broken */
3501                                 o_ptr->ident |= (IDENT_BROKEN);
3502
3503                                 /* Cursed */
3504                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3505                         }
3506                         break;
3507                 }
3508
3509                 case TV_AMULET:
3510                 {
3511                         /* Analyze */
3512                         switch (o_ptr->sval)
3513                         {
3514                                 /* Amulet of wisdom/charisma */
3515                                 case SV_AMULET_INTELLIGENCE:
3516                                 case SV_AMULET_WISDOM:
3517                                 case SV_AMULET_CHARISMA:
3518                                 {
3519                                         o_ptr->pval = 1 + m_bonus(5, level);
3520
3521                                         /* Cursed */
3522                                         if (power < 0)
3523                                         {
3524                                                 /* Broken */
3525                                                 o_ptr->ident |= (IDENT_BROKEN);
3526
3527                                                 /* Cursed */
3528                                                 o_ptr->curse_flags |= (TRC_CURSED);
3529
3530                                                 /* Reverse bonuses */
3531                                                 o_ptr->pval = 0 - o_ptr->pval;
3532                                         }
3533
3534                                         break;
3535                                 }
3536
3537                                 /* Amulet of brilliance */
3538                                 case SV_AMULET_BRILLIANCE:
3539                                 {
3540                                         o_ptr->pval = 1 + m_bonus(3, level);
3541                                         if (one_in_(4)) o_ptr->pval++;
3542
3543                                         /* Cursed */
3544                                         if (power < 0)
3545                                         {
3546                                                 /* Broken */
3547                                                 o_ptr->ident |= (IDENT_BROKEN);
3548
3549                                                 /* Cursed */
3550                                                 o_ptr->curse_flags |= (TRC_CURSED);
3551
3552                                                 /* Reverse bonuses */
3553                                                 o_ptr->pval = 0 - o_ptr->pval;
3554                                         }
3555
3556                                         break;
3557                                 }
3558
3559                                 case SV_AMULET_NO_MAGIC: case SV_AMULET_NO_TELE:
3560                                 {
3561                                         if (power < 0)
3562                                         {
3563                                                 o_ptr->curse_flags |= (TRC_CURSED);
3564                                         }
3565                                         break;
3566                                 }
3567
3568                                 case SV_AMULET_RESISTANCE:
3569                                 {
3570                                         if (one_in_(5)) one_high_resistance(o_ptr);
3571                                         if (one_in_(5)) add_flag(o_ptr->art_flags, TR_RES_POIS);
3572                                 }
3573                                 break;
3574
3575                                 /* Amulet of searching */
3576                                 case SV_AMULET_SEARCHING:
3577                                 {
3578                                         o_ptr->pval = randint1(2) + m_bonus(4, level);
3579
3580                                         /* Cursed */
3581                                         if (power < 0)
3582                                         {
3583                                                 /* Broken */
3584                                                 o_ptr->ident |= (IDENT_BROKEN);
3585
3586                                                 /* Cursed */
3587                                                 o_ptr->curse_flags |= (TRC_CURSED);
3588
3589                                                 /* Reverse bonuses */
3590                                                 o_ptr->pval = 0 - (o_ptr->pval);
3591                                         }
3592
3593                                         break;
3594                                 }
3595
3596                                 /* Amulet of the Magi -- never cursed */
3597                                 case SV_AMULET_THE_MAGI:
3598                                 {
3599                                         o_ptr->pval = randint1(5) + m_bonus(5, level);
3600                                         o_ptr->to_a = randint1(5) + m_bonus(5, level);
3601
3602                                         /* gain one low ESP */
3603                                         add_esp_weak(o_ptr);
3604
3605                                         /* Boost the rating */
3606                                         rating += 15;
3607
3608                                         /* Mention the item */
3609                                         if (cheat_peek) object_mention(o_ptr);
3610
3611                                         break;
3612                                 }
3613
3614                                 /* Amulet of Doom -- always cursed */
3615                                 case SV_AMULET_DOOM:
3616                                 {
3617                                         /* Broken */
3618                                         o_ptr->ident |= (IDENT_BROKEN);
3619
3620                                         /* Cursed */
3621                                         o_ptr->curse_flags |= (TRC_CURSED);
3622
3623                                         /* Penalize */
3624                                         o_ptr->pval = 0 - (randint1(5) + m_bonus(5, level));
3625                                         o_ptr->to_a = 0 - (randint1(5) + m_bonus(5, level));
3626                                         if (power > 0) power = 0 - power;
3627
3628                                         break;
3629                                 }
3630
3631                                 case SV_AMULET_MAGIC_MASTERY:
3632                                 {
3633                                         o_ptr->pval = 1 + m_bonus(4, level);
3634
3635                                         /* Cursed */
3636                                         if (power < 0)
3637                                         {
3638                                                 /* Broken */
3639                                                 o_ptr->ident |= (IDENT_BROKEN);
3640
3641                                                 /* Cursed */
3642                                                 o_ptr->curse_flags |= (TRC_CURSED);
3643
3644                                                 /* Reverse bonuses */
3645                                                 o_ptr->pval = 0 - o_ptr->pval;
3646                                         }
3647
3648                                         break;
3649                                 }
3650                         }
3651                         if (one_in_(150) && (power > 0) && !cursed_p(o_ptr) && (level > 79))
3652                         {
3653                                 o_ptr->pval = MIN(o_ptr->pval,4);
3654                                 /* Randart amulet */
3655                                 create_artifact(o_ptr, FALSE);
3656                         }
3657                         else if ((power == 2) && one_in_(2))
3658                         {
3659                                 while(!o_ptr->name2)
3660                                 {
3661                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3662                                         switch(randint1(21))
3663                                         {
3664                                         case 1: case 2:
3665                                                 if (have_flag(k_ptr->flags, TR_SLOW_DIGEST)) break;
3666                                                 o_ptr->name2 = EGO_AMU_SLOW_D;
3667                                                 break;
3668                                         case 3: case 4:
3669                                                 if (o_ptr->pval) break;
3670                                                 o_ptr->name2 = EGO_AMU_INFRA;
3671                                                 break;
3672                                         case 5: case 6:
3673                                                 if (have_flag(k_ptr->flags, TR_SEE_INVIS)) break;
3674                                                 o_ptr->name2 = EGO_AMU_SEE_INVIS;
3675                                                 break;
3676                                         case 7: case 8:
3677                                                 if (have_flag(k_ptr->flags, TR_HOLD_LIFE)) break;
3678                                                 o_ptr->name2 = EGO_AMU_HOLD_LIFE;
3679                                                 break;
3680                                         case 9:
3681                                                 if (have_flag(k_ptr->flags, TR_FEATHER)) break;
3682                                                 o_ptr->name2 = EGO_AMU_LEVITATION;
3683                                                 break;
3684                                         case 10: case 11: case 21:
3685                                                 o_ptr->name2 = EGO_AMU_AC;
3686                                                 break;
3687                                         case 12:
3688                                                 if (have_flag(k_ptr->flags, TR_RES_FIRE)) break;
3689                                                 if (m_bonus(10, level) > 8)
3690                                                         o_ptr->name2 = EGO_AMU_RES_FIRE_;
3691                                                 else
3692                                                         o_ptr->name2 = EGO_AMU_RES_FIRE;
3693                                                 break;
3694                                         case 13:
3695                                                 if (have_flag(k_ptr->flags, TR_RES_COLD)) break;
3696                                                 if (m_bonus(10, level) > 8)
3697                                                         o_ptr->name2 = EGO_AMU_RES_COLD_;
3698                                                 else
3699                                                         o_ptr->name2 = EGO_AMU_RES_COLD;
3700                                                 break;
3701                                         case 14:
3702                                                 if (have_flag(k_ptr->flags, TR_RES_ELEC)) break;
3703                                                 if (m_bonus(10, level) > 8)
3704                                                         o_ptr->name2 = EGO_AMU_RES_ELEC_;
3705                                                 else
3706                                                         o_ptr->name2 = EGO_AMU_RES_ELEC;
3707                                                 break;
3708                                         case 15:
3709                                                 if (have_flag(k_ptr->flags, TR_RES_ACID)) break;
3710                                                 if (m_bonus(10, level) > 8)
3711                                                         o_ptr->name2 = EGO_AMU_RES_ACID_;
3712                                                 else
3713                                                         o_ptr->name2 = EGO_AMU_RES_ACID;
3714                                                 break;
3715                                         case 16: case 17: case 18: case 19: case 20:
3716                                                 switch (o_ptr->sval)
3717                                                 {
3718                                                 case SV_AMULET_TELEPORT:
3719                                                         if (m_bonus(10, level) > 9) o_ptr->name2 = EGO_AMU_D_DOOR;
3720                                                         else if (one_in_(2)) o_ptr->name2 = EGO_AMU_JUMP;
3721                                                         else o_ptr->name2 = EGO_AMU_TELEPORT;
3722                                                         break;
3723                                                 case SV_AMULET_RESIST_ACID:
3724                                                         if ((m_bonus(10, level) > 6) && one_in_(2)) o_ptr->name2 = EGO_AMU_RES_ACID_;
3725                                                         break;
3726                                                 case SV_AMULET_SEARCHING:
3727                                                         o_ptr->name2 = EGO_AMU_STEALTH;
3728                                                         break;
3729                                                 case SV_AMULET_BRILLIANCE:
3730                                                         if (!one_in_(3)) break;
3731                                                         o_ptr->name2 = EGO_AMU_IDENT;
3732                                                         break;
3733                                                 case SV_AMULET_CHARISMA:
3734                                                         if (!one_in_(3)) break;
3735                                                         o_ptr->name2 = EGO_AMU_CHARM;
3736                                                         break;
3737                                                 case SV_AMULET_THE_MAGI:
3738                                                         if (one_in_(2)) break;
3739                                                         o_ptr->name2 = EGO_AMU_GREAT;
3740                                                         break;
3741                                                 case SV_AMULET_RESISTANCE:
3742                                                         if (!one_in_(5)) break;
3743                                                         o_ptr->name2 = EGO_AMU_DEFENDER;
3744                                                         break;
3745                                                 case SV_AMULET_TELEPATHY:
3746                                                         if (!one_in_(3)) break;
3747                                                         o_ptr->name2 = EGO_AMU_DETECTION;
3748                                                         break;
3749                                                 }
3750                                         }
3751                                 }
3752                                 /* Uncurse it */
3753                                 o_ptr->curse_flags = 0L;
3754                         }
3755                         else if ((power == -2) && one_in_(2))
3756                         {
3757                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3758                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3759                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3760                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3761                                 o_ptr->art_flags[0] = 0;
3762                                 o_ptr->art_flags[1] = 0;
3763                                 while(!o_ptr->name2)
3764                                 {
3765                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3766                                         switch(randint1(5))
3767                                         {
3768                                         case 1:
3769                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3770                                                 o_ptr->name2 = EGO_AMU_DRAIN_EXP;
3771                                                 break;
3772                                         case 2:
3773                                                 o_ptr->name2 = EGO_AMU_FOOL;
3774                                                 break;
3775                                         case 3:
3776                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3777                                                 o_ptr->name2 = EGO_AMU_AGGRAVATE;
3778                                                 break;
3779                                         case 4:
3780                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3781                                                 o_ptr->name2 = EGO_AMU_TY_CURSE;
3782                                                 break;
3783                                         case 5:
3784                                                 o_ptr->name2 = EGO_AMU_NAIVETY;
3785                                                 break;
3786                                         }
3787                                 }
3788                                 /* Broken */
3789                                 o_ptr->ident |= (IDENT_BROKEN);
3790
3791                                 /* Cursed */
3792                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3793                         }
3794                         break;
3795                 }
3796         }
3797 }
3798
3799
3800 /*
3801  * Hack -- help pick an item type
3802  */
3803 static bool item_monster_okay(int r_idx)
3804 {
3805         monster_race *r_ptr = &r_info[r_idx];
3806
3807         /* No uniques */
3808         if (r_ptr->flags1 & RF1_UNIQUE) return (FALSE);
3809         if (r_ptr->flags7 & RF7_KAGE) return (FALSE);
3810         if (r_ptr->flags3 & RF3_RES_ALL) return (FALSE);
3811         if (r_ptr->flags7 & RF7_UNIQUE_7) return (FALSE);
3812         if (r_ptr->flags1 & RF1_FORCE_DEPTH) return (FALSE);
3813         if (r_ptr->flags7 & RF7_UNIQUE2) return (FALSE);
3814
3815         /* Okay */
3816         return (TRUE);
3817 }
3818
3819
3820 /*
3821  * Apply magic to an item known to be "boring"
3822  *
3823  * Hack -- note the special code for various items
3824  */
3825 static void a_m_aux_4(object_type *o_ptr, int level, int power)
3826 {
3827         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3828
3829         /* Unused */
3830         (void)level;
3831
3832         /* Apply magic (good or bad) according to type */
3833         switch (o_ptr->tval)
3834         {
3835                 case TV_WHISTLE:
3836                 {
3837 #if 0
3838                         /* Cursed */
3839                         if (power < 0)
3840                         {
3841                                 /* Broken */
3842                                 o_ptr->ident |= (IDENT_BROKEN);
3843
3844                                 /* Cursed */
3845                                 o_ptr->curse_flags |= (TRC_CURSED);
3846                         }
3847 #endif
3848                         break;
3849                 }
3850                 case TV_FLASK:
3851                 {
3852                         o_ptr->xtra4 = o_ptr->pval;
3853                         o_ptr->pval = 0;
3854                         break;
3855                 }
3856                 case TV_LITE:
3857                 {
3858                         /* Hack -- Torches -- random fuel */
3859                         if (o_ptr->sval == SV_LITE_TORCH)
3860                         {
3861                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3862                                 o_ptr->pval = 0;
3863                         }
3864
3865                         /* Hack -- Lanterns -- random fuel */
3866                         if (o_ptr->sval == SV_LITE_LANTERN)
3867                         {
3868                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3869                                 o_ptr->pval = 0;
3870                         }
3871
3872                         if ((power == 2) || ((power == 1) && one_in_(3)))
3873                         {
3874                                 while (!o_ptr->name2)
3875                                 {
3876                                         while (1)
3877                                         {
3878                                                 bool okay_flag = TRUE;
3879
3880                                                 o_ptr->name2 = get_random_ego(INVEN_LITE, TRUE);
3881
3882                                                 switch (o_ptr->name2)
3883                                                 {
3884                                                 case EGO_LITE_LONG:
3885                                                         if (o_ptr->sval == SV_LITE_FEANOR)
3886                                                                 okay_flag = FALSE;
3887                                                 }
3888                                                 if (okay_flag)
3889                                                         break;
3890                                         }
3891                                 }
3892                         }
3893                         else if (power == -2)
3894                         {
3895                                 o_ptr->name2 = get_random_ego(INVEN_LITE, FALSE);
3896
3897                                 switch (o_ptr->name2)
3898                                 {
3899                                 case EGO_LITE_DARKNESS:
3900                                         o_ptr->xtra4 = 0;
3901                                         break;
3902                                 }
3903                         }
3904
3905                         break;
3906                 }
3907
3908                 case TV_WAND:
3909                 case TV_STAFF:
3910                 {
3911                         /* The wand or staff gets a number of initial charges equal
3912                          * to between 1/2 (+1) and the full object kind's pval. -LM-
3913                          */
3914                         o_ptr->pval = k_ptr->pval / 2 + randint1((k_ptr->pval + 1) / 2);
3915                         break;
3916                 }
3917
3918                 case TV_ROD:
3919                 {
3920                         /* Transfer the pval. -LM- */
3921                         o_ptr->pval = k_ptr->pval;
3922                         break;
3923                 }
3924
3925                 case TV_CAPTURE:
3926                 {
3927                         o_ptr->pval = 0;
3928                         object_aware(o_ptr);
3929                         object_known(o_ptr);
3930                         break;
3931                 }
3932
3933                 case TV_FIGURINE:
3934                 {
3935                         int i = 1;
3936                         int check;
3937
3938                         monster_race *r_ptr;
3939
3940                         /* Pick a random non-unique monster race */
3941                         while (1)
3942                         {
3943                                 i = randint1(max_r_idx - 1);
3944
3945                                 if (!item_monster_okay(i)) continue;
3946                                 if (i == MON_TSUCHINOKO) continue;
3947
3948                                 r_ptr = &r_info[i];
3949
3950                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
3951
3952                                 /* Ignore dead monsters */
3953                                 if (!r_ptr->rarity) continue;
3954
3955                                 /* Prefer less out-of-depth monsters */
3956                                 if (randint0(check)) continue;
3957
3958                                 break;
3959                         }
3960
3961                         o_ptr->pval = i;
3962
3963                         /* Some figurines are cursed */
3964                         if (one_in_(6)) o_ptr->curse_flags |= TRC_CURSED;
3965
3966                         if (cheat_peek)
3967                         {
3968 #ifdef JP
3969                                 msg_format("%s¤Î¿Í·Á, ¿¼¤µ +%d%s",
3970 #else
3971                                 msg_format("Figurine of %s, depth +%d%s",
3972 #endif
3973
3974                                                           r_name + r_ptr->name, check - 1,
3975                                                           !cursed_p(o_ptr) ? "" : " {cursed}");
3976                         }
3977
3978                         break;
3979                 }
3980
3981                 case TV_CORPSE:
3982                 {
3983                         int i = 1;
3984                         int check;
3985
3986                         u32b match = 0;
3987
3988                         monster_race *r_ptr;
3989
3990                         if (o_ptr->sval == SV_SKELETON)
3991                         {
3992                                 match = RF9_DROP_SKELETON;
3993                         }
3994                         else if (o_ptr->sval == SV_CORPSE)
3995                         {
3996                                 match = RF9_DROP_CORPSE;
3997                         }
3998
3999                         /* Hack -- Remove the monster restriction */
4000                         get_mon_num_prep(item_monster_okay, NULL);
4001
4002                         /* Pick a random non-unique monster race */
4003                         while (1)
4004                         {
4005                                 i = get_mon_num(dun_level);
4006
4007                                 r_ptr = &r_info[i];
4008
4009                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
4010
4011                                 /* Ignore dead monsters */
4012                                 if (!r_ptr->rarity) continue;
4013
4014                                 /* Ignore corpseless monsters */
4015                                 if (!(r_ptr->flags9 & match)) continue;
4016
4017                                 /* Prefer less out-of-depth monsters */
4018                                 if (randint0(check)) continue;
4019
4020                                 break;
4021                         }
4022
4023                         o_ptr->pval = i;
4024
4025                         if (cheat_peek)
4026                         {
4027 #ifdef JP
4028                                 msg_format("%s¤Î»àÂÎ,¿¼¤µ +%d",
4029 #else
4030                                 msg_format("Corpse of %s, depth +%d",
4031 #endif
4032
4033                                                           r_name + r_ptr->name, check - 1);
4034                         }
4035
4036                         object_aware(o_ptr);
4037                         object_known(o_ptr);
4038                         break;
4039                 }
4040
4041                 case TV_STATUE:
4042                 {
4043                         int i = 1;
4044
4045                         monster_race *r_ptr;
4046
4047                         /* Pick a random monster race */
4048                         while (1)
4049                         {
4050                                 i = randint1(max_r_idx - 1);
4051
4052                                 r_ptr = &r_info[i];
4053
4054                                 /* Ignore dead monsters */
4055                                 if (!r_ptr->rarity) continue;
4056
4057                                 break;
4058                         }
4059
4060                         o_ptr->pval = i;
4061
4062                         if (cheat_peek)
4063                         {
4064 #ifdef JP
4065                                 msg_format("%s¤ÎÁü,", r_name + r_ptr->name);
4066 #else
4067                                 msg_format("Statue of %s", r_name + r_ptr->name);
4068 #endif
4069
4070                         }
4071                         object_aware(o_ptr);
4072                         object_known(o_ptr);
4073
4074                         break;
4075                 }
4076
4077                 case TV_CHEST:
4078                 {
4079                         byte obj_level = get_object_level(o_ptr);
4080
4081                         /* Hack -- skip ruined chests */
4082                         if (obj_level <= 0) break;
4083
4084                         /* Hack -- pick a "difficulty" */
4085                         o_ptr->pval = randint1(obj_level);
4086                         if (o_ptr->sval == SV_CHEST_KANDUME) o_ptr->pval = 6;
4087
4088                         o_ptr->xtra3 = dun_level + 5;
4089
4090                         /* Never exceed "difficulty" of 55 to 59 */
4091                         if (o_ptr->pval > 55) o_ptr->pval = 55 + (byte)randint0(5);
4092
4093                         break;
4094                 }
4095         }
4096 }
4097
4098
4099 /*
4100  * Complete the "creation" of an object by applying "magic" to the item
4101  *
4102  * This includes not only rolling for random bonuses, but also putting the
4103  * finishing touches on ego-items and artifacts, giving charges to wands and
4104  * staffs, giving fuel to lites, and placing traps on chests.
4105  *
4106  * In particular, note that "Instant Artifacts", if "created" by an external
4107  * routine, must pass through this function to complete the actual creation.
4108  *
4109  * The base "chance" of the item being "good" increases with the "level"
4110  * parameter, which is usually derived from the dungeon level, being equal
4111  * to the level plus 10, up to a maximum of 75.  If "good" is true, then
4112  * the object is guaranteed to be "good".  If an object is "good", then
4113  * the chance that the object will be "great" (ego-item or artifact), also
4114  * increases with the "level", being equal to half the level, plus 5, up to
4115  * a maximum of 20.  If "great" is true, then the object is guaranteed to be
4116  * "great".  At dungeon level 65 and below, 15/100 objects are "great".
4117  *
4118  * If the object is not "good", there is a chance it will be "cursed", and
4119  * if it is "cursed", there is a chance it will be "broken".  These chances
4120  * are related to the "good" / "great" chances above.
4121  *
4122  * Otherwise "normal" rings and amulets will be "good" half the time and
4123  * "cursed" half the time, unless the ring/amulet is always good or cursed.
4124  *
4125  * If "okay" is true, and the object is going to be "great", then there is
4126  * a chance that an artifact will be created.  This is true even if both the
4127  * "good" and "great" arguments are false.  As a total hack, if "great" is
4128  * true, then the item gets 3 extra "attempts" to become an artifact.
4129  */
4130 void apply_magic(object_type *o_ptr, int lev, bool okay, bool good, bool great, bool curse)
4131 {
4132
4133         int i, rolls, f1, f2, power;
4134
4135         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN) lev += randint0(p_ptr->lev/2+10);
4136
4137         /* Maximum "level" for various things */
4138         if (lev > MAX_DEPTH - 1) lev = MAX_DEPTH - 1;
4139
4140         /* Base chance of being "good" */
4141         f1 = lev + 10;
4142
4143         /* Maximal chance of being "good" */
4144         if (f1 > d_info[dungeon_type].obj_good) f1 = d_info[dungeon_type].obj_good;
4145
4146         /* Base chance of being "great" */
4147         f2 = f1 / 2;
4148
4149         /* Maximal chance of being "great" */
4150         if ((p_ptr->pseikaku != SEIKAKU_MUNCHKIN) && (f2 > d_info[dungeon_type].obj_great))
4151                 f2 = d_info[dungeon_type].obj_great;
4152
4153         if (p_ptr->muta3 & MUT3_GOOD_LUCK)
4154         {
4155                 f1 += 5;
4156                 f2 += 2;
4157         }
4158         else if(p_ptr->muta3 & MUT3_BAD_LUCK)
4159         {
4160                 f1 -= 5;
4161                 f2 -= 2;
4162         }
4163
4164         /* Assume normal */
4165         power = 0;
4166
4167         /* Roll for "good" */
4168         if (good || magik(f1))
4169         {
4170                 /* Assume "good" */
4171                 power = 1;
4172
4173                 /* Roll for "great" */
4174                 if (great || magik(f2)) power = 2;
4175         }
4176
4177         /* Roll for "cursed" */
4178         else if (magik(f1))
4179         {
4180                 /* Assume "cursed" */
4181                 power = -1;
4182
4183                 /* Roll for "broken" */
4184                 if (magik(f2)) power = -2;
4185         }
4186
4187         /* Apply curse */
4188         if (curse)
4189         {
4190                 /* Assume 'cursed' */
4191                 if (power > 0)
4192                 {
4193                         power = 0 - power;
4194                 }
4195                 /* Everything else gets more badly cursed */
4196                 else
4197                 {
4198                         power--;
4199                 }
4200         }
4201
4202         /* Assume no rolls */
4203         rolls = 0;
4204
4205         /* Get one roll if excellent */
4206         if (power >= 2) rolls = 1;
4207
4208         /* Hack -- Get four rolls if forced great */
4209         if (great) rolls = 4;
4210
4211         /* Hack -- Get no rolls if not allowed */
4212         if (!okay || o_ptr->name1) rolls = 0;
4213
4214         /* Roll for artifacts if allowed */
4215         for (i = 0; i < rolls; i++)
4216         {
4217                 /* Roll for an artifact */
4218                 if (make_artifact(o_ptr)) break;
4219                 if ((p_ptr->muta3 & MUT3_GOOD_LUCK) && one_in_(77))
4220                 {
4221                         if (make_artifact(o_ptr)) break;
4222                 }
4223         }
4224
4225
4226         /* Hack -- analyze artifacts */
4227         if (o_ptr->name1)
4228         {
4229                 artifact_type *a_ptr = &a_info[o_ptr->name1];
4230
4231                 /* Hack -- Mark the artifact as "created" */
4232                 a_ptr->cur_num = 1;
4233
4234                 /* Hack -- Memorize location of artifact in saved floors */
4235                 if (character_dungeon)
4236                         a_ptr->floor_id = p_ptr->floor_id;
4237
4238                 /* Extract the other fields */
4239                 o_ptr->pval = a_ptr->pval;
4240                 o_ptr->ac = a_ptr->ac;
4241                 o_ptr->dd = a_ptr->dd;
4242                 o_ptr->ds = a_ptr->ds;
4243                 o_ptr->to_a = a_ptr->to_a;
4244                 o_ptr->to_h = a_ptr->to_h;
4245                 o_ptr->to_d = a_ptr->to_d;
4246                 o_ptr->weight = a_ptr->weight;
4247
4248                 /* Hack -- extract the "broken" flag */
4249                 if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4250
4251                 /* Hack -- extract the "cursed" flag */
4252                 if (a_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4253                 if (a_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4254                 if (a_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4255                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4256                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4257                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4258
4259                 /* Mega-Hack -- increase the rating */
4260                 rating += 10;
4261
4262                 /* Mega-Hack -- increase the rating again */
4263                 if (a_ptr->cost > 50000L) rating += 10;
4264
4265                 /* Mega-Hack -- increase the rating again */
4266                 if (a_ptr->cost > 100000L) rating += 10;
4267
4268                 /* Set the good item flag */
4269                 good_item_flag = TRUE;
4270
4271                 /* Cheat -- peek at the item */
4272                 if (cheat_peek) object_mention(o_ptr);
4273
4274                 /* Done */
4275                 return;
4276         }
4277
4278
4279         /* Apply magic */
4280         switch (o_ptr->tval)
4281         {
4282                 case TV_DIGGING:
4283                 case TV_HAFTED:
4284                 case TV_BOW:
4285                 case TV_SHOT:
4286                 case TV_ARROW:
4287                 case TV_BOLT:
4288                 {
4289                         if (power) a_m_aux_1(o_ptr, lev, power);
4290                         break;
4291                 }
4292
4293                 case TV_POLEARM:
4294                 {
4295                         if (power && !(o_ptr->sval == SV_DEATH_SCYTHE)) a_m_aux_1(o_ptr, lev, power);
4296                         break;
4297                 }
4298
4299                 case TV_SWORD:
4300                 {
4301                         if (power && !(o_ptr->sval == SV_DOKUBARI)) a_m_aux_1(o_ptr, lev, power);
4302                         break;
4303                 }
4304
4305                 case TV_DRAG_ARMOR:
4306                 case TV_HARD_ARMOR:
4307                 case TV_SOFT_ARMOR:
4308                 case TV_SHIELD:
4309                 case TV_HELM:
4310                 case TV_CROWN:
4311                 case TV_CLOAK:
4312                 case TV_GLOVES:
4313                 case TV_BOOTS:
4314                 {
4315                         /* Elven Cloak and Black Clothes ... */
4316                         if (((o_ptr->tval == TV_CLOAK) && (o_ptr->sval == SV_ELVEN_CLOAK)) ||
4317                             ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_KUROSHOUZOKU)))
4318                                 o_ptr->pval = randint1(4);
4319
4320 #if 1
4321                         if (power ||
4322                              ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
4323                              ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
4324                              ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
4325                              ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)))
4326                                 a_m_aux_2(o_ptr, lev, power);
4327 #else
4328                         if (power) a_m_aux_2(o_ptr, lev, power);
4329 #endif
4330                         break;
4331                 }
4332
4333                 case TV_RING:
4334                 case TV_AMULET:
4335                 {
4336                         if (!power && (randint0(100) < 50)) power = -1;
4337                         a_m_aux_3(o_ptr, lev, power);
4338                         break;
4339                 }
4340
4341                 default:
4342                 {
4343                         a_m_aux_4(o_ptr, lev, power);
4344                         break;
4345                 }
4346         }
4347
4348         if ((o_ptr->tval == TV_SOFT_ARMOR) &&
4349             (o_ptr->sval == SV_ABUNAI_MIZUGI) &&
4350             (p_ptr->pseikaku == SEIKAKU_SEXY))
4351         {
4352                 o_ptr->pval = 3;
4353                 add_flag(o_ptr->art_flags, TR_STR);
4354                 add_flag(o_ptr->art_flags, TR_INT);
4355                 add_flag(o_ptr->art_flags, TR_WIS);
4356                 add_flag(o_ptr->art_flags, TR_DEX);
4357                 add_flag(o_ptr->art_flags, TR_CON);
4358                 add_flag(o_ptr->art_flags, TR_CHR);
4359         }
4360
4361         if (o_ptr->art_name) rating += 30;
4362
4363         /* Hack -- analyze ego-items */
4364         else if (o_ptr->name2)
4365         {
4366                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
4367
4368                 /* Hack -- acquire "broken" flag */
4369                 if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4370
4371                 /* Hack -- acquire "cursed" flag */
4372                 if (e_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4373                 if (e_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4374                 if (e_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4375                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4376                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4377                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4378
4379                 if (e_ptr->gen_flags & (TRG_ONE_SUSTAIN)) one_sustain(o_ptr);
4380                 if (e_ptr->gen_flags & (TRG_XTRA_POWER)) one_ability(o_ptr);
4381                 if (e_ptr->gen_flags & (TRG_XTRA_H_RES)) one_high_resistance(o_ptr);
4382                 if (e_ptr->gen_flags & (TRG_XTRA_E_RES)) one_ele_resistance(o_ptr);
4383                 if (e_ptr->gen_flags & (TRG_XTRA_D_RES)) one_dragon_ele_resistance(o_ptr);
4384                 if (e_ptr->gen_flags & (TRG_XTRA_L_RES)) one_lordly_high_resistance(o_ptr);
4385                 if (e_ptr->gen_flags & (TRG_XTRA_RES)) one_resistance(o_ptr);
4386
4387                 /* Hack -- apply extra penalties if needed */
4388                 if (cursed_p(o_ptr) || broken_p(o_ptr))
4389                 {
4390                         /* Hack -- obtain bonuses */
4391                         if (e_ptr->max_to_h) o_ptr->to_h -= randint1(e_ptr->max_to_h);
4392                         if (e_ptr->max_to_d) o_ptr->to_d -= randint1(e_ptr->max_to_d);
4393                         if (e_ptr->max_to_a) o_ptr->to_a -= randint1(e_ptr->max_to_a);
4394
4395                         /* Hack -- obtain pval */
4396                         if (e_ptr->max_pval) o_ptr->pval -= randint1(e_ptr->max_pval);
4397                 }
4398
4399                 /* Hack -- apply extra bonuses if needed */
4400                 else
4401                 {
4402                         /* Hack -- obtain bonuses */
4403                         if (e_ptr->max_to_h)
4404                         {
4405                                 if (e_ptr->max_to_h > 127)
4406                                         o_ptr->to_h -= randint1(256-e_ptr->max_to_h);
4407                                 else o_ptr->to_h += randint1(e_ptr->max_to_h);
4408                         }
4409                         if (e_ptr->max_to_d)
4410                         {
4411                                 if (e_ptr->max_to_d > 127)
4412                                         o_ptr->to_d -= randint1(256-e_ptr->max_to_d);
4413                                 else o_ptr->to_d += randint1(e_ptr->max_to_d);
4414                         }
4415                         if (e_ptr->max_to_a)
4416                         {
4417                                 if (e_ptr->max_to_a > 127)
4418                                         o_ptr->to_a -= randint1(256-e_ptr->max_to_a);
4419                                 else o_ptr->to_a += randint1(e_ptr->max_to_a);
4420                         }
4421
4422                         /* Hack -- obtain pval */
4423                         if (e_ptr->max_pval)
4424                         {
4425                                 if ((o_ptr->name2 == EGO_HA) && (have_flag(o_ptr->art_flags, TR_BLOWS)))
4426                                 {
4427                                         o_ptr->pval++;
4428                                         if ((lev > 60) && one_in_(3) && ((o_ptr->dd*(o_ptr->ds+1)) < 15)) o_ptr->pval++;
4429                                 }
4430                                 else if (o_ptr->name2 == EGO_ATTACKS)
4431                                 {
4432                                         o_ptr->pval = randint1(e_ptr->max_pval*lev/100+1);
4433                                         if (o_ptr->pval > 3) o_ptr->pval = 3;
4434                                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA))
4435                                                 o_ptr->pval += randint1(2);
4436                                 }
4437                                 else if (o_ptr->name2 == EGO_BAT)
4438                                 {
4439                                         o_ptr->pval = randint1(e_ptr->max_pval);
4440                                         if (o_ptr->sval == SV_ELVEN_CLOAK) o_ptr->pval += randint1(2);
4441                                 }
4442                                 else
4443                                 {
4444                                         o_ptr->pval += randint1(e_ptr->max_pval);
4445                                 }
4446                         }
4447                         if ((o_ptr->name2 == EGO_SPEED) && (lev < 50))
4448                         {
4449                                 o_ptr->pval = randint1(o_ptr->pval);
4450                         }
4451                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA) && (o_ptr->pval > 2) && (o_ptr->name2 != EGO_ATTACKS))
4452                                 o_ptr->pval = 2;
4453                 }
4454
4455                 /* Hack -- apply rating bonus */
4456                 rating += e_ptr->rating;
4457
4458                 /* Cheat -- describe the item */
4459                 if (cheat_peek) object_mention(o_ptr);
4460
4461                 /* Done */
4462                 return;
4463         }
4464
4465         /* Examine real objects */
4466         if (o_ptr->k_idx)
4467         {
4468                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
4469
4470                 /* Hack -- acquire "broken" flag */
4471                 if (!get_object_cost(o_ptr)) o_ptr->ident |= (IDENT_BROKEN);
4472
4473                 /* Hack -- acquire "cursed" flag */
4474                 if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
4475                 if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
4476                 if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
4477                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4478                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4479                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4480         }
4481 }
4482
4483
4484 /*
4485  * Hack -- determine if a template is "good"
4486  */
4487 static bool kind_is_good(int k_idx)
4488 {
4489         object_kind *k_ptr = &k_info[k_idx];
4490
4491         /* Analyze the item type */
4492         switch (k_ptr->tval)
4493         {
4494                 /* Armor -- Good unless damaged */
4495                 case TV_HARD_ARMOR:
4496                 case TV_SOFT_ARMOR:
4497                 case TV_DRAG_ARMOR:
4498                 case TV_SHIELD:
4499                 case TV_CLOAK:
4500                 case TV_BOOTS:
4501                 case TV_GLOVES:
4502                 case TV_HELM:
4503                 case TV_CROWN:
4504                 {
4505                         if (k_ptr->to_a < 0) return (FALSE);
4506                         return (TRUE);
4507                 }
4508
4509                 /* Weapons -- Good unless damaged */
4510                 case TV_BOW:
4511                 case TV_SWORD:
4512                 case TV_HAFTED:
4513                 case TV_POLEARM:
4514                 case TV_DIGGING:
4515                 {
4516                         if (k_ptr->to_h < 0) return (FALSE);
4517                         if (k_ptr->to_d < 0) return (FALSE);
4518                         return (TRUE);
4519                 }
4520
4521                 /* Ammo -- Arrows/Bolts are good */
4522                 case TV_BOLT:
4523                 case TV_ARROW:
4524                 {
4525                         return (TRUE);
4526                 }
4527
4528                 /* Books -- High level books are good (except Arcane books) */
4529                 case TV_LIFE_BOOK:
4530                 case TV_SORCERY_BOOK:
4531                 case TV_NATURE_BOOK:
4532                 case TV_CHAOS_BOOK:
4533                 case TV_DEATH_BOOK:
4534                 case TV_TRUMP_BOOK:
4535                 case TV_ENCHANT_BOOK:
4536                 case TV_DAEMON_BOOK:
4537                 case TV_CRUSADE_BOOK:
4538                 case TV_MUSIC_BOOK:
4539                 case TV_HISSATSU_BOOK:
4540                 {
4541                         if (k_ptr->sval >= SV_BOOK_MIN_GOOD) return (TRUE);
4542                         return (FALSE);
4543                 }
4544
4545                 /* Rings -- Rings of Speed are good */
4546                 case TV_RING:
4547                 {
4548                         if (k_ptr->sval == SV_RING_SPEED) return (TRUE);
4549                         if (k_ptr->sval == SV_RING_LORDLY) return (TRUE);
4550                         return (FALSE);
4551                 }
4552
4553                 /* Amulets -- Amulets of the Magi and Resistance are good */
4554                 case TV_AMULET:
4555                 {
4556                         if (k_ptr->sval == SV_AMULET_THE_MAGI) return (TRUE);
4557                         if (k_ptr->sval == SV_AMULET_RESISTANCE) return (TRUE);
4558                         return (FALSE);
4559                 }
4560         }
4561
4562         /* Assume not good */
4563         return (FALSE);
4564 }
4565
4566
4567 /*
4568  * Attempt to make an object (normal or good/great)
4569  *
4570  * This routine plays nasty games to generate the "special artifacts".
4571  *
4572  * This routine uses "object_level" for the "generation level".
4573  *
4574  * We assume that the given object has been "wiped".
4575  */
4576 bool make_object(object_type *j_ptr, bool good, bool great)
4577 {
4578         int prob, base;
4579         byte obj_level;
4580
4581
4582         /* Chance of "special object" */
4583         prob = (good ? 10 : 1000);
4584
4585         /* Base level for the object */
4586         base = (good ? (object_level + 10) : object_level);
4587
4588
4589         /* Generate a special object, or a normal object */
4590         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4591         {
4592                 int k_idx;
4593
4594                 /* Good objects */
4595                 if (good)
4596                 {
4597                         /* Activate restriction */
4598                         get_obj_num_hook = kind_is_good;
4599
4600                         /* Prepare allocation table */
4601                         get_obj_num_prep();
4602                 }
4603
4604                 /* Pick a random object */
4605                 k_idx = get_obj_num(base);
4606
4607                 /* Good objects */
4608                 if (get_obj_num_hook)
4609                 {
4610                         /* Clear restriction */
4611                         get_obj_num_hook = NULL;
4612
4613                         /* Prepare allocation table */
4614                         get_obj_num_prep();
4615                 }
4616
4617                 /* Handle failure */
4618                 if (!k_idx) return (FALSE);
4619
4620                 /* Prepare the object */
4621                 object_prep(j_ptr, k_idx);
4622         }
4623
4624         /* Apply magic (allow artifacts) */
4625         apply_magic(j_ptr, object_level, TRUE, good, great, FALSE);
4626
4627         /* Hack -- generate multiple spikes/missiles */
4628         switch (j_ptr->tval)
4629         {
4630                 case TV_SPIKE:
4631                 case TV_SHOT:
4632                 case TV_ARROW:
4633                 case TV_BOLT:
4634                 {
4635                         if (!j_ptr->name1)
4636                                 j_ptr->number = (byte)damroll(6, 7);
4637                 }
4638         }
4639
4640         obj_level = get_object_level(j_ptr);
4641         if (artifact_p(j_ptr)) obj_level = a_info[j_ptr->name1].level;
4642
4643         /* Notice "okay" out-of-depth objects */
4644         if (!cursed_p(j_ptr) && !broken_p(j_ptr) &&
4645             (obj_level > dun_level))
4646         {
4647                 /* Rating increase */
4648                 rating += (obj_level - dun_level);
4649
4650                 /* Cheat -- peek at items */
4651                 if (cheat_peek) object_mention(j_ptr);
4652         }
4653
4654         /* Success */
4655         return (TRUE);
4656 }
4657
4658
4659 /*
4660  * Attempt to place an object (normal or good/great) at the given location.
4661  *
4662  * This routine plays nasty games to generate the "special artifacts".
4663  *
4664  * This routine uses "object_level" for the "generation level".
4665  *
4666  * This routine requires a clean floor grid destination.
4667  */
4668 void place_object(int y, int x, bool good, bool great)
4669 {
4670         s16b o_idx;
4671
4672         cave_type *c_ptr;
4673
4674         object_type forge;
4675         object_type *q_ptr;
4676
4677
4678         /* Paranoia -- check bounds */
4679         if (!in_bounds(y, x)) return;
4680
4681         /* Require clean floor space */
4682         if (!cave_clean_bold(y, x)) return;
4683
4684
4685         /* Get local object */
4686         q_ptr = &forge;
4687
4688         /* Wipe the object */
4689         object_wipe(q_ptr);
4690
4691         /* Make an object (if possible) */
4692         if (!make_object(q_ptr, good, great)) return;
4693
4694
4695         /* Make an object */
4696         o_idx = o_pop();
4697
4698         /* Success */
4699         if (o_idx)
4700         {
4701                 object_type *o_ptr;
4702
4703                 /* Acquire object */
4704                 o_ptr = &o_list[o_idx];
4705
4706                 /* Structure Copy */
4707                 object_copy(o_ptr, q_ptr);
4708
4709                 /* Location */
4710                 o_ptr->iy = y;
4711                 o_ptr->ix = x;
4712
4713                 /* Acquire grid */
4714                 c_ptr = &cave[y][x];
4715
4716                 /* Build a stack */
4717                 o_ptr->next_o_idx = c_ptr->o_idx;
4718
4719                 /* Place the object */
4720                 c_ptr->o_idx = o_idx;
4721
4722                 /* Notice */
4723                 note_spot(y, x);
4724
4725                 /* Redraw */
4726                 lite_spot(y, x);
4727         }
4728         else
4729         {
4730                 /* Hack -- Preserve artifacts */
4731                 if (q_ptr->name1)
4732                 {
4733                         a_info[q_ptr->name1].cur_num = 0;
4734                 }
4735         }
4736 }
4737
4738
4739 /*
4740  * Make a treasure object
4741  *
4742  * The location must be a legal, clean, floor grid.
4743  */
4744 bool make_gold(object_type *j_ptr)
4745 {
4746         int i;
4747
4748         s32b base;
4749
4750
4751         /* Hack -- Pick a Treasure variety */
4752         i = ((randint1(object_level + 2) + 2) / 2) - 1;
4753
4754         /* Apply "extra" magic */
4755         if (one_in_(GREAT_OBJ))
4756         {
4757                 i += randint1(object_level + 1);
4758         }
4759
4760         /* Hack -- Creeping Coins only generate "themselves" */
4761         if (coin_type) i = coin_type;
4762
4763         /* Do not create "illegal" Treasure Types */
4764         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4765
4766         /* Prepare a gold object */
4767         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4768
4769         /* Hack -- Base coin cost */
4770         base = k_info[OBJ_GOLD_LIST+i].cost;
4771
4772         /* Determine how much the treasure is "worth" */
4773         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4774
4775         /* Success */
4776         return (TRUE);
4777 }
4778
4779
4780 /*
4781  * Places a treasure (Gold or Gems) at given location
4782  *
4783  * The location must be a legal, clean, floor grid.
4784  */
4785 void place_gold(int y, int x)
4786 {
4787         s16b o_idx;
4788
4789         cave_type *c_ptr;
4790
4791         object_type forge;
4792         object_type *q_ptr;
4793
4794
4795         /* Paranoia -- check bounds */
4796         if (!in_bounds(y, x)) return;
4797
4798         /* Require clean floor space */
4799         if (!cave_clean_bold(y, x)) return;
4800
4801
4802         /* Get local object */
4803         q_ptr = &forge;
4804
4805         /* Wipe the object */
4806         object_wipe(q_ptr);
4807
4808         /* Make some gold */
4809         if (!make_gold(q_ptr)) return;
4810
4811
4812         /* Make an object */
4813         o_idx = o_pop();
4814
4815         /* Success */
4816         if (o_idx)
4817         {
4818                 object_type *o_ptr;
4819
4820                 /* Acquire object */
4821                 o_ptr = &o_list[o_idx];
4822
4823                 /* Copy the object */
4824                 object_copy(o_ptr, q_ptr);
4825
4826                 /* Save location */
4827                 o_ptr->iy = y;
4828                 o_ptr->ix = x;
4829
4830                 /* Acquire grid */
4831                 c_ptr = &cave[y][x];
4832
4833                 /* Build a stack */
4834                 o_ptr->next_o_idx = c_ptr->o_idx;
4835
4836                 /* Place the object */
4837                 c_ptr->o_idx = o_idx;
4838
4839                 /* Notice */
4840                 note_spot(y, x);
4841
4842                 /* Redraw */
4843                 lite_spot(y, x);
4844         }
4845 }
4846
4847
4848 /*
4849  * Let an object fall to the ground at or near a location.
4850  *
4851  * The initial location is assumed to be "in_bounds()".
4852  *
4853  * This function takes a parameter "chance".  This is the percentage
4854  * chance that the item will "disappear" instead of drop.  If the object
4855  * has been thrown, then this is the chance of disappearance on contact.
4856  *
4857  * Hack -- this function uses "chance" to determine if it should produce
4858  * some form of "description" of the drop event (under the player).
4859  *
4860  * We check several locations to see if we can find a location at which
4861  * the object can combine, stack, or be placed.  Artifacts will try very
4862  * hard to be placed, including "teleporting" to a useful grid if needed.
4863  */
4864 s16b drop_near(object_type *j_ptr, int chance, int y, int x)
4865 {
4866         int i, k, d, s;
4867
4868         int bs, bn;
4869         int by, bx;
4870         int dy, dx;
4871         int ty, tx;
4872
4873         s16b o_idx = 0;
4874
4875         s16b this_o_idx, next_o_idx = 0;
4876
4877         cave_type *c_ptr;
4878
4879         char o_name[MAX_NLEN];
4880
4881         bool flag = FALSE;
4882         bool done = FALSE;
4883
4884         bool plural = FALSE;
4885
4886
4887         /* Extract plural */
4888         if (j_ptr->number != 1) plural = TRUE;
4889
4890         /* Describe object */
4891         object_desc(o_name, j_ptr, FALSE, 0);
4892
4893
4894         /* Handle normal "breakage" */
4895         if (!(j_ptr->art_name || artifact_p(j_ptr)) && (randint0(100) < chance))
4896         {
4897                 /* Message */
4898 #ifdef JP
4899                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
4900 #else
4901                 msg_format("The %s disappear%s.",
4902                            o_name, (plural ? "" : "s"));
4903 #endif
4904
4905
4906                 /* Debug */
4907 #ifdef JP
4908                 if (p_ptr->wizard) msg_print("(ÇËÂ»)");
4909 #else
4910                 if (p_ptr->wizard) msg_print("(breakage)");
4911 #endif
4912
4913
4914                 /* Failure */
4915                 return (0);
4916         }
4917
4918
4919         /* Score */
4920         bs = -1;
4921
4922         /* Picker */
4923         bn = 0;
4924
4925         /* Default */
4926         by = y;
4927         bx = x;
4928
4929         /* Scan local grids */
4930         for (dy = -3; dy <= 3; dy++)
4931         {
4932                 /* Scan local grids */
4933                 for (dx = -3; dx <= 3; dx++)
4934                 {
4935                         bool comb = FALSE;
4936
4937                         /* Calculate actual distance */
4938                         d = (dy * dy) + (dx * dx);
4939
4940                         /* Ignore distant grids */
4941                         if (d > 10) continue;
4942
4943                         /* Location */
4944                         ty = y + dy;
4945                         tx = x + dx;
4946
4947                         /* Skip illegal grids */
4948                         if (!in_bounds(ty, tx)) continue;
4949
4950                         /* Require line of sight */
4951                         if (!los(y, x, ty, tx)) continue;
4952
4953                         /* Obtain grid */
4954                         c_ptr = &cave[ty][tx];
4955
4956                         /* Require floor space */
4957                         if ((c_ptr->feat != FEAT_FLOOR) &&
4958                             (c_ptr->feat != FEAT_SHAL_WATER) &&
4959                             (c_ptr->feat != FEAT_GRASS) &&
4960                             (c_ptr->feat != FEAT_DIRT) &&
4961                             (c_ptr->feat != FEAT_FLOWER) &&
4962                             (c_ptr->feat != FEAT_DEEP_GRASS) &&
4963                             (c_ptr->feat != FEAT_SHAL_LAVA) &&
4964                             (c_ptr->feat != FEAT_TREES)) continue;
4965                         if (c_ptr->info & (CAVE_OBJECT)) continue;
4966
4967                         /* No objects */
4968                         k = 0;
4969
4970                         /* Scan objects in that grid */
4971                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
4972                         {
4973                                 object_type *o_ptr;
4974
4975                                 /* Acquire object */
4976                                 o_ptr = &o_list[this_o_idx];
4977
4978                                 /* Acquire next object */
4979                                 next_o_idx = o_ptr->next_o_idx;
4980
4981                                 /* Check for possible combination */
4982                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
4983
4984                                 /* Count objects */
4985                                 k++;
4986                         }
4987
4988                         /* Add new object */
4989                         if (!comb) k++;
4990
4991                         /* Paranoia */
4992                         if (k > 99) continue;
4993
4994                         /* Calculate score */
4995                         s = 1000 - (d + k * 5);
4996
4997                         /* Skip bad values */
4998                         if (s < bs) continue;
4999
5000                         /* New best value */
5001                         if (s > bs) bn = 0;
5002
5003                         /* Apply the randomizer to equivalent values */
5004                         if ((++bn >= 2) && !one_in_(bn)) continue;
5005
5006                         /* Keep score */
5007                         bs = s;
5008
5009                         /* Track it */
5010                         by = ty;
5011                         bx = tx;
5012
5013                         /* Okay */
5014                         flag = TRUE;
5015                 }
5016         }
5017
5018
5019         /* Handle lack of space */
5020         if (!flag && !(artifact_p(j_ptr) || j_ptr->art_name))
5021         {
5022                 /* Message */
5023 #ifdef JP
5024                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
5025 #else
5026                 msg_format("The %s disappear%s.",
5027                            o_name, (plural ? "" : "s"));
5028 #endif
5029
5030
5031                 /* Debug */
5032 #ifdef JP
5033                 if (p_ptr->wizard) msg_print("(¾²¥¹¥Ú¡¼¥¹¤¬¤Ê¤¤)");
5034 #else
5035                 if (p_ptr->wizard) msg_print("(no floor space)");
5036 #endif
5037
5038
5039                 /* Failure */
5040                 return (0);
5041         }
5042
5043
5044         /* Find a grid */
5045         for (i = 0; !flag; i++)
5046         {
5047                 /* Bounce around */
5048                 if (i < 1000)
5049                 {
5050                         ty = rand_spread(by, 1);
5051                         tx = rand_spread(bx, 1);
5052                 }
5053
5054                 /* Random locations */
5055                 else
5056                 {
5057                         ty = randint0(cur_hgt);
5058                         tx = randint0(cur_wid);
5059                 }
5060
5061                 /* Grid */
5062                 c_ptr = &cave[ty][tx];
5063
5064                 /* Require floor space (or shallow terrain) -KMW- */
5065                 if ((c_ptr->feat != FEAT_FLOOR) &&
5066                     (c_ptr->feat != FEAT_SHAL_WATER) &&
5067                     (c_ptr->feat != FEAT_GRASS) &&
5068                     (c_ptr->feat != FEAT_DIRT) &&
5069                     (c_ptr->feat != FEAT_SHAL_LAVA)) continue;
5070
5071                 /* Bounce to that location */
5072                 by = ty;
5073                 bx = tx;
5074
5075                 /* Require floor space */
5076                 if (!cave_clean_bold(by, bx)) continue;
5077
5078                 /* Okay */
5079                 flag = TRUE;
5080         }
5081
5082
5083         /* Grid */
5084         c_ptr = &cave[by][bx];
5085
5086         /* Scan objects in that grid for combination */
5087         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5088         {
5089                 object_type *o_ptr;
5090
5091                 /* Acquire object */
5092                 o_ptr = &o_list[this_o_idx];
5093
5094                 /* Acquire next object */
5095                 next_o_idx = o_ptr->next_o_idx;
5096
5097                 /* Check for combination */
5098                 if (object_similar(o_ptr, j_ptr))
5099                 {
5100                         /* Combine the items */
5101                         object_absorb(o_ptr, j_ptr);
5102
5103                         /* Success */
5104                         done = TRUE;
5105
5106                         /* Done */
5107                         break;
5108                 }
5109         }
5110
5111         /* Get new object */
5112         if (!done) o_idx = o_pop();
5113
5114         /* Failure */
5115         if (!done && !o_idx)
5116         {
5117                 /* Message */
5118 #ifdef JP
5119                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
5120 #else
5121                 msg_format("The %s disappear%s.",
5122                            o_name, (plural ? "" : "s"));
5123 #endif
5124
5125
5126                 /* Debug */
5127 #ifdef JP
5128                 if (p_ptr->wizard) msg_print("(¥¢¥¤¥Æ¥à¤¬Â¿²á¤®¤ë)");
5129 #else
5130                 if (p_ptr->wizard) msg_print("(too many objects)");
5131 #endif
5132
5133
5134                 /* Hack -- Preserve artifacts */
5135                 if (j_ptr->name1)
5136                 {
5137                         a_info[j_ptr->name1].cur_num = 0;
5138                 }
5139
5140                 /* Failure */
5141                 return (0);
5142         }
5143
5144         /* Stack */
5145         if (!done)
5146         {
5147                 /* Structure copy */
5148                 object_copy(&o_list[o_idx], j_ptr);
5149
5150                 /* Access new object */
5151                 j_ptr = &o_list[o_idx];
5152
5153                 /* Locate */
5154                 j_ptr->iy = by;
5155                 j_ptr->ix = bx;
5156
5157                 /* No monster */
5158                 j_ptr->held_m_idx = 0;
5159
5160                 /* Build a stack */
5161                 j_ptr->next_o_idx = c_ptr->o_idx;
5162
5163                 /* Place the object */
5164                 c_ptr->o_idx = o_idx;
5165
5166                 /* Success */
5167                 done = TRUE;
5168         }
5169
5170         /* Note the spot */
5171         note_spot(by, bx);
5172
5173         /* Draw the spot */
5174         lite_spot(by, bx);
5175
5176         /* Sound */
5177         sound(SOUND_DROP);
5178
5179         /* Mega-Hack -- no message if "dropped" by player */
5180         /* Message when an object falls under the player */
5181         if (chance && (by == py) && (bx == px))
5182         {
5183 #ifdef JP
5184                 msg_print("²¿¤«¤¬Â²¼¤ËÅ¾¤¬¤Ã¤Æ¤¤¿¡£");
5185 #else
5186                 msg_print("You feel something roll beneath your feet.");
5187 #endif
5188
5189         }
5190
5191         /* XXX XXX XXX */
5192
5193         /* Result */
5194         return (o_idx);
5195 }
5196
5197
5198 /*
5199  * Scatter some "great" objects near the player
5200  */
5201 void acquirement(int y1, int x1, int num, bool great, bool known)
5202 {
5203         object_type *i_ptr;
5204         object_type object_type_body;
5205
5206         /* Acquirement */
5207         while (num--)
5208         {
5209                 /* Get local object */
5210                 i_ptr = &object_type_body;
5211
5212                 /* Wipe the object */
5213                 object_wipe(i_ptr);
5214
5215                 /* Make a good (or great) object (if possible) */
5216                 if (!make_object(i_ptr, TRUE, great)) continue;
5217
5218                 if (known)
5219                 {
5220                         object_aware(i_ptr);
5221                         object_known(i_ptr);
5222                 }
5223
5224                 /* Drop the object */
5225                 (void)drop_near(i_ptr, -1, y1, x1);
5226         }
5227 }
5228
5229
5230 #define MAX_TRAPS               18
5231
5232 static int trap_num[MAX_TRAPS] =
5233 {
5234         FEAT_TRAP_TRAPDOOR,
5235         FEAT_TRAP_PIT,
5236         FEAT_TRAP_SPIKED_PIT,
5237         FEAT_TRAP_POISON_PIT,
5238         FEAT_TRAP_TY_CURSE,
5239         FEAT_TRAP_TELEPORT,
5240         FEAT_TRAP_FIRE,
5241         FEAT_TRAP_ACID,
5242         FEAT_TRAP_SLOW,
5243         FEAT_TRAP_LOSE_STR,
5244         FEAT_TRAP_LOSE_DEX,
5245         FEAT_TRAP_LOSE_CON,
5246         FEAT_TRAP_BLIND,
5247         FEAT_TRAP_CONFUSE,
5248         FEAT_TRAP_POISON,
5249         FEAT_TRAP_SLEEP,
5250         FEAT_TRAP_TRAPS,
5251         FEAT_TRAP_ALARM,
5252 };
5253
5254
5255 /*
5256  * Get random trap
5257  *
5258  * XXX XXX XXX This routine should be redone to reflect trap "level".
5259  * That is, it does not make sense to have spiked pits at 50 feet.
5260  * Actually, it is not this routine, but the "trap instantiation"
5261  * code, which should also check for "trap doors" on quest levels.
5262  */
5263 byte choose_random_trap(void)
5264 {
5265         byte feat;
5266
5267         /* Pick a trap */
5268         while (1)
5269         {
5270                 /* Hack -- pick a trap */
5271                 feat = trap_num[randint0(MAX_TRAPS)];
5272
5273                 /* Accept non-trapdoors */
5274                 if (feat != FEAT_TRAP_TRAPDOOR) break;
5275
5276                 /* Hack -- no trap doors on special levels */
5277                 if (p_ptr->inside_arena || quest_number(dun_level)) continue;
5278
5279                 /* Hack -- no trap doors on the deepest level */
5280                 if (dun_level >= d_info[dungeon_type].maxdepth) continue;
5281
5282                 break;
5283         }
5284
5285         return feat;
5286 }
5287
5288 /*
5289  * Disclose an invisible trap
5290  */
5291 void disclose_grid(int y, int x)
5292 {
5293         cave_type *c_ptr = &cave[y][x];
5294
5295         /* Paranoia */
5296         if (!c_ptr->mimic) return;
5297
5298         /* No longer hidden */
5299         c_ptr->mimic = 0;
5300
5301         /* Notice */
5302         note_spot(y, x);
5303
5304         /* Redraw */
5305         lite_spot(y, x);
5306 }
5307
5308
5309 /*
5310  * Places a random trap at the given location.
5311  *
5312  * The location must be a legal, naked, floor grid.
5313  *
5314  * Note that all traps start out as "invisible" and "untyped", and then
5315  * when they are "discovered" (by detecting them or setting them off),
5316  * the trap is "instantiated" as a visible, "typed", trap.
5317  */
5318 void place_trap(int y, int x)
5319 {
5320         cave_type *c_ptr = &cave[y][x];
5321
5322         /* Paranoia -- verify location */
5323         if (!in_bounds(y, x)) return;
5324
5325         /* Require empty, clean, floor grid */
5326         if (!cave_naked_bold(y, x)) return;
5327
5328         /* Place an invisible trap */
5329         c_ptr->mimic = c_ptr->feat;
5330         c_ptr->feat = choose_random_trap();
5331 }
5332
5333
5334 /*
5335  * Describe the charges on an item in the inventory.
5336  */
5337 void inven_item_charges(int item)
5338 {
5339         object_type *o_ptr = &inventory[item];
5340
5341         /* Require staff/wand */
5342         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5343
5344         /* Require known item */
5345         if (!object_known_p(o_ptr)) return;
5346
5347 #ifdef JP
5348         if (o_ptr->pval <= 0)
5349         {
5350                 msg_print("¤â¤¦ËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤Ê¤¤¡£");
5351         }
5352         else
5353         {
5354                 msg_format("¤¢¤È %d ²óÊ¬¤ÎËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤ë¡£", o_ptr->pval);
5355         }
5356 #else
5357         /* Multiple charges */
5358         if (o_ptr->pval != 1)
5359         {
5360                 /* Print a message */
5361                 msg_format("You have %d charges remaining.", o_ptr->pval);
5362         }
5363
5364         /* Single charge */
5365         else
5366         {
5367                 /* Print a message */
5368                 msg_format("You have %d charge remaining.", o_ptr->pval);
5369         }
5370 #endif
5371
5372 }
5373
5374
5375 /*
5376  * Describe an item in the inventory.
5377  */
5378 void inven_item_describe(int item)
5379 {
5380         object_type *o_ptr = &inventory[item];
5381         char        o_name[MAX_NLEN];
5382
5383         /* Get a description */
5384         object_desc(o_name, o_ptr, TRUE, 3);
5385
5386         /* Print a message */
5387 #ifdef JP
5388         /* "no more" ¤Î¾ì¹ç¤Ï¤³¤Á¤é¤ÇÉ½¼¨¤¹¤ë */
5389         if (o_ptr->number <= 0)
5390         {
5391                 /*FIRST*//*¤³¤³¤Ï¤â¤¦ÄÌ¤é¤Ê¤¤¤«¤â */
5392                 msg_format("¤â¤¦%s¤ò»ý¤Ã¤Æ¤¤¤Ê¤¤¡£", o_name);
5393         }
5394         else
5395         {
5396                 /* ¥¢¥¤¥Æ¥àÌ¾¤ò±ÑÆüÀÚ¤êÂØ¤¨µ¡Ç½ÂÐ±þ */
5397                 msg_format("¤Þ¤À %s¤ò»ý¤Ã¤Æ¤¤¤ë¡£", o_name);
5398         }
5399 #else
5400         msg_format("You have %s.", o_name);
5401 #endif
5402
5403 }
5404
5405
5406 /*
5407  * Increase the "number" of an item in the inventory
5408  */
5409 void inven_item_increase(int item, int num)
5410 {
5411         object_type *o_ptr = &inventory[item];
5412
5413         /* Apply */
5414         num += o_ptr->number;
5415
5416         /* Bounds check */
5417         if (num > 255) num = 255;
5418         else if (num < 0) num = 0;
5419
5420         /* Un-apply */
5421         num -= o_ptr->number;
5422
5423         /* Change the number and weight */
5424         if (num)
5425         {
5426                 /* Add the number */
5427                 o_ptr->number += num;
5428
5429                 /* Add the weight */
5430                 p_ptr->total_weight += (num * o_ptr->weight);
5431
5432                 /* Recalculate bonuses */
5433                 p_ptr->update |= (PU_BONUS);
5434
5435                 /* Recalculate mana XXX */
5436                 p_ptr->update |= (PU_MANA);
5437
5438                 /* Combine the pack */
5439                 p_ptr->notice |= (PN_COMBINE);
5440
5441                 /* Window stuff */
5442                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5443         }
5444 }
5445
5446
5447 /*
5448  * Erase an inventory slot if it has no more items
5449  */
5450 void inven_item_optimize(int item)
5451 {
5452         object_type *o_ptr = &inventory[item];
5453
5454         /* Only optimize real items */
5455         if (!o_ptr->k_idx) return;
5456
5457         /* Only optimize empty items */
5458         if (o_ptr->number) return;
5459
5460         /* The item is in the pack */
5461         if (item < INVEN_RARM)
5462         {
5463                 int i;
5464
5465                 /* One less item */
5466                 inven_cnt--;
5467
5468                 /* Slide everything down */
5469                 for (i = item; i < INVEN_PACK; i++)
5470                 {
5471                         /* Structure copy */
5472                         inventory[i] = inventory[i+1];
5473                 }
5474
5475                 /* Erase the "final" slot */
5476                 object_wipe(&inventory[i]);
5477
5478                 /* Window stuff */
5479                 p_ptr->window |= (PW_INVEN);
5480         }
5481
5482         /* The item is being wielded */
5483         else
5484         {
5485                 /* One less item */
5486                 equip_cnt--;
5487
5488                 /* Erase the empty slot */
5489                 object_wipe(&inventory[item]);
5490
5491                 /* Recalculate bonuses */
5492                 p_ptr->update |= (PU_BONUS);
5493
5494                 /* Recalculate torch */
5495                 p_ptr->update |= (PU_TORCH);
5496
5497                 /* Recalculate mana XXX */
5498                 p_ptr->update |= (PU_MANA);
5499
5500                 /* Window stuff */
5501                 p_ptr->window |= (PW_EQUIP);
5502         }
5503
5504         /* Window stuff */
5505         p_ptr->window |= (PW_SPELL);
5506 }
5507
5508
5509 /*
5510  * Describe the charges on an item on the floor.
5511  */
5512 void floor_item_charges(int item)
5513 {
5514         object_type *o_ptr = &o_list[item];
5515
5516         /* Require staff/wand */
5517         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5518
5519         /* Require known item */
5520         if (!object_known_p(o_ptr)) return;
5521
5522 #ifdef JP
5523         if (o_ptr->pval <= 0)
5524         {
5525                 msg_print("¤³¤Î¾²¾å¤Î¥¢¥¤¥Æ¥à¤Ï¡¢¤â¤¦ËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤Ê¤¤¡£");
5526         }
5527         else
5528         {
5529                 msg_format("¤³¤Î¾²¾å¤Î¥¢¥¤¥Æ¥à¤Ï¡¢¤¢¤È %d ²óÊ¬¤ÎËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤ë¡£", o_ptr->pval);
5530         }
5531 #else
5532         /* Multiple charges */
5533         if (o_ptr->pval != 1)
5534         {
5535                 /* Print a message */
5536                 msg_format("There are %d charges remaining.", o_ptr->pval);
5537         }
5538
5539         /* Single charge */
5540         else
5541         {
5542                 /* Print a message */
5543                 msg_format("There is %d charge remaining.", o_ptr->pval);
5544         }
5545 #endif
5546
5547 }
5548
5549
5550 /*
5551  * Describe an item in the inventory.
5552  */
5553 void floor_item_describe(int item)
5554 {
5555         object_type *o_ptr = &o_list[item];
5556         char        o_name[MAX_NLEN];
5557
5558         /* Get a description */
5559         object_desc(o_name, o_ptr, TRUE, 3);
5560
5561         /* Print a message */
5562 #ifdef JP
5563         /* "no more" ¤Î¾ì¹ç¤Ï¤³¤Á¤é¤ÇÉ½¼¨¤òÊ¬¤±¤ë */
5564         if (o_ptr->number <= 0)
5565         {
5566                 msg_format("¾²¾å¤Ë¤Ï¡¢¤â¤¦%s¤Ï¤Ê¤¤¡£", o_name);
5567         }
5568         else
5569         {
5570                 msg_format("¾²¾å¤Ë¤Ï¡¢¤Þ¤À %s¤¬¤¢¤ë¡£", o_name);
5571         }
5572 #else
5573         msg_format("You see %s.", o_name);
5574 #endif
5575
5576 }
5577
5578
5579 /*
5580  * Increase the "number" of an item on the floor
5581  */
5582 void floor_item_increase(int item, int num)
5583 {
5584         object_type *o_ptr = &o_list[item];
5585
5586         /* Apply */
5587         num += o_ptr->number;
5588
5589         /* Bounds check */
5590         if (num > 255) num = 255;
5591         else if (num < 0) num = 0;
5592
5593         /* Un-apply */
5594         num -= o_ptr->number;
5595
5596         /* Change the number */
5597         o_ptr->number += num;
5598 }
5599
5600
5601 /*
5602  * Optimize an item on the floor (destroy "empty" items)
5603  */
5604 void floor_item_optimize(int item)
5605 {
5606         object_type *o_ptr = &o_list[item];
5607
5608         /* Paranoia -- be sure it exists */
5609         if (!o_ptr->k_idx) return;
5610
5611         /* Only optimize empty items */
5612         if (o_ptr->number) return;
5613
5614         /* Delete the object */
5615         delete_object_idx(item);
5616 }
5617
5618
5619 /*
5620  * Check if we have space for an item in the pack without overflow
5621  */
5622 bool inven_carry_okay(object_type *o_ptr)
5623 {
5624         int j;
5625
5626         /* Empty slot? */
5627         if (inven_cnt < INVEN_PACK) return (TRUE);
5628
5629         /* Similar slot? */
5630         for (j = 0; j < INVEN_PACK; j++)
5631         {
5632                 object_type *j_ptr = &inventory[j];
5633
5634                 /* Skip non-objects */
5635                 if (!j_ptr->k_idx) continue;
5636
5637                 /* Check if the two items can be combined */
5638                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
5639         }
5640
5641         /* Nope */
5642         return (FALSE);
5643 }
5644
5645
5646 /*
5647  * Add an item to the players inventory, and return the slot used.
5648  *
5649  * If the new item can combine with an existing item in the inventory,
5650  * it will do so, using "object_similar()" and "object_absorb()", else,
5651  * the item will be placed into the "proper" location in the inventory.
5652  *
5653  * This function can be used to "over-fill" the player's pack, but only
5654  * once, and such an action must trigger the "overflow" code immediately.
5655  * Note that when the pack is being "over-filled", the new item must be
5656  * placed into the "overflow" slot, and the "overflow" must take place
5657  * before the pack is reordered, but (optionally) after the pack is
5658  * combined.  This may be tricky.  See "dungeon.c" for info.
5659  *
5660  * Note that this code must remove any location/stack information
5661  * from the object once it is placed into the inventory.
5662  */
5663 s16b inven_carry(object_type *o_ptr)
5664 {
5665         int i, j, k;
5666         int n = -1;
5667
5668         object_type *j_ptr;
5669
5670
5671         /* Check for combining */
5672         for (j = 0; j < INVEN_PACK; j++)
5673         {
5674                 j_ptr = &inventory[j];
5675
5676                 /* Skip non-objects */
5677                 if (!j_ptr->k_idx) continue;
5678
5679                 /* Hack -- track last item */
5680                 n = j;
5681
5682                 /* Check if the two items can be combined */
5683                 if (object_similar(j_ptr, o_ptr))
5684                 {
5685                         /* Combine the items */
5686                         object_absorb(j_ptr, o_ptr);
5687
5688                         /* Increase the weight */
5689                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
5690
5691                         /* Recalculate bonuses */
5692                         p_ptr->update |= (PU_BONUS);
5693
5694                         /* Window stuff */
5695                         p_ptr->window |= (PW_INVEN);
5696
5697                         /* Success */
5698                         return (j);
5699                 }
5700         }
5701
5702
5703         /* Paranoia */
5704         if (inven_cnt > INVEN_PACK) return (-1);
5705
5706         /* Find an empty slot */
5707         for (j = 0; j <= INVEN_PACK; j++)
5708         {
5709                 j_ptr = &inventory[j];
5710
5711                 /* Use it if found */
5712                 if (!j_ptr->k_idx) break;
5713         }
5714
5715         /* Use that slot */
5716         i = j;
5717
5718
5719         /* Reorder the pack */
5720         if (i < INVEN_PACK)
5721         {
5722                 s32b o_value, j_value;
5723
5724                 /* Get the "value" of the item */
5725                 o_value = object_value(o_ptr);
5726
5727                 /* Scan every occupied slot */
5728                 for (j = 0; j < INVEN_PACK; j++)
5729                 {
5730                         j_ptr = &inventory[j];
5731
5732                         /* Use empty slots */
5733                         if (!j_ptr->k_idx) break;
5734
5735                         /* Hack -- readable books always come first */
5736                         if ((o_ptr->tval == REALM1_BOOK) &&
5737                             (j_ptr->tval != REALM1_BOOK)) break;
5738                         if ((j_ptr->tval == REALM1_BOOK) &&
5739                             (o_ptr->tval != REALM1_BOOK)) continue;
5740
5741                         if ((o_ptr->tval == REALM2_BOOK) &&
5742                             (j_ptr->tval != REALM2_BOOK)) break;
5743                         if ((j_ptr->tval == REALM2_BOOK) &&
5744                             (o_ptr->tval != REALM2_BOOK)) continue;
5745
5746                         /* Objects sort by decreasing type */
5747                         if (o_ptr->tval > j_ptr->tval) break;
5748                         if (o_ptr->tval < j_ptr->tval) continue;
5749
5750                         /* Non-aware (flavored) items always come last */
5751                         if (!object_aware_p(o_ptr)) continue;
5752                         if (!object_aware_p(j_ptr)) break;
5753
5754                         /* Objects sort by increasing sval */
5755                         if (o_ptr->sval < j_ptr->sval) break;
5756                         if (o_ptr->sval > j_ptr->sval) continue;
5757
5758                         /* Unidentified objects always come last */
5759                         if (!object_known_p(o_ptr)) continue;
5760                         if (!object_known_p(j_ptr)) break;
5761
5762                         /* Hack:  otherwise identical rods sort by
5763                         increasing recharge time --dsb */
5764                         if (o_ptr->tval == TV_ROD)
5765                         {
5766                                 if (o_ptr->pval < j_ptr->pval) break;
5767                                 if (o_ptr->pval > j_ptr->pval) continue;
5768                         }
5769
5770                         /* Determine the "value" of the pack item */
5771                         j_value = object_value(j_ptr);
5772
5773                         /* Objects sort by decreasing value */
5774                         if (o_value > j_value) break;
5775                         if (o_value < j_value) continue;
5776                 }
5777
5778                 /* Use that slot */
5779                 i = j;
5780
5781                 /* Slide objects */
5782                 for (k = n; k >= i; k--)
5783                 {
5784                         /* Hack -- Slide the item */
5785                         object_copy(&inventory[k+1], &inventory[k]);
5786                 }
5787
5788                 /* Wipe the empty slot */
5789                 object_wipe(&inventory[i]);
5790         }
5791
5792
5793         /* Copy the item */
5794         object_copy(&inventory[i], o_ptr);
5795
5796         /* Access new object */
5797         j_ptr = &inventory[i];
5798
5799         /* Forget stack */
5800         j_ptr->next_o_idx = 0;
5801
5802         /* Forget monster */
5803         j_ptr->held_m_idx = 0;
5804
5805         /* Forget location */
5806         j_ptr->iy = j_ptr->ix = 0;
5807
5808         /* No longer marked */
5809         j_ptr->marked = 0;
5810
5811         /* Increase the weight */
5812         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
5813
5814         /* Count the items */
5815         inven_cnt++;
5816
5817         /* Recalculate bonuses */
5818         p_ptr->update |= (PU_BONUS);
5819
5820         /* Combine and Reorder pack */
5821         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
5822
5823         /* Window stuff */
5824         p_ptr->window |= (PW_INVEN);
5825
5826         /* Return the slot */
5827         return (i);
5828 }
5829
5830
5831 /*
5832  * Take off (some of) a non-cursed equipment item
5833  *
5834  * Note that only one item at a time can be wielded per slot.
5835  *
5836  * Note that taking off an item when "full" may cause that item
5837  * to fall to the ground.
5838  *
5839  * Return the inventory slot into which the item is placed.
5840  */
5841 s16b inven_takeoff(int item, int amt)
5842 {
5843         int slot;
5844
5845         object_type forge;
5846         object_type *q_ptr;
5847
5848         object_type *o_ptr;
5849
5850         cptr act;
5851
5852         char o_name[MAX_NLEN];
5853
5854
5855         /* Get the item to take off */
5856         o_ptr = &inventory[item];
5857
5858         /* Paranoia */
5859         if (amt <= 0) return (-1);
5860
5861         /* Verify */
5862         if (amt > o_ptr->number) amt = o_ptr->number;
5863
5864         /* Get local object */
5865         q_ptr = &forge;
5866
5867         /* Obtain a local object */
5868         object_copy(q_ptr, o_ptr);
5869
5870         /* Modify quantity */
5871         q_ptr->number = amt;
5872
5873         /* Describe the object */
5874         object_desc(o_name, q_ptr, TRUE, 3);
5875
5876         /* Took off weapon */
5877         if (item == INVEN_RARM)
5878         {
5879 #ifdef JP
5880                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
5881 #else
5882                 act = "You were wielding";
5883 #endif
5884
5885         }
5886
5887         /* Took off bow */
5888         else if (item == INVEN_BOW)
5889         {
5890 #ifdef JP
5891                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
5892 #else
5893                 act = "You were holding";
5894 #endif
5895
5896         }
5897
5898         /* Took off light */
5899         else if (item == INVEN_LITE)
5900         {
5901 #ifdef JP
5902                 act = "¤ò¸÷¸»¤«¤é¤Ï¤º¤·¤¿";
5903 #else
5904                 act = "You were holding";
5905 #endif
5906
5907         }
5908
5909         /* Took off something */
5910         else
5911         {
5912 #ifdef JP
5913                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
5914 #else
5915                 act = "You were wearing";
5916 #endif
5917
5918         }
5919
5920         /* Modify, Optimize */
5921         inven_item_increase(item, -amt);
5922         inven_item_optimize(item);
5923
5924         /* Carry the object */
5925         slot = inven_carry(q_ptr);
5926
5927         /* Message */
5928 #ifdef JP
5929         msg_format("%s(%c)%s¡£", o_name, index_to_label(slot), act);
5930 #else
5931         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
5932 #endif
5933
5934
5935         /* Return slot */
5936         return (slot);
5937 }
5938
5939
5940 /*
5941  * Drop (some of) a non-cursed inventory/equipment item
5942  *
5943  * The object will be dropped "near" the current location
5944  */
5945 void inven_drop(int item, int amt)
5946 {
5947         object_type forge;
5948         object_type *q_ptr;
5949
5950         object_type *o_ptr;
5951
5952         char o_name[MAX_NLEN];
5953
5954
5955         /* Access original object */
5956         o_ptr = &inventory[item];
5957
5958         /* Error check */
5959         if (amt <= 0) return;
5960
5961         /* Not too many */
5962         if (amt > o_ptr->number) amt = o_ptr->number;
5963
5964
5965         /* Take off equipment */
5966         if (item >= INVEN_RARM)
5967         {
5968                 /* Take off first */
5969                 item = inven_takeoff(item, amt);
5970
5971                 /* Access original object */
5972                 o_ptr = &inventory[item];
5973         }
5974
5975
5976         /* Get local object */
5977         q_ptr = &forge;
5978
5979         /* Obtain local object */
5980         object_copy(q_ptr, o_ptr);
5981
5982         /* Distribute charges of wands or rods */
5983         distribute_charges(o_ptr, q_ptr, amt);
5984
5985         /* Modify quantity */
5986         q_ptr->number = amt;
5987
5988         /* Describe local object */
5989         object_desc(o_name, q_ptr, TRUE, 3);
5990
5991         /* Message */
5992 #ifdef JP
5993         msg_format("%s(%c)¤òÍî¤È¤·¤¿¡£", o_name, index_to_label(item));
5994 #else
5995         msg_format("You drop %s (%c).", o_name, index_to_label(item));
5996 #endif
5997
5998
5999         /* Drop it near the player */
6000         (void)drop_near(q_ptr, 0, py, px);
6001
6002         /* Modify, Describe, Optimize */
6003         inven_item_increase(item, -amt);
6004         inven_item_describe(item);
6005         inven_item_optimize(item);
6006 }
6007
6008
6009 /*
6010  * Combine items in the pack
6011  *
6012  * Note special handling of the "overflow" slot
6013  */
6014 void combine_pack(void)
6015 {
6016         int             i, j, k;
6017         object_type     *o_ptr;
6018         object_type     *j_ptr;
6019         bool            flag = FALSE;
6020
6021
6022         /* Combine the pack (backwards) */
6023         for (i = INVEN_PACK; i > 0; i--)
6024         {
6025                 /* Get the item */
6026                 o_ptr = &inventory[i];
6027
6028                 /* Skip empty items */
6029                 if (!o_ptr->k_idx) continue;
6030
6031                 /* Scan the items above that item */
6032                 for (j = 0; j < i; j++)
6033                 {
6034                         int max_num;
6035
6036                         /* Get the item */
6037                         j_ptr = &inventory[j];
6038
6039                         /* Skip empty items */
6040                         if (!j_ptr->k_idx) continue;
6041
6042                         /*
6043                          * Get maximum number of the stack if these
6044                          * are similar, get zero otherwise.
6045                          */
6046                         max_num = object_similar_part(j_ptr, o_ptr);
6047
6048                         /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
6049                         if (max_num && j_ptr->number < max_num)
6050                         {
6051                                 if (o_ptr->number + j_ptr->number <= max_num)
6052                                 {
6053                                         /* Take note */
6054                                         flag = TRUE;
6055
6056                                         /* Add together the item counts */
6057                                         object_absorb(j_ptr, o_ptr);
6058
6059                                         /* One object is gone */
6060                                         inven_cnt--;
6061
6062                                         /* Slide everything down */
6063                                         for (k = i; k < INVEN_PACK; k++)
6064                                         {
6065                                                 /* Structure copy */
6066                                                 inventory[k] = inventory[k+1];
6067                                         }
6068
6069                                         /* Erase the "final" slot */
6070                                         object_wipe(&inventory[k]);
6071                                 }
6072                                 else
6073                                 {
6074                                         int old_num = o_ptr->number;
6075                                         int remain = j_ptr->number + o_ptr->number - max_num;
6076 #if 0
6077                                         o_ptr->number -= remain;
6078 #endif
6079                                         /* Add together the item counts */
6080                                         object_absorb(j_ptr, o_ptr);
6081
6082                                         o_ptr->number = remain;
6083
6084                                         /* Hack -- if rods are stacking, add the pvals (maximum timeouts) and current timeouts together. -LM- */
6085                                         if (o_ptr->tval == TV_ROD)
6086                                         {
6087                                                 o_ptr->pval =  o_ptr->pval * remain / old_num;
6088                                                 o_ptr->timeout = o_ptr->timeout * remain / old_num;
6089                                         }
6090
6091                                         /* Hack -- if wands are stacking, combine the charges. -LM- */
6092                                         if (o_ptr->tval == TV_WAND)
6093                                         {
6094                                                 o_ptr->pval = o_ptr->pval * remain / old_num;
6095                                         }
6096                                 }
6097
6098                                 /* Window stuff */
6099                                 p_ptr->window |= (PW_INVEN);
6100
6101                                 /* Done */
6102                                 break;
6103                         }
6104                 }
6105         }
6106
6107         /* Message */
6108 #ifdef JP
6109         if (flag) msg_print("¥¶¥Ã¥¯¤ÎÃæ¤Î¥¢¥¤¥Æ¥à¤ò¤Þ¤È¤áÄ¾¤·¤¿¡£");
6110 #else
6111         if (flag) msg_print("You combine some items in your pack.");
6112 #endif
6113 }
6114
6115
6116 /*
6117  * Reorder items in the pack
6118  *
6119  * Note special handling of the "overflow" slot
6120  */
6121 void reorder_pack(void)
6122 {
6123         int             i, j, k;
6124         s32b            o_value;
6125         s32b            j_value;
6126         object_type     forge;
6127         object_type     *q_ptr;
6128         object_type     *j_ptr;
6129         object_type     *o_ptr;
6130         bool            flag = FALSE;
6131
6132
6133         /* Re-order the pack (forwards) */
6134         for (i = 0; i < INVEN_PACK; i++)
6135         {
6136                 /* Mega-Hack -- allow "proper" over-flow */
6137                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6138
6139                 /* Get the item */
6140                 o_ptr = &inventory[i];
6141
6142                 /* Skip empty slots */
6143                 if (!o_ptr->k_idx) continue;
6144
6145                 /* Get the "value" of the item */
6146                 o_value = object_value(o_ptr);
6147
6148                 /* Scan every occupied slot */
6149                 for (j = 0; j < INVEN_PACK; j++)
6150                 {
6151                         /* Get the item already there */
6152                         j_ptr = &inventory[j];
6153
6154                         /* Use empty slots */
6155                         if (!j_ptr->k_idx) break;
6156
6157                         /* Hack -- readable books always come first */
6158                         if ((o_ptr->tval == REALM1_BOOK) &&
6159                             (j_ptr->tval != REALM1_BOOK)) break;
6160                         if ((j_ptr->tval == REALM1_BOOK) &&
6161                             (o_ptr->tval != REALM1_BOOK)) continue;
6162
6163                         if ((o_ptr->tval == REALM2_BOOK) &&
6164                             (j_ptr->tval != REALM2_BOOK)) break;
6165                         if ((j_ptr->tval == REALM2_BOOK) &&
6166                             (o_ptr->tval != REALM2_BOOK)) continue;
6167
6168                         /* Objects sort by decreasing type */
6169                         if (o_ptr->tval > j_ptr->tval) break;
6170                         if (o_ptr->tval < j_ptr->tval) continue;
6171
6172                         /* Non-aware (flavored) items always come last */
6173                         if (!object_aware_p(o_ptr)) continue;
6174                         if (!object_aware_p(j_ptr)) break;
6175
6176                         /* Objects sort by increasing sval */
6177                         if (o_ptr->sval < j_ptr->sval) break;
6178                         if (o_ptr->sval > j_ptr->sval) continue;
6179
6180                         /* Unidentified objects always come last */
6181                         if (!object_known_p(o_ptr)) continue;
6182                         if (!object_known_p(j_ptr)) break;
6183
6184                         /* Hack:  otherwise identical rods sort by
6185                         increasing recharge time --dsb */
6186                         if (o_ptr->tval == TV_ROD)
6187                         {
6188                                 if (o_ptr->pval < j_ptr->pval) break;
6189                                 if (o_ptr->pval > j_ptr->pval) continue;
6190                         }
6191
6192                         /* Determine the "value" of the pack item */
6193                         j_value = object_value(j_ptr);
6194
6195
6196
6197                         /* Objects sort by decreasing value */
6198                         if (o_value > j_value) break;
6199                         if (o_value < j_value) continue;
6200                 }
6201
6202                 /* Never move down */
6203                 if (j >= i) continue;
6204
6205                 /* Take note */
6206                 flag = TRUE;
6207
6208                 /* Get local object */
6209                 q_ptr = &forge;
6210
6211                 /* Save a copy of the moving item */
6212                 object_copy(q_ptr, &inventory[i]);
6213
6214                 /* Slide the objects */
6215                 for (k = i; k > j; k--)
6216                 {
6217                         /* Slide the item */
6218                         object_copy(&inventory[k], &inventory[k-1]);
6219                 }
6220
6221                 /* Insert the moving item */
6222                 object_copy(&inventory[j], q_ptr);
6223
6224                 /* Window stuff */
6225                 p_ptr->window |= (PW_INVEN);
6226         }
6227
6228         /* Message */
6229 #ifdef JP
6230         if (flag) msg_print("¥¶¥Ã¥¯¤ÎÃæ¤Î¥¢¥¤¥Æ¥à¤òÊÂ¤ÙÄ¾¤·¤¿¡£");
6231 #else
6232         if (flag) msg_print("You reorder some items in your pack.");
6233 #endif
6234
6235 }
6236
6237
6238 /*
6239  * Hack -- display an object kind in the current window
6240  *
6241  * Include list of usable spells for readible books
6242  */
6243 void display_koff(int k_idx)
6244 {
6245         int y;
6246
6247         object_type forge;
6248         object_type *q_ptr;
6249
6250         char o_name[MAX_NLEN];
6251
6252
6253         /* Erase the window */
6254         for (y = 0; y < Term->hgt; y++)
6255         {
6256                 /* Erase the line */
6257                 Term_erase(0, y, 255);
6258         }
6259
6260         /* No info */
6261         if (!k_idx) return;
6262
6263         /* Get local object */
6264         q_ptr = &forge;
6265
6266         /* Prepare the object */
6267         object_prep(q_ptr, k_idx);
6268
6269         /* Describe */
6270         object_desc_store(o_name, q_ptr, FALSE, 0);
6271
6272         /* Mention the object name */
6273         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6274
6275         /* Warriors are illiterate */
6276         if (!(p_ptr->realm1 || p_ptr->realm2)) return;
6277
6278         /* Display spells in readible books */
6279         if ((q_ptr->tval == REALM1_BOOK) ||
6280             (q_ptr->tval == REALM2_BOOK))
6281         {
6282                 int     sval;
6283                 int     spell = -1;
6284                 int     num = 0;
6285                 byte    spells[64];
6286
6287
6288                 /* Access the item's sval */
6289                 sval = q_ptr->sval;
6290
6291                 /* Extract spells */
6292                 for (spell = 0; spell < 32; spell++)
6293                 {
6294                         /* Check for this spell */
6295                         if (fake_spell_flags[sval] & (1L << spell))
6296                         {
6297                                 /* Collect this spell */
6298                                 spells[num++] = spell;
6299                         }
6300                 }
6301
6302                 /* Print spells */
6303                 print_spells(0, spells, num, 2, 0,
6304                     (q_ptr->tval == REALM1_BOOK ? p_ptr->realm1 : p_ptr->realm2));
6305         }
6306 }
6307
6308 /* Choose one of items that have warning flag */
6309 object_type *choose_warning_item(void)
6310 {
6311         int i;
6312         int choices[INVEN_TOTAL-INVEN_RARM];
6313         int number = 0;
6314
6315         /* Paranoia -- Player has no warning-item */
6316         if (!p_ptr->warning) return (NULL);
6317
6318         /* Search Inventry */
6319         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6320         {
6321                 u32b flgs[TR_FLAG_SIZE];
6322                 object_type *o_ptr = &inventory[i];
6323
6324                 object_flags(o_ptr, flgs);
6325                 if (have_flag(flgs, TR_WARNING))
6326                 {
6327                         choices[number] = i;
6328                         number++;
6329                 }
6330         }
6331
6332         /* Choice one of them */
6333         return (&inventory[choices[randint0(number)]]);
6334 }
6335
6336 /* Examine the grid (xx,yy) and warn the player if there are any danger */
6337 bool process_frakir(int xx, int yy)
6338 {
6339         int mx,my;
6340         cave_type *c_ptr;
6341         char o_name[MAX_NLEN];
6342
6343 #define FRAKIR_AWARE_RANGE 12
6344         int dam_max = 0;
6345         static int old_damage = 0;
6346
6347         for (mx = xx-FRAKIR_AWARE_RANGE; mx < xx+FRAKIR_AWARE_RANGE+1; mx++)
6348         {
6349                 for (my = yy-FRAKIR_AWARE_RANGE; my < yy+FRAKIR_AWARE_RANGE+1; my++)
6350                 {
6351                         int dam_max0=0;
6352                         monster_type *m_ptr;
6353                         monster_race *r_ptr;
6354                         u32b f4, f5, f6;
6355                         int rlev;
6356
6357                         if (!in_bounds(my,mx) || (distance(my,mx,yy,xx)>FRAKIR_AWARE_RANGE)) continue;
6358
6359                         c_ptr = &cave[my][mx];
6360
6361                         if (!c_ptr->m_idx) continue;
6362
6363                         m_ptr = &m_list[c_ptr->m_idx];
6364                         r_ptr = &r_info[m_ptr->r_idx];
6365
6366                         f4 = r_ptr->flags4;
6367                         f5 = r_ptr->flags5;
6368                         f6 = r_ptr->flags6;
6369
6370                         rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
6371
6372                         if (m_ptr->csleep) continue;
6373                         if (is_pet(m_ptr)) continue;
6374
6375                         /* Monster spells (only powerful ones)*/
6376                         if(projectable(my,mx,yy,xx))
6377                         {
6378
6379 #define DAMCALC(f,val,max,im,vln,res,resx,resy,op,opx,opy,dmax) \
6380            if (f){ int dam = (val)>(max)? (max):(val); \
6381            if (im) dam=0; \
6382            if (vln) dam *= 2; \
6383            if (res) {dam = (dam * resx) / resy;} \
6384            if (op) {dam = (dam * opx) / opy;} \
6385            if (dam>dmax) dmax = dam; \
6386            }
6387
6388                                 DAMCALC(f4 & (RF4_BR_FIRE), m_ptr->hp / 3, 1600,
6389                                         p_ptr->immune_fire, p_ptr->muta3 & MUT3_VULN_ELEM,
6390                                         p_ptr->resist_fire, 1, 3,
6391                                         p_ptr->oppose_fire, 1, 3, dam_max0);
6392
6393                                 DAMCALC(f4 & (RF4_BR_COLD), m_ptr->hp / 3, 1600,
6394                                         p_ptr->immune_cold, p_ptr->muta3 & MUT3_VULN_ELEM,
6395                                         p_ptr->resist_cold, 1, 3,
6396                                         p_ptr->oppose_cold, 1, 3, dam_max0);
6397
6398                                 DAMCALC(f4 & (RF4_BR_ELEC), m_ptr->hp / 3, 1600,
6399                                         p_ptr->immune_elec, p_ptr->muta3 & MUT3_VULN_ELEM,
6400                                         p_ptr->resist_elec, 1, 3,
6401                                         p_ptr->oppose_elec, 1, 3, dam_max0);
6402
6403                                 DAMCALC(f4 & (RF4_BR_ACID), m_ptr->hp / 3, 1600,
6404                                         p_ptr->immune_acid, p_ptr->muta3 & MUT3_VULN_ELEM,
6405                                         p_ptr->resist_acid, 1, 3,
6406                                         p_ptr->oppose_acid, 1, 3, dam_max0);
6407
6408                                 DAMCALC(f4 & (RF4_BR_POIS), m_ptr->hp / 3, 800,
6409                                         FALSE , FALSE,
6410                                         p_ptr->resist_pois, 1, 3,
6411                                         p_ptr->oppose_pois, 1, 3, dam_max0);
6412
6413
6414                                 DAMCALC(f4 & (RF4_BR_NETH), m_ptr->hp / 6, 550, FALSE , FALSE,
6415                                         p_ptr->resist_neth, 6, 9, FALSE, 1, 1, dam_max0);
6416
6417                                 DAMCALC(f4 & (RF4_BR_LITE), m_ptr->hp / 6, 400, FALSE , FALSE,
6418                                         p_ptr->resist_lite, 4, 9, FALSE, 1, 1, dam_max0);
6419
6420                                 DAMCALC(f4 & (RF4_BR_DARK), m_ptr->hp / 6, 400, FALSE , FALSE,
6421                                         p_ptr->resist_dark, 4, 9, FALSE, 1, 1, dam_max0);
6422
6423                                 DAMCALC(f4 & (RF4_BR_CONF), m_ptr->hp / 6, 450, FALSE , FALSE,
6424                                         p_ptr->resist_conf, 5, 9, FALSE, 1, 1, dam_max0);
6425
6426                                 DAMCALC(f4 & (RF4_BR_SOUN), m_ptr->hp / 6, 450, FALSE , FALSE,
6427                                         p_ptr->resist_sound, 5, 9, FALSE, 1, 1, dam_max0);
6428
6429                                 DAMCALC(f4 & (RF4_BR_CHAO), m_ptr->hp / 6, 600, FALSE , FALSE,
6430                                         p_ptr->resist_chaos, 6, 9, FALSE, 1, 1, dam_max0);
6431
6432                                 DAMCALC(f4 & (RF4_BR_DISE), m_ptr->hp / 6, 500, FALSE , FALSE,
6433                                         p_ptr->resist_disen, 6, 9, FALSE, 1, 1, dam_max0);
6434
6435                                 DAMCALC(f4 & (RF4_BR_NEXU), m_ptr->hp / 3, 250, FALSE , FALSE,
6436                                         p_ptr->resist_nexus, 6, 9, FALSE, 1, 1, dam_max0);
6437
6438                                 DAMCALC(f4 & (RF4_BR_TIME), m_ptr->hp / 3, 150, FALSE , FALSE,
6439                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6440
6441                                 DAMCALC(f4 & (RF4_BR_INER), m_ptr->hp / 6, 200, FALSE , FALSE,
6442                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6443
6444                                 DAMCALC(f4 & (RF4_BR_GRAV), m_ptr->hp / 3, 200, FALSE , FALSE,
6445                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6446
6447                                 DAMCALC(f4 & (RF4_BR_SHAR), m_ptr->hp / 6, 500, FALSE , FALSE,
6448                                         p_ptr->resist_shard, 6, 9, FALSE, 1, 1, dam_max0);
6449
6450                                 DAMCALC(f4 & (RF4_BR_PLAS), m_ptr->hp / 6, 150, FALSE , FALSE,
6451                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6452
6453                                 DAMCALC(f4 & (RF4_BR_WALL), m_ptr->hp / 6, 200, FALSE , FALSE,
6454                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6455
6456                                 DAMCALC(f4 & (RF4_BR_MANA), m_ptr->hp / 3, 250, FALSE , FALSE,
6457                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6458
6459                                 DAMCALC(f4 & (RF4_BR_NUKE), m_ptr->hp / 3, 800, FALSE , FALSE,
6460                                         p_ptr->resist_pois, 2, 5,
6461                                         p_ptr->oppose_pois, 2, 5, dam_max0);
6462
6463                                 DAMCALC(f4 & (RF4_BR_DISI), m_ptr->hp / 3, 300, FALSE , FALSE,
6464                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6465
6466
6467                                 DAMCALC(f4 & (RF4_ROCKET), m_ptr->hp / 4, 800, FALSE , FALSE,
6468                                         p_ptr->resist_shard, 1, 2, FALSE, 1, 1, dam_max0);
6469
6470                                 DAMCALC(f5 & (RF5_BA_MANA), rlev*4 + 150, 9999, FALSE , FALSE,
6471                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6472
6473                                 DAMCALC(f5 & (RF5_BA_DARK), rlev*4 + 150, 9999, FALSE , FALSE,
6474                                         p_ptr->resist_dark, 4, 9, FALSE, 1, 1, dam_max0);
6475
6476                                 DAMCALC(f5 & (RF5_BA_LITE), rlev*4 + 150, 9999, FALSE , FALSE,
6477                                         p_ptr->resist_lite, 4, 9, FALSE, 1, 1, dam_max0);
6478
6479
6480                                 DAMCALC(f6 & (RF6_HAND_DOOM), p_ptr->chp*6/10, 9999, FALSE , FALSE,
6481                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6482
6483                         }
6484
6485                         /* Monster melee attacks */
6486                         if(mx <= xx+1 && mx >= xx-1 && my <=yy+1 && my >= yy-1)
6487                         {
6488                                 int m;
6489                                 int dam_melee=0;
6490                                 for (m = 0; m < 4; m++)
6491                                 {
6492                                         int d1, d2;
6493
6494                                         /* Skip non-attacks */
6495                                         if (!r_ptr->blow[m].method) continue;
6496
6497                                         /* Extract the attack info */
6498                                         d1 = r_ptr->blow[m].d_dice;
6499                                         d2 = r_ptr->blow[m].d_side;
6500
6501                                         dam_melee += d1*d2;
6502                                 }
6503                                 if(dam_melee>dam_max0)dam_max0=dam_melee;
6504                         }
6505
6506                         /* Contribution from this monster */
6507                         dam_max+=dam_max0;
6508                 }
6509         }
6510
6511         /* Prevent excessive warning */
6512         if(dam_max > old_damage)
6513         {
6514                 old_damage=dam_max * 3 / 2;
6515
6516                 if (dam_max>(p_ptr->chp)/2)
6517                 {
6518                         object_type *o_ptr = choose_warning_item();
6519
6520                         object_desc(o_name, o_ptr, FALSE, 0);
6521 #ifdef JP
6522                         msg_format("%s¤¬±Ô¤¯¿Ì¤¨¤¿¡ª", o_name);
6523 #else
6524                         msg_format("Your %s pulsates sharply!", o_name);
6525 #endif
6526                         disturb(0,0);
6527 #ifdef JP
6528                         return (get_check("ËÜÅö¤Ë¤³¤Î¤Þ¤Þ¿Ê¤à¤«¡©"));
6529 #else
6530                         return (get_check("Realy want to go ahead? "));
6531 #endif
6532                 }
6533         }
6534         else old_damage = old_damage/2;
6535
6536         c_ptr = &cave[yy][xx];
6537         if (((!easy_disarm && (is_trap(c_ptr->feat) || c_ptr->feat == FEAT_INVIS))
6538             || (c_ptr->mimic && is_trap(c_ptr->feat))) && !one_in_(13))
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!", 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         return(TRUE);
6556 }
6557
6558
6559 static bool item_tester_hook_melee_ammo(object_type *o_ptr)
6560 {
6561         switch (o_ptr->tval)
6562         {
6563                 case TV_HAFTED:
6564                 case TV_POLEARM:
6565                 case TV_DIGGING:
6566                 case TV_BOLT:
6567                 case TV_ARROW:
6568                 case TV_SHOT:
6569                 {
6570                         return (TRUE);
6571                 }
6572                 case TV_SWORD:
6573                 {
6574                         if (o_ptr->sval != SV_DOKUBARI) return (TRUE);
6575                 }
6576         }
6577
6578         return (FALSE);
6579 }
6580
6581
6582 /*
6583  *  A structure for smithing
6584  */
6585 typedef struct {
6586         int add;       /* TR flag number or special essence id */
6587         cptr add_name; /* Name of this ability */
6588         int type;      /* Menu number */
6589         int essence;   /* Index for carrying essences */
6590         int value;     /* Needed value to add this ability */
6591 } essence_type;
6592
6593
6594 /*
6595  *  Smithing type data for Weapon smith
6596  */
6597 #ifdef JP
6598 static essence_type essence_info[] =
6599 {
6600         {TR_STR, "ÏÓÎÏ", 4, TR_STR, 20},
6601         {TR_INT, "ÃÎÇ½", 4, TR_INT, 20},
6602         {TR_WIS, "¸¤µ", 4, TR_WIS, 20},
6603         {TR_DEX, "´ïÍÑ¤µ", 4, TR_DEX, 20},
6604         {TR_CON, "ÂÑµ×ÎÏ", 4, TR_CON, 20},
6605         {TR_CHR, "Ì¥ÎÏ", 4, TR_CHR, 20},
6606         {TR_MAGIC_MASTERY, "ËâÎÏ»ÙÇÛ", 4, TR_MAGIC_MASTERY, 20},
6607         {TR_STEALTH, "±£Ì©", 4, TR_STEALTH, 40},
6608         {TR_SEARCH, "Ãµº÷", 4, TR_SEARCH, 15},
6609         {TR_INFRA, "ÀÖ³°Àþ»ëÎÏ", 4, TR_INFRA, 15},
6610         {TR_TUNNEL, "ºÎ·¡", 4, TR_TUNNEL, 15},
6611         {TR_SPEED, "¥¹¥Ô¡¼¥É", 4, TR_SPEED, 12},
6612         {TR_BLOWS, "ÄÉ²Ã¹¶·â", 1, TR_BLOWS, 20},
6613         {TR_CHAOTIC, "¥«¥ª¥¹¹¶·â", 1, TR_CHAOTIC, 15},
6614         {TR_VAMPIRIC, "µÛ·ì¹¶·â", 1, TR_VAMPIRIC, 60},
6615         {TR_IMPACT, "ÃÏ¿ÌÈ¯Æ°", 7, TR_IMPACT, 15},
6616         {TR_BRAND_POIS, "ÆÇ»¦", 1, TR_BRAND_POIS, 20},
6617         {TR_BRAND_ACID, "ÍÏ²ò", 1, TR_BRAND_ACID, 20},
6618         {TR_BRAND_ELEC, "ÅÅ·â", 1, TR_BRAND_ELEC, 20},
6619         {TR_BRAND_FIRE, "¾Æ´þ", 1, TR_BRAND_FIRE, 20},
6620         {TR_BRAND_COLD, "Åà·ë", 1, TR_BRAND_COLD, 20},
6621         {TR_SUST_STR, "ÏÓÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
6622         {TR_SUST_INT, "ÃÎÇ½°Ý»ý", 3, TR_SUST_STR, 15},
6623         {TR_SUST_WIS, "¸¤µ°Ý»ý", 3, TR_SUST_STR, 15},
6624         {TR_SUST_DEX, "´ïÍÑ¤µ°Ý»ý", 3, TR_SUST_STR, 15},
6625         {TR_SUST_CON, "ÂÑµ×ÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
6626         {TR_SUST_CHR, "Ì¥ÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
6627         {TR_IM_ACID, "»ÀÌÈ±Ö", 2, TR_IM_ACID, 20},
6628         {TR_IM_ELEC, "ÅÅ·âÌÈ±Ö", 2, TR_IM_ACID, 20},
6629         {TR_IM_FIRE, "²Ð±êÌÈ±Ö", 2, TR_IM_ACID, 20},
6630         {TR_IM_COLD, "Îäµ¤ÌÈ±Ö", 2, TR_IM_ACID, 20},
6631         {TR_REFLECT, "È¿¼Í", 2, TR_REFLECT, 20},
6632         {TR_FREE_ACT, "ËãáãÃÎ¤é¤º", 3, TR_FREE_ACT, 20},
6633         {TR_HOLD_LIFE, "À¸Ì¿ÎÏ°Ý»ý", 3, TR_HOLD_LIFE, 20},
6634         {TR_RES_ACID, "ÂÑ»À", 2, TR_RES_ACID, 15},
6635         {TR_RES_ELEC, "ÂÑÅÅ·â", 2, TR_RES_ELEC, 15},
6636         {TR_RES_FIRE, "ÂÑ²Ð±ê", 2, TR_RES_FIRE, 15},
6637         {TR_RES_COLD, "ÂÑÎäµ¤", 2, TR_RES_COLD, 15},
6638         {TR_RES_POIS, "ÂÑÆÇ", 2, TR_RES_POIS, 25},
6639         {TR_RES_FEAR, "ÂÑ¶²ÉÝ", 2, TR_RES_FEAR, 20},
6640         {TR_RES_LITE, "ÂÑÁ®¸÷", 2, TR_RES_LITE, 20},
6641         {TR_RES_DARK, "ÂÑ°Å¹õ", 2, TR_RES_DARK, 20},
6642         {TR_RES_BLIND, "ÂÑÌÕÌÜ", 2, TR_RES_BLIND, 20},
6643         {TR_RES_CONF, "ÂÑº®Íð", 2, TR_RES_CONF, 20},
6644         {TR_RES_SOUND, "ÂÑ¹ì²»", 2, TR_RES_SOUND, 20},
6645         {TR_RES_SHARDS, "ÂÑÇËÊÒ", 2, TR_RES_SHARDS, 20},
6646         {TR_RES_NETHER, "ÂÑÃÏ¹ö", 2, TR_RES_NETHER, 20},
6647         {TR_RES_NEXUS, "ÂÑ°ø²Ìº®Íð", 2, TR_RES_NEXUS, 20},
6648         {TR_RES_CHAOS, "ÂÑ¥«¥ª¥¹", 2, TR_RES_CHAOS, 20},
6649         {TR_RES_DISEN, "ÂÑÎô²½", 2, TR_RES_DISEN, 20},
6650         {TR_SH_FIRE, "", 0, -2, 0},
6651         {TR_SH_ELEC, "", 0, -2, 0},
6652         {TR_SH_COLD, "", 0, -2, 0},
6653         {TR_NO_MAGIC, "È¿ËâË¡", 3, TR_NO_MAGIC, 15},
6654         {TR_WARNING, "·Ù¹ð", 3, TR_WARNING, 20},
6655         {TR_FEATHER, "ÉâÍ·", 3, TR_FEATHER, 20},
6656         {TR_LITE, "±Êµ×¸÷¸»", 3, TR_LITE, 15},
6657         {TR_SEE_INVIS, "²Ä»ëÆ©ÌÀ", 3, TR_SEE_INVIS, 20},
6658         {TR_TELEPATHY, "¥Æ¥ì¥Ñ¥·¡¼", 6, TR_TELEPATHY, 15},
6659         {TR_SLOW_DIGEST, "ÃÙ¾Ã²½", 3, TR_SLOW_DIGEST, 15},
6660         {TR_REGEN, "µÞÂ®²óÉü", 3, TR_REGEN, 20},
6661         {TR_TELEPORT, "¥Æ¥ì¥Ý¡¼¥È", 3, TR_TELEPORT, 25},
6662
6663         {TR_SLAY_EVIL, "¼Ù°ÇÜÂÇ", 5, TR_SLAY_EVIL, 100},
6664         {TR_KILL_EVIL, "¼Ù°ÇÜÇÜÂÇ", 0, TR_SLAY_EVIL, 60},
6665         {TR_SLAY_ANIMAL, "Æ°ÊªÇÜÂÇ", 5, TR_SLAY_ANIMAL, 20},
6666         {TR_KILL_ANIMAL, "Æ°ÊªÇÜÇÜÂÇ", 5, TR_SLAY_ANIMAL, 60},
6667         {TR_SLAY_UNDEAD, "ÉÔ»àÇÜÂÇ", 5, TR_SLAY_UNDEAD, 20},
6668         {TR_KILL_UNDEAD, "ÉÔ»àÇÜÇÜÂÇ", 5, TR_SLAY_UNDEAD, 60},
6669         {TR_SLAY_DEMON, "°ËâÇÜÂÇ", 5, TR_SLAY_DEMON, 20},
6670         {TR_KILL_DEMON, "°ËâÇÜÇÜÂÇ", 5, TR_SLAY_DEMON, 60},
6671         {TR_SLAY_ORC, "¥ª¡¼¥¯ÇÜÂÇ", 5, TR_SLAY_ORC, 15},
6672         {TR_KILL_ORC, "¥ª¡¼¥¯ÇÜÇÜÂÇ", 5, TR_SLAY_ORC, 60},
6673         {TR_SLAY_TROLL, "¥È¥í¥ëÇÜÂÇ", 5, TR_SLAY_TROLL, 15},
6674         {TR_KILL_TROLL, "¥È¥í¥ëÇÜÇÜÂÇ", 5, TR_SLAY_TROLL, 60},
6675         {TR_SLAY_GIANT, "µð¿ÍÇÜÂÇ", 5, TR_SLAY_GIANT, 20},
6676         {TR_KILL_GIANT, "µð¿ÍÇÜÇÜÂÇ", 5, TR_SLAY_GIANT, 60},
6677         {TR_SLAY_DRAGON, "ÎµÇÜÂÇ", 5, TR_SLAY_DRAGON, 20},
6678         {TR_KILL_DRAGON, "ÎµÇÜÇÜÂÇ", 5, TR_SLAY_DRAGON, 60},
6679         {TR_SLAY_HUMAN, "¿Í´ÖÇÜÂÇ", 5, TR_SLAY_HUMAN, 20},
6680         {TR_KILL_HUMAN, "¿Í´ÖÇÜÇÜÂÇ", 5, TR_SLAY_HUMAN, 60},
6681
6682         {TR_ESP_ANIMAL, "ưʪESP", 6, TR_SLAY_ANIMAL, 40},
6683         {TR_ESP_UNDEAD, "ÉÔ»àESP", 6, TR_SLAY_UNDEAD, 40},
6684         {TR_ESP_DEMON, "°ËâESP", 6, TR_SLAY_DEMON, 40},
6685         {TR_ESP_ORC, "¥ª¡¼¥¯ESP", 6, TR_SLAY_ORC, 40},
6686         {TR_ESP_TROLL, "¥È¥í¥ëESP", 6, TR_SLAY_TROLL, 40},
6687         {TR_ESP_GIANT, "µð¿ÍESP", 6, TR_SLAY_GIANT, 40},
6688         {TR_ESP_DRAGON, "εESP", 6, TR_SLAY_DRAGON, 40},
6689         {TR_ESP_HUMAN, "¿Í´ÖESP", 6, TR_SLAY_HUMAN, 40},
6690
6691         {ESSENCE_ATTACK, "¹¶·â", 10, TR_ES_ATTACK, 30},
6692         {ESSENCE_AC, "ËÉ¸æ", 10, TR_ES_AC, 15},
6693         {ESSENCE_TMP_RES_ACID, "»ÀÂÑÀÈ¯Æ°", 7, TR_RES_ACID, 50},
6694         {ESSENCE_TMP_RES_ELEC, "ÅÅ·âÂÑÀÈ¯Æ°", 7, TR_RES_ELEC, 50},
6695         {ESSENCE_TMP_RES_FIRE, "²Ð±êÂÑÀÈ¯Æ°", 7, TR_RES_FIRE, 50},
6696         {ESSENCE_TMP_RES_COLD, "Îäµ¤ÂÑÀÈ¯Æ°", 7, TR_RES_COLD, 50},
6697         {ESSENCE_SH_FIRE, "²Ð±ê¥ª¡¼¥é", 7, -1, 50},
6698         {ESSENCE_SH_ELEC, "ÅÅ·â¥ª¡¼¥é", 7, -1, 50},
6699         {ESSENCE_SH_COLD, "Îäµ¤¥ª¡¼¥é", 7, -1, 50},
6700         {ESSENCE_RESISTANCE, "Á´ÂÑÀ", 2, -1, 150},
6701         {ESSENCE_SUSTAIN, "ÁõÈ÷ÊÝ»ý", 10, -1, 10},
6702         {ESSENCE_SLAY_GLOVE, "»¦Ù¤¤Î¾®¼ê", 1, TR_ES_ATTACK, 200},
6703
6704         {-1, NULL, 0, -1, 0}
6705 };
6706 #else
6707 static essence_type essence_info[] =
6708 {
6709         {TR_STR, "strength", 4, TR_STR, 20},
6710         {TR_INT, "intelligence", 4, TR_INT, 20},
6711         {TR_WIS, "wisdom", 4, TR_WIS, 20},
6712         {TR_DEX, "dexterity", 4, TR_DEX, 20},
6713         {TR_CON, "constitution", 4, TR_CON, 20},
6714         {TR_CHR, "charisma", 4, TR_CHR, 20},
6715         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
6716         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
6717         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
6718         {TR_INFRA, "inflavision", 4, TR_INFRA, 15},
6719         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
6720         {TR_SPEED, "speed", 4, TR_SPEED, 12},
6721         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
6722         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
6723         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
6724         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
6725         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
6726         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
6727         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
6728         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
6729         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
6730         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
6731         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
6732         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
6733         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
6734         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
6735         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
6736         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
6737         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
6738         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
6739         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
6740         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
6741         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
6742         {TR_HOLD_LIFE, "hold life", 3, TR_HOLD_LIFE, 20},
6743         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
6744         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
6745         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
6746         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
6747         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
6748         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
6749         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
6750         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
6751         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
6752         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
6753         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
6754         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
6755         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
6756         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
6757         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
6758         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
6759         {TR_SH_FIRE, "", 0, -2, 0},
6760         {TR_SH_ELEC, "", 0, -2, 0},
6761         {TR_SH_COLD, "", 0, -2, 0},
6762         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
6763         {TR_WARNING, "warning", 3, TR_WARNING, 20},
6764         {TR_FEATHER, "levitation", 3, TR_FEATHER, 20},
6765         {TR_LITE, "permanent light", 3, TR_LITE, 15},
6766         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
6767         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
6768         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
6769         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
6770         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
6771
6772         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
6773         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
6774         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
6775         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
6776         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
6777         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
6778         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
6779         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
6780         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
6781         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
6782         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
6783         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
6784         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
6785         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
6786         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
6787         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
6788         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
6789         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
6790
6791         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
6792         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
6793         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
6794         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
6795         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
6796         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
6797         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
6798         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
6799
6800         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
6801         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
6802         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
6803         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
6804         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
6805         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
6806         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
6807         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
6808         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
6809         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
6810         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
6811         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
6812
6813         {-1, NULL, 0, -1, 0}
6814 };
6815 #endif
6816
6817
6818 /*
6819  *  Essense names for Weapon smith
6820  */
6821 #ifdef JP
6822 static cptr essence_name[] =
6823 {
6824         "ÏÓÎÏ",
6825         "ÃÎÇ½",
6826         "¸¤µ",
6827         "´ïÍÑ¤µ",
6828         "ÂÑµ×ÎÏ",
6829         "Ì¥ÎÏ",
6830         "ËâÎÏ»ÙÇÛ",
6831         "",
6832         "±£Ì©",
6833         "Ãµº÷",
6834         "ÀÖ³°Àþ»ëÎÏ",
6835         "ºÎ·¡",
6836         "¥¹¥Ô¡¼¥É",
6837         "ÄÉ²Ã¹¶·â",
6838         "¥«¥ª¥¹¹¶·â",
6839         "µÛ·ì¹¶·â",
6840         "Æ°ÊªÇÜÂÇ",
6841         "¼Ù°ÇÜÂÇ",
6842         "ÉÔ»àÇÜÂÇ",
6843         "°ËâÇÜÂÇ",
6844         "¥ª¡¼¥¯ÇÜÂÇ",
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         NULL
6921 };
6922
6923 #else
6924
6925 static cptr essence_name[] =
6926 {
6927         "strength",
6928         "intelligen.",
6929         "wisdom",
6930         "dexterity",
6931         "constitut.",
6932         "charisma",
6933         "magic mast.",
6934         "",
6935         "stealth",
6936         "serching",
6937         "inflavision",
6938         "digging",
6939         "speed",
6940         "extra atk",
6941         "chaos brand",
6942         "vampiric",
6943         "slay animal",
6944         "slay evil",
6945         "slay undead",
6946         "slay demon",
6947         "slay orc",
6948         "slay troll",
6949         "slay giant",
6950         "slay dragon",
6951         "",
6952         "",
6953         "quake",
6954         "pois. brand",
6955         "acid brand",
6956         "elec. brand",
6957         "fire brand",
6958         "cold brand",
6959         "sustain",
6960         "",
6961         "",
6962         "",
6963         "",
6964         "",
6965         "",
6966         "",
6967         "immunity",
6968         "",
6969         "",
6970         "",
6971         "",
6972         "reflection",
6973         "free action",
6974         "hold life",
6975         "res. acid",
6976         "res. elec.",
6977         "res. fire",
6978         "res. cold",
6979         "res. poison",
6980         "res. fear",
6981         "res. light",
6982         "res. dark",
6983         "res. blind",
6984         "res.confuse",
6985         "res. sound",
6986         "res. shard",
6987         "res. nether",
6988         "res. nexus",
6989         "res. chaos",
6990         "res. disen.",
6991         "",
6992         "",
6993         "slay human",
6994         "",
6995         "",
6996         "anti magic",
6997         "",
6998         "",
6999         "warning",
7000         "",
7001         "",
7002         "",
7003         "levitation",
7004         "perm. light",
7005         "see invis.",
7006         "telepathy",
7007         "slow dige.",
7008         "regen.",
7009         "",
7010         "",
7011         "",
7012         "",
7013         "",
7014         "",
7015         "",
7016         "",
7017         "teleport",
7018         "",
7019         "",
7020         "weapon enc.",
7021         "armor enc.",
7022
7023         NULL
7024 };
7025 #endif
7026
7027
7028 static void display_essence(void)
7029 {
7030         int i, num = 0;
7031
7032         screen_save();
7033         for (i = 1; i < 22; i++)
7034         {
7035                 prt("",i,0);
7036         }
7037 #ifdef JP
7038         prt("¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô     ¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô     ¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô", 1, 8);
7039 #else
7040         prt("Essence      Num      Essence      Num      Essence      Num ", 1, 8);
7041 #endif
7042         for (i = 0; essence_name[i]; i++)
7043         {
7044                 if (!essence_name[i][0]) continue;
7045                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
7046                 num++;
7047         }
7048 #ifdef JP
7049         prt("¸½ºß½ê»ý¤·¤Æ¤¤¤ë¥¨¥Ã¥»¥ó¥¹", 0, 0);
7050 #else
7051         prt("List of all essences you have.", 0, 0);
7052 #endif
7053         (void)inkey();
7054         screen_load();
7055         return;
7056 }
7057
7058 static void drain_essence(void)
7059 {
7060         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
7061         int i, item;
7062         int dec = 4;
7063         bool observe = FALSE;
7064         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2;
7065         u32b old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7066         object_type *o_ptr;
7067         cptr            q, s;
7068         byte iy, ix, marked, number;
7069         s16b next_o_idx, weight;
7070
7071         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7072                 drain_value[i] = 0;
7073
7074         item_tester_hook = item_tester_hook_weapon_armour;
7075         item_tester_no_ryoute = TRUE;
7076
7077         /* Get an item */
7078 #ifdef JP
7079         q = "¤É¤Î¥¢¥¤¥Æ¥à¤«¤éÃê½Ð¤·¤Þ¤¹¤«¡©";
7080         s = "Ãê½Ð¤Ç¤¤ë¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
7081 #else
7082         q = "Extract from which item? ";
7083         s = "You have nothing you can extract from.";
7084 #endif
7085
7086         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7087
7088         /* Get the item (in the pack) */
7089         if (item >= 0)
7090         {
7091                 o_ptr = &inventory[item];
7092         }
7093
7094         /* Get the item (on the floor) */
7095         else
7096         {
7097                 o_ptr = &o_list[0 - item];
7098         }
7099
7100         if (object_known_p(o_ptr) && (o_ptr->name1 || o_ptr->name2 || o_ptr->art_name || o_ptr->xtra3)) {
7101                 char o_name[MAX_NLEN];
7102                 object_desc(o_name, o_ptr, FALSE, 0);
7103 #ifdef JP
7104                 if (!get_check(format("ËÜÅö¤Ë%s¤«¤éÃê½Ð¤·¤Æ¤è¤í¤·¤¤¤Ç¤¹¤«¡©", o_name))) return;
7105 #else
7106                 if (!get_check(format("Really extract from %s? ", o_name))) return;
7107 #endif
7108         }
7109
7110         energy_use = 100;
7111
7112         object_flags(o_ptr, old_flgs);
7113         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7114         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7115         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7116         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7117         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7118         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7119         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7120         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7121         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7122
7123         old_to_a = o_ptr->to_a;
7124         old_ac = o_ptr->ac;
7125         old_to_h = o_ptr->to_h;
7126         old_to_d = o_ptr->to_d;
7127         old_ds = o_ptr->ds;
7128         old_dd = o_ptr->dd;
7129         old_pval = o_ptr->pval;
7130         old_name2 = o_ptr->name2;
7131         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7132         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7133         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7134         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7135         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7136
7137         iy = o_ptr->iy;
7138         ix = o_ptr->ix;
7139         next_o_idx = o_ptr->next_o_idx;
7140         marked = o_ptr->marked;
7141         weight = o_ptr->weight;
7142         number = o_ptr->number;
7143
7144         object_prep(o_ptr, o_ptr->k_idx);
7145
7146         o_ptr->iy=iy;
7147         o_ptr->ix=ix;
7148         o_ptr->next_o_idx=next_o_idx;
7149         o_ptr->marked=marked;
7150         o_ptr->number = number;
7151         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7152         o_ptr->ident |= (IDENT_MENTAL);
7153         object_aware(o_ptr);
7154         object_known(o_ptr);
7155
7156         object_flags(o_ptr, new_flgs);
7157
7158         for (i = 0; essence_info[i].add_name; i++)
7159         {
7160                 essence_type *es_ptr = &essence_info[i];
7161                 int pval = 0;
7162
7163                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7164                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7165
7166                 if (es_ptr->add < TR_FLAG_MAX &&
7167                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7168                     have_flag(old_flgs, es_ptr->add))
7169                 {
7170                         if (pval)
7171                         {
7172                                 drain_value[es_ptr->essence] += 10 * pval;
7173                         }
7174                         else if (es_ptr->essence != -2)
7175                         {
7176                                 drain_value[es_ptr->essence] += 10;
7177                         }
7178                         else if (es_ptr->add == TR_SH_FIRE)
7179                         {
7180                                 drain_value[TR_BRAND_FIRE] += 10;
7181                                 drain_value[TR_RES_FIRE] += 10;
7182                         }
7183                         else if (es_ptr->add == TR_SH_ELEC)
7184                         {
7185                                 drain_value[TR_BRAND_ELEC] += 10;
7186                                 drain_value[TR_RES_ELEC] += 10;
7187                         }
7188                         else if (es_ptr->add == TR_SH_COLD)
7189                         {
7190                                 drain_value[TR_BRAND_COLD] += 10;
7191                                 drain_value[TR_RES_COLD] += 10;
7192                         }
7193                 }
7194         }
7195
7196         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7197         {
7198                 drain_value[TR_INT] += 5;
7199                 drain_value[TR_WIS] += 5;
7200         }
7201         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7202         {
7203                 drain_value[TR_BRAND_POIS] += 5;
7204                 drain_value[TR_BRAND_ACID] += 5;
7205                 drain_value[TR_BRAND_ELEC] += 5;
7206                 drain_value[TR_BRAND_FIRE] += 5;
7207                 drain_value[TR_BRAND_COLD] += 5;
7208         }
7209         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7210         {
7211                 drain_value[TR_INT] += 10;
7212         }
7213         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7214         {
7215                 drain_value[TR_STR] += 10;
7216         }
7217         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7218         {
7219                 drain_value[TR_DEX] += 10;
7220         }
7221         if (old_name2 == EGO_2WEAPON)
7222         {
7223                 drain_value[TR_DEX] += 20;
7224         }
7225         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_SWORD) && (o_ptr->tval != TV_BOW))
7226         {
7227                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7228
7229                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7230         }
7231         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7232         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7233         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7234         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7235
7236         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7237         {
7238                 drain_value[i] *= number;
7239                 drain_value[i] = drain_value[i] * dec / 4;
7240                 drain_value[i] = MAX(drain_value[i], 0);
7241                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7242                 if (drain_value[i])
7243                 {
7244                         observe = TRUE;
7245                 }
7246         }
7247         if (!observe)
7248         {
7249 #ifdef JP
7250                 msg_print("¥¨¥Ã¥»¥ó¥¹¤ÏÃê½Ð¤Ç¤¤Þ¤»¤ó¤Ç¤·¤¿¡£");
7251 #else
7252                 msg_print("You were not able to extract any essence.");
7253 #endif
7254         }
7255         else
7256         {
7257 #ifdef JP
7258                 msg_print("Ãê½Ð¤·¤¿¥¨¥Ã¥»¥ó¥¹:");
7259 #else
7260                 msg_print("Extracted essences:");
7261 #endif
7262                 for (i = 0; essence_name[i]; i++)
7263                 {
7264                         if (!essence_name[i][0]) continue;
7265                         if (!drain_value[i]) continue;
7266
7267                         p_ptr->magic_num1[i] += drain_value[i];
7268                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7269                         msg_print(NULL);
7270                         msg_format("%s...%d", essence_name[i], drain_value[i]);
7271                 }
7272         }
7273
7274         /* Combine the pack */
7275         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7276
7277         /* Window stuff */
7278         p_ptr->window |= (PW_INVEN);
7279 }
7280
7281
7282
7283 static int choose_essence(void)
7284 {
7285         int mode = 0;
7286         char choice;
7287         int menu_line = (use_menu ? 1 : 0);
7288
7289 #ifdef JP
7290         cptr menu_name[] = {
7291                 "Éð´ïÂ°À",
7292                 "ÂÑÀ",
7293                 "Ç½ÎÏ",
7294                 "¿ôÃÍ",
7295                 "¥¹¥ì¥¤",
7296                 "ESP",
7297                 "¤½¤ÎÂ¾"
7298         };
7299 #else
7300         cptr menu_name[] = {
7301                 "Brand weapon",
7302                 "Resistance",
7303                 "Ability",
7304                 "Magic number",
7305                 "Slay",
7306                 "ESP",
7307                 "Others"
7308         };
7309 #endif
7310         const int mode_max = 7;
7311
7312 #ifdef ALLOW_REPEAT
7313         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
7314                 return mode;
7315         mode = 0;
7316 #endif /* ALLOW_REPEAT */
7317
7318         if (use_menu)
7319         {
7320                 screen_save();
7321
7322                 while(!mode)
7323                 {
7324                         int i;
7325                         for (i = 0; i < mode_max; i++)
7326 #ifdef JP
7327                                 prt(format(" %s %s", (menu_line == 1+i) ? "¡Õ" : "  ", menu_name[i]), 2 + i, 14);
7328                         prt("¤É¤Î¼ïÎà¤Î¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã¤ò¹Ô¤¤¤Þ¤¹¤«¡©", 0, 0);
7329 #else
7330                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
7331                         prt("Choose from menu.", 0, 0);
7332 #endif
7333
7334                         choice = inkey();
7335                         switch(choice)
7336                         {
7337                         case ESCAPE:
7338                         case 'z':
7339                         case 'Z':
7340                                 screen_load();
7341                                 return 0;
7342                         case '2':
7343                         case 'j':
7344                         case 'J':
7345                                 menu_line++;
7346                                 break;
7347                         case '8':
7348                         case 'k':
7349                         case 'K':
7350                                 menu_line += mode_max - 1;
7351                                 break;
7352                         case '\r':
7353                         case '\n':
7354                         case 'x':
7355                         case 'X':
7356                                 mode = menu_line;
7357                                 break;
7358                         }
7359                         if (menu_line > mode_max) menu_line -= mode_max;
7360                 }
7361                 screen_load();
7362         }
7363         else
7364         {
7365                 screen_save();
7366                 while (!mode)
7367                 {
7368                         int i;
7369
7370                         for (i = 0; i < mode_max; i++)
7371                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
7372
7373 #ifdef JP
7374                         if (!get_com("²¿¤òÉÕ²Ã¤·¤Þ¤¹¤«:", &choice, TRUE))
7375 #else
7376                         if (!get_com("Command :", &choice, TRUE))
7377 #endif
7378                         {
7379                                 screen_load();
7380                                 return 0;
7381                         }
7382
7383                         if (isupper(choice)) choice = tolower(choice);
7384
7385                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
7386                                 mode = (int)choice - 'a' + 1;
7387                 }
7388                 screen_load();
7389         }
7390
7391 #ifdef ALLOW_REPEAT
7392         repeat_push(mode);
7393 #endif /* ALLOW_REPEAT */
7394         return mode;
7395 }
7396
7397 static void add_essence(int mode)
7398 {
7399         int item, max_num = 0;
7400         int i;
7401         bool flag,redraw;
7402         char choice;
7403         cptr            q, s;
7404         object_type *o_ptr;
7405         int ask = TRUE;
7406         char out_val[160];
7407         int num[22];
7408         char o_name[MAX_NLEN];
7409         int use_essence;
7410         essence_type *es_ptr;
7411
7412         int menu_line = (use_menu ? 1 : 0);
7413
7414         for (i = 0; essence_info[i].add_name; i++)
7415         {
7416                 es_ptr = &essence_info[i];
7417
7418                 if (es_ptr->type != mode) continue;
7419                 num[max_num++] = i;
7420         }
7421
7422 #ifdef ALLOW_REPEAT
7423         if (!repeat_pull(&i) || i<0 || i>=max_num)
7424         {
7425 #endif /* ALLOW_REPEAT */
7426
7427
7428         /* Nothing chosen yet */
7429         flag = FALSE;
7430
7431         /* No redraw yet */
7432         redraw = FALSE;
7433
7434         /* Build a prompt */
7435 #ifdef JP
7436         (void) strnfmt(out_val, 78, "('*'¤Ç°ìÍ÷, ESC¤ÇÃæÃÇ) ¤É¤ÎÇ½ÎÏ¤òÉÕ²Ã¤·¤Þ¤¹¤«¡©");
7437 #else
7438         (void)strnfmt(out_val, 78, "(*=List, ESC=exit) Add which ability? ");
7439 #endif
7440         if (use_menu) screen_save();
7441
7442         /* Get a spell from the user */
7443
7444         choice = (always_show_list || use_menu) ? ESCAPE:1;
7445         while (!flag)
7446         {
7447                 bool able[22];
7448                 if( choice==ESCAPE ) choice = ' ';
7449                 else if( !get_com(out_val, &choice, FALSE) )break;
7450
7451                 if (use_menu && choice != ' ')
7452                 {
7453                         switch(choice)
7454                         {
7455                                 case '0':
7456                                 {
7457                                         screen_load();
7458                                         return;
7459                                         break;
7460                                 }
7461
7462                                 case '8':
7463                                 case 'k':
7464                                 case 'K':
7465                                 {
7466                                         menu_line += (max_num-1);
7467                                         break;
7468                                 }
7469
7470                                 case '2':
7471                                 case 'j':
7472                                 case 'J':
7473                                 {
7474                                         menu_line++;
7475                                         break;
7476                                 }
7477
7478                                 case '4':
7479                                 case 'h':
7480                                 case 'H':
7481                                 {
7482                                         menu_line = 1;
7483                                         break;
7484                                 }
7485                                 case '6':
7486                                 case 'l':
7487                                 case 'L':
7488                                 {
7489                                         menu_line = max_num;
7490                                         break;
7491                                 }
7492
7493                                 case 'x':
7494                                 case 'X':
7495                                 case '\r':
7496                                 case '\n':
7497                                 {
7498                                         i = menu_line - 1;
7499                                         ask = FALSE;
7500                                         break;
7501                                 }
7502                         }
7503                         if (menu_line > max_num) menu_line -= max_num;
7504                 }
7505                 /* Request redraw */
7506                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
7507                 {
7508                         /* Show the list */
7509                         if (!redraw || use_menu)
7510                         {
7511                                 byte y, x = 10;
7512                                 int ctr;
7513                                 char dummy[80], dummy2[80];
7514                                 byte col;
7515
7516                                 strcpy(dummy, "");
7517
7518                                 /* Show list */
7519                                 redraw = TRUE;
7520
7521                                 /* Save the screen */
7522                                 if (!use_menu) screen_save();
7523
7524                                 for (y = 1; y < 24; y++)
7525                                         prt("", y, x);
7526
7527                                 /* Print header(s) */
7528 #ifdef JP
7529                                 prt(format("   %-43s %6s/%s", "Ç½ÎÏ(É¬Í×¥¨¥Ã¥»¥ó¥¹)", "É¬Í×¿ô", "½ê»ý¿ô"), 1, x);
7530
7531 #else
7532                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
7533 #endif
7534                                 /* Print list */
7535                                 for (ctr = 0; ctr < max_num; ctr++)
7536                                 {
7537                                         es_ptr = &essence_info[num[ctr]];
7538
7539                                         if (use_menu)
7540                                         {
7541                                                 if (ctr == (menu_line-1))
7542 #ifdef JP
7543                                                         strcpy(dummy, "¡Õ ");
7544 #else
7545                                                         strcpy(dummy, ">  ");
7546 #endif
7547                                                 else strcpy(dummy, "   ");
7548
7549                                         }
7550                                         /* letter/number for power selection */
7551                                         else
7552                                         {
7553                                                 sprintf(dummy, "%c) ",I2A(ctr));
7554                                         }
7555
7556                                         strcat(dummy, es_ptr->add_name);
7557
7558                                         col = TERM_WHITE;
7559                                         able[ctr] = TRUE;
7560
7561                                         if (es_ptr->essence != -1)
7562                                         {
7563                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
7564                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
7565                                         }
7566                                         else
7567                                         {
7568                                                 switch(es_ptr->add)
7569                                                 {
7570                                                 case ESSENCE_SH_FIRE:
7571 #ifdef JP
7572                                                         strcat(dummy, "(¾Æ´þ+ÂÑ²Ð±ê)");
7573 #else
7574                                                         strcat(dummy, "(brand fire + res.fire)");
7575 #endif
7576                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
7577                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
7578                                                         break;
7579                                                 case ESSENCE_SH_ELEC:
7580 #ifdef JP
7581                                                         strcat(dummy, "(ÅÅ·â+ÂÑÅÅ·â)");
7582 #else
7583                                                         strcat(dummy, "(brand elec. + res. elec.)");
7584 #endif
7585                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
7586                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
7587                                                         break;
7588                                                 case ESSENCE_SH_COLD:
7589 #ifdef JP
7590                                                         strcat(dummy, "(Åà·ë+ÂÑÎäµ¤)");
7591 #else
7592                                                         strcat(dummy, "(brand cold + res. cold)");
7593 #endif
7594                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
7595                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
7596                                                         break;
7597                                                 case ESSENCE_RESISTANCE:
7598 #ifdef JP
7599                                                         strcat(dummy, "(ÂÑ²Ð±ê+ÂÑÎäµ¤+ÂÑÅÅ·â+ÂÑ»À)");
7600 #else
7601                                                         strcat(dummy, "(r.fire+r.cold+r.elec+r.acid)");
7602 #endif
7603                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
7604                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
7605                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
7606                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
7607                                                         break;
7608                                                 case ESSENCE_SUSTAIN:
7609 #ifdef JP
7610                                                         strcat(dummy, "(ÂÑ²Ð±ê+ÂÑÎäµ¤+ÂÑÅÅ·â+ÂÑ»À)");
7611 #else
7612                                                         strcat(dummy, "(r.fire+r.cold+r.elec+r.acid)");
7613 #endif
7614                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
7615                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
7616                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
7617                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
7618                                                         break;
7619                                                 }
7620                                         }
7621
7622                                         if (!able[ctr]) col = TERM_RED;
7623
7624                                         if (es_ptr->essence != -1)
7625                                         {
7626                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
7627                                         }
7628                                         else
7629                                         {
7630                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
7631                                         }
7632
7633                                         c_prt(col, dummy2, ctr+2, x);
7634                                 }
7635                         }
7636
7637                         /* Hide the list */
7638                         else
7639                         {
7640                                 /* Hide list */
7641                                 redraw = FALSE;
7642
7643                                 /* Restore the screen */
7644                                 screen_load();
7645                         }
7646
7647                         /* Redo asking */
7648                         continue;
7649                 }
7650
7651                 if (!use_menu)
7652                 {
7653                         /* Note verify */
7654                         ask = (isupper(choice));
7655
7656                         /* Lowercase */
7657                         if (ask) choice = tolower(choice);
7658
7659                         /* Extract request */
7660                         i = (islower(choice) ? A2I(choice) : -1);
7661                 }
7662
7663                 /* Totally Illegal */
7664                 if ((i < 0) || (i >= max_num) || !able[i])
7665                 {
7666                         bell();
7667                         continue;
7668                 }
7669
7670                 /* Verify it */
7671                 if (ask)
7672                 {
7673                         char tmp_val[160];
7674
7675                         /* Prompt */
7676 #ifdef JP
7677                         (void) strnfmt(tmp_val, 78, "%s¤òÉÕ²Ã¤·¤Þ¤¹¤«¡© ", essence_info[num[i]].add_name);
7678 #else
7679                         (void) strnfmt(tmp_val, 78, "Add the abilitiy of %s? ", essence_info[num[i]].add_name);
7680 #endif
7681
7682                         /* Belay that order */
7683                         if (!get_check(tmp_val)) continue;
7684                 }
7685
7686                 /* Stop the loop */
7687                 flag = TRUE;
7688         }
7689
7690         /* Restore the screen */
7691         if (redraw) screen_load();
7692
7693         if (!flag) return;
7694
7695 #ifdef ALLOW_REPEAT
7696         repeat_push(i);
7697         }
7698 #endif /* ALLOW_REPEAT */
7699
7700         es_ptr = &essence_info[num[i]];
7701
7702         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
7703                 item_tester_tval = TV_GLOVES;
7704         else if (mode == 1)
7705                 item_tester_hook = item_tester_hook_melee_ammo;
7706         else if (es_ptr->add == ESSENCE_ATTACK)
7707                 item_tester_hook = item_tester_hook_weapon;
7708         else if (es_ptr->add == ESSENCE_AC)
7709                 item_tester_hook = item_tester_hook_armour;
7710         else
7711                 item_tester_hook = item_tester_hook_weapon_armour;
7712         item_tester_no_ryoute = TRUE;
7713
7714         /* Get an item */
7715 #ifdef JP
7716         q = "¤É¤Î¥¢¥¤¥Æ¥à¤ò²þÎÉ¤·¤Þ¤¹¤«¡©";
7717         s = "²þÎÉ¤Ç¤¤ë¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
7718 #else
7719         q = "Improve which item? ";
7720         s = "You have nothing to improve.";
7721 #endif
7722
7723         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7724
7725         /* Get the item (in the pack) */
7726         if (item >= 0)
7727         {
7728                 o_ptr = &inventory[item];
7729         }
7730
7731         /* Get the item (on the floor) */
7732         else
7733         {
7734                 o_ptr = &o_list[0 - item];
7735         }
7736
7737         if ((mode != 10) && (o_ptr->name1 || o_ptr->art_name || o_ptr->xtra3))
7738         {
7739 #ifdef JP
7740                 msg_print("¤½¤Î¥¢¥¤¥Æ¥à¤Ï¤³¤ì°Ê¾å²þÎÉ¤Ç¤¤Ê¤¤¡£");
7741 #else
7742                 msg_print("This item is no more able to be improved");
7743 #endif
7744                 return;
7745         }
7746
7747         object_desc(o_name, o_ptr, FALSE, 0);
7748
7749         use_essence = es_ptr->value;
7750         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
7751         if (o_ptr->number > 1)
7752         {
7753                 use_essence *= o_ptr->number;
7754 #ifdef JP
7755                 msg_format("%d¸Ä¤¢¤ë¤Î¤Ç¥¨¥Ã¥»¥ó¥¹¤Ï%dÉ¬Í×¤Ç¤¹¡£", o_ptr->number, use_essence);
7756 #else
7757                 msg_format("It will take %d essences.",use_essence);
7758 #endif
7759
7760         }
7761
7762         if (es_ptr->essence != -1)
7763         {
7764                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
7765                 {
7766 #ifdef JP
7767                         msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7768 #else
7769                         msg_print("You don't have enough essences.");
7770 #endif
7771                         return;
7772                 }
7773                 if (is_pval_flag(es_ptr->add))
7774                 {
7775                         if (es_ptr->add == TR_BLOWS)
7776                         {
7777                                 if (o_ptr->pval > 1)
7778                                 {
7779 #ifdef JP
7780                                         if (!get_check("½¤ÀµÃÍ¤Ï1¤Ë¤Ê¤ê¤Þ¤¹¡£¤è¤í¤·¤¤¤Ç¤¹¤«¡©")) return;
7781 #else
7782                                         if (!get_check("The magic number of this weapon will become 1. Are you sure? ")) return;
7783 #endif
7784                                 }
7785                                 o_ptr->pval = 1;
7786                         }
7787                         else if (o_ptr->pval)
7788                         {
7789                                 use_essence *= o_ptr->pval;
7790 #ifdef JP
7791                                 msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£",use_essence);
7792 #else
7793                                 msg_format("It will take %d essences.",use_essence);
7794 #endif
7795                         }
7796                         else
7797                         {
7798                                 char tmp[80];
7799                                 char tmp_val[160];
7800                                 int pval;
7801                                 int limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
7802
7803
7804 #ifdef JP
7805                                 sprintf(tmp, "¤¤¤¯¤ÄÉÕ²Ã¤·¤Þ¤¹¤«¡© (1-%d): ", limit);
7806 #else
7807                                 sprintf(tmp, "Enchant how many? (1-%d): ", limit);
7808 #endif
7809                                 strcpy(tmp_val, "1");
7810
7811                                 if (!get_string(tmp, tmp_val, 1)) return;
7812                                 pval = atoi(tmp_val);
7813                                 if (pval > limit) pval = limit;
7814                                 else if (pval < 1) pval = 1;
7815                                 o_ptr->pval = pval;
7816                                 use_essence *= pval;
7817 #ifdef JP
7818                                 msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£",use_essence);
7819 #else
7820                                 msg_format("It will take %d essences.",use_essence);
7821 #endif
7822                         }
7823                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
7824                         {
7825 #ifdef JP
7826                                 msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7827 #else
7828                                 msg_print("You don't have enough essences.");
7829 #endif
7830                                 return;
7831                         }
7832                 }
7833                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
7834                 {
7835                         char tmp_val[160];
7836                         int val;
7837                         int get_to_h, get_to_d;
7838
7839                         strcpy(tmp_val, "1");
7840 #ifdef JP
7841                         if (!get_string(format("¤¤¤¯¤ÄÉÕ²Ã¤·¤Þ¤¹¤«¡© (1-%d):", p_ptr->lev/7+3), tmp_val, 2)) return;
7842 #else
7843                         if (!get_string(format("Enchant how many? (1-%d):", p_ptr->lev/7+3), tmp_val, 2)) return;
7844 #endif
7845                         val = atoi(tmp_val);
7846                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
7847                         else if (val < 1) val = 1;
7848                         use_essence *= val;
7849 #ifdef JP
7850                         msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£",use_essence);
7851 #else
7852                         msg_format("It will take %d essences.",use_essence);
7853 #endif
7854                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
7855                         {
7856 #ifdef JP
7857                                 msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7858 #else
7859                                 msg_print("You don't have enough essences");
7860 #endif
7861                                 return;
7862                         }
7863                         get_to_h = ((val+1)/2+randint0(val/2+1));
7864                         get_to_d = ((val+1)/2+randint0(val/2+1));
7865                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
7866                         o_ptr->to_h += get_to_h;
7867                         o_ptr->to_d += get_to_d;
7868                 }
7869                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
7870                 if (es_ptr->add == ESSENCE_ATTACK)
7871                 {
7872                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
7873                         {
7874 #ifdef JP
7875                                 msg_print("²þÎÉ¤Ë¼ºÇÔ¤·¤¿¡£");
7876 #else
7877                                 msg_print("You failed to enchant.");
7878 #endif
7879                                 energy_use = 100;
7880                                 return;
7881                         }
7882                         else
7883                         {
7884                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
7885                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
7886                         }
7887                 }
7888                 else if (es_ptr->add == ESSENCE_AC)
7889                 {
7890                         if (o_ptr->to_a >= p_ptr->lev/5+5)
7891                         {
7892 #ifdef JP
7893                                 msg_print("²þÎÉ¤Ë¼ºÇÔ¤·¤¿¡£");
7894 #else
7895                                 msg_print("You failed to enchant.");
7896 #endif
7897                                 energy_use = 100;
7898                                 return;
7899                         }
7900                         else
7901                         {
7902                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
7903                         }
7904                 }
7905                 else
7906                 {
7907                         o_ptr->xtra3 = es_ptr->add + 1;
7908                 }
7909         }
7910         else
7911         {
7912                 bool success = TRUE;
7913
7914                 switch(es_ptr->add)
7915                 {
7916                 case ESSENCE_SH_FIRE:
7917                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
7918                         {
7919                                 success = FALSE;
7920                                 break;
7921                         }
7922                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
7923                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
7924                         break;
7925                 case ESSENCE_SH_ELEC:
7926                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
7927                         {
7928                                 success = FALSE;
7929                                 break;
7930                         }
7931                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
7932                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
7933                         break;
7934                 case ESSENCE_SH_COLD:
7935                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
7936                         {
7937                                 success = FALSE;
7938                                 break;
7939                         }
7940                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
7941                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
7942                         break;
7943                 case ESSENCE_RESISTANCE:
7944                 case ESSENCE_SUSTAIN:
7945                         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))
7946                         {
7947                                 success = FALSE;
7948                                 break;
7949                         }
7950                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
7951                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
7952                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
7953                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
7954                         break;
7955                 }
7956                 if (!success)
7957                 {
7958 #ifdef JP
7959                         msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7960 #else
7961                         msg_print("You don't have enough essences");
7962 #endif
7963                         return;
7964                 }
7965                 if (es_ptr->add == ESSENCE_SUSTAIN)
7966                 {
7967                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
7968                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
7969                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
7970                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
7971                 }
7972                 else
7973                 {
7974                         o_ptr->xtra3 = es_ptr->add + 1;
7975                 }
7976         }
7977
7978         energy_use = 100;
7979
7980 #ifdef JP
7981         msg_format("%s¤Ë%s¤ÎÇ½ÎÏ¤òÉÕ²Ã¤·¤Þ¤·¤¿¡£", o_name, es_ptr->add_name);
7982 #else
7983         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
7984 #endif
7985
7986         /* Combine the pack */
7987         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7988
7989         /* Window stuff */
7990         p_ptr->window |= (PW_INVEN);
7991 }
7992
7993
7994 static bool item_tester_hook_kaji(object_type *o_ptr)
7995 {
7996         switch (o_ptr->tval)
7997         {
7998                 case TV_SWORD:
7999                 case TV_HAFTED:
8000                 case TV_POLEARM:
8001                 case TV_DIGGING:
8002                 case TV_BOW:
8003                 case TV_BOLT:
8004                 case TV_ARROW:
8005                 case TV_SHOT:
8006                 case TV_DRAG_ARMOR:
8007                 case TV_HARD_ARMOR:
8008                 case TV_SOFT_ARMOR:
8009                 case TV_SHIELD:
8010                 case TV_CLOAK:
8011                 case TV_CROWN:
8012                 case TV_HELM:
8013                 case TV_BOOTS:
8014                 case TV_GLOVES:
8015                 {
8016                         if (o_ptr->xtra3) return (TRUE);
8017                 }
8018         }
8019
8020         return (FALSE);
8021 }
8022
8023
8024 static void erase_essence(void)
8025 {
8026         int item;
8027         cptr q, s;
8028         object_type *o_ptr;
8029         char o_name[MAX_NLEN];
8030         u32b flgs[TR_FLAG_SIZE];
8031
8032         item_tester_hook = item_tester_hook_kaji;
8033
8034         /* Get an item */
8035 #ifdef JP
8036         q = "¤É¤Î¥¢¥¤¥Æ¥à¤Î¥¨¥Ã¥»¥ó¥¹¤ò¾Ãµî¤·¤Þ¤¹¤«¡©";
8037         s = "¥¨¥Ã¥»¥ó¥¹¤òÉÕ²Ã¤·¤¿¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
8038 #else
8039         q = "Remove from which item? ";
8040         s = "You have nothing to remove essence.";
8041 #endif
8042
8043         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
8044
8045         /* Get the item (in the pack) */
8046         if (item >= 0)
8047         {
8048                 o_ptr = &inventory[item];
8049         }
8050
8051         /* Get the item (on the floor) */
8052         else
8053         {
8054                 o_ptr = &o_list[0 - item];
8055         }
8056
8057         object_desc(o_name, o_ptr, FALSE, 0);
8058 #ifdef JP
8059         if (!get_check(format("¤è¤í¤·¤¤¤Ç¤¹¤«¡©[%s]", o_name))) return;
8060 #else
8061         if (!get_check(format("Are you sure?[%s]", o_name))) return;
8062 #endif
8063
8064         energy_use = 100;
8065
8066         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8067         {
8068                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8069                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8070                 o_ptr->xtra4 = 0;
8071         }
8072         o_ptr->xtra3 = 0;
8073         object_flags(o_ptr, flgs);
8074         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8075 #ifdef JP
8076         msg_print("¥¨¥Ã¥»¥ó¥¹¤ò¼è¤êµî¤Ã¤¿¡£");
8077 #else
8078         msg_print("You removed all essence you have added");
8079 #endif
8080
8081         /* Combine the pack */
8082         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8083
8084         /* Window stuff */
8085         p_ptr->window |= (PW_INVEN);
8086 }
8087
8088 void do_cmd_kaji(bool only_browse)
8089 {
8090         int mode = 0;
8091         char choice;
8092
8093         int menu_line = (use_menu ? 1 : 0);
8094
8095         if (!only_browse)
8096         {
8097                 if (p_ptr->confused)
8098                 {
8099 #ifdef JP
8100                         msg_print("º®Íð¤·¤Æ¤¤¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8101 #else
8102                         msg_print("You are too confused!");
8103 #endif
8104
8105                         return;
8106                 }
8107                 if (p_ptr->blind)
8108                 {
8109 #ifdef JP
8110                         msg_print("ÌÜ¤¬¸«¤¨¤Ê¤¯¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8111 #else
8112                         msg_print("You are blind!");
8113 #endif
8114
8115                         return;
8116                 }
8117                 if (p_ptr->image)
8118                 {
8119 #ifdef JP
8120                         msg_print("¤¦¤Þ¤¯¸«¤¨¤Ê¤¯¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8121 #else
8122                         msg_print("You are hullcinating!");
8123 #endif
8124
8125                         return;
8126                 }
8127         }
8128
8129 #ifdef ALLOW_REPEAT
8130         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8131         {
8132 #endif /* ALLOW_REPEAT */
8133
8134         if (only_browse) screen_save();
8135         do {
8136         if (!only_browse) screen_save();
8137         if (use_menu)
8138         {
8139                 while(!mode)
8140                 {
8141 #ifdef JP
8142                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹°ìÍ÷", (menu_line == 1) ? "¡Õ" : "  "), 2, 14);
8143                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹Ãê½Ð", (menu_line == 2) ? "¡Õ" : "  "), 3, 14);
8144                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹¾Ãµî", (menu_line == 3) ? "¡Õ" : "  "), 4, 14);
8145                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã", (menu_line == 4) ? "¡Õ" : "  "), 5, 14);
8146                         prt(format(" %s Éð´ï/ËÉ¶ñ¶¯²½", (menu_line == 5) ? "¡Õ" : "  "), 6, 14);
8147                         prt(format("¤É¤Î¼ïÎà¤Îµ»½Ñ¤ò%s¤Þ¤¹¤«¡©", only_browse ? "Ä´¤Ù" : "»È¤¤"), 0, 0);
8148 #else
8149                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8150                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8151                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8152                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8153                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8154                         prt(format("Choose command from menu."), 0, 0);
8155 #endif
8156                         choice = inkey();
8157                         switch(choice)
8158                         {
8159                         case ESCAPE:
8160                         case 'z':
8161                         case 'Z':
8162                                 screen_load();
8163                                 return;
8164                         case '2':
8165                         case 'j':
8166                         case 'J':
8167                                 menu_line++;
8168                                 break;
8169                         case '8':
8170                         case 'k':
8171                         case 'K':
8172                                 menu_line+= 4;
8173                                 break;
8174                         case '\r':
8175                         case '\n':
8176                         case 'x':
8177                         case 'X':
8178                                 mode = menu_line;
8179                                 break;
8180                         }
8181                         if (menu_line > 5) menu_line -= 5;
8182                 }
8183         }
8184
8185         else
8186         {
8187                 while (!mode)
8188                 {
8189 #ifdef JP
8190                         prt("  a) ¥¨¥Ã¥»¥ó¥¹°ìÍ÷", 2, 14);
8191                         prt("  b) ¥¨¥Ã¥»¥ó¥¹Ãê½Ð", 3, 14);
8192                         prt("  c) ¥¨¥Ã¥»¥ó¥¹¾Ãµî", 4, 14);
8193                         prt("  d) ¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã", 5, 14);
8194                         prt("  e) Éð´ï/ËÉ¶ñ¶¯²½", 6, 14);
8195                         if (!get_com(format("¤É¤ÎÇ½ÎÏ¤ò%s¤Þ¤¹¤«:", only_browse ? "Ä´¤Ù" : "»È¤¤"), &choice, TRUE))
8196 #else
8197                         prt("  a) List essences", 2, 14);
8198                         prt("  b) Extract essence", 3, 14);
8199                         prt("  c) Remove essence", 4, 14);
8200                         prt("  d) Add essence", 5, 14);
8201                         prt("  e) Enchant weapon/armor", 6, 14);
8202                         if (!get_com("Command :", &choice, TRUE))
8203 #endif
8204                         {
8205                                 screen_load();
8206                                 return;
8207                         }
8208                         switch (choice)
8209                         {
8210                         case 'A':
8211                         case 'a':
8212                                 mode = 1;
8213                                 break;
8214                         case 'B':
8215                         case 'b':
8216                                 mode = 2;
8217                                 break;
8218                         case 'C':
8219                         case 'c':
8220                                 mode = 3;
8221                                 break;
8222                         case 'D':
8223                         case 'd':
8224                                 mode = 4;
8225                                 break;
8226                         case 'E':
8227                         case 'e':
8228                                 mode = 5;
8229                                 break;
8230                         }
8231                 }
8232         }
8233
8234         if (only_browse)
8235         {
8236                 char temp[62*5];
8237                 int line, j;
8238
8239                 /* Clear lines, position cursor  (really should use strlen here) */
8240                 Term_erase(14, 21, 255);
8241                 Term_erase(14, 20, 255);
8242                 Term_erase(14, 19, 255);
8243                 Term_erase(14, 18, 255);
8244                 Term_erase(14, 17, 255);
8245                 Term_erase(14, 16, 255);
8246
8247                 roff_to_buf(kaji_tips[mode-1], 62, temp, sizeof(temp));
8248                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8249                 {
8250                         prt(&temp[j], line, 15);
8251                         line++;
8252                 }
8253                 mode = 0;
8254         }
8255         if (!only_browse) screen_load();
8256         } while (only_browse);
8257 #ifdef ALLOW_REPEAT
8258         repeat_push(mode);
8259         }
8260 #endif /* ALLOW_REPEAT */
8261
8262         switch(mode)
8263         {
8264                 case 1: display_essence();break;
8265                 case 2: drain_essence();break;
8266                 case 3: erase_essence();break;
8267                 case 4:
8268                         mode = choose_essence();
8269                         if (mode == 0)
8270                                 break;
8271                         add_essence(mode);
8272                         break;
8273                 case 5: add_essence(10);break;
8274         }
8275 }