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.101 by root, Mon Jan 29 16:11:48 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) != NULL)
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
		203	// for weird reasons, this is often "ob", keeping a circular reference
		204	ranges [range_skill] = 0;
		205
		206	players.erase (this);
		207	}
		208
		209	// connect the player with a specific client
		210	// also changed, rationalises, and fixes some incorrect settings
		211	void
		212	player::connect (client *ns)
		213	{
		214	this->ns = ns;
		215	ns->pl = this;
		216
		217	run_on = 0;
		218	fire_on = 0;
		219	ob->container = 0; //TODO: client-specific
		220
		221	ns->update_look = 0;
		222	ns->look_position = 0;
		223
		224	clear_los (ob);
		225
		226	ns->reset_stats ();
		227
		228	/* make sure he's a player -- needed because of class change. */
		229	ob->type = PLAYER; // we are paranoid
		230	ob->race = ob->arch->clone.race;
		231
		232	if (!legal_range (ob, shoottype))
		233	shoottype = range_none;
		234
		235	ob->carrying = sum_weight (ob);
		236	link_player_skills (ob);
		237
		238	CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
		239
		240	assign (title, ob->arch->clone.name);
		241
		242	/* can_use_shield is a new flag. However, the can_use.. seems to largely come
		243	* from the class, and not race. I don't see any way to get the class information
		244	* to then update this. I don't think this will actually break anything - anyone
		245	* that can use armour should be able to use a shield. What this may 'break'
		246	* are features new characters get, eg, if someone starts up with a Q, they
		247	* should be able to use a shield. However, old Q's won't get that advantage.
		248	*/
		249	if (QUERY_FLAG (ob, FLAG_USE_ARMOUR))
		250	SET_FLAG (ob, FLAG_USE_SHIELD);
		251
		252	/* if it's a dragon player, set the correct title here */
		253	if (is_dragon_pl (ob))
		254	{
		255	object *tmp, *abil = 0, *skin = 0;
		256
		257	shstr_cmp dragon_ability_force ("dragon_ability_force");
		258	shstr_cmp dragon_skin_force ("dragon_skin_force");
		259
		260	for (tmp = ob->inv; tmp; tmp = tmp->below)
		261	if (tmp->type == FORCE)
		262	if (tmp->arch->name == dragon_ability_force)
		263	abil = tmp;
		264	else if (tmp->arch->name == dragon_skin_force)
		265	skin = tmp;
		266
		267	set_dragon_name (ob, abil, skin);
		268	}
		269
		270	new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
		271
		272	esrv_new_player (this, ob->weight + ob->carrying);
		273
		274	ob->update_stats ();
		275	ns->floorbox_update ();
		276
		277	esrv_send_inventory (ob, ob);
		278	esrv_add_spells (this, 0);
		279
		280	activate ();
		281
		282	send_rules (ob);
		283	send_news (ob);
		284	display_motd (ob);
		285
		286	INVOKE_PLAYER (CONNECT, this);
		287	INVOKE_PLAYER (LOGIN, this);
		288	}
		289
		290	void
		291	player::disconnect ()
		292	{
		293	if (ns)
		294	{
		295	if (active)
		296	INVOKE_PLAYER (LOGOUT, this, ARG_INT (0));
		297
		298	INVOKE_PLAYER (DISCONNECT, this);
		299
		300	ns->reset_stats ();
		301	ns->pl = 0;
		302	this->ns = 0;
		303	}
		304
		305	ob->container = 0; //TODO: client-specific
		306	deactivate ();
		307	}
		308
		309	// the need for this function can be explained
		310	// by load_object not returning the object
		311	void
		312	player::set_object (object *op)
		313	{
		314	ob = op;
		315	ob->contr = this; /* this aren't yet in archetype */
		316
		317	ob->speed_left = 0.5;
		318	ob->speed = 1.0;
		319	ob->direction = 5; /* So player faces south */
		320	ob->stats.wc = 2;
		321	ob->run_away = 25; /* Then we panick... */
		322
		323	ob->roll_stats ();
		324	}
		325
		326	player::player ()
		327	{
		328	/* There are some elements we want initialised to non zero value -
		329	* we deal with that below this point.
		330	*/
		331	outputs_sync = 16; /* Every 2 seconds */
		332	outputs_count = 8; /* Keeps present behaviour */
		333	unapply = unapply_nochoice;
		334
		335	savebed_map = first_map_path; /* Init. respawn position */
		336
		337	gen_sp_armour = 10;
		338	shoottype = range_none;
		339	bowtype = bow_normal;
		340	petmode = pet_normal;
		341	listening = 10;
		342	usekeys = containers;
		343	peaceful = 1; /* default peaceful */
		344	do_los = 1;
		345	}
		346
		347	void
		348	player::do_destroy ()
		349	{
		350	disconnect ();
		351
		352	attachable::do_destroy ();
		353
		354	if (ob)
		355	{
		356	ob->destroy_inv (false);
		357	ob->destroy ();
		358	}
		359	}
		360
		361	player::~player ()
		362	{
		363	/* Clear item stack */
		364	free (stack_items);
		365	}
		366
300	/* Tries to add player on the connection passwd in ns.	367	/* 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	368	* All we can really get in this is some settings like host and display
302	* mode.	369	* mode.
303	*/	370	*/
304		371	player *
305	int	372	player::create ()
306	add_player (client_socket *ns)
307	{	373	{
308	player *p = new player;	374	player *pl = new player;
309		375
310	p->socket = ns;	376	pl->set_object (arch_to_object (get_player_archetype (0)));
311	ns->pl = p;
312
313	p->next = first_player;
314	first_player = p;
315
316	p = get_player (p);
317
318	set_first_map (p->ob);	377	set_first_map (pl->ob);
319		378
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;	379	return pl;
328	}	380	}
329		381
330	/*	382	/*
331	* get_player_archetype() return next player archetype from archetype	383	* get_player_archetype() return next player archetype from archetype
332	* list. Not very efficient routine, but used only creating new players.	384	* list. Not very efficient routine, but used only creating new players.
…		…
341	{	393	{
342	if (at == NULL || at->next == NULL)	394	if (at == NULL || at->next == NULL)
343	at = first_archetype;	395	at = first_archetype;
344	else	396	else
345	at = at->next;	397	at = at->next;
		398
346	if (at->clone.type == PLAYER)	399	if (at->clone.type == PLAYER)
347	return at;	400	return at;
		401
348	if (at == start)	402	if (at == start)
349	{	403	{
350	LOG (llevError, "No Player archetypes\n");	404	LOG (llevError, "No Player archetypes\n");
351	exit (-1);	405	exit (-1);
352	}	406	}
353	}	407	}
354	}	408	}
355		409
356
357	object *	410	object *
358	get_nearest_player (object *mon)	411	get_nearest_player (object *mon)
359	{	412	{
360	object *op = NULL;	413	object *op = NULL;
361	player *pl = NULL;
362	objectlink *ol;	414	objectlink *ol;
363	unsigned lastdist;	415	unsigned lastdist;
364	rv_vector rv;	416	rv_vector rv;
365		417
366	for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next)	418	for (ol = first_friendly_object, lastdist = 1000; ol; ol = ol->next)
367	{	419	{
368	/* We should not find free objects on this friendly list, but it	420	/* We should not find free objects on this friendly list, but it
369	* does periodically happen. Given that, lets deal with it.	421	* does periodically happen. Given that, lets deal with it.
370	* While unlikely, it is possible the next object on the friendly	422	* While unlikely, it is possible the next object on the friendly
371	* list is also free, so encapsulate this in a while loop.	423	* list is also free, so encapsulate this in a while loop.
…		…
375	object *tmp = ol->ob;	427	object *tmp = ol->ob;
376		428
377	/* Can't do much more other than log the fact, because the object	429	/* Can't do much more other than log the fact, because the object
378	* itself will have been cleared.	430	* itself will have been cleared.
379	*/	431	*/
380	LOG (llevDebug, "get_nearest_player: Found free/non friendly object on friendly list\n");	432	LOG (llevDebug, "get_nearest_player: Found free/non friendly object '%s' on friendly list\n",
		433	tmp->debug_desc ());
381	ol = ol->next;	434	ol = ol->next;
382	remove_friendly_object (tmp);	435	remove_friendly_object (tmp);
383	if (!ol)	436	if (!ol)
384	return op;	437	return op;
385	}	438	}
…		…
398	{	451	{
399	op = ol->ob;	452	op = ol->ob;
400	lastdist = rv.distance;	453	lastdist = rv.distance;
401	}	454	}
402	}	455	}
403	for (pl = first_player; pl != NULL; pl = pl->next)	456
404	{	457	for_all_players (pl)
405	if (can_detect_enemy (mon, pl->ob, &rv))	458	if (can_detect_enemy (mon, pl->ob, &rv))
406	{
407
408	if (lastdist > rv.distance)	459	if (lastdist > rv.distance)
409	{	460	{
410	op = pl->ob;	461	op = pl->ob;
411	lastdist = rv.distance;	462	lastdist = rv.distance;
412	}	463	}
413	}	464
414	}
415	#if 0	465	#if 0
416	LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");	466	LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");
417	#endif	467	#endif
418	return op;	468	return op;
419	}	469	}
…		…
437	* circling behaviour. Unfortunately, this function is also used to determined	487	* 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	488	* if the creature should cast a spell, so returning a direction in that case
439	* is probably not a good thing.	489	* is probably not a good thing.
440	*/	490	*/
441	#define MAX_SPACES 50	491	#define MAX_SPACES 50
442
443		492
444	/*	493	/*
445	* Returns the direction to the player, if valid. Returns 0 otherwise.	494	* 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	495	* 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	496	* player and if path is blocked then see if blockage is close enough to player that
…		…
478	x = mon->x;	527	x = mon->x;
479	y = mon->y;	528	y = mon->y;
480	m = mon->map;	529	m = mon->map;
481	dir = rv.direction;	530	dir = rv.direction;
482	lastdir = firstdir = rv.direction; /* perhaps we stand next to pl, init firstdir too */	531	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);	532	diff = ::max (abs (rv.distance_x), abs (rv.distance_y));
		533
484	/* If we can't solve it within the search distance, return now. */	534	/* If we can't solve it within the search distance, return now. */
485	if (diff > max)	535	if (diff > max)
486	return 0;	536	return 0;
		537
487	while (diff > 1 && max > 0)	538	while (diff > 1 && max > 0)
488	{	539	{
489	lastx = x;	540	lastx = x;
490	lasty = y;	541	lasty = y;
491	lastmap = m;	542	lastmap = m;
…		…
573	max--;	624	max--;
574	lastdir = dir;	625	lastdir = dir;
575	if (!firstdir)	626	if (!firstdir)
576	firstdir = dir;	627	firstdir = dir;
577	}	628	}
		629
