ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/player.C

Comparing deliantra/server/server/player.C (file contents):
Revision 1.44 by root, Sat Dec 16 03:21:08 2006 UTC vs.
Revision 1.91 by root, Sun Jan 7 23:10:43 2007 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game
3		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
10	(at your option) any later version.	11	* (at your 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 GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20		21	*
21	The author can be reached via e-mail to <crossfire@schmorp.de>	22	* The author can be reached via e-mail to <crossfire@schmorp.de>
22	*/	23	*/
23		24
24	#include <global.h>	25	#include <global.h>
25	#include <pwd.h>	26	#include <pwd.h>
26	#include <sproto.h>	27	#include <sproto.h>
27	#include <sounds.h>	28	#include <sounds.h>
28	#include <living.h>	29	#include <living.h>
29	#include <object.h>	30	#include <object.h>
30	#include <spells.h>	31	#include <spells.h>
31	#include <skills.h>	32	#include <skills.h>
32		33
33	#ifdef COZY_SERVER	34	#include <algorithm>
34	extern int same_party (partylist *a, partylist *b);	35	#include <functional>
35	#endif
36		36
37	player *	37	playervec players;
38	find_player (const char *plname)
39	{
40	player *pl;
41
42	for (pl = first_player; pl != NULL; pl = pl->next)
43	{
44	if (pl->ob != NULL && !strcmp (query_name (pl->ob), plname))
45	return pl;
46	};
47	return NULL;
48	}
49
50	player *
51	find_player_partial_name (const char *plname)
52	{
53	player *pl;
54	player *found = NULL;
55	size_t namelen = strlen (plname);
56
57	for (pl = first_player; pl != NULL; pl = pl->next)
58	{
59	if ((size_t) strlen (pl->ob->name) < namelen)
60	continue;
61
62	if (!strcmp (pl->ob->name, plname))
63	return pl;
64
65	if (!strncasecmp (pl->ob->name, plname, namelen))
66	{
67	if (found)
68	return NULL;
69
70	found = pl;
71	}
72	}
73	return found;
74	}
75		38
76	void	39	void
77	display_motd (const object *op)	40	display_motd (const object *op)
78	{	41	{
79	char buf[MAX_BUF];	42	char buf[MAX_BUF];
…		…
87	return;	50	return;
88		51
89	motd[0] = '\0';	52	motd[0] = '\0';
90	size = 0;	53	size = 0;
91		54
92	while (fgets (buf, MAX_BUF, fp) != NULL)	55	while (fgets (buf, MAX_BUF, fp))
93	{	56	{
94	if (*buf == '#')	57	if (*buf == '#')
95	continue;	58	continue;
96		59
97	strncat (motd + size, buf, HUGE_BUF - size);	60	strncat (motd + size, buf, HUGE_BUF - size);
…		…
116	return;	79	return;
117		80
118	rules[0] = '\0';	81	rules[0] = '\0';
119	size = 0;	82	size = 0;
120		83
121	while (fgets (buf, MAX_BUF, fp) != NULL)	84	while (fgets (buf, MAX_BUF, fp))
122	{	85	{
123	if (*buf == '#')	86	if (*buf == '#')
124	continue;	87	continue;
125		88
126	if (size + strlen (buf) >= HUGE_BUF)	89	if (size + strlen (buf) >= HUGE_BUF)
…		…
162		125
163	if (*buf == '%')	126	if (*buf == '%')
164	{ /* send one news */	127	{ /* send one news */
165	if (size > 0)	128	if (size > 0)
166	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s", "%s\n%s", subject, news); /*send previously read news */	129	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s", "%s\n%s", subject, news); /*send previously read news */
		130
167	strcpy (subject, buf + 1);	131	strcpy (subject, buf + 1);
168	strip_endline (subject);	132	strip_endline (subject);
169	size = 0;	133	size = 0;
170	news[0] = '\0';	134	news[0] = '\0';
171	}	135	}
…		…
184	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,	148	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
185	MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", "%s\n%s", subject, news);	149	MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", "%s\n%s", subject, news);
186	close_and_delete (fp, comp);	150	close_and_delete (fp, comp);
187	}	151	}
188		152
189	int	153	/* This loads the first map an puts the player on it. */
190	playername_ok (const char *cp)	154	static void
		155	set_first_map (object *op)
191	{	156	{
192	/* Don't allow - or _ as first character in the name */	157	op->contr->maplevel = first_map_path;
193	if (*cp == '-' || *cp == '_')	158	op->x = -1;
		159	op->y = -1;
		160	}
		161
		162	void
		163	player::enter_map ()
		164	{
		165	object *tmp = object::create ();
		166
		167	EXIT_PATH (tmp) = maplevel;
		168	EXIT_X (tmp) = ob->x;
		169	EXIT_Y (tmp) = ob->y;
		170	ob->enter_exit (tmp);
		171
		172	tmp->destroy ();
		173	}
		174
		175	void
		176	player::activate ()
		177	{
		178	if (active)
194	return 0;	179	return;
195		180
196	for (; *cp != '\0'; cp++)	181	players.insert (this);
197	if (!((*cp >= 'a' && *cp <= 'z') || (*cp >= 'A' && *cp <= 'Z')) && *cp != '-' && *cp != '_')	182	ob->remove ();
		183	ob->map = 0;
		184	ob->activate_recursive ();
		185	enter_map ();
		186	}
		187
		188	void
		189	player::deactivate ()
		190	{
		191	if (!active)
198	return 0;	192	return;
199		193
200	return 1;	194	terminate_all_pets (ob);
201	}	195	ob->deactivate_recursive ();
		196	ob->remove ();
		197	ob->map = 0;
202		198
203	/* This no longer sets the player map. Also, it now updates	199	players.erase (this);
204	* all the pointers so the caller doesn't need to do that.	200	}
205	* Caller is responsible for setting the correct map.
206	*/
207		201
208	/* Redo this to do both get_player_ob and get_player.	202	// connect the player with a specific client
209	* Hopefully this will be less bugfree and simpler.	203	// also changed, rationalises, and fixes some incorrect settings
210	* Returns the player structure. If 'p' is null,	204	void
211	* we create a new one. Otherwise, we recycle	205	player::connect (client *ns)
212	* the one that is passed.
213	*/
214	static player *
215	get_player (player *p)
216	{	206	{
217	object *op = arch_to_object (get_player_archetype (0));	207	this->ns = ns;
218	int i;	208	ns->pl = this;
219		209
220	/* Clears basically the entire player structure except	210	ns->update_look = 0;
221	* for next and socket.	211	ns->look_position = 0;
		212
		213	clear_los (ob);
		214
		215	/* make sure he's a player -- needed because of class change. */
		216	ob->type = PLAYER; // we are paranoid
		217	ob->race = ob->arch->clone.race;
		218
		219	if (!legal_range (ob, shoottype))
		220	shoottype = range_none;
		221
		222	ob->carrying = sum_weight (ob);
		223	link_player_skills (ob);
		224
		225	CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
		226
		227	assign (title, ob->arch->clone.name);
		228
		229	/* can_use_shield is a new flag. However, the can_use.. seems to largely come
		230	* from the class, and not race. I don't see any way to get the class information
		231	* to then update this. I don't think this will actually break anything - anyone
		232	* that can use armour should be able to use a shield. What this may 'break'
		233	* are features new characters get, eg, if someone starts up with a Q, they
		234	* should be able to use a shield. However, old Q's won't get that advantage.
222	*/	235	*/
223	p->clear ();	236	if (QUERY_FLAG (ob, FLAG_USE_ARMOUR))
		237	SET_FLAG (ob, FLAG_USE_SHIELD);
224		238
		239	/* if it's a dragon player, set the correct title here */
		240	if (is_dragon_pl (ob))
		241	{
		242	object *tmp, *abil = 0, *skin = 0;
		243
		244	shstr_cmp dragon_ability_force ("dragon_ability_force");
		245	shstr_cmp dragon_skin_force ("dragon_skin_force");
		246
		247	for (tmp = ob->inv; tmp; tmp = tmp->below)
		248	if (tmp->type == FORCE)
		249	if (tmp->arch->name == dragon_ability_force)
		250	abil = tmp;
		251	else if (tmp->arch->name == dragon_skin_force)
		252	skin = tmp;
		253
		254	set_dragon_name (ob, abil, skin);
		255	}
		256
		257	CLEAR_FLAG (ob, FLAG_FRIENDLY);
		258	add_friendly_object (ob);
		259
		260	new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
		261
		262	esrv_new_player (this, ob->weight + ob->carrying);
		263
		264	ob->update_stats ();
		265	ns->floorbox_update ();
		266
		267	esrv_send_inventory (ob, ob);
		268	esrv_add_spells (this, 0);
		269
		270	activate ();
		271
		272	send_rules (ob);
		273	send_news (ob);
		274	display_motd (ob);
		275
		276	INVOKE_PLAYER (CONNECT, this);
		277	INVOKE_PLAYER (LOGIN, this);
		278	}
		279
		280	void
		281	player::disconnect ()
		282	{
		283	if (ns)
		284	{
		285	if (active)
		286	INVOKE_PLAYER (LOGOUT, this, ARG_INT (0));
		287
		288	INVOKE_PLAYER (DISCONNECT, this);
		289
		290	ns->pl = 0;
		291	this->ns = 0;
		292	}
		293
		294	deactivate ();
		295	}
		296
		297	// the need for this function can be explained
		298	// by load_object not returning the object
		299	void
		300	player::set_object (object *op)
		301	{
		302	ob = op;
		303	ob->contr = this; /* this aren't yet in archetype */
		304
		305	ob->speed_left = 0.5;
		306	ob->speed = 1.0;
		307	ob->direction = 5; /* So player faces south */
		308	ob->stats.wc = 2;
		309	ob->run_away = 25; /* Then we panick... */
		310
		311	ob->roll_stats ();
		312	}
		313
		314	player::player ()
		315	{
225	/* There are some elements we want initialized to non zero value -	316	/* There are some elements we want initialised to non zero value -
226	* we deal with that below this point.	317	* we deal with that below this point.
227	*/	318	*/
228	p->party = NULL;
229	p->outputs_sync = 16; /* Every 2 seconds */	319	outputs_sync = 16; /* Every 2 seconds */
230	p->outputs_count = 8; /* Keeps present behaviour */	320	outputs_count = 8; /* Keeps present behaviour */
231	p->unapply = unapply_nochoice;	321	unapply = unapply_nochoice;
232	p->Swap_First = -1;
233		322
234	#ifdef AUTOSAVE
235	p->last_save_tick = 9999999;
236	#endif
237
238	strcpy (p->savebed_map, first_map_path); /* Init. respawn position */	323	savebed_map = first_map_path; /* Init. respawn position */
239		324
240	op->contr = p; /* this aren't yet in archetype */
241	p->ob = op;
242	op->speed_left = 0.5;
243	op->speed = 1.0;
244	op->direction = 5; /* So player faces south */
245	op->stats.wc = 2;
246	op->run_away = 25; /* Then we panick... */
247
248	{
249	int oldmon = p->socket->monitor_spells; // what a hack
250	p->socket->monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */
251	roll_stats (op);
252	p->socket->monitor_spells = oldmon;
253	}
254	p->state = ST_ROLL_STAT;
255	clear_los (op);
256
257	p->gen_sp_armour = 10;	325	gen_sp_armour = 10;
258	p->last_speed = -1;	326	last_speed = -1;
259	p->shoottype = range_none;	327	shoottype = range_none;
260	p->bowtype = bow_normal;	328	bowtype = bow_normal;
261	p->petmode = pet_normal;	329	petmode = pet_normal;
262	p->listening = 10;	330	listening = 10;
263	p->usekeys = containers;	331	usekeys = containers;
264	p->last_weapon_sp = -1;	332	last_weapon_sp = -1;
265	p->peaceful = 1; /* default peaceful */	333	peaceful = 1; /* default peaceful */
266	p->do_los = 1;	334	do_los = 1;
267	p->explore = 0;
268	p->no_shout = 0; /* default can shout */
269
270	assign (p->title, op->arch->clone.name);
271	op->race = op->arch->clone.race;
272
273	CLEAR_FLAG (op, FLAG_READY_SKILL);
274		335
275	/* we need to clear these to -1 and not zero - otherwise,	336	/* we need to clear these to -1 and not zero - otherwise,
276	* if a player quits and starts a new character, we wont	337	* if a player quits and starts a new character, we wont
277	* send new values to the client, as things like exp start	338	* send new values to the client, as things like exp start
278	* at zero.	339	* at zero.
279	*/	340	*/
280	for (i = 0; i < NUM_SKILLS; i++)	341	for (int i = 0; i < NUM_SKILLS; i++)
281	{
282	p->last_skill_exp[i] = -1;	342	last_skill_exp[i] = -1;
283	p->last_skill_ob[i] = NULL;
284	}
285		343
286	for (i = 0; i < NROFATTACKS; i++)	344	for (int i = 0; i < NROFATTACKS; i++)
287	p->last_resist[i] = -1;	345	last_resist[i] = -1;
288		346
289	p->last_stats.exp = -1;	347	last_stats.exp = -1;
290	p->last_weight = (uint32) - 1;	348	last_weight = (uint32) - 1;
291
292	p->socket->update_look = 0;
293	p->socket->look_position = 0;
294
295	return p;
296	}	349	}
297		350
298	/* This loads the first map an puts the player on it. */	351	void
299	static void	352	player::do_destroy ()
300	set_first_map (object *op)
301	{	353	{
302	strcpy (op->contr->maplevel, first_map_path);	354	disconnect ();
303	op->x = -1;
304	op->y = -1;
305	enter_exit (op, NULL);
306	}
307		355
		356	attachable::do_destroy ();
		357
		358	if (ob)
		359	{
		360	ob->destroy_inv (false);
		361	ob->destroy ();
		362	}
		363	}
		364
		365	player::~player ()
		366	{
		367	/* Clear item stack */
		368	free (stack_items);
		369	}
		370
308	/* Tries to add player on the connection passwd in ns.	371	/* Tries to add player on the connection passed in ns.
309	* All we can really get in this is some settings like host and display	372	* All we can really get in this is some settings like host and display
310	* mode.	373	* mode.
311	*/	374	*/
312		375	player *
313	int	376	player::create ()
314	add_player (client *ns)
315	{	377	{
316	player *p = new player;	378	player *pl = new player;
317		379
318	p->socket = ns;	380	pl->set_object (arch_to_object (get_player_archetype (0)));
319	ns->pl = p;
320
321	p->next = first_player;
322	first_player = p;
323
324	p = get_player (p);
325
326	set_first_map (p->ob);	381	set_first_map (pl->ob);
327		382
328	CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
329	add_friendly_object (p->ob);
330	send_rules (p->ob);
331	send_news (p->ob);
332	display_motd (p->ob);
333	get_name (p->ob);
334
335	return 0;	383	return pl;
336	}	384	}
337		385
338	/*	386	/*
339	* get_player_archetype() return next player archetype from archetype	387	* get_player_archetype() return next player archetype from archetype
340	* list. Not very efficient routine, but used only creating new players.	388	* list. Not very efficient routine, but used only creating new players.
…		…
349	{	397	{
350	if (at == NULL || at->next == NULL)	398	if (at == NULL || at->next == NULL)
351	at = first_archetype;	399	at = first_archetype;
352	else	400	else
353	at = at->next;	401	at = at->next;
		402
354	if (at->clone.type == PLAYER)	403	if (at->clone.type == PLAYER)
355	return at;	404	return at;
		405
356	if (at == start)	406	if (at == start)
357	{	407	{
358	LOG (llevError, "No Player archetypes\n");	408	LOG (llevError, "No Player archetypes\n");
359	exit (-1);	409	exit (-1);
360	}	410	}
361	}	411	}
362	}	412	}
363		413
364
365	object *	414	object *
366	get_nearest_player (object *mon)	415	get_nearest_player (object *mon)
367	{	416	{
368	object *op = NULL;	417	object *op = NULL;
369	player *pl = NULL;
370	objectlink *ol;	418	objectlink *ol;
371	unsigned lastdist;	419	unsigned lastdist;
372	rv_vector rv;	420	rv_vector rv;
373		421
374	for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next)	422	for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next)
…		…
406	{	454	{
407	op = ol->ob;	455	op = ol->ob;
408	lastdist = rv.distance;	456	lastdist = rv.distance;
409	}	457	}
410	}	458	}
411	for (pl = first_player; pl != NULL; pl = pl->next)	459
412	{	460	for_all_players (pl)
413	if (can_detect_enemy (mon, pl->ob, &rv))	461	if (can_detect_enemy (mon, pl->ob, &rv))
414	{
415
416	if (lastdist > rv.distance)	462	if (lastdist > rv.distance)
417	{	463	{
418	op = pl->ob;	464	op = pl->ob;
419	lastdist = rv.distance;	465	lastdist = rv.distance;
420	}	466	}
421	}	467
422	}
423	#if 0	468	#if 0
424	LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");	469	LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");
425	#endif	470	#endif
426	return op;	471	return op;
427	}	472	}
…		…
445	* circling behaviour. Unfortunately, this function is also used to determined	490	* circling behaviour. Unfortunately, this function is also used to determined
446	* if the creature should cast a spell, so returning a direction in that case	491	* if the creature should cast a spell, so returning a direction in that case
447	* is probably not a good thing.	492	* is probably not a good thing.
448	*/	493	*/
449	#define MAX_SPACES 50	494	#define MAX_SPACES 50
450
451		495
452	/*	496	/*
453	* Returns the direction to the player, if valid. Returns 0 otherwise.	497	* Returns the direction to the player, if valid. Returns 0 otherwise.
454	* modified to verify there is a path to the player. Does this by stepping towards	498	* modified to verify there is a path to the player. Does this by stepping towards
455	* player and if path is blocked then see if blockage is close enough to player that	499	* player and if path is blocked then see if blockage is close enough to player that
…		…
694	/* Need to set up the skill pointers */	738	/* Need to set up the skill pointers */
695	link_player_skills (pl);	739	link_player_skills (pl);
696	}	740	}
697		741
698	void	742	void
699	get_name (object *op)
700	{
701	op->contr->write_buf[0] = '\0';
702	op->contr->state = ST_GET_NAME;
703	send_query (op->contr->socket, 0, "What is your name?\n:");
704	}
705
706	void
707	get_password (object *op)
708	{
709	op->contr->write_buf[0] = '\0';
710	op->contr->state = ST_GET_PASSWORD;
711	send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
712	}
713
714	void
715	play_again (object *op)
716	{
717	op->contr->state = ST_PLAY_AGAIN;
718	op->chosen_skill = NULL;
719	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
720	/* a bit of a hack, but there are various places early in th
721	* player creation process that a user can quit (eg, roll
722	* stats) that isn't removing the player. Taking a quick
723	* look, there are many places that call play_again without
724	* removing the player - it probably makes more sense
725	* to leave it to play_again to remove the object in all
726	* cases.
727	*/
728	if (!QUERY_FLAG (op, FLAG_REMOVED))
729	op->remove ();
730	/* Need to set this to null - otherwise, it could point to garbage,
731	* and draw() doesn't check to see if the player is removed, only if
732	* the map is null or not swapped out.
733	*/
734	op->map = NULL;
735	}
736
737	int
738	receive_play_again (object *op, char key)
739	{
740	if (key == 'q' || key == 'Q')
741	{
742	remove_friendly_object (op);
743	leave (op->contr, 0); /* ericserver will draw the message */
744	return 2;
745	}
746	else if (key == 'a' || key == 'A')
747	{
748	player *pl = op->contr;
749	shstr name = op->name;
750
751	op->contr = 0;
752	op->type = 0;
753	op->destroy (1);
754	pl = get_player (pl);
755	op = pl->ob;
756	add_friendly_object (op);
757	op->contr->password[0] = '~';
758	op->name = op->name_pl = 0;
759	/* Lets put a space in here */
760	new_draw_info (NDI_UNIQUE, 0, op, "\n");
761	get_name (op);
762	op->name = op->name_pl = name;
763	set_first_map (op);
764	}
765	else
766	/* user pressed something else so just ask again... */
767	play_again (op);
768
769	return 0;
770	}
771
772	void
773	confirm_password (object *op)
774	{
775
776	op->contr->write_buf[0] = '\0';
777	op->contr->state = ST_CONFIRM_PASSWORD;
778	send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
779	}
780
781	void
782	get_party_password (object *op, partylist *party)	743	get_party_password (object *op, partylist *party)
783	{	744	{
784	if (party == NULL)	745	if (party == NULL)
785	{	746	{
786	LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);	747	LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);
787	return;	748	return;
788	}	749	}
		750
789	op->contr->write_buf[0] = '\0';	751	op->contr->write_buf[0] = '\0';
790	op->contr->state = ST_GET_PARTY_PASSWORD;	752	op->contr->ns->state = ST_GET_PARTY_PASSWORD;
791	op->contr->party_to_join = party;	753	op->contr->party_to_join = party;
792	send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:");	754	send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:");
793	}	755	}
794
795		756
796	/* This rolls four 1-6 rolls and sums the best 3 of the 4. */	757	/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
797	int	758	static int
798	roll_stat (void)	759	roll_stat (void)
799	{	760	{
800	int a[4], i, j, k;	761	int a[4], i, j, k;
801		762
802	for (i = 0; i < 4; i++)	763	for (i = 0; i < 4; i++)
…		…
805	for (i = 0, j = 0, k = 7; i < 4; i++)	766	for (i = 0, j = 0, k = 7; i < 4; i++)
806	if (a[i] < k)	767	if (a[i] < k)
807	k = a[i], j = i;	768	k = a[i], j = i;
808		769
809	for (i = 0, k = 0; i < 4; i++)	770	for (i = 0, k = 0; i < 4; i++)
810	{
811	if (i != j)	771	if (i != j)
812	k += a[i];	772	k += a[i];
813	}	773
814	return k;	774	return k;
815	}	775	}
816		776
817	void	777	void
818	roll_stats (object *op)	778	object::roll_stats ()
819	{	779	{
820	int sum = 0;
821	int i = 0, j = 0;
822	int statsort[7];	780	int statsort [7];
823		781
824	do	782	for (;;)
825	{
826	op->stats.Str = roll_stat ();
827	op->stats.Dex = roll_stat ();
828	op->stats.Int = roll_stat ();
829	op->stats.Con = roll_stat ();
830	op->stats.Wis = roll_stat ();
831	op->stats.Pow = roll_stat ();
832	op->stats.Cha = roll_stat ();
833	sum = op->stats.Str + op->stats.Dex + op->stats.Int + op->stats.Con + op->stats.Wis + op->stats.Pow + op->stats.Cha;
834	}	783	{
835	while (sum < 82 || sum > 116);	784	int sum = 0;
		785	for (int i = 7; i--; )
		786	sum += statsort [i] = roll_stat ();
836		787
		788	if (sum >= 82 && sum <= 116)
		789	break;
		790	}
		791
837	/* Sort the stats so that rerolling is easier... */	792	// Sort the stats so that rerolling is easier...
838	statsort[0] = op->stats.Str;	793	std::sort (statsort, statsort + 7, std::greater<int>());
839	statsort[1] = op->stats.Dex;
840	statsort[2] = op->stats.Int;
841	statsort[3] = op->stats.Con;
842	statsort[4] = op->stats.Wis;
843	statsort[5] = op->stats.Pow;
844	statsort[6] = op->stats.Cha;
845		794
846	/* a quick and dirty bubblesort? */
847	do
848	{
849	if (statsort[i] < statsort[i + 1])
850	{
851	j = statsort[i];
852	statsort[i] = statsort[i + 1];
853	statsort[i + 1] = j;
854	i = 0;
855	}
856	else
857	{
858	i++;
859	}
860	}
861	while (i < 6);
862
863	op->stats.Str = statsort[0];	795	stats.Str = statsort[0];
864	op->stats.Dex = statsort[1];	796	stats.Dex = statsort[1];
865	op->stats.Con = statsort[2];	797	stats.Con = statsort[2];
866	op->stats.Int = statsort[3];	798	stats.Int = statsort[3];
867	op->stats.Wis = statsort[4];	799	stats.Wis = statsort[4];
868	op->stats.Pow = statsort[5];	800	stats.Pow = statsort[5];
869	op->stats.Cha = statsort[6];	801	stats.Cha = statsort[6];
870		802
871
872	op->contr->orig_stats.Str = op->stats.Str;
873	op->contr->orig_stats.Dex = op->stats.Dex;
874	op->contr->orig_stats.Int = op->stats.Int;
875	op->contr->orig_stats.Con = op->stats.Con;
876	op->contr->orig_stats.Wis = op->stats.Wis;
877	op->contr->orig_stats.Pow = op->stats.Pow;
878	op->contr->orig_stats.Cha = op->stats.Cha;
879
880	op->level = 1;
881	op->stats.exp = 0;	803	stats.exp = 0;
882	op->stats.ac = 0;	804	stats.ac = 0;
883		805
884	op->contr->levhp[1] = 9;
885	op->contr->levsp[1] = 6;
886	op->contr->levgrace[1] = 3;
887
888	fix_player (op);
889	op->stats.hp = op->stats.maxhp;	806	stats.hp = stats.maxhp;
890	op->stats.sp = op->stats.maxsp;	807	stats.sp = stats.maxsp;
891	op->stats.grace = op->stats.maxgrace;	808	stats.grace = stats.maxgrace;
		809
		810	if (contr)
		811	{
		812	contr->levhp[1] = 9;
		813	contr->levsp[1] = 6;
		814	contr->levgrace[1] = 3;
		815
892	op->contr->orig_stats = op->stats;	816	contr->orig_stats = stats;
		817	}
893	}	818	}
894		819
895	void	820	void
896	Roll_Again (object *op)	821	object::swap_stats (int a, int b)
897	{	822	{
898	esrv_new_player (op->contr, 0);	823	int tmp = get_attr_value (&contr->orig_stats, a);
899	send_query (op->contr->socket, CS_QUERY_SINGLECHAR,	824	set_attr_value (&contr->orig_stats, a, get_attr_value (&contr->orig_stats, b));
900	"[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? ");	825	set_attr_value (&contr->orig_stats, b, tmp);
901	}
902		826
903	void	827	stats.Str = contr->orig_stats.Str;
904	Swap_Stat (object *op, int Swap_Second)	828	stats.Dex = contr->orig_stats.Dex;
		829	stats.Con = contr->orig_stats.Con;
		830	stats.Int = contr->orig_stats.Int;
		831	stats.Wis = contr->orig_stats.Wis;
		832	stats.Pow = contr->orig_stats.Pow;
		833	stats.Cha = contr->orig_stats.Cha;
		834
		835	//TODO: the following code looks so borked and should, at the very least,
		836	// be merged with the similar code in roll_stats
		837	stats.ac = 0;
		838
		839	level = 1;
		840	stats.exp = 0;
		841	stats.ac = 0;
		842
		843	stats.hp = stats.maxhp;
		844	stats.sp = stats.maxsp;
		845	stats.grace = stats.maxgrace;
		846
		847	if (contr)
		848	{
		849	contr->levhp[1] = 9;
		850	contr->levsp[1] = 6;
		851	contr->levgrace[1] = 3;
		852
		853	contr->orig_stats = stats;
		854	}
		855	}
		856
		857	static void
		858	start_info (object *op)
