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.19 by root, Mon Sep 11 23:53:30 2006 UTC vs.
Revision 1.158 by root, Mon Aug 13 15:46:45 2007 UTC

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

Diff Legend

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