578	if (diff <= 1)	630	if (diff <= 1)
579	{	631	{
580	/* Recalculate diff (distance) because we may not have actually	632	/* Recalculate diff (distance) because we may not have actually
581	* headed toward player for entire distance.	633	* headed toward player for entire distance.
582	*/	634	*/
583	get_rangevector_from_mapcoord (m, x, y, pl, &rv, 0);	635	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);	636	diff = ::max (abs (rv.distance_x), abs (rv.distance_y));
585	}	637	}
		638
586	if (diff > max)	639	if (diff > max)
587	return 0;	640	return 0;
588	}	641	}
		642
589	/* If we reached the max, didn't find a direction in time */	643	/* If we reached the max, didn't find a direction in time */
590	if (!max)	644	if (!max)
591	return 0;	645	return 0;
592		646
593	return firstdir;	647	return firstdir;
…		…
686	/* Need to set up the skill pointers */	740	/* Need to set up the skill pointers */
687	link_player_skills (pl);	741	link_player_skills (pl);
688	}	742	}
689		743
690	void	744	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)	745	get_party_password (object *op, partylist *party)
775	{	746	{
776	if (party == NULL)	747	if (party == NULL)
777	{	748	{
778	LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);	749	LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);
779	return;	750	return;
780	}	751	}
		752
781	op->contr->write_buf[0] = '\0';	753	op->contr->write_buf[0] = '\0';
782	op->contr->state = ST_GET_PARTY_PASSWORD;	754	op->contr->ns->state = ST_GET_PARTY_PASSWORD;
783	op->contr->party_to_join = party;	755	op->contr->party_to_join = party;
784	send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:");	756	send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:");
785	}	757	}
786
787		758
788	/* This rolls four 1-6 rolls and sums the best 3 of the 4. */	759	/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
789	int	760	static int
790	roll_stat (void)	761	roll_stat (void)
791	{	762	{
792	int a[4], i, j, k;	763	int a[4], i, j, k;
793		764
794	for (i = 0; i < 4; i++)	765	for (i = 0; i < 4; i++)
795	a[i] = (int) RANDOM () % 6 + 1;	766	a[i] = (int) rndm (6) + 1;
796		767
797	for (i = 0, j = 0, k = 7; i < 4; i++)	768	for (i = 0, j = 0, k = 7; i < 4; i++)
798	if (a[i] < k)	769	if (a[i] < k)
799	k = a[i], j = i;	770	k = a[i], j = i;
800		771
801	for (i = 0, k = 0; i < 4; i++)	772	for (i = 0, k = 0; i < 4; i++)
802	{
803	if (i != j)	773	if (i != j)
804	k += a[i];	774	k += a[i];
805	}	775
806	return k;	776	return k;
807	}	777	}
808		778
809	void	779	void
810	roll_stats (object *op)	780	object::roll_stats ()
811	{	781	{
812	int sum = 0;
813	int i = 0, j = 0;
814	int statsort[7];	782	int statsort [7];
815		783
816	do	784	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	}	785	{
827	while (sum < 82 || sum > 116);	786	int sum = 0;
		787	for (int i = 7; i--; )
		788	sum += statsort [i] = roll_stat ();
828		789
		790	if (sum >= 82 && sum <= 116)
		791	break;
		792	}
		793
829	/* Sort the stats so that rerolling is easier... */	794	// Sort the stats so that rerolling is easier...
830	statsort[0] = op->stats.Str;	795	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		796
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];	797	stats.Str = statsort[0];
856	op->stats.Dex = statsort[1];	798	stats.Dex = statsort[1];
857	op->stats.Con = statsort[2];	799	stats.Con = statsort[2];
858	op->stats.Int = statsort[3];	800	stats.Int = statsort[3];
859	op->stats.Wis = statsort[4];	801	stats.Wis = statsort[4];
860	op->stats.Pow = statsort[5];	802	stats.Pow = statsort[5];
861	op->stats.Cha = statsort[6];	803	stats.Cha = statsort[6];
862		804
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;	805	stats.exp = 0;
874	op->stats.ac = 0;	806	stats.ac = 0;
875		807
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;	808	stats.hp = stats.maxhp;
882	op->stats.sp = op->stats.maxsp;	809	stats.sp = stats.maxsp;
883	op->stats.grace = op->stats.maxgrace;	810	stats.grace = stats.maxgrace;
		811
		812	if (contr)
		813	{
		814	contr->levhp[1] = 9;
		815	contr->levsp[1] = 6;
		816	contr->levgrace[1] = 3;
		817
884	op->contr->orig_stats = op->stats;	818	contr->orig_stats = stats;
		819	}
885	}	820	}
886		821
887	void	822	void
888	Roll_Again (object *op)	823	object::swap_stats (int a, int b)
889	{	824	{
890	esrv_new_player (op->contr, 0);	825	int tmp = get_attr_value (&contr->orig_stats, a);
891	send_query (op->contr->socket, CS_QUERY_SINGLECHAR,	826	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)? ");	827	set_attr_value (&contr->orig_stats, b, tmp);
893	}
894		828
895	void	829	stats.Str = contr->orig_stats.Str;
896	Swap_Stat (object *op, int Swap_Second)	830	stats.Dex = contr->orig_stats.Dex;
		831	stats.Con = contr->orig_stats.Con;
		832	stats.Int = contr->orig_stats.Int;
		833	stats.Wis = contr->orig_stats.Wis;
		834	stats.Pow = contr->orig_stats.Pow;
		835	stats.Cha = contr->orig_stats.Cha;
		836
		837	//TODO: the following code looks so borked and should, at the very least,
		838	// be merged with the similar code in roll_stats
		839	stats.ac = 0;
		840
		841	level = 1;
		842	stats.exp = 0;
		843	stats.ac = 0;
		844
		845	stats.hp = stats.maxhp;
		846	stats.sp = stats.maxsp;
		847	stats.grace = stats.maxgrace;
		848
		849	if (contr)
		850	{
		851	contr->levhp[1] = 9;
		852	contr->levsp[1] = 6;
		853	contr->levgrace[1] = 3;
		854
		855	contr->orig_stats = stats;
		856	}
		857	}
		858
		859	static void
		860	start_info (object *op)
897	{	861	{
898	signed char tmp;
899	char buf[MAX_BUF];	862	char buf[MAX_BUF];
900		863
901	if (op->contr->Swap_First == -1)	864	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);	865	new_draw_info (NDI_UNIQUE, 0, op, buf);
917	op->stats.Str = op->contr->orig_stats.Str;	866	//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);	867	//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	}	868	}
1016		869
1017	/* This function takes the key that is passed, and does the	870	/* This function takes the key that is passed, and does the
1018	* appropriate action with it (change race, or other things).	871	* appropriate action with it (change race, or other things).
1019	* The function name is for historical reasons - now we have	872	* The function name is for historical reasons - now we have
1020	* separate race and class; this actually changes the RACE,	873	* separate race and class; this actually changes the RACE,
1021	* not the class.	874	* not the class.
1022	*/	875	*/
1023
1024	int	876	int
1025	key_change_class (object *op, char key)	877	key_change_class (object *op, char key)
1026	{	878	{
1027	int tmp_loop;	879	int tmp_loop;
1028		880
1029	if (key == 'q' || key == 'Q')
1030	{
1031	op->remove ();
1032	play_again (op);
1033	return 0;
1034	}
1035	if (key == 'd' || key == 'D')	881	if (key == 'd' || key == 'D')
1036	{	882	{
1037	char buf[MAX_BUF];	883	char buf[MAX_BUF];
1038		884
1039	/* this must before then initial items are given */	885	/* this must before then initial items are given */
…		…
1044	create_treasure (tl, op, 0, 0, 0);	890	create_treasure (tl, op, 0, 0, 0);
1045		891
1046	INVOKE_PLAYER (BIRTH, op->contr);	892	INVOKE_PLAYER (BIRTH, op->contr);
1047	INVOKE_PLAYER (LOGIN, op->contr);	893	INVOKE_PLAYER (LOGIN, op->contr);
1048		894
1049	op->contr->state = ST_PLAYING;	895	op->contr->ns->state = ST_PLAYING;
1050		896
1051	if (op->msg)	897	if (op->msg)
1052	op->msg = NULL;	898	op->msg = NULL;
1053		899
1054	/* We create this now because some of the unique maps will need it	900	/* We create this now because some of the unique maps will need it
1055	* to save here.	901	* to save here.
1056	*/	902	*/
1057	sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name);	903	sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name);
1058	make_path_to_file (buf);	904	make_path_to_file (buf);
1059		905
1060	#ifdef AUTOSAVE
1061	op->contr->last_save_tick = pticks;
1062	#endif
1063	start_info (op);	906	start_info (op);
1064	CLEAR_FLAG (op, FLAG_WIZ);	907	CLEAR_FLAG (op, FLAG_WIZ);
1065	give_initial_items (op, op->randomitems);	908	give_initial_items (op, op->randomitems);
1066	link_player_skills (op);	909	link_player_skills (op);
1067	esrv_send_inventory (op, op);	910	esrv_send_inventory (op, op);
1068	fix_player (op);	911	op->update_stats ();
1069		912
1070	/* This moves the player to a different start map, if there	913	/* This moves the player to a different start map, if there
1071	* is one for this race	914	* is one for this race
1072	*/	915	*/
1073	if (*first_map_ext_path)	916	if (*first_map_ext_path)
1074	{	917	{
1075	object *tmp;	918	object *tmp;
1076	char mapname[MAX_BUF];	919	char mapname[MAX_BUF];
1077		920
1078	snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name);	921	snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &op->arch->name);
1079	tmp = object::create ();	922	tmp = object::create ();
1080	EXIT_PATH (tmp) = mapname;	923	EXIT_PATH (tmp) = mapname;
1081	EXIT_X (tmp) = op->x;	924	EXIT_X (tmp) = op->x;
1082	EXIT_Y (tmp) = op->y;	925	EXIT_Y (tmp) = op->y;
1083	enter_exit (op, tmp); /* we don't really care if it succeeded;	926	op->enter_exit (tmp); /* we don't really care if it succeeded;
1084	* if the map isn't there, then stay on the	927	* if the map isn't there, then stay on the
1085	* default initial map */	928	* default initial map */
1086	tmp->destroy ();	929	tmp->destroy ();
1087	}	930	}
1088	else	931	else
1089	{
1090	LOG (llevDebug, "first_map_ext_path not set\n");	932	LOG (llevDebug, "first_map_ext_path not set\n");
1091	}	933
1092	return 0;	934	return 0;
1093	}	935	}
1094		936
1095	/* Following actually changes the race - this is the default command	937	/* Following actually changes the race - this is the default command
1096	* if we don't match with one of the options above.	938	* if we don't match with one of the options above.
…		…
1100	while (!tmp_loop)	942	while (!tmp_loop)
1101	{	943	{
1102	shstr name = op->name;	944	shstr name = op->name;
1103	int x = op->x, y = op->y;	945	int x = op->x, y = op->y;
1104		946
1105	remove_statbonus (op);	947	op->remove_statbonus ();
1106	op->remove ();	948	op->remove ();
1107	op->arch = get_player_archetype (op->arch);	949	op->arch = get_player_archetype (op->arch);
1108	op->arch->clone.copy_to (op);	950	op->arch->clone.copy_to (op);
1109	op->instantiate ();	951	op->instantiate ();
1110	op->stats = op->contr->orig_stats;	952	op->stats = op->contr->orig_stats;
…		…
1112	op->x = x;	954	op->x = x;
1113	op->y = y;	955	op->y = y;
1114	SET_ANIMATION (op, 2); /* So player faces south */	956	SET_ANIMATION (op, 2); /* So player faces south */
1115	insert_ob_in_map (op, op->map, op, 0);	957	insert_ob_in_map (op, op->map, op, 0);
1116	assign (op->contr->title, op->arch->clone.name);	958	assign (op->contr->title, op->arch->clone.name);
1117	add_statbonus (op);	959	op->add_statbonus ();
1118	tmp_loop = allowed_class (op);	960	tmp_loop = allowed_class (op);
1119	}	961	}
1120		962
1121	update_object (op, UP_OBJ_FACE);	963	update_object (op, UP_OBJ_FACE);
1122	esrv_update_item (UPD_FACE, op, op);	964	esrv_update_item (UPD_FACE, op, op);
1123	fix_player (op);	965	op->update_stats ();
1124	op->stats.hp = op->stats.maxhp;	966	op->stats.hp = op->stats.maxhp;
1125	op->stats.sp = op->stats.maxsp;	967	op->stats.sp = op->stats.maxsp;
1126	op->stats.grace = 0;	968	op->stats.grace = 0;
1127		969
1128	if (op->msg)	970	if (op->msg)
1129	new_draw_info (NDI_BLUE, 0, op, op->msg);	971	new_draw_info (NDI_BLUE, 0, op, op->msg);
1130		972
1131	send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");	973	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;	974	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	}	975	}
1183		976
1184	void	977	void
1185	flee_player (object *op)	978	flee_player (object *op)
1186	{	979	{
…		…
1216	{	1009	{
1217	op->enemy = NULL;	1010	op->enemy = NULL;
1218	CLEAR_FLAG (op, FLAG_SCARED);	1011	CLEAR_FLAG (op, FLAG_SCARED);
1219	return;	1012	return;
1220	}	1013	}
		1014
1221	get_rangevector (op, op->enemy, &rv, 0);	1015	get_rangevector (op, op->enemy, &rv, 0);
1222		1016
1223	dir = absdir (4 + rv.direction);	1017	dir = absdir (4 + rv.direction);
1224	for (diff = 0; diff < 3; diff++)	1018	for (diff = 0; diff < 3; diff++)
1225	{	1019	{
1226	int m = 1 - (RANDOM () & 2);	1020	int m = 1 - (RANDOM () & 2);
1227		1021
1228	if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))	1022	if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))
1229	{
1230	return;	1023	return;
1231	}
1232	}	1024	}
		1025