905	{	859	{
906	signed char tmp;
907	char buf[MAX_BUF];	860	char buf[MAX_BUF];
908		861
909	if (op->contr->Swap_First == -1)	862	sprintf (buf, "Welcome to Crossfire v%s!", VERSION);
910	{
911	new_draw_info (NDI_UNIQUE, 0, op, "How the hell did you get here?!?!!!");
912	new_draw_info (NDI_UNIQUE, 0, op, "Error in Swap_Stat code,");
913	new_draw_info (NDI_UNIQUE, 0, op, "mail korg@rdt.monash.edu.au");
914	return;
915	}
916
917	tmp = get_attr_value (&op->contr->orig_stats, op->contr->Swap_First);
918
919	set_attr_value (&op->contr->orig_stats, op->contr->Swap_First, get_attr_value (&op->contr->orig_stats, Swap_Second));
920
921	set_attr_value (&op->contr->orig_stats, Swap_Second, tmp);
922
923	sprintf (buf, "%s done\n", short_stat_name[Swap_Second]);
924	new_draw_info (NDI_UNIQUE, 0, op, buf);	863	new_draw_info (NDI_UNIQUE, 0, op, buf);
925	op->stats.Str = op->contr->orig_stats.Str;	864	//new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
926	op->stats.Dex = op->contr->orig_stats.Dex;
927	op->stats.Con = op->contr->orig_stats.Con;
928	op->stats.Int = op->contr->orig_stats.Int;
929	op->stats.Wis = op->contr->orig_stats.Wis;
930	op->stats.Pow = op->contr->orig_stats.Pow;
931	op->stats.Cha = op->contr->orig_stats.Cha;
932	op->stats.ac = 0;
933
934	op->level = 1;
935	op->stats.exp = 0;
936	op->stats.ac = 0;
937
938	op->contr->levhp[1] = 9;
939	op->contr->levsp[1] = 6;
940	op->contr->levgrace[1] = 3;
941
942	fix_player (op);
943	op->stats.hp = op->stats.maxhp;
944	op->stats.sp = op->stats.maxsp;
945	op->stats.grace = op->stats.maxgrace;
946	op->contr->orig_stats = op->stats;
947	op->contr->Swap_First = -1;
948	}
949
950
951	/* This code has been greatly reduced, because with set_attr_value
952	* and get_attr_value, the stats can be accessed just numeric
953	* ids. stat_trans is a table that translate the number entered
954	* into the actual stat. It is needed because the order the stats
955	* are displayed in the stat window is not the same as how
956	* the number's access that stat. The table does that translation.
957	*/
958	int
959	key_roll_stat (object *op, char key)
960	{
961	int keynum = key - '0';
962	char buf[MAX_BUF];
963	static sint8 stat_trans[] = { -1, STR, DEX, CON, INT, WIS, POW, CHA };
964
965	if (keynum > 0 && keynum <= 7)
966	{
967	if (op->contr->Swap_First == -1)
968	{
969	op->contr->Swap_First = stat_trans[keynum];
970	sprintf (buf, "%s ->", short_stat_name[stat_trans[keynum]]);
971	new_draw_info (NDI_UNIQUE, 0, op, buf);	865	//new_draw_info (NDI_UNIQUE, 0, op, " ");
972	}
973	else
974	Swap_Stat (op, stat_trans[keynum]);
975
976	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
977	return 1;
978	}
979	switch (key)
980	{
981	case 'n':
982	case 'N':
983	{
984	SET_FLAG (op, FLAG_WIZ);
985	if (op->map == NULL)
986	{
987	LOG (llevError, "Map == NULL in state 2\n");
988	break;
989	}
990
991	#if 0
992	/* So that enter_exit will put us at startx/starty */
993	op->x = -1;
994
995	enter_exit (op, NULL);
996	#endif
997	SET_ANIMATION (op, 2); /* So player faces south */
998	/* Enter exit adds a player otherwise */
999	add_statbonus (op);
1000	send_query (op->contr->socket, CS_QUERY_SINGLECHAR,
1001	"Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
1002	op->contr->state = ST_CHANGE_CLASS;
1003	if (op->msg)
1004	new_draw_info (NDI_BLUE, 0, op, op->msg);
1005	return 0;
1006	}
1007	case 'y':
1008	case 'Y':
1009	roll_stats (op);
1010	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
1011	return 1;
1012
1013	case 'q':
1014	case 'Q':
1015	play_again (op);
1016	return 1;
1017
1018	default:
1019	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1020	return 0;
1021	}
1022	return 0;
1023	}	866	}
1024		867
1025	/* This function takes the key that is passed, and does the	868	/* This function takes the key that is passed, and does the
1026	* appropriate action with it (change race, or other things).	869	* appropriate action with it (change race, or other things).
1027	* The function name is for historical reasons - now we have	870	* The function name is for historical reasons - now we have
1028	* separate race and class; this actually changes the RACE,	871	* separate race and class; this actually changes the RACE,
1029	* not the class.	872	* not the class.
1030	*/	873	*/
1031
1032	int	874	int
1033	key_change_class (object *op, char key)	875	key_change_class (object *op, char key)
1034	{	876	{
1035	int tmp_loop;	877	int tmp_loop;
1036		878
1037	if (key == 'q' || key == 'Q')
1038	{
1039	op->remove ();
1040	play_again (op);
1041	return 0;
1042	}
1043	if (key == 'd' || key == 'D')	879	if (key == 'd' || key == 'D')
1044	{	880	{
1045	char buf[MAX_BUF];	881	char buf[MAX_BUF];
1046		882
1047	/* this must before then initial items are given */	883	/* this must before then initial items are given */
…		…
1052	create_treasure (tl, op, 0, 0, 0);	888	create_treasure (tl, op, 0, 0, 0);
1053		889
1054	INVOKE_PLAYER (BIRTH, op->contr);	890	INVOKE_PLAYER (BIRTH, op->contr);
1055	INVOKE_PLAYER (LOGIN, op->contr);	891	INVOKE_PLAYER (LOGIN, op->contr);
1056		892
1057	op->contr->state = ST_PLAYING;	893	op->contr->ns->state = ST_PLAYING;
1058		894
1059	if (op->msg)	895	if (op->msg)
1060	op->msg = NULL;	896	op->msg = NULL;
1061		897
1062	/* We create this now because some of the unique maps will need it	898	/* We create this now because some of the unique maps will need it
…		…
1071	start_info (op);	907	start_info (op);
1072	CLEAR_FLAG (op, FLAG_WIZ);	908	CLEAR_FLAG (op, FLAG_WIZ);
1073	give_initial_items (op, op->randomitems);	909	give_initial_items (op, op->randomitems);
1074	link_player_skills (op);	910	link_player_skills (op);
1075	esrv_send_inventory (op, op);	911	esrv_send_inventory (op, op);
1076	fix_player (op);	912	op->update_stats ();
1077		913
1078	/* This moves the player to a different start map, if there	914	/* This moves the player to a different start map, if there
1079	* is one for this race	915	* is one for this race
1080	*/	916	*/
1081	if (*first_map_ext_path)	917	if (*first_map_ext_path)
1082	{	918	{
1083	object *tmp;	919	object *tmp;
1084	char mapname[MAX_BUF];	920	char mapname[MAX_BUF];
1085		921
1086	snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name);	922	snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &op->arch->name);
1087	tmp = object::create ();	923	tmp = object::create ();
1088	EXIT_PATH (tmp) = mapname;	924	EXIT_PATH (tmp) = mapname;
1089	EXIT_X (tmp) = op->x;	925	EXIT_X (tmp) = op->x;
1090	EXIT_Y (tmp) = op->y;	926	EXIT_Y (tmp) = op->y;
1091	enter_exit (op, tmp); /* we don't really care if it succeeded;	927	op->enter_exit (tmp); /* we don't really care if it succeeded;
1092	* if the map isn't there, then stay on the	928	* if the map isn't there, then stay on the
1093	* default initial map */	929	* default initial map */
1094	tmp->destroy ();	930	tmp->destroy ();
1095	}	931	}
1096	else	932	else
1097	{
1098	LOG (llevDebug, "first_map_ext_path not set\n");	933	LOG (llevDebug, "first_map_ext_path not set\n");
1099	}	934
1100	return 0;	935	return 0;
1101	}	936	}
1102		937
1103	/* Following actually changes the race - this is the default command	938	/* Following actually changes the race - this is the default command
1104	* if we don't match with one of the options above.	939	* if we don't match with one of the options above.
…		…
1108	while (!tmp_loop)	943	while (!tmp_loop)
1109	{	944	{
1110	shstr name = op->name;	945	shstr name = op->name;
1111	int x = op->x, y = op->y;	946	int x = op->x, y = op->y;
1112		947
1113	remove_statbonus (op);	948	op->remove_statbonus ();
1114	op->remove ();	949	op->remove ();
1115	op->arch = get_player_archetype (op->arch);	950	op->arch = get_player_archetype (op->arch);
1116	op->arch->clone.copy_to (op);	951	op->arch->clone.copy_to (op);
1117	op->instantiate ();	952	op->instantiate ();
1118	op->stats = op->contr->orig_stats;	953	op->stats = op->contr->orig_stats;
…		…
1120	op->x = x;	955	op->x = x;
1121	op->y = y;	956	op->y = y;
1122	SET_ANIMATION (op, 2); /* So player faces south */	957	SET_ANIMATION (op, 2); /* So player faces south */
1123	insert_ob_in_map (op, op->map, op, 0);	958	insert_ob_in_map (op, op->map, op, 0);
1124	assign (op->contr->title, op->arch->clone.name);	959	assign (op->contr->title, op->arch->clone.name);
1125	add_statbonus (op);	960	op->add_statbonus ();
1126	tmp_loop = allowed_class (op);	961	tmp_loop = allowed_class (op);
1127	}	962	}
1128		963
1129	update_object (op, UP_OBJ_FACE);	964	update_object (op, UP_OBJ_FACE);
1130	esrv_update_item (UPD_FACE, op, op);	965	esrv_update_item (UPD_FACE, op, op);
1131	fix_player (op);	966	op->update_stats ();
1132	op->stats.hp = op->stats.maxhp;	967	op->stats.hp = op->stats.maxhp;
1133	op->stats.sp = op->stats.maxsp;	968	op->stats.sp = op->stats.maxsp;
1134	op->stats.grace = 0;	969	op->stats.grace = 0;
1135		970
1136	if (op->msg)	971	if (op->msg)
1137	new_draw_info (NDI_BLUE, 0, op, op->msg);	972	new_draw_info (NDI_BLUE, 0, op, op->msg);
1138		973
1139	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");	974	send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");
1140	return 0;	975	return 0;
1141	}
1142
1143	int
1144	key_confirm_quit (object *op, char key)
1145	{
1146	char buf[MAX_BUF];
1147
1148	if (key != 'y' && key != 'Y' && key != 'q' && key != 'Q')
1149	{
1150	op->contr->state = ST_PLAYING;
1151	new_draw_info (NDI_UNIQUE, 0, op, "OK, continuing to play.");
1152	return 1;
1153	}
1154
1155	INVOKE_PLAYER (LOGOUT, op->contr);
1156	INVOKE_PLAYER (QUIT, op->contr);
1157
1158	terminate_all_pets (op);
1159	leave_map (op);
1160	op->direction = 0;
1161	new_draw_info_format (NDI_UNIQUE | NDI_ALL, 5, NULL, "%s quits the game.", &op->name);
1162
1163	strcpy (op->contr->killer, "quit");
1164	check_score (op);
1165	op->contr->party = NULL;
1166	if (settings.set_title == TRUE)
1167	op->contr->own_title[0] = '\0';
1168
1169	if (!QUERY_FLAG (op, FLAG_WAS_WIZ))
1170	{
1171	maptile *mp, *next;
1172
1173	/* We need to hunt for any per player unique maps in memory and
1174	* get rid of them. The trailing slash in the path is intentional,
1175	* so that players named 'Ab' won't match against players 'Abe' pathname
1176	*/
1177	sprintf (buf, "%s/%s/%s/", settings.localdir, settings.playerdir, &op->name);
1178	for (mp = first_map; mp != NULL; mp = next)
1179	{
1180	next = mp->next;
1181	if (!strncmp (mp->path, buf, strlen (buf)))
1182	delete_map (mp);
1183	}
1184
1185	delete_character (op->name, 1);
1186	}
1187
1188	play_again (op);
1189	return 1;
1190	}	976	}
1191		977
1192	void	978	void
1193	flee_player (object *op)	979	flee_player (object *op)
1194	{	980	{
…		…
1224	{	1010	{
1225	op->enemy = NULL;	1011	op->enemy = NULL;
1226	CLEAR_FLAG (op, FLAG_SCARED);	1012	CLEAR_FLAG (op, FLAG_SCARED);
1227	return;	1013	return;
1228	}	1014	}
		1015
1229	get_rangevector (op, op->enemy, &rv, 0);	1016	get_rangevector (op, op->enemy, &rv, 0);
1230		1017
1231	dir = absdir (4 + rv.direction);	1018	dir = absdir (4 + rv.direction);
1232	for (diff = 0; diff < 3; diff++)	1019	for (diff = 0; diff < 3; diff++)
1233	{	1020	{
1234	int m = 1 - (RANDOM () & 2);	1021	int m = 1 - (RANDOM () & 2);
1235		1022
1236	if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))	1023	if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))
1237	{
1238	return;	1024	return;
1239	}
1240	}	1025	}
		1026
