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.41 by root, Fri Dec 15 04:21:29 2006 UTC vs.
Revision 1.104 by root, Fri Feb 16 19:43:41 2007 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game
3		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20		21	*
21	The author can be reached via e-mail to <crossfire@schmorp.de>	22	* The author can be reached via e-mail to <crossfire@schmorp.de>
22	*/	23	*/
23		24
24	#include <global.h>	25	#include <global.h>
25	#include <pwd.h>	26	#include <pwd.h>
26	#include <sproto.h>	27	#include <sproto.h>
27	#include <sounds.h>	28	#include <sounds.h>
28	#include <living.h>	29	#include <living.h>
29	#include <object.h>	30	#include <object.h>
30	#include <spells.h>	31	#include <spells.h>
31	#include <skills.h>	32	#include <skills.h>
32	#include <newclient.h>
33		33
34	#ifdef COZY_SERVER	34	#include <algorithm>
35	extern int same_party (partylist *a, partylist *b);	35	#include <functional>
36	#endif
37		36
38	player *	37	playervec players;
39	find_player (const char *plname)
40	{
41	player *pl;
42
43	for (pl = first_player; pl != NULL; pl = pl->next)
44	{
45	if (pl->ob != NULL && !strcmp (query_name (pl->ob), plname))
46	return pl;
47	};
48	return NULL;
49	}
50
51	player *
52	find_player_partial_name (const char *plname)
53	{
54	player *pl;
55	player *found = NULL;
56	size_t namelen = strlen (plname);
57
58	for (pl = first_player; pl != NULL; pl = pl->next)
59	{
60	if ((size_t) strlen (pl->ob->name) < namelen)
61	continue;
62
63	if (!strcmp (pl->ob->name, plname))
64	return pl;
65
66	if (!strncasecmp (pl->ob->name, plname, namelen))
67	{
68	if (found)
69	return NULL;
70
71	found = pl;
72	}
73	}
74	return found;
75	}
76		38
77	void	39	void
78	display_motd (const object *op)	40	display_motd (const object *op)
79	{	41	{
80	char buf[MAX_BUF];	42	char buf[MAX_BUF];
…		…
83	int comp;	45	int comp;
84	int size;	46	int size;
85		47
86	sprintf (buf, "%s/%s", settings.confdir, settings.motd);	48	sprintf (buf, "%s/%s", settings.confdir, settings.motd);
87	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)	49	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
88	{
89	return;	50	return;
90	}	51
91	motd[0] = '\0';	52	motd[0] = '\0';
92	size = 0;	53	size = 0;
		54
93	while (fgets (buf, MAX_BUF, fp) != NULL)	55	while (fgets (buf, MAX_BUF, fp))
94	{	56	{
95	if (*buf == '#')	57	if (*buf == '#')
96	continue;	58	continue;
		59
97	strncat (motd + size, buf, HUGE_BUF - size);	60	strncat (motd + size, buf, HUGE_BUF - size);
98	size += strlen (buf);	61	size += strlen (buf);
99	}	62	}
		63
100	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);
101	close_and_delete (fp, comp);	65	close_and_delete (fp, comp);
102	}	66	}
103		67
104	void	68	void
…		…
110	int comp;	74	int comp;
111	int size;	75	int size;
112		76
113	sprintf (buf, "%s/%s", settings.confdir, settings.rules);	77	sprintf (buf, "%s/%s", settings.confdir, settings.rules);
114	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)	78	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
115	{
116	return;	79	return;
117	}	80
118	rules[0] = '\0';	81	rules[0] = '\0';
119	size = 0;	82	size = 0;
		83
120	while (fgets (buf, MAX_BUF, fp) != NULL)	84	while (fgets (buf, MAX_BUF, fp))
121	{	85	{
122	if (*buf == '#')	86	if (*buf == '#')
123	continue;	87	continue;
		88
124	if (size + strlen (buf) >= HUGE_BUF)	89	if (size + strlen (buf) >= HUGE_BUF)
125	{	90	{
126	LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);	91	LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);
127	break;	92	break;
128	}	93	}
		94
129	strncat (rules + size, buf, HUGE_BUF - size);	95	strncat (rules + size, buf, HUGE_BUF - size);
130	size += strlen (buf);	96	size += strlen (buf);
131	}	97	}
		98
132	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);
133	close_and_delete (fp, comp);	100	close_and_delete (fp, comp);
134	}	101	}
135		102
136	void	103	void
…		…
144	int size;	111	int size;
145		112
146	sprintf (buf, "%s/%s", settings.confdir, settings.news);	113	sprintf (buf, "%s/%s", settings.confdir, settings.news);
147	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)	114	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
148	return;	115	return;
		116
149	news[0] = '\0';	117	news[0] = '\0';
150	subject[0] = '\0';	118	subject[0] = '\0';
151	size = 0;	119	size = 0;
		120
152	while (fgets (buf, MAX_BUF, fp) != NULL)	121	while (fgets (buf, MAX_BUF, fp))
153	{	122	{
154	if (*buf == '#')	123	if (*buf == '#')
155	continue;	124	continue;
		125
156	if (*buf == '%')	126	if (*buf == '%')
157	{ /* send one news */	127	{ /* send one news */
158	if (size > 0)	128	if (size > 0)
159	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
160	strcpy (subject, buf + 1);	131	strcpy (subject, buf + 1);
161	strip_endline (subject);	132	strip_endline (subject);
162	size = 0;	133	size = 0;
163	news[0] = '\0';	134	news[0] = '\0';
164	}	135	}
…		…
177	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,	148	draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
178	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);
179	close_and_delete (fp, comp);	150	close_and_delete (fp, comp);
180	}	151	}
181		152
182	int
183	playername_ok (const char *cp)
184	{
185	/* Don't allow - or _ as first character in the name */
186	if (*cp == '-' || *cp == '_')
187	return 0;
188
189	for (; *cp != '\0'; cp++)
190	if (!((*cp >= 'a' && *cp <= 'z') || (*cp >= 'A' && *cp <= 'Z')) && *cp != '-' && *cp != '_')
191	return 0;
192	return 1;
193	}
194
195	/* This no longer sets the player map. Also, it now updates
196	* all the pointers so the caller doesn't need to do that.
197	* Caller is responsible for setting the correct map.
198	*/
199
200	/* Redo this to do both get_player_ob and get_player.
201	* Hopefully this will be less bugfree and simpler.
202	* Returns the player structure. If 'p' is null,
203	* we create a new one. Otherwise, we recycle
204	* the one that is passed.
205	*/
206	static player *
207	get_player (player *p)
208	{
209	object *op = arch_to_object (get_player_archetype (0));
210	int i;
211
212	/* Clears basically the entire player structure except
213	* for next and socket.
214	*/
215	p->clear ();
216
217	/* There are some elements we want initialized to non zero value -
218	* we deal with that below this point.
219	*/
220	p->party = NULL;
221	p->outputs_sync = 16; /* Every 2 seconds */
222	p->outputs_count = 8; /* Keeps present behaviour */
223	p->unapply = unapply_nochoice;
224	p->Swap_First = -1;
225
226	#ifdef AUTOSAVE
227	p->last_save_tick = 9999999;
228	#endif
229
230	strcpy (p->savebed_map, first_map_path); /* Init. respawn position */
231
232	op->contr = p; /* this aren't yet in archetype */
233	p->ob = op;
234	op->speed_left = 0.5;
235	op->speed = 1.0;
236	op->direction = 5; /* So player faces south */
237	op->stats.wc = 2;
238	op->run_away = 25; /* Then we panick... */
239
240	{
241	int oldmon = p->socket->monitor_spells; // what a hack
242	p->socket->monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */
243	roll_stats (op);
244	p->socket->monitor_spells = oldmon;
245	}
246	p->state = ST_ROLL_STAT;
247	clear_los (op);
248
249	p->gen_sp_armour = 10;
250	p->last_speed = -1;
251	p->shoottype = range_none;
252	p->bowtype = bow_normal;
253	p->petmode = pet_normal;
254	p->listening = 10;
255	p->usekeys = containers;
256	p->last_weapon_sp = -1;
257	p->peaceful = 1; /* default peaceful */
258	p->do_los = 1;
259	p->explore = 0;
260	p->no_shout = 0; /* default can shout */
261
262	assign (p->title, op->arch->clone.name);
263	op->race = op->arch->clone.race;
264
265	CLEAR_FLAG (op, FLAG_READY_SKILL);
266
267	/* we need to clear these to -1 and not zero - otherwise,
268	* if a player quits and starts a new character, we wont
269	* send new values to the client, as things like exp start
270	* at zero.
271	*/
272	for (i = 0; i < NUM_SKILLS; i++)
273	{
274	p->last_skill_exp[i] = -1;
275	p->last_skill_ob[i] = NULL;
276	}
277
278	for (i = 0; i < NROFATTACKS; i++)
279	p->last_resist[i] = -1;
280
281	p->last_stats.exp = -1;
282	p->last_weight = (uint32) - 1;
283
284	p->socket->update_look = 0;
285	p->socket->look_position = 0;
286
287	return p;
288	}
289
290	/* This loads the first map an puts the player on it. */	153	/* This loads the first map an puts the player on it. */
291	static void	154	static void
292	set_first_map (object *op)	155	set_first_map (object *op)
293	{	156	{
294	strcpy (op->contr->maplevel, first_map_path);	157	op->contr->maplevel = first_map_path;
295	op->x = -1;	158	op->x = -1;
296	op->y = -1;	159	op->y = -1;
297	enter_exit (op, NULL);
298	}	160	}
299		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)
		179	return;
		180
		181	players.insert (this);
		182	ob->remove ();
		183	ob->map = 0;
		184	ob->activate_recursive ();
		185	CLEAR_FLAG (ob, FLAG_FRIENDLY);
		186	add_friendly_object (ob);
		187	enter_map ();
		188	}
		189
		190	void
		191	player::deactivate ()
		192	{
		193	if (!active)
		194	return;
		195
		196	terminate_all_pets (ob);
		197	remove_friendly_object (ob);
		198	ob->deactivate_recursive ();
		199	maplevel = ob->map->path;
		200	ob->remove ();
		201	ob->map = 0;
		202	party = 0;
		203
		204	// for weird reasons, this is often "ob", keeping a circular reference
		205	ranges [range_skill] = 0;
		206
		207	players.erase (this);
		208	}
		209
		210	// connect the player with a specific client
		211	// also changed, rationalises, and fixes some incorrect settings
		212	void
		213	player::connect (client *ns)
		214	{
		215	this->ns = ns;
		216	ns->pl = this;
		217
		218	run_on = 0;
		219	fire_on = 0;
		220	ob->close_container (); //TODO: client-specific
		221
		222	ns->update_look = 0;
		223	ns->look_position = 0;
		224
		225	clear_los (ob);
		226
		227	ns->reset_stats ();
		228
		229	/* make sure he's a player -- needed because of class change. */
		230	ob->type = PLAYER; // we are paranoid
		231	ob->race = ob->arch->clone.race;
		232
		233	if (!legal_range (ob, shoottype))
		234	shoottype = range_none;
		235
		236	ob->carrying = sum_weight (ob);
		237	link_player_skills (ob);
		238
		239	CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
		240
		241	assign (title, ob->arch->clone.name);
		242
		243	/* if it's a dragon player, set the correct title here */
		244	if (is_dragon_pl (ob))
		245	{
		246	object *tmp, *abil = 0, *skin = 0;
		247
		248	shstr_cmp dragon_ability_force ("dragon_ability_force");
		249	shstr_cmp dragon_skin_force ("dragon_skin_force");
		250
		251	for (tmp = ob->inv; tmp; tmp = tmp->below)
		252	if (tmp->type == FORCE)
		253	if (tmp->arch->name == dragon_ability_force)
		254	abil = tmp;
		255	else if (tmp->arch->name == dragon_skin_force)
		256	skin = tmp;
		257
		258	set_dragon_name (ob, abil, skin);
		259	}
		260
		261	new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
		262
		263	esrv_new_player (this, ob->weight + ob->carrying);
		264
		265	ob->update_stats ();
		266	ns->floorbox_update ();
		267
		268	esrv_send_inventory (ob, ob);
		269	esrv_add_spells (this, 0);
		270
		271	activate ();
		272
		273	send_rules (ob);
		274	send_news (ob);
		275	display_motd (ob);
		276
		277	INVOKE_PLAYER (CONNECT, this);
		278	INVOKE_PLAYER (LOGIN, this);
		279	}
		280
		281	void
		282	player::disconnect ()
		283	{
		284	if (ns)
		285	{
		286	if (active)
		287	INVOKE_PLAYER (LOGOUT, this, ARG_INT (0));
		288
		289	INVOKE_PLAYER (DISCONNECT, this);
		290
		291	ns->reset_stats ();
		292	ns->pl = 0;
		293	this->ns = 0;
		294	}
		295
		296	ob->close_container (); //TODO: client-specific
		297	deactivate ();
		298	}
		299
		300	// the need for this function can be explained
		301	// by load_object not returning the object
		302	void
		303	player::set_object (object *op)
		304	{
		305	ob = op;
		306	ob->contr = this; /* this aren't yet in archetype */
		307
		308	ob->speed_left = 0.5;
		309	ob->speed = 1.0;
		310	ob->direction = 5; /* So player faces south */
		311	}
		312
		313	player::player ()
		314	{
		315	/* There are some elements we want initialised to non zero value -
		316	* we deal with that below this point.
		317	*/
		318	outputs_sync = 16; /* Every 2 seconds */
		319	outputs_count = 8; /* Keeps present behaviour */
		320	unapply = unapply_nochoice;
		321
		322	savebed_map = first_map_path; /* Init. respawn position */
		323
		324	gen_sp_armour = 10;
		325	shoottype = range_none;
		326	bowtype = bow_normal;
		327	petmode = pet_normal;
		328	listening = 10;
		329	usekeys = containers;
		330	peaceful = 1; /* default peaceful */
		331	do_los = 1;
		332	}
		333
		334	void
		335	player::do_destroy ()
		336	{
		337	disconnect ();
		338
		339	attachable::do_destroy ();
		340
		341	if (ob)
		342	{
		343	ob->destroy_inv (false);
		344	ob->destroy ();
		345	}
		346	}
		347
		348	player::~player ()
		349	{
		350	/* Clear item stack */
		351	free (stack_items);
		352	}
		353
