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.31 by pippijn, Mon Dec 11 19:46:47 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	#ifndef __CEXTRACT__
27	# include <sproto.h>	27	#include <sproto.h>
28	#endif
29	#include <sounds.h>	28	#include <sounds.h>
30	#include <living.h>	29	#include <living.h>
31	#include <object.h>	30	#include <object.h>
32	#include <spells.h>	31	#include <spells.h>
33	#include <skills.h>	32	#include <skills.h>
34	#include <newclient.h>
35		33
36	#ifdef COZY_SERVER	34	#include <algorithm>
37	extern int same_party (partylist *a, partylist *b);	35	#include <functional>
38	#endif
39		36
40	player *	37	playervec players;
41	find_player (const char *plname)
42	{
43	player *pl;
44
45	for (pl = first_player; pl != NULL; pl = pl->next)
46	{
47	if (pl->ob != NULL && !strcmp (query_name (pl->ob), plname))
48	return pl;
49	};
50	return NULL;
51	}
52
53	player *
54	find_player_partial_name (const char *plname)
55	{
56	player *pl;
57	player *found = NULL;
58	size_t namelen = strlen (plname);
59
60	for (pl = first_player; pl != NULL; pl = pl->next)
61	{
62	if ((size_t) strlen (pl->ob->name) < namelen)
63	continue;
64
65	if (!strcmp (pl->ob->name, plname))
66	return pl;
67
68	if (!strncasecmp (pl->ob->name, plname, namelen))
69	{
70	if (found)
71	return NULL;
72
73	found = pl;
74	}
75	}
76	return found;
77	}
78		38
79	void	39	void
80	display_motd (const object *op)	40	display_motd (const object *op)
81	{	41	{
82	char buf[MAX_BUF];	42	char buf[MAX_BUF];
…		…
85	int comp;	45	int comp;
86	int size;	46	int size;
87		47
88	sprintf (buf, "%s/%s", settings.confdir, settings.motd);	48	sprintf (buf, "%s/%s", settings.confdir, settings.motd);
89	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)	49	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
90	{
91	return;	50	return;
92	}	51
93	motd[0] = '\0';	52	motd[0] = '\0';
94	size = 0;	53	size = 0;
		54
95	while (fgets (buf, MAX_BUF, fp) != NULL)	55	while (fgets (buf, MAX_BUF, fp))
96	{	56	{
97	if (*buf == '#')	57	if (*buf == '#')
98	continue;	58	continue;
		59
99	strncat (motd + size, buf, HUGE_BUF - size);	60	strncat (motd + size, buf, HUGE_BUF - size);
100	size += strlen (buf);	61	size += strlen (buf);
101	}	62	}
		63
102	draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL);	64	draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL);
103	close_and_delete (fp, comp);	65	close_and_delete (fp, comp);
104	}	66	}
105		67
106	void	68	void
…		…
112	int comp;	74	int comp;
113	int size;	75	int size;
114		76
115	sprintf (buf, "%s/%s", settings.confdir, settings.rules);	77	sprintf (buf, "%s/%s", settings.confdir, settings.rules);
116	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)	78	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
117	{
118	return;	79	return;
119	}	80
120	rules[0] = '\0';	81	rules[0] = '\0';
121	size = 0;	82	size = 0;
		83
122	while (fgets (buf, MAX_BUF, fp) != NULL)	84	while (fgets (buf, MAX_BUF, fp))
123	{	85	{
124	if (*buf == '#')	86	if (*buf == '#')
125	continue;	87	continue;
		88
126	if (size + strlen (buf) >= HUGE_BUF)	89	if (size + strlen (buf) >= HUGE_BUF)
127	{	90	{
128	LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);	91	LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);
129	break;	92	break;
130	}	93	}
		94
131	strncat (rules + size, buf, HUGE_BUF - size);	95	strncat (rules + size, buf, HUGE_BUF - size);
132	size += strlen (buf);	96	size += strlen (buf);
133	}	97	}
		98
134	draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL);	99	draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL);
135	close_and_delete (fp, comp);	100	close_and_delete (fp, comp);
136	}	101	}
137		102
138	void	103	void
…		…
146	int size;	111	int size;
147		112
148	sprintf (buf, "%s/%s", settings.confdir, settings.news);	113	sprintf (buf, "%s/%s", settings.confdir, settings.news);
149	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)	114	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
150	return;	115	return;
		116
151	news[0] = '\0';	117	news[0] = '\0';
152	subject[0] = '\0';	118	subject[0] = '\0';
153	size = 0;	119	size = 0;
		120
154	while (fgets (buf, MAX_BUF, fp) != NULL)	121	while (fgets (buf, MAX_BUF, fp) != NULL)
155	{	122	{
156	if (*buf == '#')	123	if (*buf == '#')
157	continue;	124	continue;
		125
158	if (*buf == '%')	126	if (*buf == '%')
159	{ /* send one news */	127	{ /* send one news */
160	if (size > 0)	128	if (size > 0)
161	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
162	strcpy (subject, buf + 1);	131	strcpy (subject, buf + 1);
163	strip_endline (subject);	132	strip_endline (subject);
164	size = 0;	133	size = 0;
165	news[0] = '\0';	134	news[0] = '\0';
166	}	135	}
…		…
179	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,	148	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
180	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);
181	close_and_delete (fp, comp);	150	close_and_delete (fp, comp);
182	}	151	}
183		152
184	int	153	/* This loads the first map an puts the player on it. */
185	playername_ok (const char *cp)	154	static void
		155	set_first_map (object *op)