1241	/* Cornered, get rid of scared */	1027	/* Cornered, get rid of scared */
1242	CLEAR_FLAG (op, FLAG_SCARED);	1028	CLEAR_FLAG (op, FLAG_SCARED);
1243	op->enemy = NULL;	1029	op->enemy = NULL;
1244	}	1030	}
1245		1031
…		…
1331	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1117	sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1332	&tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));	1118	&tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1333	else	1119	else
1334	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1120	sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1335	&tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));	1121	&tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
		1122
1336	new_draw_info (NDI_UNIQUE, 0, op, putstring);	1123	new_draw_info (NDI_UNIQUE, 0, op, putstring);
1337
1338	sprintf (putstring, "...flags: ");
1339	for (k = 0; k < 4; k++)
1340	{
1341	for (j = 0; j < 32; j++)
1342	{
1343	if ((tmp->flags[k] >> j) & 0x01)
1344	{
1345	sprintf (tmpstr, "%d ", k * 32 + j);
1346	strcat (putstring, tmpstr);
1347	}
1348	}
1349	}
1350	new_draw_info (NDI_UNIQUE, 0, op, putstring);
1351
1352	#if 0
1353	/* print the flags too */
1354	for (k = 0; k < 4; k++)
1355	{
1356	fprintf (stderr, "%d [%d] ", k, k * 32 + 31);
1357	for (j = 0; j < 32; j++)
1358	{
1359	fprintf (stderr, "%d", tmp->flags[k] >> (31 - j) & 0x01);
1360	if (!((j + 1) % 4))
1361	fprintf (stderr, " ");
1362	}
1363	fprintf (stderr, " [%d]\n", k * 32);
1364	}
1365	#endif
1366	}	1124	}
		1125