300	/* Tries to add player on the connection passwd in ns.	354	/* Tries to add player on the connection passed in ns.
301	* All we can really get in this is some settings like host and display	355	* All we can really get in this is some settings like host and display
302	* mode.	356	* mode.
303	*/	357	*/
304		358	player *
305	int	359	player::create ()
306	add_player (client_socket *ns)
307	{	360	{
308	player *p = new player;	361	player *pl = new player;
309		362
310	p->socket = ns;	363	pl->set_object (arch_to_object (get_player_archetype (0)));
311	ns->pl = p;
312		364
313	p->next = first_player;	365	pl->ob->roll_stats ();
314	first_player = p;	366	pl->ob->stats.wc = 2;
		367	pl->ob->run_away = 25; /* Then we panick... */
315		368
316	p = get_player (p);
317
318	set_first_map (p->ob);	369	set_first_map (pl->ob);
319		370
320	CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
321	add_friendly_object (p->ob);
322	send_rules (p->ob);
323	send_news (p->ob);
324	display_motd (p->ob);
325	get_name (p->ob);
326
327	return 0;	371	return pl;
328	}	372	}
329		373
330	/*	374	/*
331	* get_player_archetype() return next player archetype from archetype	375	* get_player_archetype() return next player archetype from archetype
332	* list. Not very efficient routine, but used only creating new players.	376	* list. Not very efficient routine, but used only creating new players.
…		…
341	{	385	{
342	if (at == NULL || at->next == NULL)	386	if (at == NULL || at->next == NULL)
343	at = first_archetype;	387	at = first_archetype;
344	else	388	else
345	at = at->next;	389	at = at->next;
		390
346	if (at->clone.type == PLAYER)	391	if (at->clone.type == PLAYER)
347	return at;	392	return at;
		393
348	if (at == start)	394	if (at == start)
349	{	395	{
350	LOG (llevError, "No Player archetypes\n");	396	LOG (llevError, "No Player archetypes\n");
351	exit (-1);	397	exit (-1);
352	}	398	}
353	}	399	}
354	}	400	}
355		401
356
357	object *	402	object *
358	get_nearest_player (object *mon)	403	get_nearest_player (object *mon)
359	{	404	{
360	object *op = NULL;	405	object *op = NULL;
361	player *pl = NULL;
362	objectlink *ol;	406	objectlink *ol;
363	unsigned lastdist;	407	unsigned lastdist;
364	rv_vector rv;	408	rv_vector rv;
365		409
366	for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next)	410	for (ol = first_friendly_object, lastdist = 1000; ol; ol = ol->next)
367	{	411	{
368	/* We should not find free objects on this friendly list, but it	412	/* We should not find free objects on this friendly list, but it
369	* does periodically happen. Given that, lets deal with it.	413	* does periodically happen. Given that, lets deal with it.
370	* While unlikely, it is possible the next object on the friendly	414	* While unlikely, it is possible the next object on the friendly
371	* list is also free, so encapsulate this in a while loop.	415	* list is also free, so encapsulate this in a while loop.
…		…
375	object *tmp = ol->ob;	419	object *tmp = ol->ob;
376		420
377	/* Can't do much more other than log the fact, because the object	421	/* Can't do much more other than log the fact, because the object
378	* itself will have been cleared.	422	* itself will have been cleared.
379	*/	423	*/
380	LOG (llevDebug, "get_nearest_player: Found free/non friendly object on friendly list\n");	424	LOG (llevDebug, "get_nearest_player: Found free/non friendly object '%s' on friendly list\n",
		425	tmp->debug_desc ());
381	ol = ol->next;	426	ol = ol->next;
382	remove_friendly_object (tmp);	427	remove_friendly_object (tmp);
383	if (!ol)	428	if (!ol)
384	return op;	429	return op;
385	}	430	}
…		…
398	{	443	{
399	op = ol->ob;	444	op = ol->ob;
400	lastdist = rv.distance;	445	lastdist = rv.distance;
401	}	446	}
402	}	447	}
403	for (pl = first_player; pl != NULL; pl = pl->next)	448
404	{	449	for_all_players (pl)
405	if (can_detect_enemy (mon, pl->ob, &rv))	450	if (can_detect_enemy (mon, pl->ob, &rv))
406	{
407
408	if (lastdist > rv.distance)	451	if (lastdist > rv.distance)
409	{	452	{
410	op = pl->ob;	453	op = pl->ob;
411	lastdist = rv.distance;	454	lastdist = rv.distance;
412	}	455	}
413	}	456
414	}
415	#if 0	457	#if 0
416	LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");	458	LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");
417	#endif	459	#endif
418	return op;	460	return op;
419	}	461	}
…		…
437	* circling behaviour. Unfortunately, this function is also used to determined	479	* circling behaviour. Unfortunately, this function is also used to determined
438	* if the creature should cast a spell, so returning a direction in that case	480	* if the creature should cast a spell, so returning a direction in that case
439	* is probably not a good thing.	481	* is probably not a good thing.
440	*/	482	*/
441	#define MAX_SPACES 50	483	#define MAX_SPACES 50
442
443		484
444	/*	485	/*
445	* Returns the direction to the player, if valid. Returns 0 otherwise.	486	* Returns the direction to the player, if valid. Returns 0 otherwise.
446	* modified to verify there is a path to the player. Does this by stepping towards	487	* modified to verify there is a path to the player. Does this by stepping towards
447	* player and if path is blocked then see if blockage is close enough to player that	488	* player and if path is blocked then see if blockage is close enough to player that
…		…
478	x = mon->x;	519	x = mon->x;
479	y = mon->y;	520	y = mon->y;
480	m = mon->map;	521	m = mon->map;
481	dir = rv.direction;	522	dir = rv.direction;
482	lastdir = firstdir = rv.direction; /* perhaps we stand next to pl, init firstdir too */	523	lastdir = firstdir = rv.direction; /* perhaps we stand next to pl, init firstdir too */
483	diff = FABS (rv.distance_x) > FABS (rv.distance_y) ? FABS (rv.distance_x) : FABS (rv.distance_y);	524	diff = ::max (abs (rv.distance_x), abs (rv.distance_y));
		525
484	/* If we can't solve it within the search distance, return now. */	526	/* If we can't solve it within the search distance, return now. */
485	if (diff > max)	527	if (diff > max)
486	return 0;	528	return 0;
		529
487	while (diff > 1 && max > 0)	530	while (diff > 1 && max > 0)
488	{	531	{
489	lastx = x;	532	lastx = x;
490	lasty = y;	533	lasty = y;
491	lastmap = m;	534	lastmap = m;
…		…
573	max--;	616	max--;
574	lastdir = dir;	617	lastdir = dir;
575	if (!firstdir)	618	if (!firstdir)
576	firstdir = dir;	619	firstdir = dir;
577	}	620	}
		621
578	if (diff <= 1)	622	if (diff <= 1)
579	{	623	{
580	/* Recalculate diff (distance) because we may not have actually	624	/* Recalculate diff (distance) because we may not have actually
581	* headed toward player for entire distance.	625	* headed toward player for entire distance.
582	*/	626	*/
583	get_rangevector_from_mapcoord (m, x, y, pl, &rv, 0);	627	get_rangevector_from_mapcoord (m, x, y, pl, &rv, 0);
584	diff = FABS (rv.distance_x) > FABS (rv.distance_y) ? FABS (rv.distance_x) : FABS (rv.distance_y);	628	diff = ::max (abs (rv.distance_x), abs (rv.distance_y));
585	}	629	}
		630
586	if (diff > max)	631	if (diff > max)
587	return 0;	632	return 0;
588	}	633	}
		634
589	/* If we reached the max, didn't find a direction in time */	635	/* If we reached the max, didn't find a direction in time */
590	if (!max)	636	if (!max)
591	return 0;	637	return 0;
592		638
593	return firstdir;	639	return firstdir;
…		…
686	/* Need to set up the skill pointers */	732	/* Need to set up the skill pointers */
687	link_player_skills (pl);	733	link_player_skills (pl);
688	}	734	}
689		735
690	void	736	void
691	get_name (object *op)
692	{
693	op->contr->write_buf[0] = '\0';
694	op->contr->state = ST_GET_NAME;
695	send_query (op->contr->socket, 0, "What is your name?\n:");
696	}
697
698	void
699	get_password (object *op)
700	{
701	op->contr->write_buf[0] = '\0';
702	op->contr->state = ST_GET_PASSWORD;
703	send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
704	}
705
706	void
707	play_again (object *op)
708	{
709	op->contr->state = ST_PLAY_AGAIN;
710	op->chosen_skill = NULL;
711	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
712	/* a bit of a hack, but there are various places early in th
713	* player creation process that a user can quit (eg, roll
714	* stats) that isn't removing the player. Taking a quick
715	* look, there are many places that call play_again without
716	* removing the player - it probably makes more sense
717	* to leave it to play_again to remove the object in all
718	* cases.
719	*/
720	if (!QUERY_FLAG (op, FLAG_REMOVED))
721	op->remove ();
722	/* Need to set this to null - otherwise, it could point to garbage,
723	* and draw() doesn't check to see if the player is removed, only if
724	* the map is null or not swapped out.
725	*/
726	op->map = NULL;
727	}
728
729	int
730	receive_play_again (object *op, char key)
731	{
732	if (key == 'q' || key == 'Q')
733	{
734	remove_friendly_object (op);
735	leave (op->contr, 0); /* ericserver will draw the message */
736	return 2;
737	}
738	else if (key == 'a' || key == 'A')
739	{
740	player *pl = op->contr;
741	shstr name = op->name;
742
743	op->contr = 0;
744	op->type = 0;
745	op->destroy (1);
746	pl = get_player (pl);
747	op = pl->ob;
748	add_friendly_object (op);
749	op->contr->password[0] = '~';
750	op->name = op->name_pl = 0;
751	/* Lets put a space in here */
752	new_draw_info (NDI_UNIQUE, 0, op, "\n");
753	get_name (op);
754	op->name = op->name_pl = name;
755	set_first_map (op);
756	}
757	else
758	/* user pressed something else so just ask again... */
759	play_again (op);
760
761	return 0;
762	}
763
764	void
765	confirm_password (object *op)
766	{
767
768	op->contr->write_buf[0] = '\0';
769	op->contr->state = ST_CONFIRM_PASSWORD;
770	send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
771	}
772
773	void
774	get_party_password (object *op, partylist *party)	737	get_party_password (object *op, partylist *party)
775	{	738	{
776	if (party == NULL)	739	if (party == NULL)
777	{	740	{
778	LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);	741	LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);
779	return;	742	return;
780	}	743	}
		744
781	op->contr->write_buf[0] = '\0';	745	op->contr->write_buf[0] = '\0';
782	op->contr->state = ST_GET_PARTY_PASSWORD;	746	op->contr->ns->state = ST_GET_PARTY_PASSWORD;
783	op->contr->party_to_join = party;	747	op->contr->party_to_join = party;
784	send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:");	748	send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:");
785	}	749	}
786
787		750
788	/* This rolls four 1-6 rolls and sums the best 3 of the 4. */	751	/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
789	int	752	static int
790	roll_stat (void)	753	roll_stat (void)
791	{	754	{
792	int a[4], i, j, k;	755	int a[4], i, j, k;
793		756
794	for (i = 0; i < 4; i++)	757	for (i = 0; i < 4; i++)
795	a[i] = (int) RANDOM () % 6 + 1;	758	a[i] = (int) rndm (6) + 1;
796		759
797	for (i = 0, j = 0, k = 7; i < 4; i++)	760	for (i = 0, j = 0, k = 7; i < 4; i++)
798	if (a[i] < k)	761	if (a[i] < k)
799	k = a[i], j = i;	762	k = a[i], j = i;
800		763
801	for (i = 0, k = 0; i < 4; i++)	764	for (i = 0, k = 0; i < 4; i++)
802	{
803	if (i != j)	765	if (i != j)
804	k += a[i];	766	k += a[i];
805	}	767
806	return k;	768	return k;
807	}	769	}
808		770
809	void	771	void
810	roll_stats (object *op)	772	object::roll_stats ()
811	{	773	{
812	int sum = 0;
813	int i = 0, j = 0;
814	int statsort[7];	774	int statsort [7];
815		775
816	do	776	for (;;)
817	{
818	op->stats.Str = roll_stat ();
819	op->stats.Dex = roll_stat ();
820	op->stats.Int = roll_stat ();
821	op->stats.Con = roll_stat ();
822	op->stats.Wis = roll_stat ();
823	op->stats.Pow = roll_stat ();
824	op->stats.Cha = roll_stat ();
825	sum = op->stats.Str + op->stats.Dex + op->stats.Int + op->stats.Con + op->stats.Wis + op->stats.Pow + op->stats.Cha;
826	}	777	{
827	while (sum < 82 || sum > 116);	778	int sum = 0;
		779	for (int i = 7; i--; )
		780	sum += statsort [i] = roll_stat ();
828		781
		782	if (sum >= 82 && sum <= 116)
		783	break;
		784	}
		785
829	/* Sort the stats so that rerolling is easier... */	786	// Sort the stats so that rerolling is easier...
830	statsort[0] = op->stats.Str;	787	std::sort (statsort, statsort + 7, std::greater<int>());
831	statsort[1] = op->stats.Dex;
832	statsort[2] = op->stats.Int;
833	statsort[3] = op->stats.Con;
834	statsort[4] = op->stats.Wis;
835	statsort[5] = op->stats.Pow;
836	statsort[6] = op->stats.Cha;
837		788
838	/* a quick and dirty bubblesort? */
839	do
840	{
841	if (statsort[i] < statsort[i + 1])
842	{
843	j = statsort[i];
844	statsort[i] = statsort[i + 1];
845	statsort[i + 1] = j;
846	i = 0;
847	}
848	else
849	{
850	i++;
851	}
852	}
853	while (i < 6);
854
855	op->stats.Str = statsort[0];	789	stats.Str = statsort[0];
856	op->stats.Dex = statsort[1];	790	stats.Dex = statsort[1];
857	op->stats.Con = statsort[2];	791	stats.Con = statsort[2];
858	op->stats.Int = statsort[3];	792	stats.Int = statsort[3];
859	op->stats.Wis = statsort[4];	793	stats.Wis = statsort[4];
860	op->stats.Pow = statsort[5];	794	stats.Pow = statsort[5];
861	op->stats.Cha = statsort[6];	795	stats.Cha = statsort[6];
862		796
863
864	op->contr->orig_stats.Str = op->stats.Str;
865	op->contr->orig_stats.Dex = op->stats.Dex;
866	op->contr->orig_stats.Int = op->stats.Int;
867	op->contr->orig_stats.Con = op->stats.Con;
868	op->contr->orig_stats.Wis = op->stats.Wis;
869	op->contr->orig_stats.Pow = op->stats.Pow;
870	op->contr->orig_stats.Cha = op->stats.Cha;
871
872	op->level = 1;
873	op->stats.exp = 0;	797	stats.exp = 0;
874	op->stats.ac = 0;	798	stats.ac = 0;
875		799
876	op->contr->levhp[1] = 9;
877	op->contr->levsp[1] = 6;
878	op->contr->levgrace[1] = 3;
879
880	fix_player (op);
881	op->stats.hp = op->stats.maxhp;	800	stats.hp = stats.maxhp;
882	op->stats.sp = op->stats.maxsp;	801	stats.sp = stats.maxsp;
883	op->stats.grace = op->stats.maxgrace;	802	stats.grace = stats.maxgrace;
		803
		804	if (contr)
		805	{
		806	contr->levhp[1] = 9;
		807	contr->levsp[1] = 6;
		808	contr->levgrace[1] = 3;
		809
884	op->contr->orig_stats = op->stats;	810	contr->orig_stats = stats;
		811	}
885	}	812	}
886		813
887	void	814	void
888	Roll_Again (object *op)	815	object::swap_stats (int a, int b)
889	{	816	{
890	esrv_new_player (op->contr, 0);	817	int tmp = get_attr_value (&contr->orig_stats, a);
891	send_query (op->contr->socket, CS_QUERY_SINGLECHAR,	818	set_attr_value (&contr->orig_stats, a, get_attr_value (&contr->orig_stats, b));
892	"[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? ");	819	set_attr_value (&contr->orig_stats, b, tmp);
893	}
894		820
895	void	821	stats.Str = contr->orig_stats.Str;
896	Swap_Stat (object *op, int Swap_Second)	822	stats.Dex = contr->orig_stats.Dex;
		823	stats.Con = contr->orig_stats.Con;
		824	stats.Int = contr->orig_stats.Int;
		825	stats.Wis = contr->orig_stats.Wis;
		826	stats.Pow = contr->orig_stats.Pow;
		827	stats.Cha = contr->orig_stats.Cha;
		828
		829	//TODO: the following code looks so borked and should, at the very least,
		830	// be merged with the similar code in roll_stats
		831	stats.ac = 0;
		832
		833	level = 1;
		834	stats.exp = 0;
		835	stats.ac = 0;
		836
		837	stats.hp = stats.maxhp;
		838	stats.sp = stats.maxsp;
		839	stats.grace = stats.maxgrace;
		840
		841	if (contr)
		842	{
		843	contr->levhp[1] = 9;
		844	contr->levsp[1] = 6;
		845	contr->levgrace[1] = 3;
		846
		847	contr->orig_stats = stats;
		848	}
		849	}
		850
		851	static void
		852	start_info (object *op)
