ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/living.C

Comparing deliantra/server/common/living.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:00 2006 UTC vs.
Revision 1.40 by root, Sun Apr 29 18:11:21 2007 UTC

1	/*	1	/*
2	* static char *rcsid_living_c =
3	* "$Id: living.C,v 1.1 2006/08/13 17:16:00 elmex Exp $";
4	*/
5
6	/*
7	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game
8		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
11		7	*
12	This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
13	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
14	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
15	(at your option) any later version.	11	* (at your option) any later version.
16		12	*
17	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
18	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	GNU General Public License for more details.	16	* GNU General Public License for more details.
21		17	*
22	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
23	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25		21	*
26	The authors can be reached via e-mail at crossfire-devel@real-time.com	22	* The authors can be reached via e-mail at <crossfire@schmorp.de>
27	*/	23	*/
28		24
29	#include <global.h>	25	#include <global.h>
30	#include <funcpoint.h>	26	#include <funcpoint.h>
31		27
32	/* Handy little macro that adds exp and keeps it within bounds. Since	28	/* Handy little macro that adds exp and keeps it within bounds. Since
33	* we are now using 64 bit values, I'm not all concerned about overflow issues	29	* we are now using 64 bit values, I'm not all concerned about overflow issues
34	* with exptotal wrapping. exptotal is typically op->exp, or op->perm_exp	30	* with exptotal wrapping. exptotal is typically op->exp, or op->perm_exp
35	*/	31	*/
36	#define ADD_EXP(exptotal, exp) {exptotal += exp; if (exptotal > MAX_EXPERIENCE) exptotal = MAX_EXPERIENCE; }	32	#define ADD_EXP(exptotal, exp) {exptotal += exp; if (exptotal > MAX_EXPERIENCE) exptotal = MAX_EXPERIENCE; }
37		33
38	static const int con_bonus[MAX_STAT + 1]={	34	static const int con_bonus[MAX_STAT + 1] = {
39	-6,-5,-4,-3,-2,-1,-1,0,0,0,0,1,2,3,4,5,6,7,8,9,10,12,14,16,18,20,	35	-6, -5, -4, -3, -2, -1, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20,
40	22,25,30,40,50	36	22, 25, 30, 40, 50
41	};	37	};
42		38
43	/* changed the name of this to "sp_bonus" from "int_bonus"	39	/* changed the name of this to "sp_bonus" from "int_bonus"
44	* because Pow can now be the stat that controls spellpoint	40	* because Pow can now be the stat that controls spellpoint
45	* advancement. -b.t.	41	* advancement. -b.t.
46	*/	42	*/
47	static const int sp_bonus[MAX_STAT + 1]={	43	static const int sp_bonus[MAX_STAT + 1] = {
48	-10,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,12,15,20,25,	44	-10, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20, 25,
49	30,40,50,70,100	45	30, 40, 50, 70, 100
50	};	46	};
51		47
52	static const int grace_bonus[MAX_STAT +1] = {	48	static const int grace_bonus[MAX_STAT + 1] = {
53	-10,-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10,12,15,20,25,	49	-10, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20, 25,
54	30,40,50,70,100	50	30, 40, 50, 70, 100
55	};	51	};
56		52
57	/* 0.92.7 Changed way charisma works. Values now	53	/* 0.92.7 Changed way charisma works. Values now
58	* represent how much more it costs to buy something than to sell it	54	* represent how much more it costs to buy something than to sell it
59	* (10, a value of 10 means it is that if it costs 50 gp to buy, you	55	* (10, a value of 10 means it is that if it costs 50 gp to buy, you
…		…
69	* This is figured by diff=(y-1)/(1+y), and for buy, it is 1+diff, for sell	65	* This is figured by diff=(y-1)/(1+y), and for buy, it is 1+diff, for sell
70	* it is 1-diff	66	* it is 1-diff
71	*/	67	*/
72		68
73	const float cha_bonus[MAX_STAT + 1] = { 10.0,	69	const float cha_bonus[MAX_STAT + 1] = { 10.0,
74	10.0, 9.0, 8.0, 7.0, 6.0, /* 5 */	70	10.0, 9.0, 8.0, 7.0, 6.0, /* 5 */
75	5.0, 4.5, 4.0, 3.5, 3.0, /* 10 */	71	5.0, 4.5, 4.0, 3.5, 3.0, /* 10 */
76	2.9, 2.8, 2.7, 2.6, 2.5, /* 15 */	72	2.9, 2.8, 2.7, 2.6, 2.5, /* 15 */
77	2.4, 2.3, 2.2, 2.1, 2.0, /* 20 */	73	2.4, 2.3, 2.2, 2.1, 2.0, /* 20 */
78	1.9, 1.8, 1.7, 1.6, 1.5, /* 25 */	74	1.9, 1.8, 1.7, 1.6, 1.5, /* 25 */
79	1.4, 1.3, 1.2, 1.1, 1.0 /* 30 */	75	1.4, 1.3, 1.2, 1.1, 1.0 /* 30 */
80	};	76	};
81		77
82	const int dex_bonus[MAX_STAT + 1]={	78	const int dex_bonus[MAX_STAT + 1] = {
83	-4,-3,-2,-2,-1,-1,-1,0,0,0,0,0,0,0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,6,6,7	79	-4, -3, -2, -2, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7
84	};	80	};
85		81
86	/* speed_bonus uses dex as its stat */	82	/* speed_bonus uses dex as its stat */
87	const float speed_bonus[MAX_STAT + 1]={	83	const float speed_bonus[MAX_STAT + 1] = {
88	-0.4, -0.35, -0.3, -0.25, -0.2, -0.16, -0.12, -0.09, -0.06, -0.03, -0.01, 0, 0.01, 0.03,	84	-0.4, -0.35, -0.3, -0.25, -0.2, -0.16, -0.12, -0.09, -0.06, -0.03, -0.01, 0, 0.01, 0.03,
89	0.05, 0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1.0, 1.2, 1.4,	85	0.05, 0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1.0, 1.2, 1.4,
90	1.6, 1.8, 2.0, 2.5, 3.0	86	1.6, 1.8, 2.0, 2.5, 3.0
91	};	87	};
92		88
93	/* dam_bonus, thaco_bonus, max_carry, weight limit all are based on	89	/* dam_bonus, thaco_bonus, max_carry, weight limit all are based on
94	* strength.	90	* strength.
95	*/	91	*/
96	const int dam_bonus[MAX_STAT + 1]={	92	const int dam_bonus[MAX_STAT + 1] = {
97	-2,-2,-2,-1,-1,-1,0,0,0,0,0,0,1,1,1,2,2,2,3,3,3,4,4,5,5,6,6,7,8,10,15	93	-2, -2, -2, -1, -1, -1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 10, 15
98	};	94	};
99		95
100	const int thaco_bonus[MAX_STAT + 1]={	96	const int thaco_bonus[MAX_STAT + 1] = {
101	-2,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,1,1,1,2,2,2,3,3,3,4,4,5,5,6,7,8,10	97	-2, -2, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 8, 10
102	};	98	};
103		99
104	/* Max you can carry before you start getting extra speed penalties */	100	/* Max you can carry before you start getting extra speed penalties */
105	const int max_carry[MAX_STAT + 1]={	101	const int max_carry[MAX_STAT + 1] = {
106	2,4,7,11,16,22,29,37,46,56,67,79,92,106,121,137,154,172,191,211,232,254,277,	102	2, 4, 7, 11, 16, 22, 29, 37, 46, 56, 67, 79, 92, 106, 121, 137, 154, 172, 191, 211, 232, 254, 277,
107	301,326,352,400,450,500,600,1000	103	301, 326, 352, 400, 450, 500, 600, 1000
108	};	104	};
109		105
110	/* weight_limit - the absolute most a character can carry - a character can't	106	/* weight_limit - the absolute most a character can carry - a character can't
111	* pick stuff up if it would put him above this limit.	107	* pick stuff up if it would put him above this limit.
112	* value is in grams, so we don't need to do conversion later	108	* value is in grams, so we don't need to do conversion later
113	* These limits are probably overly generous, but being there were no values	109	* These limits are probably overly generous, but being there were no values
114	* before, you need to start someplace.	110	* before, you need to start someplace.
115	*/	111	*/
116		112
117	const uint32 weight_limit[MAX_STAT+ 1] = {	113	const uint32 weight_limit[MAX_STAT + 1] = {
118	200000, /* 0 */	114	200000, /* 0 */
119	250000,300000,350000,400000,500000, /* 5*/	115	250000, 300000, 350000, 400000, 500000, /* 5 */
120	600000,700000,800000,900000,1000000, /* 10 */	116	600000, 700000, 800000, 900000, 1000000, /* 10 */
121	1100000,1200000,1300000,1400000,1500000,/* 15 */	117	1100000, 1200000, 1300000, 1400000, 1500000, /* 15 */
122	1650000,1800000,1950000,2100000,2250000,/* 20 */	118	1650000, 1800000, 1950000, 2100000, 2250000, /* 20 */
123	2400000,2550000,2700000,2850000,3000000, /* 25 */	119	2400000, 2550000, 2700000, 2850000, 3000000, /* 25 */
124	3250000,3500000,3750000,4000000,4500000 /*30 */	120	3250000, 3500000, 3750000, 4000000, 4500000 /*30 */
125	};	121	};
126		122
127	const int learn_spell[MAX_STAT + 1]={	123	const int learn_spell[MAX_STAT + 1] = {
128	0,0,0,1,2,4,8,12,16,25,36,45,55,65,70,75,80,85,90,95,100,100,100,100,100,	124	0, 0, 0, 1, 2, 4, 8, 12, 16, 25, 36, 45, 55, 65, 70, 75, 80, 85, 90, 95, 100, 100, 100, 100, 100,
129	100,100,100,100,100,100	125	100, 100, 100, 100, 100, 100
130	};	126	};
131		127
132	const int cleric_chance[MAX_STAT + 1]={	128	const int cleric_chance[MAX_STAT + 1] = {
133	100,100,100,100,90,80,70,60,50,40,35,30,25,20,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,0	129	100, 100, 100, 100, 90, 80, 70, 60, 50, 40, 35, 30, 25, 20, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0
134	};	130	};
135		131
136	const int turn_bonus[MAX_STAT + 1]={	132	const int turn_bonus[MAX_STAT + 1] = {
137	-1,-1,-1,-1,-1,-1,-1,-1,0,0,0,1,1,1,2,2,2,3,3,3,4,4,5,5,6,7,8,9,10,12,15	133	-1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 12, 15
138	};	134	};
139		135
140	const int fear_bonus[MAX_STAT + 1]={	136	const int fear_bonus[MAX_STAT + 1] = {
141	3,3,3,3,2,2,2,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0	137	3, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
142	};	138	};
143		139
144	/*	140	/*
145	Since this is nowhere defined ...	141	Since this is nowhere defined ...
146	Both come in handy at least in function add_exp()	142	Both come in handy at least in function add_exp()
…		…
161	* line with progression of previous levels, so	157	* line with progression of previous levels, so
162	* if more levels are desired, this should be fixed.	158	* if more levels are desired, this should be fixed.
163	* -b.t.	159	* -b.t.
164	*/	160	*/
165		161
166	#define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1)	162	#define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1)
167		163
168	#ifndef WIN32
169	extern uint64 *levels;
170	#else
171	extern sint64 *levels;	164	extern sint64 *levels;
172	#endif
173		165
174	#define MAX_SAVE_LEVEL 110	166	#define MAX_SAVE_LEVEL 110
		167
175	/* This no longer needs to be changed anytime the number of	168	/* This no longer needs to be changed anytime the number of
176	* levels is increased - rather, did_make_save will do the	169	* levels is increased - rather, did_make_save will do the
177	* right thing and always use range within this table.	170	* right thing and always use range within this table.
178	* for safety, savethrow should not be accessed directly anymore,	171	* for safety, savethrow should not be accessed directly anymore,
179	* and instead did_make_save should be used instead.	172	* and instead did_make_save should be used instead.
180	*/	173	*/
181	static const int savethrow[MAX_SAVE_LEVEL+1]={	174	static const int savethrow[MAX_SAVE_LEVEL + 1] = {
182	18,	175	18,
183	18,17,16,15,14,14,13,13,12,12,12,11,11,11,11,10,10,10,10, 9,	176	18, 17, 16, 15, 14, 14, 13, 13, 12, 12, 12, 11, 11, 11, 11, 10, 10, 10, 10, 9,
184	9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6,	177	9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6,
185	6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4,	178	6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4,
186	4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2,	179	4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2,
187	2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,	180	2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
188	1, 1, 1, 1, 1, 1, 1, 1, 1, 1	181	1, 1, 1, 1, 1, 1, 1, 1, 1, 1
189	};	182	};
190		183
191	const char *const attacks[NROFATTACKS] = {	184	const char *const attacks[NROFATTACKS] = {
192	"physical", "magical", "fire", "electricity", "cold", "confusion",	185	"physical", "magical", "fire", "electricity", "cold", "confusion",
193	"acid", "drain", "weaponmagic", "ghosthit", "poison", "slow",	186	"acid", "drain", "weaponmagic", "ghosthit", "poison", "slow",
194	"paralyze", "turn undead", "fear", "cancellation", "depletion", "death",	187	"paralyze", "turn undead", "fear", "cancellation", "depletion", "death",
195	"chaos","counterspell","god power","holy power","blinding", "",	188	"chaos", "counterspell", "god power", "holy power", "blinding", "",
196	"life stealing"	189	"life stealing"
197	};	190	};
198		191
199	static const char *const drain_msg[NUM_STATS] = {	192	static const char *const drain_msg[NUM_STATS] = {
200	"Oh no! You are weakened!",	193	"Oh no! You are weakened!",
201	"You're feeling clumsy!",	194	"You're feeling clumsy!",
202	"You feel less healthy",	195	"You feel less healthy",
203	"You suddenly begin to lose your memory!",	196	"You suddenly begin to lose your memory!",
		197	"Watch out, your mind is going!",
		198	"Your spirit feels drained!",
204	"Your face gets distorted!",	199	"Your face gets distorted!",
205	"Watch out, your mind is going!",
206	"Your spirit feels drained!"
207	};	200	};
208	const char *const restore_msg[NUM_STATS] = {	201	const char *const restore_msg[NUM_STATS] = {
209	"You feel your strength return.",	202	"You feel your strength return.",
210	"You feel your agility return.",	203	"You feel your agility return.",
211	"You feel your health return.",	204	"You feel your health return.",
		205	"You feel your memory return.",
212	"You feel your wisdom return.",	206	"You feel your wisdom return.",
		207	"You feel your spirits return.",
213	"You feel your charisma return.",	208	"You feel your charisma return.",
214	"You feel your memory return.",
215	"You feel your spirits return."
216	};	209	};
217	const char *const gain_msg[NUM_STATS] = {	210	const char *const gain_msg[NUM_STATS] = {
218	"You feel stronger.",	211	"You feel stronger.",
219	"You feel more agile.",	212	"You feel more agile.",
220	"You feel healthy.",	213	"You feel healthy.",
		214	"You feel smarter.",
221	"You feel wiser.",	215	"You feel wiser.",
		216	"You feel more potent.",
222	"You seem to look better.",	217	"You seem to look better.",
223	"You feel smarter.",
224	"You feel more potent."
225	};	218	};
226	const char *const lose_msg[NUM_STATS] = {	219	const char *const lose_msg[NUM_STATS] = {
227	"You feel weaker!",	220	"You feel weaker!",
228	"You feel clumsy!",	221	"You feel clumsy!",
229	"You feel less healthy!",	222	"You feel less healthy!",
		223	"You feel stupid!",
230	"You lose some of your memory!",	224	"You lose some of your memory!",
231	"You look ugly!",
232	"You feel stupid!",
233	"You feel less potent!"	225	"You feel less potent!",
		226	"You look ugly!",
234	};	227	};
235		228
236	const char *const statname[NUM_STATS] = {	229	const char *const statname[NUM_STATS] = {
237	"strength", "dexterity", "constitution", "wisdom", "charisma", "intelligence","power"	230	"strength", "dexterity", "constitution", "intelligence", "wisdom", "power", "charisma"
238	};	231	};
239		232
240	const char *const short_stat_name[NUM_STATS] = {	233	const char *const short_stat_name[NUM_STATS] = {
241	"Str", "Dex", "Con", "Wis", "Cha", "Int","Pow"	234	"Str", "Dex", "Con", "Int", "Wis", "Pow", "Cha"
242	};	235	};
243		236
244	/*	237	/*
245	* sets Str/Dex/con/Wis/Cha/Int/Pow in stats to value, depending on	238	* sets Str/Dex/con/Wis/Cha/Int/Pow in stats to value, depending on
246	* what attr is (STR to POW).	239	* what attr is (STR to POW).
247	*/	240	*/
248
249	void	241	void
250	set_attr_value(living *stats,int attr,sint8 value) {	242	set_attr_value (living *stats, int attr, sint8 value)
		243	{
251	switch(attr) {	244	switch (attr)
		245	{
252	case STR:	246	case STR:
253	stats->Str=value;	247	stats->Str = value;
254	break;	248	break;
255	case DEX:	249	case DEX:
256	stats->Dex=value;	250	stats->Dex = value;
257	break;	251	break;
258	case CON:	252	case CON:
259	stats->Con=value;	253	stats->Con = value;
260	break;	254	break;
261	case WIS:	255	case WIS:
262	stats->Wis=value;	256	stats->Wis = value;
263	break;	257	break;
264	case POW:	258	case POW:
265	stats->Pow=value;	259	stats->Pow = value;
266	break;	260	break;
267	case CHA:	261	case CHA:
268	stats->Cha=value;	262	stats->Cha = value;
269	break;	263	break;
270	case INT:	264	case INT:
271	stats->Int=value;	265	stats->Int = value;
272	break;	266	break;
273	}	267	}
274	}	268	}
275		269
276	/*	270	/*
277	* Like set_attr_value(), but instead the value (which can be negative)	271	* Like set_attr_value(), but instead the value (which can be negative)
278	* is added to the specified stat.	272	* is added to the specified stat.
279	*/	273	*/
280
281	void	274	void
282	change_attr_value(living *stats,int attr,sint8 value) {	275	change_attr_value (living *stats, int attr, sint8 value)
		276	{
283	if (value==0) return;	277	if (value == 0)
		278	return;
		279
284	switch(attr) {	280	switch (attr)
		281	{
285	case STR:	282	case STR:
286	stats->Str+=value;	283	stats->Str += value;
287	break;	284	break;
288	case DEX:	285	case DEX:
289	stats->Dex+=value;	286	stats->Dex += value;
290	break;	287	break;
291	case CON:	288	case CON:
292	stats->Con+=value;	289	stats->Con += value;
293	break;	290	break;
294	case WIS:	291	case WIS:
295	stats->Wis+=value;	292	stats->Wis += value;
296	break;	293	break;
297	case POW:	294	case POW:
298	stats->Pow+=value;	295	stats->Pow += value;
299	break;	296	break;
300	case CHA:	297	case CHA:
301	stats->Cha+=value;	298	stats->Cha += value;
302	break;	299	break;
303	case INT:	300	case INT:
304	stats->Int+=value;	301	stats->Int += value;
305	break;	302	break;
306	default:	303	default:
307	LOG(llevError,"Invalid attribute in change_attr_value: %d\n", attr);	304	LOG (llevError, "Invalid attribute in change_attr_value: %d\n", attr);
308	}	305	}
309	}	306	}
310		307
311	/*	308	/*
312	* returns the specified stat. See also set_attr_value().	309	* returns the specified stat. See also set_attr_value().
313	*/	310	*/
314		311
315	sint8	312	sint8
316	get_attr_value(const living *stats,int attr) {	313	get_attr_value (const living *stats, int attr)
		314	{
317	switch(attr) {	315	switch (attr)
318	case STR:	316	{
319	return(stats->Str);	317	case STR: return stats->Str;
320	case DEX:	318	case DEX: return stats->Dex;
321	return(stats->Dex);	319	case CON: return stats->Con;
322	case CON:	320	case WIS: return stats->Wis;
323	return(stats->Con);	321	case CHA: return stats->Cha;
324	case WIS:	322	case INT: return stats->Int;
325	return(stats->Wis);	323	case POW: return stats->Pow;
326	case CHA:
327	return(stats->Cha);
328	case INT:
329	return(stats->Int);
330	case POW:
331	return(stats->Pow);
332	}	324	}
		325
333	return 0;	326	return 0;
334	}	327	}
335		328
336	/*	329	/*
337	* Ensures that all stats (str/dex/con/wis/cha/int) are within the	330	* Ensures that all stats (str/dex/con/wis/cha/int) are within the
338	* 1-30 stat limit.	331	* 1-30 stat limit.
339	*/	332	*/
340		333
		334	void
