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