897	{	853	{
898	signed char tmp;
899	char buf[MAX_BUF];	854	char buf[MAX_BUF];
900		855
901	if (op->contr->Swap_First == -1)	856	sprintf (buf, "Welcome to Crossfire v%s!", VERSION);
902	{
903	new_draw_info (NDI_UNIQUE, 0, op, "How the hell did you get here?!?!!!");
904	new_draw_info (NDI_UNIQUE, 0, op, "Error in Swap_Stat code,");
905	new_draw_info (NDI_UNIQUE, 0, op, "mail korg@rdt.monash.edu.au");
906	return;
907	}
908
909	tmp = get_attr_value (&op->contr->orig_stats, op->contr->Swap_First);
910
911	set_attr_value (&op->contr->orig_stats, op->contr->Swap_First, get_attr_value (&op->contr->orig_stats, Swap_Second));
912
913	set_attr_value (&op->contr->orig_stats, Swap_Second, tmp);
914
915	sprintf (buf, "%s done\n", short_stat_name[Swap_Second]);
916	new_draw_info (NDI_UNIQUE, 0, op, buf);	857	new_draw_info (NDI_UNIQUE, 0, op, buf);
917	op->stats.Str = op->contr->orig_stats.Str;	858	//new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
918	op->stats.Dex = op->contr->orig_stats.Dex;
919	op->stats.Con = op->contr->orig_stats.Con;
920	op->stats.Int = op->contr->orig_stats.Int;
921	op->stats.Wis = op->contr->orig_stats.Wis;
922	op->stats.Pow = op->contr->orig_stats.Pow;
923	op->stats.Cha = op->contr->orig_stats.Cha;
924	op->stats.ac = 0;
925
926	op->level = 1;
927	op->stats.exp = 0;
928	op->stats.ac = 0;
929
930	op->contr->levhp[1] = 9;
931	op->contr->levsp[1] = 6;
932	op->contr->levgrace[1] = 3;
933
934	fix_player (op);
935	op->stats.hp = op->stats.maxhp;
936	op->stats.sp = op->stats.maxsp;
937	op->stats.grace = op->stats.maxgrace;
938	op->contr->orig_stats = op->stats;
939	op->contr->Swap_First = -1;
940	}
941
942
943	/* This code has been greatly reduced, because with set_attr_value
944	* and get_attr_value, the stats can be accessed just numeric
945	* ids. stat_trans is a table that translate the number entered
946	* into the actual stat. It is needed because the order the stats
947	* are displayed in the stat window is not the same as how
948	* the number's access that stat. The table does that translation.
949	*/
950	int
951	key_roll_stat (object *op, char key)
952	{
953	int keynum = key - '0';
954	char buf[MAX_BUF];
955	static sint8 stat_trans[] = { -1, STR, DEX, CON, INT, WIS, POW, CHA };
956
957	if (keynum > 0 && keynum <= 7)
958	{
959	if (op->contr->Swap_First == -1)
960	{
961	op->contr->Swap_First = stat_trans[keynum];
962	sprintf (buf, "%s ->", short_stat_name[stat_trans[keynum]]);
963	new_draw_info (NDI_UNIQUE, 0, op, buf);	859	//new_draw_info (NDI_UNIQUE, 0, op, " ");
964	}
965	else
966	Swap_Stat (op, stat_trans[keynum]);
967
968	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
969	return 1;
970	}
971	switch (key)
972	{
973	case 'n':
974	case 'N':
975	{
976	SET_FLAG (op, FLAG_WIZ);
977	if (op->map == NULL)
978	{
979	LOG (llevError, "Map == NULL in state 2\n");
980	break;
981	}
982
983	#if 0
984	/* So that enter_exit will put us at startx/starty */
985	op->x = -1;
986
987	enter_exit (op, NULL);
988	#endif
989	SET_ANIMATION (op, 2); /* So player faces south */
990	/* Enter exit adds a player otherwise */
991	add_statbonus (op);
992	send_query (op->contr->socket, CS_QUERY_SINGLECHAR,
993	"Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
994	op->contr->state = ST_CHANGE_CLASS;
995	if (op->msg)
996	new_draw_info (NDI_BLUE, 0, op, op->msg);
997	return 0;
998	}
999	case 'y':
1000	case 'Y':
1001	roll_stats (op);
1002	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
1003	return 1;
1004
1005	case 'q':
1006	case 'Q':
1007	play_again (op);
1008	return 1;
1009
1010	default:
1011	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1012	return 0;
1013	}
1014	return 0;
1015	}	860	}
1016		861
1017	/* This function takes the key that is passed, and does the	862	/* This function takes the key that is passed, and does the
1018	* appropriate action with it (change race, or other things).	863	* appropriate action with it (change race, or other things).
1019	* The function name is for historical reasons - now we have	864	* The function name is for historical reasons - now we have
1020	* separate race and class; this actually changes the RACE,	865	* separate race and class; this actually changes the RACE,
1021	* not the class.	866	* not the class.
1022	*/	867	*/
1023
1024	int	868	int
1025	key_change_class (object *op, char key)	869	key_change_class (object *op, char key)
1026	{	870	{
1027	int tmp_loop;	871	int tmp_loop;
1028		872
1029	if (key == 'q' || key == 'Q')
1030	{
1031	op->remove ();
1032	play_again (op);
1033	return 0;
1034	}
1035	if (key == 'd' || key == 'D')	873	if (key == 'd' || key == 'D')
1036	{	874	{
1037	char buf[MAX_BUF];	875	char buf[MAX_BUF];
1038		876
1039	/* this must before then initial items are given */	877	/* this must before then initial items are given */
…		…
1044	create_treasure (tl, op, 0, 0, 0);	882	create_treasure (tl, op, 0, 0, 0);
1045		883
1046	INVOKE_PLAYER (BIRTH, op->contr);	884	INVOKE_PLAYER (BIRTH, op->contr);
1047	INVOKE_PLAYER (LOGIN, op->contr);	885	INVOKE_PLAYER (LOGIN, op->contr);
1048		886
1049	op->contr->state = ST_PLAYING;	887	op->contr->ns->state = ST_PLAYING;
1050		888
1051	if (op->msg)	889	if (op->msg)
1052	op->msg = NULL;	890	op->msg = NULL;
1053		891
1054	/* We create this now because some of the unique maps will need it	892	/* We create this now because some of the unique maps will need it
1055	* to save here.	893	* to save here.
1056	*/	894	*/
1057	sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name);	895	sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name);
1058	make_path_to_file (buf);	896	make_path_to_file (buf);
1059		897
1060	#ifdef AUTOSAVE
1061	op->contr->last_save_tick = pticks;
1062	#endif
1063	start_info (op);	898	start_info (op);
1064	CLEAR_FLAG (op, FLAG_WIZ);	899	CLEAR_FLAG (op, FLAG_WIZ);
1065	give_initial_items (op, op->randomitems);	900	give_initial_items (op, op->randomitems);
1066	link_player_skills (op);	901	link_player_skills (op);
1067	esrv_send_inventory (op, op);	902	esrv_send_inventory (op, op);
1068	fix_player (op);	903	op->update_stats ();
1069		904
1070	/* This moves the player to a different start map, if there	905	/* This moves the player to a different start map, if there
1071	* is one for this race	906	* is one for this race
1072	*/	907	*/
1073	if (*first_map_ext_path)	908	if (*first_map_ext_path)
1074	{	909	{
1075	object *tmp;	910	object *tmp;
1076	char mapname[MAX_BUF];	911	char mapname[MAX_BUF];
1077		912
1078	snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name);	913	snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &op->arch->name);
1079	tmp = object::create ();	914	tmp = object::create ();
1080	EXIT_PATH (tmp) = mapname;	915	EXIT_PATH (tmp) = mapname;
1081	EXIT_X (tmp) = op->x;	916	EXIT_X (tmp) = op->x;
1082	EXIT_Y (tmp) = op->y;	917	EXIT_Y (tmp) = op->y;
1083	enter_exit (op, tmp); /* we don't really care if it succeeded;	918	op->enter_exit (tmp); /* we don't really care if it succeeded;
1084	* if the map isn't there, then stay on the	919	* if the map isn't there, then stay on the
1085	* default initial map */	920	* default initial map */
1086	tmp->destroy ();	921	tmp->destroy ();
1087	}	922	}
1088	else	923	else
1089	{
1090	LOG (llevDebug, "first_map_ext_path not set\n");	924	LOG (llevDebug, "first_map_ext_path not set\n");
1091	}	925
1092	return 0;	926	return 0;
1093	}	927	}
1094		928
1095	/* Following actually changes the race - this is the default command	929	/* Following actually changes the race - this is the default command
1096	* if we don't match with one of the options above.	930	* if we don't match with one of the options above.
…		…
1100	while (!tmp_loop)	934	while (!tmp_loop)
1101	{	935	{
1102	shstr name = op->name;	936	shstr name = op->name;
1103	int x = op->x, y = op->y;	937	int x = op->x, y = op->y;
1104		938
1105	remove_statbonus (op);	939	op->remove_statbonus ();
1106	op->remove ();	940	op->remove ();
1107	op->arch = get_player_archetype (op->arch);	941	op->arch = get_player_archetype (op->arch);
1108	op->arch->clone.copy_to (op);	942	op->arch->clone.copy_to (op);
1109	op->instantiate ();	943	op->instantiate ();
1110	op->stats = op->contr->orig_stats;	944	op->stats = op->contr->orig_stats;
…		…
1112	op->x = x;	946	op->x = x;
1113	op->y = y;	947	op->y = y;
1114	SET_ANIMATION (op, 2); /* So player faces south */	948	SET_ANIMATION (op, 2); /* So player faces south */
1115	insert_ob_in_map (op, op->map, op, 0);	949	insert_ob_in_map (op, op->map, op, 0);
1116	assign (op->contr->title, op->arch->clone.name);	950	assign (op->contr->title, op->arch->clone.name);
1117	add_statbonus (op);	951	op->add_statbonus ();
1118	tmp_loop = allowed_class (op);	952	tmp_loop = allowed_class (op);
1119	}	953	}
1120		954
1121	update_object (op, UP_OBJ_FACE);	955	update_object (op, UP_OBJ_FACE);
1122	esrv_update_item (UPD_FACE, op, op);	956	esrv_update_item (UPD_FACE, op, op);
1123	fix_player (op);	957	op->update_stats ();
1124	op->stats.hp = op->stats.maxhp;	958	op->stats.hp = op->stats.maxhp;
1125	op->stats.sp = op->stats.maxsp;	959	op->stats.sp = op->stats.maxsp;
1126	op->stats.grace = 0;	960	op->stats.grace = 0;
1127		961
1128	if (op->msg)	962	if (op->msg)
1129	new_draw_info (NDI_BLUE, 0, op, op->msg);	963	new_draw_info (NDI_BLUE, 0, op, op->msg);
1130		964
1131	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");	965	send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");
1132	return 0;	966	return 0;
1133	}
1134
1135	int
1136	key_confirm_quit (object *op, char key)
1137	{
1138	char buf[MAX_BUF];
1139
1140	if (key != 'y' && key != 'Y' && key != 'q' && key != 'Q')
1141	{
1142	op->contr->state = ST_PLAYING;
1143	new_draw_info (NDI_UNIQUE, 0, op, "OK, continuing to play.");
1144	return 1;
1145	}
1146
1147	INVOKE_PLAYER (LOGOUT, op->contr);
1148	INVOKE_PLAYER (QUIT, op->contr);
1149
1150	terminate_all_pets (op);
1151	leave_map (op);
1152	op->direction = 0;
1153	new_draw_info_format (NDI_UNIQUE | NDI_ALL, 5, NULL, "%s quits the game.", &op->name);
1154
1155	strcpy (op->contr->killer, "quit");
1156	check_score (op);
1157	op->contr->party = NULL;
1158	if (settings.set_title == TRUE)
1159	op->contr->own_title[0] = '\0';
1160
1161	if (!QUERY_FLAG (op, FLAG_WAS_WIZ))
1162	{
1163	maptile *mp, *next;
1164
1165	/* We need to hunt for any per player unique maps in memory and
1166	* get rid of them. The trailing slash in the path is intentional,
1167	* so that players named 'Ab' won't match against players 'Abe' pathname
1168	*/
1169	sprintf (buf, "%s/%s/%s/", settings.localdir, settings.playerdir, &op->name);
1170	for (mp = first_map; mp != NULL; mp = next)
1171	{
1172	next = mp->next;
1173	if (!strncmp (mp->path, buf, strlen (buf)))
1174	delete_map (mp);
1175	}
1176
1177	delete_character (op->name, 1);
1178	}
1179
1180	play_again (op);
1181	return 1;
1182	}	967	}
1183		968
1184	void	969	void
1185	flee_player (object *op)	970	flee_player (object *op)
1186	{	971	{
…		…
1216	{	1001	{
1217	op->enemy = NULL;	1002	op->enemy = NULL;
1218	CLEAR_FLAG (op, FLAG_SCARED);	1003	CLEAR_FLAG (op, FLAG_SCARED);
1219	return;	1004	return;
1220	}	1005	}
		1006
1221	get_rangevector (op, op->enemy, &rv, 0);	1007	get_rangevector (op, op->enemy, &rv, 0);
1222		1008
1223	dir = absdir (4 + rv.direction);	1009	dir = absdir (4 + rv.direction);
1224	for (diff = 0; diff < 3; diff++)	1010	for (diff = 0; diff < 3; diff++)
1225	{	1011	{
1226	int m = 1 - (RANDOM () & 2);	1012	int m = 1 - (RANDOM () & 2);
1227		1013
1228	if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))	1014	if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))
1229	{
1230	return;	1015	return;
1231	}
1232	}	1016	}
		1017
