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.16 by root, Tue Sep 5 18:18:09 2006 UTC vs.
Revision 1.171 by root, Sat Sep 8 07:06:51 2007 UTC

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

Diff Legend

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