341	void check_stat_bounds(living *stats) {	335	check_stat_bounds (living *stats)
		336	{
342	int i,v;	337	int i, v;
		338
343	for(i=0;i<NUM_STATS;i++)	339	for (i = 0; i < NUM_STATS; i++)
344	if((v=get_attr_value(stats,i))>MAX_STAT)	340	if ((v = get_attr_value (stats, i)) > MAX_STAT)
345	set_attr_value(stats,i,MAX_STAT);	341	set_attr_value (stats, i, MAX_STAT);
346	else if(v<MIN_STAT)	342	else if (v < MIN_STAT)
347	set_attr_value(stats,i,MIN_STAT);	343	set_attr_value (stats, i, MIN_STAT);
348	}	344	}
349		345
350	#define ORIG_S(xyz,abc) (op->contr->orig_stats.abc)	346	#define ORIG_S(xyz,abc) (op->contr->orig_stats.abc)
351		347
352	/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,	348	/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,
…		…
355	*/	351	*/
356	#define DIFF_MSG(flag, msg1, msg2) \	352	#define DIFF_MSG(flag, msg1, msg2) \
357	new_draw_info(NDI_UNIQUE, 0, op, (flag>0)?msg1:msg2);	353	new_draw_info(NDI_UNIQUE, 0, op, (flag>0)?msg1:msg2);
358		354
359	/* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */	355	/* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */
		356
360	/* flag is set to 1 if we are applying the object, -1 if we are removing	357	/* flag is set to 1 if we are applying the object, -1 if we are removing
361	* the object.	358	* the object.
362	* It is the calling functions responsibilty to check to see if the object	359	* It is the calling functions responsibilty to check to see if the object
363	* can be applied or not.	360	* can be applied or not.
364	* The main purpose of calling this function is the messages that are	361	* The main purpose of calling this function is the messages that are
…		…
366	* removing an object - that is because it is impossible to know if some object	363	* removing an object - that is because it is impossible to know if some object
367	* is the only source of an attacktype or spell attunement, so this function	364	* is the only source of an attacktype or spell attunement, so this function
368	* will clear the bits, but the player may still have some other object	365	* will clear the bits, but the player may still have some other object
369	* that gives them that ability.	366	* that gives them that ability.
370	*/	367	*/
		368	int
371	int change_abil(object *op, object *tmp) {	369	change_abil (object *op, object *tmp)
		370	{
372	int flag=QUERY_FLAG(tmp,FLAG_APPLIED)?1:-1,i,j,success=0;	371	int flag = QUERY_FLAG (tmp, FLAG_APPLIED) ? 1 : -1, i, j, success = 0;
373	object refop;
374	char message[MAX_BUF];	372	char message[MAX_BUF];
375	int potion_max=0;	373	int potion_max = 0;
376		374
377	/* remember what object was like before it was changed. note that	375	/* remember what object was like before it was changed. note that
378	* refop is a local copy of op only to be used for detecting changes	376	* refop is a local copy of op only to be used for detecting changes
379	* found by fix_player. refop is not a real object	377	* found by update_stats. refop is not a real object
380	*/	378	*/
381	memcpy(&refop, op, sizeof(object));	379	object_copy refop = *op;
382		380
383	if(op->type==PLAYER) {	381	if (op->type == PLAYER)
		382	{
384	if (tmp->type==POTION) {	383	if (tmp->type == POTION)
		384	{
385	potion_max=1;	385	potion_max = 1;
386	for(j=0;j<NUM_STATS;j++) {	386	for (j = 0; j < NUM_STATS; j++)
387	int nstat, ostat;	387	{
		388	int nstat, ostat;
388		389
389	ostat = get_attr_value(&(op->contr->orig_stats),j);	390	ostat = get_attr_value (&(op->contr->orig_stats), j);
390	i = get_attr_value(&(tmp->stats),j);	391	i = get_attr_value (&(tmp->stats), j);
391		392
392	/* nstat is what the stat will be after use of the potion */	393	/* nstat is what the stat will be after use of the potion */
393	nstat = flag*i + ostat;	394	nstat = flag * i + ostat;
394		395
395	/* Do some bounds checking. While I don't think any	396	/* Do some bounds checking. While I don't think any
396	* potions do so right now, there is the potential for potions	397	* potions do so right now, there is the potential for potions
397	* that adjust that stat by more than one point, so we need	398	* that adjust that stat by more than one point, so we need
398	* to allow for that.	399	* to allow for that.
399	*/	400	*/
400	if (nstat < 1 && i*flag < 0 ) nstat = 1;	401	if (nstat < 1 && i * flag < 0)
		402	nstat = 1;
401	else if (nstat > 20 + get_attr_value(&(op->arch->clone.stats),j)) {	403	else if (nstat > 20 + get_attr_value (&(op->arch->clone.stats), j))
		404	{
402	nstat = 20 + get_attr_value(&(op->arch->clone.stats),j);	405	nstat = 20 + get_attr_value (&(op->arch->clone.stats), j);
403	}	406	}
404	if (nstat != ostat) {	407
		408	if (nstat != ostat)
		409	{
405	set_attr_value(&(op->contr->orig_stats), j, nstat);	410	set_attr_value (&(op->contr->orig_stats), j, nstat);
406	potion_max=0;	411	potion_max = 0;
407	}	412	}
408	else if (i) {	413	else if (i)
		414	{
409	/* potion is useless - player has already hit the natural maximum */	415	/* potion is useless - player has already hit the natural maximum */
410	potion_max = 1;	416	potion_max = 1;
411	}	417	}
412	}	418	}
		419
413	/* This section of code ups the characters normal stats also. I am not	420	/* This section of code ups the characters normal stats also. I am not
414	* sure if this is strictly necessary, being that fix_player probably	421	* sure if this is strictly necessary, being that fix_player probably
415	* recalculates this anyway.	422	* recalculates this anyway.
416	*/	423	*/
417	for(j=0;j<NUM_STATS;j++)	424	for (j = 0; j < NUM_STATS; j++)
418	change_attr_value(&(op->stats),j,flag*get_attr_value(&(tmp->stats),j));	425	change_attr_value (&(op->stats), j, flag * get_attr_value (&(tmp->stats), j));
		426
419	check_stat_bounds(&(op->stats));	427	check_stat_bounds (&(op->stats));
420	} /* end of potion handling code */	428	} /* end of potion handling code */
421	}	429	}
422		430
423	/* reset attributes that fix_player doesn't reset since it doesn't search	431	/* reset attributes that fix_player doesn't reset since it doesn't search
424	* everything to set	432	* everything to set
425	*/	433	*/
426	if(flag == -1) {	434	if (flag == -1)
		435	{
427	op->attacktype&=~tmp->attacktype;	436	op->attacktype &= ~tmp->attacktype;
428	op->path_attuned&=~tmp->path_attuned;	437	op->path_attuned &= ~tmp->path_attuned;
429	op->path_repelled&=~tmp->path_repelled;	438	op->path_repelled &= ~tmp->path_repelled;
430	op->path_denied&=~tmp->path_denied;	439	op->path_denied &= ~tmp->path_denied;
431	/* Presuming here that creatures only have move_type,	440	/* Presuming here that creatures only have move_type,
432	* and not the other move_ fields.	441	* and not the other move_ fields.
433	*/	442	*/
434	op->move_type &= ~tmp->move_type;	443	op->move_type &= ~tmp->move_type;
435	}	444	}
436		445
437	/* call fix_player since op object could have whatever attribute due	446	/* call fix_player since op object could have whatever attribute due
438	* to multiple items. if fix_player always has to be called after	447	* to multiple items. if fix_player always has to be called after
439	* change_ability then might as well call it from here	448	* change_ability then might as well call it from here
440	*/	449	*/
441	fix_player(op);	450	op->update_stats ();
442		451
443	/* Fix player won't add the bows ability to the player, so don't	452	/* Fix player won't add the bows ability to the player, so don't
444	* print out message if this is a bow.	453	* print out message if this is a bow.
445	*/	454	*/
446	if(tmp->attacktype & AT_CONFUSION && tmp->type != BOW) {	455	if (tmp->attacktype & AT_CONFUSION && tmp->type != BOW)
447	success=1;
448	DIFF_MSG(flag, "Your hands begin to glow red.",
449	"Your hands stop glowing red.");
450	}	456	{
		457	success = 1;
		458	DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red.");
		459	}
		460
451	if ( QUERY_FLAG(op,FLAG_LIFESAVE) != QUERY_FLAG(&refop,FLAG_LIFESAVE)){	461	if (QUERY_FLAG (op, FLAG_LIFESAVE) != QUERY_FLAG (&refop, FLAG_LIFESAVE))
452	success=1;
453	DIFF_MSG(flag, "You feel very protected.",
454	"You don't feel protected anymore.");
455	}	462	{
		463	success = 1;
		464	DIFF_MSG (flag, "You feel very protected.", "You don't feel protected anymore.");
		465	}
		466
456	if ( QUERY_FLAG(op,FLAG_REFL_MISSILE) != QUERY_FLAG(&refop,FLAG_REFL_MISSILE)){	467	if (QUERY_FLAG (op, FLAG_REFL_MISSILE) != QUERY_FLAG (&refop, FLAG_REFL_MISSILE))
457	success=1;
458	DIFF_MSG(flag, "A magic force shimmers around you.",
459	"The magic force fades away.");
460	}	468	{
		469	success = 1;
		470	DIFF_MSG (flag, "A magic force shimmers around you.", "The magic force fades away.");
		471	}
		472
461	if ( QUERY_FLAG(op,FLAG_REFL_SPELL) != QUERY_FLAG(&refop,FLAG_REFL_SPELL)){	473	if (QUERY_FLAG (op, FLAG_REFL_SPELL) != QUERY_FLAG (&refop, FLAG_REFL_SPELL))
462	success=1;
463	DIFF_MSG(flag, "You feel more safe now, somehow.",
464	"Suddenly you feel less safe, somehow.");
465	}	474	{
		475	success = 1;
		476	DIFF_MSG (flag, "You feel more safe now, somehow.", "Suddenly you feel less safe, somehow.");
		477	}
		478
466	/* movement type has changed. We don't care about cases where	479	/* movement type has changed. We don't care about cases where
467	* user has multiple items giving the same type appled like we	480	* user has multiple items giving the same type appled like we
468	* used to - that is more work than what we gain, plus messages	481	* used to - that is more work than what we gain, plus messages
469	* can be misleading (a little higher could be miscontrued from	482	* can be misleading (a little higher could be miscontrued from
470	* from fly high)	483	* from fly high)
471	*/	484	*/
472	if (tmp->move_type && op->move_type != refop.move_type) {	485	if (tmp->move_type && op->move_type != refop.move_type)
473	success=1;	486	{
		487	success = 1;
474		488
475	/* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low	489	/* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low
476	* status doesn't make a difference if you are flying high	490	* status doesn't make a difference if you are flying high
477	*/	491	*/
478	if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH)) {	492	if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH))
		493	{
479	DIFF_MSG(flag, "You start to float in the air!.", "You float down to the ground.");	494	DIFF_MSG (flag, "You start to float in the air!.", "You float down to the ground.");
480	}	495	}
481		496
482	if (tmp->move_type & MOVE_FLY_HIGH) {	497	if (tmp->move_type & MOVE_FLY_HIGH)
		498	{
483	/* double conditional - second case covers if you have move_fly_low -	499	/* double conditional - second case covers if you have move_fly_low -
484	* in that case, you don't actually land	500	* in that case, you don't actually land
485	*/	501	*/
486	DIFF_MSG(flag, "You soar into the air air!.",	502	DIFF_MSG (flag, "You soar into the air air!.",
487	(op->move_type&MOVE_FLY_LOW ? "You fly lower in the air":	503	(op->move_type & MOVE_FLY_LOW ? "You fly lower in the air" : "You float down to the ground."));
488	"You float down to the ground."));	504	}
489	}
490	if (tmp->move_type & MOVE_SWIM)	505	if (tmp->move_type & MOVE_SWIM)
491	DIFF_MSG(flag,"You feel ready for a swim", "You no longer feel like swimming");	506	DIFF_MSG (flag, "You feel ready for a swim", "You no longer feel like swimming");
492		507
493	/* Changing move status may mean you are affected by things you weren't before */	508	/* Changing move status may mean you are affected by things you weren't before */
494	check_move_on(op, op);	509	check_move_on (op, op);
495	}	510	}
496		511
497	/* becoming UNDEAD... a special treatment for this flag. Only those not	512	/* becoming UNDEAD... a special treatment for this flag. Only those not
498	* originally undead may change their status	513	* originally undead may change their status
499	*/	514	*/
500	if(!QUERY_FLAG(&op->arch->clone,FLAG_UNDEAD))	515	if (!QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
501	if ( QUERY_FLAG(op,FLAG_UNDEAD) != QUERY_FLAG(&refop,FLAG_UNDEAD)) {	516	if (QUERY_FLAG (op, FLAG_UNDEAD) != QUERY_FLAG (&refop, FLAG_UNDEAD))
		517	{
502	success=1;	518	success = 1;
503	if(flag>0) {	519	if (flag > 0)
504	if(op->race) free_string(op->race);	520	{
505	op->race=add_string("undead");	521	op->race = "undead";
506	new_draw_info(NDI_UNIQUE, 0, op,"Your lifeforce drains away!");	522	new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!");
507	} else {	523	}
508	if(op->race) free_string(op->race);	524	else
509	if(op->arch->clone.race)	525	{
510	op->race=add_string(op->arch->clone.race);	526	op->race = op->arch->clone.race;
511	else
512	op->race = NULL;
513	new_draw_info(NDI_UNIQUE, 0, op,"Your lifeforce returns!");	527	new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");
		528	}
514	}	529	}
515	}
516		530
517	if ( QUERY_FLAG(op,FLAG_STEALTH) != QUERY_FLAG(&refop,FLAG_STEALTH)){	531	if (QUERY_FLAG (op, FLAG_STEALTH) != QUERY_FLAG (&refop, FLAG_STEALTH))
518	success=1;	532	{
		533	success = 1;
519	DIFF_MSG(flag, "You walk more quietly.", "You walk more noisily.");	534	DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily.");
520	}	535	}
		536
521	if ( QUERY_FLAG(op,FLAG_MAKE_INVIS) != QUERY_FLAG(&refop,FLAG_MAKE_INVIS)){	537	if (QUERY_FLAG (op, FLAG_MAKE_INVIS) != QUERY_FLAG (&refop, FLAG_MAKE_INVIS))
522	success=1;	538	{
		539	success = 1;
523	DIFF_MSG(flag, "You become transparent.", "You can see yourself.");	540	DIFF_MSG (flag, "You become transparent.", "You can see yourself.");
524	}	541	}
		542
525	/* blinded you can tell if more blinded since blinded player has minimal	543	/* blinded you can tell if more blinded since blinded player has minimal
526	* vision	544	* vision
527	*/	545	*/
528	if(QUERY_FLAG(tmp,FLAG_BLIND)) {	546	if (QUERY_FLAG (tmp, FLAG_BLIND))
529	success=1;	547	{
530	if(flag>0) {	548	success = 1;
		549	if (flag > 0)
		550	{
531	if(QUERY_FLAG(op,FLAG_WIZ))	551	if (QUERY_FLAG (op, FLAG_WIZ))
532	new_draw_info(NDI_UNIQUE, 0, op,"Your mortal self is blinded.");	552	new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self is blinded.");
533	else {	553	else
		554	{
534	new_draw_info(NDI_UNIQUE, 0, op,"You are blinded.");	555	new_draw_info (NDI_UNIQUE, 0, op, "You are blinded.");
535	SET_FLAG(op,FLAG_BLIND);	556	SET_FLAG (op, FLAG_BLIND);
536	if(op->type==PLAYER)	557	if (op->type == PLAYER)
537	op->contr->do_los=1;	558	op->contr->do_los = 1;
		559	}
		560	}
		561	else
		562	{
		563	if (QUERY_FLAG (op, FLAG_WIZ))
		564	new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self can now see again.");
		565	else
		566	{
		567	new_draw_info (NDI_UNIQUE, 0, op, "Your vision returns.");
		568	CLEAR_FLAG (op, FLAG_BLIND);
		569	if (op->type == PLAYER)
		570	op->contr->do_los = 1;
		571	}
		572	}
538	}	573	}
539	} else {
540	if(QUERY_FLAG(op,FLAG_WIZ))
541	new_draw_info(NDI_UNIQUE, 0, op,"Your mortal self can now see again.");
542	else {
543	new_draw_info(NDI_UNIQUE, 0, op,"Your vision returns.");
544	CLEAR_FLAG(op,FLAG_BLIND);
545	if(op->type==PLAYER)
546	op->contr->do_los=1;
547	}
548	}
549	}
550		574
551	if ( QUERY_FLAG(op,FLAG_SEE_IN_DARK) != QUERY_FLAG(&refop,FLAG_SEE_IN_DARK)){	575	if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) != QUERY_FLAG (&refop, FLAG_SEE_IN_DARK))
552	success=1;	576	{
		577	success = 1;
553	if(op->type==PLAYER)	578	if (op->type == PLAYER)
554	op->contr->do_los=1;	579	op->contr->do_los = 1;
555	DIFF_MSG(flag, "Your vision is better in the dark.", "You see less well in the dark.");	580	DIFF_MSG (flag, "Your vision is better in the dark.", "You see less well in the dark.");
556	}	581	}
557		582
558	if ( QUERY_FLAG(op,FLAG_XRAYS) != QUERY_FLAG(&refop,FLAG_XRAYS)){	583	if (QUERY_FLAG (op, FLAG_XRAYS) != QUERY_FLAG (&refop, FLAG_XRAYS))
559	success=1;	584	{
560	if(flag>0) {	585	success = 1;
		586	if (flag > 0)
		587	{
561	if(QUERY_FLAG(op,FLAG_WIZ))	588	if (QUERY_FLAG (op, FLAG_WIZ))
562	new_draw_info(NDI_UNIQUE, 0, op,"Your vision becomes a little clearer.");	589	new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a little clearer.");
563	else {	590	else
		591	{
564	new_draw_info(NDI_UNIQUE, 0, op,"Everything becomes transparent.");	592	new_draw_info (NDI_UNIQUE, 0, op, "Everything becomes transparent.");
565	if(op->type==PLAYER)	593	if (op->type == PLAYER)
566	op->contr->do_los=1;	594	op->contr->do_los = 1;
		595	}
		596	}
		597	else
		598	{
		599	if (QUERY_FLAG (op, FLAG_WIZ))
		600	new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a bit out of focus.");
		601	else
		602	{
		603	new_draw_info (NDI_UNIQUE, 0, op, "Everything suddenly looks very solid.");
		604	if (op->type == PLAYER)
		605	op->contr->do_los = 1;
		606	}
		607	}
567	}	608	}
568	} else {
569	if(QUERY_FLAG(op,FLAG_WIZ))
570	new_draw_info(NDI_UNIQUE, 0, op,"Your vision becomes a bit out of focus.");
571	else {
572	new_draw_info(NDI_UNIQUE, 0, op,"Everything suddenly looks very solid.");
573	if(op->type==PLAYER)
574	op->contr->do_los=1;
575	}
576	}
577	}
578		609
579	if(tmp->stats.luck) {	610	if (tmp->stats.luck)
580	success=1;	611	{
		612	success = 1;
581	DIFF_MSG(flag*tmp->stats.luck, "You feel more lucky.", "You feel less lucky.");	613	DIFF_MSG (flag * tmp->stats.luck, "You feel more lucky.", "You feel less lucky.");
582	}	614	}
583		615
584	if(tmp->stats.hp && op->type==PLAYER) {	616	if (tmp->stats.hp && op->type == PLAYER)
585	success=1;
586	DIFF_MSG(flag*tmp->stats.hp, "You feel much more healthy!",
587	"You feel much less healthy!");
588	}	617	{
		618	success = 1;
		619	DIFF_MSG (flag * tmp->stats.hp, "You feel much more healthy!", "You feel much less healthy!");
		620	}