1233	/* Cornered, get rid of scared */	1026	/* Cornered, get rid of scared */
1234	CLEAR_FLAG (op, FLAG_SCARED);	1027	CLEAR_FLAG (op, FLAG_SCARED);
1235	op->enemy = NULL;	1028	op->enemy = NULL;
1236	}	1029	}
1237		1030
…		…
1323	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1116	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))));	1117	&tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1325	else	1118	else
1326	sprintf (putstring, "item name: %s item type: %d weight/value: %d",	1119	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))));	1120	&tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
		1121
1328	new_draw_info (NDI_UNIQUE, 0, op, putstring);	1122	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	}	1123	}
		1124
1359	/* philosophy:	1125	/* philosophy:
1360	* It's easy to grab an item type from a pile, as long as it's	1126	* 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	1127	* generic. This takes no game-time. For more detailed pickups
1362	* and selections, select-items shoul dbe used. This is a	1128	* and selections, select-items should be used. This is a
1363	* grab-as-you-run type mode that's really useful for arrows for	1129	* grab-as-you-run type mode that's really useful for arrows for
1364	* example.	1130	* example.
1365	* The drawback: right now it has no frontend, so you need to	1131	* 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	1132	* stick the bits you want into a calculator in hex mode and then
1367	* convert to decimal and then 'pickup <#>	1133	* convert to decimal and then 'pickup <#>
…		…
1793	if (!dir)	1559	if (!dir)
1794	{	1560	{
1795	new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");	1561	new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1796	return 0;	1562	return 0;
1797	}	1563	}
		1564
1798	if (op->type == PLAYER)	1565	if (op->type == PLAYER)
1799	bow = op->contr->ranges[range_bow];	1566	bow = op->contr->ranges[range_bow];
1800	else	1567	else
1801	{	1568	{
1802	for (bow = op->inv; bow; bow = bow->below)	1569	for (bow = op->inv; bow; bow = bow->below)
…		…
1810	{	1577	{
1811	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);	1578	LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1812	return 0;	1579	return 0;
1813	}	1580	}
1814	}	1581	}
		1582
1815	if (!bow->race || !bow->skill)	1583	if (!bow->race || !bow->skill)
1816	{	1584	{
1817	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);	1585	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);
1818	return 0;	1586	return 0;
1819	}	1587	}
…		…
1821	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];	1589	bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];
1822		1590
1823	/* penalize ROF for bestarrow */	1591	/* penalize ROF for bestarrow */
1824	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)	1592	if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)
1825	bowspeed -= dex_bonus[op->stats.Dex] + 5;	1593	bowspeed -= dex_bonus[op->stats.Dex] + 5;
		1594
1826	if (bowspeed < 1)	1595	if (bowspeed < 1)
1827	bowspeed = 1;	1596	bowspeed = 1;
1828		1597
1829	if (arrow == NULL)	1598	if (arrow == NULL)
1830	{	1599	{
…		…
1836	else	1605	else
1837	CLEAR_FLAG (op, FLAG_READY_BOW);	1606	CLEAR_FLAG (op, FLAG_READY_BOW);
1838	return 0;	1607	return 0;
1839	}	1608	}
1840	}	1609	}
		1610
1841	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);	1611	mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1842	if (mflags & P_OUT_OF_MAP)	1612	if (mflags & P_OUT_OF_MAP)
1843	{
1844	return 0;	1613	return 0;
1845	}	1614
1846	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)	1615	if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1847	{	1616	{
1848	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	1617	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1849	return 0;	1618	return 0;
1850	}	1619	}
…		…
1856	return 0;	1625	return 0;
1857	}	1626	}
1858		1627
1859	left = arrow; /* these are arrows left to the player */	1628	left = arrow; /* these are arrows left to the player */
1860	arrow = get_split_ob (arrow, 1);	1629	arrow = get_split_ob (arrow, 1);
1861	if (arrow == NULL)	1630	if (!arrow)
1862	{	1631	{
1863	new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);	1632	new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1864	return 0;	1633	return 0;
1865	}	1634	}
		1635
1866	arrow->set_owner (op);	1636	arrow->set_owner (op);
1867	arrow->skill = bow->skill;	1637	arrow->skill = bow->skill;
1868
1869	arrow->direction = dir;	1638	arrow->direction = dir;
1870	arrow->x = sx;
1871	arrow->y = sy;
1872		1639
1873	if (op->type == PLAYER)	1640	if (op->type == PLAYER)
1874	{	1641	{
1875	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;	1642	op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;
1876	fix_player (op);	1643	op->update_stats ();
1877	}	1644	}
1878		1645
1879	SET_ANIMATION (arrow, arrow->direction);	1646	SET_ANIMATION (arrow, arrow->direction);
1880	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */	1647	arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1881	arrow->stats.hp = arrow->stats.dam;	1648	arrow->stats.hp = arrow->stats.dam;
…		…
1891		1658
1892	/* update the speed */	1659	/* update the speed */
1893	arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?	1660	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;	1661	0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;
1895		1662
1896	if (arrow->speed < 1.0)	1663	arrow->set_speed (max (arrow->speed, 1.0));
1897	arrow->speed = 1.0;
1898	update_ob_speed (arrow);
1899	arrow->speed_left = 0;	1664	arrow->speed_left = 0;
1900		1665
1901	if (op->type == PLAYER)	1666	if (op->type == PLAYER)
1902	{	1667	{
1903	arrow->stats.wc = 20 - bow->magic - arrow->magic -	1668	arrow->stats.wc = 20 - bow->magic - arrow->magic -
…		…
1913	}	1678	}
1914		1679
1915	if (arrow->attacktype == AT_PHYSICAL)	1680	if (arrow->attacktype == AT_PHYSICAL)
1916	arrow->attacktype |= bow->attacktype;	1681	arrow->attacktype |= bow->attacktype;
1917		1682
1918	if (bow->slaying != NULL)	1683	if (bow->slaying)
1919	arrow->slaying = bow->slaying;	1684	arrow->slaying = bow->slaying;
1920		1685
1921	arrow->map = m;
1922	arrow->move_type = MOVE_FLY_LOW;	1686	arrow->move_type = MOVE_FLY_LOW;
1923	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;	1687	arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1924		1688
1925	play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);	1689	play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);
1926	insert_ob_in_map (arrow, m, op, 0);	1690	m->insert (arrow, sx, sy, op);
1927		1691
1928	if (!arrow->destroyed ())	1692	if (!arrow->destroyed ())
1929	move_arrow (arrow);	1693	move_arrow (arrow);
1930		1694
1931	if (op->type == PLAYER)	1695	if (op->type == PLAYER)
…		…
1957	}	1721	}
1958	else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)	1722	else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)
1959	{	1723	{
1960	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))	1724	if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))
1961	wcmod = -1;	1725	wcmod = -1;
		1726