186	{	156	{
187	/* Don't allow - or _ as first character in the name */	157	op->contr->maplevel = first_map_path;
188	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)
189	return 0;	179	return;
190		180
191	for (; *cp != '\0'; cp++)	181	players.insert (this);
192	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)
193	return 0;	192	return;
194	return 1;
195	}
196		193
197	/* This no longer sets the player map. Also, it now updates	194	terminate_all_pets (ob);
198	* all the pointers so the caller doesn't need to do that.	195	ob->deactivate_recursive ();
199	* Caller is responsible for setting the correct map.	196	ob->remove ();
200	*/	197	ob->map = 0;
201		198
202	/* Redo this to do both get_player_ob and get_player.	199	players.erase (this);
203	* Hopefully this will be less bugfree and simpler.	200	}
204	* Returns the player structure. If 'p' is null,
205	* we create a new one. Otherwise, we recycle
206	* the one that is passed.
207	*/
208	static player *
209	get_player (player *p)
210	{
211	object *op = arch_to_object (get_player_archetype (NULL));
212	int i;
213		201
214	if (!p)	202	// connect the player with a specific client
215	{	203	// also changed, rationalises, and fixes some incorrect settings
216	p = new player;	204	void
		205	player::connect (client *ns)
		206	{
		207	this->ns = ns;
		208	ns->pl = this;
217		209
218	/* This adds the player in the linked list. There is extra	210	ns->update_look = 0;
219	* complexity here because we want to add the new player at the	211	ns->look_position = 0;
220	* end of the list - there is in fact no compelling reason that
221	* that needs to be done except for things like output of
222	* 'who'.
223	*/
224	player *tmp = first_player;
225		212
226	while (tmp != NULL && tmp->next != NULL)	213	clear_los (ob);
227	tmp = tmp->next;
228	if (tmp != NULL)
229	tmp->next = p;
230	else
231	first_player = p;
232		214
233	p->next = NULL;	215	/* make sure he's a player -- needed because of class change. */
234	}	216	ob->type = PLAYER; // we are paranoid
		217	ob->race = ob->arch->clone.race;
235		218
236	/* Clears basically the entire player structure except	219	if (!legal_range (ob, shoottype))
237	* for next and socket.	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.
238	*/	235	*/
239	p->clear ();	236	if (QUERY_FLAG (ob, FLAG_USE_ARMOUR))
		237	SET_FLAG (ob, FLAG_USE_SHIELD);
240		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	{
241	/* There are some elements we want initialized to non zero value -	316	/* There are some elements we want initialised to non zero value -
242	* we deal with that below this point.	317	* we deal with that below this point.
243	*/	318	*/
244	p->party = NULL;
245	p->outputs_sync = 16; /* Every 2 seconds */	319	outputs_sync = 16; /* Every 2 seconds */
246	p->outputs_count = 8; /* Keeps present behaviour */	320	outputs_count = 8; /* Keeps present behaviour */
247	p->unapply = unapply_nochoice;	321	unapply = unapply_nochoice;
248	p->Swap_First = -1;
249		322
250	#ifdef AUTOSAVE
251	p->last_save_tick = 9999999;
252	#endif
253
254	strcpy (p->savebed_map, first_map_path); /* Init. respawn position */	323	savebed_map = first_map_path; /* Init. respawn position */
255		324
256	op->contr = p; /* this aren't yet in archetype */
257	p->ob = op;
258	op->speed_left = 0.5;
259	op->speed = 1.0;
260	op->direction = 5; /* So player faces south */
261	op->stats.wc = 2;
262	op->run_away = 25; /* Then we panick... */
263	p->socket.monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */
264
265	roll_stats (op);
266	p->state = ST_ROLL_STAT;
267	clear_los (op);
268
269	p->gen_sp_armour = 10;	325	gen_sp_armour = 10;
270	p->last_speed = -1;	326	last_speed = -1;
271	p->shoottype = range_none;	327	shoottype = range_none;
272	p->bowtype = bow_normal;	328	bowtype = bow_normal;
273	p->petmode = pet_normal;	329	petmode = pet_normal;
274	p->listening = 10;	330	listening = 10;
275	p->usekeys = containers;	331	usekeys = containers;
276	p->last_weapon_sp = -1;	332	last_weapon_sp = -1;
277	p->peaceful = 1; /* default peaceful */	333	peaceful = 1; /* default peaceful */
278	p->do_los = 1;	334	do_los = 1;
279	p->explore = 0;
280	p->no_shout = 0; /* default can shout */
281
282	assign (p->title, op->arch->clone.name);
283	op->race = op->arch->clone.race;
284
285	CLEAR_FLAG (op, FLAG_READY_SKILL);
286		335
287	/* we need to clear these to -1 and not zero - otherwise,	336	/* we need to clear these to -1 and not zero - otherwise,
288	* if a player quits and starts a new character, we wont	337	* if a player quits and starts a new character, we wont
289	* send new values to the client, as things like exp start	338	* send new values to the client, as things like exp start
290	* at zero.	339	* at zero.
291	*/	340	*/
292	for (i = 0; i < NUM_SKILLS; i++)	341	for (int i = 0; i < NUM_SKILLS; i++)
293	{
294	p->last_skill_exp[i] = -1;	342	last_skill_exp[i] = -1;
295	p->last_skill_ob[i] = NULL;	343
296	}
297	for (i = 0; i < NROFATTACKS; i++)	344	for (int i = 0; i < NROFATTACKS; i++)
298	{
299	p->last_resist[i] = -1;	345	last_resist[i] = -1;
300	}	346
301	p->last_stats.exp = -1;	347	last_stats.exp = -1;
302	p->last_weight = (uint32) - 1;	348	last_weight = (uint32) - 1;
303
304	p->socket.update_look = 0;
305	p->socket.look_position = 0;
306	return p;
307	}	349	}
308		350
309	/* This loads the first map an puts the player on it. */	351	void
310	static void	352	player::do_destroy ()
311	set_first_map (object *op)
312	{	353	{
313	strcpy (op->contr->maplevel, first_map_path);	354	disconnect ();
314	op->x = -1;
315	op->y = -1;
316	enter_exit (op, NULL);
317	}
318		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
319	/* Tries to add player on the connection passwd in ns.	371	/* Tries to add player on the connection passed in ns.
320	* 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
321	* mode.	373	* mode.
322	*/	374	*/
323
324	int
325	add_player (NewSocket * ns)
326	{
327	player *p;	375	player *
		376	player::create ()
		377	{
		378	player *pl = new player;
328		379
329	p = get_player (NULL);	380	pl->set_object (arch_to_object (get_player_archetype (0)));
330	p->socket = *ns;
331	p->socket.faces_sent = (uint8 *) malloc (p->socket.faces_sent_len * sizeof (*p->socket.faces_sent));
332
333	if (p->socket.faces_sent == NULL)
334	fatal (OUT_OF_MEMORY);
335
336	memcpy (p->socket.faces_sent, ns->faces_sent, p->socket.faces_sent_len * sizeof (*p->socket.faces_sent));
337	/* Needed because the socket we just copied over needs to be cleared.
338	* Note that this can result in a client reset if there is partial data
339	* on the uncoming socket.
340	*/
341	p->socket.inbuf.len = 0;
342	set_first_map (p->ob);	381	set_first_map (pl->ob);
343		382
344	CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
345	add_friendly_object (p->ob);
346	send_rules (p->ob);
347	send_news (p->ob);
348	display_motd (p->ob);
349	get_name (p->ob);
350
351	return 0;	383	return pl;
352	}	384	}
353		385
354	/*	386	/*
355	* get_player_archetype() return next player archetype from archetype	387	* get_player_archetype() return next player archetype from archetype
356	* list. Not very efficient routine, but used only creating new players.	388	* list. Not very efficient routine, but used only creating new players.
…		…
365	{	397	{
366	if (at == NULL || at->next == NULL)	398	if (at == NULL || at->next == NULL)
367	at = first_archetype;	399	at = first_archetype;
368	else	400	else
369	at = at->next;	401	at = at->next;
		402
370	if (at->clone.type == PLAYER)	403	if (at->clone.type == PLAYER)
371	return at;	404	return at;
		405
372	if (at == start)	406	if (at == start)
373	{	407	{
374	LOG (llevError, "No Player archetypes\n");	408	LOG (llevError, "No Player archetypes\n");
375	exit (-1);	409	exit (-1);
376	}	410	}
377	}	411	}
378	}	412	}
379		413
380
381	object *	414	object *
382	get_nearest_player (object *mon)	415	get_nearest_player (object *mon)
383	{	416	{
384	object *op = NULL;	417	object *op = NULL;
385	player *pl = NULL;
386	objectlink *ol;	418	objectlink *ol;
387	unsigned lastdist;	419	unsigned lastdist;
388	rv_vector rv;	420	rv_vector rv;
389		421
390	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)
…		…
422	{	454	{
423	op = ol->ob;	455	op = ol->ob;
424	lastdist = rv.distance;	456	lastdist = rv.distance;
425	}	457	}
426	}	458	}
427	for (pl = first_player; pl != NULL; pl = pl->next)	459
428	{	460	for_all_players (pl)
429	if (can_detect_enemy (mon, pl->ob, &rv))	461	if (can_detect_enemy (mon, pl->ob, &rv))
430	{
431
432	if (lastdist > rv.distance)	462	if (lastdist > rv.distance)
433	{	463	{
434	op = pl->ob;	464	op = pl->ob;
435	lastdist = rv.distance;	465	lastdist = rv.distance;
436	}	466	}
437	}	467
438	}
439	#if 0	468	#if 0
440	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)");
441	#endif	470	#endif
442	return op;	471	return op;
443	}	472	}
…		…
461	* circling behaviour. Unfortunately, this function is also used to determined	490	* circling behaviour. Unfortunately, this function is also used to determined
462	* 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
463	* is probably not a good thing.	492	* is probably not a good thing.
464	*/	493	*/
465	#define MAX_SPACES 50	494	#define MAX_SPACES 50
466
467		495
468	/*	496	/*
469	* Returns the direction to the player, if valid. Returns 0 otherwise.	497	* Returns the direction to the player, if valid. Returns 0 otherwise.
470	* 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
471	* 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
…		…
644	(op->type == ARMOUR || op->type == BOOTS ||	672	(op->type == ARMOUR || op->type == BOOTS ||
645	op->type == CLOAK || op->type == HELMET ||	673	op->type == CLOAK || op->type == HELMET ||
646	op->type == SHIELD || op->type == GLOVES ||	674	op->type == SHIELD || op->type == GLOVES ||
647	op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON))	675	op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON))
648	{	676	{
649	remove_ob (op);	677	op->destroy ();
650	free_object (op);
651	continue;	678	continue;
652	}	679	}
653	}	680	}
654		681
655	/* This really needs to be better - we should really give	682	/* This really needs to be better - we should really give
…		…
666	if (tmp->type == op->type && tmp->name == op->name)	693	if (tmp->type == op->type && tmp->name == op->name)
667	break;	694	break;
668		695
669	if (tmp)	696	if (tmp)
670	{	697	{
671	remove_ob (op);	698	op->destroy ();
672	free_object (op);
673	LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name);	699	LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name);
674	continue;	700	continue;
675	}	701	}
		702
676	if (op->nrof > 1)	703	if (op->nrof > 1)
677	op->nrof = 1;	704	op->nrof = 1;
678	}	705	}
679		706
680	if (op->type == SPELLBOOK && op->inv)	707	if (op->type == SPELLBOOK && op->inv)
…		…
692	CLEAR_FLAG (op, FLAG_CURSED);	719	CLEAR_FLAG (op, FLAG_CURSED);
693	CLEAR_FLAG (op, FLAG_DAMNED);	720	CLEAR_FLAG (op, FLAG_DAMNED);
694	}	721	}
695	if (op->type == SPELL)	722	if (op->type == SPELL)
696	{	723	{
697	remove_ob (op);	724	op->destroy ();
698	free_object (op);
699	continue;	725	continue;
700	}	726	}
701	else if (op->type == SKILL)	727	else if (op->type == SKILL)
702	{	728	{
703	SET_FLAG (op, FLAG_CAN_USE_SKILL);	729	SET_FLAG (op, FLAG_CAN_USE_SKILL);
…		…
712	/* Need to set up the skill pointers */	738	/* Need to set up the skill pointers */
713	link_player_skills (pl);	739	link_player_skills (pl);
714	}	740	}
715		741
716	void	742	void
717	get_name (object *op)
718	{
719	op->contr->write_buf[0] = '\0';
720	op->contr->state = ST_GET_NAME;
721	send_query (&op->contr->socket, 0, "What is your name?\n:");
722	}
723
724	void
725	get_password (object *op)
726	{
727	op->contr->write_buf[0] = '\0';
728	op->contr->state = ST_GET_PASSWORD;
729	send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
730	}
731
732	void
733	play_again (object *op)
734	{
735	op->contr->state = ST_PLAY_AGAIN;
736	op->chosen_skill = NULL;
737	send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
738	/* a bit of a hack, but there are various places early in th
739	* player creation process that a user can quit (eg, roll
740	* stats) that isn't removing the player. Taking a quick
741	* look, there are many places that call play_again without
742	* removing the player - it probably makes more sense
743	* to leave it to play_again to remove the object in all
744	* cases.
745	*/
746	if (!QUERY_FLAG (op, FLAG_REMOVED))
747	remove_ob (op);
748	/* Need to set this to null - otherwise, it could point to garbage,
749	* and draw() doesn't check to see if the player is removed, only if
750	* the map is null or not swapped out.
751	*/
752	op->map = NULL;
753	}
754
755	int
756	receive_play_again (object *op, char key)
757	{
758	if (key == 'q' || key == 'Q')
759	{
760	remove_friendly_object (op);
761	leave (op->contr, 0); /* ericserver will draw the message */
762	return 2;
763	}
764	else if (key == 'a' || key == 'A')
765	{
766	player *pl = op->contr;
767	shstr name = op->name;
768
769	op->contr = 0;
770	op->type = 0;
771	op->destroy (1);
772	pl = get_player (pl);
773	op = pl->ob;
774	add_friendly_object (op);
775	op->contr->password[0] = '~';
776	op->name = op->name_pl = 0;
777	/* Lets put a space in here */
778	new_draw_info (NDI_UNIQUE, 0, op, "\n");
779	get_name (op);
780	op->name = op->name_pl = name;
781	set_first_map (op);
782	}
783	else
784	/* user pressed something else so just ask again... */
785	play_again (op);
786
787	return 0;
788	}
789
790	void
791	confirm_password (object *op)
792	{
793
794	op->contr->write_buf[0] = '\0';
795	op->contr->state = ST_CONFIRM_PASSWORD;
796	send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
797	}
798
799	void
800	get_party_password (object *op, partylist *party)	743	get_party_password (object *op, partylist *party)
801	{	744	{
802	if (party == NULL)	745	if (party == NULL)
803	{	746	{
804	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);
805	return;	748	return;
806	}	749	}
		750
807	op->contr->write_buf[0] = '\0';	751	op->contr->write_buf[0] = '\0';
808	op->contr->state = ST_GET_PARTY_PASSWORD;	752	op->contr->ns->state = ST_GET_PARTY_PASSWORD;
809	op->contr->party_to_join = party;	753	op->contr->party_to_join = party;
810	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:");
811	}	755	}
812
813		756
814	/* 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. */
815	int	758	static int
816	roll_stat (void)	759	roll_stat (void)
817	{	760	{
818	int a[4], i, j, k;	761	int a[4], i, j, k;
819		762
820	for (i = 0; i < 4; i++)	763	for (i = 0; i < 4; i++)
…		…
823	for (i = 0, j = 0, k = 7; i < 4; i++)	766	for (i = 0, j = 0, k = 7; i < 4; i++)
824	if (a[i] < k)	767	if (a[i] < k)
825	k = a[i], j = i;	768	k = a[i], j = i;
826		769
827	for (i = 0, k = 0; i < 4; i++)	770	for (i = 0, k = 0; i < 4; i++)
828	{
829	if (i != j)	771	if (i != j)
830	k += a[i];	772	k += a[i];
831	}	773
832	return k;	774	return k;
833	}	775	}
834		776
835	void	777	void
836	roll_stats (object *op)	778	object::roll_stats ()
837	{	779	{
838	int sum = 0;
839	int i = 0, j = 0;
840	int statsort[7];	780	int statsort [7];
841		781
842	do	782	for (;;)
843	{
844	op->stats.Str = roll_stat ();
845	op->stats.Dex = roll_stat ();
846	op->stats.Int = roll_stat ();
847	op->stats.Con = roll_stat ();
848	op->stats.Wis = roll_stat ();
849	op->stats.Pow = roll_stat ();
850	op->stats.Cha = roll_stat ();
851	sum = op->stats.Str + op->stats.Dex + op->stats.Int + op->stats.Con + op->stats.Wis + op->stats.Pow + op->stats.Cha;
852	}	783	{
853	while (sum < 82 || sum > 116);	784	int sum = 0;
		785	for (int i = 7; i--; )
		786	sum += statsort [i] = roll_stat ();
854		787
		788	if (sum >= 82 && sum <= 116)
		789	break;
		790	}
		791
855	/* Sort the stats so that rerolling is easier... */	792	// Sort the stats so that rerolling is easier...
856	statsort[0] = op->stats.Str;	793	std::sort (statsort, statsort + 7, std::greater<int>());
857	statsort[1] = op->stats.Dex;
858	statsort[2] = op->stats.Int;
859	statsort[3] = op->stats.Con;
860	statsort[4] = op->stats.Wis;
861	statsort[5] = op->stats.Pow;
862	statsort[6] = op->stats.Cha;
863		794
864	/* a quick and dirty bubblesort? */
865	do
866	{
867	if (statsort[i] < statsort[i + 1])
868	{
869	j = statsort[i];
870	statsort[i] = statsort[i + 1];
871	statsort[i + 1] = j;
872	i = 0;
873	}
874	else
875	{
876	i++;
877	}
878	}
879	while (i < 6);
880
881	op->stats.Str = statsort[0];	795	stats.Str = statsort[0];
882	op->stats.Dex = statsort[1];	796	stats.Dex = statsort[1];
883	op->stats.Con = statsort[2];	797	stats.Con = statsort[2];
884	op->stats.Int = statsort[3];	798	stats.Int = statsort[3];
885	op->stats.Wis = statsort[4];	799	stats.Wis = statsort[4];
886	op->stats.Pow = statsort[5];	800	stats.Pow = statsort[5];
887	op->stats.Cha = statsort[6];	801	stats.Cha = statsort[6];
888		802
889
890	op->contr->orig_stats.Str = op->stats.Str;
891	op->contr->orig_stats.Dex = op->stats.Dex;
892	op->contr->orig_stats.Int = op->stats.Int;
893	op->contr->orig_stats.Con = op->stats.Con;
894	op->contr->orig_stats.Wis = op->stats.Wis;
895	op->contr->orig_stats.Pow = op->stats.Pow;
896	op->contr->orig_stats.Cha = op->stats.Cha;
897
898	op->level = 1;
899	op->stats.exp = 0;	803	stats.exp = 0;
900	op->stats.ac = 0;	804	stats.ac = 0;
901		805
902	op->contr->levhp[1] = 9;
903	op->contr->levsp[1] = 6;
904	op->contr->levgrace[1] = 3;
905
906	fix_player (op);
907	op->stats.hp = op->stats.maxhp;	806	stats.hp = stats.maxhp;
908	op->stats.sp = op->stats.maxsp;	807	stats.sp = stats.maxsp;
909	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
910	op->contr->orig_stats = op->stats;	816	contr->orig_stats = stats;
		817	}
911	}	818	}
912		819
913	void	820	void
914	Roll_Again (object *op)	821	object::swap_stats (int a, int b)
915	{	822	{
916	esrv_new_player (op->contr, 0);	823	int tmp = get_attr_value (&contr->orig_stats, a);
917	send_query (&op->contr->socket, CS_QUERY_SINGLECHAR,	824	set_attr_value (&contr->orig_stats, a, get_attr_value (&contr->orig_stats, b));
918	"[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);
919	}
920		826
921	void	827	stats.Str = contr->orig_stats.Str;
922	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)
923	{	859	{
924	signed char tmp;
925	char buf[MAX_BUF];	860	char buf[MAX_BUF];
926		861
927	if (op->contr->Swap_First == -1)	862	sprintf (buf, "Welcome to Crossfire v%s!", VERSION);
928	{
929	new_draw_info (NDI_UNIQUE, 0, op, "How the hell did you get here?!?!!!");
930	new_draw_info (NDI_UNIQUE, 0, op, "Error in Swap_Stat code,");
931	new_draw_info (NDI_UNIQUE, 0, op, "mail korg@rdt.monash.edu.au");
932	return;
933	}
934
935	tmp = get_attr_value (&op->contr->orig_stats, op->contr->Swap_First);
936
937	set_attr_value (&op->contr->orig_stats, op->contr->Swap_First, get_attr_value (&op->contr->orig_stats, Swap_Second));
938
939	set_attr_value (&op->contr->orig_stats, Swap_Second, tmp);
940
941	sprintf (buf, "%s done\n", short_stat_name[Swap_Second]);
942	new_draw_info (NDI_UNIQUE, 0, op, buf);	863	new_draw_info (NDI_UNIQUE, 0, op, buf);
943	op->stats.Str = op->contr->orig_stats.Str;	864	//new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
944	op->stats.Dex = op->contr->orig_stats.Dex;
945	op->stats.Con = op->contr->orig_stats.Con;
946	op->stats.Int = op->contr->orig_stats.Int;
947	op->stats.Wis = op->contr->orig_stats.Wis;
948	op->stats.Pow = op->contr->orig_stats.Pow;
949	op->stats.Cha = op->contr->orig_stats.Cha;
950	op->stats.ac = 0;
951
952	op->level = 1;
953	op->stats.exp = 0;
954	op->stats.ac = 0;
955
956	op->contr->levhp[1] = 9;
957	op->contr->levsp[1] = 6;
958	op->contr->levgrace[1] = 3;
959
960	fix_player (op);
961	op->stats.hp = op->stats.maxhp;
962	op->stats.sp = op->stats.maxsp;
963	op->stats.grace = op->stats.maxgrace;
964	op->contr->orig_stats = op->stats;
965	op->contr->Swap_First = -1;
966	}
967
968
969	/* This code has been greatly reduced, because with set_attr_value
970	* and get_attr_value, the stats can be accessed just numeric
971	* ids. stat_trans is a table that translate the number entered
972	* into the actual stat. It is needed because the order the stats
973	* are displayed in the stat window is not the same as how
974	* the number's access that stat. The table does that translation.
975	*/
976	int
977	key_roll_stat (object *op, char key)
978	{
979	int keynum = key - '0';
980	char buf[MAX_BUF];
981	static sint8 stat_trans[] = { -1, STR, DEX, CON, INT, WIS, POW, CHA };
982
983	if (keynum > 0 && keynum <= 7)
984	{
985	if (op->contr->Swap_First == -1)
986	{
987	op->contr->Swap_First = stat_trans[keynum];
988	sprintf (buf, "%s ->", short_stat_name[stat_trans[keynum]]);
989	new_draw_info (NDI_UNIQUE, 0, op, buf);	865	//new_draw_info (NDI_UNIQUE, 0, op, " ");
990	}
991	else
992	Swap_Stat (op, stat_trans[keynum]);
993
994	send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "");
995	return 1;
996	}
997	switch (key)
998	{
999	case 'n':
1000	case 'N':
1001	{
1002	SET_FLAG (op, FLAG_WIZ);
1003	if (op->map == NULL)
1004	{
1005	LOG (llevError, "Map == NULL in state 2\n");
1006	break;
1007	}
1008
1009	#if 0
1010	/* So that enter_exit will put us at startx/starty */
1011	op->x = -1;
1012
1013	enter_exit (op, NULL);
1014	#endif
1015	SET_ANIMATION (op, 2); /* So player faces south */
1016	/* Enter exit adds a player otherwise */
1017	add_statbonus (op);
1018	send_query (&op->contr->socket, CS_QUERY_SINGLECHAR,
1019	"Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
1020	op->contr->state = ST_CHANGE_CLASS;
1021	if (op->msg)
1022	new_draw_info (NDI_BLUE, 0, op, op->msg);
1023	return 0;
1024	}
1025	case 'y':
1026	case 'Y':
1027	roll_stats (op);
1028	send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "");
1029	return 1;
1030
1031	case 'q':
1032	case 'Q':
1033	play_again (op);
1034	return 1;
1035
1036	default:
1037	send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1038	return 0;
1039	}
1040	return 0;
1041	}	866	}
1042		867
1043	/* This function takes the key that is passed, and does the	868	/* This function takes the key that is passed, and does the
1044	* appropriate action with it (change race, or other things).	869	* appropriate action with it (change race, or other things).
1045	* The function name is for historical reasons - now we have	870	* The function name is for historical reasons - now we have
1046	* separate race and class; this actually changes the RACE,	871	* separate race and class; this actually changes the RACE,
1047	* not the class.	872	* not the class.
1048	*/	873	*/
1049
1050	int	874	int
1051	key_change_class (object *op, char key)	875	key_change_class (object *op, char key)
1052	{	876	{
1053	int tmp_loop;	877	int tmp_loop;
1054		878
1055	if (key == 'q' || key == 'Q')
1056	{
1057	remove_ob (op);
1058	play_again (op);
1059	return 0;
1060	}
1061	if (key == 'd' || key == 'D')	879	if (key == 'd' || key == 'D')
1062	{	880	{
1063	char buf[MAX_BUF];	881	char buf[MAX_BUF];
1064		882
1065	/* this must before then initial items are given */	883	/* this must before then initial items are given */
1066	esrv_new_player (op->contr, op->weight + op->carrying);	884	esrv_new_player (op->contr, op->weight + op->carrying);
		885
1067	create_treasure (find_treasurelist ("starting_wealth"), op, 0, 0, 0);	886	treasurelist *tl = find_treasurelist ("starting_wealth");
		887	if (tl)
		888	create_treasure (tl, op, 0, 0, 0);
1068		889
1069	INVOKE_PLAYER (BIRTH, op->contr);	890	INVOKE_PLAYER (BIRTH, op->contr);
1070	INVOKE_PLAYER (LOGIN, op->contr);	891	INVOKE_PLAYER (LOGIN, op->contr);
1071		892
1072	op->contr->state = ST_PLAYING;	893	op->contr->ns->state = ST_PLAYING;
1073		894
1074	if (op->msg)	895	if (op->msg)
1075	op->msg = NULL;	896	op->msg = NULL;
1076		897
1077	/* 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
…		…
1086	start_info (op);	907	start_info (op);
1087	CLEAR_FLAG (op, FLAG_WIZ);	908	CLEAR_FLAG (op, FLAG_WIZ);
1088	give_initial_items (op, op->randomitems);	909	give_initial_items (op, op->randomitems);
1089	link_player_skills (op);	910	link_player_skills (op);
1090	esrv_send_inventory (op, op);	911	esrv_send_inventory (op, op);
1091	fix_player (op);	912	op->update_stats ();
1092		913
1093	/* This moves the player to a different start map, if there	914	/* This moves the player to a different start map, if there
1094	* is one for this race	915	* is one for this race
1095	*/	916	*/
1096	if (*first_map_ext_path)	917	if (*first_map_ext_path)
1097	{	918	{
1098	object *tmp;	919	object *tmp;
1099	char mapname[MAX_BUF];	920	char mapname[MAX_BUF];
1100		921
1101	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);
1102	tmp = get_object ();	923	tmp = object::create ();
1103	EXIT_PATH (tmp) = mapname;	924	EXIT_PATH (tmp) = mapname;
1104	EXIT_X (tmp) = op->x;	925	EXIT_X (tmp) = op->x;
1105	EXIT_Y (tmp) = op->y;	926	EXIT_Y (tmp) = op->y;
1106	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;
1107	* if the map isn't there, then stay on the	928	* if the map isn't there, then stay on the
1108	* default initial map */	929	* default initial map */
1109	free_object (tmp);	930	tmp->destroy ();
1110	}	931	}
1111	else	932	else
1112	{
1113	LOG (llevDebug, "first_map_ext_path not set\n");	933	LOG (llevDebug, "first_map_ext_path not set\n");
1114	}	934
1115	return 0;	935	return 0;
1116	}	936	}
1117		937
1118	/* Following actually changes the race - this is the default command	938	/* Following actually changes the race - this is the default command
1119	* if we don't match with one of the options above.	939	* if we don't match with one of the options above.
…		…
1123	while (!tmp_loop)	943	while (!tmp_loop)
1124	{	944	{
1125	shstr name = op->name;	945	shstr name = op->name;
1126	int x = op->x, y = op->y;	946	int x = op->x, y = op->y;
1127		947
1128	remove_statbonus (op);	948	op->remove_statbonus ();
1129	remove_ob (op);	949	op->remove ();
1130	op->arch = get_player_archetype (op->arch);	950	op->arch = get_player_archetype (op->arch);
1131	copy_object (&op->arch->clone, op);	951	op->arch->clone.copy_to (op);
1132	op->instantiate ();	952	op->instantiate ();
1133	op->stats = op->contr->orig_stats;	953	op->stats = op->contr->orig_stats;
1134	op->name = op->name_pl = name;	954	op->name = op->name_pl = name;
1135	op->x = x;	955	op->x = x;
1136	op->y = y;	956	op->y = y;
1137	SET_ANIMATION (op, 2); /* So player faces south */	957	SET_ANIMATION (op, 2); /* So player faces south */
1138	insert_ob_in_map (op, op->map, op, 0);	958	insert_ob_in_map (op, op->map, op, 0);
1139	assign (op->contr->title, op->arch->clone.name);	959	assign (op->contr->title, op->arch->clone.name);
1140	add_statbonus (op);	960	op->add_statbonus ();
1141	tmp_loop = allowed_class (op);	961	tmp_loop = allowed_class (op);
1142	}	962	}
1143		963
1144	update_object (op, UP_OBJ_FACE);	964	update_object (op, UP_OBJ_FACE);
1145	esrv_update_item (UPD_FACE, op, op);	965	esrv_update_item (UPD_FACE, op, op);
1146	fix_player (op);	966	op->update_stats ();
1147	op->stats.hp = op->stats.maxhp;	967	op->stats.hp = op->stats.maxhp;
1148	op->stats.sp = op->stats.maxsp;	968	op->stats.sp = op->stats.maxsp;
1149	op->stats.grace = 0;	969	op->stats.grace = 0;
1150		970
1151	if (op->msg)	971	if (op->msg)
1152	new_draw_info (NDI_BLUE, 0, op, op->msg);	972	new_draw_info (NDI_BLUE, 0, op, op->msg);
1153		973
1154	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");
1155	return 0;	975	return 0;
1156	}
1157
1158	int
1159	key_confirm_quit (object *op, char key)
1160	{
1161	char buf[MAX_BUF];
1162
1163	if (key != 'y' && key != 'Y' && key != 'q' && key != 'Q')
1164	{
1165	op->contr->state = ST_PLAYING;
1166	new_draw_info (NDI_UNIQUE, 0, op, "OK, continuing to play.");
1167	return 1;
1168	}
1169
1170	INVOKE_PLAYER (LOGOUT, op->contr);
1171	INVOKE_PLAYER (QUIT, op->contr);
1172
1173	terminate_all_pets (op);
1174	leave_map (op);
1175	op->direction = 0;
1176	new_draw_info_format (NDI_UNIQUE | NDI_ALL, 5, NULL, "%s quits the game.", &op->name);
1177
1178	strcpy (op->contr->killer, "quit");
1179	check_score (op);
1180	op->contr->party = NULL;
1181	if (settings.set_title == TRUE)
1182	op->contr->own_title[0] = '\0';
1183
1184	if (!QUERY_FLAG (op, FLAG_WAS_WIZ))
1185	{
1186	maptile *mp, *next;
1187
1188	/* We need to hunt for any per player unique maps in memory and
1189	* get rid of them. The trailing slash in the path is intentional,
1190	* so that players named 'Ab' won't match against players 'Abe' pathname
1191	*/
1192	sprintf (buf, "%s/%s/%s/", settings.localdir, settings.playerdir, &op->name);
1193	for (mp = first_map; mp != NULL; mp = next)
1194	{
1195	next = mp->next;
1196	if (!strncmp (mp->path, buf, strlen (buf)))
1197	delete_map (mp);
1198	}
1199
1200	delete_character (op->name, 1);
1201	}
1202
1203	play_again (op);
1204	return 1;
1205	}	976	}
1206		977
1207	void	978	void
1208	flee_player (object *op)	979	flee_player (object *op)
1209	{	980	{
…		…
1239	{	1010	{
1240	op->enemy = NULL;	1011	op->enemy = NULL;
1241	CLEAR_FLAG (op, FLAG_SCARED);	1012	CLEAR_FLAG (op, FLAG_SCARED);
1242	return;	1013	return;
1243	}	1014	}
		1015
1244	get_rangevector (op, op->enemy, &rv, 0);	1016	get_rangevector (op, op->enemy, &rv, 0);
1245		1017
1246	dir = absdir (4 + rv.direction);	1018	dir = absdir (4 + rv.direction);
1247	for (diff = 0; diff < 3; diff++)	1019	for (diff = 0; diff < 3; diff++)
1248	{	1020	{
1249	int m = 1 - (RANDOM () & 2);	1021	int m = 1 - (RANDOM () & 2);
1250		1022
1251	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)))
1252	{
1253	return;	1024	return;
1254	}
1255	}	1025	}
		1026