589		621
590	if(tmp->stats.sp && op->type==PLAYER && tmp->type!=SKILL) {	622	if (tmp->stats.sp && op->type == PLAYER && tmp->type != SKILL)
591	success=1;
592	DIFF_MSG(flag*tmp->stats.sp, "You feel one with the powers of magic!",
593	"You suddenly feel very mundane.");
594	}	623	{
		624	success = 1;
		625	DIFF_MSG (flag * tmp->stats.sp, "You feel one with the powers of magic!", "You suddenly feel very mundane.");
		626	}
595		627
596	/* for the future when artifacts set this -b.t. */	628	/* for the future when artifacts set this -b.t. */
597	if(tmp->stats.grace && op->type==PLAYER) {	629	if (tmp->stats.grace && op->type == PLAYER)
598	success=1;
599	DIFF_MSG(flag*tmp->stats.grace, "You feel closer to your god!",
600	"You suddenly feel less holy.");
601	}	630	{
		631	success = 1;
		632	DIFF_MSG (flag * tmp->stats.grace, "You feel closer to your god!", "You suddenly feel less holy.");
		633	}
602		634
603	if(tmp->stats.food && op->type==PLAYER) {	635	if (tmp->stats.food && op->type == PLAYER)
604	success=1;
605	DIFF_MSG(flag*tmp->stats.food, "You feel your digestion slowing down.",
606	"You feel your digestion speeding up.");
607	}	636	{
		637	success = 1;
		638	DIFF_MSG (flag * tmp->stats.food, "You feel your digestion slowing down.", "You feel your digestion speeding up.");
		639	}
608		640
609	/* Messages for changed resistance */	641	/* Messages for changed resistance */
610	for (i=0; i<NROFATTACKS; i++) {	642	for (i = 0; i < NROFATTACKS; i++)
611	if (i==ATNR_PHYSICAL) continue; /* Don't display about armour */
612		643	{
613	if (op->resist[i] != refop.resist[i]) {	644	if (i == ATNR_PHYSICAL)
614	success=1;	645	continue; /* Don't display about armour */
		646
615	if (op->resist[i] > refop.resist[i])	647	if (op->resist[i] != refop.resist[i])
616	sprintf(message, "Your resistance to %s rises to %d%%.",
617	change_resist_msg[i], op->resist[i]);
618	else
619	sprintf(message, "Your resistance to %s drops to %d%%.",
620	change_resist_msg[i], op->resist[i]);
621		648	{
		649	success = 1;
		650	if (op->resist[i] > refop.resist[i])
		651	sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg[i], op->resist[i]);
		652	else
		653	sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg[i], op->resist[i]);
		654
622	new_draw_info(NDI_UNIQUE|NDI_BLUE, 0, op, message);	655	new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
623	}	656	}
624	}
625
626	if(tmp->type!=EXPERIENCE && !potion_max) {
627	for (j=0; j<NUM_STATS; j++) {
628	if ((i=get_attr_value(&(tmp->stats),j))!=0) {
629	success=1;
630	DIFF_MSG(i * flag, gain_msg[j], lose_msg[j]);
631	}	657	}
632	}	658
		659	if (!potion_max)
633	}	660	{
		661	for (j = 0; j < NUM_STATS; j++)
		662	{
		663	if ((i = get_attr_value (&(tmp->stats), j)) != 0)
		664	{
		665	success = 1;
		666	DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
		667	}
		668	}
		669	}
		670
634	return success;	671	return success;
635	}	672	}
636		673
637	/*	674	/*
638	* Stat draining by Vick 930307	675	* Stat draining by Vick 930307
639	* (Feeling evil, I made it work as well now. -Frank 8)	676	* (Feeling evil, I made it work as well now. -Frank 8)
640	*/	677	*/
641		678
642	void drain_stat(object *op) {	679	void
		680	object::drain_stat ()
		681	{
643	drain_specific_stat(op, RANDOM()%NUM_STATS);	682	drain_specific_stat (rndm (NUM_STATS));
644	}	683	}
645		684
		685	void