1962	ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);	1727	ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
1963	}	1728	}
1964	else if (op->contr->bowtype == bow_threewide)	1729	else if (op->contr->bowtype == bow_threewide)
1965	{	1730	{
1966	ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);	1731	ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
…		…
2036		1801
2037	if (item->arch)	1802	if (item->arch)
2038	{	1803	{
2039	CLEAR_FLAG (item, FLAG_ANIMATE);	1804	CLEAR_FLAG (item, FLAG_ANIMATE);
2040	item->face = item->arch->clone.face;	1805	item->face = item->arch->clone.face;
2041	item->speed = 0;	1806	item->set_speed (0);
2042	update_ob_speed (item);
2043	}	1807	}
		1808
2044	if ((tmp = is_player_inv (item)))	1809	if ((tmp = item->in_player ()))
2045	esrv_update_item (UPD_ANIM, tmp, item);	1810	esrv_update_item (UPD_ANIM, tmp, item);
2046	}	1811	}
2047	}	1812	}
2048	else if (item->type == ROD || item->type == HORN)	1813	else if (item->type == ROD || item->type == HORN)
2049	{
2050	drain_rod_charge (item);	1814	drain_rod_charge (item);
2051	}
2052	}	1815	}
2053	}	1816	}
2054		1817
2055	/* Received a fire command for the player - go and do it.	1818	/* Received a fire command for the player - go and do it.
2056	*/	1819	*/
…		…
2095	{	1858	{
2096	if (op->type == PLAYER)	1859	if (op->type == PLAYER)
2097	new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use.");	1860	new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use.");
2098	return;	1861	return;
2099	}	1862	}
		1863
2100	(void) do_skill (op, op, op->chosen_skill, dir, NULL);	1864	do_skill (op, op, op->chosen_skill, dir, NULL);
2101	return;	1865	return;
2102	case range_builder:	1866	case range_builder:
2103	apply_map_builder (op, dir);	1867	apply_map_builder (op, dir);
2104	return;	1868	return;
2105	default:	1869	default:
…		…
2199	* 0 otherwise	1963	* 0 otherwise
2200	*/	1964	*/
2201	static int	1965	static int
2202	player_attack_door (object *op, object *door)	1966	player_attack_door (object *op, object *door)
2203	{	1967	{
2204
2205	/* If its a door, try to find a use a key. If we do destroy the door,	1968	/* If its a door, try to find a use a key. If we do destroy the door,
2206	* might as well return immediately as there is nothing more to do -	1969	* might as well return immediately as there is nothing more to do -
2207	* otherwise, we fall through to the rest of the code.	1970	* otherwise, we fall through to the rest of the code.
2208	*/	1971	*/
2209	object *key = find_key (op, op, door);	1972	object *key = find_key (op, op, door);
…		…
2247	* It should keep the code cleaner.	2010	* It should keep the code cleaner.
2248	* When this is called, the players direction has been updated	2011	* When this is called, the players direction has been updated
2249	* (taking into account confusion.) The player is also actually	2012	* (taking into account confusion.) The player is also actually
2250	* going to try and move (not fire weapons).	2013	* going to try and move (not fire weapons).
2251	*/	2014	*/
2252
2253	void	2015	void
2254	move_player_attack (object *op, int dir)	2016	move_player_attack (object *op, int dir)
2255	{	2017	{
2256	object *tmp, *mon;	2018	object *tmp, *mon;
2257	sint16 nx, ny;	2019	sint16 nx, ny;
…		…
2259	maptile *m;	2021	maptile *m;
2260		2022
2261	nx = freearr_x[dir] + op->x;	2023	nx = freearr_x[dir] + op->x;
2262	ny = freearr_y[dir] + op->y;	2024	ny = freearr_y[dir] + op->y;
2263		2025
2264	on_battleground = op_on_battleground (op, NULL, NULL);	2026	on_battleground = op_on_battleground (op, 0, 0);
2265		2027
2266	/* If braced, or can't move to the square, and it is not out of the	2028	/* If braced, or can't move to the square, and it is not out of the
2267	* map, attack it. Note order of if statement is important - don't	2029	* map, attack it. Note order of if statement is important - don't
2268	* want to be calling move_ob if braced, because move_ob will move the	2030	* want to be calling move_ob if braced, because move_ob will move the
2269	* player. This is a pretty nasty hack, because if we could	2031	* player. This is a pretty nasty hack, because if we could
…		…
2274	*/	2036	*/
2275	if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))	2037	if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))
2276	{	2038	{
2277	if (OUT_OF_REAL_MAP (op->map, nx, ny))	2039	if (OUT_OF_REAL_MAP (op->map, nx, ny))
2278	{	2040	{
2279	m = get_map_from_coord (op->map, &nx, &ny);	2041	m = op->map->xy_find (nx, ny);
2280	if (!m)	2042	if (!m)
2281	return; /* Don't think this should happen */	2043	return; /* Don't think this should happen */
2282	}	2044	}
2283	else	2045	else
2284	m = op->map;	2046	m = op->map;
2285		2047
2286	if ((tmp = get_map_ob (m, nx, ny)) == NULL)	2048	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;	2049	return;
2290	}
2291		2050
2292	mon = NULL;	2051	mon = 0;
2293	/* Go through all the objects, and find ones of interest. Only stop if	2052	/* Go through all the objects, and find ones of interest. Only stop if
2294	* we find a monster - that is something we know we want to attack.	2053	* we find a monster - that is something we know we want to attack.
2295	* if its a door or barrel (can roll) see if there may be monsters	2054	* if its a door or barrel (can roll) see if there may be monsters
2296	* on the space	2055	* on the space
2297	*/	2056	*/
2298	while (tmp != NULL)	2057	while (tmp)
2299	{	2058	{
2300	if (tmp == op)	2059	if (tmp == op)
2301	{	2060	{
2302	tmp = tmp->above;	2061	tmp = tmp->above;
2303	continue;	2062	continue;
…		…
2313	mon = tmp;	2072	mon = tmp;
2314		2073
2315	tmp = tmp->above;	2074	tmp = tmp->above;
2316	}	2075	}
2317		2076
2318	if (mon == NULL) /* This happens anytime the player tries to move */	2077	if (!mon) /* This happens anytime the player tries to move */
2319	return; /* into a wall */	2078	return; /* into a wall */
2320		2079
2321	if (mon->head != NULL)	2080	if (mon->head)
2322	mon = mon->head;	2081	mon = mon->head;
2323		2082
2324	if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))	2083	if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
2325	if (player_attack_door (op, mon))	2084	if (player_attack_door (op, mon))
2326	return;	2085	return;
…		…
2348	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))	2107	&& (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2349	{	2108	{
2350	/* If we're braced, we don't want to switch places with it */	2109	/* If we're braced, we don't want to switch places with it */
2351	if (op->contr->braced)	2110	if (op->contr->braced)
2352	return;	2111	return;
		2112
2353	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);	2113	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2354	(void) push_ob (mon, dir, op);	2114	(void) push_ob (mon, dir, op);
2355	if (op->contr->tmp_invis || op->hide)	2115	if (op->contr->tmp_invis || op->hide)
2356	make_visible (op);	2116	make_visible (op);
		2117
2357	return;	2118	return;
2358	}	2119	}
2359		2120
2360	/* in certain circumstances, you shouldn't attack friendly	2121	/* in certain circumstances, you shouldn't attack friendly
2361	* creatures. Note that if you are braced, you can't push	2122	* creatures. Note that if you are braced, you can't push
…		…
2363	* attack them either.	2124	* attack them either.
2364	*/	2125	*/
2365	if ((mon->type == PLAYER || mon->enemy != op) &&	2126	if ((mon->type == PLAYER || mon->enemy != op) &&
2366	(mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (	2127	(mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (
2367	#ifdef PROHIBIT_PLAYERKILL	2128	#ifdef PROHIBIT_PLAYERKILL
2368	(op->contr->peaceful	2129	(op->contr->peaceful
2369	|| (mon->type == PLAYER	2130	|| (mon->type == PLAYER
2370	&& mon->contr->	2131	&& mon->contr->
2371	peaceful)) &&	2132	peaceful)) &&
2372	#else	2133	#else
2373	op->contr->peaceful &&	2134	op->contr->peaceful &&
2374	#endif	2135	#endif
2375	!on_battleground))	2136	!on_battleground))
2376	{	2137	{
2377	if (!op->contr->braced)	2138	if (!op->contr->braced)
2378	{	2139	{
2379	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);	2140	play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2380	(void) push_ob (mon, dir, op);	2141	push_ob (mon, dir, op);
2381	}	2142	}
2382	else	2143	else
2383	{
2384	new_draw_info (0, 0, op, "You withhold your attack");	2144	new_draw_info (0, 0, op, "You withhold your attack");
2385	}	2145
2386	if (op->contr->tmp_invis || op->hide)	2146	if (op->contr->tmp_invis || op->hide)
2387	make_visible (op);	2147	make_visible (op);
2388	}	2148	}
2389		2149
2390	/* If the object is a boulder or other rollable object, then	2150	/* 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	2161	* 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:	2162	* 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	2163	* 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.	2164	* that party_number -1 is no party, so attacks can still happen.
2405	*/	2165	*/
2406
2407	else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&	2166	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)))	2167	((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))
2409	{	2168	{
2410		2169
2411	/* If the player hasn't hit something this tick, and does	2170	/* If the player hasn't hit something this tick, and does
…		…
2418	op->speed_left += op->speed / op->contr->weapon_sp;	2177	op->speed_left += op->speed / op->contr->weapon_sp;
2419		2178
2420	op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */	2179	op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */
2421	}	2180	}
2422		2181
2423	skill_attack (mon, op, 0, NULL, NULL);	2182	skill_attack (mon, op, 0, 0, 0);
2424		2183
2425	/* If attacking another player, that player gets automatic	2184	/* If attacking another player, that player gets automatic
2426	* hitback, and doesn't loose luck either.	2185	* hitback, and doesn't loose luck either.
2427	* Disable hitback on the battleground or if the target is	2186	* Disable hitback on the battleground or if the target is
2428	* the wiz.	2187	* the wiz.
…		…
2430	if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))	2189	if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2431	{	2190	{
2432	short luck = mon->stats.luck;	2191	short luck = mon->stats.luck;
2433		2192
2434	mon->contr->has_hit = 1;	2193	mon->contr->has_hit = 1;
2435	skill_attack (op, mon, 0, NULL, NULL);	2194	skill_attack (op, mon, 0, 0, 0);
2436	mon->stats.luck = luck;	2195	mon->stats.luck = luck;
2437	}	2196	}
		2197
2438	if (action_makes_visible (op))	2198	if (action_makes_visible (op))
2439	make_visible (op);	2199	make_visible (op);
2440	}	2200	}
2441	} /* if player should attack something */	2201	} /* if player should attack something */
2442	}	2202	}
…		…
2444	int	2204	int
2445	move_player (object *op, int dir)	2205	move_player (object *op, int dir)
2446	{	2206	{
2447	int pick;	2207	int pick;
2448		2208
2449	if (op->map == NULL || op->map->in_memory != MAP_IN_MEMORY)	2209	if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
2450	return 0;	2210	return 0;
2451		2211
2452	/* Sanity check: make sure dir is valid */	2212	/* Sanity check: make sure dir is valid */
2453	if ((dir < 0) || (dir >= 9))	2213	if ((dir < 0) || (dir >= 9))
2454	{	2214	{
2455	LOG (llevError, "move_player: invalid direction %d\n", dir);	2215	LOG (llevError, "move_player: invalid direction %d\n", dir);
2456	return 0;	2216	return 0;
2457	}	2217	}
2458		2218
2459	/* peterm: added following line */	2219	/* peterm: added following line */
2460	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)	2220	if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)
2461	dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);	2221	dir = absdir (dir + rndm (3) + rndm (3) - 2);
2462		2222
2463	op->facing = dir;	2223	op->facing = dir;
2464		2224
2465	if (op->hide)	2225	if (op->hide)
2466	do_hidden_move (op);	2226	do_hidden_move (op);
…		…
2477		2237
2478	/* Add special check for newcs players and fire on - this way, the	2238	/* Add special check for newcs players and fire on - this way, the
2479	* server can handle repeat firing.	2239	* server can handle repeat firing.
2480	*/	2240	*/
2481	if (op->contr->fire_on || (op->contr->run_on && pick != 0))	2241	if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2482	{
2483	op->direction = dir;	2242	op->direction = dir;
2484	}
2485	else	2243	else
2486	{
2487	op->direction = 0;	2244	op->direction = 0;
2488	}	2245
2489	/* Update how the player looks. Use the facing, so direction may	2246	/* Update how the player looks. Use the facing, so direction may
2490	* get reset to zero. This allows for full animation capabilities	2247	* get reset to zero. This allows for full animation capabilities
2491	* for players.	2248	* for players.
2492	*/	2249	*/
2493	animate_object (op, op->facing);	2250	animate_object (op, op->facing);
…		…
2545		2302
2546	/* call this here - we also will call this in do_ericserver, but	2303	/* call this here - we also will call this in do_ericserver, but
2547	* the players time has been increased when doericserver has been	2304	* the players time has been increased when doericserver has been
2548	* called, so we recheck it here.	2305	* called, so we recheck it here.
2549	*/	2306	*/
2550	HandleClient (op->contr->socket, op->contr);	2307	if (op->contr->ns->handle_command ())
		2308	return 1;
		2309
