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