ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/attack.C

Comparing deliantra/server/server/attack.C (file contents):
Revision 1.17 by root, Thu Sep 14 22:34:03 2006 UTC vs.
Revision 1.48 by root, Thu Jan 18 22:20:00 2007 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game for X-windows
3		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20		21	*
21	The authors can be reached via e-mail to <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/	23	*/
23	#include <assert.h>	24	#include <assert.h>
24	#include <global.h>	25	#include <global.h>
25	#include <living.h>	26	#include <living.h>
26	#include <material.h>	27	#include <material.h>
27	#include <skills.h>	28	#include <skills.h>
…		…
44	* its magical benefits.	45	* its magical benefits.
45	*/	46	*/
46	void	47	void
47	cancellation (object *op)	48	cancellation (object *op)
48	{	49	{
49	object *tmp;
50
51	if (op->invisible)	50	if (op->invisible)
52	return;	51	return;
53		52
54	if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ)	53	if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ)
55	{	54	{
56	/* Recur through the inventory */	55	/* Recurse through the inventory */
57	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	56	for (object *tmp = op->inv; tmp; tmp = tmp->below)
58	if (!did_make_save_item (tmp, AT_CANCELLATION, op))	57	if (!did_make_save_item (tmp, AT_CANCELLATION, op))
59	cancellation (tmp);	58	cancellation (tmp);
60	}	59	}
61	else if (FABS (op->magic) <= (rndm (0, 5)))	60	else if (FABS (op->magic) <= rndm (0, 5))
62	{	61	{
63	/* Nullify this object. This code could probably be more complete */	62	/* Nullify this object. This code could probably be more complete */
64	/* in what abilities it should cancel */	63	/* in what abilities it should cancel */
65	op->magic = 0;	64	op->magic = 0;
		65
66	CLEAR_FLAG (op, FLAG_DAMNED);	66	CLEAR_FLAG (op, FLAG_DAMNED);
67	CLEAR_FLAG (op, FLAG_CURSED);	67	CLEAR_FLAG (op, FLAG_CURSED);
68	CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);	68	CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
69	CLEAR_FLAG (op, FLAG_KNOWN_CURSED);	69	CLEAR_FLAG (op, FLAG_KNOWN_CURSED);
		70
70	if (op->env && op->env->type == PLAYER)	71	if (op->env && op->env->type == PLAYER)
71	{
72	esrv_send_item (op->env, op);	72	esrv_send_item (op->env, op);
73	}
74	}	73	}
75	}	74	}
76
77
78		75
79	/* did_make_save_item just checks to make sure the item actually	76	/* did_make_save_item just checks to make sure the item actually
80	* made its saving throw based on the tables. It does not take	77	* made its saving throw based on the tables. It does not take
81	* any further action (like destroying the item).	78	* any further action (like destroying the item).
82	*/	79	*/
83
84	int	80	int
85	did_make_save_item (object *op, int type, object *originator)	81	did_make_save_item (object *op, int type, object *originator)
86	{	82	{
87	int i, roll, saves = 0, attacks = 0, number;	83	int i, roll, saves = 0, attacks = 0, number;
88	materialtype_t *mt;	84	materialtype_t *mt;
89		85
90	if (op->materialname == NULL)	86	if (op->materialname == NULL)
91	{	87	{
92	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)	88	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
93	{
94	if (op->material & mt->material)	89	if (op->material & mt->material)
95	break;	90	break;
96	}
97	}	91	}
98	else	92	else
99	mt = name_to_material (op->materialname);	93	mt = name_to_material (op->materialname);
		94
100	if (mt == NULL)	95	if (mt == NULL)
101	return TRUE;	96	return TRUE;
		97
102	roll = rndm (1, 20);	98	roll = rndm (1, 20);
103		99
104	/* the attacktypes have no meaning for object saves	100	/* the attacktypes have no meaning for object saves
105	* If the type is only magic, don't adjust type - basically, if	101	* If the type is only magic, don't adjust type - basically, if
106	* pure magic is hitting an object, it should save. However, if it	102	* pure magic is hitting an object, it should save. However, if it
…		…
135	saves++;	131	saves++;
136	}	132	}
137		133
138	if (saves == attacks || attacks == 0)	134	if (saves == attacks || attacks == 0)
139	return TRUE;	135	return TRUE;
		136
140	if ((saves == 0) || (rndm (1, attacks) > saves))	137	if (saves == 0 || (rndm (1, attacks) > saves))
141	return FALSE;	138	return FALSE;
		139
142	return TRUE;	140	return TRUE;
143	}	141	}
144		142
145	/* This function calls did_make_save_item. It then performs the	143	/* This function calls did_make_save_item. It then performs the
146	* appropriate actions to the item (such as burning the item up,	144	* appropriate actions to the item (such as burning the item up,
147	* calling cancellation, etc.)	145	* calling cancellation, etc.)
148	*/	146	*/
149
150	void	147	void
151	save_throw_object (object *op, int type, object *originator)	148	save_throw_object (object *op, int type, object *originator)
152	{	149	{
153	if (!did_make_save_item (op, type, originator))	150	if (!did_make_save_item (op, type, originator))
154	{	151	{
155	object *env = op->env;	152	object *env = op->env;
156	int x = op->x, y = op->y;	153	int x = op->x, y = op->y;
157	mapstruct *m = op->map;	154	maptile *m = op->map;
158		155
159	op = stop_item (op);	156	op = stop_item (op);
160	if (op == NULL)	157	if (op == NULL)
161	return;	158	return;
162		159
…		…
212	}	209	}
213	else	210	else
214	{	211	{
215	if (op->env)	212	if (op->env)
216	{	213	{
217	object *tmp = is_player_inv (op->env);	214	object *tmp = op->in_player ();
218		215
219	if (tmp)	216	if (tmp)
220	esrv_del_item (tmp->contr, op->count);	217	esrv_del_item (tmp->contr, op->count);
221	}	218	}
222		219
223	if (!QUERY_FLAG (op, FLAG_REMOVED))	220	op->destroy ();
224	remove_ob (op);
225
226	free_object (op);
227	}	221	}
228		222
229	if (type & (AT_FIRE | AT_ELECTRICITY))	223	if (type & (AT_FIRE | AT_ELECTRICITY))
230	if (env)	224	if (env)
231	{	225	{
…		…
264	tmp->move_slow = 0;	258	tmp->move_slow = 0;
265	insert_ob_in_map (tmp, op->map, originator, 0);	259	insert_ob_in_map (tmp, op->map, originator, 0);
266	}	260	}
267		261
268	if (!QUERY_FLAG (op, FLAG_REMOVED))	262	if (!QUERY_FLAG (op, FLAG_REMOVED))
269	remove_ob (op);	263	op->remove ();
270		264
271	insert_ob_in_ob (op, tmp);	265	insert_ob_in_ob (op, tmp);
272	return;	266	return;
273	}	267	}
274	}	268	}
…		…
281	*/	275	*/
282		276
283	int	277	int
284	hit_map (object *op, int dir, int type, int full_hit)	278	hit_map (object *op, int dir, int type, int full_hit)
285	{	279	{
286	object *tmp, *next;
287	mapstruct *map;	280	maptile *map;
288	sint16 x, y;	281	sint16 x, y;
289	int retflag = 0; /* added this flag.. will return 1 if it hits a monster */	282	int retflag = 0; /* added this flag.. will return 1 if it hits a monster */
290		283
291	tag_t op_tag, next_tag = 0;
292
293	if (QUERY_FLAG (op, FLAG_FREED))	284	if (QUERY_FLAG (op, FLAG_FREED))
294	{	285	{
295	LOG (llevError, "BUG: hit_map(): free object\n");	286	LOG (llevError, "BUG: hit_map(): free object\n");
296	return 0;	287	return 0;
297	}	288	}
…		…
308	return 0;	299	return 0;
309	}	300	}
310		301
311	if (op->head)	302	if (op->head)
312	op = op->head;	303	op = op->head;
313
314	op_tag = op->count;
315		304
316	map = op->map;	305	map = op->map;
317	x = op->x + freearr_x[dir];	306	x = op->x + freearr_x[dir];
318	y = op->y + freearr_y[dir];	307	y = op->y + freearr_y[dir];
319		308
320	int mflags = get_map_flags (map, &map, x, y, &x, &y);	309	if (!xy_normalise (map, x, y))
		310	return 0;
321		311
322	// elmex: a safe map tile can't be hit!	312	// elmex: a safe map tile can't be hit!
323	// this should prevent most harmful effects on items and players there.	313	// this should prevent most harmful effects on items and players there.
324	if (mflags & (P_OUT_OF_MAP | P_SAFE))	314	mapspace &ms = map->at (x, y);
		315
		316	if (ms.flags () & P_SAFE)