1367	/* philosophy:	1126	/* philosophy:
1368	* It's easy to grab an item type from a pile, as long as it's	1127	* It's easy to grab an item type from a pile, as long as it's
1369	* generic. This takes no game-time. For more detailed pickups	1128	* generic. This takes no game-time. For more detailed pickups
1370	* and selections, select-items shoul dbe used. This is a	1129	* and selections, select-items should be used. This is a
1371	* grab-as-you-run type mode that's really useful for arrows for	1130	* grab-as-you-run type mode that's really useful for arrows for
1372	* example.	1131	* example.
1373	* The drawback: right now it has no frontend, so you need to	1132	* The drawback: right now it has no frontend, so you need to
1374	* stick the bits you want into a calculator in hex mode and then	1133	* stick the bits you want into a calculator in hex mode and then
1375	* convert to decimal and then 'pickup <#>	1134	* convert to decimal and then 'pickup <#>
…		…
1801	if (!dir)	1560	if (!dir)
1802	{	1561	{
1803	new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");	1562	new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1804	return 0;	1563	return 0;
1805	}	1564	}
		1565
1806	if (op->type == PLAYER)	1566	if (op->type == PLAYER)
1807	bow = op->contr->ranges[range_bow];	1567	bow = op->contr->ranges[range_bow];
1808	else	1568	else
1809	{	1569	{
1810	for (bow = op->inv; bow; bow = bow->below)	1570	for (bow = op->inv; bow; bow = bow->below)
…		…
1818	{	1578	{
1819	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);	1579	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1820	return 0;	1580	return 0;
1821	}	1581	}
1822	}	1582	}
		1583
1823	if (!bow->race || !bow->skill)	1584	if (!bow->race || !bow->skill)
1824	{	1585	{
1825	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);	1586	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);
1826	return 0;	1587	return 0;
1827	}	1588	}
…		…
1829	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];	1590	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];
1830		1591
1831	/* penalize ROF for bestarrow */	1592	/* penalize ROF for bestarrow */
1832	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)	1593	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)
1833	bowspeed -= dex_bonus[op->stats.Dex] + 5;	1594	bowspeed -= dex_bonus[op->stats.Dex] + 5;
		1595
1834	if (bowspeed < 1)	1596	if (bowspeed < 1)
1835	bowspeed = 1;	1597	bowspeed = 1;
1836		1598
1837	if (arrow == NULL)	1599	if (arrow == NULL)
1838	{	1600	{
…		…
1844	else	1606	else
1845	CLEAR_FLAG (op, FLAG_READY_BOW);	1607	CLEAR_FLAG (op, FLAG_READY_BOW);
1846	return 0;	1608	return 0;
1847	}	1609	}
1848	}	1610	}
		1611
1849	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);	1612	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1850	if (mflags & P_OUT_OF_MAP)	1613	if (mflags & P_OUT_OF_MAP)
1851	{
1852	return 0;	1614	return 0;
1853	}	1615
1854	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)	1616	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1855	{	1617	{
1856	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1618	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1857	return 0;	1619	return 0;
1858	}	1620	}
…		…
1864	return 0;	1626	return 0;
1865	}	1627	}
1866		1628
1867	left = arrow; /* these are arrows left to the player */	1629	left = arrow; /* these are arrows left to the player */
1868	arrow = get_split_ob (arrow, 1);	1630	arrow = get_split_ob (arrow, 1);
1869	if (arrow == NULL)	1631	if (!arrow)
1870	{	1632	{
1871	new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);	1633	new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1872	return 0;	1634	return 0;
1873	}	1635	}
		1636
1874	arrow->set_owner (op);	1637	arrow->set_owner (op);
1875	arrow->skill = bow->skill;	1638	arrow->skill = bow->skill;
1876
1877	arrow->direction = dir;	1639	arrow->direction = dir;
1878	arrow->x = sx;
1879	arrow->y = sy;
1880		1640
1881	if (op->type == PLAYER)	1641	if (op->type == PLAYER)
1882	{	1642	{
1883	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;	1643	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;
1884	fix_player (op);	1644	op->update_stats ();
1885	}	1645	}
1886		1646
1887	SET_ANIMATION (arrow, arrow->direction);	1647	SET_ANIMATION (arrow, arrow->direction);
1888	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */	1648	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1889	arrow->stats.hp = arrow->stats.dam;	1649	arrow->stats.hp = arrow->stats.dam;
…		…
1899		1659
1900	/* update the speed */	1660	/* update the speed */
1901	arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?	1661	arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?
1902	0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;	1662	0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;
1903		1663
1904	if (arrow->speed < 1.0)	1664	arrow->set_speed (max (arrow->speed, 1.0));
1905	arrow->speed = 1.0;
1906	update_ob_speed (arrow);
1907	arrow->speed_left = 0;	1665	arrow->speed_left = 0;
1908		1666
1909	if (op->type == PLAYER)	1667	if (op->type == PLAYER)
1910	{	1668	{
1911	arrow->stats.wc = 20 - bow->magic - arrow->magic -	1669	arrow->stats.wc = 20 - bow->magic - arrow->magic -
…		…
1921	}	1679	}
1922		1680
1923	if (arrow->attacktype == AT_PHYSICAL)	1681	if (arrow->attacktype == AT_PHYSICAL)
1924	arrow->attacktype |= bow->attacktype;	1682	arrow->attacktype |= bow->attacktype;
1925		1683
1926	if (bow->slaying != NULL)	1684	if (bow->slaying)
1927	arrow->slaying = bow->slaying;	1685	arrow->slaying = bow->slaying;
1928		1686
1929	arrow->map = m;
1930	arrow->move_type = MOVE_FLY_LOW;	1687	arrow->move_type = MOVE_FLY_LOW;
1931	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;	1688	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1932		1689
1933	play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);	1690	play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);
1934	insert_ob_in_map (arrow, m, op, 0);	1691	m->insert (arrow, sx, sy, op);
1935		1692
1936	if (!arrow->destroyed ())	1693	if (!arrow->destroyed ())
1937	move_arrow (arrow);	1694	move_arrow (arrow);
1938		1695
1939	if (op->type == PLAYER)	1696	if (op->type == PLAYER)
…		…
1965	}	1722	}
1966	else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)	1723	else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)
1967	{	1724	{
1968	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))	1725	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))
1969	wcmod = -1;	1726	wcmod = -1;
		1727