1256	/* Cornered, get rid of scared */	1027	/* Cornered, get rid of scared */
1257	CLEAR_FLAG (op, FLAG_SCARED);	1028	CLEAR_FLAG (op, FLAG_SCARED);
1258	op->enemy = NULL;	1029	op->enemy = NULL;
1259	}	1030	}
1260		1031
…		…
1346	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1117	sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1347	&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))));
1348	else	1119	else
1349	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1120	sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1350	&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
1351	new_draw_info (NDI_UNIQUE, 0, op, putstring);	1123	new_draw_info (NDI_UNIQUE, 0, op, putstring);
1352
1353	sprintf (putstring, "...flags: ");
1354	for (k = 0; k < 4; k++)
1355	{
1356	for (j = 0; j < 32; j++)
1357	{
1358	if ((tmp->flags[k] >> j) & 0x01)
1359	{
1360	sprintf (tmpstr, "%d ", k * 32 + j);
1361	strcat (putstring, tmpstr);
1362	}
1363	}
1364	}
1365	new_draw_info (NDI_UNIQUE, 0, op, putstring);
1366
1367	#if 0
1368	/* print the flags too */
1369	for (k = 0; k < 4; k++)
1370	{
1371	fprintf (stderr, "%d [%d] ", k, k * 32 + 31);
1372	for (j = 0; j < 32; j++)
1373	{
1374	fprintf (stderr, "%d", tmp->flags[k] >> (31 - j) & 0x01);
1375	if (!((j + 1) % 4))
1376	fprintf (stderr, " ");
1377	}
1378	fprintf (stderr, " [%d]\n", k * 32);
1379	}
1380	#endif
1381	}	1124	}
		1125