646	void drain_specific_stat(object *op, int deplete_stats) {	686	object::drain_specific_stat (int deplete_stats)
		687	{
647	object *tmp;	688	object *tmp;
648	archetype *at;	689	archetype *at;
649		690
650	at = find_archetype(ARCH_DEPLETION);	691	at = archetype::find (ARCH_DEPLETION);
651	if (!at) {	692	if (!at)
		693	{
652	LOG(llevError, "Couldn't find archetype depletion.\n");	694	LOG (llevError, "Couldn't find archetype depletion.\n");
653	return;	695	return;
		696	}
654	} else {	697	else
		698	{
655	tmp = present_arch_in_ob(at, op);	699	tmp = present_arch_in_ob (at, this);
		700
656	if (!tmp) {	701	if (!tmp)
		702	{
657	tmp = arch_to_object(at);	703	tmp = arch_to_object (at);
658	tmp = insert_ob_in_ob(tmp, op);	704	tmp = insert_ob_in_ob (tmp, this);
659	SET_FLAG(tmp,FLAG_APPLIED);	705	SET_FLAG (tmp, FLAG_APPLIED);
660	}	706	}
661	}	707	}
662		708
663	new_draw_info(NDI_UNIQUE, 0, op, drain_msg[deplete_stats]);	709	new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);
664	change_attr_value(&tmp->stats, deplete_stats, -1);	710	change_attr_value (&tmp->stats, deplete_stats, -1);
665	fix_player(op);	711	update_stats ();
666	}	712	}
667		713
668	/*	714	/*
669	* A value of 0 indicates timeout, otherwise change the luck of the object.	715	* A value of 0 indicates timeout, otherwise change the luck of the object.
670	* via an applied bad_luck object.	716	* via an applied bad_luck object.
671	*/	717	*/
672		718	void
673	void change_luck(object *op, int value) {	719	object::change_luck (int value)
674	object *tmp;	720	{
675	archetype *at;	721	archetype *at = archetype::find ("luck");
676	int new_luck;
677
678	at = find_archetype("luck");
679	if (!at)	722	if (!at)
680	LOG(llevError, "Couldn't find archetype luck.\n");	723	LOG (llevError, "Couldn't find archetype luck.\n");
681	else {	724	else
		725	{
682	tmp = present_arch_in_ob(at, op);	726	object *tmp = present_arch_in_ob (at, this);
		727
683	if (!tmp) {	728	if (!tmp)
		729	{
		730	if (!value)
		731	return;
		732
		733	tmp = arch_to_object (at);
		734	tmp = insert_ob_in_ob (tmp, this);
		735	SET_FLAG (tmp, FLAG_APPLIED);
		736	}
		737
684	if (!value)	738	if (value)
685	return;	739	{
686	tmp = arch_to_object(at);
687	tmp = insert_ob_in_ob(tmp, op);
688	SET_FLAG(tmp,FLAG_APPLIED);
689	}
690	if (value) {
691	/* Limit the luck value of the bad luck object to +/-100. This	740	/* Limit the luck value of the bad luck object to +/-100. This
692	* (arbitrary) value prevents overflows (both in the bad luck object and	741	* (arbitrary) value prevents overflows (both in the bad luck object and
693	* in op itself).	742	* in op itself).
694	*/	743	*/
695	new_luck = tmp->stats.luck+value;	744	int new_luck = tmp->stats.luck + value;
		745
696	if (new_luck >= -100 && new_luck <= 100) {	746	if (new_luck >= -100 && new_luck <= 100)
		747	{
697	op->stats.luck+=value;	748	stats.luck += value;
698	tmp->stats.luck = new_luck;	749	tmp->stats.luck = new_luck;
		750	}
699	}	751	}
700	} else {	752	else
		753	{
701	if (!tmp->stats.luck) {	754	if (!tmp->stats.luck)
702	return;	755	return;
703	}	756
704	/* Randomly change the players luck. Basically, we move it	757	/* Randomly change the players luck. Basically, we move it
705	* back neutral (if greater>0, subtract, otherwise add)	758	* back neutral (if greater>0, subtract, otherwise add)
706	*/	759	*/
707	if (RANDOM()%(FABS(tmp->stats.luck)) >= RANDOM()%30) {	760	if (rndm (abs (tmp->stats.luck)) >= rndm (30))
		761	{
708	int diff = tmp->stats.luck>0?-1:1;	762	int diff = tmp->stats.luck > 0 ? -1 : 1;
		763
709	op->stats.luck += diff;	764	stats.luck += diff;
710	tmp->stats.luck += diff;	765	tmp->stats.luck += diff;
		766	}
711	}	767	}
712	}
713	}	768	}
714	}	769	}
715		770
716	/*	771	/*
717	* Subtracts stat-bonuses given by the class which the player has chosen.	772	* Subtracts stat-bonuses given by the class which the player has chosen.
718	*/	773	*/
719		774	void
720	void remove_statbonus(object *op) {	775	object::remove_statbonus ()
		776	{
721	op->stats.Str -= op->arch->clone.stats.Str;	777	stats.Str -= arch->clone.stats.Str;
722	op->stats.Dex -= op->arch->clone.stats.Dex;	778	stats.Dex -= arch->clone.stats.Dex;
723	op->stats.Con -= op->arch->clone.stats.Con;	779	stats.Con -= arch->clone.stats.Con;
724	op->stats.Wis -= op->arch->clone.stats.Wis;	780	stats.Wis -= arch->clone.stats.Wis;
725	op->stats.Pow -= op->arch->clone.stats.Pow;	781	stats.Pow -= arch->clone.stats.Pow;
726	op->stats.Cha -= op->arch->clone.stats.Cha;	782	stats.Cha -= arch->clone.stats.Cha;
727	op->stats.Int -= op->arch->clone.stats.Int;	783	stats.Int -= arch->clone.stats.Int;
		784
728	op->contr->orig_stats.Str -= op->arch->clone.stats.Str;	785	contr->orig_stats.Str -= arch->clone.stats.Str;
729	op->contr->orig_stats.Dex -= op->arch->clone.stats.Dex;	786	contr->orig_stats.Dex -= arch->clone.stats.Dex;
730	op->contr->orig_stats.Con -= op->arch->clone.stats.Con;	787	contr->orig_stats.Con -= arch->clone.stats.Con;
731	op->contr->orig_stats.Wis -= op->arch->clone.stats.Wis;	788	contr->orig_stats.Wis -= arch->clone.stats.Wis;
732	op->contr->orig_stats.Pow -= op->arch->clone.stats.Pow;	789	contr->orig_stats.Pow -= arch->clone.stats.Pow;
733	op->contr->orig_stats.Cha -= op->arch->clone.stats.Cha;	790	contr->orig_stats.Cha -= arch->clone.stats.Cha;
734	op->contr->orig_stats.Int -= op->arch->clone.stats.Int;	791	contr->orig_stats.Int -= arch->clone.stats.Int;
735	}	792	}
736		793
737	/*	794	/*
738	* Adds stat-bonuses given by the class which the player has chosen.	795	* Adds stat-bonuses given by the class which the player has chosen.
739	*/	796	*/
740		797	void
741	void add_statbonus(object *op) {	798	object::add_statbonus ()
		799	{
742	op->stats.Str += op->arch->clone.stats.Str;	800	stats.Str += arch->clone.stats.Str;
743	op->stats.Dex += op->arch->clone.stats.Dex;	801	stats.Dex += arch->clone.stats.Dex;
744	op->stats.Con += op->arch->clone.stats.Con;	802	stats.Con += arch->clone.stats.Con;
745	op->stats.Wis += op->arch->clone.stats.Wis;	803	stats.Wis += arch->clone.stats.Wis;
746	op->stats.Pow += op->arch->clone.stats.Pow;	804	stats.Pow += arch->clone.stats.Pow;
747	op->stats.Cha += op->arch->clone.stats.Cha;	805	stats.Cha += arch->clone.stats.Cha;
748	op->stats.Int += op->arch->clone.stats.Int;	806	stats.Int += arch->clone.stats.Int;
		807
749	op->contr->orig_stats.Str += op->arch->clone.stats.Str;	808	contr->orig_stats.Str += arch->clone.stats.Str;
750	op->contr->orig_stats.Dex += op->arch->clone.stats.Dex;	809	contr->orig_stats.Dex += arch->clone.stats.Dex;
751	op->contr->orig_stats.Con += op->arch->clone.stats.Con;	810	contr->orig_stats.Con += arch->clone.stats.Con;
752	op->contr->orig_stats.Wis += op->arch->clone.stats.Wis;	811	contr->orig_stats.Wis += arch->clone.stats.Wis;
753	op->contr->orig_stats.Pow += op->arch->clone.stats.Pow;	812	contr->orig_stats.Pow += arch->clone.stats.Pow;
754	op->contr->orig_stats.Cha += op->arch->clone.stats.Cha;	813	contr->orig_stats.Cha += arch->clone.stats.Cha;
755	op->contr->orig_stats.Int += op->arch->clone.stats.Int;	814	contr->orig_stats.Int += arch->clone.stats.Int;
756	}	815	}
757		816
758	/*	817	/*
759	* Updates all abilities given by applied objects in the inventory	818	* Updates all abilities given by applied objects in the inventory
760	* of the given object. Note: This function works for both monsters	819	* of the given object. Note: This function works for both monsters
761	* and players; the "player" in the name is purely an archaic inheritance.	820	* and players; the "player" in the name is purely an archaic inheritance.
762	* This functions starts from base values (archetype or player object)	821	* This functions starts from base values (archetype or player object)
763	* and then adjusts them according to what the player has equipped.	822	* and then adjusts them according to what the player has equipped.
764	*/	823	*
765	/* July 95 - inserted stuff to handle new skills/exp system - b.t.	824	* July 95 - inserted stuff to handle new skills/exp system - b.t.
766	spell system split, grace points now added to system --peterm	825	* spell system split, grace points now added to system --peterm
767	*/	826	*/
768		827	void
769	void fix_player(object *op) {	828	object::update_stats ()
		829	{
770	int i,j;	830	int i, j;
771	event *evt;
772	float f,max=9,added_speed=0,bonus_speed=0, sp_tmp,speed_reduce_from_disease=1;	831	float f, max = 9, added_speed = 0, bonus_speed = 0, sp_tmp, speed_reduce_from_disease = 1;
773	int weapon_weight=0,weapon_speed=0;	832	int weapon_weight = 0, weapon_speed = 0;
774	int best_wc=0, best_ac=0, wc=0, ac=0;	833	int best_wc = 0, best_ac = 0, wc = 0, ac = 0;
775	int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];	834	int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
776	object *grace_obj=NULL,*mana_obj=NULL,*wc_obj=NULL,*tmp;	835	object *grace_obj = NULL, *mana_obj = NULL, *wc_obj = NULL, *tmp;
		836	float old_speed = speed;
777		837
778	/* First task is to clear all the values back to their original values */	838	/* First task is to clear all the values back to their original values */
779	if(op->type==PLAYER) {	839	if (type == PLAYER)
		840	{
780	for(i=0;i<NUM_STATS;i++) {	841	for (i = 0; i < NUM_STATS; i++)
781	set_attr_value(&(op->stats),i,get_attr_value(&(op->contr->orig_stats),i));	842	set_attr_value (&(stats), i, get_attr_value (&(contr->orig_stats), i));
782	}	843
783	if (settings.spell_encumbrance == TRUE)	844	if (settings.spell_encumbrance == TRUE)
784	op->contr->encumbrance=0;	845	contr->encumbrance = 0;
785		846
786	op->attacktype=0;	847	attacktype = 0;
787	op->contr->digestion = 0;	848
788	op->contr->gen_hp = 0;	849	contr->digestion = 0;
789	op->contr->gen_sp = 0;	850	contr->gen_hp = 0;
790	op->contr->gen_grace = 0;	851	contr->gen_sp = 0;
		852	contr->gen_grace = 0;
791	op->contr->gen_sp_armour = 10;	853	contr->gen_sp_armour = 10;
792	op->contr->item_power = 0;	854	contr->item_power = 0;
793		855
794	/* Don't clobber all the range_ values. range_golem otherwise	856	/* Don't clobber all the range_ values. range_golem otherwise
795	* gets reset for no good reason, and we don't want to reset	857	* gets reset for no good reason, and we don't want to reset
796	* range_magic (what spell is readied). These three below	858	* range_magic (what spell is readied). These three below
797	* well get filled in based on what the player has equipped.	859	* well get filled in based on what the player has equipped.
798	*/	860	*/
799	op->contr->ranges[range_bow] = NULL;	861	contr->ranges[range_bow] = 0;
800	op->contr->ranges[range_misc] = NULL;	862	contr->ranges[range_misc] = 0;
801	op->contr->ranges[range_skill] = NULL;	863	contr->ranges[range_skill] = 0;
802	}	864	}
		865
803	memcpy(op->body_used, op->body_info, sizeof(op->body_info));	866	memcpy (body_used, body_info, sizeof (body_info));
804		867
805	if(op->slaying!=NULL) {	868	slaying = 0;
806	free_string(op->slaying);	869
807	op->slaying=NULL;
808	}
809	if(!QUERY_FLAG(op,FLAG_WIZ)) {	870	if (!QUERY_FLAG (this, FLAG_WIZ))
		871	{
810	CLEAR_FLAG(op, FLAG_XRAYS);	872	CLEAR_FLAG (this, FLAG_XRAYS);
811	CLEAR_FLAG(op, FLAG_MAKE_INVIS);	873	CLEAR_FLAG (this, FLAG_MAKE_INVIS);
812	}	874	}
813		875
814	CLEAR_FLAG(op,FLAG_LIFESAVE);	876	CLEAR_FLAG (this, FLAG_LIFESAVE);
815	CLEAR_FLAG(op,FLAG_STEALTH);	877	CLEAR_FLAG (this, FLAG_STEALTH);
816	CLEAR_FLAG(op,FLAG_BLIND);	878	CLEAR_FLAG (this, FLAG_BLIND);
817	if ( ! QUERY_FLAG (&op->arch->clone, FLAG_REFL_SPELL))
818	CLEAR_FLAG(op,FLAG_REFL_SPELL);
819	if ( ! QUERY_FLAG (&op->arch->clone, FLAG_REFL_MISSILE))
820	CLEAR_FLAG(op,FLAG_REFL_MISSILE);
821	if(!QUERY_FLAG(&op->arch->clone,FLAG_UNDEAD))
822	CLEAR_FLAG(op,FLAG_UNDEAD);
823	if ( ! QUERY_FLAG (&op->arch->clone, FLAG_SEE_IN_DARK))
824	CLEAR_FLAG(op,FLAG_SEE_IN_DARK);
825		879
		880	if (!QUERY_FLAG (&arch->clone, FLAG_REFL_SPELL )) CLEAR_FLAG (this, FLAG_REFL_SPELL);
		881	if (!QUERY_FLAG (&arch->clone, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE);
		882	if (!QUERY_FLAG (&arch->clone, FLAG_UNDEAD )) CLEAR_FLAG (this, FLAG_UNDEAD);
		883	if (!QUERY_FLAG (&arch->clone, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK);
		884
826	op->path_attuned=op->arch->clone.path_attuned;	885	path_attuned = arch->clone.path_attuned;
827	op->path_repelled=op->arch->clone.path_repelled;	886	path_repelled = arch->clone.path_repelled;
828	op->path_denied=op->arch->clone.path_denied;	887	path_denied = arch->clone.path_denied;
829	op->glow_radius=op->arch->clone.glow_radius;	888	glow_radius = arch->clone.glow_radius;
830	op->move_type = op->arch->clone.move_type;	889	move_type = arch->clone.move_type;
		890
831	op->chosen_skill = NULL;	891	chosen_skill = NULL;
832		892
833	/* initializing resistances from the values in player/monster's	893	/* initializing resistances from the values in player/monster's
834	* archetype clone	894	* archetype clone
835	*/	895	*/
836	memcpy(&op->resist, &op->arch->clone.resist, sizeof(op->resist));	896	memcpy (&resist, &arch->clone.resist, sizeof (resist));
837		897
838	for (i=0;i<NROFATTACKS;i++) {	898	for (i = 0; i < NROFATTACKS; i++)
		899	{
839	if (op->resist[i] > 0)	900	if (resist[i] > 0)
840	prot[i]= op->resist[i], vuln[i]=0;	901	prot[i] = resist[i], vuln[i] = 0;
841	else	902	else
842	vuln[i]= -(op->resist[i]), prot[i]=0;	903	vuln[i] = -(resist[i]), prot[i] = 0;
843	potion_resist[i]=0;	904	potion_resist[i] = 0;
844	}	905	}
845		906
846	wc=op->arch->clone.stats.wc;	907	wc = arch->clone.stats.wc;
847	op->stats.dam=op->arch->clone.stats.dam;	908	stats.dam = arch->clone.stats.dam;
848		909
849	/* for players which cannot use armour, they gain AC -1 per 3 levels,	910	/* for players which cannot use armour, they gain AC -1 per 3 levels,
850	* plus a small amount of physical resist, those poor suckers. ;)	911	* plus a small amount of physical resist, those poor suckers. ;)
851	* the fact that maxlevel is factored in could be considered sort of bogus -	912	* the fact that maxlevel is factored in could be considered sort of bogus -
852	* we should probably give them some bonus and cap it off - otherwise,	913	* we should probably give them some bonus and cap it off - otherwise,
853	* basically, if a server updates its max level, these playes may find	914	* basically, if a server updates its max level, these playes may find
854	* that their protection from physical goes down	915	* that their protection from physical goes down
855	*/	916	*/
856	if(!QUERY_FLAG(op,FLAG_USE_ARMOUR) && op->type==PLAYER) {	917	if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER)
		918	{
857	ac=MAX(-10,op->arch->clone.stats.ac - op->level/3);	919	ac = MAX (-10, arch->clone.stats.ac - level / 3);
858	prot[ATNR_PHYSICAL] += ((100-prot[AT_PHYSICAL])*(80*op->level/settings.max_level))/100;	920	prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;
859	}	921	}
860	else	922	else
861	ac=op->arch->clone.stats.ac;	923	ac = arch->clone.stats.ac;
862		924
863	op->stats.luck=op->arch->clone.stats.luck;	925	stats.luck = arch->clone.stats.luck;
864	op->speed = op->arch->clone.speed;	926	speed = arch->clone.speed;
865		927
866	/* OK - we've reset most all the objects attributes to sane values.	928	/* OK - we've reset most all the objects attributes to sane values.
867	* now go through and make adjustments for what the player has equipped.	929	* now go through and make adjustments for what the player has equipped.
868	*/	930	*/
869
870	for(tmp=op->inv;tmp!=NULL;tmp=tmp->below) {	931	for (tmp = inv; tmp; tmp = tmp->below)
		932	{
871	/* See note in map.c:update_position about making this additive	933	/* See note in map.c:update_position about making this additive
872	* since light sources are never applied, need to put check here.	934	* since light sources are never applied, need to put check here.
873	*/	935	*/
874	if (tmp->glow_radius > op->glow_radius) op->glow_radius=tmp->glow_radius;	936	if (tmp->glow_radius > glow_radius)
		937	glow_radius = tmp->glow_radius;
875		938
876	/* This happens because apply_potion calls change_abil with the potion	939	/* This happens because apply_potion calls change_abil with the potion
877	* applied so we can tell the player what chagned. But change_abil	940	* applied so we can tell the player what changed. But change_abil
878	* then calls this function.	941	* then calls this function.
879	*/	942	*/
880	if (QUERY_FLAG(tmp, FLAG_APPLIED) && tmp->type == POTION) {	943	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
881	continue;	944	continue;
882	}
883		945
884	/* For some things, we don't care what is equipped */	946	/* For some things, we don't care what is equipped */
885	if (tmp->type == SKILL) {	947	if (tmp->type == SKILL)
		948	{
886	/* Want to take the highest skill here. */	949	/* Want to take the highest skill here. */
887	if (IS_MANA_SKILL(tmp->subtype)) {	950	if (IS_MANA_SKILL (tmp->subtype))
888	if (!mana_obj) mana_obj=tmp;	951	{
889	else if (tmp->level > mana_obj->level) mana_obj = tmp;	952	if (!mana_obj)
890	}	953	mana_obj = tmp;
		954	else if (tmp->level > mana_obj->level)
		955	mana_obj = tmp;
		956	}
		957
891	if (IS_GRACE_SKILL(tmp->subtype)) {	958	if (IS_GRACE_SKILL (tmp->subtype))
892	if (!grace_obj) grace_obj=tmp;	959	{
893	else if (tmp->level > grace_obj->level) grace_obj = tmp;	960	if (!grace_obj)
894	}	961	grace_obj = tmp;
895	}	962	else if (tmp->level > grace_obj->level)
		963	grace_obj = tmp;
		964	}
		965	}
896		966
897	/* Container objects are not meant to adjust a players, but other applied	967	/* Container objects are not meant to adjust a players, but other applied
898	* objects need to make adjustments.	968	* objects need to make adjustments.
899	* This block should handle all player specific changes	969	* This block should handle all player specific changes
900	* The check for Praying is a bit of a hack - god given bonuses are put	970	* The check for Praying is a bit of a hack - god given bonuses are put
901	* in the praying skill, and the player should always get those.	971	* in the praying skill, and the player should always get those.
902	* It also means we need to put in additional checks for applied below,	972	* It also means we need to put in additional checks for applied below,
903	* because the skill shouldn't count against body positions being used	973	* because the skill shouldn't count against body positions being used
904	* up, etc.	974	* up, etc.
905	*/	975	*/
906	if ((QUERY_FLAG(tmp,FLAG_APPLIED) && tmp->type!=CONTAINER && tmp->type!=CLOSE_CON) ||	976	if ((QUERY_FLAG (tmp, FLAG_APPLIED)
907	(tmp->type == SKILL && tmp->subtype == SK_PRAYING)) {	977	&& tmp->type != CONTAINER
908	if(op->type==PLAYER) {	978	&& tmp->type != CLOSE_CON)
909	if (tmp->type == BOW)	979	|| (tmp->type == SKILL
910	op->contr->ranges[range_bow] = tmp;	980	&& tmp->subtype == SK_PRAYING))
		981	{
		982	if (type == PLAYER)
		983	{
		984	if (tmp->type == BOW)
		985	contr->ranges[range_bow] = tmp;
911		986
912	if (tmp->type == WAND || tmp->type == ROD || tmp->type==HORN)	987	if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
913	op->contr->ranges[range_misc] = tmp;	988	contr->ranges[range_misc] = tmp;
914		989
915	for(i=0;i<NUM_STATS;i++)	990	for (i = 0; i < NUM_STATS; i++)
916	change_attr_value(&(op->stats),i,get_attr_value(&(tmp->stats),i));	991	change_attr_value (&stats, i, get_attr_value (&tmp->stats, i));
917		992
918	/* these are the items that currently can change digestion, regeneration,	993	/* these are the items that currently can change digestion, regeneration,
919	* spell point recovery and mana point recovery. Seems sort of an arbitary	994	* spell point recovery and mana point recovery. Seems sort of an arbitary
920	* list, but other items store other info into stats array.	995	* list, but other items store other info into stats array.
921	*/	996	*/
922	if ((tmp->type == EXPERIENCE) || (tmp->type == WEAPON) ||	997	if ((tmp->type == WEAPON) || (tmp->type == BOW) ||
923	(tmp->type == ARMOUR) || (tmp->type == HELMET) ||	998	(tmp->type == ARMOUR) || (tmp->type == HELMET) ||
924	(tmp->type == SHIELD) || (tmp->type == RING) ||	999	(tmp->type == SHIELD) || (tmp->type == RING) ||
925	(tmp->type == BOOTS) || (tmp->type == GLOVES) ||	1000	(tmp->type == BOOTS) || (tmp->type == GLOVES) ||
926	(tmp->type == AMULET ) || (tmp->type == GIRDLE) ||	1001	(tmp->type == AMULET) || (tmp->type == GIRDLE) ||
927	(tmp->type == BRACERS ) || (tmp->type == CLOAK) ||	1002	(tmp->type == BRACERS) || (tmp->type == CLOAK) ||
928	(tmp->type == DISEASE) || (tmp->type == FORCE) ||	1003	(tmp->type == DISEASE) || (tmp->type == FORCE) ||
929	(tmp->type == SKILL)) {	1004	(tmp->type == SKILL))
		1005	{
930	op->contr->digestion += tmp->stats.food;	1006	contr->digestion += tmp->stats.food;
931	op->contr->gen_hp += tmp->stats.hp;	1007	contr->gen_hp += tmp->stats.hp;
932	op->contr->gen_sp += tmp->stats.sp;	1008	contr->gen_sp += tmp->stats.sp;
933	op->contr->gen_grace += tmp->stats.grace;	1009	contr->gen_grace += tmp->stats.grace;
934	op->contr->gen_sp_armour+= tmp->gen_sp_armour;	1010	contr->gen_sp_armour += tmp->gen_sp_armour;
935	op->contr->item_power += tmp->item_power;	1011	contr->item_power += tmp->item_power;
936	}	1012	}
937	} /* if this is a player */	1013	} /* if this is a player */
938		1014
939	/* Update slots used for items */	1015	/* Update slots used for items */
940	if (QUERY_FLAG(tmp,FLAG_APPLIED)) {	1016	if (QUERY_FLAG (tmp, FLAG_APPLIED))
941	for (i=0; i<NUM_BODY_LOCATIONS; i++)	1017	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
942	op->body_used[i] += tmp->body_info[i];	1018	body_used[i] += tmp->body_info[i];
943	}
944		1019
945	if(tmp->type==SYMPTOM) {	1020	if (tmp->type == SYMPTOM)
		1021	{
946	speed_reduce_from_disease = tmp->last_sp / 100.0;	1022	speed_reduce_from_disease = tmp->last_sp / 100.f;
947	if(speed_reduce_from_disease ==0) speed_reduce_from_disease = 1;
948	}
949		1023
		1024	if (speed_reduce_from_disease == 0)
		1025	speed_reduce_from_disease = 1;
		1026	}
		1027
950	/* Pos. and neg. protections are counted seperate (-> pro/vuln).	1028	/* Pos. and neg. protections are counted seperate (-> pro/vuln).
951	* (Negative protections are calculated extactly like positive.)	1029	* (Negative protections are calculated exactly like positive.)
952	* Resistance from potions are treated special as well. If there's	1030	* Resistance from potions are treated special as well. If there's
953	* more than one potion-effect, the bigger prot.-value is taken.	1031	* more than one potion-effect, the bigger prot.-value is taken.
954	*/	1032	*/
955	if (tmp->type != POTION) {	1033	if (tmp->type != POTION)
956	for (i=0; i<NROFATTACKS; i++) {	1034	{
		1035	for (i = 0; i < NROFATTACKS; i++)
		1036	{
957	/* Potential for cursed potions, in which case we just can use	1037	/* Potential for cursed potions, in which case we just can use
958	* a straight MAX, as potion_resist is initialized to zero.	1038	* a straight MAX, as potion_resist is initialised to zero.
959	*/	1039	*/
960	if (tmp->type==POTION_EFFECT) {	1040	if (tmp->type == POTION_EFFECT)
961	if (potion_resist[i])	1041	{
		1042	if (potion_resist[i])
962	potion_resist[i] = MAX(potion_resist[i], tmp->resist[i]);	1043	potion_resist[i] = MAX (potion_resist[i], tmp->resist[i]);
963	else	1044	else
964	potion_resist[i] = tmp->resist[i];	1045	potion_resist[i] = tmp->resist[i];
965	}	1046	}
966	else if (tmp->resist[i] > 0)	1047	else if (tmp->resist[i] > 0)
967	prot[i] += ((100-prot[i])*tmp->resist[i])/100;	1048	prot[i] += ((100 - prot[i]) * tmp->resist[i]) / 100;
968	else if (tmp->resist[i] < 0)	1049	else if (tmp->resist[i] < 0)
969	vuln[i] += ((100-vuln[i])*(-tmp->resist[i]))/100;	1050	vuln[i] += ((100 - vuln[i]) * -tmp->resist[i]) / 100;
970	}	1051	}
971	}	1052	}
972		1053
973	/* There may be other things that should not adjust the attacktype */	1054	/* There may be other things that should not adjust the attacktype */
974	if (tmp->type!=BOW && tmp->type != SYMPTOM)	1055	if (tmp->type != BOW && tmp->type != SYMPTOM)
975	op->attacktype|=tmp->attacktype;	1056	attacktype |= tmp->attacktype;
976		1057
977	op->path_attuned|=tmp->path_attuned;	1058	path_attuned |= tmp->path_attuned;
978	op->path_repelled|=tmp->path_repelled;	1059	path_repelled |= tmp->path_repelled;
979	op->path_denied|=tmp->path_denied;	1060	path_denied |= tmp->path_denied;
980	op->stats.luck+=tmp->stats.luck;	1061	move_type |= tmp->move_type;
981	op->move_type |= tmp->move_type;	1062	stats.luck += tmp->stats.luck;
982		1063
983	if(QUERY_FLAG(tmp,FLAG_LIFESAVE)) SET_FLAG(op,FLAG_LIFESAVE);	1064	if (QUERY_FLAG (tmp, FLAG_LIFESAVE )) SET_FLAG (this, FLAG_LIFESAVE);
984	if(QUERY_FLAG(tmp,FLAG_REFL_SPELL)) SET_FLAG(op,FLAG_REFL_SPELL);	1065	if (QUERY_FLAG (tmp, FLAG_REFL_SPELL )) SET_FLAG (this, FLAG_REFL_SPELL);
985	if(QUERY_FLAG(tmp,FLAG_REFL_MISSILE)) SET_FLAG(op,FLAG_REFL_MISSILE);	1066	if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE)) SET_FLAG (this, FLAG_REFL_MISSILE);
986	if(QUERY_FLAG(tmp,FLAG_STEALTH)) SET_FLAG(op,FLAG_STEALTH);	1067	if (QUERY_FLAG (tmp, FLAG_STEALTH )) SET_FLAG (this, FLAG_STEALTH);
987	if(QUERY_FLAG(tmp,FLAG_XRAYS)) SET_FLAG(op,FLAG_XRAYS);	1068	if (QUERY_FLAG (tmp, FLAG_XRAYS )) SET_FLAG (this, FLAG_XRAYS);
988	if(QUERY_FLAG(tmp,FLAG_BLIND)) SET_FLAG(op,FLAG_BLIND);	1069	if (QUERY_FLAG (tmp, FLAG_BLIND )) SET_FLAG (this, FLAG_BLIND);
989	if(QUERY_FLAG(tmp,FLAG_SEE_IN_DARK)) SET_FLAG(op,FLAG_SEE_IN_DARK);	1070	if (QUERY_FLAG (tmp, FLAG_SEE_IN_DARK )) SET_FLAG (this, FLAG_SEE_IN_DARK);
990		1071
991	if(QUERY_FLAG(tmp,FLAG_UNDEAD)&&!QUERY_FLAG(&op->arch->clone,FLAG_UNDEAD))	1072	if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (&arch->clone, FLAG_UNDEAD))
992	SET_FLAG(op,FLAG_UNDEAD);	1073	SET_FLAG (this, FLAG_UNDEAD);
993		1074
994	if(QUERY_FLAG(tmp,FLAG_MAKE_INVIS)) {	1075	if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS))
995	SET_FLAG(op,FLAG_MAKE_INVIS);	1076	{
996	op->invisible=1;	1077	SET_FLAG (this, FLAG_MAKE_INVIS);
997	}	1078	invisible = 1;
		1079	}
998		1080
999	if(tmp->stats.exp && tmp->type!=SKILL) {	1081	if (tmp->stats.exp && tmp->type != SKILL)
1000	if(tmp->stats.exp > 0) {	1082	{
1001	added_speed+=(float)tmp->stats.exp/3.0;	1083	if (tmp->stats.exp > 0)
1002	bonus_speed+=1.0+(float)tmp->stats.exp/3.0;	1084	{
1003	} else	1085	added_speed += tmp->stats.exp / 3.f;
1004	added_speed+=(float)tmp->stats.exp;	1086	bonus_speed += 1.f + tmp->stats.exp / 3.f;
1005	}	1087	}
		1088	else
		1089	added_speed += tmp->stats.exp;
		1090	}
1006		1091
1007	switch(tmp->type) {	1092	switch (tmp->type)
		1093	{
1008	/* skills modifying the character -b.t. */	1094	/* skills modifying the character -b.t. */
1009	/* for all skills and skill granting objects */	1095	/* for all skills and skill granting objects */
1010	case SKILL:	1096	case SKILL:
1011	if (!QUERY_FLAG(tmp,FLAG_APPLIED)) break;	1097	if (!QUERY_FLAG (tmp, FLAG_APPLIED))
		1098	break;
1012		1099
1013	if (IS_COMBAT_SKILL(tmp->subtype)) wc_obj=tmp;	1100	if (IS_COMBAT_SKILL (tmp->subtype))
		1101	wc_obj = tmp;
1014		1102
1015	if (op->chosen_skill) {	1103	if (chosen_skill)
1016	LOG(llevDebug, "fix_player, op %s has multiple skills applied\n", op->name);	1104	LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name);
1017	}	1105
1018	op->chosen_skill = tmp;	1106	chosen_skill = tmp;
1019	if(tmp->stats.dam>0) { /* skill is a 'weapon' */	1107
1020	if(!QUERY_FLAG(op,FLAG_READY_WEAPON))	1108	if (tmp->stats.dam > 0)
1021	weapon_speed = (int) WEAPON_SPEED(tmp);	1109	{ /* skill is a 'weapon' */
1022	if(weapon_speed<0) weapon_speed = 0;	1110	if (!QUERY_FLAG (this, FLAG_READY_WEAPON))
1023	weapon_weight=tmp->weight;	1111	weapon_speed = WEAPON_SPEED (tmp);
		1112
		1113	if (weapon_speed < 0)
		1114	weapon_speed = 0;
		1115
		1116	weapon_weight = tmp->weight;
1024	op->stats.dam+=tmp->stats.dam*(1 + (op->chosen_skill->level/9));	1117	stats.dam += tmp->stats.dam * (1 + (chosen_skill->level / 9));
1025	if(tmp->magic) op->stats.dam += tmp->magic;
1026	}
1027	if(tmp->stats.wc)
1028	wc-=(tmp->stats.wc+tmp->magic);
1029		1118
1030	if(tmp->slaying!=NULL) {	1119	if (tmp->magic)
1031	if (op->slaying != NULL)	1120	stats.dam += tmp->magic;
1032	free_string (op->slaying);	1121	}
1033	add_refcount(op->slaying = tmp->slaying);
1034	}
1035		1122
1036	if(tmp->stats.ac)	1123	if (tmp->stats.wc)
1037	ac-=(tmp->stats.ac+tmp->magic);	1124	wc -= (tmp->stats.wc + tmp->magic);
		1125
		1126	if (tmp->slaying != NULL)
		1127	slaying = tmp->slaying;
		1128
		1129	if (tmp->stats.ac)
		1130	ac -= (tmp->stats.ac + tmp->magic);
		1131
1038	if(settings.spell_encumbrance == TRUE && op->type==PLAYER)	1132	if (settings.spell_encumbrance == TRUE && type == PLAYER)
1039	op->contr->encumbrance+=(int)3*tmp->weight/1000;	1133	contr->encumbrance += (int) 3 *tmp->weight / 1000;
1040	if (op->type == PLAYER)
1041	op->contr->ranges[range_skill] = op;
1042	break;
1043		1134
1044	case SKILL_TOOL:	1135	if (type == PLAYER)
1045	if (op->chosen_skill) {	1136	contr->ranges[range_skill] = this;
		1137
		1138	break;
		1139
		1140	case SKILL_TOOL:
		1141	if (chosen_skill)
1046	LOG(llevDebug, "fix_player, op %s has multiple skills applied\n", op->name);	1142	LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name);
1047	}
1048	op->chosen_skill = tmp;
1049	if (op->type == PLAYER)
1050	op->contr->ranges[range_skill] = op;
1051	break;
1052		1143
1053	case SHIELD:	1144	chosen_skill = tmp;
		1145
		1146	if (type == PLAYER)
		1147	contr->ranges[range_skill] = this;
		1148	break;
		1149
		1150	case SHIELD:
1054	if(settings.spell_encumbrance == TRUE && op->type==PLAYER)	1151	if (settings.spell_encumbrance == TRUE && type == PLAYER)
1055	op->contr->encumbrance+=(int)tmp->weight/2000;	1152	contr->encumbrance += (int) tmp->weight / 2000;
1056	case RING:	1153	case RING:
1057	case AMULET:	1154	case AMULET:
1058	case GIRDLE:	1155	case GIRDLE:
1059	case HELMET:	1156	case HELMET:
1060	case BOOTS:	1157	case BOOTS:
1061	case GLOVES:	1158	case GLOVES:
1062	case CLOAK:	1159	case CLOAK:
1063	if(tmp->stats.wc)	1160	if (tmp->stats.wc)
1064	wc-=(tmp->stats.wc+tmp->magic);	1161	wc -= tmp->stats.wc + tmp->magic;
1065	if(tmp->stats.dam)
1066	op->stats.dam+=(tmp->stats.dam+tmp->magic);
1067	if(tmp->stats.ac)
1068	ac-=(tmp->stats.ac+tmp->magic);
1069	break;
1070		1162
1071	case WEAPON:	1163	if (tmp->stats.dam)
		1164	stats.dam += tmp->stats.dam + tmp->magic;
		1165
		1166	if (tmp->stats.ac)
		1167	ac -= tmp->stats.ac + tmp->magic;
		1168
		1169	break;
		1170
		1171	case BOW:
		1172	case WEAPON:
1072	wc-=(tmp->stats.wc+tmp->magic);	1173	wc -= tmp->stats.wc + tmp->magic;
		1174
1073	if(tmp->stats.ac&&tmp->stats.ac+tmp->magic>0)	1175	if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
1074	ac-=tmp->stats.ac+tmp->magic;	1176	ac -= tmp->stats.ac + tmp->magic;
1075	op->stats.dam+=(tmp->stats.dam+tmp->magic);	1177
		1178	stats.dam += tmp->stats.dam + tmp->magic;
1076	weapon_weight=tmp->weight;	1179	weapon_weight = tmp->weight;
1077	weapon_speed=((int)WEAPON_SPEED(tmp)*2-tmp->magic)/2;	1180	weapon_speed = ((int) WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;
1078	if(weapon_speed<0) weapon_speed=0;	1181
1079	if(tmp->slaying!=NULL) {	1182	if (weapon_speed < 0)
1080	if (op->slaying != NULL)	1183	weapon_speed = 0;
1081	free_string (op->slaying);	1184
1082	add_refcount(op->slaying = tmp->slaying);	1185	slaying = tmp->slaying;
1083	}	1186
1084	/* If there is desire that two handed weapons should do	1187	/* If there is desire that two handed weapons should do
1085	* extra strength damage, this is where the code should	1188	* extra strength damage, this is where the code should
1086	* go.	1189	* go.
1087	*/	1190	*/
1088	evt = find_event(tmp,EVENT_ATTACK);
1089	if (evt != NULL) {
1090	if (op->current_weapon_script)
1091	free_string(op->current_weapon_script);
1092	op->current_weapon_script=add_string(query_name(tmp));
1093	}
1094	op->current_weapon = tmp;
1095	if(settings.spell_encumbrance == TRUE && op->type==PLAYER)
1096	op->contr->encumbrance+=(int)3*tmp->weight/1000;
1097	break;
1098		1191
		1192	current_weapon = tmp;
		1193	if (type == PLAYER && settings.spell_encumbrance)
		1194	contr->encumbrance += tmp->weight * 3 / 1000;
		1195
		1196	break;
		1197
1099	case ARMOUR: /* Only the best of these three are used: */	1198	case ARMOUR: /* Only the best of these three are used: */
1100	if(settings.spell_encumbrance == TRUE && op->type==PLAYER)	1199	if (settings.spell_encumbrance == TRUE && type == PLAYER)
1101	op->contr->encumbrance+=(int)tmp->weight/1000;	1200	contr->encumbrance += tmp->weight / 1000;
1102		1201
1103	case BRACERS:	1202	case BRACERS:
1104	case FORCE:	1203	case FORCE:
1105	if(tmp->stats.wc) {	1204	if (tmp->stats.wc)
1106	if(best_wc<tmp->stats.wc+tmp->magic) {	1205	{
1107	wc+=best_wc;	1206	if (best_wc < tmp->stats.wc + tmp->magic)
1108	best_wc=tmp->stats.wc+tmp->magic;	1207	{
1109	} else	1208	wc += best_wc;
1110	wc+=tmp->stats.wc+tmp->magic;	1209	best_wc = tmp->stats.wc + tmp->magic;
1111	}	1210	}
1112	if(tmp->stats.ac) {	1211	else
1113	if(best_ac<tmp->stats.ac+tmp->magic) {	1212	wc += tmp->stats.wc + tmp->magic;
		1213	}
		1214
		1215	if (tmp->stats.ac)
		1216	{
		1217	if (best_ac < tmp->stats.ac + tmp->magic)
		1218	{
1114	ac+=best_ac; /* Remove last bonus */	1219	ac += best_ac; /* Remove last bonus */
1115	best_ac=tmp->stats.ac+tmp->magic;	1220	best_ac = tmp->stats.ac + tmp->magic;
1116	}	1221	}
1117	else /* To nullify the below effect */	1222	else /* To nullify the below effect */
1118	ac+=tmp->stats.ac+tmp->magic;	1223	ac += tmp->stats.ac + tmp->magic;
1119	}	1224	}
1120	if(tmp->stats.wc) wc-=(tmp->stats.wc+tmp->magic);	1225
1121	if(tmp->stats.ac) ac-=(tmp->stats.ac+tmp->magic);	1226	if (tmp->stats.wc)
		1227	wc -= (tmp->stats.wc + tmp->magic);
		1228
		1229	if (tmp->stats.ac)
		1230	ac -= (tmp->stats.ac + tmp->magic);
		1231
1122	if(ARMOUR_SPEED(tmp)&&ARMOUR_SPEED(tmp)/10.0<max)	1232	if (ARMOUR_SPEED (tmp) && ARMOUR_SPEED (tmp) / 10.f < max)
1123	max=ARMOUR_SPEED(tmp)/10.0;	1233	max = ARMOUR_SPEED (tmp) / 10.f;
1124	break;
1125	} /* switch tmp->type */
1126	} /* item is equipped */
1127	} /* for loop of items */
1128		1234
		1235	break;
		1236	} /* switch tmp->type */
		1237	} /* item is equipped */
		1238	} /* for loop of items */
		1239