325	return 0;	317	return 0;
326		318
327	/* peterm: a few special cases for special attacktypes --counterspell	319	/* peterm: a few special cases for special attacktypes --counterspell
328	* must be out here because it strikes things which are not alive	320	* must be out here because it strikes things which are not alive
329	*/	321	*/
330		322	if (type & (AT_COUNTERSPELL | AT_CHAOS))
		323	{
331	if (type & AT_COUNTERSPELL)	324	if (type & AT_COUNTERSPELL)
332	{	325	{
333	counterspell (op, dir); /* see spell_effect.c */	326	counterspell (op, dir); /* see spell_effect.c */
334		327
335	/* If the only attacktype is counterspell or magic, don't need	328	/* If the only attacktype is counterspell or magic, don't need
336	* to do any further processing.	329	* to do any further processing.
337	*/
338	if (!(type & ~(AT_COUNTERSPELL | AT_MAGIC)))
339	return 0;
340
341	type &= ~AT_COUNTERSPELL;
342	}
343
344	if (type & AT_CHAOS)
345	{
346	shuffle_attack (op, 1); /*1 flag tells it to change the face */
347	update_object (op, UP_OBJ_FACE);
348	type &= ~AT_CHAOS;
349	}
350
351	next = get_map_ob (map, x, y);
352	if (next)
353	next_tag = next->count;
354
355	while (next)
356	{
357	if (was_destroyed (next, next_tag))
358	{
359	/* There may still be objects that were above 'next', but there is no
360	* simple way to find out short of copying all object references and
361	* tags into a temporary array before we start processing the first
362	* object. That's why we just abort.
363	*
364	* This happens whenever attack spells (like fire) hit a pile
365	* of objects. This is not a bug - nor an error. The errormessage
366	* below was spamming the logs for absolutely no reason.
367	*/	330	*/
368	/* LOG (llevDebug, "hit_map(): next object destroyed\n"); */	331	if (!(type & ~(AT_COUNTERSPELL | AT_MAGIC)))
369	break;	332	return 0;
		333
		334	type &= ~AT_COUNTERSPELL;
		335	}
		336
		337	if (type & AT_CHAOS)
370	}	338	{
		339	shuffle_attack (op, 1); /* flag tells it to change the face */
		340	update_object (op, UP_OBJ_FACE);
		341	type &= ~AT_CHAOS;
		342	}
		343	}
371		344
		345	/* There may still be objects that were above 'next', but there is no
		346	* simple way to find out short of copying all object references and
		347	* tags into a temporary array before we start processing the first
		348	* object. That's why we just abort on destroy.
		349	*
		350	* This happens whenever attack spells (like fire) hit a pile
		351	* of objects. This is not a bug - nor an error.
		352	*/
		353	for (object *next = ms.bot; next && !next->destroyed (); )
		354	{
372	tmp = next;	355	object *tmp = next;
373	next = tmp->above;	356	next = tmp->above;
374
375	if (next)
376	next_tag = next->count;
377
378	if (QUERY_FLAG (tmp, FLAG_FREED))
379	{
380	LOG (llevError, "BUG: hit_map(): found freed object\n");
381	break;
382	}
383		357
384	/* Something could have happened to 'tmp' while 'tmp->below' was processed.	358	/* Something could have happened to 'tmp' while 'tmp->below' was processed.
385	* For example, 'tmp' was put in an icecube.	359	* For example, 'tmp' was put in an icecube.
386	* This is one of the few cases where on_same_map should not be used.	360	* This is one of the few cases where on_same_map should not be used.
387	*/	361	*/
…		…
390		364
391	if (QUERY_FLAG (tmp, FLAG_ALIVE))	365	if (QUERY_FLAG (tmp, FLAG_ALIVE))
392	{	366	{
393	hit_player (tmp, op->stats.dam, op, type, full_hit);	367	hit_player (tmp, op->stats.dam, op, type, full_hit);
394	retflag |= 1;	368	retflag |= 1;
		369
395	if (was_destroyed (op, op_tag))	370	if (op->destroyed ())
396	break;	371	break;
397	}	372	}
398
399	/* Here we are potentially destroying an object. If the object has	373	/* Here we are potentially destroying an object. If the object has
400	* NO_PASS set, it is also immune - you can't destroy walls. Note	374	* NO_PASS set, it is also immune - you can't destroy walls. Note
401	* that weak walls have is_alive set, which prevent objects from	375	* that weak walls have is_alive set, which prevent objects from
402	* passing over/through them. We don't care what type of movement	376	* passing over/through them. We don't care what type of movement
403	* the wall blocks - if it blocks any type of movement, can't be	377	* the wall blocks - if it blocks any type of movement, can't be
404	* destroyed right now.	378	* destroyed right now.
405	*/	379	*/
406	else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 && !tmp->move_block)	380	else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 && !tmp->move_block)
407	{	381	{
408	save_throw_object (tmp, type, op);	382	save_throw_object (tmp, type, op);
		383
409	if (was_destroyed (op, op_tag))	384	if (op->destroyed ())
410	break;	385	break;
411	}	386	}
412	}	387	}
413		388
414	return 0;	389	return 0;
…		…
417	void	392	void
418	attack_message (int dam, int type, object *op, object *hitter)	393	attack_message (int dam, int type, object *op, object *hitter)
419	{	394	{
420	char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF];	395	char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF];
421	int i, found = 0;	396	int i, found = 0;
422	mapstruct *map;	397	maptile *map;
423	object *next, *tmp;	398	object *next, *tmp;
424		399
425	/* put in a few special messages for some of the common attacktypes	400	/* put in a few special messages for some of the common attacktypes
426	* a player might have. For example, fire, electric, cold, etc	401	* a player might have. For example, fire, electric, cold, etc
427	* [garbled 20010919]	402	* [garbled 20010919]
…		…
444	sprintf (buf1, "missed %s", &op->name);	419	sprintf (buf1, "missed %s", &op->name);
445	sprintf (buf2, " misses");	420	sprintf (buf2, " misses");
446	found++;	421	found++;
447	}	422	}
448	else if ((hitter->type == DISEASE || hitter->type == SYMPTOM ||	423	else if ((hitter->type == DISEASE || hitter->type == SYMPTOM ||
449	hitter->type == POISONING || (type & AT_POISON && IS_LIVE (op))) && !found)	424	hitter->type == POISONING || (type & AT_POISON && op->is_alive ())) && !found)
450	{	425	{
451	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1; i++)	426	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1; i++)
452	if (dam < attack_mess[ATM_SUFFER][i].level || attack_mess[ATM_SUFFER][i + 1].level == -1)	427	if (dam < attack_mess[ATM_SUFFER][i].level || attack_mess[ATM_SUFFER][i + 1].level == -1)
453	{	428	{
454	sprintf (buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1, &op->name, attack_mess[ATM_SUFFER][i].buf2);	429	sprintf (buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1, &op->name, attack_mess[ATM_SUFFER][i].buf2);
…		…
466	strcpy (buf2, attack_mess[ATM_DOOR][i].buf3);	441	strcpy (buf2, attack_mess[ATM_DOOR][i].buf3);
467	found++;	442	found++;
468	break;	443	break;
469	}	444	}
470	}	445	}
471	else if (hitter->type == PLAYER && IS_LIVE (op))	446	else if (hitter->type == PLAYER && op->is_alive ())
472	{	447	{
473	if (USING_SKILL (hitter, SK_KARATE))	448	if (USING_SKILL (hitter, SK_KARATE))
474	{	449	{
475	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1; i++)	450	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1; i++)
476	if (dam < attack_mess[ATM_KARATE][i].level || attack_mess[ATM_KARATE][i + 1].level == -1)	451	if (dam < attack_mess[ATM_KARATE][i].level || attack_mess[ATM_KARATE][i + 1].level == -1)
…		…
502	found++;	477	found++;
503	break;	478	break;
504	}	479	}
505	}	480	}
506	}	481	}
		482
507	if (found)	483	if (found)
508	{	484	{
509	/* done */	485	/* done */
510	}	486	}
511	else if (IS_ARROW (hitter) && (type == AT_PHYSICAL || type == AT_MAGIC))	487	else if (hitter->is_arrow () && (type == AT_PHYSICAL || type == AT_MAGIC))
512	{	488	{
513	sprintf (buf1, "hit"); /* just in case */	489	sprintf (buf1, "hit"); /* just in case */
514	for (i = 0; i < MAXATTACKMESS; i++)	490	for (i = 0; i < MAXATTACKMESS; i++)
515	if (dam < attack_mess[ATM_ARROW][i].level || attack_mess[ATM_ARROW][i + 1].level == -1)	491	if (dam < attack_mess[ATM_ARROW][i].level || attack_mess[ATM_ARROW][i + 1].level == -1)
516	{	492	{
517	strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);	493	strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);
518	found++;	494	found++;
519	break;	495	break;
520	}	496	}
521	}	497	}
522	else if (type & AT_DRAIN && IS_LIVE (op))	498	else if (type & AT_DRAIN && op->is_alive ())
523	{	499	{
524	/* drain is first, because some items have multiple attypes */	500	/* drain is first, because some items have multiple attypes */
525	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1; i++)	501	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1; i++)
526	if (dam < attack_mess[ATM_DRAIN][i].level || attack_mess[ATM_DRAIN][i + 1].level == -1)	502	if (dam < attack_mess[ATM_DRAIN][i].level || attack_mess[ATM_DRAIN][i + 1].level == -1)
527	{	503	{
…		…
529	strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);	505	strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);
530	found++;	506	found++;
531	break;	507	break;
532	}	508	}
533	}	509	}
534	else if (type & AT_ELECTRICITY && IS_LIVE (op))	510	else if (type & AT_ELECTRICITY && op->is_alive ())
535	{	511	{
536	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1; i++)	512	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1; i++)
537	if (dam < attack_mess[ATM_ELEC][i].level || attack_mess[ATM_ELEC][i + 1].level == -1)	513	if (dam < attack_mess[ATM_ELEC][i].level || attack_mess[ATM_ELEC][i + 1].level == -1)
538	{	514	{
539	sprintf (buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1, &op->name, attack_mess[ATM_ELEC][i].buf2);	515	sprintf (buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1, &op->name, attack_mess[ATM_ELEC][i].buf2);
540	strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);	516	strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);
541	found++;	517	found++;
542	break;	518	break;
543	}	519	}
544	}	520	}
545	else if (type & AT_COLD && IS_LIVE (op))	521	else if (type & AT_COLD && op->is_alive ())
546	{	522	{
547	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1; i++)	523	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1; i++)
548	if (dam < attack_mess[ATM_COLD][i].level || attack_mess[ATM_COLD][i + 1].level == -1)	524	if (dam < attack_mess[ATM_COLD][i].level || attack_mess[ATM_COLD][i + 1].level == -1)
549	{	525	{
550	sprintf (buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1, &op->name, attack_mess[ATM_COLD][i].buf2);	526	sprintf (buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1, &op->name, attack_mess[ATM_COLD][i].buf2);
…		…
627	strcpy (buf1, "hit");	603	strcpy (buf1, "hit");
628	strcpy (buf2, " hits");	604	strcpy (buf2, " hits");
629	}	605	}
630		606
631	/* bail out if a monster is casting spells */	607	/* bail out if a monster is casting spells */
632	if (!(hitter->type == PLAYER || (get_owner (hitter) != NULL && hitter->owner->type == PLAYER)))	608	if (!(hitter->type == PLAYER || (hitter->owner != NULL && hitter->owner->type == PLAYER)))
633	return;	609	return;
634		610
635	/* scale down magic considerably. */	611	/* scale down magic considerably. */
636	if (type & AT_MAGIC && rndm (0, 5))	612	if (type & AT_MAGIC && rndm (0, 5))
637	return;	613	return;
638		614
639	/* Did a player hurt another player? Inform both! */	615	/* Did a player hurt another player? Inform both! */
640	if (op->type == PLAYER && (get_owner (hitter) == NULL ? hitter->type : hitter->owner->type) == PLAYER)	616	if (op->type == PLAYER && (hitter->owner == NULL ? hitter->type : hitter->owner->type) == PLAYER)
641	{	617	{
642	if (get_owner (hitter) != NULL)	618	if (hitter->owner != NULL)
643	sprintf (buf, "%s's %s%s you.", &hitter->owner->name, &hitter->name, buf2);	619	sprintf (buf, "%s's %s%s you.", &hitter->owner->name, &hitter->name, buf2);
644	else	620	else
645	{	621	{
646	sprintf (buf, "%s%s you.", &hitter->name, buf2);	622	sprintf (buf, "%s%s you.", &hitter->name, buf2);
647	if (dam != 0)	623	if (dam != 0)
…		…
669	else	645	else
670	play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS3, 0, 0);	646	play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS3, 0, 0);
671	}	647	}
672	new_draw_info (NDI_BLACK, 0, hitter, buf);	648	new_draw_info (NDI_BLACK, 0, hitter, buf);
673	}	649	}
674	else if (get_owner (hitter) != NULL && hitter->owner->type == PLAYER)	650	else if (hitter->owner != NULL && hitter->owner->type == PLAYER)
675	{	651	{
676	/* look for stacked spells and start reducing the message chances */	652	/* look for stacked spells and start reducing the message chances */
677	if (hitter->type == SPELL_EFFECT && (hitter->subtype == SP_EXPLOSION || hitter->subtype == SP_BULLET || hitter->subtype == SP_CONE))	653	if (hitter->type == SPELL_EFFECT && (hitter->subtype == SP_EXPLOSION || hitter->subtype == SP_BULLET || hitter->subtype == SP_CONE))
678	{	654	{
679	i = 4;	655	i = 4;
680	map = hitter->map;	656	map = hitter->map;
681	if (out_of_map (map, hitter->x, hitter->y))	657	if (out_of_map (map, hitter->x, hitter->y))
682	return;	658	return;
683	next = get_map_ob (map, hitter->x, hitter->y);	659	next = GET_MAP_OB (map, hitter->x, hitter->y);
684	if (next)	660	if (next)
685	while (next)	661	while (next)
686	{	662	{
687	if (next->type == SPELL_EFFECT && (next->subtype == SP_EXPLOSION || next->subtype == SP_BULLET || next->subtype == SP_CONE))	663	if (next->type == SPELL_EFFECT && (next->subtype == SP_EXPLOSION || next->subtype == SP_BULLET || next->subtype == SP_CONE))
688	i *= 3;	664	i *= 3;
…		…
754	attack_ob_simple (object *op, object *hitter, int base_dam, int base_wc)	730	attack_ob_simple (object *op, object *hitter, int base_dam, int base_wc)
755	{	731	{
756	int simple_attack, roll, dam = 0;	732	int simple_attack, roll, dam = 0;
757	uint32 type;	733	uint32 type;
758	shstr op_name;	734	shstr op_name;
759	tag_t op_tag, hitter_tag;
760		735
761	if (get_attack_mode (&op, &hitter, &simple_attack))	736	if (get_attack_mode (&op, &hitter, &simple_attack))
762	goto error;	737	goto error;
763		738
764	if (hitter->current_weapon)	739	if (hitter->current_weapon)
765	if (INVOKE_OBJECT (WEAPON_ATTACK, hitter->current_weapon, ARG_OBJECT (hitter), ARG_OBJECT (op)))	740	if (INVOKE_OBJECT (WEAPON_ATTACK, hitter->current_weapon, ARG_OBJECT (hitter), ARG_OBJECT (op)))
766	return RESULT_INT (0);	741	return RESULT_INT (0);
767		742
768	if (INVOKE_OBJECT (ATTACK, op, ARG_OBJECT (hitter)))	743	if (INVOKE_OBJECT (ATTACK, op, ARG_OBJECT (hitter)))
769	return RESULT_INT (0);	744	return RESULT_INT (0);
770
771	op_tag = op->count;
772	hitter_tag = hitter->count;
773		745
774	/*	746	/*
775	* A little check to make it more difficult to dance forward and back	747	* A little check to make it more difficult to dance forward and back
776	* to avoid ever being hit by monsters.	748	* to avoid ever being hit by monsters.
777	*/	749	*/
…		…
782	* which then gets here again. By decreasing the speed before	754	* which then gets here again. By decreasing the speed before
783	* we call process_object, the 'if' statement above will fail.	755	* we call process_object, the 'if' statement above will fail.
784	*/	756	*/
785	op->speed_left--;	757	op->speed_left--;
786	process_object (op);	758	process_object (op);
		759
787	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))	760	if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
788	goto error;	761	goto error;
789	}	762	}
790		763
791	op_name = op->name;	764	op_name = op->name;
792		765
…		…
804	if (settings.casting_time == TRUE)	777	if (settings.casting_time == TRUE)
805	{	778	{
806	if ((hitter->type == PLAYER) && (hitter->casting_time > -1))	779	if ((hitter->type == PLAYER) && (hitter->casting_time > -1))
807	{	780	{
808	hitter->casting_time = -1;	781	hitter->casting_time = -1;
809	new_draw_info (NDI_UNIQUE, 0, hitter, "You attacked and lost " "your spell!");	782	new_draw_info (NDI_UNIQUE, 0, hitter, "You attacked and lost your spell!");
810	}	783	}
811	if ((op->casting_time > -1) && (hitdam > 0))	784	if ((op->casting_time > -1) && (hitdam > 0))
812	{	785	{
813	op->casting_time = -1;	786	op->casting_time = -1;
814	if (op->type == PLAYER)	787	if (op->type == PLAYER)
815	{	788	{
816	new_draw_info (NDI_UNIQUE, 0, op, "You were hit and lost " "your spell!");	789	new_draw_info (NDI_UNIQUE, 0, op, "You were hit and lost your spell!");
817	new_draw_info_format (NDI_ALL | NDI_UNIQUE, 5, NULL, "%s was hit by %s and lost a spell.", &op_name, &hitter->name);	790	new_draw_info_format (NDI_ALL | NDI_UNIQUE, 5, NULL, "%s was hit by %s and lost a spell.", &op_name, &hitter->name);
818	}	791	}
819	}	792	}
820	}	793	}
821	if (!simple_attack)	794	if (!simple_attack)
…		…
826	if (QUERY_FLAG (op, FLAG_SLEEP))	799	if (QUERY_FLAG (op, FLAG_SLEEP))
827	CLEAR_FLAG (op, FLAG_SLEEP);	800	CLEAR_FLAG (op, FLAG_SLEEP);
828		801
829	/* If the victim can't see the attacker, it may alert others	802	/* If the victim can't see the attacker, it may alert others
830	* for help. */	803	* for help. */
831	if (op->type != PLAYER && !can_see_enemy (op, hitter) && !get_owner (op) && rndm (0, op->stats.Int))	804	if (op->type != PLAYER && !can_see_enemy (op, hitter) && !op->owner && rndm (0, op->stats.Int))
832	npc_call_help (op);	805	npc_call_help (op);
833		806
834	/* if you were hidden and hit by a creature, you are discovered */	807	/* if you were hidden and hit by a creature, you are discovered */
835	if (op->hide && QUERY_FLAG (hitter, FLAG_ALIVE))	808	if (op->hide && QUERY_FLAG (hitter, FLAG_ALIVE))
836	{	809	{
…		…
843	* when they hit the victim. For things like thrown daggers,	816	* when they hit the victim. For things like thrown daggers,
844	* this sets 'hitter' to the actual dagger, and not the	817	* this sets 'hitter' to the actual dagger, and not the
845	* wrapper object.	818	* wrapper object.
846	*/	819	*/
847	thrown_item_effect (hitter, op);	820	thrown_item_effect (hitter, op);
		821
848	if (was_destroyed (hitter, hitter_tag) || was_destroyed (op, op_tag) || abort_attack (op, hitter, simple_attack))	822	if (hitter->destroyed () || op->destroyed () || abort_attack (op, hitter, simple_attack))
849	goto leave;	823	goto leave;
850	}	824	}
851		825
852	/* Need to do at least 1 damage, otherwise there is no point	826	/* Need to do at least 1 damage, otherwise there is no point
853	* to go further and it will cause FPE's below.	827	* to go further and it will cause FPE's below.
854	*/	828	*/
855	if (hitdam <= 0)	829	if (hitdam <= 0)
856	hitdam = 1;	830	hitdam = 1;
857		831
858	type = hitter->attacktype;	832	type = hitter->attacktype;
		833
859	if (!type)	834	if (!type)
860	type = AT_PHYSICAL;	835	type = AT_PHYSICAL;
		836
861	/* Handle monsters that hit back */	837	/* Handle monsters that hit back */
862	if (!simple_attack && QUERY_FLAG (op, FLAG_HITBACK) && QUERY_FLAG (hitter, FLAG_ALIVE))	838	if (!simple_attack && QUERY_FLAG (op, FLAG_HITBACK) && QUERY_FLAG (hitter, FLAG_ALIVE))
863	{	839	{
864	if (op->attacktype & AT_ACID && hitter->type == PLAYER)	840	if (op->attacktype & AT_ACID && hitter->type == PLAYER)
865	new_draw_info (NDI_UNIQUE, 0, hitter, "You are splashed by acid!\n");	841	new_draw_info (NDI_UNIQUE, 0, hitter, "You are splashed by acid!\n");
		842
866	hit_player (hitter, random_roll (0, (op->stats.dam), hitter, PREFER_LOW), op, op->attacktype, 1);	843	hit_player (hitter, random_roll (0, (op->stats.dam), hitter, PREFER_LOW), op, op->attacktype, 1);
		844
867	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))	845	if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
868	goto leave;	846	goto leave;
869	}	847	}
870		848
871	/* In the new attack code, it should handle multiple attack	849	/* In the new attack code, it should handle multiple attack
872	* types in its area, so remove it from here.	850	* types in its area, so remove it from here.
873	*/	851	*/
874	dam = hit_player (op, random_roll (1, hitdam, hitter, PREFER_HIGH), hitter, type, 1);	852	dam = hit_player (op, random_roll (1, hitdam, hitter, PREFER_HIGH), hitter, type, 1);
		853
875	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))	854	if (op->destroyed () || hitter->destroyed () || abort_attack (op, hitter, simple_attack))
876	goto leave;	855	goto leave;
877	} /* end of if hitter hit op */	856	} /* end of if hitter hit op */
878	/* if we missed, dam=0 */	857	/* if we missed, dam=0 */
879		858
880	/*attack_message(dam, type, op, hitter); */	859	/*attack_message(dam, type, op, hitter); */
…		…
914	if (op->weight <= 5000 && tmp->stats.hp >= 0)	893	if (op->weight <= 5000 && tmp->stats.hp >= 0)
915	{	894	{
916	if (tmp->head != NULL)	895	if (tmp->head != NULL)
917	tmp = tmp->head;	896	tmp = tmp->head;
918		897
919	remove_ob (op);	898	op->remove ();
920	op = insert_ob_in_ob (op, tmp);	899	op = insert_ob_in_ob (op, tmp);
921		900
922	if (tmp->type == PLAYER)	901	if (tmp->type == PLAYER)
923	esrv_send_item (tmp, op);	902	esrv_send_item (tmp, op);
924		903
…		…
937	object *	916	object *
938	hit_with_arrow (object *op, object *victim)	917	hit_with_arrow (object *op, object *victim)
939	{	918	{
940	object *container, *hitter;	919	object *container, *hitter;
941	int hit_something = 0;	920	int hit_something = 0;
942	tag_t victim_tag, hitter_tag;
943	sint16 victim_x, victim_y;
944		921
945	/* Disassemble missile */	922	/* Disassemble missile */
946	if (op->inv)	923	if (op->inv)
947	{	924	{
948	container = op;	925	container = op;
949	hitter = op->inv;	926	hitter = op->inv;
950	remove_ob (hitter);	927	hitter->remove ();
951	insert_ob_in_map (hitter, container->map, hitter, INS_NO_MERGE | INS_NO_WALK_ON);	928	insert_ob_in_map (hitter, container->map, hitter, INS_NO_MERGE | INS_NO_WALK_ON);
952	/* Note that we now have an empty THROWN_OBJ on the map. Code that	929	/* Note that we now have an empty THROWN_OBJ on the map. Code that
953	* might be called until this THROWN_OBJ is either reassembled or	930	* might be called until this THROWN_OBJ is either reassembled or
954	* removed at the end of this function must be able to deal with empty	931	* removed at the end of this function must be able to deal with empty
955	* THROWN_OBJs. */	932	* THROWN_OBJs. */
956	}	933	}
957	else	934	else
958	{	935	{
959	container = NULL;	936	container = 0;
960	hitter = op;	937	hitter = op;
961	}	938	}
962		939
963	/* Try to hit victim */	940	/* Try to hit victim */
964	victim_x = victim->x;
965	victim_y = victim->y;
966	victim_tag = victim->count;
967	hitter_tag = hitter->count;
968
969	hit_something = attack_ob_simple (victim, hitter, op->stats.dam, op->stats.wc);	941	hit_something = attack_ob_simple (victim, hitter, op->stats.dam, op->stats.wc);
970		942
971	/* Arrow attacks door, rune of summoning is triggered, demon is put on	943	/* Arrow attacks door, rune of summoning is triggered, demon is put on
972	* arrow, move_apply() calls this function, arrow sticks in demon,	944	* arrow, move_apply() calls this function, arrow sticks in demon,
973	* attack_ob_simple() returns, and we've got an arrow that still exists	945	* attack_ob_simple() returns, and we've got an arrow that still exists
974	* but is no longer on the map. Ugh. (Beware: Such things can happen at	946	* but is no longer on the map. Ugh. (Beware: Such things can happen at
975	* other places as well!)	947	* other places as well!)
976	*/	948	*/
977	if (was_destroyed (hitter, hitter_tag) || hitter->env != NULL)	949	if (hitter->destroyed () || hitter->env != NULL)
978	{	950	{
979	if (container)	951	if (container)
980	{	952	{
981	remove_ob (container);	953	container->remove ();
982	free_object (container);	954	container->destroy ();
983	}	955	}
		956
984	return NULL;	957	return 0;
985	}	958	}
986		959
987	/* Missile hit victim */	960	/* Missile hit victim */
988	/* if the speed is > 10, then this is a fast moving arrow, we go straight	961	/* if the speed is > 10, then this is a fast moving arrow, we go straight
989	* through the target	962	* through the target
990	*/	963	*/
991	if (hit_something && op->speed <= 10.0)	964	if (hit_something && op->speed <= 10.0)
992	{	965	{
993	/* Stop arrow */	966	/* Stop arrow */
994	if (container == NULL)	967	if (!container)
995	{	968	{
996	hitter = fix_stopped_arrow (hitter);	969	hitter = fix_stopped_arrow (hitter);
997	if (hitter == NULL)	970	if (!hitter)
998	return NULL;	971	return 0;
999	}	972	}
1000	else	973	else
1001	{	974	container->destroy ();
1002	remove_ob (container);
1003	free_object (container);
1004	}
1005		975
1006	/* Try to stick arrow into victim */	976	/* Try to stick arrow into victim */
1007	if (!was_destroyed (victim, victim_tag) && stick_arrow (hitter, victim))	977	if (!victim->destroyed () && stick_arrow (hitter, victim))
1008	return NULL;	978	return 0;
1009		979
1010	/* Else try to put arrow on victim's map square	980	/* Else try to put arrow on victim's map square
1011	* remove check for P_WALL here. If the arrow got to this	981	* remove check for P_WALL here. If the arrow got to this
1012	* space, that is good enough - with the new movement code,	982	* space, that is good enough - with the new movement code,
1013	* there is now the potential for lots of spaces where something	983	* there is now the potential for lots of spaces where something
1014	* can fly over but not otherwise move over. What is the correct	984	* can fly over but not otherwise move over. What is the correct
1015	* way to handle those otherwise?	985	* way to handle those otherwise?
1016	*/	986	*/
1017	if (victim_x != hitter->x || victim_y != hitter->y)	987	if (victim->x != hitter->x || victim->y != hitter->y)
1018	{	988	{
1019	remove_ob (hitter);	989	hitter->remove ();
1020	hitter->x = victim_x;	990	hitter->x = victim->x;
1021	hitter->y = victim_y;	991	hitter->y = victim->y;
1022	insert_ob_in_map (hitter, victim->map, hitter, 0);	992	insert_ob_in_map (hitter, victim->map, hitter, 0);
1023	}	993	}
1024	else	994	else
1025	{
1026	/* Else leave arrow where it is */	995	/* Else leave arrow where it is */
1027	merge_ob (hitter, NULL);	996	merge_ob (hitter, NULL);
1028	}	997
1029	return NULL;	998	return 0;
1030	}	999	}
1031		1000
1032	if (hit_something && op->speed >= 10.0)	1001	if (hit_something && op->speed >= 10.0)
1033	op->speed -= 1.0;	1002	op->speed -= 1.0;
1034		1003
1035	/* Missile missed victim - reassemble missile */	1004	/* Missile missed victim - reassemble missile */
1036	if (container)	1005	if (container)
1037	{	1006	{
1038	remove_ob (hitter);	1007	hitter->remove ();
1039	insert_ob_in_ob (hitter, container);	1008	insert_ob_in_ob (hitter, container);
1040	}	1009	}
		1010
1041	return op;	1011	return op;
1042	}	1012	}
1043		1013
1044		1014
1045	void	1015	void
…		…
1054	}	1024	}
1055	else if (!GET_ANIM_ID (op))	1025	else if (!GET_ANIM_ID (op))
1056	{	1026	{
1057	/* Object has been called - no animations, so remove it */	1027	/* Object has been called - no animations, so remove it */
1058	if (op->stats.hp < 0)	1028	if (op->stats.hp < 0)
		1029	op->destroy ();
1059	{	1030
1060	remove_ob (op); /* Should update LOS */
1061	free_object (op);
1062	/* Don't know why this is here - remove_ob should do it for us */
1063	/*update_position(m, x, y); */
1064	}
1065	return; /* no animations, so nothing more to do */	1031	return; /* no animations, so nothing more to do */
1066	}	1032	}
		1033
