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

Diff Legend

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