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

Diff Legend

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