1067	perc = NUM_ANIMATIONS (op) - ((int) NUM_ANIMATIONS (op) * op->stats.hp) / op->stats.maxhp;	1034	perc = NUM_ANIMATIONS (op) - ((int) NUM_ANIMATIONS (op) * op->stats.hp) / op->stats.maxhp;
		1035
1068	if (perc >= (int) NUM_ANIMATIONS (op))	1036	if (perc >= (int) NUM_ANIMATIONS (op))
1069	perc = NUM_ANIMATIONS (op) - 1;	1037	perc = NUM_ANIMATIONS (op) - 1;
1070	else if (perc < 1)	1038	else if (perc < 1)
1071	perc = 1;	1039	perc = 1;
		1040
1072	SET_ANIMATION (op, perc);	1041	SET_ANIMATION (op, perc);
1073	update_object (op, UP_OBJ_FACE);	1042	update_object (op, UP_OBJ_FACE);
		1043
1074	if (perc == NUM_ANIMATIONS (op) - 1)	1044	if (perc == NUM_ANIMATIONS (op) - 1)
1075	{ /* Reached the last animation */	1045	{ /* Reached the last animation */
1076	if (op->face == blank_face)	1046	if (op->face == blank_face)
1077	{
1078	/* If the last face is blank, remove the ob */	1047	/* If the last face is blank, remove the ob */
1079	remove_ob (op); /* Should update LOS */	1048	op->destroy ();
1080	free_object (op);
1081
1082	/* remove_ob should call update_position for us */
1083	/*update_position(m, x, y); */
1084
1085	}
1086	else	1049	else
1087	{ /* The last face was not blank, leave an image */	1050	{ /* The last face was not blank, leave an image */
1088	CLEAR_FLAG (op, FLAG_BLOCKSVIEW);	1051	CLEAR_FLAG (op, FLAG_BLOCKSVIEW);
1089	update_all_los (op->map, op->x, op->y);	1052	update_all_los (op->map, op->x, op->y);
1090	op->move_block = 0;	1053	op->move_block = 0;
…		…
1094	}	1057	}
1095		1058
1096	void	1059	void
1097	scare_creature (object *target, object *hitter)	1060	scare_creature (object *target, object *hitter)
1098	{	1061	{
1099	object *owner = get_owner (hitter);	1062	object *owner = hitter->owner;
1100		1063
1101	if (!owner)	1064	if (!owner)
1102	owner = hitter;	1065	owner = hitter;
1103		1066
1104	SET_FLAG (target, FLAG_SCARED);	1067	SET_FLAG (target, FLAG_SCARED);
…		…
1111	* appropriate attacktype. Only 1 attacktype should be set at a time.	1074	* appropriate attacktype. Only 1 attacktype should be set at a time.
1112	* This doesn't damage the player, but returns how much it should	1075	* This doesn't damage the player, but returns how much it should
1113	* take. However, it will do other effects (paralyzation, slow, etc.)	1076	* take. However, it will do other effects (paralyzation, slow, etc.)
1114	* Note - changed for PR code - we now pass the attack number and not	1077	* Note - changed for PR code - we now pass the attack number and not
1115	* the attacktype. Makes it easier for the PR code. */	1078	* the attacktype. Makes it easier for the PR code. */
1116
1117	int	1079	int
1118	hit_player_attacktype (object *op, object *hitter, int dam, uint32 attacknum, int magic)	1080	hit_player_attacktype (object *op, object *hitter, int dam, uint32 attacknum, int magic)
1119	{	1081	{
1120
1121	int doesnt_slay = 1;	1082	int doesnt_slay = 1;
1122		1083
1123	/* Catch anyone that may be trying to send us a bitmask instead of the number */	1084	/* Catch anyone that may be trying to send us a bitmask instead of the number */
1124	if (attacknum >= NROFATTACKS)	1085	if (attacknum >= NROFATTACKS)
1125	{	1086	{
…		…
1127	return 0;	1088	return 0;
1128	}	1089	}
1129		1090
1130	if (dam < 0)	1091	if (dam < 0)
1131	{	1092	{
1132	LOG (llevError, "hit_player_attacktype called with negative damage: %d\n", dam);	1093	LOG (llevError, "hit_player_attacktype called with negative damage %d (hitter %s, target %s)\n", dam, hitter->debug_desc (), op->debug_desc2 ());
1133	return 0;	1094	return 0;
1134	}	1095	}
1135		1096
1136	/* AT_INTERNAL is supposed to do exactly dam. Put a case here so	1097	/* AT_INTERNAL is supposed to do exactly dam. Put a case here so
1137	* people can't mess with that or it otherwise get confused. */	1098	* people can't mess with that or it otherwise get confused. */
…		…
1170		1131
1171	/* Keep this in order - makes things easier to find */	1132	/* Keep this in order - makes things easier to find */
1172		1133
1173	switch (attacknum)	1134	switch (attacknum)
1174	{	1135	{
1175	case ATNR_PHYSICAL:	1136	case ATNR_PHYSICAL:
1176	/* here also check for diseases */	1137	/* here also check for diseases */
1177	check_physically_infect (op, hitter);	1138	check_physically_infect (op, hitter);
1178	break;	1139	break;
1179		1140
1180	/* Don't need to do anything for:	1141	/* Don't need to do anything for:
1181	magic,	1142	magic,
1182	fire,	1143	fire,
1183	electricity,	1144	electricity,
1184	cold */	1145	cold */
1185		1146
1186	case ATNR_CONFUSION:	1147	case ATNR_CONFUSION:
1187	case ATNR_POISON:	1148	case ATNR_POISON:
1188	case ATNR_SLOW:	1149	case ATNR_SLOW:
1189	case ATNR_PARALYZE:	1150	case ATNR_PARALYZE:
1190	case ATNR_FEAR:	1151	case ATNR_FEAR:
1191	case ATNR_CANCELLATION:	1152	case ATNR_CANCELLATION:
1192	case ATNR_DEPLETE:	1153	case ATNR_DEPLETE:
1193	case ATNR_BLIND:	1154	case ATNR_BLIND:
1194	{	1155	{
1195	/* chance for inflicting a special attack depends on the	1156	/* chance for inflicting a special attack depends on the
1196	* difference between attacker's and defender's level	1157	* difference between attacker's and defender's level
1197	*/	1158	*/
1198	int level_diff = MIN (110, MAX (0, op->level - hitter->level));	1159	int level_diff = MIN (110, MAX (0, op->level - hitter->level));
1199		1160
1200	/* First, only creatures/players with speed can be affected.	1161	/* First, only creatures/players with speed can be affected.
1201	* Second, just getting hit doesn't mean it always affects	1162	* Second, just getting hit doesn't mean it always affects
1202	* you. Third, you still get a saving through against the	1163	* you. Third, you still get a saving through against the
1203	* effect.	1164	* effect.
1204	*/	1165	*/
1205	if (op->speed &&	1166	if (op->speed &&
1206	(QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) &&	1167	(QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) &&
1207	!(rndm (0, (attacknum == ATNR_SLOW ? 6 : 3) - 1)) && !did_make_save (op, level_diff, op->resist[attacknum] / 10))	1168	!(rndm (0, (attacknum == ATNR_SLOW ? 6 : 3) - 1)) && !did_make_save (op, level_diff, op->resist[attacknum] / 10))
1208	{	1169	{
1209		1170
1210	/* Player has been hit by something */	1171	/* Player has been hit by something */
1211	if (attacknum == ATNR_CONFUSION)	1172	if (attacknum == ATNR_CONFUSION)
1212	confuse_player (op, hitter, dam);	1173	confuse_player (op, hitter, dam);
1213	else if (attacknum == ATNR_POISON)	1174	else if (attacknum == ATNR_POISON)
1214	poison_player (op, hitter, dam);	1175	poison_player (op, hitter, dam);
1215	else if (attacknum == ATNR_SLOW)	1176	else if (attacknum == ATNR_SLOW)
1216	slow_player (op, hitter, dam);	1177	slow_player (op, hitter, dam);
1217	else if (attacknum == ATNR_PARALYZE)	1178	else if (attacknum == ATNR_PARALYZE)
1218	paralyze_player (op, hitter, dam);	1179	paralyze_player (op, hitter, dam);
1219	else if (attacknum == ATNR_FEAR)	1180	else if (attacknum == ATNR_FEAR)
1220	scare_creature (op, hitter);	1181	scare_creature (op, hitter);
1221	else if (attacknum == ATNR_CANCELLATION)	1182	else if (attacknum == ATNR_CANCELLATION)
1222	cancellation (op);	1183	cancellation (op);
1223	else if (attacknum == ATNR_DEPLETE)	1184	else if (attacknum == ATNR_DEPLETE)
1224	drain_stat (op);	1185	op->drain_stat ();
1225	else if (attacknum == ATNR_BLIND && !QUERY_FLAG (op, FLAG_UNDEAD) && !QUERY_FLAG (op, FLAG_GENERATOR))	1186	else if (attacknum == ATNR_BLIND && !QUERY_FLAG (op, FLAG_UNDEAD) && !QUERY_FLAG (op, FLAG_GENERATOR))
1226	blind_player (op, hitter, dam);	1187	blind_player (op, hitter, dam);
1227	}	1188	}
1228	dam = 0; /* These are all effects and don't do real damage */	1189	dam = 0; /* These are all effects and don't do real damage */
1229	}	1190	}
1230	break;	1191	break;
		1192
1231	case ATNR_ACID:	1193	case ATNR_ACID:
1232	{	1194	{
1233	int flag = 0;	1195	int flag = 0;
1234		1196
1235	/* Items only get corroded if you're not on a battleground and	1197	/* Items only get corroded if you're not on a battleground and
1236	* if your acid resistance is below 50%. */	1198	* if your acid resistance is below 50%. */
1237	if (!op_on_battleground (op, NULL, NULL) && (op->resist[ATNR_ACID] < 50))	1199	if (!op_on_battleground (op, NULL, NULL) && (op->resist[ATNR_ACID] < 50))
1238	{	1200	{
1239	object *tmp;
1240
1241	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	1201	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1242	{	1202	{
1243	if (tmp->invisible)	1203	if (tmp->invisible)
1244	continue;	1204	continue;
1245	if (!QUERY_FLAG (tmp, FLAG_APPLIED) || (tmp->resist[ATNR_ACID] >= 10))	1205	if (!QUERY_FLAG (tmp, FLAG_APPLIED) || (tmp->resist[ATNR_ACID] >= 10))
1246	/* >= 10% acid res. on itmes will protect these */	1206	/* >= 10% acid res. on items will protect these */
1247	continue;	1207	continue;
1248	if (!(tmp->material & M_IRON))	1208	if (!(tmp->material & M_IRON))
1249	continue;	1209	continue;
1250	if (tmp->magic < -4) /* Let's stop at -5 */	1210	if (tmp->magic < -4) /* Let's stop at -5 */
1251	continue;	1211	continue;
1252	if (tmp->type == RING ||	1212	if (tmp->type == RING
1253	/* removed boots and gloves from exclusion list in	1213	/* removed boots and gloves from exclusion list in PR */
1254	PR */	1214	|| tmp->type == GIRDLE
1255	tmp->type == GIRDLE || tmp->type == AMULET || tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)	1215	|| tmp->type == AMULET
		1216	|| tmp->type == WAND
		1217	|| tmp->type == ROD
		1218	|| tmp->type == HORN)
1256	continue; /* To avoid some strange effects */	1219	continue; /* To avoid some strange effects */
1257		1220
1258	/* High damage acid has better chance of corroding	1221	/* High damage acid has better chance of corroding
1259	objects */	1222	objects */
1260	if (rndm (0, dam + 4) > random_roll (0, 39, op, PREFER_HIGH) + 2 * tmp->magic)	1223	if (rndm (0, dam + 4) > random_roll (0, 39, op, PREFER_HIGH) + 2 * tmp->magic)
1261	{	1224	{
1262	if (op->type == PLAYER)	1225	if (op->type == PLAYER)
1263	/* Make this more visible */	1226	/* Make this more visible */
1264	new_draw_info_format (NDI_UNIQUE | NDI_RED, 0, op,	1227	new_draw_info_format (NDI_UNIQUE | NDI_RED, 0, op,
1265	"The %s's acid corrodes your %s!", query_name (hitter), query_name (tmp));	1228	"The %s's acid corrodes your %s!", query_name (hitter), query_name (tmp));
1266	flag = 1;	1229	flag = 1;
1267	tmp->magic--;	1230	tmp->magic--;
1268	if (op->type == PLAYER)	1231	if (op->type == PLAYER)
1269	esrv_send_item (op, tmp);	1232	esrv_send_item (op, tmp);
1270	}	1233	}
1271	}	1234	}
1272	if (flag)
1273	fix_player (op); /* Something was corroded */
1274	}	1235
		1236	if (flag)
		1237	op->update_stats (); /* Something was corroded */
1275	}	1238	}
		1239	}
1276	break;	1240	break;
		1241
1277	case ATNR_DRAIN:	1242	case ATNR_DRAIN:
1278	{	1243	{
1279	/* rate is the proportion of exp drained. High rate means	1244	/* rate is the proportion of exp drained. High rate means
1280	* not much is drained, low rate means a lot is drained.	1245	* not much is drained, low rate means a lot is drained.
1281	*/	1246	*/
1282	int rate;	1247	int rate;
1283		1248
1284	if (op->resist[ATNR_DRAIN] >= 0)	1249	if (op->resist[ATNR_DRAIN] >= 0)
1285	rate = 400 + op->resist[ATNR_DRAIN] * 3;	1250	rate = 400 + op->resist[ATNR_DRAIN] * 3;
1286	else	1251	else
1287	rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);	1252	rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);
1288		1253
1289	if (op->stats.exp <= rate)	1254	if (op->stats.exp <= rate)
1290	{	1255	{
1291	if (op->type == GOLEM)	1256	if (op->type == GOLEM)
1292	dam = 999; /* Its force is "sucked" away. 8) */	1257	dam = 999; /* Its force is "sucked" away. 8) */
1293	else	1258	else
1294	/* If we can't drain, lets try to do physical damage */	1259	/* If we can't drain, lets try to do physical damage */
1295	dam = hit_player_attacktype (op, hitter, dam, ATNR_PHYSICAL, magic);	1260	dam = hit_player_attacktype (op, hitter, dam, ATNR_PHYSICAL, magic);
1296	}	1261	}
1297	else	1262	else
1298	{	1263	{
1299	/* Randomly give the hitter some hp */	1264	/* Randomly give the hitter some hp */
1300	if (hitter->stats.hp < hitter->stats.maxhp &&	1265	if (hitter->stats.hp < hitter->stats.maxhp &&
1301	(op->level > hitter->level) && random_roll (0, (op->level - hitter->level + 2), hitter, PREFER_HIGH) > 3)	1266	(op->level > hitter->level) && random_roll (0, (op->level - hitter->level + 2), hitter, PREFER_HIGH) > 3)
1302	hitter->stats.hp++;	1267	hitter->stats.hp++;
1303		1268
1304	/* Can't do drains on battleground spaces.	1269	/* Can't do drains on battleground spaces.
1305	* Move the wiz check up here - before, the hitter wouldn't gain exp	1270	* Move the wiz check up here - before, the hitter wouldn't gain exp
1306	* exp, but the wiz would still lose exp! If drainee is a wiz,	1271	* exp, but the wiz would still lose exp! If drainee is a wiz,
1307	* nothing happens.	1272	* nothing happens.
1308	* Try to credit the owner. We try to display player -> player drain	1273	* Try to credit the owner. We try to display player -> player drain
1309	* attacks, hence all the != PLAYER checks.	1274	* attacks, hence all the != PLAYER checks.
1310	*/	1275	*/
1311	if (!op_on_battleground (hitter, NULL, NULL) && !QUERY_FLAG (op, FLAG_WAS_WIZ))	1276	if (!op_on_battleground (hitter, NULL, NULL) && !QUERY_FLAG (op, FLAG_WAS_WIZ))
1312	{	1277	{
1313	object *owner = get_owner (hitter);	1278	object *owner = hitter->owner;
1314		1279
1315	if (owner && owner != hitter)	1280	if (owner && owner != hitter)
1316	{	1281	{
1317	if (op->type != PLAYER || owner->type != PLAYER)	1282	if (op->type != PLAYER || owner->type != PLAYER)
1318	change_exp (owner, op->stats.exp / (rate * 2),	1283	change_exp (owner, op->stats.exp / (rate * 2),
1319	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, SK_EXP_TOTAL);	1284	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, SK_EXP_TOTAL);
1320	}	1285	}
1321	else if (op->type != PLAYER || hitter->type != PLAYER)	1286	else if (op->type != PLAYER || hitter->type != PLAYER)
1322	{	1287	{
1323	change_exp (hitter, op->stats.exp / (rate * 2),	1288	change_exp (hitter, op->stats.exp / (rate * 2),
1324	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, 0);	1289	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, 0);
1325	}	1290	}
1326	change_exp (op, -op->stats.exp / rate, NULL, 0);	1291	change_exp (op, -op->stats.exp / rate, NULL, 0);
1327	}	1292	}
		1293
1328	dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure	1294	dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure
1329	* drain attack, you won't know that you are actually sucking out EXP,	1295	* drain attack, you won't know that you are actually sucking out EXP,
1330	* as the messages will say you missed	1296	* as the messages will say you missed
1331	*/	1297	*/
1332	}	1298	}
1333	}	1299	}
1334	break;	1300	break;
		1301
1335	case ATNR_TURN_UNDEAD:	1302	case ATNR_TURN_UNDEAD:
1336	{	1303	{
1337	if (QUERY_FLAG (op, FLAG_UNDEAD))	1304	if (QUERY_FLAG (op, FLAG_UNDEAD))
1338	{	1305	{
1339	object *owner = hitter->owner ? (object *)hitter->owner : hitter;	1306	object *owner = hitter->owner ? (object *)hitter->owner : hitter;
1340	object *god = find_god (determine_god (owner));	1307	object *god = find_god (determine_god (owner));
1341	int div = 1;	1308	int div = 1;
1342		1309
1343	/* if undead are not an enemy of your god, you turn them	1310	/* if undead are not an enemy of your god, you turn them
1344	* at half strength */	1311	* at half strength */
1345	if (!god || !god->slaying || strstr (god->slaying, undead_name) == NULL)	1312	if (!god || !god->slaying || strstr (god->slaying, undead_name) == NULL)
1346	div = 2;	1313	div = 2;
1347	/* Give a bonus if you resist turn undead */	1314	/* Give a bonus if you resist turn undead */
1348	if (op->level * div < (turn_bonus[owner->stats.Wis] + owner->level + (op->resist[ATNR_TURN_UNDEAD] / 100)))	1315	if (op->level * div < (turn_bonus[owner->stats.Wis] + owner->level + (op->resist[ATNR_TURN_UNDEAD] / 100)))
1349	scare_creature (op, owner);	1316	scare_creature (op, owner);
1350	}	1317	}
1351	else	1318	else
1352	dam = 0; /* don't damage non undead - should we damage	1319	dam = 0; /* don't damage non undead - should we damage
1353	undead? */	1320	undead? */
1354	}	1321	}
1355	break;	1322	break;
		1323
1356	case ATNR_DEATH:	1324	case ATNR_DEATH:
1357	deathstrike_player (op, hitter, &dam);	1325	deathstrike_player (op, hitter, &dam);
1358	break;	1326	break;
		1327
1359	case ATNR_CHAOS:	1328	case ATNR_CHAOS:
1360	LOG (llevError, "%s was hit by %s with non-specific chaos.\n", query_name (op), query_name (hitter));	1329	LOG (llevError, "%s was hit by %s with non-specific chaos.\n", op->debug_desc (), hitter->debug_desc2 ());
1361	dam = 0;	1330	dam = 0;
1362	break;	1331	break;
		1332
1363	case ATNR_COUNTERSPELL:	1333	case ATNR_COUNTERSPELL:
1364	LOG (llevError, "%s was hit by %s with counterspell attack.\n", query_name (op), query_name (hitter));	1334	LOG (llevError, "%s was hit by %s with counterspell attack.\n", op->debug_desc (), hitter->debug_desc2 ());
1365	dam = 0;	1335	dam = 0;
1366	/* This should never happen. Counterspell is handled	1336	/* This should never happen. Counterspell is handled
1367	* seperately and filtered out. If this does happen,	1337	* seperately and filtered out. If this does happen,
1368	* Counterspell has no effect on anything but spells, so it	1338	* Counterspell has no effect on anything but spells, so it
1369	* does no damage. */	1339	* does no damage. */
1370	break;	1340	break;
		1341
1371	case ATNR_HOLYWORD:	1342	case ATNR_HOLYWORD:
1372	{	1343	{
1373	/* This has already been handled by hit_player,	1344	/* This has already been handled by hit_player,
1374	* no need to check twice -- DAMN */	1345	* no need to check twice -- DAMN */
1375	object *owner = hitter->owner ? (object *)hitter->owner : hitter;	1346	object *owner = hitter->owner ? (object *)hitter->owner : hitter;
1376		1347
1377	/* As with turn undead above, give a bonus on the saving throw */	1348	/* As with turn undead above, give a bonus on the saving throw */
1378	if ((op->level + (op->resist[ATNR_HOLYWORD] / 100)) < owner->level + turn_bonus[owner->stats.Wis])	1349	if ((op->level + (op->resist[ATNR_HOLYWORD] / 100)) < owner->level + turn_bonus[owner->stats.Wis])
1379	scare_creature (op, owner);	1350	scare_creature (op, owner);
1380	}	1351	}
1381	break;	1352	break;
		1353
1382	case ATNR_LIFE_STEALING:	1354	case ATNR_LIFE_STEALING:
1383	{	1355	{
1384	int new_hp;	1356	int new_hp;
1385		1357
1386	/* this is replacement to drain for players, instead of taking	1358	/* this is replacement to drain for players, instead of taking
1387	* exp it takes hp. It is geared for players, probably not	1359	* exp it takes hp. It is geared for players, probably not
1388	* much use giving it to monsters	1360	* much use giving it to monsters
1389	*	1361	*
1390	* life stealing doesn't do a lot of damage, but it gives the	1362	* life stealing doesn't do a lot of damage, but it gives the
1391	* damage it does do to the player. Given that,	1363	* damage it does do to the player. Given that,
1392	* it only does 1/10'th normal damage (hence the divide by	1364	* it only does 1/10'th normal damage (hence the divide by
1393	* 1000).	1365	* 1000).
1394	*/	1366	*/
1395	/* You can't steal life from something undead */	1367	/* You can't steal life from something undead */
1396	if ((op->type == GOLEM) || (QUERY_FLAG (op, FLAG_UNDEAD)))	1368	if ((op->type == GOLEM) || (QUERY_FLAG (op, FLAG_UNDEAD)))
1397	return 0;	1369	return 0;
		1370
1398	/* If drain protection is higher than life stealing, use that */	1371	/* If drain protection is higher than life stealing, use that */
1399	if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])	1372	if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])
1400	dam = (dam * (100 - op->resist[ATNR_DRAIN])) / 3000;	1373	dam = (dam * (100 - op->resist[ATNR_DRAIN])) / 3000;
1401	else	1374	else
1402	dam = (dam * (100 - op->resist[ATNR_LIFE_STEALING])) / 3000;	1375	dam = (dam * (100 - op->resist[ATNR_LIFE_STEALING])) / 3000;
		1376
1403	/* You die at -1 hp, not zero. */	1377	/* You die at -1 hp, not zero. */
1404	if (dam > (op->stats.hp + 1))	1378	if (dam > (op->stats.hp + 1))
1405	dam = op->stats.hp + 1;	1379	dam = op->stats.hp + 1;
		1380
1406	new_hp = hitter->stats.hp + dam;	1381	new_hp = hitter->stats.hp + dam;
1407	if (new_hp > hitter->stats.maxhp)	1382	if (new_hp > hitter->stats.maxhp)
1408	new_hp = hitter->stats.maxhp;	1383	new_hp = hitter->stats.maxhp;
		1384
1409	if (new_hp > hitter->stats.hp)	1385	if (new_hp > hitter->stats.hp)
1410	hitter->stats.hp = new_hp;	1386	hitter->stats.hp = new_hp;
1411	}	1387	}
1412	}	1388	}
		1389