1970	ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);	1728	ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
1971	}	1729	}
1972	else if (op->contr->bowtype == bow_threewide)	1730	else if (op->contr->bowtype == bow_threewide)
1973	{	1731	{
1974	ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);	1732	ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
…		…
2044		1802
2045	if (item->arch)	1803	if (item->arch)
2046	{	1804	{
2047	CLEAR_FLAG (item, FLAG_ANIMATE);	1805	CLEAR_FLAG (item, FLAG_ANIMATE);
2048	item->face = item->arch->clone.face;	1806	item->face = item->arch->clone.face;
2049	item->speed = 0;	1807	item->set_speed (0);
2050	update_ob_speed (item);
2051	}	1808	}
		1809
2052	if ((tmp = is_player_inv (item)))	1810	if ((tmp = item->in_player ()))
2053	esrv_update_item (UPD_ANIM, tmp, item);	1811	esrv_update_item (UPD_ANIM, tmp, item);
2054	}	1812	}
2055	}	1813	}
2056	else if (item->type == ROD || item->type == HORN)	1814	else if (item->type == ROD || item->type == HORN)
2057	{
2058	drain_rod_charge (item);	1815	drain_rod_charge (item);
2059	}
2060	}	1816	}
2061	}	1817	}
2062		1818
2063	/* Received a fire command for the player - go and do it.	1819	/* Received a fire command for the player - go and do it.
2064	*/	1820	*/
…		…
2207	* 0 otherwise	1963	* 0 otherwise
2208	*/	1964	*/
2209	static int	1965	static int
2210	player_attack_door (object *op, object *door)	1966	player_attack_door (object *op, object *door)
2211	{	1967	{
2212
2213	/* If its a door, try to find a use a key. If we do destroy the door,	1968	/* If its a door, try to find a use a key. If we do destroy the door,
2214	* might as well return immediately as there is nothing more to do -	1969	* might as well return immediately as there is nothing more to do -
2215	* otherwise, we fall through to the rest of the code.	1970	* otherwise, we fall through to the rest of the code.
2216	*/	1971	*/
2217	object *key = find_key (op, op, door);	1972	object *key = find_key (op, op, door);
…		…
2255	* It should keep the code cleaner.	2010	* It should keep the code cleaner.
2256	* When this is called, the players direction has been updated	2011	* When this is called, the players direction has been updated
2257	* (taking into account confusion.) The player is also actually	2012	* (taking into account confusion.) The player is also actually
2258	* going to try and move (not fire weapons).	2013	* going to try and move (not fire weapons).
2259	*/	2014	*/
2260
2261	void	2015	void
2262	move_player_attack (object *op, int dir)	2016	move_player_attack (object *op, int dir)
2263	{	2017	{
2264	object *tmp, *mon;	2018	object *tmp, *mon;
2265	sint16 nx, ny;	2019	sint16 nx, ny;
…		…
2267	maptile *m;	2021	maptile *m;
2268		2022
2269	nx = freearr_x[dir] + op->x;	2023	nx = freearr_x[dir] + op->x;
2270	ny = freearr_y[dir] + op->y;	2024	ny = freearr_y[dir] + op->y;
2271		2025
2272	on_battleground = op_on_battleground (op, NULL, NULL);	2026	on_battleground = op_on_battleground (op, 0, 0);
2273		2027
2274	/* If braced, or can't move to the square, and it is not out of the	2028	/* If braced, or can't move to the square, and it is not out of the
2275	* map, attack it. Note order of if statement is important - don't	2029	* map, attack it. Note order of if statement is important - don't
2276	* want to be calling move_ob if braced, because move_ob will move the	2030	* want to be calling move_ob if braced, because move_ob will move the
2277	* player. This is a pretty nasty hack, because if we could	2031	* player. This is a pretty nasty hack, because if we could
…		…
2282	*/	2036	*/
2283	if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))	2037	if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))
2284	{	2038	{
2285	if (OUT_OF_REAL_MAP (op->map, nx, ny))	2039	if (OUT_OF_REAL_MAP (op->map, nx, ny))
2286	{	2040	{
2287	m = get_map_from_coord (op->map, &nx, &ny);	2041	m = op->map->xy_find (nx, ny);
2288	if (!m)	2042	if (!m)
2289	return; /* Don't think this should happen */	2043	return; /* Don't think this should happen */
2290	}	2044	}
2291	else	2045	else
2292	m = op->map;	2046	m = op->map;
2293		2047
2294	if ((tmp = get_map_ob (m, nx, ny)) == NULL)	2048	if (!(tmp = m->at (nx, ny).bot))
2295	{
2296	/* LOG(llevError,"player_move_attack: get_map_ob returns NULL, but player can not more there.\n"); */
2297	return;	2049	return;
2298	}
2299		2050
2300	mon = NULL;	2051	mon = 0;
2301	/* Go through all the objects, and find ones of interest. Only stop if	2052	/* Go through all the objects, and find ones of interest. Only stop if
2302	* we find a monster - that is something we know we want to attack.	2053	* we find a monster - that is something we know we want to attack.
2303	* if its a door or barrel (can roll) see if there may be monsters	2054	* if its a door or barrel (can roll) see if there may be monsters
2304	* on the space	2055	* on the space
2305	*/	2056	*/
2306	while (tmp != NULL)	2057	while (tmp)
2307	{	2058	{
2308	if (tmp == op)	2059	if (tmp == op)
2309	{	2060	{
2310	tmp = tmp->above;	2061	tmp = tmp->above;
2311	continue;	2062	continue;
…		…
2321	mon = tmp;	2072	mon = tmp;
2322		2073
2323	tmp = tmp->above;	2074	tmp = tmp->above;
2324	}	2075	}
2325		2076
2326	if (mon == NULL) /* This happens anytime the player tries to move */	2077	if (!mon) /* This happens anytime the player tries to move */
2327	return; /* into a wall */	2078	return; /* into a wall */
2328		2079
2329	if (mon->head != NULL)	2080	if (mon->head)
2330	mon = mon->head;	2081	mon = mon->head;
2331		2082
2332	if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))	2083	if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
2333	if (player_attack_door (op, mon))	2084	if (player_attack_door (op, mon))
2334	return;	2085	return;
…		…
2356	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))	2107	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2357	{	2108	{
2358	/* If we're braced, we don't want to switch places with it */	2109	/* If we're braced, we don't want to switch places with it */
2359	if (op->contr->braced)	2110	if (op->contr->braced)
2360	return;	2111	return;
		2112
2361	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);	2113	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2362	(void) push_ob (mon, dir, op);	2114	(void) push_ob (mon, dir, op);
2363	if (op->contr->tmp_invis || op->hide)	2115	if (op->contr->tmp_invis || op->hide)
2364	make_visible (op);	2116	make_visible (op);
		2117
2365	return;	2118	return;
2366	}	2119	}
2367		2120
2368	/* in certain circumstances, you shouldn't attack friendly	2121	/* in certain circumstances, you shouldn't attack friendly
2369	* creatures. Note that if you are braced, you can't push	2122	* creatures. Note that if you are braced, you can't push
…		…
2371	* attack them either.	2124	* attack them either.
2372	*/	2125	*/
2373	if ((mon->type == PLAYER || mon->enemy != op) &&	2126	if ((mon->type == PLAYER || mon->enemy != op) &&
2374	(mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (	2127	(mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (
2375	#ifdef PROHIBIT_PLAYERKILL	2128	#ifdef PROHIBIT_PLAYERKILL
2376	(op->contr->peaceful	2129	(op->contr->peaceful
2377	|| (mon->type == PLAYER	2130	|| (mon->type == PLAYER
2378	&& mon->contr->	2131	&& mon->contr->
2379	peaceful)) &&	2132	peaceful)) &&
2380	#else	2133	#else
2381	op->contr->peaceful &&	2134	op->contr->peaceful &&
2382	#endif	2135	#endif
2383	!on_battleground))	2136	!on_battleground))
2384	{	2137	{
2385	if (!op->contr->braced)	2138	if (!op->contr->braced)
2386	{	2139	{
2387	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);	2140	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2388	(void) push_ob (mon, dir, op);	2141	push_ob (mon, dir, op);
2389	}	2142	}
2390	else	2143	else
2391	{
2392	new_draw_info (0, 0, op, "You withhold your attack");	2144	new_draw_info (0, 0, op, "You withhold your attack");
2393	}	2145
2394	if (op->contr->tmp_invis || op->hide)	2146	if (op->contr->tmp_invis || op->hide)
2395	make_visible (op);	2147	make_visible (op);
2396	}	2148	}
2397		2149
2398	/* If the object is a boulder or other rollable object, then	2150	/* If the object is a boulder or other rollable object, then
…		…
2409	* Way it works is like this: First, it must have some hit points	2161	* Way it works is like this: First, it must have some hit points
2410	* and be living. Then, it must be one of the following:	2162	* and be living. Then, it must be one of the following:
2411	* 1) Not a player, 2) A player, but of a different party. Note	2163	* 1) Not a player, 2) A player, but of a different party. Note
2412	* that party_number -1 is no party, so attacks can still happen.	2164	* that party_number -1 is no party, so attacks can still happen.
2413	*/	2165	*/
2414
2415	else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&	2166	else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2416	((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))	2167	((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))
2417	{	2168	{
2418		2169
2419	/* If the player hasn't hit something this tick, and does	2170	/* If the player hasn't hit something this tick, and does
…		…
2426	op->speed_left += op->speed / op->contr->weapon_sp;	2177	op->speed_left += op->speed / op->contr->weapon_sp;
2427		2178
2428	op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */	2179	op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */
2429	}	2180	}
2430		2181
2431	skill_attack (mon, op, 0, NULL, NULL);	2182	skill_attack (mon, op, 0, 0, 0);
2432		2183
2433	/* If attacking another player, that player gets automatic	2184	/* If attacking another player, that player gets automatic
2434	* hitback, and doesn't loose luck either.	2185	* hitback, and doesn't loose luck either.
2435	* Disable hitback on the battleground or if the target is	2186	* Disable hitback on the battleground or if the target is
2436	* the wiz.	2187	* the wiz.
…		…
2438	if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))	2189	if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2439	{	2190	{
2440	short luck = mon->stats.luck;	2191	short luck = mon->stats.luck;
2441		2192
2442	mon->contr->has_hit = 1;	2193	mon->contr->has_hit = 1;
2443	skill_attack (op, mon, 0, NULL, NULL);	2194	skill_attack (op, mon, 0, 0, 0);
2444	mon->stats.luck = luck;	2195	mon->stats.luck = luck;
2445	}	2196	}
		2197
2446	if (action_makes_visible (op))	2198	if (action_makes_visible (op))
2447	make_visible (op);	2199	make_visible (op);
2448	}	2200	}
2449	} /* if player should attack something */	2201	} /* if player should attack something */
2450	}	2202	}
…		…
2452	int	2204	int
2453	move_player (object *op, int dir)	2205	move_player (object *op, int dir)
2454	{	2206	{
2455	int pick;	2207	int pick;
2456		2208
2457	if (op->map == NULL || op->map->in_memory != MAP_IN_MEMORY)	2209	if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
2458	return 0;	2210	return 0;
2459		2211
2460	/* Sanity check: make sure dir is valid */	2212	/* Sanity check: make sure dir is valid */
2461	if ((dir < 0) || (dir >= 9))	2213	if ((dir < 0) || (dir >= 9))
2462	{	2214	{
2463	LOG (llevError, "move_player: invalid direction %d\n", dir);	2215	LOG (llevError, "move_player: invalid direction %d\n", dir);
2464	return 0;	2216	return 0;
2465	}	2217	}
2466		2218
2467	/* peterm: added following line */	2219	/* peterm: added following line */
2468	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)	2220	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)
2469	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	2221	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
2470		2222
2471	op->facing = dir;	2223	op->facing = dir;
2472		2224
…		…
2485		2237
2486	/* Add special check for newcs players and fire on - this way, the	2238	/* Add special check for newcs players and fire on - this way, the
2487	* server can handle repeat firing.	2239	* server can handle repeat firing.
2488	*/	2240	*/
2489	if (op->contr->fire_on || (op->contr->run_on && pick != 0))	2241	if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2490	{
2491	op->direction = dir;	2242	op->direction = dir;
2492	}
2493	else	2243	else
2494	{
2495	op->direction = 0;	2244	op->direction = 0;
2496	}	2245
2497	/* Update how the player looks. Use the facing, so direction may	2246	/* Update how the player looks. Use the facing, so direction may
2498	* get reset to zero. This allows for full animation capabilities	2247	* get reset to zero. This allows for full animation capabilities
2499	* for players.	2248	* for players.
2500	*/	2249	*/
2501	animate_object (op, op->facing);	2250	animate_object (op, op->facing);
…		…
2553		2302
2554	/* call this here - we also will call this in do_ericserver, but	2303	/* call this here - we also will call this in do_ericserver, but
2555	* the players time has been increased when doericserver has been	2304	* the players time has been increased when doericserver has been
2556	* called, so we recheck it here.	2305	* called, so we recheck it here.
2557	*/	2306	*/
2558	op->contr->socket->handle_command ();	2307	if (op->contr->ns->handle_command ())
		2308	return 1;
		2309
2559	if (op->speed_left < 0)	2310	if (op->speed_left > 0)
2560	return 0;	2311	{
2561
2562	if (op->direction && (op->contr->run_on || op->contr->fire_on))	2312	if (op->direction && (op->contr->run_on || op->contr->fire_on))
2563	{	2313	{
2564	/* All move commands take 1 tick, at least for now */	2314	/* All move commands take 1 tick, at least for now */
2565	op->speed_left--;	2315	op->speed_left--;
2566		2316
2567	/* Instead of all the stuff below, let move_player take care	2317	/* Instead of all the stuff below, let move_player take care
2568	* of it. Also, some of the skill stuff is only put in	2318	* of it. Also, some of the skill stuff is only put in
2569	* there, as well as the confusion stuff.	2319	* there, as well as the confusion stuff.
2570	*/	2320	*/
2571	move_player (op, op->direction);	2321	move_player (op, op->direction);
2572	if (op->speed_left > 0)	2322
2573	return 1;	2323	return op->speed_left > 0;
2574	else	2324	}
2575	return 0;
2576	}	2325	}
2577		2326
2578	return 0;	2327	return 0;
2579	}	2328	}
2580		2329
…		…
2600	op->stats.hp = op->stats.maxhp;	2349	op->stats.hp = op->stats.maxhp;
2601		2350
2602	if (op->stats.food < 0)	2351	if (op->stats.food < 0)
2603	op->stats.food = 999;	2352	op->stats.food = 999;
2604		2353
2605	fix_player (op);	2354	op->update_stats ();
2606	return 1;	2355	return 1;
2607	}	2356	}
2608		2357
2609	LOG (llevError, "Error: LIFESAVE set without applied object.\n");	2358	LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2610	CLEAR_FLAG (op, FLAG_LIFESAVE);	2359	CLEAR_FLAG (op, FLAG_LIFESAVE);
…		…
2622	{	2371	{
2623	object *next;	2372	object *next;
2624		2373
2625	while (op)	2374	while (op)
2626	{	2375	{
2627	next = op->below; /* Make sure we have a good value, in case	2376	object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2628	* we remove object 'op'	2377
2629	*/
2630	if (QUERY_FLAG (op, FLAG_UNPAID))	2378	if (QUERY_FLAG (op, FLAG_UNPAID))
2631	{	2379	{
2632	op->remove ();
2633	op->x = env->x;
2634	op->y = env->y;
2635	if (env->type == PLAYER)	2380	if (env->type == PLAYER)
2636	esrv_del_item (env->contr, op->count);	2381	esrv_del_item (env->contr, op->count);
2637	insert_ob_in_map (op, env->map, NULL, 0);	2382
		2383	op->insert_at (env);
2638	}	2384	}
2639	else if (op->inv)	2385	else if (op->inv)
2640	remove_unpaid_objects (op->inv, env);	2386	remove_unpaid_objects (op->inv, env);
2641		2387
2642	op = next;	2388	op = next;
2643	}	2389	}
2644	}	2390	}
2645
2646		2391
2647	/*	2392	/*
2648	* Returns pointer a static string containing gravestone text	2393	* Returns pointer a static string containing gravestone text
2649	* Moved from apply.c to player.c - player.c is what	2394	* Moved from apply.c to player.c - player.c is what
2650	* actually uses this function. player.c may not be quite the	2395	* actually uses this function. player.c may not be quite the
…		…
2684	strncat (buf2, " ", 20 - strlen (buf) / 2);	2429	strncat (buf2, " ", 20 - strlen (buf) / 2);
2685	strcat (buf2, buf);	2430	strcat (buf2, buf);
2686		2431
2687	return buf2;	2432	return buf2;
2688	}	2433	}
2689
2690
2691		2434
2692	void	2435	void
2693	do_some_living (object *op)	2436	do_some_living (object *op)
2694	{	2437	{
2695	int last_food = op->stats.food;	2438	int last_food = op->stats.food;
…		…
2704	const int max_grace = 1;	2447	const int max_grace = 1;
2705		2448
2706	if (op->contr->outputs_sync)	2449	if (op->contr->outputs_sync)
2707	{	2450	{
2708	for (i = 0; i < NUM_OUTPUT_BUFS; i++)	2451	for (i = 0; i < NUM_OUTPUT_BUFS; i++)
2709	if (op->contr->outputs[i].buf != NULL && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks)	2452	if (op->contr->outputs[i].buf && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks)
2710	flush_output_element (op, &op->contr->outputs[i]);	2453	flush_output_element (op, &op->contr->outputs[i]);
2711	}	2454	}
2712		2455
2713	if (op->contr->state == ST_PLAYING)	2456	if (op->contr->ns->state == ST_PLAYING)
2714	{	2457	{
2715
2716	/* these next three if clauses make it possible to SLOW DOWN	2458	/* these next three if clauses make it possible to SLOW DOWN
2717	hp/grace/spellpoint regeneration. */	2459	hp/grace/spellpoint regeneration. */
2718	if (op->contr->gen_hp >= 0)	2460	if (op->contr->gen_hp >= 0)
2719	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;	2461	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2720	else	2462	else
2721	{	2463	{
2722	gen_hp = op->stats.maxhp;	2464	gen_hp = op->stats.maxhp;
2723	rate_hp -= rate_hp / 2 * op->contr->gen_hp;	2465	rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2724	}	2466	}
		2467
