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.6 by root, Sat Aug 26 23:36:34 2006 UTC vs.
Revision 1.17 by pippijn, Thu Sep 7 10:01:58 2006 UTC

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

Diff Legend

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