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