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

Diff Legend

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