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.15 by root, Mon Sep 4 11:08:00 2006 UTC vs.
Revision 1.37 by root, Thu Dec 14 02:37:37 2006 UTC

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

Diff Legend

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