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

Comparing deliantra/server/common/living.C (file contents):
Revision 1.9 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.19 by root, Fri Dec 22 16:34:00 2006 UTC

1
2/*
3 * static char *rcsid_living_c =
4 * "$Id: living.C,v 1.9 2006/09/10 16:00:23 root Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 22*/
29 23
30#include <global.h> 24#include <global.h>
31#include <funcpoint.h> 25#include <funcpoint.h>
32 26
… …
164 * -b.t. 158 * -b.t.
165 */ 159 */
166 160
167#define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1) 161#define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1)
168 162
169#ifndef WIN32
170extern uint64 *levels;
171#else
172extern sint64 *levels; 163extern sint64 *levels;
173#endif
174 164
175#define MAX_SAVE_LEVEL 110 165#define MAX_SAVE_LEVEL 110
176 166
177/* This no longer needs to be changed anytime the number of 167/* This no longer needs to be changed anytime the number of
178 * levels is increased - rather, did_make_save will do the 168 * levels is increased - rather, did_make_save will do the
… …
245 235
246/* 236/*
247 * sets Str/Dex/con/Wis/Cha/Int/Pow in stats to value, depending on 237 * sets Str/Dex/con/Wis/Cha/Int/Pow in stats to value, depending on
248 * what attr is (STR to POW). 238 * what attr is (STR to POW).
249 */ 239 */
250
251void 240void
252set_attr_value (living * stats, int attr, sint8 value) 241set_attr_value (living *stats, int attr, sint8 value)
253{ 242{
254 switch (attr) 243 switch (attr)
255 { 244 {
256 case STR: 245 case STR:
257 stats->Str = value; 246 stats->Str = value;
258 break; 247 break;
259 case DEX: 248 case DEX:
260 stats->Dex = value; 249 stats->Dex = value;
261 break; 250 break;
262 case CON: 251 case CON:
263 stats->Con = value; 252 stats->Con = value;
264 break; 253 break;
265 case WIS: 254 case WIS:
266 stats->Wis = value; 255 stats->Wis = value;
267 break; 256 break;
268 case POW: 257 case POW:
269 stats->Pow = value; 258 stats->Pow = value;
270 break; 259 break;
271 case CHA: 260 case CHA:
272 stats->Cha = value; 261 stats->Cha = value;
273 break; 262 break;
274 case INT: 263 case INT:
275 stats->Int = value; 264 stats->Int = value;
276 break; 265 break;
277 } 266 }
278} 267}
279 268
280/* 269/*
281 * Like set_attr_value(), but instead the value (which can be negative) 270 * Like set_attr_value(), but instead the value (which can be negative)
282 * is added to the specified stat. 271 * is added to the specified stat.
283 */ 272 */
284
285void 273void
286change_attr_value (living * stats, int attr, sint8 value) 274change_attr_value (living *stats, int attr, sint8 value)
287{ 275{
288 if (value == 0) 276 if (value == 0)
289 return; 277 return;
278
290 switch (attr) 279 switch (attr)
291 { 280 {
292 case STR: 281 case STR:
293 stats->Str += value; 282 stats->Str += value;
294 break; 283 break;
295 case DEX: 284 case DEX:
296 stats->Dex += value; 285 stats->Dex += value;
297 break; 286 break;
298 case CON: 287 case CON:
299 stats->Con += value; 288 stats->Con += value;
300 break; 289 break;
301 case WIS: 290 case WIS:
302 stats->Wis += value; 291 stats->Wis += value;
303 break; 292 break;
304 case POW: 293 case POW:
305 stats->Pow += value; 294 stats->Pow += value;
306 break; 295 break;
307 case CHA: 296 case CHA:
308 stats->Cha += value; 297 stats->Cha += value;
309 break; 298 break;
310 case INT: 299 case INT:
311 stats->Int += value; 300 stats->Int += value;
312 break; 301 break;
313 default: 302 default:
314 LOG (llevError, "Invalid attribute in change_attr_value: %d\n", attr); 303 LOG (llevError, "Invalid attribute in change_attr_value: %d\n", attr);
315 } 304 }
316} 305}
317 306
318/* 307/*
319 * returns the specified stat. See also set_attr_value(). 308 * returns the specified stat. See also set_attr_value().
320 */ 309 */
321 310
322sint8 311sint8
323get_attr_value (const living * stats, int attr) 312get_attr_value (const living *stats, int attr)
324{ 313{
325 switch (attr) 314 switch (attr)
326 { 315 {
327 case STR:
328 return (stats->Str); 316 case STR: return stats->Str;
329 case DEX:
330 return (stats->Dex); 317 case DEX: return stats->Dex;
331 case CON:
332 return (stats->Con); 318 case CON: return stats->Con;
333 case WIS:
334 return (stats->Wis); 319 case WIS: return stats->Wis;
335 case CHA:
336 return (stats->Cha); 320 case CHA: return stats->Cha;
337 case INT:
338 return (stats->Int); 321 case INT: return stats->Int;
339 case POW:
340 return (stats->Pow); 322 case POW: return stats->Pow;
341 } 323 }
324
342 return 0; 325 return 0;
343} 326}
344 327
345/* 328/*
346 * Ensures that all stats (str/dex/con/wis/cha/int) are within the 329 * Ensures that all stats (str/dex/con/wis/cha/int) are within the
347 * 1-30 stat limit. 330 * 1-30 stat limit.
348 */ 331 */
349 332
350void 333void
351check_stat_bounds (living * stats) 334check_stat_bounds (living *stats)
352{ 335{
353 int i, v; 336 int i, v;
354 337
355 for (i = 0; i < NUM_STATS; i++) 338 for (i = 0; i < NUM_STATS; i++)
356 if ((v = get_attr_value (stats, i)) > MAX_STAT) 339 if ((v = get_attr_value (stats, i)) > MAX_STAT)
… …
458 441
459 /* call fix_player since op object could have whatever attribute due 442 /* call fix_player since op object could have whatever attribute due
460 * to multiple items. if fix_player always has to be called after 443 * to multiple items. if fix_player always has to be called after
461 * change_ability then might as well call it from here 444 * change_ability then might as well call it from here
462 */ 445 */
463 fix_player (op); 446 op->update_stats ();
464 447
465 /* Fix player won't add the bows ability to the player, so don't 448 /* Fix player won't add the bows ability to the player, so don't
466 * print out message if this is a bow. 449 * print out message if this is a bow.
467 */ 450 */
468 if (tmp->attacktype & AT_CONFUSION && tmp->type != BOW) 451 if (tmp->attacktype & AT_CONFUSION && tmp->type != BOW)
… …
661 644
662 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message); 645 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
663 } 646 }
664 } 647 }
665 648
666 if (tmp->type != EXPERIENCE && !potion_max) 649 if (!potion_max)
667 { 650 {
668 for (j = 0; j < NUM_STATS; j++) 651 for (j = 0; j < NUM_STATS; j++)
669 { 652 {
670 if ((i = get_attr_value (&(tmp->stats), j)) != 0) 653 if ((i = get_attr_value (&(tmp->stats), j)) != 0)
671 { 654 {
… …
681 * Stat draining by Vick 930307 664 * Stat draining by Vick 930307
682 * (Feeling evil, I made it work as well now. -Frank 8) 665 * (Feeling evil, I made it work as well now. -Frank 8)
683 */ 666 */
684 667
685void 668void
686drain_stat (object *op) 669object::drain_stat ()
687{ 670{
688 drain_specific_stat (op, RANDOM () % NUM_STATS); 671 drain_specific_stat (RANDOM () % NUM_STATS);
689} 672}
690 673
691void 674void
692drain_specific_stat (object *op, int deplete_stats) 675object::drain_specific_stat (int deplete_stats)
693{ 676{
694 object *tmp; 677 object *tmp;
695 archetype *at; 678 archetype *at;
696 679
697 at = find_archetype (ARCH_DEPLETION); 680 at = archetype::find (ARCH_DEPLETION);
698 if (!at) 681 if (!at)
699 { 682 {
700 LOG (llevError, "Couldn't find archetype depletion.\n"); 683 LOG (llevError, "Couldn't find archetype depletion.\n");
701 return; 684 return;
702 } 685 }
703 else 686 else
704 { 687 {
705 tmp = present_arch_in_ob (at, op); 688 tmp = present_arch_in_ob (at, this);
689
706 if (!tmp) 690 if (!tmp)
707 { 691 {
708 tmp = arch_to_object (at); 692 tmp = arch_to_object (at);
709 tmp = insert_ob_in_ob (tmp, op); 693 tmp = insert_ob_in_ob (tmp, this);
710 SET_FLAG (tmp, FLAG_APPLIED); 694 SET_FLAG (tmp, FLAG_APPLIED);
711 } 695 }
712 } 696 }
713 697
714 new_draw_info (NDI_UNIQUE, 0, op, drain_msg[deplete_stats]); 698 new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);
715 change_attr_value (&tmp->stats, deplete_stats, -1); 699 change_attr_value (&tmp->stats, deplete_stats, -1);
716 fix_player (op); 700 update_stats ();
717} 701}
718 702
719/* 703/*
720 * A value of 0 indicates timeout, otherwise change the luck of the object. 704 * A value of 0 indicates timeout, otherwise change the luck of the object.
721 * via an applied bad_luck object. 705 * via an applied bad_luck object.
722 */ 706 */
723
724void 707void
725change_luck (object *op, int value) 708object::change_luck (int value)
726{ 709{
727 object *tmp; 710 archetype *at = archetype::find ("luck");
728 archetype *at;
729 int new_luck;
730
731 at = find_archetype ("luck");
732 if (!at) 711 if (!at)
733 LOG (llevError, "Couldn't find archetype luck.\n"); 712 LOG (llevError, "Couldn't find archetype luck.\n");
734 else 713 else
735 { 714 {
736 tmp = present_arch_in_ob (at, op); 715 object *tmp = present_arch_in_ob (at, this);
716
737 if (!tmp) 717 if (!tmp)
738 { 718 {
739 if (!value) 719 if (!value)
740 return; 720 return;
721
741 tmp = arch_to_object (at); 722 tmp = arch_to_object (at);
742 tmp = insert_ob_in_ob (tmp, op); 723 tmp = insert_ob_in_ob (tmp, this);
743 SET_FLAG (tmp, FLAG_APPLIED); 724 SET_FLAG (tmp, FLAG_APPLIED);
744 } 725 }
726
745 if (value) 727 if (value)
746 { 728 {
747 /* Limit the luck value of the bad luck object to +/-100. This 729 /* Limit the luck value of the bad luck object to +/-100. This
748 * (arbitrary) value prevents overflows (both in the bad luck object and 730 * (arbitrary) value prevents overflows (both in the bad luck object and
749 * in op itself). 731 * in op itself).
750 */ 732 */
751 new_luck = tmp->stats.luck + value; 733 int new_luck = tmp->stats.luck + value;
734
752 if (new_luck >= -100 && new_luck <= 100) 735 if (new_luck >= -100 && new_luck <= 100)
753 { 736 {
754 op->stats.luck += value; 737 stats.luck += value;
755 tmp->stats.luck = new_luck; 738 tmp->stats.luck = new_luck;
756 } 739 }
757 } 740 }
758 else 741 else
759 { 742 {
760 if (!tmp->stats.luck) 743 if (!tmp->stats.luck)
761 {
762 return; 744 return;
763 } 745
764 /* Randomly change the players luck. Basically, we move it 746 /* Randomly change the players luck. Basically, we move it
765 * back neutral (if greater>0, subtract, otherwise add) 747 * back neutral (if greater>0, subtract, otherwise add)
766 */ 748 */
767 if (RANDOM () % (FABS (tmp->stats.luck)) >= RANDOM () % 30) 749 if (RANDOM () % (FABS (tmp->stats.luck)) >= RANDOM () % 30)
768 { 750 {
769 int diff = tmp->stats.luck > 0 ? -1 : 1; 751 int diff = tmp->stats.luck > 0 ? -1 : 1;
770 752
771 op->stats.luck += diff; 753 stats.luck += diff;
772 tmp->stats.luck += diff; 754 tmp->stats.luck += diff;
773 } 755 }
774 } 756 }
775 } 757 }
776} 758}
777 759
778/* 760/*
779 * Subtracts stat-bonuses given by the class which the player has chosen. 761 * Subtracts stat-bonuses given by the class which the player has chosen.
780 */ 762 */
781
782void 763void
783remove_statbonus (object *op) 764object::remove_statbonus ()
784{ 765{
785 op->stats.Str -= op->arch->clone.stats.Str; 766 stats.Str -= arch->clone.stats.Str;
786 op->stats.Dex -= op->arch->clone.stats.Dex; 767 stats.Dex -= arch->clone.stats.Dex;
787 op->stats.Con -= op->arch->clone.stats.Con; 768 stats.Con -= arch->clone.stats.Con;
788 op->stats.Wis -= op->arch->clone.stats.Wis; 769 stats.Wis -= arch->clone.stats.Wis;
789 op->stats.Pow -= op->arch->clone.stats.Pow; 770 stats.Pow -= arch->clone.stats.Pow;
790 op->stats.Cha -= op->arch->clone.stats.Cha; 771 stats.Cha -= arch->clone.stats.Cha;
791 op->stats.Int -= op->arch->clone.stats.Int; 772 stats.Int -= arch->clone.stats.Int;
773
792 op->contr->orig_stats.Str -= op->arch->clone.stats.Str; 774 contr->orig_stats.Str -= arch->clone.stats.Str;
793 op->contr->orig_stats.Dex -= op->arch->clone.stats.Dex; 775 contr->orig_stats.Dex -= arch->clone.stats.Dex;
794 op->contr->orig_stats.Con -= op->arch->clone.stats.Con; 776 contr->orig_stats.Con -= arch->clone.stats.Con;
795 op->contr->orig_stats.Wis -= op->arch->clone.stats.Wis; 777 contr->orig_stats.Wis -= arch->clone.stats.Wis;
796 op->contr->orig_stats.Pow -= op->arch->clone.stats.Pow; 778 contr->orig_stats.Pow -= arch->clone.stats.Pow;
797 op->contr->orig_stats.Cha -= op->arch->clone.stats.Cha; 779 contr->orig_stats.Cha -= arch->clone.stats.Cha;
798 op->contr->orig_stats.Int -= op->arch->clone.stats.Int; 780 contr->orig_stats.Int -= arch->clone.stats.Int;
799} 781}
800 782
801/* 783/*
802 * Adds stat-bonuses given by the class which the player has chosen. 784 * Adds stat-bonuses given by the class which the player has chosen.
803 */ 785 */
804
805void 786void
806add_statbonus (object *op) 787object::add_statbonus ()
807{ 788{
808 op->stats.Str += op->arch->clone.stats.Str; 789 stats.Str += arch->clone.stats.Str;
809 op->stats.Dex += op->arch->clone.stats.Dex; 790 stats.Dex += arch->clone.stats.Dex;
810 op->stats.Con += op->arch->clone.stats.Con; 791 stats.Con += arch->clone.stats.Con;
811 op->stats.Wis += op->arch->clone.stats.Wis; 792 stats.Wis += arch->clone.stats.Wis;
812 op->stats.Pow += op->arch->clone.stats.Pow; 793 stats.Pow += arch->clone.stats.Pow;
813 op->stats.Cha += op->arch->clone.stats.Cha; 794 stats.Cha += arch->clone.stats.Cha;
814 op->stats.Int += op->arch->clone.stats.Int; 795 stats.Int += arch->clone.stats.Int;
796
815 op->contr->orig_stats.Str += op->arch->clone.stats.Str; 797 contr->orig_stats.Str += arch->clone.stats.Str;
816 op->contr->orig_stats.Dex += op->arch->clone.stats.Dex; 798 contr->orig_stats.Dex += arch->clone.stats.Dex;
817 op->contr->orig_stats.Con += op->arch->clone.stats.Con; 799 contr->orig_stats.Con += arch->clone.stats.Con;
818 op->contr->orig_stats.Wis += op->arch->clone.stats.Wis; 800 contr->orig_stats.Wis += arch->clone.stats.Wis;
819 op->contr->orig_stats.Pow += op->arch->clone.stats.Pow; 801 contr->orig_stats.Pow += arch->clone.stats.Pow;
820 op->contr->orig_stats.Cha += op->arch->clone.stats.Cha; 802 contr->orig_stats.Cha += arch->clone.stats.Cha;
821 op->contr->orig_stats.Int += op->arch->clone.stats.Int; 803 contr->orig_stats.Int += arch->clone.stats.Int;
822} 804}
823 805
824/* 806/*
825 * Updates all abilities given by applied objects in the inventory 807 * Updates all abilities given by applied objects in the inventory
826 * of the given object. Note: This function works for both monsters 808 * of the given object. Note: This function works for both monsters
… …
832/* July 95 - inserted stuff to handle new skills/exp system - b.t. 814/* July 95 - inserted stuff to handle new skills/exp system - b.t.
833 spell system split, grace points now added to system --peterm 815 spell system split, grace points now added to system --peterm
834 */ 816 */
835 817
836void 818void
837fix_player (object *op) 819object::update_stats ()
838{ 820{
839 int i, j; 821 int i, j;
840 float f, max = 9, added_speed = 0, bonus_speed = 0, sp_tmp, speed_reduce_from_disease = 1; 822 float f, max = 9, added_speed = 0, bonus_speed = 0, sp_tmp, speed_reduce_from_disease = 1;
841 int weapon_weight = 0, weapon_speed = 0; 823 int weapon_weight = 0, weapon_speed = 0;
842 int best_wc = 0, best_ac = 0, wc = 0, ac = 0; 824 int best_wc = 0, best_ac = 0, wc = 0, ac = 0;
843 int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS]; 825 int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
844 object *grace_obj = NULL, *mana_obj = NULL, *wc_obj = NULL, *tmp; 826 object *grace_obj = NULL, *mana_obj = NULL, *wc_obj = NULL, *tmp;
845 827
846 /* First task is to clear all the values back to their original values */ 828 /* First task is to clear all the values back to their original values */
847 if (op->type == PLAYER) 829 if (type == PLAYER)
848 { 830 {
849 for (i = 0; i < NUM_STATS; i++) 831 for (i = 0; i < NUM_STATS; i++)
850 {
851 set_attr_value (&(op->stats), i, get_attr_value (&(op->contr->orig_stats), i)); 832 set_attr_value (&(stats), i, get_attr_value (&(contr->orig_stats), i));
852 } 833
853 if (settings.spell_encumbrance == TRUE) 834 if (settings.spell_encumbrance == TRUE)
854 op->contr->encumbrance = 0; 835 contr->encumbrance = 0;
855 836
856 op->attacktype = 0; 837 attacktype = 0;
857 op->contr->digestion = 0; 838 contr->digestion = 0;
858 op->contr->gen_hp = 0; 839 contr->gen_hp = 0;
859 op->contr->gen_sp = 0; 840 contr->gen_sp = 0;
860 op->contr->gen_grace = 0; 841 contr->gen_grace = 0;
861 op->contr->gen_sp_armour = 10; 842 contr->gen_sp_armour = 10;
862 op->contr->item_power = 0; 843 contr->item_power = 0;
863 844
864 /* Don't clobber all the range_ values. range_golem otherwise 845 /* Don't clobber all the range_ values. range_golem otherwise
865 * gets reset for no good reason, and we don't want to reset 846 * gets reset for no good reason, and we don't want to reset
866 * range_magic (what spell is readied). These three below 847 * range_magic (what spell is readied). These three below
867 * well get filled in based on what the player has equipped. 848 * well get filled in based on what the player has equipped.
868 */ 849 */
869 op->contr->ranges[range_bow] = NULL; 850 contr->ranges[range_bow] = NULL;
870 op->contr->ranges[range_misc] = NULL; 851 contr->ranges[range_misc] = NULL;
871 op->contr->ranges[range_skill] = NULL; 852 contr->ranges[range_skill] = NULL;
872 } 853 }
854
873 memcpy (op->body_used, op->body_info, sizeof (op->body_info)); 855 memcpy (body_used, body_info, sizeof (body_info));
874 856
875 op->slaying = 0; 857 slaying = 0;
876 858
877 if (!QUERY_FLAG (op, FLAG_WIZ)) 859 if (!QUERY_FLAG (this, FLAG_WIZ))
878 { 860 {
879 CLEAR_FLAG (op, FLAG_XRAYS); 861 CLEAR_FLAG (this, FLAG_XRAYS);
880 CLEAR_FLAG (op, FLAG_MAKE_INVIS); 862 CLEAR_FLAG (this, FLAG_MAKE_INVIS);
881 } 863 }
882 864
883 CLEAR_FLAG (op, FLAG_LIFESAVE); 865 CLEAR_FLAG (this, FLAG_LIFESAVE);
884 CLEAR_FLAG (op, FLAG_STEALTH); 866 CLEAR_FLAG (this, FLAG_STEALTH);
885 CLEAR_FLAG (op, FLAG_BLIND); 867 CLEAR_FLAG (this, FLAG_BLIND);
886 if (!QUERY_FLAG (&op->arch->clone, FLAG_REFL_SPELL))
887 CLEAR_FLAG (op, FLAG_REFL_SPELL);
888 if (!QUERY_FLAG (&op->arch->clone, FLAG_REFL_MISSILE))
889 CLEAR_FLAG (op, FLAG_REFL_MISSILE);
890 if (!QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
891 CLEAR_FLAG (op, FLAG_UNDEAD);
892 if (!QUERY_FLAG (&op->arch->clone, FLAG_SEE_IN_DARK))
893 CLEAR_FLAG (op, FLAG_SEE_IN_DARK);
894 868
869 if (!QUERY_FLAG (&arch->clone, FLAG_REFL_SPELL )) CLEAR_FLAG (this, FLAG_REFL_SPELL);
870 if (!QUERY_FLAG (&arch->clone, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE);
871 if (!QUERY_FLAG (&arch->clone, FLAG_UNDEAD )) CLEAR_FLAG (this, FLAG_UNDEAD);
872 if (!QUERY_FLAG (&arch->clone, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK);
873
895 op->path_attuned = op->arch->clone.path_attuned; 874 path_attuned = arch->clone.path_attuned;
896 op->path_repelled = op->arch->clone.path_repelled; 875 path_repelled = arch->clone.path_repelled;
897 op->path_denied = op->arch->clone.path_denied; 876 path_denied = arch->clone.path_denied;
898 op->glow_radius = op->arch->clone.glow_radius; 877 glow_radius = arch->clone.glow_radius;
899 op->move_type = op->arch->clone.move_type; 878 move_type = arch->clone.move_type;
900 op->chosen_skill = NULL; 879 chosen_skill = NULL;
901 880
902 /* initializing resistances from the values in player/monster's 881 /* initializing resistances from the values in player/monster's
903 * archetype clone 882 * archetype clone
904 */ 883 */
905 memcpy (&op->resist, &op->arch->clone.resist, sizeof (op->resist)); 884 memcpy (&resist, &arch->clone.resist, sizeof (resist));
906 885
907 for (i = 0; i < NROFATTACKS; i++) 886 for (i = 0; i < NROFATTACKS; i++)
908 { 887 {
909 if (op->resist[i] > 0) 888 if (resist[i] > 0)
910 prot[i] = op->resist[i], vuln[i] = 0; 889 prot[i] = resist[i], vuln[i] = 0;
911 else 890 else
912 vuln[i] = -(op->resist[i]), prot[i] = 0; 891 vuln[i] = -(resist[i]), prot[i] = 0;
913 potion_resist[i] = 0; 892 potion_resist[i] = 0;
914 } 893 }
915 894
916 wc = op->arch->clone.stats.wc; 895 wc = arch->clone.stats.wc;
917 op->stats.dam = op->arch->clone.stats.dam; 896 stats.dam = arch->clone.stats.dam;
918 897
919 /* for players which cannot use armour, they gain AC -1 per 3 levels, 898 /* for players which cannot use armour, they gain AC -1 per 3 levels,
920 * plus a small amount of physical resist, those poor suckers. ;) 899 * plus a small amount of physical resist, those poor suckers. ;)
921 * the fact that maxlevel is factored in could be considered sort of bogus - 900 * the fact that maxlevel is factored in could be considered sort of bogus -
922 * we should probably give them some bonus and cap it off - otherwise, 901 * we should probably give them some bonus and cap it off - otherwise,
923 * basically, if a server updates its max level, these playes may find 902 * basically, if a server updates its max level, these playes may find
924 * that their protection from physical goes down 903 * that their protection from physical goes down
925 */ 904 */
926 if (!QUERY_FLAG (op, FLAG_USE_ARMOUR) && op->type == PLAYER) 905 if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER)
927 { 906 {
928 ac = MAX (-10, op->arch->clone.stats.ac - op->level / 3); 907 ac = MAX (-10, arch->clone.stats.ac - level / 3);
929 prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * op->level / settings.max_level)) / 100; 908 prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;
930 } 909 }
931 else 910 else
932 ac = op->arch->clone.stats.ac; 911 ac = arch->clone.stats.ac;
933 912
934 op->stats.luck = op->arch->clone.stats.luck; 913 stats.luck = arch->clone.stats.luck;
935 op->speed = op->arch->clone.speed; 914 speed = arch->clone.speed;
936 915
937 /* OK - we've reset most all the objects attributes to sane values. 916 /* OK - we've reset most all the objects attributes to sane values.
938 * now go through and make adjustments for what the player has equipped. 917 * now go through and make adjustments for what the player has equipped.
939 */ 918 */
940 919
941 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 920 for (tmp = inv; tmp; tmp = tmp->below)
942 { 921 {
943 /* See note in map.c:update_position about making this additive 922 /* See note in map.c:update_position about making this additive
944 * since light sources are never applied, need to put check here. 923 * since light sources are never applied, need to put check here.
945 */ 924 */
946 if (tmp->glow_radius > op->glow_radius) 925 if (tmp->glow_radius > glow_radius)
947 op->glow_radius = tmp->glow_radius; 926 glow_radius = tmp->glow_radius;
948 927
949 /* This happens because apply_potion calls change_abil with the potion 928 /* This happens because apply_potion calls change_abil with the potion
950 * applied so we can tell the player what chagned. But change_abil 929 * applied so we can tell the player what chagned. But change_abil
951 * then calls this function. 930 * then calls this function.
952 */ 931 */
953 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION) 932 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
954 {
955 continue; 933 continue;
956 }
957 934
958 /* For some things, we don't care what is equipped */ 935 /* For some things, we don't care what is equipped */
959 if (tmp->type == SKILL) 936 if (tmp->type == SKILL)
960 { 937 {
961 /* Want to take the highest skill here. */ 938 /* Want to take the highest skill here. */
… …
964 if (!mana_obj) 941 if (!mana_obj)
965 mana_obj = tmp; 942 mana_obj = tmp;
966 else if (tmp->level > mana_obj->level) 943 else if (tmp->level > mana_obj->level)
967 mana_obj = tmp; 944 mana_obj = tmp;
968 } 945 }
946
969 if (IS_GRACE_SKILL (tmp->subtype)) 947 if (IS_GRACE_SKILL (tmp->subtype))
970 { 948 {
971 if (!grace_obj) 949 if (!grace_obj)
972 grace_obj = tmp; 950 grace_obj = tmp;
973 else if (tmp->level > grace_obj->level) 951 else if (tmp->level > grace_obj->level)
… …
985 * up, etc. 963 * up, etc.
986 */ 964 */
987 if ((QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type != CONTAINER && tmp->type != CLOSE_CON) || 965 if ((QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type != CONTAINER && tmp->type != CLOSE_CON) ||
988 (tmp->type == SKILL && tmp->subtype == SK_PRAYING)) 966 (tmp->type == SKILL && tmp->subtype == SK_PRAYING))
989 { 967 {
990 if (op->type == PLAYER) 968 if (type == PLAYER)
991 { 969 {
992 if (tmp->type == BOW) 970 if (tmp->type == BOW)
993 op->contr->ranges[range_bow] = tmp; 971 contr->ranges[range_bow] = tmp;
994 972
995 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN) 973 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
996 op->contr->ranges[range_misc] = tmp; 974 contr->ranges[range_misc] = tmp;
997 975
998 for (i = 0; i < NUM_STATS; i++) 976 for (i = 0; i < NUM_STATS; i++)
999 change_attr_value (&(op->stats), i, get_attr_value (&(tmp->stats), i)); 977 change_attr_value (&(stats), i, get_attr_value (&(tmp->stats), i));
1000 978
1001 /* these are the items that currently can change digestion, regeneration, 979 /* these are the items that currently can change digestion, regeneration,
1002 * spell point recovery and mana point recovery. Seems sort of an arbitary 980 * spell point recovery and mana point recovery. Seems sort of an arbitary
1003 * list, but other items store other info into stats array. 981 * list, but other items store other info into stats array.
1004 */ 982 */
1005 if ((tmp->type == EXPERIENCE) || (tmp->type == WEAPON) || 983 if ((tmp->type == WEAPON) ||
1006 (tmp->type == ARMOUR) || (tmp->type == HELMET) || 984 (tmp->type == ARMOUR) || (tmp->type == HELMET) ||
1007 (tmp->type == SHIELD) || (tmp->type == RING) || 985 (tmp->type == SHIELD) || (tmp->type == RING) ||
1008 (tmp->type == BOOTS) || (tmp->type == GLOVES) || 986 (tmp->type == BOOTS) || (tmp->type == GLOVES) ||
1009 (tmp->type == AMULET) || (tmp->type == GIRDLE) || 987 (tmp->type == AMULET) || (tmp->type == GIRDLE) ||
1010 (tmp->type == BRACERS) || (tmp->type == CLOAK) || (tmp->type == DISEASE) || (tmp->type == FORCE) || (tmp->type == SKILL)) 988 (tmp->type == BRACERS) || (tmp->type == CLOAK) ||
989 (tmp->type == DISEASE) || (tmp->type == FORCE) ||
990 (tmp->type == SKILL))
1011 { 991 {
1012 op->contr->digestion += tmp->stats.food; 992 contr->digestion += tmp->stats.food;
1013 op->contr->gen_hp += tmp->stats.hp; 993 contr->gen_hp += tmp->stats.hp;
1014 op->contr->gen_sp += tmp->stats.sp; 994 contr->gen_sp += tmp->stats.sp;
1015 op->contr->gen_grace += tmp->stats.grace; 995 contr->gen_grace += tmp->stats.grace;
1016 op->contr->gen_sp_armour += tmp->gen_sp_armour; 996 contr->gen_sp_armour += tmp->gen_sp_armour;
1017 op->contr->item_power += tmp->item_power; 997 contr->item_power += tmp->item_power;
1018 } 998 }
1019 } /* if this is a player */ 999 } /* if this is a player */
1020 1000
1021 /* Update slots used for items */ 1001 /* Update slots used for items */
1022 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 1002 if (QUERY_FLAG (tmp, FLAG_APPLIED))
1023 {
1024 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 1003 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1025 op->body_used[i] += tmp->body_info[i]; 1004 body_used[i] += tmp->body_info[i];
1026 }
1027 1005
1028 if (tmp->type == SYMPTOM) 1006 if (tmp->type == SYMPTOM)
1029 { 1007 {
1030 speed_reduce_from_disease = tmp->last_sp / 100.0; 1008 speed_reduce_from_disease = tmp->last_sp / 100.0;
1031 if (speed_reduce_from_disease == 0) 1009 if (speed_reduce_from_disease == 0)
… …
1058 } 1036 }
1059 } 1037 }
1060 1038
1061 /* There may be other things that should not adjust the attacktype */ 1039 /* There may be other things that should not adjust the attacktype */
1062 if (tmp->type != BOW && tmp->type != SYMPTOM) 1040 if (tmp->type != BOW && tmp->type != SYMPTOM)
1063 op->attacktype |= tmp->attacktype; 1041 attacktype |= tmp->attacktype;
1064 1042
1065 op->path_attuned |= tmp->path_attuned; 1043 path_attuned |= tmp->path_attuned;
1066 op->path_repelled |= tmp->path_repelled; 1044 path_repelled |= tmp->path_repelled;
1067 op->path_denied |= tmp->path_denied; 1045 path_denied |= tmp->path_denied;
1068 op->stats.luck += tmp->stats.luck; 1046 stats.luck += tmp->stats.luck;
1069 op->move_type |= tmp->move_type; 1047 move_type |= tmp->move_type;
1070 1048
1071 if (QUERY_FLAG (tmp, FLAG_LIFESAVE)) 1049 if (QUERY_FLAG (tmp, FLAG_LIFESAVE )) SET_FLAG (this, FLAG_LIFESAVE);
1072 SET_FLAG (op, FLAG_LIFESAVE); 1050 if (QUERY_FLAG (tmp, FLAG_REFL_SPELL )) SET_FLAG (this, FLAG_REFL_SPELL);
1073 if (QUERY_FLAG (tmp, FLAG_REFL_SPELL)) 1051 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE)) SET_FLAG (this, FLAG_REFL_MISSILE);
1074 SET_FLAG (op, FLAG_REFL_SPELL); 1052 if (QUERY_FLAG (tmp, FLAG_STEALTH )) SET_FLAG (this, FLAG_STEALTH);
1075 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE)) 1053 if (QUERY_FLAG (tmp, FLAG_XRAYS )) SET_FLAG (this, FLAG_XRAYS);
1076 SET_FLAG (op, FLAG_REFL_MISSILE); 1054 if (QUERY_FLAG (tmp, FLAG_BLIND )) SET_FLAG (this, FLAG_BLIND);
1077 if (QUERY_FLAG (tmp, FLAG_STEALTH)) 1055 if (QUERY_FLAG (tmp, FLAG_SEE_IN_DARK )) SET_FLAG (this, FLAG_SEE_IN_DARK);
1078 SET_FLAG (op, FLAG_STEALTH);
1079 if (QUERY_FLAG (tmp, FLAG_XRAYS))
1080 SET_FLAG (op, FLAG_XRAYS);
1081 if (QUERY_FLAG (tmp, FLAG_BLIND))
1082 SET_FLAG (op, FLAG_BLIND);
1083 if (QUERY_FLAG (tmp, FLAG_SEE_IN_DARK))
1084 SET_FLAG (op, FLAG_SEE_IN_DARK);
1085 1056
1086 if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 1057 if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (&arch->clone, FLAG_UNDEAD))
1087 SET_FLAG (op, FLAG_UNDEAD); 1058 SET_FLAG (this, FLAG_UNDEAD);
1088 1059
1089 if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS)) 1060 if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS))
1090 { 1061 {
1091 SET_FLAG (op, FLAG_MAKE_INVIS); 1062 SET_FLAG (this, FLAG_MAKE_INVIS);
1092 op->invisible = 1; 1063 invisible = 1;
1093 } 1064 }
1094 1065
1095 if (tmp->stats.exp && tmp->type != SKILL) 1066 if (tmp->stats.exp && tmp->type != SKILL)
1096 { 1067 {
1097 if (tmp->stats.exp > 0) 1068 if (tmp->stats.exp > 0)
… …
1103 added_speed += (float) tmp->stats.exp; 1074 added_speed += (float) tmp->stats.exp;
1104 } 1075 }
1105 1076
1106 switch (tmp->type) 1077 switch (tmp->type)
1107 { 1078 {
1108 /* skills modifying the character -b.t. */ 1079 /* skills modifying the character -b.t. */
1109 /* for all skills and skill granting objects */ 1080 /* for all skills and skill granting objects */
1110 case SKILL: 1081 case SKILL:
1111 if (!QUERY_FLAG (tmp, FLAG_APPLIED)) 1082 if (!QUERY_FLAG (tmp, FLAG_APPLIED))
1112 break;
1113
1114 if (IS_COMBAT_SKILL (tmp->subtype))
1115 wc_obj = tmp;
1116
1117 if (op->chosen_skill)
1118 {
1119 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &op->name);
1120 }
1121 op->chosen_skill = tmp;
1122 if (tmp->stats.dam > 0)
1123 { /* skill is a 'weapon' */
1124 if (!QUERY_FLAG (op, FLAG_READY_WEAPON))
1125 weapon_speed = (int) WEAPON_SPEED (tmp);
1126 if (weapon_speed < 0)
1127 weapon_speed = 0;
1128 weapon_weight = tmp->weight;
1129 op->stats.dam += tmp->stats.dam * (1 + (op->chosen_skill->level / 9));
1130 if (tmp->magic)
1131 op->stats.dam += tmp->magic;
1132 }
1133 if (tmp->stats.wc)
1134 wc -= (tmp->stats.wc + tmp->magic);
1135
1136 if (tmp->slaying != NULL)
1137 op->slaying = tmp->slaying;
1138
1139 if (tmp->stats.ac)
1140 ac -= (tmp->stats.ac + tmp->magic);
1141 if (settings.spell_encumbrance == TRUE && op->type == PLAYER)
1142 op->contr->encumbrance += (int) 3 *tmp->weight / 1000;
1143
1144 if (op->type == PLAYER)
1145 op->contr->ranges[range_skill] = op;
1146 break; 1083 break;
1147 1084
1148 case SKILL_TOOL: 1085 if (IS_COMBAT_SKILL (tmp->subtype))
1086 wc_obj = tmp;
1087
1149 if (op->chosen_skill) 1088 if (chosen_skill)
1150 {
1151 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &op->name); 1089 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name);
1090
1091 chosen_skill = tmp;
1092
1093 if (tmp->stats.dam > 0)
1094 { /* skill is a 'weapon' */
1095 if (!QUERY_FLAG (this, FLAG_READY_WEAPON))
1096 weapon_speed = (int) WEAPON_SPEED (tmp);
1097
1098 if (weapon_speed < 0)
1099 weapon_speed = 0;
1100
1101 weapon_weight = tmp->weight;
1102 stats.dam += tmp->stats.dam * (1 + (chosen_skill->level / 9));
1103
1104 if (tmp->magic)
1105 stats.dam += tmp->magic;
1152 } 1106 }
1153 op->chosen_skill = tmp;
1154 if (op->type == PLAYER)
1155 op->contr->ranges[range_skill] = op;
1156 break;
1157 1107
1158 case SHIELD:
1159 if (settings.spell_encumbrance == TRUE && op->type == PLAYER)
1160 op->contr->encumbrance += (int) tmp->weight / 2000;
1161 case RING:
1162 case AMULET:
1163 case GIRDLE:
1164 case HELMET:
1165 case BOOTS:
1166 case GLOVES:
1167 case CLOAK:
1168 if (tmp->stats.wc) 1108 if (tmp->stats.wc)
1169 wc -= (tmp->stats.wc + tmp->magic);
1170 if (tmp->stats.dam)
1171 op->stats.dam += (tmp->stats.dam + tmp->magic);
1172 if (tmp->stats.ac)
1173 ac -= (tmp->stats.ac + tmp->magic);
1174 break;
1175
1176 case WEAPON:
1177 wc -= (tmp->stats.wc + tmp->magic); 1109 wc -= (tmp->stats.wc + tmp->magic);
1110
1111 if (tmp->slaying != NULL)
1112 slaying = tmp->slaying;
1113
1114 if (tmp->stats.ac)
1115 ac -= (tmp->stats.ac + tmp->magic);
1116
1117 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1118 contr->encumbrance += (int) 3 *tmp->weight / 1000;
1119
1120 if (type == PLAYER)
1121 contr->ranges[range_skill] = this;
1122
1123 break;
1124
1125 case SKILL_TOOL:
1126 if (chosen_skill)
1127 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name);
1128
1129 chosen_skill = tmp;
1130
1131 if (type == PLAYER)
1132 contr->ranges[range_skill] = this;
1133 break;
1134
1135 case SHIELD:
1136 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1137 contr->encumbrance += (int) tmp->weight / 2000;
1138 case RING:
1139 case AMULET:
1140 case GIRDLE:
1141 case HELMET:
1142 case BOOTS:
1143 case GLOVES:
1144 case CLOAK:
1145 if (tmp->stats.wc)
1146 wc -= (tmp->stats.wc + tmp->magic);
1147
1148 if (tmp->stats.dam)
1149 stats.dam += (tmp->stats.dam + tmp->magic);
1150
1151 if (tmp->stats.ac)
1152 ac -= (tmp->stats.ac + tmp->magic);
1153
1154 break;
1155
1156 case WEAPON:
1157 wc -= (tmp->stats.wc + tmp->magic);
1158
1178 if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0) 1159 if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
1179 ac -= tmp->stats.ac + tmp->magic; 1160 ac -= tmp->stats.ac + tmp->magic;
1161
1180 op->stats.dam += (tmp->stats.dam + tmp->magic); 1162 stats.dam += (tmp->stats.dam + tmp->magic);
1181 weapon_weight = tmp->weight; 1163 weapon_weight = tmp->weight;
1182 weapon_speed = ((int) WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2; 1164 weapon_speed = ((int) WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;
1165
1183 if (weapon_speed < 0) 1166 if (weapon_speed < 0)
1184 weapon_speed = 0; 1167 weapon_speed = 0;
1168
1185 op->slaying = tmp->slaying; 1169 slaying = tmp->slaying;
1186 /* If there is desire that two handed weapons should do 1170 /* If there is desire that two handed weapons should do
1187 * extra strength damage, this is where the code should 1171 * extra strength damage, this is where the code should
1188 * go. 1172 * go.
1189 */ 1173 */
1190 op->current_weapon = tmp; 1174 current_weapon = tmp;
1191 if (settings.spell_encumbrance == TRUE && op->type == PLAYER) 1175 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1192 op->contr->encumbrance += (int) 3 *tmp->weight / 1000; 1176 contr->encumbrance += (int) 3 *tmp->weight / 1000;
1193 1177
1194 break; 1178 break;
1195 1179
1196 case ARMOUR: /* Only the best of these three are used: */ 1180 case ARMOUR: /* Only the best of these three are used: */
1197 if (settings.spell_encumbrance == TRUE && op->type == PLAYER) 1181 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1198 op->contr->encumbrance += (int) tmp->weight / 1000; 1182 contr->encumbrance += (int) tmp->weight / 1000;
1199 1183
1200 case BRACERS: 1184 case BRACERS:
1201 case FORCE: 1185 case FORCE:
1202 if (tmp->stats.wc) 1186 if (tmp->stats.wc)
1203 { 1187 {
1204 if (best_wc < tmp->stats.wc + tmp->magic) 1188 if (best_wc < tmp->stats.wc + tmp->magic)
1205 { 1189 {
1206 wc += best_wc; 1190 wc += best_wc;
1207 best_wc = tmp->stats.wc + tmp->magic; 1191 best_wc = tmp->stats.wc + tmp->magic;
1208 } 1192 }
1209 else 1193 else
1210 wc += tmp->stats.wc + tmp->magic; 1194 wc += tmp->stats.wc + tmp->magic;
1211 } 1195 }
1196
1212 if (tmp->stats.ac) 1197 if (tmp->stats.ac)
1213 { 1198 {
1214 if (best_ac < tmp->stats.ac + tmp->magic) 1199 if (best_ac < tmp->stats.ac + tmp->magic)
1215 { 1200 {
1216 ac += best_ac; /* Remove last bonus */ 1201 ac += best_ac; /* Remove last bonus */
1217 best_ac = tmp->stats.ac + tmp->magic; 1202 best_ac = tmp->stats.ac + tmp->magic;
1218 } 1203 }
1219 else /* To nullify the below effect */ 1204 else /* To nullify the below effect */
1220 ac += tmp->stats.ac + tmp->magic; 1205 ac += tmp->stats.ac + tmp->magic;
1221 } 1206 }
1207
1222 if (tmp->stats.wc) 1208 if (tmp->stats.wc)
1223 wc -= (tmp->stats.wc + tmp->magic); 1209 wc -= (tmp->stats.wc + tmp->magic);
1210
1224 if (tmp->stats.ac) 1211 if (tmp->stats.ac)
1225 ac -= (tmp->stats.ac + tmp->magic); 1212 ac -= (tmp->stats.ac + tmp->magic);
1213
1226 if (ARMOUR_SPEED (tmp) && ARMOUR_SPEED (tmp) / 10.0 < max) 1214 if (ARMOUR_SPEED (tmp) && ARMOUR_SPEED (tmp) / 10.0 < max)
1227 max = ARMOUR_SPEED (tmp) / 10.0; 1215 max = ARMOUR_SPEED (tmp) / 10.0;
1216
1228 break; 1217 break;
1229 } /* switch tmp->type */ 1218 } /* switch tmp->type */
1230 } /* item is equipped */ 1219 } /* item is equipped */
1231 } /* for loop of items */ 1220 } /* for loop of items */
1232 1221
1233 /* We've gone through all the objects the player has equipped. For many things, we 1222 /* We've gone through all the objects the player has equipped. For many things, we
… …
1240 * If there is a cursed (and no uncursed) potion in effect, we take 1229 * If there is a cursed (and no uncursed) potion in effect, we take
1241 * 'total resistance = vulnerability from cursed potion'. 1230 * 'total resistance = vulnerability from cursed potion'.
1242 */ 1231 */
1243 for (i = 0; i < NROFATTACKS; i++) 1232 for (i = 0; i < NROFATTACKS; i++)
1244 { 1233 {
1245 op->resist[i] = prot[i] - vuln[i]; 1234 resist[i] = prot[i] - vuln[i];
1235
1246 if (potion_resist[i] && ((potion_resist[i] > op->resist[i]) || (potion_resist[i] < 0))) 1236 if (potion_resist[i] && ((potion_resist[i] > resist[i]) || (potion_resist[i] < 0)))
1247 op->resist[i] = potion_resist[i]; 1237 resist[i] = potion_resist[i];
1248 } 1238 }
1249 1239
1250 /* Figure out the players sp/mana/hp totals. */ 1240 /* Figure out the players sp/mana/hp totals. */
1251 if (op->type == PLAYER) 1241 if (type == PLAYER)
1252 { 1242 {
1253 int pl_level; 1243 int pl_level;
1254 1244
1255 check_stat_bounds (&(op->stats)); 1245 check_stat_bounds (&(stats));
1256 pl_level = op->level; 1246 pl_level = level;
1257 1247
1258 if (pl_level < 1) 1248 if (pl_level < 1)
1259 pl_level = 1; /* safety, we should always get 1 levels worth of hp! */ 1249 pl_level = 1; /* safety, we should always get 1 levels worth of hp! */
1260 1250
1261 /* You basically get half a con bonus/level. But we do take into account rounding, 1251 /* You basically get half a con bonus/level. But we do take into account rounding,
1262 * so if your bonus is 7, you still get 7 worth of bonus every 2 levels. 1252 * so if your bonus is 7, you still get 7 worth of bonus every 2 levels.
1263 */ 1253 */
1264 for (i = 1, op->stats.maxhp = 0; i <= pl_level && i <= 10; i++) 1254 for (i = 1, stats.maxhp = 0; i <= pl_level && i <= 10; i++)
1265 { 1255 {
1266 j = op->contr->levhp[i] + con_bonus[op->stats.Con] / 2; 1256 j = contr->levhp[i] + con_bonus[stats.Con] / 2;
1257
1267 if (i % 2 && con_bonus[op->stats.Con] % 2) 1258 if (i % 2 && con_bonus[stats.Con] % 2)
1268 { 1259 {
1269 if (con_bonus[op->stats.Con] > 0) 1260 if (con_bonus[stats.Con] > 0)
1270 j++; 1261 j++;
1271 else 1262 else
1272 j--; 1263 j--;
1273 } 1264 }
1265
1274 op->stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */ 1266 stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */
1275 } 1267 }
1276 1268
1277 for (i = 11; i <= op->level; i++) 1269 for (i = 11; i <= level; i++)
1278 op->stats.maxhp += 2; 1270 stats.maxhp += 2;
1279 1271
1280 if (op->stats.hp > op->stats.maxhp) 1272 if (stats.hp > stats.maxhp)
1281 op->stats.hp = op->stats.maxhp; 1273 stats.hp = stats.maxhp;
1282 1274
1283 /* Sp gain is controlled by the level of the player's 1275 /* Sp gain is controlled by the level of the player's
1284 * relevant experience object (mana_obj, see above) 1276 * relevant experience object (mana_obj, see above)
1285 */ 1277 */
1286 /* following happen when skills system is not used */ 1278 /* following happen when skills system is not used */
1287 if (!mana_obj) 1279 if (!mana_obj)
1288 mana_obj = op; 1280 mana_obj = this;
1281
1289 if (!grace_obj) 1282 if (!grace_obj)
1290 grace_obj = op; 1283 grace_obj = this;
1284
1291 /* set maxsp */ 1285 /* set maxsp */
1292 if (!mana_obj || !mana_obj->level || op->type != PLAYER) 1286 if (!mana_obj || !mana_obj->level || type != PLAYER)
1293 mana_obj = op; 1287 mana_obj = this;
1294 1288
1295 if (mana_obj == op && op->type == PLAYER) 1289 if (mana_obj == this && type == PLAYER)
1296 {
1297 op->stats.maxsp = 1; 1290 stats.maxsp = 1;
1298 }
1299 else 1291 else
1300 { 1292 {
1301 sp_tmp = 0.0; 1293 sp_tmp = 0.0;
1294
1302 for (i = 1; i <= mana_obj->level && i <= 10; i++) 1295 for (i = 1; i <= mana_obj->level && i <= 10; i++)
1303 { 1296 {
1304 float stmp; 1297 float stmp;
1305 1298
1306 /* Got some extra bonus at first level */ 1299 /* Got some extra bonus at first level */
1307 if (i < 2) 1300 if (i < 2)
1308 {
1309 stmp = op->contr->levsp[i] + ((2.0 * (float) sp_bonus[op->stats.Pow] + (float) sp_bonus[op->stats.Int]) / 6.0); 1301 stmp = contr->levsp[i] + ((2.0 * (float) sp_bonus[stats.Pow] + (float) sp_bonus[stats.Int]) / 6.0);
1310 }
1311 else 1302 else
1312 {
1313 stmp = (float) op->contr->levsp[i] + (2.0 * (float) sp_bonus[op->stats.Pow] + (float) sp_bonus[op->stats.Int]) / 12.0; 1303 stmp = (float) contr->levsp[i] + (2.0 * (float) sp_bonus[stats.Pow] + (float) sp_bonus[stats.Int]) / 12.0;
1314 } 1304
1315 if (stmp < 1.0) 1305 if (stmp < 1.0)
1316 stmp = 1.0; 1306 stmp = 1.0;
1307
1317 sp_tmp += stmp; 1308 sp_tmp += stmp;
1318 } 1309 }
1310
1319 op->stats.maxsp = (int) sp_tmp; 1311 stats.maxsp = (int) sp_tmp;
1320 1312
1321 for (i = 11; i <= mana_obj->level; i++) 1313 for (i = 11; i <= mana_obj->level; i++)
1322 op->stats.maxsp += 2; 1314 stats.maxsp += 2;
1323 } 1315 }
1324 /* Characters can get their sp supercharged via rune of transferrance */ 1316 /* Characters can get their sp supercharged via rune of transferrance */
1325 if (op->stats.sp > op->stats.maxsp * 2) 1317 if (stats.sp > stats.maxsp * 2)
1326 op->stats.sp = op->stats.maxsp * 2; 1318 stats.sp = stats.maxsp * 2;
1327 1319
1328 /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */ 1320 /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */
1329 if (!grace_obj || !grace_obj->level || op->type != PLAYER) 1321 if (!grace_obj || !grace_obj->level || type != PLAYER)
1330 grace_obj = op; 1322 grace_obj = this;
1331 1323
1332 if (grace_obj == op && op->type == PLAYER) 1324 if (grace_obj == this && type == PLAYER)
1333 {
1334 op->stats.maxgrace = 1; 1325 stats.maxgrace = 1;
1335 }
1336 else 1326 else
1337 { 1327 {
1338 /* store grace in a float - this way, the divisions below don't create 1328 /* store grace in a float - this way, the divisions below don't create
1339 * big jumps when you go from level to level - with int's, it then 1329 * big jumps when you go from level to level - with int's, it then
1340 * becomes big jumps when the sums of the bonuses jump to the next 1330 * becomes big jumps when the sums of the bonuses jump to the next
1341 * step of 8 - with floats, even fractional ones are useful. 1331 * step of 8 - with floats, even fractional ones are useful.
1342 */ 1332 */
1343 sp_tmp = 0.0; 1333 sp_tmp = 0.0;
1344 for (i = 1, op->stats.maxgrace = 0; i <= grace_obj->level && i <= 10; i++) 1334 for (i = 1, stats.maxgrace = 0; i <= grace_obj->level && i <= 10; i++)
1345 { 1335 {
1346 float grace_tmp = 0.0; 1336 float grace_tmp = 0.0;
1347 1337
1348 /* Got some extra bonus at first level */ 1338 /* Got some extra bonus at first level */
1349 if (i < 2) 1339 if (i < 2)
1350 {
1351 grace_tmp = op->contr->levgrace[i] + (((float) grace_bonus[op->stats.Pow] + 1340 grace_tmp = contr->levgrace[i] + (((float) grace_bonus[stats.Pow] +
1352 2.0 * (float) grace_bonus[op->stats.Wis]) / 6.0); 1341 2.0 * (float) grace_bonus[stats.Wis]) / 6.0);
1353 }
1354 else 1342 else
1355 {
1356 grace_tmp = (float) op->contr->levgrace[i] 1343 grace_tmp = (float) contr->levgrace[i]
1357 + ((float) grace_bonus[op->stats.Pow] + 2.0 * (float) grace_bonus[op->stats.Wis]) / 12.0; 1344 + ((float) grace_bonus[stats.Pow] + 2.0 * (float) grace_bonus[stats.Wis]) / 12.0;
1358 } 1345
1359 if (grace_tmp < 1.0) 1346 if (grace_tmp < 1.0)
1360 grace_tmp = 1.0; 1347 grace_tmp = 1.0;
1348
1361 sp_tmp += grace_tmp; 1349 sp_tmp += grace_tmp;
1362 } 1350 }
1351
1363 op->stats.maxgrace = (int) sp_tmp; 1352 stats.maxgrace = (int) sp_tmp;
1364 1353
1365 /* two grace points per level after 11 */ 1354 /* two grace points per level after 11 */
1366 for (i = 11; i <= grace_obj->level; i++) 1355 for (i = 11; i <= grace_obj->level; i++)
1367 op->stats.maxgrace += 2; 1356 stats.maxgrace += 2;
1368 } 1357 }
1369 /* No limit on grace vs maxgrace */ 1358 /* No limit on grace vs maxgrace */
1370 1359
1371 if (op->contr->braced) 1360 if (contr->braced)
1372 { 1361 {
1373 ac += 2; 1362 ac += 2;
1374 wc += 4; 1363 wc += 4;
1375 } 1364 }
1376 else 1365 else
1377 ac -= dex_bonus[op->stats.Dex]; 1366 ac -= dex_bonus[stats.Dex];
1378 1367
1379 /* In new exp/skills system, wc bonuses are related to 1368 /* In new exp/skills system, wc bonuses are related to
1380 * the players level in a relevant exp object (wc_obj) 1369 * the players level in a relevant exp object (wc_obj)
1381 * not the general player level -b.t. 1370 * not the general player level -b.t.
1382 * I changed this slightly so that wc bonuses are better 1371 * I changed this slightly so that wc bonuses are better
… …
1386 * we give the player a bonus here in wc and dam 1375 * we give the player a bonus here in wc and dam
1387 * to make up for the change. Note that I left the 1376 * to make up for the change. Note that I left the
1388 * monster bonus the same as before. -b.t. 1377 * monster bonus the same as before. -b.t.
1389 */ 1378 */
1390 1379
1391 if (op->type == PLAYER && wc_obj && wc_obj->level > 1) 1380 if (type == PLAYER && wc_obj && wc_obj->level > 1)
1392 { 1381 {
1393 wc -= (wc_obj->level + thaco_bonus[op->stats.Str]); 1382 wc -= (wc_obj->level + thaco_bonus[stats.Str]);
1394 for (i = 1; i < wc_obj->level; i++) 1383 for (i = 1; i < wc_obj->level; i++)
1395 { 1384 {
1396 /* addtional wc every 6 levels */ 1385 /* addtional wc every 6 levels */
1397 if (!(i % 6)) 1386 if (!(i % 6))
1398 wc--; 1387 wc--;
1399 /* addtional dam every 4 levels. */ 1388 /* addtional dam every 4 levels. */
1400 if (!(i % 4) && (dam_bonus[op->stats.Str] >= 0)) 1389 if (!(i % 4) && (dam_bonus[stats.Str] >= 0))
1401 op->stats.dam += (1 + (dam_bonus[op->stats.Str] / 5)); 1390 stats.dam += (1 + (dam_bonus[stats.Str] / 5));
1402 } 1391 }
1403 } 1392 }
1404 else 1393 else
1405 wc -= (op->level + thaco_bonus[op->stats.Str]); 1394 wc -= (level + thaco_bonus[stats.Str]);
1406 1395
1407 op->stats.dam += dam_bonus[op->stats.Str]; 1396 stats.dam += dam_bonus[stats.Str];
1408 1397
1409 if (op->stats.dam < 1) 1398 if (stats.dam < 1)
1410 op->stats.dam = 1; 1399 stats.dam = 1;
1411 1400
1412 op->speed = 1.0 + speed_bonus[op->stats.Dex]; 1401 speed = 1.0 + speed_bonus[stats.Dex];
1402
1413 if (settings.search_items && op->contr->search_str[0]) 1403 if (settings.search_items && contr->search_str[0])
1414 op->speed -= 1; 1404 speed -= 1;
1405
1415 if (op->attacktype == 0) 1406 if (attacktype == 0)
1416 op->attacktype = op->arch->clone.attacktype; 1407 attacktype = arch->clone.attacktype;
1417 1408
1418 } /* End if player */ 1409 } /* End if player */
1419 1410
1420 if (added_speed >= 0) 1411 if (added_speed >= 0)
1421 op->speed += added_speed / 10.0; 1412 speed += added_speed / 10.0;
1422 else /* Something wrong here...: */ 1413 else /* Something wrong here...: */
1423 op->speed /= (float) (1.0 - added_speed); 1414 speed /= (float) (1.0 - added_speed);
1424 1415
1425 /* Max is determined by armour */ 1416 /* Max is determined by armour */
1426 if (op->speed > max) 1417 if (speed > max)
1427 op->speed = max; 1418 speed = max;
1428 1419
1429 if (op->type == PLAYER) 1420 if (type == PLAYER)
1430 { 1421 {
1431 /* f is a number the represents the number of kg above (positive num) 1422 /* f is a number the represents the number of kg above (positive num)
1432 * or below (negative number) that the player is carrying. If above 1423 * or below (negative number) that the player is carrying. If above
1433 * weight limit, then player suffers a speed reduction based on how 1424 * weight limit, then player suffers a speed reduction based on how
1434 * much above he is, and what is max carry is 1425 * much above he is, and what is max carry is
1435 */ 1426 */
1436 f = (op->carrying / 1000) - max_carry[op->stats.Str]; 1427 f = (carrying / 1000) - max_carry[stats.Str];
1437 if (f > 0) 1428 if (f > 0)
1438 op->speed = op->speed / (1.0 + f / max_carry[op->stats.Str]); 1429 speed = speed / (1.0 + f / max_carry[stats.Str]);
1439 } 1430 }
1440 1431
1441 op->speed += bonus_speed / 10.0; /* Not affected by limits */ 1432 speed += bonus_speed / 10.0; /* Not affected by limits */
1442 1433
1443 /* Put a lower limit on speed. Note with this speed, you move once every 1434 /* Put a lower limit on speed. Note with this speed, you move once every
1444 * 100 ticks or so. This amounts to once every 12 seconds of realtime. 1435 * 100 ticks or so. This amounts to once every 12 seconds of realtime.
1445 */ 1436 */
1446 op->speed = op->speed * speed_reduce_from_disease; 1437 speed = speed * speed_reduce_from_disease;
1447 1438
1448 if (op->speed < 0.01 && op->type == PLAYER) 1439 if (speed < 0.01 && type == PLAYER)
1449 op->speed = 0.01; 1440 speed = 0.01;
1450 1441
1451 if (op->type == PLAYER) 1442 if (type == PLAYER)
1452 { 1443 {
1453 float M, W, s, D, K, S, M2; 1444 float M, W, s, D, K, S, M2;
1454 1445
1455 /* (This formula was made by vidarl@ifi.uio.no) 1446 /* (This formula was made by vidarl@ifi.uio.no)
1456 * Note that we never used these values again - basically 1447 * Note that we never used these values again - basically
1457 * all of these could be subbed into one big equation, but 1448 * all of these could be subbed into one big equation, but
1458 * that would just be a real pain to read. 1449 * that would just be a real pain to read.
1459 */ 1450 */
1460 M = (max_carry[op->stats.Str] - 121) / 121.0; 1451 M = (max_carry[stats.Str] - 121) / 121.0;
1461 M2 = max_carry[op->stats.Str] / 100.0; 1452 M2 = max_carry[stats.Str] / 100.0;
1462 W = weapon_weight / 20000.0; 1453 W = weapon_weight / 20000.0;
1463 s = 2 - weapon_speed / 10.0; 1454 s = 2 - weapon_speed / 10.0;
1464 D = (op->stats.Dex - 14) / 14.0; 1455 D = (stats.Dex - 14) / 14.0;
1465 K = 1 + M / 3.0 - W / (3 * M2) + op->speed / 5.0 + D / 2.0; 1456 K = 1 + M / 3.0 - W / (3 * M2) + speed / 5.0 + D / 2.0;
1466 K *= (4 + op->level) / (float) (6 + op->level) * 1.2; 1457 K *= (4 + level) / (float) (6 + level) * 1.2;
1467 if (K <= 0) 1458 if (K <= 0)
1468 K = 0.01; 1459 K = 0.01;
1469 S = op->speed / (K * s); 1460 S = speed / (K * s);
1470 op->contr->weapon_sp = S; 1461 contr->weapon_sp = S;
1471 } 1462 }
1463
1472 /* I want to limit the power of small monsters with big weapons: */ 1464 /* I want to limit the power of small monsters with big weapons: */
1473 if (op->type != PLAYER && op->arch != NULL && op->stats.dam > op->arch->clone.stats.dam * 3) 1465 if (type != PLAYER && arch != NULL && stats.dam > arch->clone.stats.dam * 3)
1474 op->stats.dam = op->arch->clone.stats.dam * 3; 1466 stats.dam = arch->clone.stats.dam * 3;
1475 1467
1476 /* Prevent overflows of wc - best you can get is ABS(120) - this 1468 /* Prevent overflows of wc - best you can get is ABS(120) - this
1477 * should be more than enough - remember, AC is also in 8 bits, 1469 * should be more than enough - remember, AC is also in 8 bits,
1478 * so its value is the same. 1470 * so its value is the same.
1479 */ 1471 */
1480 if (wc > 120) 1472 if (wc > 120)
1481 wc = 120; 1473 wc = 120;
1482 else if (wc < -120) 1474 else if (wc < -120)
1483 wc = -120; 1475 wc = -120;
1476
1484 op->stats.wc = wc; 1477 stats.wc = wc;
1485 1478
1486 if (ac > 120) 1479 if (ac > 120)
1487 ac = 120; 1480 ac = 120;
1488 else if (ac < -120) 1481 else if (ac < -120)
1489 ac = -120; 1482 ac = -120;
1483
1490 op->stats.ac = ac; 1484 stats.ac = ac;
1491 1485
1492 /* if for some reason the creature doesn't have any move type, 1486 /* if for some reason the creature doesn't have any move type,
1493 * give them walking as a default. 1487 * give them walking as a default.
1494 * The second case is a special case - to more closely mimic the 1488 * The second case is a special case - to more closely mimic the
1495 * old behaviour - if your flying, your not walking - just 1489 * old behaviour - if your flying, your not walking - just
1496 * one or the other. 1490 * one or the other.
1497 */ 1491 */
1498 if (op->move_type == 0) 1492 if (move_type == 0)
1499 op->move_type = MOVE_WALK; 1493 move_type = MOVE_WALK;
1500 else if (op->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) 1494 else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))
1501 op->move_type &= ~MOVE_WALK; 1495 move_type &= ~MOVE_WALK;
1502 1496
1503 update_ob_speed (op); 1497 update_ob_speed (this);
1504 1498
1505 /* It is quite possible that a player's spell costing might have changed, 1499 /* It is quite possible that a player's spell costing might have changed,
1506 * so we will check that now. 1500 * so we will check that now.
1507 */ 1501 */
1508 if (op->type == PLAYER) 1502 if (type == PLAYER)
1503 {
1504 esrv_update_stats (contr);
1509 esrv_update_spells (op->contr); 1505 esrv_update_spells (contr);
1506 }
1510} 1507}
1511 1508
1512/* 1509/*
1513 * Returns true if the given player is a legal class. 1510 * Returns true if the given player is a legal class.
1514 * The function to add and remove class-bonuses to the stats doesn't 1511 * The function to add and remove class-bonuses to the stats doesn't
1515 * check if the stat becomes negative, thus this function 1512 * check if the stat becomes negative, thus this function
1516 * merely checks that all stats are 1 or more, and returns 1513 * merely checks that all stats are 1 or more, and returns
1517 * false otherwise. 1514 * false otherwise.
1518 */ 1515 */
1519
1520int 1516int
1521allowed_class (const object *op) 1517allowed_class (const object *op)
1522{ 1518{
1523 return op->stats.Dex > 0 && op->stats.Str > 0 && op->stats.Con > 0 && 1519 return op->stats.Dex > 0 && op->stats.Str > 0 && op->stats.Con > 0 &&
1524 op->stats.Int > 0 && op->stats.Wis > 0 && op->stats.Pow > 0 && op->stats.Cha > 0; 1520 op->stats.Int > 0 && op->stats.Wis > 0 && op->stats.Pow > 0 && op->stats.Cha > 0;
… …
1709 who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1; 1705 who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;
1710 who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH); 1706 who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);
1711 who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1; 1707 who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;
1712 } 1708 }
1713 1709
1714 fix_player (who); 1710 who->update_stats ();
1715 if (op->level > 1) 1711 if (op->level > 1)
1716 { 1712 {
1717 if (op->type != PLAYER) 1713 if (op->type != PLAYER)
1718 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name); 1714 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1719 else 1715 else
… …
1724 player_lvl_adj (who, op); /* To increase more levels */ 1720 player_lvl_adj (who, op); /* To increase more levels */
1725 } 1721 }
1726 else if (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul)) 1722 else if (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))
1727 { 1723 {
1728 op->level--; 1724 op->level--;
1729 fix_player (who); 1725 who->update_stats ();
1730 if (op->type != PLAYER) 1726 if (op->type != PLAYER)
1731 { 1727 {
1732 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name); 1728 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1733 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf); 1729 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1734 } 1730 }
1735 player_lvl_adj (who, op); /* To decrease more levels */ 1731 player_lvl_adj (who, op); /* To decrease more levels */
1736 } 1732 }
1733
1737 /* check if the spell data has changed */ 1734 /* check if the spell data has changed */
1735 esrv_update_stats (who->contr);
1738 esrv_update_spells (who->contr); 1736 esrv_update_spells (who->contr);
1739} 1737}
1740 1738
1741/* 1739/*
1742 * Returns how much experience is needed for a player to become 1740 * Returns how much experience is needed for a player to become
… …
1776 op->perm_exp = 0; 1774 op->perm_exp = 0;
1777 else if (op->perm_exp > (sint64) MAX_EXPERIENCE) 1775 else if (op->perm_exp > (sint64) MAX_EXPERIENCE)
1778 op->perm_exp = MAX_EXPERIENCE; 1776 op->perm_exp = MAX_EXPERIENCE;
1779} 1777}
1780 1778
1781
1782/* Add experience to a player - exp should only be positive. 1779/* Add experience to a player - exp should only be positive.
1783 * Updates permanent exp for the skill we are adding to. 1780 * Updates permanent exp for the skill we are adding to.
1784 * skill_name is the skill to add exp to. Skill name can be 1781 * skill_name is the skill to add exp to. Skill name can be
1785 * NULL, in which case exp increases the players general 1782 * NULL, in which case exp increases the players general
1786 * total, but not any particular skill. 1783 * total, but not any particular skill.
1787 * flag is what to do if the player doesn't have the skill: 1784 * flag is what to do if the player doesn't have the skill:
1788 */ 1785 */
1789
1790static void 1786static void
1791add_player_exp (object *op, sint64 exp, const char *skill_name, int flag) 1787add_player_exp (object *op, sint64 exp, const char *skill_name, int flag)
1792{ 1788{
1793 object *skill_obj = NULL; 1789 object *skill_obj = NULL;
1794 sint64 limit, exp_to_add; 1790 sint64 limit, exp_to_add;
… …
1964void 1960void
1965change_exp (object *op, sint64 exp, const char *skill_name, int flag) 1961change_exp (object *op, sint64 exp, const char *skill_name, int flag)
1966{ 1962{
1967 1963
1968#ifdef EXP_DEBUG 1964#ifdef EXP_DEBUG
1969# ifndef WIN32
1970 LOG (llevDebug, "change_exp() called for %s, exp = %lld\n", query_name (op), exp);
1971# else
1972 LOG (llevDebug, "change_exp() called for %s, exp = %I64d\n", query_name (op), exp); 1965 LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
1973# endif
1974#endif 1966#endif
1975 1967
1976 /* safety */ 1968 /* safety */
1977 if (!op) 1969 if (!op)
1978 { 1970 {
… …
2081 if (level > MAX_SAVE_LEVEL) 2073 if (level > MAX_SAVE_LEVEL)
2082 level = MAX_SAVE_LEVEL; 2074 level = MAX_SAVE_LEVEL;
2083 2075
2084 if ((random_roll (1, 20, op, PREFER_HIGH) + bonus) < savethrow[level]) 2076 if ((random_roll (1, 20, op, PREFER_HIGH) + bonus) < savethrow[level])
2085 return 0; 2077 return 0;
2078
2086 return 1; 2079 return 1;
2087} 2080}

Diff Legend

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