1382	/* philosophy:	1126	/* philosophy:
1383	* 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
1384	* generic. This takes no game-time. For more detailed pickups	1128	* generic. This takes no game-time. For more detailed pickups
1385	* and selections, select-items shoul dbe used. This is a	1129	* and selections, select-items should be used. This is a
1386	* 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
1387	* example.	1131	* example.
1388	* 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
1389	* 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
1390	* convert to decimal and then 'pickup <#>	1134	* convert to decimal and then 'pickup <#>
…		…
1816	if (!dir)	1560	if (!dir)
1817	{	1561	{
1818	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!");
1819	return 0;	1563	return 0;
1820	}	1564	}
		1565
1821	if (op->type == PLAYER)	1566	if (op->type == PLAYER)
1822	bow = op->contr->ranges[range_bow];	1567	bow = op->contr->ranges[range_bow];
1823	else	1568	else
1824	{	1569	{
1825	for (bow = op->inv; bow; bow = bow->below)	1570	for (bow = op->inv; bow; bow = bow->below)
…		…
1833	{	1578	{
1834	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);	1579	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1835	return 0;	1580	return 0;
1836	}	1581	}
1837	}	1582	}
		1583
1838	if (!bow->race || !bow->skill)	1584	if (!bow->race || !bow->skill)
1839	{	1585	{
1840	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);
1841	return 0;	1587	return 0;
1842	}	1588	}
…		…
1844	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];	1590	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];
1845		1591
1846	/* penalize ROF for bestarrow */	1592	/* penalize ROF for bestarrow */
1847	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)	1593	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)
1848	bowspeed -= dex_bonus[op->stats.Dex] + 5;	1594	bowspeed -= dex_bonus[op->stats.Dex] + 5;
		1595
1849	if (bowspeed < 1)	1596	if (bowspeed < 1)
1850	bowspeed = 1;	1597	bowspeed = 1;
1851		1598
1852	if (arrow == NULL)	1599	if (arrow == NULL)
1853	{	1600	{
…		…
1859	else	1606	else
1860	CLEAR_FLAG (op, FLAG_READY_BOW);	1607	CLEAR_FLAG (op, FLAG_READY_BOW);
1861	return 0;	1608	return 0;
1862	}	1609	}
1863	}	1610	}
		1611
1864	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);	1612	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1865	if (mflags & P_OUT_OF_MAP)	1613	if (mflags & P_OUT_OF_MAP)
1866	{
1867	return 0;	1614	return 0;
1868	}	1615
1869	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)	1616	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1870	{	1617	{
1871	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.");
1872	return 0;	1619	return 0;
1873	}	1620	}
1874		1621
1875	/* this should not happen, but sometimes does */	1622	/* this should not happen, but sometimes does */
1876	if (arrow->nrof == 0)	1623	if (arrow->nrof == 0)
1877	{	1624	{
1878	remove_ob (arrow);	1625	arrow->destroy ();
1879	free_object (arrow);
1880	return 0;	1626	return 0;
1881	}	1627	}
1882		1628
1883	left = arrow; /* these are arrows left to the player */	1629	left = arrow; /* these are arrows left to the player */
1884	arrow = get_split_ob (arrow, 1);	1630	arrow = get_split_ob (arrow, 1);
1885	if (arrow == NULL)	1631	if (!arrow)
1886	{	1632	{
1887	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);
1888	return 0;	1634	return 0;
1889	}	1635	}
1890	set_owner (arrow, op);	1636
		1637	arrow->set_owner (op);
1891	arrow->skill = bow->skill;	1638	arrow->skill = bow->skill;
1892
1893	arrow->direction = dir;	1639	arrow->direction = dir;
1894	arrow->x = sx;
1895	arrow->y = sy;
1896		1640
1897	if (op->type == PLAYER)	1641	if (op->type == PLAYER)
1898	{	1642	{
1899	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;	1643	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;
1900	fix_player (op);	1644	op->update_stats ();
1901	}	1645	}
1902		1646
1903	SET_ANIMATION (arrow, arrow->direction);	1647	SET_ANIMATION (arrow, arrow->direction);
1904	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */	1648	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1905	arrow->stats.hp = arrow->stats.dam;	1649	arrow->stats.hp = arrow->stats.dam;
1906	arrow->stats.grace = arrow->attacktype;	1650	arrow->stats.grace = arrow->attacktype;
1907	if (arrow->slaying != NULL)	1651	if (arrow->slaying != NULL)
1908	arrow->spellarg = strdup_local (arrow->slaying);	1652	arrow->spellarg = strdup (arrow->slaying);
1909		1653
1910	/* Note that this was different for monsters - they got their level	1654	/* Note that this was different for monsters - they got their level
1911	* added to the damage. I think the strength bonus is more proper.	1655	* added to the damage. I think the strength bonus is more proper.
1912	*/	1656	*/
1913		1657
…		…
1915		1659
1916	/* update the speed */	1660	/* update the speed */
1917	arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?	1661	arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?
1918	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;
1919		1663
1920	if (arrow->speed < 1.0)	1664	arrow->set_speed (max (arrow->speed, 1.0));
1921	arrow->speed = 1.0;
1922	update_ob_speed (arrow);
1923	arrow->speed_left = 0;	1665	arrow->speed_left = 0;
1924		1666
1925	if (op->type == PLAYER)	1667	if (op->type == PLAYER)
1926	{	1668	{
1927	arrow->stats.wc = 20 - bow->magic - arrow->magic -	1669	arrow->stats.wc = 20 - bow->magic - arrow->magic -
…		…
1937	}	1679	}
1938		1680
1939	if (arrow->attacktype == AT_PHYSICAL)	1681	if (arrow->attacktype == AT_PHYSICAL)
1940	arrow->attacktype |= bow->attacktype;	1682	arrow->attacktype |= bow->attacktype;
1941		1683
1942	if (bow->slaying != NULL)	1684	if (bow->slaying)
1943	arrow->slaying = bow->slaying;	1685	arrow->slaying = bow->slaying;
1944		1686
1945	arrow->map = m;
1946	arrow->move_type = MOVE_FLY_LOW;	1687	arrow->move_type = MOVE_FLY_LOW;
1947	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;	1688	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1948		1689
1949	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);
1950	insert_ob_in_map (arrow, m, op, 0);	1691	m->insert (arrow, sx, sy, op);
1951		1692
1952	if (!arrow->destroyed ())	1693	if (!arrow->destroyed ())
1953	move_arrow (arrow);	1694	move_arrow (arrow);
1954		1695
1955	if (op->type == PLAYER)	1696	if (op->type == PLAYER)
…		…
1981	}	1722	}
1982	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)
1983	{	1724	{
1984	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))	1725	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))
1985	wcmod = -1;	1726	wcmod = -1;
		1727