1233	/* Cornered, get rid of scared */	1018	/* Cornered, get rid of scared */
1234	CLEAR_FLAG (op, FLAG_SCARED);	1019	CLEAR_FLAG (op, FLAG_SCARED);
1235	op->enemy = NULL;	1020	op->enemy = NULL;
1236	}	1021	}
1237		1022
…		…
1323	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1108	sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1324	&tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));	1109	&tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1325	else	1110	else
1326	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1111	sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1327	&tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));	1112	&tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
		1113
1328	new_draw_info (NDI_UNIQUE, 0, op, putstring);	1114	new_draw_info (NDI_UNIQUE, 0, op, putstring);
1329
1330	sprintf (putstring, "...flags: ");
1331	for (k = 0; k < 4; k++)
1332	{
1333	for (j = 0; j < 32; j++)
1334	{
1335	if ((tmp->flags[k] >> j) & 0x01)
1336	{
1337	sprintf (tmpstr, "%d ", k * 32 + j);
1338	strcat (putstring, tmpstr);
1339	}
1340	}
1341	}
1342	new_draw_info (NDI_UNIQUE, 0, op, putstring);
1343
1344	#if 0
1345	/* print the flags too */
1346	for (k = 0; k < 4; k++)
1347	{
1348	fprintf (stderr, "%d [%d] ", k, k * 32 + 31);
1349	for (j = 0; j < 32; j++)
1350	{
1351	fprintf (stderr, "%d", tmp->flags[k] >> (31 - j) & 0x01);
1352	if (!((j + 1) % 4))
1353	fprintf (stderr, " ");
1354	}
1355	fprintf (stderr, " [%d]\n", k * 32);
1356	}
1357	#endif
1358	}	1115	}
		1116
1359	/* philosophy:	1117	/* philosophy:
1360	* It's easy to grab an item type from a pile, as long as it's	1118	* It's easy to grab an item type from a pile, as long as it's
1361	* generic. This takes no game-time. For more detailed pickups	1119	* generic. This takes no game-time. For more detailed pickups
1362	* and selections, select-items shoul dbe used. This is a	1120	* and selections, select-items should be used. This is a
1363	* grab-as-you-run type mode that's really useful for arrows for	1121	* grab-as-you-run type mode that's really useful for arrows for
1364	* example.	1122	* example.
1365	* The drawback: right now it has no frontend, so you need to	1123	* The drawback: right now it has no frontend, so you need to
1366	* stick the bits you want into a calculator in hex mode and then	1124	* stick the bits you want into a calculator in hex mode and then
1367	* convert to decimal and then 'pickup <#>	1125	* convert to decimal and then 'pickup <#>
…		…
1618	* found object is returned.	1376	* found object is returned.
1619	*/	1377	*/
1620	object *	1378	object *
1621	find_arrow (object *op, const char *type)	1379	find_arrow (object *op, const char *type)
1622	{	1380	{
1623	object *tmp = NULL;	1381	object *tmp = 0;
1624		1382
1625	for (op = op->inv; op; op = op->below)	1383	for (op = op->inv; op; op = op->below)
1626	if (!tmp && op->type == CONTAINER && op->race == type && QUERY_FLAG (op, FLAG_APPLIED))	1384	if (!tmp && op->type == CONTAINER && op->race == type && QUERY_FLAG (op, FLAG_APPLIED))
1627	tmp = find_arrow (op, type);	1385	tmp = find_arrow (op, type);
1628	else if (op->type == ARROW && op->race == type)	1386	else if (op->type == ARROW && op->race == type)
1629	return op;	1387	return op;
		1388
1630	return tmp;	1389	return tmp;
1631	}	1390	}
1632		1391
1633	/*	1392	/*
1634	* Similar to find_arrow, but looks for (roughly) the best arrow to use	1393	* Similar to find_arrow, but looks for (roughly) the best arrow to use
1635	* against the target. A full test is not performed, simply a basic test	1394	* against the target. A full test is not performed, simply a basic test
1636	* of resistances. The archer is making a quick guess at what he sees down	1395	* of resistances. The archer is making a quick guess at what he sees down
1637	* the hall. Failing that it does it's best to pick the highest plus arrow.	1396	* the hall. Failing that it does it's best to pick the highest plus arrow.
1638	*/	1397	*/
1639
1640	object *	1398	object *
1641	find_better_arrow (object *op, object *target, const char *type, int *better)	1399	find_better_arrow (object *op, object *target, const char *type, int *better)
1642	{	1400	{
1643	object *tmp = NULL, *arrow, *ntmp;	1401	object *tmp = NULL, *arrow, *ntmp;
1644	int attacknum, attacktype, betterby = 0, i;	1402	int attacknum, attacktype, betterby = 0, i;
…		…
1793	if (!dir)	1551	if (!dir)
1794	{	1552	{
1795	new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");	1553	new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1796	return 0;	1554	return 0;
1797	}	1555	}
		1556
1798	if (op->type == PLAYER)	1557	if (op->type == PLAYER)
1799	bow = op->contr->ranges[range_bow];	1558	bow = op->contr->ranges[range_bow];
1800	else	1559	else
1801	{	1560	{
1802	for (bow = op->inv; bow; bow = bow->below)	1561	for (bow = op->inv; bow; bow = bow->below)
…		…
1810	{	1569	{
1811	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);	1570	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1812	return 0;	1571	return 0;
1813	}	1572	}
1814	}	1573	}
		1574
1815	if (!bow->race || !bow->skill)	1575	if (!bow->race || !bow->skill)
1816	{	1576	{
1817	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);	1577	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);
1818	return 0;	1578	return 0;
1819	}	1579	}
…		…
1821	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];	1581	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];
1822		1582
1823	/* penalize ROF for bestarrow */	1583	/* penalize ROF for bestarrow */
1824	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)	1584	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)
1825	bowspeed -= dex_bonus[op->stats.Dex] + 5;	1585	bowspeed -= dex_bonus[op->stats.Dex] + 5;
		1586
1826	if (bowspeed < 1)	1587	if (bowspeed < 1)
1827	bowspeed = 1;	1588	bowspeed = 1;
1828		1589
1829	if (arrow == NULL)	1590	if (arrow == NULL)
1830	{	1591	{
…		…
1836	else	1597	else
1837	CLEAR_FLAG (op, FLAG_READY_BOW);	1598	CLEAR_FLAG (op, FLAG_READY_BOW);
1838	return 0;	1599	return 0;
1839	}	1600	}
1840	}	1601	}
		1602
1841	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);	1603	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1842	if (mflags & P_OUT_OF_MAP)	1604	if (mflags & P_OUT_OF_MAP)
1843	{
1844	return 0;	1605	return 0;
1845	}	1606
1846	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)	1607	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1847	{	1608	{
1848	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1609	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1849	return 0;	1610	return 0;
1850	}	1611	}
…		…
1856	return 0;	1617	return 0;
1857	}	1618	}
1858		1619
1859	left = arrow; /* these are arrows left to the player */	1620	left = arrow; /* these are arrows left to the player */
1860	arrow = get_split_ob (arrow, 1);	1621	arrow = get_split_ob (arrow, 1);
1861	if (arrow == NULL)	1622	if (!arrow)
1862	{	1623	{
1863	new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);	1624	new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1864	return 0;	1625	return 0;
1865	}	1626	}
		1627
1866	arrow->set_owner (op);	1628	arrow->set_owner (op);
1867	arrow->skill = bow->skill;	1629	arrow->skill = bow->skill;
1868
1869	arrow->direction = dir;	1630	arrow->direction = dir;
1870	arrow->x = sx;
1871	arrow->y = sy;
1872		1631
1873	if (op->type == PLAYER)	1632	if (op->type == PLAYER)
1874	{	1633	{
1875	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;	1634	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;
1876	fix_player (op);	1635	op->update_stats ();
1877	}	1636	}
1878		1637
1879	SET_ANIMATION (arrow, arrow->direction);	1638	SET_ANIMATION (arrow, arrow->direction);
1880	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */	1639	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1881	arrow->stats.hp = arrow->stats.dam;	1640	arrow->stats.hp = arrow->stats.dam;
…		…
1891		1650
1892	/* update the speed */	1651	/* update the speed */
1893	arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?	1652	arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?
1894	0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;	1653	0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;
1895		1654
1896	if (arrow->speed < 1.0)	1655	arrow->set_speed (max (arrow->speed, 1.0));
1897	arrow->speed = 1.0;
1898	update_ob_speed (arrow);
1899	arrow->speed_left = 0;	1656	arrow->speed_left = 0;
1900		1657
1901	if (op->type == PLAYER)	1658	if (op->type == PLAYER)
1902	{	1659	{
1903	arrow->stats.wc = 20 - bow->magic - arrow->magic -	1660	arrow->stats.wc = 20 - bow->magic - arrow->magic -
…		…
1913	}	1670	}
1914		1671
1915	if (arrow->attacktype == AT_PHYSICAL)	1672	if (arrow->attacktype == AT_PHYSICAL)
1916	arrow->attacktype |= bow->attacktype;	1673	arrow->attacktype |= bow->attacktype;
1917		1674
1918	if (bow->slaying != NULL)	1675	if (bow->slaying)
1919	arrow->slaying = bow->slaying;	1676	arrow->slaying = bow->slaying;
1920		1677
1921	arrow->map = m;
1922	arrow->move_type = MOVE_FLY_LOW;	1678	arrow->move_type = MOVE_FLY_LOW;
1923	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;	1679	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1924		1680
1925	play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);	1681	play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);
1926	insert_ob_in_map (arrow, m, op, 0);	1682	m->insert (arrow, sx, sy, op);
1927		1683
1928	if (!arrow->destroyed ())	1684	if (!arrow->destroyed ())
1929	move_arrow (arrow);	1685	move_arrow (arrow);
1930		1686
1931	if (op->type == PLAYER)	1687	if (op->type == PLAYER)
…		…
1957	}	1713	}
1958	else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)	1714	else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)
1959	{	1715	{
1960	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))	1716	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))
1961	wcmod = -1;	1717	wcmod = -1;
		1718
1962	ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);	1719	ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
1963	}	1720	}
1964	else if (op->contr->bowtype == bow_threewide)	1721	else if (op->contr->bowtype == bow_threewide)
1965	{	1722	{
1966	ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);	1723	ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
…		…
2036		1793
2037	if (item->arch)	1794	if (item->arch)
2038	{	1795	{
2039	CLEAR_FLAG (item, FLAG_ANIMATE);	1796	CLEAR_FLAG (item, FLAG_ANIMATE);
2040	item->face = item->arch->clone.face;	1797	item->face = item->arch->clone.face;
2041	item->speed = 0;	1798	item->set_speed (0);
2042	update_ob_speed (item);
2043	}	1799	}
		1800
2044	if ((tmp = is_player_inv (item)))	1801	if ((tmp = item->in_player ()))
2045	esrv_update_item (UPD_ANIM, tmp, item);	1802	esrv_update_item (UPD_ANIM, tmp, item);
2046	}	1803	}
2047	}	1804	}
2048	else if (item->type == ROD || item->type == HORN)	1805	else if (item->type == ROD || item->type == HORN)
2049	{
2050	drain_rod_charge (item);	1806	drain_rod_charge (item);
2051	}
2052	}	1807	}
2053	}	1808	}
2054		1809
2055	/* Received a fire command for the player - go and do it.	1810	/* Received a fire command for the player - go and do it.
2056	*/	1811	*/
…		…
2095	{	1850	{
2096	if (op->type == PLAYER)	1851	if (op->type == PLAYER)
2097	new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use.");	1852	new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use.");
2098	return;	1853	return;
2099	}	1854	}
		1855
2100	(void) do_skill (op, op, op->chosen_skill, dir, NULL);	1856	do_skill (op, op, op->chosen_skill, dir, NULL);
2101	return;	1857	return;
2102	case range_builder:	1858	case range_builder:
2103	apply_map_builder (op, dir);	1859	apply_map_builder (op, dir);
2104	return;	1860	return;
2105	default:	1861	default:
2106	new_draw_info (NDI_UNIQUE, 0, op, "Illegal shoot type.");	1862	new_draw_info (NDI_UNIQUE, 0, op, "Illegal shoot type.");
2107	return;	1863	return;
2108	}	1864	}
2109	}	1865	}
2110
2111
2112		1866
2113	/* find_key	1867	/* find_key
2114	* We try to find a key for the door as passed. If we find a key	1868	* We try to find a key for the door as passed. If we find a key
2115	* and successfully use it, we return the key, otherwise NULL	1869	* and successfully use it, we return the key, otherwise NULL
2116	* This function merges both normal and locked door, since the logic	1870	* This function merges both normal and locked door, since the logic
…		…
2118	* pl is the player,	1872	* pl is the player,
2119	* inv is the objects inventory to searched	1873	* inv is the objects inventory to searched
2120	* door is the door we are trying to match against.	1874	* door is the door we are trying to match against.
2121	* This function can be called recursively to search containers.	1875	* This function can be called recursively to search containers.
2122	*/	1876	*/
2123
2124	object *	1877	object *
2125	find_key (object *pl, object *container, object *door)	1878	find_key (object *pl, object *container, object *door)
2126	{	1879	{
2127	object *tmp, *key;	1880	object *tmp, *key;
2128		1881
2129	/* Should not happen, but sanity checking is never bad */	1882	/* Should not happen, but sanity checking is never bad */
2130	if (container->inv == NULL)	1883	if (!container->inv)
2131	return NULL;	1884	return 0;
2132		1885
2133	/* First, lets try to find a key in the top level inventory */	1886	/* First, lets try to find a key in the top level inventory */
2134	for (tmp = container->inv; tmp != NULL; tmp = tmp->below)	1887	for (tmp = container->inv; tmp; tmp = tmp->below)
2135	{	1888	{
2136	if (door->type == DOOR && tmp->type == KEY)	1889	if (door->type == DOOR && tmp->type == KEY)
2137	break;	1890	break;
2138	/* For sanity, we should really check door type, but other stuff	1891	/* For sanity, we should really check door type, but other stuff
2139	* (like containers) can be locked with special keys	1892	* (like containers) can be locked with special keys
2140	*/	1893	*/
2141	if (tmp->slaying && tmp->type == SPECIAL_KEY && tmp->slaying == door->slaying)	1894	if (tmp->slaying && tmp->type == SPECIAL_KEY && tmp->slaying == door->slaying)
2142	break;	1895	break;
2143	}	1896	}
		1897
2144	/* No key found - lets search inventories now */	1898	/* No key found - lets search inventories now */
2145	/* If we find and use a key in an inventory, return at that time.	1899	/* If we find and use a key in an inventory, return at that time.
2146	* otherwise, if we search all the inventories and still don't find	1900	* otherwise, if we search all the inventories and still don't find
2147	* a key, return	1901	* a key, return
2148	*/	1902	*/
2149	if (!tmp)	1903	if (!tmp)
2150	{	1904	{
2151	for (tmp = container->inv; tmp != NULL; tmp = tmp->below)	1905	for (tmp = container->inv; tmp; tmp = tmp->below)
2152	{	1906	{
2153	/* No reason to search empty containers */	1907	/* No reason to search empty containers */
2154	if (tmp->type == CONTAINER && tmp->inv)	1908	if (tmp->type == CONTAINER && tmp->inv)
2155	{	1909	{
2156	if ((key = find_key (pl, tmp, door)) != NULL)	1910	if ((key = find_key (pl, tmp, door)))
2157	return key;	1911	return key;
2158	}	1912	}
2159	}	1913	}
		1914
2160	if (!tmp)	1915	if (!tmp)
2161	return NULL;	1916	return NULL;
2162	}	1917	}
		1918
2163	/* We get down here if we have found a key. Now if its in a container,	1919	/* We get down here if we have found a key. Now if its in a container,
2164	* see if we actually want to use it	1920	* see if we actually want to use it
2165	*/	1921	*/
2166	if (pl != container)	1922	if (pl != container)
2167	{	1923	{
…		…
2188	new_draw_info_format (NDI_UNIQUE | NDI_BROWN, 0, pl,	1944	new_draw_info_format (NDI_UNIQUE | NDI_BROWN, 0, pl,
2189	"The %s in your %s vibrates as you approach the door", query_name (tmp), query_name (container));	1945	"The %s in your %s vibrates as you approach the door", query_name (tmp), query_name (container));
2190	return NULL;	1946	return NULL;
2191	}	1947	}
2192	}	1948	}
		1949