2725	if (op->contr->gen_sp >= 0)	2468	if (op->contr->gen_sp >= 0)
2726	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;	2469	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2727	else	2470	else
2728	{	2471	{
2729	gen_sp = op->stats.maxsp;	2472	gen_sp = op->stats.maxsp;
2730	rate_sp -= rate_sp / 2 * op->contr->gen_sp;	2473	rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2731	}	2474	}
		2475
2732	if (op->contr->gen_grace >= 0)	2476	if (op->contr->gen_grace >= 0)
2733	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;	2477	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2734	else	2478	else
2735	{	2479	{
2736	gen_grace = op->stats.maxgrace;	2480	gen_grace = op->stats.maxgrace;
…		…
2752	op->stats.food += op->contr->digestion;	2496	op->stats.food += op->contr->digestion;
2753	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))	2497	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2754	op->stats.food = last_food;	2498	op->stats.food = last_food;
2755	}	2499	}
2756	}	2500	}
		2501
2757	if (max_sp > 1)	2502	if (max_sp > 1)
2758	{	2503	{
2759	over_sp = (gen_sp + 10) / rate_sp;	2504	over_sp = (gen_sp + 10) / rate_sp;
2760	if (over_sp > 0)	2505	if (over_sp > 0)
2761	{	2506	{
2762	if (op->stats.sp < op->stats.maxsp)	2507	if (op->stats.sp < op->stats.maxsp)
2763	{	2508	{
2764	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;	2509	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
		2510
2765	if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))	2511	if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))
2766	op->stats.sp--;	2512	op->stats.sp--;
		2513
2767	if (op->stats.sp > op->stats.maxsp)	2514	if (op->stats.sp > op->stats.maxsp)
2768	op->stats.sp = op->stats.maxsp;	2515	op->stats.sp = op->stats.maxsp;
2769	}	2516	}
2770	op->last_sp = 0;	2517	op->last_sp = 0;
2771	}	2518	}
2772	else	2519	else
2773	{
2774	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);	2520	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2775	}
2776	}	2521	}
2777	else	2522	else
2778	{
2779	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);	2523	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2780	}
2781	}	2524	}
2782		2525
2783	/* Regenerate Grace */	2526	/* Regenerate Grace */
2784	/* I altered this a little - maximum grace is ony achieved through prayer -b.t. */	2527	/* I altered this a little - maximum grace is ony achieved through prayer -b.t. */
2785	if (--op->last_grace < 0)	2528	if (--op->last_grace < 0)
2786	{	2529	{
2787	if (op->stats.grace < op->stats.maxgrace / 2)	2530	if (op->stats.grace < op->stats.maxgrace / 2)
2788	op->stats.grace++; /* no penalty in food for regaining grace */	2531	op->stats.grace++; /* no penalty in food for regaining grace */
		2532
2789	if (max_grace > 1)	2533	if (max_grace > 1)
2790	{	2534	{
2791	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;	2535	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2792	if (over_grace > 0)	2536	if (over_grace > 0)
2793	{	2537	{
…		…
2821	op->stats.food += op->contr->digestion;	2565	op->stats.food += op->contr->digestion;
2822	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))	2566	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2823	op->stats.food = last_food;	2567	op->stats.food = last_food;
2824	}	2568	}
2825	}	2569	}
		2570
2826	if (max_hp > 1)	2571	if (max_hp > 1)
2827	{	2572	{
2828	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;	2573	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2829	if (over_hp > 0)	2574	if (over_hp > 0)
2830	{	2575	{
…		…
2854		2599
2855	if (op->contr->gen_hp > 0)	2600	if (op->contr->gen_hp > 0)
2856	op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);	2601	op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);
2857	else	2602	else
2858	op->last_eat = 25 * (1 + bonus) / (penalty + 1);	2603	op->last_eat = 25 * (1 + bonus) / (penalty + 1);
		2604
2859	/* dms do not consume food */	2605	/* dms do not consume food */
2860	if (!QUERY_FLAG (op, FLAG_WIZ))	2606	if (!QUERY_FLAG (op, FLAG_WIZ))
2861	op->stats.food--;	2607	op->stats.food--;
2862	}	2608	}
2863	}
2864		2609
2865	if (op->contr->state == ST_PLAYING && op->stats.food < 0 && op->stats.hp >= 0)	2610	if (op->stats.food < 0 && op->stats.hp >= 0)
2866	{	2611	{
2867	object *tmp, *flesh = NULL;	2612	object *tmp, *flesh = 0;
2868		2613
2869	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	2614	for (tmp = op->inv; tmp; tmp = tmp->below)
2870	{	2615	{
2871	if (!QUERY_FLAG (tmp, FLAG_UNPAID))	2616	if (!QUERY_FLAG (tmp, FLAG_UNPAID))
2872	{
2873	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2874	{	2617	{
		2618	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
		2619	{
2875	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");	2620	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2876	manual_apply (op, tmp, 0);	2621	manual_apply (op, tmp, 0);
2877	if (op->stats.food >= 0 || op->stats.hp < 0)	2622	if (op->stats.food >= 0 || op->stats.hp < 0)
2878	break;	2623	break;
2879	}	2624	}
2880	else if (tmp->type == FLESH)	2625	else if (tmp->type == FLESH)
2881	flesh = tmp;	2626	flesh = tmp;
2882	} /* End if paid for object */	2627	} /* End if paid for object */
2883	} /* end of for loop */	2628	} /* end of for loop */
		2629
2884	/* If player is still starving, it means they don't have any food, so	2630	/* If player is still starving, it means they don't have any food, so
2885	* eat flesh instead.	2631	* eat flesh instead.
2886	*/	2632	*/
2887	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)	2633	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2888	{	2634	{
2889	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");	2635	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2890	manual_apply (op, flesh, 0);	2636	manual_apply (op, flesh, 0);
2891	}	2637	}
2892	} /* end if player is starving */	2638	}
2893		2639
2894	while (op->stats.food < 0 && op->stats.hp > 0)	2640	while (op->stats.food < 0 && op->stats.hp >= 0)
2895	op->stats.food++, op->stats.hp--;	2641	op->stats.food++, op->stats.hp--;
2896		2642
2897	if (!op->contr->state && !QUERY_FLAG (op, FLAG_WIZ) && (op->stats.hp < 0 || op->stats.food < 0))	2643	if (op->stats.hp < 0 && !QUERY_FLAG (op, FLAG_WIZ))
2898	kill_player (op);	2644	kill_player (op);
		2645	}