1129	/* We've gone through all the objects the player has equipped. For many things, we	1240	/* We've gone through all the objects the player has equipped. For many things, we
1130	* have generated intermediate values which we now need to assign.	1241	* have generated intermediate values which we now need to assign.
1131	*/	1242	*/
1132		1243
1133	/* 'total resistance = total protections - total vulnerabilities'.	1244	/* 'total resistance = total protections - total vulnerabilities'.
1134	* If there is an uncursed potion in effect, granting more protection	1245	* If there is an uncursed potion in effect, granting more protection
1135	* than that, we take: 'total resistance = resistance from potion'.	1246	* than that, we take: 'total resistance = resistance from potion'.
1136	* If there is a cursed (and no uncursed) potion in effect, we take	1247	* If there is a cursed (and no uncursed) potion in effect, we take
1137	* 'total resistance = vulnerability from cursed potion'.	1248	* 'total resistance = vulnerability from cursed potion'.
1138	*/	1249	*/
1139	for (i=0; i<NROFATTACKS; i++) {	1250	for (i = 0; i < NROFATTACKS; i++)
		1251	{
1140	op->resist[i] = prot[i] - vuln[i];	1252	resist[i] = prot[i] - vuln[i];
		1253
1141	if (potion_resist[i] && ((potion_resist[i] > op->resist[i]) ||	1254	if (potion_resist[i] && ((potion_resist[i] > resist[i]) || (potion_resist[i] < 0)))
1142	(potion_resist[i] < 0)))
1143	op->resist[i] = potion_resist[i];	1255	resist[i] = potion_resist[i];
1144	}	1256	}
1145		1257
1146	/* Figure out the players sp/mana/hp totals. */	1258	/* Figure out the players sp/mana/hp totals. */
1147	if(op->type==PLAYER) {	1259	if (type == PLAYER)
		1260	{
1148	int pl_level;	1261	int pl_level;
1149		1262
1150	check_stat_bounds(&(op->stats));	1263	check_stat_bounds (&(stats));
1151	pl_level=op->level;	1264	pl_level = level;
1152		1265
		1266	if (pl_level < 1)
1153	if(pl_level<1) pl_level=1; /* safety, we should always get 1 levels worth of hp! */	1267	pl_level = 1; /* safety, we should always get 1 levels worth of hp! */
1154		1268
1155	/* You basically get half a con bonus/level. But we do take into account rounding,	1269	/* You basically get half a con bonus/level. But we do take into account rounding,
1156	* so if your bonus is 7, you still get 7 worth of bonus every 2 levels.	1270	* so if your bonus is 7, you still get 7 worth of bonus every 2 levels.
1157	*/	1271	*/
1158	for(i=1,op->stats.maxhp=0;i<=pl_level&&i<=10;i++) {	1272	for (i = 1, stats.maxhp = 0; i <= pl_level && i <= 10; i++)
		1273	{
1159	j=op->contr->levhp[i]+con_bonus[op->stats.Con]/2;	1274	j = contr->levhp[i] + con_bonus[stats.Con] / 2;
		1275
1160	if(i%2 && con_bonus[op->stats.Con]%2) {	1276	if (i % 2 && con_bonus[stats.Con] % 2)
1161	if (con_bonus[op->stats.Con]>0)	1277	{
1162	j++;	1278	if (con_bonus[stats.Con] > 0)
1163	else	1279	j++;
1164	j--;	1280	else
1165	}	1281	j--;
		1282	}
		1283
1166	op->stats.maxhp+=j>1?j:1; /* always get at least 1 hp/level */	1284	stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */
1167	}	1285	}
1168		1286
1169	for(i=11;i<=op->level;i++)	1287	for (i = 11; i <= level; i++)
1170	op->stats.maxhp+=2;	1288	stats.maxhp += 2;
1171		1289
1172	if(op->stats.hp>op->stats.maxhp)	1290	if (stats.hp > stats.maxhp)
1173	op->stats.hp=op->stats.maxhp;	1291	stats.hp = stats.maxhp;
1174		1292
1175	/* Sp gain is controlled by the level of the player's	1293	/* Sp gain is controlled by the level of the player's
1176	* relevant experience object (mana_obj, see above)	1294	* relevant experience object (mana_obj, see above)
1177	*/	1295	*/
1178	/* following happen when skills system is not used */	1296	/* following happen when skills system is not used */
1179	if(!mana_obj) mana_obj = op;	1297	if (!mana_obj)
1180	if(!grace_obj) grace_obj = op;	1298	mana_obj = this;
		1299
		1300	if (!grace_obj)
		1301	grace_obj = this;
		1302
1181	/* set maxsp */	1303	/* set maxsp */
1182	if(!mana_obj || !mana_obj->level || op->type!=PLAYER) mana_obj = op;	1304	if (!mana_obj || !mana_obj->level || type != PLAYER)
		1305	mana_obj = this;
1183		1306
1184	if (mana_obj == op && op->type == PLAYER) {	1307	if (mana_obj == this && type == PLAYER)
1185	op->stats.maxsp = 1;	1308	stats.maxsp = 1;
1186	} else {	1309	else
1187	sp_tmp=0.0;	1310	{
		1311	sp_tmp = 0.f;
		1312
1188	for(i=1;i<=mana_obj->level&&i<=10;i++) {	1313	for (i = 1; i <= mana_obj->level && i <= 10; i++)
1189	float stmp;	1314	{
		1315	float stmp;
1190		1316
1191	/* Got some extra bonus at first level */	1317	/* Got some extra bonus at first level */
1192	if(i<2) {	1318	if (i < 2)
1193	stmp = op->contr->levsp[i] +((2.0 * (float)sp_bonus[op->stats.Pow] +	1319	stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 6.f;
1194	(float)sp_bonus[op->stats.Int])/6.0);	1320	else
1195	} else {	1321	stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f;
1196	stmp=(float)op->contr->levsp[i]
1197	+(2.0 * (float)sp_bonus[op->stats.Pow] +
1198	(float)sp_bonus[op->stats.Int])/12.0;
1199	}
1200	if (stmp<1.0) stmp=1.0;
1201	sp_tmp+=stmp;
1202	}
1203	op->stats.maxsp=(int)sp_tmp;
1204		1322
		1323	if (stmp < 1.f)
		1324	stmp = 1.f;
		1325
		1326	sp_tmp += stmp;
		1327	}
		1328
		1329	stats.maxsp = (sint16)sp_tmp;
		1330
1205	for(i=11;i<=mana_obj->level;i++)	1331	for (i = 11; i <= mana_obj->level; i++)
1206	op->stats.maxsp+=2;	1332	stats.maxsp += 2;
1207	}	1333	}
1208	/* Characters can get their sp supercharged via rune of transferrance */	1334	/* Characters can get their sp supercharged via rune of transferrance */
1209	if(op->stats.sp>op->stats.maxsp*2)	1335	if (stats.sp > stats.maxsp * 2)
1210	op->stats.sp=op->stats.maxsp*2;	1336	stats.sp = stats.maxsp * 2;
1211		1337
1212	/* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */	1338	/* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */
1213	if(!grace_obj || !grace_obj->level || op->type!=PLAYER) grace_obj = op;	1339	if (!grace_obj || !grace_obj->level || type != PLAYER)
		1340	grace_obj = this;
1214		1341
1215	if (grace_obj == op && op->type == PLAYER) {	1342	if (grace_obj == this && type == PLAYER)
1216	op->stats.maxgrace = 1;	1343	stats.maxgrace = 1;
1217	} else {	1344	else
		1345	{
1218	/* store grace in a float - this way, the divisions below don't create	1346	/* store grace in a float - this way, the divisions below don't create
1219	* big jumps when you go from level to level - with int's, it then	1347	* big jumps when you go from level to level - with int's, it then
1220	* becomes big jumps when the sums of the bonuses jump to the next	1348	* becomes big jumps when the sums of the bonuses jump to the next
1221	* step of 8 - with floats, even fractional ones are useful.	1349	* step of 8 - with floats, even fractional ones are useful.
1222	*/	1350	*/
1223	sp_tmp=0.0;	1351	sp_tmp = 0.f;
1224	for(i=1,op->stats.maxgrace=0;i<=grace_obj->level&&i<=10;i++) {	1352	for (i = 1, stats.maxgrace = 0; i <= grace_obj->level && i <= 10; i++)
1225	float grace_tmp=0.0;	1353	{
		1354	float grace_tmp = 0.f;
1226		1355
1227	/* Got some extra bonus at first level */	1356	/* Got some extra bonus at first level */
1228	if(i<2) {	1357	if (i < 2)
1229	grace_tmp = op->contr->levgrace[i]+(((float)grace_bonus[op->stats.Pow] +	1358	grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 6.f;
1230	2.0 * (float)grace_bonus[op->stats.Wis])/6.0);	1359	else
1231	} else {	1360	grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f;
1232	grace_tmp=(float)op->contr->levgrace[i]
1233	+((float)grace_bonus[op->stats.Pow] +
1234	2.0 * (float)grace_bonus[op->stats.Wis])/12.0;
1235	}
1236	if (grace_tmp<1.0) grace_tmp=1.0;
1237	sp_tmp+=grace_tmp;
1238	}
1239	op->stats.maxgrace=(int)sp_tmp;
1240		1361
		1362	if (grace_tmp < 1.f)
		1363	grace_tmp = 1.f;
		1364
		1365	sp_tmp += grace_tmp;
		1366	}
		1367
		1368	stats.maxgrace = (sint16)sp_tmp;
		1369
1241	/* two grace points per level after 11 */	1370	/* two grace points per level after 11 */
1242	for(i=11;i<=grace_obj->level;i++)	1371	for (i = 11; i <= grace_obj->level; i++)
1243	op->stats.maxgrace+=2;	1372	stats.maxgrace += 2;
1244	}	1373	}
1245	/* No limit on grace vs maxgrace */	1374	/* No limit on grace vs maxgrace */
1246		1375
1247	if(op->contr->braced) {	1376	if (contr->braced)
1248	ac+=2;	1377	{
1249	wc+=4;	1378	ac += 2;
1250	}	1379	wc += 4;
1251	else	1380	}
		1381	else
1252	ac-=dex_bonus[op->stats.Dex];	1382	ac -= dex_bonus[stats.Dex];
1253		1383
1254	/* In new exp/skills system, wc bonuses are related to	1384	/* In new exp/skills system, wc bonuses are related to
1255	* the players level in a relevant exp object (wc_obj)	1385	* the players level in a relevant exp object (wc_obj)
1256	* not the general player level -b.t.	1386	* not the general player level -b.t.
1257	* I changed this slightly so that wc bonuses are better	1387	* I changed this slightly so that wc bonuses are better
1258	* than before. This is to balance out the fact that	1388	* than before. This is to balance out the fact that
1259	* the player no longer gets a personal weapon w/ 1	1389	* the player no longer gets a personal weapon w/ 1
1260	* improvement every level, now its fighterlevel/5. So	1390	* improvement every level, now its fighterlevel/5. So
1261	* we give the player a bonus here in wc and dam	1391	* we give the player a bonus here in wc and dam
1262	* to make up for the change. Note that I left the	1392	* to make up for the change. Note that I left the
1263	* monster bonus the same as before. -b.t.	1393	* monster bonus the same as before. -b.t.
1264	*/	1394	*/
1265		1395
1266	if(op->type==PLAYER && wc_obj && wc_obj->level>1) {	1396	if (type == PLAYER && wc_obj && wc_obj->level > 1)
		1397	{
1267	wc-=(wc_obj->level+thaco_bonus[op->stats.Str]);	1398	wc -= wc_obj->level + thaco_bonus[stats.Str];
		1399
1268	for(i=1;i<wc_obj->level;i++) {	1400	for (i = 1; i < wc_obj->level; i++)
		1401	{
1269	/* addtional wc every 6 levels */	1402	/* addtional wc every 6 levels */
1270	if(!(i%6)) wc--;	1403	if (!(i % 6))
		1404	wc--;
		1405
1271	/* addtional dam every 4 levels. */	1406	/* addtional dam every 4 levels. */
1272	if(!(i%4) && (dam_bonus[op->stats.Str]>=0))	1407	if (!(i % 4) && dam_bonus[stats.Str] >= 0)
1273	op->stats.dam+=(1+(dam_bonus[op->stats.Str]/5));	1408	stats.dam += 1 + dam_bonus[stats.Str] / 5;
1274	}	1409	}
1275	} else	1410	}
		1411	else
1276	wc-=(op->level+thaco_bonus[op->stats.Str]);	1412	wc -= level + thaco_bonus[stats.Str];
1277		1413
1278	op->stats.dam+=dam_bonus[op->stats.Str];	1414	stats.dam += dam_bonus[stats.Str];
1279		1415
1280	if(op->stats.dam<1)	1416	if (stats.dam < 1)
1281	op->stats.dam=1;	1417	stats.dam = 1;
1282		1418
1283	op->speed=1.0+speed_bonus[op->stats.Dex];	1419	speed = 1.f + speed_bonus[stats.Dex];
		1420
1284	if (settings.search_items && op->contr->search_str[0])	1421	if (settings.search_items && contr->search_str[0])
1285	op->speed -= 1;	1422	speed -= 1;
1286	if (op->attacktype==0)
1287	op->attacktype=op->arch->clone.attacktype;
1288		1423
1289	} /* End if player */	1424	if (attacktype == 0)
		1425	attacktype = arch->clone.attacktype;
1290		1426
		1427	} /* End if player */
		1428
