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.51 by root, Thu Dec 21 06:12:37 2006 UTC vs.
Revision 1.221 by root, Wed Dec 31 17:35:38 2008 UTC

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

Diff Legend

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