2193	return tmp;	1950	return tmp;
2194	}	1951	}
2195		1952
2196	/* moved door processing out of move_player_attack.	1953	/* moved door processing out of move_player_attack.
2197	* returns 1 if player has opened the door with a key	1954	* returns 1 if player has opened the door with a key
…		…
2199	* 0 otherwise	1956	* 0 otherwise
2200	*/	1957	*/
2201	static int	1958	static int
2202	player_attack_door (object *op, object *door)	1959	player_attack_door (object *op, object *door)
2203	{	1960	{
2204
2205	/* If its a door, try to find a use a key. If we do destroy the door,	1961	/* If its a door, try to find a use a key. If we do destroy the door,
2206	* might as well return immediately as there is nothing more to do -	1962	* might as well return immediately as there is nothing more to do -
2207	* otherwise, we fall through to the rest of the code.	1963	* otherwise, we fall through to the rest of the code.
2208	*/	1964	*/
2209	object *key = find_key (op, op, door);	1965	object *key = find_key (op, op, door);
…		…
2216	play_sound_map (op->map, op->x, op->y, SOUND_OPEN_DOOR);	1972	play_sound_map (op->map, op->x, op->y, SOUND_OPEN_DOOR);
2217	if (action_makes_visible (op))	1973	if (action_makes_visible (op))
2218	make_visible (op);	1974	make_visible (op);
2219	if (door->inv && (door->inv->type == RUNE || door->inv->type == TRAP))	1975	if (door->inv && (door->inv->type == RUNE || door->inv->type == TRAP))
2220	spring_trap (door->inv, op);	1976	spring_trap (door->inv, op);
		1977
2221	if (door->type == DOOR)	1978	if (door->type == DOOR)
2222	{
2223	hit_player (door, 9998, op, AT_PHYSICAL, 1); /* Break through the door */	1979	hit_player (door, 9998, op, AT_PHYSICAL, 1); /* Break through the door */
2224	}
2225	else if (door->type == LOCKED_DOOR)	1980	else if (door->type == LOCKED_DOOR)
2226	{	1981	{
2227	new_draw_info_format (NDI_UNIQUE, NDI_BROWN, op, "You open the door with the %s", query_short_name (key));	1982	new_draw_info_format (NDI_UNIQUE, NDI_BROWN, op, "You open the door with the %s", query_short_name (key));
2228	remove_door2 (door); /* remove door without violence ;-) */	1983	remove_door2 (door); /* remove door without violence ;-) */
2229	}	1984	}
		1985
2230	/* Do this after we print the message */	1986	/* Do this after we print the message */
2231	decrease_ob (key); /* Use up one of the keys */	1987	decrease_ob (key); /* Use up one of the keys */
2232	/* Need to update the weight the container the key was in */	1988	/* Need to update the weight the container the key was in */
2233	if (container != op)	1989	if (container != op)
2234	esrv_update_item (UPD_WEIGHT, op, container);	1990	esrv_update_item (UPD_WEIGHT, op, container);
		1991
2235	return 1; /* Nothing more to do below */	1992	return 1; /* Nothing more to do below */
2236	}	1993	}
2237	else if (door->type == LOCKED_DOOR)	1994	else if (door->type == LOCKED_DOOR)
2238	{	1995	{
2239	/* Might as well return now - no other way to open this */	1996	/* Might as well return now - no other way to open this */
2240	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, door->msg);	1997	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, door->msg);
2241	return 1;	1998	return 1;
2242	}	1999	}
		2000
2243	return 0;	2001	return 0;
2244	}	2002	}
2245		2003
2246	/* This function is just part of a breakup from move_player.	2004	/* This function is just part of a breakup from move_player.
2247	* It should keep the code cleaner.	2005	* It should keep the code cleaner.
2248	* When this is called, the players direction has been updated	2006	* When this is called, the players direction has been updated
2249	* (taking into account confusion.) The player is also actually	2007	* (taking into account confusion.) The player is also actually
2250	* going to try and move (not fire weapons).	2008	* going to try and move (not fire weapons).
2251	*/	2009	*/
2252
2253	void	2010	void
2254	move_player_attack (object *op, int dir)	2011	move_player_attack (object *op, int dir)
2255	{	2012	{
2256	object *tmp, *mon;	2013	object *tmp, *mon;
2257	sint16 nx, ny;	2014	sint16 nx, ny;
…		…
2259	maptile *m;	2016	maptile *m;
2260		2017
2261	nx = freearr_x[dir] + op->x;	2018	nx = freearr_x[dir] + op->x;
2262	ny = freearr_y[dir] + op->y;	2019	ny = freearr_y[dir] + op->y;
2263		2020
2264	on_battleground = op_on_battleground (op, NULL, NULL);	2021	on_battleground = op_on_battleground (op, 0, 0);
2265		2022
2266	/* If braced, or can't move to the square, and it is not out of the	2023	/* If braced, or can't move to the square, and it is not out of the
2267	* map, attack it. Note order of if statement is important - don't	2024	* map, attack it. Note order of if statement is important - don't
2268	* want to be calling move_ob if braced, because move_ob will move the	2025	* want to be calling move_ob if braced, because move_ob will move the
2269	* player. This is a pretty nasty hack, because if we could	2026	* player. This is a pretty nasty hack, because if we could
…		…
2274	*/	2031	*/
2275	if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))	2032	if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))
2276	{	2033	{
2277	if (OUT_OF_REAL_MAP (op->map, nx, ny))	2034	if (OUT_OF_REAL_MAP (op->map, nx, ny))
2278	{	2035	{
2279	m = get_map_from_coord (op->map, &nx, &ny);	2036	m = op->map->xy_find (nx, ny);
2280	if (!m)	2037	if (!m)
2281	return; /* Don't think this should happen */	2038	return; /* Don't think this should happen */
2282	}	2039	}
2283	else	2040	else
2284	m = op->map;	2041	m = op->map;
2285		2042
2286	if ((tmp = get_map_ob (m, nx, ny)) == NULL)	2043	if (!(tmp = m->at (nx, ny).bot))
2287	{
2288	/* LOG(llevError,"player_move_attack: get_map_ob returns NULL, but player can not more there.\n"); */
2289	return;	2044	return;
2290	}
2291		2045
2292	mon = NULL;	2046	mon = 0;
2293	/* Go through all the objects, and find ones of interest. Only stop if	2047	/* Go through all the objects, and find ones of interest. Only stop if
2294	* we find a monster - that is something we know we want to attack.	2048	* we find a monster - that is something we know we want to attack.
2295	* if its a door or barrel (can roll) see if there may be monsters	2049	* if its a door or barrel (can roll) see if there may be monsters
2296	* on the space	2050	* on the space
2297	*/	2051	*/
2298	while (tmp != NULL)	2052	while (tmp)
2299	{	2053	{
2300	if (tmp == op)	2054	if (tmp == op)
2301	{	2055	{
2302	tmp = tmp->above;	2056	tmp = tmp->above;
2303	continue;	2057	continue;
…		…
2313	mon = tmp;	2067	mon = tmp;
2314		2068
2315	tmp = tmp->above;	2069	tmp = tmp->above;
2316	}	2070	}
2317		2071
2318	if (mon == NULL) /* This happens anytime the player tries to move */	2072	if (!mon) /* This happens anytime the player tries to move */
2319	return; /* into a wall */	2073	return; /* into a wall */
2320		2074
2321	if (mon->head != NULL)	2075	if (mon->head)
2322	mon = mon->head;	2076	mon = mon->head;
2323		2077
2324	if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))	2078	if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
2325	if (player_attack_door (op, mon))	2079	if (player_attack_door (op, mon))
2326	return;	2080	return;
…		…
2348	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))	2102	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2349	{	2103	{
2350	/* If we're braced, we don't want to switch places with it */	2104	/* If we're braced, we don't want to switch places with it */
2351	if (op->contr->braced)	2105	if (op->contr->braced)
2352	return;	2106	return;
		2107
2353	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);	2108	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2354	(void) push_ob (mon, dir, op);	2109	(void) push_ob (mon, dir, op);
2355	if (op->contr->tmp_invis || op->hide)	2110	if (op->contr->tmp_invis || op->hide)
2356	make_visible (op);	2111	make_visible (op);
		2112
2357	return;	2113	return;
2358	}	2114	}
2359		2115
2360	/* in certain circumstances, you shouldn't attack friendly	2116	/* in certain circumstances, you shouldn't attack friendly
2361	* creatures. Note that if you are braced, you can't push	2117	* creatures. Note that if you are braced, you can't push
…		…
2363	* attack them either.	2119	* attack them either.
2364	*/	2120	*/
2365	if ((mon->type == PLAYER || mon->enemy != op) &&	2121	if ((mon->type == PLAYER || mon->enemy != op) &&
2366	(mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (	2122	(mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (
2367	#ifdef PROHIBIT_PLAYERKILL	2123	#ifdef PROHIBIT_PLAYERKILL
2368	(op->contr->peaceful	2124	(op->contr->peaceful
2369	|| (mon->type == PLAYER	2125	|| (mon->type == PLAYER
2370	&& mon->contr->	2126	&& mon->contr->
2371	peaceful)) &&	2127	peaceful)) &&
2372	#else	2128	#else
2373	op->contr->peaceful &&	2129	op->contr->peaceful &&
2374	#endif	2130	#endif
2375	!on_battleground))	2131	!on_battleground))
2376	{	2132	{
2377	if (!op->contr->braced)	2133	if (!op->contr->braced)
2378	{	2134	{
2379	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);	2135	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2380	(void) push_ob (mon, dir, op);	2136	push_ob (mon, dir, op);
2381	}	2137	}
2382	else	2138	else
2383	{
2384	new_draw_info (0, 0, op, "You withhold your attack");	2139	new_draw_info (0, 0, op, "You withhold your attack");
2385	}	2140
2386	if (op->contr->tmp_invis || op->hide)	2141	if (op->contr->tmp_invis || op->hide)
2387	make_visible (op);	2142	make_visible (op);
2388	}	2143	}
2389		2144
2390	/* If the object is a boulder or other rollable object, then	2145	/* If the object is a boulder or other rollable object, then
…		…
2401	* Way it works is like this: First, it must have some hit points	2156	* Way it works is like this: First, it must have some hit points
2402	* and be living. Then, it must be one of the following:	2157	* and be living. Then, it must be one of the following:
2403	* 1) Not a player, 2) A player, but of a different party. Note	2158	* 1) Not a player, 2) A player, but of a different party. Note
2404	* that party_number -1 is no party, so attacks can still happen.	2159	* that party_number -1 is no party, so attacks can still happen.
2405	*/	2160	*/
2406
2407	else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&	2161	else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2408	((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))	2162	((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))
2409	{	2163	{
2410		2164
2411	/* If the player hasn't hit something this tick, and does	2165	/* If the player hasn't hit something this tick, and does
…		…
2418	op->speed_left += op->speed / op->contr->weapon_sp;	2172	op->speed_left += op->speed / op->contr->weapon_sp;
2419		2173
2420	op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */	2174	op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */
2421	}	2175	}
2422		2176
2423	skill_attack (mon, op, 0, NULL, NULL);	2177	skill_attack (mon, op, 0, 0, 0);
2424		2178
2425	/* If attacking another player, that player gets automatic	2179	/* If attacking another player, that player gets automatic
2426	* hitback, and doesn't loose luck either.	2180	* hitback, and doesn't loose luck either.
2427	* Disable hitback on the battleground or if the target is	2181	* Disable hitback on the battleground or if the target is
2428	* the wiz.	2182	* the wiz.
…		…
2430	if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))	2184	if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2431	{	2185	{
2432	short luck = mon->stats.luck;	2186	short luck = mon->stats.luck;
2433		2187
2434	mon->contr->has_hit = 1;	2188	mon->contr->has_hit = 1;
2435	skill_attack (op, mon, 0, NULL, NULL);	2189	skill_attack (op, mon, 0, 0, 0);
2436	mon->stats.luck = luck;	2190	mon->stats.luck = luck;
2437	}	2191	}
		2192
2438	if (action_makes_visible (op))	2193	if (action_makes_visible (op))
2439	make_visible (op);	2194	make_visible (op);
2440	}	2195	}
2441	} /* if player should attack something */	2196	} /* if player should attack something */
2442	}	2197	}
…		…
2444	int	2199	int
2445	move_player (object *op, int dir)	2200	move_player (object *op, int dir)
2446	{	2201	{
2447	int pick;	2202	int pick;
2448		2203
2449	if (op->map == NULL || op->map->in_memory != MAP_IN_MEMORY)	2204	if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
2450	return 0;	2205	return 0;
2451		2206
2452	/* Sanity check: make sure dir is valid */	2207	/* Sanity check: make sure dir is valid */
2453	if ((dir < 0) || (dir >= 9))	2208	if ((dir < 0) || (dir >= 9))
2454	{	2209	{
2455	LOG (llevError, "move_player: invalid direction %d\n", dir);	2210	LOG (llevError, "move_player: invalid direction %d\n", dir);
2456	return 0;	2211	return 0;
2457	}	2212	}
2458		2213
2459	/* peterm: added following line */	2214	/* peterm: added following line */
2460	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)	2215	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)
2461	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	2216	dir = absdir (dir + rndm (3) + rndm (3) - 2);
2462		2217
2463	op->facing = dir;	2218	op->facing = dir;
2464		2219
2465	if (op->hide)	2220	if (op->hide)
2466	do_hidden_move (op);	2221	do_hidden_move (op);
…		…
2477		2232
2478	/* Add special check for newcs players and fire on - this way, the	2233	/* Add special check for newcs players and fire on - this way, the
2479	* server can handle repeat firing.	2234	* server can handle repeat firing.
2480	*/	2235	*/
2481	if (op->contr->fire_on || (op->contr->run_on && pick != 0))	2236	if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2482	{
2483	op->direction = dir;	2237	op->direction = dir;
2484	}
2485	else	2238	else
2486	{
2487	op->direction = 0;	2239	op->direction = 0;
2488	}	2240
2489	/* Update how the player looks. Use the facing, so direction may	2241	/* Update how the player looks. Use the facing, so direction may
2490	* get reset to zero. This allows for full animation capabilities	2242	* get reset to zero. This allows for full animation capabilities
2491	* for players.	2243	* for players.
2492	*/	2244	*/
2493	animate_object (op, op->facing);	2245	animate_object (op, op->facing);
…		…
2545		2297
2546	/* call this here - we also will call this in do_ericserver, but	2298	/* call this here - we also will call this in do_ericserver, but
2547	* the players time has been increased when doericserver has been	2299	* the players time has been increased when doericserver has been
2548	* called, so we recheck it here.	2300	* called, so we recheck it here.
2549	*/	2301	*/
2550	HandleClient (op->contr->socket, op->contr);	2302	if (op->contr->ns->handle_command ())
		2303	return 1;
		2304