1291	if(added_speed>=0)	1429	if (added_speed >= 0)
1292	op->speed+=added_speed/10.0;	1430	speed += added_speed / 10.f;
1293	else /* Something wrong here...: */	1431	else /* Something wrong here...: */
1294	op->speed /= (float)(1.0-added_speed);	1432	speed /= 1.f - added_speed;
1295		1433
1296	/* Max is determined by armour */	1434	/* Max is determined by armour */
1297	if(op->speed>max)	1435	if (speed > max)
1298	op->speed=max;	1436	speed = max;
1299		1437
1300	if(op->type == PLAYER) {	1438	if (type == PLAYER)
		1439	{
1301	/* f is a number the represents the number of kg above (positive num)	1440	/* f is a number the represents the number of kg above (positive num)
1302	* or below (negative number) that the player is carrying. If above	1441	* or below (negative number) that the player is carrying. If above
1303	* weight limit, then player suffers a speed reduction based on how	1442	* weight limit, then player suffers a speed reduction based on how
1304	* much above he is, and what is max carry is	1443	* much above he is, and what is max carry is
1305	*/	1444	*/
1306	f=(op->carrying/1000)-max_carry[op->stats.Str];	1445	f = (carrying / 1000) - max_carry[stats.Str];
1307	if(f>0) op->speed=op->speed/(1.0+f/max_carry[op->stats.Str]);	1446	if (f > 0)
		1447	speed = speed / (1.f + f / max_carry[stats.Str]);
1308	}	1448	}
1309		1449
1310	op->speed+=bonus_speed/10.0; /* Not affected by limits */	1450	speed += bonus_speed / 10.f; /* Not affected by limits */
1311		1451
1312	/* Put a lower limit on speed. Note with this speed, you move once every	1452	/* Put a lower limit on speed. Note with this speed, you move once every
1313	* 100 ticks or so. This amounts to once every 12 seconds of realtime.	1453	* 100 ticks or so. This amounts to once every 12 seconds of realtime.
1314	*/	1454	*/
1315	op->speed = op->speed * speed_reduce_from_disease;	1455	speed = speed * speed_reduce_from_disease;
1316		1456
1317	if (op->speed<0.01 && op->type==PLAYER) op->speed=0.01;	1457	if (speed < 0.01f && type == PLAYER)
		1458	speed = 0.01f;
1318		1459
1319	if(op->type == PLAYER) {	1460	if (type == PLAYER)
1320	float M,W,s,D,K,S,M2;	1461	{
1321
1322	/* (This formula was made by vidarl@ifi.uio.no)	1462	/* (This formula was made by vidarl@ifi.uio.no)
1323	* Note that we never used these values again - basically	1463	* Note that we never used these values again - basically
1324	* all of these could be subbed into one big equation, but	1464	* all of these could be subbed into one big equation, but
1325	* that would just be a real pain to read.	1465	* that would just be a real pain to read.
1326	*/	1466	*/
1327	M=(max_carry[op->stats.Str]-121)/121.0;	1467	float M = (max_carry[stats.Str] - 121) / 121.f;
1328	M2=max_carry[op->stats.Str]/100.0;	1468	float M2 = max_carry[stats.Str] / 100.f;
1329	W=weapon_weight/20000.0;	1469	float W = weapon_weight / 20000.f;
1330	s=2-weapon_speed/10.0;	1470	float s = 2 - weapon_speed / 10.f;
1331	D=(op->stats.Dex-14)/14.0;	1471	float D = (stats.Dex - 14) / 14.f;
1332	K=1 + M/3.0 - W/(3*M2) + op->speed/5.0 + D/2.0;	1472	float K = 1 + M / 3.f - W / (3 * M2) + speed / 5.f + D / 2.f;
1333	K*=(4+op->level)/(float)(6+op->level)*1.2;	1473
1334	if(K<=0) K=0.01;	1474	K *= (4 + level) *1.2f / (6 + level);
1335	S=op->speed/(K*s);	1475
1336	op->contr->weapon_sp=S;	1476	if (K <= 0.f)
		1477	K = 0.01f;
		1478
		1479	float S = speed / (K * s);
		1480
		1481	contr->weapon_sp = S;
1337	}	1482	}
		1483
1338	/* I want to limit the power of small monsters with big weapons: */	1484	/* I want to limit the power of small monsters with big weapons: */
1339	if(op->type!=PLAYER&&op->arch!=NULL&&	1485	if (type != PLAYER && arch && stats.dam > arch->clone.stats.dam * 3)
1340	op->stats.dam>op->arch->clone.stats.dam*3)	1486	stats.dam = arch->clone.stats.dam * 3;
1341	op->stats.dam=op->arch->clone.stats.dam*3;
1342		1487
1343	/* Prevent overflows of wc - best you can get is ABS(120) - this	1488	/* Prevent overflows of wc - best you can get is ABS(120) - this
1344	* should be more than enough - remember, AC is also in 8 bits,	1489	* should be more than enough - remember, AC is also in 8 bits,
1345	* so its value is the same.	1490	* so its value is the same.
1346	*/	1491	*/
1347	if (wc>120) wc=120;	1492	if (wc > 120)
1348	else if (wc<-120) wc=-120;	1493	wc = 120;
		1494	else if (wc < -120)
		1495	wc = -120;
		1496
1349	op->stats.wc=wc;	1497	stats.wc = wc;
1350		1498
1351	if (ac>120) ac=120;	1499	if (ac > 120)
1352	else if (ac<-120) ac=-120;	1500	ac = 120;
		1501	else if (ac < -120)
		1502	ac = -120;
		1503
1353	op->stats.ac=ac;	1504	stats.ac = ac;
1354		1505
1355	/* if for some reason the creature doesn't have any move type,	1506	/* if for some reason the creature doesn't have any move type,
1356	* give them walking as a default.	1507	* give them walking as a default.
1357	* The second case is a special case - to more closely mimic the	1508	* The second case is a special case - to more closely mimic the
1358	* old behaviour - if your flying, your not walking - just	1509	* old behaviour - if your flying, your not walking - just
1359	* one or the other.	1510	* one or the other.
1360	*/	1511	*/
1361	if (op->move_type == 0) op->move_type = MOVE_WALK;	1512	if (move_type == 0)
		1513	move_type = MOVE_WALK;
1362	else if (op->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) op->move_type &= ~MOVE_WALK;	1514	else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))
		1515	move_type &= ~MOVE_WALK;
1363		1516
1364	update_ob_speed(op);	1517	if (speed != old_speed)
		1518	set_speed (speed);
1365		1519
1366	/* It is quite possible that a player's spell costing might have changed,	1520	/* It is quite possible that a player's spell costing might have changed,
1367	* so we will check that now.	1521	* so we will check that now.
1368	*/	1522	*/
1369	if (op->type == PLAYER) esrv_update_spells(op->contr);	1523	if (type == PLAYER)
		1524	{
		1525	esrv_update_stats (contr);
		1526	esrv_update_spells (contr);
		1527	}
		1528
		1529	// update the mapspace, if we are on a map
		1530	if (!flag [FLAG_REMOVED] && map)
		1531	map->at (x, y).flags_ = 0;
1370	}	1532	}
1371		1533
1372	/*	1534	/*
1373	* Returns true if the given player is a legal class.	1535	* Returns true if the given player is a legal class.
1374	* The function to add and remove class-bonuses to the stats doesn't	1536	* The function to add and remove class-bonuses to the stats doesn't
1375	* check if the stat becomes negative, thus this function	1537	* check if the stat becomes negative, thus this function
1376	* merely checks that all stats are 1 or more, and returns	1538	* merely checks that all stats are 1 or more, and returns
1377	* false otherwise.	1539	* false otherwise.
1378	*/	1540	*/
1379		1541	int
1380	int allowed_class(const object *op) {	1542	allowed_class (const object *op)
1381	return op->stats.Dex>0&&op->stats.Str>0&&op->stats.Con>0&&	1543	{
1382	op->stats.Int>0&&op->stats.Wis>0&&op->stats.Pow>0&&	1544	return op->stats.Dex > 0
		1545	&& op->stats.Str > 0
		1546	&& op->stats.Con > 0
		1547	&& op->stats.Int > 0
		1548	&& op->stats.Wis > 0
		1549	&& op->stats.Pow > 0
1383	op->stats.Cha>0;	1550	&& op->stats.Cha > 0;
1384	}	1551	}
1385		1552
1386	/*	1553	/*
1387	* set the new dragon name after gaining levels or	1554	* set the new dragon name after gaining levels or
1388	* changing ability focus (later this can be extended to	1555	* changing ability focus (later this can be extended to
…		…
1391	* Note that the title is written to 'own_title' in the	1558	* Note that the title is written to 'own_title' in the
1392	* player struct. This should be changed to 'ext_title'	1559	* player struct. This should be changed to 'ext_title'
1393	* as soon as clients support this!	1560	* as soon as clients support this!
1394	* Please, anyone, write support for 'ext_title'.	1561	* Please, anyone, write support for 'ext_title'.
1395	*/	1562	*/
		1563	void
