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

Diff Legend

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