1986	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);
1987	}	1729	}
1988	else if (op->contr->bowtype == bow_threewide)	1730	else if (op->contr->bowtype == bow_threewide)
1989	{	1731	{
1990	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);
…		…
2060		1802
2061	if (item->arch)	1803	if (item->arch)
2062	{	1804	{
2063	CLEAR_FLAG (item, FLAG_ANIMATE);	1805	CLEAR_FLAG (item, FLAG_ANIMATE);
2064	item->face = item->arch->clone.face;	1806	item->face = item->arch->clone.face;
2065	item->speed = 0;	1807	item->set_speed (0);
2066	update_ob_speed (item);
2067	}	1808	}
		1809
2068	if ((tmp = is_player_inv (item)))	1810	if ((tmp = item->in_player ()))
2069	esrv_update_item (UPD_ANIM, tmp, item);	1811	esrv_update_item (UPD_ANIM, tmp, item);
2070	}	1812	}
2071	}	1813	}
2072	else if (item->type == ROD || item->type == HORN)	1814	else if (item->type == ROD || item->type == HORN)
2073	{
2074	drain_rod_charge (item);	1815	drain_rod_charge (item);
2075	}
2076	}	1816	}
2077	}	1817	}
2078		1818
2079	/* Received a fire command for the player - go and do it.	1819	/* Received a fire command for the player - go and do it.
2080	*/	1820	*/
…		…
2223	* 0 otherwise	1963	* 0 otherwise
2224	*/	1964	*/
2225	static int	1965	static int
2226	player_attack_door (object *op, object *door)	1966	player_attack_door (object *op, object *door)
2227	{	1967	{
2228
2229	/* 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,
2230	* 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 -
2231	* otherwise, we fall through to the rest of the code.	1970	* otherwise, we fall through to the rest of the code.
2232	*/	1971	*/
2233	object *key = find_key (op, op, door);	1972	object *key = find_key (op, op, door);
…		…
2271	* It should keep the code cleaner.	2010	* It should keep the code cleaner.
2272	* When this is called, the players direction has been updated	2011	* When this is called, the players direction has been updated
2273	* (taking into account confusion.) The player is also actually	2012	* (taking into account confusion.) The player is also actually
2274	* going to try and move (not fire weapons).	2013	* going to try and move (not fire weapons).
2275	*/	2014	*/
2276
2277	void	2015	void
2278	move_player_attack (object *op, int dir)	2016	move_player_attack (object *op, int dir)
2279	{	2017	{
2280	object *tmp, *mon;	2018	object *tmp, *mon;
2281	sint16 nx, ny;	2019	sint16 nx, ny;
…		…
2283	maptile *m;	2021	maptile *m;
2284		2022
2285	nx = freearr_x[dir] + op->x;	2023	nx = freearr_x[dir] + op->x;
2286	ny = freearr_y[dir] + op->y;	2024	ny = freearr_y[dir] + op->y;
2287		2025
2288	on_battleground = op_on_battleground (op, NULL, NULL);	2026	on_battleground = op_on_battleground (op, 0, 0);
2289		2027
2290	/* 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
2291	* 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
2292	* 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
2293	* player. This is a pretty nasty hack, because if we could	2031	* player. This is a pretty nasty hack, because if we could
…		…
2298	*/	2036	*/
2299	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))
2300	{	2038	{
2301	if (OUT_OF_REAL_MAP (op->map, nx, ny))	2039	if (OUT_OF_REAL_MAP (op->map, nx, ny))
2302	{	2040	{
2303	m = get_map_from_coord (op->map, &nx, &ny);	2041	m = op->map->xy_find (nx, ny);
2304	if (!m)	2042	if (!m)
2305	return; /* Don't think this should happen */	2043	return; /* Don't think this should happen */
2306	}	2044	}
2307	else	2045	else
2308	m = op->map;	2046	m = op->map;
2309		2047
2310	if ((tmp = get_map_ob (m, nx, ny)) == NULL)	2048	if (!(tmp = m->at (nx, ny).bot))
2311	{
2312	/* LOG(llevError,"player_move_attack: get_map_ob returns NULL, but player can not more there.\n"); */
2313	return;	2049	return;
2314	}
2315		2050
2316	mon = NULL;	2051	mon = 0;
2317	/* 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
2318	* 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.
2319	* 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
2320	* on the space	2055	* on the space
2321	*/	2056	*/
2322	while (tmp != NULL)	2057	while (tmp)
2323	{	2058	{
2324	if (tmp == op)	2059	if (tmp == op)
2325	{	2060	{
2326	tmp = tmp->above;	2061	tmp = tmp->above;
2327	continue;	2062	continue;
…		…
2337	mon = tmp;	2072	mon = tmp;
2338		2073
2339	tmp = tmp->above;	2074	tmp = tmp->above;
2340	}	2075	}
2341		2076
2342	if (mon == NULL) /* This happens anytime the player tries to move */	2077	if (!mon) /* This happens anytime the player tries to move */
2343	return; /* into a wall */	2078	return; /* into a wall */
2344		2079
2345	if (mon->head != NULL)	2080	if (mon->head)
2346	mon = mon->head;	2081	mon = mon->head;
2347		2082
2348	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))
2349	if (player_attack_door (op, mon))	2084	if (player_attack_door (op, mon))
2350	return;	2085	return;
…		…
2362	* player owns it and it is either friendly or unagressive.	2097	* player owns it and it is either friendly or unagressive.
2363	*/	2098	*/
2364	if ((op->type == PLAYER)	2099	if ((op->type == PLAYER)
2365	#if COZY_SERVER	2100	#if COZY_SERVER
2366	&&	2101	&&
2367	((get_owner (mon) && get_owner (mon)->contr	2102	((mon->owner && mon->owner->contr
2368	&& same_party (get_owner (mon)->contr->party, op->contr->party)) || get_owner (mon) == op)	2103	&& same_party (mon->owner->contr->party, op->contr->party)) || mon->owner == op)
2369	#else	2104	#else
2370	&& get_owner (mon) == op	2105	&& mon->owner == op
2371	#endif	2106	#endif
2372	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))	2107	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2373	{	2108	{
2374	/* 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 */
2375	if (op->contr->braced)	2110	if (op->contr->braced)
2376	return;	2111	return;
		2112
2377	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);
2378	(void) push_ob (mon, dir, op);	2114	(void) push_ob (mon, dir, op);
2379	if (op->contr->tmp_invis || op->hide)	2115	if (op->contr->tmp_invis || op->hide)
2380	make_visible (op);	2116	make_visible (op);
		2117
2381	return;	2118	return;
2382	}	2119	}
2383		2120
2384	/* in certain circumstances, you shouldn't attack friendly	2121	/* in certain circumstances, you shouldn't attack friendly
2385	* creatures. Note that if you are braced, you can't push	2122	* creatures. Note that if you are braced, you can't push
…		…
2387	* attack them either.	2124	* attack them either.
2388	*/	2125	*/
2389	if ((mon->type == PLAYER || mon->enemy != op) &&	2126	if ((mon->type == PLAYER || mon->enemy != op) &&
2390	(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)) && (
2391	#ifdef PROHIBIT_PLAYERKILL	2128	#ifdef PROHIBIT_PLAYERKILL
2392	(op->contr->peaceful	2129	(op->contr->peaceful
2393	|| (mon->type == PLAYER	2130	|| (mon->type == PLAYER
2394	&& mon->contr->	2131	&& mon->contr->
2395	peaceful)) &&	2132	peaceful)) &&
2396	#else	2133	#else
2397	op->contr->peaceful &&	2134	op->contr->peaceful &&
2398	#endif	2135	#endif
2399	!on_battleground))	2136	!on_battleground))
2400	{	2137	{
2401	if (!op->contr->braced)	2138	if (!op->contr->braced)
2402	{	2139	{
2403	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);
2404	(void) push_ob (mon, dir, op);	2141	push_ob (mon, dir, op);
2405	}	2142	}
2406	else	2143	else
2407	{
2408	new_draw_info (0, 0, op, "You withhold your attack");	2144	new_draw_info (0, 0, op, "You withhold your attack");
2409	}	2145
2410	if (op->contr->tmp_invis || op->hide)	2146	if (op->contr->tmp_invis || op->hide)
2411	make_visible (op);	2147	make_visible (op);
2412	}	2148	}
2413		2149
2414	/* If the object is a boulder or other rollable object, then	2150	/* If the object is a boulder or other rollable object, then
…		…
2425	* 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
2426	* and be living. Then, it must be one of the following:	2162	* and be living. Then, it must be one of the following:
2427	* 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
2428	* 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.
2429	*/	2165	*/
2430
2431	else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&	2166	else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2432	((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)))
2433	{	2168	{
2434		2169
2435	/* If the player hasn't hit something this tick, and does	2170	/* If the player hasn't hit something this tick, and does
…		…
2442	op->speed_left += op->speed / op->contr->weapon_sp;	2177	op->speed_left += op->speed / op->contr->weapon_sp;
2443		2178
2444	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 */
2445	}	2180	}
2446		2181
2447	skill_attack (mon, op, 0, NULL, NULL);	2182	skill_attack (mon, op, 0, 0, 0);
2448		2183
2449	/* If attacking another player, that player gets automatic	2184	/* If attacking another player, that player gets automatic
2450	* hitback, and doesn't loose luck either.	2185	* hitback, and doesn't loose luck either.
2451	* Disable hitback on the battleground or if the target is	2186	* Disable hitback on the battleground or if the target is
2452	* the wiz.	2187	* the wiz.
…		…
2454	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))
2455	{	2190	{
2456	short luck = mon->stats.luck;	2191	short luck = mon->stats.luck;
2457		2192
2458	mon->contr->has_hit = 1;	2193	mon->contr->has_hit = 1;
2459	skill_attack (op, mon, 0, NULL, NULL);	2194	skill_attack (op, mon, 0, 0, 0);
2460	mon->stats.luck = luck;	2195	mon->stats.luck = luck;
2461	}	2196	}
		2197
2462	if (action_makes_visible (op))	2198	if (action_makes_visible (op))
2463	make_visible (op);	2199	make_visible (op);
2464	}	2200	}
2465	} /* if player should attack something */	2201	} /* if player should attack something */
2466	}	2202	}
…		…
2468	int	2204	int
2469	move_player (object *op, int dir)	2205	move_player (object *op, int dir)
2470	{	2206	{
2471	int pick;	2207	int pick;
2472		2208
2473	if (op->map == NULL || op->map->in_memory != MAP_IN_MEMORY)	2209	if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
2474	return 0;	2210	return 0;
2475		2211
2476	/* Sanity check: make sure dir is valid */	2212	/* Sanity check: make sure dir is valid */
2477	if ((dir < 0) || (dir >= 9))	2213	if ((dir < 0) || (dir >= 9))
2478	{	2214	{
2479	LOG (llevError, "move_player: invalid direction %d\n", dir);	2215	LOG (llevError, "move_player: invalid direction %d\n", dir);
2480	return 0;	2216	return 0;
2481	}	2217	}
2482		2218
2483	/* peterm: added following line */	2219	/* peterm: added following line */
2484	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)	2220	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)
2485	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	2221	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
2486		2222
2487	op->facing = dir;	2223	op->facing = dir;
2488		2224
…		…
2501		2237
2502	/* 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
2503	* server can handle repeat firing.	2239	* server can handle repeat firing.
2504	*/	2240	*/
2505	if (op->contr->fire_on || (op->contr->run_on && pick != 0))	2241	if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2506	{
2507	op->direction = dir;	2242	op->direction = dir;
2508	}
2509	else	2243	else
2510	{
2511	op->direction = 0;	2244	op->direction = 0;
2512	}	2245
2513	/* Update how the player looks. Use the facing, so direction may	2246	/* Update how the player looks. Use the facing, so direction may
2514	* get reset to zero. This allows for full animation capabilities	2247	* get reset to zero. This allows for full animation capabilities
2515	* for players.	2248	* for players.
2516	*/	2249	*/
2517	animate_object (op, op->facing);	2250	animate_object (op, op->facing);
…		…
2569		2302
2570	/* 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
2571	* the players time has been increased when doericserver has been	2304	* the players time has been increased when doericserver has been
2572	* called, so we recheck it here.	2305	* called, so we recheck it here.
2573	*/	2306	*/
2574	HandleClient (&op->contr->socket, op->contr);	2307	if (op->contr->ns->handle_command ())
		2308	return 1;
		2309
2575	if (op->speed_left < 0)	2310	if (op->speed_left > 0)
2576	return 0;	2311	{
2577
2578	if (op->direction && (op->contr->run_on || op->contr->fire_on))	2312	if (op->direction && (op->contr->run_on || op->contr->fire_on))
2579	{	2313	{
2580	/* All move commands take 1 tick, at least for now */	2314	/* All move commands take 1 tick, at least for now */
2581	op->speed_left--;	2315	op->speed_left--;
2582		2316
2583	/* Instead of all the stuff below, let move_player take care	2317	/* Instead of all the stuff below, let move_player take care
2584	* 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
2585	* there, as well as the confusion stuff.	2319	* there, as well as the confusion stuff.
2586	*/	2320	*/
2587	move_player (op, op->direction);	2321	move_player (op, op->direction);
2588	if (op->speed_left > 0)	2322
2589	return 1;	2323	return op->speed_left > 0;
2590	else	2324	}
2591	return 0;
2592	}	2325	}
		2326
2593	return 0;	2327	return 0;
2594	}	2328	}
2595		2329
2596	int	2330	int
2597	save_life (object *op)	2331	save_life (object *op)
2598	{	2332	{
2599	object *tmp;
2600
2601	if (!QUERY_FLAG (op, FLAG_LIFESAVE))	2333	if (!QUERY_FLAG (op, FLAG_LIFESAVE))
2602	return 0;	2334	return 0;
2603		2335
2604	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	2336	for (object *tmp = op->inv; tmp; tmp = tmp->below)
2605	if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))	2337	if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2606	{	2338	{
2607	play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE);	2339	play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE);
2608	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));	2340	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));
		2341
2609	if (op->contr)	2342	if (op->contr)
2610	esrv_del_item (op->contr, tmp->count);	2343	esrv_del_item (op->contr, tmp->count);
2611	remove_ob (tmp);	2344
2612	free_object (tmp);	2345	tmp->destroy ();
2613	CLEAR_FLAG (op, FLAG_LIFESAVE);	2346	CLEAR_FLAG (op, FLAG_LIFESAVE);
		2347
2614	if (op->stats.hp < 0)	2348	if (op->stats.hp < 0)
2615	op->stats.hp = op->stats.maxhp;	2349	op->stats.hp = op->stats.maxhp;
		2350
2616	if (op->stats.food < 0)	2351	if (op->stats.food < 0)
2617	op->stats.food = 999;	2352	op->stats.food = 999;
2618	fix_player (op);	2353
		2354	op->update_stats ();
2619	return 1;	2355	return 1;
2620	}	2356	}
		2357
