ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/treasure.c
(Generate patch)

Comparing deliantra/server/common/treasure.c (file contents):
Revision 1.3 by elmex, Wed Aug 9 15:57:27 2006 UTC vs.
Revision 1.5 by elmex, Fri Aug 11 12:40:22 2006 UTC

1 1
2/* 2/*
3 * static char *rcs_treasure_c = 3 * static char *rcs_treasure_c =
4 * "$Id: treasure.c,v 1.3 2006/08/09 15:57:27 elmex Exp $"; 4 * "$Id: treasure.c,v 1.5 2006/08/11 12:40:22 elmex Exp $";
5 */ 5 */
6 6
7/* 7/*
8 CrossFire, A Multiplayer game for X-windows 8 CrossFire, A Multiplayer game for X-windows
9 9
… …
331 331
332 332
333 if((int)t->chance >= 100 || (RANDOM()%100 + 1) < (int) t->chance) { 333 if((int)t->chance >= 100 || (RANDOM()%100 + 1) < (int) t->chance) {
334 if (t->name) { 334 if (t->name) {
335 if (strcmp(t->name,"NONE") && difficulty>=t->magic) 335 if (strcmp(t->name,"NONE") && difficulty>=t->magic)
336 {
336 create_treasure(find_treasurelist(t->name), op, flag, difficulty, tries); 337 create_treasure(find_treasurelist(t->name), op, flag, difficulty, tries);
338 }
337 } 339 }
338 else { 340 else {
339 if(t->item->clone.invisible != 0 || ! (flag & GT_INVISIBLE)) { 341 if(t->item->clone.invisible != 0 || ! (flag & GT_INVISIBLE)) {
340 tmp=arch_to_object(t->item); 342 tmp=arch_to_object(t->item);
341 if(t->nrof&&tmp->nrof<=1) 343 if(t->nrof&&tmp->nrof<=1)
… …
485 * 487 *
486 * elmex Wed Aug 9 17:44:59 CEST 2006: 488 * elmex Wed Aug 9 17:44:59 CEST 2006:
487 * Removed multiplicator, too many high-level items were generated on low-difficulty maps. 489 * Removed multiplicator, too many high-level items were generated on low-difficulty maps.
488 */ 490 */
489 491
490int level_for_item(const object *op, int difficulty) 492int level_for_item (const object *op, int difficulty)
491{ 493{
492 int mult = 0, olevel = 0; 494 int mult = 0, olevel = 0;
493 495
494 if (!op->inv) 496 if (!op->inv)
495 { 497 {
… …
510 512
511/* 513/*
512 * Based upon the specified difficulty and upon the difftomagic_list array, 514 * Based upon the specified difficulty and upon the difftomagic_list array,
513 * a random magical bonus is returned. This is used when determine 515 * a random magical bonus is returned. This is used when determine
514 * the magical bonus created on specific maps. 516 * the magical bonus created on specific maps.
517 *
518 * elmex Thu Aug 10 18:45:44 CEST 2006:
519 * Scaling difficulty by max_level, as difficulty is a level and not some
520 * weird integer between 1-31.
521 *
515 */ 522 */
516 523
517int magic_from_difficulty(int difficulty) 524int magic_from_difficulty(int difficulty)
518{ 525{
519 int percent,loop; 526 int percent = 0, magic = 0;
527 int scaled_diff = ((double) difficulty / settings.max_level) * DIFFLEVELS;
520 528
521 difficulty--; 529 scaled_diff--;
522 if(difficulty<0)
523 difficulty=0;
524 530
531 if(scaled_diff < 0)
532 scaled_diff = 0;
533
525 if (difficulty>=DIFFLEVELS) 534 if (scaled_diff >= DIFFLEVELS)
526 difficulty=DIFFLEVELS-1; 535 scaled_diff = DIFFLEVELS-1;
527 536
528 percent = RANDOM()%100; 537 percent = RANDOM()%100;
529 538
530 for(loop=0;loop<(MAXMAGIC+1);++loop) { 539 for(magic = 0; magic < (MAXMAGIC + 1); magic++)
540 {
531 percent -= difftomagic_list[difficulty][loop]; 541 percent -= difftomagic_list[scaled_diff][magic];
542
532 if (percent<0) 543 if (percent < 0)
533 break; 544 break;
534 } 545 }
535 if (loop==(MAXMAGIC+1)) { 546
547 if (magic == (MAXMAGIC + 1))
548 {
536 LOG(llevError,"Warning, table for difficulty %d bad.\n",difficulty); 549 LOG(llevError,"Warning, table for difficulty (scaled %d) %d bad.\n", scaled_diff, difficulty);
537 loop=0; 550 magic = 0;
538 } 551 }
552
553 magic = (RANDOM() % 3) ? magic : -magic;
554
539/* LOG(llevDebug, "Chose magic %d for difficulty %d\n", loop, difficulty);*/ 555 /* LOG(llevDebug, "Chose magic %d for difficulty (scaled %d) %d\n", magic, scaled_diff, difficulty); */
540 return (RANDOM()%3)?loop:-loop; 556
557 return magic;
541} 558}
542 559
543/* 560/*
544 * Sets magical bonus in an object, and recalculates the effect on 561 * Sets magical bonus in an object, and recalculates the effect on
545 * the armour variable, and the effect on speed of armour. 562 * the armour variable, and the effect on speed of armour.
… …
745 * value. 762 * value.
746 * GT_MINIMAL: Does minimal processing on the object - just enough to make it 763 * GT_MINIMAL: Does minimal processing on the object - just enough to make it
747 * a working object - don't change magic, value, etc, but set it material 764 * a working object - don't change magic, value, etc, but set it material
748 * type as appropriate, for objects that need spell objects, set those, etc 765 * type as appropriate, for objects that need spell objects, set those, etc
749 */ 766 */
767
750void fix_generated_item (object *op, object *creator, int difficulty, 768void fix_generated_item (object * op, object * creator, int difficulty,
751 int max_magic, int flags) 769 int max_magic, int flags)
752{ 770{
753 int was_magic = op->magic, num_enchantments=0, save_item_power; 771 int was_magic = op->magic, num_enchantments = 0, save_item_power = 0;
754 772
755 if(!creator||creator->type==op->type) creator=op; /*safety & to prevent polymorphed 773 if (!creator || creator->type == op->type)
756 * objects giving attributes */ 774 creator = op; /*safety & to prevent polymorphed objects giving attributes */
757 775
758 /* If we make an artifact, this information will be destroyed */ 776 /* If we make an artifact, this information will be destroyed */
759 save_item_power = op->item_power; 777 save_item_power = op->item_power;
760 op->item_power = 0; 778 op->item_power = 0;
761 779
762 if (op->randomitems && op->type != SPELL) { 780 if (op->randomitems && op->type != SPELL)
781 {
763 create_treasure(op->randomitems, op,flags ,difficulty, 0); 782 create_treasure (op->randomitems, op, flags, difficulty, 0);
764 if (!op->inv) LOG(llevDebug,"fix_generated_item: Unable to generate treasure for %s\n", 783 if (!op->inv)
765 op->name); 784 LOG (llevDebug,
785 "fix_generated_item: Unable to generate treasure for %s\n",
786 op->name);
787
766 /* So the treasure doesn't get created again */ 788 /* So the treasure doesn't get created again */
767 op->randomitems = NULL; 789 op->randomitems = NULL;
768 } 790 }
769 791
770 if (difficulty<1) difficulty=1; 792 if (difficulty < 1)
793 difficulty = 1;
794
771 if (!(flags & GT_MINIMAL)) { 795 if (!(flags & GT_MINIMAL))
796 {
772 if (op->arch == crown_arch) { 797 if (op->arch == crown_arch)
798 {
773 set_magic(difficulty>25?30:difficulty+5, op, max_magic, flags); 799 set_magic (difficulty, op, max_magic, flags);
774 num_enchantments = calc_item_power(op, 1); 800 num_enchantments = calc_item_power (op, 1);
775 generate_artifact(op,difficulty); 801 generate_artifact (op, difficulty);
776 } else { 802 }
803 else
804 {
777 if(!op->magic && max_magic) 805 if (!op->magic && max_magic)
778 set_magic(difficulty,op,max_magic, flags); 806 set_magic (difficulty, op, max_magic, flags);
807
779 num_enchantments = calc_item_power(op, 1); 808 num_enchantments = calc_item_power (op, 1);
809
780 if ((!was_magic && !(RANDOM()%CHANCE_FOR_ARTIFACT)) || op->type == HORN || 810 if ((!was_magic && !(RANDOM () % CHANCE_FOR_ARTIFACT))
781 difficulty >= 999 ) 811 || op->type == HORN
812 || difficulty >= settings.max_level) /* high difficulties always generate an artifact,
813 * used for shop_floors or treasures */
782 generate_artifact(op, difficulty); 814 generate_artifact (op, difficulty);
783 } 815 }
784 816
785 /* Object was made an artifact. Calculate its item_power rating. 817 /* Object was made an artifact. Calculate its item_power rating.
786 * the item_power in the object is what the artfiact adds. 818 * the item_power in the object is what the artfiact adds.
787 */ 819 */
788 if (op->title) { 820 if (op->title)
821 {
789 /* if save_item_power is set, then most likely we started with an 822 /* if save_item_power is set, then most likely we started with an
790 * artifact and have added new abilities to it - this is rare, but 823 * artifact and have added new abilities to it - this is rare, but
791 * but I have seen things like 'strange rings of fire'. So just figure 824 * but I have seen things like 'strange rings of fire'. So just figure
792 * out the power from the base power plus what this one adds. Note 825 * out the power from the base power plus what this one adds. Note
793 * that since item_power is not quite linear, this actually ends up 826 * that since item_power is not quite linear, this actually ends up
794 * being somewhat of a bonus 827 * being somewhat of a bonus
795 */ 828 */
796 if (save_item_power) { 829 if (save_item_power)
830 op->item_power =
797 op->item_power = save_item_power + get_power_from_ench(op->item_power); 831 save_item_power + get_power_from_ench (op->item_power);
798 } else { 832 else
833 op->item_power =
799 op->item_power = get_power_from_ench(op->item_power + num_enchantments); 834 get_power_from_ench (op->item_power + num_enchantments);
800 } 835 }
801 } else if (save_item_power) { 836 else if (save_item_power)
837 {
802 /* restore the item_power field to the object if we haven't changed it. 838 /* restore the item_power field to the object if we haven't changed it.
803 * we don't care about num_enchantments - that will basically just 839 * we don't care about num_enchantments - that will basically just
804 * have calculated some value from the base attributes of the archetype. 840 * have calculated some value from the base attributes of the archetype.
805 */ 841 */
806 op->item_power = save_item_power; 842 op->item_power = save_item_power;
807 } 843 }
844 else
845 {
846 /* item_power was zero. This is suspicious, as it may be because it
847 * was never previously calculated. Let's compute a value and see if
848 * it is non-zero. If it indeed is, then assign it as the new
849 * item_power value.
850 * - gros, 21th of July 2006.
851 */
852 op->item_power = calc_item_power(op,0);
853 save_item_power = op->item_power; /* Just in case it would get used
854 * again below */
855 }
808 } 856 }
809 857
810 /* materialtype modifications. Note we allow this on artifacts. */ 858 /* materialtype modifications. Note we allow this on artifacts. */
811
812 set_materialname(op, difficulty, NULL); 859 set_materialname (op, difficulty, NULL);
813 860
814 if (flags & GT_MINIMAL) { 861 if (flags & GT_MINIMAL)
862 {
815 if (op->type == POTION) 863 if (op->type == POTION)
816 /* Handle healing and magic power potions */ 864 /* Handle healing and magic power potions */
817 if (op->stats.sp && !op->randomitems) { 865 if (op->stats.sp && !op->randomitems)
818 object *tmp; 866 {
867 object *tmp;
819 868
820 tmp = get_archetype(spell_mapping[op->stats.sp]); 869 tmp = get_archetype (spell_mapping[op->stats.sp]);
821 insert_ob_in_ob(tmp, op); 870 insert_ob_in_ob (tmp, op);
822 op->stats.sp=0; 871 op->stats.sp = 0;
872 }
823 } 873 }
824 }
825 else if (!op->title) /* Only modify object if not special */ 874 else if (!op->title) /* Only modify object if not special */
826 switch(op->type) { 875 switch (op->type)
876 {
827 case WEAPON: 877 case WEAPON:
828 case ARMOUR: 878 case ARMOUR:
829 case SHIELD: 879 case SHIELD:
830 case HELMET: 880 case HELMET:
831 case CLOAK: 881 case CLOAK:
832 if (QUERY_FLAG(op, FLAG_CURSED) && !(RANDOM()%4)) 882 if (QUERY_FLAG (op, FLAG_CURSED) && !(RANDOM () % 4))
833 set_ring_bonus(op, -DICE2); 883 set_ring_bonus (op, -DICE2);
834 break; 884 break;
835 885
836 case BRACERS: 886 case BRACERS:
837 if (!(RANDOM()%(QUERY_FLAG(op, FLAG_CURSED)?5:20))) { 887 if (!(RANDOM () % (QUERY_FLAG (op, FLAG_CURSED) ? 5 : 20)))
888 {
838 set_ring_bonus(op,QUERY_FLAG(op, FLAG_CURSED)?-DICE2:DICE2); 889 set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);
839 if (!QUERY_FLAG(op, FLAG_CURSED)) 890 if (!QUERY_FLAG (op, FLAG_CURSED))
840 op->value*=3; 891 op->value *= 3;
841 } 892 }
842 break; 893 break;
843 894
844 case POTION: { 895 case POTION:
896 {
845 int too_many_tries=0,is_special=0; 897 int too_many_tries = 0, is_special = 0;
846 898
847 /* Handle healing and magic power potions */ 899 /* Handle healing and magic power potions */
848 if (op->stats.sp && !op->randomitems) { 900 if (op->stats.sp && !op->randomitems)
849 object *tmp; 901 {
902 object *tmp;
850 903
851 tmp = get_archetype(spell_mapping[op->stats.sp]); 904 tmp = get_archetype (spell_mapping[op->stats.sp]);
852 insert_ob_in_ob(tmp, op); 905 insert_ob_in_ob (tmp, op);
853 op->stats.sp=0; 906 op->stats.sp = 0;
854 } 907 }
855 908
856 while(!(is_special=special_potion(op)) && !op->inv) { 909 while (!(is_special = special_potion (op)) && !op->inv)
910 {
857 generate_artifact(op,difficulty); 911 generate_artifact (op, difficulty);
858 if(too_many_tries++ > 10) break; 912 if (too_many_tries++ > 10)
859 } 913 break;
914 }
915
860 /* don't want to change value for healing/magic power potions, 916 /* don't want to change value for healing/magic power potions,
861 * since the value set on those is already correct. 917 * since the value set on those is already correct.
862 */ 918 */
863 if (op->inv && op->randomitems) { 919 if (op->inv && op->randomitems)
920 {
864 /* value multiplier is same as for scrolls */ 921 /* value multiplier is same as for scrolls */
865 op->value=(op->value*op->inv->value); 922 op->value = (op->value * op->inv->value);
866 op->level = op->inv->level/2+ RANDOM()%difficulty + RANDOM()%difficulty; 923 op->level =
867 } else { 924 op->inv->level / 2 + RANDOM () % difficulty
925 + RANDOM () % difficulty;
926 }
927 else
928 {
868 FREE_AND_COPY(op->name, "potion"); 929 FREE_AND_COPY (op->name, "potion");
869 FREE_AND_COPY(op->name_pl, "potions"); 930 FREE_AND_COPY (op->name_pl, "potions");
870 } 931 }
871 if ( ! (flags & GT_ONLY_GOOD) && RANDOM() % 2) 932 if (!(flags & GT_ONLY_GOOD) && RANDOM () % 2)
872 SET_FLAG(op, FLAG_CURSED); 933 SET_FLAG (op, FLAG_CURSED);
873 break; 934 break;
874 } 935 }
875 936
876 case AMULET: 937 case AMULET:
877 if(op->arch==amulet_arch) 938 if (op->arch == amulet_arch)
878 op->value*=5; /* Since it's not just decoration */ 939 op->value *= 5; /* Since it's not just decoration */
879 940
880 case RING: 941 case RING:
881 if(op->arch==NULL) { 942 if (op->arch == NULL)
943 {
882 remove_ob(op); 944 remove_ob (op);
883 free_object(op); 945 free_object (op);
884 op=NULL; 946 op = NULL;
885 break; 947 break;
886 } 948 }
949
887 if(op->arch!=ring_arch&&op->arch!=amulet_arch) /* It's a special artifact!*/ 950 if (op->arch != ring_arch && op->arch != amulet_arch) /* It's a special artifact! */
888 break; 951 break;
889 952
890 if ( ! (flags & GT_ONLY_GOOD) && ! (RANDOM() % 3)) 953 if (!(flags & GT_ONLY_GOOD) && !(RANDOM () % 3))
891 SET_FLAG(op, FLAG_CURSED); 954 SET_FLAG (op, FLAG_CURSED);
955
892 set_ring_bonus(op,QUERY_FLAG(op, FLAG_CURSED)?-DICE2:DICE2); 956 set_ring_bonus (op, QUERY_FLAG (op, FLAG_CURSED) ? -DICE2 : DICE2);
957
893 if(op->type!=RING) /* Amulets have only one ability */ 958 if (op->type != RING) /* Amulets have only one ability */
894 break; 959 break;
895 if(!(RANDOM()%4)) { 960
896 int d=(RANDOM()%2 || QUERY_FLAG(op, FLAG_CURSED))?-DICE2:DICE2; 961 if (!(RANDOM () % 4))
897 if(d>0) 962 {
898 op->value*=3; 963 int d = (RANDOM () % 2
964 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;
965
966 if (d > 0)
967 op->value *= 3;
968
899 set_ring_bonus(op,d); 969 set_ring_bonus (op, d);
900 if(!(RANDOM()%4)) { 970
901 int d=(RANDOM()%3 || QUERY_FLAG(op, FLAG_CURSED))?-DICE2:DICE2; 971 if (!(RANDOM () % 4))
902 if(d>0) 972 {
903 op->value*=5; 973 int d = (RANDOM () % 3
904 set_ring_bonus(op,d); 974 || QUERY_FLAG (op, FLAG_CURSED)) ? -DICE2 : DICE2;
905 } 975 if (d > 0)
906 } 976 op->value *= 5;
977 set_ring_bonus (op, d);
978 }
979 }
980
907 if(GET_ANIM_ID(op)) 981 if (GET_ANIM_ID (op))
908 SET_ANIMATION(op, RANDOM()%((int) NUM_ANIMATIONS(op))); 982 SET_ANIMATION (op, RANDOM () % ((int) NUM_ANIMATIONS (op)));
909 break;
910 983
984 break;
985
911 case BOOK: 986 case BOOK:
912 /* Is it an empty book?, if yes lets make a special 987 /* Is it an empty book?, if yes lets make a special
913 * msg for it, and tailor its properties based on the 988 * msg for it, and tailor its properties based on the
914 * creator and/or map level we found it on. 989 * creator and/or map level we found it on.
915 */ 990 */
916 if(!op->msg&&RANDOM()%10) { 991 if (!op->msg && RANDOM () % 10)
992 {
917 /* set the book level properly */ 993 /* set the book level properly */
918 if(creator->level==0 || QUERY_FLAG(creator,FLAG_ALIVE)) { 994 if (creator->level == 0 || QUERY_FLAG (creator, FLAG_ALIVE))
919 if(op->map&&op->map->difficulty) 995 {
920 op->level=RANDOM()%(op->map->difficulty)+RANDOM()%10+1; 996 if (op->map && op->map->difficulty)
921 else 997 op->level =
922 op->level=RANDOM()%20+1; 998 RANDOM () % (op->map->difficulty) + RANDOM () % 10 + 1;
923 } else 999 else
1000 op->level = RANDOM () % 20 + 1;
1001 }
1002 else
924 op->level=RANDOM()%creator->level; 1003 op->level = RANDOM () % creator->level;
925 1004
926 tailor_readable_ob(op,(creator&&creator->stats.sp)?creator->stats.sp:-1); 1005 tailor_readable_ob (op,
1006 (creator
1007 && creator->stats.sp) ? creator->stats.
1008 sp : -1);
927 /* books w/ info are worth more! */ 1009 /* books w/ info are worth more! */
928 op->value*=((op->level>10?op->level:(op->level+1)/2)*((strlen(op->msg)/250)+1)); 1010 op->value *=
1011 ((op->level >
1012 10 ? op->level : (op->level +
1013 1) / 2) * ((strlen (op->msg) / 250) + 1));
929 /* creator related stuff */ 1014 /* creator related stuff */
930 1015
931 /* for library, chained books. Note that some monsters have no_pick 1016 /* for library, chained books. Note that some monsters have no_pick
932 * set - we don't want to set no pick in that case. 1017 * set - we don't want to set no pick in that case.
933 */ 1018 */
934 if(QUERY_FLAG(creator,FLAG_NO_PICK) && 1019 if (QUERY_FLAG (creator, FLAG_NO_PICK) &&
935 !QUERY_FLAG(creator, FLAG_MONSTER)) 1020 !QUERY_FLAG (creator, FLAG_MONSTER))
936 SET_FLAG(op,FLAG_NO_PICK); 1021 SET_FLAG (op, FLAG_NO_PICK);
937 if(creator->slaying&&!op->slaying) /* for check_inv floors */ 1022 if (creator->slaying && !op->slaying) /* for check_inv floors */
938 op->slaying = add_string(creator->slaying); 1023 op->slaying = add_string (creator->slaying);
939 1024
940 /* add exp so reading it gives xp (once)*/ 1025 /* add exp so reading it gives xp (once) */
941 op->stats.exp = op->value>10000?op->value/5:op->value/10; 1026 op->stats.exp =
942 } 1027 op->value > 10000 ? op->value / 5 : op->value / 10;
943 break; 1028 }
1029 break;
944 1030
945 case SPELLBOOK: 1031 case SPELLBOOK:
946 op->value=op->value* op->inv->value;
947 /* add exp so learning gives xp */
948 op->level = op->inv->level;
949 op->stats.exp = op->value;
950 break;
951
952 case WAND:
953 /* nrof in the treasure list is number of charges,
954 * not number of wands. So copy that into food (charges),
955 * and reset nrof.
956 */
957 op->stats.food=op->inv->nrof;
958 op->nrof=1;
959 /* If the spell changes by level, choose a random level
960 * for it, and adjust price. If the spell doesn't
961 * change by level, just set the wand to the level of
962 * the spell, and value calculation is simpler.
963 */
964 if (op->inv->duration_modifier || op->inv->dam_modifier ||
965 op->inv->range_modifier) {
966 op->level = level_for_item(op, difficulty);
967 op->value= op->value* op->inv->value * (op->level +50)/
968 (op->inv->level + 50);
969 }
970 else {
971 op->level = op->inv->level;
972 op->value = op->value * op->inv->value; 1032 op->value = op->value * op->inv->value;
973 } 1033 /* add exp so learning gives xp */
974 break; 1034 op->level = op->inv->level;
1035 op->stats.exp = op->value;
1036 break;
975 1037
1038 case WAND:
1039 /* nrof in the treasure list is number of charges,
1040 * not number of wands. So copy that into food (charges),
1041 * and reset nrof.
1042 */
1043 op->stats.food = op->inv->nrof;
1044 op->nrof = 1;
1045 /* If the spell changes by level, choose a random level
1046 * for it, and adjust price. If the spell doesn't
1047 * change by level, just set the wand to the level of
1048 * the spell, and value calculation is simpler.
1049 */
1050 if (op->inv->duration_modifier || op->inv->dam_modifier ||
1051 op->inv->range_modifier)
1052 {
1053 op->level = level_for_item (op, difficulty);
1054 op->value = op->value * op->inv->value * (op->level + 50) /
1055 (op->inv->level + 50);
1056 }
1057 else
1058 {
1059 op->level = op->inv->level;
1060 op->value = op->value * op->inv->value;
1061 }
1062 break;
1063
976 case ROD: 1064 case ROD:
977 op->level = level_for_item(op, difficulty); 1065 op->level = level_for_item (op, difficulty);
978 /* Add 50 to both level an divisor to keep prices a little more 1066 /* Add 50 to both level an divisor to keep prices a little more
979 * reasonable. Otherwise, a high level version of a low level 1067 * reasonable. Otherwise, a high level version of a low level
980 * spell can be worth tons a money (eg, level 20 rod, level 2 spell = 1068 * spell can be worth tons a money (eg, level 20 rod, level 2 spell =
981 * 10 time multiplier). This way, the value are a bit more reasonable. 1069 * 10 time multiplier). This way, the value are a bit more reasonable.
982 */ 1070 */
1071 op->value =
983 op->value= op->value * op->inv->value * (op->level +50) / (op->inv->level + 50); 1072 op->value * op->inv->value * (op->level + 50) / (op->inv->level +
1073 50);
984 /* maxhp is used to denote how many 'charges' the rod holds before */ 1074 /* maxhp is used to denote how many 'charges' the rod holds before */
985 if (op->stats.maxhp) 1075 if (op->stats.maxhp)
986 op->stats.maxhp *= MAX(op->inv->stats.sp, op->inv->stats.grace); 1076 op->stats.maxhp *= MAX (op->inv->stats.sp, op->inv->stats.grace);
987 else 1077 else
988 op->stats.maxhp = 2 * MAX(op->inv->stats.sp, op->inv->stats.grace); 1078 op->stats.maxhp = 2 * MAX (op->inv->stats.sp, op->inv->stats.grace);
989 1079
990 op->stats.hp = op->stats.maxhp; 1080 op->stats.hp = op->stats.maxhp;
991 break; 1081 break;
992 1082
993 case SCROLL: 1083 case SCROLL:
994 op->level = level_for_item(op, difficulty); 1084 op->level = level_for_item (op, difficulty);
995 op->value= op->value * op->inv->value * (op->level +50) / (op->inv->level + 50); 1085 op->value =
1086 op->value * op->inv->value
1087 * (op->level + 50) / (op->inv->level + 50);
1088
996 /* add exp so reading them properly gives xp */ 1089 /* add exp so reading them properly gives xp */
997 op->stats.exp = op->value/5; 1090 op->stats.exp = op->value / 5;
998 op->nrof = op->inv->nrof; 1091 op->nrof = op->inv->nrof;
999 break; 1092 break;
1000 1093
1001 case RUNE: 1094 case RUNE:
1002 trap_adjust(op,difficulty); 1095 trap_adjust (op, difficulty);
1003 break; 1096 break;
1004 1097
1005 case TRAP: 1098 case TRAP:
1006 trap_adjust(op,difficulty); 1099 trap_adjust (op, difficulty);
1007 break; 1100 break;
1008 } /* switch type */ 1101 } /* switch type */
1009 1102
1010 if (flags & GT_STARTEQUIP) { 1103 if (flags & GT_STARTEQUIP)
1104 {
1011 if (op->nrof < 2 && op->type != CONTAINER 1105 if (op->nrof < 2 && op->type != CONTAINER
1012 && op->type != MONEY && ! QUERY_FLAG (op, FLAG_IS_THROWN)) 1106 && op->type != MONEY && !QUERY_FLAG (op, FLAG_IS_THROWN))
1013 SET_FLAG (op, FLAG_STARTEQUIP); 1107 SET_FLAG (op, FLAG_STARTEQUIP);
1014 else if (op->type != MONEY) 1108 else if (op->type != MONEY)
1015 op->value = 0; 1109 op->value = 0;
1016 } 1110 }
1017 1111
1018 if ( ! (flags & GT_ENVIRONMENT)) 1112 if (!(flags & GT_ENVIRONMENT))
1019 fix_flesh_item (op, creator); 1113 fix_flesh_item (op, creator);
1020} 1114}
1021 1115
1022/* 1116/*
1023 * 1117 *
1024 * 1118 *

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines