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