2621	LOG (llevError, "Error: LIFESAVE set without applied object.\n");	2358	LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2622	CLEAR_FLAG (op, FLAG_LIFESAVE);	2359	CLEAR_FLAG (op, FLAG_LIFESAVE);
2623	enter_player_savebed (op); /* bring him home. */	2360	enter_player_savebed (op); /* bring him home. */
2624	return 0;	2361	return 0;
2625	}	2362	}
…		…
2634	{	2371	{
2635	object *next;	2372	object *next;
2636		2373
2637	while (op)	2374	while (op)
2638	{	2375	{
2639	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' */
2640	* we remove object 'op'	2377
2641	*/
2642	if (QUERY_FLAG (op, FLAG_UNPAID))	2378	if (QUERY_FLAG (op, FLAG_UNPAID))
2643	{	2379	{
2644	remove_ob (op);
2645	op->x = env->x;
2646	op->y = env->y;
2647	if (env->type == PLAYER)	2380	if (env->type == PLAYER)
2648	esrv_del_item (env->contr, op->count);	2381	esrv_del_item (env->contr, op->count);
2649	insert_ob_in_map (op, env->map, NULL, 0);	2382
		2383	op->insert_at (env);
2650	}	2384	}
2651	else if (op->inv)	2385	else if (op->inv)
2652	remove_unpaid_objects (op->inv, env);	2386	remove_unpaid_objects (op->inv, env);
		2387
2653	op = next;	2388	op = next;
2654	}	2389	}
2655	}	2390	}
2656
2657		2391
2658	/*	2392	/*
2659	* Returns pointer a static string containing gravestone text	2393	* Returns pointer a static string containing gravestone text
2660	* Moved from apply.c to player.c - player.c is what	2394	* Moved from apply.c to player.c - player.c is what
2661	* actually uses this function. player.c may not be quite the	2395	* actually uses this function. player.c may not be quite the
…		…
2672	strcpy (buf2, " R.I.P.\n\n");	2406	strcpy (buf2, " R.I.P.\n\n");
2673	if (op->type == PLAYER)	2407	if (op->type == PLAYER)
2674	sprintf (buf, "%s the %s\n", &op->name, op->contr->title);	2408	sprintf (buf, "%s the %s\n", &op->name, op->contr->title);
2675	else	2409	else
2676	sprintf (buf, "%s\n", &op->name);	2410	sprintf (buf, "%s\n", &op->name);
		2411
2677	strncat (buf2, " ", 20 - strlen (buf) / 2);	2412	strncat (buf2, " ", 20 - strlen (buf) / 2);
2678	strcat (buf2, buf);	2413	strcat (buf2, buf);
2679	if (op->type == PLAYER)	2414	if (op->type == PLAYER)
2680	sprintf (buf, "who was in level %d when killed\n", op->level);	2415	sprintf (buf, "who was in level %d when killed\n", op->level);
2681	else	2416	else
2682	sprintf (buf, "who was in level %d when died.\n\n", op->level);	2417	sprintf (buf, "who was in level %d when died.\n\n", op->level);
		2418
2683	strncat (buf2, " ", 20 - strlen (buf) / 2);	2419	strncat (buf2, " ", 20 - strlen (buf) / 2);
2684	strcat (buf2, buf);	2420	strcat (buf2, buf);
2685	if (op->type == PLAYER)	2421	if (op->type == PLAYER)
2686	{	2422	{
2687	sprintf (buf, "by %s.\n\n", op->contr->killer);	2423	sprintf (buf, "by %s.\n\n", op->contr->killer);
2688	strncat (buf2, " ", 21 - strlen (buf) / 2);	2424	strncat (buf2, " ", 21 - strlen (buf) / 2);
2689	strcat (buf2, buf);	2425	strcat (buf2, buf);
2690	}	2426	}
		2427
2691	strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now));	2428	strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now));
2692	strncat (buf2, " ", 20 - strlen (buf) / 2);	2429	strncat (buf2, " ", 20 - strlen (buf) / 2);
2693	strcat (buf2, buf);	2430	strcat (buf2, buf);
		2431
2694	return buf2;	2432	return buf2;
2695	}	2433	}
2696
2697
2698		2434
2699	void	2435	void
2700	do_some_living (object *op)	2436	do_some_living (object *op)
2701	{	2437	{
2702	int last_food = op->stats.food;	2438	int last_food = op->stats.food;
…		…
2711	const int max_grace = 1;	2447	const int max_grace = 1;
2712		2448
2713	if (op->contr->outputs_sync)	2449	if (op->contr->outputs_sync)
2714	{	2450	{
2715	for (i = 0; i < NUM_OUTPUT_BUFS; i++)	2451	for (i = 0; i < NUM_OUTPUT_BUFS; i++)
2716	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)
2717	flush_output_element (op, &op->contr->outputs[i]);	2453	flush_output_element (op, &op->contr->outputs[i]);
2718	}	2454	}
2719		2455
2720	if (op->contr->state == ST_PLAYING)	2456	if (op->contr->ns->state == ST_PLAYING)
2721	{	2457	{
2722
2723	/* these next three if clauses make it possible to SLOW DOWN	2458	/* these next three if clauses make it possible to SLOW DOWN
2724	hp/grace/spellpoint regeneration. */	2459	hp/grace/spellpoint regeneration. */
2725	if (op->contr->gen_hp >= 0)	2460	if (op->contr->gen_hp >= 0)
2726	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;	2461	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2727	else	2462	else
2728	{	2463	{
2729	gen_hp = op->stats.maxhp;	2464	gen_hp = op->stats.maxhp;
2730	rate_hp -= rate_hp / 2 * op->contr->gen_hp;	2465	rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2731	}	2466	}
		2467
2732	if (op->contr->gen_sp >= 0)	2468	if (op->contr->gen_sp >= 0)
2733	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;	2469	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2734	else	2470	else
2735	{	2471	{
2736	gen_sp = op->stats.maxsp;	2472	gen_sp = op->stats.maxsp;
2737	rate_sp -= rate_sp / 2 * op->contr->gen_sp;	2473	rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2738	}	2474	}
		2475
2739	if (op->contr->gen_grace >= 0)	2476	if (op->contr->gen_grace >= 0)
2740	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;	2477	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2741	else	2478	else
2742	{	2479	{
2743	gen_grace = op->stats.maxgrace;	2480	gen_grace = op->stats.maxgrace;
…		…
2759	op->stats.food += op->contr->digestion;	2496	op->stats.food += op->contr->digestion;
2760	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))
2761	op->stats.food = last_food;	2498	op->stats.food = last_food;
2762	}	2499	}
2763	}	2500	}
		2501
2764	if (max_sp > 1)	2502	if (max_sp > 1)
2765	{	2503	{
2766	over_sp = (gen_sp + 10) / rate_sp;	2504	over_sp = (gen_sp + 10) / rate_sp;
2767	if (over_sp > 0)	2505	if (over_sp > 0)
2768	{	2506	{
2769	if (op->stats.sp < op->stats.maxsp)	2507	if (op->stats.sp < op->stats.maxsp)
2770	{	2508	{
2771	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;	2509	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
		2510
2772	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))
2773	op->stats.sp--;	2512	op->stats.sp--;
		2513
2774	if (op->stats.sp > op->stats.maxsp)	2514	if (op->stats.sp > op->stats.maxsp)
2775	op->stats.sp = op->stats.maxsp;	2515	op->stats.sp = op->stats.maxsp;
2776	}	2516	}
2777	op->last_sp = 0;	2517	op->last_sp = 0;
2778	}	2518	}
2779	else	2519	else
2780	{
2781	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);
2782	}
2783	}	2521	}
2784	else	2522	else
2785	{
2786	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);
2787	}
2788	}	2524	}
2789		2525
2790	/* Regenerate Grace */	2526	/* Regenerate Grace */
2791	/* 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. */
2792	if (--op->last_grace < 0)	2528	if (--op->last_grace < 0)
2793	{	2529	{
2794	if (op->stats.grace < op->stats.maxgrace / 2)	2530	if (op->stats.grace < op->stats.maxgrace / 2)
2795	op->stats.grace++; /* no penalty in food for regaining grace */	2531	op->stats.grace++; /* no penalty in food for regaining grace */
		2532
2796	if (max_grace > 1)	2533	if (max_grace > 1)
2797	{	2534	{
2798	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;	2535	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2799	if (over_grace > 0)	2536	if (over_grace > 0)
2800	{	2537	{
…		…
2828	op->stats.food += op->contr->digestion;	2565	op->stats.food += op->contr->digestion;
2829	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))
2830	op->stats.food = last_food;	2567	op->stats.food = last_food;
2831	}	2568	}
2832	}	2569	}
		2570
2833	if (max_hp > 1)	2571	if (max_hp > 1)
2834	{	2572	{
2835	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;	2573	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2836	if (over_hp > 0)	2574	if (over_hp > 0)
2837	{	2575	{
…		…
2861		2599
2862	if (op->contr->gen_hp > 0)	2600	if (op->contr->gen_hp > 0)
2863	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);
2864	else	2602	else
2865	op->last_eat = 25 * (1 + bonus) / (penalty + 1);	2603	op->last_eat = 25 * (1 + bonus) / (penalty + 1);
		2604
2866	/* dms do not consume food */	2605	/* dms do not consume food */
2867	if (!QUERY_FLAG (op, FLAG_WIZ))	2606	if (!QUERY_FLAG (op, FLAG_WIZ))
2868	op->stats.food--;	2607	op->stats.food--;
2869	}	2608	}
2870	}
2871		2609
2872	if (op->contr->state == ST_PLAYING && op->stats.food < 0 && op->stats.hp >= 0)	2610	if (op->stats.food < 0 && op->stats.hp >= 0)
2873	{	2611	{
2874	object *tmp, *flesh = NULL;	2612	object *tmp, *flesh = 0;
2875		2613
2876	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	2614	for (tmp = op->inv; tmp; tmp = tmp->below)
2877	{	2615	{
2878	if (!QUERY_FLAG (tmp, FLAG_UNPAID))	2616	if (!QUERY_FLAG (tmp, FLAG_UNPAID))
2879	{
2880	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2881	{	2617	{
		2618	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
		2619	{
2882	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.");
2883	manual_apply (op, tmp, 0);	2621	manual_apply (op, tmp, 0);
2884	if (op->stats.food >= 0 || op->stats.hp < 0)	2622	if (op->stats.food >= 0 || op->stats.hp < 0)
2885	break;	2623	break;
2886	}	2624	}
2887	else if (tmp->type == FLESH)	2625	else if (tmp->type == FLESH)
2888	flesh = tmp;	2626	flesh = tmp;
2889	} /* End if paid for object */	2627	} /* End if paid for object */
2890	} /* end of for loop */	2628	} /* end of for loop */
		2629
2891	/* 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
2892	* eat flesh instead.	2631	* eat flesh instead.
2893	*/	2632	*/
2894	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)	2633	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2895	{	2634	{
2896	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.");
2897	manual_apply (op, flesh, 0);	2636	manual_apply (op, flesh, 0);
2898	}	2637	}
2899	} /* end if player is starving */	2638	}
2900		2639
2901	while (op->stats.food < 0 && op->stats.hp > 0)	2640	while (op->stats.food < 0 && op->stats.hp >= 0)
2902	op->stats.food++, op->stats.hp--;	2641	op->stats.food++, op->stats.hp--;
2903		2642
2904	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))
2905	kill_player (op);	2644	kill_player (op);
		2645	}