2551	if (op->speed_left < 0)	2305	if (op->speed_left > 0)
2552	return 0;	2306	{
2553
2554	if (op->direction && (op->contr->run_on || op->contr->fire_on))	2307	if (op->direction && (op->contr->run_on || op->contr->fire_on))
2555	{	2308	{
2556	/* All move commands take 1 tick, at least for now */	2309	/* All move commands take 1 tick, at least for now */
2557	op->speed_left--;	2310	op->speed_left--;
2558		2311
2559	/* Instead of all the stuff below, let move_player take care	2312	/* Instead of all the stuff below, let move_player take care
2560	* of it. Also, some of the skill stuff is only put in	2313	* of it. Also, some of the skill stuff is only put in
2561	* there, as well as the confusion stuff.	2314	* there, as well as the confusion stuff.
2562	*/	2315	*/
2563	move_player (op, op->direction);	2316	move_player (op, op->direction);
2564	if (op->speed_left > 0)	2317
2565	return 1;	2318	return op->speed_left > 0;
2566	else	2319	}
2567	return 0;
2568	}	2320	}
2569		2321
2570	return 0;	2322	return 0;
2571	}	2323	}
2572		2324
…		…
2592	op->stats.hp = op->stats.maxhp;	2344	op->stats.hp = op->stats.maxhp;
2593		2345
2594	if (op->stats.food < 0)	2346	if (op->stats.food < 0)
2595	op->stats.food = 999;	2347	op->stats.food = 999;
2596		2348
2597	fix_player (op);	2349	op->update_stats ();
2598	return 1;	2350	return 1;
2599	}	2351	}
2600		2352
2601	LOG (llevError, "Error: LIFESAVE set without applied object.\n");	2353	LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2602	CLEAR_FLAG (op, FLAG_LIFESAVE);	2354	CLEAR_FLAG (op, FLAG_LIFESAVE);
…		…
2610	* from.	2362	* from.
2611	*/	2363	*/
2612	void	2364	void
2613	remove_unpaid_objects (object *op, object *env)	2365	remove_unpaid_objects (object *op, object *env)
2614	{	2366	{
2615	object *next;
2616
2617	while (op)	2367	while (op)
2618	{	2368	{
2619	next = op->below; /* Make sure we have a good value, in case	2369	object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2620	* we remove object 'op'	2370
2621	*/
2622	if (QUERY_FLAG (op, FLAG_UNPAID))	2371	if (QUERY_FLAG (op, FLAG_UNPAID))
2623	{	2372	{
2624	op->remove ();
2625	op->x = env->x;
2626	op->y = env->y;
2627	if (env->type == PLAYER)	2373	if (env->type == PLAYER)
2628	esrv_del_item (env->contr, op->count);	2374	esrv_del_item (env->contr, op->count);
2629	insert_ob_in_map (op, env->map, NULL, 0);	2375
		2376	op->insert_at (env);
2630	}	2377	}
2631	else if (op->inv)	2378	else if (op->inv)
2632	remove_unpaid_objects (op->inv, env);	2379	remove_unpaid_objects (op->inv, env);
2633		2380
2634	op = next;	2381	op = next;
2635	}	2382	}
2636	}	2383	}
2637
2638		2384
2639	/*	2385	/*
2640	* Returns pointer a static string containing gravestone text	2386	* Returns pointer a static string containing gravestone text
2641	* Moved from apply.c to player.c - player.c is what	2387	* Moved from apply.c to player.c - player.c is what
2642	* actually uses this function. player.c may not be quite the	2388	* actually uses this function. player.c may not be quite the
…		…
2676	strncat (buf2, " ", 20 - strlen (buf) / 2);	2422	strncat (buf2, " ", 20 - strlen (buf) / 2);
2677	strcat (buf2, buf);	2423	strcat (buf2, buf);
2678		2424
2679	return buf2;	2425	return buf2;
2680	}	2426	}
2681
2682
2683		2427
2684	void	2428	void
2685	do_some_living (object *op)	2429	do_some_living (object *op)
2686	{	2430	{
2687	int last_food = op->stats.food;	2431	int last_food = op->stats.food;
…		…
2696	const int max_grace = 1;	2440	const int max_grace = 1;
2697		2441
2698	if (op->contr->outputs_sync)	2442	if (op->contr->outputs_sync)
2699	{	2443	{
2700	for (i = 0; i < NUM_OUTPUT_BUFS; i++)	2444	for (i = 0; i < NUM_OUTPUT_BUFS; i++)
2701	if (op->contr->outputs[i].buf != NULL && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks)	2445	if (op->contr->outputs[i].buf && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks)
2702	flush_output_element (op, &op->contr->outputs[i]);	2446	flush_output_element (op, &op->contr->outputs[i]);
2703	}	2447	}
2704		2448
2705	if (op->contr->state == ST_PLAYING)	2449	if (op->contr->ns->state == ST_PLAYING)
2706	{	2450	{
2707
2708	/* these next three if clauses make it possible to SLOW DOWN	2451	/* these next three if clauses make it possible to SLOW DOWN
2709	hp/grace/spellpoint regeneration. */	2452	hp/grace/spellpoint regeneration. */
2710	if (op->contr->gen_hp >= 0)	2453	if (op->contr->gen_hp >= 0)
2711	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;	2454	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2712	else	2455	else
2713	{	2456	{
2714	gen_hp = op->stats.maxhp;	2457	gen_hp = op->stats.maxhp;
2715	rate_hp -= rate_hp / 2 * op->contr->gen_hp;	2458	rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2716	}	2459	}
		2460
2717	if (op->contr->gen_sp >= 0)	2461	if (op->contr->gen_sp >= 0)
2718	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;	2462	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2719	else	2463	else
2720	{	2464	{
2721	gen_sp = op->stats.maxsp;	2465	gen_sp = op->stats.maxsp;
2722	rate_sp -= rate_sp / 2 * op->contr->gen_sp;	2466	rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2723	}	2467	}
		2468
2724	if (op->contr->gen_grace >= 0)	2469	if (op->contr->gen_grace >= 0)
2725	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;	2470	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2726	else	2471	else
2727	{	2472	{
2728	gen_grace = op->stats.maxgrace;	2473	gen_grace = op->stats.maxgrace;
…		…
2744	op->stats.food += op->contr->digestion;	2489	op->stats.food += op->contr->digestion;
2745	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))	2490	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2746	op->stats.food = last_food;	2491	op->stats.food = last_food;
2747	}	2492	}
2748	}	2493	}
		2494
2749	if (max_sp > 1)	2495	if (max_sp > 1)
2750	{	2496	{
2751	over_sp = (gen_sp + 10) / rate_sp;	2497	over_sp = (gen_sp + 10) / rate_sp;
2752	if (over_sp > 0)	2498	if (over_sp > 0)
2753	{	2499	{
2754	if (op->stats.sp < op->stats.maxsp)	2500	if (op->stats.sp < op->stats.maxsp)
2755	{	2501	{
2756	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;	2502	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
		2503
2757	if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))	2504	if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))
2758	op->stats.sp--;	2505	op->stats.sp--;
		2506
2759	if (op->stats.sp > op->stats.maxsp)	2507	if (op->stats.sp > op->stats.maxsp)
2760	op->stats.sp = op->stats.maxsp;	2508	op->stats.sp = op->stats.maxsp;
2761	}	2509	}
2762	op->last_sp = 0;	2510	op->last_sp = 0;
2763	}	2511	}
2764	else	2512	else
2765	{
2766	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);	2513	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2767	}
2768	}	2514	}
2769	else	2515	else
2770	{
2771	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);	2516	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2772	}
2773	}	2517	}
2774		2518
2775	/* Regenerate Grace */	2519	/* Regenerate Grace */
2776	/* I altered this a little - maximum grace is ony achieved through prayer -b.t. */	2520	/* I altered this a little - maximum grace is ony achieved through prayer -b.t. */
2777	if (--op->last_grace < 0)	2521	if (--op->last_grace < 0)
2778	{	2522	{
2779	if (op->stats.grace < op->stats.maxgrace / 2)	2523	if (op->stats.grace < op->stats.maxgrace / 2)
2780	op->stats.grace++; /* no penalty in food for regaining grace */	2524	op->stats.grace++; /* no penalty in food for regaining grace */
		2525
2781	if (max_grace > 1)	2526	if (max_grace > 1)
2782	{	2527	{
2783	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;	2528	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2784	if (over_grace > 0)	2529	if (over_grace > 0)
2785	{	2530	{
…		…
2813	op->stats.food += op->contr->digestion;	2558	op->stats.food += op->contr->digestion;
2814	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))	2559	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2815	op->stats.food = last_food;	2560	op->stats.food = last_food;
2816	}	2561	}
2817	}	2562	}
		2563
2818	if (max_hp > 1)	2564	if (max_hp > 1)
2819	{	2565	{
2820	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;	2566	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2821	if (over_hp > 0)	2567	if (over_hp > 0)
2822	{	2568	{
…		…
2846		2592
2847	if (op->contr->gen_hp > 0)	2593	if (op->contr->gen_hp > 0)
2848	op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);	2594	op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);
2849	else	2595	else
2850	op->last_eat = 25 * (1 + bonus) / (penalty + 1);	2596	op->last_eat = 25 * (1 + bonus) / (penalty + 1);
		2597
2851	/* dms do not consume food */	2598	/* dms do not consume food */
2852	if (!QUERY_FLAG (op, FLAG_WIZ))	2599	if (!QUERY_FLAG (op, FLAG_WIZ))
2853	op->stats.food--;	2600	op->stats.food--;
2854	}	2601	}
2855	}
2856		2602
2857	if (op->contr->state == ST_PLAYING && op->stats.food < 0 && op->stats.hp >= 0)	2603	if (op->stats.food < 0 && op->stats.hp >= 0)
2858	{	2604	{
2859	object *tmp, *flesh = NULL;	2605	object *tmp, *flesh = 0;
2860		2606
2861	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	2607	for (tmp = op->inv; tmp; tmp = tmp->below)
2862	{	2608	{
2863	if (!QUERY_FLAG (tmp, FLAG_UNPAID))	2609	if (!QUERY_FLAG (tmp, FLAG_UNPAID))
2864	{
2865	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2866	{	2610	{
		2611	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
		2612	{
2867	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");	2613	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2868	manual_apply (op, tmp, 0);	2614	manual_apply (op, tmp, 0);
2869	if (op->stats.food >= 0 || op->stats.hp < 0)	2615	if (op->stats.food >= 0 || op->stats.hp < 0)
2870	break;	2616	break;
2871	}	2617	}
2872	else if (tmp->type == FLESH)	2618	else if (tmp->type == FLESH)
2873	flesh = tmp;	2619	flesh = tmp;
2874	} /* End if paid for object */	2620	} /* End if paid for object */
2875	} /* end of for loop */	2621	} /* end of for loop */
		2622
2876	/* If player is still starving, it means they don't have any food, so	2623	/* If player is still starving, it means they don't have any food, so
2877	* eat flesh instead.	2624	* eat flesh instead.
2878	*/	2625	*/
2879	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)	2626	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2880	{	2627	{
2881	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");	2628	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2882	manual_apply (op, flesh, 0);	2629	manual_apply (op, flesh, 0);
2883	}	2630	}
2884	} /* end if player is starving */	2631	}
2885		2632
2886	while (op->stats.food < 0 && op->stats.hp > 0)	2633	while (op->stats.food < 0 && op->stats.hp >= 0)
2887	op->stats.food++, op->stats.hp--;	2634	op->stats.food++, op->stats.hp--;
2888		2635
2889	if (!op->contr->state && !QUERY_FLAG (op, FLAG_WIZ) && (op->stats.hp < 0 || op->stats.food < 0))	2636	if (op->stats.hp < 0 && !QUERY_FLAG (op, FLAG_WIZ))
2890	kill_player (op);	2637	kill_player (op);
		2638	}
