src/object2.c

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