2906	}	2646	}
2907
2908
2909		2647
2910	/* 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.
2911	* 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
2912	* permadeath, no lifesave), this will take care of removing the player	2650	* permadeath, no lifesave), this will take care of removing the player
2913	* file.	2651	* file.
…		…
2943	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!");
2944	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...");
2945		2683
2946	/* restore player */	2684	/* restore player */
2947	at = archetype::find ("poisoning");	2685	at = archetype::find ("poisoning");
2948	tmp = present_arch_in_ob (at, op);	2686	if (object *tmp = present_arch_in_ob (at, op))
2949	if (tmp)
2950	{	2687	{
2951	remove_ob (tmp);	2688	tmp->destroy ();
2952	free_object (tmp);
2953	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2689	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2954	}	2690	}
2955		2691
2956	at = archetype::find ("confusion");	2692	at = archetype::find ("confusion");
2957	tmp = present_arch_in_ob (at, op);	2693	if (object *tmp = present_arch_in_ob (at, op))
2958	if (tmp)
2959	{	2694	{
2960	remove_ob (tmp);	2695	tmp->destroy ();
2961	free_object (tmp);
2962	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2696	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2963	}	2697	}
2964		2698
2965	cure_disease (op, 0); /* remove any disease */	2699	cure_disease (op, 0); /* remove any disease */
2966	op->stats.hp = op->stats.maxhp;	2700	op->stats.hp = op->stats.maxhp;
2967	if (op->stats.food <= 0)	2701	if (op->stats.food <= 0)
2968	op->stats.food = 999;	2702	op->stats.food = 999;
2969		2703
2970	/* create a bodypart-trophy to make the winner happy */	2704	/* create a bodypart-trophy to make the winner happy */
2971	tmp = arch_to_object (archetype::find ("finger"));	2705	if (object *tmp = arch_to_object (archetype::find ("finger")))
2972	if (tmp != NULL)
2973	{	2706	{
2974	sprintf (buf, "%s's finger", &op->name);	2707	sprintf (buf, "%s's finger", &op->name);
2975	tmp->name = buf;	2708	tmp->name = buf;
2976	sprintf (buf, " This finger has been cut off %s\n"	2709	sprintf (buf, " This finger has been cut off %s\n"
2977	" 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",
2978	&op->name, op->contr->title, (int) (op->level), op->contr->killer);	2711	&op->name, op->contr->title, (int) (op->level), op->contr->killer);
2979	tmp->msg = buf;	2712	tmp->msg = buf;
2980	tmp->value = 0, tmp->material = 0, tmp->type = 0;	2713	tmp->value = 0, tmp->material = 0, tmp->type = 0;
2981	tmp->materialname = NULL;	2714	tmp->materialname = NULL;
2982	tmp->x = op->x, tmp->y = op->y;	2715	tmp->insert_at (op, tmp);
2983	insert_ob_in_map (tmp, op->map, op, 0);
2984	}	2716	}
2985		2717
2986	/* teleport defeated player to new destination */	2718	/* teleport defeated player to new destination */
2987	transfer_ob (op, x, y, 0, NULL);	2719	transfer_ob (op, x, y, 0, NULL);
2988	op->contr->braced = 0;	2720	op->contr->braced = 0;
…		…
2993		2725
2994	command_kill_pets (op, 0);	2726	command_kill_pets (op, 0);
2995		2727
2996	if (op->stats.food < 0)	2728	if (op->stats.food < 0)
2997	{	2729	{
2998	if (op->contr->explore)
2999	{
3000	new_draw_info (NDI_UNIQUE, 0, op, "You would have starved, but you are");
3001	new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
3002	op->stats.food = 999;
3003	return;
3004	}
3005	sprintf (buf, "%s starved to death.", &op->name);	2730	sprintf (buf, "%s starved to death.", &op->name);
3006	strcpy (op->contr->killer, "starvation");	2731	strcpy (op->contr->killer, "starvation");
3007	}	2732	}
3008	else	2733	else
3009	{
3010	if (op->contr->explore)
3011	{
3012	new_draw_info (NDI_UNIQUE, 0, op, "You would have died, but you are");
3013	new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
3014	op->stats.hp = op->stats.maxhp;
3015	return;
3016	}
3017	sprintf (buf, "%s died.", &op->name);	2734	sprintf (buf, "%s died.", &op->name);
3018	}	2735
3019	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);	2736	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);
3020		2737
3021	/* save the map location for corpse, gravestone */	2738	/* save the map location for corpse, gravestone */
3022	x = op->x;	2739	x = op->x;
3023	y = op->y;	2740	y = op->y;
3024	map = op->map;	2741	map = op->map;
3025		2742
3026
3027	if (settings.not_permadeth == TRUE)
3028	{
3029	/* NOT_PERMADEATH code. This basically brings the character back to	2743	/* NOT_PERMADEATH code. This basically brings the character back to
3030	* 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.
3031	* 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.
3032	*/	2746	*/
3033		2747
3034	/* Basically two ways to go - remove a stat permanently, or just	2748	/* Basically two ways to go - remove a stat permanently, or just
3035	* make it depletion. This bunch of code deals with that aspect	2749	* make it depletion. This bunch of code deals with that aspect
3036	* of death.	2750	* of death.
3037	*/	2751	*/
3038	#ifndef COZY_SERVER	2752	#ifndef COZY_SERVER
3039	if (settings.balanced_stat_loss)	2753	if (settings.balanced_stat_loss)
3040	{	2754	{
3041	/* If stat loss is permanent, lose one stat only. */	2755	/* If stat loss is permanent, lose one stat only. */
3042	/* 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
3043	more if they do. */	2757	more if they do. */
3044	/* Higher level characters can afford things such as potions of	2758	/* Higher level characters can afford things such as potions of
3045	restoration, or better, stat potions. So we slug them that	2759	restoration, or better, stat potions. So we slug them that
3046	little bit harder. */	2760	little bit harder. */
3047	/* GD */	2761	/* GD */
3048	if (settings.stat_loss_on_death)	2762	if (settings.stat_loss_on_death)
3049	num_stats_lose = 1;	2763	num_stats_lose = 1;
3050	else
3051	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
3052	}
3053	else	2764	else
3054	{	2765	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
		2766	}
		2767	else
3055	num_stats_lose = 1;	2768	num_stats_lose = 1;
3056	}	2769
3057	lost_a_stat = 0;	2770	lost_a_stat = 0;
3058		2771
3059	for (z = 0; z < num_stats_lose; z++)	2772	for (z = 0; z < num_stats_lose; z++)
3060	{	2773	{
3061	i = RANDOM () % NUM_STATS;	2774	i = RANDOM () % NUM_STATS;
3062		2775
3063	if (settings.stat_loss_on_death)	2776	if (settings.stat_loss_on_death)
3064	{	2777	{
3065	/* 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
3066	* what he lost.	2779	* what he lost.
3067	*/	2780	*/
3068	change_attr_value (&(op->stats), i, -1);	2781	change_attr_value (&(op->stats), i, -1);
3069	check_stat_bounds (&(op->stats));	2782	check_stat_bounds (&(op->stats));
3070	change_attr_value (&(op->contr->orig_stats), i, -1);	2783	change_attr_value (&(op->contr->orig_stats), i, -1);
3071	check_stat_bounds (&(op->contr->orig_stats));	2784	check_stat_bounds (&(op->contr->orig_stats));
3072	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);	2785	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3073	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);
3074	}	2799	}
3075	else	2800	lose_this_stat = 1;
		2801	if (settings.balanced_stat_loss)
3076	{	2802	{
3077	/* deplete a stat */	2803	/* GD */
3078	archetype *deparch = archetype::find ("depletion");	2804	/* Get the stat that we're about to deplete. */
3079	object *dep;	2805	this_stat = get_attr_value (&(dep->stats), i);
3080		2806	if (this_stat < 0)
3081	dep = present_arch_in_ob (deparch, op);
3082	if (!dep)
3083	{	2807	{
3084	dep = arch_to_object (deparch);	2808	int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3085	insert_ob_in_ob (dep, op);	2809	int keep_chance = this_stat * this_stat;
3086	}	2810
3087	lose_this_stat = 1;	2811	/* Yes, I am paranoid. Sue me. */
3088	if (settings.balanced_stat_loss)
3089	{
3090	/* GD */
3091	/* Get the stat that we're about to deplete. */
3092	this_stat = get_attr_value (&(dep->stats), i);
3093	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)
3094	{	2817	{
3095	int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3096	int keep_chance = this_stat * this_stat;
3097
3098	/* Yes, I am paranoid. Sue me. */
3099	if (keep_chance < 1)
3100	keep_chance = 1;
3101
3102	/* There is a maximum depletion total per level. */
3103	if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3104	{
3105	lose_this_stat = 0;	2818	lose_this_stat = 0;
3106	/* Take loss chance vs keep chance to see if we	2819	/* Take loss chance vs keep chance to see if we
3107	retain the stat. */	2820	retain the stat. */
3108	}
3109	else
3110	{
3111	if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3112	lose_this_stat = 0;
3113	/* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
3114	this_stat, keep_chance, loss_chance,
3115	lose_this_stat?"LOSE":"KEEP"); */
3116	}
3117	}	2821	}
3118	}
3119
3120	if (lose_this_stat)
3121	{
3122	this_stat = get_attr_value (&(dep->stats), i);
3123	/* We could try to do something clever like find another
3124	* stat to reduce if this fails. But chances are, if
3125	* stats have been depleted to -50, all are pretty low
3126	* and should be roughly the same, so it shouldn't make a
3127	* difference.
3128	*/	2822	else
3129	if (this_stat >= -50)
3130	{	2823	{
3131	change_attr_value (&(dep->stats), i, -1);	2824	if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3132	SET_FLAG (dep, FLAG_APPLIED);
3133	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3134	fix_player (op);
3135	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"); */
3136	}	2829	}
3137	}	2830	}
3138	}	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	}
3139	}	2850	}
		2851	}
		2852	}
3140	/* If no stat lost, tell the player. */	2853	/* If no stat lost, tell the player. */
3141	if (!lost_a_stat)	2854	if (!lost_a_stat)
3142	{	2855	{
3143	/* determine_god() seems to not work sometimes... why is this?	2856	/* determine_god() seems to not work sometimes... why is this?
3144	Should I be using something else? GD */	2857	Should I be using something else? GD */
3145	const char *god = determine_god (op);	2858	const char *god = determine_god (op);
3146		2859
3147	if (god && (strcmp (god, "none")))	2860	if (god && (strcmp (god, "none")))
3148	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);
3149	else	2862	else
3150	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.");
3151	}	2864	}
3152	#else	2865	#else
3153	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.");
3154	#endif	2867	#endif
3155		2868
3156	/* Put a gravestone up where the character 'almost' died. List the	2869	/* Put a gravestone up where the character 'almost' died. List the
3157	* exp loss on the stone.	2870	* exp loss on the stone.
3158	*/	2871	*/
3159	tmp = arch_to_object (archetype::find ("gravestone"));	2872	tmp = arch_to_object (archetype::find ("gravestone"));
3160	sprintf (buf, "%s's gravestone", &op->name);	2873	sprintf (buf, "%s's gravestone", &op->name);
3161	tmp->name = buf;	2874	tmp->name = buf;
3162	sprintf (buf, "%s's gravestones", &op->name);	2875	sprintf (buf, "%s's gravestones", &op->name);
3163	tmp->name_pl = buf;	2876	tmp->name_pl = buf;
3164	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);
3165	tmp->msg = buf;	2878	tmp->msg = buf;
3166	tmp->x = op->x, tmp->y = op->y;	2879	tmp->x = op->x, tmp->y = op->y;
3167	insert_ob_in_map (tmp, op->map, NULL, 0);	2880	insert_ob_in_map (tmp, op->map, NULL, 0);
3168		2881
3169	/**************************************/	2882	/**************************************/
3170	/* */	2883	/* */
3171	/* Subtract the experience points, */	2884	/* Subtract the experience points, */
3172	/* if we died cause of food, give us */	2885	/* if we died cause of food, give us */
3173	/* food, and reset HP's... */	2886	/* food, and reset HP's... */
3174	/* */	2887	/* */
3175	/**************************************/	2888	/**************************************/
3176		2889
3177	/* remove any poisoning and confusion the character may be suffering. */	2890	/* remove any poisoning and confusion the character may be suffering. */
3178	/* restore player */	2891	/* restore player */
3179	at = archetype::find ("poisoning");	2892	at = archetype::find ("poisoning");
3180	tmp = present_arch_in_ob (at, op);	2893	tmp = present_arch_in_ob (at, op);
		2894