1396	void set_dragon_name(object *pl, const object *abil, const object *skin) {	1564	set_dragon_name (object *pl, const object *abil, const object *skin)
		1565	{
1397	int atnr=-1; /* attacknumber of highest level */	1566	int atnr = -1; /* attacknumber of highest level */
1398	int level=0; /* highest level */	1567	int level = 0; /* highest level */
1399	int i;	1568	int i;
1400		1569
1401	/* Perhaps do something more clever? */	1570	/* Perhaps do something more clever? */
1402	if (!abil || !skin) return;	1571	if (!abil || !skin)
1403		1572	return;
		1573
1404	/* first, look for the highest level */	1574	/* first, look for the highest level */
1405	for(i=0; i<NROFATTACKS; i++) {	1575	for (i = 0; i < NROFATTACKS; i++)
1406	if (atnr_is_dragon_enabled(i) &&	1576	{
1407	(atnr==-1 || abil->resist[i] > abil->resist[atnr])) {	1577	if (atnr_is_dragon_enabled (i) && (atnr == -1 || abil->resist[i] > abil->resist[atnr]))
		1578	{
1408	level = abil->resist[i];	1579	level = abil->resist[i];
1409	atnr = i;	1580	atnr = i;
1410	}	1581	}
1411	}	1582	}
1412		1583
1413	/* now if there are equals at highest level, pick the one with focus,	1584	/* now if there are equals at highest level, pick the one with focus,
1414	or else at random */	1585	or else at random */
1415	if (atnr_is_dragon_enabled(abil->stats.exp) &&	1586	if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level)
1416	abil->resist[abil->stats.exp] >= level)
1417	atnr = abil->stats.exp;	1587	atnr = abil->stats.exp;
1418		1588
1419	level = (int)(level/5.);	1589	level = (int) (level / 5.);
1420		1590
1421	/* now set the new title */	1591	/* now set the new title */
1422	if (pl->contr != NULL) {	1592	if (pl->contr != NULL)
		1593	{
1423	if(level == 0)	1594	if (level == 0)
1424	sprintf(pl->contr->title, "%s hatchling", attacks[atnr]);	1595	sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
1425	else if (level == 1)	1596	else if (level == 1)
1426	sprintf(pl->contr->title, "%s wyrm", attacks[atnr]);	1597	sprintf (pl->contr->title, "%s wyrm", attacks[atnr]);
1427	else if (level == 2)	1598	else if (level == 2)
1428	sprintf(pl->contr->title, "%s wyvern", attacks[atnr]);	1599	sprintf (pl->contr->title, "%s wyvern", attacks[atnr]);
1429	else if (level == 3)	1600	else if (level == 3)
1430	sprintf(pl->contr->title, "%s dragon", attacks[atnr]);	1601	sprintf (pl->contr->title, "%s dragon", attacks[atnr]);
1431	else {
1432	/* special titles for extra high resistance! */
1433	if (skin->resist[atnr] > 80)
1434	sprintf(pl->contr->title, "legendary %s dragon", attacks[atnr]);
1435	else if (skin->resist[atnr] > 50)
1436	sprintf(pl->contr->title, "ancient %s dragon", attacks[atnr]);
1437	else	1602	else
		1603	{
		1604	/* special titles for extra high resistance! */
		1605	if (skin->resist[atnr] > 80)
		1606	sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);
		1607	else if (skin->resist[atnr] > 50)
		1608	sprintf (pl->contr->title, "ancient %s dragon", attacks[atnr]);
		1609	else
1438	sprintf(pl->contr->title, "big %s dragon", attacks[atnr]);	1610	sprintf (pl->contr->title, "big %s dragon", attacks[atnr]);
1439	}	1611	}
1440	}	1612	}
1441		1613
1442	strcpy(pl->contr->own_title, "");	1614	strcpy (pl->contr->own_title, "");
1443	}	1615	}
1444		1616
1445	/*	1617	/*
1446	* This function is called when a dragon-player gains	1618	* This function is called when a dragon-player gains
1447	* an overall level. Here, the dragon might gain new abilities	1619	* an overall level. Here, the dragon might gain new abilities
1448	* or change the ability-focus.	1620	* or change the ability-focus.
1449	*/	1621	*/
		1622	void
1450	void dragon_level_gain(object *who) {	1623	dragon_level_gain (object *who)
		1624	{
1451	object *abil = NULL; /* pointer to dragon ability force*/	1625	object *abil = NULL; /* pointer to dragon ability force */
1452	object *skin = NULL; /* pointer to dragon skin force*/	1626	object *skin = NULL; /* pointer to dragon skin force */
1453	object *tmp = NULL; /* tmp. object */	1627	object *tmp = NULL; /* tmp. object */
1454	char buf[MAX_BUF]; /* tmp. string buffer */	1628	char buf[MAX_BUF]; /* tmp. string buffer */
1455		1629
1456	/* now grab the 'dragon_ability'-forces from the player's inventory */	1630	/* now grab the 'dragon_ability'-forces from the player's inventory */
		1631	shstr_cmp dragon_ability_force ("dragon_ability_force");
		1632	shstr_cmp dragon_skin_force ("dragon_skin_force");
		1633
1457	for (tmp=who->inv; tmp!=NULL; tmp=tmp->below) {	1634	for (tmp = who->inv; tmp; tmp = tmp->below)
1458	if (tmp->type == FORCE) {	1635	if (tmp->type == FORCE)
1459	if (strcmp(tmp->arch->name, "dragon_ability_force")==0)	1636	if (tmp->arch->name == dragon_ability_force)
1460	abil = tmp;	1637	abil = tmp;
1461	if (strcmp(tmp->arch->name, "dragon_skin_force")==0)	1638	else if (tmp->arch->name == dragon_skin_force)
1462	skin = tmp;	1639	skin = tmp;
1463	}	1640
1464	}
1465	/* if the force is missing -> bail out */	1641	/* if the force is missing -> bail out */
1466	if (abil == NULL) return;	1642	if (abil == NULL)
1467		1643	return;
		1644
1468	/* The ability_force keeps track of maximum level ever achieved.	1645	/* The ability_force keeps track of maximum level ever achieved.
1469	* New abilties can only be gained by surpassing this max level	1646	* New abilties can only be gained by surpassing this max level
1470	*/	1647	*/
1471	if (who->level > abil->level) {	1648	if (who->level > abil->level)
		1649	{
1472	/* increase our focused ability */	1650	/* increase our focused ability */
1473	abil->resist[abil->stats.exp]++;	1651	abil->resist[abil->stats.exp]++;
1474
1475		1652
		1653
1476	if (abil->resist[abil->stats.exp]>0 && abil->resist[abil->stats.exp]%5 == 0) {	1654	if (abil->resist[abil->stats.exp] > 0 && abil->resist[abil->stats.exp] % 5 == 0)
		1655	{
1477	/* time to hand out a new ability-gift */	1656	/* time to hand out a new ability-gift */
1478	dragon_ability_gain(who, (int)abil->stats.exp,	1657	dragon_ability_gain (who, (int) abil->stats.exp, (int) ((1 + abil->resist[abil->stats.exp]) / 5.));
1479	(int)((1+abil->resist[abil->stats.exp])/5.));	1658	}
1480	}	1659
1481
1482	if (abil->last_eat > 0 && atnr_is_dragon_enabled(abil->last_eat)) {	1660	if (abil->last_eat > 0 && atnr_is_dragon_enabled (abil->last_eat))
		1661	{
1483	/* apply new ability focus */	1662	/* apply new ability focus */
1484	sprintf(buf, "Your metabolism now focuses on %s!",	1663	sprintf (buf, "Your metabolism now focuses on %s!", change_resist_msg[abil->last_eat]);
1485	change_resist_msg[abil->last_eat]);
1486	new_draw_info(NDI_UNIQUE|NDI_BLUE, 0, who, buf);	1664	new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, who, buf);
1487		1665
1488	abil->stats.exp = abil->last_eat;	1666	abil->stats.exp = abil->last_eat;
1489	abil->last_eat = 0;	1667	abil->last_eat = 0;
1490	}	1668	}
		1669
		1670	abil->level = who->level;
1491		1671	}
1492	abil->level = who->level;	1672
1493	}
1494
1495	/* last but not least, set the new title for the dragon */	1673	/* last but not least, set the new title for the dragon */
1496	set_dragon_name(who, abil, skin);	1674	set_dragon_name (who, abil, skin);
1497	}	1675	}
1498		1676
1499	/* Handy function - given the skill name skill_name, we find the skill	1677	/* Handy function - given the skill name skill_name, we find the skill
1500	* archetype/object, set appropriate values, and insert it into	1678	* archetype/object, set appropriate values, and insert it into
1501	* the object (op) that is passed.	1679	* the object (op) that is passed.
1502	* We return the skill - this makes it easier for calling functions that	1680	* We return the skill - this makes it easier for calling functions that
1503	* want to do something with it immediately.	1681	* want to do something with it immediately.
1504	*/	1682	*/
		1683	object *
1505	object *give_skill_by_name(object *op, const char *skill_name)	1684	give_skill_by_name (object *op, const char *skill_name)
1506	{	1685	{
1507	object *skill_obj;	1686	object *skill_obj;
1508		1687
1509	skill_obj = get_archetype_by_skill_name(skill_name, SKILL);	1688	skill_obj = get_archetype_by_skill_name (skill_name, SKILL);
1510	if (!skill_obj) {	1689	if (!skill_obj)
		1690	{
1511	LOG(llevError, "add_player_exp: couldn't find skill %s\n", skill_name);	1691	LOG (llevError, "add_player_exp: couldn't find skill %s\n", skill_name);
1512	return NULL;	1692	return NULL;
1513	}	1693	}
1514	/* clear the flag - exp goes into this bucket, but player	1694	/* clear the flag - exp goes into this bucket, but player
1515	* still doesn't know it.	1695	* still doesn't know it.
1516	*/	1696	*/
1517	CLEAR_FLAG(skill_obj, FLAG_CAN_USE_SKILL);	1697	CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL);
1518	skill_obj->stats.exp = 0;	1698	skill_obj->stats.exp = 0;
1519	skill_obj->level = 1;	1699	skill_obj->level = 1;
1520	insert_ob_in_ob(skill_obj, op);	1700	insert_ob_in_ob (skill_obj, op);
		1701
1521	if (op->contr) {	1702	if (op->contr)
		1703	{
1522	op->contr->last_skill_ob[skill_obj->subtype] = skill_obj;	1704	op->contr->last_skill_ob [skill_obj->subtype] = skill_obj;
1523	op->contr->last_skill_exp[skill_obj->subtype] = -1;	1705	if (op->contr->ns)
		1706	op->contr->ns->last_skill_exp[skill_obj->subtype] = -1;//TODO: should be made superfluous
1524	}	1707	}
		1708
1525	return skill_obj;	1709	return skill_obj;
1526	}	1710	}
1527		1711
1528		1712
1529	/* player_lvl_adj() - for the new exp system. we are concerned with	1713	/* player_lvl_adj() - for the new exp system. we are concerned with
1530	* whether the player gets more hp, sp and new levels.	1714	* whether the player gets more hp, sp and new levels.
1531	* Note this this function should only be called for players. Monstes	1715	* Note this this function should only be called for players. Monstes
1532	* don't really gain levels	1716	* don't really gain levels
1533	* who is the player, op is what we are checking to gain the level	1717	* who is the player, op is what we are checking to gain the level
1534	* (eg, skill)	1718	* (eg, skill)
1535	*/	1719	*/
		1720	void
1536	void player_lvl_adj(object *who, object *op) {	1721	player_lvl_adj (object *who, object *op)
		1722	{
1537	char buf[MAX_BUF];	1723	char buf[MAX_BUF];
1538		1724
1539	if(!op) /* when rolling stats */	1725	if (!op) /* when rolling stats */
1540	op = who;	1726	op = who;
1541		1727
1542	if(op->level < settings.max_level && op->stats.exp >= level_exp(op->level+1,who->expmul)) {	1728	if (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul))
		1729	{
1543	op->level++;	1730	op->level++;
1544		1731
1545	if (op != NULL && op == who && op->stats.exp > 1 && is_dragon_pl(who))	1732	if (op != NULL && op == who && op->stats.exp > 1 && is_dragon_pl (who))
1546	dragon_level_gain(who);	1733	dragon_level_gain (who);
1547		1734
1548	/* Only roll these if it is the player (who) that gained the level */	1735	/* Only roll these if it is the player (who) that gained the level */
1549	if(op==who && (who->level < 11) && who->type==PLAYER) {	1736	if (op == who && (who->level < 11) && who->type == PLAYER)
		1737	{
1550	who->contr->levhp[who->level] = die_roll(2, 4, who, PREFER_HIGH)+1;	1738	who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;
1551	who->contr->levsp[who->level] = die_roll(2, 3, who, PREFER_HIGH);	1739	who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);
1552	who->contr->levgrace[who->level]=die_roll(2, 2, who, PREFER_HIGH)-1;	1740	who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;
1553	}	1741	}
1554		1742
1555	fix_player(who);	1743	who->update_stats ();
1556	if(op->level>1) {	1744	if (op->level > 1)
		1745	{
1557	if (op->type!=PLAYER)	1746	if (op->type != PLAYER)
1558	sprintf(buf,"You are now level %d in the %s skill.",op->level,op->name);	1747	sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1559	else	1748	else
1560	sprintf(buf,"You are now level %d.",op->level);	1749	sprintf (buf, "You are now level %d.", op->level);
		1750	if (who)
1561	if(who) new_draw_info(NDI_UNIQUE|NDI_RED, 0, who,buf);	1751	new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1562	}	1752	}
1563	player_lvl_adj(who,op); /* To increase more levels */	1753	player_lvl_adj (who, op); /* To increase more levels */
		1754	}
1564	} else if (op->level>1 && op->stats.exp<level_exp(op->level,who->expmul)) {	1755	else if (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))
		1756	{
1565	op->level--;	1757	op->level--;
1566	fix_player(who);	1758	who->update_stats ();
1567	if(op->type!=PLAYER) {	1759	if (op->type != PLAYER)
		1760	{
1568	sprintf(buf,"You are now level %d in the %s skill.",op->level,op->name);	1761	sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1569	new_draw_info(NDI_UNIQUE|NDI_RED, 0, who,buf);	1762	new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1570	}	1763	}
1571	player_lvl_adj(who,op); /* To decrease more levels */	1764	player_lvl_adj (who, op); /* To decrease more levels */
1572	}	1765	}
		1766
1573	/* check if the spell data has changed */	1767	/* check if the spell data has changed */
		1768	esrv_update_stats (who->contr);
1574	esrv_update_spells(who->contr);	1769	esrv_update_spells (who->contr);
1575	}	1770	}
1576		1771
1577	/*	1772	/*
1578	* Returns how much experience is needed for a player to become	1773	* Returns how much experience is needed for a player to become
1579	* the given level. level should really never exceed max_level	1774	* the given level. level should really never exceed max_level
1580	*/	1775	*/
1581		1776
		1777	sint64
1582	sint64 level_exp(int level,double expmul) {	1778	level_exp (int level, double expmul)
		1779	{
1583	if (level > settings.max_level)	1780	if (level > settings.max_level)
1584	return (sint64) (expmul * levels[settings.max_level]);	1781	return (sint64) (expmul * levels[settings.max_level]);
		1782
1585	return (sint64) (expmul * levels[level]);	1783	return (sint64) (expmul * levels[level]);
1586	}	1784	}
1587		1785
1588	/*	1786	/*
1589	* Ensure that the permanent experience requirements in an exp object are met.	1787	* Ensure that the permanent experience requirements in an exp object are met.
1590	* This really just checks 'op to make sure the perm_exp value is within	1788	* This really just checks 'op to make sure the perm_exp value is within
1591	* proper range. Note that the checking of what is passed through	1789	* proper range. Note that the checking of what is passed through
1592	* has been reduced. Since there is now a proper field for perm_exp,	1790	* has been reduced. Since there is now a proper field for perm_exp,
1593	* this can now work on a much larger set of objects.	1791	* this can now work on a much larger set of objects.
1594	*/	1792	*/
		1793	void
1595	void calc_perm_exp(object *op)	1794	calc_perm_exp (object *op)
1596	{	1795	{
1597	int p_exp_min;	1796	int p_exp_min;
1598		1797
1599	/* Ensure that our permanent experience minimum is met.	1798	/* Ensure that our permanent experience minimum is met.
1600	* permenent_exp_ratio is an integer percentage, we divide by 100	1799	* permenent_exp_ratio is an integer percentage, we divide by 100
1601	* to get the fraction */	1800	* to get the fraction */
1602	p_exp_min = (int)(settings.permanent_exp_ratio * (float)(op->stats.exp)/100);	1801	p_exp_min = (int) (settings.permanent_exp_ratio * (float) (op->stats.exp) / 100);
1603		1802
1604	if (op->perm_exp < p_exp_min)	1803	if (op->perm_exp < p_exp_min)
1605	op->perm_exp = p_exp_min;	1804	op->perm_exp = p_exp_min;
1606		1805
1607	/* Cap permanent experience. */	1806	/* Cap permanent experience. */
1608	if (op->perm_exp < 0)	1807	if (op->perm_exp < 0)
1609	op->perm_exp = 0;	1808	op->perm_exp = 0;
1610	else if (op->perm_exp > MAX_EXPERIENCE)	1809	else if (op->perm_exp > (sint64) MAX_EXPERIENCE)
1611	op->perm_exp = MAX_EXPERIENCE;	1810	op->perm_exp = MAX_EXPERIENCE;
1612	}	1811	}
1613
1614		1812
1615	/* Add experience to a player - exp should only be positive.	1813	/* Add experience to a player - exp should only be positive.
1616	* Updates permanent exp for the skill we are adding to.	1814	* Updates permanent exp for the skill we are adding to.
1617	* skill_name is the skill to add exp to. Skill name can be	1815	* skill_name is the skill to add exp to. Skill name can be
1618	* NULL, in which case exp increases the players general	1816	* NULL, in which case exp increases the players general
1619	* total, but not any particular skill.	1817	* total, but not any particular skill.
1620	* flag is what to do if the player doesn't have the skill:	1818	* flag is what to do if the player doesn't have the skill:
1621	*/	1819	*/
1622		1820	static void
1623	static void add_player_exp(object *op, sint64 exp, const char *skill_name, int flag)	1821	add_player_exp (object *op, sint64 exp, const char *skill_name, int flag)
1624	{	1822	{
1625	object *skill_obj=NULL;	1823	object *skill_obj = NULL;
1626	sint64 limit, exp_to_add;	1824	sint64 limit, exp_to_add;
1627	int i;	1825	int i;
1628		1826
1629	/* prevents some forms of abuse. */	1827	/* prevents some forms of abuse. */
1630	if(op->contr->braced) exp=exp/5;	1828	if (op->contr->braced)
		1829	exp = exp / 5;
1631		1830
1632	/* Try to find the matching skill.	1831	/* Try to find the matching skill.
1633	* We do a shortcut/time saving mechanism first - see if it matches	1832	* We do a shortcut/time saving mechanism first - see if it matches
1634	* chosen_skill. This means we don't need to search through	1833	* chosen_skill. This means we don't need to search through
1635	* the players inventory.	1834	* the players inventory.
1636	*/	1835	*/
1637	if (skill_name) {	1836	if (skill_name)
1638	if (op->chosen_skill && op->chosen_skill->type == SKILL &&	1837	{
1639	!strcmp(skill_name, op->chosen_skill->skill))	1838	if (op->chosen_skill && op->chosen_skill->type == SKILL && !strcmp (skill_name, op->chosen_skill->skill))
1640	skill_obj = op->chosen_skill;	1839	skill_obj = op->chosen_skill;
1641	else {	1840	else
		1841	{
1642	for (i=0; i<NUM_SKILLS; i++)	1842	for (i = 0; i < NUM_SKILLS; i++)
1643	if (op->contr->last_skill_ob[i] &&	1843	if (op->contr->last_skill_ob[i] && !strcmp (op->contr->last_skill_ob[i]->skill, skill_name))
1644	!strcmp(op->contr->last_skill_ob[i]->skill, skill_name)) {	1844	{
1645	skill_obj = op->contr->last_skill_ob[i];	1845	skill_obj = op->contr->last_skill_ob[i];
1646	break;	1846	break;
1647	}	1847	}
1648		1848
1649	/* Player doesn't have the skill. Check to see what to do, and give	1849	/* Player doesn't have the skill. Check to see what to do, and give
1650	* it to the player if necessary	1850	* it to the player if necessary
1651	*/	1851	*/
1652	if (!skill_obj) {	1852	if (!skill_obj)
1653	if (flag == SK_EXP_NONE) return;	1853	{
		1854	if (flag == SK_EXP_NONE)
		1855	return;
1654	else if (flag == SK_EXP_ADD_SKILL)	1856	else if (flag == SK_EXP_ADD_SKILL)
1655	give_skill_by_name(op, skill_name);	1857	give_skill_by_name (op, skill_name);
		1858	}
		1859	}
1656	}	1860	}
1657	}	1861
		1862	if (flag != SK_EXP_SKILL_ONLY)
1658	}	1863	{
1659
1660	/* Basically, you can never gain more experience in one shot	1864	/* Basically, you can never gain more experience in one shot
1661	* than half what you need to gain for next level.	1865	* than half what you need to gain for next level.
1662	*/	1866	*/
1663	exp_to_add = exp;	1867	exp_to_add = exp;
1664	limit=(levels[op->level+1]-levels[op->level])/2;	1868	limit = (levels[op->level + 1] - levels[op->level]) / 2;
1665	if (exp_to_add > limit) exp_to_add=limit;	1869	if (exp_to_add > limit)
		1870	exp_to_add = limit;
1666		1871
1667	ADD_EXP(op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj? skill_obj->expmul:1)));	1872	ADD_EXP (op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj ? skill_obj->expmul : 1)));
1668	if (settings.permanent_exp_ratio) {	1873	if (settings.permanent_exp_ratio)
		1874	{
1669	ADD_EXP(op->perm_exp, (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO * (skill_obj? skill_obj->expmul:1)));	1875	ADD_EXP (op->perm_exp, (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO * (skill_obj ? skill_obj->expmul : 1)));
1670	calc_perm_exp(op);	1876	calc_perm_exp (op);
1671	}	1877	}
1672		1878
1673	player_lvl_adj(op,NULL);	1879	player_lvl_adj (op, NULL);
		1880	}
		1881