2551	if (op->speed_left < 0)	2310	if (op->speed_left > 0)
2552	return 0;	2311	{
2553
2554	if (op->direction && (op->contr->run_on || op->contr->fire_on))	2312	if (op->direction && (op->contr->run_on || op->contr->fire_on))
2555	{	2313	{
2556	/* All move commands take 1 tick, at least for now */	2314	/* All move commands take 1 tick, at least for now */
2557	op->speed_left--;	2315	op->speed_left--;
2558		2316
2559	/* Instead of all the stuff below, let move_player take care	2317	/* Instead of all the stuff below, let move_player take care
2560	* of it. Also, some of the skill stuff is only put in	2318	* of it. Also, some of the skill stuff is only put in
2561	* there, as well as the confusion stuff.	2319	* there, as well as the confusion stuff.
2562	*/	2320	*/
2563	move_player (op, op->direction);	2321	move_player (op, op->direction);
2564	if (op->speed_left > 0)	2322
2565	return 1;	2323	return op->speed_left > 0;
2566	else	2324	}
2567	return 0;
2568	}	2325	}
2569		2326
2570	return 0;	2327	return 0;
2571	}	2328	}
2572		2329
…		…
2592	op->stats.hp = op->stats.maxhp;	2349	op->stats.hp = op->stats.maxhp;
2593		2350
2594	if (op->stats.food < 0)	2351	if (op->stats.food < 0)
2595	op->stats.food = 999;	2352	op->stats.food = 999;
2596		2353
2597	fix_player (op);	2354	op->update_stats ();
2598	return 1;	2355	return 1;
2599	}	2356	}
2600		2357
2601	LOG (llevError, "Error: LIFESAVE set without applied object.\n");	2358	LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2602	CLEAR_FLAG (op, FLAG_LIFESAVE);	2359	CLEAR_FLAG (op, FLAG_LIFESAVE);
…		…
2614	{	2371	{
2615	object *next;	2372	object *next;
2616		2373
2617	while (op)	2374	while (op)
2618	{	2375	{
2619	next = op->below; /* Make sure we have a good value, in case	2376	object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2620	* we remove object 'op'	2377
2621	*/
2622	if (QUERY_FLAG (op, FLAG_UNPAID))	2378	if (QUERY_FLAG (op, FLAG_UNPAID))
2623	{	2379	{
2624	op->remove ();
2625	op->x = env->x;
2626	op->y = env->y;
2627	if (env->type == PLAYER)	2380	if (env->type == PLAYER)
2628	esrv_del_item (env->contr, op->count);	2381	esrv_del_item (env->contr, op->count);
2629	insert_ob_in_map (op, env->map, NULL, 0);	2382
		2383	op->insert_at (env);
2630	}	2384	}
2631	else if (op->inv)	2385	else if (op->inv)
2632	remove_unpaid_objects (op->inv, env);	2386	remove_unpaid_objects (op->inv, env);
2633		2387
2634	op = next;	2388	op = next;
2635	}	2389	}
2636	}	2390	}
2637
2638		2391
2639	/*	2392	/*
2640	* Returns pointer a static string containing gravestone text	2393	* Returns pointer a static string containing gravestone text
2641	* Moved from apply.c to player.c - player.c is what	2394	* Moved from apply.c to player.c - player.c is what
2642	* actually uses this function. player.c may not be quite the	2395	* actually uses this function. player.c may not be quite the
…		…
2676	strncat (buf2, " ", 20 - strlen (buf) / 2);	2429	strncat (buf2, " ", 20 - strlen (buf) / 2);
2677	strcat (buf2, buf);	2430	strcat (buf2, buf);
2678		2431
2679	return buf2;	2432	return buf2;
2680	}	2433	}
2681
2682
2683		2434
2684	void	2435	void
2685	do_some_living (object *op)	2436	do_some_living (object *op)
2686	{	2437	{
2687	int last_food = op->stats.food;	2438	int last_food = op->stats.food;
…		…
2696	const int max_grace = 1;	2447	const int max_grace = 1;
2697		2448
2698	if (op->contr->outputs_sync)	2449	if (op->contr->outputs_sync)
2699	{	2450	{
2700	for (i = 0; i < NUM_OUTPUT_BUFS; i++)	2451	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)	2452	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]);	2453	flush_output_element (op, &op->contr->outputs[i]);
2703	}	2454	}
2704		2455
2705	if (op->contr->state == ST_PLAYING)	2456	if (op->contr->ns->state == ST_PLAYING)
2706	{	2457	{
2707
2708	/* these next three if clauses make it possible to SLOW DOWN	2458	/* these next three if clauses make it possible to SLOW DOWN
2709	hp/grace/spellpoint regeneration. */	2459	hp/grace/spellpoint regeneration. */
2710	if (op->contr->gen_hp >= 0)	2460	if (op->contr->gen_hp >= 0)
2711	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;	2461	gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2712	else	2462	else
2713	{	2463	{
2714	gen_hp = op->stats.maxhp;	2464	gen_hp = op->stats.maxhp;
2715	rate_hp -= rate_hp / 2 * op->contr->gen_hp;	2465	rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2716	}	2466	}
		2467
2717	if (op->contr->gen_sp >= 0)	2468	if (op->contr->gen_sp >= 0)
2718	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;	2469	gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2719	else	2470	else
2720	{	2471	{
2721	gen_sp = op->stats.maxsp;	2472	gen_sp = op->stats.maxsp;
2722	rate_sp -= rate_sp / 2 * op->contr->gen_sp;	2473	rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2723	}	2474	}
		2475
2724	if (op->contr->gen_grace >= 0)	2476	if (op->contr->gen_grace >= 0)
2725	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;	2477	gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2726	else	2478	else
2727	{	2479	{
2728	gen_grace = op->stats.maxgrace;	2480	gen_grace = op->stats.maxgrace;
…		…
2744	op->stats.food += op->contr->digestion;	2496	op->stats.food += op->contr->digestion;
2745	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))	2497	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2746	op->stats.food = last_food;	2498	op->stats.food = last_food;
2747	}	2499	}
2748	}	2500	}
		2501
2749	if (max_sp > 1)	2502	if (max_sp > 1)
2750	{	2503	{
2751	over_sp = (gen_sp + 10) / rate_sp;	2504	over_sp = (gen_sp + 10) / rate_sp;
2752	if (over_sp > 0)	2505	if (over_sp > 0)
2753	{	2506	{
2754	if (op->stats.sp < op->stats.maxsp)	2507	if (op->stats.sp < op->stats.maxsp)
2755	{	2508	{
2756	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;	2509	op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
		2510
2757	if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))	2511	if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))
2758	op->stats.sp--;	2512	op->stats.sp--;
		2513
2759	if (op->stats.sp > op->stats.maxsp)	2514	if (op->stats.sp > op->stats.maxsp)
2760	op->stats.sp = op->stats.maxsp;	2515	op->stats.sp = op->stats.maxsp;
2761	}	2516	}
2762	op->last_sp = 0;	2517	op->last_sp = 0;
2763	}	2518	}
2764	else	2519	else
2765	{
2766	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);	2520	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2767	}
2768	}	2521	}
2769	else	2522	else
2770	{
2771	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);	2523	op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2772	}
2773	}	2524	}
2774		2525
2775	/* Regenerate Grace */	2526	/* Regenerate Grace */
2776	/* I altered this a little - maximum grace is ony achieved through prayer -b.t. */	2527	/* I altered this a little - maximum grace is ony achieved through prayer -b.t. */
2777	if (--op->last_grace < 0)	2528	if (--op->last_grace < 0)
2778	{	2529	{
2779	if (op->stats.grace < op->stats.maxgrace / 2)	2530	if (op->stats.grace < op->stats.maxgrace / 2)
2780	op->stats.grace++; /* no penalty in food for regaining grace */	2531	op->stats.grace++; /* no penalty in food for regaining grace */
		2532
2781	if (max_grace > 1)	2533	if (max_grace > 1)
2782	{	2534	{
2783	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;	2535	over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2784	if (over_grace > 0)	2536	if (over_grace > 0)
2785	{	2537	{
…		…
2813	op->stats.food += op->contr->digestion;	2565	op->stats.food += op->contr->digestion;
2814	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))	2566	else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2815	op->stats.food = last_food;	2567	op->stats.food = last_food;
2816	}	2568	}
2817	}	2569	}
		2570
