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.187 by root, Mon Apr 21 07:07:36 2008 UTC

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

Diff Legend

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