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.19 by root, Fri Dec 22 16:34:00 2006 UTC vs.
Revision 1.122 by root, Fri Apr 30 21:00:39 2010 UTC

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

Diff Legend

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