1413	return dam;	1390	return dam;
1414	}	1391	}
1415
1416		1392
1417	/* GROS: This code comes from hit_player. It has been made external to	1393	/* GROS: This code comes from hit_player. It has been made external to
1418	* allow script procedures to "kill" objects in a combat-like fashion.	1394	* allow script procedures to "kill" objects in a combat-like fashion.
1419	* It was initially used by (kill-object) developed for the Collector's	1395	* It was initially used by (kill-object) developed for the Collector's
1420	* Sword. Note that nothing has been changed from the original version	1396	* Sword. Note that nothing has been changed from the original version
…		…
1455	if (QUERY_FLAG (op, FLAG_BLOCKSVIEW))	1431	if (QUERY_FLAG (op, FLAG_BLOCKSVIEW))
1456	update_all_los (op->map, op->x, op->y); /* makes sure los will be recalculated */	1432	update_all_los (op->map, op->x, op->y); /* makes sure los will be recalculated */
1457		1433
1458	if (op->type == DOOR)	1434	if (op->type == DOOR)
1459	{	1435	{
1460	op->speed = 0.1;	1436	op->set_speed (0.1);
1461	update_ob_speed (op);
1462	op->speed_left = -0.05;	1437	op->speed_left = -0.05;
1463	return maxdam;	1438	return maxdam;
1464	}	1439	}
		1440