2891	}	2639	}
2892
2893
2894		2640
2895	/* If the player should die (lack of hp, food, etc), we call this.	2641	/* If the player should die (lack of hp, food, etc), we call this.
2896	* op is the player in jeopardy. If the player can not be saved (not	2642	* op is the player in jeopardy. If the player can not be saved (not
2897	* permadeath, no lifesave), this will take care of removing the player	2643	* permadeath, no lifesave), this will take care of removing the player
2898	* file.	2644	* file.
…		…
2928	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");	2674	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");
2929	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");	2675	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");
2930		2676
2931	/* restore player */	2677	/* restore player */
2932	at = archetype::find ("poisoning");	2678	at = archetype::find ("poisoning");
2933	tmp = present_arch_in_ob (at, op);	2679	if (object *tmp = present_arch_in_ob (at, op))
2934	if (tmp)
2935	{	2680	{
2936	tmp->destroy ();	2681	tmp->destroy ();
2937	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2682	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2938	}	2683	}
2939		2684
2940	at = archetype::find ("confusion");	2685	at = archetype::find ("confusion");
2941	tmp = present_arch_in_ob (at, op);	2686	if (object *tmp = present_arch_in_ob (at, op))
2942	if (tmp)
2943	{	2687	{
2944	tmp->destroy ();	2688	tmp->destroy ();
2945	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2689	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2946	}	2690	}
2947		2691
…		…
2949	op->stats.hp = op->stats.maxhp;	2693	op->stats.hp = op->stats.maxhp;
2950	if (op->stats.food <= 0)	2694	if (op->stats.food <= 0)
2951	op->stats.food = 999;	2695	op->stats.food = 999;
2952		2696
2953	/* create a bodypart-trophy to make the winner happy */	2697	/* create a bodypart-trophy to make the winner happy */
2954	tmp = arch_to_object (archetype::find ("finger"));	2698	if (object *tmp = arch_to_object (archetype::find ("finger")))
2955	if (tmp != NULL)
2956	{	2699	{
2957	sprintf (buf, "%s's finger", &op->name);	2700	sprintf (buf, "%s's finger", &op->name);
2958	tmp->name = buf;	2701	tmp->name = buf;
2959	sprintf (buf, " This finger has been cut off %s\n"	2702	sprintf (buf, " This finger has been cut off %s\n"
2960	" the %s, when he was defeated at\n level %d by %s.\n",	2703	" the %s, when he was defeated at\n level %d by %s.\n",
2961	&op->name, op->contr->title, (int) (op->level), op->contr->killer);	2704	&op->name, op->contr->title, (int) (op->level), op->contr->killer);
2962	tmp->msg = buf;	2705	tmp->msg = buf;
2963	tmp->value = 0, tmp->material = 0, tmp->type = 0;	2706	tmp->value = 0, tmp->type = 0;
2964	tmp->materialname = NULL;	2707	tmp->materialname = "organics";
2965	tmp->x = op->x, tmp->y = op->y;	2708	tmp->insert_at (op, tmp);
2966	insert_ob_in_map (tmp, op->map, op, 0);
2967	}	2709	}
2968		2710
2969	/* teleport defeated player to new destination */	2711	/* teleport defeated player to new destination */
2970	transfer_ob (op, x, y, 0, NULL);	2712	transfer_ob (op, x, y, 0, NULL);
2971	op->contr->braced = 0;	2713	op->contr->braced = 0;
…		…
2976		2718
2977	command_kill_pets (op, 0);	2719	command_kill_pets (op, 0);
2978		2720
2979	if (op->stats.food < 0)	2721	if (op->stats.food < 0)
2980	{	2722	{
2981	if (op->contr->explore)
2982	{
2983	new_draw_info (NDI_UNIQUE, 0, op, "You would have starved, but you are");
2984	new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
2985	op->stats.food = 999;
2986	return;
2987	}
2988	sprintf (buf, "%s starved to death.", &op->name);	2723	sprintf (buf, "%s starved to death.", &op->name);
2989	strcpy (op->contr->killer, "starvation");	2724	strcpy (op->contr->killer, "starvation");
2990	}	2725	}
2991	else	2726	else
2992	{
2993	if (op->contr->explore)
2994	{
2995	new_draw_info (NDI_UNIQUE, 0, op, "You would have died, but you are");
2996	new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
2997	op->stats.hp = op->stats.maxhp;
2998	return;
2999	}
3000	sprintf (buf, "%s died.", &op->name);	2727	sprintf (buf, "%s died.", &op->name);
3001	}	2728
3002	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);	2729	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);
3003		2730
3004	/* save the map location for corpse, gravestone */	2731	/* save the map location for corpse, gravestone */
3005	x = op->x;	2732	x = op->x;
3006	y = op->y;	2733	y = op->y;
3007	map = op->map;	2734	map = op->map;
3008		2735
3009
3010	if (settings.not_permadeth == TRUE)
3011	{
3012	/* NOT_PERMADEATH code. This basically brings the character back to	2736	/* NOT_PERMADEATH code. This basically brings the character back to
3013	* life if they are dead - it takes some exp and a random stat.	2737	* life if they are dead - it takes some exp and a random stat.
3014	* See the config.h file for a little more in depth detail about this.	2738	* See the config.h file for a little more in depth detail about this.
3015	*/	2739	*/
3016		2740
3017	/* Basically two ways to go - remove a stat permanently, or just	2741	/* Basically two ways to go - remove a stat permanently, or just
3018	* make it depletion. This bunch of code deals with that aspect	2742	* make it depletion. This bunch of code deals with that aspect
3019	* of death.	2743	* of death.
3020	*/	2744	*/
3021	#ifndef COZY_SERVER	2745	#ifndef COZY_SERVER
3022	if (settings.balanced_stat_loss)	2746	if (settings.balanced_stat_loss)
3023	{	2747	{
3024	/* If stat loss is permanent, lose one stat only. */	2748	/* If stat loss is permanent, lose one stat only. */
3025	/* Lower level chars don't lose as many stats because they suffer	2749	/* Lower level chars don't lose as many stats because they suffer
3026	more if they do. */	2750	more if they do. */
3027	/* Higher level characters can afford things such as potions of	2751	/* Higher level characters can afford things such as potions of
3028	restoration, or better, stat potions. So we slug them that	2752	restoration, or better, stat potions. So we slug them that
3029	little bit harder. */	2753	little bit harder. */
3030	/* GD */	2754	/* GD */
3031	if (settings.stat_loss_on_death)	2755	if (settings.stat_loss_on_death)
3032	num_stats_lose = 1;	2756	num_stats_lose = 1;
3033	else
3034	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
3035	}
3036	else	2757	else
3037	{	2758	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
		2759	}
		2760	else
3038	num_stats_lose = 1;	2761	num_stats_lose = 1;
3039	}	2762
3040	lost_a_stat = 0;	2763	lost_a_stat = 0;
3041		2764
3042	for (z = 0; z < num_stats_lose; z++)	2765	for (z = 0; z < num_stats_lose; z++)
3043	{	2766	{
3044	i = RANDOM () % NUM_STATS;	2767	i = RANDOM () % NUM_STATS;
3045		2768
3046	if (settings.stat_loss_on_death)	2769	if (settings.stat_loss_on_death)
3047	{	2770	{
3048	/* Pick a random stat and take a point off it. Tell the player	2771	/* Pick a random stat and take a point off it. Tell the player
3049	* what he lost.	2772	* what he lost.
3050	*/	2773	*/
3051	change_attr_value (&(op->stats), i, -1);	2774	change_attr_value (&(op->stats), i, -1);
3052	check_stat_bounds (&(op->stats));	2775	check_stat_bounds (&(op->stats));
3053	change_attr_value (&(op->contr->orig_stats), i, -1);	2776	change_attr_value (&(op->contr->orig_stats), i, -1);
3054	check_stat_bounds (&(op->contr->orig_stats));	2777	check_stat_bounds (&(op->contr->orig_stats));
3055	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);	2778	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3056	lost_a_stat = 1;	2779	lost_a_stat = 1;
		2780	}
		2781	else
		2782	{
		2783	/* deplete a stat */
		2784	archetype *deparch = archetype::find ("depletion");
		2785	object *dep;
		2786
		2787	dep = present_arch_in_ob (deparch, op);
		2788	if (!dep)
		2789	{
		2790	dep = arch_to_object (deparch);
		2791	insert_ob_in_ob (dep, op);
3057	}	2792	}
3058	else	2793	lose_this_stat = 1;
		2794	if (settings.balanced_stat_loss)
3059	{	2795	{
3060	/* deplete a stat */	2796	/* GD */
3061	archetype *deparch = archetype::find ("depletion");	2797	/* Get the stat that we're about to deplete. */
3062	object *dep;	2798	this_stat = get_attr_value (&(dep->stats), i);
3063		2799	if (this_stat < 0)
3064	dep = present_arch_in_ob (deparch, op);
3065	if (!dep)
3066	{	2800	{
3067	dep = arch_to_object (deparch);	2801	int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3068	insert_ob_in_ob (dep, op);	2802	int keep_chance = this_stat * this_stat;
3069	}	2803
3070	lose_this_stat = 1;	2804	/* Yes, I am paranoid. Sue me. */
3071	if (settings.balanced_stat_loss)
3072	{
3073	/* GD */
3074	/* Get the stat that we're about to deplete. */
3075	this_stat = get_attr_value (&(dep->stats), i);
3076	if (this_stat < 0)	2805	if (keep_chance < 1)
		2806	keep_chance = 1;
		2807
		2808	/* There is a maximum depletion total per level. */
		2809	if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3077	{	2810	{
3078	int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3079	int keep_chance = this_stat * this_stat;
3080
3081	/* Yes, I am paranoid. Sue me. */
3082	if (keep_chance < 1)
3083	keep_chance = 1;
3084
3085	/* There is a maximum depletion total per level. */
3086	if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3087	{
3088	lose_this_stat = 0;	2811	lose_this_stat = 0;
3089	/* Take loss chance vs keep chance to see if we	2812	/* Take loss chance vs keep chance to see if we
3090	retain the stat. */	2813	retain the stat. */
3091	}
3092	else
3093	{
3094	if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3095	lose_this_stat = 0;
3096	/* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
3097	this_stat, keep_chance, loss_chance,
3098	lose_this_stat?"LOSE":"KEEP"); */
3099	}
3100	}	2814	}
3101	}
3102
3103	if (lose_this_stat)
3104	{
3105	this_stat = get_attr_value (&(dep->stats), i);
3106	/* We could try to do something clever like find another
3107	* stat to reduce if this fails. But chances are, if
3108	* stats have been depleted to -50, all are pretty low
3109	* and should be roughly the same, so it shouldn't make a
3110	* difference.
3111	*/	2815	else
3112	if (this_stat >= -50)
3113	{	2816	{
3114	change_attr_value (&(dep->stats), i, -1);	2817	if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3115	SET_FLAG (dep, FLAG_APPLIED);
3116	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3117	fix_player (op);
3118	lost_a_stat = 1;	2818	lose_this_stat = 0;
		2819	/* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
		2820	this_stat, keep_chance, loss_chance,
		2821	lose_this_stat?"LOSE":"KEEP"); */
3119	}	2822	}
3120	}	2823	}
3121	}	2824	}
		2825
		2826	if (lose_this_stat)
		2827	{
		2828	this_stat = get_attr_value (&(dep->stats), i);
		2829	/* We could try to do something clever like find another
		2830	* stat to reduce if this fails. But chances are, if
		2831	* stats have been depleted to -50, all are pretty low
		2832	* and should be roughly the same, so it shouldn't make a
		2833	* difference.
		2834	*/
		2835	if (this_stat >= -50)
		2836	{
		2837	change_attr_value (&(dep->stats), i, -1);
		2838	SET_FLAG (dep, FLAG_APPLIED);
		2839	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
		2840	op->update_stats ();
		2841	lost_a_stat = 1;
		2842	}
3122	}	2843	}
		2844	}
		2845	}