2818	if (max_hp > 1)	2571	if (max_hp > 1)
2819	{	2572	{
2820	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;	2573	over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2821	if (over_hp > 0)	2574	if (over_hp > 0)
2822	{	2575	{
…		…
2846		2599
2847	if (op->contr->gen_hp > 0)	2600	if (op->contr->gen_hp > 0)
2848	op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);	2601	op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);
2849	else	2602	else
2850	op->last_eat = 25 * (1 + bonus) / (penalty + 1);	2603	op->last_eat = 25 * (1 + bonus) / (penalty + 1);
		2604
2851	/* dms do not consume food */	2605	/* dms do not consume food */
2852	if (!QUERY_FLAG (op, FLAG_WIZ))	2606	if (!QUERY_FLAG (op, FLAG_WIZ))
2853	op->stats.food--;	2607	op->stats.food--;
2854	}	2608	}
2855	}
2856		2609
2857	if (op->contr->state == ST_PLAYING && op->stats.food < 0 && op->stats.hp >= 0)	2610	if (op->stats.food < 0 && op->stats.hp >= 0)
2858	{	2611	{
2859	object *tmp, *flesh = NULL;	2612	object *tmp, *flesh = 0;
2860		2613
2861	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	2614	for (tmp = op->inv; tmp; tmp = tmp->below)
2862	{	2615	{
2863	if (!QUERY_FLAG (tmp, FLAG_UNPAID))	2616	if (!QUERY_FLAG (tmp, FLAG_UNPAID))
2864	{
2865	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2866	{	2617	{
		2618	if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
		2619	{
2867	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");	2620	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2868	manual_apply (op, tmp, 0);	2621	manual_apply (op, tmp, 0);
2869	if (op->stats.food >= 0 || op->stats.hp < 0)	2622	if (op->stats.food >= 0 || op->stats.hp < 0)
2870	break;	2623	break;
2871	}	2624	}
2872	else if (tmp->type == FLESH)	2625	else if (tmp->type == FLESH)
2873	flesh = tmp;	2626	flesh = tmp;
2874	} /* End if paid for object */	2627	} /* End if paid for object */
2875	} /* end of for loop */	2628	} /* end of for loop */
		2629
2876	/* If player is still starving, it means they don't have any food, so	2630	/* If player is still starving, it means they don't have any food, so
2877	* eat flesh instead.	2631	* eat flesh instead.
2878	*/	2632	*/
2879	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)	2633	if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2880	{	2634	{
2881	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");	2635	new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2882	manual_apply (op, flesh, 0);	2636	manual_apply (op, flesh, 0);
2883	}	2637	}
2884	} /* end if player is starving */	2638	}
2885		2639
2886	while (op->stats.food < 0 && op->stats.hp > 0)	2640	while (op->stats.food < 0 && op->stats.hp >= 0)
2887	op->stats.food++, op->stats.hp--;	2641	op->stats.food++, op->stats.hp--;
2888		2642
2889	if (!op->contr->state && !QUERY_FLAG (op, FLAG_WIZ) && (op->stats.hp < 0 || op->stats.food < 0))	2643	if (op->stats.hp < 0 && !QUERY_FLAG (op, FLAG_WIZ))
2890	kill_player (op);	2644	kill_player (op);
		2645	}
2891	}	2646	}
2892
2893
2894		2647
2895	/* If the player should die (lack of hp, food, etc), we call this.	2648	/* If the player should die (lack of hp, food, etc), we call this.
2896	* op is the player in jeopardy. If the player can not be saved (not	2649	* op is the player in jeopardy. If the player can not be saved (not
2897	* permadeath, no lifesave), this will take care of removing the player	2650	* permadeath, no lifesave), this will take care of removing the player
2898	* file.	2651	* file.
…		…
2928	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");	2681	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");
2929	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");	2682	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");
2930		2683
2931	/* restore player */	2684	/* restore player */
2932	at = archetype::find ("poisoning");	2685	at = archetype::find ("poisoning");
2933	tmp = present_arch_in_ob (at, op);	2686	if (object *tmp = present_arch_in_ob (at, op))
2934	if (tmp)
2935	{	2687	{
2936	tmp->destroy ();	2688	tmp->destroy ();
2937	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2689	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2938	}	2690	}
2939		2691
2940	at = archetype::find ("confusion");	2692	at = archetype::find ("confusion");
2941	tmp = present_arch_in_ob (at, op);	2693	if (object *tmp = present_arch_in_ob (at, op))
2942	if (tmp)
2943	{	2694	{
2944	tmp->destroy ();	2695	tmp->destroy ();
2945	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2696	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2946	}	2697	}
2947		2698
…		…
2949	op->stats.hp = op->stats.maxhp;	2700	op->stats.hp = op->stats.maxhp;
2950	if (op->stats.food <= 0)	2701	if (op->stats.food <= 0)
2951	op->stats.food = 999;	2702	op->stats.food = 999;
2952		2703
2953	/* create a bodypart-trophy to make the winner happy */	2704	/* create a bodypart-trophy to make the winner happy */
2954	tmp = arch_to_object (archetype::find ("finger"));	2705	if (object *tmp = arch_to_object (archetype::find ("finger")))
2955	if (tmp != NULL)
2956	{	2706	{
2957	sprintf (buf, "%s's finger", &op->name);	2707	sprintf (buf, "%s's finger", &op->name);
2958	tmp->name = buf;	2708	tmp->name = buf;
2959	sprintf (buf, " This finger has been cut off %s\n"	2709	sprintf (buf, " This finger has been cut off %s\n"
2960	" the %s, when he was defeated at\n level %d by %s.\n",	2710	" the %s, when he was defeated at\n level %d by %s.\n",
2961	&op->name, op->contr->title, (int) (op->level), op->contr->killer);	2711	&op->name, op->contr->title, (int) (op->level), op->contr->killer);
2962	tmp->msg = buf;	2712	tmp->msg = buf;
2963	tmp->value = 0, tmp->material = 0, tmp->type = 0;	2713	tmp->value = 0, tmp->material = 0, tmp->type = 0;
2964	tmp->materialname = NULL;	2714	tmp->materialname = NULL;
2965	tmp->x = op->x, tmp->y = op->y;	2715	tmp->insert_at (op, tmp);
2966	insert_ob_in_map (tmp, op->map, op, 0);
2967	}	2716	}
2968		2717
2969	/* teleport defeated player to new destination */	2718	/* teleport defeated player to new destination */
2970	transfer_ob (op, x, y, 0, NULL);	2719	transfer_ob (op, x, y, 0, NULL);
2971	op->contr->braced = 0;	2720	op->contr->braced = 0;
…		…
2976		2725
2977	command_kill_pets (op, 0);	2726	command_kill_pets (op, 0);
2978		2727
2979	if (op->stats.food < 0)	2728	if (op->stats.food < 0)
2980	{	2729	{
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);	2730	sprintf (buf, "%s starved to death.", &op->name);
2989	strcpy (op->contr->killer, "starvation");	2731	strcpy (op->contr->killer, "starvation");
2990	}	2732	}
2991	else	2733	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);	2734	sprintf (buf, "%s died.", &op->name);
3001	}	2735
3002	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);	2736	play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);
3003		2737
3004	/* save the map location for corpse, gravestone */	2738	/* save the map location for corpse, gravestone */
3005	x = op->x;	2739	x = op->x;
3006	y = op->y;	2740	y = op->y;
3007	map = op->map;	2741	map = op->map;
3008		2742
3009
3010	if (settings.not_permadeth == TRUE)
3011	{
3012	/* NOT_PERMADEATH code. This basically brings the character back to	2743	/* NOT_PERMADEATH code. This basically brings the character back to
3013	* life if they are dead - it takes some exp and a random stat.	2744	* life if they are dead - it takes some exp and a random stat.
3014	* See the config.h file for a little more in depth detail about this.	2745	* See the config.h file for a little more in depth detail about this.
3015	*/	2746	*/
3016		2747
3017	/* Basically two ways to go - remove a stat permanently, or just	2748	/* Basically two ways to go - remove a stat permanently, or just
3018	* make it depletion. This bunch of code deals with that aspect	2749	* make it depletion. This bunch of code deals with that aspect
3019	* of death.	2750	* of death.
3020	*/	2751	*/
3021	#ifndef COZY_SERVER	2752	#ifndef COZY_SERVER
3022	if (settings.balanced_stat_loss)	2753	if (settings.balanced_stat_loss)
3023	{	2754	{
3024	/* If stat loss is permanent, lose one stat only. */	2755	/* If stat loss is permanent, lose one stat only. */
3025	/* Lower level chars don't lose as many stats because they suffer	2756	/* Lower level chars don't lose as many stats because they suffer
3026	more if they do. */	2757	more if they do. */
3027	/* Higher level characters can afford things such as potions of	2758	/* Higher level characters can afford things such as potions of
3028	restoration, or better, stat potions. So we slug them that	2759	restoration, or better, stat potions. So we slug them that
3029	little bit harder. */	2760	little bit harder. */
3030	/* GD */	2761	/* GD */
3031	if (settings.stat_loss_on_death)	2762	if (settings.stat_loss_on_death)
3032	num_stats_lose = 1;	2763	num_stats_lose = 1;
3033	else
3034	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
3035	}
3036	else	2764	else
3037	{	2765	num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
		2766	}
		2767	else
3038	num_stats_lose = 1;	2768	num_stats_lose = 1;
3039	}	2769
3040	lost_a_stat = 0;	2770	lost_a_stat = 0;
3041		2771
3042	for (z = 0; z < num_stats_lose; z++)	2772	for (z = 0; z < num_stats_lose; z++)
3043	{	2773	{
3044	i = RANDOM () % NUM_STATS;	2774	i = RANDOM () % NUM_STATS;
3045		2775
3046	if (settings.stat_loss_on_death)	2776	if (settings.stat_loss_on_death)
3047	{	2777	{
3048	/* Pick a random stat and take a point off it. Tell the player	2778	/* Pick a random stat and take a point off it. Tell the player
3049	* what he lost.	2779	* what he lost.
3050	*/	2780	*/
3051	change_attr_value (&(op->stats), i, -1);	2781	change_attr_value (&(op->stats), i, -1);
3052	check_stat_bounds (&(op->stats));	2782	check_stat_bounds (&(op->stats));
3053	change_attr_value (&(op->contr->orig_stats), i, -1);	2783	change_attr_value (&(op->contr->orig_stats), i, -1);
3054	check_stat_bounds (&(op->contr->orig_stats));	2784	check_stat_bounds (&(op->contr->orig_stats));
3055	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);	2785	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3056	lost_a_stat = 1;	2786	lost_a_stat = 1;
		2787	}
		2788	else
		2789	{
		2790	/* deplete a stat */
		2791	archetype *deparch = archetype::find ("depletion");
		2792	object *dep;
		2793
		2794	dep = present_arch_in_ob (deparch, op);
		2795	if (!dep)
		2796	{
		2797	dep = arch_to_object (deparch);
		2798	insert_ob_in_ob (dep, op);
3057	}	2799	}
3058	else	2800	lose_this_stat = 1;
		2801	if (settings.balanced_stat_loss)
3059	{	2802	{
3060	/* deplete a stat */	2803	/* GD */
3061	archetype *deparch = archetype::find ("depletion");	2804	/* Get the stat that we're about to deplete. */
3062	object *dep;	2805	this_stat = get_attr_value (&(dep->stats), i);
3063		2806	if (this_stat < 0)
3064	dep = present_arch_in_ob (deparch, op);
3065	if (!dep)
3066	{	2807	{
3067	dep = arch_to_object (deparch);	2808	int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3068	insert_ob_in_ob (dep, op);	2809	int keep_chance = this_stat * this_stat;
3069	}	2810
3070	lose_this_stat = 1;	2811	/* 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)	2812	if (keep_chance < 1)
		2813	keep_chance = 1;
		2814
		2815	/* There is a maximum depletion total per level. */
		2816	if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3077	{	2817	{
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;	2818	lose_this_stat = 0;
3089	/* Take loss chance vs keep chance to see if we	2819	/* Take loss chance vs keep chance to see if we
3090	retain the stat. */	2820	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	}	2821	}
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	*/	2822	else
3112	if (this_stat >= -50)
3113	{	2823	{
3114	change_attr_value (&(dep->stats), i, -1);	2824	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;	2825	lose_this_stat = 0;
		2826	/* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
		2827	this_stat, keep_chance, loss_chance,
		2828	lose_this_stat?"LOSE":"KEEP"); */
3119	}	2829	}
3120	}	2830	}
3121	}	2831	}
		2832
		2833	if (lose_this_stat)
		2834	{
		2835	this_stat = get_attr_value (&(dep->stats), i);
		2836	/* We could try to do something clever like find another
		2837	* stat to reduce if this fails. But chances are, if
		2838	* stats have been depleted to -50, all are pretty low
		2839	* and should be roughly the same, so it shouldn't make a
		2840	* difference.
		2841	*/
		2842	if (this_stat >= -50)
		2843	{
		2844	change_attr_value (&(dep->stats), i, -1);
		2845	SET_FLAG (dep, FLAG_APPLIED);
		2846	new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
		2847	op->update_stats ();
		2848	lost_a_stat = 1;
		2849	}
3122	}	2850	}
		2851	}
		2852	}