1465	if (QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER)	1441	if (QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER)
1466	{	1442	{
1467	remove_friendly_object (op);	1443	remove_friendly_object (op);
		1444
1468	if (get_owner (op) != NULL && op->owner->type == PLAYER && op->owner->contr->ranges[range_golem] == op)	1445	if (op->owner && op->owner->type == PLAYER && op->owner->contr->ranges[range_golem] == op)
1469	{
1470	op->owner->contr->ranges[range_golem] = NULL;	1446	op->owner->contr->ranges[range_golem] = 0;
1471	op->owner->contr->golem_count = 0;
1472	}
1473		1447
1474	remove_ob (op);	1448	op->destroy ();
1475	free_object (op);
1476	return maxdam;	1449	return maxdam;
1477	}	1450	}
1478		1451
1479	/* Now lets start dealing with experience we get for killing something */	1452	/* Now lets start dealing with experience we get for killing something */
1480		1453
1481	owner = get_owner (hitter);	1454	owner = hitter->owner;
1482	if (owner == NULL)	1455	if (!owner)
1483	owner = hitter;	1456	owner = hitter;
1484		1457
1485	/* is the victim (op) standing on battleground? */	1458	/* is the victim (op) standing on battleground? */
1486	if (op_on_battleground (op, NULL, NULL))	1459	if (op_on_battleground (op, NULL, NULL))
1487	battleg = 1;	1460	battleg = 1;
…		…
1507	char buf[256];	1480	char buf[256];
1508		1481
1509	tmv = localtime (&t);	1482	tmv = localtime (&t);
1510	strftime (buf, 256, "%a %b %d %H:%M:%S %Y", tmv);	1483	strftime (buf, 256, "%a %b %d %H:%M:%S %Y", tmv);
1511		1484
1512	LOG (llevInfo, "%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n", buf, &owner->name, owner->contr->socket.host, query_name (op));	1485	LOG (llevInfo, "%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n", buf, &owner->name, owner->contr->ns->host, query_name (op));
1513	}	1486	}
1514		1487
1515	/* try to filter some things out - basically, if you are	1488	/* try to filter some things out - basically, if you are
1516	* killing a level 1 creature and your level 20, you	1489	* killing a level 1 creature and your level 20, you
1517	* probably don't want to see that.	1490	* probably don't want to see that.
1518	*/	1491	*/
1519	if (owner->level < op->level * 2 || op->stats.exp > 1000)	1492	if (owner->level < op->level * 2 || op->stats.exp > 1000)
1520	{	1493	{
1521	if (owner != hitter)	1494	if (owner != hitter)
1522	{
1523	new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s with %s.", query_name (op), query_name (hitter));	1495	new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s with %s.", query_name (op), query_name (hitter));
1524	}
1525	else	1496	else
1526	{
1527	new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s.", query_name (op));	1497	new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s.", query_name (op));
1528	}	1498
1529	/* Only play sounds for melee kills */	1499	/* Only play sounds for melee kills */
1530	if (hitter->type == PLAYER)	1500	if (hitter->type == PLAYER)
1531	play_sound_map (owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS);	1501	play_sound_map (owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS);
1532	}	1502	}
1533		1503
…		…
1538	* player that the object belonged to - so if you killed another player	1508	* player that the object belonged to - so if you killed another player
1539	* with spells, pets, whatever, there was no penalty.	1509	* with spells, pets, whatever, there was no penalty.
1540	* Changed to make luck penalty configurable in settings.	1510	* Changed to make luck penalty configurable in settings.
1541	*/	1511	*/
1542	if (op->type == PLAYER && owner != op && !battleg)	1512	if (op->type == PLAYER && owner != op && !battleg)
1543	change_luck (owner, -settings.pk_luck_penalty);	1513	owner->change_luck (-settings.pk_luck_penalty);
1544		1514
1545	/* This code below deals with finding the appropriate skill	1515	/* This code below deals with finding the appropriate skill
1546	* to credit exp to. This is a bit problematic - we should	1516	* to credit exp to. This is a bit problematic - we should
1547	* probably never really have to look at current_weapon->skill	1517	* probably never really have to look at current_weapon->skill
1548	*/	1518	*/
1549	skill = NULL;	1519	skill = 0;
		1520
