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.60 by root, Fri May 18 01:01:01 2007 UTC vs.
Revision 1.129 by root, Mon Nov 12 03:14:32 2012 UTC

1	/*	1	/*
2	* CrossFire, A Multiplayer game	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* 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,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	17	*
		18	* You should have received a copy of the Affero GNU General Public License
		19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
		21	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	23	*/
24		24
25	#include <global.h>	25	#include <global.h>
26	#include <funcpoint.h>
27		26
28	/* Handy little macro that adds exp and keeps it within bounds. Since	27	/* Handy little macro that adds exp and keeps it within bounds. Since
29	* we are now using 64 bit values, I'm not all concerned about overflow issues	28	* we are now using 64 bit values, I'm not all concerned about overflow issues
30	* with exptotal wrapping. exptotal is typically op->exp, or op->perm_exp	29	* with exptotal wrapping. exptotal is typically op->exp, or op->perm_exp
31	*/	30	*/
…		…
109	* These limits are probably overly generous, but being there were no values	108	* These limits are probably overly generous, but being there were no values
110	* before, you need to start someplace.	109	* before, you need to start someplace.
111	*/	110	*/
112		111
113	const uint32 weight_limit[MAX_STAT + 1] = {	112	const uint32 weight_limit[MAX_STAT + 1] = {
114	200000, /* 0 */	113	200000, /* 0 */
115	250000, 300000, 350000, 400000, 500000, /* 5 */	114	250000, 300000, 350000, 400000, 500000, /* 5 */
116	600000, 700000, 800000, 900000, 1000000, /* 10 */	115	600000, 700000, 800000, 900000, 1000000, /* 10 */
117	1100000, 1200000, 1300000, 1400000, 1500000, /* 15 */	116	1100000, 1200000, 1300000, 1400000, 1500000, /* 15 */
118	1650000, 1800000, 1950000, 2100000, 2250000, /* 20 */	117	1650000, 1800000, 1950000, 2100000, 2250000, /* 20 */
119	2400000, 2550000, 2700000, 2850000, 3000000, /* 25 */	118	2400000, 2550000, 2700000, 2850000, 3000000, /* 25 */
120	3250000, 3500000, 3750000, 4000000, 4500000 /*30 */	119	3250000, 3500000, 3750000, 4000000, 4500000 /* 30 */
121	};	120	};
122		121
123	const int learn_spell[MAX_STAT + 1] = {	122	const int learn_spell[MAX_STAT + 1] = {
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,	123	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,
125	100, 100, 100, 100, 100, 100	124	100, 100, 100, 100, 100, 100
…		…
140	/*	139	/*
141	Since this is nowhere defined ...	140	Since this is nowhere defined ...
142	Both come in handy at least in function add_exp()	141	Both come in handy at least in function add_exp()
143	*/	142	*/
144		143
145	#define MAX_EXPERIENCE levels[settings.max_level]	144	#define MAX_EXPERIENCE levels [settings.max_level]
146		145
147	/* because exp_obj sum to make the total score,	146	/* because exp_obj sum to make the total score,
148	* we cannot allow that sum to exceed the maximum	147	* we cannot allow that sum to exceed the maximum
149	* amount of experience a player can gain. Thus	148	* amount of experience a player can gain. Thus
150	* we define MAX_EXP_IN_OBJ. It is important to try	149	* we define MAX_EXP_IN_OBJ. It is important to try
…		…
157	* line with progression of previous levels, so	156	* line with progression of previous levels, so
158	* if more levels are desired, this should be fixed.	157	* if more levels are desired, this should be fixed.
159	* -b.t.	158	* -b.t.
160	*/	159	*/
161		160
162	#define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1)	161	#define MAX_EXP_IN_OBJ MAX_EXP_IN_OBJ / (MAX_EXP_CAT - 1)
163
164	extern sint64 *levels;
165		162
166	#define MAX_SAVE_LEVEL 110	163	#define MAX_SAVE_LEVEL 110
167		164
168	/* This no longer needs to be changed anytime the number of	165	/* This no longer needs to be changed anytime the number of
169	* levels is increased - rather, did_make_save will do the	166	* levels is increased - rather, did_make_save will do the
…		…
263	/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,	260	/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,
264	* make this macro to clean those up. Not usuable outside change_abil	261	* make this macro to clean those up. Not usuable outside change_abil
265	* function since some of the values passed to new_draw_info are hardcoded.	262	* function since some of the values passed to new_draw_info are hardcoded.
266	*/	263	*/
267	#define DIFF_MSG(flag, msg1, msg2) \	264	#define DIFF_MSG(flag, msg1, msg2) \
268	new_draw_info(NDI_UNIQUE, 0, op, (flag>0)?msg1:msg2);	265	new_draw_info (NDI_UNIQUE, 0, op, (flag > 0) ? msg1 : msg2);
269		266
270	/* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */	267	/* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */
271		268
272	/* flag is set to 1 if we are applying the object, -1 if we are removing	269	/* flag is set to 1 if we are applying the object, -1 if we are removing
273	* the object.	270	* the object.
…		…
281	* that gives them that ability.	278	* that gives them that ability.
282	*/	279	*/
283	int	280	int
284	change_abil (object *op, object *tmp)	281	change_abil (object *op, object *tmp)
285	{	282	{
286	int flag = QUERY_FLAG (tmp, FLAG_APPLIED) ? 1 : -1, success = 0;	283	int flag = tmp->flag [FLAG_APPLIED] ? 1 : -1;
		284	int success = 0;
287	char message[MAX_BUF];	285	char message[MAX_BUF];
288	int potion_max = 0;	286	int potion_max = 0;
289		287
290	/* remember what object was like before it was changed. note that	288	// keep some stats for comparison purposes
291	* refop is a local copy of op only to be used for detecting changes	289	object::flags_t prev_flag = op->flag;
292	* found by update_stats. refop is not a real object	290	MoveType prev_move_type = op->move_type;
293	*/	291	sint16 prev_resist [NROFATTACKS]; // clumsy
294	object_copy refop = *op;	292	assert (sizeof (prev_resist) == sizeof (op->resist));
		293	memcpy (prev_resist, op->resist, sizeof (prev_resist));
295		294
296	if (op->type == PLAYER)	295	if (op->type == PLAYER)
297	{	296	{
298	if (tmp->type == POTION)	297	if (tmp->type == POTION)
299	{	298	{
300	potion_max = 1;	299	potion_max = 1;
		300
301	for (int j = 0; j < NUM_STATS; j++)	301	for (int j = 0; j < NUM_STATS; j++)
302	{	302	{
303	int ostat = op->contr->orig_stats.stat (j);	303	int ostat = op->contr->orig_stats.stat (j);
304	int i = tmp->stats.stat (j);	304	int i = tmp->stats.stat (j);
305		305
306	/* nstat is what the stat will be after use of the potion */	306	/* nstat is what the stat will be after use of the potion */
307	int nstat = flag * i + ostat;	307	int nstat = flag * i + ostat;
308		308
309	/* Do some bounds checking. While I don't think any	309	/* Do some bounds checking. There is the potential for potions
310	* potions do so right now, there is the potential for potions
311	* that adjust that stat by more than one point, so we need	310	* that adjust that stat by more than one point, so we need
312	* to allow for that.	311	* to allow for that.
313	*/	312	*/
314	if (nstat < 1 && i * flag < 0)	313	if (nstat < 1 && i * flag < 0)
315	nstat = 1;	314	nstat = 1;
316	else if (nstat > 20 + op->arch->clone.stats.stat (j))	315	else if (nstat > 20 + op->arch->stats.stat (j))
317	nstat = 20 + op->arch->clone.stats.stat (j);	316	nstat = 20 + op->arch->stats.stat (j);
318		317
319	if (nstat != ostat)	318	if (nstat != ostat)
320	{	319	{
321	op->contr->orig_stats.stat (j) = nstat;	320	op->contr->orig_stats.stat (j) = nstat;
322	potion_max = 0;	321	potion_max = 0;
…		…
367	{	366	{
368	success = 1;	367	success = 1;
369	DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red.");	368	DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red.");
370	}	369	}
371		370
372	if (QUERY_FLAG (op, FLAG_LIFESAVE) != QUERY_FLAG (&refop, FLAG_LIFESAVE))	371	if (op->flag [FLAG_LIFESAVE] != prev_flag [FLAG_LIFESAVE])
373	{	372	{
374	success = 1;	373	success = 1;
375	DIFF_MSG (flag, "You feel very protected.", "You don't feel protected anymore.");	374	DIFF_MSG (flag, "You feel very protected.", "You don't feel protected anymore.");
376	}	375	}
377		376
378	if (QUERY_FLAG (op, FLAG_REFL_MISSILE) != QUERY_FLAG (&refop, FLAG_REFL_MISSILE))	377	if (op->flag [FLAG_REFL_MISSILE] != prev_flag [FLAG_REFL_MISSILE])
379	{	378	{
380	success = 1;	379	success = 1;
381	DIFF_MSG (flag, "A magic force shimmers around you.", "The magic force fades away.");	380	DIFF_MSG (flag, "A magic force shimmers around you.", "The magic force fades away.");
382	}	381	}
383		382
384	if (QUERY_FLAG (op, FLAG_REFL_SPELL) != QUERY_FLAG (&refop, FLAG_REFL_SPELL))	383	if (op->flag [FLAG_REFL_SPELL] != prev_flag [FLAG_REFL_SPELL])
385	{	384	{
386	success = 1;	385	success = 1;
387	DIFF_MSG (flag, "You feel more safe now, somehow.", "Suddenly you feel less safe, somehow.");	386	DIFF_MSG (flag, "You feel more safe now, somehow.", "Suddenly you feel less safe, somehow.");
388	}	387	}
389		388
…		…
391	* user has multiple items giving the same type appled like we	390	* user has multiple items giving the same type appled like we
392	* used to - that is more work than what we gain, plus messages	391	* used to - that is more work than what we gain, plus messages
393	* can be misleading (a little higher could be miscontrued from	392	* can be misleading (a little higher could be miscontrued from
394	* from fly high)	393	* from fly high)
395	*/	394	*/
396	if (tmp->move_type && op->move_type != refop.move_type)	395	if (tmp->move_type && op->move_type != prev_move_type)
397	{	396	{
398	success = 1;	397	success = 1;
399		398
400	/* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low	399	/* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low
401	* status doesn't make a difference if you are flying high	400	* status doesn't make a difference if you are flying high
402	*/	401	*/
403	if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH))	402	if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH))
404	{	403	{
405	DIFF_MSG (flag, "You start to float in the air!.", "You float down to the ground.");	404	DIFF_MSG (flag, "You start to float in the air!", "You float down to the ground.");
406	}	405	}
407		406
408	if (tmp->move_type & MOVE_FLY_HIGH)	407	if (tmp->move_type & MOVE_FLY_HIGH)
409	{	408	{
410	/* double conditional - second case covers if you have move_fly_low -	409	/* double conditional - second case covers if you have move_fly_low -
…		…
414	(op->move_type & MOVE_FLY_LOW ? "You fly lower in the air" : "You float down to the ground."));	413	(op->move_type & MOVE_FLY_LOW ? "You fly lower in the air" : "You float down to the ground."));
415	}	414	}
416		415
417	if (tmp->move_type & MOVE_SWIM)	416	if (tmp->move_type & MOVE_SWIM)
418	DIFF_MSG (flag, "You feel ready for a swim", "You no longer feel like swimming");	417	DIFF_MSG (flag, "You feel ready for a swim", "You no longer feel like swimming");
419
420	/* Changing move status may mean you are affected by things you weren't before */
421	check_move_on (op, op);
422	}	418	}
423		419
424	/* becoming UNDEAD... a special treatment for this flag. Only those not	420	/* becoming UNDEAD... a special treatment for this flag. Only those not
425	* originally undead may change their status	421	* originally undead may change their status
426	*/	422	*/
427	if (!QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))	423	if (!op->arch->flag [FLAG_UNDEAD])
428	if (QUERY_FLAG (op, FLAG_UNDEAD) != QUERY_FLAG (&refop, FLAG_UNDEAD))	424	if (op->flag [FLAG_UNDEAD] != prev_flag [FLAG_UNDEAD])
429	{	425	{
430	success = 1;	426	success = 1;
431	if (flag > 0)	427	if (flag > 0)
432	{	428	{
433	op->race = "undead";	429	op->race = "undead";
434	new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!");	430	new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!");
435	}	431	}
436	else	432	else
437	{	433	{
438	op->race = op->arch->clone.race;	434	op->race = op->arch->race;
439	new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");	435	new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");
440	}	436	}
441	}	437	}
442		438
443	if (QUERY_FLAG (op, FLAG_STEALTH) != QUERY_FLAG (&refop, FLAG_STEALTH))	439	if (op->flag [FLAG_STEALTH] != prev_flag [FLAG_STEALTH])
444	{	440	{
445	success = 1;	441	success = 1;
446	DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily.");	442	DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily.");
447	}	443	}
448		444
449	if (QUERY_FLAG (op, FLAG_MAKE_INVIS) != QUERY_FLAG (&refop, FLAG_MAKE_INVIS))	445	if (op->flag [FLAG_MAKE_INVIS] != prev_flag [FLAG_MAKE_INVIS])
450	{	446	{
451	success = 1;	447	success = 1;
452	DIFF_MSG (flag, "You become transparent.", "You can see yourself.");	448	DIFF_MSG (flag, "You become transparent.", "You can see yourself.");
453	}	449	}
454		450
455	/* blinded you can tell if more blinded since blinded player has minimal	451	/* blinded you can tell if more blinded since blinded player has minimal
456	* vision	452	* vision
457	*/	453	*/
458	if (QUERY_FLAG (tmp, FLAG_BLIND))	454	if (tmp->flag [FLAG_BLIND])
459	{	455	{
460	success = 1;	456	success = 1;
461	if (flag > 0)	457	if (flag > 0)
462	{	458	{
463	if (QUERY_FLAG (op, FLAG_WIZ))	459	if (op->flag [FLAG_WIZ])
464	new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self is blinded.");	460	new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self is blinded.");
465	else	461	else
466	{	462	{
467	new_draw_info (NDI_UNIQUE, 0, op, "You are blinded.");	463	new_draw_info (NDI_UNIQUE, 0, op, "You are blinded.");
468	SET_FLAG (op, FLAG_BLIND);	464	op->set_flag (FLAG_BLIND);
469	if (op->type == PLAYER)	465	if (op->type == PLAYER)
470	op->contr->do_los = 1;	466	op->contr->do_los = 1;
471	}	467	}
472	}	468	}
473	else	469	else
474	{	470	{
475	if (QUERY_FLAG (op, FLAG_WIZ))	471	if (op->flag [FLAG_WIZ])
476	new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self can now see again.");	472	new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self can now see again.");
477	else	473	else
478	{	474	{
479	new_draw_info (NDI_UNIQUE, 0, op, "Your vision returns.");	475	new_draw_info (NDI_UNIQUE, 0, op, "Your vision returns.");
480	CLEAR_FLAG (op, FLAG_BLIND);	476	op->clr_flag (FLAG_BLIND);
481	if (op->type == PLAYER)	477	if (op->type == PLAYER)
482	op->contr->do_los = 1;	478	op->contr->do_los = 1;
483	}	479	}
484	}	480	}
485	}	481	}
486		482
487	if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) != QUERY_FLAG (&refop, FLAG_SEE_IN_DARK))	483	if (op->flag [FLAG_SEE_IN_DARK] != prev_flag [FLAG_SEE_IN_DARK])
488	{	484	{
489	success = 1;	485	success = 1;
490	if (op->type == PLAYER)	486	if (op->type == PLAYER)
491	op->contr->do_los = 1;	487	op->contr->do_los = 1;
492	DIFF_MSG (flag, "Your vision is better in the dark.", "You see less well in the dark.");	488	DIFF_MSG (flag, "Your vision is better in the dark.", "You see less well in the dark.");
493	}	489	}
494		490
495	if (QUERY_FLAG (op, FLAG_XRAYS) != QUERY_FLAG (&refop, FLAG_XRAYS))	491	if (op->flag [FLAG_XRAYS] != prev_flag [FLAG_XRAYS])
496	{	492	{
497	success = 1;	493	success = 1;
498	if (flag > 0)	494	if (flag > 0)
499	{	495	{
500	if (QUERY_FLAG (op, FLAG_WIZ))	496	if (op->flag [FLAG_WIZ])
501	new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a little clearer.");	497	new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a little clearer.");
502	else	498	else
503	{	499	{
504	new_draw_info (NDI_UNIQUE, 0, op, "Everything becomes transparent.");	500	new_draw_info (NDI_UNIQUE, 0, op, "Everything becomes transparent.");
505	if (op->type == PLAYER)	501	if (op->type == PLAYER)
506	op->contr->do_los = 1;	502	op->contr->do_los = 1;
507	}	503	}
508	}	504	}
509	else	505	else
510	{	506	{
511	if (QUERY_FLAG (op, FLAG_WIZ))	507	if (op->flag [FLAG_WIZ])
512	new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a bit out of focus.");	508	new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a bit out of focus.");
513	else	509	else
514	{	510	{
515	new_draw_info (NDI_UNIQUE, 0, op, "Everything suddenly looks very solid.");	511	new_draw_info (NDI_UNIQUE, 0, op, "Everything suddenly looks very solid.");
516	if (op->type == PLAYER)	512	if (op->type == PLAYER)
…		…
523	{	519	{
524	success = 1;	520	success = 1;
525	DIFF_MSG (flag * tmp->stats.luck, "You feel more lucky.", "You feel less lucky.");	521	DIFF_MSG (flag * tmp->stats.luck, "You feel more lucky.", "You feel less lucky.");
526	}	522	}
527		523
		524	if (digest_types [tmp->type])
		525	{
528	if (tmp->stats.hp && op->type == PLAYER)	526	if (tmp->stats.hp && op->type == PLAYER)
529	{	527	{
530	success = 1;	528	success = 1;
531	DIFF_MSG (flag * tmp->stats.hp, "You feel much more healthy!", "You feel much less healthy!");	529	DIFF_MSG (flag * tmp->stats.hp, "You feel much more healthy!", "You feel much less healthy!");
532	}	530	}
533		531
534	if (tmp->stats.sp && op->type == PLAYER && tmp->type != SKILL)	532	if (tmp->stats.sp && op->type == PLAYER
535	{	533	&& tmp->type != SKILL && tmp->type != BOW)
		534	{
536	success = 1;	535	success = 1;
537	DIFF_MSG (flag * tmp->stats.sp, "You feel one with the powers of magic!", "You suddenly feel very mundane.");	536	DIFF_MSG (flag * tmp->stats.sp, "You feel one with the powers of magic!", "You suddenly feel very mundane.");
538	}	537	}
539		538
540	/* for the future when artifacts set this -b.t. */	539	/* for the future when artifacts set this -b.t. */
541	if (tmp->stats.grace && op->type == PLAYER)	540	if (tmp->stats.grace && op->type == PLAYER)
542	{	541	{
543	success = 1;	542	success = 1;
544	DIFF_MSG (flag * tmp->stats.grace, "You feel closer to your god!", "You suddenly feel less holy.");	543	DIFF_MSG (flag * tmp->stats.grace, "You feel closer to your god!", "You suddenly feel less holy.");
545	}	544	}
546		545
547	if (tmp->stats.food && op->type == PLAYER)	546	if (tmp->stats.food && op->type == PLAYER)
548	{	547	{
549	success = 1;	548	success = 1;
550	DIFF_MSG (flag * tmp->stats.food, "You feel your digestion slowing down.", "You feel your digestion speeding up.");	549	DIFF_MSG (flag * tmp->stats.food, "You feel your digestion slowing down.", "You feel your digestion speeding up.");
		550	}
551	}	551	}
552		552
553	/* Messages for changed resistance */	553	/* Messages for changed resistance */
554	for (int i = 0; i < NROFATTACKS; i++)	554	for (int i = 0; i < NROFATTACKS; i++)
555	{	555	{
556	if (i == ATNR_PHYSICAL)	556	if (i == ATNR_PHYSICAL)
557	continue; /* Don't display about armour */	557	continue; /* Don't display about armour */
558		558
559	if (op->resist[i] != refop.resist[i])	559	if (op->resist [i] != prev_resist [i])
560	{	560	{
561	success = 1;	561	success = 1;
		562
562	if (op->resist[i] > refop.resist[i])	563	if (op->resist [i] > prev_resist [i])
563	sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg[i], op->resist[i]);	564	sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg [i], op->resist [i]);
564	else	565	else
565	sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg[i], op->resist[i]);	566	sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg [i], op->resist [i]);
566		567
567	new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);	568	new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
568	}	569	}
569	}	570	}
570		571
571	if (!potion_max)	572	if (!potion_max)
572	{
573	for (int j = 0; j < NUM_STATS; j++)	573	for (int j = 0; j < NUM_STATS; j++)
574	{
575	if (int i = tmp->stats.stat (j))	574	if (int i = tmp->stats.stat (j))
576	{	575	{
577	success = 1;	576	success = 1;
578	DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);	577	DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
579	}	578	}
580	}
581	}
582		579
583	return success;	580	return success;
584	}	581	}
585		582
586	/*	583	/*
…		…
597	object::drain_specific_stat (int deplete_stats)	594	object::drain_specific_stat (int deplete_stats)
598	{	595	{
599	object *tmp;	596	object *tmp;
600	archetype *at;	597	archetype *at;
601		598
602	at = archetype::find (ARCH_DEPLETION);	599	at = archetype::find (shstr_depletion);
603	if (!at)	600	if (!at)
604	{	601	{
605	LOG (llevError, "Couldn't find archetype depletion.\n");	602	LOG (llevError, "Couldn't find archetype depletion.\n");
606	return;	603	return;
607	}	604	}
…		…
609	{	606	{
610	tmp = present_arch_in_ob (at, this);	607	tmp = present_arch_in_ob (at, this);
611		608
612	if (!tmp)	609	if (!tmp)
613	{	610	{
614	tmp = arch_to_object (at);	611	tmp = at->instance ();
615	tmp = insert_ob_in_ob (tmp, this);	612	tmp = insert_ob_in_ob (tmp, this);
616	SET_FLAG (tmp, FLAG_APPLIED);	613	tmp->set_flag (FLAG_APPLIED);
617	}	614	}
618	}	615	}
619		616
620	new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);	617	new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);
621	change_attr_value (&tmp->stats, deplete_stats, -1);	618	change_attr_value (&tmp->stats, deplete_stats, -1);
…		…
627	* via an applied bad_luck object.	624	* via an applied bad_luck object.
628	*/	625	*/
629	void	626	void
630	object::change_luck (int value)	627	object::change_luck (int value)
631	{	628	{
632	archetype *at = archetype::find ("luck");	629	archetype *at = archetype::find (shstr_luck);
633	if (!at)	630	if (!at)
634	LOG (llevError, "Couldn't find archetype luck.\n");	631	LOG (llevError, "Couldn't find archetype luck.\n");
635	else	632	else
636	{	633	{
637	object *tmp = present_arch_in_ob (at, this);	634	object *tmp = present_arch_in_ob (at, this);
…		…
639	if (!tmp)	636	if (!tmp)
640	{	637	{
641	if (!value)	638	if (!value)
642	return;	639	return;
643		640
644	tmp = arch_to_object (at);	641	tmp = at->instance ();
645	tmp = insert_ob_in_ob (tmp, this);	642	tmp = insert_ob_in_ob (tmp, this);
646	SET_FLAG (tmp, FLAG_APPLIED);	643	tmp->set_flag (FLAG_APPLIED);
647	}	644	}
648		645
649	if (value)	646	if (value)
650	{	647	{
651	/* Limit the luck value of the bad luck object to +/-100. This	648	/* Limit the luck value of the bad luck object to +/-100. This
…		…
685	void	682	void
686	object::remove_statbonus ()	683	object::remove_statbonus ()
687	{	684	{
688	for (int i = 0; i < NUM_STATS; ++i)	685	for (int i = 0; i < NUM_STATS; ++i)
689	{	686	{
690	sint8 v = arch->clone.stats.stat (i);	687	sint8 v = arch->stats.stat (i);
691	stats.stat (i) -= v;	688	stats.stat (i) -= v;
692	contr->orig_stats.stat (i) -= v;	689	contr->orig_stats.stat (i) -= v;
693	}	690	}
694	}	691	}
695		692
…		…
699	void	696	void
700	object::add_statbonus ()	697	object::add_statbonus ()
701	{	698	{
702	for (int i = 0; i < NUM_STATS; ++i)	699	for (int i = 0; i < NUM_STATS; ++i)
703	{	700	{
704	sint8 v = arch->clone.stats.stat (i);	701	sint8 v = arch->stats.stat (i);
705	stats.stat (i) += v;	702	stats.stat (i) += v;
706	contr->orig_stats.stat (i) += v;	703	contr->orig_stats.stat (i) += v;
707	}	704	}
708	}	705	}
		706
		707	static struct copy_flags : object::flags_t
		708	{
		709	copy_flags ()
		710	{
		711	set (FLAG_LIFESAVE);
		712	set (FLAG_REFL_SPELL);
		713	set (FLAG_REFL_MISSILE);
		714	set (FLAG_STEALTH);
		715	set (FLAG_XRAYS);
		716	set (FLAG_BLIND);
		717	set (FLAG_SEE_IN_DARK);
		718	}
		719	} copy_flags;
709		720
710	/*	721	/*
711	* Updates all abilities given by applied objects in the inventory	722	* Updates all abilities given by applied objects in the inventory
712	* of the given object. Note: This function works for both monsters	723	* of the given object. Note: This function works for both monsters
713	* and players; the "player" in the name is purely an archaic inheritance.	724	* and players; the "player" in the name is purely an archaic inheritance.
…		…
718	* spell system split, grace points now added to system --peterm	729	* spell system split, grace points now added to system --peterm
719	*/	730	*/
720	void	731	void
721	object::update_stats ()	732	object::update_stats ()
722	{	733	{
723	int i, j;
724	float f, max = 9, added_speed = 0, bonus_speed = 0, sp_tmp, speed_reduce_from_disease = 1;	734	float max_speed = 9, added_speed = 0, bonus_speed = 0, speed_reduce_from_disease = 1;
725	int weapon_weight = 0, weapon_speed = 0;	735	int weapon_weight = 0, weapon_speed = 0;
726	int best_wc = 0, best_ac = 0, wc = 0, ac = 0;	736	int best_wc = 0, best_ac = 0, wc = 0, ac = 0;
727	int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];	737	int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
728	object *grace_obj = NULL, *mana_obj = NULL, *tmp;	738	object *grace_obj = NULL, *mana_obj = NULL, *tmp;
729	float old_speed = speed;	739	float old_speed = speed;
		740	int stat_sum [NUM_STATS];
		741
		742	MoveType move_type; // we use change_move_type to change it, so use a local copy
730		743
731	/* First task is to clear all the values back to their original values */	744	/* First task is to clear all the values back to their original values */
732	if (type == PLAYER)	745	if (type == PLAYER)
733	{	746	{
		747	contr->delayed_update = false;
		748
734	for (i = 0; i < NUM_STATS; i++)	749	for (int i = 0; i < NUM_STATS; i++)
735	stats.stat (i) = contr->orig_stats.stat (i);	750	stat_sum [i] = contr->orig_stats.stat (i);
736		751
737	if (settings.spell_encumbrance == TRUE)	752	if (settings.spell_encumbrance == TRUE)
738	contr->encumbrance = 0;	753	contr->encumbrance = 0;
739		754
740	attacktype = 0;	755	attacktype = 0;
…		…
750	for (int i = NUM_BODY_LOCATIONS; i--; )	765	for (int i = NUM_BODY_LOCATIONS; i--; )
751	slot[i].used = slot[i].info;	766	slot[i].used = slot[i].info;
752		767
753	slaying = 0;	768	slaying = 0;
754		769
755	if (!QUERY_FLAG (this, FLAG_WIZ))	770	if (!this->flag [FLAG_WIZ])
756	{
757	CLEAR_FLAG (this, FLAG_XRAYS);
758	CLEAR_FLAG (this, FLAG_MAKE_INVIS);
759	}	771	{
		772	this->clr_flag (FLAG_XRAYS);
		773	this->clr_flag (FLAG_MAKE_INVIS);
		774	}
760		775
761	CLEAR_FLAG (this, FLAG_LIFESAVE);	776	this->clr_flag (FLAG_LIFESAVE);
762	CLEAR_FLAG (this, FLAG_STEALTH);	777	this->clr_flag (FLAG_STEALTH);
763	CLEAR_FLAG (this, FLAG_BLIND);	778	this->clr_flag (FLAG_BLIND);
764		779
765	if (!QUERY_FLAG (&arch->clone, FLAG_REFL_SPELL )) CLEAR_FLAG (this, FLAG_REFL_SPELL);	780	if (!arch->flag [FLAG_REFL_SPELL ]) this->clr_flag (FLAG_REFL_SPELL);
766	if (!QUERY_FLAG (&arch->clone, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE);	781	if (!arch->flag [FLAG_REFL_MISSILE]) this->clr_flag (FLAG_REFL_MISSILE);
767	if (!QUERY_FLAG (&arch->clone, FLAG_UNDEAD )) CLEAR_FLAG (this, FLAG_UNDEAD);	782	if (!arch->flag [FLAG_UNDEAD ]) this->clr_flag (FLAG_UNDEAD);
768	if (!QUERY_FLAG (&arch->clone, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK);	783	if (!arch->flag [FLAG_SEE_IN_DARK ]) this->clr_flag (FLAG_SEE_IN_DARK);
769		784
770	path_attuned = arch->clone.path_attuned;	785	path_attuned = arch->path_attuned;
771	path_repelled = arch->clone.path_repelled;	786	path_repelled = arch->path_repelled;
772	path_denied = arch->clone.path_denied;	787	path_denied = arch->path_denied;
773	glow_radius = arch->clone.glow_radius;	788	glow_radius = arch->glow_radius;
774	move_type = arch->clone.move_type;	789	move_type = arch->move_type;
775
776	chosen_skill = 0;
777		790
778	/* initializing resistances from the values in player/monster's	791	/* initializing resistances from the values in player/monster's
779	* archetype clone	792	* archetype clone
780	*/	793	*/
781	memcpy (&resist, &arch->clone.resist, sizeof (resist));	794	memcpy (&resist, &arch->resist, sizeof (resist));
782		795
783	for (i = 0; i < NROFATTACKS; i++)	796	for (int i = 0; i < NROFATTACKS; i++)
784	{	797	{
785	if (resist[i] > 0)	798	if (resist[i] > 0)
786	prot[i] = resist[i], vuln[i] = 0;	799	prot[i] = resist[i], vuln[i] = 0;
787	else	800	else
788	vuln[i] = -(resist[i]), prot[i] = 0;	801	vuln[i] = -resist[i], prot[i] = 0;
789		802
790	potion_resist[i] = 0;	803	potion_resist[i] = -1000;
791	}	804	}
792		805
793	wc = arch->clone.stats.wc;	806	wc = arch->stats.wc;
794	stats.dam = arch->clone.stats.dam;	807	stats.dam = arch->stats.dam;
795		808
796	/* for players which cannot use armour, they gain AC -1 per 3 levels,	809	/* for players which cannot use armour, they gain AC -1 per 3 levels,
797	* plus a small amount of physical resist, those poor suckers. ;)	810	* plus a small amount of physical resist, those poor suckers. ;)
798	* the fact that maxlevel is factored in could be considered sort of bogus -	811	* the fact that maxlevel is factored in could be considered sort of bogus -
799	* we should probably give them some bonus and cap it off - otherwise,	812	* we should probably give them some bonus and cap it off - otherwise,
800	* basically, if a server updates its max level, these playes may find	813	* basically, if a server updates its max level, these playes may find
801	* that their protection from physical goes down	814	* that their protection from physical goes down
802	*/	815	*/
803	if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER)	816	if (!this->flag [FLAG_USE_ARMOUR] && type == PLAYER)
804	{	817	{
805	ac = MAX (-10, arch->clone.stats.ac - level / 3);	818	ac = max (-10, arch->stats.ac - level / 3);
806	prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;	819	prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;
807	}	820	}
808	else	821	else
809	ac = arch->clone.stats.ac;	822	ac = arch->stats.ac;
810		823
811	stats.luck = arch->clone.stats.luck;	824	stats.luck = arch->stats.luck;
812	speed = arch->clone.speed;	825	speed = arch->speed;
		826
		827	chosen_skill = 0;
813		828
814	/* OK - we've reset most all the objects attributes to sane values.	829	/* OK - we've reset most all the objects attributes to sane values.
815	* now go through and make adjustments for what the player has equipped.	830	* now go through and make adjustments for what the player has equipped.
816	*/	831	*/
817	for (tmp = inv; tmp; tmp = tmp->below)	832	for (tmp = inv; tmp; tmp = tmp->below)
818	{	833	{
819	/* See note in map.c:update_position about making this additive
820	* since light sources are never applied, need to put check here.
821	*/
822	if (tmp->glow_radius > glow_radius)
823	glow_radius = tmp->glow_radius;
824
825	/* This happens because apply_potion calls change_abil with the potion	834	/* This happens because apply_potion calls change_abil with the potion
826	* applied so we can tell the player what changed. But change_abil	835	* applied so we can tell the player what changed. But change_abil
827	* then calls this function.	836	* then calls this function.
828	*/	837	*/
829	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)	838	if (tmp->flag [FLAG_APPLIED] && tmp->type == POTION)
830	continue;	839	continue;
		840
		841	glow_radius += tmp->glow_radius;
831		842
832	/* For some things, we don't care what is equipped */	843	/* For some things, we don't care what is equipped */
833	if (tmp->type == SKILL)	844	if (tmp->type == SKILL)
834	{	845	{
835	/* Want to take the highest skill here. */	846	/* Want to take the highest skill here. */
…		…
848	else if (tmp->level > grace_obj->level)	859	else if (tmp->level > grace_obj->level)
849	grace_obj = tmp;	860	grace_obj = tmp;
850	}	861	}
851	}	862	}
852		863
853	/* Container objects are not meant to adjust a players, but other applied	864	/* Container objects are not meant to adjust players, but other applied
854	* objects need to make adjustments.	865	* objects need to make adjustments.
855	* This block should handle all player specific changes	866	* This block should handle all player specific changes
856	* The check for Praying is a bit of a hack - god given bonuses are put	867	* The check for Praying is a bit of a hack - god given bonuses are put
857	* in the praying skill, and the player should always get those.	868	* in the praying skill, and the player should always get those.
858	* It also means we need to put in additional checks for applied below,	869	* It also means we need to put in additional checks for applied below,
859	* because the skill shouldn't count against body positions being used	870	* because the skill shouldn't count against body positions being used
860	* up, etc.	871	* up, etc.
861	*/	872	*/
862	if ((tmp->flag [FLAG_APPLIED]	873	if ((tmp->flag [FLAG_APPLIED]
863	&& tmp->type != CONTAINER	874	&& tmp->type != CONTAINER
864	&& tmp->type != CLOSE_CON)	875	&& tmp->type != CLOSE_CON
865	|| (tmp->type == SKILL	876	&& tmp->type != SPELL)
866	&& tmp->subtype == SK_PRAYING))	877	|| (tmp->type == SKILL && tmp->subtype == SK_PRAYING))
867	{	878	{
868	if (type == PLAYER)	879	if (type == PLAYER)
869	{	880	{
870	if (tmp == contr->combat_ob || tmp == contr->ranged_ob)	881	contr->item_power += tmp->item_power;
871	if (tmp != current_weapon
872	&& (tmp->type != SKILL || tmp->subtype != SK_PRAYING)
873	&& !tmp->flag [FLAG_CURSED]
874	&& !tmp->flag [FLAG_DAMNED])
875	continue;
876		882
877	for (i = 0; i < NUM_STATS; i++)	883	for (int i = 0; i < NUM_STATS; i++)
878	change_attr_value (&stats, i, tmp->stats.stat (i));	884	stat_sum [i] += tmp->stats.stat (i);
879		885
880	/* These are the items that currently can change digestion, regeneration,	886	if (digest_types [tmp->type])
881	* spell point recovery and mana point recovery. Seems sort of an arbitary
882	* list, but other items store other info into stats array.
883	*/
884	if (tmp->type == WEAPON || tmp->type == BOW ||
885	tmp->type == ARMOUR || tmp->type == HELMET ||
886	tmp->type == SHIELD || tmp->type == RING ||
887	tmp->type == BOOTS || tmp->type == GLOVES ||
888	tmp->type == AMULET || tmp->type == GIRDLE ||
889	tmp->type == BRACERS || tmp->type == CLOAK ||
890	tmp->type == DISEASE || tmp->type == FORCE ||
891	tmp->type == SKILL)
892	{	887	{
893	contr->digestion += tmp->stats.food;	888	contr->digestion += tmp->stats.food;
894	contr->gen_hp += tmp->stats.hp;	889	contr->gen_hp += tmp->stats.hp;
		890	if (tmp->type != BOW) // ugly exception for bows
895	contr->gen_sp += tmp->stats.sp;	891	contr->gen_sp += tmp->stats.sp;
896	contr->gen_grace += tmp->stats.grace;	892	contr->gen_grace += tmp->stats.grace;
897	contr->gen_sp_armour += tmp->gen_sp_armour;	893	contr->gen_sp_armour += tmp->gen_sp_armour;
898	contr->item_power += tmp->item_power;
899	}	894	}
900	} /* if this is a player */	895	} /* if this is a player */
901	else	896	else
902	{	897	{
903	if (tmp->type == WEAPON)	898	if (tmp->type == WEAPON)
904	current_weapon = tmp;	899	current_weapon = tmp;
905	}	900	}
906		901
907	/* Update slots used for items */	902	/* Update slots used for items */
908	if (QUERY_FLAG (tmp, FLAG_APPLIED))	903	if (tmp->flag [FLAG_APPLIED]) // exclude praying...
909	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	904	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
910	slot[i].used += tmp->slot[i].info;	905	slot[i].used += tmp->slot[i].info;
911		906
912	if (tmp->type == SYMPTOM)	907	if (tmp->type == SYMPTOM)
913	{
914	speed_reduce_from_disease = tmp->last_sp / 100.f;	908	min_it (speed_reduce_from_disease, tmp->last_sp ? tmp->last_sp / 100.f : 1.f);
915		909
916	if (speed_reduce_from_disease == 0)
917	speed_reduce_from_disease = 1;
918	}
919
920	/* Pos. and neg. protections are counted seperate (-> pro/vuln).	910	/* Pos. and neg. protections are counted separate (-> pro/vuln).
921	* (Negative protections are calculated exactly like positive.)	911	* (Negative protections are calculated exactly like positive.)
922	* Resistance from potions are treated special as well. If there's	912	* Resistance from potions are treated special as well. If there's
923	* more than one potion-effect, the bigger prot.-value is taken.	913	* more than one potion-effect, the bigger prot.-value is taken.
924	*/	914	*/
925	if (tmp->type != POTION)	915	if (tmp->type == POTION_EFFECT)
926	{
927	for (i = 0; i < NROFATTACKS; i++)	916	for (int i = 0; i < NROFATTACKS; i++)
928	{
929	/* Potential for cursed potions, in which case we just can use
930	* a straight MAX, as potion_resist is initialised to zero.
931	*/
932	if (tmp->type == POTION_EFFECT)
933	{
934	if (potion_resist[i])
935	potion_resist[i] = MAX (potion_resist[i], tmp->resist[i]);
936	else
937	potion_resist[i] = tmp->resist[i];	917	max_it (potion_resist[i], tmp->resist[i]);
938	}	918	else if (tmp->type != POTION)
		919	for (int i = 0; i < NROFATTACKS; i++)
939	else if (tmp->resist[i] > 0)	920	if (tmp->resist[i] > 0)
940	prot[i] += ((100 - prot[i]) * tmp->resist[i]) / 100;	921	prot[i] += (100 - prot[i]) * tmp->resist[i] / 100;
941	else if (tmp->resist[i] < 0)	922	else if (tmp->resist[i] < 0)
942	vuln[i] += ((100 - vuln[i]) * -tmp->resist[i]) / 100;	923	vuln[i] += (100 - vuln[i]) * -tmp->resist[i] / 100;
943	}
944	}
945		924
946	/* There may be other things that should not adjust the attacktype */	925	/* There may be other things that should not adjust the attacktype */
947	if (tmp->type != SYMPTOM)	926	if (tmp->type != SYMPTOM)
948	{	927	{
949	attacktype |= tmp->attacktype;	928	attacktype |= tmp->attacktype;
…		…
952	path_denied |= tmp->path_denied;	931	path_denied |= tmp->path_denied;
953	move_type |= tmp->move_type;	932	move_type |= tmp->move_type;
954	stats.luck += tmp->stats.luck;	933	stats.luck += tmp->stats.luck;
955	}	934	}
956		935
957	if (QUERY_FLAG (tmp, FLAG_LIFESAVE )) SET_FLAG (this, FLAG_LIFESAVE);	936	flag |= tmp->flag & copy_flags;
958	if (QUERY_FLAG (tmp, FLAG_REFL_SPELL )) SET_FLAG (this, FLAG_REFL_SPELL);
959	if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE)) SET_FLAG (this, FLAG_REFL_MISSILE);
960	if (QUERY_FLAG (tmp, FLAG_STEALTH )) SET_FLAG (this, FLAG_STEALTH);
961	if (QUERY_FLAG (tmp, FLAG_XRAYS )) SET_FLAG (this, FLAG_XRAYS);
962	if (QUERY_FLAG (tmp, FLAG_BLIND )) SET_FLAG (this, FLAG_BLIND);
963	if (QUERY_FLAG (tmp, FLAG_SEE_IN_DARK )) SET_FLAG (this, FLAG_SEE_IN_DARK);
964		937
965	if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (&arch->clone, FLAG_UNDEAD))	938	if (tmp->flag [FLAG_UNDEAD] && !arch->flag [FLAG_UNDEAD])
966	SET_FLAG (this, FLAG_UNDEAD);	939	this->set_flag (FLAG_UNDEAD);
967		940
968	if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS))	941	//TODO: copy_flags?
		942	if (tmp->flag [FLAG_MAKE_INVIS])
969	{	943	{
970	SET_FLAG (this, FLAG_MAKE_INVIS);	944	set_flag (FLAG_MAKE_INVIS);
971	invisible = 1;	945	invisible = 1;
972	}	946	}
973		947
974	if (tmp->stats.exp && tmp->type != SKILL)	948	if (tmp->stats.exp && tmp->type != SKILL)
975	{	949	{
…		…
982	added_speed += tmp->stats.exp;	956	added_speed += tmp->stats.exp;
983	}	957	}
984		958
985	switch (tmp->type)	959	switch (tmp->type)
986	{	960	{
987	#if 0
988	case WAND:
989	case ROD:	961	case SKILL:
990	case HORN:	962	{
991	if (type != PLAYER || current_weapon == tmp)	963	// some skills will end up here without counting as "applied"
		964	if (!tmp->flag [FLAG_APPLIED] || skill_flags [tmp->subtype] & SF_AUTARK)
		965	break;
		966
		967	if (chosen_skill)
		968	{
		969	LOG (llevDebug, "fix_player, op %s has multiple skills applied (%s and %s)\n",
		970	&name, &chosen_skill->name, &tmp->name);
		971
		972	tmp->flag [FLAG_APPLIED] = false;
		973	update_stats ();
		974	return;
		975	}
		976
992	chosen_skill = tmp;	977	chosen_skill = tmp;
993	break;
994	#endif
995		978
996	/* skills modifying the character -b.t. */
997	/* for all skills and skill granting objects */
998	case SKILL:
999	if (!QUERY_FLAG (tmp, FLAG_APPLIED))
1000	break;
1001
1002	if (chosen_skill)
1003	LOG (llevDebug, "fix_player, op %s has multiple skills applied (%s and %s)\n",
1004	&name, &chosen_skill->name, &tmp->name);
1005
1006	chosen_skill = tmp;
1007
1008	if (tmp->stats.dam > 0)	979	if (tmp->stats.dam > 0)
1009	{ /* skill is a 'weapon' */	980	{ /* skill is a 'weapon' */
1010	if (!QUERY_FLAG (this, FLAG_READY_WEAPON))	981	if (!this->flag [FLAG_READY_WEAPON])
1011	weapon_speed = WEAPON_SPEED (tmp);	982	weapon_speed = max (0, WEAPON_SPEED (tmp));
1012		983
1013	if (weapon_speed < 0)
1014	weapon_speed = 0;
1015
1016	weapon_weight = tmp->weight;	984	weapon_weight = tmp->weight;
1017	stats.dam += 1 + (chosen_skill->level * tmp->stats.dam / 9);	985	stats.dam += 1 + chosen_skill->level * tmp->stats.dam / 9;
1018		986
1019	if (tmp->magic)	987	if (tmp->magic)
1020	stats.dam += tmp->magic;	988	stats.dam += tmp->magic;
1021	}	989	}
1022		990
1023	if (tmp->stats.wc)	991	if (tmp->stats.wc)
1024	wc -= tmp->stats.wc + tmp->magic;	992	wc -= tmp->stats.wc + tmp->magic;
1025		993
1026	if (tmp->slaying)	994	if (tmp->slaying)
1027	slaying = tmp->slaying;	995	slaying = tmp->slaying;
1028		996
1029	if (tmp->stats.ac)	997	if (tmp->stats.ac)
1030	ac -= tmp->stats.ac + tmp->magic;	998	ac -= tmp->stats.ac + tmp->magic;
1031		999
1032	if (settings.spell_encumbrance == TRUE && type == PLAYER)	1000	if (settings.spell_encumbrance == TRUE && type == PLAYER)
1033	contr->encumbrance += (int) 3 *tmp->weight / 1000;	1001	contr->encumbrance += weight_to_kg_approx (3 * tmp->weight);
		1002	}
1034		1003
1035	break;	1004	break;
1036		1005
1037	case SHIELD:	1006	case SHIELD:
1038	if (settings.spell_encumbrance == TRUE && type == PLAYER)	1007	if (settings.spell_encumbrance == TRUE && type == PLAYER)
1039	contr->encumbrance += (int) tmp->weight / 2000;	1008	contr->encumbrance += weight_to_kg_approx (tmp->weight) >> 1;
		1009	//FALLTHROUGH
1040	case RING:	1010	case RING:
1041	case AMULET:	1011	case AMULET:
1042	case GIRDLE:	1012	case GIRDLE:
1043	case HELMET:	1013	case HELMET:
1044	case BOOTS:	1014	case BOOTS:
…		…
1053	if (tmp->stats.ac)	1023	if (tmp->stats.ac)
1054	ac -= tmp->stats.ac + tmp->magic;	1024	ac -= tmp->stats.ac + tmp->magic;
1055		1025
1056	break;	1026	break;
1057		1027
		1028	case RANGED:
1058	case BOW:	1029	case BOW:
1059	case WEAPON:	1030	case WEAPON:
1060	if (type != PLAYER || current_weapon == tmp)
1061	{
1062	wc -= tmp->stats.wc + tmp->magic;	1031	wc -= tmp->stats.wc + tmp->magic;
1063		1032
1064	if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)	1033	if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
1065	ac -= tmp->stats.ac + tmp->magic;	1034	ac -= tmp->stats.ac + tmp->magic;
1066		1035
1067	stats.dam += tmp->stats.dam + tmp->magic;	1036	stats.dam += tmp->stats.dam + tmp->magic;
1068	weapon_weight = tmp->weight;	1037	weapon_weight = tmp->weight;
1069	weapon_speed = (WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;	1038	weapon_speed = (WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;
1070		1039
1071	if (weapon_speed < 0)	1040	if (weapon_speed < 0)
1072	weapon_speed = 0;	1041	weapon_speed = 0;
1073		1042
1074	slaying = tmp->slaying;	1043	slaying = tmp->slaying;
1075		1044
1076	/* If there is desire that two handed weapons should do	1045	/* If there is desire that two handed weapons should do
1077	* extra strength damage, this is where the code should	1046	* extra strength damage, this is where the code should
1078	* go.	1047	* go.
1079	*/	1048	*/
1080		1049
1081	if (type == PLAYER)	1050	if (type == PLAYER)
1082	if (settings.spell_encumbrance)	1051	if (settings.spell_encumbrance)
1083	contr->encumbrance += tmp->weight * 3 / 1000;	1052	contr->encumbrance += weight_to_kg_approx (3 * tmp->weight);
1084	}
1085		1053
1086	break;	1054	break;
1087		1055
1088	case ARMOUR: /* Only the best of these three are used: */	1056	case ARMOUR: /* Only the best of these three are used: */
1089	if (settings.spell_encumbrance == TRUE && type == PLAYER)	1057	if (settings.spell_encumbrance == TRUE && type == PLAYER)
1090	contr->encumbrance += tmp->weight / 1000;	1058	contr->encumbrance += weight_to_kg_approx (tmp->weight);
1091		1059
1092	case BRACERS:	1060	case BRACERS:
1093	case FORCE:	1061	case FORCE:
1094	if (tmp->stats.wc)	1062	if (tmp->stats.wc)
1095	{	1063	{
…		…
1112	else /* To nullify the below effect */	1080	else /* To nullify the below effect */
1113	ac += tmp->stats.ac + tmp->magic;	1081	ac += tmp->stats.ac + tmp->magic;
1114	}	1082	}
1115		1083
1116	if (tmp->stats.wc)	1084	if (tmp->stats.wc)
1117	wc -= (tmp->stats.wc + tmp->magic);	1085	wc -= tmp->stats.wc + tmp->magic;
1118		1086
1119	if (tmp->stats.ac)	1087	if (tmp->stats.ac)
1120	ac -= (tmp->stats.ac + tmp->magic);	1088	ac -= tmp->stats.ac + tmp->magic;
1121		1089
1122	if (ARMOUR_SPEED (tmp) && ARMOUR_SPEED (tmp) / 10.f < max)	1090	if (ARMOUR_SPEED (tmp))
1123	max = ARMOUR_SPEED (tmp) / 10.f;	1091	min_it (max_speed, ARMOUR_SPEED (tmp) / 10.f);
1124		1092
1125	break;	1093	break;
1126	} /* switch tmp->type */	1094	} /* switch tmp->type */
1127	} /* item is equipped */	1095	} /* item is equipped */
1128	} /* for loop of items */	1096	} /* for loop of items */
		1097
		1098	min_it (glow_radius, MAX_LIGHT_RADIUS);
1129		1099
1130	/* We've gone through all the objects the player has equipped. For many things, we	1100	/* We've gone through all the objects the player has equipped. For many things, we
1131	* have generated intermediate values which we now need to assign.	1101	* have generated intermediate values which we now need to assign.
1132	*/	1102	*/
1133		1103
…		…
1135	* If there is an uncursed potion in effect, granting more protection	1105	* If there is an uncursed potion in effect, granting more protection
1136	* than that, we take: 'total resistance = resistance from potion'.	1106	* than that, we take: 'total resistance = resistance from potion'.
1137	* If there is a cursed (and no uncursed) potion in effect, we take	1107	* If there is a cursed (and no uncursed) potion in effect, we take
1138	* 'total resistance = vulnerability from cursed potion'.	1108	* 'total resistance = vulnerability from cursed potion'.
1139	*/	1109	*/
1140	for (i = 0; i < NROFATTACKS; i++)	1110	for (int i = 0; i < NROFATTACKS; i++)
1141	{	1111	{
1142	resist[i] = prot[i] - vuln[i];	1112	resist[i] = prot[i] - vuln[i];
1143		1113
1144	if (potion_resist[i] && ((potion_resist[i] > resist[i]) || (potion_resist[i] < 0)))	1114	if (potion_resist[i] != -1000
		1115	&& (potion_resist[i] < 0 || potion_resist[i] > resist[i]))
1145	resist[i] = potion_resist[i];	1116	resist[i] = potion_resist[i];
1146	}	1117	}
1147		1118
1148	/* Figure out the players sp/mana/hp totals. */
1149	if (type == PLAYER)	1119	if (type == PLAYER)
1150	{	1120	{
		1121	// clamp various player stats
		1122	for (int i = 0; i < NUM_STATS; ++i)
		1123	stats.stat (i) = stat_sum [i];
		1124
		1125	check_stat_bounds (&stats);
		1126
		1127	contr->digestion = clamp (contr->digestion, MIN_DIGESTION, MAX_DIGESTION);
		1128
		1129	/* Figure out the players sp/mana/hp totals. */
1151	int pl_level;	1130	int pl_level;
1152		1131
1153	check_stat_bounds (&(stats));
1154	pl_level = level;
1155
1156	if (pl_level < 1)
1157	pl_level = 1; /* safety, we should always get 1 levels worth of hp! */	1132	pl_level = max (1, level); /* safety, we should always get 1 levels worth of hp! */
1158		1133
1159	/* You basically get half a con bonus/level. But we do take into account rounding,	1134	/* You basically get half a con bonus/level. But we do take into account rounding,
1160	* so if your bonus is 7, you still get 7 worth of bonus every 2 levels.	1135	* so if your bonus is 7, you still get 7 worth of bonus every 2 levels.
1161	*/	1136	*/
1162	for (i = 1, stats.maxhp = 0; i <= pl_level && i <= 10; i++)	1137	stats.maxhp = 0;
		1138	for (int i = 1; i <= min (10, pl_level); i++)
1163	{	1139	{
1164	j = contr->levhp[i] + con_bonus[stats.Con] / 2;	1140	int j = contr->levhp[i] + con_bonus[stats.Con] / 2;
1165		1141
1166	if (i % 2 && con_bonus[stats.Con] % 2)	1142	if (i % 2 && con_bonus[stats.Con] % 2)
1167	{
1168	if (con_bonus[stats.Con] > 0)	1143	if (con_bonus[stats.Con] > 0)
1169	j++;	1144	j++;
1170	else	1145	else
1171	j--;	1146	j--;
1172	}
1173		1147
1174	stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */	1148	stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */
1175	}	1149	}
1176		1150
1177	for (i = 11; i <= level; i++)	1151	stats.maxhp += 2 * max (0, level - 10);
1178	stats.maxhp += 2;
1179		1152
1180	if (stats.hp > stats.maxhp)	1153	if (stats.hp > stats.maxhp)
1181	stats.hp = stats.maxhp;	1154	stats.hp = stats.maxhp;
1182		1155
1183	/* Sp gain is controlled by the level of the player's	1156	/* Sp gain is controlled by the level of the player's
…		…
1196		1169
1197	if (mana_obj == this && type == PLAYER)	1170	if (mana_obj == this && type == PLAYER)
1198	stats.maxsp = 1;	1171	stats.maxsp = 1;
1199	else	1172	else
1200	{	1173	{
1201	sp_tmp = 0.f;	1174	float sp_tmp = 0.f;
1202		1175
1203	for (i = 1; i <= mana_obj->level && i <= 10; i++)	1176	for (int i = 1; i <= min (10, mana_obj->level); i++)
1204	{	1177	{
1205	float stmp;	1178	float stmp;
1206		1179
1207	/* Got some extra bonus at first level */	1180	/* Got some extra bonus at first level */
1208	if (i < 2)	1181	if (i < 2)
1209	stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 6.f;	1182	stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 6.f;
1210	else	1183	else
1211	stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f;	1184	stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f;
1212		1185
1213	if (stmp < 1.f)
1214	stmp = 1.f;
1215
1216	sp_tmp += stmp;	1186	sp_tmp += max (1.f, stmp);
1217	}	1187	}
1218		1188
1219	stats.maxsp = (sint16)sp_tmp;	1189	stats.maxsp = int (sp_tmp) + 2 * max (0, mana_obj->level - 10);
1220
1221	for (i = 11; i <= mana_obj->level; i++)
1222	stats.maxsp += 2;
1223	}	1190	}
1224		1191
1225	/* Characters can get their sp supercharged via rune of transferrance */	1192	/* Characters can get their sp supercharged via rune of transferrance */
1226	if (stats.sp > stats.maxsp * 2)	1193	stats.sp = min (stats.sp, stats.maxsp * 2);
1227	stats.sp = stats.maxsp * 2;
1228		1194
1229	/* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */	1195	/* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */
1230	if (!grace_obj || !grace_obj->level || type != PLAYER)	1196	if (!grace_obj || !grace_obj->level || type != PLAYER)
1231	grace_obj = this;	1197	grace_obj = this;
1232		1198
…		…
1237	/* store grace in a float - this way, the divisions below don't create	1203	/* store grace in a float - this way, the divisions below don't create
1238	* big jumps when you go from level to level - with int's, it then	1204	* big jumps when you go from level to level - with int's, it then
1239	* becomes big jumps when the sums of the bonuses jump to the next	1205	* becomes big jumps when the sums of the bonuses jump to the next
1240	* step of 8 - with floats, even fractional ones are useful.	1206	* step of 8 - with floats, even fractional ones are useful.
1241	*/	1207	*/
1242	sp_tmp = 0.f;	1208	float sp_tmp = 0.f;
1243	for (i = 1, stats.maxgrace = 0; i <= grace_obj->level && i <= 10; i++)	1209
		1210	for (int i = 1; i <= min (10, grace_obj->level); i++)
1244	{	1211	{
1245	float grace_tmp = 0.f;	1212	float grace_tmp = 0.f;
1246		1213
1247	/* Got some extra bonus at first level */	1214	/* Got some extra bonus at first level */
1248	if (i < 2)	1215	if (i < 2)
1249	grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 6.f;	1216	grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 6.f;
1250	else	1217	else
1251	grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f;	1218	grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f;
1252		1219
1253	if (grace_tmp < 1.f)
1254	grace_tmp = 1.f;
1255
1256	sp_tmp += grace_tmp;	1220	sp_tmp += max (1.f, grace_tmp);
1257	}	1221	}
1258		1222
1259	stats.maxgrace = (sint16)sp_tmp;
1260
1261	/* two grace points per level after 11 */	1223	/* two grace points per level after 10 */
1262	for (i = 11; i <= grace_obj->level; i++)	1224	stats.maxgrace = int (sp_tmp) + 2 * max (0, grace_obj->level - 10);
1263	stats.maxgrace += 2;
1264	}	1225	}
1265		1226
1266	/* No limit on grace vs maxgrace */	1227	/* No limit on grace vs maxgrace */
1267		1228
1268	if (contr->braced)	1229	if (contr->braced)
…		…
1288		1249
1289	if (contr && wc_obj && wc_obj->level > 1)	1250	if (contr && wc_obj && wc_obj->level > 1)
1290	{	1251	{
1291	wc -= wc_obj->level + thaco_bonus[stats.Str];	1252	wc -= wc_obj->level + thaco_bonus[stats.Str];
1292		1253
1293	for (i = 1; i < wc_obj->level; i++)	1254	for (int i = 1; i < wc_obj->level; i++)
1294	{	1255	{
1295	/* additional wc every 6 levels */	1256	/* additional wc every 6 levels */
1296	if (!(i % 6))	1257	if (!(i % 6))
1297	wc--;	1258	wc--;
1298		1259
…		…
1311		1272
1312	speed = 1.f + speed_bonus[stats.Dex];	1273	speed = 1.f + speed_bonus[stats.Dex];
1313		1274
1314	if (settings.search_items && contr->search_str[0])	1275	if (settings.search_items && contr->search_str[0])
1315	speed -= 1;	1276	speed -= 1;
1316
1317	if (attacktype == 0)
1318	attacktype = arch->clone.attacktype;
1319	} /* End if player */	1277	} /* End if player */
1320		1278
1321	if (added_speed >= 0)	1279	if (added_speed >= 0)
1322	speed += added_speed / 10.f;	1280	speed += added_speed / 10.f;
1323	else /* Something wrong here...: */	1281	else /* Something wrong here...: */
1324	speed /= 1.f - added_speed;	1282	speed /= 1.f - added_speed;
1325		1283
1326	/* Max is determined by armour */	1284	/* Max is determined by armour */
1327	if (speed > max)	1285	speed = min (speed, max_speed);
1328	speed = max;
1329		1286
1330	if (type == PLAYER)	1287	if (type == PLAYER)
1331	{	1288	{
1332	/* f is a number the represents the number of kg above (positive num)	1289	/* f is a number the represents the number of kg above (positive num)
1333	* or below (negative number) that the player is carrying. If above	1290	* or below (negative number) that the player is carrying. If above
1334	* weight limit, then player suffers a speed reduction based on how	1291	* weight limit, then player suffers a speed reduction based on how
1335	* much above he is, and what is max carry is	1292	* much above he is, and what is max carry is
1336	*/	1293	*/
1337	f = (carrying / 1000) - max_carry[stats.Str];	1294	double f = weight_to_kg_approx (carrying) - max_carry[stats.Str];
1338	if (f > 0)	1295	if (f > 0.f)
1339	speed = speed / (1.f + f / max_carry[stats.Str]);	1296	speed /= (1.f + f / max_carry[stats.Str]);
1340	}	1297	}
1341		1298
1342	speed += bonus_speed / 10.f; /* Not affected by limits */	1299	speed += bonus_speed / 10.f; /* Not affected by limits */
		1300	speed *= speed_reduce_from_disease;
1343		1301
1344	/* Put a lower limit on speed. Note with this speed, you move once every	1302	/* Put a lower limit on speed. Note with this speed, you move once every
1345	* 100 ticks or so. This amounts to once every 12 seconds of realtime.	1303	* 25 ticks or so. This amounts to once every 3 seconds of realtime.
1346	*/	1304	*/
1347	speed = speed * speed_reduce_from_disease;	1305	max_it (speed, is_player () ? MIN_PLAYER_SPEED : MIN_ACTIVE_SPEED);
1348		1306
1349	if (speed < 0.01f && type == PLAYER)	1307	if (speed != old_speed)
1350	speed = 0.01f;	1308	set_speed (speed);
1351		1309
1352	if (type == PLAYER)	1310	if (type == PLAYER)
1353	{	1311	{
1354	/* (This formula was made by vidarl@ifi.uio.no)	1312	/* (This formula was made by vidarl@ifi.uio.no)
1355	* Note that we never used these values again - basically	1313	* Note that we never used these values again - basically
…		…
1366	K *= (4 + level) * 1.2f / (6 + level);	1324	K *= (4 + level) * 1.2f / (6 + level);
1367		1325
1368	if (K <= 0.01f)	1326	if (K <= 0.01f)
1369	K = 0.01f;	1327	K = 0.01f;
1370		1328
1371	float S = speed / (K * s);	1329	contr->weapon_sp = K * s * .5f; //TODO: balance the .5
1372
1373	contr->weapon_sp = S;
1374	}	1330	}
1375		1331
1376	/* I want to limit the power of small monsters with big weapons: */	1332	/* I want to limit the power of small monsters with big weapons: */
1377	if (type != PLAYER && arch && stats.dam > arch->clone.stats.dam * 3)	1333	if (type != PLAYER && arch && stats.dam > arch->stats.dam * 3)
1378	stats.dam = arch->clone.stats.dam * 3;	1334	stats.dam = arch->stats.dam * 3;
1379		1335
1380	stats.wc = clamp (wc, MIN_WC, MAX_WC);	1336	stats.wc = clamp (wc, MIN_WC, MAX_WC);
1381	stats.ac = clamp (ac, MIN_AC, MAX_AC);	1337	stats.ac = clamp (ac, MIN_AC, MAX_AC);
1382		1338
1383	/* if for some reason the creature doesn't have any move type,	1339	/* if for some reason the creature doesn't have any move type,
…		…
1389	if (move_type == 0)	1345	if (move_type == 0)
1390	move_type = MOVE_WALK;	1346	move_type = MOVE_WALK;
1391	else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))	1347	else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))
1392	move_type &= ~MOVE_WALK;	1348	move_type &= ~MOVE_WALK;
1393		1349
1394	if (speed != old_speed)	1350	// now apply the new move_type
1395	set_speed (speed);	1351	if (this->move_type != move_type)
		1352	change_move_type (move_type);
1396		1353
1397	/* It is quite possible that a player's spell costing might have changed,	1354	/* It is quite possible that a player's spell costing might have changed,
1398	* so we will check that now.	1355	* so we will check that now.
1399	*/	1356	*/
1400	if (type == PLAYER)	1357	if (is_player ())
1401	{	1358	contr->update_spells ();
1402	esrv_update_stats (contr);
1403	esrv_update_spells (contr);
1404	}
1405		1359
1406	// update the mapspace, if we are on a map	1360	// update the mapspace, if we are on a map
1407	if (!flag [FLAG_REMOVED] && map)	1361	if (!flag [FLAG_REMOVED] && map)
1408	map->at (x, y).flags_ = 0;	1362	map->at (x, y).flags_ = 0;
		1363	}
		1364
		1365	void
		1366	object::set_glow_radius (sint8 rad)
		1367	{
		1368	glow_radius = rad;
		1369
		1370	if (is_on_map ())
		1371	update_all_los (map, x, y);
		1372	else if (object *env = outer_env ())
		1373	{
		1374	env->update_stats ();
		1375
		1376	if (env->is_on_map ())
		1377	update_all_los (env->map, env->x, env->y);
		1378	}
1409	}	1379	}
1410		1380
1411	/*	1381	/*
1412	* Returns true if the given player is a legal class.	1382	* Returns true if the given player is a legal class.
1413	* The function to add and remove class-bonuses to the stats doesn't	1383	* The function to add and remove class-bonuses to the stats doesn't
…		…
1429		1399
1430	/*	1400	/*
1431	* set the new dragon name after gaining levels or	1401	* set the new dragon name after gaining levels or
1432	* changing ability focus (later this can be extended to	1402	* changing ability focus (later this can be extended to
1433	* eventually change the player's face and animation)	1403	* eventually change the player's face and animation)
1434	*
1435	* Note that the title is written to 'own_title' in the
1436	* player struct. This should be changed to 'ext_title'
1437	* as soon as clients support this!
1438	* Please, anyone, write support for 'ext_title'.
1439	*/	1404	*/
1440	void	1405	void
1441	set_dragon_name (object *pl, const object *abil, const object *skin)	1406	set_dragon_name (object *pl, const object *abil, const object *skin)
1442	{	1407	{
1443	int atnr = -1; /* attacknumber of highest level */	1408	int atnr = -1; /* attacknumber of highest level */
…		…
1461	/* now if there are equals at highest level, pick the one with focus,	1426	/* now if there are equals at highest level, pick the one with focus,
1462	or else at random */	1427	or else at random */
1463	if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level)	1428	if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level)
1464	atnr = abil->stats.exp;	1429	atnr = abil->stats.exp;
1465		1430
1466	level = (int) (level / 5.);
1467
1468	/* now set the new title */	1431	/* now set the new title */
1469	if (pl->contr != NULL)
1470	{
1471	if (level == 0)
1472	sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);	1432	if (level < 25) sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
1473	else if (level == 1)
1474	sprintf (pl->contr->title, "%s wyrm", attacks[atnr]);	1433	else if (level < 50) sprintf (pl->contr->title, "%s wyrm" , attacks[atnr]);
1475	else if (level == 2)
1476	sprintf (pl->contr->title, "%s wyvern", attacks[atnr]);	1434	else if (level < 75) sprintf (pl->contr->title, "%s wyvern" , attacks[atnr]);
1477	else if (level == 3)
1478	sprintf (pl->contr->title, "%s dragon", attacks[atnr]);	1435	else if (level < 100) sprintf (pl->contr->title, "%s dragon" , attacks[atnr]);
1479	else	1436	else
1480	{	1437	{
1481	/* special titles for extra high resistance! */	1438	/* special titles for extra high resistance! */
1482	if (skin->resist[atnr] > 80)
1483	sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);	1439	if (skin->resist[atnr] > 80) sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);
1484	else if (skin->resist[atnr] > 50)
1485	sprintf (pl->contr->title, "ancient %s dragon", attacks[atnr]);	1440	else if (skin->resist[atnr] > 50) sprintf (pl->contr->title, "ancient %s dragon" , attacks[atnr]);
1486	else
1487	sprintf (pl->contr->title, "big %s dragon", attacks[atnr]);	1441	else sprintf (pl->contr->title, "big %s dragon" , attacks[atnr]);
1488	}
1489	}	1442	}
1490		1443
1491	strcpy (pl->contr->own_title, "");	1444	strcpy (pl->contr->own_title, "");
1492	}	1445	}
1493		1446
1494	/*	1447	/*
1495	* This function is called when a dragon-player gains	1448	* This function is called when a dragon-player gains
1496	* an overall level. Here, the dragon might gain new abilities	1449	* an overall level. Here, the dragon might gain new abilities
1497	* or change the ability-focus.	1450	* or change the ability-focus.
1498	*/	1451	*/
1499	void	1452	static void
1500	dragon_level_gain (object *who)	1453	dragon_level_gain (object *who)
1501	{	1454	{
1502	object *abil = NULL; /* pointer to dragon ability force */	1455	object *abil = NULL; /* pointer to dragon ability force */
1503	object *skin = NULL; /* pointer to dragon skin force */	1456	object *skin = NULL; /* pointer to dragon skin force */
1504	object *tmp = NULL; /* tmp. object */	1457	object *tmp = NULL; /* tmp. object */
1505	char buf[MAX_BUF]; /* tmp. string buffer */	1458	char buf[MAX_BUF]; /* tmp. string buffer */
1506		1459
1507	/* now grab the 'dragon_ability'-forces from the player's inventory */	1460	/* now grab the 'dragon_ability'-forces from the player's inventory */
1508	shstr_cmp dragon_ability_force ("dragon_ability_force");
1509	shstr_cmp dragon_skin_force ("dragon_skin_force");
1510
1511	for (tmp = who->inv; tmp; tmp = tmp->below)	1461	for (tmp = who->inv; tmp; tmp = tmp->below)
1512	if (tmp->type == FORCE)	1462	if (tmp->type == FORCE)
1513	if (tmp->arch->name == dragon_ability_force)	1463	if (tmp->arch->archname == shstr_dragon_ability_force)
1514	abil = tmp;	1464	abil = tmp;
1515	else if (tmp->arch->name == dragon_skin_force)	1465	else if (tmp->arch->archname == shstr_dragon_skin_force)
1516	skin = tmp;	1466	skin = tmp;
1517		1467
1518	/* if the force is missing -> bail out */	1468	/* if the force is missing -> bail out */
1519	if (abil == NULL)	1469	if (abil == NULL)
1520	return;	1470	return;
…		…
1563	object *skill_obj;	1513	object *skill_obj;
1564		1514
1565	skill_obj = get_archetype_by_skill_name (skill_name, SKILL);	1515	skill_obj = get_archetype_by_skill_name (skill_name, SKILL);
1566	if (!skill_obj)	1516	if (!skill_obj)
1567	{	1517	{
1568	LOG (llevError, "add_player_exp: couldn't find skill %s\n", skill_name);	1518	LOG (llevError, "give_skill_by_name: couldn't find skill %s\n", skill_name);
1569	return NULL;	1519	return NULL;
1570	}	1520	}
1571		1521
1572	/* clear the flag - exp goes into this bucket, but player	1522	/* clear the flag - exp goes into this bucket, but player
1573	* still doesn't know it.	1523	* still doesn't know it.
1574	*/	1524	*/
1575	CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL);	1525	skill_obj->clr_flag (FLAG_CAN_USE_SKILL);
1576	skill_obj->stats.exp = 0;	1526	skill_obj->stats.exp = 0;
1577	skill_obj->level = 1;	1527	skill_obj->level = 1;
1578	insert_ob_in_ob (skill_obj, op);	1528	op->insert (skill_obj);
1579		1529
1580	if (player *pl = op->contr)	1530	if (player *pl = op->contr)
1581	{	1531	pl->link_skills ();
1582	pl->last_skill_ob [skill_obj->subtype] = skill_obj;
1583	if (pl->ns)
1584	pl->ns->last_skill_exp[skill_obj->subtype] = -1;//TODO: should be made superfluous
1585	}
1586		1532
1587	return skill_obj;	1533	return skill_obj;
1588	}	1534	}
1589		1535
1590	/* player_lvl_adj() - for the new exp system. we are concerned with	1536	/* player_lvl_adj() - for the new exp system. we are concerned with
…		…
1596	*/	1542	*/
1597	void	1543	void
1598	player_lvl_adj (object *who, object *op)	1544	player_lvl_adj (object *who, object *op)
1599	{	1545	{
1600	char buf[MAX_BUF];	1546	char buf[MAX_BUF];
		1547	bool changed = false;
1601		1548
1602	if (!op) /* when rolling stats */	1549	if (!op) /* when rolling stats */
1603	op = who;	1550	op = who;
1604		1551
1605	if (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul))	1552	while (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul))
1606	{	1553	{
		1554	changed = true;
		1555
1607	op->level++;	1556	op->level++;
1608		1557
1609	if (op && op == who && op->stats.exp > 1 && is_dragon_pl (who))	1558	if (op && op == who && op->stats.exp > 1 && who->is_dragon ())
1610	dragon_level_gain (who);	1559	dragon_level_gain (who);
1611		1560
1612	/* Only roll these if it is the player (who) that gained the level */	1561	/* Only roll these if it is the player (who) that gained the level */
1613	if (op == who && (who->level < 11) && who->type == PLAYER)	1562	if (op == who && (who->level < 11) && who->type == PLAYER)
1614	{	1563	{
1615	who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;	1564	who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;
1616	who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);	1565	who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);
1617	who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;	1566	who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;
1618	}	1567	}
1619		1568
1620	who->update_stats ();
1621	if (op->level > 1)	1569	if (op->level > 1)
1622	{	1570	{
1623	if (op->type != PLAYER)	1571	if (op->type != PLAYER)
		1572	{
		1573	who->contr->play_sound (sound_find ("skill_up"));
1624	sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);	1574	sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
		1575	}
1625	else	1576	else
		1577	{
		1578	who->contr->play_sound (sound_find ("level_up"));
1626	sprintf (buf, "You are now level %d.", op->level);	1579	sprintf (buf, "You are now level %d.", op->level);
		1580	}
1627		1581
1628	if (who)	1582	if (who)
1629	new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);	1583	new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1630	}	1584	}
1631
1632	player_lvl_adj (who, op); /* To increase more levels */
1633	}	1585	}
		1586