1674	if (skill_obj) {	1882	if (skill_obj)
		1883	{
1675	exp_to_add = exp;	1884	exp_to_add = exp;
1676	limit=(levels[skill_obj->level+1]-levels[skill_obj->level])/2;	1885	limit = (levels[skill_obj->level + 1] - levels[skill_obj->level]) / 2;
1677	if (exp_to_add > limit) exp_to_add=limit;	1886	if (exp_to_add > limit)
		1887	exp_to_add = limit;
		1888
1678	ADD_EXP(skill_obj->stats.exp, exp_to_add);	1889	ADD_EXP (skill_obj->stats.exp, exp_to_add);
1679	if (settings.permanent_exp_ratio) {	1890	if (settings.permanent_exp_ratio)
		1891	{
1680	skill_obj->perm_exp += (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO);	1892	skill_obj->perm_exp += (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO);
1681	calc_perm_exp(skill_obj);	1893	calc_perm_exp (skill_obj);
1682	}	1894	}
		1895
1683	player_lvl_adj(op,skill_obj);	1896	player_lvl_adj (op, skill_obj);
1684	}	1897	}
1685	}	1898	}
1686		1899
1687	/* This function checks to make sure that object 'op' can	1900	/* This function checks to make sure that object 'op' can
1688	* lost 'exp' experience. It returns the amount of exp	1901	* lost 'exp' experience. It returns the amount of exp
…		…
1690	* adjustments based on permanent exp and the like.	1903	* adjustments based on permanent exp and the like.
1691	* This function should always be used for losing experience -	1904	* This function should always be used for losing experience -
1692	* the 'exp' value passed should be positive - this is the	1905	* the 'exp' value passed should be positive - this is the
1693	* amount that should get subtract from the player.	1906	* amount that should get subtract from the player.
1694	*/	1907	*/
		1908	sint64
1695	sint64 check_exp_loss(const object *op, sint64 exp)	1909	check_exp_loss (const object *op, sint64 exp)
1696	{	1910	{
1697	sint64 del_exp;	1911	sint64 del_exp;
1698		1912
1699	if (exp > op->stats.exp) exp = op->stats.exp;	1913	if (exp > op->stats.exp)
		1914	exp = op->stats.exp;
1700	if (settings.permanent_exp_ratio) {	1915	if (settings.permanent_exp_ratio)
		1916	{
1701	del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);	1917	del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);
1702	if (del_exp < 0) del_exp = 0;	1918	if (del_exp < 0)
1703	if (exp > del_exp) exp=del_exp;	1919	del_exp = 0;
		1920	if (exp > del_exp)
		1921	exp = del_exp;
1704	}	1922	}
1705	return exp;	1923	return exp;
1706	}	1924	}
1707		1925
		1926	sint64
1708	sint64 check_exp_adjust(const object *op, sint64 exp)	1927	check_exp_adjust (const object *op, sint64 exp)
1709	{	1928	{
		1929	if (exp < 0)
1710	if (exp<0) return check_exp_loss(op, exp);	1930	return check_exp_loss (op, exp);
		1931	else
1711	else return MIN(exp, MAX_EXPERIENCE - op->stats.exp);	1932	return MIN (exp, (sint64) MAX_EXPERIENCE - op->stats.exp);
1712	}	1933	}
1713		1934
1714		1935
1715	/* Subtracts experience from player.	1936	/* Subtracts experience from player.
1716	* if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we	1937	* if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we
…		…
1722	* as much as listed. Eg, if player has gotten reduced to the point	1943	* as much as listed. Eg, if player has gotten reduced to the point
1723	* where everything is at the minimum perm exp, he would lose nothing.	1944	* where everything is at the minimum perm exp, he would lose nothing.
1724	* exp is the amount of exp to subtract - thus, it should be	1945	* exp is the amount of exp to subtract - thus, it should be
1725	* a postive number.	1946	* a postive number.
1726	*/	1947	*/
		1948	static void
1727	static void subtract_player_exp(object *op, sint64 exp, const char *skill, int flag)	1949	subtract_player_exp (object *op, sint64 exp, const char *skill, int flag)
1728	{	1950	{
1729	float fraction = (float) exp/(float) op->stats.exp;	1951	float fraction = (float) exp / (float) op->stats.exp;
1730	object *tmp;	1952	object *tmp;
1731	sint64 del_exp;	1953	sint64 del_exp;
1732		1954
1733	for(tmp=op->inv;tmp;tmp=tmp->below)	1955	for (tmp = op->inv; tmp; tmp = tmp->below)
1734	if(tmp->type==SKILL && tmp->stats.exp) {	1956	if (tmp->type == SKILL && tmp->stats.exp)
		1957	{
1735	if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp(tmp->skill, skill)) {	1958	if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (tmp->skill, skill))
		1959	{
1736	del_exp = check_exp_loss(tmp, exp);	1960	del_exp = check_exp_loss (tmp, exp);
1737	tmp->stats.exp -= del_exp;	1961	tmp->stats.exp -= del_exp;
1738	player_lvl_adj(op, tmp);	1962	player_lvl_adj (op, tmp);
		1963	}
1739	} else if (flag != SK_SUBTRACT_SKILL_EXP) {	1964	else if (flag != SK_SUBTRACT_SKILL_EXP)
		1965	{
1740	/* only want to process other skills if we are not trying	1966	/* only want to process other skills if we are not trying
1741	* to match a specific skill.	1967	* to match a specific skill.
1742	*/	1968	*/
1743	del_exp = check_exp_loss(tmp, (sint64) (tmp->stats.exp * fraction));	1969	del_exp = check_exp_loss (tmp, (sint64) (tmp->stats.exp * fraction));
1744	tmp->stats.exp -= del_exp;	1970	tmp->stats.exp -= del_exp;
1745	player_lvl_adj(op, tmp);	1971	player_lvl_adj (op, tmp);
		1972	}
1746	}	1973	}
1747	}	1974
1748	if (flag != SK_SUBTRACT_SKILL_EXP) {	1975	if (flag != SK_SUBTRACT_SKILL_EXP)
		1976	{
1749	del_exp = check_exp_loss(op, exp);	1977	del_exp = check_exp_loss (op, exp);
1750	op->stats.exp -= del_exp;	1978	op->stats.exp -= del_exp;
1751	player_lvl_adj(op,NULL);	1979	player_lvl_adj (op, NULL);
1752	}	1980	}
1753	}	1981	}
1754
1755
1756		1982
1757	/* change_exp() - changes experience to a player/monster. This	1983	/* change_exp() - changes experience to a player/monster. This
1758	* does bounds checking to make sure we don't overflow the max exp.	1984	* does bounds checking to make sure we don't overflow the max exp.
1759	*	1985	*
1760	* The exp passed is typically not modified much by this function -	1986	* The exp passed is typically not modified much by this function -
1761	* it is assumed the caller has modified the exp as needed.	1987	* it is assumed the caller has modified the exp as needed.
1762	* skill_name is the skill that should get the exp added.	1988	* skill_name is the skill that should get the exp added.
1763	* flag is what to do if player doesn't have the skill.	1989	* flag is what to do if player doesn't have the skill.
1764	* these last two values are only used for players.	1990	* these last two values are only used for players.
1765	*/	1991	*/
1766		1992	void
1767	void change_exp(object *op, sint64 exp, const char *skill_name, int flag) {	1993	change_exp (object *op, sint64 exp, const char *skill_name, int flag)
1768		1994	{
1769	#ifdef EXP_DEBUG	1995	#ifdef EXP_DEBUG
1770	#ifndef WIN32
1771	LOG(llevDebug,"change_exp() called for %s, exp = %lld\n",query_name(op),exp);
1772	#else
1773	LOG(llevDebug,"change_exp() called for %s, exp = %I64d\n",query_name(op),exp);	1996	LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
1774	#endif	1997	#endif
1775	#endif
1776		1998
1777	/* safety */	1999	/* safety */
1778	if(!op) {	2000	if (!op)
		2001	{
1779	LOG(llevError,"change_exp() called for null object!\n");	2002	LOG (llevError, "change_exp() called for null object!\n");
1780	return;	2003	return;
1781	}	2004	}
1782		2005
1783	/* if no change in exp, just return - most of the below code	2006	/* if no change in exp, just return - most of the below code
1784	* won't do anything if the value is 0 anyways.	2007	* won't do anything if the value is 0 anyways.
1785	*/	2008	*/
1786	if (exp == 0) return;	2009	if (exp == 0)
		2010	return;
1787		2011
1788	/* Monsters are easy - we just adjust their exp - we	2012	/* Monsters are easy - we just adjust their exp - we
1789	* don't adjust level, since in most cases it is unrelated to	2013	* don't adjust level, since in most cases it is unrelated to
1790	* the exp they have - the monsters exp represents what its	2014	* the exp they have - the monsters exp represents what its
1791	* worth.	2015	* worth.
1792	*/	2016	*/
1793	if(op->type != PLAYER) {	2017	if (op->type != PLAYER)
		2018	{
1794	/* Sanity check */	2019	/* Sanity check */
1795	if (!QUERY_FLAG(op, FLAG_ALIVE)) return;	2020	if (!QUERY_FLAG (op, FLAG_ALIVE))
		2021	return;
1796		2022
1797	/* reset exp to max allowed value. We subtract from	2023	/* reset exp to max allowed value. We subtract from
1798	* MAX_EXPERIENCE to prevent overflows. If the player somehow has	2024	* MAX_EXPERIENCE to prevent overflows. If the player somehow has
1799	* more than max exp, just return.	2025	* more than max exp, just return.
1800	*/	2026	*/
1801	if (exp > 0 && ( op->stats.exp > (MAX_EXPERIENCE - exp))) {	2027	if (exp > 0 && (op->stats.exp > (sint64) (MAX_EXPERIENCE - exp)))
		2028	{
1802	exp = MAX_EXPERIENCE - op->stats.exp;	2029	exp = MAX_EXPERIENCE - op->stats.exp;
1803	if (exp < 0) return;	2030	if (exp < 0)
1804	}	2031	return;
		2032	}
1805		2033
1806	op->stats.exp += exp;	2034	op->stats.exp += exp;
1807	}	2035	}
1808	else { /* Players only */	2036	else
1809	if(exp>0)	2037	{ /* Players only */
		2038	if (exp > 0)
1810	add_player_exp(op, exp, skill_name, flag);	2039	add_player_exp (op, exp, skill_name, flag);
1811	else	2040	else
1812	/* note that when you lose exp, it doesn't go against	2041	/* note that when you lose exp, it doesn't go against
1813	* a particular skill, so we don't need to pass that	2042	* a particular skill, so we don't need to pass that
1814	* along.	2043	* along.
1815	*/	2044	*/
1816	subtract_player_exp(op, FABS(exp), skill_name, flag);	2045	subtract_player_exp (op, abs (exp), skill_name, flag);
1817
1818	}	2046	}
1819	}	2047	}
1820		2048
1821	/* Applies a death penalty experience, the size of this is defined by the	2049	/* Applies a death penalty experience, the size of this is defined by the
1822	* settings death_penalty_percentage and death_penalty_levels, and by the	2050	* settings death_penalty_percentage and death_penalty_levels, and by the
1823	* amount of permenent experience, whichever gives the lowest loss.	2051	* amount of permenent experience, whichever gives the lowest loss.
1824	*/	2052	*/
1825		2053	void
1826	void apply_death_exp_penalty(object *op) {	2054	apply_death_exp_penalty (object *op)
		2055	{
1827	object *tmp;	2056	object *tmp;
1828	sint64 loss;	2057	sint64 loss;
1829	sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */	2058	sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */
1830	sint64 level_loss; /* defined by the setting 'death_penalty_levels */	2059	sint64 level_loss; /* defined by the setting 'death_penalty_levels */
1831		2060
1832	for(tmp=op->inv;tmp;tmp=tmp->below)	2061	for (tmp = op->inv; tmp; tmp = tmp->below)
1833	if(tmp->type==SKILL && tmp->stats.exp) {	2062	if (tmp->type == SKILL && tmp->stats.exp)
		2063	{
1834		2064
1835	percentage_loss = tmp->stats.exp * settings.death_penalty_ratio/100;	2065	percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100;
1836	level_loss = tmp->stats.exp - levels[MAX(0,tmp->level - settings.death_penalty_level)];	2066	level_loss = tmp->stats.exp - levels[MAX (0, tmp->level - settings.death_penalty_level)];
1837		2067
1838	/* With the revised exp system, you can get cases where	2068	/* With the revised exp system, you can get cases where
1839	* losing several levels would still require that you have more	2069	* losing several levels would still require that you have more
1840	* exp than you currently have - this is true if the levels	2070	* exp than you currently have - this is true if the levels
1841	* tables is a lot harder.	2071	* tables is a lot harder.
1842	*/	2072	*/
1843	if (level_loss < 0) level_loss = 0;	2073	if (level_loss < 0)
		2074	level_loss = 0;
1844		2075
1845	loss = check_exp_loss(tmp, MIN(level_loss, percentage_loss));	2076	loss = check_exp_loss (tmp, MIN (level_loss, percentage_loss));
1846		2077
1847	tmp->stats.exp -= loss;	2078	tmp->stats.exp -= loss;
1848	player_lvl_adj(op,tmp);	2079	player_lvl_adj (op, tmp);
1849	}	2080	}
1850		2081
1851	percentage_loss = op->stats.exp * settings.death_penalty_ratio/100;	2082	percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;
1852	level_loss = op->stats.exp - levels[MAX(0,op->level - settings.death_penalty_level)];	2083	level_loss = op->stats.exp - levels[MAX (0, op->level - settings.death_penalty_level)];
1853	if (level_loss < 0) level_loss = 0;	2084	if (level_loss < 0)
		2085	level_loss = 0;
1854	loss = check_exp_loss(op, MIN(level_loss, percentage_loss));	2086	loss = check_exp_loss (op, MIN (level_loss, percentage_loss));
1855		2087
1856	op->stats.exp -= loss;	2088	op->stats.exp -= loss;
1857	player_lvl_adj(op,NULL);	2089	player_lvl_adj (op, NULL);
1858	}	2090	}
1859		2091
1860	/* This function takes an object (monster/player, op), and	2092	/* This function takes an object (monster/player, op), and
1861	* determines if it makes a basic save throw by looking at the	2093	* determines if it makes a basic save throw by looking at the
1862	* save_throw table. level is the effective level to make	2094	* save_throw table. level is the effective level to make
1863	* the save at, and bonus is any plus/bonus (typically based on	2095	* the save at, and bonus is any plus/bonus (typically based on
1864	* resistance to particular attacktype.	2096	* resistance to particular attacktype.
1865	* Returns 1 if op makes his save, 0 if he failed	2097	* Returns 1 if op makes his save, 0 if he failed
1866	*/	2098	*/
		2099	int
1867	int did_make_save(const object *op, int level, int bonus)	2100	did_make_save (const object *op, int level, int bonus)
1868	{	2101	{
1869	if (level > MAX_SAVE_LEVEL) level = MAX_SAVE_LEVEL;	2102	if (level > MAX_SAVE_LEVEL)
		2103	level = MAX_SAVE_LEVEL;
1870		2104
1871	if ((random_roll(1, 20, op, PREFER_HIGH) + bonus) < savethrow[level])	2105	if ((random_roll (1, 20, op, PREFER_HIGH) + bonus) < savethrow[level])
1872	return 0;
1873	return 1;	2106	return 0;
		2107
		2108	return 1;
1874	}	2109	}
1875

Diff Legend

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