src/object2.c

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