1634	else if (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))	1587	while (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))
1635	{	1588	{
		1589	changed = true;
		1590
1636	op->level--;	1591	op->level--;
1637	who->update_stats ();
1638		1592
1639	if (op->type != PLAYER)	1593	if (op->type != PLAYER)
1640	{	1594	{
1641	sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);	1595	sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1642	new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);	1596	new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1643	}	1597	}
1644
1645	player_lvl_adj (who, op); /* To decrease more levels */
1646	}	1598	}
1647		1599
1648	/* check if the spell data has changed */	1600	if (changed)
1649	esrv_update_stats (who->contr);	1601	who->update_stats (); // should cause esrv_update_stats and esrv_update_spells
1650	esrv_update_spells (who->contr);
1651	}	1602	}
1652		1603
1653	/*	1604	/*
1654	* Returns how much experience is needed for a player to become	1605	* Returns how much experience is needed for a player to become
1655	* the given level. level should really never exceed max_level	1606	* the given level. level should really never exceed max_level
1656	*/	1607	*/
1657		1608
1658	sint64	1609	sint64
1659	level_exp (int level, double expmul)	1610	level_exp (int level, double expmul)
1660	{	1611	{
1661	if (level > settings.max_level)	1612	return expmul * level_to_min_exp (level);
1662	return (sint64) (expmul * levels[settings.max_level]);
1663
1664	return (sint64) (expmul * levels[level]);
1665	}	1613	}
1666		1614
1667	/*	1615	/*
1668	* Ensure that the permanent experience requirements in an exp object are met.	1616	* Ensure that the permanent experience requirements in an exp object are met.
1669	* This really just checks 'op to make sure the perm_exp value is within	1617	* This really just checks 'op to make sure the perm_exp value is within
…		…
1697	* NULL, in which case exp increases the players general	1645	* NULL, in which case exp increases the players general
1698	* total, but not any particular skill.	1646	* total, but not any particular skill.
1699	* flag is what to do if the player doesn't have the skill:	1647	* flag is what to do if the player doesn't have the skill:
1700	*/	1648	*/
1701	static void	1649	static void
1702	add_player_exp (object *op, sint64 exp, const char *skill_name, int flag)	1650	add_player_exp (object *op, sint64 exp, shstr_tmp skill_name, int flag)
1703	{	1651	{
1704	object *skill_obj = NULL;	1652	object *skill_obj;
1705	sint64 limit, exp_to_add;	1653	sint64 limit, exp_to_add;
1706	int i;
1707		1654
1708	/* prevents some forms of abuse. */	1655	/* prevents some forms of abuse. */
1709	if (op->contr->braced)	1656	if (op->contr->braced)
1710	exp /= 5;	1657	exp /= 5;
1711		1658
1712	/* Try to find the matching skill.	1659	/* Try to find the matching skill.
1713	* We do a shortcut/time saving mechanism first - see if it matches	1660	* We do a shortcut/time saving mechanism first - see if it matches
1714	* chosen_skill. This means we don't need to search through	1661	* chosen_skill. This means we don't need to search through
1715	* the players inventory.	1662	* the players inventory.
1716	*/	1663	*/
		1664	skill_obj = 0;
		1665
1717	if (skill_name)	1666	if (skill_name)
1718	{	1667	{
1719	if (op->chosen_skill && op->chosen_skill->type == SKILL && !strcmp (skill_name, op->chosen_skill->skill))	1668	skill_obj = op->contr->find_skill (skill_name);
1720	skill_obj = op->chosen_skill;
1721	else
1722	{
1723	for (i = 0; i < NUM_SKILLS; i++)
1724	if (op->contr->last_skill_ob[i] && !strcmp (op->contr->last_skill_ob[i]->skill, skill_name))
1725	{
1726	skill_obj = op->contr->last_skill_ob[i];
1727	break;
1728	}
1729		1669
1730	/* Player doesn't have the skill. Check to see what to do, and give	1670	/* Player doesn't have the skill. Check to see what to do, and give
1731	* it to the player if necessary	1671	* it to the player if necessary
1732	*/	1672	*/
1733	if (!skill_obj)	1673	if (!skill_obj)
1734	{	1674	{
1735	if (flag == SK_EXP_NONE)	1675	if (flag == SK_EXP_NONE)
1736	return;	1676	return;
		1677
1737	else if (flag == SK_EXP_ADD_SKILL)	1678	if (flag == SK_EXP_ADD_SKILL)
1738	give_skill_by_name (op, skill_name);	1679	skill_obj = give_skill_by_name (op, skill_name);
1739	}
1740	}	1680	}
1741	}	1681	}
1742		1682
1743	if (flag != SK_EXP_SKILL_ONLY)	1683	if (flag != SK_EXP_SKILL_ONLY)
1744	{	1684	{
1745	/* Basically, you can never gain more experience in one shot	1685	/* Basically, you can never gain more experience in one shot
1746	* than half what you need to gain for next level.	1686	* than half what you need to gain for next level.
1747	*/	1687	*/
1748	exp_to_add = exp;	1688	exp_to_add = exp;
1749	limit = (levels[op->level + 1] - levels[op->level]) / 2;	1689	limit = (levels [op->level + 1] - levels [op->level]) / 2;
1750	if (exp_to_add > limit)	1690	if (exp_to_add > limit)
1751	exp_to_add = limit;	1691	exp_to_add = limit;
1752		1692
1753	ADD_EXP (op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj ? skill_obj->expmul : 1)));	1693	ADD_EXP (op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj ? skill_obj->expmul : 1)));
1754	if (settings.permanent_exp_ratio)	1694	if (settings.permanent_exp_ratio)
…		…
1761	}	1701	}
1762		1702
1763	if (skill_obj)	1703	if (skill_obj)
1764	{	1704	{
1765	exp_to_add = exp;	1705	exp_to_add = exp;
1766	limit = (levels[skill_obj->level + 1] - levels[skill_obj->level]) / 2;	1706	limit = (levels [skill_obj->level + 1] - levels [skill_obj->level]) / 2;
1767	if (exp_to_add > limit)	1707	if (exp_to_add > limit)
1768	exp_to_add = limit;	1708	exp_to_add = limit;
1769		1709
1770	ADD_EXP (skill_obj->stats.exp, exp_to_add);	1710	ADD_EXP (skill_obj->stats.exp, exp_to_add);
1771	if (settings.permanent_exp_ratio)	1711	if (settings.permanent_exp_ratio)
…		…
1777	player_lvl_adj (op, skill_obj);	1717	player_lvl_adj (op, skill_obj);
1778	}	1718	}
1779	}	1719	}
1780		1720
1781	/* This function checks to make sure that object 'op' can	1721	/* This function checks to make sure that object 'op' can
1782	* lost 'exp' experience. It returns the amount of exp	1722	* lose 'exp' experience. It returns the amount of exp
1783	* object 'op' can in fact lose - it basically makes	1723	* object 'op' can in fact lose - it basically makes
1784	* adjustments based on permanent exp and the like.	1724	* adjustments based on permanent exp and the like.
1785	* This function should always be used for losing experience -	1725	* This function should always be used for losing experience -
1786	* the 'exp' value passed should be positive - this is the	1726	* the 'exp' value passed should be positive - this is the
1787	* amount that should get subtract from the player.	1727	* amount that should get subtract from the player.
1788	*/	1728	*/
1789	sint64	1729	static sint64
1790	check_exp_loss (const object *op, sint64 exp)	1730	check_exp_loss (const object *op, sint64 exp)
1791	{	1731	{
1792	sint64 del_exp;	1732	sint64 del_exp;
1793		1733
1794	if (exp > op->stats.exp)	1734	if (exp > op->stats.exp)
1795	exp = op->stats.exp;	1735	exp = op->stats.exp;
		1736
1796	if (settings.permanent_exp_ratio)	1737	if (settings.permanent_exp_ratio)
1797	{	1738	{
1798	del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);	1739	del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);
		1740
1799	if (del_exp < 0)	1741	if (del_exp < 0)
1800	del_exp = 0;	1742	del_exp = 0;
		1743
1801	if (exp > del_exp)	1744	if (exp > del_exp)
1802	exp = del_exp;	1745	exp = del_exp;
1803	}	1746	}
		1747