1550	if (hitter->skill && hitter->type != PLAYER)	1521	if (hitter->skill && hitter->type != PLAYER)
1551	skill = hitter->skill;	1522	skill = hitter->skill;
1552	else if (owner->chosen_skill)	1523	else if (owner->chosen_skill)
1553	{	1524	{
1554	skill = owner->chosen_skill->skill;	1525	skill = owner->chosen_skill->skill;
…		…
1573	break;	1544	break;
1574	}	1545	}
1575	}	1546	}
1576	} /* Was it a player that hit somethign */	1547	} /* Was it a player that hit somethign */
1577	else	1548	else
1578	{
1579	skill = NULL;	1549	skill = 0;
1580	}
1581		1550
1582	/* Pet (or spell) killed something. */	1551	/* Pet (or spell) killed something. */
1583	if (owner != hitter)	1552	if (owner != hitter)
1584	{
1585	(void) sprintf (buf, "%s killed %s with %s%s%s.", &owner->name,	1553	sprintf (buf, "%s killed %s with %s%s%s.", &owner->name,
1586	query_name (op), query_name (hitter), battleg ? " (duel)" : "", pk ? " (pk)" : "");	1554	query_name (op), query_name (hitter), battleg ? " (duel)" : "", pk ? " (pk)" : "");
1587	}
1588	else	1555	else
1589	{
1590	(void) sprintf (buf, "%s killed %s%s%s%s.", &hitter->name, &op->name,	1556	sprintf (buf, "%s killed %s%s%s%s.", &hitter->name, &op->name,
1591	(QUERY_FLAG (hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?	1557	(QUERY_FLAG (hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?
1592	" in hand to hand combat" : "", battleg ? " (duel)" : "", pk ? " (pk)" : "");	1558	" in hand to hand combat" : "", battleg ? " (duel)" : "", pk ? " (pk)" : "");
1593	}	1559
1594	/* These may have been set in the player code section above */	1560	/* These may have been set in the player code section above */
1595	if (!skop)	1561	if (!skop)
1596	skop = hitter->chosen_skill;	1562	skop = hitter->chosen_skill;
		1563
1597	if (!skill && skop)	1564	if (!skill && skop)
1598	skill = skop->skill;	1565	skill = skop->skill;
1599		1566
1600	new_draw_info (NDI_ALL, op->type == PLAYER ? 1 : 10, NULL, buf);	1567	new_draw_info (NDI_ALL, op->type == PLAYER ? 1 : 10, NULL, buf);
1601		1568
1602
1603	/* If you didn't kill yourself, and your not the wizard */	1569	/* If you didn't kill yourself, and your not the wizard */
1604	if (owner != op && !QUERY_FLAG (op, FLAG_WAS_WIZ))	1570	if (owner != op && !QUERY_FLAG (op, FLAG_WAS_WIZ))
1605	{	1571	{
1606	int exp;	1572	int exp;
1607		1573
1608	/* Really don't give much experience for killing other players */	1574	/* Really don't give much experience for killing other players */
1609	// schmorp: temporary? reduce the amount of exp gained for pking enourmously	1575	// schmorp: temporarily? reduce the amount of exp gained for pking enourmously
1610	if (op->type == PLAYER)	1576	if (op->type == PLAYER)
1611	{	1577	{
1612	if (battleg)	1578	if (battleg)
1613	{	1579	{
1614	new_draw_info (NDI_UNIQUE, 0, owner, "Your foe has fallen!");	1580	new_draw_info (NDI_UNIQUE, 0, owner, "Your foe has fallen!");
…		…
1632		1598
1633	if (!settings.simple_exp)	1599	if (!settings.simple_exp)
1634	exp = exp / 2;	1600	exp = exp / 2;
1635		1601
1636	if (owner->type != PLAYER || owner->contr->party == NULL)	1602	if (owner->type != PLAYER || owner->contr->party == NULL)
1637	{
1638	change_exp (owner, exp, skill, 0);	1603	change_exp (owner, exp, skill, 0);
1639	}
1640	else	1604	else
1641	{	1605	{
1642	int shares = 0, count = 0;	1606	int shares = 0, count = 0;
1643
1644	player *pl;	1607	player *pl;
1645
1646	partylist *party = owner->contr->party;	1608	partylist *party = owner->contr->party;
1647		1609
1648	#ifdef PARTY_KILL_LOG
1649	add_kill_to_party (party, query_name (owner), query_name (op), exp);	1610	add_kill_to_party (party, query_name (owner), query_name (op), exp);
1650	#endif	1611
1651	for (pl = first_player; pl != NULL; pl = pl->next)	1612	for_all_players (pl)
1652	{
1653	if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))	1613	if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))
1654	{	1614	{
1655	count++;	1615	count++;
1656	shares += (pl->ob->level + 4);	1616	shares += (pl->ob->level + 4);
1657	}	1617	}
1658	}	1618
1659	if (count == 1 || shares > exp)	1619	if (count == 1 || shares > exp || !shares)
1660	change_exp (owner, exp, skill, SK_EXP_TOTAL);	1620	change_exp (owner, exp, skill, SK_EXP_TOTAL);
1661	else	1621	else
1662	{	1622	{
1663	int share = exp / shares, given = 0, nexp;	1623	int share = exp / shares, given = 0, nexp;
1664		1624
1665	for (pl = first_player; pl != NULL; pl = pl->next)	1625	for_all_players (pl)
1666	{
1667	if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))	1626	if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))
1668	{	1627	{
1669	nexp = (pl->ob->level + 4) * share;	1628	nexp = (pl->ob->level + 4) * share;
1670	change_exp (pl->ob, nexp, skill, SK_EXP_TOTAL);	1629	change_exp (pl->ob, nexp, skill, SK_EXP_TOTAL);
1671	given += nexp;	1630	given += nexp;
1672	}	1631	}
1673	}	1632
1674	exp -= given;	1633	exp -= given;
1675	/* give any remainder to the player */	1634	/* give any remainder to the player */
1676	change_exp (owner, exp, skill, SK_EXP_ADD_SKILL);	1635	change_exp (owner, exp, skill, SK_EXP_ADD_SKILL);
1677	}	1636	}
1678	} /* else part of a party */	1637	} /* else part of a party */
1679
1680	} /* end if person didn't kill himself */	1638	} /* end if person didn't kill himself */
1681		1639
1682	if (op->type != PLAYER)	1640	if (op->type != PLAYER)
1683	{	1641	{
1684	if (QUERY_FLAG (op, FLAG_FRIENDLY))	1642	if (QUERY_FLAG (op, FLAG_FRIENDLY))
1685	{	1643	{
1686	object *owner1 = get_owner (op);	1644	object *owner1 = op->owner;
1687		1645
1688	if (owner1 != NULL && owner1->type == PLAYER)	1646	if (owner1 && owner1->type == PLAYER)
1689	{	1647	{
1690	play_sound_player_only (owner1->contr, SOUND_PET_IS_KILLED, 0, 0);	1648	play_sound_player_only (owner1->contr, SOUND_PET_IS_KILLED, 0, 0);
1691	/* Maybe we should include the owner that killed this, maybe not */	1649	/* Maybe we should include the owner that killed this, maybe not */
1692	new_draw_info_format (NDI_UNIQUE, 0, owner1, "Your pet, the %s, is killed by %s.", &op->name, &hitter->name);	1650	new_draw_info_format (NDI_UNIQUE, 0, owner1, "Your pet, the %s, is killed by %s.", &op->name, &hitter->name);
1693	}	1651	}
1694		1652
1695	remove_friendly_object (op);	1653	remove_friendly_object (op);
1696	}	1654	}
1697		1655
1698	remove_ob (op);	1656	op->destroy ();
1699	free_object (op);
1700	}	1657	}
1701	/* Player has been killed! */
1702	else	1658	else
1703	{	1659	{
		1660	/* Player has been killed! */
1704	if (owner->type == PLAYER)	1661	if (owner->type == PLAYER)
1705	{
1706	snprintf (op->contr->killer, BIG_NAME, "%s the %s", &owner->name, owner->contr->title);	1662	snprintf (op->contr->killer, sizeof (op->contr->killer), "%s the %s", &owner->name, owner->contr->title);
1707	}
1708	else	1663	else
1709	assign (op->contr->killer, hitter->name);	1664	assign (op->contr->killer, hitter->name);
1710	}	1665	}
1711		1666
1712	/* This was return -1 - that doesn't seem correct - if we return -1, process	1667	/* This was return -1 - that doesn't seem correct - if we return -1, process
…		…
1736	return 0;	1691	return 0;
1737		1692
1738	if (hitter->type == PLAYER && hitter->contr->peaceful == 1)	1693	if (hitter->type == PLAYER && hitter->contr->peaceful == 1)
1739	return 1;	1694	return 1;
1740		1695
1741	if ((owner = get_owner (hitter)) != NULL)	1696	if ((owner = hitter->owner) != NULL)
1742	{	1697	{
1743	if (owner->type == PLAYER && owner->contr->peaceful == 1)	1698	if (owner->type == PLAYER && owner->contr->peaceful == 1)
1744	friendlyfire = 2;	1699	friendlyfire = 2;
1745	}	1700	}
1746		1701
…		…
1756	* is what is hitting the object, type is the attacktype, and	1711	* is what is hitting the object, type is the attacktype, and
1757	* full_hit is set if monster area does not matter.	1712	* full_hit is set if monster area does not matter.
1758	* dam is base damage - protections/vulnerabilities/slaying matches can	1713	* dam is base damage - protections/vulnerabilities/slaying matches can
1759	* modify it.	1714	* modify it.
1760	*/	1715	*/
1761
1762	/* Oct 95 - altered the following slightly for MULTIPLE_GODS hack	1716	/* Oct 95 - altered the following slightly for MULTIPLE_GODS hack
1763	* which needs new attacktype AT_HOLYWORD to work . b.t. */	1717	* which needs new attacktype AT_HOLYWORD to work . b.t. */
1764
1765	int	1718	int
1766	hit_player (object *op, int dam, object *hitter, int type, int full_hit)	1719	hit_player (object *op, int dam, object *hitter, int type, int full_hit)
1767	{	1720	{
1768	int maxdam = 0, ndam = 0, attacktype = 1, magic = (type & AT_MAGIC);	1721	int maxdam = 0, ndam = 0, attacktype = 1, magic = (type & AT_MAGIC);
1769	int maxattacktype, attacknum;	1722	int maxattacktype, attacknum;
1770	int body_attack = op && op->head; /* Did we hit op's head? */	1723	int body_attack = op && op->head; /* Did we hit op's head? */
1771	int simple_attack;	1724	int simple_attack;
1772	tag_t op_tag, hitter_tag;
1773	int rtn_kill = 0;	1725	int rtn_kill = 0;
1774	int friendlyfire;	1726	int friendlyfire;
1775		1727
1776	if (get_attack_mode (&op, &hitter, &simple_attack))	1728	if (get_attack_mode (&op, &hitter, &simple_attack))
1777	return 0;	1729	return 0;
…		…
1781	return 0;	1733	return 0;
1782		1734
1783	#ifdef PROHIBIT_PLAYERKILL	1735	#ifdef PROHIBIT_PLAYERKILL
1784	if (op->type == PLAYER)	1736	if (op->type == PLAYER)
1785	{	1737	{
1786	object *owner = get_owner (hitter);	1738	object *owner = hitter->owner;
1787		1739
1788	if (!owner)	1740	if (!owner)
1789	owner = hitter;	1741	owner = hitter;
		1742
1790	if (owner->type == PLAYER && (!op_on_battleground (op, 0, 0) && (op->contr->peaceful || owner->contr->peaceful)) && op != owner)	1743	if (owner->type == PLAYER && (!op_on_battleground (op, 0, 0) && (op->contr->peaceful || owner->contr->peaceful)) && op != owner)
1791	{
1792	return 0;	1744	return 0;
1793	}
1794	}	1745	}
1795	#endif	1746	#endif
1796
1797	op_tag = op->count;
1798	hitter_tag = hitter->count;
1799		1747
1800	if (body_attack)	1748	if (body_attack)
1801	{	1749	{
1802	/* slow and paralyze must hit the head. But we don't want to just	1750	/* slow and paralyze must hit the head. But we don't want to just
1803	* return - we still need to process other attacks the spell still	1751	* return - we still need to process other attacks the spell still
…		…
1809	* attack so we don't cancel out things like magic bullet.	1757	* attack so we don't cancel out things like magic bullet.
1810	*/	1758	*/
1811	if (type & (AT_PARALYZE | AT_SLOW))	1759	if (type & (AT_PARALYZE | AT_SLOW))
1812	{	1760	{
1813	type &= ~(AT_PARALYZE | AT_SLOW);	1761	type &= ~(AT_PARALYZE | AT_SLOW);
		1762
1814	if (!type || type == AT_MAGIC)	1763	if (!type || type == AT_MAGIC)
1815	return 0;	1764	return 0;
1816	}	1765	}
1817	}	1766	}
1818		1767
1819	if (!simple_attack && op->type == DOOR)	1768	if (!simple_attack && op->type == DOOR)
1820	{	1769	{
1821	object *tmp;
1822
1823	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	1770	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1824	if (tmp->type == RUNE || tmp->type == TRAP)	1771	if (tmp->type == RUNE || tmp->type == TRAP)
1825	{	1772	{
1826	spring_trap (tmp, hitter);	1773	spring_trap (tmp, hitter);
		1774
1827	if (was_destroyed (hitter, hitter_tag) || was_destroyed (op, op_tag) || abort_attack (op, hitter, simple_attack))	1775	if (hitter->destroyed () || op->destroyed () || abort_attack (op, hitter, simple_attack))
1828	return 0;	1776	return 0;
		1777
1829	break;	1778	break;
1830	}	1779	}
1831	}	1780	}
1832		1781
1833	if (!QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0)	1782	if (!QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0)
1834	{	1783	{
1835	/* FIXME: If a player is killed by a rune in a door, the	1784	/* FIXME: If a player is killed by a rune in a door, the
1836	* was_destroyed() check above doesn't return, and might get here.	1785	* destroyed() check above doesn't return, and might get here.
1837	*/	1786	*/
1838	LOG (llevDebug, "victim (arch %s, name %s) already dead in " "hit_player()\n", &op->arch->name, &op->name);	1787	LOG (llevDebug, "victim %s already dead in hit_player()\n", op->debug_desc ());
1839	return 0;	1788	return 0;
1840	}	1789	}
1841		1790
1842	#ifdef ATTACK_DEBUG	1791	#ifdef ATTACK_DEBUG
1843	LOG (llevDebug, "hit player: attacktype %d, dam %d\n", type, dam);	1792	LOG (llevDebug, "hit player: attacktype %d, dam %d\n", type, dam);
…		…
1849	* in case 0>dam>1, we try to "simulate" a float value-effect */	1798	* in case 0>dam>1, we try to "simulate" a float value-effect */
1850	dam = dam * (100 - op->resist[ATNR_MAGIC]);	1799	dam = dam * (100 - op->resist[ATNR_MAGIC]);
1851	if (dam >= 100)	1800	if (dam >= 100)
1852	dam /= 100;	1801	dam /= 100;
1853	else	1802	else
1854	dam = (dam > (rndm (0, 99))) ? 1 : 0;	1803	dam = (dam > rndm (0, 99)) ? 1 : 0;
1855	}	1804	}
1856		1805
1857	/* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map	1806	/* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map
1858	* If the attacktype still has chaos, shuffle it, then clear the Chaos bit	1807	* If the attacktype still has chaos, shuffle it, then clear the Chaos bit
1859	*/	1808	*/
…		…
1879	(hitter->title != NULL	1828	(hitter->title != NULL
1880	&& (god = find_god (determine_god (hitter))) != NULL && god->race != NULL && strstr (god->race, undead_name) != NULL)))	1829	&& (god = find_god (determine_god (hitter))) != NULL && god->race != NULL && strstr (god->race, undead_name) != NULL)))
1881	return 0;	1830	return 0;
1882	}	1831	}
1883		1832
1884	maxattacktype = type; /* initialize this to something */	1833	maxattacktype = type; /* initialise this to something */
1885	for (attacknum = 0; attacknum < NROFATTACKS; attacknum++, attacktype = 1 << attacknum)	1834	for (attacknum = 0; attacknum < NROFATTACKS; attacknum++, attacktype = 1 << attacknum)
1886	{	1835	{
1887	/* Magic isn't really a true attack type - it gets combined with other	1836	/* Magic isn't really a true attack type - it gets combined with other
1888	* attack types. As such, skip it over. However, if magic is	1837	* attack types. As such, skip it over. However, if magic is
1889	* the only attacktype in the group, then still attack with it	1838	* the only attacktype in the group, then still attack with it
…		…
1942		1891
1943	/* basically: maxdam /= area; we try to "simulate" a float	1892	/* basically: maxdam /= area; we try to "simulate" a float
1944	value-effect */	1893	value-effect */
1945	remainder = 100 * (maxdam % area) / area;	1894	remainder = 100 * (maxdam % area) / area;
1946	maxdam /= area;	1895	maxdam /= area;
1947	if (RANDOM () % 100 < remainder)	1896	if (rndm (100) < remainder)
1948	maxdam++;	1897	maxdam++;
1949	}	1898	}
1950		1899
1951	#ifdef ATTACK_DEBUG	1900	#ifdef ATTACK_DEBUG
1952	LOG (llevDebug, "Attacktype %d did %d damage\n", type, maxdam);	1901	LOG (llevDebug, "Attacktype %d did %d damage\n", type, maxdam);
1953	#endif	1902	#endif
1954		1903
1955	if (get_owner (hitter))	1904	if (hitter->owner)
1956	op->enemy = hitter->owner;	1905	op->enemy = hitter->owner;
1957	else if (QUERY_FLAG (hitter, FLAG_ALIVE))	1906	else if (QUERY_FLAG (hitter, FLAG_ALIVE))
1958	op->enemy = hitter;	1907	op->enemy = hitter;
1959		1908
1960	if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE) && op->type != PLAYER)	1909	if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE) && op->type != PLAYER)
…		…
1985		1934
1986	if (QUERY_FLAG (op, FLAG_TEAR_DOWN))	1935	if (QUERY_FLAG (op, FLAG_TEAR_DOWN))
1987	{	1936	{
1988	if (maxdam)	1937	if (maxdam)
1989	tear_down_wall (op);	1938	tear_down_wall (op);
		1939
1990	return maxdam; /* nothing more to do for wall */	1940	return maxdam; /* nothing more to do for wall */
1991	}	1941	}
1992		1942
1993	/* See if the creature has been killed */	1943	/* See if the creature has been killed */
1994	rtn_kill = kill_object (op, maxdam, hitter, type);	1944	rtn_kill = kill_object (op, maxdam, hitter, type);
…		…
2002	*/	1952	*/
2003	if (QUERY_FLAG (hitter, FLAG_ONE_HIT))	1953	if (QUERY_FLAG (hitter, FLAG_ONE_HIT))
2004	{	1954	{
2005	if (QUERY_FLAG (hitter, FLAG_FRIENDLY))	1955	if (QUERY_FLAG (hitter, FLAG_FRIENDLY))
2006	remove_friendly_object (hitter);	1956	remove_friendly_object (hitter);
2007	remove_ob (hitter);	1957
2008	free_object (hitter);	1958	hitter->destroy ();
2009	}	1959	}
2010	/* Lets handle creatures that are splitting now */	1960	/* Lets handle creatures that are splitting now */
2011	else if (type & AT_PHYSICAL && !QUERY_FLAG (op, FLAG_FREED) && QUERY_FLAG (op, FLAG_SPLITTING))	1961	else if (type & AT_PHYSICAL && !QUERY_FLAG (op, FLAG_FREED) && QUERY_FLAG (op, FLAG_SPLITTING))
2012	{	1962	{
2013	int i;	1963	int i;
2014	int friendly = QUERY_FLAG (op, FLAG_FRIENDLY);	1964	int friendly = QUERY_FLAG (op, FLAG_FRIENDLY);
2015	int unaggressive = QUERY_FLAG (op, FLAG_UNAGGRESSIVE);	1965	int unaggressive = QUERY_FLAG (op, FLAG_UNAGGRESSIVE);
2016	object *owner = get_owner (op);	1966	object *owner = op->owner;
2017		1967
2018	if (!op->other_arch)	1968	if (!op->other_arch)
2019	{	1969	{
2020	LOG (llevError, "SPLITTING without other_arch error.\n");	1970	LOG (llevError, "SPLITTING without other_arch error.\n");
2021	return maxdam;	1971	return maxdam;
2022	}	1972	}
		1973
2023	remove_ob (op);	1974	op->remove ();
		1975
2024	for (i = 0; i < NROFNEWOBJS (op); i++)	1976	for (i = 0; i < NROFNEWOBJS (op); i++)
2025	{ /* This doesn't handle op->more yet */	1977	{ /* This doesn't handle op->more yet */
2026	object *tmp = arch_to_object (op->other_arch);	1978	object *tmp = arch_to_object (op->other_arch);
2027	int j;	1979	int j;
2028		1980
2029	tmp->stats.hp = op->stats.hp;	1981	tmp->stats.hp = op->stats.hp;
		1982
2030	if (friendly)	1983	if (friendly)
2031	{	1984	{
2032	SET_FLAG (tmp, FLAG_FRIENDLY);
2033	add_friendly_object (tmp);	1985	add_friendly_object (tmp);
2034	tmp->attack_movement = PETMOVE;	1986	tmp->attack_movement = PETMOVE;
		1987
2035	if (owner != NULL)	1988	if (owner)
2036	set_owner (tmp, owner);	1989	tmp->set_owner (owner);
2037	}	1990	}
		1991
2038	if (unaggressive)	1992	if (unaggressive)
2039	SET_FLAG (tmp, FLAG_UNAGGRESSIVE);	1993	SET_FLAG (tmp, FLAG_UNAGGRESSIVE);
		1994
2040	j = find_first_free_spot (tmp, op->map, op->x, op->y);	1995	j = find_first_free_spot (tmp, op->map, op->x, op->y);
		1996
2041	if (j == -1) /* No spot to put this monster */	1997	if (j == -1) /* No spot to put this monster */
2042	free_object (tmp);	1998	tmp->destroy ();
2043	else	1999	else
2044	{	2000	{
2045	tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];	2001	tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];
2046	insert_ob_in_map (tmp, op->map, NULL, 0);	2002	insert_ob_in_map (tmp, op->map, NULL, 0);
2047	}	2003	}
2048	}	2004	}
2049	if (friendly)	2005
2050	remove_friendly_object (op);	2006	op->destroy ();
2051	free_object (op);
2052	}	2007	}
2053	else if (type & AT_DRAIN && hitter->type == GRIMREAPER && hitter->value++ > 10)	2008	else if (type & AT_DRAIN && hitter->type == GRIMREAPER && hitter->value++ > 10)
2054	{	2009	hitter->destroy ();
2055	remove_ob (hitter);	2010
2056	free_object (hitter);
2057	}
2058	return maxdam;	2011	return maxdam;
2059	}	2012	}
2060		2013
2061		2014
2062	void	2015	void
…		…
2083	if (QUERY_FLAG (hitter, FLAG_ALIVE))	2036	if (QUERY_FLAG (hitter, FLAG_ALIVE))
2084	tmp->stats.dam += hitter->level / 2;	2037	tmp->stats.dam += hitter->level / 2;
2085	else	2038	else
2086	tmp->stats.dam = dam;	2039	tmp->stats.dam = dam;
2087		2040
2088	copy_owner (tmp, hitter); /* so we get credit for poisoning kills */	2041	tmp->set_owner (hitter); /* so we get credit for poisoning kills */
2089	if (hitter->skill && hitter->skill != tmp->skill)	2042	if (hitter->skill && hitter->skill != tmp->skill)
2090	{	2043	{
2091	tmp->skill = hitter->skill;	2044	tmp->skill = hitter->skill;
2092	}	2045	}
2093		2046
…		…
2099	tmp->stats.Con = MAX (-(dam / 4 + 1), -10);	2052	tmp->stats.Con = MAX (-(dam / 4 + 1), -10);
2100	tmp->stats.Str = MAX (-(dam / 3 + 2), -10);	2053	tmp->stats.Str = MAX (-(dam / 3 + 2), -10);
2101	tmp->stats.Dex = MAX (-(dam / 6 + 1), -10);	2054	tmp->stats.Dex = MAX (-(dam / 6 + 1), -10);
2102	tmp->stats.Int = MAX (-dam / 7, -10);	2055	tmp->stats.Int = MAX (-dam / 7, -10);
2103	SET_FLAG (tmp, FLAG_APPLIED);	2056	SET_FLAG (tmp, FLAG_APPLIED);
2104	fix_player (op);	2057	op->update_stats ();
2105	new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very ill.");	2058	new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very ill.");
2106	}	2059	}
2107	if (hitter->type == PLAYER)	2060	if (hitter->type == PLAYER)
2108	new_draw_info_format (NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name);	2061	new_draw_info_format (NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name);
2109	else if (get_owner (hitter) != NULL && hitter->owner->type == PLAYER)	2062	else if (hitter->owner != NULL && hitter->owner->type == PLAYER)
2110	new_draw_info_format (NDI_UNIQUE, 0, hitter->owner, "Your %s poisons %s.", &hitter->name, &op->name);	2063	new_draw_info_format (NDI_UNIQUE, 0, hitter->owner, "Your %s poisons %s.", &hitter->name, &op->name);
2111	}	2064	}
2112	tmp->speed_left = 0;	2065	tmp->speed_left = 0;
2113	}	2066	}
2114	else	2067	else
…		…
2133	}	2086	}
2134	else	2087	else
2135	tmp->stats.food++;	2088	tmp->stats.food++;
2136	SET_FLAG (tmp, FLAG_APPLIED);	2089	SET_FLAG (tmp, FLAG_APPLIED);
2137	tmp->speed_left = 0;	2090	tmp->speed_left = 0;
2138	fix_player (op);	2091	op->update_stats ();
2139	}	2092	}
2140		2093
2141	void	2094	void
2142	confuse_player (object *op, object *hitter, int dam)	2095	confuse_player (object *op, object *hitter, int dam)
2143	{	2096	{
…		…
2187	*/	2140	*/
2188	tmp->speed = tmp->speed * (100.0 - (float) op->resist[ATNR_BLIND]) / 100;	2141	tmp->speed = tmp->speed * (100.0 - (float) op->resist[ATNR_BLIND]) / 100;
2189		2142
2190	tmp = insert_ob_in_ob (tmp, op);	2143	tmp = insert_ob_in_ob (tmp, op);
2191	change_abil (op, tmp); /* Mostly to display any messages */	2144	change_abil (op, tmp); /* Mostly to display any messages */
2192	fix_player (op); /* This takes care of some other stuff */	2145	op->update_stats (); /* This takes care of some other stuff */
2193		2146
2194	if (hitter->owner)	2147	if (hitter->owner)
2195	owner = get_owner (hitter);	2148	owner = hitter->owner;
2196	else	2149	else
2197	owner = hitter;	2150	owner = hitter;
2198		2151
2199	new_draw_info_format (NDI_UNIQUE, 0, owner, "Your attack blinds %s!", query_name (op));	2152	new_draw_info_format (NDI_UNIQUE, 0, owner, "Your attack blinds %s!", query_name (op));
2200	}	2153	}
…		…
2346	}	2299	}
2347		2300
2348	/* aimed missiles use the owning object's sight */	2301	/* aimed missiles use the owning object's sight */
2349	if (is_aimed_missile (hitter))	2302	if (is_aimed_missile (hitter))
2350	{	2303	{
2351	if ((attacker = get_owner (hitter)) == NULL)	2304	if ((attacker = hitter->owner) == NULL)
2352	attacker = hitter;	2305	attacker = hitter;
2353	/* A player who saves but hasn't quit still could have objects	2306	/* A player who saves but hasn't quit still could have objects
2354	* owned by him - need to handle that case to avoid crashes.	2307	* owned by him - need to handle that case to avoid crashes.
2355	*/	2308	*/
2356	if (QUERY_FLAG (attacker, FLAG_REMOVED))	2309	if (QUERY_FLAG (attacker, FLAG_REMOVED))

Diff Legend

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