2899	}	2646	}
2900
2901
2902		2647
2903	/* If the player should die (lack of hp, food, etc), we call this.	2648	/* If the player should die (lack of hp, food, etc), we call this.
2904	* op is the player in jeopardy. If the player can not be saved (not	2649	* op is the player in jeopardy. If the player can not be saved (not
2905	* permadeath, no lifesave), this will take care of removing the player	2650	* permadeath, no lifesave), this will take care of removing the player
2906	* file.	2651	* file.
…		…
2936	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");	2681	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");
2937	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");	2682	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");
2938		2683
2939	/* restore player */	2684	/* restore player */
2940	at = archetype::find ("poisoning");	2685	at = archetype::find ("poisoning");
2941	tmp = present_arch_in_ob (at, op);	2686	if (object *tmp = present_arch_in_ob (at, op))
2942	if (tmp)
2943	{	2687	{
2944	tmp->destroy ();	2688	tmp->destroy ();
2945	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2689	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2946	}	2690	}
2947		2691
2948	at = archetype::find ("confusion");	2692	at = archetype::find ("confusion");
2949	tmp = present_arch_in_ob (at, op);	2693	if (object *tmp = present_arch_in_ob (at, op))
2950	if (tmp)
2951	{	2694	{
2952	tmp->destroy ();	2695	tmp->destroy ();
2953	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2696	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2954	}	2697	}
2955		2698
…		…
2957	op->stats.hp = op->stats.maxhp;	2700	op->stats.hp = op->stats.maxhp;
2958	if (op->stats.food <= 0)	2701	if (op->stats.food <= 0)
2959	op->stats.food = 999;	2702	op->stats.food = 999;
2960		2703
2961	/* create a bodypart-trophy to make the winner happy */	2704	/* create a bodypart-trophy to make the winner happy */
2962	tmp = arch_to_object (archetype::find ("finger"));	2705	if (object *tmp = arch_to_object (archetype::find ("finger")))
2963	if (tmp != NULL)
2964	{	2706	{
2965	sprintf (buf, "%s's finger", &op->name);	2707	sprintf (buf, "%s's finger", &op->name);
2966	tmp->name = buf;	2708	tmp->name = buf;
2967	sprintf (buf, " This finger has been cut off %s\n"	2709	sprintf (buf, " This finger has been cut off %s\n"
2968	" the %s, when he was defeated at\n level %d by %s.\n",	2710	" the %s, when he was defeated at\n level %d by %s.\n",
2969	&op->name, op->contr->title, (int) (op->level), op->contr->killer);	2711	&op->name, op->contr->title, (int) (op->level), op->contr->killer);
2970	tmp->msg = buf;	2712	tmp->msg = buf;
2971	tmp->value = 0, tmp->material = 0, tmp->type = 0;	2713	tmp->value = 0, tmp->material = 0, tmp->type = 0;
2972	tmp->materialname = NULL;	2714	tmp->materialname = NULL;
2973	tmp->x = op->x, tmp->y = op->y;	2715	tmp->insert_at (op, tmp);
2974	insert_ob_in_map (tmp, op->map, op, 0);
2975	}	2716	}
2976		2717
2977	/* teleport defeated player to new destination */	2718	/* teleport defeated player to new destination */
2978	transfer_ob (op, x, y, 0, NULL);	2719	transfer_ob (op, x, y, 0, NULL);
2979	op->contr->braced = 0;	2720	op->contr->braced = 0;
…		…
2984		2725
2985	command_kill_pets (op, 0);	2726	command_kill_pets (op, 0);
2986		2727
2987	if (op->stats.food < 0)	2728	if (op->stats.food < 0)
2988	{	2729	{
2989	if (op->contr->explore)
2990	{
2991	new_draw_info (NDI_UNIQUE, 0, op, "You would have starved, but you are");
2992	new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
2993	op->stats.food = 999;
2994	return;
2995	}
2996	sprintf (buf, "%s starved to death.", &op->name);	2730	sprintf (buf, "%s starved to death.", &op->name);
2997	strcpy (op->contr->killer, "starvation");	2731	strcpy (op->contr->killer, "starvation");
2998	}	2732	}
2999	else	2733	else
3000	{
3001	if (op->contr->explore)
3002	{
3003	new_draw_info (NDI_UNIQUE, 0, op, "You would have died, but you are");
3004	new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
3005	op->stats.hp = op->stats.maxhp;
3006	return;
3007	}
3008	sprintf (buf, "%s died.", &op->name);	2734	sprintf (buf, "%s died.", &op->name);
3009	}	2735
3010	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);	2736	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);
3011		2737
3012	/* save the map location for corpse, gravestone */	2738	/* save the map location for corpse, gravestone */
3013	x = op->x;	2739	x = op->x;
3014	y = op->y;	2740	y = op->y;
3015	map = op->map;	2741	map = op->map;
3016		2742
3017
3018	if (settings.not_permadeth == TRUE)
3019	{
3020	/* NOT_PERMADEATH code. This basically brings the character back to	2743	/* NOT_PERMADEATH code. This basically brings the character back to
3021	* life if they are dead - it takes some exp and a random stat.	2744	* life if they are dead - it takes some exp and a random stat.
3022	* See the config.h file for a little more in depth detail about this.	2745	* See the config.h file for a little more in depth detail about this.
3023	*/	2746	*/
3024		2747
3025	/* Basically two ways to go - remove a stat permanently, or just	2748	/* Basically two ways to go - remove a stat permanently, or just
3026	* make it depletion. This bunch of code deals with that aspect	2749	* make it depletion. This bunch of code deals with that aspect
3027	* of death.	2750	* of death.
3028	*/	2751	*/
3029	#ifndef COZY_SERVER	2752	#ifndef COZY_SERVER
3030	if (settings.balanced_stat_loss)	2753	if (settings.balanced_stat_loss)
3031	{	2754	{
3032	/* If stat loss is permanent, lose one stat only. */	2755	/* If stat loss is permanent, lose one stat only. */
3033	/* Lower level chars don't lose as many stats because they suffer	2756	/* Lower level chars don't lose as many stats because they suffer
3034	more if they do. */	2757	more if they do. */
3035	/* Higher level characters can afford things such as potions of	2758	/* Higher level characters can afford things such as potions of
3036	restoration, or better, stat potions. So we slug them that	2759	restoration, or better, stat potions. So we slug them that
3037	little bit harder. */	2760	little bit harder. */
3038	/* GD */	2761	/* GD */
3039	if (settings.stat_loss_on_death)	2762	if (settings.stat_loss_on_death)
3040	num_stats_lose = 1;	2763	num_stats_lose = 1;
3041	else
3042	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
3043	}
3044	else	2764	else
3045	{	2765	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
		2766	}
		2767	else
3046	num_stats_lose = 1;	2768	num_stats_lose = 1;
3047	}	2769
3048	lost_a_stat = 0;	2770	lost_a_stat = 0;
3049		2771
3050	for (z = 0; z < num_stats_lose; z++)	2772	for (z = 0; z < num_stats_lose; z++)
3051	{	2773	{
3052	i = RANDOM () % NUM_STATS;	2774	i = RANDOM () % NUM_STATS;
3053		2775
3054	if (settings.stat_loss_on_death)	2776	if (settings.stat_loss_on_death)
3055	{	2777	{
3056	/* Pick a random stat and take a point off it. Tell the player	2778	/* Pick a random stat and take a point off it. Tell the player
3057	* what he lost.	2779	* what he lost.
3058	*/	2780	*/
3059	change_attr_value (&(op->stats), i, -1);	2781	change_attr_value (&(op->stats), i, -1);
3060	check_stat_bounds (&(op->stats));	2782	check_stat_bounds (&(op->stats));
3061	change_attr_value (&(op->contr->orig_stats), i, -1);	2783	change_attr_value (&(op->contr->orig_stats), i, -1);
3062	check_stat_bounds (&(op->contr->orig_stats));	2784	check_stat_bounds (&(op->contr->orig_stats));
3063	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);	2785	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3064	lost_a_stat = 1;	2786	lost_a_stat = 1;
		2787	}
		2788	else
		2789	{
		2790	/* deplete a stat */
		2791	archetype *deparch = archetype::find ("depletion");
		2792	object *dep;
		2793
		2794	dep = present_arch_in_ob (deparch, op);
		2795	if (!dep)
		2796	{
		2797	dep = arch_to_object (deparch);
		2798	insert_ob_in_ob (dep, op);
3065	}	2799	}
3066	else	2800	lose_this_stat = 1;
		2801	if (settings.balanced_stat_loss)
3067	{	2802	{
3068	/* deplete a stat */	2803	/* GD */
3069	archetype *deparch = archetype::find ("depletion");	2804	/* Get the stat that we're about to deplete. */
3070	object *dep;	2805	this_stat = get_attr_value (&(dep->stats), i);
3071		2806	if (this_stat < 0)
3072	dep = present_arch_in_ob (deparch, op);
3073	if (!dep)
3074	{	2807	{
3075	dep = arch_to_object (deparch);	2808	int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3076	insert_ob_in_ob (dep, op);	2809	int keep_chance = this_stat * this_stat;
3077	}	2810
3078	lose_this_stat = 1;	2811	/* Yes, I am paranoid. Sue me. */
3079	if (settings.balanced_stat_loss)
3080	{
3081	/* GD */
3082	/* Get the stat that we're about to deplete. */
3083	this_stat = get_attr_value (&(dep->stats), i);
3084	if (this_stat < 0)	2812	if (keep_chance < 1)
		2813	keep_chance = 1;
		2814
		2815	/* There is a maximum depletion total per level. */
		2816	if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3085	{	2817	{
3086	int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3087	int keep_chance = this_stat * this_stat;
3088
3089	/* Yes, I am paranoid. Sue me. */
3090	if (keep_chance < 1)
3091	keep_chance = 1;
3092
3093	/* There is a maximum depletion total per level. */
3094	if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3095	{
3096	lose_this_stat = 0;	2818	lose_this_stat = 0;
3097	/* Take loss chance vs keep chance to see if we	2819	/* Take loss chance vs keep chance to see if we
3098	retain the stat. */	2820	retain the stat. */
3099	}
3100	else
3101	{
3102	if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3103	lose_this_stat = 0;
3104	/* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
3105	this_stat, keep_chance, loss_chance,
3106	lose_this_stat?"LOSE":"KEEP"); */
3107	}
3108	}	2821	}
3109	}
3110
3111	if (lose_this_stat)
3112	{
3113	this_stat = get_attr_value (&(dep->stats), i);
3114	/* We could try to do something clever like find another
3115	* stat to reduce if this fails. But chances are, if
3116	* stats have been depleted to -50, all are pretty low
3117	* and should be roughly the same, so it shouldn't make a
3118	* difference.
3119	*/	2822	else
3120	if (this_stat >= -50)
3121	{	2823	{
3122	change_attr_value (&(dep->stats), i, -1);	2824	if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3123	SET_FLAG (dep, FLAG_APPLIED);
3124	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3125	fix_player (op);
3126	lost_a_stat = 1;	2825	lose_this_stat = 0;
		2826	/* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
		2827	this_stat, keep_chance, loss_chance,
		2828	lose_this_stat?"LOSE":"KEEP"); */
3127	}	2829	}
3128	}	2830	}
3129	}	2831	}
		2832
		2833	if (lose_this_stat)
		2834	{
		2835	this_stat = get_attr_value (&(dep->stats), i);
		2836	/* We could try to do something clever like find another
		2837	* stat to reduce if this fails. But chances are, if
		2838	* stats have been depleted to -50, all are pretty low
		2839	* and should be roughly the same, so it shouldn't make a
		2840	* difference.
		2841	*/
		2842	if (this_stat >= -50)
		2843	{
		2844	change_attr_value (&(dep->stats), i, -1);
		2845	SET_FLAG (dep, FLAG_APPLIED);
		2846	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
		2847	op->update_stats ();
		2848	lost_a_stat = 1;
		2849	}
3130	}	2850	}
		2851	}
		2852	}
