ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/player.C

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

Diff Legend

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