src/object2.c

   1 /* File: object2.c */
   2
   3 /* Purpose: Object code, part 2 */
   4
   5 /*
   6  * Copyright (c) 1989 James E. Wilson, Robert A. Koeneke
   7  *
   8  * This software may be copied and distributed for educational, research, and
   9  * not for profit purposes provided that this copyright and statement are
  10  * included in all such copies.
  11  */
  12
  13 #include "angband.h"
  14
  15 #include "kajitips.h"
  16
  17
  18 /*
  19  * Excise a dungeon object from any stacks
  20  */
  21 void excise_object_idx(int o_idx)
  22 {
  23         object_type *j_ptr;
  24
  25         s16b this_o_idx, next_o_idx = 0;
  26
  27         s16b prev_o_idx = 0;
  28
  29
  30         /* Object */
  31         j_ptr = &o_list[o_idx];
  32
  33         /* Monster */
  34         if (j_ptr->held_m_idx)
  35         {
  36                 monster_type *m_ptr;
  37
  38                 /* Monster */
  39                 m_ptr = &m_list[j_ptr->held_m_idx];
  40
  41                 /* Scan all objects in the grid */
  42                 for (this_o_idx = m_ptr->hold_o_idx; this_o_idx; this_o_idx = next_o_idx)
  43                 {
  44                         object_type *o_ptr;
  45
  46                         /* Acquire object */
  47                         o_ptr = &o_list[this_o_idx];
  48
  49                         /* Acquire next object */
  50                         next_o_idx = o_ptr->next_o_idx;
  51
  52                         /* Done */
  53                         if (this_o_idx == o_idx)
  54                         {
  55                                 /* No previous */
  56                                 if (prev_o_idx == 0)
  57                                 {
  58                                         /* Remove from list */
  59                                         m_ptr->hold_o_idx = next_o_idx;
  60                                 }
  61
  62                                 /* Real previous */
  63                                 else
  64                                 {
  65                                         object_type *k_ptr;
  66
  67                                         /* Previous object */
  68                                         k_ptr = &o_list[prev_o_idx];
  69
  70                                         /* Remove from list */
  71                                         k_ptr->next_o_idx = next_o_idx;
  72                                 }
  73
  74                                 /* Forget next pointer */
  75                                 o_ptr->next_o_idx = 0;
  76
  77                                 /* Done */
  78                                 break;
  79                         }
  80
  81                         /* Save prev_o_idx */
  82                         prev_o_idx = this_o_idx;
  83                 }
  84         }
  85
  86         /* Dungeon */
  87         else
  88         {
  89                 cave_type *c_ptr;
  90
  91                 int y = j_ptr->iy;
  92                 int x = j_ptr->ix;
  93
  94                 /* Grid */
  95                 c_ptr = &cave[y][x];
  96
  97                 /* Scan all objects in the grid */
  98                 for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
  99                 {
 100                         object_type *o_ptr;
 101
 102                         /* Acquire object */
 103                         o_ptr = &o_list[this_o_idx];
 104
 105                         /* Acquire next object */
 106                         next_o_idx = o_ptr->next_o_idx;
 107
 108                         /* Done */
 109                         if (this_o_idx == o_idx)
 110                         {
 111                                 /* No previous */
 112                                 if (prev_o_idx == 0)
 113                                 {
 114                                         /* Remove from list */
 115                                         c_ptr->o_idx = next_o_idx;
 116                                 }
 117
 118                                 /* Real previous */
 119                                 else
 120                                 {
 121                                         object_type *k_ptr;
 122
 123                                         /* Previous object */
 124                                         k_ptr = &o_list[prev_o_idx];
 125
 126                                         /* Remove from list */
 127                                         k_ptr->next_o_idx = next_o_idx;
 128                                 }
 129
 130                                 /* Forget next pointer */
 131                                 o_ptr->next_o_idx = 0;
 132
 133                                 /* Done */
 134                                 break;
 135                         }
 136
 137                         /* Save prev_o_idx */
 138                         prev_o_idx = this_o_idx;
 139                 }
 140         }
 141 }
 142
 143
 144 /*
 145  * Delete a dungeon object
 146  *
 147  * Handle "stacks" of objects correctly.
 148  */
 149 void delete_object_idx(int o_idx)
 150 {
 151         object_type *j_ptr;
 152
 153         /* Excise */
 154         excise_object_idx(o_idx);
 155
 156         /* Object */
 157         j_ptr = &o_list[o_idx];
 158
 159         /* Dungeon floor */
 160         if (!(j_ptr->held_m_idx))
 161         {
 162                 int y, x;
 163
 164                 /* Location */
 165                 y = j_ptr->iy;
 166                 x = j_ptr->ix;
 167
 168                 /* Visual update */
 169                 lite_spot(y, x);
 170         }
 171
 172         /* Wipe the object */
 173         object_wipe(j_ptr);
 174
 175         /* Count objects */
 176         o_cnt--;
 177 }
 178
 179
 180 /*
 181  * Deletes all objects at given location
 182  */
 183 void delete_object(int y, int x)
 184 {
 185         cave_type *c_ptr;
 186
 187         s16b this_o_idx, next_o_idx = 0;
 188
 189
 190         /* Refuse "illegal" locations */
 191         if (!in_bounds(y, x)) return;
 192
 193
 194         /* Grid */
 195         c_ptr = &cave[y][x];
 196
 197         /* Scan all objects in the grid */
 198         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
 199         {
 200                 object_type *o_ptr;
 201
 202                 /* Acquire object */
 203                 o_ptr = &o_list[this_o_idx];
 204
 205                 /* Acquire next object */
 206                 next_o_idx = o_ptr->next_o_idx;
 207
 208                 /* Wipe the object */
 209                 object_wipe(o_ptr);
 210
 211                 /* Count objects */
 212                 o_cnt--;
 213         }
 214
 215         /* Objects are gone */
 216         c_ptr->o_idx = 0;
 217
 218         /* Visual update */
 219         lite_spot(y, x);
 220 }
 221
 222
 223 /*
 224  * Move an object from index i1 to index i2 in the object list
 225  */
 226 static void compact_objects_aux(int i1, int i2)
 227 {
 228         int i;
 229
 230         cave_type *c_ptr;
 231
 232         object_type *o_ptr;
 233
 234
 235         /* Do nothing */
 236         if (i1 == i2) return;
 237
 238
 239         /* Repair objects */
 240         for (i = 1; i < o_max; i++)
 241         {
 242                 /* Acquire object */
 243                 o_ptr = &o_list[i];
 244
 245                 /* Skip "dead" objects */
 246                 if (!o_ptr->k_idx) continue;
 247
 248                 /* Repair "next" pointers */
 249                 if (o_ptr->next_o_idx == i1)
 250                 {
 251                         /* Repair */
 252                         o_ptr->next_o_idx = i2;
 253                 }
 254         }
 255
 256
 257         /* Acquire object */
 258         o_ptr = &o_list[i1];
 259
 260
 261         /* Monster */
 262         if (o_ptr->held_m_idx)
 263         {
 264                 monster_type *m_ptr;
 265
 266                 /* Acquire monster */
 267                 m_ptr = &m_list[o_ptr->held_m_idx];
 268
 269                 /* Repair monster */
 270                 if (m_ptr->hold_o_idx == i1)
 271                 {
 272                         /* Repair */
 273                         m_ptr->hold_o_idx = i2;
 274                 }
 275         }
 276
 277         /* Dungeon */
 278         else
 279         {
 280                 int y, x;
 281
 282                 /* Acquire location */
 283                 y = o_ptr->iy;
 284                 x = o_ptr->ix;
 285
 286                 /* Acquire grid */
 287                 c_ptr = &cave[y][x];
 288
 289                 /* Repair grid */
 290                 if (c_ptr->o_idx == i1)
 291                 {
 292                         /* Repair */
 293                         c_ptr->o_idx = i2;
 294                 }
 295         }
 296
 297
 298         /* Structure copy */
 299         o_list[i2] = o_list[i1];
 300
 301         /* Wipe the hole */
 302         object_wipe(o_ptr);
 303 }
 304
 305
 306 /*
 307  * Compact and Reorder the object list
 308  *
 309  * This function can be very dangerous, use with caution!
 310  *
 311  * When actually "compacting" objects, we base the saving throw on a
 312  * combination of object level, distance from player, and current
 313  * "desperation".
 314  *
 315  * After "compacting" (if needed), we "reorder" the objects into a more
 316  * compact order, and we reset the allocation info, and the "live" array.
 317  */
 318 void compact_objects(int size)
 319 {
 320         int i, y, x, num, cnt;
 321         int cur_lev, cur_dis, chance;
 322         object_type *o_ptr;
 323
 324
 325         /* Compact */
 326         if (size)
 327         {
 328                 /* Message */
 329 #ifdef JP
 330                 msg_print("¥¢¥¤¥Æ¥à¾ðÊó¤ò°µ½Ì¤·¤Æ¤¤¤Þ¤¹...");
 331 #else
 332                 msg_print("Compacting objects...");
 333 #endif
 334
 335
 336                 /* Redraw map */
 337                 p_ptr->redraw |= (PR_MAP);
 338
 339                 /* Window stuff */
 340                 p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);
 341         }
 342
 343
 344         /* Compact at least 'size' objects */
 345         for (num = 0, cnt = 1; num < size; cnt++)
 346         {
 347                 /* Get more vicious each iteration */
 348                 cur_lev = 5 * cnt;
 349
 350                 /* Get closer each iteration */
 351                 cur_dis = 5 * (20 - cnt);
 352
 353                 /* Examine the objects */
 354                 for (i = 1; i < o_max; i++)
 355                 {
 356                         o_ptr = &o_list[i];
 357
 358                         /* Skip dead objects */
 359                         if (!o_ptr->k_idx) continue;
 360
 361                         /* Hack -- High level objects start out "immune" */
 362                         if (get_object_level(o_ptr) > cur_lev) continue;
 363
 364                         /* Monster */
 365                         if (o_ptr->held_m_idx)
 366                         {
 367                                 monster_type *m_ptr;
 368
 369                                 /* Acquire monster */
 370                                 m_ptr = &m_list[o_ptr->held_m_idx];
 371
 372                                 /* Get the location */
 373                                 y = m_ptr->fy;
 374                                 x = m_ptr->fx;
 375
 376                                 /* Monsters protect their objects */
 377                                 if (randint0(100) < 90) continue;
 378                         }
 379
 380                         /* Dungeon */
 381                         else
 382                         {
 383                                 /* Get the location */
 384                                 y = o_ptr->iy;
 385                                 x = o_ptr->ix;
 386                         }
 387
 388                         /* Nearby objects start out "immune" */
 389                         if ((cur_dis > 0) && (distance(py, px, y, x) < cur_dis)) continue;
 390
 391                         /* Saving throw */
 392                         chance = 90;
 393
 394                         /* Hack -- only compact artifacts in emergencies */
 395                         if ((artifact_p(o_ptr) || o_ptr->art_name) &&
 396                             (cnt < 1000)) chance = 100;
 397
 398                         /* Apply the saving throw */
 399                         if (randint0(100) < chance) continue;
 400
 401                         /* Delete the object */
 402                         delete_object_idx(i);
 403
 404                         /* Count it */
 405                         num++;
 406                 }
 407         }
 408
 409
 410         /* Excise dead objects (backwards!) */
 411         for (i = o_max - 1; i >= 1; i--)
 412         {
 413                 o_ptr = &o_list[i];
 414
 415                 /* Skip real objects */
 416                 if (o_ptr->k_idx) continue;
 417
 418                 /* Move last object into open hole */
 419                 compact_objects_aux(o_max - 1, i);
 420
 421                 /* Compress "o_max" */
 422                 o_max--;
 423         }
 424 }
 425
 426
 427 /*
 428  * Delete all the items when player leaves the level
 429  *
 430  * Note -- we do NOT visually reflect these (irrelevant) changes
 431  *
 432  * Hack -- we clear the "c_ptr->o_idx" field for every grid,
 433  * and the "m_ptr->next_o_idx" field for every monster, since
 434  * we know we are clearing every object.  Technically, we only
 435  * clear those fields for grids/monsters containing objects,
 436  * and we clear it once for every such object.
 437  */
 438 void wipe_o_list(void)
 439 {
 440         int i;
 441
 442         /* Delete the existing objects */
 443         for (i = 1; i < o_max; i++)
 444         {
 445                 object_type *o_ptr = &o_list[i];
 446
 447                 /* Skip dead objects */
 448                 if (!o_ptr->k_idx) continue;
 449
 450                 /* Mega-Hack -- preserve artifacts */
 451                 if (!character_dungeon || preserve_mode)
 452                 {
 453                         /* Hack -- Preserve unknown artifacts */
 454                         if (artifact_p(o_ptr) && !object_known_p(o_ptr))
 455                         {
 456                                 /* Mega-Hack -- Preserve the artifact */
 457                                 a_info[o_ptr->name1].cur_num = 0;
 458                         }
 459                 }
 460
 461                 /* Monster */
 462                 if (o_ptr->held_m_idx)
 463                 {
 464                         monster_type *m_ptr;
 465
 466                         /* Monster */
 467                         m_ptr = &m_list[o_ptr->held_m_idx];
 468
 469                         /* Hack -- see above */
 470                         m_ptr->hold_o_idx = 0;
 471                 }
 472
 473                 /* Dungeon */
 474                 else
 475                 {
 476                         cave_type *c_ptr;
 477
 478                         /* Access location */
 479                         int y = o_ptr->iy;
 480                         int x = o_ptr->ix;
 481
 482                         /* Access grid */
 483                         c_ptr = &cave[y][x];
 484
 485                         /* Hack -- see above */
 486                         c_ptr->o_idx = 0;
 487                 }
 488
 489                 /* Wipe the object */
 490                 object_wipe(o_ptr);
 491         }
 492
 493         /* Reset "o_max" */
 494         o_max = 1;
 495
 496         /* Reset "o_cnt" */
 497         o_cnt = 0;
 498 }
 499
 500
 501 /*
 502  * Acquires and returns the index of a "free" object.
 503  *
 504  * This routine should almost never fail, but in case it does,
 505  * we must be sure to handle "failure" of this routine.
 506  */
 507 s16b o_pop(void)
 508 {
 509         int i;
 510
 511
 512         /* Initial allocation */
 513         if (o_max < max_o_idx)
 514         {
 515                 /* Get next space */
 516                 i = o_max;
 517
 518                 /* Expand object array */
 519                 o_max++;
 520
 521                 /* Count objects */
 522                 o_cnt++;
 523
 524                 /* Use this object */
 525                 return (i);
 526         }
 527
 528
 529         /* Recycle dead objects */
 530         for (i = 1; i < o_max; i++)
 531         {
 532                 object_type *o_ptr;
 533
 534                 /* Acquire object */
 535                 o_ptr = &o_list[i];
 536
 537                 /* Skip live objects */
 538                 if (o_ptr->k_idx) continue;
 539
 540                 /* Count objects */
 541                 o_cnt++;
 542
 543                 /* Use this object */
 544                 return (i);
 545         }
 546
 547
 548         /* Warn the player (except during dungeon creation) */
 549 #ifdef JP
 550         if (character_dungeon) msg_print("¥¢¥¤¥Æ¥à¤¬Â¿¤¹¤®¤ë¡ª");
 551 #else
 552         if (character_dungeon) msg_print("Too many objects!");
 553 #endif
 554
 555
 556         /* Oops */
 557         return (0);
 558 }
 559
 560
 561 /*
 562  * Apply a "object restriction function" to the "object allocation table"
 563  */
 564 errr get_obj_num_prep(void)
 565 {
 566         int i;
 567
 568         /* Get the entry */
 569         alloc_entry *table = alloc_kind_table;
 570
 571         /* Scan the allocation table */
 572         for (i = 0; i < alloc_kind_size; i++)
 573         {
 574                 /* Accept objects which pass the restriction, if any */
 575                 if (!get_obj_num_hook || (*get_obj_num_hook)(table[i].index))
 576                 {
 577                         /* Accept this object */
 578                         table[i].prob2 = table[i].prob1;
 579                 }
 580
 581                 /* Do not use this object */
 582                 else
 583                 {
 584                         /* Decline this object */
 585                         table[i].prob2 = 0;
 586                 }
 587         }
 588
 589         /* Success */
 590         return (0);
 591 }
 592
 593
 594 /*
 595  * Choose an object kind that seems "appropriate" to the given level
 596  *
 597  * This function uses the "prob2" field of the "object allocation table",
 598  * and various local information, to calculate the "prob3" field of the
 599  * same table, which is then used to choose an "appropriate" object, in
 600  * a relatively efficient manner.
 601  *
 602  * It is (slightly) more likely to acquire an object of the given level
 603  * than one of a lower level.  This is done by choosing several objects
 604  * appropriate to the given level and keeping the "hardest" one.
 605  *
 606  * Note that if no objects are "appropriate", then this function will
 607  * fail, and return zero, but this should *almost* never happen.
 608  */
 609 s16b get_obj_num(int level)
 610 {
 611         int             i, j, p;
 612         int             k_idx;
 613         long            value, total;
 614         object_kind     *k_ptr;
 615         alloc_entry     *table = alloc_kind_table;
 616
 617         if (level > MAX_DEPTH - 1) level = MAX_DEPTH - 1;
 618
 619         /* Boost level */
 620         if ((level > 0) && !(d_info[dungeon_type].flags1 & DF1_BEGINNER))
 621         {
 622                 /* Occasional "boost" */
 623                 if (one_in_(GREAT_OBJ))
 624                 {
 625                         /* What a bizarre calculation */
 626                         level = 1 + (level * MAX_DEPTH / randint1(MAX_DEPTH));
 627                 }
 628         }
 629
 630         /* Reset total */
 631         total = 0L;
 632
 633         /* Process probabilities */
 634         for (i = 0; i < alloc_kind_size; i++)
 635         {
 636                 /* Objects are sorted by depth */
 637                 if (table[i].level > level) break;
 638
 639                 /* Default */
 640                 table[i].prob3 = 0;
 641
 642                 /* Access the index */
 643                 k_idx = table[i].index;
 644
 645                 /* Access the actual kind */
 646                 k_ptr = &k_info[k_idx];
 647
 648                 /* Hack -- prevent embedded chests */
 649                 if (opening_chest && (k_ptr->tval == TV_CHEST)) continue;
 650
 651                 /* Accept */
 652                 table[i].prob3 = table[i].prob2;
 653
 654                 /* Total */
 655                 total += table[i].prob3;
 656         }
 657
 658         /* No legal objects */
 659         if (total <= 0) return (0);
 660
 661
 662         /* Pick an object */
 663         value = randint0(total);
 664
 665         /* Find the object */
 666         for (i = 0; i < alloc_kind_size; i++)
 667         {
 668                 /* Found the entry */
 669                 if (value < table[i].prob3) break;
 670
 671                 /* Decrement */
 672                 value = value - table[i].prob3;
 673         }
 674
 675
 676         /* Power boost */
 677         p = randint0(100);
 678
 679         /* Try for a "better" object once (50%) or twice (10%) */
 680         if (p < 60)
 681         {
 682                 /* Save old */
 683                 j = i;
 684
 685                 /* Pick a object */
 686                 value = randint0(total);
 687
 688                 /* Find the object */
 689                 for (i = 0; i < alloc_kind_size; i++)
 690                 {
 691                         /* Found the entry */
 692                         if (value < table[i].prob3) break;
 693
 694                         /* Decrement */
 695                         value = value - table[i].prob3;
 696                 }
 697
 698                 /* Keep the "best" one */
 699                 if (table[i].level < table[j].level) i = j;
 700         }
 701
 702         /* Try for a "better" object twice (10%) */
 703         if (p < 10)
 704         {
 705                 /* Save old */
 706                 j = i;
 707
 708                 /* Pick a object */
 709                 value = randint0(total);
 710
 711                 /* Find the object */
 712                 for (i = 0; i < alloc_kind_size; i++)
 713                 {
 714                         /* Found the entry */
 715                         if (value < table[i].prob3) break;
 716
 717                         /* Decrement */
 718                         value = value - table[i].prob3;
 719                 }
 720
 721                 /* Keep the "best" one */
 722                 if (table[i].level < table[j].level) i = j;
 723         }
 724
 725
 726         /* Result */
 727         return (table[i].index);
 728 }
 729
 730
 731 /*
 732  * Known is true when the "attributes" of an object are "known".
 733  * These include tohit, todam, toac, cost, and pval (charges).
 734  *
 735  * Note that "knowing" an object gives you everything that an "awareness"
 736  * gives you, and much more.  In fact, the player is always "aware" of any
 737  * item of which he has full "knowledge".
 738  *
 739  * But having full knowledge of, say, one "wand of wonder", does not, by
 740  * itself, give you knowledge, or even awareness, of other "wands of wonder".
 741  * It happens that most "identify" routines (including "buying from a shop")
 742  * will make the player "aware" of the object as well as fully "know" it.
 743  *
 744  * This routine also removes any inscriptions generated by "feelings".
 745  */
 746 void object_known(object_type *o_ptr)
 747 {
 748         /* Remove "default inscriptions" */
 749         o_ptr->feeling = FEEL_NONE;
 750
 751         /* Clear the "Felt" info */
 752         o_ptr->ident &= ~(IDENT_SENSE);
 753
 754         /* Clear the "Empty" info */
 755         o_ptr->ident &= ~(IDENT_EMPTY);
 756
 757         /* Now we know about the item */
 758         o_ptr->ident |= (IDENT_KNOWN);
 759 }
 760
 761
 762 /*
 763  * The player is now aware of the effects of the given object.
 764  */
 765 void object_aware(object_type *o_ptr)
 766 {
 767         bool mihanmei = !object_aware_p(o_ptr);
 768
 769 #ifndef SCRIPT_OBJ_KIND
 770         /* Fully aware of the effects */
 771         k_info[o_ptr->k_idx].aware = TRUE;
 772 #else /* SCRIPT_OBJ_KIND */
 773         /* Fully aware of the effects */
 774         o_ptr->aware = TRUE;
 775 #endif /* SCRIPT_OBJ_KIND */
 776
 777         if(mihanmei && !(k_info[o_ptr->k_idx].gen_flags & TRG_INSTA_ART) && record_ident &&
 778            !p_ptr->is_dead && ((o_ptr->tval >= TV_AMULET && o_ptr->tval <= TV_POTION) || (o_ptr->tval == TV_FOOD)))
 779         {
 780                 object_type forge;
 781                 object_type *q_ptr;
 782                 char o_name[MAX_NLEN];
 783
 784                 q_ptr = &forge;
 785                 object_copy(q_ptr, o_ptr);
 786
 787                 q_ptr->number = 1;
 788                 object_desc(o_name, q_ptr, TRUE, 0);
 789
 790                 do_cmd_write_nikki(NIKKI_HANMEI, 0, o_name);
 791         }
 792 }
 793
 794
 795 /*
 796  * Something has been "sampled"
 797  */
 798 void object_tried(object_type *o_ptr)
 799 {
 800 #ifndef SCRIPT_OBJ_KIND
 801         /* Mark it as tried (even if "aware") */
 802         k_info[o_ptr->k_idx].tried = TRUE;
 803 #else /* SCRIPT_OBJ_KIND */
 804         o_ptr->tried = TRUE;
 805 #endif /* SCRIPT_OBJ_KIND */
 806 }
 807
 808
 809 /*
 810  * Return the "value" of an "unknown" item
 811  * Make a guess at the value of non-aware items
 812  */
 813 static s32b object_value_base(object_type *o_ptr)
 814 {
 815         /* Aware item -- use template cost */
 816         if (object_aware_p(o_ptr)) return (get_object_cost(o_ptr));
 817
 818         /* Analyze the type */
 819         switch (o_ptr->tval)
 820         {
 821
 822                 /* Un-aware Food */
 823                 case TV_FOOD: return (5L);
 824
 825                 /* Un-aware Potions */
 826                 case TV_POTION: return (20L);
 827
 828                 /* Un-aware Scrolls */
 829                 case TV_SCROLL: return (20L);
 830
 831                 /* Un-aware Staffs */
 832                 case TV_STAFF: return (70L);
 833
 834                 /* Un-aware Wands */
 835                 case TV_WAND: return (50L);
 836
 837                 /* Un-aware Rods */
 838                 case TV_ROD: return (90L);
 839
 840                 /* Un-aware Rings */
 841                 case TV_RING: return (45L);
 842
 843                 /* Un-aware Amulets */
 844                 case TV_AMULET: return (45L);
 845
 846                 /* Figurines, relative to monster level */
 847                 case TV_FIGURINE:
 848                 {
 849                         int level = r_info[o_ptr->pval].level;
 850                         if (level < 20) return level*50L;
 851                         else if (level < 30) return 1000+(level-20)*150L;
 852                         else if (level < 40) return 2500+(level-30)*350L;
 853                         else if (level < 50) return 6000+(level-40)*800L;
 854                         else return 14000+(level-50)*2000L;
 855                         break;
 856                 }
 857
 858                 case TV_CAPTURE:
 859                         if (!o_ptr->pval) return 1000L;
 860                         else return ((r_info[o_ptr->pval].level) * 50L + 1000);
 861         }
 862
 863         /* Paranoia -- Oops */
 864         return (0L);
 865 }
 866
 867
 868 /* Return the value of the flags the object has... */
 869 s32b flag_cost(object_type * o_ptr, int plusses)
 870 {
 871         s32b total = 0;
 872         u32b flgs[TR_FLAG_SIZE];
 873         s32b tmp_cost;
 874         int count;
 875         int i;
 876
 877         object_flags(o_ptr, flgs);
 878
 879         if (o_ptr->name1)
 880         {
 881                 artifact_type *a_ptr = &a_info[o_ptr->name1];
 882
 883                 for (i = 0; i < TR_FLAG_SIZE; i++)
 884                         flgs[i] &= ~(a_ptr->flags[i]);
 885         }
 886         else
 887         {
 888                 if ((o_ptr->tval == TV_RING) || (o_ptr->tval == TV_AMULET))
 889                 {
 890                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
 891
 892                         for (i = 0; i < TR_FLAG_SIZE; i++)
 893                                 flgs[i] &= ~(k_ptr->flags[i]);
 894                 }
 895
 896                 if (o_ptr->name2)
 897                 {
 898                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
 899
 900                         for (i = 0; i < TR_FLAG_SIZE; i++)
 901                                 flgs[i] &= ~(e_ptr->flags[i]);
 902
 903                 }
 904                 else if (o_ptr->art_name)
 905                 {
 906                         total = 5000;
 907                 }
 908         }
 909
 910         if (have_flag(flgs, TR_STR)) total += (1500 * plusses);
 911         if (have_flag(flgs, TR_INT)) total += (1500 * plusses);
 912         if (have_flag(flgs, TR_WIS)) total += (1500 * plusses);
 913         if (have_flag(flgs, TR_DEX)) total += (1500 * plusses);
 914         if (have_flag(flgs, TR_CON)) total += (1500 * plusses);
 915         if (have_flag(flgs, TR_CHR)) total += (750 * plusses);
 916         if (have_flag(flgs, TR_MAGIC_MASTERY)) total += (600 * plusses);
 917         if (have_flag(flgs, TR_STEALTH)) total += (250 * plusses);
 918         if (have_flag(flgs, TR_SEARCH)) total += (100 * plusses);
 919         if (have_flag(flgs, TR_INFRA)) total += (150 * plusses);
 920         if (have_flag(flgs, TR_TUNNEL)) total += (175 * plusses);
 921         if ((have_flag(flgs, TR_SPEED)) && (plusses > 0))
 922                 total += (10000 + (2500 * plusses));
 923         if ((have_flag(flgs, TR_BLOWS)) && (plusses > 0))
 924                 total += (10000 + (2500 * plusses));
 925         if (have_flag(flgs, TR_DEC_MANA)) total += 10000;
 926
 927         tmp_cost = 0;
 928         count = 0;
 929         if (have_flag(flgs, TR_CHAOTIC)) {total += 5000;count++;}
 930         if (have_flag(flgs, TR_VAMPIRIC)) {total += 6500;count++;}
 931         if (have_flag(flgs, TR_FORCE_WEAPON)) {tmp_cost += 2500;count++;}
 932         if (have_flag(flgs, TR_KILL_ANIMAL)) {tmp_cost += 2800;count++;}
 933         else if (have_flag(flgs, TR_SLAY_ANIMAL)) {tmp_cost += 1800;count++;}
 934         if (have_flag(flgs, TR_KILL_EVIL)) {tmp_cost += 3300;count++;}
 935         else if (have_flag(flgs, TR_SLAY_EVIL)) {tmp_cost += 2300;count++;}
 936         if (have_flag(flgs, TR_KILL_HUMAN)) {tmp_cost += 2800;count++;}
 937         else if (have_flag(flgs, TR_SLAY_HUMAN)) {tmp_cost += 1800;count++;}
 938         if (have_flag(flgs, TR_KILL_UNDEAD)) {tmp_cost += 2800;count++;}
 939         else if (have_flag(flgs, TR_SLAY_UNDEAD)) {tmp_cost += 1800;count++;}
 940         if (have_flag(flgs, TR_KILL_DEMON)) {tmp_cost += 2800;count++;}
 941         else if (have_flag(flgs, TR_SLAY_DEMON)) {tmp_cost += 1800;count++;}
 942         if (have_flag(flgs, TR_KILL_ORC)) {tmp_cost += 2500;count++;}
 943         else if (have_flag(flgs, TR_SLAY_ORC)) {tmp_cost += 1500;count++;}
 944         if (have_flag(flgs, TR_KILL_TROLL)) {tmp_cost += 2800;count++;}
 945         else if (have_flag(flgs, TR_SLAY_TROLL)) {tmp_cost += 1800;count++;}
 946         if (have_flag(flgs, TR_KILL_GIANT)) {tmp_cost += 2800;count++;}
 947         else if (have_flag(flgs, TR_SLAY_GIANT)) {tmp_cost += 1800;count++;}
 948         if (have_flag(flgs, TR_KILL_DRAGON)) {tmp_cost += 2800;count++;}
 949         else if (have_flag(flgs, TR_SLAY_DRAGON)) {tmp_cost += 1800;count++;}
 950
 951         if (have_flag(flgs, TR_VORPAL)) {tmp_cost += 2500;count++;}
 952         if (have_flag(flgs, TR_IMPACT)) {tmp_cost += 2500;count++;}
 953         if (have_flag(flgs, TR_BRAND_POIS)) {tmp_cost += 3800;count++;}
 954         if (have_flag(flgs, TR_BRAND_ACID)) {tmp_cost += 3800;count++;}
 955         if (have_flag(flgs, TR_BRAND_ELEC)) {tmp_cost += 3800;count++;}
 956         if (have_flag(flgs, TR_BRAND_FIRE)) {tmp_cost += 2500;count++;}
 957         if (have_flag(flgs, TR_BRAND_COLD)) {tmp_cost += 2500;count++;}
 958         total += (tmp_cost * count);
 959
 960         if (have_flag(flgs, TR_SUST_STR)) total += 850;
 961         if (have_flag(flgs, TR_SUST_INT)) total += 850;
 962         if (have_flag(flgs, TR_SUST_WIS)) total += 850;
 963         if (have_flag(flgs, TR_SUST_DEX)) total += 850;
 964         if (have_flag(flgs, TR_SUST_CON)) total += 850;
 965         if (have_flag(flgs, TR_SUST_CHR)) total += 250;
 966         if (have_flag(flgs, TR_RIDING)) total += 0;
 967         if (have_flag(flgs, TR_EASY_SPELL)) total += 1500;
 968         if (have_flag(flgs, TR_THROW)) total += 5000;
 969         if (have_flag(flgs, TR_FREE_ACT)) total += 4500;
 970         if (have_flag(flgs, TR_HOLD_LIFE)) total += 8500;
 971
 972         tmp_cost = 0;
 973         count = 0;
 974         if (have_flag(flgs, TR_IM_ACID)) {tmp_cost += 15000;count += 2;}
 975         if (have_flag(flgs, TR_IM_ELEC)) {tmp_cost += 15000;count += 2;}
 976         if (have_flag(flgs, TR_IM_FIRE)) {tmp_cost += 15000;count += 2;}
 977         if (have_flag(flgs, TR_IM_COLD)) {tmp_cost += 15000;count += 2;}
 978         if (have_flag(flgs, TR_REFLECT)) {tmp_cost += 5000;count += 2;}
 979         if (have_flag(flgs, TR_RES_ACID)) {tmp_cost += 500;count++;}
 980         if (have_flag(flgs, TR_RES_ELEC)) {tmp_cost += 500;count++;}
 981         if (have_flag(flgs, TR_RES_FIRE)) {tmp_cost += 500;count++;}
 982         if (have_flag(flgs, TR_RES_COLD)) {tmp_cost += 500;count++;}
 983         if (have_flag(flgs, TR_RES_POIS)) {tmp_cost += 1000;count += 2;}
 984         if (have_flag(flgs, TR_RES_FEAR)) {tmp_cost += 1000;count += 2;}
 985         if (have_flag(flgs, TR_RES_LITE)) {tmp_cost += 800;count += 2;}
 986         if (have_flag(flgs, TR_RES_DARK)) {tmp_cost += 800;count += 2;}
 987         if (have_flag(flgs, TR_RES_BLIND)) {tmp_cost += 900;count += 2;}
 988         if (have_flag(flgs, TR_RES_CONF)) {tmp_cost += 900;count += 2;}
 989         if (have_flag(flgs, TR_RES_SOUND)) {tmp_cost += 900;count += 2;}
 990         if (have_flag(flgs, TR_RES_SHARDS)) {tmp_cost += 900;count += 2;}
 991         if (have_flag(flgs, TR_RES_NETHER)) {tmp_cost += 900;count += 2;}
 992         if (have_flag(flgs, TR_RES_NEXUS)) {tmp_cost += 900;count += 2;}
 993         if (have_flag(flgs, TR_RES_CHAOS)) {tmp_cost += 1000;count += 2;}
 994         if (have_flag(flgs, TR_RES_DISEN)) {tmp_cost += 2000;count += 2;}
 995         total += (tmp_cost * count);
 996
 997         if (have_flag(flgs, TR_SH_FIRE)) total += 5000;
 998         if (have_flag(flgs, TR_SH_ELEC)) total += 5000;
 999         if (have_flag(flgs, TR_SH_COLD)) total += 5000;
1000         if (have_flag(flgs, TR_NO_TELE)) total -= 10000;
1001         if (have_flag(flgs, TR_NO_MAGIC)) total += 2500;
1002         if (have_flag(flgs, TR_TY_CURSE)) total -= 15000;
1003         if (have_flag(flgs, TR_HIDE_TYPE)) total += 0;
1004         if (have_flag(flgs, TR_SHOW_MODS)) total += 0;
1005         if (have_flag(flgs, TR_FEATHER)) total += 1250;
1006         if (have_flag(flgs, TR_LITE)) total += 1250;
1007         if (have_flag(flgs, TR_SEE_INVIS)) total += 2000;
1008         if (have_flag(flgs, TR_TELEPATHY)) total += 20000;
1009         if (have_flag(flgs, TR_ESP_ANIMAL)) total += 1000;
1010         if (have_flag(flgs, TR_ESP_UNDEAD)) total += 1000;
1011         if (have_flag(flgs, TR_ESP_DEMON)) total += 1000;
1012         if (have_flag(flgs, TR_ESP_ORC)) total += 1000;
1013         if (have_flag(flgs, TR_ESP_TROLL)) total += 1000;
1014         if (have_flag(flgs, TR_ESP_GIANT)) total += 1000;
1015         if (have_flag(flgs, TR_ESP_DRAGON)) total += 1000;
1016         if (have_flag(flgs, TR_ESP_HUMAN)) total += 1000;
1017         if (have_flag(flgs, TR_ESP_EVIL)) total += 15000;
1018         if (have_flag(flgs, TR_ESP_GOOD)) total += 2000;
1019         if (have_flag(flgs, TR_ESP_NONLIVING)) total += 2000;
1020         if (have_flag(flgs, TR_ESP_UNIQUE)) total += 10000;
1021         if (have_flag(flgs, TR_SLOW_DIGEST)) total += 750;
1022         if (have_flag(flgs, TR_REGEN)) total += 2500;
1023         if (have_flag(flgs, TR_WARNING)) total += 2000;
1024         if (have_flag(flgs, TR_XTRA_MIGHT)) total += 2250;
1025         if (have_flag(flgs, TR_XTRA_SHOTS)) total += 10000;
1026         if (have_flag(flgs, TR_IGNORE_ACID)) total += 100;
1027         if (have_flag(flgs, TR_IGNORE_ELEC)) total += 100;
1028         if (have_flag(flgs, TR_IGNORE_FIRE)) total += 100;
1029         if (have_flag(flgs, TR_IGNORE_COLD)) total += 100;
1030         if (have_flag(flgs, TR_ACTIVATE)) total += 100;
1031         if (have_flag(flgs, TR_DRAIN_EXP)) total -= 12500;
1032         if (have_flag(flgs, TR_TELEPORT))
1033         {
1034                 if (cursed_p(o_ptr))
1035                         total -= 7500;
1036                 else
1037                         total += 250;
1038         }
1039         if (have_flag(flgs, TR_AGGRAVATE)) total -= 10000;
1040         if (have_flag(flgs, TR_BLESSED)) total += 750;
1041         if (o_ptr->curse_flags & TRC_CURSED) total -= 5000;
1042         if (o_ptr->curse_flags & TRC_HEAVY_CURSE) total -= 12500;
1043         if (o_ptr->curse_flags & TRC_PERMA_CURSE) total -= 15000;
1044
1045         /* Also, give some extra for activatable powers... */
1046         if (o_ptr->art_name && (have_flag(o_ptr->art_flags, TR_ACTIVATE)))
1047         {
1048                 int type = o_ptr->xtra2;
1049
1050                 if (type == ACT_SUNLIGHT) total += 250;
1051                 else if (type == ACT_BO_MISS_1) total += 250;
1052                 else if (type == ACT_BA_POIS_1) total += 300;
1053                 else if (type == ACT_BO_ELEC_1) total += 250;
1054                 else if (type == ACT_BO_ACID_1) total += 250;
1055                 else if (type == ACT_BO_COLD_1) total += 250;
1056                 else if (type == ACT_BO_FIRE_1) total += 250;
1057                 else if (type == ACT_BA_COLD_1) total += 750;
1058                 else if (type == ACT_BA_FIRE_1) total += 1000;
1059                 else if (type == ACT_DRAIN_1) total += 500;
1060                 else if (type == ACT_BA_COLD_2) total += 1250;
1061                 else if (type == ACT_BA_ELEC_2) total += 1500;
1062                 else if (type == ACT_DRAIN_2) total += 750;
1063                 else if (type == ACT_VAMPIRE_1) total += 1000;
1064                 else if (type == ACT_BO_MISS_2) total += 1000;
1065                 else if (type == ACT_BA_FIRE_2) total += 1750;
1066                 else if (type == ACT_BA_COLD_3) total += 2500;
1067                 else if (type == ACT_BA_ELEC_3) total += 2500;
1068                 else if (type == ACT_WHIRLWIND) total += 7500;
1069                 else if (type == ACT_VAMPIRE_2) total += 2500;
1070                 else if (type == ACT_CALL_CHAOS) total += 5000;
1071                 else if (type == ACT_ROCKET) total += 5000;
1072                 else if (type == ACT_DISP_EVIL) total += 4000;
1073                 else if (type == ACT_DISP_GOOD) total += 3500;
1074                 else if (type == ACT_BA_MISS_3) total += 5000;
1075                 else if (type == ACT_CONFUSE) total += 500;
1076                 else if (type == ACT_SLEEP) total += 750;
1077                 else if (type == ACT_QUAKE) total += 600;
1078                 else if (type == ACT_TERROR) total += 2500;
1079                 else if (type == ACT_TELE_AWAY) total += 2000;
1080                 else if (type == ACT_BANISH_EVIL) total += 2000;
1081                 else if (type == ACT_GENOCIDE) total += 10000;
1082                 else if (type == ACT_MASS_GENO) total += 10000;
1083                 else if (type == ACT_CHARM_ANIMAL) total += 7500;
1084                 else if (type == ACT_CHARM_UNDEAD) total += 10000;
1085                 else if (type == ACT_CHARM_OTHER) total += 10000;
1086                 else if (type == ACT_CHARM_ANIMALS) total += 12500;
1087                 else if (type == ACT_CHARM_OTHERS) total += 17500;
1088                 else if (type == ACT_SUMMON_ANIMAL) total += 10000;
1089                 else if (type == ACT_SUMMON_PHANTOM) total += 12000;
1090                 else if (type == ACT_SUMMON_ELEMENTAL) total += 15000;
1091                 else if (type == ACT_SUMMON_DEMON) total += 20000;
1092                 else if (type == ACT_SUMMON_UNDEAD) total += 20000;
1093                 else if (type == ACT_CURE_LW) total += 500;
1094                 else if (type == ACT_CURE_MW) total += 750;
1095                 else if (type == ACT_CURE_POISON) total += 1000;
1096                 else if (type == ACT_REST_LIFE) total += 7500;
1097                 else if (type == ACT_REST_ALL) total += 15000;
1098                 else if (type == ACT_CURE_700) total += 10000;
1099                 else if (type == ACT_CURE_1000) total += 15000;
1100                 else if (type == ACT_ESP) total += 1500;
1101                 else if (type == ACT_BERSERK) total += 800;
1102                 else if (type == ACT_PROT_EVIL) total += 5000;
1103                 else if (type == ACT_RESIST_ALL) total += 5000;
1104                 else if (type == ACT_SPEED) total += 15000;
1105                 else if (type == ACT_XTRA_SPEED) total += 25000;
1106                 else if (type == ACT_WRAITH) total += 25000;
1107                 else if (type == ACT_INVULN) total += 25000;
1108                 else if (type == ACT_LIGHT) total += 150;
1109                 else if (type == ACT_MAP_LIGHT) total += 500;
1110                 else if (type == ACT_DETECT_ALL) total += 1000;
1111                 else if (type == ACT_DETECT_XTRA) total += 12500;
1112                 else if (type == ACT_ID_FULL) total += 10000;
1113                 else if (type == ACT_ID_PLAIN) total += 1250;
1114                 else if (type == ACT_RUNE_EXPLO) total += 4000;
1115                 else if (type == ACT_RUNE_PROT) total += 10000;
1116                 else if (type == ACT_SATIATE) total += 2000;
1117                 else if (type == ACT_DEST_DOOR) total += 100;
1118                 else if (type == ACT_STONE_MUD) total += 1000;
1119                 else if (type == ACT_RECHARGE) total += 1000;
1120                 else if (type == ACT_ALCHEMY) total += 10000;
1121                 else if (type == ACT_DIM_DOOR) total += 10000;
1122                 else if (type == ACT_TELEPORT) total += 2000;
1123                 else if (type == ACT_RECALL) total += 7500;
1124         }
1125
1126         return total;
1127 }
1128
1129
1130 /*
1131  * Return the "real" price of a "known" item, not including discounts
1132  *
1133  * Wand and staffs get cost for each charge
1134  *
1135  * Armor is worth an extra 100 gold per bonus point to armor class.
1136  *
1137  * Weapons are worth an extra 100 gold per bonus point (AC,TH,TD).
1138  *
1139  * Missiles are only worth 5 gold per bonus point, since they
1140  * usually appear in groups of 20, and we want the player to get
1141  * the same amount of cash for any "equivalent" item.  Note that
1142  * missiles never have any of the "pval" flags, and in fact, they
1143  * only have a few of the available flags, primarily of the "slay"
1144  * and "brand" and "ignore" variety.
1145  *
1146  * Armor with a negative armor bonus is worthless.
1147  * Weapons with negative hit+damage bonuses are worthless.
1148  *
1149  * Every wearable item with a "pval" bonus is worth extra (see below).
1150  */
1151 s32b object_value_real(object_type *o_ptr)
1152 {
1153         s32b value;
1154
1155         u32b flgs[TR_FLAG_SIZE];
1156
1157         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1158
1159
1160         /* Hack -- "worthless" items */
1161         if (!get_object_cost(o_ptr)) return (0L);
1162
1163         /* Base cost */
1164         value = get_object_cost(o_ptr);
1165
1166         /* Extract some flags */
1167         object_flags(o_ptr, flgs);
1168
1169         /* Artifact */
1170         if (o_ptr->name1)
1171         {
1172                 artifact_type *a_ptr = &a_info[o_ptr->name1];
1173
1174                 /* Hack -- "worthless" artifacts */
1175                 if (!a_ptr->cost) return (0L);
1176
1177                 /* Hack -- Use the artifact cost instead */
1178                 value = a_ptr->cost;
1179                 value += flag_cost(o_ptr, o_ptr->pval);
1180                 return (value);
1181         }
1182
1183         /* Ego-Item */
1184         else if (o_ptr->name2)
1185         {
1186                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
1187
1188                 /* Hack -- "worthless" ego-items */
1189                 if (!e_ptr->cost) return (0L);
1190
1191                 /* Hack -- Reward the ego-item with a bonus */
1192                 value += e_ptr->cost;
1193                 value += flag_cost(o_ptr, o_ptr->pval);
1194         }
1195
1196         else
1197         {
1198                 int i;
1199                 bool flag = FALSE;
1200
1201                 for (i = 0; i < TR_FLAG_SIZE; i++)
1202                         if (o_ptr->art_flags[i]) flag = TRUE;
1203
1204                 if (flag) value += flag_cost(o_ptr, o_ptr->pval);
1205         }
1206
1207
1208         /* Analyze pval bonus */
1209         switch (o_ptr->tval)
1210         {
1211                 case TV_SHOT:
1212                 case TV_ARROW:
1213                 case TV_BOLT:
1214                 case TV_BOW:
1215                 case TV_DIGGING:
1216                 case TV_HAFTED:
1217                 case TV_POLEARM:
1218                 case TV_SWORD:
1219                 case TV_BOOTS:
1220                 case TV_GLOVES:
1221                 case TV_HELM:
1222                 case TV_CROWN:
1223                 case TV_SHIELD:
1224                 case TV_CLOAK:
1225                 case TV_SOFT_ARMOR:
1226                 case TV_HARD_ARMOR:
1227                 case TV_DRAG_ARMOR:
1228                 case TV_LITE:
1229                 case TV_AMULET:
1230                 case TV_RING:
1231                 {
1232                         /* Hack -- Negative "pval" is always bad */
1233                         if (o_ptr->pval < 0) return (0L);
1234
1235                         /* No pval */
1236                         if (!o_ptr->pval) break;
1237
1238                         /* Give credit for stat bonuses */
1239                         if (have_flag(flgs, TR_STR)) value += (o_ptr->pval * 200L);
1240                         if (have_flag(flgs, TR_INT)) value += (o_ptr->pval * 200L);
1241                         if (have_flag(flgs, TR_WIS)) value += (o_ptr->pval * 200L);
1242                         if (have_flag(flgs, TR_DEX)) value += (o_ptr->pval * 200L);
1243                         if (have_flag(flgs, TR_CON)) value += (o_ptr->pval * 200L);
1244                         if (have_flag(flgs, TR_CHR)) value += (o_ptr->pval * 200L);
1245
1246                         /* Give credit for stealth and searching */
1247                         if (have_flag(flgs, TR_MAGIC_MASTERY)) value += (o_ptr->pval * 100L);
1248                         if (have_flag(flgs, TR_STEALTH)) value += (o_ptr->pval * 100L);
1249                         if (have_flag(flgs, TR_SEARCH)) value += (o_ptr->pval * 100L);
1250
1251                         /* Give credit for infra-vision and tunneling */
1252                         if (have_flag(flgs, TR_INFRA)) value += (o_ptr->pval * 50L);
1253                         if (have_flag(flgs, TR_TUNNEL)) value += (o_ptr->pval * 50L);
1254
1255                         /* Give credit for extra attacks */
1256                         if (have_flag(flgs, TR_BLOWS)) value += (o_ptr->pval * 5000L);
1257
1258                         /* Give credit for speed bonus */
1259                         if (have_flag(flgs, TR_SPEED)) value += (o_ptr->pval * 10000L);
1260
1261                         break;
1262                 }
1263         }
1264
1265
1266         /* Analyze the item */
1267         switch (o_ptr->tval)
1268         {
1269                 /* Wands/Staffs */
1270                 case TV_WAND:
1271                 {
1272                         /* Pay extra for charges, depending on standard number of
1273                          * charges.  Handle new-style wands correctly. -LM-
1274                          */
1275                         value += (value * o_ptr->pval / o_ptr->number / (k_ptr->pval * 2));
1276
1277                         /* Done */
1278                         break;
1279                 }
1280                 case TV_STAFF:
1281                 {
1282                         /* Pay extra for charges, depending on standard number of
1283                          * charges.  -LM-
1284                          */
1285                         value += (value * o_ptr->pval / (k_ptr->pval * 2));
1286
1287                         /* Done */
1288                         break;
1289                 }
1290
1291                 /* Rings/Amulets */
1292                 case TV_RING:
1293                 case TV_AMULET:
1294                 {
1295                         /* Hack -- negative bonuses are bad */
1296                         if (o_ptr->to_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                                         /* gain one low ESP */
3583                                         add_esp_weak(o_ptr);
3584
3585                                         /* Boost the rating */
3586                                         rating += 15;
3587
3588                                         /* Mention the item */
3589                                         if (cheat_peek) object_mention(o_ptr);
3590
3591                                         break;
3592                                 }
3593
3594                                 /* Amulet of Doom -- always cursed */
3595                                 case SV_AMULET_DOOM:
3596                                 {
3597                                         /* Broken */
3598                                         o_ptr->ident |= (IDENT_BROKEN);
3599
3600                                         /* Cursed */
3601                                         o_ptr->curse_flags |= (TRC_CURSED);
3602
3603                                         /* Penalize */
3604                                         o_ptr->pval = 0 - (randint1(5) + m_bonus(5, level));
3605                                         o_ptr->to_a = 0 - (randint1(5) + m_bonus(5, level));
3606                                         if (power > 0) power = 0 - power;
3607
3608                                         break;
3609                                 }
3610
3611                                 case SV_AMULET_MAGIC_MASTERY:
3612                                 {
3613                                         o_ptr->pval = 1 + m_bonus(4, level);
3614
3615                                         /* Cursed */
3616                                         if (power < 0)
3617                                         {
3618                                                 /* Broken */
3619                                                 o_ptr->ident |= (IDENT_BROKEN);
3620
3621                                                 /* Cursed */
3622                                                 o_ptr->curse_flags |= (TRC_CURSED);
3623
3624                                                 /* Reverse bonuses */
3625                                                 o_ptr->pval = 0 - o_ptr->pval;
3626                                         }
3627
3628                                         break;
3629                                 }
3630                         }
3631                         if (one_in_(150) && (power > 0) && !cursed_p(o_ptr) && (level > 79))
3632                         {
3633                                 o_ptr->pval = MIN(o_ptr->pval,4);
3634                                 /* Randart amulet */
3635                                 create_artifact(o_ptr, FALSE);
3636                         }
3637                         else if ((power == 2) && one_in_(2))
3638                         {
3639                                 while(!o_ptr->name2)
3640                                 {
3641                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3642                                         switch(randint1(21))
3643                                         {
3644                                         case 1: case 2:
3645                                                 if (have_flag(k_ptr->flags, TR_SLOW_DIGEST)) break;
3646                                                 o_ptr->name2 = EGO_AMU_SLOW_D;
3647                                                 break;
3648                                         case 3: case 4:
3649                                                 if (o_ptr->pval) break;
3650                                                 o_ptr->name2 = EGO_AMU_INFRA;
3651                                                 break;
3652                                         case 5: case 6:
3653                                                 if (have_flag(k_ptr->flags, TR_SEE_INVIS)) break;
3654                                                 o_ptr->name2 = EGO_AMU_SEE_INVIS;
3655                                                 break;
3656                                         case 7: case 8:
3657                                                 if (have_flag(k_ptr->flags, TR_HOLD_LIFE)) break;
3658                                                 o_ptr->name2 = EGO_AMU_HOLD_LIFE;
3659                                                 break;
3660                                         case 9:
3661                                                 if (have_flag(k_ptr->flags, TR_FEATHER)) break;
3662                                                 o_ptr->name2 = EGO_AMU_LEVITATION;
3663                                                 break;
3664                                         case 10: case 11: case 21:
3665                                                 o_ptr->name2 = EGO_AMU_AC;
3666                                                 break;
3667                                         case 12:
3668                                                 if (have_flag(k_ptr->flags, TR_RES_FIRE)) break;
3669                                                 if (m_bonus(10, level) > 8)
3670                                                         o_ptr->name2 = EGO_AMU_RES_FIRE_;
3671                                                 else
3672                                                         o_ptr->name2 = EGO_AMU_RES_FIRE;
3673                                                 break;
3674                                         case 13:
3675                                                 if (have_flag(k_ptr->flags, TR_RES_COLD)) break;
3676                                                 if (m_bonus(10, level) > 8)
3677                                                         o_ptr->name2 = EGO_AMU_RES_COLD_;
3678                                                 else
3679                                                         o_ptr->name2 = EGO_AMU_RES_COLD;
3680                                                 break;
3681                                         case 14:
3682                                                 if (have_flag(k_ptr->flags, TR_RES_ELEC)) break;
3683                                                 if (m_bonus(10, level) > 8)
3684                                                         o_ptr->name2 = EGO_AMU_RES_ELEC_;
3685                                                 else
3686                                                         o_ptr->name2 = EGO_AMU_RES_ELEC;
3687                                                 break;
3688                                         case 15:
3689                                                 if (have_flag(k_ptr->flags, TR_RES_ACID)) break;
3690                                                 if (m_bonus(10, level) > 8)
3691                                                         o_ptr->name2 = EGO_AMU_RES_ACID_;
3692                                                 else
3693                                                         o_ptr->name2 = EGO_AMU_RES_ACID;
3694                                                 break;
3695                                         case 16: case 17: case 18: case 19: case 20:
3696                                                 switch (o_ptr->sval)
3697                                                 {
3698                                                 case SV_AMULET_TELEPORT:
3699                                                         if (m_bonus(10, level) > 9) o_ptr->name2 = EGO_AMU_D_DOOR;
3700                                                         else if (one_in_(2)) o_ptr->name2 = EGO_AMU_JUMP;
3701                                                         else o_ptr->name2 = EGO_AMU_TELEPORT;
3702                                                         break;
3703                                                 case SV_AMULET_RESIST_ACID:
3704                                                         if ((m_bonus(10, level) > 6) && one_in_(2)) o_ptr->name2 = EGO_AMU_RES_ACID_;
3705                                                         break;
3706                                                 case SV_AMULET_SEARCHING:
3707                                                         o_ptr->name2 = EGO_AMU_STEALTH;
3708                                                         break;
3709                                                 case SV_AMULET_BRILLIANCE:
3710                                                         if (!one_in_(3)) break;
3711                                                         o_ptr->name2 = EGO_AMU_IDENT;
3712                                                         break;
3713                                                 case SV_AMULET_CHARISMA:
3714                                                         if (!one_in_(3)) break;
3715                                                         o_ptr->name2 = EGO_AMU_CHARM;
3716                                                         break;
3717                                                 case SV_AMULET_THE_MAGI:
3718                                                         if (one_in_(2)) break;
3719                                                         o_ptr->name2 = EGO_AMU_GREAT;
3720                                                         break;
3721                                                 case SV_AMULET_RESISTANCE:
3722                                                         if (!one_in_(5)) break;
3723                                                         o_ptr->name2 = EGO_AMU_DEFENDER;
3724                                                         break;
3725                                                 case SV_AMULET_TELEPATHY:
3726                                                         if (!one_in_(3)) break;
3727                                                         o_ptr->name2 = EGO_AMU_DETECTION;
3728                                                         break;
3729                                                 }
3730                                         }
3731                                 }
3732                                 /* Uncurse it */
3733                                 o_ptr->curse_flags = 0L;
3734                         }
3735                         else if ((power == -2) && one_in_(2))
3736                         {
3737                                 if (o_ptr->to_h > 0) o_ptr->to_h = 0-o_ptr->to_h;
3738                                 if (o_ptr->to_d > 0) o_ptr->to_d = 0-o_ptr->to_d;
3739                                 if (o_ptr->to_a > 0) o_ptr->to_a = 0-o_ptr->to_a;
3740                                 if (o_ptr->pval > 0) o_ptr->pval = 0-o_ptr->pval;
3741                                 o_ptr->art_flags[0] = 0;
3742                                 o_ptr->art_flags[1] = 0;
3743                                 while(!o_ptr->name2)
3744                                 {
3745                                         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3746                                         switch(randint1(5))
3747                                         {
3748                                         case 1:
3749                                                 if (have_flag(k_ptr->flags, TR_DRAIN_EXP)) break;
3750                                                 o_ptr->name2 = EGO_AMU_DRAIN_EXP;
3751                                                 break;
3752                                         case 2:
3753                                                 o_ptr->name2 = EGO_AMU_FOOL;
3754                                                 break;
3755                                         case 3:
3756                                                 if (have_flag(k_ptr->flags, TR_AGGRAVATE)) break;
3757                                                 o_ptr->name2 = EGO_AMU_AGGRAVATE;
3758                                                 break;
3759                                         case 4:
3760                                                 if (have_flag(k_ptr->flags, TR_TY_CURSE)) break;
3761                                                 o_ptr->name2 = EGO_AMU_TY_CURSE;
3762                                                 break;
3763                                         case 5:
3764                                                 o_ptr->name2 = EGO_AMU_NAIVETY;
3765                                                 break;
3766                                         }
3767                                 }
3768                                 /* Broken */
3769                                 o_ptr->ident |= (IDENT_BROKEN);
3770
3771                                 /* Cursed */
3772                                 o_ptr->curse_flags |= (TRC_CURSED | TRC_HEAVY_CURSE);
3773                         }
3774                         break;
3775                 }
3776         }
3777 }
3778
3779
3780 /*
3781  * Hack -- help pick an item type
3782  */
3783 static bool item_monster_okay(int r_idx)
3784 {
3785         monster_race *r_ptr = &r_info[r_idx];
3786
3787         /* No uniques */
3788         if (r_ptr->flags1 & RF1_UNIQUE) return (FALSE);
3789         if (r_ptr->flags7 & RF7_KAGE) return (FALSE);
3790         if (r_ptr->flags3 & RF3_RES_ALL) return (FALSE);
3791         if (r_ptr->flags7 & RF7_UNIQUE_7) return (FALSE);
3792         if (r_ptr->flags1 & RF1_FORCE_DEPTH) return (FALSE);
3793         if (r_ptr->flags7 & RF7_UNIQUE2) return (FALSE);
3794
3795         /* Okay */
3796         return (TRUE);
3797 }
3798
3799
3800 /*
3801  * Apply magic to an item known to be "boring"
3802  *
3803  * Hack -- note the special code for various items
3804  */
3805 static void a_m_aux_4(object_type *o_ptr, int level, int power)
3806 {
3807         object_kind *k_ptr = &k_info[o_ptr->k_idx];
3808
3809         /* Apply magic (good or bad) according to type */
3810         switch (o_ptr->tval)
3811         {
3812                 case TV_WHISTLE:
3813                 {
3814 #if 0
3815                         /* Cursed */
3816                         if (power < 0)
3817                         {
3818                                 /* Broken */
3819                                 o_ptr->ident |= (IDENT_BROKEN);
3820
3821                                 /* Cursed */
3822                                 o_ptr->curse_flags |= (TRC_CURSED);
3823                         }
3824 #endif
3825                         break;
3826                 }
3827                 case TV_FLASK:
3828                 {
3829                         o_ptr->xtra4 = o_ptr->pval;
3830                         o_ptr->pval = 0;
3831                         break;
3832                 }
3833                 case TV_LITE:
3834                 {
3835                         /* Hack -- Torches -- random fuel */
3836                         if (o_ptr->sval == SV_LITE_TORCH)
3837                         {
3838                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3839                                 o_ptr->pval = 0;
3840                         }
3841
3842                         /* Hack -- Lanterns -- random fuel */
3843                         if (o_ptr->sval == SV_LITE_LANTERN)
3844                         {
3845                                 if (o_ptr->pval > 0) o_ptr->xtra4 = randint1(o_ptr->pval);
3846                                 o_ptr->pval = 0;
3847                         }
3848
3849                         if ((power == 2) || ((power == 1) && one_in_(3)))
3850                         {
3851                                 while (!o_ptr->name2)
3852                                 {
3853                                         while (1)
3854                                         {
3855                                                 bool okay_flag = TRUE;
3856
3857                                                 o_ptr->name2 = get_random_ego(INVEN_LITE, TRUE, level);
3858
3859                                                 switch (o_ptr->name2)
3860                                                 {
3861                                                 case EGO_LITE_LONG:
3862                                                         if (o_ptr->sval == SV_LITE_FEANOR)
3863                                                                 okay_flag = FALSE;
3864                                                 }
3865                                                 if (okay_flag)
3866                                                         break;
3867                                         }
3868                                 }
3869                         }
3870                         else if (power == -2)
3871                         {
3872                                 o_ptr->name2 = get_random_ego(INVEN_LITE, FALSE, level);
3873
3874                                 switch (o_ptr->name2)
3875                                 {
3876                                 case EGO_LITE_DARKNESS:
3877                                         o_ptr->xtra4 = 0;
3878                                         break;
3879                                 }
3880                         }
3881
3882                         break;
3883                 }
3884
3885                 case TV_WAND:
3886                 case TV_STAFF:
3887                 {
3888                         /* The wand or staff gets a number of initial charges equal
3889                          * to between 1/2 (+1) and the full object kind's pval. -LM-
3890                          */
3891                         o_ptr->pval = k_ptr->pval / 2 + randint1((k_ptr->pval + 1) / 2);
3892                         break;
3893                 }
3894
3895                 case TV_ROD:
3896                 {
3897                         /* Transfer the pval. -LM- */
3898                         o_ptr->pval = k_ptr->pval;
3899                         break;
3900                 }
3901
3902                 case TV_CAPTURE:
3903                 {
3904                         o_ptr->pval = 0;
3905                         object_aware(o_ptr);
3906                         object_known(o_ptr);
3907                         break;
3908                 }
3909
3910                 case TV_FIGURINE:
3911                 {
3912                         int i = 1;
3913                         int check;
3914
3915                         monster_race *r_ptr;
3916
3917                         /* Pick a random non-unique monster race */
3918                         while (1)
3919                         {
3920                                 i = randint1(max_r_idx - 1);
3921
3922                                 if (!item_monster_okay(i)) continue;
3923                                 if (i == MON_TSUCHINOKO) continue;
3924
3925                                 r_ptr = &r_info[i];
3926
3927                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
3928
3929                                 /* Ignore dead monsters */
3930                                 if (!r_ptr->rarity) continue;
3931
3932                                 /* Prefer less out-of-depth monsters */
3933                                 if (randint0(check)) continue;
3934
3935                                 break;
3936                         }
3937
3938                         o_ptr->pval = i;
3939
3940                         /* Some figurines are cursed */
3941                         if (one_in_(6)) o_ptr->curse_flags |= TRC_CURSED;
3942
3943                         if (cheat_peek)
3944                         {
3945 #ifdef JP
3946                                 msg_format("%s¤Î¿Í·Á, ¿¼¤µ +%d%s",
3947 #else
3948                                 msg_format("Figurine of %s, depth +%d%s",
3949 #endif
3950
3951                                                           r_name + r_ptr->name, check - 1,
3952                                                           !cursed_p(o_ptr) ? "" : " {cursed}");
3953                         }
3954
3955                         break;
3956                 }
3957
3958                 case TV_CORPSE:
3959                 {
3960                         int i = 1;
3961                         int check;
3962
3963                         u32b match = 0;
3964
3965                         monster_race *r_ptr;
3966
3967                         if (o_ptr->sval == SV_SKELETON)
3968                         {
3969                                 match = RF9_DROP_SKELETON;
3970                         }
3971                         else if (o_ptr->sval == SV_CORPSE)
3972                         {
3973                                 match = RF9_DROP_CORPSE;
3974                         }
3975
3976                         /* Hack -- Remove the monster restriction */
3977                         get_mon_num_prep(item_monster_okay, NULL);
3978
3979                         /* Pick a random non-unique monster race */
3980                         while (1)
3981                         {
3982                                 i = get_mon_num(dun_level);
3983
3984                                 r_ptr = &r_info[i];
3985
3986                                 check = (dun_level < r_ptr->level) ? (r_ptr->level - dun_level) : 0;
3987
3988                                 /* Ignore dead monsters */
3989                                 if (!r_ptr->rarity) continue;
3990
3991                                 /* Ignore corpseless monsters */
3992                                 if (!(r_ptr->flags9 & match)) continue;
3993
3994                                 /* Prefer less out-of-depth monsters */
3995                                 if (randint0(check)) continue;
3996
3997                                 break;
3998                         }
3999
4000                         o_ptr->pval = i;
4001
4002                         if (cheat_peek)
4003                         {
4004 #ifdef JP
4005                                 msg_format("%s¤Î»àÂÎ,¿¼¤µ +%d",
4006 #else
4007                                 msg_format("Corpse of %s, depth +%d",
4008 #endif
4009
4010                                                           r_name + r_ptr->name, check - 1);
4011                         }
4012
4013                         object_aware(o_ptr);
4014                         object_known(o_ptr);
4015                         break;
4016                 }
4017
4018                 case TV_STATUE:
4019                 {
4020                         int i = 1;
4021
4022                         monster_race *r_ptr;
4023
4024                         /* Pick a random monster race */
4025                         while (1)
4026                         {
4027                                 i = randint1(max_r_idx - 1);
4028
4029                                 r_ptr = &r_info[i];
4030
4031                                 /* Ignore dead monsters */
4032                                 if (!r_ptr->rarity) continue;
4033
4034                                 break;
4035                         }
4036
4037                         o_ptr->pval = i;
4038
4039                         if (cheat_peek)
4040                         {
4041 #ifdef JP
4042                                 msg_format("%s¤ÎÁü,", r_name + r_ptr->name);
4043 #else
4044                                 msg_format("Statue of %s", r_name + r_ptr->name);
4045 #endif
4046
4047                         }
4048                         object_aware(o_ptr);
4049                         object_known(o_ptr);
4050
4051                         break;
4052                 }
4053
4054                 case TV_CHEST:
4055                 {
4056                         byte obj_level = get_object_level(o_ptr);
4057
4058                         /* Hack -- skip ruined chests */
4059                         if (obj_level <= 0) break;
4060
4061                         /* Hack -- pick a "difficulty" */
4062                         o_ptr->pval = randint1(obj_level);
4063                         if (o_ptr->sval == SV_CHEST_KANDUME) o_ptr->pval = 6;
4064
4065                         o_ptr->xtra3 = dun_level + 5;
4066
4067                         /* Never exceed "difficulty" of 55 to 59 */
4068                         if (o_ptr->pval > 55) o_ptr->pval = 55 + (byte)randint0(5);
4069
4070                         break;
4071                 }
4072         }
4073 }
4074
4075
4076 /*
4077  * Complete the "creation" of an object by applying "magic" to the item
4078  *
4079  * This includes not only rolling for random bonuses, but also putting the
4080  * finishing touches on ego-items and artifacts, giving charges to wands and
4081  * staffs, giving fuel to lites, and placing traps on chests.
4082  *
4083  * In particular, note that "Instant Artifacts", if "created" by an external
4084  * routine, must pass through this function to complete the actual creation.
4085  *
4086  * The base "chance" of the item being "good" increases with the "level"
4087  * parameter, which is usually derived from the dungeon level, being equal
4088  * to the level plus 10, up to a maximum of 75.  If "good" is true, then
4089  * the object is guaranteed to be "good".  If an object is "good", then
4090  * the chance that the object will be "great" (ego-item or artifact), also
4091  * increases with the "level", being equal to half the level, plus 5, up to
4092  * a maximum of 20.  If "great" is true, then the object is guaranteed to be
4093  * "great".  At dungeon level 65 and below, 15/100 objects are "great".
4094  *
4095  * If the object is not "good", there is a chance it will be "cursed", and
4096  * if it is "cursed", there is a chance it will be "broken".  These chances
4097  * are related to the "good" / "great" chances above.
4098  *
4099  * Otherwise "normal" rings and amulets will be "good" half the time and
4100  * "cursed" half the time, unless the ring/amulet is always good or cursed.
4101  *
4102  * If "okay" is true, and the object is going to be "great", then there is
4103  * a chance that an artifact will be created.  This is true even if both the
4104  * "good" and "great" arguments are false.  As a total hack, if "great" is
4105  * true, then the item gets 3 extra "attempts" to become an artifact.
4106  */
4107 void apply_magic(object_type *o_ptr, int lev, bool okay, bool good, bool great, bool curse)
4108 {
4109
4110         int i, rolls, f1, f2, power;
4111
4112         if (p_ptr->pseikaku == SEIKAKU_MUNCHKIN) lev += randint0(p_ptr->lev/2+10);
4113
4114         /* Maximum "level" for various things */
4115         if (lev > MAX_DEPTH - 1) lev = MAX_DEPTH - 1;
4116
4117         /* Base chance of being "good" */
4118         f1 = lev + 10;
4119
4120         /* Maximal chance of being "good" */
4121         if (f1 > d_info[dungeon_type].obj_good) f1 = d_info[dungeon_type].obj_good;
4122
4123         /* Base chance of being "great" */
4124         f2 = f1 / 2;
4125
4126         /* Maximal chance of being "great" */
4127         if ((p_ptr->pseikaku != SEIKAKU_MUNCHKIN) && (f2 > d_info[dungeon_type].obj_great))
4128                 f2 = d_info[dungeon_type].obj_great;
4129
4130         if (p_ptr->muta3 & MUT3_GOOD_LUCK)
4131         {
4132                 f1 += 5;
4133                 f2 += 2;
4134         }
4135         else if(p_ptr->muta3 & MUT3_BAD_LUCK)
4136         {
4137                 f1 -= 5;
4138                 f2 -= 2;
4139         }
4140
4141         /* Assume normal */
4142         power = 0;
4143
4144         /* Roll for "good" */
4145         if (good || magik(f1))
4146         {
4147                 /* Assume "good" */
4148                 power = 1;
4149
4150                 /* Roll for "great" */
4151                 if (great || magik(f2)) power = 2;
4152         }
4153
4154         /* Roll for "cursed" */
4155         else if (magik(f1))
4156         {
4157                 /* Assume "cursed" */
4158                 power = -1;
4159
4160                 /* Roll for "broken" */
4161                 if (magik(f2)) power = -2;
4162         }
4163
4164         /* Apply curse */
4165         if (curse)
4166         {
4167                 /* Assume 'cursed' */
4168                 if (power > 0)
4169                 {
4170                         power = 0 - power;
4171                 }
4172                 /* Everything else gets more badly cursed */
4173                 else
4174                 {
4175                         power--;
4176                 }
4177         }
4178
4179         /* Assume no rolls */
4180         rolls = 0;
4181
4182         /* Get one roll if excellent */
4183         if (power >= 2) rolls = 1;
4184
4185         /* Hack -- Get four rolls if forced great */
4186         if (great) rolls = 4;
4187
4188         /* Hack -- Get no rolls if not allowed */
4189         if (!okay || o_ptr->name1) rolls = 0;
4190
4191         /* Roll for artifacts if allowed */
4192         for (i = 0; i < rolls; i++)
4193         {
4194                 /* Roll for an artifact */
4195                 if (make_artifact(o_ptr)) break;
4196                 if ((p_ptr->muta3 & MUT3_GOOD_LUCK) && one_in_(77))
4197                 {
4198                         if (make_artifact(o_ptr)) break;
4199                 }
4200         }
4201
4202
4203         /* Hack -- analyze artifacts */
4204         if (o_ptr->name1)
4205         {
4206                 artifact_type *a_ptr = &a_info[o_ptr->name1];
4207
4208                 /* Hack -- Mark the artifact as "created" */
4209                 a_ptr->cur_num = 1;
4210
4211                 /* Extract the other fields */
4212                 o_ptr->pval = a_ptr->pval;
4213                 o_ptr->ac = a_ptr->ac;
4214                 o_ptr->dd = a_ptr->dd;
4215                 o_ptr->ds = a_ptr->ds;
4216                 o_ptr->to_a = a_ptr->to_a;
4217                 o_ptr->to_h = a_ptr->to_h;
4218                 o_ptr->to_d = a_ptr->to_d;
4219                 o_ptr->weight = a_ptr->weight;
4220
4221                 /* Hack -- extract the "broken" flag */
4222                 if (!a_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4223
4224                 /* Hack -- extract the "cursed" flag */
4225                 if (a_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4226                 if (a_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4227                 if (a_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4228                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4229                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4230                 if (a_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4231
4232                 /* Mega-Hack -- increase the rating */
4233                 rating += 10;
4234
4235                 /* Mega-Hack -- increase the rating again */
4236                 if (a_ptr->cost > 50000L) rating += 10;
4237
4238                 /* Mega-Hack -- increase the rating again */
4239                 if (a_ptr->cost > 100000L) rating += 10;
4240
4241                 /* Set the good item flag */
4242                 good_item_flag = TRUE;
4243
4244                 /* Cheat -- peek at the item */
4245                 if (cheat_peek) object_mention(o_ptr);
4246
4247                 /* Done */
4248                 return;
4249         }
4250
4251
4252         /* Apply magic */
4253         switch (o_ptr->tval)
4254         {
4255                 case TV_DIGGING:
4256                 case TV_HAFTED:
4257                 case TV_BOW:
4258                 case TV_SHOT:
4259                 case TV_ARROW:
4260                 case TV_BOLT:
4261                 {
4262                         if (power) a_m_aux_1(o_ptr, lev, power);
4263                         break;
4264                 }
4265
4266                 case TV_POLEARM:
4267                 {
4268                         if (power && !(o_ptr->sval == SV_DEATH_SCYTHE)) a_m_aux_1(o_ptr, lev, power);
4269                         break;
4270                 }
4271
4272                 case TV_SWORD:
4273                 {
4274                         if (power && !(o_ptr->sval == SV_DOKUBARI)) a_m_aux_1(o_ptr, lev, power);
4275                         break;
4276                 }
4277
4278                 case TV_DRAG_ARMOR:
4279                 case TV_HARD_ARMOR:
4280                 case TV_SOFT_ARMOR:
4281                 case TV_SHIELD:
4282                 case TV_HELM:
4283                 case TV_CROWN:
4284                 case TV_CLOAK:
4285                 case TV_GLOVES:
4286                 case TV_BOOTS:
4287                 {
4288                         /* Elven Cloak and Black Clothes ... */
4289                         if (((o_ptr->tval == TV_CLOAK) && (o_ptr->sval == SV_ELVEN_CLOAK)) ||
4290                             ((o_ptr->tval == TV_SOFT_ARMOR) && (o_ptr->sval == SV_KUROSHOUZOKU)))
4291                                 o_ptr->pval = randint1(4);
4292
4293 #if 1
4294                         if (power ||
4295                              ((o_ptr->tval == TV_HELM) && (o_ptr->sval == SV_DRAGON_HELM)) ||
4296                              ((o_ptr->tval == TV_SHIELD) && (o_ptr->sval == SV_DRAGON_SHIELD)) ||
4297                              ((o_ptr->tval == TV_GLOVES) && (o_ptr->sval == SV_SET_OF_DRAGON_GLOVES)) ||
4298                              ((o_ptr->tval == TV_BOOTS) && (o_ptr->sval == SV_PAIR_OF_DRAGON_GREAVE)))
4299                                 a_m_aux_2(o_ptr, lev, power);
4300 #else
4301                         if (power) a_m_aux_2(o_ptr, lev, power);
4302 #endif
4303                         break;
4304                 }
4305
4306                 case TV_RING:
4307                 case TV_AMULET:
4308                 {
4309                         if (!power && (randint0(100) < 50)) power = -1;
4310                         a_m_aux_3(o_ptr, lev, power);
4311                         break;
4312                 }
4313
4314                 default:
4315                 {
4316                         a_m_aux_4(o_ptr, lev, power);
4317                         break;
4318                 }
4319         }
4320
4321         if ((o_ptr->tval == TV_SOFT_ARMOR) &&
4322             (o_ptr->sval == SV_ABUNAI_MIZUGI) &&
4323             (p_ptr->pseikaku == SEIKAKU_SEXY))
4324         {
4325                 o_ptr->pval = 3;
4326                 add_flag(o_ptr->art_flags, TR_STR);
4327                 add_flag(o_ptr->art_flags, TR_INT);
4328                 add_flag(o_ptr->art_flags, TR_WIS);
4329                 add_flag(o_ptr->art_flags, TR_DEX);
4330                 add_flag(o_ptr->art_flags, TR_CON);
4331                 add_flag(o_ptr->art_flags, TR_CHR);
4332         }
4333
4334         if (o_ptr->art_name) rating += 30;
4335
4336         /* Hack -- analyze ego-items */
4337         else if (o_ptr->name2)
4338         {
4339                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
4340
4341                 /* Hack -- acquire "broken" flag */
4342                 if (!e_ptr->cost) o_ptr->ident |= (IDENT_BROKEN);
4343
4344                 /* Hack -- acquire "cursed" flag */
4345                 if (e_ptr->gen_flags & TRG_CURSED) o_ptr->curse_flags |= (TRC_CURSED);
4346                 if (e_ptr->gen_flags & TRG_HEAVY_CURSE) o_ptr->curse_flags |= (TRC_HEAVY_CURSE);
4347                 if (e_ptr->gen_flags & TRG_PERMA_CURSE) o_ptr->curse_flags |= (TRC_PERMA_CURSE);
4348                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4349                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4350                 if (e_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4351
4352                 if (e_ptr->gen_flags & (TRG_ONE_SUSTAIN)) one_sustain(o_ptr);
4353                 if (e_ptr->gen_flags & (TRG_XTRA_POWER)) one_ability(o_ptr);
4354                 if (e_ptr->gen_flags & (TRG_XTRA_H_RES)) one_high_resistance(o_ptr);
4355                 if (e_ptr->gen_flags & (TRG_XTRA_E_RES)) one_ele_resistance(o_ptr);
4356                 if (e_ptr->gen_flags & (TRG_XTRA_D_RES)) one_dragon_ele_resistance(o_ptr);
4357                 if (e_ptr->gen_flags & (TRG_XTRA_L_RES)) one_lordly_high_resistance(o_ptr);
4358                 if (e_ptr->gen_flags & (TRG_XTRA_RES)) one_resistance(o_ptr);
4359
4360                 /* Hack -- apply extra penalties if needed */
4361                 if (cursed_p(o_ptr) || broken_p(o_ptr))
4362                 {
4363                         /* Hack -- obtain bonuses */
4364                         if (e_ptr->max_to_h) o_ptr->to_h -= randint1(e_ptr->max_to_h);
4365                         if (e_ptr->max_to_d) o_ptr->to_d -= randint1(e_ptr->max_to_d);
4366                         if (e_ptr->max_to_a) o_ptr->to_a -= randint1(e_ptr->max_to_a);
4367
4368                         /* Hack -- obtain pval */
4369                         if (e_ptr->max_pval) o_ptr->pval -= randint1(e_ptr->max_pval);
4370                 }
4371
4372                 /* Hack -- apply extra bonuses if needed */
4373                 else
4374                 {
4375                         /* Hack -- obtain bonuses */
4376                         if (e_ptr->max_to_h)
4377                         {
4378                                 if (e_ptr->max_to_h > 127)
4379                                         o_ptr->to_h -= randint1(256-e_ptr->max_to_h);
4380                                 else o_ptr->to_h += randint1(e_ptr->max_to_h);
4381                         }
4382                         if (e_ptr->max_to_d)
4383                         {
4384                                 if (e_ptr->max_to_d > 127)
4385                                         o_ptr->to_d -= randint1(256-e_ptr->max_to_d);
4386                                 else o_ptr->to_d += randint1(e_ptr->max_to_d);
4387                         }
4388                         if (e_ptr->max_to_a)
4389                         {
4390                                 if (e_ptr->max_to_a > 127)
4391                                         o_ptr->to_a -= randint1(256-e_ptr->max_to_a);
4392                                 else o_ptr->to_a += randint1(e_ptr->max_to_a);
4393                         }
4394
4395                         /* Hack -- obtain pval */
4396                         if (e_ptr->max_pval)
4397                         {
4398                                 if ((o_ptr->name2 == EGO_HA) && (have_flag(o_ptr->art_flags, TR_BLOWS)))
4399                                 {
4400                                         o_ptr->pval++;
4401                                         if ((lev > 60) && one_in_(3) && ((o_ptr->dd*(o_ptr->ds+1)) < 15)) o_ptr->pval++;
4402                                 }
4403                                 else if (o_ptr->name2 == EGO_ATTACKS)
4404                                 {
4405                                         o_ptr->pval = randint1(e_ptr->max_pval*lev/100+1);
4406                                         if (o_ptr->pval > 3) o_ptr->pval = 3;
4407                                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA))
4408                                                 o_ptr->pval += randint1(2);
4409                                 }
4410                                 else if (o_ptr->name2 == EGO_BAT)
4411                                 {
4412                                         o_ptr->pval = randint1(e_ptr->max_pval);
4413                                         if (o_ptr->sval == SV_ELVEN_CLOAK) o_ptr->pval += randint1(2);
4414                                 }
4415                                 else
4416                                 {
4417                                         o_ptr->pval += randint1(e_ptr->max_pval);
4418                                 }
4419                         }
4420                         if ((o_ptr->name2 == EGO_SPEED) && (lev < 50))
4421                         {
4422                                 o_ptr->pval = randint1(o_ptr->pval);
4423                         }
4424                         if ((o_ptr->tval == TV_SWORD) && (o_ptr->sval == SV_HAYABUSA) && (o_ptr->pval > 2) && (o_ptr->name2 != EGO_ATTACKS))
4425                                 o_ptr->pval = 2;
4426                 }
4427
4428                 /* Hack -- apply rating bonus */
4429                 rating += e_ptr->rating;
4430
4431                 /* Cheat -- describe the item */
4432                 if (cheat_peek) object_mention(o_ptr);
4433
4434                 /* Done */
4435                 return;
4436         }
4437
4438         /* Examine real objects */
4439         if (o_ptr->k_idx)
4440         {
4441                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
4442
4443                 /* Hack -- acquire "broken" flag */
4444                 if (!get_object_cost(o_ptr)) o_ptr->ident |= (IDENT_BROKEN);
4445
4446                 /* Hack -- acquire "cursed" flag */
4447                 if (k_ptr->gen_flags & (TRG_CURSED)) o_ptr->curse_flags |= (TRC_CURSED);
4448                 if (k_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
4449                 if (k_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
4450                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE0)) o_ptr->curse_flags |= get_curse(0, o_ptr);
4451                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE1)) o_ptr->curse_flags |= get_curse(1, o_ptr);
4452                 if (k_ptr->gen_flags & (TRG_RANDOM_CURSE2)) o_ptr->curse_flags |= get_curse(2, o_ptr);
4453         }
4454 }
4455
4456
4457 /*
4458  * Hack -- determine if a template is "good"
4459  */
4460 static bool kind_is_good(int k_idx)
4461 {
4462         object_kind *k_ptr = &k_info[k_idx];
4463
4464         /* Analyze the item type */
4465         switch (k_ptr->tval)
4466         {
4467                 /* Armor -- Good unless damaged */
4468                 case TV_HARD_ARMOR:
4469                 case TV_SOFT_ARMOR:
4470                 case TV_DRAG_ARMOR:
4471                 case TV_SHIELD:
4472                 case TV_CLOAK:
4473                 case TV_BOOTS:
4474                 case TV_GLOVES:
4475                 case TV_HELM:
4476                 case TV_CROWN:
4477                 {
4478                         if (k_ptr->to_a < 0) return (FALSE);
4479                         return (TRUE);
4480                 }
4481
4482                 /* Weapons -- Good unless damaged */
4483                 case TV_BOW:
4484                 case TV_SWORD:
4485                 case TV_HAFTED:
4486                 case TV_POLEARM:
4487                 case TV_DIGGING:
4488                 {
4489                         if (k_ptr->to_h < 0) return (FALSE);
4490                         if (k_ptr->to_d < 0) return (FALSE);
4491                         return (TRUE);
4492                 }
4493
4494                 /* Ammo -- Arrows/Bolts are good */
4495                 case TV_BOLT:
4496                 case TV_ARROW:
4497                 {
4498                         return (TRUE);
4499                 }
4500
4501                 /* Books -- High level books are good (except Arcane books) */
4502                 case TV_LIFE_BOOK:
4503                 case TV_SORCERY_BOOK:
4504                 case TV_NATURE_BOOK:
4505                 case TV_CHAOS_BOOK:
4506                 case TV_DEATH_BOOK:
4507                 case TV_TRUMP_BOOK:
4508                 case TV_ENCHANT_BOOK:
4509                 case TV_DAEMON_BOOK:
4510                 case TV_CRUSADE_BOOK:
4511                 case TV_MUSIC_BOOK:
4512                 case TV_HISSATSU_BOOK:
4513                 {
4514                         if (k_ptr->sval >= SV_BOOK_MIN_GOOD) return (TRUE);
4515                         return (FALSE);
4516                 }
4517
4518                 /* Rings -- Rings of Speed are good */
4519                 case TV_RING:
4520                 {
4521                         if (k_ptr->sval == SV_RING_SPEED) return (TRUE);
4522                         if (k_ptr->sval == SV_RING_LORDLY) return (TRUE);
4523                         return (FALSE);
4524                 }
4525
4526                 /* Amulets -- Amulets of the Magi and Resistance are good */
4527                 case TV_AMULET:
4528                 {
4529                         if (k_ptr->sval == SV_AMULET_THE_MAGI) return (TRUE);
4530                         if (k_ptr->sval == SV_AMULET_RESISTANCE) return (TRUE);
4531                         return (FALSE);
4532                 }
4533         }
4534
4535         /* Assume not good */
4536         return (FALSE);
4537 }
4538
4539
4540 /*
4541  * Attempt to make an object (normal or good/great)
4542  *
4543  * This routine plays nasty games to generate the "special artifacts".
4544  *
4545  * This routine uses "object_level" for the "generation level".
4546  *
4547  * We assume that the given object has been "wiped".
4548  */
4549 bool make_object(object_type *j_ptr, bool good, bool great)
4550 {
4551         int prob, base;
4552         byte obj_level;
4553
4554
4555         /* Chance of "special object" */
4556         prob = (good ? 10 : 1000);
4557
4558         /* Base level for the object */
4559         base = (good ? (object_level + 10) : object_level);
4560
4561
4562         /* Generate a special object, or a normal object */
4563         if (!one_in_(prob) || !make_artifact_special(j_ptr))
4564         {
4565                 int k_idx;
4566
4567                 /* Good objects */
4568                 if (good)
4569                 {
4570                         /* Activate restriction */
4571                         get_obj_num_hook = kind_is_good;
4572
4573                         /* Prepare allocation table */
4574                         get_obj_num_prep();
4575                 }
4576
4577                 /* Pick a random object */
4578                 k_idx = get_obj_num(base);
4579
4580                 /* Good objects */
4581                 if (get_obj_num_hook)
4582                 {
4583                         /* Clear restriction */
4584                         get_obj_num_hook = NULL;
4585
4586                         /* Prepare allocation table */
4587                         get_obj_num_prep();
4588                 }
4589
4590                 /* Handle failure */
4591                 if (!k_idx) return (FALSE);
4592
4593                 /* Prepare the object */
4594                 object_prep(j_ptr, k_idx);
4595         }
4596
4597         /* Apply magic (allow artifacts) */
4598         apply_magic(j_ptr, object_level, TRUE, good, great, FALSE);
4599
4600         /* Hack -- generate multiple spikes/missiles */
4601         switch (j_ptr->tval)
4602         {
4603                 case TV_SPIKE:
4604                 case TV_SHOT:
4605                 case TV_ARROW:
4606                 case TV_BOLT:
4607                 {
4608                         if (!j_ptr->name1)
4609                                 j_ptr->number = (byte)damroll(6, 7);
4610                 }
4611         }
4612
4613         obj_level = get_object_level(j_ptr);
4614         if (artifact_p(j_ptr)) obj_level = a_info[j_ptr->name1].level;
4615
4616         /* Notice "okay" out-of-depth objects */
4617         if (!cursed_p(j_ptr) && !broken_p(j_ptr) &&
4618             (obj_level > dun_level))
4619         {
4620                 /* Rating increase */
4621                 rating += (obj_level - dun_level);
4622
4623                 /* Cheat -- peek at items */
4624                 if (cheat_peek) object_mention(j_ptr);
4625         }
4626
4627         /* Success */
4628         return (TRUE);
4629 }
4630
4631
4632 /*
4633  * Attempt to place an object (normal or good/great) at the given location.
4634  *
4635  * This routine plays nasty games to generate the "special artifacts".
4636  *
4637  * This routine uses "object_level" for the "generation level".
4638  *
4639  * This routine requires a clean floor grid destination.
4640  */
4641 void place_object(int y, int x, bool good, bool great)
4642 {
4643         s16b o_idx;
4644
4645         cave_type *c_ptr;
4646
4647         object_type forge;
4648         object_type *q_ptr;
4649
4650
4651         /* Paranoia -- check bounds */
4652         if (!in_bounds(y, x)) return;
4653
4654         /* Require clean floor space */
4655         if (!cave_clean_bold(y, x)) return;
4656
4657
4658         /* Get local object */
4659         q_ptr = &forge;
4660
4661         /* Wipe the object */
4662         object_wipe(q_ptr);
4663
4664         /* Make an object (if possible) */
4665         if (!make_object(q_ptr, good, great)) return;
4666
4667
4668         /* Make an object */
4669         o_idx = o_pop();
4670
4671         /* Success */
4672         if (o_idx)
4673         {
4674                 object_type *o_ptr;
4675
4676                 /* Acquire object */
4677                 o_ptr = &o_list[o_idx];
4678
4679                 /* Structure Copy */
4680                 object_copy(o_ptr, q_ptr);
4681
4682                 /* Location */
4683                 o_ptr->iy = y;
4684                 o_ptr->ix = x;
4685
4686                 /* Acquire grid */
4687                 c_ptr = &cave[y][x];
4688
4689                 /* Build a stack */
4690                 o_ptr->next_o_idx = c_ptr->o_idx;
4691
4692                 /* Place the object */
4693                 c_ptr->o_idx = o_idx;
4694
4695                 /* Notice */
4696                 note_spot(y, x);
4697
4698                 /* Redraw */
4699                 lite_spot(y, x);
4700         }
4701         else
4702         {
4703                 /* Hack -- Preserve artifacts */
4704                 if (q_ptr->name1)
4705                 {
4706                         a_info[q_ptr->name1].cur_num = 0;
4707                 }
4708         }
4709 }
4710
4711
4712 /*
4713  * Make a treasure object
4714  *
4715  * The location must be a legal, clean, floor grid.
4716  */
4717 bool make_gold(object_type *j_ptr)
4718 {
4719         int i;
4720
4721         s32b base;
4722
4723
4724         /* Hack -- Pick a Treasure variety */
4725         i = ((randint1(object_level + 2) + 2) / 2) - 1;
4726
4727         /* Apply "extra" magic */
4728         if (one_in_(GREAT_OBJ))
4729         {
4730                 i += randint1(object_level + 1);
4731         }
4732
4733         /* Hack -- Creeping Coins only generate "themselves" */
4734         if (coin_type) i = coin_type;
4735
4736         /* Do not create "illegal" Treasure Types */
4737         if (i >= MAX_GOLD) i = MAX_GOLD - 1;
4738
4739         /* Prepare a gold object */
4740         object_prep(j_ptr, OBJ_GOLD_LIST + i);
4741
4742         /* Hack -- Base coin cost */
4743         base = k_info[OBJ_GOLD_LIST+i].cost;
4744
4745         /* Determine how much the treasure is "worth" */
4746         j_ptr->pval = (base + (8L * randint1(base)) + randint1(8));
4747
4748         /* Success */
4749         return (TRUE);
4750 }
4751
4752
4753 /*
4754  * Places a treasure (Gold or Gems) at given location
4755  *
4756  * The location must be a legal, clean, floor grid.
4757  */
4758 void place_gold(int y, int x)
4759 {
4760         s16b o_idx;
4761
4762         cave_type *c_ptr;
4763
4764         object_type forge;
4765         object_type *q_ptr;
4766
4767
4768         /* Paranoia -- check bounds */
4769         if (!in_bounds(y, x)) return;
4770
4771         /* Require clean floor space */
4772         if (!cave_clean_bold(y, x)) return;
4773
4774
4775         /* Get local object */
4776         q_ptr = &forge;
4777
4778         /* Wipe the object */
4779         object_wipe(q_ptr);
4780
4781         /* Make some gold */
4782         if (!make_gold(q_ptr)) return;
4783
4784
4785         /* Make an object */
4786         o_idx = o_pop();
4787
4788         /* Success */
4789         if (o_idx)
4790         {
4791                 object_type *o_ptr;
4792
4793                 /* Acquire object */
4794                 o_ptr = &o_list[o_idx];
4795
4796                 /* Copy the object */
4797                 object_copy(o_ptr, q_ptr);
4798
4799                 /* Save location */
4800                 o_ptr->iy = y;
4801                 o_ptr->ix = x;
4802
4803                 /* Acquire grid */
4804                 c_ptr = &cave[y][x];
4805
4806                 /* Build a stack */
4807                 o_ptr->next_o_idx = c_ptr->o_idx;
4808
4809                 /* Place the object */
4810                 c_ptr->o_idx = o_idx;
4811
4812                 /* Notice */
4813                 note_spot(y, x);
4814
4815                 /* Redraw */
4816                 lite_spot(y, x);
4817         }
4818 }
4819
4820
4821 /*
4822  * Let an object fall to the ground at or near a location.
4823  *
4824  * The initial location is assumed to be "in_bounds()".
4825  *
4826  * This function takes a parameter "chance".  This is the percentage
4827  * chance that the item will "disappear" instead of drop.  If the object
4828  * has been thrown, then this is the chance of disappearance on contact.
4829  *
4830  * Hack -- this function uses "chance" to determine if it should produce
4831  * some form of "description" of the drop event (under the player).
4832  *
4833  * We check several locations to see if we can find a location at which
4834  * the object can combine, stack, or be placed.  Artifacts will try very
4835  * hard to be placed, including "teleporting" to a useful grid if needed.
4836  */
4837 s16b drop_near(object_type *j_ptr, int chance, int y, int x)
4838 {
4839         int i, k, d, s;
4840
4841         int bs, bn;
4842         int by, bx;
4843         int dy, dx;
4844         int ty, tx;
4845
4846         s16b o_idx = 0;
4847
4848         s16b this_o_idx, next_o_idx = 0;
4849
4850         cave_type *c_ptr;
4851
4852         char o_name[MAX_NLEN];
4853
4854         bool flag = FALSE;
4855         bool done = FALSE;
4856
4857         bool plural = FALSE;
4858
4859
4860         /* Extract plural */
4861         if (j_ptr->number != 1) plural = TRUE;
4862
4863         /* Describe object */
4864         object_desc(o_name, j_ptr, FALSE, 0);
4865
4866
4867         /* Handle normal "breakage" */
4868         if (!(j_ptr->art_name || artifact_p(j_ptr)) && (randint0(100) < chance))
4869         {
4870                 /* Message */
4871 #ifdef JP
4872                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
4873 #else
4874                 msg_format("The %s disappear%s.",
4875                            o_name, (plural ? "" : "s"));
4876 #endif
4877
4878
4879                 /* Debug */
4880 #ifdef JP
4881                 if (p_ptr->wizard) msg_print("(ÇËÂ»)");
4882 #else
4883                 if (p_ptr->wizard) msg_print("(breakage)");
4884 #endif
4885
4886
4887                 /* Failure */
4888                 return (0);
4889         }
4890
4891
4892         /* Score */
4893         bs = -1;
4894
4895         /* Picker */
4896         bn = 0;
4897
4898         /* Default */
4899         by = y;
4900         bx = x;
4901
4902         /* Scan local grids */
4903         for (dy = -3; dy <= 3; dy++)
4904         {
4905                 /* Scan local grids */
4906                 for (dx = -3; dx <= 3; dx++)
4907                 {
4908                         bool comb = FALSE;
4909
4910                         /* Calculate actual distance */
4911                         d = (dy * dy) + (dx * dx);
4912
4913                         /* Ignore distant grids */
4914                         if (d > 10) continue;
4915
4916                         /* Location */
4917                         ty = y + dy;
4918                         tx = x + dx;
4919
4920                         /* Skip illegal grids */
4921                         if (!in_bounds(ty, tx)) continue;
4922
4923                         /* Require line of sight */
4924                         if (!los(y, x, ty, tx)) continue;
4925
4926                         /* Obtain grid */
4927                         c_ptr = &cave[ty][tx];
4928
4929                         /* Require floor space */
4930                         if ((c_ptr->feat != FEAT_FLOOR) &&
4931                             (c_ptr->feat != FEAT_SHAL_WATER) &&
4932                             (c_ptr->feat != FEAT_GRASS) &&
4933                             (c_ptr->feat != FEAT_DIRT) &&
4934                             (c_ptr->feat != FEAT_FLOWER) &&
4935                             (c_ptr->feat != FEAT_DEEP_GRASS) &&
4936                             (c_ptr->feat != FEAT_SHAL_LAVA) &&
4937                                 (c_ptr->feat != FEAT_TREES)) continue;
4938                         if (c_ptr->info & (CAVE_TRAP | CAVE_IN_MIRROR)) continue;
4939
4940                         /* No objects */
4941                         k = 0;
4942
4943                         /* Scan objects in that grid */
4944                         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
4945                         {
4946                                 object_type *o_ptr;
4947
4948                                 /* Acquire object */
4949                                 o_ptr = &o_list[this_o_idx];
4950
4951                                 /* Acquire next object */
4952                                 next_o_idx = o_ptr->next_o_idx;
4953
4954                                 /* Check for possible combination */
4955                                 if (object_similar(o_ptr, j_ptr)) comb = TRUE;
4956
4957                                 /* Count objects */
4958                                 k++;
4959                         }
4960
4961                         /* Add new object */
4962                         if (!comb) k++;
4963
4964                         /* Paranoia */
4965                         if (k > 99) continue;
4966
4967                         /* Calculate score */
4968                         s = 1000 - (d + k * 5);
4969
4970                         /* Skip bad values */
4971                         if (s < bs) continue;
4972
4973                         /* New best value */
4974                         if (s > bs) bn = 0;
4975
4976                         /* Apply the randomizer to equivalent values */
4977                         if ((++bn >= 2) && !one_in_(bn)) continue;
4978
4979                         /* Keep score */
4980                         bs = s;
4981
4982                         /* Track it */
4983                         by = ty;
4984                         bx = tx;
4985
4986                         /* Okay */
4987                         flag = TRUE;
4988                 }
4989         }
4990
4991
4992         /* Handle lack of space */
4993         if (!flag && !(artifact_p(j_ptr) || j_ptr->art_name))
4994         {
4995                 /* Message */
4996 #ifdef JP
4997                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
4998 #else
4999                 msg_format("The %s disappear%s.",
5000                            o_name, (plural ? "" : "s"));
5001 #endif
5002
5003
5004                 /* Debug */
5005 #ifdef JP
5006                 if (p_ptr->wizard) msg_print("(¾²¥¹¥Ú¡¼¥¹¤¬¤Ê¤¤)");
5007 #else
5008                 if (p_ptr->wizard) msg_print("(no floor space)");
5009 #endif
5010
5011
5012                 /* Failure */
5013                 return (0);
5014         }
5015
5016
5017         /* Find a grid */
5018         for (i = 0; !flag; i++)
5019         {
5020                 /* Bounce around */
5021                 if (i < 1000)
5022                 {
5023                         ty = rand_spread(by, 1);
5024                         tx = rand_spread(bx, 1);
5025                 }
5026
5027                 /* Random locations */
5028                 else
5029                 {
5030                         ty = randint0(cur_hgt);
5031                         tx = randint0(cur_wid);
5032                 }
5033
5034                 /* Grid */
5035                 c_ptr = &cave[ty][tx];
5036
5037                 /* Require floor space (or shallow terrain) -KMW- */
5038                 if ((c_ptr->feat != FEAT_FLOOR) &&
5039                     (c_ptr->feat != FEAT_SHAL_WATER) &&
5040                     (c_ptr->feat != FEAT_GRASS) &&
5041                     (c_ptr->feat != FEAT_DIRT) &&
5042                     (c_ptr->feat != FEAT_SHAL_LAVA)) continue;
5043
5044                 /* Bounce to that location */
5045                 by = ty;
5046                 bx = tx;
5047
5048                 /* Require floor space */
5049                 if (!cave_clean_bold(by, bx)) continue;
5050
5051                 /* Okay */
5052                 flag = TRUE;
5053         }
5054
5055
5056         /* Grid */
5057         c_ptr = &cave[by][bx];
5058
5059         /* Scan objects in that grid for combination */
5060         for (this_o_idx = c_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
5061         {
5062                 object_type *o_ptr;
5063
5064                 /* Acquire object */
5065                 o_ptr = &o_list[this_o_idx];
5066
5067                 /* Acquire next object */
5068                 next_o_idx = o_ptr->next_o_idx;
5069
5070                 /* Check for combination */
5071                 if (object_similar(o_ptr, j_ptr))
5072                 {
5073                         /* Combine the items */
5074                         object_absorb(o_ptr, j_ptr);
5075
5076                         /* Success */
5077                         done = TRUE;
5078
5079                         /* Done */
5080                         break;
5081                 }
5082         }
5083
5084         /* Get new object */
5085         if (!done) o_idx = o_pop();
5086
5087         /* Failure */
5088         if (!done && !o_idx)
5089         {
5090                 /* Message */
5091 #ifdef JP
5092                 msg_format("%s¤Ï¾Ã¤¨¤¿¡£", o_name);
5093 #else
5094                 msg_format("The %s disappear%s.",
5095                            o_name, (plural ? "" : "s"));
5096 #endif
5097
5098
5099                 /* Debug */
5100 #ifdef JP
5101                 if (p_ptr->wizard) msg_print("(¥¢¥¤¥Æ¥à¤¬Â¿²á¤®¤ë)");
5102 #else
5103                 if (p_ptr->wizard) msg_print("(too many objects)");
5104 #endif
5105
5106
5107                 /* Hack -- Preserve artifacts */
5108                 if (j_ptr->name1)
5109                 {
5110                         a_info[j_ptr->name1].cur_num = 0;
5111                 }
5112
5113                 /* Failure */
5114                 return (0);
5115         }
5116
5117         /* Stack */
5118         if (!done)
5119         {
5120                 /* Structure copy */
5121                 object_copy(&o_list[o_idx], j_ptr);
5122
5123                 /* Access new object */
5124                 j_ptr = &o_list[o_idx];
5125
5126                 /* Locate */
5127                 j_ptr->iy = by;
5128                 j_ptr->ix = bx;
5129
5130                 /* No monster */
5131                 j_ptr->held_m_idx = 0;
5132
5133                 /* Build a stack */
5134                 j_ptr->next_o_idx = c_ptr->o_idx;
5135
5136                 /* Place the object */
5137                 c_ptr->o_idx = o_idx;
5138
5139                 /* Success */
5140                 done = TRUE;
5141         }
5142
5143         /* Note the spot */
5144         note_spot(by, bx);
5145
5146         /* Draw the spot */
5147         lite_spot(by, bx);
5148
5149         /* Sound */
5150         sound(SOUND_DROP);
5151
5152         /* Mega-Hack -- no message if "dropped" by player */
5153         /* Message when an object falls under the player */
5154         if (chance && (by == py) && (bx == px))
5155         {
5156 #ifdef JP
5157                 msg_print("²¿¤«¤¬Â²¼¤ËÅ¾¤¬¤Ã¤Æ¤¤¿¡£");
5158 #else
5159                 msg_print("You feel something roll beneath your feet.");
5160 #endif
5161
5162         }
5163
5164         /* XXX XXX XXX */
5165
5166         /* Result */
5167         return (o_idx);
5168 }
5169
5170
5171 /*
5172  * Scatter some "great" objects near the player
5173  */
5174 void acquirement(int y1, int x1, int num, bool great, bool known)
5175 {
5176         object_type *i_ptr;
5177         object_type object_type_body;
5178
5179         /* Acquirement */
5180         while (num--)
5181         {
5182                 /* Get local object */
5183                 i_ptr = &object_type_body;
5184
5185                 /* Wipe the object */
5186                 object_wipe(i_ptr);
5187
5188                 /* Make a good (or great) object (if possible) */
5189                 if (!make_object(i_ptr, TRUE, great)) continue;
5190
5191                 if (known)
5192                 {
5193                         object_aware(i_ptr);
5194                         object_known(i_ptr);
5195                 }
5196
5197                 /* Drop the object */
5198                 (void)drop_near(i_ptr, -1, y1, x1);
5199         }
5200 }
5201
5202
5203 #define MAX_TRAPS               18
5204
5205 static int trap_num[MAX_TRAPS] =
5206 {
5207         FEAT_TRAP_TRAPDOOR,
5208         FEAT_TRAP_PIT,
5209         FEAT_TRAP_SPIKED_PIT,
5210         FEAT_TRAP_POISON_PIT,
5211         FEAT_TRAP_TY_CURSE,
5212         FEAT_TRAP_TELEPORT,
5213         FEAT_TRAP_FIRE,
5214         FEAT_TRAP_ACID,
5215         FEAT_TRAP_SLOW,
5216         FEAT_TRAP_LOSE_STR,
5217         FEAT_TRAP_LOSE_DEX,
5218         FEAT_TRAP_LOSE_CON,
5219         FEAT_TRAP_BLIND,
5220         FEAT_TRAP_CONFUSE,
5221         FEAT_TRAP_POISON,
5222         FEAT_TRAP_SLEEP,
5223         FEAT_TRAP_TRAPS,
5224         FEAT_TRAP_ALARM,
5225 };
5226
5227
5228 /*
5229  * Hack -- instantiate a trap
5230  *
5231  * XXX XXX XXX This routine should be redone to reflect trap "level".
5232  * That is, it does not make sense to have spiked pits at 50 feet.
5233  * Actually, it is not this routine, but the "trap instantiation"
5234  * code, which should also check for "trap doors" on quest levels.
5235  */
5236 void pick_trap(int y, int x)
5237 {
5238         int feat;
5239
5240         cave_type *c_ptr = &cave[y][x];
5241
5242         /* Paranoia */
5243         if (!(c_ptr->info & CAVE_TRAP)) return;
5244         c_ptr->info &= ~(CAVE_TRAP);
5245
5246         /* Pick a trap */
5247         while (1)
5248         {
5249                 /* Hack -- pick a trap */
5250                 feat = trap_num[randint0(MAX_TRAPS)];
5251
5252                 /* Accept non-trapdoors */
5253                 if (feat != FEAT_TRAP_TRAPDOOR) break;
5254
5255                 /* Hack -- no trap doors on special levels */
5256                 if (p_ptr->inside_arena || quest_number(dun_level)) continue;
5257
5258                 /* Hack -- no trap doors on the deepest level */
5259                 if (dun_level >= d_info[dungeon_type].maxdepth) continue;
5260
5261                 break;
5262         }
5263
5264         /* Activate the trap */
5265         cave_set_feat(y, x, feat);
5266 }
5267
5268
5269 /*
5270  * Places a random trap at the given location.
5271  *
5272  * The location must be a legal, naked, floor grid.
5273  *
5274  * Note that all traps start out as "invisible" and "untyped", and then
5275  * when they are "discovered" (by detecting them or setting them off),
5276  * the trap is "instantiated" as a visible, "typed", trap.
5277  */
5278 void place_trap(int y, int x)
5279 {
5280         /* Paranoia -- verify location */
5281         if (!in_bounds(y, x)) return;
5282
5283         /* Require empty, clean, floor grid */
5284         if (!cave_naked_bold(y, x)) return;
5285
5286         /* Place an invisible trap */
5287         cave[y][x].info |= CAVE_TRAP;
5288 }
5289
5290
5291 /*
5292  * Describe the charges on an item in the inventory.
5293  */
5294 void inven_item_charges(int item)
5295 {
5296         object_type *o_ptr = &inventory[item];
5297
5298         /* Require staff/wand */
5299         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5300
5301         /* Require known item */
5302         if (!object_known_p(o_ptr)) return;
5303
5304 #ifdef JP
5305         if (o_ptr->pval <= 0)
5306         {
5307                 msg_print("¤â¤¦ËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤Ê¤¤¡£");
5308         }
5309         else
5310         {
5311                 msg_format("¤¢¤È %d ²óÊ¬¤ÎËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤ë¡£", o_ptr->pval);
5312         }
5313 #else
5314         /* Multiple charges */
5315         if (o_ptr->pval != 1)
5316         {
5317                 /* Print a message */
5318                 msg_format("You have %d charges remaining.", o_ptr->pval);
5319         }
5320
5321         /* Single charge */
5322         else
5323         {
5324                 /* Print a message */
5325                 msg_format("You have %d charge remaining.", o_ptr->pval);
5326         }
5327 #endif
5328
5329 }
5330
5331
5332 /*
5333  * Describe an item in the inventory.
5334  */
5335 void inven_item_describe(int item)
5336 {
5337         object_type *o_ptr = &inventory[item];
5338         char        o_name[MAX_NLEN];
5339
5340         /* Get a description */
5341         object_desc(o_name, o_ptr, TRUE, 3);
5342
5343         /* Print a message */
5344 #ifdef JP
5345         /* "no more" ¤Î¾ì¹ç¤Ï¤³¤Á¤é¤ÇÉ½¼¨¤¹¤ë */
5346         if (o_ptr->number <= 0)
5347         {
5348                 /*FIRST*//*¤³¤³¤Ï¤â¤¦ÄÌ¤é¤Ê¤¤¤«¤â */
5349                 msg_format("¤â¤¦%s¤ò»ý¤Ã¤Æ¤¤¤Ê¤¤¡£", o_name);
5350         }
5351         else
5352         {
5353                 /* ¥¢¥¤¥Æ¥àÌ¾¤ò±ÑÆüÀÚ¤êÂØ¤¨µ¡Ç½ÂÐ±þ */
5354                 msg_format("¤Þ¤À %s¤ò»ý¤Ã¤Æ¤¤¤ë¡£", o_name);
5355         }
5356 #else
5357         msg_format("You have %s.", o_name);
5358 #endif
5359
5360 }
5361
5362
5363 /*
5364  * Increase the "number" of an item in the inventory
5365  */
5366 void inven_item_increase(int item, int num)
5367 {
5368         object_type *o_ptr = &inventory[item];
5369
5370         /* Apply */
5371         num += o_ptr->number;
5372
5373         /* Bounds check */
5374         if (num > 255) num = 255;
5375         else if (num < 0) num = 0;
5376
5377         /* Un-apply */
5378         num -= o_ptr->number;
5379
5380         /* Change the number and weight */
5381         if (num)
5382         {
5383                 /* Add the number */
5384                 o_ptr->number += num;
5385
5386                 /* Add the weight */
5387                 p_ptr->total_weight += (num * o_ptr->weight);
5388
5389                 /* Recalculate bonuses */
5390                 p_ptr->update |= (PU_BONUS);
5391
5392                 /* Recalculate mana XXX */
5393                 p_ptr->update |= (PU_MANA);
5394
5395                 /* Combine the pack */
5396                 p_ptr->notice |= (PN_COMBINE);
5397
5398                 /* Window stuff */
5399                 p_ptr->window |= (PW_INVEN | PW_EQUIP);
5400         }
5401 }
5402
5403
5404 /*
5405  * Erase an inventory slot if it has no more items
5406  */
5407 void inven_item_optimize(int item)
5408 {
5409         object_type *o_ptr = &inventory[item];
5410
5411         /* Only optimize real items */
5412         if (!o_ptr->k_idx) return;
5413
5414         /* Only optimize empty items */
5415         if (o_ptr->number) return;
5416
5417         /* The item is in the pack */
5418         if (item < INVEN_RARM)
5419         {
5420                 int i;
5421
5422                 /* One less item */
5423                 inven_cnt--;
5424
5425                 /* Slide everything down */
5426                 for (i = item; i < INVEN_PACK; i++)
5427                 {
5428                         /* Structure copy */
5429                         inventory[i] = inventory[i+1];
5430                 }
5431
5432                 /* Erase the "final" slot */
5433                 object_wipe(&inventory[i]);
5434
5435                 /* Window stuff */
5436                 p_ptr->window |= (PW_INVEN);
5437         }
5438
5439         /* The item is being wielded */
5440         else
5441         {
5442                 /* One less item */
5443                 equip_cnt--;
5444
5445                 /* Erase the empty slot */
5446                 object_wipe(&inventory[item]);
5447
5448                 /* Recalculate bonuses */
5449                 p_ptr->update |= (PU_BONUS);
5450
5451                 /* Recalculate torch */
5452                 p_ptr->update |= (PU_TORCH);
5453
5454                 /* Recalculate mana XXX */
5455                 p_ptr->update |= (PU_MANA);
5456
5457                 /* Window stuff */
5458                 p_ptr->window |= (PW_EQUIP);
5459         }
5460
5461         /* Window stuff */
5462         p_ptr->window |= (PW_SPELL);
5463 }
5464
5465
5466 /*
5467  * Describe the charges on an item on the floor.
5468  */
5469 void floor_item_charges(int item)
5470 {
5471         object_type *o_ptr = &o_list[item];
5472
5473         /* Require staff/wand */
5474         if ((o_ptr->tval != TV_STAFF) && (o_ptr->tval != TV_WAND)) return;
5475
5476         /* Require known item */
5477         if (!object_known_p(o_ptr)) return;
5478
5479 #ifdef JP
5480         if (o_ptr->pval <= 0)
5481         {
5482                 msg_print("¤³¤Î¾²¾å¤Î¥¢¥¤¥Æ¥à¤Ï¡¢¤â¤¦ËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤Ê¤¤¡£");
5483         }
5484         else
5485         {
5486                 msg_format("¤³¤Î¾²¾å¤Î¥¢¥¤¥Æ¥à¤Ï¡¢¤¢¤È %d ²óÊ¬¤ÎËâÎÏ¤¬»Ä¤Ã¤Æ¤¤¤ë¡£", o_ptr->pval);
5487         }
5488 #else
5489         /* Multiple charges */
5490         if (o_ptr->pval != 1)
5491         {
5492                 /* Print a message */
5493                 msg_format("There are %d charges remaining.", o_ptr->pval);
5494         }
5495
5496         /* Single charge */
5497         else
5498         {
5499                 /* Print a message */
5500                 msg_format("There is %d charge remaining.", o_ptr->pval);
5501         }
5502 #endif
5503
5504 }
5505
5506
5507 /*
5508  * Describe an item in the inventory.
5509  */
5510 void floor_item_describe(int item)
5511 {
5512         object_type *o_ptr = &o_list[item];
5513         char        o_name[MAX_NLEN];
5514
5515         /* Get a description */
5516         object_desc(o_name, o_ptr, TRUE, 3);
5517
5518         /* Print a message */
5519 #ifdef JP
5520         /* "no more" ¤Î¾ì¹ç¤Ï¤³¤Á¤é¤ÇÉ½¼¨¤òÊ¬¤±¤ë */
5521         if (o_ptr->number <= 0)
5522         {
5523                 msg_format("¾²¾å¤Ë¤Ï¡¢¤â¤¦%s¤Ï¤Ê¤¤¡£", o_name);
5524         }
5525         else
5526         {
5527                 msg_format("¾²¾å¤Ë¤Ï¡¢¤Þ¤À %s¤¬¤¢¤ë¡£", o_name);
5528         }
5529 #else
5530         msg_format("You see %s.", o_name);
5531 #endif
5532
5533 }
5534
5535
5536 /*
5537  * Increase the "number" of an item on the floor
5538  */
5539 void floor_item_increase(int item, int num)
5540 {
5541         object_type *o_ptr = &o_list[item];
5542
5543         /* Apply */
5544         num += o_ptr->number;
5545
5546         /* Bounds check */
5547         if (num > 255) num = 255;
5548         else if (num < 0) num = 0;
5549
5550         /* Un-apply */
5551         num -= o_ptr->number;
5552
5553         /* Change the number */
5554         o_ptr->number += num;
5555 }
5556
5557
5558 /*
5559  * Optimize an item on the floor (destroy "empty" items)
5560  */
5561 void floor_item_optimize(int item)
5562 {
5563         object_type *o_ptr = &o_list[item];
5564
5565         /* Paranoia -- be sure it exists */
5566         if (!o_ptr->k_idx) return;
5567
5568         /* Only optimize empty items */
5569         if (o_ptr->number) return;
5570
5571         /* Delete the object */
5572         delete_object_idx(item);
5573 }
5574
5575
5576 /*
5577  * Check if we have space for an item in the pack without overflow
5578  */
5579 bool inven_carry_okay(object_type *o_ptr)
5580 {
5581         int j;
5582
5583         /* Empty slot? */
5584         if (inven_cnt < INVEN_PACK) return (TRUE);
5585
5586         /* Similar slot? */
5587         for (j = 0; j < INVEN_PACK; j++)
5588         {
5589                 object_type *j_ptr = &inventory[j];
5590
5591                 /* Skip non-objects */
5592                 if (!j_ptr->k_idx) continue;
5593
5594                 /* Check if the two items can be combined */
5595                 if (object_similar(j_ptr, o_ptr)) return (TRUE);
5596         }
5597
5598         /* Nope */
5599         return (FALSE);
5600 }
5601
5602
5603 /*
5604  * Add an item to the players inventory, and return the slot used.
5605  *
5606  * If the new item can combine with an existing item in the inventory,
5607  * it will do so, using "object_similar()" and "object_absorb()", else,
5608  * the item will be placed into the "proper" location in the inventory.
5609  *
5610  * This function can be used to "over-fill" the player's pack, but only
5611  * once, and such an action must trigger the "overflow" code immediately.
5612  * Note that when the pack is being "over-filled", the new item must be
5613  * placed into the "overflow" slot, and the "overflow" must take place
5614  * before the pack is reordered, but (optionally) after the pack is
5615  * combined.  This may be tricky.  See "dungeon.c" for info.
5616  *
5617  * Note that this code must remove any location/stack information
5618  * from the object once it is placed into the inventory.
5619  */
5620 s16b inven_carry(object_type *o_ptr)
5621 {
5622         int i, j, k;
5623         int n = -1;
5624
5625         object_type *j_ptr;
5626
5627
5628         /* Check for combining */
5629         for (j = 0; j < INVEN_PACK; j++)
5630         {
5631                 j_ptr = &inventory[j];
5632
5633                 /* Skip non-objects */
5634                 if (!j_ptr->k_idx) continue;
5635
5636                 /* Hack -- track last item */
5637                 n = j;
5638
5639                 /* Check if the two items can be combined */
5640                 if (object_similar(j_ptr, o_ptr))
5641                 {
5642                         /* Combine the items */
5643                         object_absorb(j_ptr, o_ptr);
5644
5645                         /* Increase the weight */
5646                         p_ptr->total_weight += (o_ptr->number * o_ptr->weight);
5647
5648                         /* Recalculate bonuses */
5649                         p_ptr->update |= (PU_BONUS);
5650
5651                         /* Window stuff */
5652                         p_ptr->window |= (PW_INVEN);
5653
5654                         /* Success */
5655                         return (j);
5656                 }
5657         }
5658
5659
5660         /* Paranoia */
5661         if (inven_cnt > INVEN_PACK) return (-1);
5662
5663         /* Find an empty slot */
5664         for (j = 0; j <= INVEN_PACK; j++)
5665         {
5666                 j_ptr = &inventory[j];
5667
5668                 /* Use it if found */
5669                 if (!j_ptr->k_idx) break;
5670         }
5671
5672         /* Use that slot */
5673         i = j;
5674
5675
5676         /* Reorder the pack */
5677         if (i < INVEN_PACK)
5678         {
5679                 s32b o_value, j_value;
5680
5681                 /* Get the "value" of the item */
5682                 o_value = object_value(o_ptr);
5683
5684                 /* Scan every occupied slot */
5685                 for (j = 0; j < INVEN_PACK; j++)
5686                 {
5687                         j_ptr = &inventory[j];
5688
5689                         /* Use empty slots */
5690                         if (!j_ptr->k_idx) break;
5691
5692                         /* Hack -- readable books always come first */
5693                         if ((o_ptr->tval == REALM1_BOOK) &&
5694                             (j_ptr->tval != REALM1_BOOK)) break;
5695                         if ((j_ptr->tval == REALM1_BOOK) &&
5696                             (o_ptr->tval != REALM1_BOOK)) continue;
5697
5698                         if ((o_ptr->tval == REALM2_BOOK) &&
5699                             (j_ptr->tval != REALM2_BOOK)) break;
5700                         if ((j_ptr->tval == REALM2_BOOK) &&
5701                             (o_ptr->tval != REALM2_BOOK)) continue;
5702
5703                         /* Objects sort by decreasing type */
5704                         if (o_ptr->tval > j_ptr->tval) break;
5705                         if (o_ptr->tval < j_ptr->tval) continue;
5706
5707                         /* Non-aware (flavored) items always come last */
5708                         if (!object_aware_p(o_ptr)) continue;
5709                         if (!object_aware_p(j_ptr)) break;
5710
5711                         /* Objects sort by increasing sval */
5712                         if (o_ptr->sval < j_ptr->sval) break;
5713                         if (o_ptr->sval > j_ptr->sval) continue;
5714
5715                         /* Unidentified objects always come last */
5716                         if (!object_known_p(o_ptr)) continue;
5717                         if (!object_known_p(j_ptr)) break;
5718
5719                         /* Hack:  otherwise identical rods sort by
5720                         increasing recharge time --dsb */
5721                         if (o_ptr->tval == TV_ROD)
5722                         {
5723                                 if (o_ptr->pval < j_ptr->pval) break;
5724                                 if (o_ptr->pval > j_ptr->pval) continue;
5725                         }
5726
5727                         /* Determine the "value" of the pack item */
5728                         j_value = object_value(j_ptr);
5729
5730                         /* Objects sort by decreasing value */
5731                         if (o_value > j_value) break;
5732                         if (o_value < j_value) continue;
5733                 }
5734
5735                 /* Use that slot */
5736                 i = j;
5737
5738                 /* Slide objects */
5739                 for (k = n; k >= i; k--)
5740                 {
5741                         /* Hack -- Slide the item */
5742                         object_copy(&inventory[k+1], &inventory[k]);
5743                 }
5744
5745                 /* Wipe the empty slot */
5746                 object_wipe(&inventory[i]);
5747         }
5748
5749
5750         /* Copy the item */
5751         object_copy(&inventory[i], o_ptr);
5752
5753         /* Access new object */
5754         j_ptr = &inventory[i];
5755
5756         /* Forget stack */
5757         j_ptr->next_o_idx = 0;
5758
5759         /* Forget monster */
5760         j_ptr->held_m_idx = 0;
5761
5762         /* Forget location */
5763         j_ptr->iy = j_ptr->ix = 0;
5764
5765         /* No longer marked */
5766         j_ptr->marked = 0;
5767
5768         /* Increase the weight */
5769         p_ptr->total_weight += (j_ptr->number * j_ptr->weight);
5770
5771         /* Count the items */
5772         inven_cnt++;
5773
5774         /* Recalculate bonuses */
5775         p_ptr->update |= (PU_BONUS);
5776
5777         /* Combine and Reorder pack */
5778         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
5779
5780         /* Window stuff */
5781         p_ptr->window |= (PW_INVEN);
5782
5783         /* Return the slot */
5784         return (i);
5785 }
5786
5787
5788 /*
5789  * Take off (some of) a non-cursed equipment item
5790  *
5791  * Note that only one item at a time can be wielded per slot.
5792  *
5793  * Note that taking off an item when "full" may cause that item
5794  * to fall to the ground.
5795  *
5796  * Return the inventory slot into which the item is placed.
5797  */
5798 s16b inven_takeoff(int item, int amt)
5799 {
5800         int slot;
5801
5802         object_type forge;
5803         object_type *q_ptr;
5804
5805         object_type *o_ptr;
5806
5807         cptr act;
5808
5809         char o_name[MAX_NLEN];
5810
5811
5812         /* Get the item to take off */
5813         o_ptr = &inventory[item];
5814
5815         /* Paranoia */
5816         if (amt <= 0) return (-1);
5817
5818         /* Verify */
5819         if (amt > o_ptr->number) amt = o_ptr->number;
5820
5821         /* Get local object */
5822         q_ptr = &forge;
5823
5824         /* Obtain a local object */
5825         object_copy(q_ptr, o_ptr);
5826
5827         /* Modify quantity */
5828         q_ptr->number = amt;
5829
5830         /* Describe the object */
5831         object_desc(o_name, q_ptr, TRUE, 3);
5832
5833         /* Took off weapon */
5834         if (item == INVEN_RARM)
5835         {
5836 #ifdef JP
5837                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
5838 #else
5839                 act = "You were wielding";
5840 #endif
5841
5842         }
5843
5844         /* Took off bow */
5845         else if (item == INVEN_BOW)
5846         {
5847 #ifdef JP
5848                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
5849 #else
5850                 act = "You were holding";
5851 #endif
5852
5853         }
5854
5855         /* Took off light */
5856         else if (item == INVEN_LITE)
5857         {
5858 #ifdef JP
5859                 act = "¤ò¸÷¸»¤«¤é¤Ï¤º¤·¤¿";
5860 #else
5861                 act = "You were holding";
5862 #endif
5863
5864         }
5865
5866         /* Took off something */
5867         else
5868         {
5869 #ifdef JP
5870                 act = "¤òÁõÈ÷¤«¤é¤Ï¤º¤·¤¿";
5871 #else
5872                 act = "You were wearing";
5873 #endif
5874
5875         }
5876
5877         /* Modify, Optimize */
5878         inven_item_increase(item, -amt);
5879         inven_item_optimize(item);
5880
5881         /* Carry the object */
5882         slot = inven_carry(q_ptr);
5883
5884         /* Message */
5885 #ifdef JP
5886         msg_format("%s(%c)%s¡£", o_name, index_to_label(slot), act);
5887 #else
5888         msg_format("%s %s (%c).", act, o_name, index_to_label(slot));
5889 #endif
5890
5891
5892         /* Return slot */
5893         return (slot);
5894 }
5895
5896
5897 /*
5898  * Drop (some of) a non-cursed inventory/equipment item
5899  *
5900  * The object will be dropped "near" the current location
5901  */
5902 void inven_drop(int item, int amt)
5903 {
5904         object_type forge;
5905         object_type *q_ptr;
5906
5907         object_type *o_ptr;
5908
5909         char o_name[MAX_NLEN];
5910
5911
5912         /* Access original object */
5913         o_ptr = &inventory[item];
5914
5915         /* Error check */
5916         if (amt <= 0) return;
5917
5918         /* Not too many */
5919         if (amt > o_ptr->number) amt = o_ptr->number;
5920
5921
5922         /* Take off equipment */
5923         if (item >= INVEN_RARM)
5924         {
5925                 /* Take off first */
5926                 item = inven_takeoff(item, amt);
5927
5928                 /* Access original object */
5929                 o_ptr = &inventory[item];
5930         }
5931
5932
5933         /* Get local object */
5934         q_ptr = &forge;
5935
5936         /* Obtain local object */
5937         object_copy(q_ptr, o_ptr);
5938
5939         /* Distribute charges of wands or rods */
5940         distribute_charges(o_ptr, q_ptr, amt);
5941
5942         /* Modify quantity */
5943         q_ptr->number = amt;
5944
5945         /* Describe local object */
5946         object_desc(o_name, q_ptr, TRUE, 3);
5947
5948         /* Message */
5949 #ifdef JP
5950         msg_format("%s(%c)¤òÍî¤È¤·¤¿¡£", o_name, index_to_label(item));
5951 #else
5952         msg_format("You drop %s (%c).", o_name, index_to_label(item));
5953 #endif
5954
5955
5956         /* Drop it near the player */
5957         (void)drop_near(q_ptr, 0, py, px);
5958
5959         /* Modify, Describe, Optimize */
5960         inven_item_increase(item, -amt);
5961         inven_item_describe(item);
5962         inven_item_optimize(item);
5963 }
5964
5965
5966 /*
5967  * Combine items in the pack
5968  *
5969  * Note special handling of the "overflow" slot
5970  */
5971 void combine_pack(void)
5972 {
5973         int             i, j, k;
5974         object_type     *o_ptr;
5975         object_type     *j_ptr;
5976         bool            flag = FALSE;
5977
5978
5979         /* Combine the pack (backwards) */
5980         for (i = INVEN_PACK; i > 0; i--)
5981         {
5982                 /* Get the item */
5983                 o_ptr = &inventory[i];
5984
5985                 /* Skip empty items */
5986                 if (!o_ptr->k_idx) continue;
5987
5988                 /* Scan the items above that item */
5989                 for (j = 0; j < i; j++)
5990                 {
5991                         /* Get the item */
5992                         j_ptr = &inventory[j];
5993
5994                         /* Skip empty items */
5995                         if (!j_ptr->k_idx) continue;
5996
5997                         /* Can we (partialy) drop "o_ptr" onto "j_ptr"? */
5998                         if (object_similar_part(j_ptr, o_ptr)
5999                             && j_ptr->number < MAX_STACK_SIZE-1)
6000                         {
6001                                 if (o_ptr->number + j_ptr->number < MAX_STACK_SIZE)
6002                                 {
6003                                         /* Take note */
6004                                         flag = TRUE;
6005
6006                                         /* Add together the item counts */
6007                                         object_absorb(j_ptr, o_ptr);
6008
6009                                         /* One object is gone */
6010                                         inven_cnt--;
6011
6012                                         /* Slide everything down */
6013                                         for (k = i; k < INVEN_PACK; k++)
6014                                         {
6015                                                 /* Structure copy */
6016                                                 inventory[k] = inventory[k+1];
6017                                         }
6018
6019                                         /* Erase the "final" slot */
6020                                         object_wipe(&inventory[k]);
6021                                 }
6022                                 else
6023                                 {
6024                                         int remain = j_ptr->number + o_ptr->number - 99;
6025
6026                                         o_ptr->number -= remain;
6027
6028                                         /* Add together the item counts */
6029                                         object_absorb(j_ptr, o_ptr);
6030
6031                                         o_ptr->number = remain;
6032
6033                                 }
6034                                 /* Window stuff */
6035                                 p_ptr->window |= (PW_INVEN);
6036
6037                                 /* Done */
6038                                 break;
6039                         }
6040                 }
6041         }
6042
6043         /* Message */
6044 #ifdef JP
6045         if (flag) msg_print("¥¶¥Ã¥¯¤ÎÃæ¤Î¥¢¥¤¥Æ¥à¤ò¤Þ¤È¤áÄ¾¤·¤¿¡£");
6046 #else
6047         if (flag) msg_print("You combine some items in your pack.");
6048 #endif
6049
6050 }
6051
6052
6053 /*
6054  * Reorder items in the pack
6055  *
6056  * Note special handling of the "overflow" slot
6057  */
6058 void reorder_pack(void)
6059 {
6060         int             i, j, k;
6061         s32b            o_value;
6062         s32b            j_value;
6063         object_type     forge;
6064         object_type     *q_ptr;
6065         object_type     *j_ptr;
6066         object_type     *o_ptr;
6067         bool            flag = FALSE;
6068
6069
6070         /* Re-order the pack (forwards) */
6071         for (i = 0; i < INVEN_PACK; i++)
6072         {
6073                 /* Mega-Hack -- allow "proper" over-flow */
6074                 if ((i == INVEN_PACK) && (inven_cnt == INVEN_PACK)) break;
6075
6076                 /* Get the item */
6077                 o_ptr = &inventory[i];
6078
6079                 /* Skip empty slots */
6080                 if (!o_ptr->k_idx) continue;
6081
6082                 /* Get the "value" of the item */
6083                 o_value = object_value(o_ptr);
6084
6085                 /* Scan every occupied slot */
6086                 for (j = 0; j < INVEN_PACK; j++)
6087                 {
6088                         /* Get the item already there */
6089                         j_ptr = &inventory[j];
6090
6091                         /* Use empty slots */
6092                         if (!j_ptr->k_idx) break;
6093
6094                         /* Hack -- readable books always come first */
6095                         if ((o_ptr->tval == REALM1_BOOK) &&
6096                             (j_ptr->tval != REALM1_BOOK)) break;
6097                         if ((j_ptr->tval == REALM1_BOOK) &&
6098                             (o_ptr->tval != REALM1_BOOK)) continue;
6099
6100                         if ((o_ptr->tval == REALM2_BOOK) &&
6101                             (j_ptr->tval != REALM2_BOOK)) break;
6102                         if ((j_ptr->tval == REALM2_BOOK) &&
6103                             (o_ptr->tval != REALM2_BOOK)) continue;
6104
6105                         /* Objects sort by decreasing type */
6106                         if (o_ptr->tval > j_ptr->tval) break;
6107                         if (o_ptr->tval < j_ptr->tval) continue;
6108
6109                         /* Non-aware (flavored) items always come last */
6110                         if (!object_aware_p(o_ptr)) continue;
6111                         if (!object_aware_p(j_ptr)) break;
6112
6113                         /* Objects sort by increasing sval */
6114                         if (o_ptr->sval < j_ptr->sval) break;
6115                         if (o_ptr->sval > j_ptr->sval) continue;
6116
6117                         /* Unidentified objects always come last */
6118                         if (!object_known_p(o_ptr)) continue;
6119                         if (!object_known_p(j_ptr)) break;
6120
6121                         /* Hack:  otherwise identical rods sort by
6122                         increasing recharge time --dsb */
6123                         if (o_ptr->tval == TV_ROD)
6124                         {
6125                                 if (o_ptr->pval < j_ptr->pval) break;
6126                                 if (o_ptr->pval > j_ptr->pval) continue;
6127                         }
6128
6129                         /* Determine the "value" of the pack item */
6130                         j_value = object_value(j_ptr);
6131
6132
6133
6134                         /* Objects sort by decreasing value */
6135                         if (o_value > j_value) break;
6136                         if (o_value < j_value) continue;
6137                 }
6138
6139                 /* Never move down */
6140                 if (j >= i) continue;
6141
6142                 /* Take note */
6143                 flag = TRUE;
6144
6145                 /* Get local object */
6146                 q_ptr = &forge;
6147
6148                 /* Save a copy of the moving item */
6149                 object_copy(q_ptr, &inventory[i]);
6150
6151                 /* Slide the objects */
6152                 for (k = i; k > j; k--)
6153                 {
6154                         /* Slide the item */
6155                         object_copy(&inventory[k], &inventory[k-1]);
6156                 }
6157
6158                 /* Insert the moving item */
6159                 object_copy(&inventory[j], q_ptr);
6160
6161                 /* Window stuff */
6162                 p_ptr->window |= (PW_INVEN);
6163         }
6164
6165         /* Message */
6166 #ifdef JP
6167         if (flag) msg_print("¥¶¥Ã¥¯¤ÎÃæ¤Î¥¢¥¤¥Æ¥à¤òÊÂ¤ÙÄ¾¤·¤¿¡£");
6168 #else
6169         if (flag) msg_print("You reorder some items in your pack.");
6170 #endif
6171
6172 }
6173
6174
6175 /*
6176  * Hack -- display an object kind in the current window
6177  *
6178  * Include list of usable spells for readible books
6179  */
6180 void display_koff(int k_idx)
6181 {
6182         int y;
6183
6184         object_type forge;
6185         object_type *q_ptr;
6186
6187         char o_name[MAX_NLEN];
6188
6189
6190         /* Erase the window */
6191         for (y = 0; y < Term->hgt; y++)
6192         {
6193                 /* Erase the line */
6194                 Term_erase(0, y, 255);
6195         }
6196
6197         /* No info */
6198         if (!k_idx) return;
6199
6200         /* Get local object */
6201         q_ptr = &forge;
6202
6203         /* Prepare the object */
6204         object_prep(q_ptr, k_idx);
6205
6206         /* Describe */
6207         object_desc_store(o_name, q_ptr, FALSE, 0);
6208
6209         /* Mention the object name */
6210         Term_putstr(0, 0, -1, TERM_WHITE, o_name);
6211
6212         /* Warriors are illiterate */
6213         if (!(p_ptr->realm1 || p_ptr->realm2)) return;
6214
6215         /* Display spells in readible books */
6216         if ((q_ptr->tval == REALM1_BOOK) ||
6217             (q_ptr->tval == REALM2_BOOK))
6218         {
6219                 int     sval;
6220                 int     spell = -1;
6221                 int     num = 0;
6222                 byte    spells[64];
6223
6224
6225                 /* Access the item's sval */
6226                 sval = q_ptr->sval;
6227
6228                 /* Extract spells */
6229                 for (spell = 0; spell < 32; spell++)
6230                 {
6231                         /* Check for this spell */
6232                         if (fake_spell_flags[sval] & (1L << spell))
6233                         {
6234                                 /* Collect this spell */
6235                                 spells[num++] = spell;
6236                         }
6237                 }
6238
6239                 /* Print spells */
6240                 print_spells(0, spells, num, 2, 0,
6241                     (q_ptr->tval == REALM1_BOOK ? p_ptr->realm1 : p_ptr->realm2));
6242         }
6243 }
6244
6245 /* Choose one of items that have warning flag */
6246 object_type *choose_warning_item(void)
6247 {
6248         int i;
6249         int choices[INVEN_TOTAL-INVEN_RARM];
6250         int number = 0;
6251
6252         /* Paranoia -- Player has no warning-item */
6253         if (!p_ptr->warning) return (NULL);
6254
6255         /* Search Inventry */
6256         for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
6257         {
6258                 u32b flgs[TR_FLAG_SIZE];
6259                 object_type *o_ptr = &inventory[i];
6260
6261                 object_flags(o_ptr, flgs);
6262                 if (have_flag(flgs, TR_WARNING))
6263                 {
6264                         choices[number] = i;
6265                         number++;
6266                 }
6267         }
6268
6269         /* Choice one of them */
6270         return (&inventory[choices[randint0(number)]]);
6271 }
6272
6273 /* Examine the grid (xx,yy) and warn the player if there are any danger */
6274 bool process_frakir(int xx, int yy)
6275 {
6276         int mx,my;
6277         cave_type *c_ptr;
6278         char o_name[MAX_NLEN];
6279
6280 #define FRAKIR_AWARE_RANGE 12
6281         int dam_max = 0;
6282         static int old_damage = 0;
6283
6284         for (mx = xx-FRAKIR_AWARE_RANGE; mx < xx+FRAKIR_AWARE_RANGE+1; mx++)
6285         {
6286                 for (my = yy-FRAKIR_AWARE_RANGE; my < yy+FRAKIR_AWARE_RANGE+1; my++)
6287                 {
6288                         int dam_max0=0;
6289                         monster_type *m_ptr;
6290                         monster_race *r_ptr;
6291                         u32b f4, f5, f6;
6292                         int rlev;
6293
6294                         if (!in_bounds(my,mx) || (distance(my,mx,yy,xx)>FRAKIR_AWARE_RANGE)) continue;
6295
6296                         c_ptr = &cave[my][mx];
6297
6298                         if (!c_ptr->m_idx) continue;
6299
6300                         m_ptr = &m_list[c_ptr->m_idx];
6301                         r_ptr = &r_info[m_ptr->r_idx];
6302
6303                         f4 = r_ptr->flags4;
6304                         f5 = r_ptr->flags5;
6305                         f6 = r_ptr->flags6;
6306
6307                         rlev = ((r_ptr->level >= 1) ? r_ptr->level : 1);
6308
6309                         if (m_ptr->csleep) continue;
6310                         if (is_pet(m_ptr)) continue;
6311
6312                         /* Monster spells (only powerful ones)*/
6313                         if(projectable(my,mx,yy,xx))
6314                         {
6315
6316 #define DAMCALC(f,val,max,im,vln,res,resx,resy,op,opx,opy,dmax) \
6317            if (f){ int dam = (val)>(max)? (max):(val); \
6318            if (im) dam=0; \
6319            if (vln) dam *= 2; \
6320            if (res) {dam = (dam * resx) / resy;} \
6321            if (op) {dam = (dam * opx) / opy;} \
6322            if (dam>dmax) dmax = dam; \
6323            }
6324
6325                                 DAMCALC(f4 & (RF4_BR_FIRE), m_ptr->hp / 3, 1600,
6326                                         p_ptr->immune_fire, p_ptr->muta3 & MUT3_VULN_ELEM,
6327                                         p_ptr->resist_fire, 1, 3,
6328                                         p_ptr->oppose_fire, 1, 3, dam_max0);
6329
6330                                 DAMCALC(f4 & (RF4_BR_COLD), m_ptr->hp / 3, 1600,
6331                                         p_ptr->immune_cold, p_ptr->muta3 & MUT3_VULN_ELEM,
6332                                         p_ptr->resist_cold, 1, 3,
6333                                         p_ptr->oppose_cold, 1, 3, dam_max0);
6334
6335                                 DAMCALC(f4 & (RF4_BR_ELEC), m_ptr->hp / 3, 1600,
6336                                         p_ptr->immune_elec, p_ptr->muta3 & MUT3_VULN_ELEM,
6337                                         p_ptr->resist_elec, 1, 3,
6338                                         p_ptr->oppose_elec, 1, 3, dam_max0);
6339
6340                                 DAMCALC(f4 & (RF4_BR_ACID), m_ptr->hp / 3, 1600,
6341                                         p_ptr->immune_acid, p_ptr->muta3 & MUT3_VULN_ELEM,
6342                                         p_ptr->resist_acid, 1, 3,
6343                                         p_ptr->oppose_acid, 1, 3, dam_max0);
6344
6345                                 DAMCALC(f4 & (RF4_BR_POIS), m_ptr->hp / 3, 800,
6346                                         FALSE , FALSE,
6347                                         p_ptr->resist_pois, 1, 3,
6348                                         p_ptr->oppose_pois, 1, 3, dam_max0);
6349
6350
6351                                 DAMCALC(f4 & (RF4_BR_NETH), m_ptr->hp / 6, 550, FALSE , FALSE,
6352                                         p_ptr->resist_neth, 6, 9, FALSE, 1, 1, dam_max0);
6353
6354                                 DAMCALC(f4 & (RF4_BR_LITE), m_ptr->hp / 6, 400, FALSE , FALSE,
6355                                         p_ptr->resist_lite, 4, 9, FALSE, 1, 1, dam_max0);
6356
6357                                 DAMCALC(f4 & (RF4_BR_DARK), m_ptr->hp / 6, 400, FALSE , FALSE,
6358                                         p_ptr->resist_dark, 4, 9, FALSE, 1, 1, dam_max0);
6359
6360                                 DAMCALC(f4 & (RF4_BR_CONF), m_ptr->hp / 6, 450, FALSE , FALSE,
6361                                         p_ptr->resist_conf, 5, 9, FALSE, 1, 1, dam_max0);
6362
6363                                 DAMCALC(f4 & (RF4_BR_SOUN), m_ptr->hp / 6, 450, FALSE , FALSE,
6364                                         p_ptr->resist_sound, 5, 9, FALSE, 1, 1, dam_max0);
6365
6366                                 DAMCALC(f4 & (RF4_BR_CHAO), m_ptr->hp / 6, 600, FALSE , FALSE,
6367                                         p_ptr->resist_chaos, 6, 9, FALSE, 1, 1, dam_max0);
6368
6369                                 DAMCALC(f4 & (RF4_BR_DISE), m_ptr->hp / 6, 500, FALSE , FALSE,
6370                                         p_ptr->resist_disen, 6, 9, FALSE, 1, 1, dam_max0);
6371
6372                                 DAMCALC(f4 & (RF4_BR_NEXU), m_ptr->hp / 3, 250, FALSE , FALSE,
6373                                         p_ptr->resist_nexus, 6, 9, FALSE, 1, 1, dam_max0);
6374
6375                                 DAMCALC(f4 & (RF4_BR_TIME), m_ptr->hp / 3, 150, FALSE , FALSE,
6376                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6377
6378                                 DAMCALC(f4 & (RF4_BR_INER), m_ptr->hp / 6, 200, FALSE , FALSE,
6379                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6380
6381                                 DAMCALC(f4 & (RF4_BR_GRAV), m_ptr->hp / 3, 200, FALSE , FALSE,
6382                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6383
6384                                 DAMCALC(f4 & (RF4_BR_SHAR), m_ptr->hp / 6, 500, FALSE , FALSE,
6385                                         p_ptr->resist_shard, 6, 9, FALSE, 1, 1, dam_max0);
6386
6387                                 DAMCALC(f4 & (RF4_BR_PLAS), m_ptr->hp / 6, 150, FALSE , FALSE,
6388                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6389
6390                                 DAMCALC(f4 & (RF4_BR_WALL), m_ptr->hp / 6, 200, FALSE , FALSE,
6391                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6392
6393                                 DAMCALC(f4 & (RF4_BR_MANA), m_ptr->hp / 3, 250, FALSE , FALSE,
6394                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6395
6396                                 DAMCALC(f4 & (RF4_BR_NUKE), m_ptr->hp / 3, 800, FALSE , FALSE,
6397                                         p_ptr->resist_pois, 2, 5,
6398                                         p_ptr->oppose_pois, 2, 5, dam_max0);
6399
6400                                 DAMCALC(f4 & (RF4_BR_DISI), m_ptr->hp / 3, 300, FALSE , FALSE,
6401                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6402
6403
6404                                 DAMCALC(f4 & (RF4_ROCKET), m_ptr->hp / 4, 800, FALSE , FALSE,
6405                                         p_ptr->resist_shard, 1, 2, FALSE, 1, 1, dam_max0);
6406
6407                                 DAMCALC(f5 & (RF5_BA_MANA), rlev*4 + 150, 9999, FALSE , FALSE,
6408                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6409
6410                                 DAMCALC(f5 & (RF5_BA_DARK), rlev*4 + 150, 9999, FALSE , FALSE,
6411                                         p_ptr->resist_dark, 4, 9, FALSE, 1, 1, dam_max0);
6412
6413                                 DAMCALC(f5 & (RF5_BA_LITE), rlev*4 + 150, 9999, FALSE , FALSE,
6414                                         p_ptr->resist_lite, 4, 9, FALSE, 1, 1, dam_max0);
6415
6416
6417                                 DAMCALC(f6 & (RF6_HAND_DOOM), p_ptr->chp*6/10, 9999, FALSE , FALSE,
6418                                         FALSE, 1, 1, FALSE, 1, 1, dam_max0);
6419
6420                         }
6421
6422                         /* Monster melee attacks */
6423                         if(mx <= xx+1 && mx >= xx-1 && my <=yy+1 && my >= yy-1)
6424                         {
6425                                 int m;
6426                                 int dam_melee=0;
6427                                 for (m = 0; m < 4; m++)
6428                                 {
6429                                         int d1, d2;
6430
6431                                         /* Skip non-attacks */
6432                                         if (!r_ptr->blow[m].method) continue;
6433
6434                                         /* Extract the attack info */
6435                                         d1 = r_ptr->blow[m].d_dice;
6436                                         d2 = r_ptr->blow[m].d_side;
6437
6438                                         dam_melee += d1*d2;
6439                                 }
6440                                 if(dam_melee>dam_max0)dam_max0=dam_melee;
6441                         }
6442
6443                         /* Contribution from this monster */
6444                         dam_max+=dam_max0;
6445                 }
6446         }
6447
6448         /* Prevent excessive warning */
6449         if(dam_max > old_damage)
6450         {
6451                 old_damage=dam_max * 3 / 2;
6452
6453                 if (dam_max>(p_ptr->chp)/2)
6454                 {
6455                         object_type *o_ptr = choose_warning_item();
6456
6457                         object_desc(o_name, o_ptr, FALSE, 0);
6458 #ifdef JP
6459                         msg_format("%s¤¬±Ô¤¯¿Ì¤¨¤¿¡ª", o_name);
6460 #else
6461                         msg_format("Your %s pulsates sharply!", o_name);
6462 #endif
6463                         disturb(0,0);
6464 #ifdef JP
6465                         return (get_check("ËÜÅö¤Ë¤³¤Î¤Þ¤Þ¿Ê¤à¤«¡©"));
6466 #else
6467                         return (get_check("Realy want to go ahead? "));
6468 #endif
6469                 }
6470         }
6471         else old_damage = old_damage/2;
6472
6473         c_ptr = &cave[yy][xx];
6474         if (((is_trap(c_ptr->feat) && !easy_disarm) || (c_ptr->info & CAVE_TRAP)) && !one_in_(13))
6475         {
6476                 object_type *o_ptr = choose_warning_item();
6477
6478                 object_desc(o_name, o_ptr, FALSE, 0);
6479 #ifdef JP
6480                 msg_format("%s¤¬¿Ì¤¨¤¿¡ª", o_name);
6481 #else
6482                 msg_format("Your %s pulsates!", o_name);
6483 #endif
6484                 disturb(0,0);
6485 #ifdef JP
6486                 return (get_check("ËÜÅö¤Ë¤³¤Î¤Þ¤Þ¿Ê¤à¤«¡©"));
6487 #else
6488                 return (get_check("Realy want to go ahead? "));
6489 #endif
6490         }
6491         return(TRUE);
6492 }
6493
6494
6495 static bool item_tester_hook_melee_ammo(object_type *o_ptr)
6496 {
6497         switch (o_ptr->tval)
6498         {
6499                 case TV_HAFTED:
6500                 case TV_POLEARM:
6501                 case TV_DIGGING:
6502                 case TV_BOLT:
6503                 case TV_ARROW:
6504                 case TV_SHOT:
6505                 {
6506                         return (TRUE);
6507                 }
6508                 case TV_SWORD:
6509                 {
6510                         if (o_ptr->sval != SV_DOKUBARI) return (TRUE);
6511                 }
6512         }
6513
6514         return (FALSE);
6515 }
6516
6517
6518 /*
6519  *  A structure for smithing
6520  */
6521 typedef struct {
6522         int add;       /* TR flag number or special essence id */
6523         cptr add_name; /* Name of this ability */
6524         int type;      /* Menu number */
6525         int essence;   /* Index for carrying essences */
6526         int value;     /* Needed value to add this ability */
6527 } essence_type;
6528
6529
6530 /*
6531  *  Smithing type data for Weapon smith
6532  */
6533 #ifdef JP
6534 static essence_type essence_info[] =
6535 {
6536         {TR_STR, "ÏÓÎÏ", 4, TR_STR, 20},
6537         {TR_INT, "ÃÎÇ½", 4, TR_INT, 20},
6538         {TR_WIS, "¸¤µ", 4, TR_WIS, 20},
6539         {TR_DEX, "´ïÍÑ¤µ", 4, TR_DEX, 20},
6540         {TR_CON, "ÂÑµ×ÎÏ", 4, TR_CON, 20},
6541         {TR_CHR, "Ì¥ÎÏ", 4, TR_CHR, 20},
6542         {TR_MAGIC_MASTERY, "ËâÎÏ»ÙÇÛ", 4, TR_MAGIC_MASTERY, 20},
6543         {TR_STEALTH, "±£Ì©", 4, TR_STEALTH, 40},
6544         {TR_SEARCH, "Ãµº÷", 4, TR_SEARCH, 15},
6545         {TR_INFRA, "ÀÖ³°Àþ»ëÎÏ", 4, TR_INFRA, 15},
6546         {TR_TUNNEL, "ºÎ·¡", 4, TR_TUNNEL, 15},
6547         {TR_SPEED, "¥¹¥Ô¡¼¥É", 4, TR_SPEED, 12},
6548         {TR_BLOWS, "ÄÉ²Ã¹¶·â", 1, TR_BLOWS, 20},
6549         {TR_CHAOTIC, "¥«¥ª¥¹¹¶·â", 1, TR_CHAOTIC, 15},
6550         {TR_VAMPIRIC, "µÛ·ì¹¶·â", 1, TR_VAMPIRIC, 60},
6551         {TR_IMPACT, "ÃÏ¿ÌÈ¯Æ°", 7, TR_IMPACT, 15},
6552         {TR_BRAND_POIS, "ÆÇ»¦", 1, TR_BRAND_POIS, 20},
6553         {TR_BRAND_ACID, "ÍÏ²ò", 1, TR_BRAND_ACID, 20},
6554         {TR_BRAND_ELEC, "ÅÅ·â", 1, TR_BRAND_ELEC, 20},
6555         {TR_BRAND_FIRE, "¾Æ´þ", 1, TR_BRAND_FIRE, 20},
6556         {TR_BRAND_COLD, "Åà·ë", 1, TR_BRAND_COLD, 20},
6557         {TR_SUST_STR, "ÏÓÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
6558         {TR_SUST_INT, "ÃÎÇ½°Ý»ý", 3, TR_SUST_STR, 15},
6559         {TR_SUST_WIS, "¸¤µ°Ý»ý", 3, TR_SUST_STR, 15},
6560         {TR_SUST_DEX, "´ïÍÑ¤µ°Ý»ý", 3, TR_SUST_STR, 15},
6561         {TR_SUST_CON, "ÂÑµ×ÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
6562         {TR_SUST_CHR, "Ì¥ÎÏ°Ý»ý", 3, TR_SUST_STR, 15},
6563         {TR_IM_ACID, "»ÀÌÈ±Ö", 2, TR_IM_ACID, 20},
6564         {TR_IM_ELEC, "ÅÅ·âÌÈ±Ö", 2, TR_IM_ACID, 20},
6565         {TR_IM_FIRE, "²Ð±êÌÈ±Ö", 2, TR_IM_ACID, 20},
6566         {TR_IM_COLD, "Îäµ¤ÌÈ±Ö", 2, TR_IM_ACID, 20},
6567         {TR_REFLECT, "È¿¼Í", 2, TR_REFLECT, 20},
6568         {TR_FREE_ACT, "ËãáãÃÎ¤é¤º", 3, TR_FREE_ACT, 20},
6569         {TR_HOLD_LIFE, "À¸Ì¿ÎÏ°Ý»ý", 3, TR_HOLD_LIFE, 20},
6570         {TR_RES_ACID, "ÂÑ»À", 2, TR_RES_ACID, 15},
6571         {TR_RES_ELEC, "ÂÑÅÅ·â", 2, TR_RES_ELEC, 15},
6572         {TR_RES_FIRE, "ÂÑ²Ð±ê", 2, TR_RES_FIRE, 15},
6573         {TR_RES_COLD, "ÂÑÎäµ¤", 2, TR_RES_COLD, 15},
6574         {TR_RES_POIS, "ÂÑÆÇ", 2, TR_RES_POIS, 25},
6575         {TR_RES_FEAR, "ÂÑ¶²ÉÝ", 2, TR_RES_FEAR, 20},
6576         {TR_RES_LITE, "ÂÑÁ®¸÷", 2, TR_RES_LITE, 20},
6577         {TR_RES_DARK, "ÂÑ°Å¹õ", 2, TR_RES_DARK, 20},
6578         {TR_RES_BLIND, "ÂÑÌÕÌÜ", 2, TR_RES_BLIND, 20},
6579         {TR_RES_CONF, "ÂÑº®Íð", 2, TR_RES_CONF, 20},
6580         {TR_RES_SOUND, "ÂÑ¹ì²»", 2, TR_RES_SOUND, 20},
6581         {TR_RES_SHARDS, "ÂÑÇËÊÒ", 2, TR_RES_SHARDS, 20},
6582         {TR_RES_NETHER, "ÂÑÃÏ¹ö", 2, TR_RES_NETHER, 20},
6583         {TR_RES_NEXUS, "ÂÑ°ø²Ìº®Íð", 2, TR_RES_NEXUS, 20},
6584         {TR_RES_CHAOS, "ÂÑ¥«¥ª¥¹", 2, TR_RES_CHAOS, 20},
6585         {TR_RES_DISEN, "ÂÑÎô²½", 2, TR_RES_DISEN, 20},
6586         {TR_SH_FIRE, "", 0, -2, 0},
6587         {TR_SH_ELEC, "", 0, -2, 0},
6588         {TR_SH_COLD, "", 0, -2, 0},
6589         {TR_NO_MAGIC, "È¿ËâË¡", 3, TR_NO_MAGIC, 15},
6590         {TR_WARNING, "·Ù¹ð", 3, TR_WARNING, 20},
6591         {TR_FEATHER, "ÉâÍ·", 3, TR_FEATHER, 20},
6592         {TR_LITE, "±Êµ×¸÷¸»", 3, TR_LITE, 15},
6593         {TR_SEE_INVIS, "²Ä»ëÆ©ÌÀ", 3, TR_SEE_INVIS, 20},
6594         {TR_TELEPATHY, "¥Æ¥ì¥Ñ¥·¡¼", 6, TR_TELEPATHY, 15},
6595         {TR_SLOW_DIGEST, "ÃÙ¾Ã²½", 3, TR_SLOW_DIGEST, 15},
6596         {TR_REGEN, "µÞÂ®²óÉü", 3, TR_REGEN, 20},
6597         {TR_TELEPORT, "¥Æ¥ì¥Ý¡¼¥È", 3, TR_TELEPORT, 25},
6598
6599         {TR_SLAY_EVIL, "¼Ù°ÇÜÂÇ", 5, TR_SLAY_EVIL, 100},
6600         {TR_KILL_EVIL, "¼Ù°ÇÜÇÜÂÇ", 0, TR_SLAY_EVIL, 60},
6601         {TR_SLAY_ANIMAL, "Æ°ÊªÇÜÂÇ", 5, TR_SLAY_ANIMAL, 20},
6602         {TR_KILL_ANIMAL, "Æ°ÊªÇÜÇÜÂÇ", 5, TR_SLAY_ANIMAL, 60},
6603         {TR_SLAY_UNDEAD, "ÉÔ»àÇÜÂÇ", 5, TR_SLAY_UNDEAD, 20},
6604         {TR_KILL_UNDEAD, "ÉÔ»àÇÜÇÜÂÇ", 5, TR_SLAY_UNDEAD, 60},
6605         {TR_SLAY_DEMON, "°ËâÇÜÂÇ", 5, TR_SLAY_DEMON, 20},
6606         {TR_KILL_DEMON, "°ËâÇÜÇÜÂÇ", 5, TR_SLAY_DEMON, 60},
6607         {TR_SLAY_ORC, "¥ª¡¼¥¯ÇÜÂÇ", 5, TR_SLAY_ORC, 15},
6608         {TR_KILL_ORC, "¥ª¡¼¥¯ÇÜÇÜÂÇ", 5, TR_SLAY_ORC, 60},
6609         {TR_SLAY_TROLL, "¥È¥í¥ëÇÜÂÇ", 5, TR_SLAY_TROLL, 15},
6610         {TR_KILL_TROLL, "¥È¥í¥ëÇÜÇÜÂÇ", 5, TR_SLAY_TROLL, 60},
6611         {TR_SLAY_GIANT, "µð¿ÍÇÜÂÇ", 5, TR_SLAY_GIANT, 20},
6612         {TR_KILL_GIANT, "µð¿ÍÇÜÇÜÂÇ", 5, TR_SLAY_GIANT, 60},
6613         {TR_SLAY_DRAGON, "ÎµÇÜÂÇ", 5, TR_SLAY_DRAGON, 20},
6614         {TR_KILL_DRAGON, "ÎµÇÜÇÜÂÇ", 5, TR_SLAY_DRAGON, 60},
6615         {TR_SLAY_HUMAN, "¿Í´ÖÇÜÂÇ", 5, TR_SLAY_HUMAN, 20},
6616         {TR_KILL_HUMAN, "¿Í´ÖÇÜÇÜÂÇ", 5, TR_SLAY_HUMAN, 60},
6617
6618         {TR_ESP_ANIMAL, "ưʪESP", 6, TR_SLAY_ANIMAL, 40},
6619         {TR_ESP_UNDEAD, "ÉÔ»àESP", 6, TR_SLAY_UNDEAD, 40},
6620         {TR_ESP_DEMON, "°ËâESP", 6, TR_SLAY_DEMON, 40},
6621         {TR_ESP_ORC, "¥ª¡¼¥¯ESP", 6, TR_SLAY_ORC, 40},
6622         {TR_ESP_TROLL, "¥È¥í¥ëESP", 6, TR_SLAY_TROLL, 40},
6623         {TR_ESP_GIANT, "µð¿ÍESP", 6, TR_SLAY_GIANT, 40},
6624         {TR_ESP_DRAGON, "εESP", 6, TR_SLAY_DRAGON, 40},
6625         {TR_ESP_HUMAN, "¿Í´ÖESP", 6, TR_SLAY_HUMAN, 40},
6626
6627         {ESSENCE_ATTACK, "¹¶·â", 10, TR_ES_ATTACK, 30},
6628         {ESSENCE_AC, "ËÉ¸æ", 10, TR_ES_AC, 15},
6629         {ESSENCE_TMP_RES_ACID, "»ÀÂÑÀÈ¯Æ°", 7, TR_RES_ACID, 50},
6630         {ESSENCE_TMP_RES_ELEC, "ÅÅ·âÂÑÀÈ¯Æ°", 7, TR_RES_ELEC, 50},
6631         {ESSENCE_TMP_RES_FIRE, "²Ð±êÂÑÀÈ¯Æ°", 7, TR_RES_FIRE, 50},
6632         {ESSENCE_TMP_RES_COLD, "Îäµ¤ÂÑÀÈ¯Æ°", 7, TR_RES_COLD, 50},
6633         {ESSENCE_SH_FIRE, "²Ð±ê¥ª¡¼¥é", 7, -1, 50},
6634         {ESSENCE_SH_ELEC, "ÅÅ·â¥ª¡¼¥é", 7, -1, 50},
6635         {ESSENCE_SH_COLD, "Îäµ¤¥ª¡¼¥é", 7, -1, 50},
6636         {ESSENCE_RESISTANCE, "Á´ÂÑÀ", 2, -1, 150},
6637         {ESSENCE_SUSTAIN, "ÁõÈ÷ÊÝ»ý", 10, -1, 10},
6638         {ESSENCE_SLAY_GLOVE, "»¦Ù¤¤Î¾®¼ê", 1, TR_ES_ATTACK, 200},
6639
6640         {-1, NULL, 0, -1, 0}
6641 };
6642 #else
6643 static essence_type essence_info[] =
6644 {
6645         {TR_STR, "strength", 4, TR_STR, 20},
6646         {TR_INT, "intelligence", 4, TR_INT, 20},
6647         {TR_WIS, "wisdom", 4, TR_WIS, 20},
6648         {TR_DEX, "dexterity", 4, TR_DEX, 20},
6649         {TR_CON, "constitution", 4, TR_CON, 20},
6650         {TR_CHR, "charisma", 4, TR_CHR, 20},
6651         {TR_MAGIC_MASTERY, "magic mastery", 4, TR_MAGIC_MASTERY, 20},
6652         {TR_STEALTH, "stealth", 4, TR_STEALTH, 40},
6653         {TR_SEARCH, "serching", 4, TR_SEARCH, 15},
6654         {TR_INFRA, "inflavision", 4, TR_INFRA, 15},
6655         {TR_TUNNEL, "digging", 4, TR_TUNNEL, 15},
6656         {TR_SPEED, "speed", 4, TR_SPEED, 12},
6657         {TR_BLOWS, "extra attack", 1, TR_BLOWS, 20},
6658         {TR_CHAOTIC, "chaos brand", 1, TR_CHAOTIC, 15},
6659         {TR_VAMPIRIC, "vampiric brand", 1, TR_VAMPIRIC, 60},
6660         {TR_SLAY_ANIMAL, "slay animal", 5, TR_SLAY_ANIMAL, 20},
6661         {TR_SLAY_EVIL, "slay evil", 5, TR_SLAY_EVIL, 100},
6662         {TR_SLAY_UNDEAD, "slay undead", 5, TR_SLAY_UNDEAD, 20},
6663         {TR_SLAY_DEMON, "slay demon", 5, TR_SLAY_DEMON, 20},
6664         {TR_SLAY_ORC, "slay orc", 5, TR_SLAY_ORC, 15},
6665         {TR_SLAY_TROLL, "slay troll", 5, TR_SLAY_TROLL, 15},
6666         {TR_SLAY_GIANT, "slay giant", 5, TR_SLAY_GIANT, 20},
6667         {TR_SLAY_DRAGON, "slay dragon", 5, TR_SLAY_DRAGON, 20},
6668         {TR_KILL_DRAGON, "kill dragon", 5, TR_SLAY_DRAGON, 60},
6669         {TR_IMPACT, "quake activation", 7, TR_IMPACT, 15},
6670         {TR_BRAND_POIS, "poison brand", 1, TR_BRAND_POIS, 20},
6671         {TR_BRAND_ACID, "acid brand", 1, TR_BRAND_ACID, 20},
6672         {TR_BRAND_ELEC, "electric brand", 1, TR_BRAND_ELEC, 20},
6673         {TR_BRAND_FIRE, "fire brand", 1, TR_BRAND_FIRE, 20},
6674         {TR_BRAND_COLD, "cold brand", 1, TR_BRAND_COLD, 20},
6675         {TR_SUST_STR, "sustain strength", 3, TR_SUST_STR, 15},
6676         {TR_SUST_INT, "sustain intelligence", 3, TR_SUST_STR, 15},
6677         {TR_SUST_WIS, "sustain wisdom", 3, TR_SUST_STR, 15},
6678         {TR_SUST_DEX, "sustain dexterity", 3, TR_SUST_STR, 15},
6679         {TR_SUST_CON, "sustain constitution", 3, TR_SUST_STR, 15},
6680         {TR_SUST_CHR, "sustain charisma", 3, TR_SUST_STR, 15},
6681         {TR_IM_ACID, "acid immunity", 2, TR_IM_ACID, 20},
6682         {TR_IM_ELEC, "electric immunity", 2, TR_IM_ACID, 20},
6683         {TR_IM_FIRE, "fire immunity", 2, TR_IM_ACID, 20},
6684         {TR_IM_COLD, "cold immunity", 2, TR_IM_ACID, 20},
6685         {TR_REFLECT, "reflection", 2, TR_REFLECT, 20},
6686         {TR_FREE_ACT, "free action", 3, TR_FREE_ACT, 20},
6687         {TR_HOLD_LIFE, "hold life", 3, TR_HOLD_LIFE, 20},
6688         {TR_RES_ACID, "resistance to acid", 2, TR_RES_ACID, 15},
6689         {TR_RES_ELEC, "resistance to electric", 2, TR_RES_ELEC, 15},
6690         {TR_RES_FIRE, "resistance to fire", 2, TR_RES_FIRE, 15},
6691         {TR_RES_COLD, "resistance to cold", 2, TR_RES_COLD, 15},
6692         {TR_RES_POIS, "resistance to poison", 2, TR_RES_POIS, 25},
6693         {TR_RES_FEAR, "resistance to fear", 2, TR_RES_FEAR, 20},
6694         {TR_RES_LITE, "resistance to light", 2, TR_RES_LITE, 20},
6695         {TR_RES_DARK, "resistance to dark", 2, TR_RES_DARK, 20},
6696         {TR_RES_BLIND, "resistance to blind", 2, TR_RES_BLIND, 20},
6697         {TR_RES_CONF, "resistance to confusion", 2, TR_RES_CONF, 20},
6698         {TR_RES_SOUND, "resistance to sound", 2, TR_RES_SOUND, 20},
6699         {TR_RES_SHARDS, "resistance to shard", 2, TR_RES_SHARDS, 20},
6700         {TR_RES_NETHER, "resistance to nether", 2, TR_RES_NETHER, 20},
6701         {TR_RES_NEXUS, "resistance to nexus", 2, TR_RES_NEXUS, 20},
6702         {TR_RES_CHAOS, "resistance to chaos", 2, TR_RES_CHAOS, 20},
6703         {TR_RES_DISEN, "resistance to disenchantment", 2, TR_RES_DISEN, 20},
6704         {TR_SH_FIRE, "", 0, -2, 0},
6705         {TR_SH_ELEC, "", 0, -2, 0},
6706         {TR_SLAY_HUMAN, "slay human", 5, TR_SLAY_HUMAN, 20},
6707         {TR_SH_COLD, "", 0, -2, 0},
6708         {TR_NO_MAGIC, "anti magic", 3, TR_NO_MAGIC, 15},
6709         {TR_WARNING, "warning", 3, TR_WARNING, 20},
6710         {TR_FEATHER, "levitation", 3, TR_FEATHER, 20},
6711         {TR_LITE, "permanent light", 3, TR_LITE, 15},
6712         {TR_SEE_INVIS, "see invisible", 3, TR_SEE_INVIS, 20},
6713         {TR_TELEPATHY, "telepathy", 6, TR_TELEPATHY, 15},
6714         {TR_SLOW_DIGEST, "slow digestion", 3, TR_SLOW_DIGEST, 15},
6715         {TR_REGEN, "regeneration", 3, TR_REGEN, 20},
6716         {TR_TELEPORT, "teleport", 3, TR_TELEPORT, 25},
6717         {TR_KILL_ANIMAL, "kill animal", 5, TR_SLAY_ANIMAL, 60},
6718         {TR_KILL_EVIL, "kill evil", 0, TR_SLAY_EVIL, 60},
6719         {TR_KILL_UNDEAD, "kill undead", 5, TR_SLAY_UNDEAD, 60},
6720         {TR_KILL_DEMON, "kill demon", 5, TR_SLAY_DEMON, 60},
6721         {TR_KILL_ORC, "kill orc", 5, TR_SLAY_ORC, 60},
6722         {TR_KILL_TROLL, "kill troll", 5, TR_SLAY_TROLL, 60},
6723         {TR_KILL_GIANT, "kill giant", 5, TR_SLAY_GIANT, 60},
6724         {TR_KILL_HUMAN, "kill human", 5, TR_SLAY_HUMAN, 60},
6725         {TR_ESP_ANIMAL, "sense animal", 6, TR_SLAY_ANIMAL, 40},
6726         {TR_ESP_UNDEAD, "sense undead", 6, TR_SLAY_UNDEAD, 40},
6727         {TR_ESP_DEMON, "sense demon", 6, TR_SLAY_DEMON, 40},
6728         {TR_ESP_ORC, "sense orc", 6, TR_SLAY_ORC, 40},
6729         {TR_ESP_TROLL, "sense troll", 6, TR_SLAY_TROLL, 40},
6730         {TR_ESP_GIANT, "sense giant", 6, TR_SLAY_GIANT, 40},
6731         {TR_ESP_DRAGON, "sense dragon", 6, TR_SLAY_DRAGON, 40},
6732         {TR_ESP_HUMAN, "sense human", 6, TR_SLAY_HUMAN, 40},
6733
6734         {ESSENCE_ATTACK, "weapon enchant", 10, TR_ES_ATTACK, 30},
6735         {ESSENCE_AC, "armor enchant", 10, TR_ES_AC, 15},
6736         {ESSENCE_TMP_RES_ACID, "resist acid activation", 7, TR_RES_ACID, 50},
6737         {ESSENCE_TMP_RES_ELEC, "resist electricity activation", 7, TR_RES_ELEC, 50},
6738         {ESSENCE_TMP_RES_FIRE, "resist fire activation", 7, TR_RES_FIRE, 50},
6739         {ESSENCE_TMP_RES_COLD, "resist cold activation", 7, TR_RES_COLD, 50},
6740         {ESSENCE_SH_FIRE, "fiery sheath", 7, -1, 50},
6741         {ESSENCE_SH_ELEC, "electric sheath", 7, -1, 50},
6742         {ESSENCE_SH_COLD, "sheath of coldness", 7, -1, 50},
6743         {ESSENCE_RESISTANCE, "resistance", 2, -1, 150},
6744         {ESSENCE_SUSTAIN, "elements proof", 10, -1, 10},
6745         {ESSENCE_SLAY_GLOVE, "gauntlets of slaying", 1, TR_ES_ATTACK, 200},
6746
6747         {-1, NULL, 0, -1, 0}
6748 };
6749 #endif
6750
6751
6752 /*
6753  *  Essense names for Weapon smith
6754  */
6755 #ifdef JP
6756 static cptr essence_name[] =
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         "¹¶·â",
6852         "ËÉ¸æ",
6853
6854         NULL
6855 };
6856
6857 #else
6858
6859 static cptr essence_name[] =
6860 {
6861         "strength",
6862         "intelligen.",
6863         "wisdom",
6864         "dexterity",
6865         "constitut.",
6866         "charisma",
6867         "magic mast.",
6868         "",
6869         "stealth",
6870         "serching",
6871         "inflavision",
6872         "digging",
6873         "speed",
6874         "extra atk",
6875         "chaos brand",
6876         "vampiric",
6877         "slay animal",
6878         "slay evil",
6879         "slay undead",
6880         "slay demon",
6881         "slay orc",
6882         "slay troll",
6883         "slay giant",
6884         "slay dragon",
6885         "",
6886         "",
6887         "quake",
6888         "pois. brand",
6889         "acid brand",
6890         "elec. brand",
6891         "fire brand",
6892         "cold brand",
6893         "sustain",
6894         "",
6895         "",
6896         "",
6897         "",
6898         "",
6899         "",
6900         "",
6901         "immunity",
6902         "",
6903         "",
6904         "",
6905         "",
6906         "reflection",
6907         "free action",
6908         "hold life",
6909         "res. acid",
6910         "res. elec.",
6911         "res. fire",
6912         "res. cold",
6913         "res. poison",
6914         "res. fear",
6915         "res. light",
6916         "res. dark",
6917         "res. blind",
6918         "res.confuse",
6919         "res. sound",
6920         "res. shard",
6921         "res. nether",
6922         "res. nexus",
6923         "res. chaos",
6924         "res. disen.",
6925         "",
6926         "",
6927         "slay human",
6928         "",
6929         "",
6930         "anti magic",
6931         "",
6932         "",
6933         "warning",
6934         "",
6935         "",
6936         "",
6937         "levitation",
6938         "perm. light",
6939         "see invis.",
6940         "telepathy",
6941         "slow dige.",
6942         "regen.",
6943         "",
6944         "",
6945         "",
6946         "",
6947         "",
6948         "",
6949         "",
6950         "",
6951         "teleport",
6952         "",
6953         "",
6954         "weapon enc.",
6955         "armor enc.",
6956
6957         NULL
6958 };
6959 #endif
6960
6961
6962 static void display_essence(void)
6963 {
6964         int i, num = 0;
6965
6966         screen_save();
6967         for (i = 1; i < 22; i++)
6968         {
6969                 prt("",i,0);
6970         }
6971 #ifdef JP
6972         prt("¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô     ¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô     ¥¨¥Ã¥»¥ó¥¹   ¸Ä¿ô", 1, 8);
6973 #else
6974         prt("Essence      Num      Essence      Num      Essence      Num ", 1, 8);
6975 #endif
6976         for (i = 0; essence_name[i]; i++)
6977         {
6978                 if (!essence_name[i][0]) continue;
6979                 prt(format("%-11s %5d", essence_name[i], p_ptr->magic_num1[i]), 2+num%21, 8+num/21*22);
6980                 num++;
6981         }
6982 #ifdef JP
6983         prt("¸½ºß½ê»ý¤·¤Æ¤¤¤ë¥¨¥Ã¥»¥ó¥¹", 0, 0);
6984 #else
6985         prt("List of all essences you have.", 0, 0);
6986 #endif
6987         (void)inkey();
6988         screen_load();
6989         return;
6990 }
6991
6992 static void drain_essence(void)
6993 {
6994         int drain_value[sizeof(p_ptr->magic_num1) / sizeof(s32b)];
6995         int i, item;
6996         int dec = 4;
6997         bool observe = FALSE;
6998         int old_ds, old_dd, old_to_h, old_to_d, old_ac, old_to_a, old_pval, old_name2;
6999         u32b old_flgs[TR_FLAG_SIZE], new_flgs[TR_FLAG_SIZE];
7000         object_type *o_ptr;
7001         cptr            q, s;
7002         byte iy, ix, marked, number;
7003         s16b next_o_idx, weight;
7004
7005         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7006                 drain_value[i] = 0;
7007
7008         item_tester_hook = item_tester_hook_weapon_armour;
7009         item_tester_no_ryoute = TRUE;
7010
7011         /* Get an item */
7012 #ifdef JP
7013         q = "¤É¤Î¥¢¥¤¥Æ¥à¤«¤éÃê½Ð¤·¤Þ¤¹¤«¡©";
7014         s = "Ãê½Ð¤Ç¤¤ë¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
7015 #else
7016         q = "Extract from which item? ";
7017         s = "You have nothing you can extract from.";
7018 #endif
7019
7020         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7021
7022         /* Get the item (in the pack) */
7023         if (item >= 0)
7024         {
7025                 o_ptr = &inventory[item];
7026         }
7027
7028         /* Get the item (on the floor) */
7029         else
7030         {
7031                 o_ptr = &o_list[0 - item];
7032         }
7033
7034         if (object_known_p(o_ptr) && (o_ptr->name1 || o_ptr->name2 || o_ptr->art_name || o_ptr->xtra3)) {
7035                 char o_name[MAX_NLEN];
7036                 object_desc(o_name, o_ptr, FALSE, 0);
7037 #ifdef JP
7038                 if (!get_check(format("ËÜÅö¤Ë%s¤«¤éÃê½Ð¤·¤Æ¤è¤í¤·¤¤¤Ç¤¹¤«¡©", o_name))) return;
7039 #else
7040                 if (!get_check(format("Really extract from %s? ", o_name))) return;
7041 #endif
7042         }
7043
7044         energy_use = 100;
7045
7046         object_flags(o_ptr, old_flgs);
7047         if (have_flag(old_flgs, TR_KILL_DRAGON)) add_flag(old_flgs, TR_SLAY_DRAGON);
7048         if (have_flag(old_flgs, TR_KILL_ANIMAL)) add_flag(old_flgs, TR_SLAY_ANIMAL);
7049         if (have_flag(old_flgs, TR_KILL_EVIL)) add_flag(old_flgs, TR_SLAY_EVIL);
7050         if (have_flag(old_flgs, TR_KILL_UNDEAD)) add_flag(old_flgs, TR_SLAY_UNDEAD);
7051         if (have_flag(old_flgs, TR_KILL_DEMON)) add_flag(old_flgs, TR_SLAY_DEMON);
7052         if (have_flag(old_flgs, TR_KILL_ORC)) add_flag(old_flgs, TR_SLAY_ORC);
7053         if (have_flag(old_flgs, TR_KILL_TROLL)) add_flag(old_flgs, TR_SLAY_TROLL);
7054         if (have_flag(old_flgs, TR_KILL_GIANT)) add_flag(old_flgs, TR_SLAY_GIANT);
7055         if (have_flag(old_flgs, TR_KILL_HUMAN)) add_flag(old_flgs, TR_SLAY_HUMAN);
7056
7057         old_to_a = o_ptr->to_a;
7058         old_ac = o_ptr->ac;
7059         old_to_h = o_ptr->to_h;
7060         old_to_d = o_ptr->to_d;
7061         old_ds = o_ptr->ds;
7062         old_dd = o_ptr->dd;
7063         old_pval = o_ptr->pval;
7064         old_name2 = o_ptr->name2;
7065         if (o_ptr->curse_flags & (TRC_CURSED | TRC_HEAVY_CURSE | TRC_PERMA_CURSE)) dec--;
7066         if (have_flag(old_flgs, TR_AGGRAVATE)) dec--;
7067         if (have_flag(old_flgs, TR_NO_TELE)) dec--;
7068         if (have_flag(old_flgs, TR_DRAIN_EXP)) dec--;
7069         if (have_flag(old_flgs, TR_TY_CURSE)) dec--;
7070
7071         iy = o_ptr->iy;
7072         ix = o_ptr->ix;
7073         next_o_idx = o_ptr->next_o_idx;
7074         marked = o_ptr->marked;
7075         weight = o_ptr->weight;
7076         number = o_ptr->number;
7077
7078         object_prep(o_ptr, o_ptr->k_idx);
7079
7080         o_ptr->iy=iy;
7081         o_ptr->ix=ix;
7082         o_ptr->next_o_idx=next_o_idx;
7083         o_ptr->marked=marked;
7084         o_ptr->number = number;
7085         if (item >= 0) p_ptr->total_weight += (o_ptr->weight*o_ptr->number - weight*number);
7086         o_ptr->ident |= (IDENT_MENTAL);
7087         object_aware(o_ptr);
7088         object_known(o_ptr);
7089
7090         object_flags(o_ptr, new_flgs);
7091
7092         for (i = 0; essence_info[i].add_name; i++)
7093         {
7094                 essence_type *es_ptr = &essence_info[i];
7095                 int pval = 0;
7096
7097                 if (es_ptr->add < TR_FLAG_MAX && is_pval_flag(es_ptr->add) && old_pval)
7098                         pval = (have_flag(new_flgs, es_ptr->add)) ? old_pval - o_ptr->pval : old_pval;
7099
7100                 if (es_ptr->add < TR_FLAG_MAX &&
7101                     (!have_flag(new_flgs, es_ptr->add) || pval) &&
7102                     have_flag(old_flgs, es_ptr->add))
7103                 {
7104                         if (pval)
7105                         {
7106                                 drain_value[es_ptr->essence] += 10 * pval;
7107                         }
7108                         else if (es_ptr->essence != -2)
7109                         {
7110                                 drain_value[es_ptr->essence] += 10;
7111                         }
7112                         else if (es_ptr->add == TR_SH_FIRE)
7113                         {
7114                                 drain_value[TR_BRAND_FIRE] += 10;
7115                                 drain_value[TR_RES_FIRE] += 10;
7116                         }
7117                         else if (es_ptr->add == TR_SH_ELEC)
7118                         {
7119                                 drain_value[TR_BRAND_ELEC] += 10;
7120                                 drain_value[TR_RES_ELEC] += 10;
7121                         }
7122                         else if (es_ptr->add == TR_SH_COLD)
7123                         {
7124                                 drain_value[TR_BRAND_COLD] += 10;
7125                                 drain_value[TR_RES_COLD] += 10;
7126                         }
7127                 }
7128         }
7129
7130         if ((have_flag(old_flgs, TR_FORCE_WEAPON)) && !(have_flag(new_flgs, TR_FORCE_WEAPON)))
7131         {
7132                 drain_value[TR_INT] += 5;
7133                 drain_value[TR_WIS] += 5;
7134         }
7135         if ((have_flag(old_flgs, TR_VORPAL)) && !(have_flag(new_flgs, TR_VORPAL)))
7136         {
7137                 drain_value[TR_BRAND_POIS] += 5;
7138                 drain_value[TR_BRAND_ACID] += 5;
7139                 drain_value[TR_BRAND_ELEC] += 5;
7140                 drain_value[TR_BRAND_FIRE] += 5;
7141                 drain_value[TR_BRAND_COLD] += 5;
7142         }
7143         if ((have_flag(old_flgs, TR_DEC_MANA)) && !(have_flag(new_flgs, TR_DEC_MANA)))
7144         {
7145                 drain_value[TR_INT] += 10;
7146         }
7147         if ((have_flag(old_flgs, TR_XTRA_MIGHT)) && !(have_flag(new_flgs, TR_XTRA_MIGHT)))
7148         {
7149                 drain_value[TR_STR] += 10;
7150         }
7151         if ((have_flag(old_flgs, TR_XTRA_SHOTS)) && !(have_flag(new_flgs, TR_XTRA_SHOTS)))
7152         {
7153                 drain_value[TR_DEX] += 10;
7154         }
7155         if (old_name2 == EGO_2WEAPON)
7156         {
7157                 drain_value[TR_DEX] += 20;
7158         }
7159         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_SWORD) && (o_ptr->tval != TV_BOW))
7160         {
7161                 if (old_ds > o_ptr->ds) drain_value[TR_ES_ATTACK] += (old_ds-o_ptr->ds)*10;
7162
7163                 if (old_dd > o_ptr->dd) drain_value[TR_ES_ATTACK] += (old_dd-o_ptr->dd)*10;
7164         }
7165         if (old_to_h > o_ptr->to_h) drain_value[TR_ES_ATTACK] += (old_to_h-o_ptr->to_h)*10;
7166         if (old_to_d > o_ptr->to_d) drain_value[TR_ES_ATTACK] += (old_to_d-o_ptr->to_d)*10;
7167         if (old_ac > o_ptr->ac) drain_value[TR_ES_AC] += (old_ac-o_ptr->ac)*10;
7168         if (old_to_a > o_ptr->to_a) drain_value[TR_ES_AC] += (old_to_a-o_ptr->to_a)*10;
7169
7170         for (i = 0; i < sizeof(drain_value) / sizeof(int); i++)
7171         {
7172                 drain_value[i] *= number;
7173                 drain_value[i] = drain_value[i] * dec / 4;
7174                 drain_value[i] = MAX(drain_value[i], 0);
7175                 if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) drain_value[i] /= 10;
7176                 if (drain_value[i])
7177                 {
7178                         observe = TRUE;
7179                 }
7180         }
7181         if (!observe)
7182         {
7183 #ifdef JP
7184                 msg_print("¥¨¥Ã¥»¥ó¥¹¤ÏÃê½Ð¤Ç¤¤Þ¤»¤ó¤Ç¤·¤¿¡£");
7185 #else
7186                 msg_print("You were not able to extract any essence.");
7187 #endif
7188         }
7189         else
7190         {
7191 #ifdef JP
7192                 msg_print("Ãê½Ð¤·¤¿¥¨¥Ã¥»¥ó¥¹:");
7193 #else
7194                 msg_print("Extracted essences:");
7195 #endif
7196                 for (i = 0; essence_name[i]; i++)
7197                 {
7198                         if (!essence_name[i][0]) continue;
7199                         if (!drain_value[i]) continue;
7200
7201                         p_ptr->magic_num1[i] += drain_value[i];
7202                         p_ptr->magic_num1[i] = MIN(20000, p_ptr->magic_num1[i]);
7203                         msg_print(NULL);
7204                         msg_format("%s...%d", essence_name[i], drain_value[i]);
7205                 }
7206         }
7207
7208         /* Combine the pack */
7209         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7210
7211         /* Window stuff */
7212         p_ptr->window |= (PW_INVEN);
7213 }
7214
7215
7216
7217 static int choose_essence(void)
7218 {
7219         int mode = 0;
7220         char choice;
7221         int menu_line = (use_menu ? 1 : 0);
7222
7223 #ifdef JP
7224         cptr menu_name[] = {
7225                 "Éð´ïÂ°À",
7226                 "ÂÑÀ",
7227                 "Ç½ÎÏ",
7228                 "¿ôÃÍ",
7229                 "¥¹¥ì¥¤",
7230                 "ESP",
7231                 "¤½¤ÎÂ¾"
7232         };
7233 #else
7234         cptr menu_name[] = {
7235                 "Brand weapon",
7236                 "Resistance",
7237                 "Ability",
7238                 "Magic number",
7239                 "Slay",
7240                 "ESP",
7241                 "Others"
7242         };
7243 #endif
7244         const int mode_max = 7;
7245
7246 #ifdef ALLOW_REPEAT
7247         if (repeat_pull(&mode) && 1 <= mode && mode <= mode_max)
7248                 return mode;
7249         mode = 0;
7250 #endif /* ALLOW_REPEAT */
7251
7252         if (use_menu)
7253         {
7254                 screen_save();
7255
7256                 while(!mode)
7257                 {
7258                         int i;
7259                         for (i = 0; i < mode_max; i++)
7260 #ifdef JP
7261                                 prt(format(" %s %s", (menu_line == 1+i) ? "¡Õ" : "  ", menu_name[i]), 2 + i, 14);
7262                         prt("¤É¤Î¼ïÎà¤Î¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã¤ò¹Ô¤¤¤Þ¤¹¤«¡©", 0, 0);
7263 #else
7264                                 prt(format(" %s %s", (menu_line == 1+i) ? "> " : "  ", menu_name[i]), 2 + i, 14);
7265                         prt("Choose from menu.", 0, 0);
7266 #endif
7267
7268                         choice = inkey();
7269                         switch(choice)
7270                         {
7271                         case ESCAPE:
7272                         case 'z':
7273                         case 'Z':
7274                                 screen_load();
7275                                 return 0;
7276                         case '2':
7277                         case 'j':
7278                         case 'J':
7279                                 menu_line++;
7280                                 break;
7281                         case '8':
7282                         case 'k':
7283                         case 'K':
7284                                 menu_line += mode_max - 1;
7285                                 break;
7286                         case '\r':
7287                         case '\n':
7288                         case 'x':
7289                         case 'X':
7290                                 mode = menu_line;
7291                                 break;
7292                         }
7293                         if (menu_line > mode_max) menu_line -= mode_max;
7294                 }
7295                 screen_load();
7296         }
7297         else
7298         {
7299                 screen_save();
7300                 while (!mode)
7301                 {
7302                         int i;
7303
7304                         for (i = 0; i < mode_max; i++)
7305                                 prt(format("  %c) %s", 'a' + i, menu_name[i]), 2 + i, 14);
7306
7307 #ifdef JP
7308                         if (!get_com("²¿¤òÉÕ²Ã¤·¤Þ¤¹¤«:", &choice, TRUE))
7309 #else
7310                         if (!get_com("Command :", &choice, TRUE))
7311 #endif
7312                         {
7313                                 screen_load();
7314                                 return 0;
7315                         }
7316
7317                         if (isupper(choice)) choice = tolower(choice);
7318
7319                         if ('a' <= choice && choice <= 'a' + (char)mode_max - 1)
7320                                 mode = (int)choice - 'a' + 1;
7321                 }
7322                 screen_load();
7323         }
7324
7325 #ifdef ALLOW_REPEAT
7326         repeat_push(mode);
7327 #endif /* ALLOW_REPEAT */
7328         return mode;
7329 }
7330
7331 static void add_essence(int mode)
7332 {
7333         int item, max_num = 0;
7334         int i;
7335         bool flag,redraw;
7336         char choice;
7337         cptr            q, s;
7338         object_type *o_ptr;
7339         int ask = TRUE;
7340         char out_val[160];
7341         int num[22];
7342         char o_name[MAX_NLEN];
7343         int use_essence;
7344         essence_type *es_ptr;
7345
7346         int menu_line = (use_menu ? 1 : 0);
7347
7348         for (i = 0; essence_info[i].add_name; i++)
7349         {
7350                 es_ptr = &essence_info[i];
7351
7352                 if (es_ptr->type != mode) continue;
7353                 num[max_num++] = i;
7354         }
7355
7356 #ifdef ALLOW_REPEAT
7357         if (!repeat_pull(&i) || i<0 || i>=max_num)
7358         {
7359 #endif /* ALLOW_REPEAT */
7360
7361
7362         /* Nothing chosen yet */
7363         flag = FALSE;
7364
7365         /* No redraw yet */
7366         redraw = FALSE;
7367
7368         /* Build a prompt */
7369 #ifdef JP
7370         (void) strnfmt(out_val, 78, "('*'¤Ç°ìÍ÷, ESC¤ÇÃæÃÇ) ¤É¤ÎÇ½ÎÏ¤òÉÕ²Ã¤·¤Þ¤¹¤«¡©");
7371 #else
7372         (void)strnfmt(out_val, 78, "(*=List, ESC=exit) Add which ability? ");
7373 #endif
7374         if (use_menu) screen_save();
7375
7376         /* Get a spell from the user */
7377
7378         choice = (always_show_list || use_menu) ? ESCAPE:1;
7379         while (!flag)
7380         {
7381                 bool able[22];
7382                 if( choice==ESCAPE ) choice = ' ';
7383                 else if( !get_com(out_val, &choice, FALSE) )break;
7384
7385                 if (use_menu && choice != ' ')
7386                 {
7387                         switch(choice)
7388                         {
7389                                 case '0':
7390                                 {
7391                                         screen_load();
7392                                         return;
7393                                         break;
7394                                 }
7395
7396                                 case '8':
7397                                 case 'k':
7398                                 case 'K':
7399                                 {
7400                                         menu_line += (max_num-1);
7401                                         break;
7402                                 }
7403
7404                                 case '2':
7405                                 case 'j':
7406                                 case 'J':
7407                                 {
7408                                         menu_line++;
7409                                         break;
7410                                 }
7411
7412                                 case '4':
7413                                 case 'h':
7414                                 case 'H':
7415                                 {
7416                                         menu_line = 1;
7417                                         break;
7418                                 }
7419                                 case '6':
7420                                 case 'l':
7421                                 case 'L':
7422                                 {
7423                                         menu_line = max_num;
7424                                         break;
7425                                 }
7426
7427                                 case 'x':
7428                                 case 'X':
7429                                 case '\r':
7430                                 case '\n':
7431                                 {
7432                                         i = menu_line - 1;
7433                                         ask = FALSE;
7434                                         break;
7435                                 }
7436                         }
7437                         if (menu_line > max_num) menu_line -= max_num;
7438                 }
7439                 /* Request redraw */
7440                 if ((choice == ' ') || (choice == '*') || (choice == '?') || (use_menu && ask))
7441                 {
7442                         /* Show the list */
7443                         if (!redraw || use_menu)
7444                         {
7445                                 byte y, x = 10;
7446                                 int ctr;
7447                                 char dummy[80], dummy2[80];
7448                                 byte col;
7449
7450                                 strcpy(dummy, "");
7451
7452                                 /* Show list */
7453                                 redraw = TRUE;
7454
7455                                 /* Save the screen */
7456                                 if (!use_menu) screen_save();
7457
7458                                 for (y = 1; y < 24; y++)
7459                                         prt("", y, x);
7460
7461                                 /* Print header(s) */
7462 #ifdef JP
7463                                 prt(format("   %-43s %6s/%s", "Ç½ÎÏ(É¬Í×¥¨¥Ã¥»¥ó¥¹)", "É¬Í×¿ô", "½ê»ý¿ô"), 1, x);
7464
7465 #else
7466                                 prt(format("   %-43s %6s/%s", "Ability (needed essence)", "Needs", "Possess"), 1, x);
7467 #endif
7468                                 /* Print list */
7469                                 for (ctr = 0; ctr < max_num; ctr++)
7470                                 {
7471                                         es_ptr = &essence_info[num[ctr]];
7472
7473                                         if (use_menu)
7474                                         {
7475                                                 if (ctr == (menu_line-1))
7476 #ifdef JP
7477                                                         strcpy(dummy, "¡Õ ");
7478 #else
7479                                                         strcpy(dummy, ">  ");
7480 #endif
7481                                                 else strcpy(dummy, "   ");
7482
7483                                         }
7484                                         /* letter/number for power selection */
7485                                         else
7486                                         {
7487                                                 sprintf(dummy, "%c) ",I2A(ctr));
7488                                         }
7489
7490                                         strcat(dummy, es_ptr->add_name);
7491
7492                                         col = TERM_WHITE;
7493                                         able[ctr] = TRUE;
7494
7495                                         if (es_ptr->essence != -1)
7496                                         {
7497                                                 strcat(dummy, format("(%s)", essence_name[es_ptr->essence]));
7498                                                 if (p_ptr->magic_num1[es_ptr->essence] < es_ptr->value) able[ctr] = FALSE;
7499                                         }
7500                                         else
7501                                         {
7502                                                 switch(es_ptr->add)
7503                                                 {
7504                                                 case ESSENCE_SH_FIRE:
7505 #ifdef JP
7506                                                         strcat(dummy, "(¾Æ´þ+ÂÑ²Ð±ê)");
7507 #else
7508                                                         strcat(dummy, "(brand fire + res.fire)");
7509 #endif
7510                                                         if (p_ptr->magic_num1[TR_BRAND_FIRE] < es_ptr->value) able[ctr] = FALSE;
7511                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
7512                                                         break;
7513                                                 case ESSENCE_SH_ELEC:
7514 #ifdef JP
7515                                                         strcat(dummy, "(ÅÅ·â+ÂÑÅÅ·â)");
7516 #else
7517                                                         strcat(dummy, "(brand elec. + res. elec.)");
7518 #endif
7519                                                         if (p_ptr->magic_num1[TR_BRAND_ELEC] < es_ptr->value) able[ctr] = FALSE;
7520                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
7521                                                         break;
7522                                                 case ESSENCE_SH_COLD:
7523 #ifdef JP
7524                                                         strcat(dummy, "(Åà·ë+ÂÑÎäµ¤)");
7525 #else
7526                                                         strcat(dummy, "(brand cold + res. cold)");
7527 #endif
7528                                                         if (p_ptr->magic_num1[TR_BRAND_COLD] < es_ptr->value) able[ctr] = FALSE;
7529                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
7530                                                         break;
7531                                                 case ESSENCE_RESISTANCE:
7532 #ifdef JP
7533                                                         strcat(dummy, "(ÂÑ²Ð±ê+ÂÑÎäµ¤+ÂÑÅÅ·â+ÂÑ»À)");
7534 #else
7535                                                         strcat(dummy, "(r.fire+r.cold+r.elec+r.acid)");
7536 #endif
7537                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
7538                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
7539                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
7540                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
7541                                                         break;
7542                                                 case ESSENCE_SUSTAIN:
7543 #ifdef JP
7544                                                         strcat(dummy, "(ÂÑ²Ð±ê+ÂÑÎäµ¤+ÂÑÅÅ·â+ÂÑ»À)");
7545 #else
7546                                                         strcat(dummy, "(r.fire+r.cold+r.elec+r.acid)");
7547 #endif
7548                                                         if (p_ptr->magic_num1[TR_RES_FIRE] < es_ptr->value) able[ctr] = FALSE;
7549                                                         if (p_ptr->magic_num1[TR_RES_COLD] < es_ptr->value) able[ctr] = FALSE;
7550                                                         if (p_ptr->magic_num1[TR_RES_ELEC] < es_ptr->value) able[ctr] = FALSE;
7551                                                         if (p_ptr->magic_num1[TR_RES_ACID] < es_ptr->value) able[ctr] = FALSE;
7552                                                         break;
7553                                                 }
7554                                         }
7555
7556                                         if (!able[ctr]) col = TERM_RED;
7557
7558                                         if (es_ptr->essence != -1)
7559                                         {
7560                                                 sprintf(dummy2, "%-49s %3d/%d", dummy, es_ptr->value, (int)p_ptr->magic_num1[es_ptr->essence]);
7561                                         }
7562                                         else
7563                                         {
7564                                                 sprintf(dummy2, "%-49s %3d/(\?\?)", dummy, es_ptr->value);
7565                                         }
7566
7567                                         c_prt(col, dummy2, ctr+2, x);
7568                                 }
7569                         }
7570
7571                         /* Hide the list */
7572                         else
7573                         {
7574                                 /* Hide list */
7575                                 redraw = FALSE;
7576
7577                                 /* Restore the screen */
7578                                 screen_load();
7579                         }
7580
7581                         /* Redo asking */
7582                         continue;
7583                 }
7584
7585                 if (!use_menu)
7586                 {
7587                         /* Note verify */
7588                         ask = (isupper(choice));
7589
7590                         /* Lowercase */
7591                         if (ask) choice = tolower(choice);
7592
7593                         /* Extract request */
7594                         i = (islower(choice) ? A2I(choice) : -1);
7595                 }
7596
7597                 /* Totally Illegal */
7598                 if ((i < 0) || (i >= max_num) || !able[i])
7599                 {
7600                         bell();
7601                         continue;
7602                 }
7603
7604                 /* Verify it */
7605                 if (ask)
7606                 {
7607                         char tmp_val[160];
7608
7609                         /* Prompt */
7610 #ifdef JP
7611                         (void) strnfmt(tmp_val, 78, "%s¤òÉÕ²Ã¤·¤Þ¤¹¤«¡© ", essence_info[num[i]].add_name);
7612 #else
7613                         (void) strnfmt(tmp_val, 78, "Add the abilitiy of %s? ", essence_info[num[i]].add_name);
7614 #endif
7615
7616                         /* Belay that order */
7617                         if (!get_check(tmp_val)) continue;
7618                 }
7619
7620                 /* Stop the loop */
7621                 flag = TRUE;
7622         }
7623
7624         /* Restore the screen */
7625         if (redraw) screen_load();
7626
7627         if (!flag) return;
7628
7629 #ifdef ALLOW_REPEAT
7630         repeat_push(i);
7631         }
7632 #endif /* ALLOW_REPEAT */
7633
7634         es_ptr = &essence_info[num[i]];
7635
7636         if (es_ptr->add == ESSENCE_SLAY_GLOVE)
7637                 item_tester_tval = TV_GLOVES;
7638         else if (mode == 1)
7639                 item_tester_hook = item_tester_hook_melee_ammo;
7640         else if (es_ptr->add == ESSENCE_ATTACK)
7641                 item_tester_hook = item_tester_hook_weapon;
7642         else if (es_ptr->add == ESSENCE_AC)
7643                 item_tester_hook = item_tester_hook_armour;
7644         else
7645                 item_tester_hook = item_tester_hook_weapon_armour;
7646         item_tester_no_ryoute = TRUE;
7647
7648         /* Get an item */
7649 #ifdef JP
7650         q = "¤É¤Î¥¢¥¤¥Æ¥à¤ò²þÎÉ¤·¤Þ¤¹¤«¡©";
7651         s = "²þÎÉ¤Ç¤¤ë¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
7652 #else
7653         q = "Improve which item? ";
7654         s = "You have nothing to improve.";
7655 #endif
7656
7657         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7658
7659         /* Get the item (in the pack) */
7660         if (item >= 0)
7661         {
7662                 o_ptr = &inventory[item];
7663         }
7664
7665         /* Get the item (on the floor) */
7666         else
7667         {
7668                 o_ptr = &o_list[0 - item];
7669         }
7670
7671         if ((mode != 10) && (o_ptr->name1 || o_ptr->art_name || o_ptr->xtra3))
7672         {
7673 #ifdef JP
7674                 msg_print("¤½¤Î¥¢¥¤¥Æ¥à¤Ï¤³¤ì°Ê¾å²þÎÉ¤Ç¤¤Ê¤¤¡£");
7675 #else
7676                 msg_print("This item is no more able to be improved");
7677 #endif
7678                 return;
7679         }
7680
7681         object_desc(o_name, o_ptr, FALSE, 0);
7682
7683         use_essence = es_ptr->value;
7684         if ((o_ptr->tval >= TV_SHOT) && (o_ptr->tval <= TV_BOLT)) use_essence = (use_essence+9)/10;
7685         if (o_ptr->number > 1)
7686         {
7687                 use_essence *= o_ptr->number;
7688 #ifdef JP
7689                 msg_format("%d¸Ä¤¢¤ë¤Î¤Ç¥¨¥Ã¥»¥ó¥¹¤Ï%dÉ¬Í×¤Ç¤¹¡£", o_ptr->number, use_essence);
7690 #else
7691                 msg_format("It will take %d essences.",use_essence);
7692 #endif
7693
7694         }
7695
7696         if (es_ptr->essence != -1)
7697         {
7698                 if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
7699                 {
7700 #ifdef JP
7701                         msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7702 #else
7703                         msg_print("You don't have enough essences.");
7704 #endif
7705                         return;
7706                 }
7707                 if (is_pval_flag(es_ptr->add))
7708                 {
7709                         if (es_ptr->add == TR_BLOWS)
7710                         {
7711                                 if (o_ptr->pval > 1)
7712                                 {
7713 #ifdef JP
7714                                         if (!get_check("½¤ÀµÃÍ¤Ï1¤Ë¤Ê¤ê¤Þ¤¹¡£¤è¤í¤·¤¤¤Ç¤¹¤«¡©")) return;
7715 #else
7716                                         if (!get_check("The magic number of this weapon will become 1. Are you sure? ")) return;
7717 #endif
7718                                 }
7719                                 o_ptr->pval = 1;
7720                         }
7721                         else if (o_ptr->pval)
7722                         {
7723                                 use_essence *= o_ptr->pval;
7724 #ifdef JP
7725                                 msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£",use_essence);
7726 #else
7727                                 msg_format("It will take %d essences.",use_essence);
7728 #endif
7729                         }
7730                         else
7731                         {
7732                                 char tmp[80];
7733                                 char tmp_val[160];
7734                                 int pval;
7735                                 int limit = MIN(5, p_ptr->magic_num1[es_ptr->essence]/es_ptr->value);
7736
7737
7738 #ifdef JP
7739                                 sprintf(tmp, "¤¤¤¯¤ÄÉÕ²Ã¤·¤Þ¤¹¤«¡© (1-%d): ", limit);
7740 #else
7741                                 sprintf(tmp, "Enchant how many? (1-%d): ", limit);
7742 #endif
7743                                 strcpy(tmp_val, "1");
7744
7745                                 if (!get_string(tmp, tmp_val, 1)) return;
7746                                 pval = atoi(tmp_val);
7747                                 if (pval > limit) pval = limit;
7748                                 else if (pval < 1) pval = 1;
7749                                 o_ptr->pval = pval;
7750                                 use_essence *= pval;
7751 #ifdef JP
7752                                 msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£",use_essence);
7753 #else
7754                                 msg_format("It will take %d essences.",use_essence);
7755 #endif
7756                         }
7757                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
7758                         {
7759 #ifdef JP
7760                                 msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7761 #else
7762                                 msg_print("You don't have enough essences.");
7763 #endif
7764                                 return;
7765                         }
7766                 }
7767                 else if (es_ptr->add == ESSENCE_SLAY_GLOVE)
7768                 {
7769                         char tmp_val[160];
7770                         int val;
7771                         int get_to_h, get_to_d;
7772
7773                         strcpy(tmp_val, "1");
7774 #ifdef JP
7775                         if (!get_string(format("¤¤¤¯¤ÄÉÕ²Ã¤·¤Þ¤¹¤«¡© (1-%d):", p_ptr->lev/7+3), tmp_val, 2)) return;
7776 #else
7777                         if (!get_string(format("Enchant how many? (1-%d):", p_ptr->lev/7+3), tmp_val, 2)) return;
7778 #endif
7779                         val = atoi(tmp_val);
7780                         if (val > p_ptr->lev/7+3) val = p_ptr->lev/7+3;
7781                         else if (val < 1) val = 1;
7782                         use_essence *= val;
7783 #ifdef JP
7784                         msg_format("¥¨¥Ã¥»¥ó¥¹¤ò%d¸Ä»ÈÍÑ¤·¤Þ¤¹¡£",use_essence);
7785 #else
7786                         msg_format("It will take %d essences.",use_essence);
7787 #endif
7788                         if (p_ptr->magic_num1[es_ptr->essence] < use_essence)
7789                         {
7790 #ifdef JP
7791                                 msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7792 #else
7793                                 msg_print("You don't have enough essences");
7794 #endif
7795                                 return;
7796                         }
7797                         get_to_h = ((val+1)/2+randint0(val/2+1));
7798                         get_to_d = ((val+1)/2+randint0(val/2+1));
7799                         o_ptr->xtra4 = (get_to_h<<8)+get_to_d;
7800                         o_ptr->to_h += get_to_h;
7801                         o_ptr->to_d += get_to_d;
7802                 }
7803                 p_ptr->magic_num1[es_ptr->essence] -= use_essence;
7804                 if (es_ptr->add == ESSENCE_ATTACK)
7805                 {
7806                         if ((o_ptr->to_h >= p_ptr->lev/5+5) && (o_ptr->to_d >= p_ptr->lev/5+5))
7807                         {
7808 #ifdef JP
7809                                 msg_print("²þÎÉ¤Ë¼ºÇÔ¤·¤¿¡£");
7810 #else
7811                                 msg_print("You failed to enchant.");
7812 #endif
7813                                 energy_use = 100;
7814                                 return;
7815                         }
7816                         else
7817                         {
7818                                 if (o_ptr->to_h < p_ptr->lev/5+5) o_ptr->to_h++;
7819                                 if (o_ptr->to_d < p_ptr->lev/5+5) o_ptr->to_d++;
7820                         }
7821                 }
7822                 else if (es_ptr->add == ESSENCE_AC)
7823                 {
7824                         if (o_ptr->to_a >= p_ptr->lev/5+5)
7825                         {
7826 #ifdef JP
7827                                 msg_print("²þÎÉ¤Ë¼ºÇÔ¤·¤¿¡£");
7828 #else
7829                                 msg_print("You failed to enchant.");
7830 #endif
7831                                 energy_use = 100;
7832                                 return;
7833                         }
7834                         else
7835                         {
7836                                 if (o_ptr->to_a < p_ptr->lev/5+5) o_ptr->to_a++;
7837                         }
7838                 }
7839                 else
7840                 {
7841                         o_ptr->xtra3 = es_ptr->add + 1;
7842                 }
7843         }
7844         else
7845         {
7846                 bool success = TRUE;
7847
7848                 switch(es_ptr->add)
7849                 {
7850                 case ESSENCE_SH_FIRE:
7851                         if ((p_ptr->magic_num1[TR_BRAND_FIRE] < use_essence) || (p_ptr->magic_num1[TR_RES_FIRE] < use_essence))
7852                         {
7853                                 success = FALSE;
7854                                 break;
7855                         }
7856                         p_ptr->magic_num1[TR_BRAND_FIRE] -= use_essence;
7857                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
7858                         break;
7859                 case ESSENCE_SH_ELEC:
7860                         if ((p_ptr->magic_num1[TR_BRAND_ELEC] < use_essence) || (p_ptr->magic_num1[TR_RES_ELEC] < use_essence))
7861                         {
7862                                 success = FALSE;
7863                                 break;
7864                         }
7865                         p_ptr->magic_num1[TR_BRAND_ELEC] -= use_essence;
7866                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
7867                         break;
7868                 case ESSENCE_SH_COLD:
7869                         if ((p_ptr->magic_num1[TR_BRAND_COLD] < use_essence) || (p_ptr->magic_num1[TR_RES_COLD] < use_essence))
7870                         {
7871                                 success = FALSE;
7872                                 break;
7873                         }
7874                         p_ptr->magic_num1[TR_BRAND_COLD] -= use_essence;
7875                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
7876                         break;
7877                 case ESSENCE_RESISTANCE:
7878                 case ESSENCE_SUSTAIN:
7879                         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))
7880                         {
7881                                 success = FALSE;
7882                                 break;
7883                         }
7884                         p_ptr->magic_num1[TR_RES_ACID] -= use_essence;
7885                         p_ptr->magic_num1[TR_RES_ELEC] -= use_essence;
7886                         p_ptr->magic_num1[TR_RES_FIRE] -= use_essence;
7887                         p_ptr->magic_num1[TR_RES_COLD] -= use_essence;
7888                         break;
7889                 }
7890                 if (!success)
7891                 {
7892 #ifdef JP
7893                         msg_print("¥¨¥Ã¥»¥ó¥¹¤¬Â¤ê¤Ê¤¤¡£");
7894 #else
7895                         msg_print("You don't have enough essences");
7896 #endif
7897                         return;
7898                 }
7899                 if (es_ptr->add == ESSENCE_SUSTAIN)
7900                 {
7901                         add_flag(o_ptr->art_flags, TR_IGNORE_ACID);
7902                         add_flag(o_ptr->art_flags, TR_IGNORE_ELEC);
7903                         add_flag(o_ptr->art_flags, TR_IGNORE_FIRE);
7904                         add_flag(o_ptr->art_flags, TR_IGNORE_COLD);
7905                 }
7906                 else
7907                 {
7908                         o_ptr->xtra3 = es_ptr->add + 1;
7909                 }
7910         }
7911
7912         energy_use = 100;
7913
7914 #ifdef JP
7915         msg_format("%s¤Ë%s¤ÎÇ½ÎÏ¤òÉÕ²Ã¤·¤Þ¤·¤¿¡£", o_name, es_ptr->add_name);
7916 #else
7917         msg_format("You have added ability of %s to %s.", es_ptr->add_name, o_name);
7918 #endif
7919
7920         /* Combine the pack */
7921         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
7922
7923         /* Window stuff */
7924         p_ptr->window |= (PW_INVEN);
7925 }
7926
7927
7928 static bool item_tester_hook_kaji(object_type *o_ptr)
7929 {
7930         switch (o_ptr->tval)
7931         {
7932                 case TV_SWORD:
7933                 case TV_HAFTED:
7934                 case TV_POLEARM:
7935                 case TV_DIGGING:
7936                 case TV_BOW:
7937                 case TV_BOLT:
7938                 case TV_ARROW:
7939                 case TV_SHOT:
7940                 case TV_DRAG_ARMOR:
7941                 case TV_HARD_ARMOR:
7942                 case TV_SOFT_ARMOR:
7943                 case TV_SHIELD:
7944                 case TV_CLOAK:
7945                 case TV_CROWN:
7946                 case TV_HELM:
7947                 case TV_BOOTS:
7948                 case TV_GLOVES:
7949                 {
7950                         if (o_ptr->xtra3) return (TRUE);
7951                 }
7952         }
7953
7954         return (FALSE);
7955 }
7956
7957
7958 static void erase_essence(void)
7959 {
7960         int item;
7961         cptr q, s;
7962         object_type *o_ptr;
7963         char o_name[MAX_NLEN];
7964         u32b flgs[TR_FLAG_SIZE];
7965
7966         item_tester_hook = item_tester_hook_kaji;
7967
7968         /* Get an item */
7969 #ifdef JP
7970         q = "¤É¤Î¥¢¥¤¥Æ¥à¤Î¥¨¥Ã¥»¥ó¥¹¤ò¾Ãµî¤·¤Þ¤¹¤«¡©";
7971         s = "¥¨¥Ã¥»¥ó¥¹¤òÉÕ²Ã¤·¤¿¥¢¥¤¥Æ¥à¤¬¤¢¤ê¤Þ¤»¤ó¡£";
7972 #else
7973         q = "Remove from which item? ";
7974         s = "You have nothing to remove essence.";
7975 #endif
7976
7977         if (!get_item(&item, q, s, (USE_INVEN | USE_FLOOR))) return;
7978
7979         /* Get the item (in the pack) */
7980         if (item >= 0)
7981         {
7982                 o_ptr = &inventory[item];
7983         }
7984
7985         /* Get the item (on the floor) */
7986         else
7987         {
7988                 o_ptr = &o_list[0 - item];
7989         }
7990
7991         object_desc(o_name, o_ptr, FALSE, 0);
7992 #ifdef JP
7993         if (!get_check(format("¤è¤í¤·¤¤¤Ç¤¹¤«¡©[%s]", o_name))) return;
7994 #else
7995         if (!get_check(format("Are you sure?[%s]", o_name))) return;
7996 #endif
7997
7998         energy_use = 100;
7999
8000         if (o_ptr->xtra3 == 1+ESSENCE_SLAY_GLOVE)
8001         {
8002                 o_ptr->to_h -= (o_ptr->xtra4>>8);
8003                 o_ptr->to_d -= (o_ptr->xtra4 & 0x000f);
8004                 o_ptr->xtra4 = 0;
8005         }
8006         o_ptr->xtra3 = 0;
8007         object_flags(o_ptr, flgs);
8008         if (!(have_pval_flags(flgs))) o_ptr->pval = 0;
8009 #ifdef JP
8010         msg_print("¥¨¥Ã¥»¥ó¥¹¤ò¼è¤êµî¤Ã¤¿¡£");
8011 #else
8012         msg_print("You removed all essence you have added");
8013 #endif
8014
8015         /* Combine the pack */
8016         p_ptr->notice |= (PN_COMBINE | PN_REORDER);
8017
8018         /* Window stuff */
8019         p_ptr->window |= (PW_INVEN);
8020 }
8021
8022 void do_cmd_kaji(bool only_browse)
8023 {
8024         int mode = 0;
8025         char choice;
8026
8027         int menu_line = (use_menu ? 1 : 0);
8028
8029         if (!only_browse)
8030         {
8031                 if (p_ptr->confused)
8032                 {
8033 #ifdef JP
8034                         msg_print("º®Íð¤·¤Æ¤¤¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8035 #else
8036                         msg_print("You are too confused!");
8037 #endif
8038
8039                         return;
8040                 }
8041                 if (p_ptr->blind)
8042                 {
8043 #ifdef JP
8044                         msg_print("ÌÜ¤¬¸«¤¨¤Ê¤¯¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8045 #else
8046                         msg_print("You are blind!");
8047 #endif
8048
8049                         return;
8050                 }
8051                 if (p_ptr->image)
8052                 {
8053 #ifdef JP
8054                         msg_print("¤¦¤Þ¤¯¸«¤¨¤Ê¤¯¤Æºî¶È¤Ç¤¤Ê¤¤¡ª");
8055 #else
8056                         msg_print("You are hullcinating!");
8057 #endif
8058
8059                         return;
8060                 }
8061         }
8062
8063 #ifdef ALLOW_REPEAT
8064         if (!(repeat_pull(&mode) && 1 <= mode && mode <= 5))
8065         {
8066 #endif /* ALLOW_REPEAT */
8067
8068         if (only_browse) screen_save();
8069         do {
8070         if (!only_browse) screen_save();
8071         if (use_menu)
8072         {
8073                 while(!mode)
8074                 {
8075 #ifdef JP
8076                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹°ìÍ÷", (menu_line == 1) ? "¡Õ" : "  "), 2, 14);
8077                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹Ãê½Ð", (menu_line == 2) ? "¡Õ" : "  "), 3, 14);
8078                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹¾Ãµî", (menu_line == 3) ? "¡Õ" : "  "), 4, 14);
8079                         prt(format(" %s ¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã", (menu_line == 4) ? "¡Õ" : "  "), 5, 14);
8080                         prt(format(" %s Éð´ï/ËÉ¶ñ¶¯²½", (menu_line == 5) ? "¡Õ" : "  "), 6, 14);
8081                         prt(format("¤É¤Î¼ïÎà¤Îµ»½Ñ¤ò%s¤Þ¤¹¤«¡©", only_browse ? "Ä´¤Ù" : "»È¤¤"), 0, 0);
8082 #else
8083                         prt(format(" %s List essences", (menu_line == 1) ? "> " : "  "), 2, 14);
8084                         prt(format(" %s Extract essence", (menu_line == 2) ? "> " : "  "), 3, 14);
8085                         prt(format(" %s Remove essence", (menu_line == 3) ? "> " : "  "), 4, 14);
8086                         prt(format(" %s Add essence", (menu_line == 4) ? "> " : "  "), 5, 14);
8087                         prt(format(" %s Enchant weapon/armor", (menu_line == 5) ? "> " : "  "), 6, 14);
8088                         prt(format("Choose command from menu."), 0, 0);
8089 #endif
8090                         choice = inkey();
8091                         switch(choice)
8092                         {
8093                         case ESCAPE:
8094                         case 'z':
8095                         case 'Z':
8096                                 screen_load();
8097                                 return;
8098                         case '2':
8099                         case 'j':
8100                         case 'J':
8101                                 menu_line++;
8102                                 break;
8103                         case '8':
8104                         case 'k':
8105                         case 'K':
8106                                 menu_line+= 4;
8107                                 break;
8108                         case '\r':
8109                         case '\n':
8110                         case 'x':
8111                         case 'X':
8112                                 mode = menu_line;
8113                                 break;
8114                         }
8115                         if (menu_line > 5) menu_line -= 5;
8116                 }
8117         }
8118
8119         else
8120         {
8121                 while (!mode)
8122                 {
8123 #ifdef JP
8124                         prt("  a) ¥¨¥Ã¥»¥ó¥¹°ìÍ÷", 2, 14);
8125                         prt("  b) ¥¨¥Ã¥»¥ó¥¹Ãê½Ð", 3, 14);
8126                         prt("  c) ¥¨¥Ã¥»¥ó¥¹¾Ãµî", 4, 14);
8127                         prt("  d) ¥¨¥Ã¥»¥ó¥¹ÉÕ²Ã", 5, 14);
8128                         prt("  e) Éð´ï/ËÉ¶ñ¶¯²½", 6, 14);
8129                         if (!get_com(format("¤É¤ÎÇ½ÎÏ¤ò%s¤Þ¤¹¤«:", only_browse ? "Ä´¤Ù" : "»È¤¤"), &choice, TRUE))
8130 #else
8131                         prt("  a) List essences", 2, 14);
8132                         prt("  b) Extract essence", 3, 14);
8133                         prt("  c) Remove essence", 4, 14);
8134                         prt("  d) Add essence", 5, 14);
8135                         prt("  e) Enchant weapon/armor", 6, 14);
8136                         if (!get_com("Command :", &choice, TRUE))
8137 #endif
8138                         {
8139                                 screen_load();
8140                                 return;
8141                         }
8142                         switch (choice)
8143                         {
8144                         case 'A':
8145                         case 'a':
8146                                 mode = 1;
8147                                 break;
8148                         case 'B':
8149                         case 'b':
8150                                 mode = 2;
8151                                 break;
8152                         case 'C':
8153                         case 'c':
8154                                 mode = 3;
8155                                 break;
8156                         case 'D':
8157                         case 'd':
8158                                 mode = 4;
8159                                 break;
8160                         case 'E':
8161                         case 'e':
8162                                 mode = 5;
8163                                 break;
8164                         }
8165                 }
8166         }
8167
8168         if (only_browse)
8169         {
8170                 char temp[62*5];
8171                 int line, j;
8172
8173                 /* Clear lines, position cursor  (really should use strlen here) */
8174                 Term_erase(14, 21, 255);
8175                 Term_erase(14, 20, 255);
8176                 Term_erase(14, 19, 255);
8177                 Term_erase(14, 18, 255);
8178                 Term_erase(14, 17, 255);
8179                 Term_erase(14, 16, 255);
8180
8181                 roff_to_buf( kaji_tips[mode-1],62,temp);
8182                 for(j=0, line = 17;temp[j];j+=(1+strlen(&temp[j])))
8183                 {
8184                         prt(&temp[j], line, 15);
8185                         line++;
8186                 }
8187                 mode = 0;
8188         }
8189         if (!only_browse) screen_load();
8190         } while (only_browse);
8191 #ifdef ALLOW_REPEAT
8192         repeat_push(mode);
8193         }
8194 #endif /* ALLOW_REPEAT */
8195
8196         switch(mode)
8197         {
8198                 case 1: display_essence();break;
8199                 case 2: drain_essence();break;
8200                 case 3: erase_essence();break;
8201                 case 4:
8202                         mode = choose_essence();
8203                         if (mode == 0)
8204                                 break;
8205                         add_essence(mode);
8206                         break;
8207                 case 5: add_essence(10);break;
8208         }
8209 }