3131	/* If no stat lost, tell the player. */	2853	/* If no stat lost, tell the player. */
3132	if (!lost_a_stat)	2854	if (!lost_a_stat)
3133	{	2855	{
3134	/* determine_god() seems to not work sometimes... why is this?	2856	/* determine_god() seems to not work sometimes... why is this?
3135	Should I be using something else? GD */	2857	Should I be using something else? GD */
3136	const char *god = determine_god (op);	2858	const char *god = determine_god (op);
3137		2859
3138	if (god && (strcmp (god, "none")))	2860	if (god && (strcmp (god, "none")))
3139	new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);	2861	new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3140	else	2862	else
3141	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");	2863	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3142	}	2864	}
3143	#else	2865	#else
3144	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");	2866	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3145	#endif	2867	#endif
3146		2868
3147	/* Put a gravestone up where the character 'almost' died. List the	2869	/* Put a gravestone up where the character 'almost' died. List the
3148	* exp loss on the stone.	2870	* exp loss on the stone.
3149	*/	2871	*/
3150	tmp = arch_to_object (archetype::find ("gravestone"));	2872	tmp = arch_to_object (archetype::find ("gravestone"));
3151	sprintf (buf, "%s's gravestone", &op->name);	2873	sprintf (buf, "%s's gravestone", &op->name);
3152	tmp->name = buf;	2874	tmp->name = buf;
3153	sprintf (buf, "%s's gravestones", &op->name);	2875	sprintf (buf, "%s's gravestones", &op->name);
3154	tmp->name_pl = buf;	2876	tmp->name_pl = buf;
3155	sprintf (buf, "RIP\nHere rests the hero %s the %s,\n" "who was killed\n" "by %s.\n", &op->name, op->contr->title, op->contr->killer);	2877	sprintf (buf, "RIP\nHere rests the hero %s the %s,\n" "who was killed\n" "by %s.\n", &op->name, op->contr->title, op->contr->killer);
3156	tmp->msg = buf;	2878	tmp->msg = buf;
3157	tmp->x = op->x, tmp->y = op->y;	2879	tmp->x = op->x, tmp->y = op->y;
3158	insert_ob_in_map (tmp, op->map, NULL, 0);	2880	insert_ob_in_map (tmp, op->map, NULL, 0);
3159		2881
3160	/**************************************/	2882	/**************************************/
3161	/* */	2883	/* */
3162	/* Subtract the experience points, */	2884	/* Subtract the experience points, */
3163	/* if we died cause of food, give us */	2885	/* if we died cause of food, give us */
3164	/* food, and reset HP's... */	2886	/* food, and reset HP's... */
3165	/* */	2887	/* */
3166	/**************************************/	2888	/**************************************/
3167		2889
3168	/* remove any poisoning and confusion the character may be suffering. */	2890	/* remove any poisoning and confusion the character may be suffering. */
3169	/* restore player */	2891	/* restore player */
3170	at = archetype::find ("poisoning");	2892	at = archetype::find ("poisoning");
3171	tmp = present_arch_in_ob (at, op);	2893	tmp = present_arch_in_ob (at, op);
3172		2894
3173	if (tmp)	2895	if (tmp)
3174	{	2896	{
3175	tmp->destroy ();	2897	tmp->destroy ();
3176	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2898	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3177	}	2899	}
3178		2900
3179	at = archetype::find ("confusion");	2901	at = archetype::find ("confusion");
3180	tmp = present_arch_in_ob (at, op);	2902	tmp = present_arch_in_ob (at, op);
3181	if (tmp)	2903	if (tmp)
3182	{	2904	{
3183	tmp->destroy ();	2905	tmp->destroy ();
3184	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2906	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3185	}	2907	}
3186		2908
3187	cure_disease (op, 0); /* remove any disease */	2909	cure_disease (op, 0); /* remove any disease */
3188		2910
3189	/*add_exp(op, (op->stats.exp * -0.20)); */	2911	/*add_exp(op, (op->stats.exp * -0.20)); */
3190	apply_death_exp_penalty (op);	2912	apply_death_exp_penalty (op);
3191	if (op->stats.food < 100)	2913	if (op->stats.food < 100)
3192	op->stats.food = 900;	2914	op->stats.food = 900;
3193	op->stats.hp = op->stats.maxhp;	2915	op->stats.hp = op->stats.maxhp;
3194	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);	2916	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);
3195	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);	2917	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);
3196		2918
3197	/*	2919	/*
3198	* Check to see if the player is in a shop. IF so, then check to see if	2920	* Check to see if the player is in a shop. IF so, then check to see if
3199	* the player has any unpaid items. If so, remove them and put them back	2921	* the player has any unpaid items. If so, remove them and put them back
3200	* in the map.	2922	* in the map.
3201	*/	2923	*/
3202		2924
3203	if (is_in_shop (op))	2925	if (is_in_shop (op))
3204	remove_unpaid_objects (op->inv, op);	2926	remove_unpaid_objects (op->inv, op);
3205		2927
3206	/****************************************/	2928	/****************************************/
3207	/* */	2929	/* */
3208	/* Move player to his current respawn- */	2930	/* Move player to his current respawn- */
3209	/* position (usually last savebed) */	2931	/* position (usually last savebed) */
3210	/* */	2932	/* */
3211	/****************************************/	2933	/****************************************/
3212		2934
3213	enter_player_savebed (op);	2935	enter_player_savebed (op);
3214		2936
3215	/* Save the player before inserting the force to reduce
3216	* chance of abuse.
3217	*/
3218	op->contr->braced = 0;	2937	op->contr->braced = 0;
3219	save_player (op, 1);
3220		2938
3221	/* it is possible that the player has blown something up	2939	/* it is possible that the player has blown something up
3222	* at his savebed location, and that can have long lasting	2940	* at his savebed location, and that can have long lasting
3223	* spell effects. So first see if there is a spell effect	2941	* spell effects. So first see if there is a spell effect
3224	* on the space that might harm the player.	2942	* on the space that might harm the player.
3225	*/	2943	*/
3226	will_kill_again = 0;	2944	will_kill_again = 0;
3227	for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above)	2945	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
3228	if (tmp->type == SPELL_EFFECT)	2946	if (tmp->type == SPELL_EFFECT)
3229	will_kill_again |= tmp->attacktype;	2947	will_kill_again |= tmp->attacktype;
3230		2948
3231	if (will_kill_again)	2949	if (will_kill_again)
3232	{	2950	{
3233	object *force;	2951	object *force;
3234	int at;	2952	int at;
3235		2953
3236	force = get_archetype (FORCE_NAME);	2954	force = get_archetype (FORCE_NAME);
3237	/* 50 ticks should be enough time for the spell to abate */	2955	/* 50 ticks should be enough time for the spell to abate */
3238	force->speed = 0.1;	2956	force->speed = 0.1;
3239	force->speed_left = -5.0;	2957	force->speed_left = -5.0;
3240	SET_FLAG (force, FLAG_APPLIED);	2958	SET_FLAG (force, FLAG_APPLIED);
3241	for (at = 0; at < NROFATTACKS; at++)	2959	for (at = 0; at < NROFATTACKS; at++)
3242	if (will_kill_again & (1 << at))	2960	if (will_kill_again & (1 << at))
3243	force->resist[at] = 100;	2961	force->resist[at] = 100;
3244		2962
3245	insert_ob_in_ob (force, op);	2963	insert_ob_in_ob (force, op);
3246	fix_player (op);	2964	op->update_stats ();
3247		2965
3248	}	2966	}
3249		2967
3250	new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");	2968	new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");
3251	return;
3252	} /* NOT_PERMADETH */
3253	else
3254	{
3255	/* If NOT_PERMADETH is set, then the rest of this is not reachable. This
3256	* should probably be embedded in an else statement.
3257	*/
3258
3259	op->contr->party = NULL;
3260	if (settings.set_title == TRUE)
3261	op->contr->own_title[0] = '\0';
3262	new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3263	check_score (op);
3264
3265	if (op->contr->ranges[range_golem])
3266	{
3267	remove_friendly_object (op->contr->ranges[range_golem]);
3268	op->contr->ranges[range_golem]->destroy ();
3269	op->contr->ranges[range_golem] = 0;
3270	}
3271
3272	loot_object (op); /* Remove some of the items for good */
3273	op->remove ();
3274	op->direction = 0;
3275
3276	if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3277	{
3278	delete_character (op->name, 0);
3279	if (settings.resurrection == TRUE)
3280	{
3281	/* save playerfile sans equipment when player dies
3282	** then save it as player.pl.dead so that future resurrection
3283	** type spells will work on them nicely
3284	*/
3285	delete_character (op->name, 0);
3286	op->stats.hp = op->stats.maxhp;
3287	op->stats.food = 999;
3288
3289	/* set the location of where the person will reappear when */
3290	/* maybe resurrection code should fix map also */
3291	strcpy (op->contr->maplevel, settings.emergency_mapname);
3292	if (op->map != NULL)
3293	op->map = NULL;
3294	op->x = settings.emergency_x;
3295	op->y = settings.emergency_y;
3296	save_player (op, 0);
3297	op->map = map;
3298	/* please see resurrection.c: peterm */
3299	dead_player (op);
3300	}
3301	else
3302	delete_character (op->name, 1);
3303	}
3304
3305	play_again (op);
3306
3307	/* peterm: added to create a corpse at deathsite. */
3308	tmp = arch_to_object (archetype::find ("corpse_pl"));
3309	sprintf (buf, "%s", &op->name);
3310	tmp->name = tmp->name_pl = buf;
3311	tmp->level = op->level;
3312	tmp->x = x;
3313	tmp->y = y;
3314	tmp->msg = gravestone_text (op);
3315	SET_FLAG (tmp, FLAG_UNIQUE);
3316	insert_ob_in_map (tmp, map, NULL, 0);
3317	}
3318	}	2969	}
3319
3320		2970
3321	void	2971	void
3322	loot_object (object *op)	2972	loot_object (object *op)
3323	{ /* Grab and destroy some treasure */	2973	{ /* Grab and destroy some treasure */
3324	object *tmp, *tmp2, *next;	2974	object *tmp, *tmp2, *next;
3325		2975
3326	if (op->container)	2976	if (op->container)
3327	{ /* close open sack first */
3328	esrv_apply_container (op, op->container);	2977	esrv_apply_container (op, op->container); /* close open sack first */
3329	}
3330		2978
3331	for (tmp = op->inv; tmp != NULL; tmp = next)	2979	for (tmp = op->inv; tmp; tmp = next)
3332	{	2980	{
3333	next = tmp->below;	2981	next = tmp->below;
3334	if (tmp->type == EXPERIENCE || tmp->invisible)	2982
		2983	if (tmp->invisible)
3335	continue;	2984	continue;
		2985
3336	tmp->remove ();	2986	tmp->remove ();
3337	tmp->x = op->x, tmp->y = op->y;	2987	tmp->x = op->x, tmp->y = op->y;
3338	if (tmp->type == CONTAINER)	2988	if (tmp->type == CONTAINER)
3339	{ /* empty container to ground */	2989	{ /* empty container to ground */
3340	loot_object (tmp);	2990	loot_object (tmp);
…		…
3362	*/	3012	*/
3363		3013
3364	void	3014	void
3365	fix_weight (void)	3015	fix_weight (void)
3366	{	3016	{
3367	player *pl;	3017	for_all_players (pl)
3368
3369	for (pl = first_player; pl != NULL; pl = pl->next)
3370	{	3018	{
3371	int old = pl->ob->carrying, sum = sum_weight (pl->ob);	3019	int old = pl->ob->carrying, sum = sum_weight (pl->ob);
3372		3020
3373	if (old == sum)	3021	if (old == sum)
3374	continue;	3022	continue;
3375	fix_player (pl->ob);	3023	pl->ob->update_stats ();
3376	LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);	3024	LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);
3377	}	3025	}
3378	}	3026	}
3379		3027
3380	void	3028	void
3381	fix_luck (void)	3029	fix_luck (void)
3382	{	3030	{
3383	player *pl;	3031	for_all_players (pl)
3384
3385	for (pl = first_player; pl != NULL; pl = pl->next)
3386	if (!pl->ob->contr->state)	3032	if (!pl->ob->contr->ns->state)
3387	change_luck (pl->ob, 0);	3033	pl->ob->change_luck (0);
3388	}	3034	}
3389
3390		3035
3391	/* cast_dust() - handles op throwing objects of type 'DUST'.	3036	/* cast_dust() - handles op throwing objects of type 'DUST'.
3392	* This is much simpler in the new spell code - we basically	3037	* This is much simpler in the new spell code - we basically
3393	* just treat this as any other spell casting object.	3038	* just treat this as any other spell casting object.
3394	*/	3039	*/
3395
3396	void	3040	void
3397	cast_dust (object *op, object *throw_ob, int dir)	3041	cast_dust (object *op, object *throw_ob, int dir)
3398	{	3042	{
3399	object *skop, *spob;	3043	object *skop, *spob;
3400		3044
…		…
3445	object *tmp = NULL;	3089	object *tmp = NULL;
3446		3090
3447	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))	3091	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
3448	return 1;	3092	return 1;
3449		3093
3450	if (op->type == PLAYER)
3451	for (tmp = op->inv; tmp; tmp = tmp->below)
3452	if (tmp->type == EXPERIENCE && tmp->stats.Wis)
3453	if (QUERY_FLAG (tmp, FLAG_UNDEAD))
3454	return 1;
3455	return 0;	3094	return 0;
3456	}	3095	}
3457		3096
3458	/* look at the surrounding terrain to determine	3097	/* look at the surrounding terrain to determine
3459	* the hideability of this object. Positive levels	3098	* the hideability of this object. Positive levels
…		…
3515		3154
3516	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);	3155	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);
3517		3156
3518	/* its *extremely* hard to run and sneak/hide at the same time! */	3157	/* its *extremely* hard to run and sneak/hide at the same time! */
3519	if (op->type == PLAYER && op->contr->run_on)	3158	if (op->type == PLAYER && op->contr->run_on)
3520	{
3521	if (!skop || num >= skop->level)	3159	if (!skop || num >= skop->level)
3522	{	3160	{
3523	new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");	3161	new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");
3524	make_visible (op);	3162	make_visible (op);
3525	return;	3163	return;
3526	}	3164	}
3527	else	3165	else
3528	num += 20;	3166	num += 20;
3529	}	3167
3530	num += op->map->difficulty;	3168	num += op->map->difficulty;
3531	hide = hideability (op); /* modify by terrain hidden level */	3169	hide = hideability (op); /* modify by terrain hidden level */
3532	num -= hide;	3170	num -= hide;
		3171
3533	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))	3172	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))
3534	{	3173	{
3535	make_visible (op);	3174	make_visible (op);
3536	if (op->type == PLAYER)	3175	if (op->type == PLAYER)
3537	new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");	3176	new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");
3538	}	3177	}
3539	else if (op->type == PLAYER && skop)	3178	else if (op->type == PLAYER && skop)
3540	{
3541	change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);	3179	change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);
3542	}
3543	}	3180	}
3544		3181
3545	/* determine if who is standing near a hostile creature. */	3182	/* determine if who is standing near a hostile creature. */
3546		3183
3547	int	3184	int
…		…
3574	if (mflags & P_OUT_OF_MAP)	3211	if (mflags & P_OUT_OF_MAP)
3575	continue;	3212	continue;
3576	if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))	3213	if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))
3577	continue;	3214	continue;
3578		3215
3579	for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above)	3216	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
3580	{	3217	{
3581	if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))	3218	if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
3582	return 1;	3219	return 1;
3583	else if (tmp->type == PLAYER)	3220	else if (tmp->type == PLAYER)
3584	{	3221	{
…		…
3614	if (pl->type != PLAYER)	3251	if (pl->type != PLAYER)
3615	{	3252	{
3616	LOG (llevError, "player_can_view() called for non-player object\n");	3253	LOG (llevError, "player_can_view() called for non-player object\n");
3617	return -1;	3254	return -1;
3618	}	3255	}
		3256
3619	if (!pl || !op)	3257	if (!pl || !op)
3620	return 0;	3258	return 0;
3621		3259
3622	if (op->head)
3623	{
3624	op = op->head;	3260	op = op->head_ ();
3625	}	3261
3626	get_rangevector (pl, op, &rv, 0x1);	3262	get_rangevector (pl, op, &rv, 0x1);
3627		3263
3628	/* starting with the 'head' part, lets loop	3264	/* starting with the 'head' part, lets loop
3629	* through the object and find if it has any	3265	* through the object and find if it has any
3630	* part that is in the los array but isnt on	3266	* part that is in the los array but isnt on
…		…
3638		3274
3639	/* only the viewable area the player sees is updated by LOS	3275	/* only the viewable area the player sees is updated by LOS
3640	* code, so we need to restrict ourselves to that range of values	3276	* code, so we need to restrict ourselves to that range of values
3641	* for any meaningful values.	3277	* for any meaningful values.
3642	*/	3278	*/
3643	if (FABS (dx) <= (pl->contr->socket->mapx / 2) &&	3279	if (FABS (dx) <= (pl->contr->ns->mapx / 2) &&
3644	FABS (dy) <= (pl->contr->socket->mapy / 2) &&	3280	FABS (dy) <= (pl->contr->ns->mapy / 2) &&
3645	!pl->contr->blocked_los[dx + (pl->contr->socket->mapx / 2)][dy + (pl->contr->socket->mapy / 2)])	3281	!pl->contr->blocked_los[dx + (pl->contr->ns->mapx / 2)][dy + (pl->contr->ns->mapy / 2)])
3646	return 1;	3282	return 1;
3647	op = op->more;	3283	op = op->more;
3648	}	3284	}
3649	return 0;	3285	return 0;
3650	}	3286	}
…		…
3760	if (trlist == NULL || who->type != PLAYER)	3396	if (trlist == NULL || who->type != PLAYER)
3761	return;	3397	return;
3762		3398
3763	for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);	3399	for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);
3764		3400
3765	if (tr == NULL || tr->item == NULL)	3401	if (!tr || !tr->item)
3766	{	3402	{
3767	/* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */	3403	/* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3768	return;	3404	return;
3769	}	3405	}
3770		3406
…		…
3836	{	3472	{
3837	/* forces in the treasurelist can alter the player's stats */	3473	/* forces in the treasurelist can alter the player's stats */
3838	object *skin;	3474	object *skin;
3839		3475
3840	/* first get the dragon skin force */	3476	/* first get the dragon skin force */
		3477	shstr_cmp dragon_skin_force ("dragon_skin_force");
3841	for (skin = who->inv; skin != NULL && strcmp (skin->arch->name, "dragon_skin_force") != 0; skin = skin->below);	3478	for (skin = who->inv; skin && !(skin->arch->name == dragon_skin_force); skin = skin->below)
		3479	;
		3480
3842	if (skin == NULL)	3481	if (!skin)
3843	return;	3482	return;
3844		3483
3845	/* adding new spellpath attunements */	3484	/* adding new spellpath attunements */
3846	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))	3485	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))
3847	{	3486	{

Diff Legend

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