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