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.6 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.273 by root, Sun Apr 18 05:54:18 2010 UTC

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

Diff Legend

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