1804	return exp;	1748	return exp;
1805	}	1749	}
1806		1750
1807	sint64	1751	sint64
1808	check_exp_adjust (const object *op, sint64 exp)	1752	check_exp_adjust (const object *op, sint64 exp)
1809	{	1753	{
1810	if (exp < 0)	1754	if (exp < 0)
1811	return check_exp_loss (op, exp);	1755	return check_exp_loss (op, exp);
1812	else	1756	else
1813	return MIN (exp, (sint64) MAX_EXPERIENCE - op->stats.exp);	1757	return min (exp, (sint64)MAX_EXPERIENCE - op->stats.exp);
1814	}	1758	}
1815
1816		1759
1817	/* Subtracts experience from player.	1760	/* Subtracts experience from player.
1818	* if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we	1761	* if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we
1819	* only subtract from the matching skill. Otherwise,	1762	* only subtract from the matching skill. Otherwise,
1820	* this subtracts a portion from all	1763	* this subtracts a portion from all
…		…
1825	* where everything is at the minimum perm exp, he would lose nothing.	1768	* where everything is at the minimum perm exp, he would lose nothing.
1826	* exp is the amount of exp to subtract - thus, it should be	1769	* exp is the amount of exp to subtract - thus, it should be
1827	* a postive number.	1770	* a postive number.
1828	*/	1771	*/
1829	static void	1772	static void
1830	subtract_player_exp (object *op, sint64 exp, const char *skill, int flag)	1773	subtract_player_exp (object *op, sint64 exp, shstr_tmp skill, int flag)
1831	{	1774	{
1832	float fraction = (float) exp / (float) op->stats.exp;	1775	float fraction = (float) exp / (float) op->stats.exp;
1833	object *tmp;	1776	object *tmp;
1834	sint64 del_exp;	1777	sint64 del_exp;
1835		1778
1836	for (tmp = op->inv; tmp; tmp = tmp->below)	1779	for (tmp = op->inv; tmp; tmp = tmp->below)
1837	if (tmp->type == SKILL && tmp->stats.exp)	1780	if (tmp->type == SKILL && tmp->stats.exp)
1838	{	1781	{
1839	if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (tmp->skill, skill))	1782	if (flag == SK_SUBTRACT_SKILL_EXP && skill && tmp->skill == skill)
1840	{	1783	{
1841	del_exp = check_exp_loss (tmp, exp);	1784	del_exp = check_exp_loss (tmp, exp);
1842	tmp->stats.exp -= del_exp;	1785	tmp->stats.exp -= del_exp;
1843	player_lvl_adj (op, tmp);	1786	player_lvl_adj (op, tmp);
1844	}	1787	}
1845	else if (flag != SK_SUBTRACT_SKILL_EXP)	1788	else if (flag != SK_SUBTRACT_SKILL_EXP)
1846	{	1789	{
1847	/* only want to process other skills if we are not trying	1790	/* only want to process other skills if we are not trying
1848	* to match a specific skill.	1791	* to match a specific skill.
1849	*/	1792	*/
1850	del_exp = check_exp_loss (tmp, (sint64) (tmp->stats.exp * fraction));	1793	del_exp = check_exp_loss (tmp, tmp->stats.exp * fraction);
1851	tmp->stats.exp -= del_exp;	1794	tmp->stats.exp -= del_exp;
1852	player_lvl_adj (op, tmp);	1795	player_lvl_adj (op, tmp);
1853	}	1796	}
1854	}	1797	}
1855		1798
…		…
1869	* skill_name is the skill that should get the exp added.	1812	* skill_name is the skill that should get the exp added.
1870	* flag is what to do if player doesn't have the skill.	1813	* flag is what to do if player doesn't have the skill.
1871	* these last two values are only used for players.	1814	* these last two values are only used for players.
1872	*/	1815	*/
1873	void	1816	void
1874	change_exp (object *op, sint64 exp, const char *skill_name, int flag)	1817	change_exp (object *op, sint64 exp, shstr_tmp skill_name, int flag)
1875	{	1818	{
1876	#ifdef EXP_DEBUG	1819	#ifdef EXP_DEBUG
1877	LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);	1820	LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
1878	#endif	1821	#endif
1879		1822
…		…
1896	* worth.	1839	* worth.
1897	*/	1840	*/
1898	if (op->type != PLAYER)	1841	if (op->type != PLAYER)
1899	{	1842	{
1900	/* Sanity check */	1843	/* Sanity check */
1901	if (!QUERY_FLAG (op, FLAG_ALIVE))	1844	if (!op->flag [FLAG_ALIVE])
1902	return;	1845	return;
1903		1846
1904	/* reset exp to max allowed value. We subtract from	1847	/* reset exp to max allowed value. We subtract from
1905	* MAX_EXPERIENCE to prevent overflows. If the player somehow has	1848	* MAX_EXPERIENCE to prevent overflows. If the player somehow has
1906	* more than max exp, just return.	1849	* more than max exp, just return.
…		…
1932	* amount of permenent experience, whichever gives the lowest loss.	1875	* amount of permenent experience, whichever gives the lowest loss.
1933	*/	1876	*/
1934	void	1877	void
1935	apply_death_exp_penalty (object *op)	1878	apply_death_exp_penalty (object *op)
1936	{	1879	{
1937	object *tmp;
1938	sint64 loss;	1880	sint64 loss;
1939	sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */	1881	sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */
1940	sint64 level_loss; /* defined by the setting 'death_penalty_levels */	1882	sint64 level_loss; /* defined by the setting 'death_penalty_levels */
1941		1883
1942	for (tmp = op->inv; tmp; tmp = tmp->below)	1884	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1943	if (tmp->type == SKILL && tmp->stats.exp)	1885	if (tmp->type == SKILL && tmp->stats.exp)
1944	{	1886	{
1945
1946	percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100;	1887	percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100;
1947	level_loss = tmp->stats.exp - levels[MAX (0, tmp->level - settings.death_penalty_level)];	1888	level_loss = tmp->stats.exp - levels [max (0, tmp->level - settings.death_penalty_level)];
1948		1889
1949	/* With the revised exp system, you can get cases where	1890	/* With the revised exp system, you can get cases where
1950	* losing several levels would still require that you have more	1891	* losing several levels would still require that you have more
1951	* exp than you currently have - this is true if the levels	1892	* exp than you currently have - this is true if the levels
1952	* tables is a lot harder.	1893	* tables is a lot harder.
1953	*/	1894	*/
1954	if (level_loss < 0)	1895	if (level_loss < 0)
1955	level_loss = 0;	1896	level_loss = 0;
1956		1897
1957	loss = check_exp_loss (tmp, MIN (level_loss, percentage_loss));	1898	loss = check_exp_loss (tmp, min (level_loss, percentage_loss));
1958		1899
1959	tmp->stats.exp -= loss;	1900	tmp->stats.exp -= loss;
1960	player_lvl_adj (op, tmp);	1901	player_lvl_adj (op, tmp);
1961	}	1902	}
1962		1903
1963	percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;	1904	percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;
1964	level_loss = op->stats.exp - levels[MAX (0, op->level - settings.death_penalty_level)];	1905	level_loss = op->stats.exp - levels [max (0, op->level - settings.death_penalty_level)];
1965		1906
1966	if (level_loss < 0)	1907	if (level_loss < 0)
1967	level_loss = 0;	1908	level_loss = 0;
		1909
1968	loss = check_exp_loss (op, MIN (level_loss, percentage_loss));	1910	loss = check_exp_loss (op, min (level_loss, percentage_loss));
1969		1911
1970	op->stats.exp -= loss;	1912	op->stats.exp -= loss;
1971	player_lvl_adj (op, NULL);	1913	player_lvl_adj (op, NULL);
1972	}	1914	}
1973		1915

Diff Legend

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