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.13 by root, Thu Sep 14 00:14:51 2006 UTC vs.
Revision 1.48 by root, Thu Jan 18 22:20:00 2007 UTC

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

Diff Legend

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