3123	/* If no stat lost, tell the player. */	2853	/* If no stat lost, tell the player. */
3124	if (!lost_a_stat)	2854	if (!lost_a_stat)
3125	{	2855	{
3126	/* determine_god() seems to not work sometimes... why is this?	2856	/* determine_god() seems to not work sometimes... why is this?
3127	Should I be using something else? GD */	2857	Should I be using something else? GD */
3128	const char *god = determine_god (op);	2858	const char *god = determine_god (op);
3129		2859
3130	if (god && (strcmp (god, "none")))	2860	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);	2861	new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3132	else	2862	else
3133	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");	2863	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3134	}	2864	}
3135	#else	2865	#else
3136	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");	2866	new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3137	#endif	2867	#endif
3138		2868
3139	/* Put a gravestone up where the character 'almost' died. List the	2869	/* Put a gravestone up where the character 'almost' died. List the
3140	* exp loss on the stone.	2870	* exp loss on the stone.
3141	*/	2871	*/
3142	tmp = arch_to_object (archetype::find ("gravestone"));	2872	tmp = arch_to_object (archetype::find ("gravestone"));
3143	sprintf (buf, "%s's gravestone", &op->name);	2873	sprintf (buf, "%s's gravestone", &op->name);
3144	tmp->name = buf;	2874	tmp->name = buf;
3145	sprintf (buf, "%s's gravestones", &op->name);	2875	sprintf (buf, "%s's gravestones", &op->name);
3146	tmp->name_pl = buf;	2876	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);	2877	sprintf (buf, "RIP\nHere rests the hero %s the %s,\n" "who was killed\n" "by %s.\n", &op->name, op->contr->title, op->contr->killer);
3148	tmp->msg = buf;	2878	tmp->msg = buf;
3149	tmp->x = op->x, tmp->y = op->y;	2879	tmp->x = op->x, tmp->y = op->y;
3150	insert_ob_in_map (tmp, op->map, NULL, 0);	2880	insert_ob_in_map (tmp, op->map, NULL, 0);
3151		2881
3152	/**************************************/	2882	/**************************************/
3153	/* */	2883	/* */
3154	/* Subtract the experience points, */	2884	/* Subtract the experience points, */
3155	/* if we died cause of food, give us */	2885	/* if we died cause of food, give us */
3156	/* food, and reset HP's... */	2886	/* food, and reset HP's... */
3157	/* */	2887	/* */
3158	/**************************************/	2888	/**************************************/
3159		2889
3160	/* remove any poisoning and confusion the character may be suffering. */	2890	/* remove any poisoning and confusion the character may be suffering. */
3161	/* restore player */	2891	/* restore player */
3162	at = archetype::find ("poisoning");	2892	at = archetype::find ("poisoning");
3163	tmp = present_arch_in_ob (at, op);	2893	tmp = present_arch_in_ob (at, op);
3164		2894
3165	if (tmp)	2895	if (tmp)
3166	{	2896	{
3167	tmp->destroy ();	2897	tmp->destroy ();
3168	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");	2898	new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3169	}	2899	}
3170		2900
3171	at = archetype::find ("confusion");	2901	at = archetype::find ("confusion");
3172	tmp = present_arch_in_ob (at, op);	2902	tmp = present_arch_in_ob (at, op);
3173	if (tmp)	2903	if (tmp)
3174	{	2904	{
3175	tmp->destroy ();	2905	tmp->destroy ();
3176	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	2906	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3177	}	2907	}
3178		2908
3179	cure_disease (op, 0); /* remove any disease */	2909	cure_disease (op, 0); /* remove any disease */
3180		2910
3181	/*add_exp(op, (op->stats.exp * -0.20)); */	2911	/*add_exp(op, (op->stats.exp * -0.20)); */
3182	apply_death_exp_penalty (op);	2912	apply_death_exp_penalty (op);
3183	if (op->stats.food < 100)	2913	if (op->stats.food < 100)
3184	op->stats.food = 900;	2914	op->stats.food = 900;
3185	op->stats.hp = op->stats.maxhp;	2915	op->stats.hp = op->stats.maxhp;
3186	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);	2916	op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);
3187	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);	2917	op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);
3188		2918
3189	/*	2919	/*
3190	* Check to see if the player is in a shop. IF so, then check to see if	2920	* Check to see if the player is in a shop. IF so, then check to see if
3191	* the player has any unpaid items. If so, remove them and put them back	2921	* the player has any unpaid items. If so, remove them and put them back
3192	* in the map.	2922	* in the map.
3193	*/	2923	*/
3194		2924
3195	if (is_in_shop (op))	2925	if (is_in_shop (op))
3196	remove_unpaid_objects (op->inv, op);	2926	remove_unpaid_objects (op->inv, op);
3197		2927
3198	/****************************************/	2928	/****************************************/
3199	/* */	2929	/* */
3200	/* Move player to his current respawn- */	2930	/* Move player to his current respawn- */
3201	/* position (usually last savebed) */	2931	/* position (usually last savebed) */
3202	/* */	2932	/* */
3203	/****************************************/	2933	/****************************************/
3204		2934
3205	enter_player_savebed (op);	2935	enter_player_savebed (op);
3206		2936
3207	/* Save the player before inserting the force to reduce
3208	* chance of abuse.
3209	*/
3210	op->contr->braced = 0;	2937	op->contr->braced = 0;
3211	save_player (op, 1);
3212		2938
3213	/* it is possible that the player has blown something up	2939	/* it is possible that the player has blown something up
3214	* at his savebed location, and that can have long lasting	2940	* at his savebed location, and that can have long lasting
3215	* spell effects. So first see if there is a spell effect	2941	* spell effects. So first see if there is a spell effect
3216	* on the space that might harm the player.	2942	* on the space that might harm the player.
3217	*/	2943	*/
3218	will_kill_again = 0;	2944	will_kill_again = 0;
3219	for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above)	2945	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
3220	if (tmp->type == SPELL_EFFECT)	2946	if (tmp->type == SPELL_EFFECT)
3221	will_kill_again |= tmp->attacktype;	2947	will_kill_again |= tmp->attacktype;
3222		2948
3223	if (will_kill_again)	2949	if (will_kill_again)
3224	{	2950	{
3225	object *force;	2951	object *force;
3226	int at;	2952	int at;
3227		2953
3228	force = get_archetype (FORCE_NAME);	2954	force = get_archetype (FORCE_NAME);
3229	/* 50 ticks should be enough time for the spell to abate */	2955	/* 50 ticks should be enough time for the spell to abate */
3230	force->speed = 0.1;	2956	force->speed = 0.1;
3231	force->speed_left = -5.0;	2957	force->speed_left = -5.0;
3232	SET_FLAG (force, FLAG_APPLIED);	2958	SET_FLAG (force, FLAG_APPLIED);
3233	for (at = 0; at < NROFATTACKS; at++)	2959	for (at = 0; at < NROFATTACKS; at++)
3234	if (will_kill_again & (1 << at))	2960	if (will_kill_again & (1 << at))
3235	force->resist[at] = 100;	2961	force->resist[at] = 100;
3236		2962
3237	insert_ob_in_ob (force, op);	2963	insert_ob_in_ob (force, op);
3238	fix_player (op);	2964	op->update_stats ();
3239		2965
3240	}	2966	}
3241		2967
3242	new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");	2968	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	}	2969	}
3311
3312		2970
3313	void	2971	void
3314	loot_object (object *op)	2972	loot_object (object *op)
3315	{ /* Grab and destroy some treasure */	2973	{ /* Grab and destroy some treasure */
3316	object *tmp, *tmp2, *next;	2974	object *tmp, *tmp2, *next;
3317		2975
3318	if (op->container)	2976	if (op->container)
3319	{ /* close open sack first */
3320	esrv_apply_container (op, op->container);	2977	esrv_apply_container (op, op->container); /* close open sack first */
3321	}
3322		2978
3323	for (tmp = op->inv; tmp != NULL; tmp = next)	2979	for (tmp = op->inv; tmp; tmp = next)
3324	{	2980	{
3325	next = tmp->below;	2981	next = tmp->below;
3326	if (tmp->type == EXPERIENCE || tmp->invisible)	2982
		2983	if (tmp->invisible)
3327	continue;	2984	continue;
		2985
3328	tmp->remove ();	2986	tmp->remove ();
3329	tmp->x = op->x, tmp->y = op->y;	2987	tmp->x = op->x, tmp->y = op->y;
3330	if (tmp->type == CONTAINER)	2988	if (tmp->type == CONTAINER)
3331	{ /* empty container to ground */	2989	{ /* empty container to ground */
3332	loot_object (tmp);	2990	loot_object (tmp);
3333	}	2991	}
3334	if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3)))	2992	if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(rndm (3))))
3335	{	2993	{
3336	if (tmp->nrof > 1)	2994	if (tmp->nrof > 1)
3337	{	2995	{
3338	tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));	2996	tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));
3339	tmp2->destroy ();	2997	tmp2->destroy ();
…		…
3354	*/	3012	*/
3355		3013
3356	void	3014	void
3357	fix_weight (void)	3015	fix_weight (void)
3358	{	3016	{
3359	player *pl;	3017	for_all_players (pl)
3360
3361	for (pl = first_player; pl != NULL; pl = pl->next)
3362	{	3018	{
3363	int old = pl->ob->carrying, sum = sum_weight (pl->ob);	3019	int old = pl->ob->carrying, sum = sum_weight (pl->ob);
3364		3020
3365	if (old == sum)	3021	if (old == sum)
3366	continue;	3022	continue;
3367	fix_player (pl->ob);	3023	pl->ob->update_stats ();
3368	LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);	3024	LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);
3369	}	3025	}
3370	}	3026	}
3371		3027
3372	void	3028	void
3373	fix_luck (void)	3029	fix_luck (void)
3374	{	3030	{
3375	player *pl;	3031	for_all_players (pl)
3376
3377	for (pl = first_player; pl != NULL; pl = pl->next)
3378	if (!pl->ob->contr->state)	3032	if (!pl->ob->contr->ns->state)
3379	change_luck (pl->ob, 0);	3033	pl->ob->change_luck (0);
3380	}	3034	}
3381
3382		3035
3383	/* cast_dust() - handles op throwing objects of type 'DUST'.	3036	/* cast_dust() - handles op throwing objects of type 'DUST'.
3384	* This is much simpler in the new spell code - we basically	3037	* This is much simpler in the new spell code - we basically
3385	* just treat this as any other spell casting object.	3038	* just treat this as any other spell casting object.
3386	*/	3039	*/
3387
3388	void	3040	void
3389	cast_dust (object *op, object *throw_ob, int dir)	3041	cast_dust (object *op, object *throw_ob, int dir)
3390	{	3042	{
3391	object *skop, *spob;	3043	object *skop, *spob;
3392		3044
…		…
3437	object *tmp = NULL;	3089	object *tmp = NULL;
3438		3090
3439	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))	3091	if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
3440	return 1;	3092	return 1;
3441		3093
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;	3094	return 0;
3448	}	3095	}
3449		3096
3450	/* look at the surrounding terrain to determine	3097	/* look at the surrounding terrain to determine
3451	* the hideability of this object. Positive levels	3098	* the hideability of this object. Positive levels
…		…
3507		3154
3508	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);	3155	skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);
3509		3156
3510	/* its *extremely* hard to run and sneak/hide at the same time! */	3157	/* its *extremely* hard to run and sneak/hide at the same time! */
3511	if (op->type == PLAYER && op->contr->run_on)	3158	if (op->type == PLAYER && op->contr->run_on)
3512	{
3513	if (!skop || num >= skop->level)	3159	if (!skop || num >= skop->level)
3514	{	3160	{
3515	new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");	3161	new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");
3516	make_visible (op);	3162	make_visible (op);
3517	return;	3163	return;
3518	}	3164	}
3519	else	3165	else
3520	num += 20;	3166	num += 20;
3521	}	3167
3522	num += op->map->difficulty;	3168	num += op->map->difficulty;
3523	hide = hideability (op); /* modify by terrain hidden level */	3169	hide = hideability (op); /* modify by terrain hidden level */
3524	num -= hide;	3170	num -= hide;
		3171