3181	if (tmp)	2895	if (tmp)
3182	{	2896	{
3183	remove_ob (tmp);	2897	tmp->destroy ();
3184	free_object (tmp);
3185	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2898	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3186	}	2899	}
3187		2900
3188	at = archetype::find ("confusion");	2901	at = archetype::find ("confusion");
3189	tmp = present_arch_in_ob (at, op);	2902	tmp = present_arch_in_ob (at, op);
3190	if (tmp)	2903	if (tmp)
3191	{	2904	{
3192	remove_ob (tmp);	2905	tmp->destroy ();
3193	free_object (tmp);
3194	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2906	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3195	}	2907	}
3196		2908
3197	cure_disease (op, 0); /* remove any disease */	2909	cure_disease (op, 0); /* remove any disease */
3198		2910
3199	/*add_exp(op, (op->stats.exp * -0.20)); */	2911	/*add_exp(op, (op->stats.exp * -0.20)); */
3200	apply_death_exp_penalty (op);	2912	apply_death_exp_penalty (op);
3201	if (op->stats.food < 100)	2913	if (op->stats.food < 100)
3202	op->stats.food = 900;	2914	op->stats.food = 900;
3203	op->stats.hp = op->stats.maxhp;	2915	op->stats.hp = op->stats.maxhp;
3204	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);	2916	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);
3205	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);	2917	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);
3206		2918
3207	/*	2919	/*
3208	* 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
3209	* 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
3210	* in the map.	2922	* in the map.
3211	*/	2923	*/
3212		2924
3213	if (is_in_shop (op))	2925	if (is_in_shop (op))
3214	remove_unpaid_objects (op->inv, op);	2926	remove_unpaid_objects (op->inv, op);
3215		2927
3216	/****************************************/	2928	/****************************************/
3217	/* */	2929	/* */
3218	/* Move player to his current respawn- */	2930	/* Move player to his current respawn- */
3219	/* position (usually last savebed) */	2931	/* position (usually last savebed) */
3220	/* */	2932	/* */
3221	/****************************************/	2933	/****************************************/
3222		2934
3223	enter_player_savebed (op);	2935	enter_player_savebed (op);
3224		2936
3225	/* Save the player before inserting the force to reduce
3226	* chance of abuse.
3227	*/
3228	op->contr->braced = 0;	2937	op->contr->braced = 0;
3229	save_player (op, 1);
3230		2938
3231	/* it is possible that the player has blown something up	2939	/* it is possible that the player has blown something up
3232	* at his savebed location, and that can have long lasting	2940	* at his savebed location, and that can have long lasting
3233	* spell effects. So first see if there is a spell effect	2941	* spell effects. So first see if there is a spell effect
3234	* on the space that might harm the player.	2942	* on the space that might harm the player.
3235	*/	2943	*/
3236	will_kill_again = 0;	2944	will_kill_again = 0;
3237	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)
3238	if (tmp->type == SPELL_EFFECT)	2946	if (tmp->type == SPELL_EFFECT)
3239	will_kill_again |= tmp->attacktype;	2947	will_kill_again |= tmp->attacktype;
3240		2948
3241	if (will_kill_again)	2949	if (will_kill_again)
3242	{	2950	{
3243	object *force;	2951	object *force;
3244	int at;	2952	int at;
3245		2953
3246	force = get_archetype (FORCE_NAME);	2954	force = get_archetype (FORCE_NAME);
3247	/* 50 ticks should be enough time for the spell to abate */	2955	/* 50 ticks should be enough time for the spell to abate */
3248	force->speed = 0.1;	2956	force->speed = 0.1;
3249	force->speed_left = -5.0;	2957	force->speed_left = -5.0;
3250	SET_FLAG (force, FLAG_APPLIED);	2958	SET_FLAG (force, FLAG_APPLIED);
3251	for (at = 0; at < NROFATTACKS; at++)	2959	for (at = 0; at < NROFATTACKS; at++)
3252	if (will_kill_again & (1 << at))	2960	if (will_kill_again & (1 << at))
3253	force->resist[at] = 100;	2961	force->resist[at] = 100;
3254		2962
3255	insert_ob_in_ob (force, op);	2963	insert_ob_in_ob (force, op);
3256	fix_player (op);	2964	op->update_stats ();
3257		2965
3258	}	2966	}
3259		2967
3260	new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");	2968	new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");
3261	return;
3262	} /* NOT_PERMADETH */
3263	else
3264	{
3265	/* If NOT_PERMADETH is set, then the rest of this is not reachable. This
3266	* should probably be embedded in an else statement.
3267	*/
3268
3269	op->contr->party = NULL;
3270	if (settings.set_title == TRUE)
3271	op->contr->own_title[0] = '\0';
3272	new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3273	check_score (op);
3274
3275	if (op->contr->ranges[range_golem])
3276	{
3277	remove_friendly_object (op->contr->ranges[range_golem]);
3278	remove_ob (op->contr->ranges[range_golem]);
3279	free_object (op->contr->ranges[range_golem]);
3280	op->contr->ranges[range_golem] = 0;
3281	}
3282
3283	loot_object (op); /* Remove some of the items for good */
3284	remove_ob (op);
3285	op->direction = 0;
3286
3287	if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3288	{
3289	delete_character (op->name, 0);
3290	if (settings.resurrection == TRUE)
3291	{
3292	/* save playerfile sans equipment when player dies
3293	** then save it as player.pl.dead so that future resurrection
3294	** type spells will work on them nicely
3295	*/
3296	delete_character (op->name, 0);
3297	op->stats.hp = op->stats.maxhp;
3298	op->stats.food = 999;
3299
3300	/* set the location of where the person will reappear when */
3301	/* maybe resurrection code should fix map also */
3302	strcpy (op->contr->maplevel, settings.emergency_mapname);
3303	if (op->map != NULL)
3304	op->map = NULL;
3305	op->x = settings.emergency_x;
3306	op->y = settings.emergency_y;
3307	save_player (op, 0);
3308	op->map = map;
3309	/* please see resurrection.c: peterm */
3310	dead_player (op);
3311	}
3312	else
3313	delete_character (op->name, 1);
3314	}
3315
3316	play_again (op);
3317
3318	/* peterm: added to create a corpse at deathsite. */
3319	tmp = arch_to_object (archetype::find ("corpse_pl"));
3320	sprintf (buf, "%s", &op->name);
3321	tmp->name = tmp->name_pl = buf;
3322	tmp->level = op->level;
3323	tmp->x = x;
3324	tmp->y = y;
3325	tmp->msg = gravestone_text (op);
3326	SET_FLAG (tmp, FLAG_UNIQUE);
3327	insert_ob_in_map (tmp, map, NULL, 0);
3328	}
3329	}	2969	}
3330
3331		2970
3332	void	2971	void
3333	loot_object (object *op)	2972	loot_object (object *op)
3334	{ /* Grab and destroy some treasure */	2973	{ /* Grab and destroy some treasure */
3335	object *tmp, *tmp2, *next;	2974	object *tmp, *tmp2, *next;
3336		2975
3337	if (op->container)	2976	if (op->container)
3338	{ /* close open sack first */
3339	esrv_apply_container (op, op->container);	2977	esrv_apply_container (op, op->container); /* close open sack first */
3340	}
3341		2978
3342	for (tmp = op->inv; tmp != NULL; tmp = next)	2979	for (tmp = op->inv; tmp; tmp = next)
3343	{	2980	{
3344	next = tmp->below;	2981	next = tmp->below;
3345	if (tmp->type == EXPERIENCE || tmp->invisible)	2982
		2983	if (tmp->invisible)
3346	continue;	2984	continue;
3347	remove_ob (tmp);	2985
		2986	tmp->remove ();
3348	tmp->x = op->x, tmp->y = op->y;	2987	tmp->x = op->x, tmp->y = op->y;
3349	if (tmp->type == CONTAINER)	2988	if (tmp->type == CONTAINER)
3350	{ /* empty container to ground */	2989	{ /* empty container to ground */
3351	loot_object (tmp);	2990	loot_object (tmp);
3352	}	2991	}
3353	if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3)))	2992	if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3)))
3354	{	2993	{
3355	if (tmp->nrof > 1)	2994	if (tmp->nrof > 1)
3356	{	2995	{
3357	tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));	2996	tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));
3358	free_object (tmp2);	2997	tmp2->destroy ();
3359	insert_ob_in_map (tmp, op->map, NULL, 0);	2998	insert_ob_in_map (tmp, op->map, NULL, 0);
3360	}	2999	}
3361	else	3000	else
3362	free_object (tmp);	3001	tmp->destroy ();
3363	}	3002	}
3364	else	3003	else
3365	insert_ob_in_map (tmp, op->map, NULL, 0);	3004	insert_ob_in_map (tmp, op->map, NULL, 0);
3366	}	3005	}
3367	}	3006	}
…		…
3373	*/	3012	*/
3374		3013
3375	void	3014	void
3376	fix_weight (void)	3015	fix_weight (void)
3377	{	3016	{
3378	player *pl;	3017	for_all_players (pl)
3379
3380	for (pl = first_player; pl != NULL; pl = pl->next)
3381	{	3018	{
3382	int old = pl->ob->carrying, sum = sum_weight (pl->ob);	3019	int old = pl->ob->carrying, sum = sum_weight (pl->ob);
3383		3020
3384	if (old == sum)	3021	if (old == sum)
3385	continue;	3022	continue;
3386	fix_player (pl->ob);	3023	pl->ob->update_stats ();
3387	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);
3388	}	3025	}
3389	}	3026	}
3390		3027
3391	void	3028	void
3392	fix_luck (void)	3029	fix_luck (void)
3393	{	3030	{
3394	player *pl;	3031	for_all_players (pl)
3395
3396	for (pl = first_player; pl != NULL; pl = pl->next)
3397	if (!pl->ob->contr->state)	3032	if (!pl->ob->contr->ns->state)
3398	change_luck (pl->ob, 0);	3033	pl->ob->change_luck (0);
3399	}	3034	}
3400
3401		3035
3402	/* cast_dust() - handles op throwing objects of type 'DUST'.	3036	/* cast_dust() - handles op throwing objects of type 'DUST'.
3403	* This is much simpler in the new spell code - we basically	3037	* This is much simpler in the new spell code - we basically
3404	* just treat this as any other spell casting object.	3038	* just treat this as any other spell casting object.
3405	*/	3039	*/
3406
3407	void	3040	void
3408	cast_dust (object *op, object *throw_ob, int dir)	3041	cast_dust (object *op, object *throw_ob, int dir)
3409	{	3042	{
3410	object *skop, *spob;	3043	object *skop, *spob;
3411		3044
…		…
3432	if (op->type == PLAYER)	3065	if (op->type == PLAYER)
3433	new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name);	3066	new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name);
3434		3067
3435	cast_spell (op, throw_ob, dir, spob, NULL);	3068	cast_spell (op, throw_ob, dir, spob, NULL);
3436		3069
3437	if (!QUERY_FLAG (throw_ob, FLAG_REMOVED))	3070	throw_ob->destroy ();
3438	remove_ob (throw_ob);
3439	free_object (throw_ob);
3440	}	3071	}
3441		3072
3442	void	3073	void
3443	make_visible (object *op)	3074	make_visible (object *op)
3444	{	3075	{
…		…
3458	object *tmp = NULL;	3089	object *tmp = NULL;
3459		3090
3460	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))	3091	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
3461	return 1;	3092	return 1;
3462		3093
3463	if (op->type == PLAYER)
3464	for (tmp = op->inv; tmp; tmp = tmp->below)
3465	if (tmp->type == EXPERIENCE && tmp->stats.Wis)
3466	if (QUERY_FLAG (tmp, FLAG_UNDEAD))
3467	return 1;
3468	return 0;	3094	return 0;
3469	}	3095	}
3470		3096
3471	/* look at the surrounding terrain to determine	3097	/* look at the surrounding terrain to determine
3472	* the hideability of this object. Positive levels	3098	* the hideability of this object. Positive levels
…		…
3528		3154
3529	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);	3155	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);
3530		3156
3531	/* 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! */
3532	if (op->type == PLAYER && op->contr->run_on)	3158	if (op->type == PLAYER && op->contr->run_on)
3533	{
3534	if (!skop || num >= skop->level)	3159	if (!skop || num >= skop->level)
3535	{	3160	{
3536	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!");
3537	make_visible (op);	3162	make_visible (op);
3538	return;	3163	return;
3539	}	3164	}
3540	else	3165	else
3541	num += 20;	3166	num += 20;
3542	}	3167
3543	num += op->map->difficulty;	3168	num += op->map->difficulty;
3544	hide = hideability (op); /* modify by terrain hidden level */	3169	hide = hideability (op); /* modify by terrain hidden level */
3545	num -= hide;	3170	num -= hide;
		3171
3546	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))	3172	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))
3547	{	3173	{
3548	make_visible (op);	3174	make_visible (op);
3549	if (op->type == PLAYER)	3175	if (op->type == PLAYER)
3550	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!");
3551	}	3177	}
3552	else if (op->type == PLAYER && skop)	3178	else if (op->type == PLAYER && skop)
3553	{
3554	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);
3555	}
3556	}	3180	}
3557		3181
3558	/* determine if who is standing near a hostile creature. */	3182	/* determine if who is standing near a hostile creature. */
3559		3183
3560	int	3184	int
…		…
3587	if (mflags & P_OUT_OF_MAP)	3211	if (mflags & P_OUT_OF_MAP)
3588	continue;	3212	continue;
3589	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)))
3590	continue;	3214	continue;
3591		3215
3592	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)
3593	{	3217	{
3594	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))
3595	return 1;	3219	return 1;
3596	else if (tmp->type == PLAYER)	3220	else if (tmp->type == PLAYER)
3597	{	3221	{
…		…
3627	if (pl->type != PLAYER)	3251	if (pl->type != PLAYER)
3628	{	3252	{
3629	LOG (llevError, "player_can_view() called for non-player object\n");	3253	LOG (llevError, "player_can_view() called for non-player object\n");
3630	return -1;	3254	return -1;
3631	}	3255	}
		3256
3632	if (!pl || !op)	3257	if (!pl || !op)
3633	return 0;	3258	return 0;
3634		3259
3635	if (op->head)
3636	{
3637	op = op->head;	3260	op = op->head_ ();
3638	}	3261
3639	get_rangevector (pl, op, &rv, 0x1);	3262	get_rangevector (pl, op, &rv, 0x1);
3640		3263
3641	/* starting with the 'head' part, lets loop	3264	/* starting with the 'head' part, lets loop
3642	* through the object and find if it has any	3265	* through the object and find if it has any
3643	* part that is in the los array but isnt on	3266	* part that is in the los array but isnt on
…		…
3651		3274
3652	/* only the viewable area the player sees is updated by LOS	3275	/* only the viewable area the player sees is updated by LOS
3653	* 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
3654	* for any meaningful values.	3277	* for any meaningful values.
3655	*/	3278	*/
3656	if (FABS (dx) <= (pl->contr->socket.mapx / 2) &&	3279	if (FABS (dx) <= (pl->contr->ns->mapx / 2) &&
3657	FABS (dy) <= (pl->contr->socket.mapy / 2) &&	3280	FABS (dy) <= (pl->contr->ns->mapy / 2) &&
3658	!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)])
3659	return 1;	3282	return 1;
3660	op = op->more;	3283	op = op->more;
3661	}	3284	}
3662	return 0;	3285	return 0;
3663	}	3286	}
…		…
3773	if (trlist == NULL || who->type != PLAYER)	3396	if (trlist == NULL || who->type != PLAYER)
3774	return;	3397	return;
3775		3398
3776	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++);
3777		3400
3778	if (tr == NULL || tr->item == NULL)	3401	if (!tr || !tr->item)
3779	{	3402	{
3780	/* 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]); */
3781	return;	3404	return;
3782	}	3405	}
3783		3406
…		…
3849	{	3472	{
3850	/* forces in the treasurelist can alter the player's stats */	3473	/* forces in the treasurelist can alter the player's stats */
3851	object *skin;	3474	object *skin;
3852		3475
3853	/* first get the dragon skin force */	3476	/* first get the dragon skin force */
		3477	shstr_cmp dragon_skin_force ("dragon_skin_force");
3854	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
3855	if (skin == NULL)	3481	if (!skin)
3856	return;	3482	return;
3857		3483
3858	/* adding new spellpath attunements */	3484	/* adding new spellpath attunements */
3859	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))	3485	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))
3860	{	3486	{

Diff Legend

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