3123	/* If no stat lost, tell the player. */	2846	/* If no stat lost, tell the player. */
3124	if (!lost_a_stat)	2847	if (!lost_a_stat)
3125	{	2848	{
3126	/* determine_god() seems to not work sometimes... why is this?	2849	/* determine_god() seems to not work sometimes... why is this?
3127	Should I be using something else? GD */	2850	Should I be using something else? GD */
3128	const char *god = determine_god (op);	2851	const char *god = determine_god (op);
3129		2852
3130	if (god && (strcmp (god, "none")))	2853	if (god && (strcmp (god, "none")))
3131	new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);	2854	new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3132	else	2855	else
3133	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");	2856	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3134	}	2857	}
3135	#else	2858	#else
3136	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");	2859	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3137	#endif	2860	#endif
3138		2861
3139	/* Put a gravestone up where the character 'almost' died. List the	2862	/* Put a gravestone up where the character 'almost' died. List the
3140	* exp loss on the stone.	2863	* exp loss on the stone.
3141	*/	2864	*/
3142	tmp = arch_to_object (archetype::find ("gravestone"));	2865	tmp = arch_to_object (archetype::find ("gravestone"));
3143	sprintf (buf, "%s's gravestone", &op->name);	2866	sprintf (buf, "%s's gravestone", &op->name);
3144	tmp->name = buf;	2867	tmp->name = buf;
3145	sprintf (buf, "%s's gravestones", &op->name);	2868	sprintf (buf, "%s's gravestones", &op->name);
3146	tmp->name_pl = buf;	2869	tmp->name_pl = buf;
3147	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);	2870	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);
3148	tmp->msg = buf;	2871	tmp->msg = buf;
3149	tmp->x = op->x, tmp->y = op->y;	2872	tmp->x = op->x, tmp->y = op->y;
3150	insert_ob_in_map (tmp, op->map, NULL, 0);	2873	insert_ob_in_map (tmp, op->map, NULL, 0);
3151		2874
3152	/**************************************/	2875	/**************************************/
3153	/* */	2876	/* */
3154	/* Subtract the experience points, */	2877	/* Subtract the experience points, */
3155	/* if we died cause of food, give us */	2878	/* if we died cause of food, give us */
3156	/* food, and reset HP's... */	2879	/* food, and reset HP's... */
3157	/* */	2880	/* */
3158	/**************************************/	2881	/**************************************/
3159		2882
3160	/* remove any poisoning and confusion the character may be suffering. */	2883	/* remove any poisoning and confusion the character may be suffering. */
3161	/* restore player */	2884	/* restore player */
3162	at = archetype::find ("poisoning");	2885	at = archetype::find ("poisoning");
3163	tmp = present_arch_in_ob (at, op);	2886	tmp = present_arch_in_ob (at, op);
3164		2887
3165	if (tmp)	2888	if (tmp)
3166	{	2889	{
3167	tmp->destroy ();	2890	tmp->destroy ();
3168	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2891	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3169	}	2892	}
3170		2893
3171	at = archetype::find ("confusion");	2894	at = archetype::find ("confusion");
3172	tmp = present_arch_in_ob (at, op);	2895	tmp = present_arch_in_ob (at, op);
3173	if (tmp)	2896	if (tmp)
3174	{	2897	{
3175	tmp->destroy ();	2898	tmp->destroy ();
3176	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2899	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3177	}	2900	}
3178		2901
3179	cure_disease (op, 0); /* remove any disease */	2902	cure_disease (op, 0); /* remove any disease */
3180		2903
3181	/*add_exp(op, (op->stats.exp * -0.20)); */	2904	/*add_exp(op, (op->stats.exp * -0.20)); */
3182	apply_death_exp_penalty (op);	2905	apply_death_exp_penalty (op);
3183	if (op->stats.food < 100)	2906	if (op->stats.food < 100)
3184	op->stats.food = 900;	2907	op->stats.food = 900;
3185	op->stats.hp = op->stats.maxhp;	2908	op->stats.hp = op->stats.maxhp;
3186	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);	2909	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);
3187	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);	2910	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);
3188		2911
3189	/*	2912	/*
3190	* Check to see if the player is in a shop. IF so, then check to see if	2913	* Check to see if the player is in a shop. IF so, then check to see if
3191	* the player has any unpaid items. If so, remove them and put them back	2914	* the player has any unpaid items. If so, remove them and put them back
3192	* in the map.	2915	* in the map.
3193	*/	2916	*/
3194		2917
3195	if (is_in_shop (op))	2918	if (is_in_shop (op))
3196	remove_unpaid_objects (op->inv, op);	2919	remove_unpaid_objects (op->inv, op);
3197		2920
3198	/****************************************/	2921	/****************************************/
3199	/* */	2922	/* */
3200	/* Move player to his current respawn- */	2923	/* Move player to his current respawn- */
3201	/* position (usually last savebed) */	2924	/* position (usually last savebed) */
3202	/* */	2925	/* */
3203	/****************************************/	2926	/****************************************/
3204		2927
3205	enter_player_savebed (op);	2928	enter_player_savebed (op);
3206		2929
3207	/* Save the player before inserting the force to reduce
3208	* chance of abuse.
3209	*/
3210	op->contr->braced = 0;	2930	op->contr->braced = 0;
3211	save_player (op, 1);
3212		2931
3213	/* it is possible that the player has blown something up	2932	/* it is possible that the player has blown something up
3214	* at his savebed location, and that can have long lasting	2933	* at his savebed location, and that can have long lasting
3215	* spell effects. So first see if there is a spell effect	2934	* spell effects. So first see if there is a spell effect
3216	* on the space that might harm the player.	2935	* on the space that might harm the player.
3217	*/	2936	*/
3218	will_kill_again = 0;	2937	will_kill_again = 0;
3219	for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above)	2938	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
3220	if (tmp->type == SPELL_EFFECT)	2939	if (tmp->type == SPELL_EFFECT)
3221	will_kill_again |= tmp->attacktype;	2940	will_kill_again |= tmp->attacktype;
3222		2941
3223	if (will_kill_again)	2942	if (will_kill_again)
3224	{	2943	{
3225	object *force;	2944	object *force;
3226	int at;	2945	int at;
3227		2946
3228	force = get_archetype (FORCE_NAME);	2947	force = get_archetype (FORCE_NAME);
3229	/* 50 ticks should be enough time for the spell to abate */	2948	/* 50 ticks should be enough time for the spell to abate */
3230	force->speed = 0.1;	2949	force->speed = 0.1;
3231	force->speed_left = -5.0;	2950	force->speed_left = -5.0;
3232	SET_FLAG (force, FLAG_APPLIED);	2951	SET_FLAG (force, FLAG_APPLIED);
3233	for (at = 0; at < NROFATTACKS; at++)	2952	for (at = 0; at < NROFATTACKS; at++)
3234	if (will_kill_again & (1 << at))	2953	if (will_kill_again & (1 << at))
3235	force->resist[at] = 100;	2954	force->resist[at] = 100;
3236		2955
3237	insert_ob_in_ob (force, op);	2956	insert_ob_in_ob (force, op);
3238	fix_player (op);	2957	op->update_stats ();
3239		2958
3240	}	2959	}
3241		2960
3242	new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");	2961	new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");
3243	return;
3244	} /* NOT_PERMADETH */
3245	else
3246	{
3247	/* If NOT_PERMADETH is set, then the rest of this is not reachable. This
3248	* should probably be embedded in an else statement.
3249	*/
3250
3251	op->contr->party = NULL;
3252	if (settings.set_title == TRUE)
3253	op->contr->own_title[0] = '\0';
3254	new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3255	check_score (op);
3256
3257	if (op->contr->ranges[range_golem])
3258	{
3259	remove_friendly_object (op->contr->ranges[range_golem]);
3260	op->contr->ranges[range_golem]->destroy ();
3261	op->contr->ranges[range_golem] = 0;
3262	}
3263
3264	loot_object (op); /* Remove some of the items for good */
3265	op->remove ();
3266	op->direction = 0;
3267
3268	if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3269	{
3270	delete_character (op->name, 0);
3271	if (settings.resurrection == TRUE)
3272	{
3273	/* save playerfile sans equipment when player dies
3274	** then save it as player.pl.dead so that future resurrection
3275	** type spells will work on them nicely
3276	*/
3277	delete_character (op->name, 0);
3278	op->stats.hp = op->stats.maxhp;
3279	op->stats.food = 999;
3280
3281	/* set the location of where the person will reappear when */
3282	/* maybe resurrection code should fix map also */
3283	strcpy (op->contr->maplevel, settings.emergency_mapname);
3284	if (op->map != NULL)
3285	op->map = NULL;
3286	op->x = settings.emergency_x;
3287	op->y = settings.emergency_y;
3288	save_player (op, 0);
3289	op->map = map;
3290	/* please see resurrection.c: peterm */
3291	dead_player (op);
3292	}
3293	else
3294	delete_character (op->name, 1);
3295	}
3296
3297	play_again (op);
3298
3299	/* peterm: added to create a corpse at deathsite. */
3300	tmp = arch_to_object (archetype::find ("corpse_pl"));
3301	sprintf (buf, "%s", &op->name);
3302	tmp->name = tmp->name_pl = buf;
3303	tmp->level = op->level;
3304	tmp->x = x;
3305	tmp->y = y;
3306	tmp->msg = gravestone_text (op);
3307	SET_FLAG (tmp, FLAG_UNIQUE);
3308	insert_ob_in_map (tmp, map, NULL, 0);
3309	}
3310	}	2962	}
3311
3312		2963
3313	void	2964	void
3314	loot_object (object *op)	2965	loot_object (object *op)
3315	{ /* Grab and destroy some treasure */	2966	{ /* Grab and destroy some treasure */
3316	object *tmp, *tmp2, *next;	2967	object *tmp, *tmp2, *next;
3317		2968
3318	if (op->container)	2969	op->close_container (); /* close open sack first */
3319	{ /* close open sack first */
3320	esrv_apply_container (op, op->container);
3321	}
3322		2970
3323	for (tmp = op->inv; tmp != NULL; tmp = next)	2971	for (tmp = op->inv; tmp; tmp = next)
3324	{	2972	{
3325	next = tmp->below;	2973	next = tmp->below;
3326	if (tmp->type == EXPERIENCE || tmp->invisible)	2974
		2975	if (tmp->invisible)
3327	continue;	2976	continue;
		2977
3328	tmp->remove ();	2978	tmp->remove ();
3329	tmp->x = op->x, tmp->y = op->y;	2979	tmp->x = op->x, tmp->y = op->y;
		2980
3330	if (tmp->type == CONTAINER)	2981	if (tmp->type == CONTAINER)
3331	{ /* empty container to ground */	2982	loot_object (tmp); /* empty container to ground */
3332	loot_object (tmp);	2983
3333	}
3334	if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3)))	2984	if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(rndm (3))))
3335	{	2985	{
3336	if (tmp->nrof > 1)	2986	if (tmp->nrof > 1)
3337	{	2987	{
3338	tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));	2988	tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));
3339	tmp2->destroy ();	2989	tmp2->destroy ();
…		…
3350	/*	3000	/*
3351	* fix_weight(): Check recursively the weight of all players, and fix	3001	* fix_weight(): Check recursively the weight of all players, and fix
3352	* what needs to be fixed. Refresh windows and fix speed if anything	3002	* what needs to be fixed. Refresh windows and fix speed if anything
3353	* was changed.	3003	* was changed.
3354	*/	3004	*/
3355
3356	void	3005	void
3357	fix_weight (void)	3006	fix_weight (void)
3358	{	3007	{
3359	player *pl;	3008	for_all_players (pl)
3360
3361	for (pl = first_player; pl != NULL; pl = pl->next)
3362	{	3009	{
3363	int old = pl->ob->carrying, sum = sum_weight (pl->ob);	3010	int old = pl->ob->carrying, sum = sum_weight (pl->ob);
3364		3011
3365	if (old == sum)	3012	if (old == sum)
3366	continue;	3013	continue;
3367	fix_player (pl->ob);	3014	pl->ob->update_stats ();
3368	LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);	3015	LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);
3369	}	3016	}
3370	}	3017	}
3371		3018
3372	void	3019	void
3373	fix_luck (void)	3020	fix_luck (void)
3374	{	3021	{
3375	player *pl;	3022	for_all_players (pl)
3376
3377	for (pl = first_player; pl != NULL; pl = pl->next)
3378	if (!pl->ob->contr->state)	3023	if (!pl->ob->contr->ns->state)
3379	change_luck (pl->ob, 0);	3024	pl->ob->change_luck (0);
3380	}	3025	}
3381
3382		3026
3383	/* cast_dust() - handles op throwing objects of type 'DUST'.	3027	/* cast_dust() - handles op throwing objects of type 'DUST'.
3384	* This is much simpler in the new spell code - we basically	3028	* This is much simpler in the new spell code - we basically
3385	* just treat this as any other spell casting object.	3029	* just treat this as any other spell casting object.
3386	*/	3030	*/
3387
3388	void	3031	void
3389	cast_dust (object *op, object *throw_ob, int dir)	3032	cast_dust (object *op, object *throw_ob, int dir)
3390	{	3033	{
3391	object *skop, *spob;	3034	object *skop, *spob;
3392		3035
…		…
3437	object *tmp = NULL;	3080	object *tmp = NULL;
3438		3081
3439	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))	3082	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
3440	return 1;	3083	return 1;
3441		3084
3442	if (op->type == PLAYER)
3443	for (tmp = op->inv; tmp; tmp = tmp->below)
3444	if (tmp->type == EXPERIENCE && tmp->stats.Wis)
3445	if (QUERY_FLAG (tmp, FLAG_UNDEAD))
3446	return 1;
3447	return 0;	3085	return 0;
3448	}	3086	}
3449		3087
3450	/* look at the surrounding terrain to determine	3088	/* look at the surrounding terrain to determine
3451	* the hideability of this object. Positive levels	3089	* the hideability of this object. Positive levels
…		…
3507		3145
3508	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);	3146	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);
3509		3147
3510	/* its *extremely* hard to run and sneak/hide at the same time! */	3148	/* its *extremely* hard to run and sneak/hide at the same time! */
3511	if (op->type == PLAYER && op->contr->run_on)	3149	if (op->type == PLAYER && op->contr->run_on)
3512	{
3513	if (!skop || num >= skop->level)	3150	if (!skop || num >= skop->level)
3514	{	3151	{
3515	new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");	3152	new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");
3516	make_visible (op);	3153	make_visible (op);
3517	return;	3154	return;
3518	}	3155	}
3519	else	3156	else
3520	num += 20;	3157	num += 20;
3521	}	3158
3522	num += op->map->difficulty;	3159	num += op->map->difficulty;
3523	hide = hideability (op); /* modify by terrain hidden level */	3160	hide = hideability (op); /* modify by terrain hidden level */
3524	num -= hide;	3161	num -= hide;
		3162
3525	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))	3163	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))
3526	{	3164	{
3527	make_visible (op);	3165	make_visible (op);
3528	if (op->type == PLAYER)	3166	if (op->type == PLAYER)
3529	new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");	3167	new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");
3530	}	3168	}
3531	else if (op->type == PLAYER && skop)	3169	else if (op->type == PLAYER && skop)
3532	{
3533	change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);	3170	change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);
3534	}
3535	}	3171	}
3536		3172
3537	/* determine if who is standing near a hostile creature. */	3173	/* determine if who is standing near a hostile creature. */
3538		3174
3539	int	3175	int
…		…
3566	if (mflags & P_OUT_OF_MAP)	3202	if (mflags & P_OUT_OF_MAP)
3567	continue;	3203	continue;
3568	if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))	3204	if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))
3569	continue;	3205	continue;
3570		3206
3571	for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above)	3207	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
3572	{	3208	{
3573	if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))	3209	if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
3574	return 1;	3210	return 1;
3575	else if (tmp->type == PLAYER)	3211	else if (tmp->type == PLAYER)
3576	{	3212	{
…		…
3606	if (pl->type != PLAYER)	3242	if (pl->type != PLAYER)
3607	{	3243	{
3608	LOG (llevError, "player_can_view() called for non-player object\n");	3244	LOG (llevError, "player_can_view() called for non-player object\n");
3609	return -1;	3245	return -1;
3610	}	3246	}
		3247
3611	if (!pl || !op)	3248	if (!pl || !op)
3612	return 0;	3249	return 0;
3613		3250
3614	if (op->head)
3615	{
3616	op = op->head;	3251	op = op->head_ ();
3617	}	3252
3618	get_rangevector (pl, op, &rv, 0x1);	3253	get_rangevector (pl, op, &rv, 0x1);
3619		3254
3620	/* starting with the 'head' part, lets loop	3255	/* starting with the 'head' part, lets loop
3621	* through the object and find if it has any	3256	* through the object and find if it has any
3622	* part that is in the los array but isnt on	3257	* part that is in the los array but isnt on
…		…
3630		3265
3631	/* only the viewable area the player sees is updated by LOS	3266	/* only the viewable area the player sees is updated by LOS
3632	* code, so we need to restrict ourselves to that range of values	3267	* code, so we need to restrict ourselves to that range of values
3633	* for any meaningful values.	3268	* for any meaningful values.
3634	*/	3269	*/
3635	if (FABS (dx) <= (pl->contr->socket->mapx / 2) &&	3270	if (FABS (dx) <= (pl->contr->ns->mapx / 2) &&
3636	FABS (dy) <= (pl->contr->socket->mapy / 2) &&	3271	FABS (dy) <= (pl->contr->ns->mapy / 2) &&
3637	!pl->contr->blocked_los[dx + (pl->contr->socket->mapx / 2)][dy + (pl->contr->socket->mapy / 2)])	3272	!pl->contr->blocked_los[dx + (pl->contr->ns->mapx / 2)][dy + (pl->contr->ns->mapy / 2)])
3638	return 1;	3273	return 1;
3639	op = op->more;	3274	op = op->more;
3640	}	3275	}
3641	return 0;	3276	return 0;
3642	}	3277	}
…		…
3752	if (trlist == NULL || who->type != PLAYER)	3387	if (trlist == NULL || who->type != PLAYER)
3753	return;	3388	return;
3754		3389
3755	for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);	3390	for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);
3756		3391
3757	if (tr == NULL || tr->item == NULL)	3392	if (!tr || !tr->item)
3758	{	3393	{
3759	/* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */	3394	/* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3760	return;	3395	return;
3761	}	3396	}
3762		3397
…		…
3828	{	3463	{
3829	/* forces in the treasurelist can alter the player's stats */	3464	/* forces in the treasurelist can alter the player's stats */
3830	object *skin;	3465	object *skin;
3831		3466
3832	/* first get the dragon skin force */	3467	/* first get the dragon skin force */
		3468	shstr_cmp dragon_skin_force ("dragon_skin_force");
3833	for (skin = who->inv; skin != NULL && strcmp (skin->arch->name, "dragon_skin_force") != 0; skin = skin->below);	3469	for (skin = who->inv; skin && !(skin->arch->name == dragon_skin_force); skin = skin->below)
		3470	;
		3471
3834	if (skin == NULL)	3472	if (!skin)
3835	return;	3473	return;
3836		3474
3837	/* adding new spellpath attunements */	3475	/* adding new spellpath attunements */
3838	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))	3476	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))
3839	{	3477	{
…		…
3884	* not readied.	3522	* not readied.
3885	*/	3523	*/
3886	void	3524	void
3887	player_unready_range_ob (player *pl, object *ob)	3525	player_unready_range_ob (player *pl, object *ob)
3888	{	3526	{
3889	rangetype i;
3890
3891	for (i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1))	3527	for (rangetype i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1))
3892	{
3893	if (pl->ranges[i] == ob)	3528	if (pl->ranges[i] == ob)
3894	{	3529	{
3895	pl->ranges[i] = NULL;	3530	pl->ranges[i] = 0;
3896	if (pl->shoottype == i)	3531	if (pl->shoottype == i)
3897	{
3898	pl->shoottype = range_none;	3532	pl->shoottype = range_none;
3899	}
3900	}	3533	}
3901	}
3902	}	3534	}
		3535
		3536	sint8
		3537	player::visibility_at (maptile *map, int x, int y) const
		3538	{
		3539	if (!ns)
		3540	return 0;
		3541
		3542	int dx, dy;
		3543	if (!adjacent_map (map, ns->current_map, &dx, &dy))
		3544	return 0;
		3545
		3546	x += dx - ns->current_x + ns->mapx / 2;
		3547	y += dy - ns->current_y + ns->mapy / 2;
		3548
		3549	if (!IN_RANGE_EXC (x, 0, ns->mapx) || !IN_RANGE_EXC (y, 0, ns->mapy))
		3550	return 0;
		3551
		3552	return 100 - blocked_los [x][y];
		3553	}

Diff Legend

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