3525	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))	3172	if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))
3526	{	3173	{
3527	make_visible (op);	3174	make_visible (op);
3528	if (op->type == PLAYER)	3175	if (op->type == PLAYER)
3529	new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");	3176	new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");
3530	}	3177	}
3531	else if (op->type == PLAYER && skop)	3178	else if (op->type == PLAYER && skop)
3532	{
3533	change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);	3179	change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);
3534	}
3535	}	3180	}
3536		3181
3537	/* determine if who is standing near a hostile creature. */	3182	/* determine if who is standing near a hostile creature. */
3538		3183
3539	int	3184	int
…		…
3566	if (mflags & P_OUT_OF_MAP)	3211	if (mflags & P_OUT_OF_MAP)
3567	continue;	3212	continue;
3568	if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))	3213	if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))
3569	continue;	3214	continue;
3570		3215
3571	for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above)	3216	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
3572	{	3217	{
3573	if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))	3218	if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
3574	return 1;	3219	return 1;
3575	else if (tmp->type == PLAYER)	3220	else if (tmp->type == PLAYER)
3576	{	3221	{
…		…
3606	if (pl->type != PLAYER)	3251	if (pl->type != PLAYER)
3607	{	3252	{
3608	LOG (llevError, "player_can_view() called for non-player object\n");	3253	LOG (llevError, "player_can_view() called for non-player object\n");
3609	return -1;	3254	return -1;
3610	}	3255	}
		3256
3611	if (!pl || !op)	3257	if (!pl || !op)
3612	return 0;	3258	return 0;
3613		3259
3614	if (op->head)
3615	{
3616	op = op->head;	3260	op = op->head_ ();
3617	}	3261
3618	get_rangevector (pl, op, &rv, 0x1);	3262	get_rangevector (pl, op, &rv, 0x1);
3619		3263
3620	/* starting with the 'head' part, lets loop	3264	/* starting with the 'head' part, lets loop
3621	* through the object and find if it has any	3265	* through the object and find if it has any
3622	* part that is in the los array but isnt on	3266	* part that is in the los array but isnt on
…		…
3630		3274
3631	/* only the viewable area the player sees is updated by LOS	3275	/* only the viewable area the player sees is updated by LOS
3632	* code, so we need to restrict ourselves to that range of values	3276	* code, so we need to restrict ourselves to that range of values
3633	* for any meaningful values.	3277	* for any meaningful values.
3634	*/	3278	*/
3635	if (FABS (dx) <= (pl->contr->socket->mapx / 2) &&	3279	if (FABS (dx) <= (pl->contr->ns->mapx / 2) &&
3636	FABS (dy) <= (pl->contr->socket->mapy / 2) &&	3280	FABS (dy) <= (pl->contr->ns->mapy / 2) &&
3637	!pl->contr->blocked_los[dx + (pl->contr->socket->mapx / 2)][dy + (pl->contr->socket->mapy / 2)])	3281	!pl->contr->blocked_los[dx + (pl->contr->ns->mapx / 2)][dy + (pl->contr->ns->mapy / 2)])
3638	return 1;	3282	return 1;
3639	op = op->more;	3283	op = op->more;
3640	}	3284	}
3641	return 0;	3285	return 0;
3642	}	3286	}
…		…
3752	if (trlist == NULL || who->type != PLAYER)	3396	if (trlist == NULL || who->type != PLAYER)
3753	return;	3397	return;
3754		3398
3755	for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);	3399	for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);
3756		3400
3757	if (tr == NULL || tr->item == NULL)	3401	if (!tr || !tr->item)
3758	{	3402	{
3759	/* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */	3403	/* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3760	return;	3404	return;
3761	}	3405	}
3762		3406
…		…
3828	{	3472	{
3829	/* forces in the treasurelist can alter the player's stats */	3473	/* forces in the treasurelist can alter the player's stats */
3830	object *skin;	3474	object *skin;
3831		3475
3832	/* first get the dragon skin force */	3476	/* first get the dragon skin force */
		3477	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);	3478	for (skin = who->inv; skin && !(skin->arch->name == dragon_skin_force); skin = skin->below)
		3479	;
		3480
3834	if (skin == NULL)	3481	if (!skin)
3835	return;	3482	return;
3836		3483
3837	/* adding new spellpath attunements */	3484	/* adding new spellpath attunements */
3838	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))	3485	if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))
3839	{	3486	{
…		…
3884	* not readied.	3531	* not readied.
3885	*/	3532	*/
3886	void	3533	void
3887	player_unready_range_ob (player *pl, object *ob)	3534	player_unready_range_ob (player *pl, object *ob)
3888	{	3535	{
3889	rangetype i;
3890
3891	for (i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1))	3536	for (rangetype i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1))
3892	{
3893	if (pl->ranges[i] == ob)	3537	if (pl->ranges[i] == ob)
3894	{	3538	{
3895	pl->ranges[i] = NULL;	3539	pl->ranges[i] = 0;
3896	if (pl->shoottype == i)	3540	if (pl->shoottype == i)
3897	{
3898	pl->shoottype = range_none;	3541	pl->shoottype = range_none;
3899	}
3900	}	3542	}
3901	}
3902	}	3543	}
		3544
		3545	sint8
		3546	player::visibility_at (maptile *map, int x, int y) const
		3547	{
		3548	if (!ns)
		3549	return 0;
		3550
		3551	int dx, dy;
		3552	if (!adjacent_map (map, ns->current_map, &dx, &dy))
		3553	return 0;
		3554
		3555	x += dx - ns->current_x + ns->mapx / 2;
		3556	y += dy - ns->current_y + ns->mapy / 2;
		3557
		3558	if (!IN_RANGE_EXC (x, 0, ns->mapx) || !IN_RANGE_EXC (y, 0, ns->mapy))
		3559	return 0;
		3560
		3561	return 100 - blocked_los [x][y];
		3562	}

Diff Legend

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